גיבוי ושחזור של AlloyDB Omni באחסון שתואם ל-S3 באמצעות כלי התזמור RPM

1. מבוא

ב-Codelab הזה נסביר איך מגבים אשכול בזמינות גבוהה (HA) למאגר אובייקטים שתואם ל-S3 ב-AlloyDB Omni באמצעות כלי תזמור RPM.

בשיעור Codelab הזה נשתמש באשכול מתוך שיעור ה-Codelab Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator כדי ליצור אשכול זמינות גבוהה במכונות וירטואליות (VM) של Compute Engine. בשיעור Codelab הזה תוסיפו שרת מאגר אובייקטים שתואם ל-S3 לאחת מהמכונות הווירטואליות. אתם משתמשים בשרת מאגר אובייקטים עבור אשכול ה-HA כדי לגבות את הנתונים ולשחזר את האשכול מהשרת.

‫Cloud Shell מתחבר למכונת ה-VM של הבקרה. מכונת ה-VM של הבקרה מריצה את Ansible ואת MinIO. ‏psql מתחבר לאשכול דרך כתובת ה-IP הווירטואלית של מכונות ה-VM של HAProxy. המכונות הווירטואליות של מסד הנתונים שולחות גיבויים ל-MinIO דרך יציאה 9000.

דרישות מוקדמות

  • פרויקט ב-Google Cloud שהחיוב בו מופעל.
  • תפקידי ה-IAM שמפורטים ב-Codelab של HA.
  • ידע בסיסי בפקודות Linux ו-SQL.

מה תלמדו

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

מה תצטרכו

2. הגדרה ודרישות

  1. בשלב הזה יוצרים אשכול זמינות גבוהה באמצעות שיעור ה-Codelab Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator. מבצעים את השלבים הבאים. אם כבר יש לכם אשכול מ-codelab, ממשיכים לשלב הבא.
  2. הערה: בשלב הזה לא מבצעים את השלב "ניקוי המשאבים". תבצעו את השלב הזה בסוף ה-Codelab.
  3. חזרה ל-Codelab הזה

3. חיבור לאשכול והוספת נתונים לדוגמה

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

  1. אם אתם לא מחוברים למכונת ה-VM של הבקרה, מתחברים אליה מ-Cloud Shell:
    ‫
    gcloud compute ssh "$CLUSTER-control" --zone="$ZONE" --project="$PROJECT"
    המשתנים CLUSTER,‏ ZONE ו-PROJECT מגיעים מהשלב Prepare the VMs for the deployment ב-Codelab‏ Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator. אם המשתנים האלה לא מוגדרים ב-Cloud Shell, צריך להגדיר אותם מחדש.
  2. ב-VM של הבקרה, עוברים לספריית הבית וטוענים את משתני הסביבה. לאחר מכן מוסיפים את שם האשכול ואת משתמש ה-SSH לקובץ הסביבה:
    ‫
    cd ~
source /tmp/cluster.conf
cat >> ~/.codelab.env <<EOF
export CLUSTER="$cluster"
export SSH_USER="$service_account"
EOF
source ~/.codelab.env
env | grep -E '^(CLUSTER|SSH_USER|VIRTUAL_IP)='
    מוודאים שהפלט מציג את הערכים CLUSTER, SSH_USER ו-VIRTUAL_IP. הערה: אם מתחברים שוב למכונה הווירטואלית של הבקרה מאוחר יותר, צריך להריץ את הפקודות cd ~ ו-source ~/.codelab.env לפני שממשיכים.
  3. מוסיפים את הגדרות החיבור לקובץ הסביבה. כשמריצים את הפקודה read ומתבקשים להזין סיסמה, מזינים את הסיסמה של המשתמש postgres. הסיסמה הזו מוגדרת בשלב Bootstrap AlloyDB Omni Cluster ב-Codelab Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator
    cat >> ~/.codelab.env <<'EOF'
export PATH="/usr/pgsql-18/bin:$PATH"
export PGHOST="$VIRTUAL_IP"
export PGUSER="postgres"
EOF
read -rsp "Password of the postgres user: " PGPASSWORD; echo
printf 'export PGPASSWORD=%q\n' "$PGPASSWORD" >> ~/.codelab.env
source ~/.codelab.env
env | grep -E '^(PGHOST|PGUSER|PGPASSWORD)='
  4. ליצור טבלה ולהוסיף 1,000 שורות:
    psql <<'SQL'
CREATE TABLE public.orders (
  id integer PRIMARY KEY,
  item text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT pg_catalog.now()
);
INSERT INTO public.orders (id, item)
SELECT g, 'item-' || g FROM pg_catalog.generate_series(1, 1000) AS g;
SQL
  5. ספירת השורות:
    psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
    מוודאים שהפלט מחזיר 1000.

4. התקנה והפעלה של מאגר אובייקטים שתואם ל-S3

בשלב הזה, כותבים קובץ Ansible playbook שמתקין שרת MinIO במכונת הבקרה. בנוסף, ה-playbook יוצר את ה-bucket ואת המשתמש לגיבויים, ומוודא שמכונות ה-VM של מסד הנתונים יכולות להתחבר ל-MinIO. מריצים את כל הפקודות בשלב הזה במכונה הווירטואלית של הבקרה.

  1. ב-VM של הבקרה, מוסיפים את הגדרות האחסון לקובץ הסביבה. הפקודות openssl יוצרות סיסמאות אקראיות.
    ‫
    MD=http://metadata.google.internal/computeMetadata/v1/instance
S3_IP=$(curl -s -H "Metadata-Flavor: Google" "$MD/network-interfaces/0/ip")
cat >> ~/.codelab.env <<EOF
export S3_IP="$S3_IP"
export S3_HOST="$CLUSTER-control"
export S3_BUCKET="alloydb-backups"
export S3_REGION="us-east-1"
export MINIO_ROOT_USER="s3admin"
export MINIO_ROOT_PASSWORD="$(openssl rand -hex 16)"
export S3_ACCESS_KEY_ID="alloydb-backup"
export S3_SECRET_ACCESS_KEY="$(openssl rand -hex 16)"
export MINIO_URL="https://github.com/minio/minio/releases/download/RELEASE.2024-05-10T01-41-38Z/minio.linux-amd64.RELEASE.2024-05-10T01-41-38Z"
export MC_URL="https://github.com/minio/mc/releases/download/RELEASE.2024-05-09T17-04-24Z/mc.linux-amd64.RELEASE.2024-05-09T17-04-24Z"
EOF
source ~/.codelab.env
echo "$S3_HOST $S3_IP"
    מוודאים שהפלט מציג את השם ואת כתובת ה-IP הפנימית של מכונת ה-VM של אמצעי הבקרה, לדוגמה my-cluster-control 10.1.0.2. המכונות הווירטואליות של מסד הנתונים משתמשות בשם המארח ובכתובת ה-IP האלה כדי להתחבר ל-MinIO. כתובת ה-IP מופיעה בשרת המטא-נתונים של המכונה הווירטואלית. מידע נוסף זמין במסמכי התיעוד בנושא מטא-נתונים של מכונות וירטואליות.הערכים MINIO_URL ו-MC_URL הם כתובות ה-URL להורדה של שרת MinIO ושל לקוח MinIO ‏ (mc).
  2. מתקינים את אוסף community.crypto Ansible הנדרש במכונת הבקרה:
    ansible-galaxy collection install community.crypto
  3. יוצרים את ספר ההפעלה s3_server.yaml:
    cat > s3_server.yaml <<EOF
- name: Install and run MinIO on the control VM
  hosts: localhost
  connection: local
  become: true
  gather_facts: false
  tasks:
    - name: Create MinIO directories
      ansible.builtin.file:
        path: "{{ item }}"
        state: directory
        mode: "0755"
      loop:
        - /var/lib/minio/data
        - /var/lib/minio/certs

    - name: Download MinIO server and client
      ansible.builtin.get_url:
        url: "{{ item.url }}"
        dest: "{{ item.dest }}"
        mode: "0755"
      loop:
        - url: "$MINIO_URL"
          dest: /usr/local/bin/minio
        - url: "$MC_URL"
          dest: /usr/local/bin/mc

    - name: Generate MinIO TLS private key
      community.crypto.openssl_privatekey:
        path: /var/lib/minio/certs/private.key
        size: 2048
        mode: "0600"

    - name: Generate MinIO certificate signing request
      community.crypto.openssl_csr_pipe:
        privatekey_path: /var/lib/minio/certs/private.key
        common_name: "$S3_HOST"
        subject_alt_name:
          - "DNS:$S3_HOST"
          - "DNS:$S3_BUCKET.$S3_HOST"
          - "DNS:localhost"
          - "IP:127.0.0.1"
          - "IP:$S3_IP"
      register: minio_csr

    - name: Generate self-signed MinIO TLS certificate
      community.crypto.x509_certificate:
        path: /var/lib/minio/certs/public.crt
        csr_content: "{{ minio_csr.csr }}"
        privatekey_path: /var/lib/minio/certs/private.key
        provider: selfsigned
        selfsigned_not_after: "+365d"
        mode: "0644"

    - name: Create MinIO systemd service unit
      ansible.builtin.copy:
        dest: /etc/systemd/system/minio.service
        mode: "0600"
        content: |
          [Unit]
          Description=MinIO Object Storage
          After=network.target

          [Service]
          Environment="MINIO_ROOT_USER=$MINIO_ROOT_USER"
          Environment="MINIO_ROOT_PASSWORD=$MINIO_ROOT_PASSWORD"
          Environment="MINIO_DOMAIN=$S3_HOST"
          ExecStart=/usr/local/bin/minio server /var/lib/minio/data --certs-dir /var/lib/minio/certs
          Restart=on-failure

          [Install]
          WantedBy=multi-user.target

    - name: Start and enable MinIO service
      ansible.builtin.systemd_service:
        name: minio
        daemon_reload: true
        state: started
        enabled: true

    - name: Add storage host names to /etc/hosts on the control VM
      ansible.builtin.lineinfile:
        path: /etc/hosts
        line: "$S3_IP $S3_HOST $S3_BUCKET.$S3_HOST"
        state: present

    - name: Wait for MinIO health endpoint
      ansible.builtin.uri:
        url: "https://$S3_HOST:9000/minio/health/live"
        ca_path: /var/lib/minio/certs/public.crt
        status_code: 200
      register: minio_health
      until: minio_health.status == 200
      retries: 6
      delay: 5

    - name: Create backup bucket and user in MinIO
      ansible.builtin.command:
        argv: "{{ item }}"
      loop:
        - - /usr/local/bin/mc
          - --insecure
          - alias
          - set
          - s3repo
          - "https://$S3_HOST:9000"
          - "$MINIO_ROOT_USER"
          - "$MINIO_ROOT_PASSWORD"
        - - /usr/local/bin/mc
          - --insecure
          - mb
          - --ignore-existing
          - "s3repo/$S3_BUCKET"
        - - /usr/local/bin/mc
          - --insecure
          - admin
          - user
          - add
          - s3repo
          - "$S3_ACCESS_KEY_ID"
          - "$S3_SECRET_ACCESS_KEY"
        - - /usr/local/bin/mc
          - --insecure
          - admin
          - policy
          - attach
          - s3repo
          - readwrite
          - --user
          - "$S3_ACCESS_KEY_ID"
      become: false
      no_log: true

- name: Configure database VMs for MinIO
  hosts: primary_instance_nodes
  become: true
  gather_facts: false
  vars:
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  tasks:
    - name: Set SELinux to permissive mode
      ansible.builtin.command:
        cmd: setenforce 0

    - name: Add storage host names to /etc/hosts
      ansible.builtin.lineinfile:
        path: /etc/hosts
        line: "$S3_IP $S3_HOST $S3_BUCKET.$S3_HOST"
        state: present

    - name: Verify storage host resolution
      ansible.builtin.getent:
        database: hosts
        key: "$S3_BUCKET.$S3_HOST"

    - name: Verify connection to MinIO
      ansible.builtin.uri:
        url: "https://$S3_HOST:9000/minio/health/live"
        validate_certs: false
        status_code: 200
EOF
    המשתנה MINIO_DOMAIN מאפשר ל-MinIO לקבל בקשות בסגנון של מארח וירטואלי. הכלי לניהול הרשאות RPM משתמש במשתמש alloydb-backup כדי לכתוב את הגיבויים. המדיניות readwrite היא מדיניות מובנית של MinIO.
  4. מריצים את הפלייבוק:
    ansible-playbook s3_server.yaml -i deployment_spec.yaml
    מוודאים שהפלט של PLAY RECAP מציג failed=0 עבור localhost ועבור כל מכונת VM של מסד נתונים.
  5. מוודאים שהקטגוריה קיימת:
    ‫
    mc --insecure ls s3repo
    מוודאים שהפלט מציג את מאגר alloydb-backups/.

5. יצירת תוכנית גיבוי

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

  1. ב-VM של הבקרה, יוצרים את מדריך הגיבוי ואת מדריך הסטטוס. אתם משתמשים במדריך הגיבוי למשאבים Secret, BackupPlan ו-Backup. משתמשים ב-status playbook כדי להציג את הסטטוס של משאב.
    cat > backup.yaml <<EOF
- name: Manage AlloyDB Omni backups
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.backup
EOF
cat > status.yaml <<EOF
- name: Get resource status
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.status
EOF
  2. יוצרים משאב Secret לפרטי הכניסה של S3. ואז מחילים את המשאב:
    ‫
    S3_KEY_ID_B64=$(printf '%s' "$S3_ACCESS_KEY_ID" | base64 -w 0)
S3_KEY_B64=$(printf '%s' "$S3_SECRET_ACCESS_KEY" | base64 -w 0)
cat > s3_secret.yaml <<EOF
Secret:
  metadata:
    name: s3-backup-secret
  spec:
    type: Opaque
    data:
      access-key-id: "$S3_KEY_ID_B64"
      access-key: "$S3_KEY_B64"
EOF
ansible-playbook backup.yaml -i deployment_spec.yaml \
    -e resource_spec=s3_secret.yaml
    שמות המפתחות בקטע data צריכים להיות access-key-id ו-access-key. צריך להחיל את משאב Secret לפני שמחילים את משאב BackupPlan.
  3. יוצרים את המשאב BackupPlan ואז מחילים את המשאב:
    ‫
    cat > backup_plan.yaml <<EOF
BackupPlan:
  metadata:
    name: s3-backup-plan
  spec:
    dbclusterRef: $CLUSTER
    backupLocation:
      type: S3
      s3Options:
        bucket: $S3_BUCKET
        key: /backups
        endpoint: https://$S3_HOST:9000
        region: $S3_REGION
        secretRef:
          name: s3-backup-secret
        caBundle:
          - |
$(sed 's/^/            /' /var/lib/minio/certs/public.crt)
EOF
ansible-playbook backup.yaml -i deployment_spec.yaml \
    -e resource_spec=backup_plan.yaml
    הערך key הוא הנתיב של הגיבויים בקטגוריה. הנתיב הזה חייב להתחיל בלוכסן (/). השדה caBundle מכיל את אישור ה-CA בקידוד PEM שמאמת את האישור של שרת האחסון ב-S3.
  4. מוודאים שתוכנית הגיבוי מוכנה:
    ‫
    ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=BackupPlan -e resource_name=s3-backup-plan
    מוודאים שבשדה phase מופיע Ready. אם השלב לא Ready, ממתינים דקה ומריצים את הפקודה שוב.
  5. כשיוצרים תוכנית גיבוי, כלי התיאום של RPM מתחיל באופן אוטומטי גיבוי מלא ראשוני. ודא שהגיבוי הראשוני הזה הושלם לפני שתיצור גיבוי על פי דרישה:
    ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=Backup
    מוודאים ששלב הגיבוי הראשוני מצליח.

6. יצירת גיבוי על פי דרישה

בשלב הזה יוצרים גיבוי על פי דרישה של האשכול.

  1. במכונה הווירטואלית של הבקרה, יוצרים את המשאב Backup. ואז מחילים את המשאב:
    ‫
    cat > create_backup.yaml <<EOF
Backup:
  metadata:
    name: s3-backup-1
  spec:
    backupPlanRef: s3-backup-plan
    dbclusterRef: $CLUSTER
EOF
ansible-playbook backup.yaml -i deployment_spec.yaml \
    -e resource_spec=create_backup.yaml
    השדה backupPlanRef הוא השם של תוכנית הגיבוי. השדה dbclusterRef הוא שם האשכול.
  2. בודקים שהגיבוי הושלם:
    ‫
    ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=Backup -e resource_name=s3-backup-1
    מוודאים שבשדה phase מופיע Succeeded. אם השלב לא Succeeded, ממתינים דקה ומריצים את הפקודה שוב.
  3. מוודאים שקבצי הגיבוי נמצאים בדלי:
    ‫
    mc --insecure tree "s3repo/$S3_BUCKET"
    מוודאים שהפלט מציג תיקייה בשם backup שמכילה תיקייה בשם db.

7. שחזור האשכול מגיבוי

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

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

שחזור מהגיבוי

  1. במכונה הווירטואלית של קבוצת הבקרה, מוחקים את הטבלה orders. אחר כך סופרים את השורות:
    psql -c "DROP TABLE public.orders;"
psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
    מוודאים שהפקודה השנייה נכשלת עם שגיאה. בהודעת השגיאה מוצג שהקשר לא קיים. לדוגמה, 'ERROR: table "orders" does not exist'
  2. יוצרים את תוכנית הפעולה לשחזור:
    cat > restore.yaml <<EOF
- name: Restore AlloyDB Omni cluster
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.restore
EOF
  3. יוצרים משאב Restore לגיבוי s3-backup-1. ואז מחילים את המשאב:
    cat > restore_backup.yaml <<EOF
Restore:
  metadata:
    name: s3-restore-1
  spec:
    sourceDBCluster: $CLUSTER
    backup: s3-backup-1
EOF
ansible-playbook restore.yaml -i deployment_spec.yaml \
    -e resource_spec=restore_backup.yaml
  4. מוודאים שפעולת השחזור הושלמה:
    ‫
    ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=Restore -e resource_name=s3-restore-1
    מוודאים שבשדה phase מופיע ProvisionSucceeded. אם השלב לא ProvisionSucceeded, ממתינים דקה ומריצים את הפקודה שוב.
  5. ספירת השורות בטבלה המשוחזרת:
    ‫
    psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
    מוודאים שהפלט מציג 1000.

(אופציונלי) שחזור לנקודת זמן מסוימת

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

כללים לגבי שעת היעד

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

  • משתמשים בפורמט RFC 3339 ב-UTC: ‏YYYY-MM-DDThh:mm:ssZ. לדוגמה, 2026-06-19T14:30:00Z הוא 14:30:00 UTC ב-19 ביוני 2026. האות T מפרידה בין התאריך לבין השעה. האות Z מציינת שעון UTC.
  • להשתמש בשעה שכבר עברה.
  • משתמשים בזמן שמאוחר יותר מהערך begin בשדה recoveryWindow של CRD‏ BackupPlan.

כדי להציג את השעה הנוכחית בפורמט RFC 3339, מריצים את הפקודה הבאה:

date -u +%Y-%m-%dT%H:%M:%SZ

כדי לשנות שעה מקומית לפורמט הזה, מוסיפים את ההפרש משעון UTC של השעה המקומית לפקודה date. לדוגמה, הפקודה הבאה משנה את 16:30:00 ב-19 June 2026 בשעה UTC+02:00:

date -u -d "2026-06-19 16:30:00 +0200" +%Y-%m-%dT%H:%M:%SZ

הפקודה מחזירה 2026-06-19T14:30:00Z.

שחזור לשעת מדידה

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

  1. הוספת 500 שורות לטבלה:
    psql <<'SQL'
INSERT INTO public.orders (id, item)
SELECT g, 'item-' || g FROM pg_catalog.generate_series(1001, 1500) AS g;
SQL
  2. מציינים את השעה. בשלב הזה, הטבלה כוללת 1,500 שורות.
    sleep 5
PITR_TIME=$(date -u +%Y-%m-%dT%H:%M:%SZ)
echo "export PITR_TIME=$PITR_TIME" >> ~/.codelab.env
echo "$PITR_TIME"
sleep 5
    מוודאים שהפלט מציג שעה בפורמט YYYY-MM-DDThh:mm:ssZ, לדוגמה 2026-10-05T11:16:02Z.
  3. מוחקים שורות מהטבלה כדי לדמות מחיקה של נתונים בטעות. ואז מתחילים קובץ WAL חדש:
    psql -c "DELETE FROM public.orders WHERE id > 1000;"
psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
psql -c "SELECT pg_catalog.pg_switch_wal();"
    מוודאים ששאילתת count מציגה 1000. הפונקציה pg_switch_wal גורמת לשרת להתחיל קובץ WAL חדש. לאחר מכן השרת יכול לארכב את קובץ ה-WAL שמכיל את השינויים.
  4. מוודאים שחלון השחזור של תוכנית הגיבוי כולל את הזמן שתועד:
    ‫
    test -n "$PITR_TIME" || { echo "PITR_TIME is not set. Run step 2 again."; exit 1; }
echo "$PITR_TIME"
ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=BackupPlan -e resource_name=s3-backup-plan
    מוודאים שהערך PITR_TIME מאוחר מהערך begin בשדה recoveryWindow.
  5. יוצרים משאב Restore לזמן המוקלט. ואז מחילים את המשאב:
    cat > restore_pitr.yaml <<EOF
Restore:
  metadata:
    name: s3-restore-pitr
  spec:
    sourceDBCluster: $CLUSTER
    pointInTime: "$PITR_TIME"
EOF
ansible-playbook restore.yaml -i deployment_spec.yaml \
    -e resource_spec=restore_pitr.yaml
  6. מוודאים שפעולת השחזור הושלמה:
    ‫
    ansible-playbook status.yaml -i deployment_spec.yaml \
    -e resource_type=Restore -e resource_name=s3-restore-pitr
    מוודאים שבשדה phase מופיע ProvisionSucceeded. אם השלב לא ProvisionSucceeded, ממתינים דקה ומריצים את הפקודה שוב.
  7. ספירת השורות:
    ‫
    psql -c "SELECT pg_catalog.count(*) FROM public.orders;"
    מוודאים שהפלט מציג 1500.

8. הסרת המשאבים

כדי להימנע מחיובים בחשבון Google Cloud, צריך למחוק את המשאבים של ה-Codelab הזה ושל ה-Codelab Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator. קודם מוחקים את משאבי הגיבוי, ואז מוחקים את האשכול ואת סביבת המחשוב.

  1. ב-VM של הבקרה, יוצרים את פלייבוק המחיקה:
    cat > delete.yaml <<EOF
- name: Delete AlloyDB Omni resources
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.delete
EOF
  2. מציינים את הגיבויים:
    ansible-playbook status.yaml -i deployment_spec.yaml -e resource_type=Backup
    מוודאים שהפלט מציג את הגיבוי של s3-backup-1.
  3. מחיקת הגיבוי של s3-backup-1:
    ansible-playbook delete.yaml -i deployment_spec.yaml \
    -e resource_type=Backup -e resource_name=s3-backup-1
  4. מחיקת תוכנית הגיבוי:
    ansible-playbook delete.yaml -i deployment_spec.yaml \
    -e resource_type=BackupPlan -e resource_name=s3-backup-plan
  5. מוחקים את האשכול ואת סביבת המחשוב באמצעות השלב Clean up Resources (ניקוי משאבים) מתוך שיעור ה-Codelab Deploy AlloyDB Omni high availability cluster on GCE VMs using RPM Orchestrator (פריסת אשכול זמינות גבוהה של AlloyDB Omni במכונות וירטואליות של GCE באמצעות RPM Orchestrator). שרת MinIO והגיבויים שבו נמצאים במכונה הווירטואלית של הבקרה. כשמוחקים את סביבת המחשוב, נמחקים גם השרת וגם הגיבויים.

9. מזל טוב

מעולה. ביצעתם גיבוי של אשכול לזמינות גבוהה (HA) למאגר אובייקטים שתואם ל-S3 עבור AlloyDB Omni באמצעות כלי התזמור RPM. לאחר מכן שחזרתם את האשכול מהגיבויים.

מה למדנו

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

מידע נוסף זמין בדפים הבאים:

10. סקר

איך תשתמשו במדריך הזה?

רק לקרוא את המאמר לקרוא את המאמר ולבצע את התרגילים