terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/client-vpn-endpoint.js

@@ -0,0 +1,259 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientVpnEndpoint = exports.ClientVpnUserBasedAuthentication = exports.ClientVpnSessionTimeout = 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/client-vpn-endpoint.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const client_vpn_authorization_rule_1 = require("./client-vpn-authorization-rule");
+const client_vpn_route_1 = require("./client-vpn-route");
+const connections_1 = require("./connections");
+const network_util_1 = require("./network-util");
+const security_group_1 = require("./security-group");
+const aws_construct_1 = require("../aws-construct");
+const logs = require("../cloudwatch");
+/**
+ * Maximum VPN session duration time
+ */
+var ClientVpnSessionTimeout;
+(function (ClientVpnSessionTimeout) {
+    /** 8 hours */
+    ClientVpnSessionTimeout[ClientVpnSessionTimeout["EIGHT_HOURS"] = 8] = "EIGHT_HOURS";
+    /** 10 hours */
+    ClientVpnSessionTimeout[ClientVpnSessionTimeout["TEN_HOURS"] = 10] = "TEN_HOURS";
+    /** 12 hours */
+    ClientVpnSessionTimeout[ClientVpnSessionTimeout["TWELVE_HOURS"] = 12] = "TWELVE_HOURS";
+    /** 24 hours */
+    ClientVpnSessionTimeout[ClientVpnSessionTimeout["TWENTY_FOUR_HOURS"] = 24] = "TWENTY_FOUR_HOURS";
+})(ClientVpnSessionTimeout || (exports.ClientVpnSessionTimeout = ClientVpnSessionTimeout = {}));
+/**
+ * User-based authentication for a client VPN endpoint
+ */
+class ClientVpnUserBasedAuthentication {
+    /**
+     * Active Directory authentication
+     */
+    static activeDirectory(directoryId) {
+        return new ActiveDirectoryAuthentication(directoryId);
+    }
+    /** Federated authentication */
+    static federated(samlProvider, selfServiceSamlProvider) {
+        return new FederatedAuthentication(samlProvider, selfServiceSamlProvider);
+    }
+}
+exports.ClientVpnUserBasedAuthentication = ClientVpnUserBasedAuthentication;
+_a = JSII_RTTI_SYMBOL_1;
+ClientVpnUserBasedAuthentication[_a] = { fqn: "terraconstructs.aws.compute.ClientVpnUserBasedAuthentication", version: "0.0.12" };
+/**
+ * Active Directory authentication
+ */
+class ActiveDirectoryAuthentication extends ClientVpnUserBasedAuthentication {
+    constructor(directoryId) {
+        super();
+        this.directoryId = directoryId;
+    }
+    render() {
+        return {
+            type: "directory-service-authentication",
+            activeDirectoryId: this.directoryId,
+        };
+    }
+}
+/**
+ * Federated authentication
+ */
+class FederatedAuthentication extends ClientVpnUserBasedAuthentication {
+    constructor(samlProvider, selfServiceSamlProvider) {
+        super();
+        this.samlProvider = samlProvider;
+        this.selfServiceSamlProvider = selfServiceSamlProvider;
+    }
+    render() {
+        return {
+            type: "federated-authentication",
+            samlProviderArn: this.samlProvider.samlProviderArn,
+            selfServiceSamlProviderArn: this.selfServiceSamlProvider?.samlProviderArn,
+        };
+    }
+}
+/**
+ * A client VPN connnection
+ */
+class ClientVpnEndpoint extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing client VPN endpoint
+     */
+    static fromEndpointAttributes(scope, id, attrs) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.endpointId = attrs.endpointId;
+                this.connections = new connections_1.Connections({
+                    securityGroups: attrs.securityGroups,
+                });
+                this.targetNetworksAssociated = new constructs_1.DependencyGroup();
+            }
+            get clientVpnOutputs() {
+                return {
+                    clientVpnEndpointId: this.endpointId,
+                };
+            }
+            get outputs() {
+                return this.clientVpnOutputs;
+            }
+        }
+        return new Import(scope, id);
+    }
+    get clientVpnOutputs() {
+        return {
+            clientVpnEndpointId: this.endpointId,
+            selfServicePortalUrl: this.selfServicePortalUrl,
+        };
+    }
+    get outputs() {
+        return this.clientVpnOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this._targetNetworksAssociated = new constructs_1.DependencyGroup();
+        if (!cdktf_1.Token.isUnresolved(props.vpc.vpcCidrBlock)) {
+            const clientCidr = new network_util_1.CidrBlock(props.cidr);
+            const vpcCidr = new network_util_1.CidrBlock(props.vpc.vpcCidrBlock);
+            if (vpcCidr.containsCidr(clientCidr)) {
+                throw new Error("The client CIDR cannot overlap with the local CIDR of the VPC");
+            }
+        }
+        if (props.dnsServers && props.dnsServers.length > 2) {
+            throw new Error("A client VPN endpoint can have up to two DNS servers");
+        }
+        if (props.logging == false && (props.logGroup || props.logStream)) {
+            throw new Error("Cannot specify `logGroup` or `logStream` when logging is disabled");
+        }
+        if (props.clientConnectionHandler &&
+            !cdktf_1.Token.isUnresolved(props.clientConnectionHandler.functionName) &&
+            !props.clientConnectionHandler.functionName.startsWith("AWSClientVPN-")) {
+            throw new Error("The name of the Lambda function must begin with the `AWSClientVPN-` prefix");
+        }
+        if (props.clientLoginBanner &&
+            !cdktf_1.Token.isUnresolved(props.clientLoginBanner) &&
+            props.clientLoginBanner.length > 1400) {
+            throw new Error(`The maximum length for the client login banner is 1400, got ${props.clientLoginBanner.length}`);
+        }
+        const logging = props.logging ?? true;
+        const logGroup = logging
+            ? (props.logGroup ?? new logs.LogGroup(this, "LogGroup"))
+            : undefined;
+        const securityGroups = props.securityGroups ?? [
+            new security_group_1.SecurityGroup(this, "SecurityGroup", {
+                vpc: props.vpc,
+            }),
+        ];
+        this.connections = new connections_1.Connections({ securityGroups });
+        this.resource = new provider_aws_1.ec2ClientVpnEndpoint.Ec2ClientVpnEndpoint(this, "Resource", {
+            authenticationOptions: renderAuthenticationOptions(props.clientCertificateArn, props.userBasedAuthentication),
+            clientCidrBlock: props.cidr,
+            clientConnectOptions: props.clientConnectionHandler
+                ? {
+                    enabled: true,
+                    lambdaFunctionArn: props.clientConnectionHandler.functionArn,
+                }
+                : undefined,
+            connectionLogOptions: {
+                enabled: logging,
+                cloudwatchLogGroup: logGroup?.logGroupName,
+                cloudwatchLogStream: props.logStream?.logStreamName,
+            },
+            description: props.description,
+            dnsServers: props.dnsServers,
+            securityGroupIds: securityGroups.map((s) => s.securityGroupId),
+            selfServicePortal: booleanToEnabledDisabled(props.selfServicePortal),
+            serverCertificateArn: props.serverCertificateArn,
+            splitTunnel: props.splitTunnel,
+            transportProtocol: props.transportProtocol,
+            vpcId: props.vpc.vpcId,
+            vpnPort: props.port,
+            sessionTimeoutHours: props.sessionTimeout,
+            clientLoginBannerOptions: props.clientLoginBanner
+                ? {
+                    enabled: true,
+                    bannerText: props.clientLoginBanner,
+                }
+                : undefined,
+        });
+        this.endpointId = this.resource.id;
+        if (props.userBasedAuthentication && (props.selfServicePortal ?? true)) {
+            // Output self-service portal URL
+            this.selfServicePortalUrl = this.resource.selfServicePortalUrl;
+            // new TerraformOutput(this, "SelfServicePortalUrl", {
+            //   value: `https://self-service.clientvpn.amazonaws.com/endpoints/${this.endpointId}`,
+            // });
+        }
+        // Associate subnets
+        const subnetIds = props.vpc.selectSubnets(props.vpcSubnets).subnetIds;
+        if (cdktf_1.Token.isUnresolved(subnetIds)) {
+            throw new Error("Cannot associate subnets when VPC are imported from parameters or exports containing lists of subnet IDs.");
+        }
+        for (const [idx, subnetId] of Object.entries(subnetIds)) {
+            this._targetNetworksAssociated.add(new provider_aws_1.ec2ClientVpnNetworkAssociation.Ec2ClientVpnNetworkAssociation(this, `Association${idx}`, {
+                clientVpnEndpointId: this.endpointId,
+                subnetId,
+            }));
+        }
+        this.targetNetworksAssociated = this._targetNetworksAssociated;
+        if (props.authorizeAllUsersToVpcCidr ?? true) {
+            this.addAuthorizationRule("AuthorizeAll", {
+                cidr: props.vpc.vpcCidrBlock,
+            });
+        }
+    }
+    /**
+     * Adds an authorization rule to this endpoint
+     */
+    addAuthorizationRule(id, props) {
+        return new client_vpn_authorization_rule_1.ClientVpnAuthorizationRule(this, id, {
+            ...props,
+            clientVpnEndpoint: this,
+        });
+    }
+    /**
+     * Adds a route to this endpoint
+     */
+    addRoute(id, props) {
+        return new client_vpn_route_1.ClientVpnRoute(this, id, {
+            ...props,
+            clientVpnEndpoint: this,
+        });
+    }
+}
+exports.ClientVpnEndpoint = ClientVpnEndpoint;
+_b = JSII_RTTI_SYMBOL_1;
+ClientVpnEndpoint[_b] = { fqn: "terraconstructs.aws.compute.ClientVpnEndpoint", version: "0.0.12" };
+function renderAuthenticationOptions(clientCertificateArn, userBasedAuthentication) {
+    const authenticationOptions = [];
+    if (clientCertificateArn) {
+        authenticationOptions.push({
+            type: "certificate-authentication",
+            rootCertificateChainArn: clientCertificateArn,
+        });
+    }
+    if (userBasedAuthentication) {
+        authenticationOptions.push(userBasedAuthentication.render());
+    }
+    if (authenticationOptions.length === 0) {
+        throw new Error("A client VPN endpoint must use at least one authentication option");
+    }
+    return authenticationOptions;
+}
+function booleanToEnabledDisabled(val) {
+    switch (val) {
+        case undefined:
+            return undefined;
+        case true:
+            return "enabled";
+        case false:
+            return "disabled";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client-vpn-endpoint.js","sourceRoot":"","sources":["../../../src/aws/compute/client-vpn-endpoint.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/client-vpn-endpoint.ts\n\nimport {\n  ec2ClientVpnEndpoint,\n  ec2ClientVpnNetworkAssociation,\n} from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct, DependencyGroup, IDependable } from \"constructs\";\nimport {\n  ClientVpnAuthorizationRule,\n  ClientVpnAuthorizationRuleOptions,\n} from \"./client-vpn-authorization-rule\";\nimport {\n  IClientVpnConnectionHandler,\n  IClientVpnEndpoint,\n  ClientVpnOutputs,\n  TransportProtocol,\n  VpnPort,\n} from \"./client-vpn-endpoint-types\";\nimport { ClientVpnRoute, ClientVpnRouteOptions } from \"./client-vpn-route\";\nimport { Connections } from \"./connections\";\nimport { CidrBlock } from \"./network-util\";\nimport { ISecurityGroup, SecurityGroup } from \"./security-group\";\nimport { ISamlProvider } from \"../iam\";\nimport { IVpc, SubnetSelection } from \"./vpc\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport * as logs from \"../cloudwatch\";\n\n/**\n * Options for a client VPN endpoint\n */\nexport interface ClientVpnEndpointOptions {\n  /**\n   * The IPv4 address range, in CIDR notation, from which to assign client IP\n   * addresses. The address range cannot overlap with the local CIDR of the VPC\n   * in which the associated subnet is located, or the routes that you add manually.\n   *\n   * Changing the address range will replace the Client VPN endpoint.\n   *\n   * The CIDR block should be /22 or greater.\n   */\n  readonly cidr: string;\n\n  /**\n   * The ARN of the client certificate for mutual authentication.\n   *\n   * The certificate must be signed by a certificate authority (CA) and it must\n   * be provisioned in AWS Certificate Manager (ACM).\n   *\n   * @default - use user-based authentication\n   */\n  readonly clientCertificateArn?: string;\n\n  /**\n   * The type of user-based authentication to use.\n   *\n   * @see https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/client-authentication.html\n   *\n   * @default - use mutual authentication\n   */\n  readonly userBasedAuthentication?: ClientVpnUserBasedAuthentication;\n\n  /**\n   * Whether to enable connections logging\n   *\n   * @default true\n   */\n  readonly logging?: boolean;\n\n  /**\n   * A CloudWatch Logs log group for connection logging\n   *\n   * @default - a new group is created\n   */\n  readonly logGroup?: logs.ILogGroup;\n\n  /**\n   * A CloudWatch Logs log stream for connection logging\n   *\n   * @default - a new stream is created\n   */\n  readonly logStream?: logs.ILogStream;\n\n  /**\n   * The AWS Lambda function used for connection authorization\n   *\n   * The name of the Lambda function must begin with the `AWSClientVPN-` prefix\n   *\n   * @default - no connection handler\n   */\n  readonly clientConnectionHandler?: IClientVpnConnectionHandler;\n\n  /**\n   * A brief description of the Client VPN endpoint.\n   *\n   * @default - no description\n   */\n  readonly description?: string;\n\n  /**\n   * The security groups to apply to the target network.\n   *\n   * @default - a new security group is created\n   */\n  readonly securityGroups?: ISecurityGroup[];\n\n  /**\n   * Specify whether to enable the self-service portal for the Client VPN endpoint.\n   *\n   * @default true\n   */\n  readonly selfServicePortal?: boolean;\n\n  /**\n   * The ARN of the server certificate\n   */\n  readonly serverCertificateArn: string;\n\n  /**\n   * Indicates whether split-tunnel is enabled on the AWS Client VPN endpoint.\n   *\n   * @see https://docs.aws.amazon.com/vpn/latest/clientvpn-admin/split-tunnel-vpn.html\n   *\n   * @default false\n   */\n  readonly splitTunnel?: boolean;\n\n  /**\n   * The transport protocol to be used by the VPN session.\n   *\n   * @default TransportProtocol.UDP\n   */\n  readonly transportProtocol?: TransportProtocol;\n\n  /**\n   * The port number to assign to the Client VPN endpoint for TCP and UDP\n   * traffic.\n   *\n   * @default VpnPort.HTTPS\n   */\n  readonly port?: VpnPort;\n\n  /**\n   * Information about the DNS servers to be used for DNS resolution.\n   *\n   * A Client VPN endpoint can have up to two DNS servers.\n   *\n   * @default - use the DNS address configured on the device\n   */\n  readonly dnsServers?: string[];\n\n  /**\n   * Subnets to associate to the client VPN endpoint.\n   *\n   * @default - the VPC default strategy\n   */\n  readonly vpcSubnets?: SubnetSelection;\n\n  /**\n   * Whether to authorize all users to the VPC CIDR\n   *\n   * This automatically creates an authorization rule. Set this to `false` and\n   * use `addAuthorizationRule()` to create your own rules instead.\n   *\n   * @default true\n   */\n  readonly authorizeAllUsersToVpcCidr?: boolean;\n\n  /**\n   * The maximum VPN session duration time.\n   *\n   * @default ClientVpnSessionTimeout.TWENTY_FOUR_HOURS\n   */\n  readonly sessionTimeout?: ClientVpnSessionTimeout;\n\n  /**\n   * Customizable text that will be displayed in a banner on AWS provided clients\n   * when a VPN session is established.\n   *\n   * UTF-8 encoded characters only. Maximum of 1400 characters.\n   *\n   * @default - no banner is presented to the client\n   */\n  readonly clientLoginBanner?: string;\n  /**\n   * Whether to register Terraform outputs for this TerraConstruct\n   *\n   * @default false\n   */\n  readonly registerOutputs?: boolean;\n\n  /**\n   * Optional override for the outputs name\n   *\n   * @default id\n   */\n  readonly outputName?: string;\n}\n\n/**\n * Maximum VPN session duration time\n */\nexport enum ClientVpnSessionTimeout {\n  /** 8 hours */\n  EIGHT_HOURS = 8,\n  /** 10 hours */\n  TEN_HOURS = 10,\n  /** 12 hours */\n  TWELVE_HOURS = 12,\n  /** 24 hours */\n  TWENTY_FOUR_HOURS = 24,\n}\n\n/**\n * User-based authentication for a client VPN endpoint\n */\nexport abstract class ClientVpnUserBasedAuthentication {\n  /**\n   * Active Directory authentication\n   */\n  public static activeDirectory(\n    directoryId: string,\n  ): ClientVpnUserBasedAuthentication {\n    return new ActiveDirectoryAuthentication(directoryId);\n  }\n\n  /** Federated authentication */\n  public static federated(\n    samlProvider: ISamlProvider,\n    selfServiceSamlProvider?: ISamlProvider,\n  ): ClientVpnUserBasedAuthentication {\n    return new FederatedAuthentication(samlProvider, selfServiceSamlProvider);\n  }\n\n  /** Renders the user based authentication */\n  public abstract render(): any;\n}\n\n/**\n * Active Directory authentication\n */\nclass ActiveDirectoryAuthentication extends ClientVpnUserBasedAuthentication {\n  constructor(private readonly directoryId: string) {\n    super();\n  }\n\n  render(): any {\n    return {\n      type: \"directory-service-authentication\",\n      activeDirectoryId: this.directoryId,\n    };\n  }\n}\n\n/**\n * Federated authentication\n */\nclass FederatedAuthentication extends ClientVpnUserBasedAuthentication {\n  constructor(\n    private readonly samlProvider: ISamlProvider,\n    private readonly selfServiceSamlProvider?: ISamlProvider,\n  ) {\n    super();\n  }\n\n  render(): any {\n    return {\n      type: \"federated-authentication\",\n      samlProviderArn: this.samlProvider.samlProviderArn,\n      selfServiceSamlProviderArn: this.selfServiceSamlProvider?.samlProviderArn,\n    };\n  }\n}\n\n/**\n * Properties for a client VPN endpoint\n */\nexport interface ClientVpnEndpointProps\n  extends ClientVpnEndpointOptions,\n    AwsConstructProps {\n  /**\n   * The VPC to connect to.\n   */\n  readonly vpc: IVpc;\n}\n\n/**\n * Attributes when importing an existing client VPN endpoint\n */\nexport interface ClientVpnEndpointAttributes {\n  /**\n   * The endpoint ID\n   */\n  readonly endpointId: string;\n\n  /**\n   * The security groups associated with the endpoint\n   */\n  readonly securityGroups: ISecurityGroup[];\n}\n\n/**\n * A client VPN connnection\n */\nexport class ClientVpnEndpoint\n  extends AwsConstructBase\n  implements IClientVpnEndpoint\n{\n  /**\n   * Import an existing client VPN endpoint\n   */\n  public static fromEndpointAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ClientVpnEndpointAttributes,\n  ): IClientVpnEndpoint {\n    class Import extends AwsConstructBase implements IClientVpnEndpoint {\n      public readonly endpointId = attrs.endpointId;\n      public get clientVpnOutputs(): ClientVpnOutputs {\n        return {\n          clientVpnEndpointId: this.endpointId,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.clientVpnOutputs;\n      }\n      public readonly connections = new Connections({\n        securityGroups: attrs.securityGroups,\n      });\n      public readonly targetNetworksAssociated: IDependable =\n        new DependencyGroup();\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly endpointId: string;\n  public readonly selfServicePortalUrl?: string;\n\n  /**\n   * Allows specify security group connections for the endpoint.\n   */\n  public readonly connections: Connections;\n\n  public readonly targetNetworksAssociated: IDependable;\n\n  private readonly _targetNetworksAssociated = new DependencyGroup();\n\n  public get clientVpnOutputs(): ClientVpnOutputs {\n    return {\n      clientVpnEndpointId: this.endpointId,\n      selfServicePortalUrl: this.selfServicePortalUrl,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.clientVpnOutputs;\n  }\n  public resource: ec2ClientVpnEndpoint.Ec2ClientVpnEndpoint;\n\n  constructor(scope: Construct, id: string, props: ClientVpnEndpointProps) {\n    super(scope, id, props);\n\n    if (!Token.isUnresolved(props.vpc.vpcCidrBlock)) {\n      const clientCidr = new CidrBlock(props.cidr);\n      const vpcCidr = new CidrBlock(props.vpc.vpcCidrBlock);\n      if (vpcCidr.containsCidr(clientCidr)) {\n        throw new Error(\n          \"The client CIDR cannot overlap with the local CIDR of the VPC\",\n        );\n      }\n    }\n\n    if (props.dnsServers && props.dnsServers.length > 2) {\n      throw new Error(\"A client VPN endpoint can have up to two DNS servers\");\n    }\n\n    if (props.logging == false && (props.logGroup || props.logStream)) {\n      throw new Error(\n        \"Cannot specify `logGroup` or `logStream` when logging is disabled\",\n      );\n    }\n\n    if (\n      props.clientConnectionHandler &&\n      !Token.isUnresolved(props.clientConnectionHandler.functionName) &&\n      !props.clientConnectionHandler.functionName.startsWith(\"AWSClientVPN-\")\n    ) {\n      throw new Error(\n        \"The name of the Lambda function must begin with the `AWSClientVPN-` prefix\",\n      );\n    }\n\n    if (\n      props.clientLoginBanner &&\n      !Token.isUnresolved(props.clientLoginBanner) &&\n      props.clientLoginBanner.length > 1400\n    ) {\n      throw new Error(\n        `The maximum length for the client login banner is 1400, got ${props.clientLoginBanner.length}`,\n      );\n    }\n\n    const logging = props.logging ?? true;\n    const logGroup = logging\n      ? (props.logGroup ?? new logs.LogGroup(this, \"LogGroup\"))\n      : undefined;\n\n    const securityGroups = props.securityGroups ?? [\n      new SecurityGroup(this, \"SecurityGroup\", {\n        vpc: props.vpc,\n      }),\n    ];\n    this.connections = new Connections({ securityGroups });\n\n    this.resource = new ec2ClientVpnEndpoint.Ec2ClientVpnEndpoint(\n      this,\n      \"Resource\",\n      {\n        authenticationOptions: renderAuthenticationOptions(\n          props.clientCertificateArn,\n          props.userBasedAuthentication,\n        ),\n        clientCidrBlock: props.cidr,\n        clientConnectOptions: props.clientConnectionHandler\n          ? {\n              enabled: true,\n              lambdaFunctionArn: props.clientConnectionHandler.functionArn,\n            }\n          : undefined,\n        connectionLogOptions: {\n          enabled: logging,\n          cloudwatchLogGroup: logGroup?.logGroupName,\n          cloudwatchLogStream: props.logStream?.logStreamName,\n        },\n        description: props.description,\n        dnsServers: props.dnsServers,\n        securityGroupIds: securityGroups.map((s) => s.securityGroupId),\n        selfServicePortal: booleanToEnabledDisabled(props.selfServicePortal),\n        serverCertificateArn: props.serverCertificateArn,\n        splitTunnel: props.splitTunnel,\n        transportProtocol: props.transportProtocol,\n        vpcId: props.vpc.vpcId,\n        vpnPort: props.port,\n        sessionTimeoutHours: props.sessionTimeout,\n        clientLoginBannerOptions: props.clientLoginBanner\n          ? {\n              enabled: true,\n              bannerText: props.clientLoginBanner,\n            }\n          : undefined,\n      },\n    );\n\n    this.endpointId = this.resource.id;\n\n    if (props.userBasedAuthentication && (props.selfServicePortal ?? true)) {\n      // Output self-service portal URL\n      this.selfServicePortalUrl = this.resource.selfServicePortalUrl;\n      // new TerraformOutput(this, \"SelfServicePortalUrl\", {\n      //   value: `https://self-service.clientvpn.amazonaws.com/endpoints/${this.endpointId}`,\n      // });\n    }\n\n    // Associate subnets\n    const subnetIds = props.vpc.selectSubnets(props.vpcSubnets).subnetIds;\n\n    if (Token.isUnresolved(subnetIds)) {\n      throw new Error(\n        \"Cannot associate subnets when VPC are imported from parameters or exports containing lists of subnet IDs.\",\n      );\n    }\n\n    for (const [idx, subnetId] of Object.entries(subnetIds)) {\n      this._targetNetworksAssociated.add(\n        new ec2ClientVpnNetworkAssociation.Ec2ClientVpnNetworkAssociation(\n          this,\n          `Association${idx}`,\n          {\n            clientVpnEndpointId: this.endpointId,\n            subnetId,\n          },\n        ),\n      );\n    }\n    this.targetNetworksAssociated = this._targetNetworksAssociated;\n\n    if (props.authorizeAllUsersToVpcCidr ?? true) {\n      this.addAuthorizationRule(\"AuthorizeAll\", {\n        cidr: props.vpc.vpcCidrBlock,\n      });\n    }\n  }\n\n  /**\n   * Adds an authorization rule to this endpoint\n   */\n  public addAuthorizationRule(\n    id: string,\n    props: ClientVpnAuthorizationRuleOptions,\n  ): ClientVpnAuthorizationRule {\n    return new ClientVpnAuthorizationRule(this, id, {\n      ...props,\n      clientVpnEndpoint: this,\n    });\n  }\n\n  /**\n   * Adds a route to this endpoint\n   */\n  public addRoute(id: string, props: ClientVpnRouteOptions): ClientVpnRoute {\n    return new ClientVpnRoute(this, id, {\n      ...props,\n      clientVpnEndpoint: this,\n    });\n  }\n}\n\nfunction renderAuthenticationOptions(\n  clientCertificateArn?: string,\n  userBasedAuthentication?: ClientVpnUserBasedAuthentication,\n): ec2ClientVpnEndpoint.Ec2ClientVpnEndpointAuthenticationOptions[] {\n  const authenticationOptions: ec2ClientVpnEndpoint.Ec2ClientVpnEndpointAuthenticationOptions[] =\n    [];\n\n  if (clientCertificateArn) {\n    authenticationOptions.push({\n      type: \"certificate-authentication\",\n      rootCertificateChainArn: clientCertificateArn,\n    });\n  }\n\n  if (userBasedAuthentication) {\n    authenticationOptions.push(userBasedAuthentication.render());\n  }\n\n  if (authenticationOptions.length === 0) {\n    throw new Error(\n      \"A client VPN endpoint must use at least one authentication option\",\n    );\n  }\n  return authenticationOptions;\n}\n\nfunction booleanToEnabledDisabled(\n  val?: boolean,\n): \"enabled\" | \"disabled\" | undefined {\n  switch (val) {\n    case undefined:\n      return undefined;\n    case true:\n      return \"enabled\";\n    case false:\n      return \"disabled\";\n  }\n}\n"]}

package/lib/aws/compute/client-vpn-route.d.ts

@@ -0,0 +1,67 @@
+import { ec2ClientVpnRoute } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IClientVpnEndpoint } from "./client-vpn-endpoint-types";
+import { ISubnet } from "./vpc";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+/**
+ * Options for a ClientVpnRoute
+ */
+export interface ClientVpnRouteOptions {
+    /**
+     * The IPv4 address range, in CIDR notation, of the route destination.
+     *
+     * For example:
+     *   - To add a route for Internet access, enter 0.0.0.0/0
+     *   - To add a route for a peered VPC, enter the peered VPC's IPv4 CIDR range
+     *   - To add a route for an on-premises network, enter the AWS Site-to-Site VPN
+     *     connection's IPv4 CIDR range
+     *   - To add a route for the local network, enter the client CIDR range
+     */
+    readonly cidr: string;
+    /**
+     * A brief description of the authorization rule.
+     *
+     * @default - no description
+     */
+    readonly description?: string;
+    /**
+     * The target for the route
+     */
+    readonly target: ClientVpnRouteTarget;
+}
+/**
+ * Target for a client VPN route
+ */
+export declare abstract class ClientVpnRouteTarget {
+    /**
+     * Subnet
+     *
+     * The specified subnet must be an existing target network of the client VPN
+     * endpoint.
+     */
+    static subnet(subnet: ISubnet): ClientVpnRouteTarget;
+    /**
+     * Local network
+     */
+    static local(): ClientVpnRouteTarget;
+    /** The subnet ID */
+    abstract readonly subnetId: string;
+}
+/**
+ * Properties for a ClientVpnRoute
+ */
+export interface ClientVpnRouteProps extends ClientVpnRouteOptions, AwsConstructProps {
+    /**
+     * The client VPN endpoint to which to add the route.
+     * @default clientVpnEndpoint is required
+     */
+    readonly clientVpnEndpoint: IClientVpnEndpoint;
+}
+/**
+ * A client VPN route
+ */
+export declare class ClientVpnRoute extends AwsConstructBase {
+    resource: ec2ClientVpnRoute.Ec2ClientVpnRoute;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: ClientVpnRouteProps);
+}

package/lib/aws/compute/client-vpn-route.js

@@ -0,0 +1,57 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientVpnRoute = exports.ClientVpnRouteTarget = 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/client-vpn-route.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * Target for a client VPN route
+ */
+class ClientVpnRouteTarget {
+    /**
+     * Subnet
+     *
+     * The specified subnet must be an existing target network of the client VPN
+     * endpoint.
+     */
+    static subnet(subnet) {
+        return { subnetId: subnet.subnetId };
+    }
+    /**
+     * Local network
+     */
+    static local() {
+        return { subnetId: "local" };
+    }
+}
+exports.ClientVpnRouteTarget = ClientVpnRouteTarget;
+_a = JSII_RTTI_SYMBOL_1;
+ClientVpnRouteTarget[_a] = { fqn: "terraconstructs.aws.compute.ClientVpnRouteTarget", version: "0.0.12" };
+/**
+ * A client VPN route
+ */
+class ClientVpnRoute extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            // is this the ID of the Client VPN endpoint or the VPN route?
+            clientVpnRouteId: this.resource.id,
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.resource = new provider_aws_1.ec2ClientVpnRoute.Ec2ClientVpnRoute(this, "Resource", {
+            clientVpnEndpointId: props.clientVpnEndpoint.endpointId,
+            description: props.description,
+            destinationCidrBlock: props.cidr,
+            targetVpcSubnetId: props.target.subnetId,
+        });
+        // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-clientvpnroute.html
+        this.resource.node.addDependency(props.clientVpnEndpoint.targetNetworksAssociated);
+    }
+}
+exports.ClientVpnRoute = ClientVpnRoute;
+_b = JSII_RTTI_SYMBOL_1;
+ClientVpnRoute[_b] = { fqn: "terraconstructs.aws.compute.ClientVpnRoute", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/condition.js

@@ -300,7 +300,7 @@ class Condition {
 }
 exports.Condition = Condition;
 _a = JSII_RTTI_SYMBOL_1;
-Condition[_a] = { fqn: "terraconstructs.aws.compute.Condition", version: "0.0.11" };
+Condition[_a] = { fqn: "terraconstructs.aws.compute.Condition", version: "0.0.12" };
 /**
  * Comparison Operator types
  */

package/lib/aws/compute/connections.d.ts

@@ -0,0 +1,137 @@
+import { IPeer } from "./peer";
+import { Port } from "./port";
+import { ISecurityGroup } from "./security-group";
+/**
+ * The goal of this module is to make possible to write statements like this:
+ *
+ *  ```ts
+ *  database.connections.allowFrom(fleet);
+ *  fleet.connections.allowTo(database);
+ *  rdgw.connections.allowFromCidrIp('0.3.1.5/86');
+ *  rgdw.connections.allowTrafficTo(fleet, new AllPorts());
+ *  ```
+ *
+ * The insight here is that some connecting peers have information on what ports should
+ * be involved in the connection, and some don't.
+ */
+/**
+ * An object that has a Connections object
+ */
+export interface IConnectable {
+    /**
+     * The network connections associated with this resource.
+     */
+    readonly connections: Connections;
+}
+/**
+ * Properties to intialize a new Connections object
+ */
+export interface ConnectionsProps {
+    /**
+     * Class that represents the rule by which others can connect to this connectable
+     *
+     * This object is required, but will be derived from securityGroup if that is passed.
+     *
+     * @default Derived from securityGroup if set.
+     */
+    readonly peer?: IPeer;
+    /**
+     * What securityGroup(s) this object is managing connections for
+     *
+     * @default No security groups
+     */
+    readonly securityGroups?: ISecurityGroup[];
+    /**
+     * Default port range for initiating connections to and from this object
+     *
+     * @default - No default port
+     */
+    readonly defaultPort?: Port;
+}
+/**
+ * Manage the allowed network connections for constructs with Security Groups.
+ *
+ * Security Groups can be thought of as a firewall for network-connected
+ * devices. This class makes it easy to allow network connections to and
+ * from security groups, and between security groups individually. When
+ * establishing connectivity between security groups, it will automatically
+ * add rules in both security groups
+ *
+ * This object can manage one or more security groups.
+ */
+export declare class Connections implements IConnectable {
+    readonly connections: Connections;
+    /**
+     * The default port configured for this connection peer, if available
+     */
+    readonly defaultPort?: Port;
+    /**
+     * Underlying securityGroup for this Connections object, if present
+     *
+     * May be empty if this Connections object is not managing a SecurityGroup,
+     * but simply representing a Connectable peer.
+     */
+    private readonly _securityGroups;
+    /**
+     * The rule that defines how to represent this peer in a security group
+     */
+    private readonly _securityGroupRules;
+    /**
+     * When doing bidirectional grants between Connections, make sure we don't recursive infinitely
+     */
+    private skip;
+    /**
+     * When doing bidirectional grants between Security Groups in different stacks, put the rule on the other SG
+     */
+    private remoteRule;
+    constructor(props?: ConnectionsProps);
+    get securityGroups(): ISecurityGroup[];
+    /**
+     * Add a security group to the list of security groups managed by this object
+     */
+    addSecurityGroup(...securityGroups: ISecurityGroup[]): void;
+    /**
+     * Allow connections to the peer on the given port
+     */
+    allowTo(other: IConnectable, portRange: Port, description?: string): void;
+    /**
+     * Allow connections from the peer on the given port
+     */
+    allowFrom(other: IConnectable, portRange: Port, description?: string): void;
+    /**
+     * Allow hosts inside the security group to connect to each other on the given port
+     */
+    allowInternally(portRange: Port, description?: string): void;
+    /**
+     * Allow to all IPv4 ranges
+     */
+    allowToAnyIpv4(portRange: Port, description?: string): void;
+    /**
+     * Allow from any IPv4 ranges
+     */
+    allowFromAnyIpv4(portRange: Port, description?: string): void;
+    /**
+     * Allow connections from the peer on our default port
+     *
+     * Even if the peer has a default port, we will always use our default port.
+     */
+    allowDefaultPortFrom(other: IConnectable, description?: string): void;
+    /**
+     * Allow hosts inside the security group to connect to each other
+     */
+    allowDefaultPortInternally(description?: string): void;
+    /**
+     * Allow default connections from all IPv4 ranges
+     */
+    allowDefaultPortFromAnyIpv4(description?: string): void;
+    /**
+     * Allow connections to the security group on their default port
+     */
+    allowToDefaultPort(other: IConnectable, description?: string): void;
+    /**
+     * Allow connections from the peer on our default port
+     *
+     * Even if the peer has a default port, we will always use our default port.
+     */
+    allowDefaultPortTo(other: IConnectable, description?: string): void;
+}