Metadata-Version: 2.1
Name: aws-cdk.aws-route53
Version: 1.87.1
Summary: The CDK Construct Library for AWS::Route53
Home-page: https://github.com/aws/aws-cdk
Author: Amazon Web Services
License: Apache-2.0
Project-URL: Source, https://github.com/aws/aws-cdk.git
Description: # Amazon Route53 Construct Library
        
        <!--BEGIN STABILITY BANNER-->---
        
        
        ![cfn-resources: Stable](https://img.shields.io/badge/cfn--resources-stable-success.svg?style=for-the-badge)
        
        ![cdk-constructs: Stable](https://img.shields.io/badge/cdk--constructs-stable-success.svg?style=for-the-badge)
        
        ---
        <!--END STABILITY BANNER-->
        
        To add a public hosted zone:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_route53 as route53
        
        route53.PublicHostedZone(self, "HostedZone",
            zone_name="fully.qualified.domain.com"
        )
        ```
        
        To add a private hosted zone, use `PrivateHostedZone`. Note that
        `enableDnsHostnames` and `enableDnsSupport` must have been enabled for the
        VPC you're configuring for private hosted zones.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_ec2 as ec2
        import aws_cdk.aws_route53 as route53
        
        vpc = ec2.Vpc(self, "VPC")
        
        zone = route53.PrivateHostedZone(self, "HostedZone",
            zone_name="fully.qualified.domain.com",
            vpc=vpc
        )
        ```
        
        Additional VPCs can be added with `zone.addVpc()`.
        
        ## Adding Records
        
        To add a TXT record to your zone:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_route53 as route53
        
        route53.TxtRecord(self, "TXTRecord",
            zone=my_zone,
            record_name="_foo", # If the name ends with a ".", it will be used as-is;
            # if it ends with a "." followed by the zone name, a trailing "." will be added automatically;
            # otherwise, a ".", the zone name, and a trailing "." will be added automatically.
            # Defaults to zone root if not specified.
            values=["Bar!", "Baz?"],
            ttl=Duration.minutes(90)
        )
        ```
        
        To add an A record to your zone:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_route53 as route53
        
        route53.ARecord(self, "ARecord",
            zone=my_zone,
            target=route53.RecordTarget.from_ip_addresses("1.2.3.4", "5.6.7.8")
        )
        ```
        
        To add an A record for an EC2 instance with an Elastic IP (EIP) to your zone:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_ec2 as ec2
        import aws_cdk.aws_route53 as route53
        
        instance = ec2.Instance(self, "Instance", {})
        
        elastic_ip = ec2.CfnEIP(self, "EIP",
            domain="vpc",
            instance_id=instance.instance_id
        )
        
        route53.ARecord(self, "ARecord",
            zone=my_zone,
            target=route53.RecordTarget.from_ip_addresses(elastic_ip.ref)
        )
        ```
        
        To add an AAAA record pointing to a CloudFront distribution:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        import aws_cdk.aws_route53 as route53
        import aws_cdk.aws_route53_targets as targets
        
        route53.AaaaRecord(self, "Alias",
            zone=my_zone,
            target=route53.RecordTarget.from_alias(targets.CloudFrontTarget(distribution))
        )
        ```
        
        Constructs are available for A, AAAA, CAA, CNAME, MX, NS, SRV and TXT records.
        
        Use the `CaaAmazonRecord` construct to easily restrict certificate authorities
        allowed to issue certificates for a domain to Amazon only.
        
        ## Imports
        
        If you don't know the ID of the Hosted Zone to import, you can use the
        `HostedZone.fromLookup`:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        HostedZone.from_lookup(self, "MyZone",
            domain_name="example.com"
        )
        ```
        
        `HostedZone.fromLookup` requires an environment to be configured. Check
        out the [documentation](https://docs.aws.amazon.com/cdk/latest/guide/environments.html) for more documentation and examples. CDK
        automatically looks into your `~/.aws/config` file for the `[default]` profile.
        If you want to specify a different account run `cdk deploy --profile [profile]`.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        MyDevStack(app, "dev",
            env={
                "account": process.env.CDK_DEFAULT_ACCOUNT,
                "region": process.env.CDK_DEFAULT_REGION
            }
        )
        ```
        
        If you know the ID and Name of a Hosted Zone, you can import it directly:
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        zone = HostedZone.from_hosted_zone_attributes(self, "MyZone",
            zone_name="example.com",
            hosted_zone_id="ZOJJZC49E0EPZ"
        )
        ```
        
        Alternatively, use the `HostedZone.fromHostedZoneId` to import hosted zones if
        you know the ID and the retrieval for the `zoneName` is undesirable.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        zone = HostedZone.from_hosted_zone_id(self, "MyZone",
            hosted_zone_id="ZOJJZC49E0EPZ"
        )
        ```
        
        ## VPC Endpoint Service Private DNS
        
        When you create a VPC endpoint service, AWS generates endpoint-specific DNS hostnames that consumers use to communicate with the service.
        For example, vpce-1234-abcdev-us-east-1.vpce-svc-123345.us-east-1.vpce.amazonaws.com.
        By default, your consumers access the service with that DNS name.
        This can cause problems with HTTPS traffic because the DNS will not match the backend certificate:
        
        ```console
        curl: (60) SSL: no alternative certificate subject name matches target host name 'vpce-abcdefghijklmnopq-rstuvwx.vpce-svc-abcdefghijklmnopq.us-east-1.vpce.amazonaws.com'
        ```
        
        Effectively, the endpoint appears untrustworthy. To mitigate this, clients have to create an alias for this DNS name in Route53.
        
        Private DNS for an endpoint service lets you configure a private DNS name so consumers can
        access the service using an existing DNS name without creating this Route53 DNS alias
        This DNS name can also be guaranteed to match up with the backend certificate.
        
        Before consumers can use the private DNS name, you must verify that you have control of the domain/subdomain.
        
        Assuming your account has ownership of the particlar domain/subdomain,
        this construct sets up the private DNS configuration on the endpoint service,
        creates all the necessary Route53 entries, and verifies domain ownership.
        
        ```python
        # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826
        from aws_cdk.core import Stack
        from aws_cdk.aws_ec2 import Vpc, VpcEndpointService
        from aws_cdk.aws_elasticloadbalancingv2 import NetworkLoadBalancer
        from aws_cdk.aws_route53 import PublicHostedZone
        
        stack = Stack()
        vpc = Vpc(stack, "VPC")
        nlb = NetworkLoadBalancer(stack, "NLB",
            vpc=vpc
        )
        vpces = VpcEndpointService(stack, "VPCES",
            vpc_endpoint_service_load_balancers=[nlb]
        )
        # You must use a public hosted zone so domain ownership can be verified
        zone = PublicHostedZone(stack, "PHZ",
            zone_name="aws-cdk.dev"
        )
        VpcEndpointServiceDomainName(stack, "EndpointDomain",
            endpoint_service=vpces,
            domain_name="my-stuff.aws-cdk.dev",
            public_hosted_zone=zone
        )
        ```
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: JavaScript
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Typing :: Typed
Classifier: Development Status :: 5 - Production/Stable
Classifier: License :: OSI Approved
Classifier: Framework :: AWS CDK
Classifier: Framework :: AWS CDK :: 1
Requires-Python: >=3.6
Description-Content-Type: text/markdown
