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.
nameThe Pulumi resource name.argsArguments used to configure this HealthCheck. The set of arguments for HealthCheck.optionsResource 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
fqdnto the endpoint when performing the health check. This defaults to AWS' defaults: when thetypeis "HTTPS"enableSnidefaults totrue, whentypeis anything elseenableSnidefaults tofalse.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 forfqdnwill be passed in theHostheader.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,UnhealthyandLastKnownStatus.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, andsa-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_CONTROLlatefinal - 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_MATCHandHTTPS_STR_MATCH.latefinal -
A map of tags to assign to the health check. If configured with a provider
defaultTagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.latefinal -
A map of tags assigned to the resource, including those inherited from the provider
defaultTagsconfiguration 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_METRICandRECOVERY_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
nameandid.