Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Implementa un clúster de alta disponibilidad de AlloyDB Omni en VMs de GCE con RPM Orchestrator

1. Introducción

En este codelab, se muestra la implementación de un clúster de alta disponibilidad (HA) de AlloyDB Omni en máquinas virtuales (VM) de Google Compute Engine (GCE). Al final de este codelab, aprovisionarás una arquitectura de referencia de alta disponibilidad que consta de 3 nodos de base de datos y 2 nodos de HAProxy, junto con un nodo de control para las operaciones de administración.

Requisitos previos

Acceso a un proyecto de Google Cloud y a Cloud Shell desde Cloud Console
El SDK de Google Cloud (gcloud) instalado y configurado. Para obtener detalles sobre la instalación de gcloud, consulta gcloud-install.
Terraform v1.9.8 instalado.

Qué aprenderás

Cómo crear y preparar VMs de GCE para AlloyDB Omni
Cómo instalar y ejecutar el organizador de RPM de AlloyDB Omni
Cómo instalar y configurar los RPM de AlloyDB Omni para la arquitectura de referencia de HA

Requisitos

Obtén el vínculo de URL a los RPMs y al organizador de RPMs de AlloyDB Omni. Para ello, debes completar el formulario de registro de AlloyDB Omni. Los vínculos se envían a tu correo electrónico, que es el servidor de URLs del repositorio. Inicializa las siguientes variables de entorno para tener a mano las URLs que se usarán durante el 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="..."
```
Una terminal en funcionamiento con acceso a la pila de implementación de AlloyDB Omni Puedes usar Cloud Shell para este propósito.

2. Configuración y requisitos

Configuración del proyecto

Crea un proyecto de Google Cloud

En la consola de Google Cloud, en la página del selector de proyectos, selecciona o crea un proyecto de Google Cloud.
Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información para verificar si la facturación está habilitada en un proyecto.

Inicia Cloud Shell

Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En la consola de Google Cloud, haz clic en el ícono de Cloud Shell en la barra de herramientas de la parte superior derecha:

Ícono para activar Cloud Shell

También puedes presionar G y, luego, S. Esta secuencia activará Cloud Shell si estás en la consola de Google Cloud o usas este vínculo.

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Terminal de Google Cloud Shell que muestra que el entorno se conectó

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

3. Crea máquinas virtuales de Google Cloud Compute Engine

Prepara secuencias de comandos de Terraform

Define las variables de entorno para el ID del proyecto y el nombre del clúster deseado. Las usarás en todo el codelab.
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```
Nota: El ID del proyecto de Google Cloud debe tener entre 6 y 30 caracteres. Para obtener más información, consulta https://docs.cloud.google.com/resource-manager/docs/creating-managing-projects#before_you_begin.
Asegúrate de haber accedido con el usuario de la cuenta de Google Cloud.
```
gcloud auth login
```

Crea un directorio de trabajo para tu implementación y copia los archivos de configuración de Terraform necesarios desde la fuente de tu repositorio.

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

Crea un archivo terraform.tfvars para especificar los parámetros obligatorios según la arquitectura de referencia, como se muestra en el siguiente contenido:

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

Ejecuta secuencias de comandos de Terraform y valida

Ahora puedes aprovisionar las VMs.
```
terraform init
```

Antes de crear VMs, asegúrate de tener el acceso necesario para crear VMs y otros recursos. En resumen, necesitarás los siguientes permisos.

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

Valida la configuración y aplícala para aprovisionar los recursos.
```
terraform validate
terraform apply --auto-approve
```
Nota: Asegúrate de usar Terraform v1.9.8, como se espera en la configuración de implementación.
Una vez que Terraform finalice, verifica que las máquinas virtuales se hayan creado correctamente. Para ello, enumera las instancias creadas con gcloud.
```
gcloud compute instances list --filter="name~$CLUSTER" --project=$PROJECT
```
Deberías ver instancias que corresponden a tus 3 nodos de DB, 2 nodos de HAProxy y la VM de control, y las zonas correspondientes. Registra la ZONA del nodo de control. La necesitaremos más adelante en este codelab.
```
export ZONE=$(gcloud compute instances list \
  --filter="name=$CLUSTER-control"          \
  --format="value(zone)" --project=$PROJECT)
```

4. Prepara las VMs para la implementación

Debes crear una sesión SSH en el nodo de control y realizar los pasos para habilitar el acceso SSH a todas las VMs (también denominadas nodos).

Asegúrate de que estén definidas las variables de entorno de tu proyecto y clúster.
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```

Crea una clave SSH y agrega la misma para acceder a la VM de control.

# 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

Crea una regla de firewall para permitir conexiones SSH y también tráfico de 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"

Conéctate a la VM de control a través de SSH:

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

Crea un grupo de Linux en el nodo de control con el mismo nombre que el nombre de usuario:
```
sudo groupadd $(id -un)
sudo usermod -aG $(id -un) $(id -un)
```
La configuración de Terraform crea algunas secuencias de comandos de configuración y las organiza en el directorio /tmp/ de la VM de control, que incluye elementos como el nombre del clúster, la cuenta de servicio, el nombre del proyecto, etcétera.Crea acceso SSH sin contraseña desde los nodos de control a todos los nodos del clúster con secuencias de comandos de configuración en el nodo de control.
```
/tmp/setup-ssh-for-cluster.sh
```
Importante: Anota el usuario de service_account. Usaremos esto como SSH_USER más adelante en este codelab.
Para este codelab, podemos inhabilitar SELinux en todos los nodos. La secuencia de comandos de Terraform agrega "/tmp/run-all.sh", que se puede usar para este propósito.
```
/tmp/run-all.sh sudo setenforce 0
```

Si te registraste en AlloyDB Omni y obtuviste los vínculos, es hora de agregar esas URLs también a las variables de entorno.

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

Decide una IP virtual para tu entorno a partir de la variable de entrada cidr_range en el archivo terraform/variables.tf de modo que no entre en conflicto con los otros nodos, como se muestra en el siguiente ejemplo:

cat >> ~/.codelab.env <<EOF
export VIRTUAL_IP="10.1.0.50"
EOF

5. Instala los componentes de software necesarios en todas las VMs

El siguiente paso es instalar los componentes de SW requeridos en las VMs. Esto se puede coordinar en el nodo de control. Todos los siguientes comandos deben ejecutarse en el nodo de control.

Conéctate a la VM de control a través de SSH, si aún no estás en el nodo de control.
```
gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
```
Una vez que estés en el símbolo del sistema de SSH de la VM de control, obtén el archivo del entorno de origen.
```
source ~/.codelab.env
```

En el nodo de control, instala Ansible y las bibliotecas de Python requeridas.

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

A continuación, descarga el archivo tar de la colección de Ansible de RPM Orchestrator y, luego, instálalo.

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

Nota: Asegúrate de que la variable ORCHESTRATOR_ANSIBLE_COLLECTION_PATH tenga "/" al final.

El orquestador usa un archivo de especificación de implementación en formato de inventario de Ansible para comprender la topología de tu clúster. Crea un archivo llamado deployment_spec.yaml con los detalles de tu nodo en el nodo de control.

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

Nota: Revisa el archivo generado para asegurarte de que haga referencia a valores válidos.

Crea un playbook llamado install.yaml que haga referencia al rol de instalación de la colección del orquestador.

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

Nota: Revisa el archivo generado para asegurarte de que haga referencia a valores válidos.

Ejecuta el playbook con tu archivo de inventario para descargar e instalar los RPM en todos los nodos especificados.
```
ansible-playbook -i deployment_spec.yaml install.yaml
```

6. Arranca el clúster de AlloyDB Omni

En esta etapa, instalamos todos los componentes necesarios en todos los nodos. Ya podemos iniciar el clúster de AlloyDB Omni.

Conéctate a la VM de control a través de SSH, si aún no estás en el nodo de control.
```
gcloud compute ssh "$CLUSTER-control" --zone=$ZONE --project=$PROJECT
```
Una vez que estés en el símbolo del sistema de SSH de la VM de control, obtén el archivo del entorno de origen.
```
source ~/.codelab.env
```

Genera un hash para tu contraseña y anótalo.

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

Para crear un clúster, AlloyDB Omni debe saber cómo configurarlo. Crea un nombre de archivo dbcluster.yaml para las especificaciones del clúster de base de datos.

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

Crea un playbook llamado bootstrap.yaml, que hará referencia al rol de Ansible de arranque para crear el clúster de 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

Ejecuta tu guía para crear el clúster

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

7. (Opcional) Configura el agrupador de conexiones de PgBouncer

AlloyDB Omni admite la agrupación de conexiones liviana con PgBouncer. Puedes configurar y arrancar PgBouncer inmediatamente después de aprovisionar el clúster.

Crea un archivo de especificación de recursos llamado pgbouncer.yaml que asocie el agrupador de conexiones con tu clúster de base de datos:

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

Inicializa el agrupador de PgBouncer con el mismo playbook bootstrap.yaml que creaste antes y pasa el nuevo archivo de especificación:
```
ansible-playbook bootstrap.yaml -i deployment_spec.yaml -e resource_spec=pgbouncer.yaml
```

8. Verifica el clúster de AlloyDB Omni

Para verificar que tu clúster funcione correctamente y que se pueda acceder a él con el balanceador de cargas, puedes conectarte a él con el cliente estándar de PostgreSQL desde el nodo de control.

Instala el repositorio y el paquete del cliente de PostgreSQL 18 en el nodo de control:

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

Conéctate al clúster con la IP virtual que reservaste antes. Se te solicitará la contraseña que codificaste en dbcluster.yaml:
```
/usr/pgsql-18/bin/psql -h $VIRTUAL_IP -U postgres -W
```
Una vez que te conectes, puedes ejecutar consultas básicas de SQL para verificar el estado del clúster, por ejemplo, verificar la versión de la base de datos:
```
postgres=# SELECT version();
```
Deberías ver un resultado que indique que PostgreSQL 18 se está ejecutando con AlloyDB Omni. Escribe \q para salir del mensaje.

9. (Opcional) Crea una copia de seguridad de los datos con pgBackRest

AlloyDB Omni se integra con pgBackRest para administrar copias de seguridad directamente en Cloud Storage. Puedes configurar un plan de copias de seguridad y activar una copia de seguridad a pedido en el bucket de GCS que creó tu configuración de Terraform.

Crea un archivo de especificación del plan de copias de seguridad llamado backup_plan.yaml que apunte a tu bucket de GCS aprovisionado:

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

Crea un playbook de Ansible llamado backup.yaml que haga referencia al rol de administración de copias de seguridad:

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

Aplica el plan de copia de seguridad con el playbook backup.yaml:

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

Una vez que se establezca el plan correctamente, crea un archivo de recursos de copia de seguridad a pedido llamado create_backup.yaml.

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

Ejecuta la guía para iniciar la copia de seguridad:

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

Para verificar el estado de la copia de seguridad, crea un playbook 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

Ejecuta la guía para listar todas las copias de seguridad:

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

Como alternativa, para obtener información detallada sobre una copia de seguridad específica creada anteriormente, pasa -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. Limpia los recursos

Cuando termines con la implementación, puedes destruir los recursos aprovisionados para evitar incurrir en cargos.

Crea un playbook llamado 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

Ejecuta la guía con ansible-playbook. Si configuraste copias de seguridad, primero borra los recursos de Backup y 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 configuraste PgBouncer, borra el recurso del agrupador de conexiones a continuación:

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

Luego, especifica DBCluster como resource_type y borra el clúster de base de datos:

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

Una vez que se borre el clúster, sal del nodo de control, vuelve a tu terminal y navega a tu directorio de trabajo de Terraform.
Nota: Si acabas de acceder a Cloud Shell, recuerda configurar lo siguiente:
```
export PROJECT="your-project-id"
export CLUSTER="your-cluster-name"
```

Borra la regla de firewall de VRRP y destruye los recursos que administra 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

Confirma la destrucción cuando se te solicite. Dado que los recursos o las rutas de red persistentes pueden impedir ocasionalmente la eliminación completa, ejecuta los siguientes comandos de limpieza seguros para asegurarte de que se quiten por completo todas las reglas de firewall, las puertas de enlace de NAT, los routers, las rutas, las subredes y las redes asociadas. Reemplaza REGION por tu región de implementación específica, como "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. Felicitaciones

Felicitaciones por completar el codelab.

Temas abordados

Cómo crear y preparar VMs de GCE para AlloyDB Omni
Cómo instalar y ejecutar el organizador de RPM de AlloyDB Omni
Cómo instalar y configurar los RPM de AlloyDB Omni para la arquitectura de referencia de HA

Puedes obtener más información sobre AlloyDB Omni en la documentación.

12. Encuesta

¿Cómo usarás este instructivo?

Solo lo leeré

Lo leeré y completaré los ejercicios