Utilizzo di dischi permanenti preesistenti come volumi permanenti

Autopilot Standard

---

Questa pagina spiega come creare un PersistentVolume utilizzando dischi permanenti esistenti compilati con dati e come utilizzare l'oggetto 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 un StatefulSet per generare automaticamente richieste di volumi permanenti associate a volumi permanenti generati manualmente corrispondenti a una serie di dischi permanenti preesistenti.

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 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 NTFS file system per i pool di nodi Windows Server. Per utilizzare un disco NTFS, modifica spec.csi.fsType in NTFS nel manifest 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 visualizzerai errori nella descrizione del pod. Analogamente, i volumi CSI di dischi permanenti supportano una sola 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à, installa e poi inizializza 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 il 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. Collega il PersistentVolume a un PersistentVolumeClaim.
3. Consenti ai container del pod di accedere al PersistentVolume.

Crea PersistentVolume e PersistentVolumeClaim

Esistono diversi modi per associare un PersistentVolumeClaim a un volume persistente specifico. Ad esempio, il seguente manifest YAML crea un nuovo volume permanente e una nuova richiesta di volume permanente, quindi associa il volume alla richiesta utilizzando claimRef definito sul 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:
       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 del nuovo StorageClass.
   • DISK_SIZE: le dimensioni del disco preesistente permanente. Ad esempio, 500G.
   • PV_CLAIM_NAME: il nome del nuovo PersistentVolumeClaim.
   • DISK_ID: l'identificatore del disco preesistente permanente. 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.

Utilizzare il volume persistente in un pod

Dopo aver creato e associato PersistentVolume e PersistentVolumeClaim, puoi assegnare 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 il volume persistente 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 del 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 il seguente comando:

kubectl describe pods POD_NAME

Nell'output, controlla che la richiesta di volume permanente sia stata montata:

...
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. StatefulSet genera automaticamente un claim volume permanente per ogni replica. Puoi prevedere i nomi dei PersistentVolumeClaim generati e associarli ai PersistentVolume utilizzando claimRef.

Nell'esempio seguente, prendi due dischi permanenti preesistenti, crei PersistentVolume per utilizzarli e poi monti i volumi su un 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. Il StatefulSet utilizza il seguente formato per i nomi dei 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. Crea i PersistentVolume. Devi creare un volume persistente per ogni replica nel 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 dei PersistentVolumeClaim generati automaticamente nel formato definito nel passaggio precedente.
      • STORAGE_CLASS_NAME: il nome del tuo 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 che hai scelto nel passaggio 1. Assicurati che lo spazio di archiviazione specificato in volumeClaimTemplates sia minore o uguale alla capacità totale dei 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.