Volume

kubernetes-1.26.11/staging/src/k8s.io/api/core/v1/types.go

// PersistentVolume (PV) is a storage resource provisioned by an administrator.
// It is analogous to a node.
// More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes
type PersistentVolume struct {
    metav1.TypeMeta `json:",inline"`
    // Standard object's metadata.
    // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
    // +optional
    metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

    // spec defines a specification of a persistent volume owned by the cluster.
    // Provisioned by an administrator.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumes
    // +optional
    Spec PersistentVolumeSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`

    // status represents the current information/status for the persistent volume.
    // Populated by the system.
    // Read-only.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistent-volumes
    // +optional
    Status PersistentVolumeStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}

// PersistentVolumeSpec is the specification of a persistent volume.
type PersistentVolumeSpec struct {
    // capacity is the description of the persistent volume's resources and capacity.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#capacity
    // +optional
    // 分配存储资源大小
    Capacity ResourceList `json:"capacity,omitempty" protobuf:"bytes,1,rep,name=capacity,casttype=ResourceList,castkey=ResourceName"`
    // persistentVolumeSource is the actual volume backing the persistent volume.
    // 该持久卷使用的类型，必须设置一个
    PersistentVolumeSource `json:",inline" protobuf:"bytes,2,opt,name=persistentVolumeSource"`
    // accessModes contains all ways the volume can be mounted.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes
    // +optional
    AccessModes []PersistentVolumeAccessMode `json:"accessModes,omitempty" protobuf:"bytes,3,rep,name=accessModes,casttype=PersistentVolumeAccessMode"`
    // claimRef is part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim.
    // Expected to be non-nil when bound.
    // claim.VolumeName is the authoritative bind between PV and PVC.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding
    // +optional
    // +structType=granular
    ClaimRef *ObjectReference `json:"claimRef,omitempty" protobuf:"bytes,4,opt,name=claimRef"`
    // persistentVolumeReclaimPolicy defines what happens to a persistent volume when released from its claim.
    // Valid options are Retain (default for manually created PersistentVolumes), Delete (default
    // for dynamically provisioned PersistentVolumes), and Recycle (deprecated).
    // Recycle must be supported by the volume plugin underlying this PersistentVolume.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming
    // +optional
    PersistentVolumeReclaimPolicy PersistentVolumeReclaimPolicy `json:"persistentVolumeReclaimPolicy,omitempty" protobuf:"bytes,5,opt,name=persistentVolumeReclaimPolicy,casttype=PersistentVolumeReclaimPolicy"`
    // storageClassName is the name of StorageClass to which this persistent volume belongs. Empty value
    // means that this volume does not belong to any StorageClass.
    // +optional
    StorageClassName string `json:"storageClassName,omitempty" protobuf:"bytes,6,opt,name=storageClassName"`
    // mountOptions is the list of mount options, e.g. ["ro", "soft"]. Not validated - mount will
    // simply fail if one is invalid.
    // More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options
    // +optional
    MountOptions []string `json:"mountOptions,omitempty" protobuf:"bytes,7,opt,name=mountOptions"`
    // volumeMode defines if a volume is intended to be used with a formatted filesystem
    // or to remain in raw block state. Value of Filesystem is implied when not included in spec.
    // +optional
    VolumeMode *PersistentVolumeMode `json:"volumeMode,omitempty" protobuf:"bytes,8,opt,name=volumeMode,casttype=PersistentVolumeMode"`
    // nodeAffinity defines constraints that limit what nodes this volume can be accessed from.
    // This field influences the scheduling of pods that use this volume.
    // +optional
    NodeAffinity *VolumeNodeAffinity `json:"nodeAffinity,omitempty" protobuf:"bytes,9,opt,name=nodeAffinity"`
}

// PersistentVolumeSource is similar to VolumeSource but meant for the
// administrator who creates PVs. Exactly one of its members must be set.
type PersistentVolumeSource struct {
    // 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.
    // More info: https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
    // +optional
    GCEPersistentDisk *GCEPersistentDiskVolumeSource `json:"gcePersistentDisk,omitempty" protobuf:"bytes,1,opt,name=gcePersistentDisk"`
    // awsElasticBlockStore represents an AWS Disk resource that is attached to a
    // kubelet's host machine and then exposed to the pod.
    // More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
    // +optional
    AWSElasticBlockStore *AWSElasticBlockStoreVolumeSource `json:"awsElasticBlockStore,omitempty" protobuf:"bytes,2,opt,name=awsElasticBlockStore"`
    // hostPath represents a directory on the host.
    // Provisioned by a developer or tester.
    // This is useful for single-node development and testing only!
    // On-host storage is not supported in any way and WILL NOT WORK in a multi-node cluster.
    // More info: https://kubernetes.io/docs/concepts/storage/volumes#hostpath
    // +optional
    HostPath *HostPathVolumeSource `json:"hostPath,omitempty" protobuf:"bytes,3,opt,name=hostPath"`
    // glusterfs represents a Glusterfs volume that is attached to a host and
    // exposed to the pod. Provisioned by an admin.
    // More info: https://examples.k8s.io/volumes/glusterfs/README.md
    // +optional
    Glusterfs *GlusterfsPersistentVolumeSource `json:"glusterfs,omitempty" protobuf:"bytes,4,opt,name=glusterfs"`
    // nfs represents an NFS mount on the host. Provisioned by an admin.
    // More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs
    // +optional
    NFS *NFSVolumeSource `json:"nfs,omitempty" protobuf:"bytes,5,opt,name=nfs"`
    // rbd represents a Rados Block Device mount on the host that shares a pod's lifetime.
    // More info: https://examples.k8s.io/volumes/rbd/README.md
    // +optional
    RBD *RBDPersistentVolumeSource `json:"rbd,omitempty" protobuf:"bytes,6,opt,name=rbd"`
    // iscsi represents an ISCSI Disk resource that is attached to a
    // kubelet's host machine and then exposed to the pod. Provisioned by an admin.
    // +optional
    ISCSI *ISCSIPersistentVolumeSource `json:"iscsi,omitempty" protobuf:"bytes,7,opt,name=iscsi"`
    // cinder represents a cinder volume attached and mounted on kubelets host machine.
    // More info: https://examples.k8s.io/mysql-cinder-pd/README.md
    // +optional
    Cinder *CinderPersistentVolumeSource `json:"cinder,omitempty" protobuf:"bytes,8,opt,name=cinder"`
    // cephFS represents a Ceph FS mount on the host that shares a pod's lifetime
    // +optional
    CephFS *CephFSPersistentVolumeSource `json:"cephfs,omitempty" protobuf:"bytes,9,opt,name=cephfs"`
    // fc represents a Fibre Channel resource that is attached to a kubelet's host machine and then exposed to the pod.
    // +optional
    FC *FCVolumeSource `json:"fc,omitempty" protobuf:"bytes,10,opt,name=fc"`
    // flocker represents a Flocker volume attached to a kubelet's host machine and exposed to the pod for its usage. This depends on the Flocker control service being running
    // +optional
    Flocker *FlockerVolumeSource `json:"flocker,omitempty" protobuf:"bytes,11,opt,name=flocker"`
    // flexVolume represents a generic volume resource that is
    // provisioned/attached using an exec based plugin.
    // +optional
    FlexVolume *FlexPersistentVolumeSource `json:"flexVolume,omitempty" protobuf:"bytes,12,opt,name=flexVolume"`
    // azureFile represents an Azure File Service mount on the host and bind mount to the pod.
    // +optional
    AzureFile *AzureFilePersistentVolumeSource `json:"azureFile,omitempty" protobuf:"bytes,13,opt,name=azureFile"`
    // vsphereVolume represents a vSphere volume attached and mounted on kubelets host machine
    // +optional
    VsphereVolume *VsphereVirtualDiskVolumeSource `json:"vsphereVolume,omitempty" protobuf:"bytes,14,opt,name=vsphereVolume"`
    // quobyte represents a Quobyte mount on the host that shares a pod's lifetime
    // +optional
    Quobyte *QuobyteVolumeSource `json:"quobyte,omitempty" protobuf:"bytes,15,opt,name=quobyte"`
    // azureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.
    // +optional
    AzureDisk *AzureDiskVolumeSource `json:"azureDisk,omitempty" protobuf:"bytes,16,opt,name=azureDisk"`
    // photonPersistentDisk represents a PhotonController persistent disk attached and mounted on kubelets host machine
    PhotonPersistentDisk *PhotonPersistentDiskVolumeSource `json:"photonPersistentDisk,omitempty" protobuf:"bytes,17,opt,name=photonPersistentDisk"`
    // portworxVolume represents a portworx volume attached and mounted on kubelets host machine
    // +optional
    PortworxVolume *PortworxVolumeSource `json:"portworxVolume,omitempty" protobuf:"bytes,18,opt,name=portworxVolume"`
    // scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.
    // +optional
    ScaleIO *ScaleIOPersistentVolumeSource `json:"scaleIO,omitempty" protobuf:"bytes,19,opt,name=scaleIO"`
    // local represents directly-attached storage with node affinity
    // +optional
    Local *LocalVolumeSource `json:"local,omitempty" protobuf:"bytes,20,opt,name=local"`
    // storageOS represents a StorageOS volume that is attached to the kubelet's host machine and mounted into the pod
    // More info: https://examples.k8s.io/volumes/storageos/README.md
    // +optional
    StorageOS *StorageOSPersistentVolumeSource `json:"storageos,omitempty" protobuf:"bytes,21,opt,name=storageos"`
    // csi represents storage that is handled by an external CSI driver (Beta feature).
    // +optional
    CSI *CSIPersistentVolumeSource `json:"csi,omitempty" protobuf:"bytes,22,opt,name=csi"`
}

// +enum
type PersistentVolumeAccessMode string

const (
    // can be mounted in read/write mode to exactly 1 host
    ReadWriteOnce PersistentVolumeAccessMode = "ReadWriteOnce"
    // can be mounted in read-only mode to many hosts
    ReadOnlyMany PersistentVolumeAccessMode = "ReadOnlyMany"
    // can be mounted in read/write mode to many hosts
    ReadWriteMany PersistentVolumeAccessMode = "ReadWriteMany"
    // can be mounted in read/write mode to exactly 1 pod
    // cannot be used in combination with other access modes
    ReadWriteOncePod PersistentVolumeAccessMode = "ReadWriteOncePod"
)

// PersistentVolumeReclaimPolicy describes a policy for end-of-life maintenance of persistent volumes.
// +enum
type PersistentVolumeReclaimPolicy string

const (
    // PersistentVolumeReclaimRecycle means the volume will be recycled back into the pool of unbound persistent volumes on release from its claim.
    // The volume plugin must support Recycling.
    PersistentVolumeReclaimRecycle PersistentVolumeReclaimPolicy = "Recycle"
    // PersistentVolumeReclaimDelete means the volume will be deleted from Kubernetes on release from its claim.
    // The volume plugin must support Deletion.
    PersistentVolumeReclaimDelete PersistentVolumeReclaimPolicy = "Delete"
    // PersistentVolumeReclaimRetain means the volume will be left in its current phase (Released) for manual reclamation by the administrator.
    // The default policy is Retain.
    PersistentVolumeReclaimRetain PersistentVolumeReclaimPolicy = "Retain"
)

// PersistentVolumeMode describes how a volume is intended to be consumed, either Block or Filesystem.
// +enum
type PersistentVolumeMode string

const (
    // PersistentVolumeBlock means the volume will not be formatted with a filesystem and will remain a raw block device.
    PersistentVolumeBlock PersistentVolumeMode = "Block"
    // PersistentVolumeFilesystem means the volume will be or is formatted with a filesystem.
    PersistentVolumeFilesystem PersistentVolumeMode = "Filesystem"
)

// VolumeNodeAffinity defines constraints that limit what nodes this volume can be accessed from.
type VolumeNodeAffinity struct {
    // required specifies hard node constraints that must be met.
    Required *NodeSelector `json:"required,omitempty" protobuf:"bytes,1,opt,name=required"`
}

// A node selector represents the union of the results of one or more label queries
// over a set of nodes; that is, it represents the OR of the selectors represented
// by the node selector terms.
// +structType=atomic
type NodeSelector struct {
    // Required. A list of node selector terms. The terms are ORed.
    NodeSelectorTerms []NodeSelectorTerm `json:"nodeSelectorTerms" protobuf:"bytes,1,rep,name=nodeSelectorTerms"`
}

// A null or empty node selector term matches no objects. The requirements of
// them are ANDed.
// The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
// +structType=atomic
type NodeSelectorTerm struct {
    // A list of node selector requirements by node's labels.
    // +optional
    MatchExpressions []NodeSelectorRequirement `json:"matchExpressions,omitempty" protobuf:"bytes,1,rep,name=matchExpressions"`
    // A list of node selector requirements by node's fields.
    // +optional
    MatchFields []NodeSelectorRequirement `json:"matchFields,omitempty" protobuf:"bytes,2,rep,name=matchFields"`
}

// A node selector requirement is a selector that contains values, a key, and an operator
// that relates the key and values.
type NodeSelectorRequirement struct {
    // The label key that the selector applies to.
    Key string `json:"key" protobuf:"bytes,1,opt,name=key"`
    // Represents a key's relationship to a set of values.
    // Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
    Operator NodeSelectorOperator `json:"operator" protobuf:"bytes,2,opt,name=operator,casttype=NodeSelectorOperator"`
    // 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. If the operator is Gt or Lt, the values
    // array must have a single element, which will be interpreted as an integer.
    // This array is replaced during a strategic merge patch.
    // +optional
    Values []string `json:"values,omitempty" protobuf:"bytes,3,rep,name=values"`
}

// A node selector operator is the set of operators that can be used in
// a node selector requirement.
// +enum
type NodeSelectorOperator string

const (
    NodeSelectorOpIn           NodeSelectorOperator = "In"
    NodeSelectorOpNotIn        NodeSelectorOperator = "NotIn"
    NodeSelectorOpExists       NodeSelectorOperator = "Exists"
    NodeSelectorOpDoesNotExist NodeSelectorOperator = "DoesNotExist"
    NodeSelectorOpGt           NodeSelectorOperator = "Gt"
    NodeSelectorOpLt           NodeSelectorOperator = "Lt"
)