פריסת אשכול זמינות גבוהה של AlloyDB Omni במכונות וירטואליות של GCE באמצעות RPM Orchestrator

1. מבוא

ב-Codelab הזה נדגים איך פורסים אשכול של AlloyDB Omni עם זמינות גבוהה (HA) במכונות וירטואליות (VM) של Google Compute Engine ‏ (GCE). בסיום שיעור ה-Codelab הזה, תספקו ארכיטקטורת עזר של HA שכוללת 3 צמתי מסד נתונים ו-2 צמתי HAProxy, יחד עם צומת בקרה לפעולות ניהול.

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

  • גישה לפרויקט ב-Google Cloud ול-Cloud Shell מ-Cloud Console.
  • ה-SDK של Google Cloud‏ (gcloud) מותקן ומוגדר. פרטים על התקנת gcloud מופיעים במאמר gcloud-install.
  • ‫Terraform v1.9.8 מותקן.

מה תלמדו

  • איך יוצרים מכונות וירטואליות ב-GCE ומכינים אותן ל-AlloyDB Omni.
  • איך מתקינים ומריצים את AlloyDB Omni RPM Orchestrator.
  • איך מתקינים ומגדירים חבילות AlloyDB Omni RPM לארכיטקטורת הפניה של זמינות גבוהה.

מה תצטרכו

  • קבלת קישור לכתובת URL של חבילות RPM של AlloyDB Omni ואופרטור RPM. לשם כך, צריך למלא את טופס ההרשמה ל-AlloyDB Omni. הקישורים נשלחים לכתובת האימייל שלכם בשרת של כתובת ה-URL של המאגר. כדי שכתובות ה-URL יהיו זמינות במהלך ה-codelab, מאתחלים את משתני הסביבה הבאים.
    export ORCHESTRATOR_ANSIBLE_COLLECTION_PATH="..."
export ALLOYDB_OMNI_REPOSITORY_URL="..."
export ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL="..."
export ALLOYDB_OMNI_COMMON_REPOSITORY_URL="..."
export ETCD_REPOSITORY_URL="..."
  • טרמינל פעיל עם גישה לסטאק הפריסה של AlloyDB Omni. למטרה הזו אפשר להשתמש ב-Cloud Shell.

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

הגדרת פרויקט

יצירת פרויקט בענן של Google

  1. במסוף Google Cloud, בדף לבחירת הפרויקט, בוחרים פרויקט ב-Google Cloud או יוצרים פרויקט.
  2. הקפידו לוודא שהחיוב מופעל בפרויקט שלכם ב-Cloud. כך בודקים אם החיוב מופעל בפרויקט

מפעילים את Cloud Shell

אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-Codelab הזה נשתמש ב-Google Cloud Shell, סביבת שורת פקודה שפועלת ב-Cloud.

במסוף Google Cloud, לוחצים על סמל Cloud Shell בסרגל הכלים השמאלי העליון:

סמל להפעלת Cloud Shell

אפשר גם ללחוץ על G ואז על S. אם אתם במסוף Google Cloud, או אם אתם משתמשים בקישור הזה, הרצף הזה יפעיל את Cloud Shell.

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

מסוף Google Cloud Shell שבו מוצג שהסביבה מחוברת

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

3. יצירת מכונות וירטואליות ב-Google Cloud Compute Engine

הכנת סקריפטים של Terraform

  1. מגדירים משתני סביבה למזהה הפרויקט ולשם הרצוי של האשכול. תשתמשו בהם לאורך כל ה-codelab.
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
    הערה: מזהה הפרויקט ב-Google Cloud צריך להיות באורך של 6 עד 30 תווים בלבד. מידע נוסף זמין בכתובת https://docs.cloud.google.com/resource-manager/docs/creating-managing-projects#before_you_begin
  2. מוודאים שנכנסתם לחשבון משתמש ב-Google Cloud.
    gcloud auth login
  3. יוצרים ספריית עבודה לפריסה ומעתיקים את קובצי התצורה הנדרשים של Terraform ממקור המאגר.
    mkdir -p ~/alloydb-omni/$PROJECT/$CLUSTER
cd ~/alloydb-omni/$PROJECT/$CLUSTER
gcloud storage cp gs://alloydb-omni-install/rpm-orchestrator/gce/terraform/*.tf .
  4. יוצרים קובץ terraform.tfvars כדי לציין את הפרמטרים הנדרשים בהתאם לארכיטקטורת ההפניה, לפי התוכן הבא:
    cat > terraform.tfvars <<EOF
# Required instance counts for reference architecture
db_instance_count      = 3
haproxy_instance_count = 2
control_instance_count = 1

# Optional: Customize if needed with the below variables
# os_image             = "rocky-linux-cloud/rocky-linux-9"
# zone                 = "us-west4-c"
# region_1             = "us-west4"
# db_instance_type     = "c4-highmem-4"
# db_disk_type         = "hyperdisk-balanced"
# db_data_size         =  "50" # GB
# data_dir             =  "/data"
EOF

הפעלת סקריפטים של Terraform ואימות

  1. עכשיו אפשר להקצות את המכונות הווירטואליות.
    terraform init
  2. לפני שיוצרים מכונות וירטואליות, צריך לוודא שיש לכם את הגישה הנדרשת ליצירת מכונות וירטואליות ומשאבים אחרים. לסיכום, תצטרכו את ההרשאות הבאות.
    roles/compute.admin
roles/iam.roleAdmin
roles/compute.osAdminLogin
roles/iam.serviceAccountCreator
roles/iam.serviceAccountUser
roles/artifactregistry.repoAdmin
roles/storage.objectUser
roles/resourcemanager.projectIamAdmin
roles/serviceusage.serviceUsageAdmin
  3. מאמתים את ההגדרה ומחילים אותה כדי להקצות את המשאבים.
    ‫
    terraform validate
terraform apply --auto-approve
    הערה: חשוב לוודא שאתם משתמשים ב-Terraform v1.9.8 כמו שנדרש בהגדרות הפריסה.
  4. אחרי ש-Terraform מסיים, כדי לוודא שהמכונות הווירטואליות נוצרו בהצלחה, מריצים את הפקודה gcloud כדי להציג את רשימת המופעים שנוצרו.
    gcloud compute instances list --filter="name~$CLUSTER" --project=$PROJECT
    יוצגו מופעים שמתאימים ל-3 צמתי מסד הנתונים, ל-2 צמתי HAProxy ולמכונת ה-VM של הבקרה ולאזורים המתאימים. מציינים את האזור של צומת הבקרה. נצטרך את זה בהמשך הסדנה.
    export ZONE=$(gcloud compute instances list \
  --filter="name=$CLUSTER-control"          \
  --format="value(zone)" --project=$PROJECT)

4. הכנת המכונות הווירטואליות לפריסה

צריך ליצור סשן SSH לצומת הבקרה ולבצע את השלבים להפעלת גישת SSH לכל המכונות הווירטואליות (שנקראות גם צמתים).

  1. מוודאים שמשתני הסביבה של הפרויקט והאשכול מוגדרים.
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
  2. יוצרים מפתח SSH ומוסיפים אותו כדי להתחבר למכונת ה-VM של הבקרה.
    # Replace values with your specific GCP project, cluster and zone details
ssh-keygen -t ed25519 -f $HOME/.ssh/google_compute_engine
gcloud compute os-login ssh-keys add --key-file=$HOME/.ssh/google_compute_engine.pub --project=$PROJECT
  3. יוצרים כלל של חומת אש שמאפשר חיבורי SSH וגם תעבורת VRRP.
    gcloud compute config-ssh --project=$PROJECT
gcloud compute firewall-rules create $CLUSTER-allow-ssh --network=$CLUSTER --project=$PROJECT --direction=INGRESS --action=allow --rules=tcp:22 --source-ranges="0.0.0.0/0"
gcloud compute firewall-rules create $CLUSTER-allow-vrrp --network=$CLUSTER --project=$PROJECT --allow=112 --source-ranges="0.0.0.0/0"
  4. מתחברים למכונת הבקרה הווירטואלית באמצעות SSH:
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
  5. יוצרים קבוצת Linux בצומת הבקרה עם אותו שם כמו שם המשתמש:
    sudo groupadd -f $(id -un)
sudo usermod -aG $(id -un) $(id -un)
  6. הגדרת Terraform יוצרת כמה סקריפטים של הגדרות ומעבירה אותם לספרייה /tmp/ של מכונת הבקרה, שכוללת פרטים כמו שם האשכול, חשבון השירות, שם הפרויקט וכו'. יוצרים גישת SSH ללא סיסמה מצמתי הבקרה לכל צמתי האשכול באמצעות סקריפטים להגדרה בצומת הבקרה.
    ‫
    /tmp/setup-ssh-for-cluster.sh
    חשוב: כדאי לרשום את המשתמש service_account. נשתמש בזה כ-SSH_USER בהמשך ה-Codelab.
  7. בשיעור Codelab הזה, אפשר להשבית את SELinux בכל הצמתים. סקריפט Terraform מוסיף את ‎/tmp/run-all.sh, שאפשר להשתמש בו למטרה הזו.
    /tmp/run-all.sh sudo setenforce 0
  8. אם נרשמתם ל-AlloyDB Omni וקיבלתם את הקישורים, הגיע הזמן להוסיף את כתובות ה-URL האלה גם למשתני הסביבה.
    ‫
    cat >> ~/.codelab.env <<EOF
export ORCHESTRATOR_ANSIBLE_COLLECTION_PATH="..."
export ALLOYDB_OMNI_REPOSITORY_URL="..."
export ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL="..."
export ALLOYDB_OMNI_COMMON_REPOSITORY_URL="..."
export ETCD_REPOSITORY_URL="..."
EOF
    מחליטים על כתובת IP וירטואלית לסביבה מתוך משתנה הקלט cidr_range בקובץ terraform/variables.tf כך שלא תהיה התנגשות עם הצמתים האחרים, כמו בדוגמה הבאה:
    cat >> ~/.codelab.env <<EOF
export VIRTUAL_IP="10.1.0.50"
EOF

5. התקנת רכיבי תוכנה נדרשים בכל המכונות הווירטואליות

השלב הבא הוא להתקין את רכיבי התוכנה הנדרשים במכונות הווירטואליות. אפשר לתאם את הפעולה הזו בצומת הבקרה. צריך להריץ את כל הפקודות הבאות בצומת הבקרה.

  1. מתחברים למכונה הווירטואלית של אמצעי הבקרה באמצעות SSH, אם עדיין לא מחוברים לצומת הבקרה.
    ‫
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
    אחרי שמגיעים להנחיית ה-SSH של מכונת הבקרה, מפעילים את קובץ הסביבה.
    source ~/.codelab.env
  2. בצומת הבקרה, מתקינים את Ansible ואת ספריות Python הנדרשות.
    sudo dnf install -y https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm -y
sudo dnf install -y ansible
sudo dnf install -y python3-grpcio python3-protobuf python3-googleapis-common-protos python3-grpcio-status
  3. לאחר מכן, מורידים את קובץ ה-tar של אוסף ה-RPM Orchestrator Ansible ומתקינים אותו.
    ‫
    gcloud storage cp "gs://${ORCHESTRATOR_ANSIBLE_COLLECTION_PATH#https://storage.googleapis.com/}google-alloydbomni_orchestrator-*.tar.gz" .
COLLECTION_FILE=$(ls -1 google-alloydbomni_orchestrator-*.tar.gz \
  | sort -V | tail -n 1)
ansible-galaxy collection install "$COLLECTION_FILE"
ansible-galaxy collection list | grep alloydbomni_orchestrator
    הפקודות sort -V ו-tail -n 1 בוחרות את הקובץ עם הגרסה העדכנית ביותר. הערה: חשוב לוודא שהמשתנה ORCHESTRATOR_ANSIBLE_COLLECTION_PATH מסתיים ב-'/'.
  4. הכלי לארגון הפעולות משתמש בקובץ מפרט פריסה בפורמט מלאי של Ansible כדי להבין את הטופולוגיה של האשכול. יוצרים קובץ בשם deployment_spec.yaml עם פרטי הצומת בצומת הבקרה.
    cat > deployment_spec.yaml <<EOF
alloydbomni:
  vars:
    cluster_manager:
      name: "$CLUSTER"
    etcd:
      setup: true
      config_forcewrite: true
    alloydbomni:
      major_version: "18"
      repo_url: $ALLOYDB_OMNI_REPOSITORY_URL
    alloydbomni_monitor:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL
    alloydbomni_cluster_manager:
      repo_url: $ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL
    alloydbomni_node_manager:
      repo_url: $ALLOYDB_OMNI_ORCHESTRATOR_REPOSITORY_URL
    pgbouncer:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL
    pgbackrest:
      repo_url: $ALLOYDB_OMNI_COMMON_REPOSITORY_URL

  children:
    primary_instance_nodes:
      hosts:
        $CLUSTER-db1:
        $CLUSTER-db2:
        $CLUSTER-db3:
    load_balancer_nodes:
      hosts:
        $CLUSTER-haproxy1:
        $CLUSTER-haproxy2:
EOF
    הערה: חשוב לבדוק את הקובץ שנוצר כדי לוודא שהוא מכיל ערכים תקינים.
  5. יוצרים playbook בשם install.yaml שמפנה לתפקיד install מאוסף כלי התזמור.
    cat > install.yaml <<EOF
- name: Install AlloyDB Omni cluster components
  hosts: all
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
    - role: google.alloydbomni_orchestrator.install
EOF
    הערה: חשוב לבדוק את הקובץ שנוצר כדי לוודא שהוא מכיל ערכים תקינים.
  6. מריצים את מדריך ההפעלה באמצעות קובץ המלאי כדי להוריד ולהתקין את חבילות ה-RPM בכל הצמתים שצוינו.
    ansible-playbook -i deployment_spec.yaml install.yaml

6. אתחול אשכול AlloyDB Omni

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

  1. מתחברים למכונה הווירטואלית של אמצעי הבקרה באמצעות SSH, אם עדיין לא מחוברים לצומת הבקרה.
    ‫
    gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
    אחרי שמגיעים להנחיית ה-SSH של מכונת הבקרה, מפעילים את קובץ הסביבה.
    source ~/.codelab.env
  2. יוצרים גיבוב (hash) לסיסמה ומאחזרים את הגרסה המותקנת של מסד הנתונים AlloyDB Omni:
    encoded_password=$(echo -n "your unique password" | base64)
DB_VERSION=$(/tmp/run-all.sh -t db 'rpm -q --qf "%{VERSION}\n" alloydbomni18' | tail -n 1)
echo "$DB_VERSION"
  3. כדי ליצור אשכול, AlloyDB Omni צריך לדעת איך להגדיר אותו. יוצרים שם קובץ dbcluster.yaml למפרטים של אשכול מסד הנתונים.
    cat > dbcluster.yaml <<EOF
Secret:
  metadata:
    name: db-pw-$CLUSTER
  spec:
    type: Opaque
    data:
      $CLUSTER: $encoded_password
---
DBCluster:
  metadata:
    name: $CLUSTER
  spec:
    databaseVersion: $DB_VERSION
    mode: ""
    availability:
      numberOfStandbys: 2
      enableAutoFailover: true
      enableAutoHeal: true
      autoFailoverTriggerThreshold: 2
      autoHealTriggerThreshold: 2
      healthcheckPeriodSeconds: 5
      replayReplicationSlotsOnStandbys: false
    primarySpec:
      adminUser:
        passwordRef:
          name: db-pw-$CLUSTER
      resources:
        cpu: 4
        memory: 32Gi
        disks:
        - name: DataDisk
          path: $PGDATA
      dbLoadBalancerOptions:
        gcp:
          loadBalancerIP: "$VIRTUAL_IP"
          loadBalancerType: "internal"
          loadBalancerInterface: "eth0"
EOF
  4. יוצרים playbook בשם bootstrap.yaml, שיפנה לתפקיד bootstrap ansible ליצירת אשכול AlloyDB Omni.
    cat > bootstrap.yaml <<EOF
- name: Create DBCluster
  hosts: localhost
  roles:
  - role: google.alloydbomni_orchestrator.bootstrap
EOF
  5. מריצים את ה-playbook כדי ליצור אשכול
    ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=dbcluster.yaml

7. (אופציונלי) הגדרת PgBouncer Connection Pooler

‫AlloyDB Omni תומך בניהול מאגר חיבורים קל משקל באמצעות PgBouncer. אפשר להגדיר את PgBouncer ולבצע אתחול שלו מיד אחרי הקצאת האשכול.

  1. יוצרים קובץ מפרט משאבים בשם pgbouncer.yaml שמקשר את מאגר החיבורים לאשכול מסד הנתונים:
    cat > pgbouncer.yaml <<EOF
PgBouncer:
  metadata:
    name: pgbouncer-pooler
  spec:
    dbclusterRef: $CLUSTER
    allowSuperUserAccess: true
    accessMode: "rw"
    port: 6432
EOF
  2. מפעילים את PgBouncer pooler באמצעות אותו playbook של bootstrap.yaml שנוצר קודם, ומעבירים את קובץ המפרט החדש:
    ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=pgbouncer.yaml

8. בדיקת אשכול AlloyDB Omni

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

  1. מתקינים את מאגר הלקוח ואת החבילה של PostgreSQL 18 בצומת הבקרה:
    sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
sudo dnf install -y postgresql18
  2. מתחברים לאשכול באמצעות כתובת ה-IP הווירטואלית שהוזמנה קודם. תוצג בקשה להזין את הסיסמה שקידדתם ב-dbcluster.yaml:
    /usr/pgsql-18/bin/psql -h $VIRTUAL_IP -U postgres -W
  3. אחרי החיבור, אפשר להריץ שאילתות SQL בסיסיות כדי לוודא מה מצב האשכול. לדוגמה, אפשר לבדוק את גרסת מסד הנתונים:
    postgres=# SELECT version();
    הפלט אמור להראות ש-PostgreSQL 18 פועל עם AlloyDB Omni. מקלידים \q כדי לצאת מהפרומפט.

9. (אופציונלי) גיבוי נתונים באמצעות pgBackRest

‫AlloyDB Omni משתלב עם pgBackRest כדי לנהל גיבויים ישירות ל-Cloud Storage. אתם יכולים להגדיר תוכנית גיבוי ולהפעיל גיבוי על פי דרישה לקטגוריית GCS שנוצרה על ידי הגדרת Terraform.

  1. יוצרים קובץ מפרט של תוכנית גיבוי בשם backup_plan.yaml שמפנה לקטגוריית GCS שהוקצתה:
    cat > backup_plan.yaml <<EOF
BackupPlan:
  metadata:
    name: pgb-plan
  spec:
    dbclusterRef: $CLUSTER
    backupLocation:
      type: GCS
      gcsOptions:
        bucket: $CLUSTER-gcs-backups
        key: /backups
EOF
  2. יוצרים פלייבוק של Ansible בשם backup.yaml שמפנה לתפקיד ניהול הגיבוי:
    cat > backup.yaml <<EOF
- name: Manage AlloyDB Omni Backups
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.backup
EOF
  3. מחילים את תוכנית הגיבוי באמצעות קובץ ה-playbook‏ backup.yaml:
    ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=backup_plan.yaml
  4. אחרי שהתוכנית נוצרת בהצלחה, יוצרים קובץ משאב לגיבוי על פי דרישה בשם create_backup.yaml.
    cat > create_backup.yaml <<EOF
Backup:
  metadata:
    name: on-demand-backup
  spec:
    backupPlanRef: pgb-plan
    dbclusterRef: $CLUSTER
EOF
  5. מריצים את המדריך כדי להתחיל את הגיבוי:
    ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=create_backup.yaml
  6. כדי לאמת את סטטוס הגיבוי, יוצרים playbook של status.yaml:
cat > status.yaml <<EOF
- name: Fetch AlloyDB Omni Resource Status
  hosts: localhost
  roles:
    - role: google.alloydbomni_orchestrator.status
EOF
  1. מריצים את ה-playbook כדי לרשום את כל הגיבויים:
ansible-playbook status.yaml -i deployment_spec.yaml -e resource_type=Backup
  1. לחלופין, כדי לקבל מידע מפורט על גיבוי ספציפי שנוצר קודם, מעבירים את -e resource_name=on-demand-backup:
ansible-playbook status.yaml -i deployment_spec.yaml \
  -e resource_type=Backup \
  -e resource_name=on-demand-backup

10. מחיקת משאבים

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

  1. יוצרים פלייבוק בשם teardown.yaml:
    cat > teardown.yaml <<EOF
- name: Tear down AlloyDB Omni cluster
  hosts: localhost
  roles:
  - role: google.alloydbomni_orchestrator.delete
EOF
  2. מריצים את הפלייבוק באמצעות ansible-playbook. אם הגדרתם גיבויים, צריך קודם למחוק את משאבי הגיבוי והגיבוי המתוזמן:
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=Backup" -e "resource_name=on-demand-backup"
ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=BackupPlan" -e "resource_name=pgb-plan"
    אם הגדרתם את PgBouncer, צריך למחוק את משאב מאגר החיבורים:
    ‫
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=PgBouncer" -e "resource_name=pgbouncer-pooler"
    לאחר מכן, מציינים DBCluster כ-resource_type ומוחקים את אשכול מסד הנתונים עצמו:
    ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=DBCluster" -e "resource_name=$CLUSTER"
  3. אחרי שמוחקים את האשכול, מתנתקים מצומת הבקרה, חוזרים למסוף ועוברים לספריית העבודה של Terraform.
    הערה: אם התחברתם ל-Cloud Shell לאחרונה, צריך להגדיר את הפרטים הבאים:
    export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
  4. מוחקים את כלל חומת האש של VRRP ומכבים באופן סופי את המשאבים שמנוהלים על ידי Terraform:
    gcloud compute firewall-rules delete -q "$CLUSTER-allow-vrrp" --project="$PROJECT"
gcloud compute firewall-rules delete -q "$CLUSTER-allow-ssh" --project="$PROJECT"
terraform destroy
  5. מאשרים את ההשמדה כשמוצגת הבקשה. יכול להיות שמשאבי רשת או מסלולים שנותרו ימנעו מדי פעם את ההסרה המלאה, לכן כדאי להריץ את פקודות הניקוי הבטוחות הבאות כדי לוודא שכל כללי חומת האש, שער ה-NAT, הנתבים, המסלולים, רשתות המשנה והרשתות המשויכות מוסרים באופן מלא. מחליפים את REGION באזור הפריסה הספציפי, לדוגמה, us-central1:
    # Delete any remaining firewall rules associated with the cluster
gcloud compute firewall-rules list --project=$PROJECT 2> /dev/null | grep ^$CLUSTER- | cut -f1 -d' ' | \
  while read rule; do gcloud compute firewall-rules delete --project=$PROJECT --quiet $rule; done

# Delete the Cloud NAT gateway and router if they still exist
gcloud compute routers nats describe $CLUSTER-nat-gw --router=$CLUSTER-router --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute routers nats delete $CLUSTER-nat-gw --router=$CLUSTER-router --region=REGION --project=$PROJECT --quiet

gcloud compute routers describe $CLUSTER-router --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute routers delete $CLUSTER-router --region=REGION --project=$PROJECT --quiet

# Delete any remaining custom routes
gcloud compute routes list --project=$PROJECT --filter="network:$CLUSTER" --format="value(name)" 2>/dev/null | \
  while read route; do gcloud compute routes delete --project=$PROJECT --quiet $route 2>/dev/null || true; done

# Delete the subnet and network if they still exist
gcloud compute networks subnets describe $CLUSTER --region=REGION --project=$PROJECT 2>/dev/null \
  && gcloud compute networks subnets delete $CLUSTER --region=REGION --project=$PROJECT --quiet

gcloud compute networks describe $CLUSTER --project $PROJECT 2> /dev/null \
  && gcloud compute networks delete $CLUSTER --project $PROJECT --quiet

11. מזל טוב

כל הכבוד, סיימתם את ה-Codelab.

מה למדנו

  • איך יוצרים ומכינים מכונות וירטואליות של GCE ל-AlloyDB Omni.
  • איך מתקינים ומריצים את AlloyDB Omni RPM Orchestrator.
  • איך מתקינים ומגדירים חבילות AlloyDB Omni RPM לארכיטקטורת הפניה של HA.

מידע נוסף על AlloyDB Omni מופיע במאמרי העזרה.

12. סקר

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

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