גיבוי של אחסון Persistent Disk באמצעות תמונות מצב של נפח

בדף הזה מוסבר איך לגבות ולשחזר אחסון של Persistent Disk באמצעות תמונות מצב של נפחים.

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

דרישות

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

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

מגבלות

כל ההגבלות על יצירת תמונת מצב של דיסק ב-Compute Engine חלות גם על GKE.

שיטות מומלצות

חשוב לפעול לפי השיטות המומלצות ליצירת תמונות מצב של דיסקים ב-Compute Engine כשמשתמשים בתמונות מצב של דיסקים לאחסון מתמיד Volume ב-GKE.

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

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

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

יצירה של 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:

    Persistent Disk 

     apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: standard-rwo
   accessModes:
   - ReadWriteOnce
   resources:
     requests:
       storage: 1Gi

    בדוגמה הזו נעשה שימוש בסוג האחסון standard-rwo שמותקן כברירת מחדל עם מנהל התקן ה-CSI של דיסק מתמשך ב-Compute Engine. למידע נוסף, ראו שימוש ב-Compute Engine Persistent Disk CSI driver.

    במאפיין 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.

    Persistent Disk

    משתמשים בגרסת v1 API עבור אשכולות שפועלות בהם גרסאות 1.21 ואילך.

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

    בדוגמה הזו:

    • שדה driver משמש את מנהל ההתקן של CSI להקצאת תמונת המצב. בדוגמה הזו, pd.csi.storage.gke.io משתמש במנהל ההתקן של ה-CSI של דיסק מתמשך ב-Compute Engine.

    • השדהdeletionPolicy אומר ל-GKE מה לעשות עם האובייקט VolumeSnapshotContent ועם התמונה הבסיסית כשמוחקים את האובייקט VolumeSnapshot המצורף. מציינים Delete כדי למחוק את האובייקט VolumeSnapshotContent ואת התמונה המיידית הבסיסית. מציינים Retain אם רוצים לשמור את VolumeSnapshotContent ואת הצילום מהמצלמה שמתחתיו.

      כדי להשתמש במיקום אחסון מותאם אישית, צריך להוסיף פרמטר storage-locations למחלקת הצילום. כדי להשתמש בפרמטר הזה, האשכולות צריכים להיות בגרסה 1.21 ואילך.

      apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
parameters:
  storage-locations: us-east2
driver: pd.csi.storage.gke.io
deletionPolicy: Delete

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

      parameters:
  snapshot-type: images
  image-family: IMAGE_FAMILY

      מחליפים את IMAGE_FAMILY בשם של משפחת האימג' המועדפת, כמו preloaded-data.

  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

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

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

כדי להפנות אל VolumeSnapshot בתוך PersistentVolumeClaim, מוסיפים את השדה dataSource אל PersistentVolumeClaim. אותו תהליך משמש בין אם VolumeSnapshotContents מתייחס לתמונת דיסק או לתמונת מצב.

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

  1. בודקים אם אתם משתמשים ב-snapshot של דיסק או של תמונה, שההבדלים ביניהם הם:

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

    פרטים נוספים זמינים במאמר בנושא מגבלות על תדירות יצירת תמונות מצב. הידיעה מהו סוג הצילום עוזרת לפתור בעיות.

    בודקים את VolumeSnapshot:

    kubectl describe volumesnapshot SNAPSHOT_NAME

    השדה volumeSnapshotClassName מציין את סוג הצילום.

    kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME

    הפרמטר snapshot-type יציין snapshots או images. אם לא מציינים ערך, ברירת המחדל היא snapshots.

    אם אין מחלקה של תמונת מצב (לדוגמה, אם תמונת המצב נוצרה באופן סטטי), צריך לבדוק את VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME הפורמט של נקודת האחיזה של ה-snapshot בפלט מציין את סוג ה-snapshot, באופן הבא: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: snapshot של דיסק

    • projects/PROJECT_NAME/global/images/IMAGE_NAME: תמונת מצב של תמונה

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

    Persistent Disk 

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: standard-rwo
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

  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. מאתרים את השם של התמונה.

    מסוף 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 במזהה הפרויקט ובשם התמונה. כדי שהקישור הדו-כיווני יהיה תקף, גם volumeSnapshotRef.name וגם volumeSnapshotRef.namespace צריכים להצביע על VolumeSnapshot שנוצר קודם.

    apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotContent
metadata:
  name: restored-snapshot-content
spec:
  deletionPolicy: Retain
  driver: pd.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: standard-rwo
  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

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