גיבוי ושחזור של אחסון מתמיד באשכולות GKE

בדף הזה מוסבר איך לגבות ולשחזר את האחסון הבסיסי של Filestore שמשויך לאשכולות GKE באמצעות תמונות מצב של נפח Kubernetes.

יצירה של תמונת מצב של נפח אחסון ב-Kubernetes שקולה ליצירה של גיבוי של Filestore.

מידע נוסף זמין במאמר בנושא תמונות מצב של נפחים ב-Kubernetes.

דרישות

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

• צריך לפרוס את Filestore CSI driver. יש תמיכה רק במסלולי השירות הבאים של Filestore:

רמת שירות	סוג השיתוף	הגרסה המינימלית של GKE ל-NFSv3	הגרסה המינימלית של GKE ל-NFSv4.1
Enterprise	שיתוף יחיד, שיתוף מרובה	1.25	‫1.33 (מניה אחת בלבד)
אזורי (‎1 TiB – 9.75 TiB)	שיתוף יחיד	1.27	‫1.33
אזורי (‎10 TiB - 100 TiB)	שיתוף יחיד	1.27	‫1.33
אזורי (‎1 TiB - 100 TiB)	שיתוף יחיד	1.33.4-gke.1172000	1.33.4-gke.1172000
כונן HDD בסיסי (‎100 GiB – 63.9 TiB)^*	שיתוף יחיד	‫1.33	לא נתמך
HDD בסיסי	שיתוף יחיד	1.21	לא נתמך
SSD בסיסי	שיתוף יחיד	1.21	לא נתמך

‫^* בהתאם לגישה לתכונה של מכונות בקיבולת קטנה, טווח הקיבולת הנמוך של מכונות אזוריות ב-Filestore יכול להיות ‎100 GiB עד ‎10,239 GiB או ‎1 TiB עד ‎9.75 TiB. מידע נוסף זמין במאמר בנושא איך יוצרים אירועים קטנים של Filestore.

• להשתמש בגרסאות של מישור הבקרה 1.17 ואילך. כדי להשתמש במנהל התקן ה-CSI של Filestore ב-VolumeSnapshot, צריך להשתמש במספר הגרסה של GKE שרלוונטי לרמת השירות שלכם.

• יש לכם PersistentVolumeClaim קיים שבו אתם רוצים להשתמש לצילום תמונה. ה-PersistentVolume שמשמש כמקור לתמונת מצב צריך להיות מנוהל על ידי מנהל התקן CSI. כדי לוודא שאתם משתמשים בדרייבר CSI, בודקים שלמפרט PersistentVolume יש קטע csi עם driver: pd.csi.storage.gke.io או filestore.csi.storage.gke.io. אם PersistentVolume מוקצה באופן דינמי על ידי מנהל התקן CSI, כפי שמתואר בקטעים הבאים, הוא מנוהל על ידי מנהל התקן CSI.

מגבלות

• לנפחי אחסון של תמונת מצב יש את אותן הגבלות גודל כמו לנפחי אחסון רגילים. לדוגמה, גודל התמונות של Filestore צריך להיות 1 TiB או יותר ברמת ה-HDD הבסיסית.

• מנהל ההתקן של Filestore CSI לא תומך בהקצאה דינמית או בתהליכי עבודה של גיבויים עבור רמת השירות האזורית של Filestore:

  • אפשר לגבות רק שיתוף אחד בכל פעם. המשמעות היא שאי אפשר ליצור גיבוי עם כמה שיתופים או לשחזר גיבוי למופע עם כמה שיתופים. עם זאת, בקשות גיבוי משני שיתופים שונים בשני מופעים שונים של Filestore יפעלו בו-זמנית.

  • אפשר לשחזר גיבוי של מופע בסיסי למופע המקור באותה רמת שירות, למופע שכבר קיים או למופע חדש. אם בוחרים מופע חדש, אפשר לבחור בין מופע HDD בסיסי לבין מופע SSD בסיסי, בלי קשר לרמת המופע של המקור.

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

  רשימה מלאה של מגבלות על התכונות זמינה במאמר מגבלות על התכונות של Filestore Backup.

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

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

• מפעילים את ממשק Google Kubernetes Engine API.
הפעלת Google Kubernetes Engine API
• אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
  הערה: אם כבר התקנתם את ה-CLI של gcloud, הקפידו להגדיר את compute/region המאפיין. אם אתם משתמשים בעיקר באשכולות אזוריים, עליכם להגדיר את compute/zone במקום זאת. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו השגיאה הבאה: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

יצירה של snapshot של נפח ושימוש בו

בדוגמאות במאמר הזה מוסבר איך לבצע את המשימות הבאות:

1. יצירת PersistentVolumeClaim וDeployment.
2. מוסיפים קובץ ל-PersistentVolume שבו משתמש Deployment.
3. יוצרים VolumeSnapshotClass כדי להגדיר את ה-snapshot.
4. יצירת קובץ snapshot של עוצמת הקול של PersistentVolume.
5. מוחקים את קובץ הבדיקה.
6. משחזרים את PersistentVolume לקובץ ה-snapshot שיצרתם.
7. איך מוודאים שהשחזור פעל

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

1. יוצרים אובייקט VolumeSnapshotClass כדי לציין את מנהל ההתקן של CSI ואת מדיניות המחיקה של התמונה.
2. יוצרים אובייקט VolumeSnapshot כדי לבקש תמונת מצב של PersistentVolumeClaim קיים.
3. אפשר להפנות אל VolumeSnapshot בPersistentVolumeClaim כדי לשחזר נפח לאותו snapshot או ליצור נפח חדש באמצעות ה-snapshot.

יצירת PersistentVolumeClaim וDeployment

1. כדי ליצור את האובייקט PersistentVolumeClaim, שומרים את המניפסט הבא בתור my-pvc.yaml:

   Filestore

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-pvc
    spec:
      storageClassName: enterprise-rwx
      accessModes:
      - ReadWriteMany
      resources:
        requests:
          storage: 1Ti
   

   בדוגמה הזו נוצר PVC של Filestore ברמת Enterprise. מידע נוסף זמין במאמר בנושא גישה למופעי Filestore באמצעות מנהל התקנים של Filestore CSI.

   במאפיין spec.storageClassName, אפשר לציין כל סוג אחסון שמשתמש במנהל התקן CSI נתמך.

2. החלת המניפסט:

   kubectl apply -f my-pvc.yaml
   

3. כדי ליצור Deployment, שומרים את קובץ המניפסט הבא בשם my-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: hello-app
   spec:
     selector:
       matchLabels:
         app: hello-app
     template:
       metadata:
         labels:
           app: hello-app
       spec:
         containers:
         - name: hello-app
           image: google/cloud-sdk:slim
           args: [ "sleep", "3600" ]
           volumeMounts:
           - name: sdk-volume
             mountPath: /usr/share/hello/
         volumes:
         - name: sdk-volume
           persistentVolumeClaim:
             claimName: my-pvc
   

4. החלת המניפסט:

   kubectl apply -f my-deployment.yaml
   

5. בודקים את הסטטוס של Deployment:

   kubectl get deployment hello-app
   

   יכול להיות שיעבור קצת זמן עד שDeployment יהיה מוכן. אפשר להריץ את הפקודה הקודמת עד שיוצג פלט שדומה לזה:

   NAME        READY   UP-TO-DATE   AVAILABLE   AGE
   hello-app   1/1     1            1           2m55s
   

הוספת קובץ בדיקה לנפח האחסון

1. תכין רשימה של Pods בDeployment:

   kubectl get pods -l app=hello-app
   

   הפלט אמור להיראות כך:

   NAME                         READY   STATUS    RESTARTS   AGE
   hello-app-6d7b457c7d-vl4jr   1/1     Running   0          2m56s
   

2. יוצרים קובץ בדיקה ב-Pod:

   kubectl exec POD_NAME \
       -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'
   

   מחליפים את POD_NAME בשם של Pod.

3. מוודאים שהקובץ קיים:

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   הפלט אמור להיראות כך:

   Hello World!
   

יצירת אובייקט VolumeSnapshotClass

יוצרים אובייקט VolumeSnapshotClass כדי לציין את מנהל ההתקן של CSI ואת deletionPolicy עבור קובץ ה-snapshot של עוצמת הקול. אפשר להפנות לאובייקטים של VolumeSnapshotClass כשיוצרים אובייקטים של VolumeSnapshot.

1. שומרים את קובץ המניפסט הבא בשם volumesnapshotclass.yaml.

   Filestore

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: my-snapshotclass
   driver: filestore.csi.storage.gke.io
   parameters:
     type: backup
   deletionPolicy: Delete
   

   בדוגמה הזו:

   • השדה driver משמש את מנהל ההתקן של CSI להקצאת תמונת המצב. בדוגמה הזו, filestore.csi.storage.gke.io משתמש במנהל התקן ה-CSI של Filestore.
   • השדהdeletionPolicy אומר ל-GKE מה לעשות עם האובייקט VolumeSnapshotContent ועם התמונה הבסיסית של מצב המערכת כשמוחקים את האובייקט VolumeSnapshot שמשויך אליו. מציינים Delete כדי למחוק את האובייקט VolumeSnapshotContent ואת התמונה המיידית הבסיסית. מציינים Retain אם רוצים לשמור את VolumeSnapshotContent ואת הצילום מהמצלמה שמתחתיו.

2. החלת המניפסט:

   kubectl apply -f volumesnapshotclass.yaml
   

יצירת VolumeSnapshot

אובייקט VolumeSnapshot הוא בקשה לצילום מצב של אובייקט PersistentVolumeClaim קיים. כשיוצרים אובייקט VolumeSnapshot,‏ GKE יוצר אותו באופן אוטומטי ומקשר אותו לאובייקט VolumeSnapshotContent, שהוא משאב באשכול כמו אובייקט PersistentVolume.

1. שומרים את קובץ המניפסט הבא בשם volumesnapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: my-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       persistentVolumeClaimName: my-pvc
   

2. החלת המניפסט:

   kubectl apply -f volumesnapshot.yaml
   

   אחרי שיוצרים Volume תמונת מצב, GKE יוצר אובייקט VolumeSnapshotContent תואם באשכול. האובייקט הזה מאחסן את התמונה ואת הקישורים של אובייקטים מסוג VolumeSnapshot. אין אינטראקציה ישירה עם אובייקטים של VolumeSnapshotContents.

3. בודקים ש-GKE יצר את האובייקט VolumeSnapshotContents:

   kubectl get volumesnapshotcontents
   

   הפלט אמור להיראות כך:

   NAME                                               AGE
   snapcontent-cee5fb1f-5427-11ea-a53c-42010a1000da   55s
   

אחרי שנוצר תוכן התמונה של Volume, מנהל ההתקן של CSI שצוין ב-VolumeSnapshotClass יוצר תמונה במערכת האחסון המתאימה. אחרי ש-GKE יוצר תמונת מצב במערכת האחסון ומקשר אותה לאובייקט VolumeSnapshot באשכול, תמונת המצב מוכנה לשימוש. כדי לבדוק את הסטטוס, מריצים את הפקודה הבאה:

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

אם תמונת המצב מוכנה לשימוש, הפלט ייראה כך:

NAME               READY
my-snapshot        true

מחיקת קובץ הבדיקה

1. מוחקים את קובץ הבדיקה שיצרתם:

   kubectl exec POD_NAME \
       -- sh -c 'rm /usr/share/hello/hello.txt'
   

2. מוודאים שהקובץ כבר לא קיים:

   kubectl exec POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'
   

   הפלט אמור להיראות כך:

   cat: /usr/share/hello/hello.txt: No such file or directory
   

שחזור תמונת המצב של עוצמת הקול

1. שומרים את קובץ המניפסט הבא בשם pvc-restore.yaml:

   Filestore

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: pvc-restore
   spec:
     dataSource:
       name: my-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: enterprise-rwx
     accessModes:
     - ReadWriteMany
     resources:
       requests:
         storage: 1Ti
   

   הערה: מרחב השמות של PersistentVolumeClaim חייב להיות זהה למרחב השמות של VolumeSnapshot.

2. החלת המניפסט:

   kubectl apply -f pvc-restore.yaml
   

3. מעדכנים את הקובץ my-deployment.yaml כדי להשתמש בPersistentVolumeClaim החדש:

   ...
   volumes:
   - name: my-volume
     persistentVolumeClaim:
       claimName: pvc-restore
   

4. החלת המניפסט המעודכן:

   kubectl apply -f my-deployment.yaml
   

בודקים שהתמונה שוחזרה בהצלחה

1. מקבלים את השם של Pod החדש שנוצר על ידי GKE עבור Deployment המעודכן:

    kubectl get pods -l app=hello-app
   

מוודאים שקובץ הבדיקה קיים:

   kubectl exec NEW_POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'

מחליפים את NEW_POD_NAME בשם של Pod החדש שנוצר על ידי GKE.

הפלט אמור להיראות כך:

   Hello World!

ייבוא תמונת מצב קיימת

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

1. מאתרים את השם של התמונה.

   מסוף Google Cloud

   כניסה לדף Snapshots

   Google Cloud CLI

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

   gcloud compute snapshots list
   

   הפלט אמור להיראות כך:

   NAME                                           DISK_SIZE_GB  SRC_DISK                                                     STATUS
   snapshot-5e6af474-cbcc-49ed-b53f-32262959a0a0  1             us-central1-b/disks/pvc-69f80fca-bb06-4519-9e7d-b26f45c1f4aa READY
   

2. שומרים את קובץ המניפסט VolumeSnapshot הבא בשם restored-snapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: restored-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       volumeSnapshotContentName: restored-snapshot-content
   

3. החלת המניפסט:

   kubectl apply -f restored-snapshot.yaml
   

4. שומרים את קובץ המניפסט VolumeSnapshotContent בשם restored-snapshot-content.yaml. מחליפים את השדה snapshotHandle במזהה הפרויקט ובשם התמונה. כדי שהקישור הדו-כיווני יהיה תקף, גם volumeSnapshotRef.name וגם volumeSnapshotRef.namespace צריכים להצביע על VolumeSnapshot שנוצר קודם.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotContent
   metadata:
     name: restored-snapshot-content
   spec:
     deletionPolicy: Retain
     driver: filestore.csi.storage.gke.io
     source:
       snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
     volumeSnapshotRef:
       kind: VolumeSnapshot
       name: restored-snapshot
       namespace: default
   

5. החלת המניפסט:

   kubectl apply -f restored-snapshot-content.yaml
   

6. שומרים את קובץ המניפסט PersistentVolumeClaim הבא בשם restored-pvc.yaml. בקר האחסון של Kubernetes יחפש VolumeSnapshot בשם restored-snapshot ואז ינסה למצוא או ליצור באופן דינמי PersistentVolume כמקור הנתונים. אחר כך תוכלו להשתמש ב-PVC הזה ב-Pod כדי לגשת לנתונים המשוחזרים.

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: restored-pvc
   spec:
     dataSource:
       name: restored-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: enterprise-rwx
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: 1Gi
   

7. החלת המניפסט:

   kubectl apply -f restored-pvc.yaml
   

8. שומרים את קובץ המניפסט הבא Pod בתור restored-pod.yaml בהתאם לPersistentVolumeClaim. מנהל ההתקן של CSI יקצה PersistentVolume ויאכלס אותו מתוך תמונת המצב.

   apiVersion: v1
   kind: Pod
   metadata:
     name: restored-pod
   spec:
     containers:
     - name: busybox
       image: busybox
       args:
       - sleep
       - "3600"
       volumeMounts:
       - name: source-data
         mountPath: /demo/data
     volumes:
     - name: source-data
       persistentVolumeClaim:
         claimName: restored-pvc
         readOnly: false
   

9. החלת המניפסט:

   kubectl apply -f restored-pod.yaml
   

10. מוודאים שהקובץ שוחזר:

    kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'
    

הסרת המשאבים

כדי לא לצבור חיובים בחשבון Google Cloud על המשאבים שבהם השתמשתם בדף הזה:

1. מחיקת VolumeSnapshot:

   kubectl delete volumesnapshot my-snapshot
   

   הערה: אם הערך של VolumeSnapshotClass בתמונת מצב של נפח הוא deletionPolicy:Delete, גם VolumeSnapshotContent המתאים ותמונת המצב הפיזית במערכת האחסון נמחקים. אם יש לו deletionPolicy:Retain, GKE שומר את קובץ ה-snapshot הבסיסי.

2. מחיקת VolumeSnapshotClass:

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. מחיקת Deployment:

   kubectl delete deployments hello-app
   

4. מוחקים את האובייקטים PersistentVolumeClaim:

   kubectl delete pvc my-pvc pvc-restore
   

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

• קוראים את התיעוד בנושא Kubernetes Volume Snapshot.
• מידע נוסף על הרחבת נפח
• איך מתקינים ידנית דרייבר CSI
• מידע על Filestore כאפשרות לאחסון קבצים ב-GKE.