@aws-cdk/aws-route53/lib/vpc-endpoint-service-domain-name.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.VpcEndpointServiceDomainName = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const crypto = require("crypto");
const core_1 = require("@aws-cdk/core");
const custom_resources_1 = require("@aws-cdk/custom-resources");
const lib_1 = require("../lib");
// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.
// eslint-disable-next-line
const core_2 = require("@aws-cdk/core");
/**
 * A Private DNS configuration for a VPC endpoint service.
 */
class VpcEndpointServiceDomainName extends core_2.Construct {
    // The way this class works is by using three custom resources and a TxtRecord in conjunction
    // The first custom resource tells the VPC endpoint service to use the given DNS name
    // The VPC endpoint service will then say:
    // "ok, create a TXT record using these two values to prove you own the domain"
    // The second custom resource retrieves these two values from the service
    // The TxtRecord is created from these two values
    // The third custom resource tells the VPC Endpoint Service to verify the domain ownership
    constructor(scope, id, props) {
        super(scope, id);
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_route53_VpcEndpointServiceDomainNameProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, VpcEndpointServiceDomainName);
            }
            throw error;
        }
        const serviceUniqueId = core_1.Names.nodeUniqueId(props.endpointService.node);
        const serviceId = props.endpointService.vpcEndpointServiceId;
        this.domainName = props.domainName;
        // Make sure a user doesn't accidentally add multiple domains
        this.validateProps(props);
        VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId] = this.domainName;
        VpcEndpointServiceDomainName.endpointServices.push(props.endpointService);
        // Enable Private DNS on the endpoint service and retrieve the AWS-generated configuration
        const privateDnsConfiguration = this.getPrivateDnsConfiguration(serviceUniqueId, serviceId, this.domainName);
        // Tell AWS to verify that this account owns the domain attached to the service
        this.verifyPrivateDnsConfiguration(privateDnsConfiguration, props.publicHostedZone);
        // Finally, don't do any of the above before the endpoint service is created
        this.node.addDependency(props.endpointService);
    }
    validateProps(props) {
        const serviceUniqueId = core_1.Names.nodeUniqueId(props.endpointService.node);
        if (serviceUniqueId in VpcEndpointServiceDomainName.endpointServicesMap) {
            const endpoint = VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId];
            throw new Error(`Cannot create a VpcEndpointServiceDomainName for service ${serviceUniqueId}, another VpcEndpointServiceDomainName (${endpoint}) is already associated with it`);
        }
    }
    /**
     * Sets up Custom Resources to make AWS calls to set up Private DNS on an endpoint service,
     * returning the values to use in a TxtRecord, which AWS uses to verify domain ownership.
     */
    getPrivateDnsConfiguration(serviceUniqueId, serviceId, privateDnsName) {
        // The custom resource which tells AWS to enable Private DNS on the given service, using the given domain name
        // AWS will generate a name/value pair for use in a TxtRecord, which is used to verify domain ownership.
        const enablePrivateDnsAction = {
            service: 'EC2',
            action: 'modifyVpcEndpointServiceConfiguration',
            parameters: {
                ServiceId: serviceId,
                PrivateDnsName: privateDnsName,
            },
            physicalResourceId: custom_resources_1.PhysicalResourceId.of(serviceUniqueId),
        };
        const removePrivateDnsAction = {
            service: 'EC2',
            action: 'modifyVpcEndpointServiceConfiguration',
            parameters: {
                ServiceId: serviceId,
                RemovePrivateDnsName: true,
            },
        };
        const enable = new custom_resources_1.AwsCustomResource(this, 'EnableDns', {
            onCreate: enablePrivateDnsAction,
            onUpdate: enablePrivateDnsAction,
            onDelete: removePrivateDnsAction,
            policy: custom_resources_1.AwsCustomResourcePolicy.fromSdkCalls({
                resources: [
                    core_1.Fn.join(':', [
                        'arn',
                        core_1.Stack.of(this).partition,
                        'ec2',
                        core_1.Stack.of(this).region,
                        core_1.Stack.of(this).account,
                        core_1.Fn.join('/', [
                            'vpc-endpoint-service',
                            serviceId,
                        ]),
                    ]),
                ],
            }),
        });
        // Look up the name/value pair if the domain changes, or the service changes,
        // which would cause the values to be different. If the unique ID changes,
        // the resource may be entirely recreated, so we will need to look it up again.
        const lookup = hashcode(core_1.Names.uniqueId(this) + serviceUniqueId + privateDnsName);
        // Create the custom resource to look up the name/value pair generated by AWS
        // after the previous API call
        const retrieveNameValuePairAction = {
            service: 'EC2',
            action: 'describeVpcEndpointServiceConfigurations',
            parameters: {
                ServiceIds: [serviceId],
            },
            physicalResourceId: custom_resources_1.PhysicalResourceId.of(lookup),
        };
        const getNames = new custom_resources_1.AwsCustomResource(this, 'GetNames', {
            onCreate: retrieveNameValuePairAction,
            onUpdate: retrieveNameValuePairAction,
            // describeVpcEndpointServiceConfigurations can't take an ARN for granular permissions
            policy: custom_resources_1.AwsCustomResourcePolicy.fromSdkCalls({
                resources: custom_resources_1.AwsCustomResourcePolicy.ANY_RESOURCE,
            }),
        });
        // We only want to call and get the name/value pair after we've told AWS to enable Private DNS
        // If we call before then, we'll get an empty pair of values.
        getNames.node.addDependency(enable);
        // Get the references to the name/value pair associated with the endpoint service
        const name = getNames.getResponseField('ServiceConfigurations.0.PrivateDnsNameConfiguration.Name');
        const value = getNames.getResponseField('ServiceConfigurations.0.PrivateDnsNameConfiguration.Value');
        return { name, value, serviceId };
    }
    /**
     * Creates a Route53 entry and a Custom Resource which explicitly tells AWS to verify ownership
     * of the domain name attached to an endpoint service.
     */
    verifyPrivateDnsConfiguration(config, publicHostedZone) {
        // Create the TXT record in the provided hosted zone
        const verificationRecord = new lib_1.TxtRecord(this, 'DnsVerificationRecord', {
            recordName: config.name,
            values: [config.value],
            zone: publicHostedZone,
        });
        // Tell the endpoint service to verify the domain ownership
        const startVerificationAction = {
            service: 'EC2',
            action: 'startVpcEndpointServicePrivateDnsVerification',
            parameters: {
                ServiceId: config.serviceId,
            },
            physicalResourceId: custom_resources_1.PhysicalResourceId.of(core_1.Fn.join(':', [config.name, config.value])),
        };
        const startVerification = new custom_resources_1.AwsCustomResource(this, 'StartVerification', {
            onCreate: startVerificationAction,
            onUpdate: startVerificationAction,
            policy: custom_resources_1.AwsCustomResourcePolicy.fromSdkCalls({
                resources: [
                    core_1.Fn.join(':', [
                        'arn',
                        core_1.Stack.of(this).partition,
                        'ec2',
                        core_1.Stack.of(this).region,
                        core_1.Stack.of(this).account,
                        core_1.Fn.join('/', [
                            'vpc-endpoint-service',
                            config.serviceId,
                        ]),
                    ]),
                ],
            }),
        });
        // Only verify after the record has been created
        startVerification.node.addDependency(verificationRecord);
    }
}
exports.VpcEndpointServiceDomainName = VpcEndpointServiceDomainName;
_a = JSII_RTTI_SYMBOL_1;
VpcEndpointServiceDomainName[_a] = { fqn: "@aws-cdk/aws-route53.VpcEndpointServiceDomainName", version: "1.160.0" };
// Track all domain names created, so someone doesn't accidentally associate two domains with a single service
VpcEndpointServiceDomainName.endpointServices = [];
// Track all domain names created, so someone doesn't accidentally associate two domains with a single service
VpcEndpointServiceDomainName.endpointServicesMap = {};
/**
 * Hash a string
 */
function hashcode(s) {
    const hash = crypto.createHash('md5');
    hash.update(s);
    return hash.digest('hex');
}
;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-endpoint-service-domain-name.js","sourceRoot":"","sources":["vpc-endpoint-service-domain-name.ts"],"names":[],"mappings":";;;;;;AAAA,iCAAiC;AAEjC,wCAAiD;AACjD,gEAA2G;AAE3G,gCAAsD;AAEtD,gHAAgH;AAChH,2BAA2B;AAC3B,wCAA2D;AA4B3D;;GAEG;AACH,MAAa,4BAA6B,SAAQ,gBAAa;IAa7D,6FAA6F;IAC7F,qFAAqF;IACrF,0CAA0C;IAC1C,+EAA+E;IAC/E,yEAAyE;IACzE,iDAAiD;IACjD,0FAA0F;IAC1F,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAwC;QAChF,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;;;;;;+CArBR,4BAA4B;;;;QAuBrC,MAAM,eAAe,GAAG,YAAK,CAAC,YAAY,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACvE,MAAM,SAAS,GAAG,KAAK,CAAC,eAAe,CAAC,oBAAoB,CAAC;QAC7D,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAEnC,6DAA6D;QAC7D,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAE1B,4BAA4B,CAAC,mBAAmB,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;QACpF,4BAA4B,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAE1E,0FAA0F;QAC1F,MAAM,uBAAuB,GAAG,IAAI,CAAC,0BAA0B,CAAC,eAAe,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAE7G,+EAA+E;QAC/E,IAAI,CAAC,6BAA6B,CAAC,uBAAuB,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAEpF,4EAA4E;QAC5E,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;KAChD;IAEO,aAAa,CAAC,KAAwC;QAC5D,MAAM,eAAe,GAAG,YAAK,CAAC,YAAY,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACvE,IAAI,eAAe,IAAI,4BAA4B,CAAC,mBAAmB,EAAE;YACvE,MAAM,QAAQ,GAAG,4BAA4B,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;YACnF,MAAM,IAAI,KAAK,CACb,4DAA4D,eAAe,2CAA2C,QAAQ,iCAAiC,CAAC,CAAC;SACpK;KACF;IAED;;;OAGG;IACK,0BAA0B,CAAC,eAAuB,EAAE,SAAiB,EAAE,cAAsB;QAEnG,8GAA8G;QAC9G,wGAAwG;QACxG,MAAM,sBAAsB,GAAG;YAC7B,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,uCAAuC;YAC/C,UAAU,EAAE;gBACV,SAAS,EAAE,SAAS;gBACpB,cAAc,EAAE,cAAc;aAC/B;YACD,kBAAkB,EAAE,qCAAkB,CAAC,EAAE,CAAC,eAAe,CAAC;SAC3D,CAAC;QACF,MAAM,sBAAsB,GAAG;YAC7B,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,uCAAuC;YAC/C,UAAU,EAAE;gBACV,SAAS,EAAE,SAAS;gBACpB,oBAAoB,EAAE,IAAI;aAC3B;SACF,CAAC;QACF,MAAM,MAAM,GAAG,IAAI,oCAAiB,CAAC,IAAI,EAAE,WAAW,EAAE;YACtD,QAAQ,EAAE,sBAAsB;YAChC,QAAQ,EAAE,sBAAsB;YAChC,QAAQ,EAAE,sBAAsB;YAChC,MAAM,EAAE,0CAAuB,CAAC,YAAY,CAAC;gBAC3C,SAAS,EAAE;oBACT,SAAE,CAAC,IAAI,CAAC,GAAG,EAAE;wBACX,KAAK;wBACL,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS;wBACxB,KAAK;wBACL,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM;wBACrB,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO;wBACtB,SAAE,CAAC,IAAI,CAAC,GAAG,EAAE;4BACX,sBAAsB;4BACtB,SAAS;yBACV,CAAC;qBACH,CAAC;iBACH;aACF,CAAC;SACH,CAAC,CAAC;QAEH,6EAA6E;QAC7E,0EAA0E;QAC1E,+EAA+E;QAC/E,MAAM,MAAM,GAAG,QAAQ,CAAC,YAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,eAAe,GAAG,cAAc,CAAC,CAAC;QAEjF,6EAA6E;QAC7E,8BAA8B;QAC9B,MAAM,2BAA2B,GAAG;YAClC,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,0CAA0C;YAClD,UAAU,EAAE;gBACV,UAAU,EAAE,CAAC,SAAS,CAAC;aACxB;YACD,kBAAkB,EAAE,qCAAkB,CAAC,EAAE,CAAC,MAAM,CAAC;SAClD,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,oCAAiB,CAAC,IAAI,EAAE,UAAU,EAAE;YACvD,QAAQ,EAAE,2BAA2B;YACrC,QAAQ,EAAE,2BAA2B;YACrC,sFAAsF;YACtF,MAAM,EAAE,0CAAuB,CAAC,YAAY,CAAC;gBAC3C,SAAS,EAAE,0CAAuB,CAAC,YAAY;aAChD,CAAC;SACH,CAAC,CAAC;QAEH,8FAA8F;QAC9F,6DAA6D;QAC7D,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAEpC,iFAAiF;QACjF,MAAM,IAAI,GAAG,QAAQ,CAAC,gBAAgB,CAAC,0DAA0D,CAAC,CAAC;QACnG,MAAM,KAAK,GAAG,QAAQ,CAAC,gBAAgB,CAAC,2DAA2D,CAAC,CAAC;QAErG,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;KACnC;IAED;;;OAGG;IACK,6BAA6B,CAAC,MAA+B,EAAE,gBAAmC;QACxG,oDAAoD;QACpD,MAAM,kBAAkB,GAAG,IAAI,eAAS,CAAC,IAAI,EAAE,uBAAuB,EAAE;YACtE,UAAU,EAAE,MAAM,CAAC,IAAI;YACvB,MAAM,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC;YACtB,IAAI,EAAE,gBAAgB;SACvB,CAAC,CAAC;QAEH,2DAA2D;QAC3D,MAAM,uBAAuB,GAAG;YAC9B,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,+CAA+C;YACvD,UAAU,EAAE;gBACV,SAAS,EAAE,MAAM,CAAC,SAAS;aAC5B;YACD,kBAAkB,EAAE,qCAAkB,CAAC,EAAE,CAAC,SAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;SACrF,CAAC;QACF,MAAM,iBAAiB,GAAG,IAAI,oCAAiB,CAAC,IAAI,EAAE,mBAAmB,EAAE;YACzE,QAAQ,EAAE,uBAAuB;YACjC,QAAQ,EAAE,uBAAuB;YACjC,MAAM,EAAE,0CAAuB,CAAC,YAAY,CAAC;gBAC3C,SAAS,EAAE;oBACT,SAAE,CAAC,IAAI,CAAC,GAAG,EAAE;wBACX,KAAK;wBACL,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,SAAS;wBACxB,KAAK;wBACL,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM;wBACrB,YAAK,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO;wBACtB,SAAE,CAAC,IAAI,CAAC,GAAG,EAAE;4BACX,sBAAsB;4BACtB,MAAM,CAAC,SAAS;yBACjB,CAAC;qBACH,CAAC;iBACH;aACF,CAAC;SACH,CAAC,CAAC;QACH,gDAAgD;QAChD,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;KAC1D;;AA/KH,oEAgLC;;;AA9KC,8GAA8G;AACtF,6CAAgB,GAA0B,EAAE,CAAC;AAErE,8GAA8G;AACtF,gDAAmB,GAAyC,EAAE,CAAC;AAqLzF;;GAEG;AACH,SAAS,QAAQ,CAAC,CAAS;IACzB,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACf,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAAA,CAAC","sourcesContent":["import * as crypto from 'crypto';\nimport { IVpcEndpointService } from '@aws-cdk/aws-ec2';\nimport { Fn, Names, Stack } from '@aws-cdk/core';\nimport { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from '@aws-cdk/custom-resources';\nimport { Construct } from 'constructs';\nimport { IPublicHostedZone, TxtRecord } from '../lib';\n\n// v2 - keep this import as a separate section to reduce merge conflict when forward merging with the v2 branch.\n// eslint-disable-next-line\nimport { Construct as CoreConstruct } from '@aws-cdk/core';\n\n/**\n * Properties to configure a VPC Endpoint Service domain name\n */\nexport interface VpcEndpointServiceDomainNameProps {\n\n  /**\n   * The VPC Endpoint Service to configure Private DNS for\n   */\n  readonly endpointService: IVpcEndpointService;\n\n  /**\n   * The domain name to use.\n   *\n   * This domain name must be owned by this account (registered through Route53),\n   * or delegated to this account. Domain ownership will be verified by AWS before\n   * private DNS can be used.\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-dns-validation.html\n   */\n  readonly domainName: string;\n\n  /**\n   * The public hosted zone to use for the domain.\n   */\n  readonly publicHostedZone: IPublicHostedZone;\n}\n\n/**\n * A Private DNS configuration for a VPC endpoint service.\n */\nexport class VpcEndpointServiceDomainName extends CoreConstruct {\n\n  // Track all domain names created, so someone doesn't accidentally associate two domains with a single service\n  private static readonly endpointServices: IVpcEndpointService[] = [];\n\n  // Track all domain names created, so someone doesn't accidentally associate two domains with a single service\n  private static readonly endpointServicesMap: { [endpointService: string]: string} = {};\n\n  /**\n   * The domain name associated with the private DNS configuration\n   */\n  public domainName: string;\n\n  // The way this class works is by using three custom resources and a TxtRecord in conjunction\n  // The first custom resource tells the VPC endpoint service to use the given DNS name\n  // The VPC endpoint service will then say:\n  // \"ok, create a TXT record using these two values to prove you own the domain\"\n  // The second custom resource retrieves these two values from the service\n  // The TxtRecord is created from these two values\n  // The third custom resource tells the VPC Endpoint Service to verify the domain ownership\n  constructor(scope: Construct, id: string, props: VpcEndpointServiceDomainNameProps) {\n    super(scope, id);\n\n    const serviceUniqueId = Names.nodeUniqueId(props.endpointService.node);\n    const serviceId = props.endpointService.vpcEndpointServiceId;\n    this.domainName = props.domainName;\n\n    // Make sure a user doesn't accidentally add multiple domains\n    this.validateProps(props);\n\n    VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId] = this.domainName;\n    VpcEndpointServiceDomainName.endpointServices.push(props.endpointService);\n\n    // Enable Private DNS on the endpoint service and retrieve the AWS-generated configuration\n    const privateDnsConfiguration = this.getPrivateDnsConfiguration(serviceUniqueId, serviceId, this.domainName);\n\n    // Tell AWS to verify that this account owns the domain attached to the service\n    this.verifyPrivateDnsConfiguration(privateDnsConfiguration, props.publicHostedZone);\n\n    // Finally, don't do any of the above before the endpoint service is created\n    this.node.addDependency(props.endpointService);\n  }\n\n  private validateProps(props: VpcEndpointServiceDomainNameProps): void {\n    const serviceUniqueId = Names.nodeUniqueId(props.endpointService.node);\n    if (serviceUniqueId in VpcEndpointServiceDomainName.endpointServicesMap) {\n      const endpoint = VpcEndpointServiceDomainName.endpointServicesMap[serviceUniqueId];\n      throw new Error(\n        `Cannot create a VpcEndpointServiceDomainName for service ${serviceUniqueId}, another VpcEndpointServiceDomainName (${endpoint}) is already associated with it`);\n    }\n  }\n\n  /**\n   * Sets up Custom Resources to make AWS calls to set up Private DNS on an endpoint service,\n   * returning the values to use in a TxtRecord, which AWS uses to verify domain ownership.\n   */\n  private getPrivateDnsConfiguration(serviceUniqueId: string, serviceId: string, privateDnsName: string): PrivateDnsConfiguration {\n\n    // The custom resource which tells AWS to enable Private DNS on the given service, using the given domain name\n    // AWS will generate a name/value pair for use in a TxtRecord, which is used to verify domain ownership.\n    const enablePrivateDnsAction = {\n      service: 'EC2',\n      action: 'modifyVpcEndpointServiceConfiguration',\n      parameters: {\n        ServiceId: serviceId,\n        PrivateDnsName: privateDnsName,\n      },\n      physicalResourceId: PhysicalResourceId.of(serviceUniqueId),\n    };\n    const removePrivateDnsAction = {\n      service: 'EC2',\n      action: 'modifyVpcEndpointServiceConfiguration',\n      parameters: {\n        ServiceId: serviceId,\n        RemovePrivateDnsName: true,\n      },\n    };\n    const enable = new AwsCustomResource(this, 'EnableDns', {\n      onCreate: enablePrivateDnsAction,\n      onUpdate: enablePrivateDnsAction,\n      onDelete: removePrivateDnsAction,\n      policy: AwsCustomResourcePolicy.fromSdkCalls({\n        resources: [\n          Fn.join(':', [\n            'arn',\n            Stack.of(this).partition,\n            'ec2',\n            Stack.of(this).region,\n            Stack.of(this).account,\n            Fn.join('/', [\n              'vpc-endpoint-service',\n              serviceId,\n            ]),\n          ]),\n        ],\n      }),\n    });\n\n    // Look up the name/value pair if the domain changes, or the service changes,\n    // which would cause the values to be different. If the unique ID changes,\n    // the resource may be entirely recreated, so we will need to look it up again.\n    const lookup = hashcode(Names.uniqueId(this) + serviceUniqueId + privateDnsName);\n\n    // Create the custom resource to look up the name/value pair generated by AWS\n    // after the previous API call\n    const retrieveNameValuePairAction = {\n      service: 'EC2',\n      action: 'describeVpcEndpointServiceConfigurations',\n      parameters: {\n        ServiceIds: [serviceId],\n      },\n      physicalResourceId: PhysicalResourceId.of(lookup),\n    };\n    const getNames = new AwsCustomResource(this, 'GetNames', {\n      onCreate: retrieveNameValuePairAction,\n      onUpdate: retrieveNameValuePairAction,\n      // describeVpcEndpointServiceConfigurations can't take an ARN for granular permissions\n      policy: AwsCustomResourcePolicy.fromSdkCalls({\n        resources: AwsCustomResourcePolicy.ANY_RESOURCE,\n      }),\n    });\n\n    // We only want to call and get the name/value pair after we've told AWS to enable Private DNS\n    // If we call before then, we'll get an empty pair of values.\n    getNames.node.addDependency(enable);\n\n    // Get the references to the name/value pair associated with the endpoint service\n    const name = getNames.getResponseField('ServiceConfigurations.0.PrivateDnsNameConfiguration.Name');\n    const value = getNames.getResponseField('ServiceConfigurations.0.PrivateDnsNameConfiguration.Value');\n\n    return { name, value, serviceId };\n  }\n\n  /**\n   * Creates a Route53 entry and a Custom Resource which explicitly tells AWS to verify ownership\n   * of the domain name attached to an endpoint service.\n   */\n  private verifyPrivateDnsConfiguration(config: PrivateDnsConfiguration, publicHostedZone: IPublicHostedZone) {\n    // Create the TXT record in the provided hosted zone\n    const verificationRecord = new TxtRecord(this, 'DnsVerificationRecord', {\n      recordName: config.name,\n      values: [config.value],\n      zone: publicHostedZone,\n    });\n\n    // Tell the endpoint service to verify the domain ownership\n    const startVerificationAction = {\n      service: 'EC2',\n      action: 'startVpcEndpointServicePrivateDnsVerification',\n      parameters: {\n        ServiceId: config.serviceId,\n      },\n      physicalResourceId: PhysicalResourceId.of(Fn.join(':', [config.name, config.value])),\n    };\n    const startVerification = new AwsCustomResource(this, 'StartVerification', {\n      onCreate: startVerificationAction,\n      onUpdate: startVerificationAction,\n      policy: AwsCustomResourcePolicy.fromSdkCalls({\n        resources: [\n          Fn.join(':', [\n            'arn',\n            Stack.of(this).partition,\n            'ec2',\n            Stack.of(this).region,\n            Stack.of(this).account,\n            Fn.join('/', [\n              'vpc-endpoint-service',\n              config.serviceId,\n            ]),\n          ]),\n        ],\n      }),\n    });\n    // Only verify after the record has been created\n    startVerification.node.addDependency(verificationRecord);\n  }\n}\n\n/**\n * Represent the name/value pair associated with a Private DNS enabled endpoint service\n */\ninterface PrivateDnsConfiguration {\n  readonly name: string;\n  readonly value: string;\n  readonly serviceId: string;\n}\n\n/**\n * Hash a string\n */\nfunction hashcode(s: string): string {\n  const hash = crypto.createHash('md5');\n  hash.update(s);\n  return hash.digest('hex');\n};"]}