terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/load-balancer.d.ts

@@ -0,0 +1,336 @@
+import { elb as tfElb } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { Connections, IConnectable } from "./connections";
+import { Instance } from "./instance";
+import { Port } from "./port";
+import { ISecurityGroup } from "./security-group";
+import { IVpc, SubnetSelection } from "./vpc";
+import { Duration } from "../../duration";
+import { AwsConstructBase } from "../aws-construct";
+/**
+ * Construction properties for a LoadBalancer
+ */
+export interface LoadBalancerProps {
+    /**
+     * VPC network of the fleet instances
+     */
+    readonly vpc: IVpc;
+    /**
+     * Whether this is an internet-facing Load Balancer
+     *
+     * This controls whether the LB has a public IP address assigned. It does
+     * not open up the Load Balancer's security groups to public internet access.
+     *
+     * @default false
+     */
+    readonly internetFacing?: boolean;
+    /**
+     * What listeners to set up for the load balancer.
+     *
+     * Can also be added by .addListener()
+     *
+     * @default -
+     */
+    readonly listeners?: LoadBalancerListener[];
+    /**
+     * What targets to load balance to.
+     *
+     * Can also be added by .addTarget()
+     *
+     * @default - None.
+     */
+    readonly targets?: ILoadBalancerTarget[];
+    /**
+     * Health check settings for the load balancing targets.
+     *
+     * Not required but recommended.
+     *
+     * @default - None.
+     */
+    readonly healthCheck?: ElbHealthCheck;
+    /**
+     * Whether cross zone load balancing is enabled
+     *
+     * This controls whether the load balancer evenly distributes requests
+     * across each availability zone
+     *
+     * @default true
+     */
+    readonly crossZone?: boolean;
+    /**
+     * Which subnets to deploy the load balancer
+     *
+     * Can be used to define a specific set of subnets to deploy the load balancer to.
+     * Useful multiple public or private subnets are covering the same availability zone.
+     *
+     * @default - Public subnets if internetFacing, Private subnets otherwise
+     */
+    readonly subnetSelection?: SubnetSelection;
+    /**
+     * Enable Loadbalancer access logs
+     * Can be used to avoid manual work as aws console
+     * Required S3 bucket name , enabled flag
+     * Can add interval for pushing log
+     * Can set bucket prefix in order to provide folder name inside bucket
+     * @default - disabled
+     */
+    readonly accessLoggingPolicy?: tfElb.ElbAccessLogs;
+}
+/**
+ * Describe the health check to a load balancer
+ */
+export interface ElbHealthCheck {
+    /**
+     * What port number to health check on
+     */
+    readonly port: number;
+    /**
+     * What protocol to use for health checking
+     *
+     * The protocol is automatically determined from the port if it's not supplied.
+     *
+     * @default Automatic
+     */
+    readonly protocol?: LoadBalancingProtocol;
+    /**
+     * What path to use for HTTP or HTTPS health check (must return 200)
+     *
+     * For SSL and TCP health checks, accepting connections is enough to be considered
+     * healthy.
+     *
+     * @default "/"
+     */
+    readonly path?: string;
+    /**
+     * After how many successful checks is an instance considered healthy
+     *
+     * @default 2
+     */
+    readonly healthyThreshold?: number;
+    /**
+     * After how many unsuccessful checks is an instance considered unhealthy
+     *
+     * @default 5
+     */
+    readonly unhealthyThreshold?: number;
+    /**
+     * Number of seconds between health checks
+     *
+     * @default Duration.seconds(30)
+     */
+    readonly interval?: Duration;
+    /**
+     * Health check timeout
+     *
+     * @default Duration.seconds(5)
+     */
+    readonly timeout?: Duration;
+}
+/**
+ * Interface that is going to be implemented by constructs that you can load balance to
+ */
+export interface ILoadBalancerTarget extends IConnectable {
+    /**
+     * Attach load-balanced target to a classic ELB
+     * @param loadBalancer [disable-awslint:ref-via-interface] The load balancer to attach the target to
+     */
+    attachToClassicLB(loadBalancer: LoadBalancer): void;
+}
+/**
+ * Add a backend to the load balancer
+ */
+export interface LoadBalancerListener {
+    /**
+     * External listening port
+     */
+    readonly externalPort: number;
+    /**
+     * What public protocol to use for load balancing
+     *
+     * Either 'tcp', 'ssl', 'http' or 'https'.
+     *
+     * May be omitted if the external port is either 80 or 443.
+     */
+    readonly externalProtocol?: LoadBalancingProtocol;
+    /**
+     * Instance listening port
+     *
+     * Same as the externalPort if not specified.
+     *
+     * @default externalPort
+     */
+    readonly internalPort?: number;
+    /**
+     * What public protocol to use for load balancing
+     *
+     * Either 'tcp', 'ssl', 'http' or 'https'.
+     *
+     * May be omitted if the internal port is either 80 or 443.
+     *
+     * The instance protocol is 'tcp' if the front-end protocol
+     * is 'tcp' or 'ssl', the instance protocol is 'http' if the
+     * front-end protocol is 'https'.
+     */
+    readonly internalProtocol?: LoadBalancingProtocol;
+    /**
+     * SSL policy names
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-policy-table.html
+     */
+    readonly policyNames?: string[];
+    /**
+     * the ARN of the SSL certificate
+     *
+     * @default - none
+     */
+    readonly sslCertificateArn?: string;
+    /**
+     * Allow connections to the load balancer from the given set of connection peers
+     *
+     * By default, connections will be allowed from anywhere. Set this to an empty list
+     * to deny connections, or supply a custom list of peers to allow connections from
+     * (IP ranges or security groups).
+     *
+     * @default Anywhere
+     */
+    readonly allowConnectionsFrom?: IConnectable[];
+}
+export declare enum LoadBalancingProtocol {
+    TCP = "tcp",
+    SSL = "ssl",
+    HTTP = "http",
+    HTTPS = "https"
+}
+export interface LoadBalancerOutputs {
+    /**
+     * The name of the ELB
+     * @attribute
+     */
+    readonly loadBalancerName: string;
+    /**
+     * The canonical hosted zone ID of the ELB (to be used in a Route 53 Alias record)
+     *
+     * @attribute
+     */
+    readonly loadBalancerCanonicalHostedZoneNameId: string;
+    /**
+     * The DNS name of the ELB
+     *
+     * @attribute
+     */
+    readonly loadBalancerDnsName: string;
+    /**
+     * The ID of the security group that you can use as part of your inbound rules
+     * for your load balancer's back-end application instances.
+     *
+     * Only available on ELBs launched in a VPC.
+     *
+     * @attribute
+     */
+    readonly loadBalancerSourceSecurityGroupId: string;
+}
+/**
+ * A load balancer with a single listener
+ *
+ * Routes to a fleet of of instances in a VPC.
+ */
+export declare class LoadBalancer extends AwsConstructBase implements IConnectable {
+    /**
+     * Control all connections from and to this load balancer
+     */
+    readonly connections: Connections;
+    get loadBalancerOutputs(): LoadBalancerOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * An object controlling specifically the connections for each listener added to this load balancer
+     */
+    readonly listenerPorts: ListenerPort[];
+    private readonly elb;
+    private readonly securityGroup;
+    private readonly listeners;
+    private readonly instancePorts;
+    private readonly targets;
+    private readonly instanceIds;
+    constructor(scope: Construct, id: string, props: LoadBalancerProps);
+    /**
+     * Add a backend to the load balancer
+     *
+     * @returns A ListenerPort object that controls connections to the listener port
+     */
+    addListener(listener: LoadBalancerListener): ListenerPort;
+    addTarget(target: ILoadBalancerTarget): void;
+    /**
+     * The name of the ELB
+     * @attribute
+     */
+    get loadBalancerName(): string;
+    /**
+     * The canonical hosted zone ID of the ELB (to be used in a Route 53 Alias record)
+     *
+     * @attribute
+     */
+    get loadBalancerCanonicalHostedZoneNameId(): string;
+    /**
+     * The DNS name of the ELB
+     *
+     * @attribute
+     */
+    get loadBalancerDnsName(): string;
+    /**
+     * The ID of the security group that you can use as part of your inbound rules
+     * for your load balancer's back-end application instances.
+     *
+     * Only available on ELBs launched in a VPC.
+     *
+     * @attribute
+     */
+    get loadBalancerSourceSecurityGroupId(): string;
+    /**
+     * Allow connections to all existing targets on new instance port
+     */
+    private newInstancePort;
+    /**
+     * Allow connections to target on all existing instance ports
+     */
+    private newTarget;
+    /**
+     * Allow connections for a single (port, target) pair
+     */
+    private allowTargetConnection;
+    /**
+     * Add instance to the load balancer.
+     * @internal
+     */
+    _addInstanceId(instanceId: string): void;
+}
+/**
+ * An EC2 instance that is the target for load balancing
+ */
+export declare class ElbInstanceTarget implements ILoadBalancerTarget {
+    readonly instance: Instance;
+    readonly connections: Connections;
+    /**
+     * Create a new Instance target.
+     *
+     * @param instance Instance to register to.
+     */
+    constructor(instance: Instance);
+    attachToClassicLB(loadBalancer: LoadBalancer): void;
+}
+/**
+ * Reference to a listener's port just created.
+ *
+ * This implements IConnectable with a default port (the port that an ELB
+ * listener was just created on) for a given security group so that it can be
+ * conveniently used just like any Connectable. E.g:
+ *
+ *    const listener = elb.addListener(...);
+ *
+ *    listener.connections.allowDefaultPortFromAnyIPv4();
+ *    // or
+ *    instance.connections.allowToDefaultPort(listener);
+ */
+export declare class ListenerPort implements IConnectable {
+    readonly connections: Connections;
+    constructor(securityGroup: ISecurityGroup, defaultPort: Port);
+}

package/lib/aws/compute/load-balancer.js

@@ -0,0 +1,287 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerPort = exports.ElbInstanceTarget = exports.LoadBalancer = exports.LoadBalancingProtocol = 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-elasticloadbalancing/lib/load-balancer.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const connections_1 = require("./connections");
+const peer_1 = require("./peer");
+const port_1 = require("./port");
+const security_group_1 = require("./security-group");
+const vpc_1 = require("./vpc");
+const duration_1 = require("../../duration");
+const aws_construct_1 = require("../aws-construct");
+var LoadBalancingProtocol;
+(function (LoadBalancingProtocol) {
+    LoadBalancingProtocol["TCP"] = "tcp";
+    LoadBalancingProtocol["SSL"] = "ssl";
+    LoadBalancingProtocol["HTTP"] = "http";
+    LoadBalancingProtocol["HTTPS"] = "https";
+})(LoadBalancingProtocol || (exports.LoadBalancingProtocol = LoadBalancingProtocol = {}));
+/**
+ * A load balancer with a single listener
+ *
+ * Routes to a fleet of of instances in a VPC.
+ */
+class LoadBalancer extends aws_construct_1.AwsConstructBase {
+    get loadBalancerOutputs() {
+        return {
+            loadBalancerName: this.loadBalancerName,
+            loadBalancerCanonicalHostedZoneNameId: this.loadBalancerCanonicalHostedZoneNameId,
+            loadBalancerDnsName: this.loadBalancerDnsName,
+            loadBalancerSourceSecurityGroupId: this.loadBalancerSourceSecurityGroupId,
+        };
+    }
+    get outputs() {
+        return this.loadBalancerOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        /**
+         * An object controlling specifically the connections for each listener added to this load balancer
+         */
+        this.listenerPorts = [];
+        this.listeners = [];
+        this.instancePorts = [];
+        this.targets = [];
+        this.instanceIds = [];
+        this.securityGroup = new security_group_1.SecurityGroup(this, "SecurityGroup", {
+            vpc: props.vpc,
+            allowAllOutbound: false,
+        });
+        this.connections = new connections_1.Connections({
+            securityGroups: [this.securityGroup],
+        });
+        // Depending on whether the ELB has public or internal IPs, pick the right backend subnets
+        const selectedSubnets = loadBalancerSubnets(props);
+        this.elb = new provider_aws_1.elb.Elb(this, "Resource", {
+            securityGroups: [this.securityGroup.securityGroupId],
+            subnets: selectedSubnets.subnetIds,
+            listener: cdktf_1.Lazy.anyValue({ produce: () => this.listeners }),
+            instances: cdktf_1.Lazy.listValue({ produce: () => this.instanceIds }, { omitEmpty: true }),
+            internal: !props.internetFacing,
+            healthCheck: props.healthCheck && healthCheckToJSON(props.healthCheck),
+            crossZoneLoadBalancing: props.crossZone ?? true,
+        });
+        if (props.internetFacing) {
+            this.elb.node.addDependency(selectedSubnets.internetConnectivityEstablished);
+        }
+        if (props.accessLoggingPolicy !== undefined) {
+            this.elb.putAccessLogs(props.accessLoggingPolicy);
+        }
+        ifUndefined(props.listeners, []).forEach((b) => this.addListener(b));
+        ifUndefined(props.targets, []).forEach((t) => this.addTarget(t));
+    }
+    /**
+     * Add a backend to the load balancer
+     *
+     * @returns A ListenerPort object that controls connections to the listener port
+     */
+    addListener(listener) {
+        const protocol = ifUndefinedLazy(listener.externalProtocol, () => wellKnownProtocol(listener.externalPort));
+        const instancePort = listener.internalPort || listener.externalPort;
+        const instanceProtocol = ifUndefined(listener.internalProtocol, ifUndefined(tryWellKnownProtocol(instancePort), isHttpProtocol(protocol)
+            ? LoadBalancingProtocol.HTTP
+            : LoadBalancingProtocol.TCP));
+        this.listeners.push({
+            lbPort: listener.externalPort,
+            lbProtocol: protocol,
+            instancePort: instancePort,
+            instanceProtocol,
+            sslCertificateId: listener.sslCertificateArn,
+        });
+        // create a listener policy if there are any policy names
+        if (listener.policyNames && listener.policyNames.length > 0) {
+            new provider_aws_1.loadBalancerListenerPolicy.LoadBalancerListenerPolicy(this, `${listener.externalPort}Policy`, {
+                loadBalancerName: this.elb.name,
+                loadBalancerPort: listener.externalPort,
+                policyNames: listener.policyNames,
+            });
+        }
+        const port = new ListenerPort(this.securityGroup, port_1.Port.tcp(listener.externalPort));
+        // Allow connections on the public port for all supplied peers (default: everyone)
+        ifUndefined(listener.allowConnectionsFrom, [peer_1.Peer.anyIpv4()]).forEach((peer) => {
+            port.connections.allowDefaultPortFrom(peer, `Default rule allow on ${listener.externalPort}`);
+        });
+        this.newInstancePort(instancePort);
+        // Keep track using array so user can get to them even if they were all supplied in the constructor
+        this.listenerPorts.push(port);
+        return port;
+    }
+    addTarget(target) {
+        target.attachToClassicLB(this);
+        this.newTarget(target);
+    }
+    /**
+     * The name of the ELB
+     * @attribute
+     */
+    get loadBalancerName() {
+        return this.elb.name;
+    }
+    /**
+     * The canonical hosted zone ID of the ELB (to be used in a Route 53 Alias record)
+     *
+     * @attribute
+     */
+    get loadBalancerCanonicalHostedZoneNameId() {
+        return this.elb.zoneId;
+    }
+    /**
+     * The DNS name of the ELB
+     *
+     * @attribute
+     */
+    get loadBalancerDnsName() {
+        return this.elb.dnsName;
+    }
+    /**
+     * The ID of the security group that you can use as part of your inbound rules
+     * for your load balancer's back-end application instances.
+     *
+     * Only available on ELBs launched in a VPC.
+     *
+     * @attribute
+     */
+    get loadBalancerSourceSecurityGroupId() {
+        return this.elb.sourceSecurityGroupId;
+    }
+    /**
+     * Allow connections to all existing targets on new instance port
+     */
+    newInstancePort(instancePort) {
+        this.targets.forEach((t) => this.allowTargetConnection(instancePort, t));
+        // Keep track of port for future targets
+        this.instancePorts.push(instancePort);
+    }
+    /**
+     * Allow connections to target on all existing instance ports
+     */
+    newTarget(target) {
+        this.instancePorts.forEach((p) => this.allowTargetConnection(p, target));
+        // Keep track of target for future listeners.
+        this.targets.push(target);
+    }
+    /**
+     * Allow connections for a single (port, target) pair
+     */
+    allowTargetConnection(instancePort, target) {
+        this.connections.allowTo(target, port_1.Port.tcp(instancePort), `Port ${instancePort} LB to fleet`);
+    }
+    /**
+     * Add instance to the load balancer.
+     * @internal
+     */
+    _addInstanceId(instanceId) {
+        this.instanceIds.push(instanceId);
+    }
+}
+exports.LoadBalancer = LoadBalancer;
+_a = JSII_RTTI_SYMBOL_1;
+LoadBalancer[_a] = { fqn: "terraconstructs.aws.compute.LoadBalancer", version: "0.0.12" };
+/**
+ * An EC2 instance that is the target for load balancing
+ */
+class ElbInstanceTarget {
+    /**
+     * Create a new Instance target.
+     *
+     * @param instance Instance to register to.
+     */
+    constructor(instance) {
+        this.instance = instance;
+        this.connections = instance.connections;
+    }
+    attachToClassicLB(loadBalancer) {
+        loadBalancer._addInstanceId(this.instance.instanceId);
+    }
+}
+exports.ElbInstanceTarget = ElbInstanceTarget;
+_b = JSII_RTTI_SYMBOL_1;
+ElbInstanceTarget[_b] = { fqn: "terraconstructs.aws.compute.ElbInstanceTarget", version: "0.0.12" };
+/**
+ * Reference to a listener's port just created.
+ *
+ * This implements IConnectable with a default port (the port that an ELB
+ * listener was just created on) for a given security group so that it can be
+ * conveniently used just like any Connectable. E.g:
+ *
+ *    const listener = elb.addListener(...);
+ *
+ *    listener.connections.allowDefaultPortFromAnyIPv4();
+ *    // or
+ *    instance.connections.allowToDefaultPort(listener);
+ */
+class ListenerPort {
+    constructor(securityGroup, defaultPort) {
+        this.connections = new connections_1.Connections({
+            securityGroups: [securityGroup],
+            defaultPort,
+        });
+    }
+}
+exports.ListenerPort = ListenerPort;
+_c = JSII_RTTI_SYMBOL_1;
+ListenerPort[_c] = { fqn: "terraconstructs.aws.compute.ListenerPort", version: "0.0.12" };
+function wellKnownProtocol(port) {
+    const proto = tryWellKnownProtocol(port);
+    if (!proto) {
+        throw new Error(`Please supply protocol to go with port ${port}`);
+    }
+    return proto;
+}
+function tryWellKnownProtocol(port) {
+    if (port === 80) {
+        return LoadBalancingProtocol.HTTP;
+    }
+    if (port === 443) {
+        return LoadBalancingProtocol.HTTPS;
+    }
+    return undefined;
+}
+function isHttpProtocol(proto) {
+    return (proto === LoadBalancingProtocol.HTTPS ||
+        proto === LoadBalancingProtocol.HTTP);
+}
+function ifUndefined(x, def) {
+    return x != null ? x : def;
+}
+function ifUndefinedLazy(x, def) {
+    return x != null ? x : def();
+}
+/**
+ * Turn health check parameters into a parameter blob for the LB
+ */
+function healthCheckToJSON(healthCheck) {
+    const protocol = ifUndefined(healthCheck.protocol, ifUndefined(tryWellKnownProtocol(healthCheck.port), LoadBalancingProtocol.TCP));
+    const path = protocol === LoadBalancingProtocol.HTTP ||
+        protocol === LoadBalancingProtocol.HTTPS
+        ? ifUndefined(healthCheck.path, "/")
+        : "";
+    const target = `${protocol.toUpperCase()}:${healthCheck.port}${path}`;
+    return {
+        healthyThreshold: ifUndefined(healthCheck.healthyThreshold, 2),
+        interval: (healthCheck.interval || duration_1.Duration.seconds(30)).toSeconds(),
+        target,
+        timeout: (healthCheck.timeout || duration_1.Duration.seconds(5)).toSeconds(),
+        unhealthyThreshold: ifUndefined(healthCheck.unhealthyThreshold, 5),
+    };
+}
+function loadBalancerSubnets(props) {
+    if (props.subnetSelection !== undefined) {
+        return props.vpc.selectSubnets(props.subnetSelection);
+    }
+    else if (props.internetFacing) {
+        return props.vpc.selectSubnets({
+            subnetType: vpc_1.SubnetType.PUBLIC,
+        });
+    }
+    else {
+        return props.vpc.selectSubnets({
+            subnetType: vpc_1.SubnetType.PRIVATE_WITH_EGRESS,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-balancer.js","sourceRoot":"","sources":["../../../src/aws/compute/load-balancer.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancing/lib/load-balancer.ts\n\nimport { elb as tfElb, loadBalancerListenerPolicy } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Connections, IConnectable } from \"./connections\";\nimport { Instance } from \"./instance\";\nimport { Peer } from \"./peer\";\nimport { Port } from \"./port\";\nimport { SecurityGroup, ISecurityGroup } from \"./security-group\";\nimport { IVpc, SelectedSubnets, SubnetSelection, SubnetType } from \"./vpc\";\nimport { Duration } from \"../../duration\";\nimport { AwsConstructBase } from \"../aws-construct\";\n\n/**\n * Construction properties for a LoadBalancer\n */\nexport interface LoadBalancerProps {\n  /**\n   * VPC network of the fleet instances\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * Whether this is an internet-facing Load Balancer\n   *\n   * This controls whether the LB has a public IP address assigned. It does\n   * not open up the Load Balancer's security groups to public internet access.\n   *\n   * @default false\n   */\n  readonly internetFacing?: boolean;\n\n  /**\n   * What listeners to set up for the load balancer.\n   *\n   * Can also be added by .addListener()\n   *\n   * @default -\n   */\n  readonly listeners?: LoadBalancerListener[];\n\n  /**\n   * What targets to load balance to.\n   *\n   * Can also be added by .addTarget()\n   *\n   * @default - None.\n   */\n  readonly targets?: ILoadBalancerTarget[];\n\n  /**\n   * Health check settings for the load balancing targets.\n   *\n   * Not required but recommended.\n   *\n   * @default - None.\n   */\n  readonly healthCheck?: ElbHealthCheck;\n\n  /**\n   * Whether cross zone load balancing is enabled\n   *\n   * This controls whether the load balancer evenly distributes requests\n   * across each availability zone\n   *\n   * @default true\n   */\n  readonly crossZone?: boolean;\n\n  /**\n   * Which subnets to deploy the load balancer\n   *\n   * Can be used to define a specific set of subnets to deploy the load balancer to.\n   * Useful multiple public or private subnets are covering the same availability zone.\n   *\n   * @default - Public subnets if internetFacing, Private subnets otherwise\n   */\n  readonly subnetSelection?: SubnetSelection;\n\n  /**\n   * Enable Loadbalancer access logs\n   * Can be used to avoid manual work as aws console\n   * Required S3 bucket name , enabled flag\n   * Can add interval for pushing log\n   * Can set bucket prefix in order to provide folder name inside bucket\n   * @default - disabled\n   */\n  readonly accessLoggingPolicy?: tfElb.ElbAccessLogs;\n}\n\n/**\n * Describe the health check to a load balancer\n */\nexport interface ElbHealthCheck {\n  /**\n   * What port number to health check on\n   */\n  readonly port: number;\n\n  /**\n   * What protocol to use for health checking\n   *\n   * The protocol is automatically determined from the port if it's not supplied.\n   *\n   * @default Automatic\n   */\n  readonly protocol?: LoadBalancingProtocol;\n\n  /**\n   * What path to use for HTTP or HTTPS health check (must return 200)\n   *\n   * For SSL and TCP health checks, accepting connections is enough to be considered\n   * healthy.\n   *\n   * @default \"/\"\n   */\n  readonly path?: string;\n\n  /**\n   * After how many successful checks is an instance considered healthy\n   *\n   * @default 2\n   */\n  readonly healthyThreshold?: number;\n\n  /**\n   * After how many unsuccessful checks is an instance considered unhealthy\n   *\n   * @default 5\n   */\n  readonly unhealthyThreshold?: number;\n\n  /**\n   * Number of seconds between health checks\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly interval?: Duration;\n\n  /**\n   * Health check timeout\n   *\n   * @default Duration.seconds(5)\n   */\n  readonly timeout?: Duration;\n}\n\n/**\n * Interface that is going to be implemented by constructs that you can load balance to\n */\nexport interface ILoadBalancerTarget extends IConnectable {\n  /**\n   * Attach load-balanced target to a classic ELB\n   * @param loadBalancer [disable-awslint:ref-via-interface] The load balancer to attach the target to\n   */\n  attachToClassicLB(loadBalancer: LoadBalancer): void;\n}\n\n/**\n * Add a backend to the load balancer\n */\nexport interface LoadBalancerListener {\n  /**\n   * External listening port\n   */\n  readonly externalPort: number;\n\n  /**\n   * What public protocol to use for load balancing\n   *\n   * Either 'tcp', 'ssl', 'http' or 'https'.\n   *\n   * May be omitted if the external port is either 80 or 443.\n   */\n  readonly externalProtocol?: LoadBalancingProtocol;\n\n  /**\n   * Instance listening port\n   *\n   * Same as the externalPort if not specified.\n   *\n   * @default externalPort\n   */\n  readonly internalPort?: number;\n\n  /**\n   * What public protocol to use for load balancing\n   *\n   * Either 'tcp', 'ssl', 'http' or 'https'.\n   *\n   * May be omitted if the internal port is either 80 or 443.\n   *\n   * The instance protocol is 'tcp' if the front-end protocol\n   * is 'tcp' or 'ssl', the instance protocol is 'http' if the\n   * front-end protocol is 'https'.\n   */\n  readonly internalProtocol?: LoadBalancingProtocol;\n\n  /**\n   * SSL policy names\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/elb-security-policy-table.html\n   */\n  readonly policyNames?: string[];\n\n  /**\n   * the ARN of the SSL certificate\n   *\n   * @default - none\n   */\n  readonly sslCertificateArn?: string;\n\n  /**\n   * Allow connections to the load balancer from the given set of connection peers\n   *\n   * By default, connections will be allowed from anywhere. Set this to an empty list\n   * to deny connections, or supply a custom list of peers to allow connections from\n   * (IP ranges or security groups).\n   *\n   * @default Anywhere\n   */\n  readonly allowConnectionsFrom?: IConnectable[];\n}\n\nexport enum LoadBalancingProtocol {\n  TCP = \"tcp\",\n  SSL = \"ssl\",\n  HTTP = \"http\",\n  HTTPS = \"https\",\n}\n\nexport interface LoadBalancerOutputs {\n  /**\n   * The name of the ELB\n   * @attribute\n   */\n  readonly loadBalancerName: string;\n  /**\n   * The canonical hosted zone ID of the ELB (to be used in a Route 53 Alias record)\n   *\n   * @attribute\n   */\n  readonly loadBalancerCanonicalHostedZoneNameId: string;\n  /**\n   * The DNS name of the ELB\n   *\n   * @attribute\n   */\n  readonly loadBalancerDnsName: string;\n  /**\n   * The ID of the security group that you can use as part of your inbound rules\n   * for your load balancer's back-end application instances.\n   *\n   * Only available on ELBs launched in a VPC.\n   *\n   * @attribute\n   */\n  readonly loadBalancerSourceSecurityGroupId: string;\n}\n\n/**\n * A load balancer with a single listener\n *\n * Routes to a fleet of of instances in a VPC.\n */\nexport class LoadBalancer extends AwsConstructBase implements IConnectable {\n  /**\n   * Control all connections from and to this load balancer\n   */\n  public readonly connections: Connections;\n  public get loadBalancerOutputs(): LoadBalancerOutputs {\n    return {\n      loadBalancerName: this.loadBalancerName,\n      loadBalancerCanonicalHostedZoneNameId:\n        this.loadBalancerCanonicalHostedZoneNameId,\n      loadBalancerDnsName: this.loadBalancerDnsName,\n      loadBalancerSourceSecurityGroupId: this.loadBalancerSourceSecurityGroupId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.loadBalancerOutputs;\n  }\n\n  /**\n   * An object controlling specifically the connections for each listener added to this load balancer\n   */\n  public readonly listenerPorts: ListenerPort[] = [];\n\n  private readonly elb: tfElb.Elb;\n  private readonly securityGroup: SecurityGroup;\n  private readonly listeners: tfElb.ElbListener[] = [];\n\n  private readonly instancePorts: number[] = [];\n  private readonly targets: ILoadBalancerTarget[] = [];\n  private readonly instanceIds: string[] = [];\n\n  constructor(scope: Construct, id: string, props: LoadBalancerProps) {\n    super(scope, id);\n\n    this.securityGroup = new SecurityGroup(this, \"SecurityGroup\", {\n      vpc: props.vpc,\n      allowAllOutbound: false,\n    });\n    this.connections = new Connections({\n      securityGroups: [this.securityGroup],\n    });\n    // Depending on whether the ELB has public or internal IPs, pick the right backend subnets\n    const selectedSubnets: SelectedSubnets = loadBalancerSubnets(props);\n\n    this.elb = new tfElb.Elb(this, \"Resource\", {\n      securityGroups: [this.securityGroup.securityGroupId],\n      subnets: selectedSubnets.subnetIds,\n      listener: Lazy.anyValue({ produce: () => this.listeners }),\n      instances: Lazy.listValue(\n        { produce: () => this.instanceIds },\n        { omitEmpty: true },\n      ),\n      internal: !props.internetFacing,\n      healthCheck: props.healthCheck && healthCheckToJSON(props.healthCheck),\n      crossZoneLoadBalancing: props.crossZone ?? true,\n    });\n    if (props.internetFacing) {\n      this.elb.node.addDependency(\n        selectedSubnets.internetConnectivityEstablished,\n      );\n    }\n\n    if (props.accessLoggingPolicy !== undefined) {\n      this.elb.putAccessLogs(props.accessLoggingPolicy);\n    }\n\n    ifUndefined(props.listeners, []).forEach((b) => this.addListener(b));\n    ifUndefined(props.targets, []).forEach((t) => this.addTarget(t));\n  }\n\n  /**\n   * Add a backend to the load balancer\n   *\n   * @returns A ListenerPort object that controls connections to the listener port\n   */\n  public addListener(listener: LoadBalancerListener): ListenerPort {\n    const protocol = ifUndefinedLazy(listener.externalProtocol, () =>\n      wellKnownProtocol(listener.externalPort),\n    );\n    const instancePort = listener.internalPort || listener.externalPort;\n    const instanceProtocol = ifUndefined(\n      listener.internalProtocol,\n      ifUndefined(\n        tryWellKnownProtocol(instancePort),\n        isHttpProtocol(protocol)\n          ? LoadBalancingProtocol.HTTP\n          : LoadBalancingProtocol.TCP,\n      ),\n    );\n\n    this.listeners.push({\n      lbPort: listener.externalPort,\n      lbProtocol: protocol,\n      instancePort: instancePort,\n      instanceProtocol,\n      sslCertificateId: listener.sslCertificateArn,\n    });\n\n    // create a listener policy if there are any policy names\n    if (listener.policyNames && listener.policyNames.length > 0) {\n      new loadBalancerListenerPolicy.LoadBalancerListenerPolicy(\n        this,\n        `${listener.externalPort}Policy`,\n        {\n          loadBalancerName: this.elb.name,\n          loadBalancerPort: listener.externalPort,\n          policyNames: listener.policyNames,\n        },\n      );\n    }\n\n    const port = new ListenerPort(\n      this.securityGroup,\n      Port.tcp(listener.externalPort),\n    );\n\n    // Allow connections on the public port for all supplied peers (default: everyone)\n    ifUndefined(listener.allowConnectionsFrom, [Peer.anyIpv4()]).forEach(\n      (peer) => {\n        port.connections.allowDefaultPortFrom(\n          peer,\n          `Default rule allow on ${listener.externalPort}`,\n        );\n      },\n    );\n\n    this.newInstancePort(instancePort);\n\n    // Keep track using array so user can get to them even if they were all supplied in the constructor\n    this.listenerPorts.push(port);\n\n    return port;\n  }\n\n  public addTarget(target: ILoadBalancerTarget) {\n    target.attachToClassicLB(this);\n\n    this.newTarget(target);\n  }\n\n  /**\n   * The name of the ELB\n   * @attribute\n   */\n  public get loadBalancerName() {\n    return this.elb.name;\n  }\n\n  /**\n   * The canonical hosted zone ID of the ELB (to be used in a Route 53 Alias record)\n   *\n   * @attribute\n   */\n  public get loadBalancerCanonicalHostedZoneNameId() {\n    return this.elb.zoneId;\n  }\n\n  /**\n   * The DNS name of the ELB\n   *\n   * @attribute\n   */\n  public get loadBalancerDnsName() {\n    return this.elb.dnsName;\n  }\n\n  /**\n   * The ID of the security group that you can use as part of your inbound rules\n   * for your load balancer's back-end application instances.\n   *\n   * Only available on ELBs launched in a VPC.\n   *\n   * @attribute\n   */\n  public get loadBalancerSourceSecurityGroupId() {\n    return this.elb.sourceSecurityGroupId;\n  }\n\n  /**\n   * Allow connections to all existing targets on new instance port\n   */\n  private newInstancePort(instancePort: number) {\n    this.targets.forEach((t) => this.allowTargetConnection(instancePort, t));\n\n    // Keep track of port for future targets\n    this.instancePorts.push(instancePort);\n  }\n\n  /**\n   * Allow connections to target on all existing instance ports\n   */\n  private newTarget(target: ILoadBalancerTarget) {\n    this.instancePorts.forEach((p) => this.allowTargetConnection(p, target));\n\n    // Keep track of target for future listeners.\n    this.targets.push(target);\n  }\n\n  /**\n   * Allow connections for a single (port, target) pair\n   */\n  private allowTargetConnection(\n    instancePort: number,\n    target: ILoadBalancerTarget,\n  ) {\n    this.connections.allowTo(\n      target,\n      Port.tcp(instancePort),\n      `Port ${instancePort} LB to fleet`,\n    );\n  }\n\n  /**\n   * Add instance to the load balancer.\n   * @internal\n   */\n  public _addInstanceId(instanceId: string) {\n    this.instanceIds.push(instanceId);\n  }\n}\n\n/**\n * An EC2 instance that is the target for load balancing\n */\nexport class ElbInstanceTarget implements ILoadBalancerTarget {\n  readonly connections: Connections;\n  /**\n   * Create a new Instance target.\n   *\n   * @param instance Instance to register to.\n   */\n  constructor(public readonly instance: Instance) {\n    this.connections = instance.connections;\n  }\n\n  public attachToClassicLB(loadBalancer: LoadBalancer): void {\n    loadBalancer._addInstanceId(this.instance.instanceId);\n  }\n}\n\n/**\n * Reference to a listener's port just created.\n *\n * This implements IConnectable with a default port (the port that an ELB\n * listener was just created on) for a given security group so that it can be\n * conveniently used just like any Connectable. E.g:\n *\n *    const listener = elb.addListener(...);\n *\n *    listener.connections.allowDefaultPortFromAnyIPv4();\n *    // or\n *    instance.connections.allowToDefaultPort(listener);\n */\nexport class ListenerPort implements IConnectable {\n  public readonly connections: Connections;\n\n  constructor(securityGroup: ISecurityGroup, defaultPort: Port) {\n    this.connections = new Connections({\n      securityGroups: [securityGroup],\n      defaultPort,\n    });\n  }\n}\n\nfunction wellKnownProtocol(port: number): LoadBalancingProtocol {\n  const proto = tryWellKnownProtocol(port);\n  if (!proto) {\n    throw new Error(`Please supply protocol to go with port ${port}`);\n  }\n  return proto;\n}\n\nfunction tryWellKnownProtocol(port: number): LoadBalancingProtocol | undefined {\n  if (port === 80) {\n    return LoadBalancingProtocol.HTTP;\n  }\n  if (port === 443) {\n    return LoadBalancingProtocol.HTTPS;\n  }\n  return undefined;\n}\n\nfunction isHttpProtocol(proto: LoadBalancingProtocol): boolean {\n  return (\n    proto === LoadBalancingProtocol.HTTPS ||\n    proto === LoadBalancingProtocol.HTTP\n  );\n}\n\nfunction ifUndefined<T>(x: T | undefined, def: T): T {\n  return x != null ? x : def;\n}\n\nfunction ifUndefinedLazy<T>(x: T | undefined, def: () => T): T {\n  return x != null ? x : def();\n}\n\n/**\n * Turn health check parameters into a parameter blob for the LB\n */\nfunction healthCheckToJSON(healthCheck: ElbHealthCheck): tfElb.ElbHealthCheck {\n  const protocol = ifUndefined(\n    healthCheck.protocol,\n    ifUndefined(\n      tryWellKnownProtocol(healthCheck.port),\n      LoadBalancingProtocol.TCP,\n    ),\n  );\n\n  const path =\n    protocol === LoadBalancingProtocol.HTTP ||\n    protocol === LoadBalancingProtocol.HTTPS\n      ? ifUndefined(healthCheck.path, \"/\")\n      : \"\";\n\n  const target = `${protocol.toUpperCase()}:${healthCheck.port}${path}`;\n\n  return {\n    healthyThreshold: ifUndefined(healthCheck.healthyThreshold, 2),\n    interval: (healthCheck.interval || Duration.seconds(30)).toSeconds(),\n    target,\n    timeout: (healthCheck.timeout || Duration.seconds(5)).toSeconds(),\n    unhealthyThreshold: ifUndefined(healthCheck.unhealthyThreshold, 5),\n  };\n}\n\nfunction loadBalancerSubnets(props: LoadBalancerProps): SelectedSubnets {\n  if (props.subnetSelection !== undefined) {\n    return props.vpc.selectSubnets(props.subnetSelection);\n  } else if (props.internetFacing) {\n    return props.vpc.selectSubnets({\n      subnetType: SubnetType.PUBLIC,\n    });\n  } else {\n    return props.vpc.selectSubnets({\n      subnetType: SubnetType.PRIVATE_WITH_EGRESS,\n    });\n  }\n}\n"]}