Fehler bei persistentem Speicher debuggen

Informieren Sie sich über die Optionen, die Ihnen für die Fehlerbehebung beim persistenten Speicher und zum Eingrenzen der jeweiligen Fehlerquelle zur Verfügung stehen.

Es wird überprüft, ob der Pod, der Ihre Speicherinstanz anhängt, erfolgreich implementiert wurde

Listen Sie die Pods in Ihrem Cluster auf. Ein Pod wurde erfolgreich bereitgestellt, wenn er den Status Running (Aktiv) anzeigt.
```
oc get pods
```
Rufen Sie die Details für Ihren Pod ab und prüfen Sie, ob im Ereignisabschnitt (Events) Ihrer CLI-Ausgabe Fehler angezeigt werden.
```
oc describe pod <pod_name>
```
Rufen Sie die Protokolle für Ihre App ab und prüfen Sie, ob Sie Fehlernachrichten finden.
```
oc logs <pod_name>
```

Ihre App-Pod erneut starten

Wenn Ihr Pod Teil einer Bereitstellung ist, löschen Sie den Pod und lassen Sie die Bereitstellung den Pod erneut erstellen. Wenn Ihr Pod nicht Teil einer Bereitstellung ist, löschen Sie den Pod und wenden Sie Ihre Konfigurationsdatei für Pods erneut an.
```
oc delete pod <pod_name>
```
```
oc apply -f <app.yaml>
```
Wenn der Neustart Ihres Pods das Problem nicht behebt, laden Sie Ihren Workerknoten erneut.
Überprüfen Sie, ob Sie die neueste Version des IBM Cloud- und IBM Cloud Kubernetes Service-Plug-ins verwenden.
```
ibmcloud update
```
```
ibmcloud plugin repo-plugins
```

Überprüfen Sie, ob der Speichertreiber und die Plug-in-Pods den betriebsbereiten Status Running anzeigen

Listen Sie die Pods im Projekt kube-system auf.
```
oc get pods -n kube-system
```

Wenn die Speichertreiber- und Plug-in-Pods keinen Aktiv-Status aufweisen, rufen Sie weitere Details des Pods ab, um die Fehlerursache zu finden. Abhängig vom Status Ihres Pods können Sie möglicherweise nicht alle folgenden Befehle ausführen.

Rufen Sie die Namen der Container ab, die im Treiberpod ausgeführt werden.

    kubectl get pod <pod_name> -n kube-system -o jsonpath="{.spec['containers','initContainers'][*].name}" | tr -s '[[:space:]]' '\n'
    ```
    Beispielausgabe für Block Storage for VPC mit drei Containern:
    ```sh {: screen}
    csi-provisioner
    csi-attacher
    iks-vpc-block-driver
    ```
    Beispielausgabe für Block Storage for Classic:
    ```sh {: pre}
    ibmcloud-block-storage-driver-container
    ```
2. Exportieren Sie die Protokolle aus dem Pod für Treiber in eine Datei `logs.txt` auf Ihrer lokalen Maschine. Geben Sie den Treibercontainernamen an.
```sh {: pre}
    oc logs <pod_name> -n kube-system -c <container_name> > logs.txt
    ```
3. Überprüfen Sie die Protokolldatei.
```sh {: pre}
    cat logs.txt
    ```

Analysieren Sie den Ereignisabschnitt (Events) der CLI-Ausgabe des Befehls oc describe pod und die aktuellen Protokolle, um die eigentliche Fehlerursache herauszufinden.

Es wird überprüft, ob Ihr PVC erfolgreich bereitgestellt wurde.

Überprüfen Sie den Status Ihres PVC. Ein PVC wurde erfolgreich bereitgestellt, wenn er den Status Bound (Gebunden) anzeigt.
```
oc get pvc
```
Wenn als Status des PVC Pending (Anstehend) angezeigt wird, rufen Sie den Fehler ab, aufgrund dessen der PVC in diesem Status bleibt.
```
oc describe pvc <pvc_name>
```
Überprüfen Sie allgemeine Fehler, die während der PVC-Erstellung auftreten können.
- Dateispeicher und klassischer Blockspeicher: PVC bleibt im Wartestatus (Pending).
- Objektspeicher: PVC bleibt im Wartestatus (Pending)
Überprüfen Sie allgemeine Fehler, die auftreten können, wenn Sie einen PVC an Ihre App anhängen.

Stellen Sie sicher, dass die Version der kubectl-CLI, die Sie auf Ihrer lokalen Maschine ausführen, mit der Kubernetes-Version übereinstimmt, die in Ihrem Cluster installiert ist. Wenn Sie eine kubectl-CLI-Version verwenden, die nicht wenigstens mit der Version hauptversion.nebenversion Ihres Clusters übereinstimmt, können unerwartete Ergebnisse auftreten. Beispiel: [ Kubernetes unterstützt keine kubectl Client-Versionen, die zwei oder mehr Versionen von der Server-Version abweichen (n +/- 2).

Zeigen Sie die Version der kubectl-CLI an, die in Ihrem Cluster und auf Ihrer lokalen Maschine installiert ist.

    oc version
    ```
    Beispielausgabe
    ```sh {: screen}
    Client Version: version.Info{Major:"1", Minor:"23", GitVersion:"v1.36", GitCommit:"641856db18352033a0d96dbc99153fa3b27298e5", GitTreeState:"clean", BuildDate:"2019-03-25T15:53:57Z", GoVersion:"go1.12.1", Compiler:"gc", Platform:"darwin/amd64"}
    Server Version: version.Info{Major:"1", Minor:"23", GitVersion:"v1.36+IKS", GitCommit:"e15454c2216a73b59e9a059fd2def4e6712a7cf0", GitTreeState:"clean", BuildDate:"2019-04-01T10:08:07Z", GoVersion:"go1.11.5", Compiler:"gc", Platform:"linux/amd64"}
    ```
    Die CLI-Versionen stimmen überein, wenn in `GitVersion` für den Client und den Server dieselbe Version angezeigt wird. Sie können den `+IKS`-Teil der Version für den Server ignorieren.
2. Wenn die `kubectl`-CLI-Versionen auf Ihrer lokalen Maschine und in Ihrem Cluster nicht übereinstimmen, entweder [aktualisieren Sie Ihren Cluster](/docs/openshift?topic=openshift-update) oder [installieren Sie eine andere CLI-Version auf Ihrer lokalen Maschine](/docs/openshift?topic=openshift-cli-install).

Überprüfen Sie, ob Sie für Block Storage for VPC über die neueste Version des Add-ons verfügen.
Nur für klassischen Blockspeicher, Objektspeicher und Portworx: Stellen Sie sicher, dass Sie die neueste Helm-Chart-Version für das Plug-in installiert haben.

Block- und Objektspeicher:

1. Aktualisieren Sie Ihre Helm-Chart-Repositorys.
```sh {: pre}
    helm repo update
    ```
2. Listen Sie die Helm-Charts im Repository auf.
**Für klassischen Blockspeicher**:
```sh {: pre}
    helm search repo iks-charts | grep block-storage-plugin
    ```
    Beispielausgabe
    ```sh {: screen}
    iks-charts-stage/ibmcloud-block-storage-plugin    1.5.0                                                        A Helm chart for installing ibmcloud block storage plugin   
    iks-charts/ibmcloud-block-storage-plugin          1.5.0                                                        A Helm chart for installing ibmcloud block storage plugin   
    ```
    **Für Objektspeicher**:
    ```sh {: pre}
    helm search repo ibm-charts | grep object-storage-plugin
    ```
    Beispielausgabe
    ```sh {: screen}
    ibm-charts/ibm-object-storage-plugin             1.0.9            1.0.9                             A Helm chart for installing ibmcloud object storage plugin  
    ```
3. Listen Sie die installierten Helm-Charts in Ihrem Cluster auf und vergleichen Sie die Version, die Sie installiert haben, mit der Version, die verfügbar ist.
```sh {: pre}
    helm list --all-namespaces
    ```
4. Wenn eine neuere Version verfügbar ist, installieren Sie diese Version. Anweisungen finden Sie unter [Aktualisieren des IBM Cloud-Blockspeicher-Plug-ins](/docs/openshift?topic=openshift-vpc-block#vpc-addon-update) und [Aktualisieren des IBM Cloud Object Storage-Plug-ins](/docs/openshift?topic=openshift-storage_cos_install#update_cos_plugin).

Portworx

Finden Sie die aktuellste verfügbare Version der Helm-Tabelle.
Listen Sie die installierten Helm-Charts in Ihrem Cluster auf und vergleichen Sie die Version, die Sie installiert haben, mit der Version, die verfügbar ist.
```
helm list --all-namespaces
```
Wenn eine neuere Version verfügbar ist, installieren Sie diese Version. Anweisungen finden Sie unter Portworx in Ihrem Cluster aktualisieren.

OpenShift Datenbasis

Beschreiben Sie Ihre ODF-Ressourcen und überprüfen Sie die Befehlsausgaben für alle Fehlernachrichten.

Listen Sie den Namen Ihres ODF-Clusters auf.

oc get ocscluster

Beispielausgabe:

NAME             AGE
ocscluster-vpc   71d

Beschreiben Sie den Speichercluster und überprüfen Sie den Abschnitt Events der Ausgabe für alle Fehlernachrichten.
```
oc describe ocscluster <ocscluster-name>
```
Listen Sie die Pods im Namensbereich kube-system auf und vergewissern Sie sich, dass sie im betriebsbereiten Status Running sind.
```
oc get pods -n kube-system
```
Beschreiben Sie den Pod ibm-ocs-operator-controller-manager und überprüfen Sie den Abschnitt Events in der Ausgabe für alle Fehlernachrichten.
```
oc describe pod <ibm-ocs-operator-controller-manager-a1a1a1a> -n kube-system
```
Überprüfen Sie die Protokolle des ibm-ocs-operator-controller-manager.
```
oc logs <ibm-ocs-operator-controller-manager-a1a1a1a> -n kube-system
```
Beschreiben Sie NooBaa und überprüfen Sie den Abschnitt Events der Ausgabe auf eventuelle Fehlermeldungen.
```
oc describe noobaa -n openshift-storage
```