Utilizzo di dischi permanenti preesistenti come PersistentVolume

Autopilot Standard

---

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

Panoramica

Esistono due scenari comuni che utilizzano un disco permanente preesistente.

• Creare manualmente un PersistentVolumeClaim e un PersistentVolume, associarli e fare riferimento al PersistentVolumeClaim in una specifica del pod.
• Utilizza uno StatefulSet per generare automaticamente oggetti PersistentVolumeClaim associati a oggetti PersistentVolume generati manualmente corrispondenti a una serie di dischi permanenti preesistenti.

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

Anche se ext4 è il tipo di file system predefinito, puoi utilizzare un file system preesistente con il file system xfs, purché 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 pool di nodi Windows Server. Per utilizzare un disco NTFS, cambia spec.csi.fsType in NTFS nel manifest del PersistentVolume.

Nota: se il tipo di file system del disco permanente che utilizzi non corrisponde al valore fsType specificato nel manifest PersistentVolume, i pod che crei e che consumano i volumi non si avvieranno e vedrai errori nella descrizione del pod. Allo stesso modo, i volumi CSI dei dischi permanenti supportano solo una singola partizione. I volumi creati al di fuori di GKE con più partizioni non possono essere utilizzati con questa tecnica.

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à, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

• Assicurati di avere dischi permanenti esistenti. Per eseguire il provisioning di un disco, consulta Provisioning dei dischi permanenti a livello di regione.
• Assicurati che il cluster utilizzi Driver CSI per il disco permanente di Compute Engine.

Utilizzo di un PersistentVolumeClaim associato al PersistentVolume

Affinché un contenitore possa accedere al disco permanente preesistente, devi eseguire i seguenti passaggi:

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

crea gli oggetti PersistentVolume e PersistentVolumeClaim

Esistono diversi modi per associare un PersistentVolumeClaim a una richiesta da questo PersistentVolume. Ad esempio, il seguente manifest YAML crea un nuovo volume permanente e una nuova richiesta di volume permanente, quindi associa la richiesta al volume utilizzando un claimRef, che garantisce che il volume permanente possa essere associato solo a quel volume permanente.

Per associare un PersistentVolume a un PersistentVolumeClaim, i valori storageClassName delle due risorse devono corrispondere, così come capacity,accessModes e volumeMode. Puoi omettere storageClassName, ma devi specificare "" per impedire a Kubernetes di utilizzare StorageClass predefinito.

storageClassName non deve fare riferimento a un oggetto StorageClass esistente. Se ti basta associare la rivendicazione a un volume, puoi utilizzare qualsiasi nome. Tuttavia, se hai bisogno di funzionalità aggiuntive configurate da una classe di archiviazione, come il ridimensionamento del volume, storageClassName deve fare riferimento a un oggetto StorageClass esistente.

Per ulteriori dettagli, consulta la documentazione di Kubernetes sui volumi permanenti.

Nota: il disco permanente deve trovarsi nella stessa zona dei nodi del cluster.

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:
       namespace: default
       name: PV_CLAIM_NAME
     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"
     volumeName: PV_NAME
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: DISK_SIZE
   

   Sostituisci quanto segue:

   • PV_NAME: il nome del nuovo PersistentVolume.
   • STORAGE_CLASS_NAME: il nome del nuovo oggetto StorageClass.
   • DISK_SIZE: le dimensioni del disco preesistente permanente. Ad esempio, 500G.
   • PV_CLAIM_NAME: il nome del nuovo e PersistentVolumeClaim.
   • DISK_ID: l'identificatore del valore permanente preesistente disco. Il formato è projects/{project_id}/zones/{zone_name}/disks/{disk_name} per Dischi permanenti a livello di zona o projects/{project_id}/regions/{region_name}/disks/{disk_name} per 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 impostare questo valore su NTFS.

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

   kubectl apply -f FILE_PATH
   

   Sostituisci FILE_PATH con il percorso del file YAML.

usa il PersistentVolume in un pod

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

La seguente configurazione YAML crea un nuovo pod e un container che esegue nginx e quindi monta il 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 dell'oggetto PersistentVolumeClaim 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 l'oggetto 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 i dischi permanenti di Compute Engine preesistenti in un StatefulSet utilizzando PersistentVolume. Lo StatefulSet genera automaticamente per ogni replica. Puoi prevedere i nomi degli generati dagli oggetti PersistentVolumeClaim e associandoli agli oggetti PersistentVolume claimRef.

Nell'esempio seguente, prende in considerazione due dischi permanenti preesistenti, PersistentVolume per utilizzare i dischi e quindi montare i volumi su uno StatefulSet con due repliche nello spazio dei nomi predefinito.

1. Scegli un nome per il nuovo StatefulSet, un nome per il modello PersistentVolumeClaim e il numero di repliche nel StatefulSet.

2. Individua i nomi dei PersistentVolumeClaim generati automaticamente. La Lo 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 dello StatefulSet. Per questo esempio, utilizza 0 e 1.

3. Creare gli oggetti PersistentVolume. Devi creare un PersistentVolume per ogni replica nello 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 tuoi dischi permanenti preesistenti.
      • DISK1_ID and DISK2_ID: gli identificatori dei tuoi dischi permanenti preesistenti.
      • PVC_TEMPLATE_NAME-STATEFULSET_NAME-0 and PVC_TEMPLATE_NAME-STATEFULSET_NAME-1: i nomi degli oggetti PersistentVolumeClaim generati automaticamente nel formato definito nel passaggio precedente.
      • STORAGE_CLASS_NAME: il nome del tuo oggetto StorageClass.

   2. Applica la configurazione:

      kubectl apply -f FILE_PATH
      

      Sostituisci FILE_PATH con il percorso del file YAML.

4. Crea uno StatefulSet utilizzando i valori scelti nel passaggio 1. Assicurati che lo spazio di archiviazione specificato in volumeClaimTemplates è inferiore o uguale alla capacità totale del tuo gli oggetti 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 modello PersistentVolumeClaim.
      • STORAGE_CLASS_NAME: il nome del tuo StorageClass.
      Nota: assicurati che il nome del StatefulSet e il nome del PersistentVolumeClaim corrispondano ai valori che hai scelto nel passaggio 1.

   2. Applica la configurazione:

      kubectl apply -f FILE_PATH
      

      Sostituisci FILE_PATH con il percorso del file YAML.

Passaggi successivi

• Scopri come eseguire il deployment di un'applicazione con stato.