Diese Seite wurde von der Cloud Translation API übersetzt.

Nichtflüchtigen Speicher für GKE-Cluster sichern und wiederherstellen

Auf dieser Seite erfahren Sie, wie Sie den zugrunde liegenden Filestore sichern und wiederherstellen. Speicher, der Ihren GKE-Clustern unter Verwendung des Kubernetes-Volumes zugeordnet ist Snapshots.

Das Erstellen eines Kubernetes-Volume-Snapshots entspricht dem Erstellen einer Filestore-Sicherung.

Weitere Informationen finden Sie unter Kubernetes-Volume-Snapshots

Voraussetzungen

Zur Verwendung von Volume-Snapshots in GKE müssen Sie die folgenden Anforderungen erfüllen:

Sie müssen den Filestore-CSI-Treiber Nur die folgenden Filestore-Dienstebenen werden unterstützt:
- Basic HDD mit GKE-Version 1.21 oder höher
- Basic SSD mit GKE-Version 1.21 oder höher
- Zonal (10 TiB bis 100 TiB) mit GKE Version 1.27 oder höher
- Enterprise mit GKE-Version 1.25 oder höher
Verwenden Sie die Version 1.17 oder höher der Steuerungsebene. So verwenden Sie die Filestore-CSI-Treiber in einem VolumeSnapshot die GKE-Versionsnummer für Ihre Dienststufe.

Sie benötigen einen vorhandenen PersistentVolumeClaim, der für einen Snapshot verwendet werden kann. Der PersistentVolume, den Sie für eine Snapshot-Quelle verwenden, muss von einem CSI-Treiber verwaltet werden. Prüfen Sie, ob Sie einen CSI-Treiber verwenden. Bestätigen Sie dazu, dass die PersistentVolume-Spezifikation den Abschnitt csi mit driver: pd.csi.storage.gke.io oder filestore.csi.storage.gke.io enthält. Wenn das PersistentVolume vom CSI-Treiber dynamisch bereitgestellt wird, wie in den folgenden Abschnitten beschrieben, wird es vom CSI-Treiber verwaltet.

Beschränkungen

Für Snapshot-Volumes gelten dieselben Größenbeschränkungen wie für reguläre Volumes. Beispielsweise müssen Filestore-Snapshots größer oder gleich 1 TiB für die Stufe „Basic HDD“ sein.
Der Filestore-CSI-Treiber unterstützt keine dynamischen Bereitstellungs- oder Sicherungsworkflows für die folgenden Filestore-Dienststufen:
- Zonal (1 TiB bis 9,75 TiB)
- Regional
Sie können jeweils nur eine Freigabe pro Instanz gleichzeitig sichern. In Bezug auf Speicherpools werden Sicherungsanfragen, die von zwei verschiedenen Freigaben aus zwei verschiedenen Filestore-Instanzen ausgegeben werden, gleichzeitig ausgeführt.
Singleshare-Sicherungen können nur auf Singleshare-Volumes wiederhergestellt werden. Mit dem Filestore-CSI-Treiber können Sie ein Singleshare-Volume nur in einer neuen Filestore-Instanz wiederherstellen.
- Die neue Instanz muss dieselbe Dienststufe wie die Sicherung verwenden.
- Die neue Instanz muss dieselbe Mindestkapazität wie die Sicherung haben.
Filestore-backup restore-Vorgänge auf die Quelle oder eine vorhandene Filestore-Instanz werden nicht unterstützt. Eine vollständige Liste der Feature-Einschränkungen finden Sie unter Einschränkungen für Filestore-Sicherungsfunktionen.
Sicherungen mit mehreren Freigaben werden nicht unterstützt.

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

Volume-Snapshot erstellen und verwenden

Die Beispiele in diesem Dokument beschreiben die Ausführung der folgenden Aufgaben:

Eine PersistentVolumeClaim und ein Deployment erstellen.
Dem PersistentVolume eine Datei hinzufügen, die vom Deployment verwendet wird.
Ein VolumeSnapshotClass erstellen, um den Snapshot zu konfigurieren
Einen Volume-Snapshot vom PersistentVolume erstellen
Die Testdatei löschen
Stellen Sie PersistentVolume auf den von Ihnen erstellten Snapshot wieder her.
Prüfen, ob die Wiederherstellung funktioniert hat

So verwenden Sie einen Volume-Snapshot:

Erstellen Sie ein VolumeSnapshotClass-Objekt, um die CSI-Treiber- und Löschrichtlinie für Ihren Snapshot anzugeben.
Erstellen Sie ein VolumeSnapshot-Objekt, um einen Snapshot eines vorhandenen PersistentVolumeClaim anzufragen.
Verweisen Sie auf den VolumeSnapshot in einer PersistentVolumeClaim, um ein Volume anhand dieses Snapshots wiederherzustellen, oder erstellen Sie ein neues Volume mithilfe dieses Snapshots.

`PersistentVolumeClaim` und `Deployment` erstellen

Speichern Sie zum Erstellen des PersistentVolumeClaim-Objekts das folgende Manifest als my-pvc.yaml:
Filestore
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti
```
In diesem Beispiel wird ein PVC für Filestore der Enterprise-Stufe erstellt. Weitere Informationen finden Sie unter Mit dem CSI-Treiber von Filestore auf Filestore-Instanzen zugreifen.
Für spec.storageClassName können Sie jede Speicherklasse angeben, die einen unterstützten CSI-Treiber verwendet.
Wenden Sie das Manifest an:
```
kubectl apply -f my-pvc.yaml
```

Speichern Sie zum Erstellen eines Deployment das folgende Manifest als my-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app
spec:
  selector:
    matchLabels:
      app: hello-app
  template:
    metadata:
      labels:
        app: hello-app
    spec:
      containers:
      - name: hello-app
        image: google/cloud-sdk:slim
        args: [ "sleep", "3600" ]
        volumeMounts:
        - name: sdk-volume
          mountPath: /usr/share/hello/
      volumes:
      - name: sdk-volume
        persistentVolumeClaim:
          claimName: my-pvc

Wenden Sie das Manifest an:
```
kubectl apply -f my-deployment.yaml
```
Prüfen Sie den Status des Deployment:
```
kubectl get deployment hello-app
```
Es kann einige Zeit dauern, bis das Deployment bereit ist. Sie können den vorherigen Befehl so lange ausführen, bis eine Ausgabe wie diese angezeigt wird:
```
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
hello-app   1/1     1            1           2m55s
```

Testdatei zum Volume hinzufügen

Listen Sie die Pods im Deployment auf:

kubectl get pods -l app=hello-app

Die Ausgabe sieht in etwa so aus:

NAME                         READY   STATUS    RESTARTS   AGE
hello-app-6d7b457c7d-vl4jr   1/1     Running   0          2m56s

Erstellen Sie in einem Pod eine Testdatei:

kubectl exec POD_NAME \
    -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'

Ersetzen Sie POD_NAME durch den Namen des Pod.

Prüfen Sie, ob die Datei vorhanden ist:

kubectl exec POD_NAME \
    -- sh -c 'cat /usr/share/hello/hello.txt'

Die Ausgabe sieht in etwa so aus:

Hello World!

Erstellen Sie ein `VolumeSnapshotClass`-Objekt

Erstellen Sie ein VolumeSnapshotClass-Objekt, um den CSI-Treiber und die deletionPolicy für Ihren Volume-Snapshot anzugeben. Sie können auf VolumeSnapshotClass-Objekte verweisen, wenn Sie VolumeSnapshot-Objekte erstellen.

Speichern Sie das folgende Manifest als volumesnapshotclass.yaml.
Filestore
```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: filestore.csi.storage.gke.io
parameters:
  type: backup
deletionPolicy: Delete
```
In diesem Fall gilt Folgendes:
- Das Feld driver wird vom CSI-Treiber zum Bereitstellen des Snapshots verwendet. In diesem Beispiel verwendet filestore.csi.storage.gke.io den Filestore-CSI-Treiber.
- Das Feld deletionPolicy teilt GKE mit, was mit dem VolumeSnapshotContent-Objekt und dem zugrunde liegenden Snapshot geschieht, wenn das gebundene VolumeSnapshot-Objekt gelöscht wird. Geben Sie Delete an, um das VolumeSnapshotContent-Objekt und den zugrunde liegenden Snapshot zu löschen. Geben Sie Retain an, wenn Sie VolumeSnapshotContent und den zugrunde liegenden Snapshot beibehalten möchten.

Wenden Sie das Manifest an:

kubectl apply -f volumesnapshotclass.yaml

`VolumeSnapshot` erstellen

Ein VolumeSnapshot-Objekt ist eine Anfrage für einen Snapshot eines vorhandenen PersistentVolumeClaim-Objekts. Wenn Sie ein VolumeSnapshot-Objekt erstellen, erstellt GKE automatisch ein VolumeSnapshotContent-Objekt, das wie ein PersistentVolume-Objekt eine Ressource in Ihrem Cluster ist, und bindet es an dieses.

Speichern Sie das folgende Manifest als volumesnapshot.yaml.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: my-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    persistentVolumeClaimName: my-pvc

Wenden Sie das Manifest an:
```
kubectl apply -f volumesnapshot.yaml
```
Nachdem Sie einen Volume erstellt haben, erstellt GKE ein entsprechendes VolumeSnapshotContent-Objekt im Cluster. Dieses Objekt speichert den Snapshot und die Bindungen von VolumeSnapshot-Objekten. Sie interagieren nicht mit VolumeSnapshotContents-Objekte direkt.

Prüfen Sie, ob GKE das VolumeSnapshotContents-Objekt erstellt hat:

kubectl get volumesnapshotcontents

Die Ausgabe sieht in etwa so aus:

NAME                                               AGE
snapcontent-cee5fb1f-5427-11ea-a53c-42010a1000da   55s

Nachdem der Inhalt des Volume-Snapshots erstellt wurde, erstellt der CSI-Treiber, den Sie in VolumeSnapshotClass angegeben haben, einen Snapshot im entsprechenden Speichersystem. Nachdem GKE einen Snapshot im Speichersystem erstellt und mit einem VolumeSnapshot-Objekt im Cluster verknüpft hat, kann der Snapshot verwendet werden. Sie können den Status prüfen, indem Sie den folgenden Befehl ausführen:

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

Wenn der Snapshot einsatzbereit ist, sieht die Ausgabe in etwa so aus:

NAME               READY
my-snapshot        true

Die Testdatei löschen

Löschen Sie die erstellte Testdatei:

kubectl exec POD_NAME \
    -- sh -c 'rm /usr/share/hello/hello.txt'

Prüfen Sie, ob die Datei nicht mehr existiert:

kubectl exec POD_NAME \
    -- sh -c 'cat /usr/share/hello/hello.txt'

Die Ausgabe sieht in etwa so aus:

cat: /usr/share/hello/hello.txt: No such file or directory

Volume-Snapshot wiederherstellen

Speichern Sie das folgende Manifest als pvc-restore.yaml:

Filestore

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Ti

Wenden Sie das Manifest an:
```
kubectl apply -f pvc-restore.yaml
```

Aktualisieren Sie die Datei my-deployment.yaml, um die neue PersistentVolumeClaim zu verwenden:

...
volumes:
- name: my-volume
  persistentVolumeClaim:
    claimName: pvc-restore

Wenden Sie das aktualisierte Manifest an:
```
kubectl apply -f my-deployment.yaml
```

Auf erfolgreiche Wiederherstellung des Snapshots prüfen

Rufen Sie den Namen der neuen Pod ab, die GKE für die aktualisierte Deployment:
```
 kubectl get pods -l app=hello-app
```

Prüfen Sie, ob die Testdatei vorhanden ist:

   kubectl exec NEW_POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'

Ersetzen Sie NEW_POD_NAME durch den Namen des neuen Pod, der von GKE erstellt wurde.

Die Ausgabe sieht in etwa so aus:

   Hello World!

Vorhandenen Snapshot importieren

Sie können einen vorhandenen Volume-Snapshot verwenden, der außerhalb des aktuellen Clusters erstellt wurde um das Objekt VolumeSnapshotContents manuell bereitzustellen. So können Sie zum Beispiel ein Volume in GKE mit einem Snapshot eines anderen In einem anderen Cluster erstellte Google Cloud-Ressource.

Suchen Sie den Namen des Snapshots.

Google Cloud Console

Rufen Sie https://console.cloud.google.com/compute/snapshots auf.

Google Cloud CLI

Führen Sie dazu diesen Befehl aus:

gcloud compute snapshots list

Die Ausgabe sieht in etwa so aus:

NAME                                           DISK_SIZE_GB  SRC_DISK                                                     STATUS
snapshot-5e6af474-cbcc-49ed-b53f-32262959a0a0  1             us-central1-b/disks/pvc-69f80fca-bb06-4519-9e7d-b26f45c1f4aa READY

Speichern Sie das folgende VolumeSnapshot-Manifest als restored-snapshot.yaml.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: restored-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    volumeSnapshotContentName: restored-snapshot-content

Wenden Sie das Manifest an:

kubectl apply -f restored-snapshot.yaml

Speichern Sie das folgende VolumeSnapshotContent-Manifest als restored-snapshot-content.yaml. Ersetzen Sie das Feld snapshotHandle durch Ihre Projekt-ID und den Snapshot-Namen. Sowohl volumeSnapshotRef.name als auch volumeSnapshotRef.namespace muss auf das zuvor erstellte VolumeSnapshot, damit die bidirektionale Bindung gültig ist.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotContent
metadata:
  name: restored-snapshot-content
spec:
  deletionPolicy: Retain
  driver: filestore.csi.storage.gke.io
  source:
    snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
  volumeSnapshotRef:
    kind: VolumeSnapshot
    name: restored-snapshot
    namespace: default

Wenden Sie das Manifest an:

kubectl apply -f restored-snapshot-content.yaml

Speichern Sie das folgende PersistentVolumeClaim-Manifest als restored-pvc.yaml. Der Kubernetes-Speichercontroller sucht nach einer VolumeSnapshot mit dem Namen restored-snapshot und versucht dann, eine PersistentVolume als Datenquelle zu finden oder dynamisch zu erstellen. Sie können diesen PVC dann in einem Pod verwenden. um auf die wiederhergestellten Daten zuzugreifen.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: restored-pvc
spec:
  dataSource:
    name: restored-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Wenden Sie das Manifest an:
```
kubectl apply -f restored-pvc.yaml
```

Speichern Sie das folgende Pod-Manifest als restored-pod.yaml, das auf den PersistentVolumeClaim Der CSI-Treiber stellt ein PersistentVolume bereit und füllen es aus dem Snapshot.

apiVersion: v1
kind: Pod
metadata:
  name: restored-pod
spec:
  containers:
  - name: busybox
    image: busybox
    args:
    - sleep
    - "3600"
    volumeMounts:
    - name: source-data
      mountPath: /demo/data
  volumes:
  - name: source-data
    persistentVolumeClaim:
      claimName: restored-pvc
      readOnly: false

Wenden Sie das Manifest an:
```
kubectl apply -f restored-pod.yaml
```

Prüfen Sie, ob die Datei wiederhergestellt wurde:

kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Löschen Sie das VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Hinweis: Wenn die VolumeSnapshotClass eines Volume-Snapshots deletionPolicy:Delete hat, werden auch der entsprechende VolumeSnapshotContent und der physische Snapshot im Speichersystem gelöscht. Wenn deletionPolicy:Retain vorhanden ist, behält GKE den zugrunde liegenden Snapshot bei.

Löschen Sie das VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

Löschen Sie das Deployment:
```
kubectl delete deployments hello-app
```
PersistentVolumeClaim-Objekte löschen:
```
kubectl delete pvc my-pvc pvc-restore
```

Nächste Schritte

Dokumentation zum Kubernetes-VolumeSnapshot lesen
Weitere Informationen zur Volume-Erweiterung
CSI-Treiber manuell installieren
Filestore als Dateispeicheroption für GKE

Nichtflüchtigen Speicher für GKE-Cluster sichern und wiederherstellen

Voraussetzungen

Beschränkungen

Hinweise

Volume-Snapshot erstellen und verwenden

PersistentVolumeClaim und Deployment erstellen

Filestore

Testdatei zum Volume hinzufügen

Erstellen Sie ein VolumeSnapshotClass-Objekt

Filestore

VolumeSnapshot erstellen

Die Testdatei löschen

Volume-Snapshot wiederherstellen

Filestore

Auf erfolgreiche Wiederherstellung des Snapshots prüfen

Vorhandenen Snapshot importieren

Google Cloud Console

Google Cloud CLI

Bereinigen

Nächste Schritte

`PersistentVolumeClaim` und `Deployment` erstellen

Erstellen Sie ein `VolumeSnapshotClass`-Objekt

`VolumeSnapshot` erstellen