cdk8s-plus-31 2.0.0

package/lib/cron-job.d.ts

@@ -0,0 +1,138 @@
+import { ApiObject, Duration, Cron } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as k8s from './imports/k8s';
+import { JobProps } from './job';
+import * as workload from './workload';
+/**
+ * Concurrency policy for CronJobs.
+ */
+export declare enum ConcurrencyPolicy {
+    /**
+     * This policy allows to run job concurrently.
+     */
+    ALLOW = "Allow",
+    /**
+     * This policy does not allow to run job concurrently. It does not let a new job to be scheduled if the previous one is not finished yet.
+     */
+    FORBID = "Forbid",
+    /**
+     * This policy replaces the currently running job if a new job is being scheduled.
+     */
+    REPLACE = "Replace"
+}
+/**
+ * Properties for `CronJob`.
+ */
+export interface CronJobProps extends JobProps {
+    /**
+     * Specifies the time in which the job would run again. This is defined as a cron expression in the CronJob resource.
+     */
+    readonly schedule: Cron;
+    /**
+     * Specifies the timezone for the job. This helps aligining the schedule to follow the specified timezone.
+     *
+     * @see {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones} for list of valid timezone values.
+     *
+     * @default - Timezone of kube-controller-manager process.
+     */
+    readonly timeZone?: string;
+    /**
+     * Specifies the concurrency policy for the job.
+     *
+     * @default ConcurrencyPolicy.Forbid
+     */
+    readonly concurrencyPolicy?: ConcurrencyPolicy;
+    /**
+     * Kubernetes attempts to start cron jobs at its schedule time, but this is not guaranteed. This deadline specifies
+     * how much time can pass after a schedule point, for which kubernetes can still start the job.
+     * For example, if this is set to 100 seconds, kubernetes is allowed to start the job at a maximum 100 seconds after
+     * the scheduled time.
+     *
+     * Note that the Kubernetes CronJobController checks for things every 10 seconds, for this reason, a deadline below 10
+     * seconds is not allowed, as it may cause your job to never be scheduled.
+     *
+     * In addition, kubernetes will stop scheduling jobs if more than 100 schedules were missed (for any reason).
+     * This property also controls what time interval should kubernetes consider when counting for missed schedules.
+     *
+     * For example, suppose a CronJob is set to schedule a new Job every one minute beginning at 08:30:00,
+     * and its `startingDeadline` field is not set. If the CronJob controller happens to be down from 08:29:00 to 10:21:00,
+     * the job will not start as the number of missed jobs which missed their schedule is greater than 100.
+     * However, if `startingDeadline` is set to 200 seconds, kubernetes will only count 3 missed schedules, and thus
+     * start a new execution at 10:22:00.
+     *
+     * @default Duration.seconds(10)
+     */
+    readonly startingDeadline?: Duration;
+    /**
+     * Specifies if the cron job should be suspended. Only applies to future executions, current ones are remained untouched.
+     *
+     * @default false
+     */
+    readonly suspend?: boolean;
+    /**
+     * Specifies the number of successful jobs history retained. This would retain the Job and the associated Pod resource and can be useful for debugging.
+     *
+     * @default 3
+     */
+    readonly successfulJobsRetained?: number;
+    /**
+     * Specifies the number of failed jobs history retained. This would retain the Job and the associated Pod resource and can be useful for debugging.
+     *
+     * @default 1
+     */
+    readonly failedJobsRetained?: number;
+}
+/**
+ * A CronJob is responsible for creating a Job and scheduling it based on provided cron schedule. This helps running Jobs in a recurring manner.
+ */
+export declare class CronJob extends workload.Workload {
+    /**
+     * The schedule this cron job is scheduled to run in.
+     */
+    readonly schedule: Cron;
+    /**
+     * The timezone which this cron job would follow to schedule jobs.
+     */
+    readonly timeZone?: string;
+    /**
+     * The policy used by this cron job to determine the concurrency mode in which to schedule jobs.
+     */
+    readonly concurrencyPolicy: string;
+    /**
+     * The time by which the running cron job needs to schedule the next job execution. The job is considered as failed if it misses this deadline.
+     */
+    readonly startingDeadline: Duration;
+    /**
+     * Whether or not the cron job is currently suspended or not.
+     */
+    readonly suspend: boolean;
+    /**
+     * The number of successful jobs retained by this cron job.
+     */
+    readonly successfulJobsRetained: number;
+    /**
+     * The number of failed jobs retained by this cron job.
+     */
+    readonly failedJobsRetained: number;
+    /**
+     * The properties of the recurring `Job` that this cronjob will schedule.
+     */
+    private readonly jobProperties;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    /**
+     * Represents the resource type.
+     */
+    readonly resourceType = "cronjob";
+    constructor(scope: Construct, id: string, props: CronJobProps);
+    /**
+     * @internal
+     */
+    _toKube(): k8s.CronJobSpec;
+    /**
+     * Returns the job spec.
+     */
+    private _toJobSpec;
+}

package/lib/cron-job.js

@@ -0,0 +1,103 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJob = exports.ConcurrencyPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const k8s = require("./imports/k8s");
+const pod_1 = require("./pod");
+const workload = require("./workload");
+/**
+ * Concurrency policy for CronJobs.
+ */
+var ConcurrencyPolicy;
+(function (ConcurrencyPolicy) {
+    /**
+     * This policy allows to run job concurrently.
+     */
+    ConcurrencyPolicy["ALLOW"] = "Allow";
+    /**
+     * This policy does not allow to run job concurrently. It does not let a new job to be scheduled if the previous one is not finished yet.
+     */
+    ConcurrencyPolicy["FORBID"] = "Forbid";
+    /**
+     * This policy replaces the currently running job if a new job is being scheduled.
+     */
+    ConcurrencyPolicy["REPLACE"] = "Replace";
+})(ConcurrencyPolicy = exports.ConcurrencyPolicy || (exports.ConcurrencyPolicy = {}));
+/**
+ * A CronJob is responsible for creating a Job and scheduling it based on provided cron schedule. This helps running Jobs in a recurring manner.
+ */
+class CronJob extends workload.Workload {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            restartPolicy: pod_1.RestartPolicy.NEVER,
+            select: false,
+            ...props,
+        });
+        /**
+         * Represents the resource type.
+         */
+        this.resourceType = 'cronjob';
+        this.apiObject = new k8s.KubeCronJob(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        if (props.startingDeadline != undefined && props.startingDeadline.toSeconds() < 10) {
+            throw new Error(`The 'startingDeadline' property cannot be less than 10 seconds since the Kubernetes CronJobController checks things every 10 seconds and hence the CronJob may not be scheduled. The value passed is: ${props.startingDeadline}`);
+        }
+        if (props.ttlAfterFinished != undefined && (props.successfulJobsRetained != undefined || props.failedJobsRetained != undefined)) {
+            throw new Error('The \'ttlAfterFinished\' property cannot be set if \'successfulJobsRetained\' property or \'failedJobsRetained\' property is set. This would cause the retention of jobs to not work properly since it would delete the job based on its value.');
+        }
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+        this.schedule = props.schedule;
+        this.timeZone = props.timeZone;
+        this.concurrencyPolicy = props.concurrencyPolicy ?? ConcurrencyPolicy.FORBID;
+        this.startingDeadline = props.startingDeadline ?? cdk8s_1.Duration.seconds(10);
+        this.suspend = props.suspend ?? false;
+        this.successfulJobsRetained = props.successfulJobsRetained ?? 3;
+        this.failedJobsRetained = props.failedJobsRetained ?? 1;
+        this.jobProperties = {
+            activeDeadline: props.activeDeadline,
+            backoffLimit: props.backoffLimit,
+            ttlAfterFinished: props.ttlAfterFinished,
+        };
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            concurrencyPolicy: this.concurrencyPolicy,
+            failedJobsHistoryLimit: this.failedJobsRetained,
+            jobTemplate: {
+                spec: this._toJobSpec(),
+            },
+            schedule: this.schedule.expressionString,
+            startingDeadlineSeconds: this.startingDeadline.toSeconds(),
+            successfulJobsHistoryLimit: this.successfulJobsRetained,
+            suspend: this.suspend,
+            timeZone: this.timeZone,
+        };
+    }
+    /**
+     * Returns the job spec.
+     */
+    _toJobSpec() {
+        return {
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            activeDeadlineSeconds: this.jobProperties.activeDeadline?.toSeconds(),
+            backoffLimit: this.jobProperties.backoffLimit,
+            ttlSecondsAfterFinished: this.jobProperties.ttlAfterFinished?.toSeconds(),
+        };
+    }
+}
+exports.CronJob = CronJob;
+_a = JSII_RTTI_SYMBOL_1;
+CronJob[_a] = { fqn: "cdk8s-plus-31.CronJob", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cron-job.js","sourceRoot":"","sources":["../src/cron-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Duration, Lazy, Cron } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as k8s from './imports/k8s';\nimport { JobProps } from './job';\nimport { RestartPolicy } from './pod';\nimport * as workload from './workload';\n\n/**\n * Concurrency policy for CronJobs.\n */\nexport enum ConcurrencyPolicy {\n  /**\n   * This policy allows to run job concurrently.\n   */\n  ALLOW = 'Allow',\n  /**\n   * This policy does not allow to run job concurrently. It does not let a new job to be scheduled if the previous one is not finished yet.\n   */\n  FORBID = 'Forbid',\n  /**\n   * This policy replaces the currently running job if a new job is being scheduled.\n   */\n  REPLACE = 'Replace',\n}\n\n/**\n * Properties for `CronJob`.\n */\nexport interface CronJobProps extends JobProps {\n  /**\n   * Specifies the time in which the job would run again. This is defined as a cron expression in the CronJob resource.\n   */\n  readonly schedule: Cron;\n\n  /**\n   * Specifies the timezone for the job. This helps aligining the schedule to follow the specified timezone.\n   *\n   * @see {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones} for list of valid timezone values.\n   *\n   * @default - Timezone of kube-controller-manager process.\n   */\n  readonly timeZone?: string;\n\n  /**\n   * Specifies the concurrency policy for the job.\n   *\n   * @default ConcurrencyPolicy.Forbid\n   */\n  readonly concurrencyPolicy?: ConcurrencyPolicy;\n\n  /**\n   * Kubernetes attempts to start cron jobs at its schedule time, but this is not guaranteed. This deadline specifies\n   * how much time can pass after a schedule point, for which kubernetes can still start the job.\n   * For example, if this is set to 100 seconds, kubernetes is allowed to start the job at a maximum 100 seconds after\n   * the scheduled time.\n   *\n   * Note that the Kubernetes CronJobController checks for things every 10 seconds, for this reason, a deadline below 10\n   * seconds is not allowed, as it may cause your job to never be scheduled.\n   *\n   * In addition, kubernetes will stop scheduling jobs if more than 100 schedules were missed (for any reason).\n   * This property also controls what time interval should kubernetes consider when counting for missed schedules.\n   *\n   * For example, suppose a CronJob is set to schedule a new Job every one minute beginning at 08:30:00,\n   * and its `startingDeadline` field is not set. If the CronJob controller happens to be down from 08:29:00 to 10:21:00,\n   * the job will not start as the number of missed jobs which missed their schedule is greater than 100.\n   * However, if `startingDeadline` is set to 200 seconds, kubernetes will only count 3 missed schedules, and thus\n   * start a new execution at 10:22:00.\n   *\n   * @default Duration.seconds(10)\n   */\n  readonly startingDeadline?: Duration;\n\n  /**\n   * Specifies if the cron job should be suspended. Only applies to future executions, current ones are remained untouched.\n   *\n   * @default false\n   */\n  readonly suspend?: boolean;\n\n  /**\n   * Specifies the number of successful jobs history retained. This would retain the Job and the associated Pod resource and can be useful for debugging.\n   *\n   * @default 3\n   */\n  readonly successfulJobsRetained?: number;\n\n  /**\n   * Specifies the number of failed jobs history retained. This would retain the Job and the associated Pod resource and can be useful for debugging.\n   *\n   * @default 1\n   */\n  readonly failedJobsRetained?: number;\n}\n\n/**\n * A CronJob is responsible for creating a Job and scheduling it based on provided cron schedule. This helps running Jobs in a recurring manner.\n */\nexport class CronJob extends workload.Workload {\n  /**\n   * The schedule this cron job is scheduled to run in.\n   */\n  public readonly schedule: Cron;\n\n  /**\n   * The timezone which this cron job would follow to schedule jobs.\n   */\n  public readonly timeZone?: string;\n\n  /**\n   * The policy used by this cron job to determine the concurrency mode in which to schedule jobs.\n   */\n  public readonly concurrencyPolicy: string;\n\n  /**\n   * The time by which the running cron job needs to schedule the next job execution. The job is considered as failed if it misses this deadline.\n   */\n  public readonly startingDeadline: Duration;\n\n  /**\n   * Whether or not the cron job is currently suspended or not.\n   */\n  public readonly suspend: boolean;\n\n  /**\n   * The number of successful jobs retained by this cron job.\n   */\n  public readonly successfulJobsRetained: number;\n\n  /**\n   * The number of failed jobs retained by this cron job.\n   */\n  public readonly failedJobsRetained: number;\n\n  /**\n   * The properties of the recurring `Job` that this cronjob will schedule.\n   */\n  private readonly jobProperties: JobProps;\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  /**\n   * Represents the resource type.\n   */\n  public readonly resourceType = 'cronjob';\n\n  constructor(scope: Construct, id: string, props: CronJobProps) {\n    super(scope, id, {\n      restartPolicy: RestartPolicy.NEVER,\n      select: false,\n      ...props,\n    });\n\n    this.apiObject = new k8s.KubeCronJob(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    if (props.startingDeadline != undefined && props.startingDeadline.toSeconds() < 10) {\n      throw new Error(`The 'startingDeadline' property cannot be less than 10 seconds since the Kubernetes CronJobController checks things every 10 seconds and hence the CronJob may not be scheduled. The value passed is: ${props.startingDeadline}`);\n    }\n\n    if (props.ttlAfterFinished != undefined && (props.successfulJobsRetained != undefined || props.failedJobsRetained != undefined)) {\n      throw new Error('The \\'ttlAfterFinished\\' property cannot be set if \\'successfulJobsRetained\\' property or \\'failedJobsRetained\\' property is set. This would cause the retention of jobs to not work properly since it would delete the job based on its value.');\n    }\n\n    if (this.isolate) {\n      this.connections.isolate();\n    }\n\n    this.schedule = props.schedule;\n    this.timeZone = props.timeZone;\n    this.concurrencyPolicy = props.concurrencyPolicy ?? ConcurrencyPolicy.FORBID;\n    this.startingDeadline = props.startingDeadline ?? Duration.seconds(10);\n    this.suspend = props.suspend ?? false;\n    this.successfulJobsRetained = props.successfulJobsRetained ?? 3;\n    this.failedJobsRetained = props.failedJobsRetained ?? 1;\n    this.jobProperties = {\n      activeDeadline: props.activeDeadline,\n      backoffLimit: props.backoffLimit,\n      ttlAfterFinished: props.ttlAfterFinished,\n    };\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.CronJobSpec {\n    return {\n      concurrencyPolicy: this.concurrencyPolicy,\n      failedJobsHistoryLimit: this.failedJobsRetained,\n      jobTemplate: {\n        spec: this._toJobSpec(),\n      },\n      schedule: this.schedule.expressionString,\n      startingDeadlineSeconds: this.startingDeadline.toSeconds(),\n      successfulJobsHistoryLimit: this.successfulJobsRetained,\n      suspend: this.suspend,\n      timeZone: this.timeZone,\n    };\n  }\n\n  /**\n   * Returns the job spec.\n   */\n  private _toJobSpec(): k8s.JobSpec {\n    return {\n      template: {\n        metadata: this.podMetadata.toJson(),\n        spec: this._toPodSpec(),\n      },\n      activeDeadlineSeconds: this.jobProperties.activeDeadline?.toSeconds(),\n      backoffLimit: this.jobProperties.backoffLimit,\n      ttlSecondsAfterFinished: this.jobProperties.ttlAfterFinished?.toSeconds(),\n    };\n  }\n}"]}

package/lib/daemon-set.d.ts

@@ -0,0 +1,45 @@
+import { ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as k8s from './imports/k8s';
+import * as workload from './workload';
+/**
+ * Properties for `DaemonSet`.
+ */
+export interface DaemonSetProps extends workload.WorkloadProps {
+    /**
+     * Minimum number of seconds for which a newly created pod should
+     * be ready without any of its container crashing, for it to be considered available.
+     *
+     * @default 0
+     */
+    readonly minReadySeconds?: number;
+}
+/**
+ * A DaemonSet ensures that all (or some) Nodes run a copy of a Pod.
+ * As nodes are added to the cluster, Pods are added to them.
+ * As nodes are removed from the cluster, those Pods are garbage collected.
+ * Deleting a DaemonSet will clean up the Pods it created.
+ *
+ * Some typical uses of a DaemonSet are:
+ *
+ * - running a cluster storage daemon on every node
+ * - running a logs collection daemon on every node
+ * - running a node monitoring daemon on every node
+ *
+ * In a simple case, one DaemonSet, covering all nodes, would be used for each type of daemon.
+ * A more complex setup might use multiple DaemonSets for a single type of daemon,
+ * but with different flags and/or different memory and cpu requests for different hardware types.
+ */
+export declare class DaemonSet extends workload.Workload {
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "daemonsets";
+    readonly minReadySeconds: number;
+    constructor(scope: Construct, id: string, props?: DaemonSetProps);
+    /**
+     * @internal
+     */
+    _toKube(): k8s.DaemonSetSpec;
+}

package/lib/daemon-set.js

@@ -0,0 +1,55 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonSet = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const k8s = require("./imports/k8s");
+const workload = require("./workload");
+/**
+ * A DaemonSet ensures that all (or some) Nodes run a copy of a Pod.
+ * As nodes are added to the cluster, Pods are added to them.
+ * As nodes are removed from the cluster, those Pods are garbage collected.
+ * Deleting a DaemonSet will clean up the Pods it created.
+ *
+ * Some typical uses of a DaemonSet are:
+ *
+ * - running a cluster storage daemon on every node
+ * - running a logs collection daemon on every node
+ * - running a node monitoring daemon on every node
+ *
+ * In a simple case, one DaemonSet, covering all nodes, would be used for each type of daemon.
+ * A more complex setup might use multiple DaemonSets for a single type of daemon,
+ * but with different flags and/or different memory and cpu requests for different hardware types.
+ */
+class DaemonSet extends workload.Workload {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.resourceType = 'daemonsets';
+        this.apiObject = new k8s.KubeDaemonSet(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.minReadySeconds = props.minReadySeconds ?? 0;
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            minReadySeconds: this.minReadySeconds,
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            selector: this._toLabelSelector(),
+        };
+    }
+}
+exports.DaemonSet = DaemonSet;
+_a = JSII_RTTI_SYMBOL_1;
+DaemonSet[_a] = { fqn: "cdk8s-plus-31.DaemonSet", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/deployment.d.ts

@@ -0,0 +1,223 @@
+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;
+}
+/**
+ * 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;
+    /**
+     * @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;
+}