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
371 lines • 53.3 kB
JavaScript
"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,
},
});
}
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-29.Volume", version: "2.6.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,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