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

Der GKE Volume Populator ist nur auf Einladung verfügbar. Wenn Sie Zugriff auf den GKE Volume Populator in Ihrem Google Cloud -Projekt anfordern möchten, wenden Sie sich an Ihren Vertriebsmitarbeiter.

Mit dem GKE Volume Populator können Sie während der dynamischen Bereitstellung Daten aus einem Quellspeicher in einen Ziel-PersistentVolumeClaim vorladen, ohne zusätzliche Scripts oder Befehle für die manuelle Datenübertragung ausführen zu müssen. Mit dieser Funktion wird der Datenübertragungsprozess automatisiert und optimiert, indem die Funktion Kubernetes Volume Populator verwendet wird. Sie bietet eine nahtlose Datenübertragbarkeit, sodass Sie Speichertypen austauschen 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öchten, der von einem anderenGoogle Cloud -Speichertyp (z. B. Parallelstore) unterstützt wird.

Die Hauptschnittstelle für den GKE Volume Populator ist die gcloud CLI und die kubectl CLI. Der GKE Volume Populator wird sowohl in Autopilot- als auch in Standardclustern unterstützt. Sie müssen den GKE Volume Populator nicht aktivieren. Es ist 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.
  • Mit dem GKE Volume Populator können Sie Daten nach Bedarf verschieben.
  • GKE Volume Populator unterstützt die IAM-basierte Authentifizierung, sodass Sie Daten übertragen und gleichzeitig eine detaillierte Zugriffssteuerung beibehalten können.

Datenübertragung vom Quelldatenspeicher und Erstellen eines PV für den Zielspeicher mit dem GKE Volume Populator

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

Beschränkungen

  • Der GKE Volume Populator unterstützt nur Cloud Storage-Buckets als Quellspeicher und Parallelstore-Instanzen als Zielspeichertyp.
  • Der GKE Volume Populator unterstützt nur StorageClass-Ressourcen, deren volumeBindingMode auf Immediate festgelegt ist.
  • Die benutzerdefinierte GCPDataSource-Ressource muss sich im selben Namespace wie Ihre Kubernetes-Arbeitslast befinden. Volumes mit netzwerkübergreifenden Datenquellen werden nicht unterstützt.
  • Der GKE Volume Populator unterstützt nur die Workload Identity-Föderation für GKE, um IAM-Dienstkonten mit einem Kubernetes-Dienstkonto zu verknüpfen. Das direkte Gewähren 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.

Voraussetzungen

Damit Sie den GKE Volume Populator verwenden können, müssen Ihre Cluster die folgenden Anforderungen erfüllen:

  • Verwenden Sie die GKE-Cluster-Version 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 erfahren Sie, wie Sie Ihre GKE-Cluster erstellen und die erforderlichen Berechtigungen für die Verwendung des GKE Volume Populators einrichten.

VPC-Netzwerk einrichten

Sie müssen dasselbe VPC-Netzwerk (Virtual Private Cloud) angeben, wenn Sie die Parallelstore-Instanz und die Compute Engine-VMs oder GKE-Cluster des Clients erstellen. Damit VPC eine private Verbindung zu Google Cloud-Diensten herstellen kann, ohne den Traffic dem öffentlichen Internet auszusetzen, müssen Sie den Zugriff auf private Dienste (Private Services Access, PSA) einmalig konfigurieren, falls Sie dies noch nicht getan haben.

So konfigurieren Sie PSA:

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

    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-Netzwerk, in dem Sie die 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 bei Bedarf für andere Dienste oder andere 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 IP-Adressbereichs des VPC-Netzwerk.

  5. Legen Sie eine Umgebungsvariable mit dem CIDR-Bereich fest, der mit dem Bereich verknüpft 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, um TCP-Traffic aus dem von Ihnen erstellten IP-Bereich zuzulassen.

  7. Peering herstellen:

    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 Arbeitslast am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Autopilot

Führen Sie den folgenden Befehl aus, um einen GKE-Cluster mit Autopilot zu erstellen:

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

In GKE ist die Workload Identity-Föderation für GKE und der Parallelstore-CSI-Treiber in Autopilot-Clustern standardmäßig aktiviert.

Ersetzen Sie die folgenden Werte:

  • CLUSTER_NAME: Der Name Ihres Clusters.
  • CLUSTER_VERSION : Die GKE-Versionsnummer. Sie müssen mindestens 1.31.1-gke.1729000 angeben.
  • NETWORK_NAME: der Name des VPC-Netzwerks, das Sie für die Parallelstore-Instanz erstellt haben. Weitere Informationen finden Sie unter VPC-Netzwerk konfigurieren.
  • CLUSTER_LOCATION: die Region, in der Sie den Cluster erstellen möchten. Wir empfehlen, den Cluster an einem unterstützten Parallelstore-Speicherort zu erstellen, um die beste Leistung zu erzielen. Wenn Sie Ihren Cluster an einem nicht unterstützten Parallelstore-Speicherort erstellen möchten, müssen Sie beim Erstellen einer Parallelstore-Speicherklasse eine benutzerdefinierte Topologie angeben, die einen unterstützten Parallelstore-Speicherort verwendet. Andernfalls schlägt die Bereitstellung fehl.

Standard

Erstellen Sie mit dem folgenden Befehl einen Standardcluster mit aktiviertem Parallelstore CSI-Treiber und aktivierter Identitätsföderation von Arbeitslasten für GKE:

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

Ersetzen Sie die folgenden Werte:

  • CLUSTER_NAME: Der Name Ihres Clusters.
  • CLUSTER_VERSION: Die GKE-Versionsnummer. Sie müssen mindestens 1.31.1-gke.1729000 angeben.
  • PROJECT_ID: Ihre Google Cloud Projekt-ID.
  • NETWORK_NAME: der Name des VPC-Netzwerks, das Sie für die Parallelstore-Instanz erstellt haben. Weitere Informationen finden Sie unter VPC-Netzwerk konfigurieren.
  • CLUSTER_LOCATION: die Region oder Zone, in der Sie den Cluster erstellen möchten. Wir empfehlen, den Cluster an einem unterstützten Parallelstore-Speicherort zu erstellen, um die beste Leistung zu erzielen. Wenn Sie Ihren Cluster an einem nicht unterstützten Parallelstore-Speicherort erstellen möchten, müssen Sie beim Erstellen einer Parallelstore-Speicherklasse eine benutzerdefinierte Topologie angeben, die einen unterstützten Parallelstore-Speicherort verwendet. Andernfalls schlägt die Bereitstellung fehl.

Erforderliche Berechtigungen einrichten

Wenn Sie Daten aus einem Cloud Storage-Bucket übertragen möchten, müssen Sie Berechtigungen für die Workload Identity Federation for 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, mit dem sich Ihr Pod bei den APIs von Google Cloud authentifiziert.

  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. Weisen Sie der Parallelstore-Dienstidentität die Rolle roles/iam.serviceAccountTokenCreator zu, damit sie sich als IAM-Dienstkonto ausgeben kann. Legen Sie die Umgebungsvariable PROJECT_NUMBER fest, damit Sie sie in den nachfolgenden 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. Wie Sie diesen Wert ermitteln, erfahren Sie im Hilfeartikel Projekte erstellen und verwalten.

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

    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. Weisen Sie der GKE-Dienstidentität die Rolle roles/iam.serviceAccountUser zu, damit sie auf alle Ressourcen zugreifen kann, auf die das IAM-Dienstkonto zugreifen kann. 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. Erstellen Sie eine GCPDataSource-Ressource.
  2. Erstellen Sie eine StorageClass vom Typ „Parallelstore“.
  3. Erstellen Sie einen PersistentVolumeClaim, um auf das Volume zuzugreifen.
  4. Prüfen Sie, ob die Bereitstellung des PersistentVolumeClaim abgeschlossen ist.
  5. (Optional) Fortschritt der Datenübertragung ansehen
  6. Erstellen Sie eine Arbeitslast, die das Volume verbraucht.

Ressource GCPDataSource erstellen

Wenn Sie den GKE Volume Populator verwenden möchten, erstellen Sie eine benutzerdefinierte GCPDataSource-Ressource. In dieser Ressource werden die Quellspeichereigenschaften für die Volume-Bereitstellung definiert.

  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 der GCPDataSource-CRD, die eine Referenz auf Ihren Cloud Storage-Bucket enthält. Weitere Informationen finden Sie in der GCPDataSource-CRD-Referenz.
    • NAMESPACE: Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespacewert sollte mit dem Namespace Ihrer Arbeitslast übereinstimmen.
    • KSA_NAME: der Name des Kubernetes-Dienstkontos, mit dem sich Ihr Pod bei den APIs von Google Cloud authentifiziert. Der Wert für cloudStorage.serviceAccountName sollte das Kubernetes-Dienstkonto sein, das Sie im Schritt Erforderliche Berechtigungen einrichten für die Workload Identity Federation for GKE eingerichtet haben.
    • GCS_BUCKET: Name Ihres Cloud Storage-Buckets. Alternativ kannst du auch gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ für das Feld uri angeben.

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

    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 I/O-Leistung gewährleistet.

  1. Speichern Sie das folgende Manifest als parallelstore-class.yaml. Achten Sie darauf, dass das Feld volumeBindingMode in der StorageClass-Definition auf Immediate gesetzt ist.

    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 zum 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: Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespacewert sollte mit dem Namespace Ihrer Arbeitslast übereinstimmen.
    • GCP_DATA_SOURCE: der Name der GCPDataSource-CRD, die eine Referenz auf Ihren Cloud Storage-Bucket enthält. Weitere Informationen finden Sie in der GCPDataSource-CRD-Referenz.

  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. Wie Sie den Fortschritt der Datenübertragung prüfen, erfahren Sie unter Fortschritt der Datenübertragung ansehen. Wenn bei der Bereitstellung Fehler auftreten, lesen Sie den Hilfeartikel Fehlerbehebung.

Prüfen, ob die Bereitstellung des PersistentVolumeClaim abgeschlossen ist

Der GKE Volume Populator verwendet einen vorübergehenden PersistentVolumeClaim im Namespace gke-managed-volumepopulator für die Volumebereitstellung.

Der temporäre PersistentVolumeClaim ist im Grunde ein Snapshot Ihres PersistentVolumeClaims, der sich noch in der Übertragung befindet (die Daten werden noch vollständig geladen). 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. Lesen Sie in diesem Fall den Abschnitt Fehlerbehebung.

    Wenn die Bereitstellung erfolgreich war, sieht die Ausgabe in etwa so aus: Suchen Sie nach dem ProvisioningSucceeded-Protokoll:

    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 das Volume den Status CREATING hat. Wenn die Parallelstore-Instanz erstellt wurde, ä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 fehlgeschlagen ist, finden Sie in der Anleitung zur Fehlerbehebung für Parallelstore weitere Informationen.

(Optional) Fortschritt der Datenübertragung ansehen

In diesem Abschnitt erfahren Sie, 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 die Bindung des PersistentVolumeClaims zu lange dauert.

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

    kubectl describe pvc PVC_NAME -n NAMESPACE

  2. In der Ereignismeldung für PersistentVolumeClaims sehen Sie den Fortschritt der Datenübertragung. GKE protokolliert die Nachrichten etwa einmal pro Minute. Die 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. Dieser Vorgang hängt von der Dateigröße ab. Wenn nach mehreren Minuten kein Fortschritt bei der Datenübertragung zu sehen ist, lesen Sie den Abschnitt 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 nutzt.

  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: Namespace, in dem Ihre Arbeitslasten ausgeführt werden. Der Namespacewert 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. Der 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 Ihre Arbeitslast darauf zugreifen kann.

    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

    Die Ausgabe sollte alle Dateien enthalten, die sich im URI Ihres Cloud Storage-Buckets befinden.

PersistentVolumeClaim während der dynamischen Bereitstellung löschen

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

Das ordnungsgemäße Löschen ist weniger aufwendig, kann aber zeitaufwendiger sein und berücksichtigt keine Fehlkonfigurationen von Nutzern, die die Datenübertragung verhindern. Das erzwungene Löschen ist eine schnellere Alternative, die mehr Flexibilität und Kontrolle bietet. Diese Option eignet sich, wenn Sie schnell neu starten oder Fehlkonfigurationen korrigieren müssen.

Ordnungsgemäßes Löschen

Mit dieser Löschoption können Sie dafür sorgen, dass die Datenübertragung abgeschlossen ist, bevor GKE die zugehörigen Ressourcen löscht.

  1. Löschen Sie den Arbeitslast-Pod, falls vorhanden, mit dem folgenden Befehl:

    kubectl delete pod POD_NAME -n NAMESPACE

  2. Suchen Sie den Namen des temporären PersistentVolumeClaims:

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

echo $TEMP_PVC

  3. Suchen Sie den Namen des PersistentVolume:

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

echo ${PV_NAME?}

    Wenn die Ausgabe leer ist, wurde das PersistentVolume noch nicht erstellt.

  4. Löschen Sie den PersistentVolumeClaim mit dem folgenden Befehl: Der Finalizer blockiert den Löschvorgang. Drücken Sie Ctrl+C und fahren Sie mit dem nächsten Schritt fort.

    kubectl delete pvc PVC_NAME -n NAMESPACE

    Warten Sie, bis die Datenübertragung abgeschlossen ist. GKE löscht schließlich den PersistentVolumeClaim, das PersistentVolume und die Parallelstore-Instanz.

  5. Prüfen Sie, ob die temporären Ressourcen „PersistentVolumeClaim“, „PersistentVolumeClaim“ und „PersistentVolume“ gelöscht wurden:

    kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"

  6. Prüfen Sie, ob die Parallelstore-Instanz gelöscht wurde. Die Parallelstore-Instanz hat denselben Namen wie das PersistentVolume. Sie müssen diesen Befehl nicht ausführen, wenn Sie in Schritt 3 bestätigt haben, dass das PersistentVolume nicht erstellt wurde.

    gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}

Erzwungenes Löschen

Verwenden Sie diese Löschoption, wenn Sie einen PersistentVolumeClaim und die zugehörigen Ressourcen löschen möchten, bevor die Datenübertragung abgeschlossen ist. Dies kann beispielsweise erforderlich sein, wenn die Datenübertragung zu lange dauert oder Fehler auftreten oder wenn Sie Ressourcen schnell wiederverwenden müssen.

  1. Löschen Sie den Arbeitslast-Pod, falls vorhanden:

    kubectl delete pod POD_NAME -n NAMESPACE

  2. Aktualisieren Sie die Richtlinie für die Rückforderung von PersistentVolumes auf Delete. So wird sichergestellt, dass das PersistentVolume zusammen mit dem zugrunde liegenden Speicher automatisch gelöscht wird, wenn der zugehörige PersistentVolumeClaim gelöscht wird.

    Überspringen Sie den folgenden Befehl, wenn einer der folgenden Punkte zutrifft:

    • Sie möchten das PersistentVolume oder den zugrunde liegenden Speicher nicht löschen.
    • Ihre aktuelle Richtlinie für die Rückforderung von Speicherplatz ist Retain und Sie möchten den zugrunde liegenden Speicherplatz behalten. Bereinigen Sie das PersistentVolume und die Speicherinstanz bei Bedarf manuell.
    • Der folgende echo $PV_NAME-Befehl gibt einen leeren String aus. Das bedeutet, dass das PersistentVolume noch nicht erstellt wurde.
    PV_NAME=$(kubectl describe pvc $TEMP_PVC -n gke-managed-volumepopulator | grep "Volume:" | awk '{print $2}')

echo $PV_NAME

kubectl patch pv $PV_NAME -p '{"spec":{"persistentVolumeReclaimPolicy":"Delete"}}'

  3. Suchen Sie den Namen des temporären PersistentVolumeClaims und legen Sie die Umgebungsvariable für einen späteren Schritt fest:

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

TEMP_PVC=prime-$PVC_UID

echo $TEMP_PVC

  4. Löschen Sie den PersistentVolumeClaim mit dem folgenden Befehl: Der Finalizer blockiert den Löschvorgang. Drücken Sie Ctrl+C und fahren Sie mit dem nächsten Schritt fort.

    kubectl delete pvc PVC_NAME -n NAMESPACE

  5. Entfernen Sie den Finalizer datalayer.gke.io/populate-target-protection aus Ihrem PersistentVolumeClaim. Dieser Schritt ist nach dem Löschen des PersistentVolumeClaim erforderlich. Andernfalls fügt gke-volume-populator dem PersistentVolumeClaim den Finalizer wieder hinzu.

    kubectl get pvc PVC_NAME -n NAMESPACE -o=json | \
jq '.metadata.finalizers = null' | kubectl apply -f -

  6. Löschen Sie den temporären PersistentVolumeClaim im Namespace gke-managed-volumepopulator.

    kubectl delete pvc $TEMP_PVC -n gke-managed-volumepopulator

  7. Prüfen Sie, ob die temporären Ressourcen „PersistentVolumeClaim“, „PersistentVolumeClaim“ und „PersistentVolume“ gelöscht wurden:

    kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"

  8. Prüfen Sie, ob die Parallelstore-Instanz gelöscht wurde. Die Parallelstore-Instanz hat denselben Namen wie das PersistentVolume. Sie müssen diesen Befehl nicht ausführen, wenn Sie in Schritt 2 bestätigt haben, dass das PersistentVolume nicht erstellt wurde.

    gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}

Fehlerbehebung

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

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

kubectl describe pvc PVC_NAME -n NAMESPACE

Fehler: An internal error has occurred

Wenn der folgende Fehler auftritt, ist ein interner Fehler 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 erfassen und das Problem zu beheben:

  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 Volumenamen abzurufen:

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

  3. Wenden Sie sich an das Supportteam und geben Sie die Fehlermeldung, den Projektnamen und den Volumenamen an.

Probleme mit Berechtigungen

Wenn Sie bei der Bereitstellung von Volumes Fehler wie den folgenden erhalten, weist das 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 Probleme zu beheben:

  • Zugriff auf Cloud Storage-Bucket: Prüfen Sie, ob der Bucket vorhanden ist und das Dienstkonto die Berechtigung 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: Prüfen Sie, ob es vorhanden ist und die erforderlichen Berechtigungen (roles/iam.serviceAccountTokenCreator und roles/iam.serviceAccountUser für das IAM-Konto) hat.

Eine detaillierte Anleitung und Bestätigungsbefehle finden Sie unter Erforderliche Berechtigungen einrichten. Wenn der Fehler weiterhin auftritt, wenden Sie sich an den Support und geben Sie die Fehlermeldung, den Projektnamen und den Namen des Cloud Storage-Bucket an.

Fehlermeldungen zu ungültigen Argumenten

Wenn InvalidArgument-Fehler auftreten, haben Sie wahrscheinlich falsche Werte für GCPDataSource oder PersistentVolumeClaim angegeben. Im Fehlerprotokoll werden die genauen Felder mit den ungültigen Daten angegeben. Prüfen Sie den URI Ihres Cloud Storage-Bucket und andere relevante Felder auf Richtigkeit.

Nächste Schritte