cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/volume.js

@@ -0,0 +1,377 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostPathVolumeType = exports.AzureDiskPersistentVolumeCachingMode = exports.AzureDiskPersistentVolumeKind = exports.EmptyDirMedium = exports.Volume = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const k8s = require("./imports/k8s");
+/**
+ * Volume represents a named volume in a pod that may be accessed by any
+ * container in the pod.
+ *
+ * Docker also has a concept of volumes, though it is somewhat looser and less
+ * managed. In Docker, a volume is simply a directory on disk or in another
+ * Container. Lifetimes are not managed and until very recently there were only
+ * local-disk-backed volumes. Docker now provides volume drivers, but the
+ * functionality is very limited for now (e.g. as of Docker 1.7 only one volume
+ * driver is allowed per Container and there is no way to pass parameters to
+ * volumes).
+ *
+ * A Kubernetes volume, on the other hand, has an explicit lifetime - the same
+ * as the Pod that encloses it. Consequently, a volume outlives any Containers
+ * that run within the Pod, and data is preserved across Container restarts. Of
+ * course, when a Pod ceases to exist, the volume will cease to exist, too.
+ * Perhaps more importantly than this, Kubernetes supports many types of
+ * volumes, and a Pod can use any number of them simultaneously.
+ *
+ * At its core, a volume is just a directory, possibly with some data in it,
+ * which is accessible to the Containers in a Pod. How that directory comes to
+ * be, the medium that backs it, and the contents of it are determined by the
+ * particular volume type used.
+ *
+ * To use a volume, a Pod specifies what volumes to provide for the Pod (the
+ * .spec.volumes field) and where to mount those into Containers (the
+ * .spec.containers[*].volumeMounts field).
+ *
+ * A process in a container sees a filesystem view composed from their Docker
+ * image and volumes. The Docker image is at the root of the filesystem
+ * hierarchy, and any volumes are mounted at the specified paths within the
+ * image. Volumes can not mount onto other volumes
+ */
+class Volume extends constructs_1.Construct {
+    /**
+     * Mounts an Amazon Web Services (AWS) EBS volume into your pod.
+     * Unlike emptyDir, which is erased when a pod is removed, the contents of an EBS volume are
+     * persisted and the volume is unmounted. This means that an EBS volume can be pre-populated with data,
+     * and that data can be shared between pods.
+     *
+     * There are some restrictions when using an awsElasticBlockStore volume:
+     *
+     * - the nodes on which pods are running must be AWS EC2 instances.
+     * - those instances need to be in the same region and availability zone as the EBS volume.
+     * - EBS only supports a single EC2 instance mounting a volume.
+     */
+    static fromAwsElasticBlockStore(scope, id, volumeId, options = {}) {
+        return new Volume(scope, id, options.name ?? `ebs-${volumeId}`, {
+            awsElasticBlockStore: {
+                volumeId,
+                fsType: options.fsType ?? 'ext4',
+                partition: options.partition,
+                readOnly: options.readOnly ?? false,
+            },
+        });
+    }
+    /**
+     * Mounts a Microsoft Azure Data Disk into a pod.
+     */
+    static fromAzureDisk(scope, id, diskName, diskUri, options = {}) {
+        return new Volume(scope, id, options.name ?? `azuredisk-${diskName}`, {
+            azureDisk: {
+                diskName,
+                diskUri,
+                cachingMode: options.cachingMode ?? AzureDiskPersistentVolumeCachingMode.NONE,
+                fsType: options.fsType ?? 'ext4',
+                kind: options.kind ?? AzureDiskPersistentVolumeKind.SHARED,
+                readOnly: options.readOnly ?? false,
+            },
+        });
+    }
+    /**
+     * Mounts a Google Compute Engine (GCE) persistent disk (PD) into your Pod.
+     * Unlike emptyDir, which is erased when a pod is removed, the contents of a PD are
+     * preserved and the volume is merely unmounted. This means that a PD can be pre-populated
+     * with data, and that data can be shared between pods.
+     *
+     * There are some restrictions when using a gcePersistentDisk:
+     *
+     * - the nodes on which Pods are running must be GCE VMs
+     * - those VMs need to be in the same GCE project and zone as the persistent disk
+     */
+    static fromGcePersistentDisk(scope, id, pdName, options = {}) {
+        return new Volume(scope, id, options.name ?? `gcedisk-${pdName}`, {
+            gcePersistentDisk: {
+                pdName,
+                fsType: options.fsType ?? 'ext4',
+                partition: options.partition,
+                readOnly: options.readOnly ?? false,
+            },
+        });
+    }
+    /**
+     * Populate the volume from a ConfigMap.
+     *
+     * The configMap resource provides a way to inject configuration data into
+     * Pods. The data stored in a ConfigMap object can be referenced in a volume
+     * of type configMap and then consumed by containerized applications running
+     * in a Pod.
+     *
+     * When referencing a configMap object, you can simply provide its name in the
+     * volume to reference it. You can also customize the path to use for a
+     * specific entry in the ConfigMap.
+     *
+     * @param configMap The config map to use to populate the volume.
+     * @param options Options
+     */
+    static fromConfigMap(scope, id, configMap, options = {}) {
+        return new Volume(scope, id, options.name ?? `configmap-${configMap.name}`, {
+            configMap: {
+                name: configMap.name,
+                defaultMode: options.defaultMode,
+                optional: options.optional,
+                items: Volume.renderItems(options.items),
+            },
+        });
+    }
+    /**
+     * An emptyDir volume is first created when a Pod is assigned to a Node, and
+     * exists as long as that Pod is running on that node. As the name says, it is
+     * initially empty. Containers in the Pod can all read and write the same
+     * files in the emptyDir volume, though that volume can be mounted at the same
+     * or different paths in each Container. When a Pod is removed from a node for
+     * any reason, the data in the emptyDir is deleted forever.
+     *
+     * @see http://kubernetes.io/docs/user-guide/volumes#emptydir
+     *
+     * @param options - Additional options.
+     */
+    static fromEmptyDir(scope, id, name, options = {}) {
+        return new Volume(scope, id, name, {
+            emptyDir: {
+                medium: options.medium,
+                sizeLimit: options.sizeLimit
+                    ? k8s.Quantity.fromString(`${options.sizeLimit.toMebibytes()}Mi`)
+                    : undefined,
+            },
+        });
+    }
+    /**
+     * Populate the volume from a Secret.
+     *
+     * A secret volume is used to pass sensitive information, such as passwords, to Pods.
+     * You can store secrets in the Kubernetes API and mount them as files for use by pods
+     * without coupling to Kubernetes directly.
+     *
+     * secret volumes are backed by tmpfs (a RAM-backed filesystem)
+     * so they are never written to non-volatile storage.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#secret
+     *
+     * @param secr The secret to use to populate the volume.
+     * @param options Options
+     */
+    static fromSecret(scope, id, secr, options = {}) {
+        return new Volume(scope, id, options.name ?? `secret-${secr.name}`, {
+            secret: {
+                secretName: secr.name,
+                defaultMode: options.defaultMode,
+                optional: options.optional,
+                items: Volume.renderItems(options.items),
+            },
+        });
+    }
+    /**
+     * Used to mount a PersistentVolume into a Pod.
+     * PersistentVolumeClaims are a way for users to "claim" durable storage (such as a GCE PersistentDisk or an iSCSI volume)
+     * without knowing the details of the particular cloud environment.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/
+     */
+    static fromPersistentVolumeClaim(scope, id, claim, options = {}) {
+        return new Volume(scope, id, options.name ?? `pvc-${claim.name}`, {
+            persistentVolumeClaim: {
+                claimName: claim.name,
+                readOnly: options.readOnly ?? false,
+            },
+        });
+    }
+    /**
+     * Used to mount a file or directory from the host node's filesystem into a Pod.
+     * This is not something that most Pods will need, but it offers a powerful
+     * escape hatch for some applications.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath
+     */
+    static fromHostPath(scope, id, name, options) {
+        return new Volume(scope, id, name, {
+            hostPath: {
+                path: options.path,
+                type: options.type ?? HostPathVolumeType.DEFAULT,
+            },
+        });
+    }
+    /**
+     * Used to mount an NFS share into a Pod.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/volumes/#nfs
+     */
+    static fromNfs(scope, id, name, options) {
+        return new Volume(scope, id, name, {
+            nfs: {
+                server: options.server,
+                path: options.path,
+                readOnly: options.readOnly,
+            },
+        });
+    }
+    /**
+     * Populate the volume from a CSI driver, for example the Secrets Store CSI
+     * Driver: https://secrets-store-csi-driver.sigs.k8s.io/introduction.html.
+     * Which in turn needs an associated provider to source the secrets, such as
+     * the AWS Secrets Manager and Systems Manager Parameter Store provider:
+     * https://aws.github.io/secrets-store-csi-driver-provider-aws/.
+     *
+     * @param driver The name of the CSI driver to use to populate the volume.
+     * @param options Options for the CSI volume, including driver-specific ones.
+     */
+    static fromCsi(scope, id, driver, options = {}) {
+        return new Volume(scope, id, options.name ?? cdk8s_1.Names.toDnsLabel(scope, { extra: [id] }), {
+            csi: {
+                driver: driver,
+                fsType: options.fsType,
+                readOnly: options.readOnly,
+                volumeAttributes: options.attributes,
+            },
+        });
+    }
+    /**
+     * Create a volume with an arbitrary name and no configuration.
+     */
+    static fromName(scope, id, name) {
+        return new Volume(scope, id, name, {});
+    }
+    constructor(scope, id, name, config) {
+        super(scope, id);
+        this.name = name;
+        this.config = config;
+        this.name = name.slice(0, 63);
+    }
+    asVolume() {
+        return this;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            name: this.name,
+            ...this.config,
+        };
+    }
+}
+exports.Volume = Volume;
+_a = JSII_RTTI_SYMBOL_1;
+Volume[_a] = { fqn: "cdk8s-plus-34.Volume", version: "2.0.0" };
+/**
+ * @internal
+ */
+Volume.renderItems = (items) => {
+    if (!items) {
+        return undefined;
+    }
+    const result = new Array();
+    for (const key of Object.keys(items).sort()) {
+        result.push({
+            key,
+            path: items[key].path,
+            mode: items[key].mode,
+        });
+    }
+    return result;
+};
+/**
+ * The medium on which to store the volume.
+ */
+var EmptyDirMedium;
+(function (EmptyDirMedium) {
+    /**
+     * The default volume of the backing node.
+     */
+    EmptyDirMedium["DEFAULT"] = "";
+    /**
+     * Mount a tmpfs (RAM-backed filesystem) for you instead. While tmpfs is very
+     * fast, be aware that unlike disks, tmpfs is cleared on node reboot and any
+     * files you write will count against your Container's memory limit.
+     */
+    EmptyDirMedium["MEMORY"] = "Memory";
+})(EmptyDirMedium || (exports.EmptyDirMedium = EmptyDirMedium = {}));
+/**
+ * Azure Disk kinds.
+ */
+var AzureDiskPersistentVolumeKind;
+(function (AzureDiskPersistentVolumeKind) {
+    /**
+     * Multiple blob disks per storage account.
+     */
+    AzureDiskPersistentVolumeKind["SHARED"] = "Shared";
+    /**
+     * Single blob disk per storage account.
+     */
+    AzureDiskPersistentVolumeKind["DEDICATED"] = "Dedicated";
+    /**
+     * Azure managed data disk.
+     */
+    AzureDiskPersistentVolumeKind["MANAGED"] = "Managed";
+})(AzureDiskPersistentVolumeKind || (exports.AzureDiskPersistentVolumeKind = AzureDiskPersistentVolumeKind = {}));
+/**
+ * Azure disk caching modes.
+ */
+var AzureDiskPersistentVolumeCachingMode;
+(function (AzureDiskPersistentVolumeCachingMode) {
+    /**
+     * None.
+     */
+    AzureDiskPersistentVolumeCachingMode["NONE"] = "None";
+    /**
+     * ReadOnly.
+     */
+    AzureDiskPersistentVolumeCachingMode["READ_ONLY"] = "ReadOnly";
+    /**
+     * ReadWrite.
+     */
+    AzureDiskPersistentVolumeCachingMode["READ_WRITE"] = "ReadWrite";
+})(AzureDiskPersistentVolumeCachingMode || (exports.AzureDiskPersistentVolumeCachingMode = AzureDiskPersistentVolumeCachingMode = {}));
+/**
+ * Host path types.
+ */
+var HostPathVolumeType;
+(function (HostPathVolumeType) {
+    /**
+     * Empty string (default) is for backward compatibility, which means that no
+     * checks will be performed before mounting the hostPath volume.
+     */
+    HostPathVolumeType["DEFAULT"] = "";
+    /**
+     * If nothing exists at the given path, an empty directory will be created
+     * there as needed with permission set to 0755, having the same group and
+     * ownership with Kubelet.
+     */
+    HostPathVolumeType["DIRECTORY_OR_CREATE"] = "DirectoryOrCreate";
+    /**
+     * A directory must exist at the given path.
+     */
+    HostPathVolumeType["DIRECTORY"] = "Directory";
+    /**
+     * If nothing exists at the given path, an empty file will be created there
+     * as needed with permission set to 0644, having the same group and ownership
+     * with Kubelet.
+     */
+    HostPathVolumeType["FILE_OR_CREATE"] = "FileOrCreate";
+    /**
+     * A file must exist at the given path.
+     */
+    HostPathVolumeType["FILE"] = "File";
+    /**
+     * A UNIX socket must exist at the given path.
+     */
+    HostPathVolumeType["SOCKET"] = "Socket";
+    /**
+     * A character device must exist at the given path.
+     */
+    HostPathVolumeType["CHAR_DEVICE"] = "CharDevice";
+    /**
+     * A block device must exist at the given path.
+     */
+    HostPathVolumeType["BLOCK_DEVICE"] = "BlockDevice";
+})(HostPathVolumeType || (exports.HostPathVolumeType = HostPathVolumeType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"volume.js","sourceRoot":"","sources":["../src/volume.ts"],"names":[],"mappings":"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","sourcesContent":["import { Names, Size } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport * as configmap from './config-map';\nimport * as k8s from './imports/k8s';\nimport * as pvc from './pvc';\nimport * as secret from './secret';\n\n/**\n * Represents a piece of storage in the cluster.\n */\nexport interface IStorage extends IConstruct {\n\n  /**\n   * Convert the piece of storage into a concrete volume.\n   */\n  asVolume(): Volume;\n}\n\n/**\n * Volume represents a named volume in a pod that may be accessed by any\n * container in the pod.\n *\n * Docker also has a concept of volumes, though it is somewhat looser and less\n * managed. In Docker, a volume is simply a directory on disk or in another\n * Container. Lifetimes are not managed and until very recently there were only\n * local-disk-backed volumes. Docker now provides volume drivers, but the\n * functionality is very limited for now (e.g. as of Docker 1.7 only one volume\n * driver is allowed per Container and there is no way to pass parameters to\n * volumes).\n *\n * A Kubernetes volume, on the other hand, has an explicit lifetime - the same\n * as the Pod that encloses it. Consequently, a volume outlives any Containers\n * that run within the Pod, and data is preserved across Container restarts. Of\n * course, when a Pod ceases to exist, the volume will cease to exist, too.\n * Perhaps more importantly than this, Kubernetes supports many types of\n * volumes, and a Pod can use any number of them simultaneously.\n *\n * At its core, a volume is just a directory, possibly with some data in it,\n * which is accessible to the Containers in a Pod. How that directory comes to\n * be, the medium that backs it, and the contents of it are determined by the\n * particular volume type used.\n *\n * To use a volume, a Pod specifies what volumes to provide for the Pod (the\n * .spec.volumes field) and where to mount those into Containers (the\n * .spec.containers[*].volumeMounts field).\n *\n * A process in a container sees a filesystem view composed from their Docker\n * image and volumes. The Docker image is at the root of the filesystem\n * hierarchy, and any volumes are mounted at the specified paths within the\n * image. Volumes can not mount onto other volumes\n */\nexport class Volume extends Construct implements IStorage {\n\n  /**\n   * Mounts an Amazon Web Services (AWS) EBS volume into your pod.\n   * Unlike emptyDir, which is erased when a pod is removed, the contents of an EBS volume are\n   * persisted and the volume is unmounted. This means that an EBS volume can be pre-populated with data,\n   * and that data can be shared between pods.\n   *\n   * There are some restrictions when using an awsElasticBlockStore volume:\n   *\n   * - the nodes on which pods are running must be AWS EC2 instances.\n   * - those instances need to be in the same region and availability zone as the EBS volume.\n   * - EBS only supports a single EC2 instance mounting a volume.\n   */\n  public static fromAwsElasticBlockStore(scope: Construct, id: string, volumeId: string, options: AwsElasticBlockStoreVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `ebs-${volumeId}`, {\n      awsElasticBlockStore: {\n        volumeId,\n        fsType: options.fsType ?? 'ext4',\n        partition: options.partition,\n        readOnly: options.readOnly ?? false,\n      },\n    });\n  }\n\n  /**\n   * Mounts a Microsoft Azure Data Disk into a pod.\n   */\n  public static fromAzureDisk(scope: Construct, id: string, diskName: string, diskUri: string, options: AzureDiskVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `azuredisk-${diskName}`, {\n      azureDisk: {\n        diskName,\n        diskUri,\n        cachingMode: options.cachingMode ?? AzureDiskPersistentVolumeCachingMode.NONE,\n        fsType: options.fsType ?? 'ext4',\n        kind: options.kind ?? AzureDiskPersistentVolumeKind.SHARED,\n        readOnly: options.readOnly ?? false,\n      },\n    });\n  }\n\n  /**\n   * Mounts a Google Compute Engine (GCE) persistent disk (PD) into your Pod.\n   * Unlike emptyDir, which is erased when a pod is removed, the contents of a PD are\n   * preserved and the volume is merely unmounted. This means that a PD can be pre-populated\n   * with data, and that data can be shared between pods.\n   *\n   * There are some restrictions when using a gcePersistentDisk:\n   *\n   * - the nodes on which Pods are running must be GCE VMs\n   * - those VMs need to be in the same GCE project and zone as the persistent disk\n   */\n  public static fromGcePersistentDisk(scope: Construct, id: string, pdName: string, options: GCEPersistentDiskVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `gcedisk-${pdName}`, {\n      gcePersistentDisk: {\n        pdName,\n        fsType: options.fsType ?? 'ext4',\n        partition: options.partition,\n        readOnly: options.readOnly ?? false,\n      },\n    });\n  }\n\n  /**\n   * Populate the volume from a ConfigMap.\n   *\n   * The configMap resource provides a way to inject configuration data into\n   * Pods. The data stored in a ConfigMap object can be referenced in a volume\n   * of type configMap and then consumed by containerized applications running\n   * in a Pod.\n   *\n   * When referencing a configMap object, you can simply provide its name in the\n   * volume to reference it. You can also customize the path to use for a\n   * specific entry in the ConfigMap.\n   *\n   * @param configMap The config map to use to populate the volume.\n   * @param options Options\n   */\n  public static fromConfigMap(scope: Construct, id: string, configMap: configmap.IConfigMap, options: ConfigMapVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `configmap-${configMap.name}`, {\n      configMap: {\n        name: configMap.name,\n        defaultMode: options.defaultMode,\n        optional: options.optional,\n        items: Volume.renderItems(options.items),\n      },\n    });\n  }\n\n  /**\n   * An emptyDir volume is first created when a Pod is assigned to a Node, and\n   * exists as long as that Pod is running on that node. As the name says, it is\n   * initially empty. Containers in the Pod can all read and write the same\n   * files in the emptyDir volume, though that volume can be mounted at the same\n   * or different paths in each Container. When a Pod is removed from a node for\n   * any reason, the data in the emptyDir is deleted forever.\n   *\n   * @see http://kubernetes.io/docs/user-guide/volumes#emptydir\n   *\n   * @param options - Additional options.\n   */\n  public static fromEmptyDir(scope: Construct, id: string, name: string, options: EmptyDirVolumeOptions = {}): Volume {\n    return new Volume(scope, id, name, {\n      emptyDir: {\n        medium: options.medium,\n        sizeLimit: options.sizeLimit\n          ? k8s.Quantity.fromString(`${options.sizeLimit.toMebibytes()}Mi`)\n          : undefined,\n      },\n    });\n  }\n\n  /**\n   * Populate the volume from a Secret.\n   *\n   * A secret volume is used to pass sensitive information, such as passwords, to Pods.\n   * You can store secrets in the Kubernetes API and mount them as files for use by pods\n   * without coupling to Kubernetes directly.\n   *\n   * secret volumes are backed by tmpfs (a RAM-backed filesystem)\n   * so they are never written to non-volatile storage.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes/#secret\n   *\n   * @param secr The secret to use to populate the volume.\n   * @param options Options\n   */\n  public static fromSecret(scope: Construct, id: string, secr: secret.ISecret, options: SecretVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `secret-${secr.name}`, {\n      secret: {\n        secretName: secr.name,\n        defaultMode: options.defaultMode,\n        optional: options.optional,\n        items: Volume.renderItems(options.items),\n      },\n    });\n  }\n\n  /**\n   * Used to mount a PersistentVolume into a Pod.\n   * PersistentVolumeClaims are a way for users to \"claim\" durable storage (such as a GCE PersistentDisk or an iSCSI volume)\n   * without knowing the details of the particular cloud environment.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/\n   */\n  public static fromPersistentVolumeClaim(\n    scope: Construct, id: string,\n    claim: pvc.IPersistentVolumeClaim,\n    options: PersistentVolumeClaimVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? `pvc-${claim.name}`, {\n      persistentVolumeClaim: {\n        claimName: claim.name,\n        readOnly: options.readOnly ?? false,\n      },\n    });\n  }\n\n  /**\n   * Used to mount a file or directory from the host node's filesystem into a Pod.\n   * This is not something that most Pods will need, but it offers a powerful\n   * escape hatch for some applications.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes/#hostpath\n   */\n  public static fromHostPath(scope: Construct, id: string, name: string, options: HostPathVolumeOptions): Volume {\n    return new Volume(scope, id, name, {\n      hostPath: {\n        path: options.path,\n        type: options.type ?? HostPathVolumeType.DEFAULT,\n      },\n    });\n  }\n\n  /**\n   * Used to mount an NFS share into a Pod.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes/#nfs\n   */\n  public static fromNfs(scope: Construct, id: string, name: string, options: NfsVolumeOptions): Volume {\n    return new Volume(scope, id, name, {\n      nfs: {\n        server: options.server,\n        path: options.path,\n        readOnly: options.readOnly,\n      },\n    });\n  }\n\n  /**\n   * Populate the volume from a CSI driver, for example the Secrets Store CSI\n   * Driver: https://secrets-store-csi-driver.sigs.k8s.io/introduction.html.\n   * Which in turn needs an associated provider to source the secrets, such as\n   * the AWS Secrets Manager and Systems Manager Parameter Store provider:\n   * https://aws.github.io/secrets-store-csi-driver-provider-aws/.\n   *\n   * @param driver The name of the CSI driver to use to populate the volume.\n   * @param options Options for the CSI volume, including driver-specific ones.\n   */\n  public static fromCsi(scope: Construct, id: string, driver: string, options: CsiVolumeOptions = {}): Volume {\n    return new Volume(scope, id, options.name ?? Names.toDnsLabel(scope, { extra: [id] }), {\n      csi: {\n        driver: driver,\n        fsType: options.fsType,\n        readOnly: options.readOnly,\n        volumeAttributes: options.attributes,\n      },\n    });\n  }\n\n  /**\n   * Create a volume with an arbitrary name and no configuration.\n   */\n  public static fromName(scope: Construct, id: string, name: string): Volume {\n    return new Volume(scope, id, name, {});\n  }\n\n  /**\n   * @internal\n   */\n  private static renderItems = (items?: { [key: string]: PathMapping }): undefined | Array<k8s.KeyToPath> => {\n    if (!items) {\n      return undefined;\n    }\n    const result = new Array<k8s.KeyToPath>();\n    for (const key of Object.keys(items).sort()) {\n      result.push({\n        key,\n        path: items[key].path,\n        mode: items[key].mode,\n      });\n    }\n    return result;\n  };\n\n\n  private constructor(\n    scope: Construct, id: string,\n    public readonly name: string,\n    private readonly config: Omit<k8s.Volume, 'name'>) {\n    super(scope, id);\n    this.name = name.slice(0, 63);\n  }\n\n  public asVolume(): Volume {\n    return this;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.Volume {\n    return {\n      name: this.name,\n      ...this.config,\n    };\n  }\n}\n\n/**\n * Options of `Volume.fromGcePersistentDisk`.\n */\nexport interface GCEPersistentDiskVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * Filesystem type of the volume that you want to mount.\n   * Tip: Ensure that the filesystem type is supported by the host operating system.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default 'ext4'\n   */\n  readonly fsType?: string;\n\n  /**\n   * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.\n   * Examples: For volume /dev/sda1, you specify the partition as \"1\".\n   * Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).\n   *\n   * @default - No partition.\n   */\n  readonly partition?: number;\n\n  /**\n   * Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\".\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default false\n   */\n  readonly readOnly?: boolean;\n\n}\n\n/**\n * Options of `Volume.fromAzureDisk`.\n */\nexport interface AzureDiskVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * Host Caching mode.\n   *\n   * @default - AzureDiskPersistentVolumeCachingMode.NONE.\n   */\n  readonly cachingMode?: AzureDiskPersistentVolumeCachingMode;\n\n  /**\n   * Filesystem type to mount. Must be a filesystem type supported by the host operating system.\n   *\n   * @default 'ext4'\n   */\n  readonly fsType?: string;\n\n  /**\n   * Kind of disk.\n   *\n   * @default AzureDiskPersistentVolumeKind.SHARED\n   */\n  readonly kind?: AzureDiskPersistentVolumeKind;\n\n  /**\n   * Force the ReadOnly setting in VolumeMounts.\n   *\n   * @default false\n   */\n  readonly readOnly?: boolean;\n}\n\n/**\n * Options of `Volume.fromAwsElasticBlockStore`.\n */\nexport interface AwsElasticBlockStoreVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * Filesystem type of the volume that you want to mount.\n   * Tip: Ensure that the filesystem type is supported by the host operating system.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default 'ext4'\n   */\n  readonly fsType?: string;\n\n  /**\n   * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.\n   * Examples: For volume /dev/sda1, you specify the partition as \"1\".\n   * Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).\n   *\n   * @default - No partition.\n   */\n  readonly partition?: number;\n\n  /**\n   * Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\".\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default false\n   */\n  readonly readOnly?: boolean;\n}\n\n/**\n * Options for the ConfigMap-based volume.\n */\nexport interface ConfigMapVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * Mode bits to use on created files by default. Must be a value between 0 and\n   * 0777. Defaults to 0644. Directories within the path are not affected by\n   * this setting. This might be in conflict with other options that affect the\n   * file mode, like fsGroup, and the result can be other mode bits set.\n   *\n   * @default 0644. Directories within the path are not affected by this\n   * setting. This might be in conflict with other options that affect the file\n   * mode, like fsGroup, and the result can be other mode bits set.\n   */\n  readonly defaultMode?: number;\n\n  /**\n   * Specify whether the ConfigMap or its keys must be defined.\n   * @default - undocumented\n   */\n  readonly optional?: boolean;\n\n  /**\n   * If unspecified, each key-value pair in the Data field of the referenced\n   * ConfigMap will be projected into the volume as a file whose name is the key\n   * and content is the value. If specified, the listed keys will be projected\n   * into the specified paths, and unlisted keys will not be present. If a key\n   * is specified which is not present in the ConfigMap, the volume setup will\n   * error unless it is marked optional. Paths must be relative and may not\n   * contain the '..' path or start with '..'.\n   *\n   * @default - no mapping\n   */\n  readonly items?: { [key: string]: PathMapping };\n}\n\n/**\n * Maps a string key to a path within a volume.\n */\nexport interface PathMapping {\n  /**\n   * The relative path of the file to map the key to. May not be an absolute\n   * path. May not contain the path element '..'. May not start with the string\n   * '..'.\n   */\n  readonly path: string;\n\n  /**\n   * Optional: mode bits to use on this file, must be a value between 0 and\n   * 0777. If not specified, the volume defaultMode will be used. This might be\n   * in conflict with other options that affect the file mode, like fsGroup, and\n   * the result can be other mode bits set.\n   */\n  readonly mode?: number;\n}\n\n/**\n * Options for volumes populated with an empty directory.\n */\nexport interface EmptyDirVolumeOptions {\n  /**\n   * By default, emptyDir volumes are stored on whatever medium is backing the\n   * node - that might be disk or SSD or network storage, depending on your\n   * environment. However, you can set the emptyDir.medium field to\n   * `EmptyDirMedium.MEMORY` to tell Kubernetes to mount a tmpfs (RAM-backed\n   * filesystem) for you instead. While tmpfs is very fast, be aware that unlike\n   * disks, tmpfs is cleared on node reboot and any files you write will count\n   * against your Container's memory limit.\n   *\n   * @default EmptyDirMedium.DEFAULT\n   */\n  readonly medium?: EmptyDirMedium;\n\n  /**\n   * Total amount of local storage required for this EmptyDir volume. The size\n   * limit is also applicable for memory medium. The maximum usage on memory\n   * medium EmptyDir would be the minimum value between the SizeLimit specified\n   * here and the sum of memory limits of all containers in a pod.\n   *\n   * @default - limit is undefined\n   */\n  readonly sizeLimit?: Size;\n}\n\n/**\n * The medium on which to store the volume.\n */\nexport enum EmptyDirMedium {\n  /**\n   * The default volume of the backing node.\n   */\n  DEFAULT = '',\n\n  /**\n   * Mount a tmpfs (RAM-backed filesystem) for you instead. While tmpfs is very\n   * fast, be aware that unlike disks, tmpfs is cleared on node reboot and any\n   * files you write will count against your Container's memory limit.\n   */\n  MEMORY = 'Memory',\n}\n\n/**\n * Options for a PersistentVolumeClaim-based volume.\n */\nexport interface PersistentVolumeClaimVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - Derived from the PVC name.\n   */\n  readonly name?: string;\n\n  /**\n   * Will force the ReadOnly setting in VolumeMounts.\n   *\n   * @default false\n   */\n  readonly readOnly?: boolean;\n\n}\n\n/**\n * Options for the Secret-based volume.\n */\nexport interface SecretVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * Mode bits to use on created files by default. Must be a value between 0 and\n   * 0777. Defaults to 0644. Directories within the path are not affected by\n   * this setting. This might be in conflict with other options that affect the\n   * file mode, like fsGroup, and the result can be other mode bits set.\n   *\n   * @default 0644. Directories within the path are not affected by this\n   * setting. This might be in conflict with other options that affect the file\n   * mode, like fsGroup, and the result can be other mode bits set.\n   */\n  readonly defaultMode?: number;\n\n  /**\n   * Specify whether the secret or its keys must be defined.\n   * @default - undocumented\n   */\n  readonly optional?: boolean;\n\n  /**\n   * If unspecified, each key-value pair in the Data field of the referenced\n   * secret will be projected into the volume as a file whose name is the key\n   * and content is the value. If specified, the listed keys will be projected\n   * into the specified paths, and unlisted keys will not be present. If a key\n   * is specified which is not present in the secret, the volume setup will\n   * error unless it is marked optional. Paths must be relative and may not\n   * contain the '..' path or start with '..'.\n   *\n   * @default - no mapping\n   */\n  readonly items?: { [key: string]: PathMapping };\n\n}\n\n/**\n * Azure Disk kinds.\n */\nexport enum AzureDiskPersistentVolumeKind {\n\n  /**\n   * Multiple blob disks per storage account.\n   */\n  SHARED = 'Shared',\n\n  /**\n   * Single blob disk per storage account.\n   */\n  DEDICATED = 'Dedicated',\n\n  /**\n   * Azure managed data disk.\n   */\n  MANAGED = 'Managed',\n}\n\n/**\n * Azure disk caching modes.\n */\nexport enum AzureDiskPersistentVolumeCachingMode {\n\n  /**\n   * None.\n   */\n  NONE = 'None',\n\n  /**\n   * ReadOnly.\n   */\n  READ_ONLY = 'ReadOnly',\n\n  /**\n   * ReadWrite.\n   */\n  READ_WRITE = 'ReadWrite',\n}\n\n/**\n * Options for a HostPathVolume-based volume.\n */\nexport interface HostPathVolumeOptions {\n  /**\n   * The path of the directory on the host.\n   */\n  readonly path: string;\n\n  /**\n   * The expected type of the path found on the host.\n   *\n   * @default HostPathVolumeType.DEFAULT\n   */\n  readonly type?: HostPathVolumeType;\n\n}\n\n/**\n * Host path types.\n */\nexport enum HostPathVolumeType {\n  /**\n   * Empty string (default) is for backward compatibility, which means that no\n   * checks will be performed before mounting the hostPath volume.\n   */\n  DEFAULT = '',\n\n  /**\n   * If nothing exists at the given path, an empty directory will be created\n   * there as needed with permission set to 0755, having the same group and\n   * ownership with Kubelet.\n   */\n  DIRECTORY_OR_CREATE = 'DirectoryOrCreate',\n\n  /**\n   * A directory must exist at the given path.\n   */\n  DIRECTORY = 'Directory',\n\n  /**\n   * If nothing exists at the given path, an empty file will be created there\n   * as needed with permission set to 0644, having the same group and ownership\n   * with Kubelet.\n   */\n  FILE_OR_CREATE = 'FileOrCreate',\n\n  /**\n   * A file must exist at the given path.\n   */\n  FILE = 'File',\n\n  /**\n   * A UNIX socket must exist at the given path.\n   */\n  SOCKET = 'Socket',\n\n  /**\n   * A character device must exist at the given path.\n   */\n  CHAR_DEVICE = 'CharDevice',\n\n  /**\n   * A block device must exist at the given path.\n   */\n  BLOCK_DEVICE = 'BlockDevice',\n}\n\n/**\n * Options for the NFS based volume.\n */\nexport interface NfsVolumeOptions {\n\n  /**\n   * Server is the hostname or IP address of the NFS server.\n   */\n  readonly server: string;\n\n  /**\n   * If set to true, will force the NFS export to be mounted with read-only permissions.\n   *\n   * @default - false\n   */\n  readonly readOnly?: boolean;\n\n  /**\n   * Path that is exported by the NFS server\n   */\n  readonly path: string;\n}\n\n/**\n * Options for the CSI driver based volume.\n */\nexport interface CsiVolumeOptions {\n  /**\n   * The volume name.\n   *\n   * @default - auto-generated\n   */\n  readonly name?: string;\n\n  /**\n   * The filesystem type to mount. Ex. \"ext4\", \"xfs\", \"ntfs\". If not provided,\n   * the empty value is passed to the associated CSI driver, which will\n   * determine the default filesystem to apply.\n   *\n   * @default - driver-dependent\n   */\n  readonly fsType?: string;\n\n  /**\n   * Whether the mounted volume should be read-only or not.\n   *\n   * @default - false\n   */\n  readonly readOnly?: boolean;\n\n  /**\n   * Any driver-specific attributes to pass to the CSI volume builder.\n   *\n   * @default - undefined\n   */\n  readonly attributes?: { [key: string]: string };\n}\n"]}

package/lib/workload.d.ts

@@ -0,0 +1,121 @@
+import { ApiObjectMetadata, ApiObjectMetadataDefinition } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as k8s from './imports/k8s';
+import * as pod from './pod';
+/**
+ * Properties for `Workload`.
+ */
+export interface WorkloadProps extends pod.AbstractPodProps {
+    /**
+     * The pod metadata of this workload.
+     */
+    readonly podMetadata?: ApiObjectMetadata;
+    /**
+     * Automatically allocates a pod label selector for this workload and add
+     * it to the pod metadata. This ensures this workload manages pods created by
+     * its pod template.
+     *
+     * @default true
+     */
+    readonly select?: boolean;
+    /**
+     * Automatically spread pods across hostname and zones.
+     *
+     * @see https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/#internal-default-constraints
+     * @default false
+     */
+    readonly spread?: boolean;
+}
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ */
+export interface LabelSelectorRequirement {
+    /**
+     * The label key that the selector applies to.
+     */
+    readonly key: string;
+    /**
+     * Represents a key's relationship to a set of values.
+     */
+    readonly operator: string;
+    /**
+     * An array of string values. If the operator is In or NotIn, the values array
+     * must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic merge patch.
+     */
+    readonly values?: string[];
+}
+/**
+ * A workload is an application running on Kubernetes. Whether your workload is a single
+ * component or several that work together, on Kubernetes you run it inside a set of pods.
+ * In Kubernetes, a Pod represents a set of running containers on your cluster.
+ */
+export declare abstract class Workload extends pod.AbstractPod {
+    readonly connections: pod.PodConnections;
+    readonly scheduling: WorkloadScheduling;
+    private readonly spread;
+    private readonly _matchLabels;
+    private readonly _matchExpressions;
+    private _podMetadata?;
+    private readonly _props;
+    private readonly _matcher;
+    constructor(scope: Construct, id: string, props: WorkloadProps);
+    /**
+     * The metadata of pods in this workload.
+     */
+    get podMetadata(): ApiObjectMetadataDefinition;
+    /**
+     * Configure selectors for this workload.
+     */
+    select(...selectors: pod.LabelSelector[]): void;
+    /**
+     * The label matchers this workload will use in order to select pods.
+     *
+     * Returns a a copy. Use `select()` to add label matchers.
+     */
+    get matchLabels(): Record<string, string>;
+    /**
+     * The expression matchers this workload will use in order to select pods.
+     *
+     * Returns a a copy. Use `select()` to add expression matchers.
+     */
+    get matchExpressions(): LabelSelectorRequirement[];
+    /**
+     * @internal
+     */
+    _toLabelSelector(): k8s.LabelSelector;
+    /**
+     * @internal
+     */
+    _toPodSpec(): k8s.PodSpec;
+}
+/**
+ * Options for `WorkloadScheduling.spread`.
+ */
+export interface WorkloadSchedulingSpreadOptions {
+    /**
+     * Indicates the spread is optional, with this weight score.
+     *
+     * @default - no weight. spread is assumed to be required.
+     */
+    readonly weight?: number;
+    /**
+     * Which topology to spread on.
+     *
+     * @default - Topology.HOSTNAME
+     */
+    readonly topology?: pod.Topology;
+}
+/**
+ * Controls the pod scheduling strategy of this workload.
+ * It offers some additional API's on top of the core pod scheduling.
+ */
+export declare class WorkloadScheduling extends pod.PodScheduling {
+    /**
+     * Spread the pods in this workload by the topology key.
+     * A spread is a separation of the pod from itself and is used to
+     * balance out pod replicas across a given topology.
+     */
+    spread(options?: WorkloadSchedulingSpreadOptions): void;
+}