cdk8s-plus-25
Version:
cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-25 synthesizes Kubernetes manifests for Kubernetes 1.25.0
224 lines (223 loc) • 8.54 kB
TypeScript
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;
}