Utilizzo di dischi permanenti preesistenti come PersistentVolume

Autopilot Standard

---

Questa pagina spiega come creare un PersistentVolume utilizzando dischi permanenti esistenti completati con dati e come usare il PersistentVolume in un pod.

Panoramica

Esistono due scenari comuni in cui viene utilizzato un disco permanente preesistente.

• Creare manualmente un PersistentVolumeClaim e un PersistentVolume, associarli tra loro e fare riferimento all'oggetto PersistentVolumeClaim nella specifica di un pod.
• Usa uno StatefulSet per generare automaticamente richieste di volumi permanenti associate 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.

Mentre ext4 è il tipo di file system predefinito, puoi utilizzare un disco permanente 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 del PersistentVolume.

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

Nota: se il tipo di filesystem per il disco permanente che utilizzi non corrisponde al valore fsType specificato nel manifest del PersistentVolume, i pod che crei che consumano i volumi non verranno avviati e nella descrizione dei pod verranno visualizzati errori. Allo stesso modo, i volumi CSI del disco permanente supportano solo una singola partizione. I volumi creati all'esterno di GKE con più partizioni non possono essere utilizzati con questa tecnica.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e initialize gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti dell'interfaccia a riga di comando gcloud, assicurati di impostare le proprietà compute/region e compute/zone. Impostando le località predefinite, puoi evitare errori nellgcloud CLI come segue: One of [--zone, --region] must be supplied: Please specify location.

• Assicurati di disporre di dischi permanenti. Per eseguire il provisioning di un disco, consulta Provisioning dei dischi permanenti a livello di regione.
• Assicurati che il cluster utilizzi il driver CSI del disco permanente di Compute Engine.

Utilizzo di un PersistentVolumeClaim associato al PersistentVolume

Affinché un container possa accedere al disco permanente preesistente:

1. Esegui il provisioning del disco permanente esistente come PersistentVolume.
2. Associa il PersistentVolume a un PersistentVolumeClaim.
3. Concedi ai container nel pod l'accesso al 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 un PersistentVolumeClaim, quindi associa la richiesta al volume usando un claimRef, il che garantisce che il PersistentVolume possa essere associato solo a quel PersistentVolumeClaim.

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

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

Per maggiori dettagli, consulta la documentazione di Kubernetes sugli oggetti PersistentVolume.

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 tuo nuovo oggetto StorageClass.
   • DISK_SIZE: le dimensioni del disco permanente preesistente. Ad esempio, 500G.
   • PV_CLAIM_NAME: il nome del nuovo 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 questa opzione impostata come predefinita (ext4) o utilizzare xfs. Se i cluster utilizzano un pool di nodi Windows Server, devi modificare questo valore in NTFS.

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

   kubectl apply -f FILE_PATH
   

   Sostituisci FILE_PATH con il percorso del file YAML.

Utilizzare l'oggetto PersistentVolume in un pod

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

La seguente configurazione YAML crea un nuovo pod e un container che esegue un'immagine nginx, quindi monta l'oggetto 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 uno StatefulSet

Puoi utilizzare dischi permanenti di Compute Engine preesistenti in uno StatefulSet utilizzando PersistentVolume. Lo StatefulSet genera automaticamente un PersistentVolumeClaim per ogni replica. Puoi prevedere i nomi degli oggetti PersistentVolumeClaim generati e associarli agli oggetti PersistentVolume utilizzando claimRef.

Nell'esempio seguente, crei due dischi permanenti preesistenti, crei oggetti PersistentVolume per utilizzarli, 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 nello StatefulSet.

2. Stabilisci i nomi delle richieste di volumi permanenti generate automaticamente. 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 di 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: PVC1_NAME
        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: PVC2_NAME
        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.
      • PVC1_NAME and PVC2_NAME: i nomi delle richieste di volumi permanenti generate automaticamente.
      • 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 che hai scelto nel passaggio 1. Assicurati che lo spazio di archiviazione specificato in volumeClaimTemplates sia inferiore 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 modello di PersistentVolumeClaim.
      • STORAGE_CLASS_NAME: il nome del tuo oggetto StorageClass.
      Nota: assicurati che il nome StatefulSet e il nome di PersistentVolumeClaim corrispondano ai valori che hai deciso 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 stateful.