Usar discos permanentes com vários leitores

Autopilot Padrão

Nesta página, explicamos como adicionar um disco permanente ao cluster usando o modo de acesso ReadOnlyMany. Este modo permite que vários pods em diferentes nós montem o disco para leitura.

Para mais informações sobre esse modo, consulte modos de acesso de volume permanente.

Requisitos

Seu cluster precisa executar o GKE versão 1.22 ou posterior.
Seu cluster precisa usar o driver CSI de disco permanente do Compute Engine.

Formatar e preencher um disco permanente de origem

Para usar um disco permanente no modo somente leitura, preencha um disco permanente de origem com dados e clone o volume ou use um snapshot dele para movê-los para um novo PersistentVolume ReadOnlyMany.

Crie um PersistentVolume usando um disco permanente atual ou o provisionamento dinâmico.
Formate o disco e preencha-o com dados. Para formatar o disco, referencie-o como um PersistentVolume ReadWriteOnce em um pod. O GKE formata automaticamente o disco subjacente e permite que o pod grave dados no disco. Quando o pod for iniciado, verifique se ele grava os dados que você quer no disco.

Criar um PersistentVolume `ReadOnlyMany`

É possível criar um PersistentVolume ReadOnlyMany usando um dos métodos a seguir:

Um snapshot de volume de um PersistentVolume de origem que você preenche com dados.
Um clona de volume de um PersistentVolume de origem que você preenche com dados.
Um disco permanente preexistente que já foi preenchido com dados.

Volume do Snapshot

Crie um snapshot de volume da origem do PersistentVolume.

Salve o seguinte manifesto PersistentVolumeClaim: 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

Substitua:

PVC_NAMESPACE: o namespace do novo PersistentVolumeClaim.
PVC_NAME: o nome do novo PersistentVolumeClaim.
SNAPSHOT_NAME:o nome do objeto VolumeSnapshot.
STORAGE_SIZE: a quantidade de armazenamento a ser solicitada. Precisa ser igual ao valor solicitado no PersistentVolumeClaim da origem.

Aplique o manifesto ao cluster:
```
kubectl apply -f snapshot-pvc.yaml
```

Isso cria um novo PersistentVolumeClaim chamado PVC_NAME no cluster, que o GKE usa para provisionar dinamicamente um novo PersistentVolume que contém os dados do snapshot do disco permanente de origem.

Clonagem de volume

Antes de usar a clonagem de volume, familiarize-se com as limitações dessa abordagem.

Salve o seguinte manifesto como 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
```
Substitua:
- PVC_NAMESPACE: o namespace do novo PersistentVolumeClaim.
- PVC_NAME: o nome do novo PersistentVolumeClaim.
- SOURCE_PVC: o nome do PersistentVolumeClaim de origem preenchido com dados.
- STORAGE_CLASS_NAME: a classe de armazenamento do novo PersistentVolumeClaim. Precisa ser o mesmo da classe de armazenamento PersistentVolumeClaim.
- STORAGE_SIZE: a quantidade de armazenamento do novo PersistentVolumeClaim. Precisa ser o mesmo valor solicitado pela PersistentVolumeClaim de origem.
Aplique o manifesto ao cluster:
```
kubectl apply -f cloning-pvc.yaml
```

Isso cria um PersistentVolumeClaim chamado PVC_NAME que o GKE usa para criar um novo PersistentVolume no modo ReadOnlyMany com os dados no PersistentVolume de origem.

Para informações mais detalhadas sobre a clonagem de volume, consulte Criar clones de volumes permanentes.

Disco permanente preexistentes

Salve o seguinte manifesto como 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
```
Substitua:
- PV_NAME: o nome do novo PersistentVolume.
- STORAGE_CLASS_NAME: o nome do novo StorageClass.
- DISK_SIZE: o tamanho do disco permanente preexistente. Por exemplo, 500G.
- PVC_NAMESPACE: o namespace do novo PersistentVolumeClaim.
- PVC_NAME: o nome do novo PersistentVolumeClaim.
- DISK_ID: o identificador do disco permanente preexistente. O formato é projects/{project_id}/zones/{zone_name}/disks/{disk_name} para discos permanentes zonais ou projects/{project_id}/regions/{region_name}/disks/{disk_name} para discos permanentes regionais.
- FS_TYPE: o tipo de sistema de arquivos. Você pode deixar como padrão (ext4) ou usar xfs. Se os clusters usarem um pool de nós do Windows Server, altere esse valor para NTFS.

Aplique o manifesto ao cluster:

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

Isso cria um PersistentVolumeClaim chamado PVC_NAME e um PersistentVolume chamado PV_NAME no modo ReadOnlyMany.

Para ver informações mais detalhadas sobre como usar um disco permanente atual, consulte Disco permanente atual.

Usar o PersistentVolumeClaim em um pod

Agora é possível fazer referência ao novo PersistentVolumeClaim no modo somente leitura em vários pods em vários nós ao mesmo tempo. Não é possível anexar discos permanentes no modo ReadWriteOnce em vários nós ao mesmo tempo. Para mais informações, consulte Implantações vs. StatefulSets.

Na especificação do pod, especifique readOnly: true nas seções volumeMounts e volumes, como no exemplo a seguir:

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

A seguir

Saiba mais sobre Como usar discos permanentes preexistentes como PersistentVolumes.
Saiba mais sobre Discos permanentes do Compute Engine.