Bestehenden nichtflüchtigen Speicher als PersistentVolumes verwenden

Autopilot Standard

Auf dieser Seite wird erläutert, wie Sie mit nichtflüchtigen Speichern, die mit Daten gefüllt sind, ein PersistentVolume erstellen und es in einem Pod verwenden.

Übersicht

Es gibt zwei gängige Szenarien, in denen ein bereits vorhandener nichtflüchtiger Speicher verwendet wird.

Wenn ein PersistentVolumeClaims und ein PersistentVolumes manuell erstellt werden, die beiden aneinander gebunden werden und auf den PersistentVolumeClaim in einer Pod-Spezifikation verwiesen wird.
Wenn ein StatefulSet verwendet wird, um automatisch PersistentVolumeClaims zu erzeugen, die an manuell erzeugte PersistentVolumes gebunden sind, die einer Reihe von bereits existierenden nichtflüchtigen Speichern entsprechen.

Für die Beispiele auf dieser Seite werden vorhandene nichtflüchtige Compute Engine-Speicher verwendet.

ext4 ist zwar der Standarddateisystemtyp, Sie können aber einen bereits vorhandenen nichtflüchtigen Speicher mit dem Dateisystem xfs verwenden, solange Ihr Knoten-Image ihn unterstützt. Um ein xfs-Laufwerk zu verwenden, ändern Sie spec.csi.fsType im PersistentVolume-Manifest in xfs.

Windows unterstützt den Dateisystemtyp ext4 nicht. Für Windows Server-Knotenpools muss das Dateisystem NTFS verwendet werden. Um ein NTFS-Laufwerk zu verwenden, ändern Sie spec.csi.fsType im PersistentVolume-Manifest in NTFS.

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.

Prüfen Sie, ob bereits nichtflüchtige Speicher vorhanden sind. Informationen zum Bereitstellen eines Laufwerks finden Sie unter Regionale nichtflüchtige Speicher bereitstellen.
Prüfen Sie, ob Ihr Cluster den CSI-Treiber für den nichtflüchtigen Speicher von Compute Engine verwendet.

Mit dem PersistentVolume gebundenen PersistentVolumeClaim nutzen

Damit ein Container auf Ihren bereits vorhandenen nichtflüchtigen Speicher zugreifen kann, müssen Sie Folgendes tun:

Stellen Sie den vorhandenen nichtflüchtigen Speicher als PersistentVolume bereit.
Binden Sie PersistentVolume an einen PersistentVolumeClaim.
Gewähren Sie den Containern im Pod Zugriff auf das PersistentVolume.

Erstellen Sie PersistentVolume und PersistentVolumeClaim

Es gibt mehrere Möglichkeiten, einen PersistentVolumeClaim an ein bestimmtes PersistentVolume zu binden. Das folgende YAML-Manifest erstellt beispielsweise ein neues PersistentVolume und einen PersistentVolumeClaim und bindet dann die Anforderung mit einem claimRef an das Volume, wodurch das PersistentVolume nur an diesen PersistentVolumeClaim gebunden werden kann.

Damit ein PersistentVolume an einen PersistentVolumeClaim gebunden wird, müssen die storageClassName der beiden Ressourcen sowie capacity, accessModes und volumeMode übereinstimmen. Sie können storageClassName weglassen. Sie müssen jedoch "" angeben, damit Kubernetes nicht die Standard-StorageClass verwendet.

Der storageClassName muss sich nicht auf ein vorhandenes StorageClass-Objekt beziehen. Wenn Sie die Anforderung nur an ein Volume binden müssen, können Sie einen beliebigen Namen verwenden. Wenn Sie jedoch zusätzliche Funktionen benötigen, die durch eine StorageClass konfiguriert wurden, z. B. die Größenanpassung von Volumes, muss storageClassName auf ein vorhandenes StorageClass-Objekt verweisen.

Weitere Informationen finden Sie in der Kubernetes-Dokumentation zu PersistentVolumes.

Speichern Sie das folgende YAML-Manifest:
```
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
```
Dabei gilt:
- PV_NAME ist der Name Ihres neuen PersistentVolume.
- STORAGE_CLASS_NAME ist der Name Ihrer neuen StorageClass.
- DISK_SIZE ist die Größe des vorhandenen nichtflüchtigen Speichers. Beispiel: 500G.
- PV_CLAIM_NAME ist der Name Ihres neuen PersistentVolumeClaim.
- DISK_ID ist die Kennung des bereits vorhandenen nichtflüchtigen Speichers. Das Format ist projects/{project_id}/zones/{zone_name}/disks/{disk_name} für zonale nichtflüchtige Speicher oder projects/{project_id}/regions/{region_name}/disks/{disk_name} für regionale nichtflüchtige Speicher.
- FS_TYPE ist der Dateisystemtyp. Sie können die Standardeinstellung (ext4) beibehalten oder xfs verwenden. Wenn Ihre Cluster einen Windows Server-Knotenpool verwenden, müssen Sie den Wert in NTFS ändern.
Führen Sie den folgenden Befehl aus, um die Konfiguration anzuwenden und die PersistentVolume- und PersistentVolumeClaim-Ressourcen zu erstellen:
```
kubectl apply -f FILE_PATH
```
Ersetzen Sie FILE_PATH durch den Pfad zur YAML-Datei.

PersistentVolume in einem Pod verwenden

Nachdem Sie PersistentVolume und PersistentVolumeClaim erstellt und verknüpft haben, können Sie den Containern eines Pods Zugriff auf das Volume gewähren, indem Sie im Feld volumeMounts Werte angeben.

In der folgenden YAML-Konfiguration werden ein neuer Pod und ein Container mit einem nginx-Image erstellt. Anschließend wird das PersistentVolume auf dem Pod bereitgestellt:

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

Dabei gilt:

POD_NAME ist der Name Ihres neuen Pods.
VOLUME_NAME ist der Name des Volumes.
PV_CLAIM_NAME ist der Name des PersistentVolumeClaim, den Sie im vorherigen Schritt erstellt haben.
CONTAINER_NAME ist der Name des neuen Containers.

Wenden Sie die Konfiguration an:

kubectl apply -f FILE_PATH

Ersetzen Sie FILE_PATH durch den Pfad zur YAML-Datei.

Prüfen Sie mit dem folgenden Befehl, ob das Volume bereitgestellt wurde:

kubectl describe pods POD_NAME

Prüfen Sie in der Ausgabe, ob der PersistentVolumeClaim bereitgestellt wurde:

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

Vorhandenes Laufwerk in einem StatefulSet verwenden

Sie können bereits vorhandene nichtflüchtige Compute Engine-Speicher in einem StatefulSet mit PersistentVolumes verwenden. Das StatefulSet generiert automatisch für jedes Replikat einen PersistentVolumeClaim. Sie können die Namen der generierten PersistentVolumeClaims vorhersagen und über claimRef mit den PersistentVolumes verknüpfen.

Im folgenden Beispiel erstellen Sie zwei vorhandene nichtflüchtige Speicher, erstellen PersistentVolumes für die Laufwerke und stellen die Volumes dann auf einem StatefulSet mit zwei Replikaten im Standard-Namespace bereit.

Legen Sie einen Namen für das neue StatefulSet, einen Namen für Ihre PersistentVolumeClaim-Vorlage und die Anzahl der Replikate im StatefulSet fest.
Ermitteln Sie die Namen der automatisch generierten PersistentVolumeClaims. Das StatefulSet verwendet für PersistentVolumeClaim-Namen das folgende Format:
```
PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX
```
Dabei gilt:
- PVC_TEMPLATE_NAME ist der Name der neuen PersistentVolumeClaim-Vorlage
- STATEFULSET_NAME ist der Name Ihres neuen StatefulSets.
- REPLICA_INDEX ist der Index des StatefulSet-Replikats. Verwenden Sie für dieses Beispiel 0 und 1.

Erstellen Sie die PersistentVolumes. Sie müssen für jedes Replikat im StatefulSet ein PersistentVolume erstellen.

Speichern Sie das folgende YAML-Manifest:

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

Dabei gilt:

DISK1_SIZE and DISK2_SIZE ist die Größe Ihrer vorhandenen nichtflüchtigen Speicher.
DISK1_ID and DISK2_ID sind die IDs Ihrer vorhandenen nichtflüchtigen Speicher.
PVC1_NAME and PVC2_NAME sind die Namen der automatisch generierten PersistentVolumeClaims.
STORAGE_CLASS_NAME: ist der Name Ihrer StorageClass.

Wenden Sie die Konfiguration an:
```
kubectl apply -f FILE_PATH
```
Ersetzen Sie FILE_PATH durch den Pfad zur YAML-Datei.

Erstellen Sie ein StatefulSet mit den in Schritt 1 gewählten Werten. Achten Sie darauf, dass der in volumeClaimTemplates angegebene Speicher kleiner oder gleich der Kapazität Ihrer PersistentVolumes ist.

Speichern Sie das folgende YAML-Manifest:

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

Dabei gilt:

STATEFULSET_NAME ist der Name Ihres neuen StatefulSets.
PVC_TEMPLATE_NAME ist der Name der neuen PersistentVolumeClaim-Vorlage
STORAGE_CLASS_NAME: ist der Name Ihrer StorageClass.

Wenden Sie die Konfiguration an:
```
kubectl apply -f FILE_PATH
```
Ersetzen Sie FILE_PATH durch den Pfad zur YAML-Datei.

Nächste Schritte

Weitere Informationen zum Bereitstellen einer zustandsorientierten Anwendung