terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/nlb/network-listener.js

@@ -0,0 +1,217 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkListener = 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-listener.ts
+const cdktf_1 = require("cdktf");
+const network_listener_action_1 = require("./network-listener-action");
+const network_listener_certificate_1 = require("./network-listener-certificate");
+const network_target_group_1 = require("./network-target-group");
+const duration_1 = require("../../../duration");
+const aws_construct_1 = require("../../aws-construct");
+const base_listener_1 = require("../lb-shared/base-listener");
+const enums_1 = require("../lb-shared/enums");
+const util_1 = require("../lb-shared/util");
+/**
+ * Define a Network Listener
+ *
+ * @resource AWS::ElasticLoadBalancingV2::Listener
+ */
+class NetworkListener extends base_listener_1.BaseListener {
+    // TODO: Add Grid Lookup support
+    // /**
+    //  * Looks up a network listener
+    //  */
+    // public static fromLookup(
+    //   scope: Construct,
+    //   id: string,
+    //   options: NetworkListenerLookupOptions,
+    // ): INetworkListener {
+    //   let listenerProtocol: LoadBalancerListenerProtocol | undefined;
+    //   if (options.listenerProtocol) {
+    //     validateNetworkProtocol(options.listenerProtocol);
+    //     switch (options.listenerProtocol) {
+    //       case Protocol.TCP:
+    //         listenerProtocol = LoadBalancerListenerProtocol.TCP;
+    //         break;
+    //       case Protocol.UDP:
+    //         listenerProtocol = LoadBalancerListenerProtocol.UDP;
+    //         break;
+    //       case Protocol.TCP_UDP:
+    //         listenerProtocol = LoadBalancerListenerProtocol.TCP_UDP;
+    //         break;
+    //       case Protocol.TLS:
+    //         listenerProtocol = LoadBalancerListenerProtocol.TLS;
+    //         break;
+    //     }
+    //   }
+    //   const props = BaseListener._queryContextProvider(scope, {
+    //     userOptions: options,
+    //     listenerProtocol: listenerProtocol,
+    //     loadBalancerType: LoadBalancerType.NETWORK,
+    //   });
+    //   class LookedUp extends AwsConstructBase implements INetworkListener {
+    //     public listenerArn = props.listenerArn;
+    //   }
+    //   return new LookedUp(scope, id);
+    // }
+    /**
+     * Import an existing listener
+     */
+    static fromNetworkListenerArn(scope, id, networkListenerArn) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.listenerArn = networkListenerArn;
+                this.listenerOutputs = {
+                    listenerArn: networkListenerArn,
+                };
+                this.outputs = {
+                    listenerArn: networkListenerArn,
+                };
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        const certs = props.certificates || [];
+        const proto = props.protocol || (certs.length > 0 ? enums_1.LbProtocol.TLS : enums_1.LbProtocol.TCP);
+        (0, util_1.validateNetworkProtocol)(proto);
+        if (proto === enums_1.LbProtocol.TLS &&
+            certs.filter((v) => v != null).length === 0) {
+            throw new Error("When the protocol is set to TLS, you must specify certificates");
+        }
+        if (proto !== enums_1.LbProtocol.TLS && certs.length > 0) {
+            throw new Error("Protocol must be TLS when certificates have been specified");
+        }
+        if (proto !== enums_1.LbProtocol.TLS && props.alpnPolicy) {
+            throw new Error("Protocol must be TLS when alpnPolicy have been specified");
+        }
+        super(scope, id, {
+            loadBalancerArn: props.loadBalancer.loadBalancerArn,
+            protocol: proto,
+            port: props.port,
+            sslPolicy: props.sslPolicy,
+            certificateArn: cdktf_1.Lazy.stringValue({
+                produce: () => this.certificateArns.length > 0 ? this.certificateArns[0] : undefined,
+            }),
+            alpnPolicy: props.alpnPolicy ? props.alpnPolicy : undefined,
+        });
+        this.certificateArns = [];
+        this.loadBalancer = props.loadBalancer;
+        this.protocol = proto;
+        if (certs.length > 0) {
+            this.addCertificates("DefaultCertificates", certs);
+        }
+        if (props.defaultAction && props.defaultTargetGroups) {
+            throw new Error("Specify at most one of 'defaultAction' and 'defaultTargetGroups'");
+        }
+        if (props.defaultAction) {
+            this.setDefaultAction(props.defaultAction);
+        }
+        if (props.defaultTargetGroups) {
+            this.setDefaultAction(network_listener_action_1.NetworkListenerAction.forward(props.defaultTargetGroups));
+        }
+        if (props.tcpIdleTimeout !== undefined &&
+            !cdktf_1.Token.isUnresolved(props.tcpIdleTimeout)) {
+            if (props.tcpIdleTimeout.toMilliseconds() <
+                duration_1.Duration.seconds(1).toMilliseconds()) {
+                throw new Error(`\`tcpIdleTimeout\` must be between 60 and 6000 seconds, got ${props.tcpIdleTimeout.toMilliseconds()} milliseconds.`);
+            }
+            const tcpIdleTimeoutSeconds = props.tcpIdleTimeout.toSeconds();
+            if (proto === enums_1.LbProtocol.UDP) {
+                throw new Error("`tcpIdleTimeout` cannot be set when `protocol` is `Protocol.UDP`.");
+            }
+            if (tcpIdleTimeoutSeconds < 60 || tcpIdleTimeoutSeconds > 6000) {
+                throw new Error(`\`tcpIdleTimeout\` must be between 60 and 6000 seconds, got ${tcpIdleTimeoutSeconds} seconds.`);
+            }
+            this.setAttribute("tcp.idle_timeout.seconds", tcpIdleTimeoutSeconds.toString());
+        }
+    }
+    /**
+     * Add one or more certificates to this listener.
+     *
+     * After the first certificate, this creates NetworkListenerCertificates
+     * resources since cloudformation requires the certificates array on the
+     * listener resource to have a length of 1.
+     */
+    addCertificates(id, certificates) {
+        const additionalCerts = [...certificates];
+        if (this.certificateArns.length === 0 && additionalCerts.length > 0) {
+            const first = additionalCerts.splice(0, 1)[0];
+            this.certificateArns.push(first.certificateArn);
+        }
+        // Only one certificate can be specified per resource, even though
+        // `certificates` is of type Array
+        for (let i = 0; i < additionalCerts.length; i++) {
+            new network_listener_certificate_1.NetworkListenerCertificate(this, `${id}${i + 1}`, {
+                listener: this,
+                certificates: [additionalCerts[i]],
+            });
+        }
+    }
+    /**
+     * Load balance incoming requests to the given target groups.
+     *
+     * All target groups will be load balanced to with equal weight and without
+     * stickiness. For a more complex configuration than that, use `addAction()`.
+     */
+    addTargetGroups(_id, ...targetGroups) {
+        this.setDefaultAction(network_listener_action_1.NetworkListenerAction.forward(targetGroups));
+    }
+    /**
+     * Perform the given Action on incoming requests
+     *
+     * This allows full control of the default Action of the load balancer,
+     * including weighted forwarding. See the `NetworkListenerAction` class for
+     * all options.
+     */
+    addAction(_id, props) {
+        this.setDefaultAction(props.action);
+    }
+    /**
+     * Load balance incoming requests to the given load balancing targets.
+     *
+     * This method implicitly creates a NetworkTargetGroup for the targets
+     * involved, and a 'forward' action to route traffic to the given TargetGroup.
+     *
+     * If you want more control over the precise setup, create the TargetGroup
+     * and use `addAction` yourself.
+     *
+     * It's possible to add conditions to the targets added in this way. At least
+     * one set of targets must be added without conditions.
+     *
+     * @returns The newly created target group
+     */
+    addTargets(id, props) {
+        if (!this.loadBalancer.vpc) {
+            // eslint-disable-next-line max-len
+            throw new Error("Can only call addTargets() when using a constructed Load Balancer or imported Load Balancer with specified VPC; construct a new TargetGroup and use addTargetGroup");
+        }
+        const group = new network_target_group_1.NetworkTargetGroup(this, id + "Group", {
+            deregistrationDelay: props.deregistrationDelay,
+            healthCheck: props.healthCheck,
+            port: props.port,
+            protocol: props.protocol ?? this.protocol,
+            proxyProtocolV2: props.proxyProtocolV2,
+            preserveClientIp: props.preserveClientIp,
+            targetGroupName: props.targetGroupName,
+            targets: props.targets,
+            vpc: this.loadBalancer.vpc,
+        });
+        this.addTargetGroups(id, group);
+        return group;
+    }
+    /**
+     * Wrapper for _setDefaultAction which does a type-safe bind
+     */
+    setDefaultAction(action) {
+        action.bind(this, this);
+        this._setDefaultAction(action);
+    }
+}
+exports.NetworkListener = NetworkListener;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkListener[_a] = { fqn: "terraconstructs.aws.compute.NetworkListener", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-listener.js","sourceRoot":"","sources":["../../../../src/aws/compute/nlb/network-listener.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/nlb/network-listener.ts\n\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { NetworkListenerAction } from \"./network-listener-action\";\nimport { NetworkListenerCertificate } from \"./network-listener-certificate\";\nimport { INetworkLoadBalancer } from \"./network-load-balancer\";\nimport {\n  INetworkLoadBalancerTarget,\n  INetworkTargetGroup,\n  NetworkTargetGroup,\n} from \"./network-target-group\";\nimport { Duration } from \"../../../duration\";\nimport { AwsConstructBase } from \"../../aws-construct\";\nimport {\n  BaseListener,\n  BaseListenerLookupOptions,\n  IListener,\n} from \"../lb-shared/base-listener\";\nimport { HealthCheck } from \"../lb-shared/base-target-group\";\nimport { AlpnPolicy, LbProtocol, SslPolicy } from \"../lb-shared/enums\";\n// import {\n//   LoadBalancerType,\n//   LoadBalancerListenerProtocol,\n// } from \"../lb-shared/grid-lookup-types\";\nimport { IListenerCertificate } from \"../lb-shared/listener-certificate\";\nimport { validateNetworkProtocol } from \"../lb-shared/util\";\n\n/**\n * Basic properties for a Network Listener\n */\nexport interface BaseNetworkListenerProps {\n  /**\n   * The port on which the listener listens for requests.\n   */\n  readonly port: number;\n\n  /**\n   * Default target groups to load balance to\n   *\n   * All target groups will be load balanced to with equal weight and without\n   * stickiness. For a more complex configuration than that, use\n   * either `defaultAction` or `addAction()`.\n   *\n   * Cannot be specified together with `defaultAction`.\n   *\n   * @default - None.\n   */\n  readonly defaultTargetGroups?: INetworkTargetGroup[];\n\n  /**\n   * Default action to take for requests to this listener\n   *\n   * This allows full control of the default Action of the load balancer,\n   * including weighted forwarding. See the `NetworkListenerAction` class for\n   * all options.\n   *\n   * Cannot be specified together with `defaultTargetGroups`.\n   *\n   * @default - None.\n   */\n  readonly defaultAction?: NetworkListenerAction;\n\n  /**\n   * Protocol for listener, expects TCP, TLS, UDP, or TCP_UDP.\n   *\n   * @default - TLS if certificates are provided. TCP otherwise.\n   */\n  readonly protocol?: LbProtocol;\n\n  /**\n   * Certificate list of ACM cert ARNs. You must provide exactly one certificate if the listener protocol is HTTPS or TLS.\n   *\n   * @default - No certificates.\n   */\n  readonly certificates?: IListenerCertificate[];\n\n  /**\n   * SSL Policy\n   *\n   * @default - Current predefined security policy.\n   */\n  readonly sslPolicy?: SslPolicy;\n\n  /**\n   * Application-Layer Protocol Negotiation (ALPN) is a TLS extension that is sent on the initial TLS handshake hello messages.\n   * ALPN enables the application layer to negotiate which protocols should be used over a secure connection, such as HTTP/1 and HTTP/2.\n   *\n   * Can only be specified together with Protocol TLS.\n   *\n   * @default - None\n   */\n  readonly alpnPolicy?: AlpnPolicy;\n\n  /**\n   * The load balancer TCP idle timeout.\n   *\n   * @default Duration.seconds(350)\n   */\n  readonly tcpIdleTimeout?: Duration;\n}\n\n/**\n * Properties for adding a certificate to a listener\n *\n * This interface exists for backwards compatibility.\n *\n * @deprecated Use IListenerCertificate instead\n */\nexport interface INetworkListenerCertificateProps\n  extends IListenerCertificate {}\n\n/**\n * Properties for a Network Listener attached to a Load Balancer\n */\nexport interface NetworkListenerProps extends BaseNetworkListenerProps {\n  /**\n   * The load balancer to attach this listener to\n   */\n  readonly loadBalancer: INetworkLoadBalancer;\n}\n\n/**\n * Options for looking up a network listener.\n */\nexport interface NetworkListenerLookupOptions\n  extends BaseListenerLookupOptions {\n  /**\n   * Protocol of the listener port\n   * @default - listener is not filtered by protocol\n   */\n  readonly listenerProtocol?: LbProtocol;\n}\n\n/**\n * Define a Network Listener\n *\n * @resource AWS::ElasticLoadBalancingV2::Listener\n */\nexport class NetworkListener extends BaseListener implements INetworkListener {\n  // TODO: Add Grid Lookup support\n  // /**\n  //  * Looks up a network listener\n  //  */\n  // public static fromLookup(\n  //   scope: Construct,\n  //   id: string,\n  //   options: NetworkListenerLookupOptions,\n  // ): INetworkListener {\n  //   let listenerProtocol: LoadBalancerListenerProtocol | undefined;\n  //   if (options.listenerProtocol) {\n  //     validateNetworkProtocol(options.listenerProtocol);\n\n  //     switch (options.listenerProtocol) {\n  //       case Protocol.TCP:\n  //         listenerProtocol = LoadBalancerListenerProtocol.TCP;\n  //         break;\n  //       case Protocol.UDP:\n  //         listenerProtocol = LoadBalancerListenerProtocol.UDP;\n  //         break;\n  //       case Protocol.TCP_UDP:\n  //         listenerProtocol = LoadBalancerListenerProtocol.TCP_UDP;\n  //         break;\n  //       case Protocol.TLS:\n  //         listenerProtocol = LoadBalancerListenerProtocol.TLS;\n  //         break;\n  //     }\n  //   }\n\n  //   const props = BaseListener._queryContextProvider(scope, {\n  //     userOptions: options,\n  //     listenerProtocol: listenerProtocol,\n  //     loadBalancerType: LoadBalancerType.NETWORK,\n  //   });\n\n  //   class LookedUp extends AwsConstructBase implements INetworkListener {\n  //     public listenerArn = props.listenerArn;\n  //   }\n\n  //   return new LookedUp(scope, id);\n  // }\n\n  /**\n   * Import an existing listener\n   */\n  public static fromNetworkListenerArn(\n    scope: Construct,\n    id: string,\n    networkListenerArn: string,\n  ): INetworkListener {\n    class Import extends AwsConstructBase implements INetworkListener {\n      public listenerArn = networkListenerArn;\n      public listenerOutputs = {\n        listenerArn: networkListenerArn,\n      };\n      public outputs = {\n        listenerArn: networkListenerArn,\n      };\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * The load balancer this listener is attached to\n   */\n  public readonly loadBalancer: INetworkLoadBalancer;\n\n  /**\n   * ARNs of certificates added to this listener\n   *\n   * The first certificate is used as the default certificate.\n   */\n  private readonly certificateArns: string[];\n\n  /**\n   * the protocol of the listener\n   */\n  private readonly protocol: LbProtocol;\n\n  constructor(scope: Construct, id: string, props: NetworkListenerProps) {\n    const certs = props.certificates || [];\n    const proto =\n      props.protocol || (certs.length > 0 ? LbProtocol.TLS : LbProtocol.TCP);\n\n    validateNetworkProtocol(proto);\n\n    if (\n      proto === LbProtocol.TLS &&\n      certs.filter((v) => v != null).length === 0\n    ) {\n      throw new Error(\n        \"When the protocol is set to TLS, you must specify certificates\",\n      );\n    }\n\n    if (proto !== LbProtocol.TLS && certs.length > 0) {\n      throw new Error(\n        \"Protocol must be TLS when certificates have been specified\",\n      );\n    }\n\n    if (proto !== LbProtocol.TLS && props.alpnPolicy) {\n      throw new Error(\n        \"Protocol must be TLS when alpnPolicy have been specified\",\n      );\n    }\n\n    super(scope, id, {\n      loadBalancerArn: props.loadBalancer.loadBalancerArn,\n      protocol: proto,\n      port: props.port,\n      sslPolicy: props.sslPolicy,\n      certificateArn: Lazy.stringValue({\n        produce: () =>\n          this.certificateArns.length > 0 ? this.certificateArns[0] : undefined,\n      }),\n      alpnPolicy: props.alpnPolicy ? props.alpnPolicy : undefined,\n    });\n\n    this.certificateArns = [];\n    this.loadBalancer = props.loadBalancer;\n    this.protocol = proto;\n\n    if (certs.length > 0) {\n      this.addCertificates(\"DefaultCertificates\", certs);\n    }\n    if (props.defaultAction && props.defaultTargetGroups) {\n      throw new Error(\n        \"Specify at most one of 'defaultAction' and 'defaultTargetGroups'\",\n      );\n    }\n\n    if (props.defaultAction) {\n      this.setDefaultAction(props.defaultAction);\n    }\n\n    if (props.defaultTargetGroups) {\n      this.setDefaultAction(\n        NetworkListenerAction.forward(props.defaultTargetGroups),\n      );\n    }\n\n    if (\n      props.tcpIdleTimeout !== undefined &&\n      !Token.isUnresolved(props.tcpIdleTimeout)\n    ) {\n      if (\n        props.tcpIdleTimeout.toMilliseconds() <\n        Duration.seconds(1).toMilliseconds()\n      ) {\n        throw new Error(\n          `\\`tcpIdleTimeout\\` must be between 60 and 6000 seconds, got ${props.tcpIdleTimeout.toMilliseconds()} milliseconds.`,\n        );\n      }\n\n      const tcpIdleTimeoutSeconds = props.tcpIdleTimeout.toSeconds();\n\n      if (proto === LbProtocol.UDP) {\n        throw new Error(\n          \"`tcpIdleTimeout` cannot be set when `protocol` is `Protocol.UDP`.\",\n        );\n      }\n\n      if (tcpIdleTimeoutSeconds < 60 || tcpIdleTimeoutSeconds > 6000) {\n        throw new Error(\n          `\\`tcpIdleTimeout\\` must be between 60 and 6000 seconds, got ${tcpIdleTimeoutSeconds} seconds.`,\n        );\n      }\n\n      this.setAttribute(\n        \"tcp.idle_timeout.seconds\",\n        tcpIdleTimeoutSeconds.toString(),\n      );\n    }\n  }\n\n  /**\n   * Add one or more certificates to this listener.\n   *\n   * After the first certificate, this creates NetworkListenerCertificates\n   * resources since cloudformation requires the certificates array on the\n   * listener resource to have a length of 1.\n   */\n  public addCertificates(\n    id: string,\n    certificates: IListenerCertificate[],\n  ): void {\n    const additionalCerts = [...certificates];\n    if (this.certificateArns.length === 0 && additionalCerts.length > 0) {\n      const first = additionalCerts.splice(0, 1)[0];\n      this.certificateArns.push(first.certificateArn);\n    }\n    // Only one certificate can be specified per resource, even though\n    // `certificates` is of type Array\n    for (let i = 0; i < additionalCerts.length; i++) {\n      new NetworkListenerCertificate(this, `${id}${i + 1}`, {\n        listener: this,\n        certificates: [additionalCerts[i]],\n      });\n    }\n  }\n\n  /**\n   * Load balance incoming requests to the given target groups.\n   *\n   * All target groups will be load balanced to with equal weight and without\n   * stickiness. For a more complex configuration than that, use `addAction()`.\n   */\n  public addTargetGroups(\n    _id: string,\n    ...targetGroups: INetworkTargetGroup[]\n  ): void {\n    this.setDefaultAction(NetworkListenerAction.forward(targetGroups));\n  }\n\n  /**\n   * Perform the given Action on incoming requests\n   *\n   * This allows full control of the default Action of the load balancer,\n   * including weighted forwarding. See the `NetworkListenerAction` class for\n   * all options.\n   */\n  public addAction(_id: string, props: AddNetworkActionProps): void {\n    this.setDefaultAction(props.action);\n  }\n\n  /**\n   * Load balance incoming requests to the given load balancing targets.\n   *\n   * This method implicitly creates a NetworkTargetGroup for the targets\n   * involved, and a 'forward' action to route traffic to the given TargetGroup.\n   *\n   * If you want more control over the precise setup, create the TargetGroup\n   * and use `addAction` yourself.\n   *\n   * It's possible to add conditions to the targets added in this way. At least\n   * one set of targets must be added without conditions.\n   *\n   * @returns The newly created target group\n   */\n  public addTargets(\n    id: string,\n    props: AddNetworkTargetsProps,\n  ): NetworkTargetGroup {\n    if (!this.loadBalancer.vpc) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        \"Can only call addTargets() when using a constructed Load Balancer or imported Load Balancer with specified VPC; construct a new TargetGroup and use addTargetGroup\",\n      );\n    }\n\n    const group = new NetworkTargetGroup(this, id + \"Group\", {\n      deregistrationDelay: props.deregistrationDelay,\n      healthCheck: props.healthCheck,\n      port: props.port,\n      protocol: props.protocol ?? this.protocol,\n      proxyProtocolV2: props.proxyProtocolV2,\n      preserveClientIp: props.preserveClientIp,\n      targetGroupName: props.targetGroupName,\n      targets: props.targets,\n      vpc: this.loadBalancer.vpc,\n    });\n\n    this.addTargetGroups(id, group);\n\n    return group;\n  }\n\n  /**\n   * Wrapper for _setDefaultAction which does a type-safe bind\n   */\n  private setDefaultAction(action: NetworkListenerAction) {\n    action.bind(this, this);\n    this._setDefaultAction(action);\n  }\n}\n\n/**\n * Properties to reference an existing listener\n */\nexport interface INetworkListener extends IListener {}\n\n/**\n * Properties for adding a new action to a listener\n */\nexport interface AddNetworkActionProps {\n  /**\n   * Action to perform\n   */\n  readonly action: NetworkListenerAction;\n}\n\n/**\n * Properties for adding new network targets to a listener\n */\nexport interface AddNetworkTargetsProps {\n  /**\n   * The port on which the target receives traffic.\n   *\n   * @default Determined from protocol if known\n   */\n  readonly port: number;\n\n  /**\n   * Protocol for target group, expects TCP, TLS, UDP, or TCP_UDP.\n   *\n   * @default - inherits the protocol of the listener\n   */\n  readonly protocol?: LbProtocol;\n\n  /**\n   * The targets to add to this target group.\n   *\n   * Can be `Instance`, `IPAddress`, or any self-registering load balancing\n   * target. If you use either `Instance` or `IPAddress` as targets, all\n   * target must be of the same type.\n   */\n  readonly targets?: INetworkLoadBalancerTarget[];\n\n  /**\n   * The name of the target group.\n   *\n   * This name must be unique per region per account, can have a maximum of\n   * 32 characters, must contain only alphanumeric characters or hyphens, and\n   * must not begin or end with a hyphen.\n   *\n   * @default Automatically generated\n   */\n  readonly targetGroupName?: string;\n\n  /**\n   * The amount of time for Elastic Load Balancing to wait before deregistering a target.\n   *\n   * The range is 0-3600 seconds.\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly deregistrationDelay?: Duration;\n\n  /**\n   * Indicates whether Proxy Protocol version 2 is enabled.\n   *\n   * @default false\n   */\n  readonly proxyProtocolV2?: boolean;\n\n  /**\n   * Indicates whether client IP preservation is enabled.\n   *\n   * @default false if the target group type is IP address and the\n   * target group protocol is TCP or TLS. Otherwise, true.\n   */\n  readonly preserveClientIp?: boolean;\n\n  /**\n   * Health check configuration\n   *\n   * @default - The default value for each property in this configuration varies depending on the target.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#aws-resource-elasticloadbalancingv2-targetgroup-properties\n   */\n  readonly healthCheck?: HealthCheck;\n}\n"]}

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

@@ -0,0 +1,315 @@
+import { Construct } from "constructs";
+import { BaseNetworkListenerProps, NetworkListener } from "./network-listener";
+import * as cloudwatch from "../../cloudwatch";
+import { Connections, IConnectable } from "../connections";
+import { BaseLoadBalancer, BaseLoadBalancerLookupOptions, BaseLoadBalancerProps, ILoadBalancerV2 } from "../lb-shared/base-load-balancer";
+import { IpAddressType } from "../lb-shared/enums";
+import { ISecurityGroup } from "../security-group";
+import { IVpc } from "../vpc";
+import { IVpcEndpointServiceLoadBalancer } from "../vpc-endpoint-service";
+/**
+ * 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
+ */
+export declare enum ClientRoutingPolicy {
+    /**
+     * 100 percent zonal affinity
+     */
+    AVAILABILITY_ZONE_AFFINITY = "availability_zone_affinity",
+    /**
+     * 85 percent zonal affinity
+     */
+    PARTIAL_AVAILABILITY_ZONE_AFFINITY = "partial_availability_zone_affinity",
+    /**
+     * No zonal affinity
+     */
+    ANY_AVAILABILITY_ZONE = "any_availability_zone"
+}
+/**
+ * Properties for a network load balancer
+ */
+export interface NetworkLoadBalancerProps extends BaseLoadBalancerProps {
+    /**
+     * Security groups to associate with this load balancer
+     *
+     * @default - No security groups associated with the load balancer.
+     */
+    readonly securityGroups?: ISecurityGroup[];
+    /**
+     * The type of IP addresses to use
+     *
+     * If you want to add a UDP or TCP_UDP listener to the load balancer,
+     * you must choose IPv4.
+     *
+     * @default IpAddressType.IPV4
+     */
+    readonly ipAddressType?: IpAddressType;
+    /**
+     * The AZ affinity routing policy
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancers.html#zonal-dns-affinity
+     *
+     * @default - AZ affinity is disabled.
+     */
+    readonly clientRoutingPolicy?: ClientRoutingPolicy;
+    /**
+     * Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink.
+     *
+     * @default true
+     */
+    readonly enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: boolean;
+    /**
+     * Indicates whether zonal shift is enabled
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/network/zonal-shift.html
+     *
+     * @default false
+     */
+    readonly zonalShift?: boolean;
+}
+/**
+ * Properties to reference an existing load balancer
+ */
+export interface NetworkLoadBalancerAttributes {
+    /**
+     * ARN of the load balancer
+     */
+    readonly loadBalancerArn: string;
+    /**
+     * The canonical hosted zone ID of this load balancer
+     *
+     * @default - Token via data source from loadBalancerArn.
+     */
+    readonly loadBalancerCanonicalHostedZoneId?: string;
+    /**
+     * The DNS name of this load balancer
+     *
+     * @default - Token via data source from loadBalancerArn.
+     */
+    readonly loadBalancerDnsName?: string;
+    /**
+     * The VPC to associate with the load balancer.
+     *
+     * @default - When not provided, listeners cannot be created on imported load
+     * balancers.
+     */
+    readonly vpc?: IVpc;
+    /**
+     * Security groups to associate with this load balancer
+     *
+     * @default - No security groups associated with the load balancer.
+     */
+    readonly loadBalancerSecurityGroups?: string[];
+}
+/**
+ * Options for looking up an NetworkLoadBalancer
+ */
+export interface NetworkLoadBalancerLookupOptions extends BaseLoadBalancerLookupOptions {
+}
+/**
+ * Define a new network load balancer
+ *
+ * @resource AWS::ElasticLoadBalancingV2::LoadBalancer
+ */
+export declare class NetworkLoadBalancer extends BaseLoadBalancer implements INetworkLoadBalancer {
+    static fromNetworkLoadBalancerAttributes(scope: Construct, id: string, attrs: NetworkLoadBalancerAttributes): INetworkLoadBalancer;
+    readonly metrics: INetworkLoadBalancerMetrics;
+    readonly ipAddressType?: IpAddressType;
+    readonly connections: Connections;
+    private readonly isSecurityGroupsPropertyDefined;
+    private readonly _enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?;
+    /**
+     * 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(): string[] | undefined;
+    constructor(scope: Construct, id: string, props: NetworkLoadBalancerProps);
+    get enforceSecurityGroupInboundRulesOnPrivateLinkTraffic(): string | undefined;
+    /**
+     * Add a listener to this load balancer
+     *
+     * @returns The newly created listener
+     */
+    addListener(id: string, props: BaseNetworkListenerProps): NetworkListener;
+    /**
+     * Add a security group to this load balancer
+     */
+    addSecurityGroup(securityGroup: ISecurityGroup): void;
+    /**
+     * Return the given named metric for this Network Load Balancer
+     *
+     * @default Average over 5 minutes
+     * @deprecated Use ``NetworkLoadBalancer.metrics.custom`` instead
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of targets that are considered healthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated use ``NetworkTargetGroup.metricHealthyHostCount`` instead
+     */
+    metricHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of targets that are considered unhealthy.
+     *
+     * @default Average over 5 minutes
+     * @deprecated use ``NetworkTargetGroup.metricUnHealthyHostCount`` instead
+     */
+    metricUnHealthyHostCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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?: cloudwatch.MetricOptions): cloudwatch.Metric;
+}
+/**
+ * Contains all metrics for a Network Load Balancer.
+ */
+export interface INetworkLoadBalancerMetrics {
+    /**
+     * Return the given named metric for this Network Load Balancer
+     *
+     * @default Average over 5 minutes
+     */
+    custom(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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
+     */
+    activeFlowCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The number of load balancer capacity units (LCU) used by your load balancer.
+     *
+     * @default Sum over 5 minutes
+     */
+    consumedLCUs(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The total number of new TCP flows (or connections) established from clients to targets in the time period.
+     *
+     * @default Sum over 5 minutes
+     */
+    newFlowCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The total number of bytes processed by the load balancer, including TCP/IP headers.
+     *
+     * @default Sum over 5 minutes
+     */
+    processedBytes(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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
+     */
+    tcpClientResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * The total number of reset (RST) packets generated by the load balancer.
+     *
+     * @default Sum over 5 minutes
+     */
+    tcpElbResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * 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
+     */
+    tcpTargetResetCount(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+}
+/**
+ * A network load balancer
+ */
+export interface INetworkLoadBalancer extends ILoadBalancerV2, IVpcEndpointServiceLoadBalancer, IConnectable {
+    /**
+     * The VPC this load balancer has been created in (if available)
+     */
+    readonly vpc?: IVpc;
+    /**
+     * All metrics available for this load balancer
+     */
+    readonly metrics: INetworkLoadBalancerMetrics;
+    /**
+     * Security groups associated with this load balancer
+     */
+    readonly securityGroups?: string[];
+    /**
+     * The type of IP addresses to use
+     *
+     * @default IpAddressType.IPV4
+     */
+    readonly ipAddressType?: IpAddressType;
+    /**
+     * Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink
+     *
+     * @default on
+     */
+    readonly enforceSecurityGroupInboundRulesOnPrivateLinkTraffic?: string;
+    /**
+     * Add a listener to this load balancer
+     *
+     * @returns The newly created listener
+     */
+    addListener(id: string, props: BaseNetworkListenerProps): NetworkListener;
+}