aws-cdk-lib.aws_route53_targets

Route53 Alias Record Targets for the CDK Route53 Library

This library contains Route53 Alias Record targets for:

• API Gateway custom domains

import * as apigw from 'aws-cdk-lib/aws-apigateway';

declare const zone: route53.HostedZone;
declare const restApi: apigw.LambdaRestApi;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.ApiGateway(restApi)),
  // or - route53.RecordTarget.fromAlias(new alias.ApiGatewayDomain(domainName)),
});

import aws_cdk.aws_apigateway as apigw

# zone: route53.HostedZone
# rest_api: apigw.LambdaRestApi


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.ApiGateway(rest_api))
)

import software.amazon.awscdk.services.apigateway.*;

HostedZone zone;
LambdaRestApi restApi;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new ApiGateway(restApi)))
        .build();

using Amazon.CDK.AWS.APIGateway;

HostedZone zone;
LambdaRestApi restApi;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new ApiGateway(restApi))
});

import apigw "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var restApi LambdaRestApi


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewApiGateway(restApi)),
})

• API Gateway V2 custom domains

import * as apigwv2 from 'aws-cdk-lib/aws-apigatewayv2';

declare const zone: route53.HostedZone;
declare const domainName: apigwv2.DomainName;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.ApiGatewayv2DomainProperties(domainName.regionalDomainName, domainName.regionalHostedZoneId)),
});

import aws_cdk.aws_apigatewayv2 as apigwv2

# zone: route53.HostedZone
# domain_name: apigwv2.DomainName


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.ApiGatewayv2DomainProperties(domain_name.regional_domain_name, domain_name.regional_hosted_zone_id))
)

import software.amazon.awscdk.services.apigatewayv2.*;

HostedZone zone;
DomainName domainName;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new ApiGatewayv2DomainProperties(domainName.getRegionalDomainName(), domainName.getRegionalHostedZoneId())))
        .build();

using Amazon.CDK.AWS.Apigatewayv2;

HostedZone zone;
DomainName domainName;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new ApiGatewayv2DomainProperties(domainName.RegionalDomainName, domainName.RegionalHostedZoneId))
});

import apigwv2 "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var domainName DomainName


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewApiGatewayv2DomainProperties(domainName.regionalDomainName, domainName.regionalHostedZoneId)),
})

• AppSync custom domains

import * as appsync from 'aws-cdk-lib/aws-appsync';

declare const zone: route53.HostedZone;
declare const graphqlApi: appsync.GraphqlApi;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.AppSyncTarget(graphqlApi)),
});

import aws_cdk.aws_appsync as appsync

# zone: route53.HostedZone
# graphql_api: appsync.GraphqlApi


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.AppSyncTarget(graphql_api))
)

import software.amazon.awscdk.services.appsync.*;

HostedZone zone;
GraphqlApi graphqlApi;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new AppSyncTarget(graphqlApi)))
        .build();

using Amazon.CDK.AWS.AppSync;

HostedZone zone;
GraphqlApi graphqlApi;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new AppSyncTarget(graphqlApi))
});

import appsync "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var graphqlApi GraphqlApi


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewAppSyncTarget(graphqlApi)),
})

• CloudFront distributions

import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';

declare const zone: route53.HostedZone;
declare const distribution: cloudfront.CloudFrontWebDistribution;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
});

import aws_cdk.aws_cloudfront as cloudfront

# zone: route53.HostedZone
# distribution: cloudfront.CloudFrontWebDistribution


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.CloudFrontTarget(distribution))
)

import software.amazon.awscdk.services.cloudfront.*;

HostedZone zone;
CloudFrontWebDistribution distribution;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new CloudFrontTarget(distribution)))
        .build();

using Amazon.CDK.AWS.CloudFront;

HostedZone zone;
CloudFrontWebDistribution distribution;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new CloudFrontTarget(distribution))
});

import cloudfront "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var distribution CloudFrontWebDistribution


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewCloudFrontTarget(distribution)),
})

• ELBv2 load balancers

By providing optional properties, you can specify whether to evaluate target health.

import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';

declare const zone: route53.HostedZone;
declare const lb: elbv2.ApplicationLoadBalancer;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.LoadBalancerTarget(lb, {
      evaluateTargetHealth: true,
    }),
  ),
});

import aws_cdk.aws_elasticloadbalancingv2 as elbv2

# zone: route53.HostedZone
# lb: elbv2.ApplicationLoadBalancer


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.LoadBalancerTarget(lb, {
            "evaluate_target_health": True
        }))
)

import software.amazon.awscdk.services.elasticloadbalancingv2.*;

HostedZone zone;
ApplicationLoadBalancer lb;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new LoadBalancerTarget(lb, Map.of(
                "evaluateTargetHealth", true))))
        .build();

using Amazon.CDK.AWS.ElasticLoadBalancingV2;

HostedZone zone;
ApplicationLoadBalancer lb;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new LoadBalancerTarget(lb, new Dictionary<string, boolean?> {
        { "evaluateTargetHealth", true }
    }))
});

import elbv2 "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var lb ApplicationLoadBalancer


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewLoadBalancerTarget(lb, map[string]*bool{
		"evaluateTargetHealth": jsii.Boolean(true),
	})),
})

• Classic load balancers

By providing optional properties, you can specify whether to evaluate target health.

import * as elb from 'aws-cdk-lib/aws-elasticloadbalancing';

declare const zone: route53.HostedZone;
declare const lb: elb.LoadBalancer;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.ClassicLoadBalancerTarget(lb, {
      evaluateTargetHealth: true,
    }),
  ),
});

import aws_cdk.aws_elasticloadbalancing as elb

# zone: route53.HostedZone
# lb: elb.LoadBalancer


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.ClassicLoadBalancerTarget(lb, {
            "evaluate_target_health": True
        }))
)

import software.amazon.awscdk.services.elasticloadbalancing.*;

HostedZone zone;
LoadBalancer lb;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new ClassicLoadBalancerTarget(lb, Map.of(
                "evaluateTargetHealth", true))))
        .build();

using Amazon.CDK.AWS.ElasticLoadBalancing;

HostedZone zone;
LoadBalancer lb;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new ClassicLoadBalancerTarget(lb, new Dictionary<string, boolean?> {
        { "evaluateTargetHealth", true }
    }))
});

import elb "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var lb LoadBalancer


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewClassicLoadBalancerTarget(lb, map[string]*bool{
		"evaluateTargetHealth": jsii.Boolean(true),
	})),
})

Important: Based on AWS documentation, all alias record in Route 53 that points to a Elastic Load Balancer will always include dualstack for the DNSName to resolve IPv4/IPv6 addresses (without dualstack IPv6 will not resolve).

For example, if the Amazon-provided DNS for the load balancer is ALB-xxxxxxx.us-west-2.elb.amazonaws.com, CDK will create alias target in Route 53 will be dualstack.ALB-xxxxxxx.us-west-2.elb.amazonaws.com.

• GlobalAccelerator

By providing optional properties, you can specify whether to evaluate target health.

import * as globalaccelerator from 'aws-cdk-lib/aws-globalaccelerator';

declare const zone: route53.HostedZone;
declare const accelerator: globalaccelerator.Accelerator;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.GlobalAcceleratorTarget(accelerator, {
      evaluateTargetHealth: true,
    }),
  ),
  // or
  // route53.RecordTarget.fromAlias(new targets.GlobalAcceleratorDomainTarget('xyz.awsglobalaccelerator.com',{
  //   evaluateTargetHealth: true,
  // })),
});

import aws_cdk.aws_globalaccelerator as globalaccelerator

# zone: route53.HostedZone
# accelerator: globalaccelerator.Accelerator


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.GlobalAcceleratorTarget(accelerator, {
            "evaluate_target_health": True
        }))
)

import software.amazon.awscdk.services.globalaccelerator.*;

HostedZone zone;
Accelerator accelerator;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new GlobalAcceleratorTarget(accelerator, Map.of(
                "evaluateTargetHealth", true))))
        .build();

using Amazon.CDK.AWS.GlobalAccelerator;

HostedZone zone;
Accelerator accelerator;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new GlobalAcceleratorTarget(accelerator, new Dictionary<string, boolean?> {
        { "evaluateTargetHealth", true }
    }))
});

import globalaccelerator "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var accelerator Accelerator


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewGlobalAcceleratorTarget(accelerator, map[string]*bool{
		"evaluateTargetHealth": jsii.Boolean(true),
	})),
})

Important: If you use GlobalAcceleratorDomainTarget, passing a string rather than an instance of IAccelerator, ensure that the string is a valid domain name of an existing Global Accelerator instance. See the documentation on DNS addressing with Global Accelerator for more info.

• InterfaceVpcEndpoints

Important: Based on the CFN docs for VPCEndpoints - see here - the attributes returned for DnsEntries in CloudFormation is a combination of the hosted zone ID and the DNS name. The entries are ordered as follows: regional public DNS, zonal public DNS, private DNS, and wildcard DNS. This order is not enforced for AWS Marketplace services, and therefore this CDK construct is ONLY guaranteed to work with non-marketplace services.

import * as ec2 from 'aws-cdk-lib/aws-ec2';

declare const zone: route53.HostedZone;
declare const interfaceVpcEndpoint: ec2.InterfaceVpcEndpoint;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.InterfaceVpcEndpointTarget(interfaceVpcEndpoint)),
});

import aws_cdk.aws_ec2 as ec2

# zone: route53.HostedZone
# interface_vpc_endpoint: ec2.InterfaceVpcEndpoint


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.InterfaceVpcEndpointTarget(interface_vpc_endpoint))
)

import software.amazon.awscdk.services.ec2.*;

HostedZone zone;
InterfaceVpcEndpoint interfaceVpcEndpoint;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new InterfaceVpcEndpointTarget(interfaceVpcEndpoint)))
        .build();

using Amazon.CDK.AWS.EC2;

HostedZone zone;
InterfaceVpcEndpoint interfaceVpcEndpoint;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new InterfaceVpcEndpointTarget(interfaceVpcEndpoint))
});

import ec2 "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var interfaceVpcEndpoint InterfaceVpcEndpoint


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewInterfaceVpcEndpointTarget(interfaceVpcEndpoint)),
})

• S3 Bucket Website:

Important: The Bucket name must strictly match the full DNS name. See the Developer Guide for more info.

By providing optional properties, you can specify whether to evaluate target health.

import * as s3 from 'aws-cdk-lib/aws-s3';

const recordName = 'www';
const domainName = 'example.com';

const bucketWebsite = new s3.Bucket(this, 'BucketWebsite', {
  bucketName: [recordName, domainName].join('.'), // www.example.com
  publicReadAccess: true,
  websiteIndexDocument: 'index.html',
});

const zone = route53.HostedZone.fromLookup(this, 'Zone', { domainName }); // example.com

new route53.ARecord(this, 'AliasRecord', {
  zone,
  recordName, // www
  target: route53.RecordTarget.fromAlias(
    new targets.BucketWebsiteTarget(bucketWebsite, {
      evaluateTargetHealth: true,
    }),
  ),
});

import aws_cdk.aws_s3 as s3


record_name = "www"
domain_name = "example.com"

bucket_website = s3.Bucket(self, "BucketWebsite",
    bucket_name=[record_name, domain_name].join("."),  # www.example.com
    public_read_access=True,
    website_index_document="index.html"
)

zone = route53.HostedZone.from_lookup(self, "Zone", domain_name=domain_name) # example.com

route53.ARecord(self, "AliasRecord",
    zone=zone,
    record_name=record_name,  # www
    target=route53.RecordTarget.from_alias(
        targets.BucketWebsiteTarget(bucket_website, {
            "evaluate_target_health": True
        }))
)

import software.amazon.awscdk.services.s3.*;


String recordName = "www";
String domainName = "example.com";

Bucket bucketWebsite = Bucket.Builder.create(this, "BucketWebsite")
        .bucketName(List.of(recordName, domainName).join(".")) // www.example.com
        .publicReadAccess(true)
        .websiteIndexDocument("index.html")
        .build();

IHostedZone zone = HostedZone.fromLookup(this, "Zone", HostedZoneProviderProps.builder().domainName(domainName).build()); // example.com

 // example.com
ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .recordName(recordName) // www
        .target(RecordTarget.fromAlias(
        new BucketWebsiteTarget(bucketWebsite, Map.of(
                "evaluateTargetHealth", true))))
        .build();

using Amazon.CDK.AWS.S3;


var recordName = "www";
var domainName = "example.com";

var bucketWebsite = new Bucket(this, "BucketWebsite", new BucketProps {
    BucketName = new [] { recordName, domainName }.Join("."),  // www.example.com
    PublicReadAccess = true,
    WebsiteIndexDocument = "index.html"
});

var zone = HostedZone.FromLookup(this, "Zone", new HostedZoneProviderProps { DomainName = domainName }); // example.com

 // example.com
new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    RecordName = recordName,  // www
    Target = RecordTarget.FromAlias(
    new BucketWebsiteTarget(bucketWebsite, new Dictionary<string, boolean?> {
        { "evaluateTargetHealth", true }
    }))
});

import s3 "github.com/aws/aws-cdk-go/awscdk"


recordName := "www"
domainName := "example.com"

bucketWebsite := s3.NewBucket(this, jsii.String("BucketWebsite"), &BucketProps{
	BucketName: []*string{
		recordName,
		domainName,
	}.join(jsii.String(".")),
	 // www.example.com
	PublicReadAccess: jsii.Boolean(true),
	WebsiteIndexDocument: jsii.String("index.html"),
})

zone := route53.HostedZone_FromLookup(this, jsii.String("Zone"), &HostedZoneProviderProps{
	DomainName: jsii.String(DomainName),
}) // example.com

 // example.com
route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	RecordName: jsii.String(RecordName),
	 // www
	Target: route53.RecordTarget_FromAlias(
	targets.NewBucketWebsiteTarget(bucketWebsite, map[string]*bool{
		"evaluateTargetHealth": jsii.Boolean(true),
	})),
})

• User pool domain

import * as cognito from 'aws-cdk-lib/aws-cognito';

declare const zone: route53.HostedZone;
declare const domain: cognito.UserPoolDomain;
new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.UserPoolDomainTarget(domain)),
});

import aws_cdk.aws_cognito as cognito

# zone: route53.HostedZone
# domain: cognito.UserPoolDomain

route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.UserPoolDomainTarget(domain))
)

import software.amazon.awscdk.services.cognito.*;

HostedZone zone;
UserPoolDomain domain;

ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new UserPoolDomainTarget(domain)))
        .build();

using Amazon.CDK.AWS.Cognito;

HostedZone zone;
UserPoolDomain domain;

new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new UserPoolDomainTarget(domain))
});

import cognito "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var domain UserPoolDomain

route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewUserPoolDomainTarget(domain)),
})

• Route 53 record

declare const zone: route53.HostedZone;
declare const record: route53.ARecord;
new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(new targets.Route53RecordTarget(record)),
});

# zone: route53.HostedZone
# record: route53.ARecord

route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(targets.Route53RecordTarget(record))
)

HostedZone zone;
ARecord record;

ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(new Route53RecordTarget(record)))
        .build();

HostedZone zone;
ARecord record;

new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(new Route53RecordTarget(record))
});

var zone HostedZone
var record ARecord

route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(targets.NewRoute53RecordTarget(record)),
})

• Elastic Beanstalk environment:

Important: Only supports Elastic Beanstalk environments created after 2016 that have a regional endpoint.

By providing optional properties, you can specify whether to evaluate target health.

declare const zone: route53.HostedZone;
declare const ebsEnvironmentUrl: string;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, {
      evaluateTargetHealth: true,
    }),
  ),
});

# zone: route53.HostedZone
# ebs_environment_url: str


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url, {
            "evaluate_target_health": True
        }))
)

HostedZone zone;
String ebsEnvironmentUrl;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, Map.of(
                "evaluateTargetHealth", true))))
        .build();

HostedZone zone;
string ebsEnvironmentUrl;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, new Dictionary<string, boolean?> {
        { "evaluateTargetHealth", true }
    }))
});

var zone HostedZone
var ebsEnvironmentUrl string


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, map[string]*bool{
		"evaluateTargetHealth": jsii.Boolean(true),
	})),
})

If Elastic Beanstalk environment URL is not available at synth time, you can specify Hosted Zone ID of the target

import { RegionInfo } from 'aws-cdk-lib/region-info';

declare const zone: route53.HostedZone;
declare const ebsEnvironmentUrl: string;

new route53.ARecord(this, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, {
      hostedZoneId: RegionInfo.get('us-east-1').ebsEnvEndpointHostedZoneId,
    }),
  ),
});

from aws_cdk.region_info import RegionInfo

# zone: route53.HostedZone
# ebs_environment_url: str


route53.ARecord(self, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url, {
            "hosted_zone_id": RegionInfo.get("us-east-1").ebs_env_endpoint_hosted_zone_id
        }))
)

import software.amazon.awscdk.regioninfo.RegionInfo;

HostedZone zone;
String ebsEnvironmentUrl;


ARecord.Builder.create(this, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, Map.of(
                "hostedZoneId", RegionInfo.get("us-east-1").getEbsEnvEndpointHostedZoneId()))))
        .build();

using Amazon.CDK.RegionInfo;

HostedZone zone;
string ebsEnvironmentUrl;


new ARecord(this, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, new Dictionary<string, string?> {
        { "hostedZoneId", RegionInfo.Get("us-east-1").EbsEnvEndpointHostedZoneId }
    }))
});

import "github.com/aws/aws-cdk-go/awscdk"

var zone HostedZone
var ebsEnvironmentUrl string


route53.NewARecord(this, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl, map[string]*string{
		"hostedZoneId": awscdk.RegionInfo_get(jsii.String("us-east-1")).ebsEnvEndpointHostedZoneId,
	})),
})

Or you can specify Stack region for CDK to generate the correct Hosted Zone ID.

import { App } from 'aws-cdk-lib';

declare const app: App;
declare const zone: route53.HostedZone;
declare const ebsEnvironmentUrl: string;

const stack = new Stack(app, 'my-stack', {
  env: {
    region: 'us-east-1',
  },
});

new route53.ARecord(stack, 'AliasRecord', {
  zone,
  target: route53.RecordTarget.fromAlias(
    new targets.ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl),
  ),
});

from aws_cdk import Environment
from aws_cdk import App

# app: App
# zone: route53.HostedZone
# ebs_environment_url: str


stack = Stack(app, "my-stack",
    env=Environment(
        region="us-east-1"
    )
)

route53.ARecord(stack, "AliasRecord",
    zone=zone,
    target=route53.RecordTarget.from_alias(
        targets.ElasticBeanstalkEnvironmentEndpointTarget(ebs_environment_url))
)

import software.amazon.awscdk.App;

App app;
HostedZone zone;
String ebsEnvironmentUrl;


Stack stack = Stack.Builder.create(app, "my-stack")
        .env(Environment.builder()
                .region("us-east-1")
                .build())
        .build();

ARecord.Builder.create(stack, "AliasRecord")
        .zone(zone)
        .target(RecordTarget.fromAlias(
        new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl)))
        .build();

using Amazon.CDK;

App app;
HostedZone zone;
string ebsEnvironmentUrl;


var stack = new Stack(app, "my-stack", new StackProps {
    Env = new Environment {
        Region = "us-east-1"
    }
});

new ARecord(stack, "AliasRecord", new ARecordProps {
    Zone = zone,
    Target = RecordTarget.FromAlias(
    new ElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl))
});

import "github.com/aws/aws-cdk-go/awscdk"

var app App
var zone HostedZone
var ebsEnvironmentUrl string


stack := awscdk.Newstack(app, jsii.String("my-stack"), &StackProps{
	Env: &Environment{
		Region: jsii.String("us-east-1"),
	},
})

route53.NewARecord(stack, jsii.String("AliasRecord"), &ARecordProps{
	Zone: Zone,
	Target: route53.RecordTarget_FromAlias(
	targets.NewElasticBeanstalkEnvironmentEndpointTarget(ebsEnvironmentUrl)),
})

See the documentation of aws-cdk-lib/aws-route53 for more information.

Types

Name	Kind	Summary
ApiGateway	Class	Defines an API Gateway REST API as the alias target. Requires that the domain name will be defined through RestApiProps.domainName.
ApiGatewayDomain	Class	Defines an API Gateway domain name as the alias target.
ApiGatewayv2DomainProperties	Class	Defines an API Gateway V2 domain name as the alias target.
AppSyncTarget	Class	Defines an AppSync Graphql API as the alias target.
BucketWebsiteTarget	Class	Use a S3 as an alias record target.
ClassicLoadBalancerTarget	Class	Use a classic ELB as an alias record target.
CloudFrontTarget	Class	Use a CloudFront Distribution as an alias record target.
ElasticBeanstalkEnvironmentEndpointTarget	Class	Use an Elastic Beanstalk environment URL as an alias record target. E.g. mysampleenvironment.xyz.us-east-1.elasticbeanstalk.com or mycustomcnameprefix.us-east-1.elasticbeanstalk.com.
GlobalAcceleratorDomainTarget	Class	Use a Global Accelerator domain name as an alias record target.
GlobalAcceleratorTarget	Class	Use a Global Accelerator instance domain name as an alias record target.
IAliasRecordTargetProps	Interface	Properties the alias record target.
InterfaceVpcEndpointTarget	Class	Set an InterfaceVpcEndpoint as a target for an ARecord.
LoadBalancerTarget	Class	Use an ELBv2 as an alias record target.
Route53RecordTarget	Class	Use another Route 53 record as an alias record target.
UserPoolDomainTarget	Class	Use a user pool domain as an alias record target.