Utiliser des disques persistants préexistants en tant que PersistentVolumes

Autopilot Standard

---

Cette page explique comment créer un objet PersistentVolume à l'aide de disques persistants existants contenant des données et l'utiliser ensuite dans un pod.

Présentation

Il existe deux scénarios courants qui utilisent un disque persistant préexistant :

• Créer manuellement un PersistentVolumeClaim et un PersistentVolume, les lier entre eux et faire référence à PersistentVolumeClaim dans une spécification de pod.
• Utiliser un StatefulSet pour générer automatiquement des PersistentVolumeClaims qui sont liées à des PersistentVolumes générés manuellement correspondant à une série de disques persistants préexistants.

Les exemples de cette page utilisent des disques persistants Compute Engine existants.

Bien que ext4 soit le type de système de fichiers par défaut, vous pouvez utiliser un disque persistant préexistant avec le système de fichiers xfs, à condition que votre image de nœud soit compatible. Pour utiliser un disque xfs, remplacez spec.csi.fsType par xfs dans le fichier manifeste PersistentVolume.

Windows n'accepte pas le type de système de fichiers ext4. Vous devez utiliser le système de fichiers NTFS pour les pools de nœuds Windows Server. Pour utiliser un disque NTFS, remplacez spec.csi.fsType par NTFS dans le fichier manifeste PersistentVolume.

Remarque : Si le type de système de fichiers du disque persistant que vous utilisez ne correspond pas au fsType que vous spécifiez dans le fichier manifeste PersistentVolume, les pods que vous créez qui consomment les volumes ne démarrent pas et des erreurs s'affichent dans la description du pod. De même, les volumes CSI de disque persistant n'acceptent qu'une seule partition. Les volumes créés en dehors de GKE avec plusieurs partitions ne peuvent pas être utilisés avec cette technique.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
  Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

• Assurez-vous de disposer de disques persistants existants. Pour provisionner un disque, consultez la section Provisionner des disques persistants régionaux.
• Assurez-vous que votre cluster utilise le pilote CSI de disque persistant Compute Engine.

Utiliser un objet PersistentVolumeClaim lié à l'objet PersistentVolume

Pour qu'un conteneur puisse accéder à votre disque persistant préexistant, vous devez procéder comme suit :

1. Provisionnez le disque persistant existant en tant que PersistentVolume.
2. Liez le PersistentVolume à un PersistentVolumeClaim.
3. Accordez aux conteneurs du pod l'accès au PersistentVolume.

Créez les objets PersistentVolume et PersistentVolumeClaim

Il existe plusieurs façons de lier un objet PersistentVolumeClaim à un objet PersistentVolume spécifique. Par exemple, le fichier manifeste YAML suivant crée un nouvel objet PersistentVolume et PersistentVolumeClaim, puis lie la revendication au volume à l'aide de claimRef, ce qui garantit que le PersistentVolume ne peut être lié qu'à ce PersistentVolumeClaim.

Pour lier un PersistentVolume à une PersistentVolumeClaim, le storageClassName des deux ressources doit correspondre, ainsi que les objets capacity, accessModes et volumeMode. Vous pouvez omettre le storageClassName, mais vous devez spécifier "" pour empêcher Kubernetes d'utiliser la StorageClass par défaut.

Le storageClassName n'a pas besoin de faire référence à un objet StorageClass existant. Si vous avez simplement besoin de lier la revendication à un volume, vous pouvez utiliser le nom de votre choix. Toutefois, si vous avez besoin de fonctionnalités supplémentaires configurées par une StorageClass, telles que le redimensionnement du volume, storageClassName doit faire référence à un objet StorageClass existant.

Pour en savoir plus, consultez la documentation Kubernetes sur les PersistentVolumes.

Remarque : Le disque persistant doit se trouver dans la même zone que les nœuds du cluster.

1. Enregistrez le manifeste YAML suivant :

   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
   

   Remplacez les éléments suivants :

   • PV_NAME : nom de votre nouveau PersistentVolume.
   • STORAGE_CLASS_NAME : nom de votre nouvelle ressource StorageClass.
   • DISK_SIZE : taille de votre disque persistant préexistant. Exemple :500G
   • PV_CLAIM_NAME : nom de votre nouvel objet PersistentVolumeClaim.
   • DISK_ID : identifiant de votre disque persistant préexistant. Le format est projects/{project_id}/zones/{zone_name}/disks/{disk_name} pour les disques persistants zonaux ou projects/{project_id}/regions/{region_name}/disks/{disk_name} pour les disques persistants régionaux.
   • FS_TYPE : le type de système de fichiers. Vous pouvez conserver cette valeur par défaut (ext4) ou utiliser xfs. Si vos clusters utilisent un pool de nœuds Windows Server, vous devez remplacer cette valeur par NTFS.

2. Pour appliquer la configuration et créer les ressources PersistentVolume et PersistentVolumeClaim, exécutez la commande suivante :

   kubectl apply -f FILE_PATH
   

   Remplacez FILE_PATH par le chemin d'accès au fichier YAML.

Utiliser l'objet PersistentVolume dans un pod

Une fois les objets PersistentVolume et PersistentVolumeClaim créés et associés, vous pouvez autoriser les conteneurs d'un pod à accéder au volume en spécifiant des valeurs dans le champ volumeMounts.

La configuration YAML suivante crée un pod et un conteneur exécutant une image nginx, puis installe le PersistentVolume sur le 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

Remplacez les éléments suivants :

• POD_NAME : nom de votre nouveau pod.
• VOLUME_NAME : nom du volume.
• PV_CLAIM_NAME : nom de l'objet PersistentVolumeClaim que vous avez créé à l'étape précédente.
• CONTAINER_NAME : nom de votre nouveau conteneur.

Appliquez la configuration :

kubectl apply -f FILE_PATH

Remplacez FILE_PATH par le chemin d'accès au fichier YAML.

Pour vérifier que le volume a été installé, exécutez la commande suivante :

kubectl describe pods POD_NAME

Dans le résultat, vérifiez que l'objet PersistentVolumeClaim a été installé :

...
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

Utiliser un disque préexistant dans un objet StatefulSet

Vous pouvez utiliser des disques persistants Compute Engine préexistants dans un objet StatefulSet à l'aide de PersistentVolumes. L'objet StatefulSet génère automatiquement une PersistentVolumeClaim pour chaque instance dupliquée. Vous pouvez prédire les noms des PersistentVolumeClaims générés et les lier aux PersistentVolumes à l'aide de claimRef.

Dans l'exemple suivant, vous allez utiliser deux disques persistants préexistants, créer des PersistentVolumes pour utiliser les disques, puis installer les volumes sur un StatefulSet avec deux instances dupliquées dans l'espace de noms par défaut.

1. Choisissez un nom pour votre nouvel objet StatefulSet, un nom pour votre modèle PersistentVolumeClaim et le nombre d'instances dupliquées dans l'objet StatefulSet.

2. Supprimez les noms des PersistentVolumeClaims générés automatiquement. L'objet StatefulSet utilise le format suivant pour les noms de PersistentVolumeClaim :

   PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX
   

   Remplacez les éléments suivants :

   • PVC_TEMPLATE_NAME : nom du nouveau modèle PersistentVolumeClaim.
   • STATEFULSET_NAME : nom du nouvel objet StatefulSet.
   • REPLICA_INDEX : index de l'instance dupliquée de l'objet StatefulSet. Pour cet exemple, utilisez 0 et 1.

3. Créez les PersistentVolumes. Vous devez créer un PersistentVolume pour chaque instance dupliquée dans l'objet StatefulSet.

   1. Enregistrez le manifeste YAML suivant :

      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
      

      Remplacez les éléments suivants :

      • DISK1_SIZE and DISK2_SIZE : tailles de vos disques persistants préexistants.
      • DISK1_ID and DISK2_ID: identifiants de vos disques persistants préexistants.
      • PVC1_NAME and PVC2_NAME : noms des PersistentVolumeClaims générées automatiquement.
      • STORAGE_CLASS_NAME : nom de votre StorageClass.

   2. Appliquez la configuration :

      kubectl apply -f FILE_PATH
      

      Remplacez FILE_PATH par le chemin d'accès au fichier YAML.

4. Créez un StatefulSet à l'aide des valeurs que vous avez choisies à l'étape 1. Assurez-vous que l'espace de stockage que vous spécifiez dans volumeClaimTemplates est inférieur ou égal à la capacité de vos objets PersistentVolume.

   1. Enregistrez le manifeste YAML suivant :

      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
      

      Remplacez les éléments suivants :

      • STATEFULSET_NAME : nom du nouvel objet StatefulSet.
      • PVC_TEMPLATE_NAME : nom du nouveau modèle PersistentVolumeClaim.
      • STORAGE_CLASS_NAME : nom de votre StorageClass.
      Remarque : Assurez-vous que le nom de votre StatefulSet et le nom de votre PersistentVolumeClaim correspondent aux valeurs que vous avez définies à l'étape 1.

   2. Appliquez la configuration :

      kubectl apply -f FILE_PATH
      

      Remplacez FILE_PATH par le chemin d'accès au fichier YAML.

Étape suivante

• Apprenez à déployer une application avec état.