Portworx im Cluster installieren

Stellen Sie eine Portworx-Serviceinstanz über den IBM Cloud-Katalog bereit. Nachdem Sie die Serviceinstanz erstellt haben, wird die neueste Portworx Enterprise Edition (px-enterprise) unter Verwendung von Helm auf Ihrem Cluster installiert. Darüber hinaus ist Stork auch auf Ihrem Cluster „ IBM Cloud Kubernetes Service “ installiert. Stork ist der Portworx-Speicherscheduler. Mit Stork können Sie Pods zusammen mit ihren Daten unterbringen sowie Snapshots von „ Portworx “-Volumes erstellen und wiederherstellen.

Suchen Sie nach Anweisungen zum Aktualisieren oder Entfernen von Portworx? Siehe „ Portworx aktualisieren“ und „ Portworx entfernen “.

Die Standardinstallationsmethode für „ Portworx Enterprise “ und „ Portworx “ Backup wird für private Cluster in der Region Montreal noch nicht unterstützt. Wenden Sie sich an den Portworx-Support, wenn Sie Portworx Enterprise oder Portworx Backup in einem privaten Cluster in Montreal installieren müssen. Weitere Informationen finden Sie unter „ Portworx-Support“

Vorbereitende Schritte:

Gehen Sie wie folgt vor, um Portworx zu installieren:

  1. Öffnen Sie den Dienst „ Portworx “ aus dem Katalog „ IBM Cloud “ und füllen Sie die Felder wie folgt aus:

    1. Wählen Sie die Region aus, in der sich Ihr IBM Cloud Kubernetes Service-Cluster befindet.

    2. Lesen Sie die Preisinformationen zu Portworx.

    3. Geben Sie einen Namen für Ihre Portworx-Serviceinstanz ein.

    4. Wählen Sie die Ressourcengruppe aus, in der sich Ihr Cluster befindet.

    5. Geben Sie im Feld Tag den Namen des Clusters ein, in dem Sie Portworx installieren möchten. Nachdem Sie die Portworx-Serviceinstanz erstellt haben, wird der Cluster, in dem Sie Portworx installiert haben, nicht angezeigt. Um den Cluster später leichter auffinden zu können, achten Sie darauf, den Clusternamen und eventuelle Zusatzinformationen als Tags einzugeben.

    6. Geben Sie einen IBM Cloud-API-Schlüssel ein, um die Liste von Clustern abzurufen, auf die Sie Zugriff haben. Wenn Sie keinen API-Schlüssel haben, lesen Sie die Informationen unter Benutzer-API-Schlüssel verwalten. Nach der Eingabe des API-Schlüssels wird das Feld Kubernetes- oder OpenShift-Clustername eingeblendet.

    7. Geben Sie einen eindeutigen Portworx-Clusternamen ein.

    8. Gehen Sie im Menü Cloud-Laufwerke wie folgt vor:

      1. Wählen Sie Cloudlaufwerke verwenden (nur VPC-Cluster) aus, um Block Storage for VPC dynamisch für Portworx bereitzustellen. Wählen Sie nach der Auswahl von Cloud-Laufwerke verwenden den Speicherklassennamen und die Größe der Blockspeicher-Laufwerke aus, die Sie bereitstellen möchten.
      2. Wählen Sie Bereits angehängte Laufwerke verwenden (Klassisch, VPC oder Satellit) aus, um den Blockspeicher zu verwenden, der bereits Ihren Workerknoten zugeordnet wurde.

    9. Wählen Sie in der Dropdown-Liste für den Schlüssel/Wert-Speicher für Portworx-Metadaten den Typ des Schlüssel/Wert-Speichers aus, der zum Speichern der Portworx-Metadaten verwendet werden soll. Wählen Sie Portworx-KVDB aus, damit während der Portworx-Installation automatisch ein Schlüssel/Wert-Speicher erstellt wird, oder wählen Sie Databases for etcd aus, wenn Sie eine vorhandene Databases for etcd-Instanz verwenden möchten. Wenn Sie Databases for etcd auswählen, werden die Felder Etcd-API-Endpunkte und Name des geheimen Etcd-Schlüssels angezeigt.

    10. Namensbereich: Geben Sie den Namensbereich ein, in dem Sie die Portworx-Ressourcen bereitstellen wollen.

    11. Nur für Databases for etcd erforderlich: Geben Sie die Informationen zu Ihrer Databases for etcd-Serviceinstanz ein.

      1. Rufen Sie den etcd-Endpunkt und den Namen des geheimen Kubernetes-Schlüssels ab, den Sie für die Databases for etcd-Serviceinstanz erstellt haben.
      2. Geben Sie unter etcd-API-Endpunkte den API-Endpunkt Ihrer Databases for etcd-Serviceinstanz ein, den Sie zuvor abgerufen haben. Stellen Sie sicher, dass Sie den Endpunkt im Format etcd:<etcd_endpoint1>;etcd:<etcd_endpoint2> eingeben. Wenn Sie mehr als einen Endpunkt haben, schließen Sie alle Endpunkte ein und trennen Sie sie mit einem Semikolon (;).
      3. Geben Sie im Feld Name des geheimen etcd-Schlüssels den Namen des geheimen Kubernetes-Schlüssels ein, um die Databases for etcd-Serviceberechtigungsnachweise zu speichern.

    12. Wählen Sie aus der Dropdown-Liste Kubernetes- oder OpenShift-Clustername den Cluster aus, in dem Portworx installiert werden soll. Wenn Ihr Cluster nicht aufgelistet ist, achten Sie darauf, die richtige IBM Cloud-Region auszuwählen. Wenn die Region korrekt ist, stellen Sie sicher, dass Ihre Berechtigungen ausreichen, um den Cluster anzeigen oder mit ihm arbeiten zu können. Stellen Sie sicher, dass Sie einen Cluster auswählen, der die Mindestanforderungen an die Hardware für „ Portworx “ erfüllt.

    13. Optional: Wählen Sie in der Dropdown-Liste Speichertyp für geheime Portworx-Schlüssel den Typ des geheimen Speicherschlüssels aus, den Sie zum Speichern des Datenträgerverschlüsselungsschlüssels verwenden möchten.

      • Geheimer Kubernetes-Schlüssel: Wählen Sie diese Option aus, wenn Sie Ihren eigenen angepassten Schlüssel zum Verschlüsseln Ihrer Datenträger in einem geheimen Kubernetes-Schlüssel in Ihrem Custer speichern möchten. Der geheime Schlüssel darf vor der Installation von Portworx nicht vorhanden sein. Sie können den geheimen Schlüssel nach der Installation von Portworx erstellen. Weitere Informationen finden Sie in der Dokumentation zu „ Portworx “.
      • IBM Key Protect: Wählen Sie diese Option aus, wenn Sie Rootschlüssel in IBM Key Protect zum Verschlüsseln Ihrer Datenträger verwenden möchten. Achten Sie darauf, die Anweisungen für die Erstellung Ihrer IBM Key Protect-Serviceinstanz zu befolgen und die Berechtigungsnachweise für den Zugriff auf Ihre Serviceinstanz in einem geheimen Kubernetes-Schlüssel im portworx-Namensbereich zu speichern, bevor Sie Portworx installieren.

    14. Optional: Wenn Sie eine Journaleinheit oder KVDB-Einheiten konfigurieren möchten, geben Sie die Einheitendetails im Feld Erweiterte Optionen ein. Wählen Sie eine der folgenden Optionen für Journaleinheiten aus.

      • Geben Sie j;auto ein, damit Portworx automatisch eine 3-GB-Partition auf einer Ihrer Blockspeichereinheiten für das Journal erstellen kann.
      • Geben Sie j;</device/path> ein, um eine bestimmte Einheit für das Journal zu verwenden. Geben Sie beispielsweise j;/dev/vde ein, um die Platte zu verwenden, die sich unter /dev/vde befindet. Um den Pfad der Einheit zu finden, die Sie für das Journal verwenden möchten, melden Sie sich bei einem Workerknoten an und führen Sie lsblk aus.
      • Geben Sie kvdb_dev;<device path> ein, um die Einheit anzugeben, auf der Sie interne KVDB-Daten speichern wollen. Beispiel: kvdb_dev;/dev/vdd. Um den Pfad der Einheit zu finden, die verwendet werden soll, melden Sie sich an einem Workerknoten an und führen lsblk aus. Um eine bestimmte Einheit für KVDB-Daten verwenden zu können, müssen Sie über eine verfügbare Speichereinheit von 3 GB oder mindestens 3 Workerknoten verfügen. Die Geräte müssen außerdem auf jedem Worker-Knoten denselben Pfad haben. Beispiel: /dev/vdd.

  2. Klicken Sie auf Erstellen, um die Portworx-Installation in Ihrem Cluster zu starten. Dieser Prozess kann einige Minuten dauern. Die Seite 'Servicedetails' wird geöffnet. Sie enthält Anweisungen zum Überprüfen Ihrer Portworx-Installation, Erstellen eines persistenten Datenträgers (PVC) und Anhängen des PVC an eine App.

  3. Suchen Sie im „ IBM Cloud Ressourcenliste “ den von Ihnen erstellten Dienst „ Portworx “.

  4. Sehen Sie in der Spalte Status nach, ob die Installation erfolgreich war oder fehlgeschlagen ist. Die Aktualisierung des Status kann einige Minuten in Anspruch nehmen.

  5. Wenn sich der Status in Provision failure ändert, folgen Sie den Anweisungen, um die Ursache für das Scheitern der Installation zu beheben.

  6. Wenn sich der Status in Provisioned ändert, überprüfen Sie, ob Ihre Portworx-Installation erfolgreich ausgeführt wurde und alle Ihre lokalen Platten erkannt und der Portworx-Speicherebene hinzugefügt wurden.

    1. Listen Sie die Portworx-Pods im kube-system-Namensbereich auf. Die Installation war erfolgreich, wenn ein oder mehrere Pods portworx, stork und stork-scheduler angezeigt werden. Die Anzahl der Pods entspricht der Anzahl der Workerknoten in Ihrem Portworx-Cluster. Alle Pods müssen den Status Running aufweisen.
        kubectl get pods -n kube-system | grep 'portworx\|stork'
    ```
    Beispielausgabe
    ```sh {: screen}
    portworx-594rw                          1/1       Running     0          20h
    portworx-rn6wk                          1/1       Running     0          20h
    portworx-rx9vf                          1/1       Running     0          20h
    stork-6b99cf5579-5q6x4                  1/1       Running     0          20h
    stork-6b99cf5579-slqlr                  1/1       Running     0          20h
    stork-6b99cf5579-vz9j4                  1/1       Running     0          20h
    stork-scheduler-7dd8799cc-bl75b         1/1       Running     0          20h
    stork-scheduler-7dd8799cc-j4rc9         1/1       Running     0          20h
    stork-scheduler-7dd8799cc-knjwt         1/1       Running     0          20h
    ```
2. Melden Sie sich bei einem Ihrer Pods `portworx` an und listen Sie den Status Ihres Portworx-Clusters auf.
```sh {: pre}
    kubectl exec <portworx_pod> -it -n kube-system -- /opt/pwx/bin/pxctl status
    ```
    Beispielausgabe
    ```sh {: screen}
    Status: PX is operational
    License: Trial (expires in 30 days)
    Node ID: 10.176.48.67
    IP: 10.176.48.67
    Local Storage Pool: 1 pool
    POOL    IO_PRIORITY    RAID_LEVEL    USABLE    USED    STATUS    ZONE    REGION
      0    LOW        raid0        20 GiB    3.0 GiB    Online    dal10    us-south
    Local Storage Devices: 1 device
    Device    Path                        Media Type        Size        Last-Scan
        0:1    /dev/mapper/3600a09803830445455244c4a38754c66    STORAGE_MEDIUM_MAGNETIC    20 GiB        17 Sep 18 20:36 UTC
            total                            -            20 GiB
    Cluster Summary
    Cluster ID: mycluster
        Cluster UUID: a0d287ba-be82-4aac-b81c-7e22ac49faf5
    Scheduler: kubernetes
    Nodes: 2 node(s) with storage (2 online), 1 node(s) without storage (1 online)
      IP        ID        StorageNode    Used    Capacity    Status    StorageStatus    Version        Kernel            OS
      10.184.58.11    10.184.58.11    Yes        3.0 GiB    20 GiB        Online    Up        1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
      10.176.48.67    10.176.48.67    Yes        3.0 GiB    20 GiB        Online    Up (This node)    1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
      10.176.48.83    10.176.48.83    No        0 B    0 B        Online    No Storage    1.5.0.0-bc1c580    4.4.0-133-generic    Ubuntu 20.04.5 LTS
    Global Storage Pool
      Total Used        :  6.0 GiB
      Total Capacity    :  40 GiB
    ```
3. Überprüfen Sie, ob alle Workerknoten, die Sie in Ihre Portworx-Speicherebene einschließen wollten, eingeschlossen wurden, indem Sie die Spalte **StorageNode** im Abschnitt **Cluster Summary** der Ausgabe Ihres CLI-Befehls prüfen. Workerknoten, die sich auf der Speicherebene befinden, werden mit `Yes` in der Spalte **StorageNode** angezeigt.

    Da Portworx als DaemonSet in Ihrem Cluster ausgeführt wird, werden vorhandene Workerknoten automatisch auf unformatierten Blockspeicher überprüft und der Portworx-Datenebene hinzugefügt, wenn Sie Portworx bereitstellen. Wenn Sie Ihrem Cluster Workerknoten hinzufügen und diesen Workern unformatierten Blockspeicher hinzufügen, starten Sie die Portworx-Pods auf den neuen Workerknoten erneut, damit Ihre Speicherdatenträger vom DaemonSet erkannt werden.
    {: note}

4. Vergewissern Sie sich, dass jeder Speicherknoten mit der richtigen Menge an unaufbereitetem Blockspeicher aufgeführt wird, indem Sie die Spalte **Capacity** im Abschnitt **Cluster Summary** der Ausgabe Ihres CLI-Befehls prüfen.

5. Prüfen Sie die Portworx-E/A-Klassifikation, die den Platten zugeordnet wurde, die Teil des Portworx-Clusters sind. Während der Einrichtung Ihres Portworx-Clusters wird jede Platte untersucht, um das Leistungsprofil der Einheit zu bestimmen. Die Profilklassifikation hängt von der Geschwindigkeit des Netzes, mit dem Ihr Workerknoten verbunden ist, sowie vom Typ der verwendeten Speichereinheit ab. Platten von SDS-Workerknoten werden mit `high` (hoch) klassifiziert. Wenn Sie Platten manuell einem virtuellen Workerknoten zuordnen, werden diese Platten aufgrund der geringeren Netzgeschwindigkeit, die mit virtuellen Workerknoten einhergeht, als `low` klassifiziert.
```sh {: pre}
    kubectl exec -it <portworx_pod> -n kube-system -- /opt/pwx/bin/pxctl cluster provision-status
    ```
    Beispielausgabe

    ```sh {: screen}
    NODE        NODE STATUS    POOL    POOL STATUS    IO_PRIORITY    SIZE    AVAILABLE    USED    PROVISIONED    RESERVEFACTOR    ZONE    REGION        RACK
    10.184.58.11    Up        0    Online        LOW        20 GiB    17 GiB        3.0 GiB    0 B        0        dal12    us-south    default
    10.176.48.67    Up        0    Online        LOW        20 GiB    17 GiB        3.0 GiB    0 B        0        dal10    us-south    default
    10.176.48.83    Up        0    Online        HIGH        3.5 TiB    3.5 TiB        10 GiB    0 B        0        dal10    us-south    default
    ```

Portworx-Datenträger erstellen

Erstellen Sie „ Portworx “-Volumes mithilfe der dynamischen Bereitstellung von „ Kubernetes “.

  1. Listen Sie die in Ihrem Cluster verfügbaren Speicherklassen auf und prüfen Sie, ob Sie eine vorhandene Portworx-Speicherklasse verwenden können, die während der Portworx-Installation eingerichtet wurde. Die vordefinierten Speicherklassen sind für die Datenbanknutzung und für die gemeinsame Nutzung von Daten in den Pods optimiert.

    kubectl get sc | grep portworx

    Führen Sie kubectl describe storageclass <storageclass_name> aus, um die Details einer Speicherklasse anzuzeigen.

  2. Wenn Sie keine vorhandene Speicherklasse verwenden möchten, erstellen Sie eine angepasste Speicherklasse. Eine vollständige Liste der unterstützten Optionen, die Sie in Ihrer Speicherklasse festlegen können, finden Sie unter „ Dynamische Bereitstellung verwenden “.

    1. Erstellen Sie eine Konfigurationsdatei für Ihre Speicherklasse.
        kind: StorageClass
    apiVersion: storage.k8s.io/v1
    metadata:
      name: <storageclass_name>
    provisioner: kubernetes.io/portworx-volume
    parameters:
      repl: "<replication_factor>"
      secure: "<true_or_false>"
      priority_io: "<io_priority>"
      shared: "<true_or_false>"
    ```
    `metadata.name`
    :   Geben Sie einen Namen für Ihre Speicherklasse ein.

    `parameters.repl`
    :   Geben Sie die Anzahl der Replikate für Ihre Daten ein, die Sie auf verschiedenen Workerknoten speichern wollen. Zulässige Zahlen sind `1`, `2` oder `3`. Wenn Sie beispielsweise `3` eingeben, werden Ihre Daten auf drei verschiedenen Workerknoten in Ihrem Portworx-Cluster repliziert. Zur hoch verfügbaren Speicherung Ihrer Daten verwenden Sie einen Mehrzonencluster und replizieren Ihre Daten auf drei Workerknoten in verschiedenen Zonen.
                    Sie müssen über genügend Workerknoten verfügen, um Ihre Replikationsanforderung zu erfüllen. Wenn Sie zum Beispiel zwei Workerknoten haben, jedoch drei Replikate angeben, schlägt die Erstellung des PVC mit dieser Speicherklasse fehl.
        {: note}

    `parameters.secure`
    :   Geben Sie an, ob die Daten auf Ihrem Datenträger mit IBM Key Protect verschlüsselt werden sollen. Wählen Sie eine der folgenden Optionen aus.
        - `true`: Geben Sie `true` ein, um die Verschlüsselung für Ihre Portworx-Datenträger zu aktivieren. Zur Verschlüsselung von Datenträgern müssen Sie eine IBM Key Protect-Serviceinstanz und einen geheimen Schlüssel für Kubernetes haben, in dem Ihr Kundenrootschlüssel (CRK) gespeichert ist. Weitere Informationen zur Einrichtung der Verschlüsselung für Portworx-Datenträger finden Sie unter [Portworx-Datenträger verschlüsseln](/docs/containers?topic=containers-storage_portworx_encryption).
        - `false`: Wenn Sie `false` eingeben, werden Ihre Portworx-Datenträger nicht verschlüsselt. Wenn Sie diese Option nicht angeben, werden Ihre Portworx-Datenträger standardmäßig nicht verschlüsselt. Sie können die Datenträgerverschlüsselung in Ihrer PVC aktivieren, auch wenn Sie die Verschlüsselung in Ihrer Speicherklasse deaktiviert haben. Die Einstellung, die Sie im PVC angeben, hat Vorrang vor den Einstellungen in der Speicherklasse.

    `parameters.priority_io`
    :   Geben Sie die Portworx-E/A-Priorität ein, die Sie für Ihre Daten anfordern wollen. Verfügbare Optionen: `high`, `medium` und `low`. Während der Einrichtung Ihres Portworx-Clusters wird jede Platte untersucht, um das Leistungsprofil der Einheit zu bestimmen. Die Profilklassifikation hängt von der Netzbandbreite Ihres Workerknotens und dem Typ der Speichereinheit ab. Platten von SDS-Workerknoten werden mit `high` (hoch) klassifiziert. Wenn Sie Platten manuell einem virtuellen Workerknoten zuordnen, werden diese Platten aufgrund der geringeren Netzgeschwindigkeit, die mit virtuellen Workerknoten einhergeht, als `low` klassifiziert.
        :    Wenn Sie einen PVC mit einer Speicherklasse erstellen, überschreibt die Anzahl der Replikate, die Sie in `parameters/repl` angeben, die E/A-Priorität. Wenn Sie zum Beispiel drei Replikate angeben, die Sie auf Hochgeschwindigkeitsplatten speichern möchten, jedoch nur einen Workerknoten mit einer Hochgeschwindigkeitsplatte in Ihrem Cluster haben, wird der PVC trotzdem erfolgreich erstellt. Ihre Daten werden sowohl auf Hochgeschwindigkeitsplatten als auch auf Niedergeschwindigkeitsplatten repliziert.

    `parameters.shared`
    :   Definieren Sie, ob Sie zulassen wollen, dass mehrere Pods auf denselben Datenträger zugreifen. Wählen Sie eine der beiden folgenden Optionen aus:
        - True: Wenn Sie diese Option auf `true` setzen, können Sie mit mehreren Pods, die auf Workerknoten in verschiedenen Zonen verteilt sind, auf denselben Datenträger zugreifen.
        - Falsch: Wenn Sie diese Option auf `false` setzen, können Sie nur dann von mehreren Pods aus auf den Datenträger zugreifen, wenn die Pods auf dem Workerknoten bereitgestellt werden, der die physische Platte, auf der der Datenträger gesichert ist, anhängt. Wenn Ihr Pod auf einem anderen Workerknoten bereitgestellt wird, kann er nicht auf den Datenträger zugreifen.

2. Erstellen Sie die Speicherklasse.
```sh {: pre}
    kubectl apply -f storageclass.yaml
    ```
3. Überprüfen Sie, ob die Speicherklasse erstellt wurde.
```sh {: pre}
    kubectl get sc
    ```

  3. Erstellen Sie einen Persistent Volume Claim (PVC).

    1. Erstellen Sie eine Konfigurationsdatei für Ihren PVC.
        kind: PersistentVolumeClaim
    apiVersion: v1
    metadata:
      name: mypvc
    spec:
      accessModes:
        - <access_mode>
      resources:
        requests:
          storage: <size>
      storageClassName: portworx-shared-sc
    ```
    `metadata.name`
    :   Geben Sie einen Namen für Ihren PVC ein, wie z. B. `mypvc`.

    `spec.accessModes`
    :   Geben Sie den „ [Kubernetes Zugriffsmodus](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes){: external} “ ein, den Sie verwenden möchten.

    `resources.requests.storage`
    :   Geben Sie die Speicherkapazität in Gigabyte an, die Sie aus Ihrem Portworx-Cluster zuordnen wollen. Beispiel: Zur Zuordnung von 2 Gigabyte aus Ihrem Portworx-Cluster geben Sie `2Gi` ein. Die Speicherkapazität, die Sie angeben, wird durch die Speicherkapazität begrenzt, die in Ihrem Portworx-Cluster verfügbar ist. Wenn Sie einen Replikationsfaktor in Ihrer Speicherklasse größer als 1 angegeben haben, wird die Speicherkapazität, die Sie in Ihrem PVC angeben, auf mehreren Workerknoten reserviert.

    `spec.storageClassName`
    :   Geben Sie den Namen der Speicherklasse ein, die Sie zuvor ausgewählt oder erstellt haben und die zur Bereitstellung Ihres persistenten Datenträgers (PV) verwendet werden soll. In der YAML-Beispieldatei wird die Speicherklasse `portworx-shared-sc` verwendet.

2. Erstellen Sie Ihre PVC.
```sh {: pre}
    kubectl apply -f pvc.yaml
    ```
3. Überprüfen Sie, ob Ihr PVC erstellt und an einen persistenten Datenträger gebunden wurde. Dieser Prozess kann einige Minuten dauern.
```sh {: pre}
    kubectl get pvc
    ```

Datenträger an Ihre App anhängen

Damit Ihre App auf den Speicher zugreifen kann, müssen Sie den PVC an Ihre App anhängen.

  1. Erstellen Sie eine Konfigurationsdatei für eine Bereitstellung, die den PVC anhängt.

    Tipps zum Bereitstellen einer statusabhängigen Gruppe mit Portworx finden Sie unter StatefulSets. Die Dokumentation zu „ Portworx “ enthält auch Beispiele für die Bereitstellung von „ Cassandra “, Kafka „ ElasticSearch “ mit Kibana und „ WordPress “ mit „ MySQL “.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: <deployment_name>
  labels:
    app: <deployment_label>
spec:
  selector:
    matchLabels:
      app: <app_name>
  template:
    metadata:
      labels:
        app: <app_name>
    spec:
      schedulerName: stork
      containers:
      - image: <image_name>
        name: <container_name>
      securityContext:
          fsGroup: <group_ID>
        volumeMounts:
        - name: <volume_name>
          mountPath: /<file_path>
      volumes:
      - name: <volume_name>
        persistentVolumeClaim:
          claimName: <pvc_name>
    metadata.labels.app
    Eine Bezeichnung für die Bereitstellung.
    spec.selector.matchLabels.app und spec.template.metadata.labels.app
    Eine Bezeichnung für Ihre App.
    template.metadata.labels.app
    Eine Bezeichnung für die Bereitstellung.
    spec.schedulerName
    Verwenden Sie Stork als Scheduler für Ihren „ Portworx “-Cluster. Mit Stork können Sie Pods zusammen mit ihren Daten unterbringen, Pods im Falle von Speicherfehlern nahtlos migrieren und Snapshots von „ Portworx “-Volumes einfacher erstellen und wiederherstellen.
    spec.containers.image
    Der Name des Images, das Sie verwenden möchten. Führen Sie ibmcloud cr image-list aus, um die verfügbaren Images in Ihrem IBM Cloud Container Registry-Konto aufzulisten.
    spec.containers.name
    Der Name des Containers, den Sie in Ihrem Cluster bereitstellen möchten.
    spec.containers.securityContext.fsGroup
    Optional: Um mit einem Nicht-Root-Benutzer auf Ihren Speicher zuzugreifen, geben Sie den Sicherheitskontext für Ihren Pod an und definieren Sie die Gruppe der Benutzer, denen Sie Zugriff gewähren möchten, im Abschnitt „ fsGroup “ Ihrer Deployment-YAML-Datei. Weitere Informationen finden Sie unter „ Zugriff auf „ Portworx “-Volumes mit einem Nicht-Root-Benutzer “.
    spec.containers.volumeMounts.mountPath
    Der absolute Pfad des Verzeichnisses, in dem der Datenträger innerhalb des Containers angehängt wird. Wenn Sie ein Volume für mehrere Apps gemeinsam nutzen möchten, können Sie für jede Ihrer Apps Teilpfade des Volumes festlegen.
    spec.containers.volumeMounts.name
    Der Name des Datenträgers, der an Ihren Pod angehängt werden soll.
    volumes.name
    Der Name des Datenträgers, der an Ihren Pod angehängt werden soll. Dieser Name ist in der Regel mit volumeMounts/name identisch.
    volumes.persistentVolumeClaim.claimName
    Der Name des PVC, der den zu verwendenden persistenten Datenträger bindet.

  2. Erstellen Sie Ihre Bereitstellung.

    kubectl apply -f deployment.yaml

  3. Überprüfen Sie, dass der persistente Datenträger (PV) erfolgreich an Ihre App angehängt wurde.

    kubectl describe deployment <deployment_name>

    Der Mountpunkt ist im Feld Datenträgermounts angegeben und der Datenträger im Feld Datenträger .

    Volume Mounts:
        /var/run/secrets/kubernetes.io/serviceaccount from default-token-tqp61 (ro)
        /volumemount from myvol (rw)
...
Volumes:
    myvol:
    Type:    PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:    mypvc
    ReadOnly:    false

  4. Überprüfen Sie, ob Sie Daten in Ihren Portworx-Cluster schreiben können.

    1. Melden Sie sich bei dem Pod an, der Ihren PV anhängt.
        kubectl exec <pod_name> -it bash
    ```
2. Navigieren Sie zu Ihrem Datenträgermountpfad, den Sie in Ihrer App-Bereitstellung definiert haben.
3. Erstellen Sie eine Textdatei.
```sh {: pre}
    echo "This is a test" > test.txt
    ```
4. Lesen Sie die Datei, die Sie erstellt haben.
```sh {: pre}
    cat test.txt
    ```