Daten während der dynamischen Bereitstellung mit dem GKE Volume Populator aus Cloud Storage übertragen

Mit GKE Volume Populator können Sie Daten aus einem Quellspeicher in einen Ziel-PersistentVolumeClaim vorab laden, wenn dynamische Bereitstellung erfolgt. Dazu sind keine zusätzlichen Skripts oder CLI-Befehle für die manuelle Datenübertragung erforderlich. Diese Funktion automatisiert und optimiert den Datenübertragungsprozess mithilfe der Funktion Kubernetes Volume Populator. Sie bietet nahtlose Datenportabilität, sodass Sie Speichertypen tauschen können, um von Preis- oder Leistungsoptimierungen zu profitieren.

Verwenden Sie diese Funktion, wenn Sie große Datenmengen aus Cloud Storage-Buckets in einen PersistentVolumeClaim übertragen müssen, der von einem anderenGoogle Cloud -Speichertyp (z. B. Parallelstore) unterstützt wird.

Sie interagieren hauptsächlich über die gcloud CLI und die kubectl CLI mit GKE Volume Populator. GKE Volume Populator wird sowohl in Autopilot- als auch in Standard-Clustern unterstützt. Sie müssen den GKE Volume Populator nicht aktivieren. Es handelt sich um eine von GKE verwaltete Komponente, die standardmäßig aktiviert ist.

Vorteile

• Wenn Sie die Leistung eines verwalteten parallelen Dateisystems nutzen möchten, Ihre Daten aber in Cloud Storage gespeichert sind, können Sie den GKE Volume Populator verwenden, um die Datenübertragung zu vereinfachen.
• GKE Volume Populator ermöglicht die Datenportabilität. Sie können Daten nach Bedarf verschieben.
• GKE Volume Populator unterstützt die IAM-basierte Authentifizierung, sodass Sie Daten übertragen können und gleichzeitig eine differenzierte Zugriffssteuerung beibehalten.

Das Diagramm zeigt, wie Daten vom Quellspeicher zum Zielspeicher fließen und wie das PersistentVolume für den Zielspeicher mit GKE Volume Populator erstellt wird.

Beschränkungen

• GKE Volume Populator unterstützt nur Cloud Storage-Buckets als Quellspeicher und Parallelstore-Instanzen als Zielspeichertyp.
• Die benutzerdefinierte GCPDataSource-Ressource muss sich im selben Namespace wie Ihre Kubernetes-Arbeitslast befinden. Volumes mit Datenquellen, die mehrere Namespaces umfassen, werden nicht unterstützt.
• GKE Volume Populator unterstützt nur die Workload Identity-Föderation für GKE zum Binden von IAM-Dienstkonten an ein Kubernetes-Dienstkonto. Das direkte Erteilen von IAM-Berechtigungen für das Kubernetes-Dienstkonto wird nicht unterstützt.

Hinweise

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

• Aktivieren Sie die Parallelstore API und die Google Kubernetes Engine API.
APIs 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.

• Informationen zu Einschränkungen und Anforderungen finden Sie in der Übersicht zum Parallelstore-CSI-Treiber.
• Erstellen Sie Ihre Cloud Storage-Buckets, die mit den Daten gefüllt sind, die Sie übertragen möchten.

Voraussetzungen

Für die Verwendung von GKE Volume Populator müssen Ihre Cluster die folgenden Anforderungen erfüllen:

• Verwenden Sie die GKE-Clusterversion 1.31.1-gke.1729000 oder höher.
• Der Parallelstore-CSI-Treiber muss aktiviert sein. In GKE wird der CSI-Treiber standardmäßig für neue und vorhandene GKE Autopilot-Cluster aktiviert. In neuen und vorhandenen Standardclustern müssen Sie den CSI-Treiber aktivieren.

Umgebung vorbereiten

In diesem Abschnitt wird beschrieben, wie Sie Ihre GKE-Cluster erstellen und die erforderlichen Berechtigungen für die Verwendung von GKE Volume Populator einrichten.

VPC-Netzwerk einrichten

Sie müssen beim Erstellen der Parallelstore-Instanz und der Compute Engine-VMs oder GKE-Cluster für den Client dasselbe VPC-Netzwerk (Virtual Private Cloud) angeben. Damit VPC eine private Verbindung zu Google Cloud-Diensten herstellen kann, ohne dass der Traffic dem öffentlichen Internet ausgesetzt wird, müssen Sie einmalig den Zugriff auf private Dienste (Private Services Access, PSA) konfigurieren, sofern Sie dies noch nicht getan haben.

So konfigurieren Sie PSA:

1. Um Netzwerk-Peering für Ihr Projekt einzurichten, konfigurieren Sie die IAM-Berechtigung Compute-Netzwerkadministrator (roles/compute.networkAdmin).

   Führen Sie zum Zuweisen der Rolle den folgenden Befehl aus:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member="user:EMAIL_ADDRESS" \
       --role=roles/compute.networkAdmin
   

   Ersetzen Sie EMAIL_ADDRESS durch Ihre E-Mail-Adresse.

2. Service Networking aktivieren:

   gcloud services enable servicenetworking.googleapis.com
   

3. Erstellen Sie ein VPC-Netzwerk:

   gcloud compute networks create NETWORK_NAME \
     --subnet-mode=auto \
     --mtu=8896 \
     --project=PROJECT_ID
   

   Ersetzen Sie Folgendes:

   • NETWORK_NAME: der Name des VPC-Netzwerks, in dem Sie Ihre Parallelstore-Instanz erstellen.
   • PROJECT_ID: Ihre Google Cloud Projekt-ID.

4. Erstellen Sie einen IP-Bereich.

   Für den Zugriff auf private Dienste ist ein IP-Adressbereich (CIDR-Block) mit einer Präfixlänge von mindestens /24 (256 Adressen) erforderlich. Parallelstore reserviert 64 Adressen pro Instanz. Sie können diesen IP-Bereich also bei Bedarf mit anderen Diensten oder anderen Parallelstore-Instanzen wiederverwenden.

   gcloud compute addresses create IP_RANGE_NAME \
     --global \
     --purpose=VPC_PEERING \
     --prefix-length=24 \
     --description="Parallelstore VPC Peering" \
     --network=NETWORK_NAME \
     --project=PROJECT_ID
   

   Ersetzen Sie IP_RANGE_NAME durch den Namen des VPC-Netzwerk-IP-Bereichs.

5. Legen Sie eine Umgebungsvariable mit dem CIDR-Bereich fest, der dem Bereich zugeordnet ist, den Sie im vorherigen Schritt erstellt haben:

   CIDR_RANGE=$(
     gcloud compute addresses describe IP_RANGE_NAME \
       --global  \
       --format="value[separator=/](address, prefixLength)" \
       --project=PROJECT_ID \
   )
   

6. Erstellen Sie eine Firewallregel, um TCP-Traffic aus dem von Ihnen erstellten IP-Bereich zuzulassen:

   gcloud compute firewall-rules create FIREWALL_NAME \
     --allow=tcp \
     --network=NETWORK_NAME \
     --source-ranges=$CIDR_RANGE \
     --project=PROJECT_ID
   

   Ersetzen Sie FIREWALL_NAME durch den Namen der Firewallregel, mit der Sie TCP-Traffic aus dem von Ihnen erstellten IP-Bereich zulassen.

7. Stellen Sie die Peering-Verbindung her:

   gcloud services vpc-peerings connect \
     --network=NETWORK_NAME \
     --ranges=IP_RANGE_NAME \
     --project=PROJECT_ID \
     --service=servicenetworking.googleapis.com
   

Wenn beim Einrichten des VPC-Netzwerk Probleme auftreten, lesen Sie den Leitfaden zur Fehlerbehebung für Parallelstore.

GKE-Cluster erstellen

Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslastanforderungen am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

gcloud container clusters create-auto CLUSTER_NAME  \
    --network=NETWORK_NAME  \
    --cluster-version=CLUSTER_VERSION \
    --location=CLUSTER_LOCATION

gcloud container clusters create CLUSTER_NAME \
    --addons=ParallelstoreCsiDriver \
    --cluster-version=CLUSTER_VERSION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --network=NETWORK_NAME \
    --location=CLUSTER_LOCATION

Erforderliche Berechtigungen einrichten

Wenn Sie Daten aus einem Cloud Storage-Bucket übertragen möchten, müssen Sie Berechtigungen für die Workload Identity-Föderation für GKE einrichten.

1. Erstellen Sie einen Kubernetes-Namespace:

   kubectl create namespace NAMESPACE
   

   Ersetzen Sie NAMESPACE durch den Namespace, in dem Ihre Arbeitslasten ausgeführt werden.

2. Erstellen Sie ein Kubernetes-Dienstkonto.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Ersetzen Sie KSA_NAME durch den Namen des Kubernetes-Dienstkontos, das Ihr Pod zur Authentifizierung bei Google Cloud -APIs verwendet.

3. IAM-Dienstkonto erstellen. Sie können auch jedes vorhandene IAM-Dienstkonto in jedem Projekt in Ihrer Organisation verwenden:

   gcloud iam service-accounts create IAM_SA_NAME \
       --project=PROJECT_ID
   

   Ersetzen Sie Folgendes:

   • IAM_SA_NAME: Der Name Ihres IAM-Dienstkontos.
   • PROJECT_ID: Ihre Google Cloud Projekt-ID.

4. Weisen Sie Ihrem IAM-Dienstkonto die Rolle roles/storage.objectViewer zu, damit es auf Ihren Cloud Storage-Bucket zugreifen kann:

   gcloud storage buckets \
       add-iam-policy-binding gs://GCS_BUCKET \
       --member "serviceAccount:IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --role "roles/storage.objectViewer"
   

   Ersetzen Sie GCS_BUCKET durch den Namen Ihres Cloud Storage-Bucket.

5. Erstellen Sie die IAM-Zulassungsrichtlinie, die dem Kubernetes-Dienstkonto Zugriff gewährt, um die Identität des IAM-Dienstkontos zu übernehmen:

   gcloud iam service-accounts \
       add-iam-policy-binding IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
   

6. Annotieren Sie das Kubernetes-Dienstkonto, damit GKE die Verknüpfung zwischen den Dienstkonten sieht.

   kubectl annotate serviceaccount KSA_NAME \
       --namespace NAMESPACE \
       iam.gke.io/gcp-service-account=IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com
   

7. Erstellen Sie die Parallelstore-Dienstidentität:

   gcloud beta services identity create \
       --service=parallelstore.googleapis.com \
       --project=PROJECT_ID
   

8. Damit die Parallelstore-Dienstidentität die Identität des IAM-Dienstkontos übernehmen kann, weisen Sie der Parallelstore-Dienstidentität die Rolle roles/iam.serviceAccountTokenCreator zu. Legen Sie die Umgebungsvariable PROJECT_NUMBER fest, damit Sie sie in den folgenden Schritten verwenden können.

   export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountTokenCreator
   

   Der Wert PROJECT_NUMBER ist die automatisch generierte eindeutige Kennung für Ihr Projekt. Informationen zum Ermitteln dieses Werts finden Sie unter Projekte erstellen und verwalten.

9. Damit die Parallelstore-Dienstidentität auf alle Ressourcen zugreifen kann, auf die das IAM-Dienstkonto zugreifen kann, weisen Sie der Parallelstore-Dienstidentität die Rolle roles/iam.serviceAccountUser zu:

   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountUser
   

10. Damit die GKE-Dienstidentität auf alle Ressourcen zugreifen kann, auf die das IAM-Dienstkonto zugreifen kann, weisen Sie der GKE-Dienstidentität die Rolle roles/iam.serviceAccountUser zu. Dieser Schritt ist nicht erforderlich, wenn sich der GKE-Cluster und das IAM-Dienstkonto im selben Projekt befinden.

    gcloud iam service-accounts \
        add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
        --member=serviceAccount:"service-${PROJECT_NUMBER?}@container-engine-robot.iam.gserviceaccount.com" \
        --role=roles/iam.serviceAccountUser
    

Parallelstore-Volume mit vorab geladenen Daten erstellen

In den folgenden Abschnitten wird das typische Verfahren zum Erstellen eines Parallelstore-Volumes mit Daten beschrieben, die mit dem GKE-Volume-Populator aus einem Cloud Storage-Bucket vorab geladen wurden.

1. GCPDataSource-Ressource erstellen
2. Parallelstore-StorageClass erstellen
3. Einen PersistentVolumeClaim für den Zugriff auf das Volume erstellen.
4. (Optional) Fortschritt der Datenübertragung ansehen
5. Erstellen Sie eine Arbeitslast, die das Volume verbraucht.

Ressource GCPDataSource erstellen

Wenn Sie GKE Volume Populator verwenden möchten, erstellen Sie eine benutzerdefinierte GCPDataSource-Ressource. Diese Ressource definiert die Quellspeichereigenschaften, die für die Volume-Erstellung verwendet werden sollen.

1. Speichern Sie folgendes Manifest in einer Datei mit dem Namen gcpdatasource.yaml.

   apiVersion: datalayer.gke.io/v1
   kind: GCPDataSource
   metadata:
     name: GCP_DATA_SOURCE
     namespace: NAMESPACE
   spec:
     cloudStorage:
       serviceAccountName: KSA_NAME
       uri: gs://GCS_BUCKET/
   

   Ersetzen Sie die folgenden Werte:

   • GCP_DATA_SOURCE: Der Name des GCPDataSourceCRD, das einen Verweis auf Ihren Cloud Storage-Bucket enthält. Weitere Informationen finden Sie in der GCPDataSource-CRD-Referenz.
   • NAMESPACE: der Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespace-Wert sollte mit dem Namespace Ihrer Arbeitslast übereinstimmen.
   • KSA_NAME: der Name des Kubernetes-Dienstkontos, das Ihr Pod zur Authentifizierung bei Google Cloud -APIs verwendet. Der Wert cloudStorage.serviceAccountName sollte das Kubernetes-Dienstkonto sein, das Sie im Schritt Erforderliche Berechtigungen einrichten für die Workload Identity-Föderation für GKE eingerichtet haben.
   • GCS_BUCKET: Name Ihres Cloud Storage-Buckets. Alternativ können Sie auch gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ für das Feld uri angeben.

2. Erstellen Sie die GCPDataSource-Ressource mit dem folgenden Befehl:

   kubectl apply -f gcpdatasource.yaml
   

Parallelstore-StorageClass erstellen

Erstellen Sie eine StorageClass, um den Parallelstore-CSI-Treiber anzuweisen, Parallelstore-Instanzen in derselben Region wie Ihr GKE-Cluster bereitzustellen. So wird eine optimale E/A-Leistung gewährleistet.

1. Speichern Sie das folgende Manifest als parallelstore-class.yaml.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: parallelstore-class
   provisioner: parallelstore.csi.storage.gke.io
   volumeBindingMode: Immediate
   reclaimPolicy: Delete
   

2. Erstellen Sie die StorageClass mit dem folgenden Befehl:

   kubectl apply -f parallelstore-class.yaml
   

Wenn Sie eine benutzerdefinierte StorageClass mit einer bestimmten Topologie erstellen möchten, lesen Sie den Parallelstore CSI-Leitfaden.

PersistentVolumeClaim für den Zugriff auf das Volume erstellen

In der folgenden Manifestdatei wird ein Beispiel für das Erstellen eines PersistentVolumeClaim im ReadWriteMany-Zugriffsmodus gezeigt, der auf die zuvor erstellte StorageClass verweist.

1. Speichern Sie folgendes Manifest in einer Datei mit dem Namen volume-populator-pvc.yaml:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: PVC_NAME
     namespace: NAMESPACE
   spec:
     accessModes:
     -   ReadWriteMany
     storageClassName: parallelstore-class
     resources:
       requests:
         storage: 12Gi
     dataSourceRef:
       apiGroup: datalayer.gke.io
       kind: GCPDataSource
       name: GCP_DATA_SOURCE
   

   Ersetzen Sie die folgenden Werte:

   • PVC_NAME: Der Name des PersistentVolumeClaim, in den Sie Ihre Daten übertragen möchten. Der PersistentVolumeClaim muss von einer Parallelstore-Instanz unterstützt werden.
   • NAMESPACE: Der Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespace-Wert sollte mit dem Namespace Ihrer Arbeitslast übereinstimmen.
   • GCP_DATA_SOURCE: Der Name des GCPDataSourceCRD, das einen Verweis auf Ihren Cloud Storage-Bucket enthält. Weitere Informationen finden Sie in der CRD-Referenz zu GCPDataSource.

2. Erstellen Sie den PersistentVolumeClaim mit dem folgenden Befehl:

   kubectl apply -f volume-populator-pvc.yaml
   

GKE plant den Arbeitslast-Pod erst, wenn die Bereitstellung des PersistentVolumeClaim abgeschlossen ist. Informationen zum Überprüfen des Fortschritts der Datenübertragung finden Sie unter Fortschritt der Datenübertragung ansehen. Wenn bei der Bereitstellung Fehler auftreten, lesen Sie den Abschnitt Fehlerbehebung.

(Optional) Fortschritt der Datenübertragung ansehen

In diesem Abschnitt wird beschrieben, wie Sie den Fortschritt Ihrer Datenübertragungen von einem Cloud Storage-Bucket zu einem Parallelstore-Volume verfolgen können. So können Sie den Status der Übertragung im Blick behalten und dafür sorgen, dass Ihre Daten erfolgreich kopiert werden. Sie sollten diesen Befehl auch ausführen, wenn der Bindungsvorgang für Ihren PersistentVolumeClaim zu lange dauert.

1. Prüfen Sie den Status Ihres PersistentVolumeClaim mit dem folgenden Befehl:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Sehen Sie sich die Ereignismeldung des PersistentVolumeClaim an, um den Fortschritt der Datenübertragung zu ermitteln. GKE protokolliert die Nachrichten etwa einmal pro Minute. Die entsprechende Ausgabe sieht etwa so aus:

   Reason                          Message
   ------                          -------
   PopulateOperationStartSuccess   Populate operation started
   PopulateOperationStartSuccess   Populate operation started
   Provisioning                    External provisioner is provisioning volume for claim "my-namespace/my-pvc"
   Provisioning                    Assuming an external populator will provision the volume
   ExternalProvisioning            Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   PopulateOperationStartSuccess   Populate operation started
   PopulatorPVCCreationProgress    objects found 7, objects copied 7, objects skipped 0. bytes found 1000020010, bytes copied 1000020010, bytes skipped 0
   PopulateOperationFinished       Populate operation finished
   PopulatorFinished               Populator finished
   

Es kann einige Zeit dauern, bis der Vorgang zum Auffüllen gestartet wird. Die Dauer hängt von der Dateigröße ab. Wenn nach einigen Minuten kein Fortschritt bei der Datenübertragung zu sehen ist, lesen Sie den Abschnitt zur Fehlerbehebung.

Arbeitslast erstellen, die das Volume verbraucht

In diesem Abschnitt wird ein Beispiel für das Erstellen eines Pods gezeigt, der die zuvor erstellte PersistentVolumeClaim-Ressource verwendet.

1. Speichern Sie das folgende YAML-Manifest für Ihren Pod als pod.yaml.

   apiVersion: v1
   kind: Pod
   metadata:
     name: POD_NAME
     namespace: NAMESPACE
   spec:
     volumes:
     -   name: parallelstore-volume
       persistentVolumeClaim:
         claimName: PVC_NAME
     containers:
     -   image: nginx
       name: nginx
       volumeMounts:
       -   name: parallelstore-volume
         mountPath: /mnt/data
   

   Ersetzen Sie die folgenden Werte:

   • POD_NAME: der Name des Pods, in dem Ihre Arbeitslast ausgeführt wird.
   • NAMESPACE: Der Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespace-Wert sollte mit dem Namespace Ihrer Arbeitslast übereinstimmen.
   • PVC_NAME: Der Name des PersistentVolumeClaim, in den Sie Ihre Daten übertragen möchten. Der PersistentVolumeClaim muss von einer Parallelstore-Instanz unterstützt werden.

2. Führen Sie den folgenden Befehl aus, um das Manifest auf den Cluster anzuwenden:

   kubectl apply -f pod.yaml
   

3. Prüfen Sie den Status Ihres Pods und warten Sie, bis er RUNNING lautet. Ihr PersistentVolumeClaim muss gebunden sein, bevor die Arbeitslast ausgeführt werden kann.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Prüfen Sie, ob die Dateien erfolgreich übertragen wurden und von Ihrer Arbeitslast aufgerufen werden können.

   kubectl exec -it POD_NAME -n NAMESPACE -c nginx -- /bin/sh
   

   Wechseln Sie in das Verzeichnis /mnt/data und führen Sie ls aus:

   cd /mnt/data
   ls
   

   In der Ausgabe sollten alle Dateien aufgeführt sein, die in Ihrem Cloud Storage-Bucket-URI vorhanden sind.

PersistentVolumeClaim während der dynamischen Bereitstellung löschen

Wenn Sie Ihren PersistentVolumeClaim löschen müssen, während Daten während der dynamischen Bereitstellung noch übertragen werden, haben Sie zwei Möglichkeiten: das ordnungsgemäße Löschen und das erzwungene Löschen.

Das sanfte Löschen erfordert weniger Aufwand, kann aber zeitaufwendiger sein und berücksichtigt keine Fehlkonfigurationen durch Nutzer, die verhindern, dass die Datenübertragung abgeschlossen wird. Das Erzwingen des Löschens bietet eine schnellere Alternative, die mehr Flexibilität und Kontrolle ermöglicht. Diese Option eignet sich, wenn Sie schnell neu starten oder Fehlkonfigurationen korrigieren müssen.

Fehlerbehebung

In diesem Abschnitt wird beschrieben, wie Sie Probleme im Zusammenhang mit dem GKE Volume Populator beheben.

Führen Sie vor dem Fortfahren den folgenden Befehl aus, um nach Ereigniswarnungen für PersistentVolumeClaim zu suchen:

kubectl describe pvc PVC_NAME -n NAMESPACE

Fehler: An internal error has occurred

Wenn der folgende Fehler auftritt, ist ein interner Fehler in der Parallelstore API aufgetreten.

Warning  PopulateOperationStartError  gkevolumepopulator-populator  Failed to start populate operation: populate data for PVC "xxx". Import data failed, error: rpc error: code = Internal desc = An internal error has occurred ("xxx")

Führen Sie die folgenden Schritte aus, um Daten für den Support zu sammeln:

1. Führen Sie die folgenden Befehle aus, um den Namen des temporären PersistentVolumeClaim abzurufen. Ersetzen Sie dabei die Platzhalter durch die tatsächlichen Namen:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-${PVC_UID?}
   
   echo ${TEMP_PVC?}
   

2. Führen Sie den folgenden Befehl aus, um den Volumennamen abzurufen:

   PV_NAME=$(kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator | grep "Volume:" | awk '{print $2}')
   

3. Wenden Sie sich mit der Fehlermeldung, Ihrem Projektnamen und dem Namen des Volumes an das Supportteam.

Probleme mit Berechtigungen

Wenn bei der Volume-Erstellung Fehler wie die folgenden auftreten, deutet dies auf ein Berechtigungsproblem in GKE hin:

• Cloud Storage-Bucket ist nicht vorhanden: PopulateOperationStartError mit code = PermissionDenied
• Fehlende Berechtigungen für den Cloud Storage-Bucket oder die Dienstkonten: PopulateOperationFailed mit "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• Dienstkonto nicht gefunden: PopulateOperationStartError mit code = Unauthenticated.

Prüfen Sie Folgendes, um diese Fehler zu beheben:

• Cloud Storage-Bucket-Zugriff: Prüfen Sie, ob der Bucket vorhanden ist und das Dienstkonto die roles/storage.objectViewer permission hat.
• Dienstkonten: Prüfen Sie, ob sowohl das Kubernetes-Dienstkonto als auch das IAM-Dienstkonto vorhanden und richtig verknüpft sind.
• Parallelstore-Dienstkonto: Achten Sie darauf, dass das Parallelstore-Dienstkonto vorhanden ist und die erforderlichen Berechtigungen (roles/iam.serviceAccountTokenCreator und roles/iam.serviceAccountUser für das IAM-Konto) hat.

Eine detaillierte Anleitung und Überprüfungsbefehle finden Sie unter Erforderliche Berechtigungen einrichten. Wenn weiterhin Fehler auftreten, wenden Sie sich mit der Fehlermeldung, dem Projektnamen und dem Namen des Cloud Storage-Bucket an den Support.

Fehler bei ungültigem Argument

Wenn Sie auf InvalidArgument-Fehler stoßen, haben Sie wahrscheinlich falsche Werte im GCPDataSource oder PersistentVolumeClaim angegeben. Im Fehlerlog werden die Felder mit den ungültigen Daten genau angegeben. Prüfen Sie, ob der Cloud Storage-Bucket-URI und andere relevante Felder korrekt sind.

Prüfen, ob die Bereitstellung des PersistentVolumeClaim abgeschlossen ist

GKE Volume Populator verwendet einen temporären PersistentVolumeClaim im Namespace gke-managed-volumepopulator für die Volume-Bereitstellung.

Der temporäre PersistentVolumeClaim ist im Grunde ein Snapshot Ihres PersistentVolumeClaim, der sich noch in der Übertragung befindet (es wird darauf gewartet, dass die Daten vollständig geladen werden). Der Name hat das Format prime-YOUR_PVC_UID.

So prüfen Sie den Status:

1. Führen Sie folgende Befehle aus:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-$PVC_UID
   
   echo $TEMP_PVC
   
   kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator
   

   Wenn die Ausgabe leer ist, wurde der temporäre PersistentVolumeClaim nicht erstellt. Führen Sie den folgenden Befehl aus, um nach Ereigniswarnungen für PersistentVolumeClaim zu suchen:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Wenn die Bereitstellung erfolgreich ist, sieht die Ausgabe in etwa so aus. Suchen Sie nach dem ProvisioningSucceeded-Log:

   Warning  ProvisioningFailed     9m12s                   parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = context deadline exceeded
   Warning  ProvisioningFailed     3m41s (x11 over 9m11s)  parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = Volume pvc-808e41a4-b688-4afe-9131-162fe5d672ec not ready, current state: CREATING
   Normal   ExternalProvisioning   3m10s (x43 over 13m)    persistentvolume-controller                                                                                  Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   Normal  Provisioning  8s (x13 over 10m)  "xxx"  External provisioner is provisioning volume for claim "xxx"
   Normal  ProvisioningSucceeded  7s  "xxx"  Successfully provisioned volume "xxx"
   

2. Prüfen Sie, ob die Erstellung der Parallelstore-Instanz gestartet wurde.

   gcloud beta parallelstore instances list \
       --project=PROJECT_ID \
       --location=-
   

   Die entsprechende Ausgabe sieht etwa so aus: Prüfen Sie, ob sich Ihr Volume im Status CREATING befindet. Wenn die Erstellung der Parallelstore-Instanz abgeschlossen ist, ändert sich der Status in ACTIVE.

   "projects/PROJECT_ID/locations/<my-location>/<my-volume>"  12000  2024-10-09T17:59:42.582857261Z  2024-10-09T17:59:42.582857261Z  CREATING  projects/PROJECT_ID/global/NETWORK_NAME
   

Wenn die Bereitstellung fehlschlägt, finden Sie im Leitfaden zur Fehlerbehebung für Parallelstore weitere Informationen.

Nächste Schritte

• Referenzdokumentation zu Parallelstore CSI
• Informationen zur Verwendung der Parallelstore-Abfangbibliothek zur Verbesserung der Workload-Leistung
• Anleitung zum Trainieren eines TensorFlow-Modells mit Keras in GKE