Mentransfer data dari Cloud Storage selama penyediaan dinamis menggunakan GKE Volume Populator

Pengisi Volume GKE memungkinkan Anda memuat data terlebih dahulu dari penyimpanan sumber ke PersistentVolumeClaim tujuan selama penyediaan dinamis, tanpa menjalankan skrip atau perintah CLI tambahan untuk transfer data manual. Fitur ini menangani otomatisasi dan penyederhanaan proses transfer data dengan memanfaatkan fitur Kubernetes Volume Populator. Layanan ini menyediakan portabilitas data yang lancar sehingga Anda dapat menukar jenis penyimpanan untuk mendapatkan manfaat dari pengoptimalan harga atau performa.

Gunakan fitur ini jika Anda perlu mentransfer sejumlah besar data dari bucket Cloud Storage ke PersistentVolumeClaim yang didukung oleh jenis penyimpananGoogle Cloud lain (seperti Parallelstore).

Anda terutama berinteraksi dengan GKE Volume Populator melalui gcloud CLI dan kubectl CLI. Pengisi Volume GKE didukung di cluster Autopilot dan Standard. Anda tidak perlu mengaktifkan GKE Volume Populator. Komponen ini adalah komponen yang dikelola GKE dan diaktifkan secara default.

Manfaat

• Jika ingin memanfaatkan performa sistem file paralel terkelola, tetapi data Anda disimpan di Cloud Storage, Anda dapat menggunakan GKE Volume Populator untuk menyederhanakan transfer data.
• Pengisi Volume GKE memungkinkan portabilitas data. Anda dapat memindahkan data sesuai kebutuhan.
• Pengisi Volume GKE mendukung autentikasi berbasis IAM sehingga Anda dapat mentransfer data sambil mempertahankan kontrol akses yang mendetail.

Diagram menunjukkan cara data mengalir dari penyimpanan sumber ke penyimpanan tujuan, dan pembuatan PersistentVolume untuk penyimpanan tujuan menggunakan GKE Volume Populator.

Batasan

• Pengelola Volume GKE hanya mendukung bucket Cloud Storage sebagai penyimpanan sumber dan instance Parallelstore sebagai jenis penyimpanan tujuan.
• Resource kustom GCPDataSource harus berada di namespace yang sama dengan workload Kubernetes Anda. Volume dengan sumber data lintas namespace tidak didukung.
• Pengisi Volume GKE hanya mendukung pengikatan Federasi Workload Identity untuk GKE akun layanan IAM ke akun layanan Kubernetes. Pemberian izin IAM langsung ke akun layanan Kubernetes tidak didukung.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

• Aktifkan Parallelstore API dan Google Kubernetes Engine API.
Aktifkan API
• Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.

• Lihat ringkasan driver CSI Parallelstore untuk mengetahui batasan dan persyaratan.
• Buat bucket Cloud Storage yang diisi dengan data yang ingin Anda transfer.

Persyaratan

Untuk menggunakan Pengisi Volume GKE, cluster Anda harus memenuhi persyaratan berikut:

• Gunakan cluster GKE versi 1.31.1-gke.1729000 atau yang lebih baru.
• Mengaktifkan driver CSI Parallelstore. GKE mengaktifkan driver CSI untuk Anda secara default di cluster GKE Autopilot baru dan yang sudah ada. Di cluster Standard baru dan yang sudah ada, Anda perlu mengaktifkan driver CSI.

Menyiapkan lingkungan Anda

Bagian ini mencakup langkah-langkah untuk membuat cluster GKE dan menyiapkan izin yang diperlukan untuk menggunakan GKE Volume Populator.

Siapkan jaringan VPC Anda

Anda harus menentukan jaringan Virtual Private Cloud (VPC) yang sama saat membuat instance Parallelstore dan VM Compute Engine klien atau cluster GKE. Untuk mengaktifkan VPC agar terhubung secara pribadi ke layanan tanpa mengekspos traffic ke internet publik, Anda perlu melakukan konfigurasi akses layanan pribadi (PSA) satu kali, jika Anda belum melakukannya. Google Cloud

Untuk mengonfigurasi PSA, ikuti langkah-langkah berikut:

1. Untuk menyiapkan peering jaringan untuk project Anda, konfigurasi izin IAM Compute Network Admin (roles/compute.networkAdmin).

   Untuk memberikan peran, jalankan perintah berikut:

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

   Ganti EMAIL_ADDRESS dengan alamat email Anda.

2. Aktifkan Service Networking:

   gcloud services enable servicenetworking.googleapis.com
   

3. Buat jaringan VPC:

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

   Ganti kode berikut:

   • NETWORK_NAME: nama jaringan VPC tempat Anda akan membuat instance Parallelstore.
   • PROJECT_ID: Google Cloud project ID Anda.

4. Buat rentang IP.

   Akses layanan pribadi memerlukan rentang alamat IP (blok CIDR) dengan panjang awalan minimal /24 (256 alamat). Parallelstore mencadangkan 64 alamat per instance, yang berarti Anda dapat menggunakan kembali rentang IP ini dengan layanan lain atau instance Parallelstore lain jika diperlukan.

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

   Ganti IP_RANGE_NAME dengan nama rentang IP jaringan VPC.

5. Tetapkan variabel lingkungan dengan rentang CIDR yang terkait dengan rentang yang Anda buat pada langkah sebelumnya:

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

6. Buat aturan firewall untuk mengizinkan traffic TCP dari rentang IP yang Anda buat:

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

   Ganti FIREWALL_NAME dengan nama aturan firewall untuk mengizinkan traffic TCP dari rentang IP yang Anda buat.

7. Hubungkan peering:

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

Jika Anda mengalami masalah saat menyiapkan jaringan VPC, periksa panduan pemecahan masalah Parallelstore.

Buat cluster GKE Anda

Sebaiknya gunakan cluster Autopilot untuk mendapatkan pengalaman Kubernetes yang terkelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai dengan kebutuhan workload Anda, lihat Memilih mode operasi GKE.

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

Menyiapkan izin yang diperlukan

Untuk mentransfer data dari bucket Cloud Storage, Anda perlu menyiapkan izin untuk Workload Identity Federation for GKE.

1. Membuat namespace Kubernetes:

   kubectl create namespace NAMESPACE
   

   Ganti NAMESPACE dengan namespace tempat beban kerja Anda akan berjalan.

2. Buat akun layanan Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Ganti KSA_NAME dengan nama akun layanan Kubernetes yang digunakan Pod Anda untuk mengautentikasi ke API Google Cloud .

3. Buat akun layanan IAM. Anda juga dapat menggunakan akun layanan IAM yang ada di project mana pun di organisasi Anda:

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

   Ganti kode berikut:

   • IAM_SA_NAME: nama akun layanan IAM Anda.
   • PROJECT_ID: Google Cloud project ID Anda.

4. Berikan peran roles/storage.objectViewer ke akun layanan IAM Anda agar akun tersebut dapat mengakses bucket Cloud Storage Anda:

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

   Ganti GCS_BUCKET dengan nama bucket Cloud Storage Anda.

5. Buat kebijakan izinkan IAM yang memberi akun layanan Kubernetes akses untuk meniru identitas akun layanan IAM:

   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. Anotasikan akun layanan Kubernetes sehingga GKE melihat link antara akun layanan.

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

7. Buat identitas layanan Parallelstore:

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

8. Agar identitas layanan Parallelstore dapat meniru identitas akun layanan IAM, berikan peran roles/iam.serviceAccountTokenCreator ke identitas layanan Parallelstore. Tetapkan variabel lingkungan PROJECT_NUMBER agar Anda dapat menggunakannya di langkah-langkah berikutnya.

   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
   

   Nilai PROJECT_NUMBER adalah ID unik yang dibuat secara otomatis untuk project Anda. Untuk menemukan nilai ini, lihat Membuat dan mengelola project.

9. Untuk mengizinkan akses identitas layanan Parallelstore ke semua resource yang dapat diakses oleh akun layanan IAM, berikan peran roles/iam.serviceAccountUser ke identitas layanan Parallelstore:

   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. Agar identitas layanan GKE dapat mengakses semua resource yang dapat diakses oleh akun layanan IAM, berikan peran roles/iam.serviceAccountUser ke identitas layanan GKE. Langkah ini tidak diperlukan jika cluster GKE dan akun layanan IAM berada dalam project yang sama.

    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
    

Membuat volume Parallelstore dengan data yang sudah dimuat sebelumnya

Bagian berikut menjelaskan proses umum untuk membuat volume Parallelstore dengan data yang sudah dimuat sebelumnya dari bucket Cloud Storage, menggunakan GKE Volume Populator.

1. Buat resource GCPDataSource.
2. Buat StorageClass Parallelstore.
3. Buat PersistentVolumeClaim untuk mengakses volume.
4. (Opsional) Lihat progres transfer data.
5. Buat workload yang menggunakan volume.

Buat resource GCPDataSource

Untuk menggunakan Pengisi Volume GKE, buat resource kustom GCPDataSource. Resource ini menentukan properti penyimpanan sumber yang akan digunakan untuk pengisian volume.

1. Simpan manifes berikut dalam file bernama 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/
   

   Ganti nilai berikut:

   • GCP_DATA_SOURCE: nama CRD GCPDataSource yang menyimpan referensi ke bucket Cloud Storage Anda. Lihat referensi CRD GCPDataSource untuk detail selengkapnya.
   • NAMESPACE: namespace tempat beban kerja Anda akan berjalan. Nilai namespace harus sama dengan namespace workload Anda.
   • KSA_NAME: nama akun layanan Kubernetes yang digunakan Pod Anda untuk mengautentikasi ke API Google Cloud . Nilai cloudStorage.serviceAccountName harus berupa akun layanan Kubernetes yang Anda siapkan untuk Workload Identity Federation for GKE di langkah Siapkan izin yang diperlukan.
   • GCS_BUCKET: nama bucket Cloud Storage Anda. Atau, Anda juga dapat menentukan gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ untuk kolom uri.

2. Buat resource GCPDataSource dengan menjalankan perintah ini:

   kubectl apply -f gcpdatasource.yaml
   

Membuat StorageClass Parallelstore

Buat StorageClass untuk mengarahkan driver CSI Parallelstore agar menyediakan instance Parallelstore di region yang sama dengan cluster GKE Anda. Hal ini membantu memastikan performa I/O yang optimal.

1. Simpan manifes berikut sebagai 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. Buat StorageClass dengan menjalankan perintah ini:

   kubectl apply -f parallelstore-class.yaml
   

Jika Anda ingin membuat StorageClass kustom dengan topologi tertentu, lihat panduan Parallelstore CSI.

Membuat PersistentVolumeClaim untuk mengakses volume

File manifes berikut menunjukkan contoh cara membuat PersistentVolumeClaim dalam mode akses ReadWriteMany yang mereferensikan StorageClass yang Anda buat sebelumnya.

1. Simpan manifes berikut dalam file bernama 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
   

   Ganti nilai berikut:

   • PVC_NAME: nama PersistentVolumeClaim tempat Anda ingin mentransfer data. PersistentVolumeClaim harus didukung oleh instance Parallelstore.
   • NAMESPACE: namespace tempat workload Anda akan berjalan. Nilai namespace harus sama dengan namespace workload Anda.
   • GCP_DATA_SOURCE: nama CRD GCPDataSource yang menyimpan referensi ke bucket Cloud Storage Anda. Untuk mengetahui detail selengkapnya, lihat referensi GCPDataSource CRD.

2. Buat PersistentVolumeClaim dengan menjalankan perintah berikut:

   kubectl apply -f volume-populator-pvc.yaml
   

GKE tidak akan menjadwalkan Pod workload hingga penyediaan PersistentVolumeClaim selesai. Untuk memeriksa progres transfer data, lihat Melihat progres transfer data. Jika Anda mengalami error selama penyediaan, lihat Pemecahan masalah.

(Opsional) Melihat progres transfer data

Bagian ini menunjukkan cara melacak progres transfer data dari bucket Cloud Storage ke volume Parallelstore. Anda dapat melakukannya untuk memantau status transfer dan memastikan data Anda disalin dengan berhasil. Anda juga harus menjalankan perintah ini jika operasi pengikatan PersistentVolumeClaim membutuhkan waktu terlalu lama.

1. Verifikasi status PersistentVolumeClaim Anda dengan menjalankan perintah berikut:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Periksa pesan peristiwa PersistentVolumeClaim untuk mengetahui progres transfer data. GKE mencatat pesan sekitar satu kali per menit. Outputnya mirip dengan hal berikut:

   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
   

Proses pengisian data mungkin memerlukan waktu beberapa saat untuk dimulai; proses ini bergantung pada ukuran file. Jika Anda tidak melihat progres apa pun dalam transfer data setelah beberapa menit, lihat bagian Pemecahan masalah.

Membuat workload yang menggunakan volume

Bagian ini menunjukkan contoh cara membuat Pod yang menggunakan resource PersistentVolumeClaim yang Anda buat sebelumnya.

1. Simpan manifes YAML berikut untuk Pod Anda sebagai 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
   

   Ganti nilai berikut:

   • POD_NAME: nama Pod yang menjalankan workload Anda.
   • NAMESPACE: namespace tempat workload Anda akan berjalan. Nilai namespace harus sama dengan namespace workload Anda.
   • PVC_NAME: nama PersistentVolumeClaim tempat Anda ingin mentransfer data. PersistentVolumeClaim harus didukung oleh instance Parallelstore.

2. Jalankan perintah berikut untuk menerapkan manifes ke cluster:

   kubectl apply -f pod.yaml
   

3. Periksa status Pod Anda dan tunggu hingga statusnya menjadi RUNNING. PersistentVolumeClaim Anda harus terikat sebelum workload dapat berjalan.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Pastikan file berhasil ditransfer dan dapat diakses oleh beban kerja Anda.

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

   Ubah ke direktori /mnt/data dan jalankan ls:

   cd /mnt/data
   ls
   

   Output akan mencantumkan semua file yang ada di URI bucket Cloud Storage Anda.

Menghapus PersistentVolumeClaim selama penyediaan dinamis

Jika Anda perlu menghapus PersistentVolumeClaim saat data masih ditransfer selama penyediaan dinamis, Anda memiliki dua opsi: penghapusan yang benar dan penghapusan paksa.

Penghapusan yang benar memerlukan lebih sedikit upaya, tetapi dapat memakan lebih banyak waktu dan tidak memperhitungkan kesalahan konfigurasi pengguna yang mencegah transfer data selesai. Penghapusan paksa menawarkan alternatif yang lebih cepat yang memungkinkan fleksibilitas dan kontrol yang lebih besar; opsi ini cocok saat Anda perlu memulai ulang atau memperbaiki kesalahan konfigurasi dengan cepat.

Pemecahan masalah

Bagian ini menunjukkan cara menyelesaikan masalah terkait GKE Volume Populator.

Sebelum melanjutkan, jalankan perintah berikut untuk memeriksa peringatan peristiwa PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

Error: An internal error has occurred

Jika Anda mengalami error berikut, hal ini menunjukkan bahwa telah terjadi error internal Parallelstore API.

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")

Untuk menyelesaikan masalah ini, Anda harus mengikuti langkah-langkah berikut untuk mengumpulkan data bagi Dukungan:

1. Jalankan perintah berikut untuk mendapatkan nama PersistentVolumeClaim sementara, dengan mengganti placeholder dengan nama sebenarnya:

   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. Jalankan perintah berikut untuk mendapatkan nama volume:

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

3. Hubungi tim dukungan dengan menyertakan pesan error, nama project, dan nama volume.

Masalah izin

Jika Anda mengalami error seperti berikut selama pengisian volume, hal ini menunjukkan bahwa GKE mengalami masalah izin:

• Bucket Cloud Storage tidak ada: PopulateOperationStartError dengan code = PermissionDenied
• Izin yang tidak ada di bucket Cloud Storage atau akun layanan: PopulateOperationFailed dengan "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• Akun layanan tidak ditemukan: PopulateOperationStartError dengan code = Unauthenticated.

Untuk mengatasi error ini, periksa kembali hal berikut:

• Akses bucket Cloud Storage: verifikasi bahwa bucket ada dan akun layanan memiliki roles/storage.objectViewer permission.
• Akun layanan: pastikan akun layanan Kubernetes dan akun layanan IAM ada dan ditautkan dengan benar.
• Akun layanan Parallelstore: pastikan akun layanan Parallelstore ada dan memiliki izin yang diperlukan (roles/iam.serviceAccountTokenCreator dan roles/iam.serviceAccountUser di akun IAM).

Untuk mengetahui langkah-langkah mendetail dan perintah verifikasi, lihat Menyiapkan izin yang diperlukan. Jika error tetap berlanjut, hubungi dukungan dengan menyertakan pesan error, nama project, dan nama bucket Cloud Storage Anda.

Error argumen tidak valid

Jika Anda mengalami error InvalidArgument, artinya Anda mungkin memberikan nilai yang salah di GCPDataSource atau PersistentVolumeClaim. Log error akan menunjukkan kolom yang tepat yang berisi data tidak valid. Periksa akurasi URI bucket Cloud Storage dan kolom relevan lainnya.

Pastikan penyediaan PersistentVolumeClaim selesai

Pengisi Volume GKE menggunakan PersistentVolumeClaim sementara di namespace gke-managed-volumepopulator untuk penyediaan volume.

PersistentVolumeClaim sementara pada dasarnya adalah snapshot dari PersistentVolumeClaim Anda yang masih dalam pengiriman (menunggu data dimuat sepenuhnya). Namanya memiliki format prime-YOUR_PVC_UID.

Untuk memeriksa statusnya:

1. Jalankan perintah berikut:

   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
   

   Jika output kosong, berarti PersistentVolumeClaim sementara tidak dibuat. Jalankan perintah berikut untuk memeriksa peringatan peristiwa PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Jika penyediaan berhasil, output-nya akan mirip dengan berikut ini. Cari log ProvisioningSucceeded:

   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. Periksa apakah pembuatan instance Parallelstore telah dimulai.

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

   Outputnya mirip dengan yang berikut ini. Pastikan volume Anda dalam status CREATING. Setelah pembuatan instance Parallelstore selesai, status akan berubah menjadi 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
   

Jika penyediaan gagal, lihat panduan pemecahan masalah Parallelstore untuk mendapatkan panduan tambahan.

Langkah berikutnya

• Pelajari dokumentasi referensi CSI Parallelstore.
• Pelajari cara menggunakan library pencegatan Parallelstore untuk meningkatkan performa beban kerja.
• Coba tutorial untuk melatih model TensorFlow dengan Keras di GKE.