Questa pagina è stata tradotta dall'API Cloud Translation.

Usa dischi permanenti con più lettori

Autopilot Standard

Questa pagina spiega come aggiungere un disco permanente al tuo cluster utilizzando la modalità di accesso ReadOnlyMany. Questa modalità consente a più pod su diversi nodi di montare il disco per la lettura.

Per ulteriori informazioni su questa modalità, consulta l'articolo sull'accesso al volume permanente modalità.

Requisiti

Il cluster deve eseguire GKE 1.22 o versioni successive.
Il cluster deve utilizzare il driver CSI per il disco permanente di Compute Engine.

Formatta e compila un disco permanente di origine

Per utilizzare un disco permanente in modalità di sola lettura, devi completare un'origine un disco permanente con dati, quindi clona il volume o utilizzane uno uno snapshot per spostare i dati in un nuovo PersistentVolume ReadOnly Many.

Crea un PersistentVolume utilizzando disco permanente esistente o utilizzando il provisioning dinamico.
Formatta il disco e compilalo con i dati. Per formattare il disco, fai riferimento al disco come PersistentVolume ReadWriteOnce in un pod. GKE formatta automaticamente il disco sottostante e consente al pod di scrivere i dati sul disco. All'avvio del pod, assicurati che scriva i dati che ti interessano sul disco.

Crea un PersistentVolume `ReadOnlyMany`

Puoi creare un PersistentVolume ReadOnlyMany utilizzando uno dei seguenti elementi metodo:

Uno snapshot del volume di un PersistentVolume di origine che completi con i dati.
Un clone del volume di un PersistentVolume di origine che viene compilato con i dati.
Un disco permanente preesistente già compilato con dati.

Istantanea del volume

Crea uno snapshot del volume del PersistentVolume di origine.
Salva il seguente manifest PersistentVolumeClaim come 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
```
Sostituisci quanto segue:
- PVC_NAMESPACE: lo spazio dei nomi del nuovo PersistentVolumeClaim.
- PVC_NAME: il nome del nuovo PersistentVolumeClaim.
- SNAPSHOT_NAME:il nome del tuo Oggetto VolumeSnapshot.
- STORAGE_SIZE: la quantità di spazio di archiviazione da richiedere. Deve corrispondere all'importo richiesto nella fonte e PersistentVolumeClaim.
Applica il manifest al cluster:
```
kubectl apply -f snapshot-pvc.yaml
```

Viene creato un nuovo PersistentVolumeClaim denominato PVC_NAME nel cluster, che GKE utilizza per eseguire il provisioning dinamico di un nuovo PersistentVolume che contiene i dati dello snapshot del disco permanente di origine.

Clonazione volumi

Prima di utilizzare la clonazione dei volumi, assicurati di conoscere i limiti di questo approccio.

Salva il seguente manifest come 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
```
Sostituisci quanto segue:
- PVC_NAMESPACE: lo spazio dei nomi del nuovo PersistentVolumeClaim.
- PVC_NAME: il nome del nuovo e PersistentVolumeClaim.
- SOURCE_PVC: il nome della fonte PersistentVolumeClaim compilato con i dati.
- STORAGE_CLASS_NAME: la classe di archiviazione per e un nuovo oggetto PersistentVolumeClaim. Deve essere uguale all'unità di archiviazione del PersistentVolumeClaim di origine.
- STORAGE_SIZE: la quantità di spazio di archiviazione per il nuovo PersistentVolumeClaim. Deve essere lo stesso importo richiesto dal PersistentVolumeClaim di origine.
Applica il manifest al cluster:
```
kubectl apply -f cloning-pvc.yaml
```

Viene creato un oggetto PersistentVolumeClaim denominato PVC_NAME che GKE per creare un nuovo PersistentVolume in modalità ReadOnly Many con i dati nel PersistentVolume di origine.

Per informazioni più dettagliate sulla clonazione dei volumi, consulta Creare cloni di volumi permanenti.

Disco permanente preesistente

Salva il seguente manifest come 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
```
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.
- PVC_NAMESPACE: lo spazio dei nomi del nuovo PersistentVolumeClaim.
- PVC_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 questa impostazione predefinita (ext4) o utilizzare xfs. Se i tuoi cluster utilizzano un pool di nodi Windows Server, devi impostare questo valore su NTFS.

Applica il manifest al cluster:

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

Viene creato un oggetto PersistentVolumeClaim denominato PVC_NAME e un PersistentVolume denominato PV_NAME in modalità ReadOnly Many.

Per informazioni più dettagliate sull'utilizzo di un disco permanente preesistente, consulta disco permanente esistente.

Utilizzare PersistentVolumeClaim in un pod

Ora puoi fare riferimento al nuovo PersistentVolumeClaim in modalità di sola lettura in più pod su più nodi contemporaneamente. Non puoi collegare i pod in modalità ReadWriteOnce su più nodi contemporaneamente. Per ulteriori informazioni, consulta Deployment e StatefulSet.

Nella specifica del pod, devi specificare readOnly: true nel volumeMounts e volumes, come quelle che seguono esempio:

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

Passaggi successivi

Scopri di più sull'utilizzo di dischi permanenti preesistenti come volumi permanenti.
Scopri di più sui dischi permanenti Compute Engine.