Halaman ini diterjemahkan oleh Cloud Translation API.

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

Autopilot Standard

GKE Volume Populator hanya tersedia melalui undangan. Jika Anda ingin meminta akses ke GKE Volume Populator di project Google Cloud, hubungi Sales Rep Anda.

GKE Volume Populator memungkinkan Anda memuat data secara otomatis dari penyimpanan sumber ke PersistentVolumeClaim tujuan selama penyediaan dinamis, tanpa perlu 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 data dalam jumlah besar dari bucket Cloud Storage ke PersistentVolumeClaim yang didukung oleh jenis penyimpanan Google Cloud lain (seperti Parallelstore).

Anda terutama berinteraksi dengan GKE Volume Populator melalui gcloud CLI dan kubectl CLI. GKE Volume Populator didukung di cluster Autopilot dan Standard. Anda tidak perlu mengaktifkan GKE Volume Populator. Ini adalah komponen yang dikelola GKE yang 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.
GKE Volume Populator memungkinkan portabilitas data; Anda dapat memindahkan data sesuai kebutuhan.
GKE Volume Populator mendukung autentikasi berbasis IAM sehingga Anda dapat mentransfer data sekaligus mempertahankan kontrol akses yang sangat terperinci.

Transfer data dari penyimpanan data sumber dan pembuatan PV untuk penyimpanan tujuan menggunakan GKE Volume Populator

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

Batasan

GKE Volume Populator hanya mendukung bucket Cloud Storage sebagai penyimpanan sumber dan instance Parallelstore sebagai jenis penyimpanan tujuan.
GKE Volume Populator hanya mendukung resource StorageClass yang menetapkan volumeBindingMode ke Immediate.
Resource kustom GCPDataSource harus berada dalam namespace yang sama dengan workload Kubernetes Anda. Volume dengan sumber data lintas namespace tidak didukung.
GKE Volume Populator hanya mendukung pengikatan akun layanan IAM ke akun layanan Kubernetes Workload Identity Federation for GKE. Memberikan izin IAM ke akun layanan Kubernetes secara langsung 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.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region dan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location.

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 GKE Volume Populator, cluster Anda harus memenuhi persyaratan berikut:

Gunakan cluster GKE versi 1.31.1-gke.1729000 atau yang lebih baru.
Aktifkan 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 harus mengaktifkan driver CSI.

Menyiapkan lingkungan Anda

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

Menyiapkan jaringan VPC

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

Untuk mengonfigurasi PSA, ikuti langkah-langkah berikut:

Konfigurasikan izin IAM Compute Network Admin (roles/compute.networkAdmin) untuk menyiapkan peering jaringan bagi project Anda.

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.

Aktifkan jaringan layanan:

gcloud services enable servicenetworking.googleapis.com

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: project ID Google Cloud Anda.
Catatan: Menetapkan nilai mtu (unit transmisi maksimum, atau ukuran paket IP terbesar yang dapat ditransmisikan di jaringan ini) ke nilai maksimum yang diizinkan sebesar 8896 akan meningkatkan performa hingga 10% dibandingkan dengan nilai default 1.460 byte.
Buat rentang IP.

Akses layanan pribadi memerlukan rentang alamat IP (blok CIDR) dengan panjang awalan setidaknya /24 (256 alamat). Parallelstore mencadangkan 64 alamat per instance, yang berarti Anda dapat menggunakan kembali rentang IP ini dengan layanan lain atau instance Parallelstore lainnya 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.

Tetapkan variabel lingkungan dengan rentang CIDR yang terkait dengan rentang yang Anda buat di langkah sebelumnya:

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

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 akan Anda buat.

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.

Membuat cluster GKE

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

Autopilot

Untuk membuat cluster GKE menggunakan Autopilot, jalankan perintah berikut:

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

GKE mengaktifkan Workload Identity Federation for GKE dan Driver CSI Parallelstore secara default di cluster Autopilot.

Ganti nilai berikut:

CLUSTER_NAME: nama cluster Anda.
CLUSTER_VERSION : nomor versi GKE. Anda harus menentukan 1.31.1-gke.1729000 atau yang lebih baru.
NETWORK_NAME: nama jaringan VPC yang Anda buat untuk instance Parallelstore. Untuk mempelajari lebih lanjut, lihat Mengonfigurasi jaringan VPC.
CLUSTER_LOCATION: region tempat Anda ingin membuat cluster. Sebaiknya buat cluster di lokasi Parallelstore yang didukung untuk performa terbaik. Jika ingin membuat cluster di lokasi Parallelstore yang tidak didukung, saat membuat StorageClass Parallelstore, Anda harus menentukan topologi kustom yang menggunakan lokasi Parallelstore yang didukung. Jika tidak, penyediaan akan gagal.

Standard

Buat cluster Standard dengan mengaktifkan Parallelstore CSI Driver dan Workload Identity Federation untuk GKE menggunakan perintah berikut:

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

Ganti nilai berikut:

CLUSTER_NAME: nama cluster Anda.
CLUSTER_VERSION: nomor versi GKE. Anda harus menentukan 1.31.1-gke.1729000 atau yang lebih baru.
PROJECT_ID: project ID Google Cloud Anda.
NETWORK_NAME: nama jaringan VPC yang Anda buat untuk instance Parallelstore. Untuk mempelajari lebih lanjut, lihat Mengonfigurasi jaringan VPC.
CLUSTER_LOCATION: region atau zona tempat Anda ingin membuat cluster. Sebaiknya buat cluster di lokasi Parallelstore yang didukung untuk performa terbaik. Jika ingin membuat cluster di lokasi Parallelstore yang tidak didukung, saat membuat StorageClass Parallelstore, Anda harus menentukan topologi kustom yang menggunakan lokasi Parallelstore yang didukung. Jika tidak, penyediaan akan gagal.

Menyiapkan izin yang diperlukan

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

Membuat namespace Kubernetes:
```
kubectl create namespace NAMESPACE
```
Ganti NAMESPACE dengan namespace tempat beban kerja Anda akan dijalankan.
Buat akun layanan Kubernetes.
```
kubectl create serviceaccount KSA_NAME \
    --namespace=NAMESPACE
```
Ganti KSA_NAME dengan nama akun layanan Kubernetes yang digunakan Pod Anda untuk melakukan autentikasi ke Google Cloud API.

Perhatian: Menggunakan kembali akun layanan Kubernetes ini dalam workload dalam namespace yang sama akan memungkinkan Pod tersebut mengakses bucket Cloud Storage. Sebaiknya jangan gunakan kembali akun layanan ini untuk workload di namespace.
Buat akun layanan IAM. Anda juga dapat menggunakan akun layanan IAM yang ada di project apa pun di organisasi Anda:
```
gcloud iam service-accounts create IAM_SA_NAME \
    --project=PROJECT_ID
```
Ganti kode berikut:
- IAM_SA_NAME: nama untuk akun layanan IAM Anda.
- PROJECT_ID: project ID Google Cloud Anda.

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

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.

Buat kebijakan izin 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]"

Anotasikan akun layanan Kubernetes agar 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

Buat identitas layanan Parallelstore:

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

Berikan peran roles/iam.serviceAccountTokenCreator kepada identitas layanan Parallelstore agar dapat meniru identitas akun layanan IAM. Tetapkan variabel lingkungan PROJECT_NUMBER agar Anda dapat menggunakannya di 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 dihasilkan secara otomatis untuk project Anda. Untuk menemukan nilai ini, lihat Membuat dan mengelola project.

Berikan peran roles/iam.serviceAccountUser kepada identitas layanan Parallelstore agar dapat mengakses semua resource yang dapat diakses oleh akun layanan IAM:

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

Berikan peran roles/iam.serviceAccountUser ke identitas layanan GKE agar dapat mengakses semua resource yang dapat diakses oleh akun layanan IAM. 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 dimuat sebelumnya

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

Buat resource GCPDataSource.
Membuat StorageClass Parallelstore.
Buat PersistentVolumeClaim untuk mengakses volume.
Verifikasi bahwa penyediaan PersistentVolumeClaim telah selesai.
(Opsional) Lihat progres transfer data.
Buat beban kerja yang menggunakan volume.

Membuat resource `GCPDataSource`

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

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 mengetahui 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 melakukan autentikasi ke Google Cloud API. Nilai cloudStorage.serviceAccountName harus berupa akun layanan Kubernetes yang Anda siapkan untuk Workload Identity Federation untuk GKE pada langkah Menyiapkan izin yang diperlukan.
- GCS_BUCKET: nama bucket Cloud Storage Anda. Atau, Anda juga dapat menentukan gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ untuk kolom uri.
Buat resource GCPDataSource dengan menjalankan perintah ini:
```
kubectl apply -f gcpdatasource.yaml
```

Membuat StorageClass Parallelstore

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

Simpan manifes berikut sebagai parallelstore-class.yaml. Pastikan kolom volumeBindingMode dalam definisi StorageClass ditetapkan ke Immediate.

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

Buat StorageClass dengan menjalankan perintah ini:
```
kubectl apply -f parallelstore-class.yaml
```

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

Membuat PersistentVolumeClaim untuk mengakses volume

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

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 beban kerja 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. Lihat referensi CRD GCPDataSource untuk mengetahui detail selengkapnya.
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.

Memverifikasi bahwa penyediaan PersistentVolumeClaim telah selesai

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

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

Untuk memeriksa statusnya:

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, artinya PersistentVolumeClaim sementara tidak dibuat. Jika demikian, lihat bagian Pemecahan masalah.

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"

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 panduan tambahan.

(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 berhasil disalin. Anda juga harus menjalankan perintah ini jika operasi binding PersistentVolumeClaim memakan waktu terlalu lama.

Verifikasi status PersistentVolumeClaim Anda dengan menjalankan perintah berikut:
```
kubectl describe pvc PVC_NAME -n NAMESPACE
```

Periksa pesan peristiwa PersistentVolumeClaim untuk menemukan progres transfer data. GKE mencatat pesan sekitar satu kali per menit. Outputnya mirip dengan yang berikut ini:

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

Mungkin perlu waktu beberapa saat hingga operasi pengisian dimulai; operasi ini bergantung pada ukuran file. Jika Anda tidak melihat progres 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.

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 beban kerja Anda.
- NAMESPACE: namespace tempat beban kerja 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.
Jalankan perintah berikut untuk menerapkan manifes ke cluster:
```
kubectl apply -f pod.yaml
```
Periksa status Pod Anda dan tunggu hingga statusnya menjadi RUNNING. PersistentVolumeClaim Anda harus terikat sebelum beban kerja dapat berjalan.
```
kubectl describe pod POD_NAME -n NAMESPACE
```
Pastikan file berhasil ditransfer dan dapat diakses oleh workload 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 perlu menghapus PersistentVolumeClaim saat data masih ditransfer selama penyediaan dinamis, Anda memiliki dua opsi: penghapusan halus dan penghapusan paksa.

Penghapusan halus memerlukan lebih sedikit upaya, tetapi dapat lebih memakan waktu dan tidak mempertimbangkan 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 jika Anda perlu memulai ulang atau memperbaiki kesalahan konfigurasi dengan cepat.

Penghapusan halus

Gunakan opsi penghapusan ini untuk memastikan bahwa proses transfer data selesai sebelum GKE menghapus resource terkait.

Hapus Pod beban kerja jika ada, dengan menjalankan perintah ini:
```
kubectl delete pod POD_NAME -n NAMESPACE
```

Temukan nama PersistentVolumeClaim sementara:

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

echo $TEMP_PVC

Temukan nama PersistentVolume:

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

echo ${PV_NAME?}

Jika output kosong, berarti PersistentVolume belum dibuat.

Hapus PersistentVolumeClaim Anda dengan menjalankan perintah ini. Finalizer akan memblokir operasi penghapusan Anda. Tekan Ctrl+C, lalu lanjutkan ke langkah berikutnya.
```
kubectl delete pvc PVC_NAME -n NAMESPACE
```
Tunggu hingga transfer data selesai. GKE pada akhirnya akan menghapus instance PersistentVolumeClaim, PersistentVolume, dan Parallelstore.
Pastikan resource PersistentVolumeClaim, PersistentVolumeClaim, dan PersistentVolume sementara dihapus:
```
kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
```
Pastikan instance Parallelstore dihapus. Instance Parallelstore akan memiliki nama yang sama dengan PersistentVolume. Anda tidak perlu menjalankan perintah ini jika telah mengonfirmasi di Langkah 3 bahwa PersistentVolume tidak dibuat.
```
gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}
```

Penghapusan paksa

Gunakan opsi penghapusan ini jika Anda perlu menghapus PersistentVolumeClaim dan resource terkait sebelum proses transfer data selesai. Hal ini mungkin diperlukan dalam situasi saat transfer data memerlukan waktu terlalu lama atau mengalami error, atau jika Anda perlu mengklaim kembali resource dengan cepat.

Hapus Pod workload jika ada:

kubectl delete pod POD_NAME -n NAMESPACE

Perbarui kebijakan pengambil alihan PersistentVolume ke Delete. Tindakan ini memastikan bahwa PersistentVolume, beserta penyimpanan pokoknya, akan otomatis dihapus saat PersistentVolumeClaim terkait dihapus.

Lewati perintah berikut jika salah satu hal berikut berlaku:
- Anda tidak ingin menghapus PersistentVolume atau penyimpanan yang mendasarinya.
- Kebijakan pengklaiman ulang Anda saat ini adalah Retain dan Anda ingin mempertahankan penyimpanan pokok. Bersihkan instance penyimpanan dan PersistentVolume secara manual sesuai kebutuhan.
- Perintah echo $PV_NAME berikut menghasilkan string kosong, yang berarti bahwa PersistentVolume belum dibuat.
```
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"}}'
```

Temukan nama PersistentVolumeClaim sementara dan tetapkan variabel lingkungan untuk langkah berikutnya:

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

TEMP_PVC=prime-$PVC_UID

echo $TEMP_PVC

Hapus PersistentVolumeClaim dengan menjalankan perintah ini. Finalizer akan memblokir operasi penghapusan Anda. Tekan Ctrl+C, lalu lanjutkan ke langkah berikutnya.
```
kubectl delete pvc PVC_NAME -n NAMESPACE
```
Hapus finalizer datalayer.gke.io/populate-target-protection dari PersistentVolumeClaim Anda. Langkah ini diperlukan setelah menghapus PersistentVolumeClaim. Jika tidak, gke-volume-populator akan menambahkan finalizer kembali ke PersistentVolumeClaim.
```
kubectl get pvc PVC_NAME -n NAMESPACE -o=json | \
jq '.metadata.finalizers = null' | kubectl apply -f -
```
Hapus PersistentVolumeClaim sementara di namespace gke-managed-volumepopulator.
```
kubectl delete pvc $TEMP_PVC -n gke-managed-volumepopulator
```
Pastikan resource PersistentVolumeClaim, PersistentVolumeClaim, dan PersistentVolume sementara dihapus:
```
kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
```
Pastikan instance Parallelstore dihapus. Instance Parallelstore akan memiliki nama yang sama dengan PersistentVolume. Anda tidak perlu menjalankan perintah ini jika telah mengonfirmasi di Langkah 2 bahwa PersistentVolume tidak dibuat.
```
gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}
```

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, ini menunjukkan bahwa error internal Parallelstore API telah terjadi.

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 mengatasi masalah ini, Anda harus mengikuti langkah-langkah berikut untuk mengumpulkan data bagi Dukungan:

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?}

Jalankan perintah berikut untuk mendapatkan nama volume:

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

Hubungi tim dukungan dengan pesan error, nama project Anda, 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
Tidak ada izin 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 mengatasinya, periksa kembali hal berikut:

Akses bucket Cloud Storage: Pastikan 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 tersebut 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.

Error argumen tidak valid

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