feat(route53): added EvaluateTargetHealth to Route53 Alias targets (#9481)

packages/aws-cdk-lib/aws-route53-targets/lib/bucket-website-target.ts

@@ -7,8 +7,7 @@ import { RegionInfo } from '../../region-info';
  * Use a S3 as an alias record target
  */
 export class BucketWebsiteTarget implements route53.IAliasRecordTarget {
-  constructor(private readonly bucket: s3.IBucket) {
-  }
+  constructor(private readonly bucket: s3.IBucket, private readonly props?: BucketWebsiteTargetProps) {}
 
   public bind(_record: route53.IRecordSet, _zone?: route53.IHostedZone): route53.AliasRecordTargetConfig {
     const { region } = Stack.of(this.bucket.stack);
@@ -27,6 +26,17 @@ export class BucketWebsiteTarget implements route53.IAliasRecordTarget {
       throw new Error(`Bucket website target is not supported for the "${region}" region`);
     }
 
-    return { hostedZoneId, dnsName };
+    return { hostedZoneId, dnsName, evaluateTargetHealth: this.props?.evaluateTargetHealth };
   }
 }
+
+/**
+ * Properties for a bucket website target
+ */
+export interface BucketWebsiteTargetProps {
+  /**
+   * Evaluate target health
+   * @default - no health check configuration
+   */
+  readonly evaluateTargetHealth?: boolean;
+}

packages/aws-cdk-lib/aws-route53-targets/lib/classic-load-balancer-target.ts

@@ -5,13 +5,24 @@ import * as route53 from '../../aws-route53';
  * Use a classic ELB as an alias record target
  */
 export class ClassicLoadBalancerTarget implements route53.IAliasRecordTarget {
-  constructor(private readonly loadBalancer: elb.LoadBalancer) {
-  }
+  constructor(private readonly loadBalancer: elb.LoadBalancer, private readonly props?: ClassicLoadBalancerTargetProps) {}
 
   public bind(_record: route53.IRecordSet, _zone?: route53.IHostedZone): route53.AliasRecordTargetConfig {
     return {
       hostedZoneId: this.loadBalancer.loadBalancerCanonicalHostedZoneNameId,
       dnsName: `dualstack.${this.loadBalancer.loadBalancerDnsName}`,
+      evaluateTargetHealth: this.props?.evaluateTargetHealth,
     };
   }
 }
+
+/**
+ * Properties for a classic ELB target
+ */
+export interface ClassicLoadBalancerTargetProps {
+  /**
+   * Evaluate target health
+   * @default - no health check configuration
+   */
+  readonly evaluateTargetHealth?: boolean;
+}

packages/aws-cdk-lib/aws-route53-targets/lib/elastic-beanstalk-environment-target.ts

@@ -10,8 +10,10 @@ import { RegionInfo } from '../../region-info';
  * Only supports Elastic Beanstalk environments created after 2016 that have a regional endpoint.
  */
 export class ElasticBeanstalkEnvironmentEndpointTarget implements route53.IAliasRecordTarget {
-  constructor(private readonly environmentEndpoint: string) {
-  }
+  constructor(
+    private readonly environmentEndpoint: string,
+    private readonly props: ElasticBeanstalkEnvironmentEndpointTargetProps = { evaluateTargetHealth: false },
+  ) {}
 
   public bind(_record: route53.IRecordSet, _zone?: route53.IHostedZone): route53.AliasRecordTargetConfig {
     if (cdk.Token.isUnresolved(this.environmentEndpoint)) {
@@ -31,6 +33,18 @@ export class ElasticBeanstalkEnvironmentEndpointTarget implements route53.IAlias
     return {
       hostedZoneId,
       dnsName,
+      evaluateTargetHealth: this.props.evaluateTargetHealth,
     };
   }
 }
+
+/**
+ * Properties for an Elastic Beanstalk environment URL target
+ */
+export interface ElasticBeanstalkEnvironmentEndpointTargetProps {
+  /**
+   * Evaluate target health
+   * @default - false
+   */
+  readonly evaluateTargetHealth?: boolean;
+}

packages/aws-cdk-lib/aws-route53-targets/lib/global-accelerator-target.ts

@@ -15,13 +15,13 @@ export class GlobalAcceleratorDomainTarget implements route53.IAliasRecordTarget
   /**
    * Create an Alias Target for a Global Accelerator domain name.
    */
-  constructor(private readonly acceleratorDomainName: string) {
-  }
+  constructor(private readonly acceleratorDomainName: string, private readonly props?: GlobalAcceleratorDomainTargetProps) {}
 
   bind(_record: route53.IRecordSet, _zone?: route53.IHostedZone): route53.AliasRecordTargetConfig {
     return {
       hostedZoneId: GlobalAcceleratorTarget.GLOBAL_ACCELERATOR_ZONE_ID,
       dnsName: this.acceleratorDomainName,
+      evaluateTargetHealth: this.props?.evaluateTargetHealth,
     };
   }
 }
@@ -30,11 +30,21 @@ export class GlobalAcceleratorDomainTarget implements route53.IAliasRecordTarget
  * Use a Global Accelerator instance domain name as an alias record target.
  */
 export class GlobalAcceleratorTarget extends GlobalAcceleratorDomainTarget {
-
   /**
    * Create an Alias Target for a Global Accelerator instance.
    */
-  constructor(accelerator: globalaccelerator.IAccelerator) {
-    super(accelerator.dnsName);
+  constructor(accelerator: globalaccelerator.IAccelerator, props?: GlobalAcceleratorDomainTargetProps) {
+    super(accelerator.dnsName, props);
   }
 }
+
+/**
+ * Properties for a Global Accelerator domain name target
+ */
+export interface GlobalAcceleratorDomainTargetProps {
+  /**
+   * Evaluate target health
+   * @default - no health check configuration
+   */
+  readonly evaluateTargetHealth?: boolean;
+}

packages/aws-cdk-lib/aws-route53-targets/lib/load-balancer-target.ts

@@ -5,13 +5,24 @@ import * as route53 from '../../aws-route53';
  * Use an ELBv2 as an alias record target
  */
 export class LoadBalancerTarget implements route53.IAliasRecordTarget {
-  constructor(private readonly loadBalancer: elbv2.ILoadBalancerV2) {
-  }
+  constructor(private readonly loadBalancer: elbv2.ILoadBalancerV2, private readonly props?: LoadBalancerTargetProps) {}
 
   public bind(_record: route53.IRecordSet, _zone?: route53.IHostedZone): route53.AliasRecordTargetConfig {
     return {
       hostedZoneId: this.loadBalancer.loadBalancerCanonicalHostedZoneId,
       dnsName: `dualstack.${this.loadBalancer.loadBalancerDnsName}`,
+      evaluateTargetHealth: this.props?.evaluateTargetHealth,
     };
   }
 }
+
+/**
+ * Properties for an ELBv2 target
+ */
+export interface LoadBalancerTargetProps {
+  /**
+   * Evaluate target health
+   * @default - no health check configuration
+   */
+  readonly evaluateTargetHealth?: boolean;
+}

packages/aws-cdk-lib/aws-route53-targets/test/bucket-website-target.test.ts

@@ -31,6 +31,33 @@ test('use S3 bucket website as record target', () => {
   });
 });
 
+test('use S3 bucket website as record target with health check', () => {
+  // GIVEN
+  const app = new App();
+  const stack = new Stack(app, 'test', { env: { region: 'us-east-1' } });
+
+  const bucketWebsite = new s3.Bucket(stack, 'Bucket', { bucketName });
+
+  // WHEN
+  const zone = new route53.PublicHostedZone(stack, 'HostedZone', { zoneName });
+  new route53.ARecord(zone, 'Alias', {
+    zone,
+    recordName,
+    target: route53.RecordTarget.fromAlias(
+      new targets.BucketWebsiteTarget(bucketWebsite, {
+        evaluateTargetHealth: true,
+      }),
+    ),
+  });
+
+  // THEN
+  Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
+    AliasTarget: {
+      EvaluateTargetHealth: true,
+    },
+  });
+});
+
 test('use S3 bucket website as record target (fromBucketName)', () => {
   // GIVEN
   const app = new App();

packages/aws-cdk-lib/aws-route53-targets/test/classic-load-balancer-target.test.ts

@@ -33,3 +33,35 @@ test('use classic ELB as record target', () => {
     },
   });
 });
+
+test('use classic ELB as record target with health check', () => {
+  // GIVEN
+  const stack = new Stack();
+  const vpc = new ec2.Vpc(stack, 'VPC', {
+    maxAzs: 2,
+  });
+  const lb = new elb.LoadBalancer(stack, 'LB', {
+    vpc,
+    internetFacing: true,
+  });
+
+  const zone = new route53.PublicHostedZone(stack, 'HostedZone', { zoneName: 'test.public' });
+
+  // WHEN
+  new route53.ARecord(zone, 'Alias', {
+    zone,
+    recordName: '_foo',
+    target: route53.RecordTarget.fromAlias(
+      new targets.ClassicLoadBalancerTarget(lb, {
+        evaluateTargetHealth: true,
+      }),
+    ),
+  });
+
+  // THEN
+  Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
+    AliasTarget: {
+      EvaluateTargetHealth: true,
+    },
+  });
+});

packages/aws-cdk-lib/aws-route53-targets/test/elastic-beanstalk-environment-target.test.ts

@@ -12,7 +12,9 @@ test('use EBS environment as record target', () => {
   new route53.ARecord(stack, 'Alias', {
     zone,
     recordName: '_foo',
-    target: route53.RecordTarget.fromAlias(new targets.ElasticBeanstalkEnvironmentEndpointTarget('mysampleenvironment.xyz.us-east-1.elasticbeanstalk.com')),
+    target: route53.RecordTarget.fromAlias(
+      new targets.ElasticBeanstalkEnvironmentEndpointTarget('mysampleenvironment.xyz.us-east-1.elasticbeanstalk.com'),
+    ),
   });
 
   // THEN
@@ -44,3 +46,27 @@ test('support 4-levels subdomain URLs for EBS environments', () => {
     },
   });
 });
+
+test('use EBS environment as record target with health check', () => {
+  // GIVEN
+  const stack = new Stack();
+  const zone = new route53.PublicHostedZone(stack, 'HostedZone', { zoneName: 'test.public' });
+
+  // WHEN
+  new route53.ARecord(stack, 'Alias', {
+    zone,
+    recordName: '_foo',
+    target: route53.RecordTarget.fromAlias(
+      new targets.ElasticBeanstalkEnvironmentEndpointTarget('mysampleenvironment.xyz.us-east-1.elasticbeanstalk.com', {
+        evaluateTargetHealth: true,
+      }),
+    ),
+  });
+
+  // THEN
+  Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
+    AliasTarget: {
+      EvaluateTargetHealth: true,
+    },
+  });
+});

packages/aws-cdk-lib/aws-route53-targets/test/global-accelerator-target.test.ts

@@ -48,12 +48,34 @@ test('GlobalAcceleratorTarget creates an alias resource with a Global Accelerato
   Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
     AliasTarget: {
       DNSName: {
-        'Fn::GetAtt': [
-          logicalId,
-          'DnsName',
-        ],
+        'Fn::GetAtt': [logicalId, 'DnsName'],
       },
       HostedZoneId: 'Z2BJ6XQ5FK7U4H',
     },
   });
-});
+});
+
+test('GlobalAcceleratorTarget creates an alias resource with health check', () => {
+  // GIVEN
+  const stack = new Stack();
+  const accelerator = new globalaccelerator.Accelerator(stack, 'Accelerator');
+  const zone = new route53.PublicHostedZone(stack, 'HostedZone', { zoneName: 'test.public' });
+
+  // WHEN
+  new route53.ARecord(stack, 'GlobalAcceleratorAlias', {
+    target: route53.RecordTarget.fromAlias(
+      new targets.GlobalAcceleratorTarget(accelerator, {
+        evaluateTargetHealth: true,
+      }),
+    ),
+    recordName: 'test',
+    zone,
+  });
+
+  // THEN
+  Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
+    AliasTarget: {
+      EvaluateTargetHealth: true,
+    },
+  });
+});

packages/aws-cdk-lib/aws-route53-targets/test/load-balancer-target.test.ts

@@ -33,3 +33,35 @@ test('use ALB as record target', () => {
     },
   });
 });
+
+test('use ALB as record target with health check', () => {
+  // GIVEN
+  const stack = new Stack();
+  const vpc = new ec2.Vpc(stack, 'VPC', {
+    maxAzs: 2,
+  });
+  const lb = new elbv2.ApplicationLoadBalancer(stack, 'LB', {
+    vpc,
+    internetFacing: true,
+  });
+
+  const zone = new route53.PublicHostedZone(stack, 'HostedZone', { zoneName: 'test.public' });
+
+  // WHEN
+  new route53.ARecord(zone, 'Alias', {
+    zone,
+    recordName: '_foo',
+    target: route53.RecordTarget.fromAlias(
+      new targets.LoadBalancerTarget(lb, {
+        evaluateTargetHealth: true,
+      }),
+    ),
+  });
+
+  // THEN
+  Template.fromStack(stack).hasResourceProperties('AWS::Route53::RecordSet', {
+    AliasTarget: {
+      EvaluateTargetHealth: true,
+    },
+  });
+});

packages/aws-cdk-lib/aws-route53/lib/alias-record-target.ts

@@ -25,4 +25,11 @@ export interface AliasRecordTargetConfig {
    * DNS name of the target
    */
   readonly dnsName: string;
+
+  /**
+   * Evaluate the target health
+   *
+   * @default - undefined
+   */
+  readonly evaluateTargetHealth?: boolean;
 }