cdk8s-plus-29
Version:
cdk8s+ is a software development framework that provides high level abstractions for authoring Kubernetes applications. cdk8s-plus-29 synthesizes Kubernetes manifests for Kubernetes 1.29.0
174 lines • 24.3 kB
JavaScript
"use strict";
var _a, _b;
Object.defineProperty(exports, "__esModule", { value: true });
exports.StatefulSetUpdateStrategy = exports.StatefulSet = exports.PodManagementPolicy = 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");
/**
* Controls how pods are created during initial scale up, when replacing pods on nodes,
* or when scaling down.
*
* The default policy is `OrderedReady`, where pods are created in increasing order
* (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before
* continuing. When scaling down, the pods are removed in the opposite order.
*
* The alternative policy is `Parallel` which will create pods in parallel to match the
* desired scale without waiting, and on scale down will delete all pods at once.
*/
var PodManagementPolicy;
(function (PodManagementPolicy) {
PodManagementPolicy["ORDERED_READY"] = "OrderedReady";
PodManagementPolicy["PARALLEL"] = "Parallel";
})(PodManagementPolicy || (exports.PodManagementPolicy = PodManagementPolicy = {}));
/**
* StatefulSet is the workload API object used to manage stateful applications.
*
* Manages the deployment and scaling of a set of Pods, and provides guarantees
* about the ordering and uniqueness of these Pods.
*
* Like a Deployment, a StatefulSet manages Pods that are based on an identical
* container spec. Unlike a Deployment, a StatefulSet maintains a sticky identity
* for each of their Pods. These pods are created from the same spec, but are not
* interchangeable: each has a persistent identifier that it maintains across any
* rescheduling.
*
* If you want to use storage volumes to provide persistence for your workload, you
* can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet
* are susceptible to failure, the persistent Pod identifiers make it easier to match existing
* volumes to the new Pods that replace any that have failed.
*
* Using StatefulSets
* ------------------
* StatefulSets are valuable for applications that require one or more of the following.
*
* - Stable, unique network identifiers.
* - Stable, persistent storage.
* - Ordered, graceful deployment and scaling.
* - Ordered, automated rolling updates.
*/
class StatefulSet extends workload.Workload {
constructor(scope, id, props) {
super(scope, id, props);
this.resourceType = 'statefulsets';
this.hasAutoscaler = false;
this.apiObject = new k8s.KubeStatefulSet(this, 'Resource', {
metadata: props.metadata,
spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
});
this.service = props.service ?? this._createHeadlessService();
this.apiObject.addDependency(this.service);
this.replicas = props.replicas;
this.strategy = props.strategy ?? StatefulSetUpdateStrategy.rollingUpdate(),
this.podManagementPolicy = props.podManagementPolicy ?? PodManagementPolicy.ORDERED_READY;
this.minReady = props.minReady ?? cdk8s_1.Duration.seconds(0);
this.service.select(this);
if (this.isolate) {
this.connections.isolate();
}
}
_createHeadlessService() {
const myPorts = container.extractContainerPorts(this);
const myPortNumbers = myPorts.map(p => p.number);
const 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 create a service for the stateful set ${this.name}: StatefulSet ports cannot be determined.`);
}
// 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 stateful set ${this.name} via a service: Port ${targetPort} is not exposed by any container`);
}
}
const metadata = { namespace: this.metadata.namespace };
return new service.Service(this, 'Service', {
selector: this,
ports,
metadata,
clusterIP: 'None',
type: service.ServiceType.CLUSTER_IP,
});
}
/**
* @internal
*/
_toKube() {
return {
replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 1),
serviceName: this.service.name,
minReadySeconds: this.minReady.toSeconds(),
template: {
metadata: this.podMetadata.toJson(),
spec: this._toPodSpec(),
},
selector: this._toLabelSelector(),
podManagementPolicy: this.podManagementPolicy,
updateStrategy: this.strategy._toKube(),
};
}
/**
* @see IScalable.markHasAutoscaler()
*/
markHasAutoscaler() {
this.hasAutoscaler = true;
}
/**
* @see IScalable.toScalingTarget()
*/
toScalingTarget() {
return {
kind: this.apiObject.kind,
apiVersion: this.apiObject.apiVersion,
name: this.name,
containers: this.containers,
replicas: this.replicas,
};
}
}
exports.StatefulSet = StatefulSet;
_a = JSII_RTTI_SYMBOL_1;
StatefulSet[_a] = { fqn: "cdk8s-plus-29.StatefulSet", version: "2.6.0" };
/**
* StatefulSet update strategies.
*/
class StatefulSetUpdateStrategy {
/**
* The controller will not automatically update the Pods in a StatefulSet.
* Users must manually delete Pods to cause the controller to create new Pods
* that reflect modifications.
*/
static onDelete() {
return new StatefulSetUpdateStrategy({
type: 'OnDelete',
});
}
/**
* The controller will delete and recreate each Pod in the StatefulSet.
* It will proceed in the same order as Pod termination (from the largest ordinal to the smallest),
* updating each Pod one at a time. The Kubernetes control plane waits until an updated
* Pod is Running and Ready prior to updating its predecessor.
*/
static rollingUpdate(options = {}) {
return new StatefulSetUpdateStrategy({
type: 'RollingUpdate',
rollingUpdate: { partition: options.partition ?? 0 },
});
}
constructor(strategy) {
this.strategy = strategy;
}
/**
* @internal
*/
_toKube() {
return this.strategy;
}
}
exports.StatefulSetUpdateStrategy = StatefulSetUpdateStrategy;
_b = JSII_RTTI_SYMBOL_1;
StatefulSetUpdateStrategy[_b] = { fqn: "cdk8s-plus-29.StatefulSetUpdateStrategy", version: "2.6.0" };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateful-set.js","sourceRoot":"","sources":["../src/stateful-set.ts"],"names":[],"mappings":"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","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 service from './service';\nimport * as workload from './workload';\n\n/**\n * Controls how pods are created during initial scale up, when replacing pods on nodes,\n * or when scaling down.\n *\n * The default policy is `OrderedReady`, where pods are created in increasing order\n * (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before\n * continuing. When scaling down, the pods are removed in the opposite order.\n *\n * The alternative policy is `Parallel` which will create pods in parallel to match the\n * desired scale without waiting, and on scale down will delete all pods at once.\n */\nexport enum PodManagementPolicy {\n  ORDERED_READY = 'OrderedReady',\n  PARALLEL = 'Parallel',\n}\n\n/**\n * Properties for initialization of `StatefulSet`.\n */\nexport interface StatefulSetProps extends workload.WorkloadProps {\n  /**\n   * Service to associate with the statefulset.\n   *\n   * @default - A new headless service will be created.\n   */\n  readonly service?: service.Service;\n\n  /**\n    * Number of desired pods.\n    *\n    * @default 1\n    */\n  readonly replicas?: number;\n\n  /**\n    * Pod management policy to use for this statefulset.\n    *\n    * @default PodManagementPolicy.ORDERED_READY\n    */\n  readonly podManagementPolicy?: PodManagementPolicy;\n\n  /**\n   * Indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.\n   *\n   * @default - RollingUpdate with partition set to 0\n   */\n  readonly strategy?: StatefulSetUpdateStrategy;\n\n  /**\n   * Minimum duration for which a newly created pod should be ready without any of its container crashing,\n   * for it to be considered available. Zero means the pod will be considered available as soon as it is ready.\n   *\n   * This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.\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\n/**\n * StatefulSet is the workload API object used to manage stateful applications.\n *\n * Manages the deployment and scaling of a set of Pods, and provides guarantees\n * about the ordering and uniqueness of these Pods.\n *\n * Like a Deployment, a StatefulSet manages Pods that are based on an identical\n * container spec. Unlike a Deployment, a StatefulSet maintains a sticky identity\n * for each of their Pods. These pods are created from the same spec, but are not\n * interchangeable: each has a persistent identifier that it maintains across any\n * rescheduling.\n *\n * If you want to use storage volumes to provide persistence for your workload, you\n * can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet\n * are susceptible to failure, the persistent Pod identifiers make it easier to match existing\n * volumes to the new Pods that replace any that have failed.\n *\n * Using StatefulSets\n * ------------------\n * StatefulSets are valuable for applications that require one or more of the following.\n *\n * - Stable, unique network identifiers.\n * - Stable, persistent storage.\n * - Ordered, graceful deployment and scaling.\n * - Ordered, automated rolling updates.\n */\nexport class StatefulSet extends workload.Workload implements IScalable {\n  /**\n    * Number of desired pods.\n    */\n  public readonly replicas?: number;\n\n  /**\n    * Management policy to use for the set.\n    */\n  public readonly podManagementPolicy: PodManagementPolicy;\n\n  /**\n   * The update startegy of this stateful set.\n   */\n  public readonly strategy: StatefulSetUpdateStrategy;\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    * @see base.Resource.apiObject\n    */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'statefulsets';\n\n  public hasAutoscaler = false;\n\n  public readonly service: service.Service;\n\n  constructor(scope: Construct, id: string, props: StatefulSetProps) {\n    super(scope, id, props);\n\n    this.apiObject = new k8s.KubeStatefulSet(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n    this.service = props.service ?? this._createHeadlessService();\n\n    this.apiObject.addDependency(this.service);\n\n    this.replicas = props.replicas;\n    this.strategy = props.strategy ?? StatefulSetUpdateStrategy.rollingUpdate(),\n    this.podManagementPolicy = props.podManagementPolicy ?? PodManagementPolicy.ORDERED_READY;\n    this.minReady = props.minReady ?? Duration.seconds(0);\n\n    this.service.select(this);\n\n    if (this.isolate) {\n      this.connections.isolate();\n    }\n\n  }\n\n  private _createHeadlessService() {\n\n    const myPorts = container.extractContainerPorts(this);\n    const myPortNumbers = myPorts.map(p => p.number);\n    const ports: service.ServicePort[] = myPorts.map(p => ({ port: p.number, targetPort: p.number, protocol: p.protocol, name: p.name }));\n    if (ports.length === 0) {\n      throw new Error(`Unable to create a service for the stateful set ${this.name}: StatefulSet ports cannot be determined.`);\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 stateful set ${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    return new service.Service(this, 'Service', {\n      selector: this,\n      ports,\n      metadata,\n      clusterIP: 'None',\n      type: service.ServiceType.CLUSTER_IP,\n    });\n\n  }\n\n  /**\n    * @internal\n    */\n  public _toKube(): k8s.StatefulSetSpec {\n    return {\n      replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 1),\n      serviceName: this.service.name,\n      minReadySeconds: this.minReady.toSeconds(),\n      template: {\n        metadata: this.podMetadata.toJson(),\n        spec: this._toPodSpec(),\n      },\n      selector: this._toLabelSelector(),\n      podManagementPolicy: this.podManagementPolicy,\n      updateStrategy: this.strategy._toKube(),\n    };\n  }\n\n  /**\n   * @see IScalable.markHasAutoscaler()\n   */\n  public markHasAutoscaler() {\n    this.hasAutoscaler = true;\n  }\n\n  /**\n   * @see IScalable.toScalingTarget()\n   */\n  public toScalingTarget(): ScalingTarget {\n    return {\n      kind: this.apiObject.kind,\n      apiVersion: this.apiObject.apiVersion,\n      name: this.name,\n      containers: this.containers,\n      replicas: this.replicas,\n    };\n  }\n}\n\n/**\n * Options for `StatefulSetUpdateStrategy.rollingUpdate`.\n */\nexport interface StatefulSetUpdateStrategyRollingUpdateOptions {\n\n  /**\n   * If specified, all Pods with an ordinal that is greater than or equal to the partition will\n   * be updated when the StatefulSet's .spec.template is updated. All Pods with an ordinal that\n   * is less than the partition will not be updated, and, even if they are deleted, they will be\n   * recreated at the previous version.\n   *\n   * If the partition is greater than replicas, updates to the pod template will not be propagated to Pods.\n   * In most cases you will not need to use a partition, but they are useful if you want to stage an\n   * update, roll out a canary, or perform a phased roll out.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#partitions\n   * @default 0\n   */\n  readonly partition?: number;\n\n}\n\n/**\n * StatefulSet update strategies.\n */\nexport class StatefulSetUpdateStrategy {\n\n  /**\n   * The controller will not automatically update the Pods in a StatefulSet.\n   * Users must manually delete Pods to cause the controller to create new Pods\n   * that reflect modifications.\n   */\n  public static onDelete(): StatefulSetUpdateStrategy {\n    return new StatefulSetUpdateStrategy({\n      type: 'OnDelete',\n    });\n  }\n\n  /**\n   * The controller will delete and recreate each Pod in the StatefulSet.\n   * It will proceed in the same order as Pod termination (from the largest ordinal to the smallest),\n   * updating each Pod one at a time. The Kubernetes control plane waits until an updated\n   * Pod is Running and Ready prior to updating its predecessor.\n   */\n  public static rollingUpdate(options: StatefulSetUpdateStrategyRollingUpdateOptions = {}): StatefulSetUpdateStrategy {\n\n    return new StatefulSetUpdateStrategy({\n      type: 'RollingUpdate',\n      rollingUpdate: { partition: options.partition ?? 0 },\n    });\n  }\n\n  private constructor(private readonly strategy: k8s.StatefulSetUpdateStrategy) {}\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.StatefulSetUpdateStrategy {\n    return this.strategy;\n  }\n\n}\n"]}