גיבוי ושחזור של אשכול משתמשים

במאמר הזה מוסבר איך לגבות ולשחזר את מאגר ה-etcd של אשכול משתמש שנוצר באמצעות Google Distributed Cloud (תוכנה בלבד) ל-VMware. בדף הזה יש גם סקריפט שבעזרתו אפשר לגבות באופן אוטומטי את מאגר ה-etcd של האשכול.

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

מגבלות

  • התהליך הזה לא מגבה נתונים ספציפיים לאפליקציה.

  • התהליך הזה לא מגבה את ה-PersistentVolumes.

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

  • אי אפשר לשחזר אשכול אחרי שדרוג שנכשל.

  • התהליך הזה לא מיועד לשחזור של אשכול שנמחק.

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

למידע נוסף על המגבלות, ראו חוסר תאימות לתשתית.

גיבוי אשכול משתמשים

גיבוי של אשכול משתמשים הוא תמונת מצב של מאגר ה-etcd של אשכול המשתמשים. מאגר ה-etcd מכיל את כל האובייקטים של Kubernetes והאובייקטים בהתאמה אישית שנדרשים לניהול המצב של האשכול. התמונה מכילה את הנתונים שנדרשים כדי ליצור מחדש את הרכיבים ואת עומסי העבודה של האשכול.

שלבי הגיבוי שתבצעו תלויים בשאלה אם Controlplane V2 מופעל באשכול המשתמש. כשהתכונה Controlplane V2 מופעלת, מישור הבקרה של אשכול המשתמש פועל באשכול המשתמש עצמו. כש-Controlplane V2 לא מופעל, מישור הבקרה של אשכול המשתמש פועל בצומת אחד או יותר באשכול האדמין, שנקרא kubeception.

מריצים את הפקודה הבאה כדי לבדוק אם Controlplane V2 מופעל באשכול:

kubectl get onpremuserclusters --kubeconfig USER_CLUSTER_KUBECONFIG \
  -n kube-system -o jsonpath='{.items[0].spec.enableControlplaneV2}' && echo

אם הפלט הוא true, פועלים לפי השלבים של Controlplane V2 כדי לגבות את האשכול. אם לא, פועלים לפי השלבים של Kubeception.

Kubeception

  1. פותחים מעטפת בקונטיינר kube-etcd:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec -it \
     kube-etcd-0 -c kube-etcd -n USER_CLUSTER_NAME \
     -- /bin/sh
    

    כאשר:

    • ‫ADMIN_CLUSTER_KUBECONFIG הוא קובץ ה-kubeconfig של אשכול האדמין.
    • ‫USER_CLUSTER_NAME הוא השם של אשכול המשתמשים.
  2. במעטפת, בספרייה /tmp, יוצרים גיבוי בשם snapshot.db:

    ETCDCTL_API=3 etcdctl \
      --endpoints=https://127.0.0.1:2379 \
      --cacert=/etcd.local.config/certificates/etcdCA.crt \
      --cert=/etcd.local.config/certificates/etcd.crt \
      --key=/etcd.local.config/certificates/etcd.key \
      snapshot save /tmp/snapshot.db
    
  3. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  4. מעתיקים את /tmp/snapshot.db מהמאגר kube-etcd לספרייה הנוכחית:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp \
      USER_CLUSTER_NAME/kube-etcd-0:/tmp/snapshot.db \
      --container kube-etcd snapshot.db
    

Controlplane V2

  1. משיגים את השם של ה-Pod של etcd:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get pods \
     -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[*].metadata.name}{"\n"}'
    

    כאשר:

    • ‫USER_CLUSTER_KUBECONFIG הוא קובץ ה-kubeconfig של אשכול המשתמש.

    דוגמה:

    NAME          READY   STATUS    RESTARTS   AGE
    etcd-uc1-cp1  1/1     Running   0          38m
    etcd-uc1-cp2  1/1     Running   0          37m
    etcd-uc1-cp3  1/1     Running   0          38m
    

    שימו לב שיכולים להיות כמה פודים של etcd, לדוגמה, 3 לאשכולות HA. לגיבוי, כל יחידת etcd אמורה לעבוד.

  2. פותחים מעטפת בקונטיינר etcd:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG exec -it \
     POD_NAME -c etcd -n kube-system -- /bin/sh
    
    

    כאשר:

    • ‫POD_NAME הוא השם של pod ה-etcd מהשלב הקודם.
  3. במעטפת, יוצרים קובץ גיבוי בשם snapshot.db:

    ETCDCTL_API=3 etcdctl \
      --endpoints=https://127.0.0.1:2379 \
      --cacert=/etc/kubernetes/pki/etcd/ca.crt \
      --cert=/etc/kubernetes/pki/etcd/server.crt \
      --key=/etc/kubernetes/pki/etcd/server.key \
      snapshot save /tmp/snapshot.db
    
  4. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  5. מעתיקים את snapshot.db מהמאגר etcd לספריית הבית של תחנת העבודה:

    kubectl --kubeconfig USER_CLUSTER_KUBECONFIG \
     cp POD_NAME:/tmp/snapshot.db ~/snapshot.db \
     -c etcd -n kube-system
    
  6. מעתיקים את הסודות מספריית ה-PKI:

    ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
    sudo chmod -R 0644 /etc/kubernetes/pki/*
    sudo chmod 0755 /etc/kubernetes/pki/etcd
    exit
    scp -ri NODE_NAME.key ubuntu@NODE_EXTERNAL_IP:/etc/kubernetes/pki ~/pki_NODE_NAME
    

    כאשר:

    • ‫NODE_NAME הוא הקובץ שמכיל את מפתח ה-SSH של צומת מישור הבקרה
    • ‫NODE_EXTERNAL_IP היא כתובת ה-IP של צומת מישור הבקרה של המשתמש שממנו רוצים להעתיק את הסודות.

שחזור אשכול משתמש מגיבוי (ללא זמינות גבוהה)

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

בהוראות הבאות מוסבר איך להשתמש בקובץ גיבוי כדי לשחזר אשכול משתמש במקרים שבהם נתוני ה-etcd של האשכול נפגמו, וה-Pod של ה-etcd של אשכול המשתמש נמצא ב-crashlooping.

Kubeception

כדי לשחזר את נתוני ה-etcd, אתם יכולים לפרוס Pod של כלי שמשכתב את הנתונים הפגומים באמצעות הגיבוי. שרת ה-API של אשכול האדמין חייב לפעול, והמתזמן של אשכול האדמין חייב להיות מסוגל לתזמן Pods חדשים.

  1. מאתרים את שם הסוד שמשמש את etcd באשכול המשתמש:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG -n USER_CLUSTER_NAME \
       get secrets | grep kube-etcd-certs
    
  2. מעתיקים את מניפסט ה-Pod הבא לקובץ בשם etcd-utility.yaml. מחליפים את הערכים בשדות הבאים:

    • ‫NODE_NAME: הצומת שבו פועל ה-Pod של kube-etcd-0.

    • ‫ADMIN_CLUSTER_KUBECONFIG: קובץ ה-kubeconfig של אשכול האדמין.

    • ‫USER_CLUSTER_NAME: שם אשכול המשתמש.

    • ‫GKE_ON_PREM_VERSION: גרסת האשכול שבו רוצים לבצע את השחזור של etcd (לדוגמה, ‎1.5.0-gke.0).

    • ‫KUBE_ETCD_SECRET_NAME: השם של הסוד שמשמש את etcd באשכול המשתמש, שמתחיל ב-kube-etcd-certs.

    apiVersion: v1
    kind: Pod
    metadata:
     name: etcd-utility-0
     namespace: USER_CLUSTER_NAME
    spec:
     containers:
     - command: ["/bin/sh"]
       args: ["-ec", "while :; do echo '.'; sleep 5 ; done"]
       image: gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION
       name: etcd-utility
       volumeMounts:
       - mountPath: /var/lib/etcd
         name: data
       - mountPath: /etcd.local.config/certificates
         name: etcd-certs
     nodeSelector:
       kubernetes.googleapis.com/cluster-name: USER_CLUSTER_NAME
       kubernetes.io/hostname: NODE_NAME
     tolerations:
     - effect: NoExecute
       key: node.kubernetes.io/not-ready
       operator: Exists
       tolerationSeconds: 300
     - effect: NoExecute
       key: node.kubernetes.io/unreachable
       operator: Exists
       tolerationSeconds: 300
     - effect: NoSchedule
       key: node.kubernetes.io/unschedulable
       operator: Exists
     volumes:
     - name: data
       persistentVolumeClaim:
         claimName: data-kube-etcd-0
     - name: etcd-certs
       secret:
         defaultMode: 420
         secretName: KUBE_ETCD_SECRET_NAME
    
  3. פורסים את ה-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
      create -f etcd-utility.yaml --namespace USER_CLUSTER_NAME
    
  4. מעתיקים את snapshot.db מהספרייה הנוכחית לתיקיית השורש של ה-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG cp snapshot.db \
      USER_CLUSTER_NAME/etcd-utility-0:snapshot.db --container etcd-utility
    
  5. פותחים מעטפת בקונטיינר etcd-utility:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG exec it \
      etcd-utility-0 --container etcd-utility --namespace USER_CLUSTER_NAME \
      -- bin/sh
    
  6. במעטפת, בתיקיית השורש, מריצים את הפקודה הבאה כדי ליצור תיקייה חדשה שמכילה את הגיבוי:

    ETCDCTL_API=3 etcdctl \
      --endpoints=https://127.0.0.1:2379 \
      --cacert=/etcd.local.config/certificates/etcdCA.crt \
      --cert=/etcd.local.config/certificates/etcd.crt \
      --key=/etcd.local.config/certificates/etcd.key \
      snapshot restore snapshot.db
    
  7. במעטפת, מוחקים את נתוני ה-etcd הישנים:

    rm -r var/lib/etcd/*
    
  8. במעטפת, מעתיקים את נתוני ה-etcd ששוחזרו למיקום הקבוע שלהם:

    cp -r default.etcd/* var/lib/etcd/
    
  9. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  10. מוחקים את ה-Pod של etcd שקורס:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
      delete pod kube-etcd-0 --namespace USER_CLUSTER_NAME
    
  11. מוודאים שה-Pod של etcd לא קורס יותר.

  12. מוחקים את ה-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG \
      delete pod etcd-utility-0 --namespace USER_CLUSTER_NAME
  13. מסירים את etcd-utility.yaml מהספרייה הנוכחית:

    rm etcd-utility.yaml
    

Controlplane V2

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

  1. פותחים מעטפת (shell) בצומת של מישור הבקרה של המשתמש:

    ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
    
  2. במעטפת, עוצרים את שרת ה-API של Kubernetes ואת שרת ה-etcd:

    sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/manifests/etcd.yaml ~
    
  3. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  4. מריצים את הפקודה scp כדי להעתיק את קובץ הגיבוי snapshot.db והסודות לצומת מישור הבקרה של המשתמש:

    scp -i NODE_NAME.key ~/snapshot.db ubuntu@NODE_EXTERNAL_IP:/tmp/
    
    chmod a+rw pki/
    scp -ri NODE_NAME.key ~/pki_NODE_NAME ubuntu@NODE_EXTERNAL_IP:/etc/kubernetes/pki
    
  5. במעטפת, משתמשים ב-snapshot.db כדי לשחזר את נתוני ה-etcd:

    ETCDCTL_API=3 sudo etcdctl \
     --cacert=/etc/kubernetes/pki/etcd/ca.crt \
     --cert=/etc/kubernetes/pki/etcd/server.crt \
     --key=/etc/kubernetes/pki/etcd/server.key \
     --data-dir=/opt/data/var/lib/etcd \
     --name=NODE_NAME \
     --initial-advertise-peer-urls=https://NODE_IP_ADDRESS:2380 \
     --initial-cluster=NODE_NAME=https://NODE_IP_ADDRESS:2380 \
     snapshot restore /tmp/snapshot.db
    

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

    • ‫NODE_NAME: שם הצומת שבו מתבצע השחזור
    • ‫NODE_IP_ADDRESS: כתובת ה-IP של הצומת.
  6. מוסיפים את הדגל - --initial-cluster-state=new בקובץ המניפסט של etcd, בקטע container command.

    דוגמה:

    containers:
          - command:
            - etcd
            ...
            - --initial-cluster-state=new
            ...

  7. במעטפת, מפעילים את השרתים kube-apiserver ו-etcd:

    sudo mv ~/etcd.yaml ~/kube-apiserver.yaml /etc/kubernetes/manifests/
    
  8. במעטפת, מזינים exit כדי לצאת מהמעטפת.

שחזור אשכול משתמש מגיבוי (HA)

Kubeception

בקטע הזה מוסבר איך לשחזר את נתוני ה-etcd של אשכול משתמש בזמינות גבוהה (HA).

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

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

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

כדי לבצע את השלבים בקטע הזה, צריך ליצור קובץ snapshot.db כמו שמתואר במאמר גיבוי של אשכול משתמש.

הצגת רשימה של הפודים והצמתים של etcd

  1. מציגים את ה-Pods של etcd שמנהלים את מאגר ה-etcd של אשכול המשתמש. ה-Pods האלה פועלים באשכול האדמין:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG get pods --namespace USER_CLUSTER_NAME \
    --output wide | grep kube-etcd
    

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

    NAME              ...   NODE
    kube-etcd-0       ...   xxx
    kube-etcd-1       ...   yyy
    kube-etcd-2       ...   zzz
    
  2. מומלץ לרשום את שמות ה-Pod ואת שמות הצמתים של מישור הבקרה לשימוש בהמשך.

    שימו לב שלכל pod של etcd יש את השם kube-etcd בתוספת מספר. המספר הזה נקרא מספר המנוי של ה-Pod. הוא מזהה את ה-Pod כחבר מסוים באשכול ה-etcd שמכיל את נתוני האובייקטים של אשכול המשתמש. במדריך הזה, הפלייסהולדר MEMBER_NUMBER מתייחס למספר החבר של ה-Pod ב-etcd.

    שימו לב גם שכל Pod באשכול etcd פועל בצומת משלו.

הכנה לפריסת ה-Pods של כלי השירות

  1. שומרים מניפסט ל-PodDisruptionBudget‏ (PDB) לשרת ה-API של Kubernetes באשכול המשתמש. ואז למחוק את ה-PDB.

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG get pdb --namespace USER_CLUSTER_NAME \
    kube-apiserver-pdb --output yaml > kube-apiserver-pdb.yaml
    
    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG delete pdb --namespace USER_CLUSTER_NAME \
    kube-apiserver-pdb
    
  2. עוצרים את שרת ה-API של Kubernetes ואת פריסת התחזוקה של etcd. כך מוודאים שאף רכיב לא ישתמש ב-etcd במהלך השחזור:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG --namespace USER_CLUSTER_NAME \
    scale --replicas 0 statefulset kube-apiserver
    
    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG --namespace USER_CLUSTER_NAME \
    scale --replicas 0 deployment gke-master-etcd-maintenance
    
  3. זוכרים את השם של קובץ האימג' של הקונטיינר של ה-Pods של etcd.

פריסת ה-Pods של כלי השירות

  1. זוכרים את שם ה-Pod של etcd ואת שם הצומת שבו ה-Pod פועל.

  2. שומרים את מניפסט ה-Pod הבא בספרייה הנוכחית בקובץ בשם etcd-utility-MEMBER_NUMBER.yaml:

 apiVersion: v1
 kind: Pod
 metadata:
   name: etcd-utility-MEMBER_NUMBER
   namespace: USER_CLUSTER_NAME
 spec:
   containers:
   - command: ["/bin/sh"]
     args: ["-ec", "while :; do echo '.'; sleep 5 ; done"]
     image: gcr.io/gke-on-prem-release/etcd-util:GKE_ON_PREM_VERSION
     name: etcd-utility
     volumeMounts:
     - mountPath: /var/lib/etcd
       name: data
     - mountPath: /etcd.local.config/certificates
       name: etcd-certs
   nodeSelector:
     kubernetes.googleapis.com/cluster-name: USER_CLUSTER_NAME
     kubernetes.io/hostname: NODE_NAME
   tolerations:
   - effect: NoExecute
     key: node.kubernetes.io/not-ready
     operator: Exists
     tolerationSeconds: 300
   - effect: NoExecute
     key: node.kubernetes.io/unreachable
     operator: Exists
     tolerationSeconds: 300
   - effect: NoSchedule
     key: node.kubernetes.io/unschedulable
     operator: Exists
   volumes:
   - name: data
     persistentVolumeClaim:
       claimName: data-kube-etcd-MEMBER_NUMBER
   - name: etcd-certs
     secret:
       defaultMode: 420
       secretName: KUBE_ETCD_SECRET_NAME

המניפסט הקודם מתאר Pod של כלי שאתם מריצים באופן זמני כדי לשחזר נתוני etcd.

  1. יוצרים את ה-Pod של כלי השירות באשכול האדמין:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG apply -f etcd-utility-MEMBER_NUMBER.yaml
    
  2. מעתיקים את קובץ הגיבוי, snapshot.db, לתיקיית השורש של ה-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG cp snapshot.db \
    USER_CLUSTER_NAME/etcd-utility-MEMBER_NUMBER:snapshot.db
    
  3. פותחים מעטפת לקונטיינר etcd-utility ב-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG exec -it --namespace USER_CLUSTER_NAME \
    etcd-utility-MEMBER_NUMBER --container etcd-utility -- bin/sh
    
  4. במעטפת, בתיקיית השורש, משתמשים ב-snapshot.db כדי לשחזר את נתוני ה-etcd:

    ETCDCTL_API=3 etcdctl \
    --endpoints=https://127.0.0.1:2379 \
    --cacert=/etcd.local.config/certificates/etcdCA.crt \
    --cert=/etcd.local.config/certificates/etcd.crt \
    --key=/etcd.local.config/certificates/etcd.key \
    --name=kube-etcd-MEMBER_NUMBER \
    --initial-cluster=kube-etcd-0=https://kube-etcd-0.kube-etcd:2380,kube-etcd-1=https://kube-etcd-1.kube-etcd:2380,kube-etcd-2=https://kube-etcd-2.kube-etcd:2380 \
    --initial-cluster-token=etcd-cluster-1 \
    --initial-advertise-peer-urls=https://kube-etcd-MEMBER_NUMBER.kube-etcd:2380 \
    snapshot restore snapshot.db
    

    הפקודה הקודמת אחסנה את נתוני etcd בספרייה /kube-etcd-MEMBER_NUMBER.etcd.

  5. במעטפת, מוחקים את נתוני ה-etcd הישנים:

    rm -r var/lib/etcd/*
    
  6. במעטפת, מעתיקים את נתוני ה-etcd ששוחזרו למיקום הקבוע שלהם:

    cp -r kube-etcd-MEMBER_NUMBER.etcd/* var/lib/etcd/
    
  7. במעטפת, מסירים את ספריית ה-etcd הזמנית ואת קובץ הגיבוי:

    rm -R kube-etcd-MEMBER_NUMBER.etcd/
    rm snapshot.db
    
  8. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  9. מוחקים את ה-Pod של כלי השירות:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG delete pod \
    --namespace USER_CLUSTER_NAME etcd-utility-MEMBER_NUMBER
    

הפעלה מחדש של רכיבים

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

  1. מפעילים מחדש את ה-Pods ב-StatefulSet של kube-etcd:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONFIG rollout restart statefulset \
    --namespace USER_CLUSTER_NAME kube-etcd
    
  2. מפעילים את שרתי ה-API של Kubernetes באשכול המשתמש:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale statefulset --replicas 3 \
    --namespace USER_CLUSTER_NAME kube-apiserver
    
  3. מפעילים את פריסת התחזוקה של etcd באשכול המשתמשים:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG scale deployment --replicas 1 \
    --namespace=USER_CLUSTER_NAME  gke-master-etcd-maintenance
    
  4. משחזרים את ה-PDB של שרת ה-API של Kubernetes:

    kubectl --kubeconfig ADMIN_CLUSTER_KUBECONIFG apply -f kube-apiserver-pdb.yaml
    

Controlplane V2

בקטע הזה מוסבר איך לשחזר את נתוני ה-etcd של אשכול משתמש בזמינות גבוהה (HA).

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

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

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

כדי לבצע את השלבים בקטע הזה, צריך ליצור קובץ snapshot.db כמו שמתואר במאמר גיבוי של אשכול משתמש.

הצגת רשימה של הפודים והצמתים של etcd

  1. מציגים את ה-Pods של etcd ואת הצומת המתאים שלהם:

    kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
     -n kube-system -l component=etcd,tier=control-plane -o wide
    

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

    NAME           ...   NODE
    etcd-xxx       ...   xxx
    etcd-yyy       ...   yyy
    etcd-zzz       ...   zzz
    
  2. מומלץ לרשום את שמות ה-Pod ואת שמות הצמתים של מישור הבקרה לשימוש בהמשך.

    שימו לב שלכל pod של etcd יש את השם etcd-xxx, שאליו מצורף שם של צומת. הסיבה לכך היא שב-Controlplane V2, הפודים של etcd פועלים כפודים סטטיים.

בתהליך הכנה לשחזור

  1. מריצים את הפקודה scp כדי להעתיק את קובץ הגיבוי snapshot.db לכל הצמתים של מישור הבקרה של המשתמש:

    scp -i NODE_NAME.key ~/snapshot.db ubuntu@NODE_EXTERNAL_IP:/tmp/
    
  2. מעתיקים את הסודות לצומת המתאים במישור הבקרה של המשתמש:

    chmod a+rw ~/pki_*
    scp -ri NODE_NAME.key ~/pki_NODE_NAME/* ubuntu@NODE_EXTERNAL_IP:/opt/data/etc/kubernetes/pki/
    
  3. פותחים מעטפת (shell) בצומת של מישור הבקרה של המשתמש:

    ssh -i NODE_NAME.key ubuntu@NODE_EXTERNAL_IP
    

ביצוע השחזור

  1. זוכרים את שם ה-Pod של etcd ואת שם הצומת שבו ה-Pod פועל.

  2. ב-shell, עוצרים את שרת ה-API של Kubernetes ואת שרת ה-etcd בכל הצמתים של מישור הבקרה של המשתמש:

    sudo mv /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/manifests/etcd.yaml ~
    
  3. במעטפת, משתמשים ב-snapshot.db כדי לשחזר את נתוני ה-etcd בכל הצמתים של מישור הבקרה של המשתמש:

    ETCDCTL_API=3 sudo etcdctl \
     --cacert=/etc/kubernetes/pki/etcd/ca.crt \
     --cert=/etc/kubernetes/pki/etcd/server.crt \
     --key=/etc/kubernetes/pki/etcd/server.key \
     --data-dir=/opt/data/var/lib/etcd \
     --name=NODE_NAME \
     --initial-advertise-peer-urls=https://NODE_IP_ADDRESS:2380 \
     --initial-cluster=NODE1=https://NODE1_IP:2380,NODE2=https://NODE2_IP:2380,NODE3=https://NODE3_IP:2380 \
     snapshot restore /tmp/snapshot.db
    

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

    • ‫NODE_NAME: שם הצומת שבו מתבצע השחזור.
    • ‫NODE_IP_ADDRESS: כתובת ה-IP של הצומת.
    • ממלאים את השדות NODE1,‏ NODE2,‏ NODE3 ואת השדות NODE1_IP,‏ NODE2_IP,‏ NODE3_IP של הצומת המתאים לדגל --initial-cluster. אפשר גם לקבל את זה מהמניפסט של etcd.
  4. מוסיפים את הדגל - --initial-cluster-state=existing בקובץ המניפסט של etcd, בקטע container command.

    דוגמה:

    containers:
          - command:
            - etcd
            ...
            - --initial-cluster-state=existing
            ...

הפעלה מחדש של רכיבים

  1. במעטפת, מפעילים את השרתים kube-apiserver ו-etcd בכל הצמתים של מישור הבקרה של המשתמש:

    sudo mv ~/etcd.yaml ~/kube-apiserver.yaml /etc/kubernetes/manifests/
    
  2. במעטפת, מזינים exit כדי לצאת מהמעטפת.

  3. מוודאים ש-kube-apiserver ו-etcd פועלים בכל הצמתים של מישור הבקרה של המשתמש:

    kubectl get pod --kubeconfig USER_CLUSTER_KUBECONFIG \
    -n kube-system -l tier=control-plane
    

גיבוי אוטומטי של אשכולות

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

Kubeception

  • מגדירים את BACKUP_DIR לנתיב שבו רוצים לאחסן את הגיבויים של אשכולות האדמין והמשתמשים. הנתיב הזה לא אמור להיות קיים.
  • מגדירים את ADMIN_CLUSTER_KUBECONFIG לנתיב של קובץ ה-kubeconfig של אשכול האדמין.
  • מגדירים את USER_CLUSTER_NAMESPACE לשם של אשכול המשתמשים. השם של אשכול המשתמש הוא מרחב שמות באשכול האדמין.
  • מגדירים את EXTERNAL_IP לכתובת ה-VIP ששמרתם לשירות מישור הבקרה של האדמין.
  • מגדירים את SSH_PRIVATE_KEY לנתיב של מפתח ה-SSH.
  • אם אתם משתמשים ברשת פרטית, צריך להגדיר את JUMP_IP לכתובת ה-IP של שרת ה-jump של הרשת.
#!/usr/bin/env bash

# Automates manual steps for taking backups of user and admin clusters.
# Fill in the variables below before running the script.

BACKUP_DIR=""                       # path to store user and admin cluster backups
ADMIN_CLUSTER_KUBECONFIG=""         # path to admin cluster kubeconfig
USER_CLUSTER_NAMESPACE=""           # user cluster namespace
EXTERNAL_IP=""                      # admin control plane node external ip - follow steps in documentation
SSH_PRIVATE_KEY=""                  # path to vsphere_tmp ssh private key - follow steps in documentation
JUMP_IP=""                          # network jump server IP - leave empty string if not using private network.

mkdir -p $BACKUP_DIR
mkdir $BACKUP_DIR/pki

# USER CLUSTER BACKUP

# Snapshot user cluster etcd
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} exec -it -n ${USER_CLUSTER_NAMESPACE} kube-etcd-0 -c kube-etcd -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etcd.local.config/certificates/etcdCA.crt --cert=/etcd.local.config/certificates/etcd.crt --key=/etcd.local.config/certificates/etcd.key snapshot save ${USER_CLUSTER_NAMESPACE}_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp ${USER_CLUSTER_NAMESPACE}/kube-etcd-0:${USER_CLUSTER_NAMESPACE}_snapshot.db $BACKUP_DIR/user-cluster_${USER_CLUSTER_NAMESPACE}_snapshot.db 

# ADMIN CLUSTER BACKUP

# Set up ssh options
SSH_OPTS=(-oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY})
if [ "${JUMP_IP}" != "" ]; then
  SSH_OPTS+=(-oProxyCommand="ssh -oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY} -W %h:%p ubuntu@${JUMP_IP}")
fi

# Copy admin certs
ssh "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP} 'sudo chmod -R +rw /etc/kubernetes/pki/*'
scp -r "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP}:/etc/kubernetes/pki/* ${BACKUP_DIR}/pki/

# Snapshot admin cluster etcd
admin_etcd=$(kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} get pods -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[*].metadata.name}{"\n"}')
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} exec -it -n kube-system ${admin_etcd} -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key snapshot save admin_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp -n kube-system ${admin_etcd}:admin_snapshot.db $BACKUP_DIR/admin-cluster_snapshot.db

Controlplane V2

  • מגדירים את BACKUP_DIR לנתיב שבו רוצים לאחסן את הגיבויים של אשכולות האדמין והמשתמשים. הנתיב הזה לא אמור להיות קיים.
  • מגדירים את ADMIN_CLUSTER_KUBECONFIG לנתיב של קובץ ה-kubeconfig של אשכול האדמין.
  • מגדירים את USER_CLUSTER_KUBECONFIG לנתיב של kubeconfig של אשכול המשתמשים.
  • מגדירים את EXTERNAL_IP לכתובת ה-VIP ששמרתם לשירות מישור הבקרה של האדמין.
  • מגדירים את SSH_PRIVATE_KEY לנתיב של מפתח ה-SSH.
  • אם אתם משתמשים ברשת פרטית, צריך להגדיר את JUMP_IP לכתובת ה-IP של שרת ה-jump של הרשת.
#!/usr/bin/env bash

# Automates manual steps for taking backups of user and admin clusters.
# Fill in the variables below before running the script.

BACKUP_DIR=""                       # path to store user and admin cluster backups
ADMIN_CLUSTER_KUBECONFIG=""         # path to admin cluster kubeconfig
USER_CLUSTER_KUBECONFIG=""          # path to user cluster kubeconfig
EXTERNAL_IP=""                      # admin control plane node external ip - follow steps in documentation
SSH_PRIVATE_KEY=""                  # path to ssh private key - follow steps in documentation
JUMP_IP=""                          # network jump server IP - leave empty string if not using private network

mkdir -p $BACKUP_DIR
mkdir $BACKUP_DIR/pki

# USER CLUSTER BACKUP
user_etcd=$(kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} get pods -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[0].metadata.name}{"\n"}')
kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} exec -it -n kube-system ${user_etcd} -c etcd -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key snapshot save /tmp/${user_etcd}_snapshot.db"
kubectl --kubeconfig=${USER_CLUSTER_KUBECONFIG} cp kube-system/${user_etcd}:/tmp/${user_etcd}_snapshot.db $BACKUP_DIR/${user_etcd}_snapshot.db

# ADMIN CLUSTER BACKUP

# Set up ssh options
SSH_OPTS=(-oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY})
if [ "${JUMP_IP}" != "" ]; then
  SSH_OPTS+=(-oProxyCommand="ssh -oStrictHostKeyChecking=no -i ${SSH_PRIVATE_KEY} -W %h:%p ubuntu@${JUMP_IP}")
fi

# Copy admin certs
ssh "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP} 'sudo chmod -R +rw /etc/kubernetes/pki/*'
scp -r "${SSH_OPTS[@]}" ubuntu@${EXTERNAL_IP}:/etc/kubernetes/pki/* ${BACKUP_DIR}/pki/

# Snapshot admin cluster etcd
admin_etcd=$(kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} get pods -n kube-system -l component=etcd,tier=control-plane -ojsonpath='{$.items[*].metadata.name}{"\n"}')
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} exec -it -n kube-system ${admin_etcd} -- /bin/sh -ec "export ETCDCTL_API=3; etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt --key=/etc/kubernetes/pki/etcd/healthcheck-client.key snapshot save /tmp/${admin_etcd}_snapshot.db"
kubectl --kubeconfig=${ADMIN_CLUSTER_KUBECONFIG} cp -n kube-system ${admin_etcd}:/tmp/${admin_etcd}_snapshot.db $BACKUP_DIR/${admin_etcd}_snapshot.db

אימות השחזור

כדי לוודא שהאשכול שוחזר בהצלחה, מריצים את הפקודה gkectl diagnose cluster.

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