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
376 lines (375 loc) • 13.2 kB
TypeScript
import { ApiObject, Size } from 'cdk8s';
import { Construct } from 'constructs';
import * as base from './base';
import * as k8s from './imports/k8s';
import * as pvc from './pvc';
import * as volume from './volume';
/**
* Contract of a `PersistentVolumeClaim`.
*/
export interface IPersistentVolume extends base.IResource {
}
/**
* Properties for `PersistentVolume`.
*/
export interface PersistentVolumeProps extends base.ResourceProps {
/**
* Contains all ways the volume can be mounted.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes
* @default - No access modes.
*/
readonly accessModes?: pvc.PersistentVolumeAccessMode[];
/**
* What is the storage capacity of this volume.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
* @default - No specified.
*/
readonly storage?: Size;
/**
* Part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim.
* Expected to be non-nil when bound.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding
* @default - Not bound to a specific claim.
*/
readonly claim?: pvc.IPersistentVolumeClaim;
/**
* A list of mount options, e.g. ["ro", "soft"]. Not validated - mount will simply fail if one is invalid.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options
* @default - No options.
*/
readonly mountOptions?: string[];
/**
* When a user is done with their volume, they can delete the PVC objects from the API that
* allows reclamation of the resource. The reclaim policy tells the cluster what to do with
* the volume after it has been released of its claim.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming
* @default PersistentVolumeReclaimPolicy.RETAIN
*/
readonly reclaimPolicy?: PersistentVolumeReclaimPolicy;
/**
* Name of StorageClass to which this persistent volume belongs.
*
* @default - Volume does not belong to any storage class.
*/
readonly storageClassName?: string;
/**
* Defines what type of volume is required by the claim.
*
* @default VolumeMode.FILE_SYSTEM
*/
readonly volumeMode?: pvc.PersistentVolumeMode;
}
/**
* A PersistentVolume (PV) is a piece of storage in the cluster that has been
* provisioned by an administrator or dynamically provisioned using Storage Classes.
* It is a resource in the cluster just like a node is a cluster resource.
* PVs are volume plugins like Volumes, but have a lifecycle independent of any
* individual Pod that uses the PV. This API object captures the details of the
* implementation of the storage, be that NFS, iSCSI, or a
* cloud-provider-specific storage system.
*/
export declare class PersistentVolume extends base.Resource implements IPersistentVolume, volume.IStorage {
/**
* Imports a pv from the cluster as a reference.
*/
static fromPersistentVolumeName(scope: Construct, id: string, volumeName: string): IPersistentVolume;
/**
* @see base.Resource.apiObject
*/
protected readonly apiObject: ApiObject;
readonly resourceType = "persistentvolumes";
private _claim?;
/**
* Storage size of this volume.
*/
readonly storage?: Size;
/**
* Volume mode of this volume.
*/
readonly mode: pvc.PersistentVolumeMode;
/**
* Storage class this volume belongs to.
*/
readonly storageClassName?: string;
/**
* Access modes requirement of this claim.
*/
private readonly _accessModes?;
/**
* Mount options of this volume.
*/
readonly mountOptions?: string[];
/**
* Reclaim policy of this volume.
*/
readonly reclaimPolicy: PersistentVolumeReclaimPolicy;
protected constructor(scope: Construct, id: string, props?: PersistentVolumeProps);
/**
* Access modes requirement of this claim.
*/
get accessModes(): pvc.PersistentVolumeAccessMode[] | undefined;
/**
* PVC this volume is bound to. Undefined means this volume is not yet
* claimed by any PVC.
*/
get claim(): pvc.IPersistentVolumeClaim | undefined;
/**
* Reserve a `PersistentVolume` by creating a `PersistentVolumeClaim`
* that is wired to claim this volume.
*
* Note that this method will throw in case the volume is already claimed.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#reserving-a-persistentvolume
*/
reserve(): pvc.PersistentVolumeClaim;
/**
* Bind a volume to a specific claim.
* Note that you must also bind the claim to the volume.
*
* @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding
*
* @param claim The PVC to bind to.
*/
bind(claim: pvc.IPersistentVolumeClaim): void;
asVolume(): volume.Volume;
/**
* @internal
*/
_toKube(): k8s.PersistentVolumeSpec;
}
/**
* Reclaim Policies.
*/
export declare enum PersistentVolumeReclaimPolicy {
/**
* The Retain reclaim policy allows for manual reclamation of the resource.
* When the PersistentVolumeClaim is deleted, the PersistentVolume still exists and the
* volume is considered "released". But it is not yet available for another claim
* because the previous claimant's data remains on the volume.
* An administrator can manually reclaim the volume with the following steps:
*
* 1. Delete the PersistentVolume. The associated storage asset in external
* infrastructure (such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume) still exists after the PV is deleted.
* 2. Manually clean up the data on the associated storage asset accordingly.
* 3. Manually delete the associated storage asset.
*
* If you want to reuse the same storage asset, create a new PersistentVolume
* with the same storage asset definition.
*/
RETAIN = "Retain",
/**
* For volume plugins that support the Delete reclaim policy, deletion removes both the
* PersistentVolume object from Kubernetes, as well as the associated storage asset in
* the external infrastructure, such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume.
* Volumes that were dynamically provisioned inherit the reclaim policy of their StorageClass, which defaults to Delete.
* The administrator should configure the StorageClass according to users' expectations; otherwise,
* the PV must be edited or patched after it is created
*/
DELETE = "Delete"
}
/**
* Properties for `AwsElasticBlockStorePersistentVolume`.
*/
export interface AwsElasticBlockStorePersistentVolumeProps extends PersistentVolumeProps {
/**
* Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
*/
readonly volumeId: string;
/**
* Filesystem type of the volume that you want to mount.
* Tip: Ensure that the filesystem type is supported by the host operating system.
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
* @default 'ext4'
*/
readonly fsType?: string;
/**
* The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.
* Examples: For volume /dev/sda1, you specify the partition as "1".
* Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty).
*
* @default - No partition.
*/
readonly partition?: number;
/**
* Specify "true" to force and set the ReadOnly property in VolumeMounts to "true".
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
* @default false
*/
readonly readOnly?: boolean;
}
/**
* Represents an AWS Disk resource that is attached to a kubelet's host machine and
* then exposed to the pod.
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
*/
export declare class AwsElasticBlockStorePersistentVolume extends PersistentVolume {
/**
* Volume id of this volume.
*/
readonly volumeId: string;
/**
* Whether or not it is mounted as a read-only volume.
*/
readonly readOnly: boolean;
/**
* File system type of this volume.
*/
readonly fsType: string;
/**
* Partition of this volume.
*/
readonly partition?: number;
constructor(scope: Construct, id: string, props: AwsElasticBlockStorePersistentVolumeProps);
/**
* @internal
*/
_toKube(): k8s.PersistentVolumeSpec;
}
/**
* Properties for `AzureDiskPersistentVolume`.
*/
export interface AzureDiskPersistentVolumeProps extends PersistentVolumeProps {
/**
* The Name of the data disk in the blob storage
*/
readonly diskName: string;
/**
* The URI the data disk in the blob storage
*/
readonly diskUri: string;
/**
* Host Caching mode.
*
* @default - AzureDiskPersistentVolumeCachingMode.NONE.
*/
readonly cachingMode?: volume.AzureDiskPersistentVolumeCachingMode;
/**
* Filesystem type to mount. Must be a filesystem type supported by the host operating system.
*
* @default 'ext4'
*/
readonly fsType?: string;
/**
* Kind of disk.
*
* @default AzureDiskPersistentVolumeKind.SHARED
*/
readonly kind?: volume.AzureDiskPersistentVolumeKind;
/**
* Force the ReadOnly setting in VolumeMounts.
*
* @default false
*/
readonly readOnly?: boolean;
}
/**
* AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.
*/
export declare class AzureDiskPersistentVolume extends PersistentVolume {
/**
* Disk name of this volume.
*/
readonly diskName: string;
/**
* Disk URI of this volume.
*/
readonly diskUri: string;
/**
* Whether or not it is mounted as a read-only volume.
*/
readonly readOnly: boolean;
/**
* Caching mode of this volume.
*/
readonly cachingMode: volume.AzureDiskPersistentVolumeCachingMode;
/**
* File system type of this volume.
*/
readonly fsType: string;
/**
* Azure kind of this volume.
*/
readonly azureKind: volume.AzureDiskPersistentVolumeKind;
constructor(scope: Construct, id: string, props: AzureDiskPersistentVolumeProps);
/**
* @internal
*
* @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md
*/
_toKube(): k8s.PersistentVolumeSpec;
}
/**
* Properties for `GCEPersistentDiskPersistentVolume`.
*/
export interface GCEPersistentDiskPersistentVolumeProps extends PersistentVolumeProps {
/**
* Unique name of the PD resource in GCE. Used to identify the disk in GCE.
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
*/
readonly pdName: string;
/**
* Filesystem type of the volume that you want to mount.
* Tip: Ensure that the filesystem type is supported by the host operating system.
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
* @default 'ext4'
*/
readonly fsType?: string;
/**
* The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.
* Examples: For volume /dev/sda1, you specify the partition as "1".
* Similarly, the volume partition for /dev/sda is "0" (or you can leave the property empty).
*
* @default - No partition.
*/
readonly partition?: number;
/**
* Specify "true" to force and set the ReadOnly property in VolumeMounts to "true".
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
* @default false
*/
readonly readOnly?: boolean;
}
/**
* GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine
* and then exposed to the pod. Provisioned by an admin.
*
* @see https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
*/
export declare class GCEPersistentDiskPersistentVolume extends PersistentVolume {
/**
* PD resource in GCE of this volume.
*/
readonly pdName: string;
/**
* Whether or not it is mounted as a read-only volume.
*/
readonly readOnly: boolean;
/**
* File system type of this volume.
*/
readonly fsType: string;
/**
* Partition of this volume.
*/
readonly partition?: number;
constructor(scope: Construct, id: string, props: GCEPersistentDiskPersistentVolumeProps);
/**
* @internal
*
* @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md
*/
_toKube(): k8s.PersistentVolumeSpec;
}