Configure AWS Route53 Health Checks

The aws:route53/healthCheck:HealthCheck resource, part of the Pulumi AWS provider, defines Route 53 health checks that monitor endpoint availability, response content, CloudWatch alarms, or aggregate status from multiple checks. This guide focuses on three capabilities: HTTP endpoint monitoring with status and content verification, aggregate health checks combining multiple endpoints, and CloudWatch alarm integration for metric-based health.

Health checks monitor existing web servers, APIs, or CloudWatch alarms and feed into DNS failover decisions. The examples are intentionally small. Combine them with your own Route 53 records and failover policies.

Check HTTP endpoint connectivity and status codes

Most health checks verify that an HTTP endpoint responds successfully, probing at regular intervals and marking unhealthy after consecutive failures.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.route53.HealthCheck("example", {
    fqdn: "example.com",
    port: 80,
    type: "HTTP",
    resourcePath: "/",
    failureThreshold: 5,
    requestInterval: 30,
    tags: {
        Name: "tf-test-health-check",
    },
});

import pulumi
import pulumi_aws as aws

example = aws.route53.HealthCheck("example",
    fqdn="example.com",
    port=80,
    type="HTTP",
    resource_path="/",
    failure_threshold=5,
    request_interval=30,
    tags={
        "Name": "tf-test-health-check",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(80),
			Type:             pulumi.String("HTTP"),
			ResourcePath:     pulumi.String("/"),
			FailureThreshold: pulumi.Int(5),
			RequestInterval:  pulumi.Int(30),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-test-health-check"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Route53.HealthCheck("example", new()
    {
        Fqdn = "example.com",
        Port = 80,
        Type = "HTTP",
        ResourcePath = "/",
        FailureThreshold = 5,
        RequestInterval = 30,
        Tags = 
        {
            { "Name", "tf-test-health-check" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.route53.HealthCheck;
import com.pulumi.aws.route53.HealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new HealthCheck("example", HealthCheckArgs.builder()
            .fqdn("example.com")
            .port(80)
            .type("HTTP")
            .resourcePath("/")
            .failureThreshold(5)
            .requestInterval(30)
            .tags(Map.of("Name", "tf-test-health-check"))
            .build());

    }
}

resources:
  example:
    type: aws:route53:HealthCheck
    properties:
      fqdn: example.com
      port: 80
      type: HTTP
      resourcePath: /
      failureThreshold: '5'
      requestInterval: '30'
      tags:
        Name: tf-test-health-check

Route 53 sends HTTP requests to the specified fqdn and port, checking the resourcePath. The type property determines the protocol (HTTP, HTTPS, TCP). The failureThreshold sets how many consecutive failures trigger unhealthy status; requestInterval controls probe frequency (30 seconds here).

Verify response body contains expected content

Beyond connectivity, you can confirm endpoints return correct content, not just HTTP 200 responses.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.route53.HealthCheck("example", {
    failureThreshold: 5,
    fqdn: "example.com",
    port: 443,
    requestInterval: 30,
    resourcePath: "/",
    searchString: "example",
    type: "HTTPS_STR_MATCH",
});

import pulumi
import pulumi_aws as aws

example = aws.route53.HealthCheck("example",
    failure_threshold=5,
    fqdn="example.com",
    port=443,
    request_interval=30,
    resource_path="/",
    search_string="example",
    type="HTTPS_STR_MATCH")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			FailureThreshold: pulumi.Int(5),
			Fqdn:             pulumi.String("example.com"),
			Port:             pulumi.Int(443),
			RequestInterval:  pulumi.Int(30),
			ResourcePath:     pulumi.String("/"),
			SearchString:     pulumi.String("example"),
			Type:             pulumi.String("HTTPS_STR_MATCH"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.Route53.HealthCheck("example", new()
    {
        FailureThreshold = 5,
        Fqdn = "example.com",
        Port = 443,
        RequestInterval = 30,
        ResourcePath = "/",
        SearchString = "example",
        Type = "HTTPS_STR_MATCH",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.route53.HealthCheck;
import com.pulumi.aws.route53.HealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new HealthCheck("example", HealthCheckArgs.builder()
            .failureThreshold(5)
            .fqdn("example.com")
            .port(443)
            .requestInterval(30)
            .resourcePath("/")
            .searchString("example")
            .type("HTTPS_STR_MATCH")
            .build());

    }
}

resources:
  example:
    type: aws:route53:HealthCheck
    properties:
      failureThreshold: '5'
      fqdn: example.com
      port: 443
      requestInterval: '30'
      resourcePath: /
      searchString: example
      type: HTTPS_STR_MATCH

The HTTPS_STR_MATCH type adds content verification. Route 53 searches the first 5120 bytes of the response for the searchString. If the string is missing, the check fails even with a 200 status code, detecting degraded services that return success codes but wrong content.

Combine multiple health checks into one status

Complex services spanning multiple endpoints or regions can use aggregate health checks to define overall service health.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const parent = new aws.route53.HealthCheck("parent", {
    type: "CALCULATED",
    childHealthThreshold: 1,
    childHealthchecks: [child.id],
    tags: {
        Name: "tf-test-calculated-health-check",
    },
});

import pulumi
import pulumi_aws as aws

parent = aws.route53.HealthCheck("parent",
    type="CALCULATED",
    child_health_threshold=1,
    child_healthchecks=[child["id"]],
    tags={
        "Name": "tf-test-calculated-health-check",
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := route53.NewHealthCheck(ctx, "parent", &route53.HealthCheckArgs{
			Type:                 pulumi.String("CALCULATED"),
			ChildHealthThreshold: pulumi.Int(1),
			ChildHealthchecks: pulumi.StringArray{
				child.Id,
			},
			Tags: pulumi.StringMap{
				"Name": pulumi.String("tf-test-calculated-health-check"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var parent = new Aws.Route53.HealthCheck("parent", new()
    {
        Type = "CALCULATED",
        ChildHealthThreshold = 1,
        ChildHealthchecks = new[]
        {
            child.Id,
        },
        Tags = 
        {
            { "Name", "tf-test-calculated-health-check" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.route53.HealthCheck;
import com.pulumi.aws.route53.HealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var parent = new HealthCheck("parent", HealthCheckArgs.builder()
            .type("CALCULATED")
            .childHealthThreshold(1)
            .childHealthchecks(child.id())
            .tags(Map.of("Name", "tf-test-calculated-health-check"))
            .build());

    }
}

resources:
  parent:
    type: aws:route53:HealthCheck
    properties:
      type: CALCULATED
      childHealthThreshold: 1
      childHealthchecks:
        - ${child.id}
      tags:
        Name: tf-test-calculated-health-check

The CALCULATED type creates a parent health check that monitors child checks. The childHealthThreshold sets the minimum number of healthy children required; here, at least 1 child must pass. This lets you mark a service healthy when a minimum number of endpoints are available, even if some fail.

Monitor CloudWatch alarms as health signals

Some conditions are best detected through CloudWatch metrics rather than direct probes, such as queue depth or connection counts.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const foobar = new aws.cloudwatch.MetricAlarm("foobar", {
    name: "test-foobar5",
    comparisonOperator: "GreaterThanOrEqualToThreshold",
    evaluationPeriods: 2,
    metricName: "CPUUtilization",
    namespace: "AWS/EC2",
    period: 120,
    statistic: "Average",
    threshold: 80,
    alarmDescription: "This metric monitors ec2 cpu utilization",
});
const foo = new aws.route53.HealthCheck("foo", {
    type: "CLOUDWATCH_METRIC",
    cloudwatchAlarmName: foobar.name,
    cloudwatchAlarmRegion: "us-west-2",
    insufficientDataHealthStatus: "Healthy",
});

import pulumi
import pulumi_aws as aws

foobar = aws.cloudwatch.MetricAlarm("foobar",
    name="test-foobar5",
    comparison_operator="GreaterThanOrEqualToThreshold",
    evaluation_periods=2,
    metric_name="CPUUtilization",
    namespace="AWS/EC2",
    period=120,
    statistic="Average",
    threshold=80,
    alarm_description="This metric monitors ec2 cpu utilization")
foo = aws.route53.HealthCheck("foo",
    type="CLOUDWATCH_METRIC",
    cloudwatch_alarm_name=foobar.name,
    cloudwatch_alarm_region="us-west-2",
    insufficient_data_health_status="Healthy")

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foobar, err := cloudwatch.NewMetricAlarm(ctx, "foobar", &cloudwatch.MetricAlarmArgs{
			Name:               pulumi.String("test-foobar5"),
			ComparisonOperator: pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:  pulumi.Int(2),
			MetricName:         pulumi.String("CPUUtilization"),
			Namespace:          pulumi.String("AWS/EC2"),
			Period:             pulumi.Int(120),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Float64(80),
			AlarmDescription:   pulumi.String("This metric monitors ec2 cpu utilization"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewHealthCheck(ctx, "foo", &route53.HealthCheckArgs{
			Type:                         pulumi.String("CLOUDWATCH_METRIC"),
			CloudwatchAlarmName:          foobar.Name,
			CloudwatchAlarmRegion:        pulumi.String("us-west-2"),
			InsufficientDataHealthStatus: pulumi.String("Healthy"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var foobar = new Aws.CloudWatch.MetricAlarm("foobar", new()
    {
        Name = "test-foobar5",
        ComparisonOperator = "GreaterThanOrEqualToThreshold",
        EvaluationPeriods = 2,
        MetricName = "CPUUtilization",
        Namespace = "AWS/EC2",
        Period = 120,
        Statistic = "Average",
        Threshold = 80,
        AlarmDescription = "This metric monitors ec2 cpu utilization",
    });

    var foo = new Aws.Route53.HealthCheck("foo", new()
    {
        Type = "CLOUDWATCH_METRIC",
        CloudwatchAlarmName = foobar.Name,
        CloudwatchAlarmRegion = "us-west-2",
        InsufficientDataHealthStatus = "Healthy",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.route53.HealthCheck;
import com.pulumi.aws.route53.HealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var foobar = new MetricAlarm("foobar", MetricAlarmArgs.builder()
            .name("test-foobar5")
            .comparisonOperator("GreaterThanOrEqualToThreshold")
            .evaluationPeriods(2)
            .metricName("CPUUtilization")
            .namespace("AWS/EC2")
            .period(120)
            .statistic("Average")
            .threshold(80.0)
            .alarmDescription("This metric monitors ec2 cpu utilization")
            .build());

        var foo = new HealthCheck("foo", HealthCheckArgs.builder()
            .type("CLOUDWATCH_METRIC")
            .cloudwatchAlarmName(foobar.name())
            .cloudwatchAlarmRegion("us-west-2")
            .insufficientDataHealthStatus("Healthy")
            .build());

    }
}

resources:
  foobar:
    type: aws:cloudwatch:MetricAlarm
    properties:
      name: test-foobar5
      comparisonOperator: GreaterThanOrEqualToThreshold
      evaluationPeriods: '2'
      metricName: CPUUtilization
      namespace: AWS/EC2
      period: '120'
      statistic: Average
      threshold: '80'
      alarmDescription: This metric monitors ec2 cpu utilization
  foo:
    type: aws:route53:HealthCheck
    properties:
      type: CLOUDWATCH_METRIC
      cloudwatchAlarmName: ${foobar.name}
      cloudwatchAlarmRegion: us-west-2
      insufficientDataHealthStatus: Healthy

The CLOUDWATCH_METRIC type monitors an existing CloudWatch alarm instead of probing an endpoint. The cloudwatchAlarmName and cloudwatchAlarmRegion identify the alarm. The insufficientDataHealthStatus determines health when CloudWatch lacks data (Healthy, Unhealthy, or LastKnownStatus).

Synchronize health check when alarm changes

When CloudWatch alarms update, health checks don’t automatically detect the change. The triggers property forces synchronization.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.cloudwatch.MetricAlarm("example", {
    name: "example",
    comparisonOperator: "GreaterThanOrEqualToThreshold",
    evaluationPeriods: 2,
    metricName: "CPUUtilization",
    namespace: "AWS/EC2",
    period: 120,
    statistic: "Average",
    threshold: 80,
    alarmDescription: "This metric monitors ec2 cpu utilization",
});
const exampleHealthCheck = new aws.route53.HealthCheck("example", {
    type: "CLOUDWATCH_METRIC",
    cloudwatchAlarmName: example.name,
    cloudwatchAlarmRegion: "us-west-2",
    insufficientDataHealthStatus: "Healthy",
    triggers: {
        threshold: example.threshold,
    },
});

import pulumi
import pulumi_aws as aws

example = aws.cloudwatch.MetricAlarm("example",
    name="example",
    comparison_operator="GreaterThanOrEqualToThreshold",
    evaluation_periods=2,
    metric_name="CPUUtilization",
    namespace="AWS/EC2",
    period=120,
    statistic="Average",
    threshold=80,
    alarm_description="This metric monitors ec2 cpu utilization")
example_health_check = aws.route53.HealthCheck("example",
    type="CLOUDWATCH_METRIC",
    cloudwatch_alarm_name=example.name,
    cloudwatch_alarm_region="us-west-2",
    insufficient_data_health_status="Healthy",
    triggers={
        "threshold": example.threshold,
    })

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := cloudwatch.NewMetricAlarm(ctx, "example", &cloudwatch.MetricAlarmArgs{
			Name:               pulumi.String("example"),
			ComparisonOperator: pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:  pulumi.Int(2),
			MetricName:         pulumi.String("CPUUtilization"),
			Namespace:          pulumi.String("AWS/EC2"),
			Period:             pulumi.Int(120),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Float64(80),
			AlarmDescription:   pulumi.String("This metric monitors ec2 cpu utilization"),
		})
		if err != nil {
			return err
		}
		_, err = route53.NewHealthCheck(ctx, "example", &route53.HealthCheckArgs{
			Type:                         pulumi.String("CLOUDWATCH_METRIC"),
			CloudwatchAlarmName:          example.Name,
			CloudwatchAlarmRegion:        pulumi.String("us-west-2"),
			InsufficientDataHealthStatus: pulumi.String("Healthy"),
			Triggers: pulumi.StringMap{
				"threshold": example.Threshold,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() => 
{
    var example = new Aws.CloudWatch.MetricAlarm("example", new()
    {
        Name = "example",
        ComparisonOperator = "GreaterThanOrEqualToThreshold",
        EvaluationPeriods = 2,
        MetricName = "CPUUtilization",
        Namespace = "AWS/EC2",
        Period = 120,
        Statistic = "Average",
        Threshold = 80,
        AlarmDescription = "This metric monitors ec2 cpu utilization",
    });

    var exampleHealthCheck = new Aws.Route53.HealthCheck("example", new()
    {
        Type = "CLOUDWATCH_METRIC",
        CloudwatchAlarmName = example.Name,
        CloudwatchAlarmRegion = "us-west-2",
        InsufficientDataHealthStatus = "Healthy",
        Triggers = 
        {
            { "threshold", example.Threshold },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.route53.HealthCheck;
import com.pulumi.aws.route53.HealthCheckArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new MetricAlarm("example", MetricAlarmArgs.builder()
            .name("example")
            .comparisonOperator("GreaterThanOrEqualToThreshold")
            .evaluationPeriods(2)
            .metricName("CPUUtilization")
            .namespace("AWS/EC2")
            .period(120)
            .statistic("Average")
            .threshold(80.0)
            .alarmDescription("This metric monitors ec2 cpu utilization")
            .build());

        var exampleHealthCheck = new HealthCheck("exampleHealthCheck", HealthCheckArgs.builder()
            .type("CLOUDWATCH_METRIC")
            .cloudwatchAlarmName(example.name())
            .cloudwatchAlarmRegion("us-west-2")
            .insufficientDataHealthStatus("Healthy")
            .triggers(Map.of("threshold", example.threshold()))
            .build());

    }
}

resources:
  example:
    type: aws:cloudwatch:MetricAlarm
    properties:
      name: example
      comparisonOperator: GreaterThanOrEqualToThreshold
      evaluationPeriods: '2'
      metricName: CPUUtilization
      namespace: AWS/EC2
      period: '120'
      statistic: Average
      threshold: '80'
      alarmDescription: This metric monitors ec2 cpu utilization
  exampleHealthCheck:
    type: aws:route53:HealthCheck
    name: example
    properties:
      type: CLOUDWATCH_METRIC
      cloudwatchAlarmName: ${example.name}
      cloudwatchAlarmRegion: us-west-2
      insufficientDataHealthStatus: Healthy
      triggers:
        threshold: ${example.threshold}

The triggers map contains arbitrary key-value pairs. When any value changes (like the alarm’s threshold), Route 53 updates the health check. This keeps the health check synchronized with alarm configuration changes, ensuring DNS failover decisions reflect current alarm thresholds.

Beyond these examples

These snippets focus on specific health check features: endpoint connectivity and content verification, aggregate and calculated health checks, and CloudWatch alarm integration. They’re intentionally minimal rather than full monitoring solutions.

The examples may reference pre-existing infrastructure such as web servers or API endpoints to monitor, CloudWatch alarms for metric-based checks, and child health checks for aggregate checks. They focus on configuring the health check rather than provisioning the monitored infrastructure.

To keep things focused, common health check patterns are omitted, including:

Regional health checker selection (regions)
Latency measurement (measureLatency)
Health check inversion (invertHealthcheck)
Disabling checks without deletion (disabled)

These omissions are intentional: the goal is to illustrate how each health check feature is wired, not provide drop-in monitoring modules. See the Route 53 HealthCheck resource reference for all available configuration options.

Let's configure AWS Route53 Health Checks

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Health Check Types & Configuration

What types of health checks can I create?

Route 53 supports eight health check types: HTTP, HTTPS, HTTP_STR_MATCH, HTTPS_STR_MATCH, TCP, CALCULATED, CLOUDWATCH_METRIC, and RECOVERY_CONTROL. The type property is immutable after creation.

How do I check for specific text in the HTTP response?

Use HTTP_STR_MATCH or HTTPS_STR_MATCH as the health check type and set searchString to the text you want to find. Route 53 searches the first 5120 bytes of the response body.

How do I create an aggregate health check that monitors other health checks?

Set type to CALCULATED, specify childHealthchecks with an array of child health check IDs, and set childHealthThreshold to the minimum number of healthy children required (0-256).

How do I monitor a CloudWatch alarm with a health check?

Set type to CLOUDWATCH_METRIC and configure cloudwatchAlarmName and cloudwatchAlarmRegion to specify which alarm to monitor.

CloudWatch Integration

How do I keep my health check synchronized when a CloudWatch alarm changes?

Use the triggers argument with a map of alarm properties (like threshold) that should trigger health check updates when modified. This ensures the health check stays in sync with alarm configuration changes.

What happens when CloudWatch doesn't have enough data about my alarm?

Set insufficientDataHealthStatus to control the health check status when CloudWatch has insufficient alarm data. Valid values are Healthy, Unhealthy, and LastKnownStatus.

Endpoint Configuration

What's the difference between fqdn and ipAddress?

Both specify the endpoint to check, but when you set ipAddress, the fqdn value is passed in the Host header of the health check request instead of being used as the connection target.

When does Route 53 automatically enable SNI for health checks?

enableSni defaults to true when type is HTTPS, and false for all other health check types. This controls whether Route 53 sends the fqdn to the endpoint during the health check.

Health Check Behavior

What happens when I disable a health check?

Route 53 stops performing health checks but considers the health check status to always be healthy, so traffic continues routing to the resource. To stop traffic routing, use invertHealthcheck instead of or in addition to disabled.

How do I make Route 53 treat a healthy endpoint as unhealthy?

Set invertHealthcheck to true to invert the health check status. For example, a healthy endpoint will be considered unhealthy by Route 53.

Immutability & Limitations

Which health check properties can't be changed after creation?

Five properties are immutable: type, measureLatency, requestInterval, referenceName, and routingControlArn. Changing any of these requires recreating the health check.

Using a different cloud?

Explore networking guides for other cloud providers:

Azure Guides GCP Guides