terraconstructs 0.0.11 → 0.0.12

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

@@ -0,0 +1,360 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkLoadBalancer = exports.ClientRoutingPolicy = 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-elasticloadbalancingv2/lib/nlb/network-load-balancer.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const network_listener_1 = require("./network-listener");
+const aws_construct_1 = require("../../aws-construct");
+const cloudwatch = require("../../cloudwatch");
+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");
+/**
+ * Indicates how traffic is distributed among the load balancer Availability Zones.
+ *
+ * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#zonal-dns-affinity
+ */
+var ClientRoutingPolicy;
+(function (ClientRoutingPolicy) {
+    /**
+     * 100 percent zonal affinity
+     */
+    ClientRoutingPolicy["AVAILABILITY_ZONE_AFFINITY"] = "availability_zone_affinity";
+    /**
+     * 85 percent zonal affinity
+     */
+    ClientRoutingPolicy["PARTIAL_AVAILABILITY_ZONE_AFFINITY"] = "partial_availability_zone_affinity";
+    /**
+     * No zonal affinity
+     */
+    ClientRoutingPolicy["ANY_AVAILABILITY_ZONE"] = "any_availability_zone";
+})(ClientRoutingPolicy || (exports.ClientRoutingPolicy = ClientRoutingPolicy = {}));
+/**
+ * The metrics for a network load balancer.
+ */
+class NetworkLoadBalancerMetrics {
+    constructor(scope, loadBalancerFullName) {
+        this.scope = scope;
+        this.loadBalancerFullName = loadBalancerFullName;
+    }
+    custom(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/NetworkELB",
+            metricName,
+            dimensionsMap: { LoadBalancer: this.loadBalancerFullName },
+            ...props,
+        }).attachTo(this.scope);
+    }
+    activeFlowCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.activeFlowCountAverage, props);
+    }
+    consumedLCUs(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.consumedLcUsAverage, {
+            statistic: "Sum",
+            ...props,
+        });
+    }
+    newFlowCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.newFlowCountSum, props);
+    }
+    processedBytes(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.processedBytesSum, props);
+    }
+    tcpClientResetCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.tcpClientResetCountSum, props);
+    }
+    tcpElbResetCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.tcpElbResetCountSum, props);
+    }
+    tcpTargetResetCount(props) {
+        return this.cannedMetric(elasticloadbalancingv2_canned_metrics_generated_1.NetworkELBMetrics.tcpTargetResetCountSum, props);
+    }
+    cannedMetric(fn, props) {
+        return new cloudwatch.Metric({
+            ...fn({ LoadBalancer: this.loadBalancerFullName }),
+            ...props,
+        }).attachTo(this.scope);
+    }
+}
+/**
+ * Define a new network load balancer
+ *
+ * @resource AWS::ElasticLoadBalancingV2::LoadBalancer
+ */
+class NetworkLoadBalancer extends base_load_balancer_1.BaseLoadBalancer {
+    // TODO: Add Grid lookup support
+    // /**
+    //  * Looks up the network load balancer.
+    //  */
+    // public static fromLookup(
+    //   scope: Construct,
+    //   id: string,
+    //   options: NetworkLoadBalancerLookupOptions,
+    // ): INetworkLoadBalancer {
+    //   const props = BaseLoadBalancer._queryContextProvider(scope, {
+    //     userOptions: options,
+    //     loadBalancerType: LoadBalancerType.NETWORK,
+    //   });
+    //   return new LookedUpNetworkLoadBalancer(scope, id, props);
+    // }
+    static fromNetworkLoadBalancerAttributes(scope, id, attrs) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor(props) {
+                super(scope, id, props);
+                this.connections = new connections_1.Connections({
+                    securityGroups: attrs.loadBalancerSecurityGroups?.map((securityGroupId, index) => security_group_1.SecurityGroup.fromSecurityGroupId(this, `SecurityGroup-${index}`, securityGroupId)),
+                });
+                this.loadBalancerArn = attrs.loadBalancerArn;
+                this.vpc = attrs.vpc;
+                this.metrics = new NetworkLoadBalancerMetrics(this, (0, util_1.parseLoadBalancerFullName)(attrs.loadBalancerArn));
+                this.securityGroups = attrs.loadBalancerSecurityGroups;
+                this.resource = new provider_aws_1.dataAwsLb.DataAwsLb(this, "Resource", {
+                    arn: attrs.loadBalancerArn,
+                });
+            }
+            addListener(lid, props) {
+                return new network_listener_1.NetworkListener(this, lid, {
+                    loadBalancer: this,
+                    ...props,
+                });
+            }
+            get loadBalancerCanonicalHostedZoneId() {
+                if (attrs.loadBalancerCanonicalHostedZoneId) {
+                    return attrs.loadBalancerCanonicalHostedZoneId;
+                }
+                return this.resource.zoneId;
+                // // eslint-disable-next-line max-len
+                // throw new Error(
+                //   `'loadBalancerCanonicalHostedZoneId' was not provided when constructing Network Load Balancer ${this.node.path} from attributes`,
+                // );
+            }
+            get loadBalancerDnsName() {
+                if (attrs.loadBalancerDnsName) {
+                    return attrs.loadBalancerDnsName;
+                }
+                return this.resource.dnsName;
+                // // eslint-disable-next-line max-len
+                // throw new Error(
+                //   `'loadBalancerDnsName' was not provided when constructing Network Load Balancer ${this.node.path} from attributes`,
+                // );
+            }
+            get loadBalancerV2Outputs() {
+                return {
+                    loadBalancerCanonicalHostedZoneId: this.loadBalancerCanonicalHostedZoneId,
+                    loadBalancerDnsName: this.loadBalancerDnsName,
+                };
+            }
+            get outputs() {
+                return this.loadBalancerV2Outputs;
+            }
+        }
+        return new Import({ environmentFromArn: attrs.loadBalancerArn });
+    }
+    // TODO: Missing in provider-aws
+    // https://github.com/hashicorp/terraform-provider-aws/issues/40379
+    // private enablePrefixForIpv6SourceNat?: boolean;
+    /**
+     * After the implementation of `IConnectable` (see https://github.com/aws/aws-cdk/pull/28494), the default
+     * value for `securityGroups` is set by the `Connections` constructor to an empty array.
+     * To keep backward compatibility (`securityGroups` is `undefined` if the related property is not specified)
+     * a getter has been added.
+     */
+    get securityGroups() {
+        return this.isSecurityGroupsPropertyDefined ||
+            this.connections.securityGroups.length
+            ? this.connections.securityGroups.map((sg) => sg.securityGroupId)
+            : undefined;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props, {
+            loadBalancerType: "network",
+            securityGroups: cdktf_1.Lazy.listValue({ produce: () => this.securityGroups }),
+            ipAddressType: props.ipAddressType,
+            enforceSecurityGroupInboundRulesOnPrivateLinkTraffic: cdktf_1.Lazy.stringValue({
+                produce: () => this.enforceSecurityGroupInboundRulesOnPrivateLinkTraffic,
+            }),
+            // TODO: Missing in provider-aws
+            // https://github.com/hashicorp/terraform-provider-aws/issues/40379
+            // enablePrefixForIpv6SourceNat:
+            //   props.enablePrefixForIpv6SourceNat === true
+            //     ? "on"
+            //     : props.enablePrefixForIpv6SourceNat === false
+            //       ? "off"
+            //       : undefined,
+        });
+        // this.enablePrefixForIpv6SourceNat = props.enablePrefixForIpv6SourceNat;
+        this.metrics = new NetworkLoadBalancerMetrics(this, this.loadBalancerFullName);
+        this.isSecurityGroupsPropertyDefined = !!props.securityGroups;
+        this.connections = new connections_1.Connections({
+            securityGroups: props.securityGroups,
+        });
+        this.ipAddressType = props.ipAddressType ?? enums_1.IpAddressType.IPV4;
+        if (props.clientRoutingPolicy) {
+            this.setAttribute("dns_record.client_routing_policy", props.clientRoutingPolicy);
+        }
+        if (props.zonalShift !== undefined) {
+            this.setAttribute("zonal_shift.config.enabled", props.zonalShift ? "true" : "false");
+        }
+        this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic =
+            props.enforceSecurityGroupInboundRulesOnPrivateLinkTraffic;
+    }
+    get enforceSecurityGroupInboundRulesOnPrivateLinkTraffic() {
+        if (this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic === undefined)
+            return undefined;
+        return this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic
+            ? "on"
+            : "off";
+    }
+    /**
+     * Add a listener to this load balancer
+     *
+     * @returns The newly created listener
+     */
+    addListener(id, props) {
+        // UDP listener with dual stack NLB requires prefix IPv6 source NAT to be enabled
+        if ((props.protocol === enums_1.LbProtocol.UDP ||
+            props.protocol === enums_1.LbProtocol.TCP_UDP) &&
+            (this.ipAddressType === enums_1.IpAddressType.DUAL_STACK ||
+                this.ipAddressType === enums_1.IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4) // &&
+        // this.enablePrefixForIpv6SourceNat !== true
+        ) {
+            throw new Error("To add a listener with UDP protocol to a dual stack NLB, missing in terraform see: https://github.com/hashicorp/terraform-provider-aws/issues/40379.");
+            // throw new Error(
+            //   "To add a listener with UDP protocol to a dual stack NLB, 'enablePrefixForIpv6SourceNat' must be set to true.",
+            // );
+        }
+        return new network_listener_1.NetworkListener(this, id, {
+            loadBalancer: this,
+            ...props,
+        });
+    }
+    /**
+     * Add a security group to this load balancer
+     */
+    addSecurityGroup(securityGroup) {
+        this.connections.addSecurityGroup(securityGroup);
+    }
+    /**
+     * Return the given named metric for this Network Load Balancer
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.custom`` instead
+     */
+    metric(metricName, props) {
+        return new cloudwatch.Metric({
+            namespace: "AWS/NetworkELB",
+            metricName,
+            dimensionsMap: { LoadBalancer: this.loadBalancerFullName },
+            ...props,
+        }).attachTo(this);
+    }
+    /**
+     * The total number of concurrent TCP flows (or connections) from clients to targets.
+     *
+     * This metric includes connections in the SYN_SENT and ESTABLISHED states.
+     * TCP connections are not terminated at the load balancer, so a client
+     * opening a TCP connection to a target counts as a single flow.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.activeFlowCount`` instead
+     */
+    metricActiveFlowCount(props) {
+        return this.metrics.activeFlowCount(props);
+    }
+    /**
+     * The number of load balancer capacity units (LCU) used by your load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.activeFlowCount`` instead
+     */
+    metricConsumedLCUs(props) {
+        return this.metrics.consumedLCUs(props);
+    }
+    /**
+     * The number of targets that are considered healthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated use ``NetworkTargetGroup.metricHealthyHostCount`` instead
+     */
+    metricHealthyHostCount(props) {
+        return this.metric("HealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    /**
+     * The number of targets that are considered unhealthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated use ``NetworkTargetGroup.metricUnHealthyHostCount`` instead
+     */
+    metricUnHealthyHostCount(props) {
+        return this.metric("UnHealthyHostCount", {
+            statistic: "Average",
+            ...props,
+        });
+    }
+    /**
+     * The total number of new TCP flows (or connections) established from clients to targets in the time period.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.newFlowCount`` instead
+     */
+    metricNewFlowCount(props) {
+        return this.metrics.newFlowCount(props);
+    }
+    /**
+     * The total number of bytes processed by the load balancer, including TCP/IP headers.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.processedBytes`` instead
+     */
+    metricProcessedBytes(props) {
+        return this.metrics.processedBytes(props);
+    }
+    /**
+     * The total number of reset (RST) packets sent from a client to a target.
+     *
+     * These resets are generated by the client and forwarded by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.tcpClientResetCount`` instead
+     */
+    metricTcpClientResetCount(props) {
+        return this.metrics.tcpClientResetCount(props);
+    }
+    /**
+     * The total number of reset (RST) packets generated by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.tcpElbResetCount`` instead
+     */
+    metricTcpElbResetCount(props) {
+        return this.metrics.tcpElbResetCount(props);
+    }
+    /**
+     * The total number of reset (RST) packets sent from a target to a client.
+     *
+     * These resets are generated by the target and forwarded by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.tcpTargetResetCount`` instead
+     */
+    metricTcpTargetResetCount(props) {
+        return this.metrics.tcpTargetResetCount(props);
+    }
+}
+exports.NetworkLoadBalancer = NetworkLoadBalancer;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkLoadBalancer[_a] = { fqn: "terraconstructs.aws.compute.NetworkLoadBalancer", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-load-balancer.js","sourceRoot":"","sources":["../../../../src/aws/compute/nlb/network-load-balancer.ts"],"names":[],"mappings":";;;;;AAAA,gIAAgI;AAEhI,sDAAgD;AAChD,iCAA6B;AAE7B,yDAA+E;AAC/E,uDAA0E;AAC1E,+CAA+C;AAC/C,gDAA2D;AAC3D,WAAW;AACX,sBAAsB;AACtB,kCAAkC;AAClC,2CAA2C;AAC3C,wHAAuF;AACvF,wEAMyC;AACzC,8CAA+D;AAC/D,4CAA8D;AAC9D,sDAAkE;AAQlE;;;;GAIG;AACH,IAAY,mBAaX;AAbD,WAAY,mBAAmB;IAC7B;;OAEG;IACH,gFAAyD,CAAA;IACzD;;OAEG;IACH,gGAAyE,CAAA;IACzE;;OAEG;IACH,sEAA+C,CAAA;AACjD,CAAC,EAbW,mBAAmB,mCAAnB,mBAAmB,QAa9B;AAyGD;;GAEG;AACH,MAAM,0BAA0B;IAI9B,YAAY,KAAgB,EAAE,oBAA4B;QACxD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,oBAAoB,GAAG,oBAAoB,CAAC;IACnD,CAAC;IAEM,MAAM,CACX,UAAkB,EAClB,KAAgC;QAEhC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;YAC3B,SAAS,EAAE,gBAAgB;YAC3B,UAAU;YACV,aAAa,EAAE,EAAE,YAAY,EAAE,IAAI,CAAC,oBAAoB,EAAE;YAC1D,GAAG,KAAK;SACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAEM,eAAe,CAAC,KAAgC;QACrD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;IAC5E,CAAC;IAEM,YAAY,CAAC,KAAgC;QAClD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,mBAAmB,EAAE;YAC9D,SAAS,EAAE,KAAK;YAChB,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAEM,YAAY,CAAC,KAAgC;QAClD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;IAEM,cAAc,CAAC,KAAgC;QACpD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;IACvE,CAAC;IAEM,mBAAmB,CAAC,KAAgC;QACzD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;IAC5E,CAAC;IACM,gBAAgB,CAAC,KAAgC;QACtD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;IACzE,CAAC;IACM,mBAAmB,CAAC,KAAgC;QACzD,OAAO,IAAI,CAAC,YAAY,CAAC,mEAAiB,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;IAC5E,CAAC;IAEO,YAAY,CAClB,EAA8D,EAC9D,KAAgC;QAEhC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;YAC3B,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAClD,GAAG,KAAK;SACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;CACF;AAED;;;;GAIG;AACH,MAAa,mBACX,SAAQ,qCAAgB;IAGxB,gCAAgC;IAChC,MAAM;IACN,yCAAyC;IACzC,MAAM;IACN,4BAA4B;IAC5B,sBAAsB;IACtB,gBAAgB;IAChB,+CAA+C;IAC/C,4BAA4B;IAC5B,kEAAkE;IAClE,4BAA4B;IAC5B,kDAAkD;IAClD,QAAQ;IAER,8DAA8D;IAC9D,IAAI;IAEG,MAAM,CAAC,iCAAiC,CAC7C,KAAgB,EAChB,EAAU,EACV,KAAoC;QAEpC,MAAM,MAAO,SAAQ,gCAAgB;YAsBnC,YAAY,KAAwB;gBAClC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;gBAtBV,gBAAW,GAAgB,IAAI,yBAAW,CAAC;oBACzD,cAAc,EAAE,KAAK,CAAC,0BAA0B,EAAE,GAAG,CACnD,CAAC,eAAe,EAAE,KAAK,EAAE,EAAE,CACzB,8BAAa,CAAC,mBAAmB,CAC/B,IAAI,EACJ,iBAAiB,KAAK,EAAE,EACxB,eAAe,CAChB,CACJ;iBACF,CAAC,CAAC;gBACa,oBAAe,GAAG,KAAK,CAAC,eAAe,CAAC;gBACxC,QAAG,GAAU,KAAK,CAAC,GAAG,CAAC;gBACvB,YAAO,GACrB,IAAI,0BAA0B,CAC5B,IAAI,EACJ,IAAA,gCAAyB,EAAC,KAAK,CAAC,eAAe,CAAC,CACjD,CAAC;gBACY,mBAAc,GAC5B,KAAK,CAAC,0BAA0B,CAAC;gBAKjC,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAS,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE;oBACxD,GAAG,EAAE,KAAK,CAAC,eAAe;iBAC3B,CAAC,CAAC;YACL,CAAC;YAEM,WAAW,CAChB,GAAW,EACX,KAA+B;gBAE/B,OAAO,IAAI,kCAAe,CAAC,IAAI,EAAE,GAAG,EAAE;oBACpC,YAAY,EAAE,IAAI;oBAClB,GAAG,KAAK;iBACT,CAAC,CAAC;YACL,CAAC;YAED,IAAW,iCAAiC;gBAC1C,IAAI,KAAK,CAAC,iCAAiC,EAAE,CAAC;oBAC5C,OAAO,KAAK,CAAC,iCAAiC,CAAC;gBACjD,CAAC;gBACD,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBAC5B,sCAAsC;gBACtC,mBAAmB;gBACnB,sIAAsI;gBACtI,KAAK;YACP,CAAC;YAED,IAAW,mBAAmB;gBAC5B,IAAI,KAAK,CAAC,mBAAmB,EAAE,CAAC;oBAC9B,OAAO,KAAK,CAAC,mBAAmB,CAAC;gBACnC,CAAC;gBACD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAC7B,sCAAsC;gBACtC,mBAAmB;gBACnB,wHAAwH;gBACxH,KAAK;YACP,CAAC;YAED,IAAW,qBAAqB;gBAC9B,OAAO;oBACL,iCAAiC,EAC/B,IAAI,CAAC,iCAAiC;oBACxC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;iBAC9C,CAAC;YACJ,CAAC;YACD,IAAW,OAAO;gBAChB,OAAO,IAAI,CAAC,qBAAqB,CAAC;YACpC,CAAC;SACF;QAED,OAAO,IAAI,MAAM,CAAC,EAAE,kBAAkB,EAAE,KAAK,CAAC,eAAe,EAAE,CAAC,CAAC;IACnE,CAAC;IAOD,gCAAgC;IAChC,mEAAmE;IACnE,kDAAkD;IAElD;;;;;OAKG;IACH,IAAW,cAAc;QACvB,OAAO,IAAI,CAAC,+BAA+B;YACzC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM;YACtC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,eAAe,CAAC;YACjE,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA+B;QACvE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE;YACtB,gBAAgB,EAAE,SAAS;YAC3B,cAAc,EAAE,YAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACtE,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,oDAAoD,EAAE,YAAI,CAAC,WAAW,CAAC;gBACrE,OAAO,EAAE,GAAG,EAAE,CACZ,IAAI,CAAC,oDAAoD;aAC5D,CAAC;YACF,gCAAgC;YAChC,mEAAmE;YACnE,gCAAgC;YAChC,gDAAgD;YAChD,aAAa;YACb,qDAAqD;YACrD,gBAAgB;YAChB,qBAAqB;SACtB,CAAC,CAAC;QAEH,0EAA0E;QAC1E,IAAI,CAAC,OAAO,GAAG,IAAI,0BAA0B,CAC3C,IAAI,EACJ,IAAI,CAAC,oBAAoB,CAC1B,CAAC;QACF,IAAI,CAAC,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;QAC9D,IAAI,CAAC,WAAW,GAAG,IAAI,yBAAW,CAAC;YACjC,cAAc,EAAE,KAAK,CAAC,cAAc;SACrC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,IAAI,qBAAa,CAAC,IAAI,CAAC;QAC/D,IAAI,KAAK,CAAC,mBAAmB,EAAE,CAAC;YAC9B,IAAI,CAAC,YAAY,CACf,kCAAkC,EAClC,KAAK,CAAC,mBAAmB,CAC1B,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,YAAY,CACf,4BAA4B,EAC5B,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CACpC,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,qDAAqD;YACxD,KAAK,CAAC,oDAAoD,CAAC;IAC/D,CAAC;IAED,IAAW,oDAAoD;QAG7D,IACE,IAAI,CAAC,qDAAqD,KAAK,SAAS;YAExE,OAAO,SAAS,CAAC;QACnB,OAAO,IAAI,CAAC,qDAAqD;YAC/D,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,KAAK,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACI,WAAW,CAChB,EAAU,EACV,KAA+B;QAE/B,iFAAiF;QACjF,IACE,CAAC,KAAK,CAAC,QAAQ,KAAK,kBAAU,CAAC,GAAG;YAChC,KAAK,CAAC,QAAQ,KAAK,kBAAU,CAAC,OAAO,CAAC;YACxC,CAAC,IAAI,CAAC,aAAa,KAAK,qBAAa,CAAC,UAAU;gBAC9C,IAAI,CAAC,aAAa,KAAK,qBAAa,CAAC,8BAA8B,CAAC,CAAC,KAAK;QAC5E,6CAA6C;UAC7C,CAAC;YACD,MAAM,IAAI,KAAK,CACb,sJAAsJ,CACvJ,CAAC;YACF,mBAAmB;YACnB,oHAAoH;YACpH,KAAK;QACP,CAAC;QACD,OAAO,IAAI,kCAAe,CAAC,IAAI,EAAE,EAAE,EAAE;YACnC,YAAY,EAAE,IAAI;YAClB,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,gBAAgB,CAAC,aAA6B;QACnD,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;IACnD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CACX,UAAkB,EAClB,KAAgC;QAEhC,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC;YAC3B,SAAS,EAAE,gBAAgB;YAC3B,UAAU;YACV,aAAa,EAAE,EAAE,YAAY,EAAE,IAAI,CAAC,oBAAoB,EAAE;YAC1D,GAAG,KAAK;SACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IAED;;;;;;;;;OASG;IACI,qBAAqB,CAAC,KAAgC;QAC3D,OAAO,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACI,kBAAkB,CAAC,KAAgC;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACI,sBAAsB,CAAC,KAAgC;QAC5D,OAAO,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE;YACrC,SAAS,EAAE,SAAS;YACpB,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,wBAAwB,CAAC,KAAgC;QAC9D,OAAO,IAAI,CAAC,MAAM,CAAC,oBAAoB,EAAE;YACvC,SAAS,EAAE,SAAS;YACpB,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,kBAAkB,CAAC,KAAgC;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACI,oBAAoB,CAAC,KAAgC;QAC1D,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;OAOG;IACI,yBAAyB,CAAC,KAAgC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACI,sBAAsB,CAAC,KAAgC;QAC5D,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACI,yBAAyB,CAAC,KAAgC;QAC/D,OAAO,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;;AAlVH,kDAmVC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/nlb/network-load-balancer.ts\n\nimport { dataAwsLb } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { BaseNetworkListenerProps, NetworkListener } from \"./network-listener\";\nimport { AwsConstructBase, AwsConstructProps } from \"../../aws-construct\";\nimport * as cloudwatch from \"../../cloudwatch\";\nimport { Connections, IConnectable } from \"../connections\";\n// import {\n//   LoadBalancerType,\n//   LoadBalancerListenerProtocol,\n// } from \"../lb-shared/grid-lookup-types\";\nimport { NetworkELBMetrics } from \"../elasticloadbalancingv2-canned-metrics.generated\";\nimport {\n  BaseLoadBalancer,\n  BaseLoadBalancerLookupOptions,\n  BaseLoadBalancerProps,\n  ILoadBalancerV2,\n  LoadBalancerV2Outputs,\n} from \"../lb-shared/base-load-balancer\";\nimport { IpAddressType, LbProtocol } from \"../lb-shared/enums\";\nimport { parseLoadBalancerFullName } from \"../lb-shared/util\";\nimport { ISecurityGroup, SecurityGroup } from \"../security-group\";\nimport {\n  IVpc,\n  // TODO: Add Grid Lookup support\n  // Vpc,\n} from \"../vpc\";\nimport { IVpcEndpointServiceLoadBalancer } from \"../vpc-endpoint-service\";\n\n/**\n * Indicates how traffic is distributed among the load balancer Availability Zones.\n *\n * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#zonal-dns-affinity\n */\nexport enum ClientRoutingPolicy {\n  /**\n   * 100 percent zonal affinity\n   */\n  AVAILABILITY_ZONE_AFFINITY = \"availability_zone_affinity\",\n  /**\n   * 85 percent zonal affinity\n   */\n  PARTIAL_AVAILABILITY_ZONE_AFFINITY = \"partial_availability_zone_affinity\",\n  /**\n   * No zonal affinity\n   */\n  ANY_AVAILABILITY_ZONE = \"any_availability_zone\",\n}\n\n/**\n * Properties for a network load balancer\n */\nexport interface NetworkLoadBalancerProps extends BaseLoadBalancerProps {\n  /**\n   * Security groups to associate with this load balancer\n   *\n   * @default - No security groups associated with the load balancer.\n   */\n  readonly securityGroups?: ISecurityGroup[];\n\n  /**\n   * The type of IP addresses to use\n   *\n   * If you want to add a UDP or TCP_UDP listener to the load balancer,\n   * you must choose IPv4.\n   *\n   * @default IpAddressType.IPV4\n   */\n  readonly ipAddressType?: IpAddressType;\n\n  /**\n   * The AZ affinity routing policy\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#zonal-dns-affinity\n   *\n   * @default - AZ affinity is disabled.\n   */\n  readonly clientRoutingPolicy?: ClientRoutingPolicy;\n\n  /**\n   * Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink.\n   *\n   * @default true\n   */\n  readonly enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: boolean;\n\n  /**\n   * Indicates whether zonal shift is enabled\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/zonal-shift.html\n   *\n   * @default false\n   */\n  readonly zonalShift?: boolean;\n\n  // TODO: Missing in provider-aws\n  // https://github.com/hashicorp/terraform-provider-aws/issues/40379\n  // /**\n  //  * Indicates whether to use an IPv6 prefix from each subnet for source NAT.\n  //  *\n  //  * The IP address type must be IpAddressType.DUALSTACK.\n  //  *\n  //  * @default undefined - NLB default behavior is false\n  //  */\n  // readonly enablePrefixForIpv6SourceNat?: boolean;\n}\n\n/**\n * Properties to reference an existing load balancer\n */\nexport interface NetworkLoadBalancerAttributes {\n  /**\n   * ARN of the load balancer\n   */\n  readonly loadBalancerArn: string;\n\n  /**\n   * The canonical hosted zone ID of this load balancer\n   *\n   * @default - Token via data source from loadBalancerArn.\n   */\n  readonly loadBalancerCanonicalHostedZoneId?: string;\n\n  /**\n   * The DNS name of this load balancer\n   *\n   * @default - Token via data source from loadBalancerArn.\n   */\n  readonly loadBalancerDnsName?: string;\n\n  /**\n   * The VPC to associate with the load balancer.\n   *\n   * @default - When not provided, listeners cannot be created on imported load\n   * balancers.\n   */\n  readonly vpc?: IVpc;\n\n  /**\n   * Security groups to associate with this load balancer\n   *\n   * @default - No security groups associated with the load balancer.\n   */\n  readonly loadBalancerSecurityGroups?: string[];\n}\n\n/**\n * Options for looking up an NetworkLoadBalancer\n */\nexport interface NetworkLoadBalancerLookupOptions\n  extends BaseLoadBalancerLookupOptions {}\n\n/**\n * The metrics for a network load balancer.\n */\nclass NetworkLoadBalancerMetrics implements INetworkLoadBalancerMetrics {\n  private readonly loadBalancerFullName: string;\n  private readonly scope: Construct;\n\n  constructor(scope: Construct, loadBalancerFullName: string) {\n    this.scope = scope;\n    this.loadBalancerFullName = loadBalancerFullName;\n  }\n\n  public custom(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/NetworkELB\",\n      metricName,\n      dimensionsMap: { LoadBalancer: this.loadBalancerFullName },\n      ...props,\n    }).attachTo(this.scope);\n  }\n\n  public activeFlowCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.activeFlowCountAverage, props);\n  }\n\n  public consumedLCUs(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.consumedLcUsAverage, {\n      statistic: \"Sum\",\n      ...props,\n    });\n  }\n\n  public newFlowCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.newFlowCountSum, props);\n  }\n\n  public processedBytes(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.processedBytesSum, props);\n  }\n\n  public tcpClientResetCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.tcpClientResetCountSum, props);\n  }\n  public tcpElbResetCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.tcpElbResetCountSum, props);\n  }\n  public tcpTargetResetCount(props?: cloudwatch.MetricOptions) {\n    return this.cannedMetric(NetworkELBMetrics.tcpTargetResetCountSum, props);\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 * Define a new network load balancer\n *\n * @resource AWS::ElasticLoadBalancingV2::LoadBalancer\n */\nexport class NetworkLoadBalancer\n  extends BaseLoadBalancer\n  implements INetworkLoadBalancer\n{\n  // TODO: Add Grid lookup support\n  // /**\n  //  * Looks up the network load balancer.\n  //  */\n  // public static fromLookup(\n  //   scope: Construct,\n  //   id: string,\n  //   options: NetworkLoadBalancerLookupOptions,\n  // ): INetworkLoadBalancer {\n  //   const props = BaseLoadBalancer._queryContextProvider(scope, {\n  //     userOptions: options,\n  //     loadBalancerType: LoadBalancerType.NETWORK,\n  //   });\n\n  //   return new LookedUpNetworkLoadBalancer(scope, id, props);\n  // }\n\n  public static fromNetworkLoadBalancerAttributes(\n    scope: Construct,\n    id: string,\n    attrs: NetworkLoadBalancerAttributes,\n  ): INetworkLoadBalancer {\n    class Import extends AwsConstructBase implements INetworkLoadBalancer {\n      public readonly connections: Connections = new Connections({\n        securityGroups: attrs.loadBalancerSecurityGroups?.map(\n          (securityGroupId, index) =>\n            SecurityGroup.fromSecurityGroupId(\n              this,\n              `SecurityGroup-${index}`,\n              securityGroupId,\n            ),\n        ),\n      });\n      public readonly loadBalancerArn = attrs.loadBalancerArn;\n      public readonly vpc?: IVpc = attrs.vpc;\n      public readonly metrics: INetworkLoadBalancerMetrics =\n        new NetworkLoadBalancerMetrics(\n          this,\n          parseLoadBalancerFullName(attrs.loadBalancerArn),\n        );\n      public readonly securityGroups?: string[] =\n        attrs.loadBalancerSecurityGroups;\n\n      public readonly resource: dataAwsLb.DataAwsLb;\n      constructor(props: AwsConstructProps) {\n        super(scope, id, props);\n        this.resource = new dataAwsLb.DataAwsLb(this, \"Resource\", {\n          arn: attrs.loadBalancerArn,\n        });\n      }\n\n      public addListener(\n        lid: string,\n        props: BaseNetworkListenerProps,\n      ): NetworkListener {\n        return new NetworkListener(this, lid, {\n          loadBalancer: this,\n          ...props,\n        });\n      }\n\n      public get loadBalancerCanonicalHostedZoneId(): string {\n        if (attrs.loadBalancerCanonicalHostedZoneId) {\n          return attrs.loadBalancerCanonicalHostedZoneId;\n        }\n        return this.resource.zoneId;\n        // // eslint-disable-next-line max-len\n        // throw new Error(\n        //   `'loadBalancerCanonicalHostedZoneId' was not provided when constructing Network Load Balancer ${this.node.path} from attributes`,\n        // );\n      }\n\n      public get loadBalancerDnsName(): string {\n        if (attrs.loadBalancerDnsName) {\n          return attrs.loadBalancerDnsName;\n        }\n        return this.resource.dnsName;\n        // // eslint-disable-next-line max-len\n        // throw new Error(\n        //   `'loadBalancerDnsName' was not provided when constructing Network Load Balancer ${this.node.path} from attributes`,\n        // );\n      }\n\n      public get loadBalancerV2Outputs(): LoadBalancerV2Outputs {\n        return {\n          loadBalancerCanonicalHostedZoneId:\n            this.loadBalancerCanonicalHostedZoneId,\n          loadBalancerDnsName: this.loadBalancerDnsName,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.loadBalancerV2Outputs;\n      }\n    }\n\n    return new Import({ environmentFromArn: attrs.loadBalancerArn });\n  }\n\n  public readonly metrics: INetworkLoadBalancerMetrics;\n  public readonly ipAddressType?: IpAddressType;\n  public readonly connections: Connections;\n  private readonly isSecurityGroupsPropertyDefined: boolean;\n  private readonly _enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: boolean;\n  // TODO: Missing in provider-aws\n  // https://github.com/hashicorp/terraform-provider-aws/issues/40379\n  // private enablePrefixForIpv6SourceNat?: boolean;\n\n  /**\n   * After the implementation of `IConnectable` (see https://github.com/aws/aws-cdk/pull/28494), the default\n   * value for `securityGroups` is set by the `Connections` constructor to an empty array.\n   * To keep backward compatibility (`securityGroups` is `undefined` if the related property is not specified)\n   * a getter has been added.\n   */\n  public get securityGroups(): string[] | undefined {\n    return this.isSecurityGroupsPropertyDefined ||\n      this.connections.securityGroups.length\n      ? this.connections.securityGroups.map((sg) => sg.securityGroupId)\n      : undefined;\n  }\n\n  constructor(scope: Construct, id: string, props: NetworkLoadBalancerProps) {\n    super(scope, id, props, {\n      loadBalancerType: \"network\",\n      securityGroups: Lazy.listValue({ produce: () => this.securityGroups }),\n      ipAddressType: props.ipAddressType,\n      enforceSecurityGroupInboundRulesOnPrivateLinkTraffic: Lazy.stringValue({\n        produce: () =>\n          this.enforceSecurityGroupInboundRulesOnPrivateLinkTraffic,\n      }),\n      // TODO: Missing in provider-aws\n      // https://github.com/hashicorp/terraform-provider-aws/issues/40379\n      // enablePrefixForIpv6SourceNat:\n      //   props.enablePrefixForIpv6SourceNat === true\n      //     ? \"on\"\n      //     : props.enablePrefixForIpv6SourceNat === false\n      //       ? \"off\"\n      //       : undefined,\n    });\n\n    // this.enablePrefixForIpv6SourceNat = props.enablePrefixForIpv6SourceNat;\n    this.metrics = new NetworkLoadBalancerMetrics(\n      this,\n      this.loadBalancerFullName,\n    );\n    this.isSecurityGroupsPropertyDefined = !!props.securityGroups;\n    this.connections = new Connections({\n      securityGroups: props.securityGroups,\n    });\n    this.ipAddressType = props.ipAddressType ?? IpAddressType.IPV4;\n    if (props.clientRoutingPolicy) {\n      this.setAttribute(\n        \"dns_record.client_routing_policy\",\n        props.clientRoutingPolicy,\n      );\n    }\n    if (props.zonalShift !== undefined) {\n      this.setAttribute(\n        \"zonal_shift.config.enabled\",\n        props.zonalShift ? \"true\" : \"false\",\n      );\n    }\n    this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic =\n      props.enforceSecurityGroupInboundRulesOnPrivateLinkTraffic;\n  }\n\n  public get enforceSecurityGroupInboundRulesOnPrivateLinkTraffic():\n    | string\n    | undefined {\n    if (\n      this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic === undefined\n    )\n      return undefined;\n    return this._enforceSecurityGroupInboundRulesOnPrivateLinkTraffic\n      ? \"on\"\n      : \"off\";\n  }\n\n  /**\n   * Add a listener to this load balancer\n   *\n   * @returns The newly created listener\n   */\n  public addListener(\n    id: string,\n    props: BaseNetworkListenerProps,\n  ): NetworkListener {\n    // UDP listener with dual stack NLB requires prefix IPv6 source NAT to be enabled\n    if (\n      (props.protocol === LbProtocol.UDP ||\n        props.protocol === LbProtocol.TCP_UDP) &&\n      (this.ipAddressType === IpAddressType.DUAL_STACK ||\n        this.ipAddressType === IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4) // &&\n      // this.enablePrefixForIpv6SourceNat !== true\n    ) {\n      throw new Error(\n        \"To add a listener with UDP protocol to a dual stack NLB, missing in terraform see: https://github.com/hashicorp/terraform-provider-aws/issues/40379.\",\n      );\n      // throw new Error(\n      //   \"To add a listener with UDP protocol to a dual stack NLB, 'enablePrefixForIpv6SourceNat' must be set to true.\",\n      // );\n    }\n    return new NetworkListener(this, id, {\n      loadBalancer: this,\n      ...props,\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 Network Load Balancer\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.custom`` instead\n   */\n  public metric(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: \"AWS/NetworkELB\",\n      metricName,\n      dimensionsMap: { LoadBalancer: this.loadBalancerFullName },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * The total number of concurrent TCP flows (or connections) from clients to targets.\n   *\n   * This metric includes connections in the SYN_SENT and ESTABLISHED states.\n   * TCP connections are not terminated at the load balancer, so a client\n   * opening a TCP connection to a target counts as a single flow.\n   *\n   * @default Average over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.activeFlowCount`` instead\n   */\n  public metricActiveFlowCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.activeFlowCount(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 ``NetworkLoadBalancer.metrics.activeFlowCount`` instead\n   */\n  public metricConsumedLCUs(props?: cloudwatch.MetricOptions) {\n    return this.metrics.consumedLCUs(props);\n  }\n\n  /**\n   * The number of targets that are considered healthy.\n   *\n   * @default Average over 5 minutes\n   * @deprecated use ``NetworkTargetGroup.metricHealthyHostCount`` instead\n   */\n  public metricHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metric(\"HealthyHostCount\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  /**\n   * The number of targets that are considered unhealthy.\n   *\n   * @default Average over 5 minutes\n   * @deprecated use ``NetworkTargetGroup.metricUnHealthyHostCount`` instead\n   */\n  public metricUnHealthyHostCount(props?: cloudwatch.MetricOptions) {\n    return this.metric(\"UnHealthyHostCount\", {\n      statistic: \"Average\",\n      ...props,\n    });\n  }\n\n  /**\n   * The total number of new TCP flows (or connections) established from clients to targets in the time period.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.newFlowCount`` instead\n   */\n  public metricNewFlowCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.newFlowCount(props);\n  }\n\n  /**\n   * The total number of bytes processed by the load balancer, including TCP/IP headers.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.processedBytes`` instead\n   */\n  public metricProcessedBytes(props?: cloudwatch.MetricOptions) {\n    return this.metrics.processedBytes(props);\n  }\n\n  /**\n   * The total number of reset (RST) packets sent from a client to a target.\n   *\n   * These resets are generated by the client and forwarded by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.tcpClientResetCount`` instead\n   */\n  public metricTcpClientResetCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.tcpClientResetCount(props);\n  }\n\n  /**\n   * The total number of reset (RST) packets generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.tcpElbResetCount`` instead\n   */\n  public metricTcpElbResetCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.tcpElbResetCount(props);\n  }\n\n  /**\n   * The total number of reset (RST) packets sent from a target to a client.\n   *\n   * These resets are generated by the target and forwarded by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   * @deprecated Use ``NetworkLoadBalancer.metrics.tcpTargetResetCount`` instead\n   */\n  public metricTcpTargetResetCount(props?: cloudwatch.MetricOptions) {\n    return this.metrics.tcpTargetResetCount(props);\n  }\n}\n\n/**\n * Contains all metrics for a Network Load Balancer.\n */\nexport interface INetworkLoadBalancerMetrics {\n  /**\n   * Return the given named metric for this Network 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 flows (or connections) from clients to targets.\n   *\n   * This metric includes connections in the SYN_SENT and ESTABLISHED states.\n   * TCP connections are not terminated at the load balancer, so a client\n   * opening a TCP connection to a target counts as a single flow.\n   *\n   * @default Average over 5 minutes\n   */\n  activeFlowCount(props?: cloudwatch.MetricOptions): 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 total number of new TCP flows (or connections) established from clients to targets in the time period.\n   *\n   * @default Sum over 5 minutes\n   */\n  newFlowCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of bytes processed by the load balancer, including TCP/IP headers.\n   *\n   * @default Sum over 5 minutes\n   */\n  processedBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of reset (RST) packets sent from a client to a target.\n   *\n   * These resets are generated by the client and forwarded by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  tcpClientResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of reset (RST) packets generated by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  tcpElbResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * The total number of reset (RST) packets sent from a target to a client.\n   *\n   * These resets are generated by the target and forwarded by the load balancer.\n   *\n   * @default Sum over 5 minutes\n   */\n  tcpTargetResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * A network load balancer\n */\nexport interface INetworkLoadBalancer\n  extends ILoadBalancerV2,\n    IVpcEndpointServiceLoadBalancer,\n    IConnectable {\n  /**\n   * The VPC this load balancer has been created in (if available)\n   */\n  readonly vpc?: IVpc;\n\n  /**\n   * All metrics available for this load balancer\n   */\n  readonly metrics: INetworkLoadBalancerMetrics;\n\n  /**\n   * Security groups associated with this load balancer\n   */\n  readonly securityGroups?: string[];\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 to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink\n   *\n   * @default on\n   */\n  readonly enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: string;\n\n  /**\n   * Add a listener to this load balancer\n   *\n   * @returns The newly created listener\n   */\n  addListener(id: string, props: BaseNetworkListenerProps): NetworkListener;\n}\n\n// TODO: Add Grid Lookup support\n// class LookedUpNetworkLoadBalancer\n//   extends AwsConstructBase\n//   implements INetworkLoadBalancer\n// {\n//   public readonly loadBalancerCanonicalHostedZoneId: string;\n//   public readonly loadBalancerDnsName: string;\n//   public readonly loadBalancerArn: string;\n//   public readonly vpc?: IVpc;\n//   public readonly metrics: INetworkLoadBalancerMetrics;\n//   public readonly securityGroups?: string[];\n//   public readonly ipAddressType?: IpAddressType;\n//   public readonly connections: Connections;\n\n//   constructor(\n//     scope: Construct,\n//     id: string,\n//     props: cxapi.LoadBalancerContextResponse,\n//   ) {\n//     super(scope, id, { environmentFromArn: props.loadBalancerArn });\n\n//     this.loadBalancerArn = props.loadBalancerArn;\n//     this.loadBalancerCanonicalHostedZoneId =\n//       props.loadBalancerCanonicalHostedZoneId;\n//     this.loadBalancerDnsName = props.loadBalancerDnsName;\n//     this.metrics = new NetworkLoadBalancerMetrics(\n//       this,\n//       parseLoadBalancerFullName(props.loadBalancerArn),\n//     );\n//     this.securityGroups = props.securityGroupIds;\n//     this.connections = new Connections({\n//       securityGroups: props.securityGroupIds.map((securityGroupId, index) =>\n//         SecurityGroup.fromLookupById(\n//           this,\n//           `SecurityGroup-${index}`,\n//           securityGroupId,\n//         ),\n//       ),\n//     });\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//     }\n\n//     this.vpc = Vpc.fromLookup(this, \"Vpc\", {\n//       vpcId: props.vpcId,\n//     });\n//   }\n\n//   public addListener(\n//     lid: string,\n//     props: BaseNetworkListenerProps,\n//   ): NetworkListener {\n//     return new NetworkListener(this, lid, {\n//       loadBalancer: this,\n//       ...props,\n//     });\n//   }\n// }\n"]}

package/lib/aws/compute/nlb/network-target-group.d.ts

@@ -0,0 +1,153 @@
+import { Construct } from "constructs";
+import { INetworkListener } from "./network-listener";
+import * as cloudwatch from "../../cloudwatch";
+import { BaseTargetGroupProps, ITargetGroup, LoadBalancerTargetProps, TargetGroupAttributes, TargetGroupBase, TargetGroupImportProps } from "../lb-shared/base-target-group";
+import { LbProtocol } from "../lb-shared/enums";
+/**
+ * Properties for a new Network Target Group
+ */
+export interface NetworkTargetGroupProps extends BaseTargetGroupProps {
+    /**
+     * The port on which the target receives traffic.
+     */
+    readonly port: number;
+    /**
+     * Protocol for target group, expects TCP, TLS, UDP, or TCP_UDP.
+     *
+     * @default - TCP
+     */
+    readonly protocol?: LbProtocol;
+    /**
+     * Indicates whether Proxy Protocol version 2 is enabled.
+     *
+     * @default false
+     */
+    readonly proxyProtocolV2?: boolean;
+    /**
+     * Indicates whether client IP preservation is enabled.
+     *
+     * @default false if the target group type is IP address and the
+     * target group protocol is TCP or TLS. Otherwise, true.
+     */
+    readonly preserveClientIp?: boolean;
+    /**
+     * The targets to add to this target group.
+     *
+     * Can be `Instance`, `IPAddress`, or any self-registering load balancing
+     * target. If you use either `Instance` or `IPAddress` as targets, all
+     * target must be of the same type.
+     *
+     * @default - No targets.
+     */
+    readonly targets?: INetworkLoadBalancerTarget[];
+    /**
+     *
+     * Indicates whether the load balancer terminates connections at
+     * the end of the deregistration timeout.
+     *
+     * @default false
+     */
+    readonly connectionTermination?: boolean;
+}
+/**
+ * Contains all metrics for a Target Group of a Network Load Balancer.
+ */
+export interface INetworkTargetGroupMetrics {
+    /**
+     * Return the given named metric for this Network Target Group
+     *
+     * @default Average over 5 minutes
+     */
+    custom(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of targets that are considered healthy.
+     *
+     * @default Average over 5 minutes
+     */
+    healthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of targets that are considered unhealthy.
+     *
+     * @default Average over 5 minutes
+     */
+    unHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+}
+/**
+ * Define a Network Target Group
+ */
+export declare class NetworkTargetGroup extends TargetGroupBase implements INetworkTargetGroup {
+    /**
+     * Import an existing target group
+     */
+    static fromTargetGroupAttributes(scope: Construct, id: string, attrs: TargetGroupAttributes): INetworkTargetGroup;
+    /**
+     * Import an existing listener
+     *
+     * @deprecated Use `fromTargetGroupAttributes` instead
+     */
+    static import(scope: Construct, id: string, props: TargetGroupImportProps): INetworkTargetGroup;
+    private readonly listeners;
+    private _metrics?;
+    constructor(scope: Construct, id: string, props: NetworkTargetGroupProps);
+    get metrics(): INetworkTargetGroupMetrics;
+    /**
+     * Add a load balancing target to this target group
+     */
+    addTarget(...targets: INetworkLoadBalancerTarget[]): void;
+    /**
+     * Register a listener that is load balancing to this target group.
+     *
+     * Don't call this directly. It will be called by listeners.
+     */
+    registerListener(listener: INetworkListener): void;
+    /**
+     * The number of targets that are considered healthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead
+     */
+    metricHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of targets that are considered unhealthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkTargetGroup.metrics.healthyHostCount`` instead
+     */
+    metricUnHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Full name of first load balancer
+     */
+    get firstLoadBalancerFullName(): string;
+    protected validateTargetGroup(): string[];
+}
+/**
+ * A network target group
+ */
+export interface INetworkTargetGroup extends ITargetGroup {
+    /**
+     * All metrics available for this target group.
+     */
+    readonly metrics: INetworkTargetGroupMetrics;
+    /**
+     * Register a listener that is load balancing to this target group.
+     *
+     * Don't call this directly. It will be called by listeners.
+     */
+    registerListener(listener: INetworkListener): void;
+    /**
+     * Add a load balancing target to this target group
+     */
+    addTarget(...targets: INetworkLoadBalancerTarget[]): void;
+}
+/**
+ * Interface for constructs that can be targets of an network load balancer
+ */
+export interface INetworkLoadBalancerTarget {
+    /**
+     * Attach load-balanced target to a TargetGroup
+     *
+     * May return JSON to directly add to the [Targets] list, or return undefined
+     * if the target will register itself with the load balancer.
+     */
+    attachToNetworkTargetGroup(targetGroup: INetworkTargetGroup): LoadBalancerTargetProps;
+}