pulumi-aws-kotlin/com.pulumi.aws.route53.kotlin/HealthCheckArgs

HealthCheckArgs

data class HealthCheckArgs(val childHealthThreshold: Output<Int>? = null, val childHealthchecks: Output<List<String>>? = null, val cloudwatchAlarmName: Output<String>? = null, val cloudwatchAlarmRegion: Output<String>? = null, val disabled: Output<Boolean>? = null, val enableSni: Output<Boolean>? = null, val failureThreshold: Output<Int>? = null, val fqdn: Output<String>? = null, val insufficientDataHealthStatus: Output<String>? = null, val invertHealthcheck: Output<Boolean>? = null, val ipAddress: Output<String>? = null, val measureLatency: Output<Boolean>? = null, val port: Output<Int>? = null, val referenceName: Output<String>? = null, val regions: Output<List<String>>? = null, val requestInterval: Output<Int>? = null, val resourcePath: Output<String>? = null, val routingControlArn: Output<String>? = null, val searchString: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val triggers: Output<Map<String, String>>? = null, val type: Output<String>? = null) : ConvertibleToJava<HealthCheckArgs>

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",
    },
});
Content copied to clipboard
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",
    })
Content copied to clipboard
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" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

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",
});
Content copied to clipboard
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")
Content copied to clipboard
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",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:route53:HealthCheck
    properties:
      failureThreshold: '5'
      fqdn: example.com
      port: 443
      requestInterval: '30'
      resourcePath: /
      searchString: example
      type: HTTPS_STR_MATCH
Content copied to clipboard

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&#46;id],
    tags: {
        Name: "tf-test-calculated-health-check",
    },
});
Content copied to clipboard
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",
    })
Content copied to clipboard
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" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
resources:
  parent:
    type: aws:route53:HealthCheck
    properties:
      type: CALCULATED
      childHealthThreshold: 1
      childHealthchecks:
        - ${child.id}
      tags:
        Name: tf-test-calculated-health-check
Content copied to clipboard

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",
});
Content copied to clipboard
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")
Content copied to clipboard
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",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v6/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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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
Content copied to clipboard

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,
    },
});
Content copied to clipboard
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,
    })
Content copied to clipboard
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 },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v6/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
	})
}
Content copied to clipboard
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());
    }
}
Content copied to clipboard
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}
Content copied to clipboard

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
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(childHealthThreshold: Output<Int>? = null, childHealthchecks: Output<List<String>>? = null, cloudwatchAlarmName: Output<String>? = null, cloudwatchAlarmRegion: Output<String>? = null, disabled: Output<Boolean>? = null, enableSni: Output<Boolean>? = null, failureThreshold: Output<Int>? = null, fqdn: Output<String>? = null, insufficientDataHealthStatus: Output<String>? = null, invertHealthcheck: Output<Boolean>? = null, ipAddress: Output<String>? = null, measureLatency: Output<Boolean>? = null, port: Output<Int>? = null, referenceName: Output<String>? = null, regions: Output<List<String>>? = null, requestInterval: Output<Int>? = null, resourcePath: Output<String>? = null, routingControlArn: Output<String>? = null, searchString: Output<String>? = null, tags: Output<Map<String, String>>? = null, triggers: Output<Map<String, String>>? = null, type: Output<String>? = null)

Properties

Link copied to clipboard
val childHealthchecks: Output<List<String>>? = null

For a specified parent health check, a list of HealthCheckId values for the associated child health checks.

Link copied to clipboard
val childHealthThreshold: Output<Int>? = null

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

Link copied to clipboard
val cloudwatchAlarmName: Output<String>? = null

The name of the CloudWatch alarm.

Link copied to clipboard
val cloudwatchAlarmRegion: Output<String>? = null

The region that the CloudWatch alarm was created in.

Link copied to clipboard
val disabled: Output<Boolean>? = null

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:

Link copied to clipboard
val enableSni: Output<Boolean>? = null

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" enable_sni defaults to true, when type is anything else enable_sni defaults to false.

Link copied to clipboard
val failureThreshold: Output<Int>? = null

The number of consecutive health checks that an endpoint must pass or fail.

Link copied to clipboard
val fqdn: Output<String>? = null

The fully qualified domain name of the endpoint to be checked. If a value is set for ip_address, the value set for fqdn will be passed in the Host header.

Link copied to clipboard
val insufficientDataHealthStatus: Output<String>? = null

The status of the health check when CloudWatch has insufficient data about the state of associated alarm. Valid values are Healthy , Unhealthy and LastKnownStatus.

Link copied to clipboard
val invertHealthcheck: Output<Boolean>? = null

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.

Link copied to clipboard
val ipAddress: Output<String>? = null

The IP address of the endpoint to be checked.

Link copied to clipboard
val measureLatency: Output<Boolean>? = null

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.

Link copied to clipboard
val port: Output<Int>? = null

The port of the endpoint to be checked.

Link copied to clipboard
val referenceName: Output<String>? = null

This is a reference name used in Caller Reference (helpful for identifying single health_check set amongst others)

Link copied to clipboard
val regions: Output<List<String>>? = null

A list of AWS regions that you want Amazon Route 53 health checkers to check the specified endpoint from.

Link copied to clipboard
val requestInterval: Output<Int>? = null

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.

Link copied to clipboard
val resourcePath: Output<String>? = null

The path that you want Amazon Route 53 to request when performing health checks.

Link copied to clipboard
val routingControlArn: Output<String>? = null

The Amazon Resource Name (ARN) for the Route 53 Application Recovery Controller routing control. This is used when health check type is RECOVERY_CONTROL

Link copied to clipboard
val searchString: Output<String>? = null

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.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

A map of tags to assign to the health check. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val triggers: Output<Map<String, String>>? = null

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.

Link copied to clipboard
val type: Output<String>? = null

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.

Functions

Link copied to clipboard
open override fun toJava(): HealthCheckArgs