Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Déployer un cluster AlloyDB Omni à haute disponibilité sur des VM GCE à l'aide de RPM Orchestrator

1. Introduction

Cet atelier de programmation explique comment déployer un cluster AlloyDB Omni à haute disponibilité sur des machines virtuelles Google Compute Engine (GCE). À la fin de cet atelier de programmation, vous provisionnerez une architecture de référence HA composée de trois nœuds de base de données et de deux nœuds HAProxy, ainsi que d'un nœud de contrôle pour les opérations de gestion.

Prérequis

Accès à un projet Google Cloud et à Cloud Shell depuis la console Cloud.
Le SDK Google Cloud (gcloud) est installé et configuré. Pour en savoir plus sur l'installation de gcloud, consultez gcloud-install.
Terraform v1.9.8 est installé.

Points abordés

Découvrez comment créer et préparer des VM GCE pour AlloyDB Omni.
Comment installer et exécuter l'outil d'orchestration RPM AlloyDB Omni.
Comment installer et configurer les RPM AlloyDB Omni pour l'architecture de référence HA.

Prérequis

Obtenez le lien URL vers les RPM AlloyDB Omni et l'outil d'orchestration RPM. Pour ce faire, vous devez remplir le formulaire d'inscription à AlloyDB Omni. Les liens sont envoyés à l'adresse e-mail du serveur d'URL du dépôt. Initialisez les variables d'environnement suivantes pour conserver les URL à portée de main, qui seront utilisées pendant l'atelier de programmation.
```
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="..."
```
Un terminal fonctionnel ayant accès à la pile de déploiement AlloyDB Omni. Vous pouvez utiliser Cloud Shell à cette fin.

2. Préparation

Configuration du projet

Créer un projet Google Cloud

Dans la console Google Cloud, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Icône d'activation de Cloud Shell

Vous pouvez également appuyer sur G, puis sur S. Cette séquence activera Cloud Shell si vous êtes dans la console Google Cloud ou si vous utilisez ce lien.

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Terminal Google Cloud Shell indiquant que l'environnement est connecté

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

3. Créer des machines virtuelles Google Cloud Compute Engine

Préparer les scripts Terraform

Définissez des variables d'environnement pour l'ID de votre projet et le nom de cluster souhaité. Vous les utiliserez tout au long de l'atelier de programmation.
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```
Remarque : L'ID du projet Google Cloud doit comporter entre 6 et 30 caractères. Pour en savoir plus, consultez https://docs.cloud.google.com/resource-manager/docs/creating-managing-projects#before_you_begin.
Assurez-vous d'être connecté avec un compte utilisateur Google Cloud.
```
gcloud auth login
```

Créez un répertoire de travail pour votre déploiement et copiez les fichiers de configuration Terraform requis à partir de la source de votre dépôt.

mkdir -p ~/alloydb-omni/$PROJECT/$CLUSTER
cd ~/alloydb-omni/$PROJECT/$CLUSTER
gcloud storage cp gs://alloydb-omni-install/rpm-orchestrator/gce/terraform/*.tf .

Créez un fichier terraform.tfvars pour spécifier les paramètres requis conformément à l'architecture de référence, comme suit :

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

Exécuter des scripts Terraform et valider

Vous pouvez maintenant provisionner les VM.
```
terraform init
```

Avant de créer des VM, assurez-vous de disposer des accès requis pour créer des VM et d'autres ressources. En résumé, vous aurez besoin des autorisations suivantes.

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

Validez la configuration et appliquez-la pour provisionner les ressources.
```
terraform validate
terraform apply --auto-approve
```
Remarque : Assurez-vous d'utiliser Terraform v1.9.8, comme prévu par la configuration du déploiement.
Une fois Terraform terminé, vérifiez que les machines virtuelles ont bien été créées en listant les instances créées à l'aide de gcloud.
```
gcloud compute instances list --filter="name~$CLUSTER" --project=$PROJECT
```
Vous devriez voir les instances correspondant à vos trois nœuds de base de données, à vos deux nœuds HAProxy, à la VM de contrôle et aux zones correspondantes. Enregistrez la ZONE du nœud de contrôle. Nous en aurons besoin plus tard dans cet atelier de programmation.
```
export ZONE=$(gcloud compute instances list \
  --filter="name=$CLUSTER-control"          \
  --format="value(zone)" --project=$PROJECT)
```

4. Préparer les VM pour le déploiement

Vous devez créer une session SSH sur le nœud de contrôle et suivre les étapes pour activer l'accès SSH à toutes les VM (également appelées nœuds).

Assurez-vous que les variables d'environnement de votre projet et de votre cluster sont définies.
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```

Créez une clé SSH et ajoutez-la pour vous connecter à la VM de contrôle.

# 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

Créez une règle de pare-feu pour autoriser les connexions SSH et le trafic 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"

Connectez-vous à la VM de contrôle via SSH :

gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT

Créez un groupe Linux sur le nœud de contrôle portant le même nom que le nom d'utilisateur :
```
sudo groupadd $(id -un)
sudo usermod -aG $(id -un) $(id -un)
```
La configuration Terraform crée quelques scripts de configuration et les prépare dans le répertoire /tmp/ de la VM de contrôle, qui inclut des éléments tels que le nom du cluster, le compte de service, le nom du projet, etc.Créez un accès SSH sans mot de passe à partir des nœuds de contrôle vers tous les nœuds du cluster à l'aide des scripts de configuration sur le nœud de contrôle.
```
/tmp/setup-ssh-for-cluster.sh
```
Important : Notez l'utilisateur service_account. Nous l'utiliserons comme SSH_USER plus tard dans cet atelier de programmation.
Pour cet atelier de programmation, nous pouvons désactiver SELinux sur tous les nœuds. Le script Terraform ajoute "/tmp/run-all.sh", qui peut être utilisé à cette fin.
```
/tmp/run-all.sh sudo setenforce 0
```
Si vous vous êtes inscrit à AlloyDB Omni et que vous avez obtenu les liens, il est temps d'ajouter ces URL aux variables d'environnement.
```
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
```
Choisissez une adresse IP virtuelle pour votre environnement à partir de la variable d'entrée cidr_range dans le fichier terraform/variables.tf afin qu'elle n'entre pas en conflit avec les autres nœuds, comme indiqué dans l'exemple suivant :
```
cat >> ~/.codelab.env <<EOF
export VIRTUAL_IP="10.1.0.50"
EOF
```

5. Installez les composants logiciels requis sur toutes les VM.

L'étape suivante consiste à installer les composants logiciels requis sur les VM. Cette coordination peut être effectuée sur le nœud de contrôle. Toutes les commandes suivantes doivent être exécutées sur le nœud de contrôle.

Connectez-vous à la VM de contrôle via SSH, si vous n'êtes pas déjà sur le nœud de contrôle.
```
gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
```
Une fois que vous êtes à l'invite SSH de la VM de contrôle, sourcez le fichier d'environnement.
```
source ~/.codelab.env
```

Sur le nœud de contrôle, installez Ansible et les bibliothèques Python requises.

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

Ensuite, téléchargez le fichier tar de la collection Ansible de RPM Orchestrator et installez-le.

gcloud storage cp "gs://${ORCHESTRATOR_ANSIBLE_COLLECTION_PATH#https://storage.googleapis.com/}google-alloydbomni_orchestrator-*.tar.gz" .
ansible-galaxy collection install google-alloydbomni_orchestrator-0.1.0-6.tar.gz
ansible-galaxy collection list | grep alloydbomni_orchestrator

Remarque : Assurez-vous que la variable ORCHESTRATOR_ANSIBLE_COLLECTION_PATH se termine par "/".

L'orchestrateur utilise un fichier de spécification de déploiement au format d'inventaire Ansible pour comprendre la topologie de votre cluster. Créez un fichier nommé deployment_spec.yaml avec les détails de votre nœud sur le nœud de contrôle.

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

Remarque : Examinez le fichier généré pour vous assurer qu'il fait référence à des valeurs valides.

Créez un playbook nommé install.yaml qui fait référence au rôle d'installation de la collection d'orchestrateur.

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

Remarque : Examinez le fichier généré pour vous assurer qu'il fait référence à des valeurs valides.

Exécutez le playbook à l'aide de votre fichier d'inventaire pour télécharger et installer les RPM sur tous les nœuds spécifiés.
```
ansible-playbook -i deployment_spec.yaml install.yaml
```

6. Amorcer le cluster AlloyDB Omni

À ce stade, nous avons installé tous les composants requis sur tous les nœuds. Nous sommes prêts à amorcer le cluster AlloyDB Omni.

Connectez-vous à la VM de contrôle via SSH, si vous n'êtes pas déjà sur le nœud de contrôle.
```
gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
```
Une fois que vous êtes à l'invite SSH de la VM de contrôle, sourcez le fichier d'environnement.
```
source ~/.codelab.env
```

Générez un hachage pour votre mot de passe et notez-le.

encoded_password=$(echo -n "your unique password" | base64)

Pour créer un cluster, AlloyDB Omni doit savoir comment le configurer. Créez un nom de fichier dbcluster.yaml pour les spécifications du cluster de bases de données.

cat > dbcluster.yaml <<EOF
Secret:
  metadata:
    name: db-pw-$CLUSTER
  spec:
    type: Opaque
    data:
      $CLUSTER: $encoded_password
---
DBCluster:
  metadata:
    name: $CLUSTER
  spec:
    databaseVersion: 18.1.0
    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

Créez un playbook nommé bootstrap.yaml, qui fera référence au rôle Ansible d'amorçage pour créer un cluster AlloyDB Omni.

cat > bootstrap.yaml <<EOF
- name: Create DBCluster
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
  - role: google.alloydbomni_orchestrator.bootstrap
EOF

Exécuter votre playbook pour créer un cluster

ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=dbcluster.yaml

7. (Facultatif) Configurer le pooler de connexions PgBouncer

AlloyDB Omni est compatible avec le pooling de connexions léger à l'aide de PgBouncer. Vous pouvez configurer et amorcer PgBouncer juste après le provisionnement de votre cluster.

Créez un fichier de spécification de ressources nommé pgbouncer.yaml qui associe le pooler de connexion à votre cluster de bases de données :

cat > pgbouncer.yaml <<EOF
PgBouncer:
  metadata:
    name: pgbouncer-pooler
  spec:
    dbclusterRef: $CLUSTER
    allowSuperUserAccess: true
    accessMode: "rw"
    port: 6432
EOF

Amorcez le pooler PgBouncer à l'aide du même playbook bootstrap.yaml créé précédemment, en transmettant le nouveau fichier de spécification :
```
ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=pgbouncer.yaml
```

8. Vérifier le cluster AlloyDB Omni

Pour vérifier que votre cluster fonctionne correctement et qu'il est accessible à l'aide de l'équilibreur de charge, vous pouvez vous y connecter à l'aide du client PostgreSQL standard à partir du nœud de contrôle.

Installez le dépôt et le package du client PostgreSQL 18 sur le nœud de contrôle :

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

Connectez-vous au cluster à l'aide de l'adresse IP virtuelle réservée précédemment. Vous serez invité à saisir le mot de passe que vous avez encodé dans dbcluster.yaml :
```
/usr/pgsql-18/bin/psql -h $VIRTUAL_IP -U postgres -W
```
Une fois connecté, vous pouvez exécuter des requêtes SQL de base pour vérifier l'état du cluster, par exemple en vérifiant la version de la base de données :
```
postgres=# SELECT version();
```
Vous devriez voir un résultat indiquant que PostgreSQL 18 s'exécute avec AlloyDB Omni. Saisissez \q pour quitter l'invite.

9. (Facultatif) Sauvegarder les données à l'aide de pgBackRest

AlloyDB Omni s'intègre à pgBackRest pour gérer les sauvegardes directement dans Cloud Storage. Vous pouvez configurer un plan de sauvegarde et déclencher une sauvegarde à la demande dans le bucket GCS créé par votre configuration Terraform.

Créez un fichier de spécification du plan de sauvegarde nommé backup_plan.yaml pointant vers le bucket GCS provisionné :

cat > backup_plan.yaml <<EOF
BackupPlan:
  metadata:
    name: pgb-plan
  spec:
    dbclusterRef: $CLUSTER
    backupLocation:
      type: GCS
      gcsOptions:
        bucket: $CLUSTER-gcs-backups
        key: /backups
EOF

Créez un playbook Ansible nommé backup.yaml qui fait référence au rôle de gestion des sauvegardes :

cat > backup.yaml <<EOF
- name: Manage AlloyDB Omni Backups
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
    - role: google.alloydbomni_orchestrator.backup
EOF

Appliquez le plan de sauvegarde à l'aide du playbook backup.yaml :

ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=backup_plan.yaml

Une fois le plan établi, créez un fichier de ressources de sauvegarde à la demande nommé create_backup.yaml.

cat > create_backup.yaml <<EOF
Backup:
  metadata:
    name: on-demand-backup
  spec:
    backupPlanRef: pgb-plan
    dbclusterRef: $CLUSTER
EOF

Exécutez le playbook pour lancer la sauvegarde :

ansible-playbook backup.yaml -i deployment_spec.yaml -e resource_spec=create_backup.yaml

Pour vérifier l'état de la sauvegarde, créez un fichier de règles status.yaml :

- name: Fetch AlloyDB Omni Resource Status
hosts: localhost
vars:
  ansible_become: true
  ansible_user: $SSH_USER
  ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
roles:
  - role: google.alloydbomni_orchestrator.status
EOF

Exécutez le playbook pour lister toutes les sauvegardes :

ansible-playbook status.yaml -i deployment_spec.yaml -e resource_type=Backup

Vous pouvez également transmettre -e resource_name=on-demand-backup pour obtenir des informations détaillées sur une sauvegarde spécifique créée précédemment :

ansible-playbook status.yaml -i deployment_spec.yaml \
  -e resource_type=Backup \
  -e resource_name=on-demand-backup

10. Nettoyer les ressources

Une fois le déploiement terminé, vous pouvez détruire les ressources provisionnées pour éviter d'être facturé.

Créez un playbook nommé teardown.yaml :

cat > teardown.yaml <<EOF
- name: Tear down AlloyDB Omni cluster
  hosts: localhost
  vars:
    ansible_become: true
    ansible_user: $SSH_USER
    ansible_ssh_private_key_file: $HOME/ssh-key-cluster-sa
  roles:
  - role: google.alloydbomni_orchestrator.delete
EOF

Exécutez le playbook à l'aide d'ansible-playbook. Si vous avez configuré des sauvegardes, supprimez d'abord les ressources Backup et BackupPlan :

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"

Si vous avez configuré PgBouncer, supprimez ensuite la ressource du pooler de connexions :

ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=PgBouncer" -e "resource_name=pgbouncer-pooler"

Spécifiez ensuite DBCluster comme resource_type et supprimez le cluster de bases de données lui-même :

ansible-playbook teardown.yaml -i deployment_spec.yaml  -e "resource_type=DBCluster" -e "resource_name=$CLUSTER"

Une fois le cluster supprimé, déconnectez-vous du nœud de contrôle, revenez à votre terminal et accédez à votre répertoire de travail Terraform.
Remarque : Si vous venez de vous connecter à Cloud Shell, n'oubliez pas de définir les éléments suivants :
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```

Supprimez la règle de pare-feu VRRP et détruisez les ressources gérées par 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

Confirmez la destruction lorsque vous y êtes invité. Étant donné que des ressources ou des routes réseau persistantes peuvent parfois empêcher la suppression complète, exécutez les commandes de nettoyage sécurisé suivantes pour vous assurer que toutes les règles de pare-feu, passerelles NAT, routes, sous-réseaux et réseaux associés sont entièrement supprimés. Remplacez REGION par votre région de déploiement spécifique, par exemple "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. Félicitations

Bravo ! Vous avez terminé cet atelier de programmation.

Points abordés

Découvrez comment créer et préparer des VM GCE pour AlloyDB Omni.
Comment installer et exécuter l'outil d'orchestration RPM AlloyDB Omni.
Comment installer et configurer les RPM AlloyDB Omni pour l'architecture de référence HA.

Pour en savoir plus sur AlloyDB Omni, consultez la documentation.

12. Enquête

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement

Je vais le lire et effectuer les exercices