Utilizzo di dischi permanenti preesistenti come volumi permanenti

Questa pagina spiega come creare un PersistentVolume utilizzando dischi permanenti esistenti compilati con i dati e come utilizzare PersistentVolume in un pod.

Panoramica

Esistono due scenari comuni che utilizzano un disco permanente preesistente.

Gli esempi in questa pagina utilizzano dischi permanenti di Compute Engine esistenti.

Sebbene ext4 sia il tipo di file system predefinito, puoi utilizzare un disco permanente preesistente con il file system xfs, a condizione che l'immagine del nodo lo supporti. Per utilizzare un disco xfs, modifica spec.csi.fsType in xfs nel manifest PersistentVolume.

Windows non supporta il tipo di file system ext4. Devi utilizzare il file system NTFS per i node pool Windows Server. Per utilizzare un disco NTFS, modifica spec.csi.fsType in NTFS nel manifest PersistentVolume.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Utilizzo di un oggetto PersistentVolumeClaim associato a PersistentVolume

Affinché un container possa accedere al disco permanente preesistente, devi:

  1. Esegui il provisioning del disco permanente esistente come PersistentVolume.
  2. Collega il PersistentVolume a un PersistentVolumeClaim.
  3. Concedi ai container nel pod l'accesso a PersistentVolume.

Crea PersistentVolume e PersistentVolumeClaim

Esistono diversi modi per associare un PersistentVolumeClaim a un PersistentVolume specifico. Ad esempio, il seguente manifest YAML crea un nuovo PersistentVolume e PersistentVolumeClaim, quindi associa il volume alla richiesta utilizzando claimRef definito in PersistentVolume.

Per associare un PersistentVolume a un PersistentVolumeClaim, devono corrispondere storageClassName delle due risorse, nonché capacity, accessModes e volumeMode. Puoi omettere storageClassName, ma devi specificare "" per impedire a Kubernetes di utilizzare StorageClass predefinita.

storageClassName non deve fare riferimento a un oggetto StorageClass esistente. Se devi solo associare la rivendicazione a un volume, puoi utilizzare il nome che preferisci. Tuttavia, se hai bisogno di funzionalità aggiuntive configurate da una StorageClass, come il ridimensionamento del volume, storageClassName deve fare riferimento a un oggetto StorageClass esistente.

Per ulteriori dettagli, consulta la documentazione di Kubernetes su PersistentVolumes.

  1. Salva il seguente manifest YAML:

    apiVersion: v1
kind: PersistentVolume
metadata:
  name: PV_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    name: PV_CLAIM_NAME
    namespace: default
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK_ID
    fsType: FS_TYPE
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  namespace: default
  name: PV_CLAIM_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: DISK_SIZE

    Sostituisci quanto segue:

    • PV_NAME: il nome del nuovo PersistentVolume.
    • STORAGE_CLASS_NAME: il nome della nuova StorageClass.
    • DISK_SIZE: le dimensioni del disco permanente preesistente. Ad esempio, 500G.
    • PV_CLAIM_NAME: il nome della nuova PersistentVolumeClaim.
    • DISK_ID: l'identificatore del disco permanente preesistente. Il formato è projects/{project_id}/zones/{zone_name}/disks/{disk_name} per i dischi permanenti a livello di zona o projects/{project_id}/regions/{region_name}/disks/{disk_name} per i dischi permanenti a livello di regione.
    • FS_TYPE: il tipo di file system. Puoi lasciare il valore predefinito (ext4) o utilizzare xfs. Se i tuoi cluster utilizzano un pool di nodi Windows Server, devi modificarlo in NTFS.

  2. Per applicare la configurazione e creare le risorse PersistentVolume e PersistentVolumeClaim, esegui il comando seguente:

    kubectl apply -f FILE_PATH

    Sostituisci FILE_PATH con il percorso del file YAML.

Utilizza PersistentVolume in un pod

Dopo aver creato e associato PersistentVolume e PersistentVolumeClaim, puoi concedere ai container di un pod l'accesso al volume specificando i valori nel campo volumeMounts.

La seguente configurazione YAML crea un nuovo pod e un container che esegue un'immagine nginx, quindi monta PersistentVolume sul pod:

kind: Pod
apiVersion: v1
metadata:
  name: POD_NAME
spec:
  volumes:
    - name: VOLUME_NAME
      persistentVolumeClaim:
        claimName: PV_CLAIM_NAME
  containers:
    - name: CONTAINER_NAME
      image: nginx
      ports:
        - containerPort: 80
          name: "http-server"
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: VOLUME_NAME

Sostituisci quanto segue:

  • POD_NAME: il nome del nuovo pod.
  • VOLUME_NAME: il nome del volume.
  • PV_CLAIM_NAME: il nome di PersistentVolumeClaim che hai creato nel passaggio precedente.
  • CONTAINER_NAME: il nome del nuovo contenitore.

Applica la configurazione:

kubectl apply -f FILE_PATH

Sostituisci FILE_PATH con il percorso del file YAML.

Per verificare che il volume sia stato montato, esegui questo comando:

kubectl describe pods POD_NAME

Nell'output, verifica che PersistentVolumeClaim sia stato montato:

...
Volumes:
  VOLUME_NAME:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  PV_CLAIM_NAME
    ReadOnly:   false
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               29s   default-scheduler        Successfully assigned default/POD_NAME to gke-cluster-1-default-pool-d5cde866-o4g4
  Normal  SuccessfulAttachVolume  21s   attachdetach-controller  AttachVolume.Attach succeeded for volume "PV_NAME"
  Normal  Pulling                 19s   kubelet                  Pulling image "nginx"
  Normal  Pulled                  19s   kubelet                  Successfully pulled image "nginx"
  Normal  Created                 18s   kubelet                  Created container CONTAINER_NAME
  Normal  Started                 18s   kubelet                  Started container CONTAINER_NAME

Utilizzo di un disco preesistente in un StatefulSet

Puoi utilizzare dischi permanenti di Compute Engine preesistenti in un StatefulSet utilizzando PersistentVolume. StatefulSet genera automaticamente una PersistentVolumeClaim per ogni replica. Puoi prevedere i nomi dei PersistentVolumeClaim generati e associarli ai PersistentVolume utilizzando claimRef.

Nell'esempio seguente, prendi due dischi permanenti preesistenti, crea PersistentVolume per utilizzare i dischi e poi monta i volumi su un StatefulSet con due repliche nello spazio dei nomi predefinito.

  1. Decidi un nome per il nuovo StatefulSet, un nome per il modello PersistentVolumeClaim e il numero di repliche in StatefulSet.

  2. Determina i nomi delle PersistentVolumeClaim generate automaticamente. StatefulSet utilizza il seguente formato per i nomi PersistentVolumeClaim:

    PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX

    Sostituisci quanto segue:

    • PVC_TEMPLATE_NAME: il nome del nuovo modello PersistentVolumeClaim.
    • STATEFULSET_NAME: il nome del nuovo StatefulSet.
    • REPLICA_INDEX: l'indice della replica di StatefulSet. Per questo esempio, utilizza 0 e 1.

  3. Crea i PersistentVolume. Devi creare un PersistentVolume per ogni replica in StatefulSet.

    1. Salva il seguente manifest YAML:

      apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-ss-demo-0
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK1_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    namespace: default
    name: PVC_TEMPLATE_NAME-STATEFULSET_NAME-0
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK1_ID
    fsType: FS_TYPE
 ---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-ss-demo-1
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK2_SIZE
  accessModes:
    - ReadWriteOnce
  claimRef:
    namespace: default
    name: PVC_TEMPLATE_NAME-STATEFULSET_NAME-1
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK2_ID
    fsType: FS_TYPE

      Sostituisci quanto segue:

      • DISK1_SIZE and DISK2_SIZE: le dimensioni dei dischi permanenti preesistenti.
      • DISK1_ID and DISK2_ID: gli identificatori dei dischi permanenti preesistenti.
      • PVC_TEMPLATE_NAME-STATEFULSET_NAME-0 and PVC_TEMPLATE_NAME-STATEFULSET_NAME-1: i nomi dei PersistentVolumeClaim generati automaticamente nel formato definito nel passaggio precedente.
      • STORAGE_CLASS_NAME: il nome di StorageClass.

    2. Applica la configurazione:

      kubectl apply -f FILE_PATH

      Sostituisci FILE_PATH con il percorso del file YAML.

  4. Crea un StatefulSet utilizzando i valori scelti nel passaggio 1. Assicurati che lo spazio di archiviazione specificato in volumeClaimTemplates sia minore o uguale alla capacità totale dei tuoi PersistentVolume.

    1. Salva il seguente manifest YAML:

      apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: STATEFULSET_NAME
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "nginx"
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: registry.k8s.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: PVC_TEMPLATE_NAME
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: PVC_TEMPLATE_NAME
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "STORAGE_CLASS_NAME"
      resources:
        requests:
          storage: 100Gi

      Sostituisci quanto segue:

      • STATEFULSET_NAME: il nome del nuovo StatefulSet.
      • PVC_TEMPLATE_NAME: il nome del nuovo template PersistentVolumeClaim
      • STORAGE_CLASS_NAME: il nome di StorageClass.

    2. Applica la configurazione:

      kubectl apply -f FILE_PATH

      Sostituisci FILE_PATH con il percorso del file YAML.

Passaggi successivi