cdk8s-plus-31 2.0.0

package/lib/deployment.js

@@ -0,0 +1,214 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentStrategy = exports.PercentOrAbsolute = exports.Deployment = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const container = require("./container");
+const k8s = require("./imports/k8s");
+const service = require("./service");
+const workload = require("./workload");
+/**
+*
+* A Deployment provides declarative updates for Pods and ReplicaSets.
+*
+* You describe a desired state in a Deployment, and the Deployment Controller changes the actual
+* state to the desired state at a controlled rate. You can define Deployments to create new ReplicaSets, or to remove
+* existing Deployments and adopt all their resources with new Deployments.
+*
+* > Note: Do not manage ReplicaSets owned by a Deployment. Consider opening an issue in the main Kubernetes repository if your use case is not covered below.
+*
+* Use Case
+*
+* The following are typical use cases for Deployments:
+*
+* - Create a Deployment to rollout a ReplicaSet. The ReplicaSet creates Pods in the background.
+*   Check the status of the rollout to see if it succeeds or not.
+* - Declare the new state of the Pods by updating the PodTemplateSpec of the Deployment.
+*   A new ReplicaSet is created and the Deployment manages moving the Pods from the old ReplicaSet to the new one at a controlled rate.
+*   Each new ReplicaSet updates the revision of the Deployment.
+* - Rollback to an earlier Deployment revision if the current state of the Deployment is not stable.
+*   Each rollback updates the revision of the Deployment.
+* - Scale up the Deployment to facilitate more load.
+* - Pause the Deployment to apply multiple fixes to its PodTemplateSpec and then resume it to start a new rollout.
+* - Use the status of the Deployment as an indicator that a rollout has stuck.
+* - Clean up older ReplicaSets that you don't need anymore.
+*
+**/
+class Deployment extends workload.Workload {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.resourceType = 'deployments';
+        this.hasAutoscaler = false;
+        this.apiObject = new k8s.KubeDeployment(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.minReady = props.minReady ?? cdk8s_1.Duration.seconds(0);
+        this.progressDeadline = props.progressDeadline ?? cdk8s_1.Duration.seconds(600);
+        if (this.progressDeadline.toSeconds() <= this.minReady.toSeconds()) {
+            throw new Error(`'progressDeadline' (${this.progressDeadline.toSeconds()}s) must be greater than 'minReady' (${this.minReady.toSeconds()}s)`);
+        }
+        this.replicas = props.replicas;
+        this.strategy = props.strategy ?? DeploymentStrategy.rollingUpdate();
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    /**
+     * Expose a deployment via a service.
+     *
+     * This is equivalent to running `kubectl expose deployment <deployment-name>`.
+     *
+     * @param options Options to determine details of the service and port exposed.
+     */
+    exposeViaService(options = {}) {
+        const myPorts = container.extractContainerPorts(this);
+        const myPortNumbers = myPorts.map(p => p.number);
+        const ports = options.ports ?? myPorts.map(p => ({
+            port: p.number, targetPort: p.number, protocol: p.protocol, name: p.name,
+        }));
+        if (ports.length === 0) {
+            throw new Error(`Unable to expose deployment ${this.name} via a service: `
+                + 'Deployment port cannot be determined.'
+                + 'Either pass \'ports\', or configure ports on the containers of the deployment');
+        }
+        const portNames = ports.map(p => p.name);
+        if (ports.length > 1 && portNames.includes(undefined)) {
+            throw new Error(`Unable to expose deployment ${this.name} via a service: `
+                + 'When using multiple ports for a service, all ports must have port names so they are unambiguous.');
+        }
+        // validate the ports are owned by our containers
+        for (const port of ports) {
+            const targetPort = port.targetPort ?? port.port;
+            if (!myPortNumbers.includes(targetPort)) {
+                throw new Error(`Unable to expose deployment ${this.name} via a service: Port ${targetPort} is not exposed by any container`);
+            }
+        }
+        const metadata = { namespace: this.metadata.namespace };
+        if (options.name) {
+            metadata.name = options.name;
+        }
+        return new service.Service(this, `${options.name ?? ''}Service`, {
+            selector: this,
+            ports,
+            metadata,
+            type: options.serviceType ?? service.ServiceType.CLUSTER_IP,
+        });
+    }
+    /**
+     * Expose a deployment via an ingress.
+     *
+     * This will first expose the deployment with a service, and then expose the service via an ingress.
+     *
+     * @param path The ingress path to register under.
+     * @param options Additional options.
+     */
+    exposeViaIngress(path, options = {}) {
+        const ser = this.exposeViaService(options);
+        return ser.exposeViaIngress(path, options);
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 2),
+            minReadySeconds: this.minReady.toSeconds(),
+            progressDeadlineSeconds: this.progressDeadline.toSeconds(),
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            selector: this._toLabelSelector(),
+            strategy: this.strategy._toKube(),
+        };
+    }
+    /**
+     * @see IScalable.markHasAutoscaler()
+     */
+    markHasAutoscaler() {
+        this.hasAutoscaler = true;
+    }
+    /**
+     * @see IScalable.toScalingTarget()
+     */
+    toScalingTarget() {
+        return {
+            kind: this.apiObject.kind,
+            apiVersion: this.apiObject.apiVersion,
+            name: this.name,
+            containers: this.containers,
+            replicas: this.replicas,
+        };
+    }
+}
+exports.Deployment = Deployment;
+_a = JSII_RTTI_SYMBOL_1;
+Deployment[_a] = { fqn: "cdk8s-plus-31.Deployment", version: "2.0.0" };
+/**
+ * Union like class repsenting either a ration in
+ * percents or an absolute number.
+ */
+class PercentOrAbsolute {
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Percent ratio.
+     */
+    static percent(percent) {
+        return new PercentOrAbsolute(`${percent}%`);
+    }
+    /**
+     * Absolute number.
+     */
+    static absolute(num) {
+        return new PercentOrAbsolute(num);
+    }
+    isZero() {
+        return this.value === PercentOrAbsolute.absolute(0).value || this.value === PercentOrAbsolute.percent(0).value;
+    }
+}
+exports.PercentOrAbsolute = PercentOrAbsolute;
+_b = JSII_RTTI_SYMBOL_1;
+PercentOrAbsolute[_b] = { fqn: "cdk8s-plus-31.PercentOrAbsolute", version: "2.0.0" };
+/**
+ * Deployment strategies.
+ */
+class DeploymentStrategy {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * All existing Pods are killed before new ones are created.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#recreate-deployment
+     */
+    static recreate() {
+        return new DeploymentStrategy({
+            type: 'Recreate',
+        });
+    }
+    static rollingUpdate(options = {}) {
+        const maxSurge = options.maxSurge ?? PercentOrAbsolute.percent(25);
+        const maxUnavailable = options.maxUnavailable ?? PercentOrAbsolute.percent(25);
+        if (maxSurge.isZero() && maxUnavailable.isZero()) {
+            throw new Error('\'maxSurge\' and \'maxUnavailable\' cannot be both zero');
+        }
+        return new DeploymentStrategy({
+            type: 'RollingUpdate',
+            rollingUpdate: { maxSurge, maxUnavailable },
+        });
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return this.strategy;
+    }
+}
+exports.DeploymentStrategy = DeploymentStrategy;
+_c = JSII_RTTI_SYMBOL_1;
+DeploymentStrategy[_c] = { fqn: "cdk8s-plus-31.DeploymentStrategy", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment.js","sourceRoot":"","sources":["../src/deployment.ts"],"names":[],"mappings":";;;;;AAAA,iCAAkD;AAElD,yCAAyC;AAEzC,qCAAqC;AAErC,qCAAqC;AACrC,uCAAuC;AAgFvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,UAAW,SAAQ,QAAQ,CAAC,QAAQ;IAgC/C,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAyB,EAAE;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QALV,iBAAY,GAAG,aAAa,CAAC;QAEtC,kBAAa,GAAG,KAAK,CAAC;QAK3B,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE;YACxD,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,IAAI,EAAE,YAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;SAClD,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,gBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,IAAI,gBAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAExE,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,EAAE;YAClE,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,uCAAuC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;SAC/I;QAED,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,kBAAkB,CAAC,aAAa,EAAE,CAAC;QAErE,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;SAC5B;IACH,CAAC;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,UAA6C,EAAE;QACrE,MAAM,OAAO,GAAG,SAAS,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACtD,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACjD,MAAM,KAAK,GAA0B,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACtE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI;SACzE,CAAC,CAAC,CAAC;QACJ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,kBAAkB;kBACtE,uCAAuC;kBACvC,+EAA+E,CAAC,CAAC;SACtF;QACD,MAAM,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;YACrD,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,kBAAkB;kBACtE,kGAAkG,CAAC,CAAC;SACzG;QAED,iDAAiD;QACjD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC;YAChD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE;gBACvC,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,wBAAwB,UAAU,kCAAkC,CAAC,CAAC;aAC/H;SACF;QAED,MAAM,QAAQ,GAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC7D,IAAI,OAAO,CAAC,IAAI,EAAE;YAChB,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;SAC9B;QACD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,IAAI,EAAE,SAAS,EAAE;YAC/D,QAAQ,EAAE,IAAI;YACd,KAAK;YACL,QAAQ;YACR,IAAI,EAAE,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,UAAU;SAC5D,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACI,gBAAgB,CAAC,IAAY,EAAE,UAA6C,EAAE;QACnF,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC3C,OAAO,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;YAC/D,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE;YAC1C,uBAAuB,EAAE,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE;YAC1D,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;gBACnC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;aACxB;YACD,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE;YACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;SAClC,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,iBAAiB;QACtB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI;YACzB,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU;YACrC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC;IACJ,CAAC;;AAnJH,gCAoJC;;;AAuCD;;;GAGG;AACH,MAAa,iBAAiB;IAgB5B,YAAoC,KAAU;QAAV,UAAK,GAAL,KAAK,CAAK;IAAG,CAAC;IAdlD;;OAEG;IACI,MAAM,CAAC,OAAO,CAAC,OAAe;QACnC,OAAO,IAAI,iBAAiB,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,QAAQ,CAAC,GAAW;QAChC,OAAO,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACpC,CAAC;IAIM,MAAM;QACX,OAAO,IAAI,CAAC,KAAK,KAAK,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACjH,CAAC;;AApBH,8CAsBC;;;AAED;;GAEG;AACH,MAAa,kBAAkB;IA4B7B,YAAqC,QAAgC;QAAhC,aAAQ,GAAR,QAAQ,CAAwB;IAAG,CAAC;IA1BzE;;;;OAIG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,IAAI,kBAAkB,CAAC;YAC5B,IAAI,EAAE,UAAU;SACjB,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,aAAa,CAAC,UAAkD,EAAE;QAE9E,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACnE,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAE/E,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;SAC5E;QAED,OAAO,IAAI,kBAAkB,CAAC;YAC5B,IAAI,EAAE,eAAe;YACrB,aAAa,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE;SAC5C,CAAC,CAAC;IACL,CAAC;IAID;;OAEG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;;AAnCH,gDAqCC","sourcesContent":["import { ApiObject, Lazy, Duration } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as container from './container';\nimport { IScalable, ScalingTarget } from './horizontal-pod-autoscaler';\nimport * as k8s from './imports/k8s';\nimport * as ingress from './ingress';\nimport * as service from './service';\nimport * as workload from './workload';\n\n/**\n * Properties for `Deployment`.\n */\nexport interface DeploymentProps extends workload.WorkloadProps {\n\n  /**\n   * Number of desired pods.\n   *\n   * @default 2\n   */\n  readonly replicas?: number;\n\n  /**\n   * Specifies the strategy used to replace old Pods by new ones.\n   *\n   * @default - RollingUpdate with maxSurge and maxUnavailable set to 25%.\n   */\n  readonly strategy?: DeploymentStrategy;\n\n  /**\n   * Minimum duration for which a newly created pod should be ready without\n   * any of its container crashing, for it to be considered available.\n   *\n   * Zero means the pod will be considered available as soon as it is ready.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#min-ready-seconds\n   * @default Duration.seconds(0)\n   */\n  readonly minReady?: Duration;\n\n  /**\n   * The maximum duration for a deployment to make progress before it\n   * is considered to be failed. The deployment controller will continue\n   * to process failed deployments and a condition with a ProgressDeadlineExceeded\n   * reason will be surfaced in the deployment status.\n   *\n   * Note that progress will not be estimated during the time a deployment is paused.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#progress-deadline-seconds\n   * @default Duration.seconds(600)\n   */\n  readonly progressDeadline?: Duration;\n\n}\n\n/**\n * Options for `Deployment.exposeViaService`.\n */\nexport interface DeploymentExposeViaServiceOptions {\n  /**\n   * The ports that the service should bind to.\n   *\n   * @default - extracted from the deployment.\n   */\n  readonly ports?: service.ServicePort[];\n\n  /**\n   * The type of the exposed service.\n   *\n   * @default - ClusterIP.\n   */\n  readonly serviceType?: service.ServiceType;\n\n  /**\n   * The name of the service to expose.\n   * If you'd like to expose the deployment multiple times,\n   * you must explicitly set a name starting from the second expose call.\n   *\n   * @default - auto generated.\n   */\n  readonly name?: string;\n}\n\n/**\n * Options for exposing a deployment via an ingress.\n */\nexport interface ExposeDeploymentViaIngressOptions extends DeploymentExposeViaServiceOptions, service.ExposeServiceViaIngressOptions {}\n\n/**\n*\n* A Deployment provides declarative updates for Pods and ReplicaSets.\n*\n* You describe a desired state in a Deployment, and the Deployment Controller changes the actual\n* state to the desired state at a controlled rate. You can define Deployments to create new ReplicaSets, or to remove\n* existing Deployments and adopt all their resources with new Deployments.\n*\n* > Note: Do not manage ReplicaSets owned by a Deployment. Consider opening an issue in the main Kubernetes repository if your use case is not covered below.\n*\n* Use Case\n*\n* The following are typical use cases for Deployments:\n*\n* - Create a Deployment to rollout a ReplicaSet. The ReplicaSet creates Pods in the background.\n*   Check the status of the rollout to see if it succeeds or not.\n* - Declare the new state of the Pods by updating the PodTemplateSpec of the Deployment.\n*   A new ReplicaSet is created and the Deployment manages moving the Pods from the old ReplicaSet to the new one at a controlled rate.\n*   Each new ReplicaSet updates the revision of the Deployment.\n* - Rollback to an earlier Deployment revision if the current state of the Deployment is not stable.\n*   Each rollback updates the revision of the Deployment.\n* - Scale up the Deployment to facilitate more load.\n* - Pause the Deployment to apply multiple fixes to its PodTemplateSpec and then resume it to start a new rollout.\n* - Use the status of the Deployment as an indicator that a rollout has stuck.\n* - Clean up older ReplicaSets that you don't need anymore.\n*\n**/\nexport class Deployment extends workload.Workload implements IScalable {\n\n  /**\n   * Number of desired pods.\n   */\n  public readonly replicas?: number;\n\n  /**\n   * Minimum duration for which a newly created pod should be ready without\n   * any of its container crashing, for it to be considered available.\n   */\n  public readonly minReady: Duration;\n\n  /**\n   * The maximum duration for a deployment to make progress before it is considered to be failed.\n   */\n  public readonly progressDeadline: Duration;\n\n  /*\n   * The upgrade strategy of this deployment.\n   */\n  public readonly strategy: DeploymentStrategy;\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'deployments';\n\n  public hasAutoscaler = false;\n\n  constructor(scope: Construct, id: string, props: DeploymentProps = {}) {\n    super(scope, id, props);\n\n    this.apiObject = new k8s.KubeDeployment(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this.minReady = props.minReady ?? Duration.seconds(0);\n    this.progressDeadline = props.progressDeadline ?? Duration.seconds(600);\n\n    if (this.progressDeadline.toSeconds() <= this.minReady.toSeconds()) {\n      throw new Error(`'progressDeadline' (${this.progressDeadline.toSeconds()}s) must be greater than 'minReady' (${this.minReady.toSeconds()}s)`);\n    }\n\n    this.replicas = props.replicas;\n    this.strategy = props.strategy ?? DeploymentStrategy.rollingUpdate();\n\n    if (this.isolate) {\n      this.connections.isolate();\n    }\n  }\n\n  /**\n   * Expose a deployment via a service.\n   *\n   * This is equivalent to running `kubectl expose deployment <deployment-name>`.\n   *\n   * @param options Options to determine details of the service and port exposed.\n   */\n  public exposeViaService(options: DeploymentExposeViaServiceOptions = {}): service.Service {\n    const myPorts = container.extractContainerPorts(this);\n    const myPortNumbers = myPorts.map(p => p.number);\n    const ports: service.ServicePort[] = options.ports ?? myPorts.map(p => ({\n      port: p.number, targetPort: p.number, protocol: p.protocol, name: p.name,\n    }));\n    if (ports.length === 0) {\n      throw new Error(`Unable to expose deployment ${this.name} via a service: `\n        + 'Deployment port cannot be determined.'\n        + 'Either pass \\'ports\\', or configure ports on the containers of the deployment');\n    }\n    const portNames = ports.map(p => p.name);\n    if (ports.length > 1 && portNames.includes(undefined)) {\n      throw new Error(`Unable to expose deployment ${this.name} via a service: `\n        + 'When using multiple ports for a service, all ports must have port names so they are unambiguous.');\n    }\n\n    // validate the ports are owned by our containers\n    for (const port of ports) {\n      const targetPort = port.targetPort ?? port.port;\n      if (!myPortNumbers.includes(targetPort)) {\n        throw new Error(`Unable to expose deployment ${this.name} via a service: Port ${targetPort} is not exposed by any container`);\n      }\n    }\n\n    const metadata: any = { namespace: this.metadata.namespace };\n    if (options.name) {\n      metadata.name = options.name;\n    }\n    return new service.Service(this, `${options.name ?? ''}Service`, {\n      selector: this,\n      ports,\n      metadata,\n      type: options.serviceType ?? service.ServiceType.CLUSTER_IP,\n    });\n  }\n\n  /**\n   * Expose a deployment via an ingress.\n   *\n   * This will first expose the deployment with a service, and then expose the service via an ingress.\n   *\n   * @param path The ingress path to register under.\n   * @param options Additional options.\n   */\n  public exposeViaIngress(path: string, options: ExposeDeploymentViaIngressOptions = {}): ingress.Ingress {\n    const ser = this.exposeViaService(options);\n    return ser.exposeViaIngress(path, options);\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.DeploymentSpec {\n    return {\n      replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 2),\n      minReadySeconds: this.minReady.toSeconds(),\n      progressDeadlineSeconds: this.progressDeadline.toSeconds(),\n      template: {\n        metadata: this.podMetadata.toJson(),\n        spec: this._toPodSpec(),\n      },\n      selector: this._toLabelSelector(),\n      strategy: this.strategy._toKube(),\n    };\n  }\n\n  /**\n   * @see IScalable.markHasAutoscaler()\n   */\n  public markHasAutoscaler() {\n    this.hasAutoscaler = true;\n  }\n\n  /**\n   * @see IScalable.toScalingTarget()\n   */\n  public toScalingTarget(): ScalingTarget {\n    return {\n      kind: this.apiObject.kind,\n      apiVersion: this.apiObject.apiVersion,\n      name: this.name,\n      containers: this.containers,\n      replicas: this.replicas,\n    };\n  }\n}\n\n/**\n * Options for `DeploymentStrategy.rollingUpdate`.\n */\nexport interface DeploymentStrategyRollingUpdateOptions {\n\n  /**\n   * The maximum number of pods that can be scheduled above the desired number of pods.\n   * Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).\n   * Absolute number is calculated from percentage by rounding up.\n   * This can not be 0 if `maxUnavailable` is 0.\n   *\n   * Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update\n   * starts, such that the total number of old and new pods do not exceed 130% of desired pods.\n   * Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that\n   * total number of pods running at any time during the update is at most 130% of desired pods.\n   *\n   * @default '25%'\n   */\n  readonly maxSurge?: PercentOrAbsolute;\n\n  /**\n   * The maximum number of pods that can be unavailable during the update.\n   * Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).\n   * Absolute number is calculated from percentage by rounding down.\n   * This can not be 0 if `maxSurge` is 0.\n   *\n   * Example: when this is set to 30%, the old ReplicaSet can be scaled down to 70% of desired\n   * pods immediately when the rolling update starts. Once new pods are ready, old ReplicaSet can\n   * be scaled down further, followed by scaling up the new ReplicaSet, ensuring that the total\n   * number of pods available at all times during the update is at least 70% of desired pods.\n   *\n   * @default '25%'\n   */\n  readonly maxUnavailable?: PercentOrAbsolute;\n\n}\n\n/**\n * Union like class repsenting either a ration in\n * percents or an absolute number.\n */\nexport class PercentOrAbsolute {\n\n  /**\n   * Percent ratio.\n   */\n  public static percent(percent: number): PercentOrAbsolute {\n    return new PercentOrAbsolute(`${percent}%`);\n  }\n\n  /**\n   * Absolute number.\n   */\n  public static absolute(num: number): PercentOrAbsolute {\n    return new PercentOrAbsolute(num);\n  }\n\n  private constructor(public readonly value: any) {}\n\n  public isZero(): boolean {\n    return this.value === PercentOrAbsolute.absolute(0).value || this.value === PercentOrAbsolute.percent(0).value;\n  }\n\n}\n\n/**\n * Deployment strategies.\n */\nexport class DeploymentStrategy {\n\n  /**\n   * All existing Pods are killed before new ones are created.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#recreate-deployment\n   */\n  public static recreate(): DeploymentStrategy {\n    return new DeploymentStrategy({\n      type: 'Recreate',\n    });\n  }\n\n  public static rollingUpdate(options: DeploymentStrategyRollingUpdateOptions = {}): DeploymentStrategy {\n\n    const maxSurge = options.maxSurge ?? PercentOrAbsolute.percent(25);\n    const maxUnavailable = options.maxUnavailable ?? PercentOrAbsolute.percent(25);\n\n    if (maxSurge.isZero() && maxUnavailable.isZero()) {\n      throw new Error('\\'maxSurge\\' and \\'maxUnavailable\\' cannot be both zero');\n    }\n\n    return new DeploymentStrategy({\n      type: 'RollingUpdate',\n      rollingUpdate: { maxSurge, maxUnavailable },\n    });\n  }\n\n  private constructor(private readonly strategy: k8s.DeploymentStrategy) {}\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.DeploymentStrategy {\n    return this.strategy;\n  }\n\n}\n"]}

package/lib/handler.d.ts

@@ -0,0 +1,62 @@
+import * as container from './container';
+import * as k8s from './imports/k8s';
+/**
+ * Options for `Handler.fromTcpSocket`.
+ */
+export interface HandlerFromTcpSocketOptions {
+    /**
+     * The TCP port to connect to on the container.
+     *
+     * @default - defaults to `container.port`.
+     */
+    readonly port?: number;
+    /**
+     * The host name to connect to on the container.
+     *
+     * @default - defaults to the pod IP
+     */
+    readonly host?: string;
+}
+/**
+ * Options for `Handler.fromHttpGet`.
+ */
+export interface HandlerFromHttpGetOptions {
+    /**
+     * The TCP port to use when sending the GET request.
+     *
+     * @default - defaults to `container.port`.
+     */
+    readonly port?: number;
+}
+/**
+ * Defines a specific action that should be taken.
+ */
+export declare class Handler {
+    private readonly tcpSocketOptions?;
+    private readonly commandOptions?;
+    private readonly httpGetOptions?;
+    /**
+     * Defines a handler based on an HTTP GET request to the IP address of the container.
+     *
+     * @param path The URL path to hit
+     * @param options Options
+     */
+    static fromHttpGet(path: string, options?: HandlerFromHttpGetOptions): Handler;
+    /**
+     * Defines a handler based on a command which is executed within the container.
+     *
+     * @param command The command to execute
+     */
+    static fromCommand(command: string[]): Handler;
+    /**
+     * Defines a handler based opening a connection to a TCP socket on the container.
+     *
+     * @param options Options
+     */
+    static fromTcpSocket(options?: HandlerFromTcpSocketOptions): Handler;
+    private constructor();
+    /**
+     * @internal
+     */
+    _toKube(cont: container.Container): k8s.LifecycleHandler;
+}

package/lib/handler.js

@@ -0,0 +1,54 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const _action = require("./_action");
+/**
+ * Defines a specific action that should be taken.
+ */
+class Handler {
+    constructor(tcpSocketOptions, commandOptions, httpGetOptions) {
+        this.tcpSocketOptions = tcpSocketOptions;
+        this.commandOptions = commandOptions;
+        this.httpGetOptions = httpGetOptions;
+    }
+    /**
+     * Defines a handler based on an HTTP GET request to the IP address of the container.
+     *
+     * @param path The URL path to hit
+     * @param options Options
+     */
+    static fromHttpGet(path, options = {}) {
+        return new Handler(undefined, undefined, { path, ...options });
+    }
+    /**
+     * Defines a handler based on a command which is executed within the container.
+     *
+     * @param command The command to execute
+     */
+    static fromCommand(command) {
+        return new Handler(undefined, { command }, undefined);
+    }
+    /**
+     * Defines a handler based opening a connection to a TCP socket on the container.
+     *
+     * @param options Options
+     */
+    static fromTcpSocket(options = {}) {
+        return new Handler(options, undefined, undefined);
+    }
+    /**
+     * @internal
+     */
+    _toKube(cont) {
+        const exec = this.commandOptions ? _action.Action.fromCommand(this.commandOptions.command) : undefined;
+        const httpGet = this.httpGetOptions ? _action.Action.fromHttpGet(cont, this.httpGetOptions.path, this.httpGetOptions) : undefined;
+        const tcpSocket = this.tcpSocketOptions ? _action.Action.fromTcpSocket(cont, this.tcpSocketOptions) : undefined;
+        return { exec, httpGet, tcpSocket };
+    }
+}
+exports.Handler = Handler;
+_a = JSII_RTTI_SYMBOL_1;
+Handler[_a] = { fqn: "cdk8s-plus-31.Handler", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,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