cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/deployment.d.ts

@@ -0,0 +1,235 @@
+import { ApiObject, Duration } from 'cdk8s';
+import { Construct } from 'constructs';
+import { IScalable, ScalingTarget } from './horizontal-pod-autoscaler';
+import * as k8s from './imports/k8s';
+import * as ingress from './ingress';
+import * as service from './service';
+import * as workload from './workload';
+/**
+ * Properties for `Deployment`.
+ */
+export interface DeploymentProps extends workload.WorkloadProps {
+    /**
+     * Number of desired pods.
+     *
+     * @default 2
+     */
+    readonly replicas?: number;
+    /**
+     * Specifies the strategy used to replace old Pods by new ones.
+     *
+     * @default - RollingUpdate with maxSurge and maxUnavailable set to 25%.
+     */
+    readonly strategy?: DeploymentStrategy;
+    /**
+     * Minimum duration for which a newly created pod should be ready without
+     * any of its container crashing, for it to be considered available.
+     *
+     * Zero means the pod will be considered available as soon as it is ready.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#min-ready-seconds
+     * @default Duration.seconds(0)
+     */
+    readonly minReady?: Duration;
+    /**
+     * The maximum duration for a deployment to make progress before it
+     * is considered to be failed. The deployment controller will continue
+     * to process failed deployments and a condition with a ProgressDeadlineExceeded
+     * reason will be surfaced in the deployment status.
+     *
+     * Note that progress will not be estimated during the time a deployment is paused.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#progress-deadline-seconds
+     * @default Duration.seconds(600)
+     */
+    readonly progressDeadline?: Duration;
+    /**
+     * 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.
+     *
+     * @default 10
+     */
+    readonly revisionHistoryLimit?: number;
+}
+/**
+ * Options for `Deployment.exposeViaService`.
+ */
+export interface DeploymentExposeViaServiceOptions {
+    /**
+     * The ports that the service should bind to.
+     *
+     * @default - extracted from the deployment.
+     */
+    readonly ports?: service.ServicePort[];
+    /**
+     * The type of the exposed service.
+     *
+     * @default - ClusterIP.
+     */
+    readonly serviceType?: service.ServiceType;
+    /**
+     * The name of the service to expose.
+     * If you'd like to expose the deployment multiple times,
+     * you must explicitly set a name starting from the second expose call.
+     *
+     * @default - auto generated.
+     */
+    readonly name?: string;
+}
+/**
+ * Options for exposing a deployment via an ingress.
+ */
+export interface ExposeDeploymentViaIngressOptions extends DeploymentExposeViaServiceOptions, service.ExposeServiceViaIngressOptions {
+}
+/**
+*
+* 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.
+*
+**/
+export declare class Deployment extends workload.Workload implements IScalable {
+    /**
+     * Number of desired pods.
+     */
+    readonly replicas?: number;
+    /**
+     * Minimum duration for which a newly created pod should be ready without
+     * any of its container crashing, for it to be considered available.
+     */
+    readonly minReady: Duration;
+    /**
+     * The maximum duration for a deployment to make progress before it is considered to be failed.
+     */
+    readonly progressDeadline: Duration;
+    readonly strategy: DeploymentStrategy;
+    /**
+     * Number of desired replicasets history.
+     *
+     * @default 10
+     */
+    readonly revisionHistoryLimit: number;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "deployments";
+    hasAutoscaler: boolean;
+    constructor(scope: Construct, id: string, props?: DeploymentProps);
+    /**
+     * 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?: DeploymentExposeViaServiceOptions): service.Service;
+    /**
+     * 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: string, options?: ExposeDeploymentViaIngressOptions): ingress.Ingress;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.DeploymentSpec;
+    /**
+     * @see IScalable.markHasAutoscaler()
+     */
+    markHasAutoscaler(): void;
+    /**
+     * @see IScalable.toScalingTarget()
+     */
+    toScalingTarget(): ScalingTarget;
+}
+/**
+ * Options for `DeploymentStrategy.rollingUpdate`.
+ */
+export interface DeploymentStrategyRollingUpdateOptions {
+    /**
+     * The maximum number of pods that can be scheduled above the desired number of pods.
+     * Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+     * Absolute number is calculated from percentage by rounding up.
+     * This can not be 0 if `maxUnavailable` is 0.
+     *
+     * Example: when this is set to 30%, the new ReplicaSet can be scaled up immediately when the rolling update
+     * starts, such that the total number of old and new pods do not exceed 130% of desired pods.
+     * Once old pods have been killed, new ReplicaSet can be scaled up further, ensuring that
+     * total number of pods running at any time during the update is at most 130% of desired pods.
+     *
+     * @default '25%'
+     */
+    readonly maxSurge?: PercentOrAbsolute;
+    /**
+     * The maximum number of pods that can be unavailable during the update.
+     * Value can be an absolute number (ex: 5) or a percentage of desired pods (ex: 10%).
+     * Absolute number is calculated from percentage by rounding down.
+     * This can not be 0 if `maxSurge` is 0.
+     *
+     * Example: when this is set to 30%, the old ReplicaSet can be scaled down to 70% of desired
+     * pods immediately when the rolling update starts. Once new pods are ready, old ReplicaSet can
+     * be scaled down further, followed by scaling up the new ReplicaSet, ensuring that the total
+     * number of pods available at all times during the update is at least 70% of desired pods.
+     *
+     * @default '25%'
+     */
+    readonly maxUnavailable?: PercentOrAbsolute;
+}
+/**
+ * Union like class repsenting either a ration in
+ * percents or an absolute number.
+ */
+export declare class PercentOrAbsolute {
+    readonly value: any;
+    /**
+     * Percent ratio.
+     */
+    static percent(percent: number): PercentOrAbsolute;
+    /**
+     * Absolute number.
+     */
+    static absolute(num: number): PercentOrAbsolute;
+    private constructor();
+    isZero(): boolean;
+}
+/**
+ * Deployment strategies.
+ */
+export declare class DeploymentStrategy {
+    private readonly strategy;
+    /**
+     * All existing Pods are killed before new ones are created.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#recreate-deployment
+     */
+    static recreate(): DeploymentStrategy;
+    static rollingUpdate(options?: DeploymentStrategyRollingUpdateOptions): DeploymentStrategy;
+    private constructor();
+    /**
+     * @internal
+     */
+    _toKube(): k8s.DeploymentStrategy;
+}

package/lib/deployment.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 = __importStar(require("./container"));
+const k8s = __importStar(require("./imports/k8s"));
+const service = __importStar(require("./service"));
+const workload = __importStar(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 {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Deployment", version: "2.0.0" };
+    /**
+     * Number of desired pods.
+     */
+    replicas;
+    /**
+     * Minimum duration for which a newly created pod should be ready without
+     * any of its container crashing, for it to be considered available.
+     */
+    minReady;
+    /**
+     * The maximum duration for a deployment to make progress before it is considered to be failed.
+     */
+    progressDeadline;
+    /*
+     * The upgrade strategy of this deployment.
+     */
+    strategy;
+    /**
+     * Number of desired replicasets history.
+     *
+     * @default 10
+     */
+    revisionHistoryLimit;
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'deployments';
+    hasAutoscaler = false;
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        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;
+/**
+ * Union like class repsenting either a ration in
+ * percents or an absolute number.
+ */
+class PercentOrAbsolute {
+    value;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.PercentOrAbsolute", version: "2.0.0" };
+    /**
+     * 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;
+/**
+ * Deployment strategies.
+ */
+class DeploymentStrategy {
+    strategy;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.DeploymentStrategy", version: "2.0.0" };
+    /**
+     * 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;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment.js","sourceRoot":"","sources":["../src/deployment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAkD;AAElD,uDAAyC;AAEzC,mDAAqC;AAErC,mDAAqC;AACrC,qDAAuC;AAsFvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,UAAW,SAAQ,QAAQ,CAAC,QAAQ;;IAE/C;;OAEG;IACa,QAAQ,CAAU;IAElC;;;OAGG;IACa,QAAQ,CAAW;IAEnC;;OAEG;IACa,gBAAgB,CAAW;IAE3C;;OAEG;IACa,QAAQ,CAAqB;IAE7C;;;;OAIG;IAEM,oBAAoB,CAAS;IACtC;;OAEG;IACgB,SAAS,CAAY;IAExB,YAAY,GAAG,aAAa,CAAC;IAEtC,aAAa,GAAG,KAAK,CAAC;IAE7B,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAyB,EAAE;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,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;IAgBQ;;IAdpC;;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;IA4BQ;;IA1BrC;;;;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;
+}