אוטומציה של העברת נתונים מ-Cloud Storage ל-Parallelstore באמצעות GKE Volume Populator

במדריך הזה מוסבר איך לטעון מראש כמויות גדולות של נתונים מקטגוריה של Cloud Storage לנפח אחסון של Parallelstore ב-Google Kubernetes Engine ‏ (GKE) במהלך הקצאה דינמית באמצעות GKE Volume Populator. מידע נוסף זמין במאמר מידע על GKE Volume Populator.

המדריך הזה מיועד למומחי אחסון שיוצרים ומקצים אחסון, ומנהלים את אבטחת הנתונים והגישה אליהם. כדי לקבל מידע נוסף על תפקידים נפוצים ועל משימות לדוגמה שאנחנו מתייחסים אליהן ב Google Cloud תוכן, אפשר לעיין במאמר תפקידים נפוצים של משתמשי GKE ומשימות.

מגבלות

• GCPDataSource המשאב המותאם אישית צריך להיות באותו מרחב שמות כמו עומס העבודה של Kubernetes. אין תמיכה בנפחים עם מקורות נתונים חוצי מרחבי שמות.
• הכלי GKE Volume Populator תומך רק בקישור של חשבונות שירות של IAM לחשבונות שירות של Kubernetes באמצעות איחוד זהויות של עומסי עבודה ל-GKE. אין תמיכה בהענקת הרשאות IAM ישירות לחשבון השירות של Kubernetes.

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את הפעולות הבאות:

• מפעילים את Parallelstore API ואת Google Kubernetes Engine API.
הפעלת ממשקי API
• אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-CLI של gcloud. אם התק��תם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.

• במאמר סקירה כללית של מנהל התקן Parallelstore CSI מפורטות המגבלות והדרישות.
• יוצרים קטגוריות ב-Cloud Storage ומאכלסים אותן בנתונים שרוצים להעביר.

דרישות

כדי להשתמש ב-GKE Volume Populator, האשכולות צריכים לעמוד בדרישות הבאות:

• משתמשים בגרסה 1.31.1-gke.1729000 של אשכול GKE ואילך.
• הפעלתם את מנהל ההתקן Parallelstore CSI. ב-GKE, מנהל התקן CSI מופעל כברירת מחדל באשכולות GKE Autopilot חדשים וקיימים. במערכות קיימות ובמערכות חדשות של אשכולות רגילים, צריך להפעיל את מנהל ההתקן של CSI.

הכנת הסביבה

בקטע הזה מוסבר איך ליצור את אשכולות GKE ולהגדיר את ההרשאות הנדרשות לשימוש ב-GKE Volume Populator.

הגדרת רשת VPC

כשיוצרים את מכונות ה-VM של Parallelstore ואת מכונות ה-VM של הלקוח ב-Compute Engine או את אשכולות GKE, צריך לציין את אותה רשת של ענן וירטואלי פרטי (VPC). כדי לאפשר חיבור פרטי של VPC ל��ירותי�� ב��י ל��שו�� את תעבורת הנתונים לאינטרנט הציבורי, צריך להגדיר גישה לשירותים פרטיים (PSA) פעם אחת, אם עדיין לא עשיתם זאת. Google Cloud

כדי להגדיר PSA, מבצעים את השלבים הבאים:

1. כדי להגדיר שיתוף פעולה בין רשתות בפרויקט, צריך להגדיר את הרשאת ה-IAM‏ Compute Network Admin (אדמין רשתות של Compute) ‏(roles/compute.networkAdmin).

   כדי להעניק את התפקיד, מריצים את הפקודה הבאה:

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

   מחליפים את EMAIL_ADDRESS בכתובת האימייל.

2. מפעילים את Service Networking:

   gcloud services enable servicenetworking.googleapis.com
   

3. יוצרים רשת VPC:

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫NETWORK_NAME: השם של רשת ה-VPC שבה תיצרו את מופע Parallelstore.
   • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .

4. יוצרים טווח כתובות IP.

   כדי להשתמש בגישה לשירותים פרטיים, צריך טווח כתובות IP (בלוק CIDR) עם אורך קידומת של /24 לפחות (256 כתובות). ‫Parallelstore שומרת 64 כתובות לכל מופע, מה שאומר שאפשר לעשות שימוש חוזר בטווח כתובות ה-IP הזה עם שירותים אחרים או מופעים אחרים של Parallelstore אם יש צורך.

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

   מחליפים את IP_RANGE_NAME בשם של טווח כתובות ה-IP של רשת ה-VPC.

5. מגדירים משתנה סביבה עם טווח ה-CIDR שמשויך לטווח שיצרתם בשלב הקודם:

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

6. יוצרים כלל חומת אש כדי לאפשר תעבורת TCP מטווח כתובות ה-IP שיצרתם:

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

   מחליפים את FIREWALL_NAME בשם של כלל חומת האש כדי לאפשר תעבורת TCP מטווח כתובות ה-IP שיצרתם.

7. מחברים את ה-peering:

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

אם נתקלתם בבעיות בהגדרת רשת ה-VPC, כדאי לעיין במדריך לפתרון בעיות ב-Parallelstore.

יצירת אשכול GKE

מומלץ להשתמש באשכול Autopilot כדי ליהנות מחוויית Kubernetes מנוהלת באופן מלא. כדי לבחור את מצב הפעולה של GKE שהכי מתאים לצורכי עומס העבודה שלכם, תוכלו לעיין במאמר בחירת מצב פעולה של 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

הגדרת ההרשאות הנדרשות

כדי להעביר נתונים מקטגוריה של Cloud Storage, צריך להגדיר הרשאות לאיחוד זהויות של עומסי עבודה ל-GKE.

1. יוצרים מרחב שמות של Kubernetes:

   kubectl create namespace NAMESPACE
   

   מחליפים את NAMESPACE במרחב השמות שבו יפעלו עומסי העבודה.

2. יוצרים חשבון שירות של Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   מחליפים את KSA_NAME בשם של חשבון השירות של Kubernetes שה-Pod משתמש בו כדי לבצע אימות ל- Google Cloud APIs.

3. יוצרים חשבון שירות ב-IAM. אפשר גם להשתמש בכל חשבון שירות קיים של IAM בכל פרויקט בארגון:

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

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫IAM_SA_NAME: השם של חשבון השירות ב-IAM.
   • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .

4. מקצים לחשבון השירות של IAM את התפקיד roles/storage.objectViewer כדי שיוכל לגשת לקטגוריה שלכם ב-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"
   

   מחליפים את GCS_BUCKET בשם הקטגוריה ב-Cloud Storage.

5. יוצרים את מדיניות ההרשאות ב-IAM שנותנת לחשבון השירות של Kubernetes גישה להתחזות לחשבון השירות של 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. מוסיפים הערה לחשבון השירות של Kubernetes כדי ש-GKE יראה את הקישור בין חשבונות השירות.

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

7. יוצרים את הזהות בשירות Parallelstore:

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

8. כדי לאפשר לזהות השירות של Parallelstore להתחזות לחשבון השירות של IAM, צריך להקצות את התפקיד roles/iam.serviceAccountTokenCreator לזהות השירות של Parallelstore. מגדירים את משתנה הסביבה PROJECT_NUMBER כדי שאפשר יהיה להשתמש בו בשלבים הבאים.

   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
   

   הערך PROJECT_NUMBER הוא המזהה הייחודי של הפרויקט שנוצר באופן אוטומטי. כדי למצוא את הערך הזה, קראו את המאמר יצירה וניהול של פרויקטים.

9. כדי לאפשר לזהות השירות של Parallelstore גישה לכל המשאבים שחשבון השירות של IAM יכול לגשת אליהם, צריך להקצות לזהות השירות של Parallelstore את התפקיד roles/iam.serviceAccountUser:

   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. כדי לאפשר לזהות של חשבון השירות ב-GKE לגשת לכל המשאבים שלחשבון השירות ב-IAM יש גישה אליהם, צריך להקצות את התפקיד roles/iam.serviceAccountUser לזהות של חשבון השירות ב-GKE. לא צריך לבצע את השלב הזה אם אשכול GKE וחשבון השירות של IAM נמצאים באותו פרויקט.

    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 עם נתונים שנטענו מראש

בקטעים הבאים מתואר התהליך הרגיל ליצירת נפח אחסון של Parallelstore עם נתונים שנטענו מראש ממאגר (bucket) של Cloud Storage, באמצעות GKE Volume Populator.

1. יוצרים משאב GCPDataSource.
2. יצירת Parallelstore StorageClass.
3. יוצרים PersistentVolumeClaim כדי לגשת לנפח האחסון.
4. (אופציונלי) צפייה בהתקדמות העברת הנתונים.
5. יוצרים עומס עבודה שצורכת את הנפח.

יצירת משאב GCPDataSource

כדי להשתמש ב-GKE Volume Populator, צריך ליצור משאב מותאם אישית מסוג GCPDataSource. המשאב הזה מגדיר את מאפייני האחסון של המקור שמשמשים לאכלוס הנפח.

1. שומרים את המניפסט הבא בקובץ בשם 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/
   

   מחליפים את ה��רכים הבאים:

   • ‫GCP_DATA_SOURCE: השם של GCPDataSource ה-CRD שמכיל הפניה לקטגוריה שלכם ב-Cloud Storage. לפרטים נוספים, אפשר לעיין במאמר בנושא GCPDataSource CRD.
   • ‫NAMESPACE: מרחב השמות שעליו יפעלו עומסי העבודה. ערך מרחב השמות צריך להיות זהה למרחב השמות של עומס העבודה.
   • ‫KSA_NAME: השם של חשבון השירות של Kubernetes שה-Pod משתמש בו כדי לבצע אימות לממשקי ה-API של Google Cloud . הערך של cloudStorage.serviceAccountName צריך להיות חשבון השירות של Kubernetes שהגדרתם עבור איחוד הזהויות של עומסי עבודה ל-GKE בשלב הגדרת ההרשאות הנדרשות.
   • ‫GCS_BUCKET: שם הקטגוריה שלכם ב-Cloud Storage. אפשר גם לציין gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ בשדה uri.

2. כדי ליצור את משאב GCPDataSource, מריצים את הפקודה הבאה:

   kubectl apply -f gcpdatasource.yaml
   

יצירת StorageClass של Parallelstore

יוצרים StorageClass כדי להנחות את מנהל ההתקן של Parallelstore CSI להקצות מופעי Parallelstore באותו אזור שבו נמצא אשכול ה-GKE. כך אפשר להבטיח ביצועים אופטימליים של קלט/פלט.

1. שומרים את קובץ המניפסט הבא בשם 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. כדי ליצור את StorageClass, מריצים את הפקודה הבאה:

   kubectl apply -f parallelstore-class.yaml
   

אם רוצים ליצור StorageClass בהתאמה אישית עם טופולוגיה ספציפית, אפשר לעיין במדריך Parallelstore CSI.

יצירת דרישת נפח אחסון מתמיד (PersistentVolumeClaim) כדי לגשת לנפח האחסון

קובץ המניפסט הבא מציג דוגמה ליצירת PersistentVolumeClaim במצב גישה ReadWriteMany שמפנה אל StorageClass שיצרתם קודם.

1. שומרים את המניפסט הבא בקובץ בשם 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
   

   מחליפים את הערכים הבאים:

   • ‫PVC_NAME: השם של PersistentVolumeClaim שאליו רוצים להעביר את הנתונים. ה-PersistentVolumeClaim צריך להיות מגובה על ידי מופע Parallelstore.
   • ‫NAMESPACE: מרחב השמות שבו יפעלו עומסי העבודה. ערך מרחב השמות צריך להיות זהה למרחב השמות של עומס העבודה.
   • ‫GCP_DATA_SOURCE: השם של GCPDataSource ה-CRD שמכיל הפניה לקטגוריה שלכם ב-Cloud Storage. פרטים נוספים זמינים במאמר בנושא GCPDataSource CRD.

2. כדי ליצור את PersistentVolumeClaim, מריצים את הפקודה הבאה:

   kubectl apply -f volume-populator-pvc.yaml
   

מערכת GKE לא תתזמן את ה-Pod של עומס העבודה עד שהקצאת PersistentVolumeClaim תושלם. כדי לבדוק את התקדמות העברת הנתונים, אפשר לעיין במאמר איך בודקים את התקדמות העברת הנתונים. אם נתקלתם בשגיאות במהלך הקצאת ההרשאות, כדאי לעיין במאמר בנושא פתרון בעיות.

(אופציונלי) צפייה בהתקדמות העברת הנתונים

בקטע הזה מוסבר איך לעקוב אחרי התקדמות העברת הנתונים מקטגוריה ב-Cloud Storage לנפח אחסון של Parallelstore. כדאי לעשות את זה כדי לעקוב אחרי סטטוס ההעברה ולוודא שהנתונים מועתקים בהצלחה. כדאי להריץ את הפקודה הזו גם אם פעולת הקישור של PersistentVolumeClaim נמשכת יותר מדי זמן.

1. מריצים את הפקודה הבאה כדי לוודא שהסטטוס של PersistentVolumeClaim הוא Bound:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. בודקים את הודעת האירועים של PersistentVolumeClaim כדי לראות את התקדמות העברת הנתונים. יומני GKE מתעדים את ההודעות בערך פעם בדקה. הפלט אמור להיראות כך:

   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
   

יכול להיות שיעבור זמן מה עד שתהליך האכלוס יתחיל, כי הוא תלוי בגודל הקובץ. אם לא רואים התקדמות בהעברת הנתונים אחרי כמה דקות, כדאי לעיין בקטע פתרון בעיות.

יצירת עומס עבודה שמשתמש בנפח האחסון

בקטע הזה מוצגת דוגמה ליצירת Pod שמשתמש במשאב PersistentVolumeClaim שיצרתם קודם.

1. שומרים את מניפסט ה-YAML הבא בשביל ה-Pod בתור 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
   

   מחליפים את הערכים הבאים:

   • ‫POD_NAME: השם של ה-Pod שמריץ את עומס העבודה.
   • ‫NAMESPACE: מרחב השמות שבו יפעלו עומסי העבודה. ערך מרחב השמות צריך להיות זהה למרחב השמות של עומס העבודה.
   • ‫PVC_NAME: השם של PersistentVolumeClaim שאליו רוצים להעביר את הנתונים. ה-PersistentVolumeClaim צריך להיות מגובה על ידי מופע Parallelstore.

2. מריצים את הפקודה הבאה כדי להחיל את המניפסט על האשכול:

   kubectl apply -f pod.yaml
   

3. בודקים את הסטטוס של ה-Pod ומחכים עד שהסטטוס שלו יהיה RUNNING. לפני הפעלת עומס העבודה, צריך לבצע binding של PersistentVolumeClaim.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. מוודאים שהקבצים הועברו בהצלחה ושיש לכם גישה אליהם בעומס העבודה.

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

   עוברים לספרייה /mnt/data ומריצים את הפקודה ls:

   cd /mnt/data
   ls
   

   הפלט צריך לכלול רשימה של כל הקבצים שקיימים ב-URI של הקטגוריה ב-Cloud Storage.

מחיקת PersistentVolumeClaim במהלך הקצאה דינמית

אם אתם צריכים למחוק את PersistentVolumeClaim בזמן שהנתונים עדיין מועברים במהלך הקצאה דינמית, יש לכם שתי אפשרויות: מחיקה הדרגתית ומחיקה בכוח.

מחיקה הדרגתית דורשת פחות מאמץ, אבל היא עלולה לקחת יותר זמן ולא להתחשב בטעות בהגדרות של המשתמש שמונעת את השלמת העברת הנתונים. מחיקה בכפייה היא חלופה מהירה יותר שמאפשרת גמישות ושליטה רבות יותר. האפשרות הזו מתאימה כשצריך להפעיל מחדש במהירות או לתקן הגדרות שגויות.

פתרון בעיות

בקטע הזה מוסבר איך לפתור בעיות שקשורות ל-GKE Volume Populator.

לפני שממשיכים, מריצים את הפקודה הבאה כדי לבדוק אם יש אזהרות לגבי אירועים של PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

שגיאה: An internal error has occurred

אם אתם נתקלים בשגיאה הבאה, המשמעות היא שקרתה שגיאה פנימית ב-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")

כדי לפתור את הבעיה, צריך לבצע את השלבים הבאים כדי לאסוף נתונים לתמיכה:

1. מריצים את הפקודות הבאות כדי לקבל את השם של PersistentVolumeClaim הזמני, אחרי שמחליפים את ה-placeholders בשמות בפועל:

   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. מריצים את הפקודה הבאה כדי לקבל את שם אמצעי האחסון:

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

3. פונים לצוות התמיכה עם הודעת השגיאה, שם הפרויקט ושם האחסון.

בעיות בהרשאות

אם נתקלים בשגיאות כמו השגיאות הבאות במהלך מילוי הנפח, המשמעות היא ש-GKE נתקל בבעיית הרשאות:

• קטגוריה של Cloud Storage לא קיימת: PopulateOperationStartError עם code = PermissionDenied
• חסרות הרשאות בקטגוריה של Cloud Storage או בחשבונות השירות: PopulateOperationFailed עם "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• חשבון השירות לא נמצא: PopulateOperationStartError עם code = Unauthenticated.

כדי לפתור את השגיאות האלה, צריך לבדוק היטב את הפרטים הבאים:

• גישה לקטגוריה של Cloud Storage: צריך לוודא שהקטגוריה קיימת ולחשבון השירות יש את ההרשאה roles/storage.objectViewer permission.
• חשבונות שירות: מוודאים שחשבון השירות של Kubernetes וחשבון השירות של IAM קיימים ומקושרים בצורה נכונה.
• חשבון השירות של Parallelstore: מוודאים שחשבון השירות של Parallelstore קיים ושיש לו את ההרשאות הנדרשות (roles/iam.serviceAccountTokenCreator ו-roles/iam.serviceAccountUser בחשבון IAM).

הוראות מפורטות ופקודות אימות מופיעות במאמר הגדרת ההרשאות הנדרשות. אם השגיאות נמשכות, פנו לתמיכה וציינו את הודעת השגיאה, שם הפרויקט ושם הקטגוריה של Cloud Storage.

שגיאות של ארגומנט לא תקין

אם נתקלתם בשגיאות InvalidArgument, סביר להניח שסיפקתם ערכים שגויים במשאב GCPDataSource או ב-PersistentVolumeClaim. יומן השגיאות יציין את השדות המדויקים שמכילים את הנתונים הלא תקינים. בודקים את ה-URI של קטגוריית Cloud Storage ואת השדות הרלוונטיים האחרים כדי לוודא שהם מדויקים.

אימות ההקצאה של PersistentVolumeClaim

הכלי GKE Volume Populator משתמש ב-PersistentVolumeClaim זמני במרחב השמות gke-managed-volumepopulator כדי להקצות נפח אחסון.

ה-PersistentVolumeClaim הזמני הוא בעצם תמונת מצב של ה-PersistentVolumeClaim שלכם, שנמצא עדיין בהעברה (ממתין לטעינה מלאה של הנתונים). השם שלו הוא בפורמט prime-YOUR_PVC_UID.

כדי לבדוק את הסטטוס:

1. מריצים את הפקודות הבאות:

   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
   

   אם הפלט ריק, המשמעות היא שלא נוצר PersistentVolumeClaim זמני. מריצים את הפקודה הבאה כדי לבדוק אם יש אזהרות לגבי אירועים של PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   אם ההקצאה מצליחה, הפלט דומה לזה שמופיע בהמשך. מחפשים את היומן 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. בודקים אם התחילה יצירה של מופע Parallelstore.

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

   הפלט אמור להיראות כך: מוודאים שעוצמת הקול במצב CREATING. כשסיימתם ליצור את מופע Parallelstore, המצב ישתנה ל-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
   

אם ההקצאה נכשלת, אפשר לעיין במדריך לפתרון בעיות ב-Parallelstore לקבלת הנחיות נוספות.

המאמרים הבאים

• מידע על GKE Volume Populator
• לעיון במסמכי העזרה בנושא Parallelstore CSI
• איך משתמשים בספריית היירוט Parallelstore כדי לשפר את הביצועים של עומסי עבודה
• כדאי לנסות את המדריך לאימון מודל TensorFlow באמצעות Keras ב-GKE.