HealthCheck class

Provides a Route53 health check.

Example Usage

Connectivity and HTTP Status Code Check

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",
    })
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 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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 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.ArrayList;
import java.util.Arrays;
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

Connectivity and String Matching Check

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")
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 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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 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.ArrayList;
import java.util.Arrays;
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

Aggregate Check

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",
    })
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 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_route53_healthcheck" "parent" {
  type                   = "CALCULATED"
  child_health_threshold = 1
  child_healthchecks     = [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.ArrayList;
import java.util.Arrays;
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

CloudWatch Alarm Check

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=float(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")
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 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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"
}
resource "aws_route53_healthcheck" "foo" {
  type                            = "CLOUDWATCH_METRIC"
  cloudwatch_alarm_name           = aws_cloudwatch_metricalarm.foobar.name
  cloudwatch_alarm_region         = "us-west-2"
  insufficient_data_health_status = "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.ArrayList;
import java.util.Arrays;
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

CloudWatch Alarm Check With Triggers

The triggers argument allows the Route53 health check to be synchronized when a change to the upstream CloudWatch alarm is made. In the configuration below, the health check will be synchronized any time the threshold of the alarm is changed.

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.apply(x =>String(x)),
    },
});
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=float(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.apply(lambda x: str(x)),
    })
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 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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"
}
resource "aws_route53_healthcheck" "example" {
  type                            = "CLOUDWATCH_METRIC"
  cloudwatch_alarm_name           = aws_cloudwatch_metricalarm.example.name
  cloudwatch_alarm_region         = "us-west-2"
  insufficient_data_health_status = "Healthy"
  triggers = {
    "threshold" = aws_cloudwatch_metricalarm.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.ArrayList;
import java.util.Arrays;
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}

Import

Using pulumi import, import Route53 Health Checks using the health check id. For example:

$ pulumi import aws:route53/healthCheck:HealthCheck http_check abcdef11-2222-3333-4444-555555fedcba

Constructors

HealthCheck(String name, {HealthCheckArgs? args, CustomResourceOptions? options})
Creates a new HealthCheck. name The Pulumi resource name. args Arguments used to configure this HealthCheck. The set of arguments for HealthCheck. options Resource options controlling this resource's behavior.
HealthCheck.reference(String urn)
Creates a typed reference to an existing HealthCheck resource.

Properties

arn ↔ Output<String>
ARN of the Health Check.
latefinal
childHealthchecks ↔ Output<List<String>?>
For a specified parent health check, a list of HealthCheckId values for the associated child health checks.
latefinal
childHealthThreshold ↔ Output<int?>
The minimum number of child health checks that must be healthy for Route 53 to consider the parent health check to be healthy. Valid values are integers between 0 and 256, inclusive
latefinal
childResources → Set<Resource>
finalinherited
cloudwatchAlarmName ↔ Output<String?>
The name of the CloudWatch alarm.
latefinal
cloudwatchAlarmRegion ↔ Output<String?>
The region that the CloudWatch alarm was created in.
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
disabled ↔ Output<bool?>
A boolean value that stops Route 53 from performing health checks. When set to true, Route 53 will do the following depending on the type of health check:
latefinal
enableSni ↔ Output<bool>
A boolean value that indicates whether Route53 should send the fqdn to the endpoint when performing the health check. This defaults to AWS' defaults: when the type is "HTTPS" enableSni defaults to true, when type is anything else enableSni defaults to false.
latefinal
failureThreshold ↔ Output<int>
The number of consecutive health checks that an endpoint must pass or fail.
latefinal
fqdn ↔ Output<String?>
The fully qualified domain name of the endpoint to be checked. If a value is set for ipAddress, the value set for fqdn will be passed in the Host header.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
insufficientDataHealthStatus ↔ Output<String?>
The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are Healthy , Unhealthy and LastKnownStatus.
latefinal
invertHealthcheck ↔ Output<bool?>
A boolean value that indicates whether the status of health check should be inverted. For example, if a health check is healthy but Inverted is True , then Route 53 considers the health check to be unhealthy.
latefinal
ipAddress ↔ Output<String?>
The IP address of the endpoint to be checked.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
measureLatency ↔ Output<bool?>
A Boolean value that indicates whether you want Route 53 to measure the latency between health checkers in multiple AWS regions and your endpoint and to display CloudWatch latency graphs in the Route 53 console.
latefinal
port ↔ Output<int?>
The port of the endpoint to be checked.
latefinal
referenceName ↔ Output<String?>
This is a reference name used in Caller Reference (helpful for identifying single healthCheck set amongst others)
latefinal
regions ↔ Output<List<String>>
List of AWS Regions from which Amazon Route 53 health checkers check the specified endpoint. Valid values are us-east-1, us-west-1, us-west-2, eu-west-1, ap-southeast-1, ap-southeast-2, ap-northeast-1, and sa-east-1. If not specified, all of the regions listed under Valid values are used by default. Once this argument is set, removing it has no effect.
latefinal
requestInterval ↔ Output<int?>
The number of seconds between the time that Amazon Route 53 gets a response from your endpoint and the time that it sends the next health-check request.
latefinal
resourcePath ↔ Output<String?>
The path that you want Amazon Route 53 to request when performing health checks.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
routingControlArn ↔ Output<String?>
ARN for the Route 53 Application Recovery Controller routing control. This is used when health check type is RECOVERY_CONTROL
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
searchString ↔ Output<String?>
String searched in the first 5120 bytes of the response body for check to be considered healthy. Only valid with HTTP_STR_MATCH and HTTPS_STR_MATCH.
latefinal
tags ↔ Output<Map<String, String>?>
A map of tags to assign to the health check. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
triggers ↔ Output<Map<String, String>>
Map of arbitrary keys and values that, when changed, will trigger an in-place update of the CloudWatch alarm arguments. Use this argument to synchronize the health check when an alarm is changed. See example above.
latefinal
type ↔ Output<String>
The protocol to use when performing health checks. Valid values are HTTP, HTTPS, HTTP_STR_MATCH, HTTPS_STR_MATCH, TCP, CALCULATED, CLOUDWATCH_METRIC and RECOVERY_CONTROL.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {HealthCheckState? state, CustomResourceOptions? options}) → HealthCheck
Gets an existing HealthCheck resource's state with the given name and id.