terraconstructs 0.0.10 → 0.0.12

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

@@ -0,0 +1,780 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpCodeTarget = exports.HttpCodeElb = exports.ApplicationLoadBalancer = exports.XffHeaderProcessingMode = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const application_listener_1 = require("./application-listener");
+const application_listener_action_1 = require("./application-listener-action");
+const aws_construct_1 = require("../../aws-construct");
+const aws_stack_1 = require("../../aws-stack");
+const cloudwatch = require("../../cloudwatch");
+const policy_statement_1 = require("../../iam/policy-statement");
+const principals_1 = require("../../iam/principals");
+const connections_1 = require("../connections");
+// import {
+//   LoadBalancerType,
+//   LoadBalancerListenerProtocol,
+// } from "../lb-shared/grid-lookup-types";
+const elasticloadbalancingv2_canned_metrics_generated_1 = require("../elasticloadbalancingv2-canned-metrics.generated");
+const base_load_balancer_1 = require("../lb-shared/base-load-balancer");
+const enums_1 = require("../lb-shared/enums");
+const util_1 = require("../lb-shared/util");
+const security_group_1 = require("../security-group");
+/**
+ * Processing mode of the X-Forwarded-For header in the HTTP request
+ * before the Application Load Balancer sends the request to the target.
+ */
+var XffHeaderProcessingMode;
+(function (XffHeaderProcessingMode) {
+    /**
+     * Application Load Balancer adds the client IP address (of the last hop) to the X-Forwarded-For header
+     * in the HTTP request before it sends it to targets.
+     */
+    XffHeaderProcessingMode["APPEND"] = "append";
+    /**
+     * Application Load Balancer preserves the X-Forwarded-For header in the HTTP request,
+     * and sends it to targets without any change.
+     */
+    XffHeaderProcessingMode["PRESERVE"] = "preserve";
+    /**
+     * Application Load Balancer removes the X-Forwarded-For header
+     * in the HTTP request before it sends it to targets.
+     */
+    XffHeaderProcessingMode["REMOVE"] = "remove";
+})(XffHeaderProcessingMode || (exports.XffHeaderProcessingMode = XffHeaderProcessingMode = {}));
+/**
+ * Define an Application Load Balancer
+ *
+ * @resource AWS::ElasticLoadBalancingV2::LoadBalancer
+ */
+class ApplicationLoadBalancer extends base_load_balancer_1.BaseLoadBalancer {
+    // TODO: Add Grid lookup support
+    // /**
+    //  * Look up an application load balancer.
+    //  */
+    // public static fromLookup(
+    //   scope: Construct,
+    //   id: string,
+    //   options: ApplicationLoadBalancerLookupOptions,
+    // ): IApplicationLoadBalancer {
+    //   const props = BaseLoadBalancer._queryContextProvider(scope, {
+    //     userOptions: options,
+    //     loadBalancerType: LoadBalancerType.APPLICATION,
+    //   });
+    //   return new LookedUpApplicationLoadBalancer(scope, id, props);
+    // }
+    /**
+     * Import an existing Application Load Balancer
+     */
+    static fromApplicationLoadBalancerAttributes(scope, id, attrs) {
+        return new ImportedApplicationLoadBalancer(scope, id, attrs);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props, {
+            loadBalancerType: "application",
+            securityGroups: cdktf_1.Lazy.listValue({
+                produce: () => this.connections.securityGroups.map((sg) => sg.securityGroupId),
+            }),
+            ipAddressType: props.ipAddressType,
+        });
+        this.ipAddressType = props.ipAddressType ?? enums_1.IpAddressType.IPV4;
+        if (props.ipAddressType === enums_1.IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4 &&
+            !props.internetFacing) {
+            throw new Error("dual-stack without public IPv4 address can only be used with internet-facing scheme.");
+        }
+        const securityGroups = [
+            props.securityGroup ||
+                new security_group_1.SecurityGroup(this, "SecurityGroup", {
+                    vpc: props.vpc,
+                    description: `Automatically created Security Group for ELB ${aws_stack_1.AwsStack.uniqueId(this)}`,
+                    allowAllOutbound: false,
+                }),
+        ];
+        this.connections = new connections_1.Connections({ securityGroups });
+        this.listeners = [];
+        this.metrics = new ApplicationLoadBalancerMetrics(this, this.loadBalancerFullName);
+        if (props.http2Enabled !== undefined) {
+            this.setAttribute("routing.http2.enabled", props.http2Enabled ? "true" : "false");
+        }
+        if (props.idleTimeout !== undefined) {
+            this.setAttribute("idle_timeout.timeout_seconds", props.idleTimeout.toSeconds().toString());
+        }
+        if (props.dropInvalidHeaderFields) {
+            this.setAttribute("routing.http.drop_invalid_header_fields.enabled", "true");
+        }
+        if (props.desyncMitigationMode !== undefined) {
+            this.setAttribute("routing.http.desync_mitigation_mode", props.desyncMitigationMode);
+        }
+        if (props.preserveHostHeader) {
+            this.setAttribute("routing.http.preserve_host_header.enabled", "true");
+        }
+        if (props.xAmznTlsVersionAndCipherSuiteHeaders) {
+            this.setAttribute("routing.http.x_amzn_tls_version_and_cipher_suite.enabled", "true");
+        }
+        if (props.preserveXffClientPort) {
+            this.setAttribute("routing.http.xff_client_port.enabled", "true");
+        }
+        if (props.xffHeaderProcessingMode !== undefined) {
+            this.setAttribute("routing.http.xff_header_processing.mode", props.xffHeaderProcessingMode);
+        }
+        if (props.wafFailOpen) {
+            this.setAttribute("waf.fail_open.enabled", "true");
+        }
+        if (props.clientKeepAlive !== undefined) {
+            const clientKeepAliveInMillis = props.clientKeepAlive.toMilliseconds();
+            if (clientKeepAliveInMillis < 1000) {
+                throw new Error(`\'clientKeepAlive\' must be between 60 and 604800 seconds. Got: ${clientKeepAliveInMillis} milliseconds`);
+            }
+            const clientKeepAliveInSeconds = props.clientKeepAlive.toSeconds();
+            if (clientKeepAliveInSeconds < 60 || clientKeepAliveInSeconds > 604800) {
+                throw new Error(`\'clientKeepAlive\' must be between 60 and 604800 seconds. Got: ${clientKeepAliveInSeconds} seconds`);
+            }
+            this.setAttribute("client_keep_alive.seconds", clientKeepAliveInSeconds.toString());
+        }
+        if (props.crossZoneEnabled === false) {
+            throw new Error("crossZoneEnabled cannot be false with Application Load Balancers.");
+        }
+    }
+    /**
+     * Add a new listener to this load balancer
+     */
+    addListener(id, props) {
+        const listener = new application_listener_1.ApplicationListener(this, id, {
+            loadBalancer: this,
+            ...props,
+        });
+        this.listeners.push(listener);
+        return listener;
+    }
+    /**
+     * Add a redirection listener to this load balancer
+     */
+    addRedirect(props = {}) {
+        const sourcePort = props.sourcePort ?? 80;
+        const targetPort = (props.targetPort ?? 443).toString();
+        return this.addListener(`Redirect${sourcePort}To${targetPort}`, {
+            protocol: props.sourceProtocol ?? enums_1.ApplicationProtocol.HTTP,
+            port: sourcePort,
+            open: props.open ?? true,
+            defaultAction: application_listener_action_1.ListenerAction.redirect({
+                port: targetPort,
+                protocol: props.targetProtocol ?? enums_1.ApplicationProtocol.HTTPS,
+                permanent: true,
+            }),
+        });
+    }
+    /**
+     * Enable access logging for this load balancer.
+     *
+     * A region must be specified on the stack containing the load balancer; you cannot enable logging on
+     * environment-agnostic stacks. See https://docs.aws.amazon.com/cdk/latest/guide/environments.html
+     */
+    logAccessLogs(bucket, prefix) {
+        // TODO: Why does this override BaseLoadBalancer.putAccessLogs?
+        /**
+         * KMS key encryption is not supported on Access Log bucket for ALB, the bucket must use Amazon S3-managed keys (SSE-S3).
+         * See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-access-logging.html#bucket-permissions-troubleshooting
+         */
+        if (bucket.encryptionKey) {
+            throw new Error("Encryption key detected. Bucket encryption using KMS keys is unsupported");
+        }
+        // prefix = prefix; // prefix is optional in TF || "";
+        this.setAttribute("access_logs.s3.enabled", "true");
+        this.setAttribute("access_logs.s3.bucket", bucket.bucketName.toString());
+        this.setAttribute("access_logs.s3.prefix", prefix);
+        const logsDeliveryServicePrincipal = new principals_1.ServicePrincipal("delivery.logs.amazonaws.com");
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:PutObject"],
+            principals: [this.resourcePolicyPrincipal()],
+            resources: [
+                bucket.arnForObjects(`${prefix ? prefix + "/" : ""}AWSLogs/${aws_stack_1.AwsStack.ofAwsConstruct(this).account}/*`),
+            ],
+        }));
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:PutObject"],
+            principals: [logsDeliveryServicePrincipal],
+            resources: [
+                bucket.arnForObjects(`${prefix ? prefix + "/" : ""}AWSLogs/${this.env.account}/*`),
+            ],
+            condition: [
+                {
+                    test: "StringEquals",
+                    variable: "s3:x-amz-acl",
+                    values: ["bucket-owner-full-control"],
+                },
+            ],
+        }));
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:GetBucketAcl"],
+            principals: [logsDeliveryServicePrincipal],
+            resources: [bucket.bucketArn],
+        }));
+        // make sure the bucket's policy is created before the ALB (see https://github.com/aws/aws-cdk/issues/1633)
+        // at the L1 level to avoid creating a circular dependency (see https://github.com/aws/aws-cdk/issues/27528
+        // and https://github.com/aws/aws-cdk/issues/27928)
+        const lb = this.node.defaultChild;
+        const bucketPolicy = bucket.policy?.node.defaultChild;
+        if (lb &&
+            bucketPolicy &&
+            cdktf_1.TerraformResource.isTerraformResource(lb) &&
+            cdktf_1.TerraformResource.isTerraformResource(bucketPolicy)) {
+            lb.node.addDependency(bucketPolicy);
+        }
+        // TODO: Should putAccessLogs be handled as part of prepareStack (in toTerraform() instead)?
+        // only if lb.accessLogs.internalValue !== undefined? (or based on this.attributes?)
+        lb?.putAccessLogs({
+            enabled: this.lazyBoolAttr(util_1.LoadBalancerAttribute.accessLogsS3Enabled),
+            bucket: this.lazyStringAttr(util_1.LoadBalancerAttribute.accessLogsS3Bucket),
+            prefix: this.lazyStringAttr(util_1.LoadBalancerAttribute.accessLogsS3Prefix),
+        });
+    }
+    /**
+     * Enable connection logging for this load balancer.
+     *
+     * A region must be specified on the stack containing the load balancer; you cannot enable logging on
+     * environment-agnostic stacks.
+     *
+     * @see https://docs.aws.amazon.com/cdk/latest/guide/environments.html
+     */
+    logConnectionLogs(bucket, prefix) {
+        /**
+         * KMS key encryption is not supported on Connection Log bucket for ALB, the bucket must use Amazon S3-managed keys (SSE-S3).
+         * See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-connection-logging.html#bucket-permissions-troubleshooting-connection
+         */
+        if (bucket.encryptionKey) {
+            throw new Error("Encryption key detected. Bucket encryption using KMS keys is unsupported");
+        }
+        prefix = prefix || "";
+        this.setAttribute("connection_logs.s3.enabled", "true");
+        this.setAttribute("connection_logs.s3.bucket", bucket.bucketName.toString());
+        this.setAttribute("connection_logs.s3.prefix", prefix);
+        // https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-connection-logging.html
+        const logsDeliveryServicePrincipal = new principals_1.ServicePrincipal("delivery.logs.amazonaws.com");
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:PutObject"],
+            principals: [this.resourcePolicyPrincipal()],
+            resources: [
+                bucket.arnForObjects(`${prefix ? prefix + "/" : ""}AWSLogs/${aws_stack_1.AwsStack.ofAwsConstruct(this).account}/*`),
+            ],
+        }));
+        // We still need this policy for the bucket using the ACL
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:PutObject"],
+            principals: [logsDeliveryServicePrincipal],
+            resources: [
+                bucket.arnForObjects(`${prefix ? prefix + "/" : ""}AWSLogs/${aws_stack_1.AwsStack.ofAwsConstruct(this).account}/*`),
+            ],
+            condition: [
+                {
+                    test: "StringEquals",
+                    variable: "s3:x-amz-acl",
+                    values: ["bucket-owner-full-control"],
+                },
+            ],
+        }));
+        bucket.addToResourcePolicy(new policy_statement_1.PolicyStatement({
+            actions: ["s3:GetBucketAcl"],
+            principals: [logsDeliveryServicePrincipal],
+            resources: [bucket.bucketArn],
+        }));
+        // make sure the bucket's policy is created before the ALB (see https://github.com/aws/aws-cdk/issues/1633)
+        // at the L1 level to avoid creating a circular dependency (see https://github.com/aws/aws-cdk/issues/27528
+        // and https://github.com/aws/aws-cdk/issues/27928)
+        const lb = this.node.defaultChild;
+        const bucketPolicy = bucket.policy?.node.defaultChild;
+        if (lb &&
+            bucketPolicy &&
+            cdktf_1.TerraformResource.isTerraformResource(lb) &&
+            cdktf_1.TerraformResource.isTerraformResource(bucketPolicy)) {
+            lb.node.addDependency(bucketPolicy);
+        }
+        // TODO: Should putConnectionLogs be handled as part of prepareStack (in toTerraform() instead)?
+        // only if lb.connectionLogs.internalValue !== undefined? (or based on this.attributes?)
+        lb?.putConnectionLogs({
+            enabled: this.lazyBoolAttr(util_1.LoadBalancerAttribute.connectionLogsS3Enabled),
+            bucket: this.lazyStringAttr(util_1.LoadBalancerAttribute.connectionLogsS3Bucket),
+            prefix: this.lazyStringAttr(util_1.LoadBalancerAttribute.connectionLogsS3Prefix),
+        });
+    }
+    /**
+     * Add a security group to this load balancer
+     */
+    addSecurityGroup(securityGroup) {
+        this.connections.addSecurityGroup(securityGroup);
+    }
+    /**
+     * Return the given named metric for this Application Load Balancer
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.custom`` instead
+     */
+    metric(metricName, props) {
+        return this.metrics.custom(metricName, props);
+    }
+    /**
+     * The total number of concurrent TCP connections active from clients to the
+     * load balancer and from the load balancer to targets.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.activeConnectionCount`` instead
+     */
+    metricActiveConnectionCount(props) {
+        return this.metrics.activeConnectionCount(props);
+    }
+    /**
+     * The number of TLS connections initiated by the client that did not
+     * establish a session with the load balancer. Possible causes include a
+     * mismatch of ciphers or protocols.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.clientTlsNegotiationErrorCount`` instead
+     */
+    metricClientTlsNegotiationErrorCount(props) {
+        return this.metrics.clientTlsNegotiationErrorCount(props);
+    }
+    /**
+     * The number of load balancer capacity units (LCU) used by your load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.consumedLCUs`` instead
+     */
+    metricConsumedLCUs(props) {
+        return this.metrics.consumedLCUs(props);
+    }
+    /**
+     * The number of fixed-response actions that were successful.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.httpFixedResponseCount`` instead
+     */
+    metricHttpFixedResponseCount(props) {
+        return this.metrics.httpFixedResponseCount(props);
+    }
+    /**
+     * The number of redirect actions that were successful.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.httpRedirectCount`` instead
+     */
+    metricHttpRedirectCount(props) {
+        return this.metrics.httpRedirectCount(props);
+    }
+    /**
+     * The number of redirect actions that couldn't be completed because the URL
+     * in the response location header is larger than 8K.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.httpRedirectUrlLimitExceededCount`` instead
+     */
+    metricHttpRedirectUrlLimitExceededCount(props) {
+        return this.metrics.httpRedirectUrlLimitExceededCount(props);
+    }
+    /**
+     * The number of HTTP 3xx/4xx/5xx codes that originate from the load balancer.
+     *
+     * This does not include any response codes generated by the targets.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.httpCodeElb`` instead
+     */
+    metricHttpCodeElb(code, props) {
+        return this.metrics.httpCodeElb(code, props);
+    }
+    /**
+     * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets
+     * in the load balancer.
+     *
+     * This does not include any response codes generated by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.httpCodeTarget`` instead
+     */
+    metricHttpCodeTarget(code, props) {
+        return this.metrics.httpCodeTarget(code, props);
+    }
+    /**
+     * The total number of bytes processed by the load balancer over IPv6.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.ipv6ProcessedBytes`` instead
+     */
+    metricIpv6ProcessedBytes(props) {
+        return this.metrics.ipv6ProcessedBytes(props);
+    }
+    /**
+     * The number of IPv6 requests received by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.ipv6RequestCount`` instead
+     */
+    metricIpv6RequestCount(props) {
+        return this.metrics.ipv6RequestCount(props);
+    }
+    /**
+     * The total number of new TCP connections established from clients to the
+     * load balancer and from the load balancer to targets.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.newConnectionCount`` instead
+     */
+    metricNewConnectionCount(props) {
+        return this.metrics.newConnectionCount(props);
+    }
+    /**
+     * The total number of bytes processed by the load balancer over IPv4 and IPv6.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.processedBytes`` instead
+     */
+    metricProcessedBytes(props) {
+        return this.metrics.processedBytes(props);
+    }
+    /**
+     * The number of connections that were rejected because the load balancer had
+     * reached its maximum number of connections.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.rejectedConnectionCount`` instead
+     */
+    metricRejectedConnectionCount(props) {
+        return this.metrics.rejectedConnectionCount(props);
+    }
+    /**
+     * The number of requests processed over IPv4 and IPv6.
+     *
+     * This count includes only the requests with a response generated by a target of the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.requestCount`` instead
+     */
+    metricRequestCount(props) {
+        return this.metrics.requestCount(props);
+    }
+    /**
+     * The number of rules processed by the load balancer given a request rate averaged over an hour.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.ruleEvaluations`` instead
+     */
+    metricRuleEvaluations(props) {
+        return this.metrics.ruleEvaluations(props);
+    }
+    /**
+     * The number of connections that were not successfully established between the load balancer and target.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.targetConnectionErrorCount`` instead
+     */
+    metricTargetConnectionErrorCount(props) {
+        return this.metrics.targetConnectionErrorCount(props);
+    }
+    /**
+     * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.targetResponseTime`` instead
+     */
+    metricTargetResponseTime(props) {
+        return this.metrics.targetResponseTime(props);
+    }
+    /**
+     * The number of TLS connections initiated by the load balancer that did not establish a session with the target.
+     *
+     * Possible causes include a mismatch of ciphers or protocols.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.targetTLSNegotiationErrorCount`` instead
+     */
+    metricTargetTLSNegotiationErrorCount(props) {
+        return this.metrics.targetTLSNegotiationErrorCount(props);
+    }
+    /**
+     * The number of user authentications that could not be completed
+     *
+     * Because an authenticate action was misconfigured, the load balancer
+     * couldn't establish a connection with the IdP, or the load balancer
+     * couldn't complete the authentication flow due to an internal error.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthError`` instead
+     */
+    metricElbAuthError(props) {
+        return this.metrics.elbAuthError(props);
+    }
+    /**
+     * The number of user authentications that could not be completed because the
+     * IdP denied access to the user or an authorization code was used more than
+     * once.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthFailure`` instead
+     */
+    metricElbAuthFailure(props) {
+        return this.metrics.elbAuthFailure(props);
+    }
+    /**
+     * The time elapsed, in milliseconds, to query the IdP for the ID token and user info.
+     *
+     * If one or more of these operations fail, this is the time to failure.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthLatency`` instead
+     */
+    metricElbAuthLatency(props) {
+        return this.metrics.elbAuthLatency(props);
+    }
+    /**
+     * The number of authenticate actions that were successful.
+     *
+     * This metric is incremented at the end of the authentication workflow,
+     * after the load balancer has retrieved the user claims from the IdP.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthSuccess`` instead
+     *
+     */
+    metricElbAuthSuccess(props) {
+        return this.metrics.elbAuthSuccess(props);
+    }
+}
+exports.ApplicationLoadBalancer = ApplicationLoadBalancer;
+_a = JSII_RTTI_SYMBOL_1;
+ApplicationLoadBalancer[_a] = { fqn: "terraconstructs.aws.compute.ApplicationLoadBalancer", version: "0.0.12" };
+class ApplicationLoadBalancerMetrics {
+    constructor(scope, loadBalancerFullName) {
+        this.scope = scope;
+        this.loadBalancerFullName = loadBalancerFullName;
+    }
+    /**
+     * Return the given named metric for this Application Load Balancer
+     *
+     * @default Average over 5 minutes
+     */
+    custom(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/ApplicationELB",
+            metricName,
+            dimensionsMap: { LoadBalancer: this.loadBalancerFullName },
+            ...props,
+        });
+    }
+    activeConnectionCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.activeConnectionCountSum, props);
+    }
+    clientTlsNegotiationErrorCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.clientTlsNegotiationErrorCountSum, props);
+    }
+    consumedLCUs(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.consumedLcUsAverage, {
+            statistic: "sum",
+            ...props,
+        });
+    }
+    httpFixedResponseCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.httpFixedResponseCountSum, props);
+    }
+    httpRedirectCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.httpRedirectCountSum, props);
+    }
+    httpRedirectUrlLimitExceededCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.httpRedirectUrlLimitExceededCountSum, props);
+    }
+    httpCodeElb(code, props) {
+        return this.custom(code, {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    httpCodeTarget(code, props) {
+        return this.custom(code, {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    ipv6ProcessedBytes(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.iPv6ProcessedBytesSum, props);
+    }
+    ipv6RequestCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.iPv6RequestCountSum, props);
+    }
+    newConnectionCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.newConnectionCountSum, props);
+    }
+    processedBytes(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.processedBytesSum, props);
+    }
+    rejectedConnectionCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.rejectedConnectionCountSum, props);
+    }
+    requestCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.requestCountSum, props);
+    }
+    ruleEvaluations(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.ApplicationELBMetrics.ruleEvaluationsSum, props);
+    }
+    targetConnectionErrorCount(props) {
+        return this.custom("TargetConnectionErrorCount", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    targetResponseTime(props) {
+        return this.custom("TargetResponseTime", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    targetTLSNegotiationErrorCount(props) {
+        return this.custom("TargetTLSNegotiationErrorCount", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    elbAuthError(props) {
+        return this.custom("ELBAuthError", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    elbAuthFailure(props) {
+        return this.custom("ELBAuthFailure", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    elbAuthLatency(props) {
+        return this.custom("ELBAuthLatency", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    elbAuthSuccess(props) {
+        return this.custom("ELBAuthSuccess", {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({ LoadBalancer: this.loadBalancerFullName }),
+            ...props,
+        }).attachTo(this.scope);
+    }
+}
+/**
+ * Count of HTTP status originating from the load balancer
+ *
+ * This count does not include any response codes generated by the targets.
+ */
+var HttpCodeElb;
+(function (HttpCodeElb) {
+    /**
+     * The number of HTTP 3XX redirection codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_3XX_COUNT"] = "HTTPCode_ELB_3XX_Count";
+    /**
+     * The number of HTTP 4XX client error codes that originate from the load balancer.
+     *
+     * Client errors are generated when requests are malformed or incomplete.
+     * These requests have not been received by the target. This count does not
+     * include any response codes generated by the targets.
+     */
+    HttpCodeElb["ELB_4XX_COUNT"] = "HTTPCode_ELB_4XX_Count";
+    /**
+     * The number of HTTP 5XX server error codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_5XX_COUNT"] = "HTTPCode_ELB_5XX_Count";
+    /**
+     * The number of HTTP 500 server error codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_500_COUNT"] = "HTTPCode_ELB_500_Count";
+    /**
+     * The number of HTTP 502 server error codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_502_COUNT"] = "HTTPCode_ELB_502_Count";
+    /**
+     * The number of HTTP 503 server error codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_503_COUNT"] = "HTTPCode_ELB_503_Count";
+    /**
+     * The number of HTTP 504 server error codes that originate from the load balancer.
+     */
+    HttpCodeElb["ELB_504_COUNT"] = "HTTPCode_ELB_504_Count";
+})(HttpCodeElb || (exports.HttpCodeElb = HttpCodeElb = {}));
+/**
+ * Count of HTTP status originating from the targets
+ */
+var HttpCodeTarget;
+(function (HttpCodeTarget) {
+    /**
+     * The number of 2xx response codes from targets
+     */
+    HttpCodeTarget["TARGET_2XX_COUNT"] = "HTTPCode_Target_2XX_Count";
+    /**
+     * The number of 3xx response codes from targets
+     */
+    HttpCodeTarget["TARGET_3XX_COUNT"] = "HTTPCode_Target_3XX_Count";
+    /**
+     * The number of 4xx response codes from targets
+     */
+    HttpCodeTarget["TARGET_4XX_COUNT"] = "HTTPCode_Target_4XX_Count";
+    /**
+     * The number of 5xx response codes from targets
+     */
+    HttpCodeTarget["TARGET_5XX_COUNT"] = "HTTPCode_Target_5XX_Count";
+})(HttpCodeTarget || (exports.HttpCodeTarget = HttpCodeTarget = {}));
+/**
+ * An ApplicationLoadBalancer that has been defined elsewhere
+ */
+class ImportedApplicationLoadBalancer extends aws_construct_1.AwsConstructBase {
+    get loadBalancerV2Outputs() {
+        return {
+            loadBalancerCanonicalHostedZoneId: this.loadBalancerCanonicalHostedZoneId,
+            loadBalancerDnsName: this.loadBalancerDnsName,
+        };
+    }
+    get outputs() {
+        return this.loadBalancerV2Outputs;
+    }
+    get listeners() {
+        throw Error(".listeners can only be accessed if the class was constructed as an owned, not imported, load balancer");
+    }
+    constructor(scope, id, props) {
+        super(scope, id, {
+            environmentFromArn: props.loadBalancerArn,
+        });
+        this.props = props;
+        this.vpc = props.vpc;
+        this.loadBalancerArn = props.loadBalancerArn;
+        this.connections = new connections_1.Connections({
+            securityGroups: [
+                security_group_1.SecurityGroup.fromSecurityGroupId(this, "SecurityGroup", props.securityGroupId, {
+                    allowAllOutbound: props.securityGroupAllowsAllOutbound,
+                }),
+            ],
+        });
+        this.metrics = new ApplicationLoadBalancerMetrics(this, (0, util_1.parseLoadBalancerFullName)(props.loadBalancerArn));
+    }
+    addListener(id, props) {
+        return new application_listener_1.ApplicationListener(this, id, {
+            loadBalancer: this,
+            ...props,
+        });
+    }
+    get loadBalancerCanonicalHostedZoneId() {
+        if (this.props.loadBalancerCanonicalHostedZoneId) {
+            return this.props.loadBalancerCanonicalHostedZoneId;
+        }
+        // eslint-disable-next-line max-len
+        throw new Error(`'loadBalancerCanonicalHostedZoneId' was not provided when constructing Application Load Balancer ${this.node.path} from attributes`);
+    }
+    get loadBalancerDnsName() {
+        if (this.props.loadBalancerDnsName) {
+            return this.props.loadBalancerDnsName;
+        }
+        // eslint-disable-next-line max-len
+        throw new Error(`'loadBalancerDnsName' was not provided when constructing Application Load Balancer ${this.node.path} from attributes`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-load-balancer.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/application-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-elasticloadbalancingv2/lib/alb/application-load-balancer.ts\n\nimport { lb as tfLoadBalancer } from \"@cdktf/provider-aws\";\nimport { TerraformResource, Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ApplicationListener,\n  BaseApplicationListenerProps,\n} from \"./application-listener\";\nimport { ListenerAction } from \"./application-listener-action\";\nimport { Duration } from \"../../../duration\";\nimport { AwsConstructBase } from \"../../aws-construct\";\nimport { AwsStack } from \"../../aws-stack\";\nimport * as cloudwatch from \"../../cloudwatch\";\nimport { PolicyStatement } from \"../../iam/policy-statement\";\nimport { ServicePrincipal } from \"../../iam/principals\";\nimport * as s3 from \"../../storage\";\nimport { Connections, IConnectable } from \"../connections\";\n// import {\n//   LoadBalancerType,\n//   LoadBalancerListenerProtocol,\n// } from \"../lb-shared/grid-lookup-types\";\nimport { ApplicationELBMetrics } from \"../elasticloadbalancingv2-canned-metrics.generated\";\nimport {\n  BaseLoadBalancer,\n  BaseLoadBalancerLookupOptions,\n  BaseLoadBalancerProps,\n  ILoadBalancerV2,\n  LoadBalancerV2Outputs,\n} from \"../lb-shared/base-load-balancer\";\nimport {\n  IpAddressType,\n  ApplicationProtocol,\n  DesyncMitigationMode,\n} from \"../lb-shared/enums\";\nimport {\n  parseLoadBalancerFullName,\n  LoadBalancerAttribute as Attribute,\n} from \"../lb-shared/util\";\nimport { ISecurityGroup, SecurityGroup } from \"../security-group\";\nimport {\n  IVpc,\n  // Vpc\n} from \"../vpc\";\n\n/**\n * Properties for defining an Application Load Balancer\n *\n * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/application-load-balancers.html#load-balancer-attributes\n */\nexport interface ApplicationLoadBalancerProps extends BaseLoadBalancerProps {\n  /**\n   * Security group to associate with this load balancer\n   *\n   * @default A security group is created\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * The type of IP addresses to use\n   *\n   * @default IpAddressType.IPV4\n   */\n  readonly ipAddressType?: IpAddressType;\n\n  /**\n   * Indicates whether HTTP/2 is enabled.\n   *\n   * @default true\n   */\n  readonly http2Enabled?: boolean;\n\n  /**\n   * The load balancer idle timeout, in seconds\n   *\n   * @default 60\n   */\n  readonly idleTimeout?: Duration;\n\n  /**\n   * Indicates whether HTTP headers with invalid header fields are removed\n   * by the load balancer (true) or routed to targets (false)\n   *\n   * @default false\n   */\n  readonly dropInvalidHeaderFields?: boolean;\n\n  /**\n   * Determines how the load balancer handles requests that\n   * might pose a security risk to your application\n   *\n   * @default DesyncMitigationMode.DEFENSIVE\n   */\n  readonly desyncMitigationMode?: DesyncMitigationMode;\n\n  /**\n   * The client keep alive duration. The valid range is 60 to 604800 seconds (1 minute to 7 days).\n   *\n   * @default - Duration.seconds(3600)\n   */\n  readonly clientKeepAlive?: Duration;\n\n  /**\n   * Indicates whether the Application Load Balancer should preserve the host header in the HTTP request\n   * and send it to the target without any change.\n   *\n   * @default false\n   */\n  readonly preserveHostHeader?: boolean;\n\n  /**\n   * Indicates whether the two headers (x-amzn-tls-version and x-amzn-tls-cipher-suite),\n   * which contain information about the negotiated TLS version and cipher suite,\n   * are added to the client request before sending it to the target.\n   *\n   * The x-amzn-tls-version header has information about the TLS protocol version negotiated with the client,\n   * and the x-amzn-tls-cipher-suite header has information about the cipher suite negotiated with the client.\n   *\n   * Both headers are in OpenSSL format.\n   *\n   * @default false\n   */\n  readonly xAmznTlsVersionAndCipherSuiteHeaders?: boolean;\n\n  /**\n   * Indicates whether the X-Forwarded-For header should preserve the source port\n   * that the client used to connect to the load balancer.\n   *\n   * @default false\n   */\n  readonly preserveXffClientPort?: boolean;\n\n  /**\n   * Enables you to modify, preserve, or remove the X-Forwarded-For header in the HTTP request\n   * before the Application Load Balancer sends the request to the target.\n   *\n   * @default XffHeaderProcessingMode.APPEND\n   */\n  readonly xffHeaderProcessingMode?: XffHeaderProcessingMode;\n\n  /**\n   * Indicates whether to allow a WAF-enabled load balancer to route requests to targets\n   * if it is unable to forward the request to AWS WAF.\n   *\n   * @default false\n   */\n  readonly wafFailOpen?: boolean;\n}\n\n/**\n * Processing mode of the X-Forwarded-For header in the HTTP request\n * before the Application Load Balancer sends the request to the target.\n */\nexport enum XffHeaderProcessingMode {\n  /**\n   * Application Load Balancer adds the client IP address (of the last hop) to the X-Forwarded-For header\n   * in the HTTP request before it sends it to targets.\n   */\n  APPEND = \"append\",\n  /**\n   * Application Load Balancer preserves the X-Forwarded-For header in the HTTP request,\n   * and sends it to targets without any change.\n   */\n  PRESERVE = \"preserve\",\n  /**\n   * Application Load Balancer removes the X-Forwarded-For header\n   * in the HTTP request before it sends it to targets.\n   */\n  REMOVE = \"remove\",\n}\n\n/**\n * Options for looking up an ApplicationLoadBalancer\n */\nexport interface ApplicationLoadBalancerLookupOptions\n  extends BaseLoadBalancerLookupOptions {}\n\n/**\n * Define an Application Load Balancer\n *\n * @resource AWS::ElasticLoadBalancingV2::LoadBalancer\n */\nexport class ApplicationLoadBalancer\n  extends BaseLoadBalancer\n  implements IApplicationLoadBalancer\n{\n  // TODO: Add Grid lookup support\n  // /**\n  //  * Look up an application load balancer.\n  //  */\n  // public static fromLookup(\n  //   scope: Construct,\n  //   id: string,\n  //   options: ApplicationLoadBalancerLookupOptions,\n  // ): IApplicationLoadBalancer {\n  //   const props = BaseLoadBalancer._queryContextProvider(scope, {\n  //     userOptions: options,\n  //     loadBalancerType: LoadBalancerType.APPLICATION,\n  //   });\n\n  //   return new LookedUpApplicationLoadBalancer(scope, id, props);\n  // }\n\n  /**\n   * Import an existing Application Load Balancer\n   */\n  public static fromApplicationLoadBalancerAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ApplicationLoadBalancerAttributes,\n  ): IApplicationLoadBalancer {\n    return new ImportedApplicationLoadBalancer(scope, id, attrs);\n  }\n\n  public readonly connections: Connections;\n  public readonly ipAddressType?: IpAddressType;\n  public readonly listeners: ApplicationListener[];\n  public readonly metrics: IApplicationLoadBalancerMetrics;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: ApplicationLoadBalancerProps,\n  ) {\n    super(scope, id, props, {\n      loadBalancerType: \"application\",\n      securityGroups: Lazy.listValue({\n        produce: () =>\n          this.connections.securityGroups.map((sg) => sg.securityGroupId),\n      }),\n      ipAddressType: props.ipAddressType,\n    });\n\n    this.ipAddressType = props.ipAddressType ?? IpAddressType.IPV4;\n\n    if (\n      props.ipAddressType === IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4 &&\n      !props.internetFacing\n    ) {\n      throw new Error(\n        \"dual-stack without public IPv4 address can only be used with internet-facing scheme.\",\n      );\n    }\n\n    const securityGroups = [\n      props.securityGroup ||\n        new SecurityGroup(this, \"SecurityGroup\", {\n          vpc: props.vpc,\n          description: `Automatically created Security Group for ELB ${AwsStack.uniqueId(this)}`,\n          allowAllOutbound: false,\n        }),\n    ];\n    this.connections = new Connections({ securityGroups });\n    this.listeners = [];\n    this.metrics = new ApplicationLoadBalancerMetrics(\n      this,\n      this.loadBalancerFullName,\n    );\n\n    if (props.http2Enabled !== undefined) {\n      this.setAttribute(\n        \"routing.http2.enabled\",\n        props.http2Enabled ? \"true\" : \"false\",\n      );\n    }\n    if (props.idleTimeout !== undefined) {\n      this.setAttribute(\n        \"idle_timeout.timeout_seconds\",\n        props.idleTimeout.toSeconds().toString(),\n      );\n    }\n    if (props.dropInvalidHeaderFields) {\n      this.setAttribute(\n        \"routing.http.drop_invalid_header_fields.enabled\",\n        \"true\",\n      );\n    }\n    if (props.desyncMitigationMode !== undefined) {\n      this.setAttribute(\n        \"routing.http.desync_mitigation_mode\",\n        props.desyncMitigationMode,\n      );\n    }\n    if (props.preserveHostHeader) {\n      this.setAttribute(\"routing.http.preserve_host_header.enabled\", \"true\");\n    }\n    if (props.xAmznTlsVersionAndCipherSuiteHeaders) {\n      this.setAttribute(\n        \"routing.http.x_amzn_tls_version_and_cipher_suite.enabled\",\n        \"true\",\n      );\n    }\n    if (props.preserveXffClientPort) {\n      this.setAttribute(\"routing.http.xff_client_port.enabled\", \"true\");\n    }\n    if (props.xffHeaderProcessingMode !== undefined) {\n      this.setAttribute(\n        \"routing.http.xff_header_processing.mode\",\n        props.xffHeaderProcessingMode,\n      );\n    }\n    if (props.wafFailOpen) {\n      this.setAttribute(\"waf.fail_open.enabled\", \"true\");\n    }\n    if (props.clientKeepAlive !== undefined) {\n      const clientKeepAliveInMillis = props.clientKeepAlive.toMilliseconds();\n      if (clientKeepAliveInMillis < 1000) {\n        throw new Error(\n          `\\'clientKeepAlive\\' must be between 60 and 604800 seconds. Got: ${clientKeepAliveInMillis} milliseconds`,\n        );\n      }\n\n      const clientKeepAliveInSeconds = props.clientKeepAlive.toSeconds();\n      if (clientKeepAliveInSeconds < 60 || clientKeepAliveInSeconds > 604800) {\n        throw new Error(\n          `\\'clientKeepAlive\\' must be between 60 and 604800 seconds. Got: ${clientKeepAliveInSeconds} seconds`,\n        );\n      }\n      this.setAttribute(\n        \"client_keep_alive.seconds\",\n        clientKeepAliveInSeconds.toString(),\n      );\n    }\n\n    if (props.crossZoneEnabled === false) {\n      throw new Error(\n        \"crossZoneEnabled cannot be false with Application Load Balancers.\",\n      );\n    }\n  }\n\n  /**\n   * Add a new listener to this load balancer\n   */\n  public addListener(\n    id: string,\n    props: BaseApplicationListenerProps,\n  ): ApplicationListener {\n    const listener = new ApplicationListener(this, id, {\n      loadBalancer: this,\n      ...props,\n    });\n    this.listeners.push(listener);\n    return listener;\n  }\n\n  /**\n   * Add a redirection listener to this load balancer\n   */\n  public addRedirect(\n    props: ApplicationLoadBalancerRedirectConfig = {},\n  ): ApplicationListener {\n    const sourcePort = props.sourcePort ?? 80;\n    const targetPort = (props.targetPort ?? 443).toString();\n    return this.addListener(`Redirect${sourcePort}To${targetPort}`, {\n      protocol: props.sourceProtocol ?? ApplicationProtocol.HTTP,\n      port: sourcePort,\n      open: props.open ?? true,\n      defaultAction: ListenerAction.redirect({\n        port: targetPort,\n        protocol: props.targetProtocol ?? ApplicationProtocol.HTTPS,\n        permanent: true,\n      }),\n    });\n  }\n\n  /**\n   * Enable access logging for this load balancer.\n   *\n   * A region must be specified on the stack containing the load balancer; you cannot enable logging on\n   * environment-agnostic stacks. See https://docs.aws.amazon.com/cdk/latest/guide/environments.html\n   */\n  public logAccessLogs(bucket: s3.IBucket, prefix?: string) {\n    // TODO: Why does this override BaseLoadBalancer.putAccessLogs?\n    /**\n     * KMS key encryption is not supported on Access Log bucket for ALB, the bucket must use Amazon S3-managed keys (SSE-S3).\n     * See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-access-logging.html#bucket-permissions-troubleshooting\n     */\n    if (bucket.encryptionKey) {\n      throw new Error(\n        \"Encryption key detected. Bucket encryption using KMS keys is unsupported\",\n      );\n    }\n\n    // prefix = prefix; // prefix is optional in TF || \"\";\n    this.setAttribute(\"access_logs.s3.enabled\", \"true\");\n    this.setAttribute(\"access_logs.s3.bucket\", bucket.bucketName.toString());\n    this.setAttribute(\"access_logs.s3.prefix\", prefix);\n\n    const logsDeliveryServicePrincipal = new ServicePrincipal(\n      \"delivery.logs.amazonaws.com\",\n    );\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:PutObject\"],\n        principals: [this.resourcePolicyPrincipal()],\n        resources: [\n          bucket.arnForObjects(\n            `${prefix ? prefix + \"/\" : \"\"}AWSLogs/${AwsStack.ofAwsConstruct(this).account}/*`,\n          ),\n        ],\n      }),\n    );\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:PutObject\"],\n        principals: [logsDeliveryServicePrincipal],\n        resources: [\n          bucket.arnForObjects(\n            `${prefix ? prefix + \"/\" : \"\"}AWSLogs/${this.env.account}/*`,\n          ),\n        ],\n        condition: [\n          {\n            test: \"StringEquals\",\n            variable: \"s3:x-amz-acl\",\n            values: [\"bucket-owner-full-control\"],\n          },\n        ],\n      }),\n    );\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetBucketAcl\"],\n        principals: [logsDeliveryServicePrincipal],\n        resources: [bucket.bucketArn],\n      }),\n    );\n\n    // make sure the bucket's policy is created before the ALB (see https://github.com/aws/aws-cdk/issues/1633)\n    // at the L1 level to avoid creating a circular dependency (see https://github.com/aws/aws-cdk/issues/27528\n    // and https://github.com/aws/aws-cdk/issues/27928)\n    const lb = this.node.defaultChild as tfLoadBalancer.Lb | undefined;\n    const bucketPolicy = bucket.policy?.node.defaultChild;\n    if (\n      lb &&\n      bucketPolicy &&\n      TerraformResource.isTerraformResource(lb) &&\n      TerraformResource.isTerraformResource(bucketPolicy)\n    ) {\n      lb.node.addDependency(bucketPolicy);\n    }\n    // TODO: Should putAccessLogs be handled as part of prepareStack (in toTerraform() instead)?\n    // only if lb.accessLogs.internalValue !== undefined? (or based on this.attributes?)\n    lb?.putAccessLogs({\n      enabled: this.lazyBoolAttr(Attribute.accessLogsS3Enabled),\n      bucket: this.lazyStringAttr(Attribute.accessLogsS3Bucket),\n      prefix: this.lazyStringAttr(Attribute.accessLogsS3Prefix),\n    });\n  }\n\n  /**\n   * Enable connection logging for this load balancer.\n   *\n   * A region must be specified on the stack containing the load balancer; you cannot enable logging on\n   * environment-agnostic stacks.\n   *\n   * @see https://docs.aws.amazon.com/cdk/latest/guide/environments.html\n   */\n  public logConnectionLogs(bucket: s3.IBucket, prefix?: string) {\n    /**\n     * KMS key encryption is not supported on Connection Log bucket for ALB, the bucket must use Amazon S3-managed keys (SSE-S3).\n     * See https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-connection-logging.html#bucket-permissions-troubleshooting-connection\n     */\n    if (bucket.encryptionKey) {\n      throw new Error(\n        \"Encryption key detected. Bucket encryption using KMS keys is unsupported\",\n      );\n    }\n\n    prefix = prefix || \"\";\n    this.setAttribute(\"connection_logs.s3.enabled\", \"true\");\n    this.setAttribute(\n      \"connection_logs.s3.bucket\",\n      bucket.bucketName.toString(),\n    );\n    this.setAttribute(\"connection_logs.s3.prefix\", prefix);\n\n    // https://docs.aws.amazon.com/elasticloadbalancing/latest/application/enable-connection-logging.html\n    const logsDeliveryServicePrincipal = new ServicePrincipal(\n      \"delivery.logs.amazonaws.com\",\n    );\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:PutObject\"],\n        principals: [this.resourcePolicyPrincipal()],\n        resources: [\n          bucket.arnForObjects(\n            `${prefix ? prefix + \"/\" : \"\"}AWSLogs/${AwsStack.ofAwsConstruct(this).account}/*`,\n          ),\n        ],\n      }),\n    );\n    // We still need this policy for the bucket using the ACL\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:PutObject\"],\n        principals: [logsDeliveryServicePrincipal],\n        resources: [\n          bucket.arnForObjects(\n            `${prefix ? prefix + \"/\" : \"\"}AWSLogs/${AwsStack.ofAwsConstruct(this).account}/*`,\n          ),\n        ],\n        condition: [\n          {\n            test: \"StringEquals\",\n            variable: \"s3:x-amz-acl\",\n            values: [\"bucket-owner-full-control\"],\n          },\n        ],\n      }),\n    );\n    bucket.addToResourcePolicy(\n      new PolicyStatement({\n        actions: [\"s3:GetBucketAcl\"],\n        principals: [logsDeliveryServicePrincipal],\n        resources: [bucket.bucketArn],\n      }),\n    );\n\n    // make sure the bucket's policy is created before the ALB (see https://github.com/aws/aws-cdk/issues/1633)\n    // at the L1 level to avoid creating a circular dependency (see https://github.com/aws/aws-cdk/issues/27528\n    // and https://github.com/aws/aws-cdk/issues/27928)\n    const lb = this.node.defaultChild as tfLoadBalancer.Lb | undefined;\n    const bucketPolicy = bucket.policy?.node.defaultChild;\n    if (\n      lb &&\n      bucketPolicy &&\n      TerraformResource.isTerraformResource(lb) &&\n      TerraformResource.isTerraformResource(bucketPolicy)\n    ) {\n      lb.node.addDependency(bucketPolicy);\n    }\n    // TODO: Should putConnectionLogs be handled as part of prepareStack (in toTerraform() instead)?\n    // only if lb.connectionLogs.internalValue !== undefined? (or based on this.attributes?)\n    lb?.putConnectionLogs({\n      enabled: this.lazyBoolAttr(Attribute.connectionLogsS3Enabled),\n      bucket: this.lazyStringAttr(Attribute.connectionLogsS3Bucket),\n      prefix: this.lazyStringAttr(Attribute.connectionLogsS3Prefix),\n    });\n  }\n\n  /**\n   * Add a security group to this load balancer\n   */\n  public addSecurityGroup(securityGroup: ISecurityGroup) {\n    this.connections.addSecurityGroup(securityGroup);\n  }\n\n  /**\n   * Return the given named metric for this Application Load Balancer\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.custom`` instead\n   */\n  public metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return this.metrics.custom(metricName, props);\n  }\n\n  /**\n   * The total number of concurrent TCP connections active from clients to the\n   * load balancer and from the load balancer to targets.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.activeConnectionCount`` instead\n   */\n  public metricActiveConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.activeConnectionCount(props);\n  }\n\n  /**\n   * The number of TLS connections initiated by the client that did not\n   * establish a session with the load balancer. Possible causes include a\n   * mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.clientTlsNegotiationErrorCount`` instead\n   */\n  public metricClientTlsNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.clientTlsNegotiationErrorCount(props);\n  }\n\n  /**\n   * The number of load balancer capacity units (LCU) used by your load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.consumedLCUs`` instead\n   */\n  public metricConsumedLCUs(props?: cloudwatch.MetricOptions) {\n    return this.metrics.consumedLCUs(props);\n  }\n\n  /**\n   * The number of fixed-response actions that were successful.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.httpFixedResponseCount`` instead\n   */\n  public metricHttpFixedResponseCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.httpFixedResponseCount(props);\n  }\n\n  /**\n   * The number of redirect actions that were successful.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.httpRedirectCount`` instead\n   */\n  public metricHttpRedirectCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.httpRedirectCount(props);\n  }\n\n  /**\n   * The number of redirect actions that couldn't be completed because the URL\n   * in the response location header is larger than 8K.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.httpRedirectUrlLimitExceededCount`` instead\n   */\n  public metricHttpRedirectUrlLimitExceededCount(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.httpRedirectUrlLimitExceededCount(props);\n  }\n\n  /**\n   * The number of HTTP 3xx/4xx/5xx codes that originate from the load balancer.\n   *\n   * This does not include any response codes generated by the targets.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.httpCodeElb`` instead\n   */\n  public metricHttpCodeElb(\n    code: HttpCodeElb,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.httpCodeElb(code, props);\n  }\n\n  /**\n   * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets\n   * in the load balancer.\n   *\n   * This does not include any response codes generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.httpCodeTarget`` instead\n   */\n  public metricHttpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.httpCodeTarget(code, props);\n  }\n\n  /**\n   * The total number of bytes processed by the load balancer over IPv6.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.ipv6ProcessedBytes`` instead\n   */\n  public metricIpv6ProcessedBytes(props?: cloudwatch.MetricOptions) {\n    return this.metrics.ipv6ProcessedBytes(props);\n  }\n\n  /**\n   * The number of IPv6 requests received by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.ipv6RequestCount`` instead\n   */\n  public metricIpv6RequestCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.ipv6RequestCount(props);\n  }\n\n  /**\n   * The total number of new TCP connections established from clients to the\n   * load balancer and from the load balancer to targets.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.newConnectionCount`` instead\n   */\n  public metricNewConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.newConnectionCount(props);\n  }\n\n  /**\n   * The total number of bytes processed by the load balancer over IPv4 and IPv6.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.processedBytes`` instead\n   */\n  public metricProcessedBytes(props?: cloudwatch.MetricOptions) {\n    return this.metrics.processedBytes(props);\n  }\n\n  /**\n   * The number of connections that were rejected because the load balancer had\n   * reached its maximum number of connections.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.rejectedConnectionCount`` instead\n   */\n  public metricRejectedConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.rejectedConnectionCount(props);\n  }\n\n  /**\n   * The number of requests processed over IPv4 and IPv6.\n   *\n   * This count includes only the requests with a response generated by a target of the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.requestCount`` instead\n   */\n  public metricRequestCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.requestCount(props);\n  }\n\n  /**\n   * The number of rules processed by the load balancer given a request rate averaged over an hour.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.ruleEvaluations`` instead\n   */\n  public metricRuleEvaluations(props?: cloudwatch.MetricOptions) {\n    return this.metrics.ruleEvaluations(props);\n  }\n\n  /**\n   * The number of connections that were not successfully established between the load balancer and target.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.targetConnectionErrorCount`` instead\n   */\n  public metricTargetConnectionErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.targetConnectionErrorCount(props);\n  }\n\n  /**\n   * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.targetResponseTime`` instead\n   */\n  public metricTargetResponseTime(props?: cloudwatch.MetricOptions) {\n    return this.metrics.targetResponseTime(props);\n  }\n\n  /**\n   * The number of TLS connections initiated by the load balancer that did not establish a session with the target.\n   *\n   * Possible causes include a mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.targetTLSNegotiationErrorCount`` instead\n   */\n  public metricTargetTLSNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.metrics.targetTLSNegotiationErrorCount(props);\n  }\n\n  /**\n   * The number of user authentications that could not be completed\n   *\n   * Because an authenticate action was misconfigured, the load balancer\n   * couldn't establish a connection with the IdP, or the load balancer\n   * couldn't complete the authentication flow due to an internal error.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthError`` instead\n   */\n  public metricElbAuthError(props?: cloudwatch.MetricOptions) {\n    return this.metrics.elbAuthError(props);\n  }\n\n  /**\n   * The number of user authentications that could not be completed because the\n   * IdP denied access to the user or an authorization code was used more than\n   * once.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthFailure`` instead\n   */\n  public metricElbAuthFailure(props?: cloudwatch.MetricOptions) {\n    return this.metrics.elbAuthFailure(props);\n  }\n\n  /**\n   * The time elapsed, in milliseconds, to query the IdP for the ID token and user info.\n   *\n   * If one or more of these operations fail, this is the time to failure.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthLatency`` instead\n   */\n  public metricElbAuthLatency(props?: cloudwatch.MetricOptions) {\n    return this.metrics.elbAuthLatency(props);\n  }\n\n  /**\n   * The number of authenticate actions that were successful.\n   *\n   * This metric is incremented at the end of the authentication workflow,\n   * after the load balancer has retrieved the user claims from the IdP.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``ApplicationLoadBalancer.metrics.elbAuthSuccess`` instead\n   *\n   */\n  public metricElbAuthSuccess(props?: cloudwatch.MetricOptions) {\n    return this.metrics.elbAuthSuccess(props);\n  }\n}\n\nclass ApplicationLoadBalancerMetrics\n  implements IApplicationLoadBalancerMetrics\n{\n  private readonly scope: Construct;\n  private readonly loadBalancerFullName: string;\n\n  constructor(scope: Construct, loadBalancerFullName: string) {\n    this.scope = scope;\n    this.loadBalancerFullName = loadBalancerFullName;\n  }\n\n  /**\n   * Return the given named metric for this Application Load Balancer\n   *\n   * @default Average over 5 minutes\n   */\n  public custom(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/ApplicationELB\",\n      metricName,\n      dimensionsMap: { LoadBalancer: this.loadBalancerFullName },\n      ...props,\n    });\n  }\n\n  public activeConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.activeConnectionCountSum,\n      props,\n    );\n  }\n\n  public clientTlsNegotiationErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.clientTlsNegotiationErrorCountSum,\n      props,\n    );\n  }\n\n  public consumedLCUs(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.consumedLcUsAverage, {\n      statistic: \"sum\",\n      ...props,\n    });\n  }\n\n  public httpFixedResponseCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.httpFixedResponseCountSum,\n      props,\n    );\n  }\n\n  public httpRedirectCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.httpRedirectCountSum, props);\n  }\n\n  public httpRedirectUrlLimitExceededCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.httpRedirectUrlLimitExceededCountSum,\n      props,\n    );\n  }\n\n  public httpCodeElb(code: HttpCodeElb, props?: cloudwatch.MetricOptions) {\n    return this.custom(code, {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public httpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ) {\n    return this.custom(code, {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public ipv6ProcessedBytes(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.iPv6ProcessedBytesSum,\n      props,\n    );\n  }\n\n  public ipv6RequestCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.iPv6RequestCountSum, props);\n  }\n\n  public newConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.newConnectionCountSum,\n      props,\n    );\n  }\n\n  public processedBytes(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.processedBytesSum, props);\n  }\n\n  public rejectedConnectionCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(\n      ApplicationELBMetrics.rejectedConnectionCountSum,\n      props,\n    );\n  }\n\n  public requestCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.requestCountSum, props);\n  }\n\n  public ruleEvaluations(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(ApplicationELBMetrics.ruleEvaluationsSum, props);\n  }\n\n  public targetConnectionErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetConnectionErrorCount\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public targetResponseTime(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetResponseTime\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  public targetTLSNegotiationErrorCount(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"TargetTLSNegotiationErrorCount\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public elbAuthError(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"ELBAuthError\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public elbAuthFailure(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"ELBAuthFailure\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public elbAuthLatency(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"ELBAuthLatency\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  public elbAuthSuccess(props?: cloudwatch.MetricOptions) {\n    return this.custom(\"ELBAuthSuccess\", {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  private cannedMetric(\n    fn: (dims: { LoadBalancer: string }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...fn({ LoadBalancer: this.loadBalancerFullName }),\n      ...props,\n    }).attachTo(this.scope);\n  }\n}\n\n/**\n * Count of HTTP status originating from the load balancer\n *\n * This count does not include any response codes generated by the targets.\n */\nexport enum HttpCodeElb {\n  /**\n   * The number of HTTP 3XX redirection codes that originate from the load balancer.\n   */\n  ELB_3XX_COUNT = \"HTTPCode_ELB_3XX_Count\",\n\n  /**\n   * The number of HTTP 4XX client error codes that originate from the load balancer.\n   *\n   * Client errors are generated when requests are malformed or incomplete.\n   * These requests have not been received by the target. This count does not\n   * include any response codes generated by the targets.\n   */\n  ELB_4XX_COUNT = \"HTTPCode_ELB_4XX_Count\",\n\n  /**\n   * The number of HTTP 5XX server error codes that originate from the load balancer.\n   */\n  ELB_5XX_COUNT = \"HTTPCode_ELB_5XX_Count\",\n\n  /**\n   * The number of HTTP 500 server error codes that originate from the load balancer.\n   */\n  ELB_500_COUNT = \"HTTPCode_ELB_500_Count\",\n\n  /**\n   * The number of HTTP 502 server error codes that originate from the load balancer.\n   */\n  ELB_502_COUNT = \"HTTPCode_ELB_502_Count\",\n\n  /**\n   * The number of HTTP 503 server error codes that originate from the load balancer.\n   */\n  ELB_503_COUNT = \"HTTPCode_ELB_503_Count\",\n\n  /**\n   * The number of HTTP 504 server error codes that originate from the load balancer.\n   */\n  ELB_504_COUNT = \"HTTPCode_ELB_504_Count\",\n}\n\n/**\n * Count of HTTP status originating from the targets\n */\nexport enum HttpCodeTarget {\n  /**\n   * The number of 2xx response codes from targets\n   */\n  TARGET_2XX_COUNT = \"HTTPCode_Target_2XX_Count\",\n\n  /**\n   * The number of 3xx response codes from targets\n   */\n  TARGET_3XX_COUNT = \"HTTPCode_Target_3XX_Count\",\n\n  /**\n   * The number of 4xx response codes from targets\n   */\n  TARGET_4XX_COUNT = \"HTTPCode_Target_4XX_Count\",\n\n  /**\n   * The number of 5xx response codes from targets\n   */\n  TARGET_5XX_COUNT = \"HTTPCode_Target_5XX_Count\",\n}\n\n/**\n * Contains all metrics for an Application Load Balancer.\n */\nexport interface IApplicationLoadBalancerMetrics {\n  /**\n   * Return the given named metric for this Application Load Balancer\n   *\n   * @default Average over 5 minutes\n   */\n  custom(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The total number of concurrent TCP connections active from clients to the\n   * load balancer and from the load balancer to targets.\n   *\n   * @default Sum over 5 minutes\n   */\n  activeConnectionCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of TLS connections initiated by the client that did not\n   * establish a session with the load balancer. Possible causes include a\n   * mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   */\n  clientTlsNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of load balancer capacity units (LCU) used by your load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  consumedLCUs(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of fixed-response actions that were successful.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpFixedResponseCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of redirect actions that were successful.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpRedirectCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of redirect actions that couldn't be completed because the URL\n   * in the response location header is larger than 8K.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpRedirectUrlLimitExceededCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of HTTP 3xx/4xx/5xx codes that originate from the load balancer.\n   *\n   * This does not include any response codes generated by the targets.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpCodeElb(\n    code: HttpCodeElb,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of HTTP 2xx/3xx/4xx/5xx response codes generated by all targets\n   * in the load balancer.\n   *\n   * This does not include any response codes generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  httpCodeTarget(\n    code: HttpCodeTarget,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The total number of bytes processed by the load balancer over IPv6.\n   *\n   * @default Sum over 5 minutes\n   */\n  ipv6ProcessedBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of IPv6 requests received by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  ipv6RequestCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of new TCP connections established from clients to the\n   * load balancer and from the load balancer to targets.\n   *\n   * @default Sum over 5 minutes\n   */\n  newConnectionCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of bytes processed by the load balancer over IPv4 and IPv6.\n   *\n   * @default Sum over 5 minutes\n   */\n  processedBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of connections that were rejected because the load balancer had\n   * reached its maximum number of connections.\n   *\n   * @default Sum over 5 minutes\n   */\n  rejectedConnectionCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of requests processed over IPv4 and IPv6.\n   *\n   * This count includes only the requests with a response generated by a target of the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  requestCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of rules processed by the load balancer given a request rate averaged over an hour.\n   *\n   * @default Sum over 5 minutes\n   */\n  ruleEvaluations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of connections that were not successfully established between the load balancer and target.\n   *\n   * @default Sum over 5 minutes\n   */\n  targetConnectionErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The time elapsed, in seconds, after the request leaves the load balancer until a response from the target is received.\n   *\n   * @default Average over 5 minutes\n   */\n  targetResponseTime(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of TLS connections initiated by the load balancer that did not establish a session with the target.\n   *\n   * Possible causes include a mismatch of ciphers or protocols.\n   *\n   * @default Sum over 5 minutes\n   */\n  targetTLSNegotiationErrorCount(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * The number of user authentications that could not be completed\n   *\n   * Because an authenticate action was misconfigured, the load balancer\n   * couldn't establish a connection with the IdP, or the load balancer\n   * couldn't complete the authentication flow due to an internal error.\n   *\n   * @default Sum over 5 minutes\n   */\n  elbAuthError(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of user authentications that could not be completed because the\n   * IdP denied access to the user or an authorization code was used more than\n   * once.\n   *\n   * @default Sum over 5 minutes\n   */\n  elbAuthFailure(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The time elapsed, in milliseconds, to query the IdP for the ID token and user info.\n   *\n   * If one or more of these operations fail, this is the time to failure.\n   *\n   * @default Average over 5 minutes\n   */\n  elbAuthLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The number of authenticate actions that were successful.\n   *\n   * This metric is incremented at the end of the authentication workflow,\n   * after the load balancer has retrieved the user claims from the IdP.\n   *\n   * @default Sum over 5 minutes\n   */\n  elbAuthSuccess(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * An application load balancer\n */\nexport interface IApplicationLoadBalancer\n  extends ILoadBalancerV2,\n    IConnectable {\n  /**\n   * The ARN of this load balancer\n   */\n  readonly loadBalancerArn: string;\n\n  /**\n   * The VPC this load balancer has been created in (if available).\n   * If this interface is the result of an import call to fromApplicationLoadBalancerAttributes,\n   * the vpc attribute will be undefined unless specified in the optional properties of that method.\n   */\n  readonly vpc?: IVpc;\n\n  /**\n   * The IP Address Type for this load balancer\n   *\n   * If the `@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault`\n   * feature flag is set (the default for new projects), and `addListener()` is called with `open: true`,\n   * the load balancer's security group will automatically include both IPv4 and IPv6 ingress rules\n   * when using `IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4`.\n   *\n   * For existing projects that only have IPv4 rules, you can opt-in to IPv6 ingress rules\n   * by enabling the feature flag in your cdk.json file. Note that enabling this feature flag\n   * will modify existing security group rules.\n   *\n   * @default IpAddressType.IPV4\n   */\n  readonly ipAddressType?: IpAddressType;\n\n  /**\n   * A list of listeners that have been added to the load balancer.\n   * This list is only valid for owned constructs.\n   */\n  readonly listeners: ApplicationListener[];\n\n  /**\n   * All metrics available for this load balancer\n   */\n  readonly metrics: IApplicationLoadBalancerMetrics;\n\n  /**\n   * Add a new listener to this load balancer\n   */\n  addListener(\n    id: string,\n    props: BaseApplicationListenerProps,\n  ): ApplicationListener;\n}\n\n/**\n * Properties to reference an existing load balancer\n */\nexport interface ApplicationLoadBalancerAttributes {\n  /**\n   * ARN of the load balancer\n   */\n  readonly loadBalancerArn: string;\n\n  /**\n   * ID of the load balancer's security group\n   */\n  readonly securityGroupId: string;\n\n  /**\n   * The canonical hosted zone ID of this load balancer\n   *\n   * @default - When not provided, LB cannot be used as Route53 Alias target.\n   */\n  readonly loadBalancerCanonicalHostedZoneId?: string;\n\n  /**\n   * The DNS name of this load balancer\n   *\n   * @default - When not provided, LB cannot be used as Route53 Alias target.\n   */\n  readonly loadBalancerDnsName?: string;\n\n  /**\n   * Whether the security group allows all outbound traffic or not\n   *\n   * Unless set to `false`, no egress rules will be added to the security group.\n   *\n   * @default true\n   */\n  readonly securityGroupAllowsAllOutbound?: boolean;\n\n  /**\n   * The VPC this load balancer has been created in, if available\n   *\n   * @default - If the Load Balancer was imported and a VPC was not specified,\n   * the VPC is not available.\n   */\n  readonly vpc?: IVpc;\n}\n\n/**\n * An ApplicationLoadBalancer that has been defined elsewhere\n */\nclass ImportedApplicationLoadBalancer\n  extends AwsConstructBase\n  implements IApplicationLoadBalancer\n{\n  public get loadBalancerV2Outputs(): LoadBalancerV2Outputs {\n    return {\n      loadBalancerCanonicalHostedZoneId: this.loadBalancerCanonicalHostedZoneId,\n      loadBalancerDnsName: this.loadBalancerDnsName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.loadBalancerV2Outputs;\n  }\n  /**\n   * Manage connections for this load balancer\n   */\n  public readonly connections: Connections;\n\n  /**\n   * ARN of the load balancer\n   */\n  public readonly loadBalancerArn: string;\n\n  public get listeners(): ApplicationListener[] {\n    throw Error(\n      \".listeners can only be accessed if the class was constructed as an owned, not imported, load balancer\",\n    );\n  }\n\n  /**\n   * VPC of the load balancer\n   *\n   * Undefined if optional vpc is not specified.\n   */\n  public readonly vpc?: IVpc;\n  public readonly metrics: IApplicationLoadBalancerMetrics;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    private readonly props: ApplicationLoadBalancerAttributes,\n  ) {\n    super(scope, id, {\n      environmentFromArn: props.loadBalancerArn,\n    });\n\n    this.vpc = props.vpc;\n    this.loadBalancerArn = props.loadBalancerArn;\n    this.connections = new Connections({\n      securityGroups: [\n        SecurityGroup.fromSecurityGroupId(\n          this,\n          \"SecurityGroup\",\n          props.securityGroupId,\n          {\n            allowAllOutbound: props.securityGroupAllowsAllOutbound,\n          },\n        ),\n      ],\n    });\n    this.metrics = new ApplicationLoadBalancerMetrics(\n      this,\n      parseLoadBalancerFullName(props.loadBalancerArn),\n    );\n  }\n\n  public addListener(\n    id: string,\n    props: BaseApplicationListenerProps,\n  ): ApplicationListener {\n    return new ApplicationListener(this, id, {\n      loadBalancer: this,\n      ...props,\n    });\n  }\n\n  public get loadBalancerCanonicalHostedZoneId(): string {\n    if (this.props.loadBalancerCanonicalHostedZoneId) {\n      return this.props.loadBalancerCanonicalHostedZoneId;\n    }\n    // eslint-disable-next-line max-len\n    throw new Error(\n      `'loadBalancerCanonicalHostedZoneId' was not provided when constructing Application Load Balancer ${this.node.path} from attributes`,\n    );\n  }\n\n  public get loadBalancerDnsName(): string {\n    if (this.props.loadBalancerDnsName) {\n      return this.props.loadBalancerDnsName;\n    }\n    // eslint-disable-next-line max-len\n    throw new Error(\n      `'loadBalancerDnsName' was not provided when constructing Application Load Balancer ${this.node.path} from attributes`,\n    );\n  }\n}\n// TODO: Add Grid Lookup support\n// class LookedUpApplicationLoadBalancer\n//   extends AwsConstructBase\n//   implements IApplicationLoadBalancer\n// {\n//   public readonly loadBalancerArn: string;\n//   public readonly loadBalancerCanonicalHostedZoneId: string;\n//   public readonly loadBalancerDnsName: string;\n//   public readonly ipAddressType?: IpAddressType;\n//   public readonly connections: Connections;\n//   public readonly vpc?: IVpc;\n//   public readonly metrics: IApplicationLoadBalancerMetrics;\n\n//   public get listeners(): ApplicationListener[] {\n//     throw Error(\n//       \".listeners can only be accessed if the class was constructed as an owned, not looked up, load balancer\",\n//     );\n//   }\n\n//   constructor(\n//     scope: Construct,\n//     id: string,\n//     props: cxapi.LoadBalancerContextResponse,\n//   ) {\n//     super(scope, id, {\n//       environmentFromArn: props.loadBalancerArn,\n//     });\n\n//     this.loadBalancerArn = props.loadBalancerArn;\n//     this.loadBalancerCanonicalHostedZoneId =\n//       props.loadBalancerCanonicalHostedZoneId;\n//     this.loadBalancerDnsName = props.loadBalancerDnsName;\n\n//     if (props.ipAddressType === cxapi.LoadBalancerIpAddressType.IPV4) {\n//       this.ipAddressType = IpAddressType.IPV4;\n//     } else if (\n//       props.ipAddressType === cxapi.LoadBalancerIpAddressType.DUAL_STACK\n//     ) {\n//       this.ipAddressType = IpAddressType.DUAL_STACK;\n//     } else if (\n//       props.ipAddressType ===\n//       cxapi.LoadBalancerIpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4\n//     ) {\n//       this.ipAddressType = IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4;\n//     }\n\n//     this.vpc = Vpc.fromLookup(this, \"Vpc\", {\n//       vpcId: props.vpcId,\n//     });\n\n//     this.connections = new Connections();\n//     for (const securityGroupId of props.securityGroupIds) {\n//       const securityGroup = SecurityGroup.fromLookupById(\n//         this,\n//         `SecurityGroup-${securityGroupId}`,\n//         securityGroupId,\n//       );\n//       this.connections.addSecurityGroup(securityGroup);\n//     }\n//     this.metrics = new ApplicationLoadBalancerMetrics(\n//       this,\n//       parseLoadBalancerFullName(this.loadBalancerArn),\n//     );\n//   }\n\n//   public addListener(\n//     id: string,\n//     props: BaseApplicationListenerProps,\n//   ): ApplicationListener {\n//     return new ApplicationListener(this, id, {\n//       ...props,\n//       loadBalancer: this,\n//     });\n//   }\n// }\n\n/**\n * Properties for a redirection config\n */\nexport interface ApplicationLoadBalancerRedirectConfig {\n  /**\n   * The protocol of the listener being created\n   *\n   * @default HTTP\n   */\n  readonly sourceProtocol?: ApplicationProtocol;\n\n  /**\n   * The port number to listen to\n   *\n   * @default 80\n   */\n  readonly sourcePort?: number;\n\n  /**\n   * The protocol of the redirection target\n   *\n   * @default HTTPS\n   */\n  readonly targetProtocol?: ApplicationProtocol;\n\n  /**\n   * The port number to redirect to\n   *\n   * @default 443\n   */\n  readonly targetPort?: number;\n\n  /**\n   * Allow anyone to connect to this listener\n   *\n   * If this is specified, the listener will be opened up to anyone who can reach it.\n   * For internal load balancers this is anyone in the same VPC. For public load\n   * balancers, this is anyone on the internet.\n   *\n   * If you want to be more selective about who can access this load\n   * balancer, set this to `false` and use the listener's `connections`\n   * object to selectively grant access to the listener.\n   *\n   * @default true\n   */\n  readonly open?: boolean;\n}\n"]}