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

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

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

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

דרישות

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

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

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

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

מגבלות

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

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

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

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

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

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

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

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

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

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

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

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

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

1. יוצרים אובייקט VolumeSnapshotClass כדי לציין את מנהל ההתקן של CSI ואת מדיניות המחיקה של התמונה.
2. יוצרים אובייקט VolumeSnapshot כדי לבקש קובץ snapshot של 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 ועם קובץ ה-snapshot הבסיסי כשמוחקים את האובייקט המקושר VolumeSnapshot. מציינים את Delete כדי למחוק את האובייקט VolumeSnapshotContent ואת קובץ ה-snapshot הבסיסי. צריך לציין את Retain אם רוצים לשמור את VolumeSnapshotContent ואת קובץ ה-snapshot הבסיסי.

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
   

   אחרי שיוצרים קובץ snapshot של 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'

אם קובץ ה-snapshot מוכן לשימוש, הפלט דומה לפלט הבא:

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
   

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 עם תמונת מצב שלCloud de Confiance משאב אחר שנוצר באשכול אחר.

1. מאתרים את שם קובץ ה-snapshot.

   מסוף Cloud de Confiance

   כניסה לדף 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 במזהה הפרויקט ובשם של קובץ ה-snapshot. כדי שהקישור הדו-כיווני יהיה תקף, גם 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'
    

הסרת המשאבים

כדי לא לצבור חיובים בחשבון Cloud de Confiance by S3NS על המשאבים שבהם השתמשתם בדף הזה, מבצעים את הפעולות הבאות.

1. מחיקת VolumeSnapshot:

   kubectl delete volumesnapshot my-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.