cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/deployment.js

@@ -0,0 +1,216 @@
+"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();
+        this.revisionHistoryLimit = props.revisionHistoryLimit ?? 10;
+        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(),
+            revisionHistoryLimit: this.revisionHistoryLimit,
+        };
+    }
+    /**
+     * @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-34.Deployment", version: "2.0.0" };
+/**
+ * Union like class repsenting either a ration in
+ * percents or an absolute number.
+ */
+class PercentOrAbsolute {
+    /**
+     * Percent ratio.
+     */
+    static percent(percent) {
+        return new PercentOrAbsolute(`${percent}%`);
+    }
+    /**
+     * Absolute number.
+     */
+    static absolute(num) {
+        return new PercentOrAbsolute(num);
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    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-34.PercentOrAbsolute", version: "2.0.0" };
+/**
+ * Deployment strategies.
+ */
+class DeploymentStrategy {
+    /**
+     * 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 },
+        });
+    }
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return this.strategy;
+    }
+}
+exports.DeploymentStrategy = DeploymentStrategy;
+_c = JSII_RTTI_SYMBOL_1;
+DeploymentStrategy[_c] = { fqn: "cdk8s-plus-34.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;AAsFvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,UAAW,SAAQ,QAAQ,CAAC,QAAQ;IAuC/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,CAAC;YACnE,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,uCAAuC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAChJ,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,kBAAkB,CAAC,aAAa,EAAE,CAAC;QACrE,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC,oBAAoB,IAAI,EAAE,CAAC;QAE7D,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAC7B,CAAC;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,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,kBAAkB;kBACtE,uCAAuC;kBACvC,+EAA+E,CAAC,CAAC;QACvF,CAAC;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,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,kBAAkB;kBACtE,kGAAkG,CAAC,CAAC;QAC1G,CAAC;QAED,iDAAiD;QACjD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC;YAChD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,wBAAwB,UAAU,kCAAkC,CAAC,CAAC;YAChI,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC7D,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YACjB,QAAQ,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QAC/B,CAAC;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;YACjC,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;SAChD,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;;AA5JH,gCA6JC;;;AAuCD;;;GAGG;AACH,MAAa,iBAAiB;IAE5B;;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;IAED,YAAoC,KAAU;QAAV,UAAK,GAAL,KAAK,CAAK;IAAG,CAAC;IAE3C,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;IAE7B;;;;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,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;QAC7E,CAAC;QAED,OAAO,IAAI,kBAAkB,CAAC;YAC5B,IAAI,EAAE,eAAe;YACrB,aAAa,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE;SAC5C,CAAC,CAAC;IACL,CAAC;IAED,YAAqC,QAAgC;QAAhC,aAAQ,GAAR,QAAQ,CAAwB;IAAG,CAAC;IAEzE;;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   * Specify how many old ReplicaSets for this Deployment you want to retain. The rest will be garbage-collected in the background. By default, it is 10.\n   *\n   * @default 10\n   */\n  readonly revisionHistoryLimit?: number;\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   * Number of desired replicasets history.\n   *\n   * @default 10\n   */\n\n  readonly revisionHistoryLimit: number;\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    this.revisionHistoryLimit = props.revisionHistoryLimit ?? 10;\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      revisionHistoryLimit: this.revisionHistoryLimit,\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 {
+    /**
+     * 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);
+    }
+    constructor(tcpSocketOptions, commandOptions, httpGetOptions) {
+        this.tcpSocketOptions = tcpSocketOptions;
+        this.commandOptions = commandOptions;
+        this.httpGetOptions = httpGetOptions;
+    }
+    /**
+     * @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-34.Handler", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,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