terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/vpc-endpoint-service.d.ts

@@ -0,0 +1,149 @@
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase } from "../aws-construct";
+import { IDnsZone } from "../edge";
+import { ArnPrincipal } from "../iam";
+/**
+ * A load balancer that can host a VPC Endpoint Service
+ *
+ */
+export interface IVpcEndpointServiceLoadBalancer {
+    /**
+     * The ARN of the load balancer that hosts the VPC Endpoint Service
+     *
+     * @attribute
+     */
+    readonly loadBalancerArn: string;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface VpcEndpointServiceOutputs {
+    /**
+     * The service name of the VPC Endpoint Service that clients use to connect to,
+     * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx
+     *
+     * @attribute
+     */
+    readonly vpcEndpointServiceName: string;
+    /**
+     * The id of the VPC Endpoint Service that clients use to connect to,
+     * like vpce-svc-xxxxxxxxxxxxxxxx
+     *
+     * @attribute
+     */
+    readonly vpcEndpointServiceId: string;
+}
+/**
+ * A VPC endpoint service.
+ *
+ */
+export interface IVpcEndpointService extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly vpcEndpointServiceOutputs: VpcEndpointServiceOutputs;
+    /**
+     * The service name of the VPC Endpoint Service that clients use to connect to,
+     * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx
+     *
+     * @attribute
+     */
+    readonly vpcEndpointServiceName: string;
+    /**
+     * The id of the VPC Endpoint Service that clients use to connect to,
+     * like vpce-svc-xxxxxxxxxxxxxxxx
+     *
+     * @attribute
+     */
+    readonly vpcEndpointServiceId: string;
+}
+/**
+ * A VPC endpoint service
+ * @resource aws_vpc_endpoint_service
+ *
+ */
+export declare class VpcEndpointService extends AwsConstructBase implements IVpcEndpointService {
+    /**
+     * The default value for a VPC Endpoint Service name prefix, useful if you do
+     * not have a synthesize-time region literal available.
+     */
+    static readonly DEFAULT_PREFIX = "com.amazonaws.vpce";
+    /**
+     * One or more network load balancers to host the service.
+     * @attribute
+     */
+    readonly vpcEndpointServiceLoadBalancers: IVpcEndpointServiceLoadBalancer[];
+    /**
+     * Whether to require manual acceptance of new connections to the service.
+     *
+     */
+    readonly acceptanceRequired: boolean;
+    /**
+     * One or more Principal ARNs to allow inbound connections to.
+     * @deprecated use `allowedPrincipals`
+     */
+    readonly whitelistedPrincipals: ArnPrincipal[];
+    /**
+     * One or more Principal ARNs to allow inbound connections to.
+     *
+     */
+    readonly allowedPrincipals: ArnPrincipal[];
+    /**
+     * The id of the VPC Endpoint Service, like vpce-svc-xxxxxxxxxxxxxxxx.
+     * @attribute
+     */
+    readonly vpcEndpointServiceId: string;
+    /**
+     * The service name of the VPC Endpoint Service that clients use to connect to,
+     * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx
+     *
+     * @attribute
+     */
+    readonly vpcEndpointServiceName: string;
+    get vpcEndpointServiceOutputs(): VpcEndpointServiceOutputs;
+    get outputs(): Record<string, any>;
+    private readonly endpointService;
+    constructor(scope: Construct, id: string, props: VpcEndpointServiceProps);
+}
+/**
+ * Construction properties for a VpcEndpointService.
+ *
+ */
+export interface VpcEndpointServiceProps {
+    /**
+     * The private DNS name for the service.
+     */
+    readonly privateDnsName?: string;
+    /**
+     * Zone to validate the domain ownership.
+     *
+     * required if `privateDnsName` is set
+     */
+    readonly dnsZone?: IDnsZone;
+    /**
+     * One or more load balancers to host the VPC Endpoint Service.
+     *
+     */
+    readonly vpcEndpointServiceLoadBalancers: IVpcEndpointServiceLoadBalancer[];
+    /**
+     * Whether requests from service consumers to connect to the service through
+     * an endpoint must be accepted.
+     * @default true
+     *
+     */
+    readonly acceptanceRequired?: boolean;
+    /**
+     * IAM users, IAM roles, or AWS accounts to allow inbound connections from.
+     * These principals can connect to your service using VPC endpoints. Takes a
+     * list of one or more ArnPrincipal.
+     * @default - no principals
+     * @deprecated use `allowedPrincipals`
+     */
+    readonly whitelistedPrincipals?: ArnPrincipal[];
+    /**
+     * IAM users, IAM roles, or AWS accounts to allow inbound connections from.
+     * These principals can connect to your service using VPC endpoints. Takes a
+     * list of one or more ArnPrincipal.
+     * @default - no principals
+     *
+     */
+    readonly allowedPrincipals?: ArnPrincipal[];
+}

package/lib/aws/compute/vpc-endpoint-service.js

@@ -0,0 +1,90 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcEndpointService = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc-endpoint-service.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const edge_1 = require("../edge");
+/**
+ * A VPC endpoint service
+ * @resource aws_vpc_endpoint_service
+ *
+ */
+class VpcEndpointService extends aws_construct_1.AwsConstructBase {
+    get vpcEndpointServiceOutputs() {
+        return {
+            vpcEndpointServiceName: this.vpcEndpointServiceName,
+            vpcEndpointServiceId: this.vpcEndpointServiceId,
+        };
+    }
+    get outputs() {
+        return this.vpcEndpointServiceOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (props.vpcEndpointServiceLoadBalancers === undefined ||
+            props.vpcEndpointServiceLoadBalancers.length === 0) {
+            throw new Error("VPC Endpoint Service must have at least one load balancer specified.");
+        }
+        if (props.privateDnsName && !props.dnsZone) {
+            throw new Error("A DNS zone must be provided for validation when a private DNS name is specified.");
+        }
+        this.vpcEndpointServiceLoadBalancers =
+            props.vpcEndpointServiceLoadBalancers;
+        this.acceptanceRequired = props.acceptanceRequired ?? true;
+        // this.contributorInsightsEnabled = props.contributorInsights;
+        if (props.allowedPrincipals && props.whitelistedPrincipals) {
+            throw new Error("`whitelistedPrincipals` is deprecated; please use `allowedPrincipals` instead");
+        }
+        this.allowedPrincipals =
+            props.allowedPrincipals ?? props.whitelistedPrincipals ?? [];
+        this.whitelistedPrincipals = this.allowedPrincipals;
+        this.endpointService = new provider_aws_1.vpcEndpointService.VpcEndpointService(this, id, {
+            networkLoadBalancerArns: this.vpcEndpointServiceLoadBalancers.map((lb) => lb.loadBalancerArn),
+            acceptanceRequired: this.acceptanceRequired,
+            privateDnsName: props.privateDnsName,
+            // Not supported in Terraform
+            // contributorInsightsEnabled: this.contributorInsightsEnabled,
+        });
+        this.vpcEndpointServiceId = this.endpointService.id;
+        this.vpcEndpointServiceName = this.endpointService.serviceName;
+        // TODO: This fails when enabling privateDnsName on existing resources?
+        // relevant GH Issue:
+        // https://github.com/hashicorp/terraform-provider-aws/issues/24044
+        if (props.privateDnsName && props.dnsZone) {
+            // this value is only available if privateDnsName is set
+            const privateDnsNameConfiguration = this.endpointService.privateDnsNameConfiguration.get(0);
+            // create Route53 TXT records to validate the domain ownership
+            const verificationRecord = new edge_1.TxtRecord(this, "PrivateDnsVerificationRecord", {
+                zone: props.dnsZone,
+                recordName: privateDnsNameConfiguration.name,
+                values: [privateDnsNameConfiguration.value],
+            });
+            const endpointVerification = new provider_aws_1.vpcEndpointServicePrivateDnsVerification.VpcEndpointServicePrivateDnsVerification(this, "PrivateDnsVerification", {
+                serviceId: this.endpointService.id,
+                // verificationRecord is not a TerraformResource, must use addDependency
+                // dependsOn: [verificationRecord],
+            });
+            endpointVerification.node.addDependency(verificationRecord);
+        }
+        if (this.allowedPrincipals.length > 0) {
+            this.allowedPrincipals.map((principal, index) => {
+                new provider_aws_1.vpcEndpointServiceAllowedPrincipal.VpcEndpointServiceAllowedPrincipal(this, `Permissions${index}`, {
+                    vpcEndpointServiceId: this.endpointService.id,
+                    principalArn: principal.arn,
+                });
+            });
+        }
+    }
+}
+exports.VpcEndpointService = VpcEndpointService;
+_a = JSII_RTTI_SYMBOL_1;
+VpcEndpointService[_a] = { fqn: "terraconstructs.aws.compute.VpcEndpointService", version: "0.0.12" };
+/**
+ * The default value for a VPC Endpoint Service name prefix, useful if you do
+ * not have a synthesize-time region literal available.
+ */
+VpcEndpointService.DEFAULT_PREFIX = "com.amazonaws.vpce";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-endpoint-service.js","sourceRoot":"","sources":["../../../src/aws/compute/vpc-endpoint-service.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/vpc-endpoint-service.ts\n\nimport {\n  vpcEndpointService,\n  vpcEndpointServiceAllowedPrincipal,\n  vpcEndpointServicePrivateDnsVerification,\n} from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { IAwsConstruct, AwsConstructBase } from \"../aws-construct\";\nimport { IDnsZone, TxtRecord } from \"../edge\";\nimport { ArnPrincipal } from \"../iam\";\n\n/**\n * A load balancer that can host a VPC Endpoint Service\n *\n */\nexport interface IVpcEndpointServiceLoadBalancer {\n  /**\n   * The ARN of the load balancer that hosts the VPC Endpoint Service\n   *\n   * @attribute\n   */\n  readonly loadBalancerArn: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface VpcEndpointServiceOutputs {\n  /**\n   * The service name of the VPC Endpoint Service that clients use to connect to,\n   * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx\n   *\n   * @attribute\n   */\n  readonly vpcEndpointServiceName: string;\n\n  /**\n   * The id of the VPC Endpoint Service that clients use to connect to,\n   * like vpce-svc-xxxxxxxxxxxxxxxx\n   *\n   * @attribute\n   */\n  readonly vpcEndpointServiceId: string;\n}\n/**\n * A VPC endpoint service.\n *\n */\nexport interface IVpcEndpointService extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly vpcEndpointServiceOutputs: VpcEndpointServiceOutputs;\n  /**\n   * The service name of the VPC Endpoint Service that clients use to connect to,\n   * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx\n   *\n   * @attribute\n   */\n  readonly vpcEndpointServiceName: string;\n\n  /**\n   * The id of the VPC Endpoint Service that clients use to connect to,\n   * like vpce-svc-xxxxxxxxxxxxxxxx\n   *\n   * @attribute\n   */\n  readonly vpcEndpointServiceId: string;\n}\n\n/**\n * A VPC endpoint service\n * @resource aws_vpc_endpoint_service\n *\n */\nexport class VpcEndpointService\n  extends AwsConstructBase\n  implements IVpcEndpointService\n{\n  /**\n   * The default value for a VPC Endpoint Service name prefix, useful if you do\n   * not have a synthesize-time region literal available.\n   */\n  public static readonly DEFAULT_PREFIX = \"com.amazonaws.vpce\";\n\n  /**\n   * One or more network load balancers to host the service.\n   * @attribute\n   */\n  public readonly vpcEndpointServiceLoadBalancers: IVpcEndpointServiceLoadBalancer[];\n\n  /**\n   * Whether to require manual acceptance of new connections to the service.\n   *\n   */\n  public readonly acceptanceRequired: boolean;\n\n  // TODO: Not supported in Terraform\n  // /**\n  //  * Whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink.\n  //  *\n  //  */\n  // public readonly contributorInsightsEnabled?: boolean;\n\n  /**\n   * One or more Principal ARNs to allow inbound connections to.\n   * @deprecated use `allowedPrincipals`\n   */\n  public readonly whitelistedPrincipals: ArnPrincipal[];\n\n  /**\n   * One or more Principal ARNs to allow inbound connections to.\n   *\n   */\n  public readonly allowedPrincipals: ArnPrincipal[];\n\n  /**\n   * The id of the VPC Endpoint Service, like vpce-svc-xxxxxxxxxxxxxxxx.\n   * @attribute\n   */\n  public readonly vpcEndpointServiceId: string;\n\n  /**\n   * The service name of the VPC Endpoint Service that clients use to connect to,\n   * like com.amazonaws.vpce.<region>.vpce-svc-xxxxxxxxxxxxxxxx\n   *\n   * @attribute\n   */\n  public readonly vpcEndpointServiceName: string;\n  public get vpcEndpointServiceOutputs(): VpcEndpointServiceOutputs {\n    return {\n      vpcEndpointServiceName: this.vpcEndpointServiceName,\n      vpcEndpointServiceId: this.vpcEndpointServiceId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.vpcEndpointServiceOutputs;\n  }\n\n  private readonly endpointService: vpcEndpointService.VpcEndpointService;\n\n  constructor(scope: Construct, id: string, props: VpcEndpointServiceProps) {\n    super(scope, id);\n\n    if (\n      props.vpcEndpointServiceLoadBalancers === undefined ||\n      props.vpcEndpointServiceLoadBalancers.length === 0\n    ) {\n      throw new Error(\n        \"VPC Endpoint Service must have at least one load balancer specified.\",\n      );\n    }\n\n    if (props.privateDnsName && !props.dnsZone) {\n      throw new Error(\n        \"A DNS zone must be provided for validation when a private DNS name is specified.\",\n      );\n    }\n\n    this.vpcEndpointServiceLoadBalancers =\n      props.vpcEndpointServiceLoadBalancers;\n    this.acceptanceRequired = props.acceptanceRequired ?? true;\n    // this.contributorInsightsEnabled = props.contributorInsights;\n\n    if (props.allowedPrincipals && props.whitelistedPrincipals) {\n      throw new Error(\n        \"`whitelistedPrincipals` is deprecated; please use `allowedPrincipals` instead\",\n      );\n    }\n    this.allowedPrincipals =\n      props.allowedPrincipals ?? props.whitelistedPrincipals ?? [];\n    this.whitelistedPrincipals = this.allowedPrincipals;\n\n    this.endpointService = new vpcEndpointService.VpcEndpointService(this, id, {\n      networkLoadBalancerArns: this.vpcEndpointServiceLoadBalancers.map(\n        (lb) => lb.loadBalancerArn,\n      ),\n      acceptanceRequired: this.acceptanceRequired,\n      privateDnsName: props.privateDnsName,\n      // Not supported in Terraform\n      // contributorInsightsEnabled: this.contributorInsightsEnabled,\n    });\n\n    this.vpcEndpointServiceId = this.endpointService.id;\n    this.vpcEndpointServiceName = this.endpointService.serviceName;\n\n    // TODO: This fails when enabling privateDnsName on existing resources?\n    // relevant GH Issue:\n    // https://github.com/hashicorp/terraform-provider-aws/issues/24044\n    if (props.privateDnsName && props.dnsZone) {\n      // this value is only available if privateDnsName is set\n      const privateDnsNameConfiguration =\n        this.endpointService.privateDnsNameConfiguration.get(0);\n      // create Route53 TXT records to validate the domain ownership\n      const verificationRecord = new TxtRecord(\n        this,\n        \"PrivateDnsVerificationRecord\",\n        {\n          zone: props.dnsZone,\n          recordName: privateDnsNameConfiguration.name,\n          values: [privateDnsNameConfiguration.value],\n        },\n      );\n      const endpointVerification =\n        new vpcEndpointServicePrivateDnsVerification.VpcEndpointServicePrivateDnsVerification(\n          this,\n          \"PrivateDnsVerification\",\n          {\n            serviceId: this.endpointService.id,\n            // verificationRecord is not a TerraformResource, must use addDependency\n            // dependsOn: [verificationRecord],\n          },\n        );\n      endpointVerification.node.addDependency(verificationRecord);\n    }\n\n    if (this.allowedPrincipals.length > 0) {\n      this.allowedPrincipals.map((principal, index) => {\n        new vpcEndpointServiceAllowedPrincipal.VpcEndpointServiceAllowedPrincipal(\n          this,\n          `Permissions${index}`,\n          {\n            vpcEndpointServiceId: this.endpointService.id,\n            principalArn: principal.arn,\n          },\n        );\n      });\n    }\n  }\n}\n\n/**\n * Construction properties for a VpcEndpointService.\n *\n */\nexport interface VpcEndpointServiceProps {\n  // /**\n  //  * Name of the Vpc Endpoint Service\n  //  * @deprecated This property is not used\n  //  * @default - CDK generated name\n  //  */\n  // readonly vpcEndpointServiceName?: string;\n\n  /**\n   * The private DNS name for the service.\n   */\n  readonly privateDnsName?: string;\n\n  /**\n   * Zone to validate the domain ownership.\n   *\n   * required if `privateDnsName` is set\n   */\n  readonly dnsZone?: IDnsZone;\n\n  /**\n   * One or more load balancers to host the VPC Endpoint Service.\n   *\n   */\n  readonly vpcEndpointServiceLoadBalancers: IVpcEndpointServiceLoadBalancer[];\n\n  /**\n   * Whether requests from service consumers to connect to the service through\n   * an endpoint must be accepted.\n   * @default true\n   *\n   */\n  readonly acceptanceRequired?: boolean;\n\n  // TODO: Not supported in Terraform\n  // /**\n  //  * Indicates whether to enable the built-in Contributor Insights rules provided by AWS PrivateLink.\n  //  * @default false\n  //  *\n  //  */\n  // readonly contributorInsights?: boolean;\n\n  /**\n   * IAM users, IAM roles, or AWS accounts to allow inbound connections from.\n   * These principals can connect to your service using VPC endpoints. Takes a\n   * list of one or more ArnPrincipal.\n   * @default - no principals\n   * @deprecated use `allowedPrincipals`\n   */\n  readonly whitelistedPrincipals?: ArnPrincipal[];\n\n  /**\n   * IAM users, IAM roles, or AWS accounts to allow inbound connections from.\n   * These principals can connect to your service using VPC endpoints. Takes a\n   * list of one or more ArnPrincipal.\n   * @default - no principals\n   *\n   */\n  readonly allowedPrincipals?: ArnPrincipal[];\n}\n"]}