Utiliser des disques persistants avec plusieurs lecteurs

Autopilot Standard

Cette page explique comment ajouter un disque persistant à votre cluster à l'aide du mode d'accès ReadOnlyMany. Ce mode permet à plusieurs pods sur différents nœuds d'installer ce disque en lecture.

Pour plus d'informations sur ce mode, reportez-vous à la section Modes d'accès aux volumes persistants.

Conditions requises

Votre cluster doit exécuter GKE 1.22 ou une version ultérieure.
Votre cluster doit utiliser le pilote CSI de disque persistant Compute Engine.

Formater et remplir un disque persistant source

Pour utiliser un disque persistant en mode lecture seule, vous devez renseigner les données d'un disque persistant source, puis cloner le volume ou utiliser un instantané de volume pour déplacer les données dans un nouvel objet PersistentVolume ReadOnlyMany.

Créez un PersistentVolume à l'aide d'un disque persistant existant ou d'un provisionnement dynamique.
Formatez le disque et remplissez-le avec des données. Pour formater le disque, référencez-le en tant que PersistentVolume ReadWriteOnce dans un pod. GKE formate automatiquement le disque sous-jacent et permet au pod d'écrire des données sur le disque. Au démarrage du pod, assurez-vous qu'il écrit les données que vous souhaitez sur le disque.

Créer un objet PersistentVolume `ReadOnlyMany`

Vous pouvez créer un objet PersistentVolume ReadOnlyMany à l'aide de l'une des méthodes suivantes :

Un instantané de volume d'un PersistentVolume source contenant des données.
Un clone de volume d'un objet PersistentVolume source contenant des données.
Un disque persistant préexistant qui contient déjà des données.

Instantané de volume

Créez un instantané de volume du PersistentVolume.
Enregistrez le fichier manifeste de PersistentVolumeClaim suivant sous le nom snapshot-pvc.yaml :
```
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  namespace: PVC_NAMESPACE
  name: PVC_NAME
spec:
  dataSource:
    apiGroup: snapshot.storage.k8s.io
    kind: VolumeSnapshot
    name: SNAPSHOT_NAME
  accessModes:
    - ReadOnlyMany
  storageClassName: premium-rwo
  resources:
    requests:
      storage: STORAGE_SIZE
```
Remplacez les éléments suivants :
- PVC_NAMESPACE : espace de noms du nouveau PersistentVolumeClaim.
- PVC_NAME : nom du nouveau PersistentVolumeClaim.
- SNAPSHOT_NAME : nom de votre objet VolumeSnapshot.
- STORAGE_SIZE : la quantité de stockage à demander. Il doit s'agir de la quantité demandée dans l'objet PersistentVolumeClaim source.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f snapshot-pvc.yaml
```

Cela crée une PersistentVolumeClaim nommée PVC_NAME dans votre cluster, que GKE utilise pour provisionner de manière dynamique un PersistentVolume contenant les données de l'instantané du disque persistant source.

Clonage de volume

Avant d'utiliser le clonage de volume, veillez à vous familiariser avec les limites de cette approche.

Enregistrez le manifeste suivant sous le nom cloning-pvc.yaml :
```
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  namespace: PVC_NAMESPACE
  name: PVC_NAME
spec:
  dataSource:
    name: SOURCE_PVC
    kind: PersistentVolumeClaim
  accessModes:
    - ReadOnlyMany
  storageClassName: STORAGE_CLASS_NAME
  resources:
    requests:
      storage: STORAGE_SIZE
```
Remplacez les éléments suivants :
- PVC_NAMESPACE : espace de noms du nouveau PersistentVolumeClaim.
- PVC_NAME : nom du nouveau PersistentVolumeClaim.
- SOURCE_PVC : nom du PersistentVolumeClaim source contenant des données.
- STORAGE_CLASS_NAME : classe de stockage du nouveau PersistentVolumeClaim. Il doit s'agir de la même classe de stockage que celle du PersistentVolumeClaim source.
- STORAGE_SIZE : quantité de stockage du nouveau PersistentVolumeClaim. Il doit s'agir de la quantité demandée par le PersistentVolumeClaim source.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f cloning-pvc.yaml
```

Cela crée un objet PersistentVolumeClaim nommé PVC_NAME, que GKE utilise pour créer un objet PersistentVolume en mode ReadOnlyMany avec les données de l'objet PersistentVolume source.

Pour en savoir plus sur le clonage de volume, consultez la section Créer des clones de volumes persistants.

Disque persistant préexistant

Enregistrez le manifeste suivant sous le nom preexisting-disk-pv-pvc.yaml :
```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: PV_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  capacity:
    storage: DISK_SIZE
  accessModes:
    - ReadOnlyMany
  claimRef:
    namespace: PVC_NAMESPACE
    name: PVC_NAME
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: DISK_ID
    fsType: FS_TYPE
    readOnly: true
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  namespace: PVC_NAMESPACE
  name: PVC_NAME
spec:
  storageClassName: "STORAGE_CLASS_NAME"
  volumeName: PV_NAME
  accessModes:
    - ReadOnlyMany
  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. Par exemple, 500G.
- PVC_NAMESPACE : espace de noms du nouveau PersistentVolumeClaim.
- PVC_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.

Appliquez le fichier manifeste à votre cluster :

kubectl apply -f preexisting-disk-pv-pvc.yaml

Cela crée un objet PersistentVolumeClaim nommé PVC_NAME et un objet PersistentVolume nommé PV_NAME en mode ReadOnlyMany.

Pour plus d'informations sur l'utilisation d'un disque persistant préexistant, consultez la page Disque persistant existant.

Utiliser l'objet PersistentVolumeClaim dans un pod

Vous pouvez maintenant référencer la nouvelle PersistentVolumeClaim en mode lecture seule dans plusieurs pods sur plusieurs nœuds en même temps. Vous ne pouvez pas associer des disques persistants en mode ReadWriteOnce à plusieurs nœuds en même temps. Pour en savoir plus, consultez la section Déploiements et StatefulSets.

Dans la spécification de pod, vous devez indiquer readOnly: true dans les sections volumeMounts et volumes, comme dans l'exemple suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-read
  labels:
    app: web-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-server
  template:
    metadata:
      labels:
        app: web-server
    spec:
      containers:
      - name: web-server
        image: nginx
        volumeMounts:
        - mountPath: /test-mnt
          name: my-volume
          readOnly: true
      volumes:
      - name: my-volume
        persistentVolumeClaim:
          claimName: PVC_NAME
          readOnly: true

Remarque : Les systèmes de fichiers ext3 et ext4 en lecture seule ne permettent pas la lecture des journaux. Si le système de fichiers du disque persistant source est marqué comme sale lorsque vous le clonez ou créez un instantané, les données de votre disque persistant en lecture seule peuvent être incohérentes ou corrompues. Le pilote CSI de disque persistant Compute Engine tente d'installer le disque normalement. Si l'impossibilité de lire le journal entraîne l'échec de l'installation du volume, le pilote CSI relance automatiquement l'installation avec l'option noload, qui désactive les tentatives de lecture sur les systèmes de fichiers ext3 et ext4. Si le système de fichiers source était incohérent au moment du clonage ou de l'instantané, l'installation en lecture seule sera également incohérente.

Étapes suivantes

Découvrez comment utiliser des disques persistants préexistants en tant que ressources PersistentVolume.
En savoir plus sur les disques persistants Compute Engine.