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

Replicación lógica con AlloyDB Omni

1. Introducción

En este codelab, se muestra cómo configurar la replicación lógica entre instancias independientes de AlloyDB Omni. Implementarás varias instancias de AlloyDB Omni en una sola VM de Compute Engine y configurarás la replicación entre ellas con la extensión pglogical.

Ejecutar varias instancias en un solo nodo es útil para el desarrollo, las pruebas o la simulación de entornos de replicación. Al final de este codelab, tendrás una configuración de replicación que funcione con una instancia que actúe como proveedor y otra como suscriptor.

Requisitos previos

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

Qué aprenderás

Cómo crear y preparar una VM de Compute Engine para varias instancias de AlloyDB Omni con gcloud
Cómo instalar los RPM de AlloyDB Omni
Cómo configurar e inicializar varias instancias de AlloyDB Omni con plantillas de systemd
Cómo configurar la replicación lógica entre instancias de AlloyDB Omni con pglogical
Cómo verificar la replicación replicando datos del proveedor al suscriptor

Requisitos

Obtén un vínculo de URL a los RPM de AlloyDB Omni. Los vínculos se envían a tu correo electrónico, incluido un vínculo al servidor de URLs del repositorio. Inicializa la siguiente variable de entorno para mantener la URL lista para usar durante el codelab.
```
export ALLOYDB_OMNI_REPOSITORY_URL="..."
```
Una terminal en funcionamiento con acceso a Google Cloud Puedes usar Cloud Shell para este propósito.

2. Configuración y requisitos

Configura el 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.

Inicie Cloud Shell

Si bien puedes operar Google Cloud de forma 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.

Ícono para activar Cloud Shell

Abre la consola de Google Cloud y haz clic en el ícono de Cloud Shell en la barra de herramientas de la parte superior derecha.También puedes abrir Cloud Shell de una de las siguientes maneras:
- Si usas la consola de Google Cloud, presiona G y, luego, S.
- Haz clic en este vínculo.

Por lo general, Cloud Shell tarda unos minutos en aprovisionar y conectarse al entorno. Cuando se complete esta operación, verás un resultado similar al siguiente:

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

3. Crea la VM de Compute Engine

En esta sección, crearás una sola máquina virtual (VM) de Compute Engine con la herramienta de línea de comandos gcloud. Usa una imagen de Rocky Linux 9, que es totalmente compatible con los RPM de AlloyDB Omni.

Define variables de entorno para el ID del proyecto, el nombre de la VM, la zona y la región.

export PROJECT="your-project-id"
export INSTANCE_NAME="alloydb-omni-multi-vm"
export ZONE="us-central1-c"
export REGION="us-central1"

Accede con tu cuenta de Google Cloud y configura el proyecto predeterminado.
```
gcloud auth login
gcloud config set project $PROJECT
```

Para permitir las conexiones SSH a tu VM con Identity-Aware Proxy (IAP), crea una regla de firewall.

gcloud compute firewall-rules create allow-ssh-alloydb-omni \
    --project=$PROJECT \
    --direction=INGRESS \
    --action=allow \
    --rules=tcp:22 \
    --source-ranges="0.0.0.0/0"

Como la VM se crea sin una dirección IP pública, configura un Cloud Router y una puerta de enlace de Cloud NAT para permitir que la VM acceda a repositorios de paquetes externos y descargue el software requerido.

gcloud compute routers create alloydb-omni-router \
    --project=$PROJECT \
    --network=default \
    --region=$REGION

gcloud compute routers nats create alloydb-omni-nat \
    --project=$PROJECT \
    --router=alloydb-omni-router \
    --region=$REGION \
    --nat-all-subnet-ip-ranges \
    --auto-allocate-nat-external-ips

Verifica que tu red de nube privada virtual (VPC) tenga una ruta de puerta de enlace de Internet predeterminada válida. Esta ruta es necesaria para que Cloud NAT reenvíe el tráfico saliente a Internet.
```
gcloud compute routes create default-internet-route \
    --project=$PROJECT \
    --network=default \
    --destination-range=0.0.0.0/0 \
    --next-hop-gateway=default-internet-gateway
```

Crea la instancia de VM de Compute Engine con las especificaciones requeridas (16 vCPU, 20 GB de disco persistente balanceado, Rocky Linux 9). Para mejorar la seguridad, usa la marca --no-address para asegurarte de que a la VM no se le asigne una dirección IP pública.

gcloud compute instances create $INSTANCE_NAME \
    --project=$PROJECT \
    --zone=$ZONE \
    --machine-type=n2-highmem-16 \
    --image-family=rocky-linux-9 \
    --image-project=rocky-linux-cloud \
    --boot-disk-size=20GB \
    --boot-disk-type=pd-balanced \
    --no-address

Después de crear la VM, verifica su estado.

gcloud compute instances list --filter="name=$INSTANCE_NAME" --project=$PROJECT

4. Prepara la VM

En esta sección, te conectarás a la VM que acabas de crear y prepararás el entorno del sistema operativo.

Conéctate a la VM a través de SSH con IAP. Debido a que la VM no tiene una dirección IP pública, gcloud automáticamente crea un túnel para la conexión SSH a través de IAP.
```
gcloud compute ssh $INSTANCE_NAME --zone=$ZONE --project=$PROJECT --tunnel-through-iap
```
Define una variable de entorno para el directorio de datos base.
```
export BASE_PGDATA="/var/lib/alloydbomni"
```
Crea el directorio de datos base.
```
sudo mkdir -p $BASE_PGDATA
```
Instala el paquete policycoreutils-python-utils para que se pueda configurar la política de SELinux.
```
sudo dnf install -y policycoreutils-python-utils
```

5. Instalar AlloyDB Omni

Con la VM preparada, ahora puedes configurar el repositorio de paquetes e instalar el paquete RPM de AlloyDB Omni.

Crea el archivo de configuración del repositorio para configurar el repositorio de YUM en tu VM. Reemplaza $ALLOYDB_OMNI_REPOSITORY_URL por la URL que recibiste.

export ALLOYDB_OMNI_REPOSITORY_URL="..."
sudo tee /etc/yum.repos.d/alloydbomni.repo << EOF
[alloydbomni]
name=alloydbomni
baseurl=$ALLOYDB_OMNI_REPOSITORY_URL
enabled=1
repo_gpgcheck=0
gpgcheck=1
gpgkey=https://dl.google.com/linux/linux_signing_key.pub
EOF

Actualiza la caché de YUM.
```
sudo yum makecache
```
Instala la versión 18 del paquete RPM de AlloyDB Omni.
```
sudo dnf install -y alloydbomni18
```

6. Configura varias instancias

En esta sección, configurarás dos instancias: inst1 y inst2.

Para admitir varias instancias, crea el archivo de servicio de la plantilla systemd alloydbomni18@.service.

sudo tee /etc/systemd/system/alloydbomni18@.service << EOF
[Unit]
Description=AlloyDB Omni Database server instance %I
After=syslog.target
After=network-online.target

[Service]
SyslogIdentifier=alloydbomni-%I
Type=notify

User=postgres
Group=postgres

# Load configuration for the instance
EnvironmentFile=/etc/alloydbomni/%I.conf

OOMScoreAdjust=-1000
Environment=PG_OOM_ADJUST_FILE=/proc/self/oom_score_adj
Environment=PG_OOM_ADJUST_VALUE=0

ExecStartPre=/usr/lib/postgresql/18/bin/alloydbomni18-check-db-dir \${PGDATA}
ExecStart=/usr/lib/postgresql/18/bin/postgres -D \${PGDATA}
ExecReload=/bin/kill -HUP \$MAINPID

KillMode=mixed
KillSignal=SIGINT

TimeoutSec=0
TimeoutStartSec=0
TimeoutStopSec=1h

[Install]
WantedBy=multi-user.target
EOF

Vuelve a cargar la configuración del administrador de systemd para reconocer el nuevo servicio de plantillas.
```
sudo systemctl daemon-reload
```
Crea el directorio de configuración para las instancias de AlloyDB Omni.
```
sudo mkdir -p /etc/alloydbomni
```

Configura el directorio de datos para inst1.

sudo tee /etc/alloydbomni/inst1.conf << EOF
PGDATA=/var/lib/alloydbomni/inst1
EOF

Configura el directorio de datos para inst2.

sudo tee /etc/alloydbomni/inst2.conf << EOF
PGDATA=/var/lib/alloydbomni/inst2
EOF

Establece los permisos adecuados en los archivos de configuración.

sudo chmod 640 /etc/alloydbomni/*.conf
sudo chown postgres:postgres /etc/alloydbomni/*.conf

Crea los directorios de datos para ambas instancias y establece la propiedad correcta.

sudo mkdir -p /var/lib/alloydbomni/inst1
sudo mkdir -p /var/lib/alloydbomni/inst2
sudo chown -R postgres:postgres /var/lib/alloydbomni
sudo chmod 750 /var/lib/alloydbomni/inst1 /var/lib/alloydbomni/inst2

Opcional: Establece límites de recursos para cada instancia. Esto evita que una instancia consuma todos los recursos de la VM. Crea directorios y archivos de anulación de systemd para ambas instancias.Nota: Los límites de recursos que se usan en las siguientes configuraciones (40%) son valores de ejemplo. Ajusta los límites según tu carga de trabajo específica y la capacidad de la VM.Para inst1, haz lo siguiente:
```
sudo mkdir -p /etc/systemd/system/alloydbomni18@inst1.service.d
sudo tee /etc/systemd/system/alloydbomni18@inst1.service.d/override.conf << EOF
[Service]
CPUQuota=40%
MemoryMax=40%
EOF
```
Para inst2:
```
sudo mkdir -p /etc/systemd/system/alloydbomni18@inst2.service.d
sudo tee /etc/systemd/system/alloydbomni18@inst2.service.d/override.conf << EOF
[Service]
CPUQuota=40%
MemoryMax=40%
EOF
```

7. Inicializa y prepara bases de datos

Inicializa y prepara cada instancia de la base de datos por separado.

Configura SELinux en modo permisivo para la configuración.
```
sudo setenforce 0
```
Precaución: Configurar SELinux en modo permisivo inhabilita la aplicación y debe usarse con precaución. Se usa en este codelab para simplificar la instalación. En producción, configura las políticas de SELinux adecuadas para que AlloyDB Omni se ejecute en modo de aplicación forzosa. Puedes volver a habilitar la aplicación de la política después de la configuración ejecutando sudo setenforce 1.
Define una contraseña segura para el usuario administrador postgres de PostgreSQL. Esta contraseña se usa para ambas instancias en este codelab.
```
export PGPASSWORD="YourStrongPassword123!"
```
Nota: Aquí se pasan contraseñas con variables de entorno en la línea de comandos (p.ej., PGPASSWORD=$PGPASSWORD) para simplificar el codelab, pero esto puede exponer la contraseña en las listas de procesos. En producción, usa métodos más seguros, como un archivo .pgpass o un administrador de secretos.

Configura inst1

Inicializa el directorio de la base de datos para inst1.

sudo PGPASSWORD=$PGPASSWORD \
  PGDATA=/var/lib/alloydbomni/inst1 \
  /usr/lib/postgresql/18/bin/alloydbomni18-setup initdb

Actualiza el archivo postgresql.conf de la instancia para configurarla de modo que escuche en el puerto 5433.

sudo sed -i \
  "s/^#*[[:space:]]*port[[:space:]]*=[[:space:]]*[0-9]*/port = 5433/" \
  /var/lib/alloydbomni/inst1/postgresql.conf

Prepara la instancia de la base de datos para AlloyDB Omni.

sudo PGPASSWORD=$PGPASSWORD \
  PGDATA=/var/lib/alloydbomni/inst1 \
  PGPORT=5433 \
  /usr/lib/postgresql/18/bin/alloydbomni18-setup preparedb

Configura inst2

Inicializa el directorio de la base de datos para inst2.

sudo PGPASSWORD=$PGPASSWORD \
  PGDATA=/var/lib/alloydbomni/inst2 \
  /usr/lib/postgresql/18/bin/alloydbomni18-setup initdb

Configura la instancia para que escuche en el puerto 5434.

sudo sed -i \
  "s/^#*[[:space:]]*port[[:space:]]*=[[:space:]]*[0-9]*/port = 5434/" \
  /var/lib/alloydbomni/inst2/postgresql.conf

Prepara la instancia de la base de datos.

sudo PGPASSWORD=$PGPASSWORD \
  PGDATA=/var/lib/alloydbomni/inst2 \
  PGPORT=5434 \
  /usr/lib/postgresql/18/bin/alloydbomni18-setup preparedb

8. Inicia los servicios de AlloyDB Omni

Ahora puedes iniciar los servicios de systemd para ambas instancias.

Para reconocer la nueva configuración y las anulaciones, vuelve a cargar la configuración del administrador de systemd.
```
sudo systemctl daemon-reload
```

Habilita e inicia el servicio para inst1.

sudo systemctl enable alloydbomni18@inst1
sudo systemctl start alloydbomni18@inst1

Habilita e inicia el servicio para inst2.

sudo systemctl enable alloydbomni18@inst2
sudo systemctl start alloydbomni18@inst2

Verifica que ambos servicios estén activos y en ejecución.
```
sudo systemctl status alloydbomni18@inst1
sudo systemctl status alloydbomni18@inst2
```
Verifica que el resultado de ambos indique Active: active (running).

9. Verifica las instancias de AlloyDB Omni

Verifica que ambas instancias funcionen correctamente y sean independientes.

Conéctate a inst1 (puerto 5433). Se te solicitará la contraseña que configuraste en Inicializa y prepara bases de datos.
```
/usr/lib/postgresql/18/bin/psql -h localhost -p 5433 -U postgres -W
```
Ejecuta una consulta para verificar la conexión.
```
postgres=# SELECT version();
```
Desconéctate de la instancia.
```
postgres=# \q
```

Conéctate a inst2 (puerto 5434).

/usr/lib/postgresql/18/bin/psql -h localhost -p 5434 -U postgres -W

Ejecuta una consulta para verificar la conexión.
```
postgres=# SELECT version();
```
Desconéctate de la instancia.
```
postgres=# \q
```

10. Configura la replicación pglogical

Configura la replicación lógica entre las dos instancias con la extensión pglogical. En este caso, inst1 actúa como proveedor y inst2 como suscriptor.

Nota: En este codelab, se usa el superusuario postgres para las conexiones de replicación. En un entorno de producción, crea un usuario de replicación dedicado con privilegios de REPLICATION y otórgale acceso solo a las tablas que se replican.

Configura instancias para pglogical

Habilita pglogical en shared_preload_libraries y configura otros parámetros de replicación en postgresql.conf para inst1.

# Append pglogical to shared_preload_libraries
sudo sed -i \
  "s/\(shared_preload_libraries\s*=\s*'\)\([^']*\)'/\1\2,pglogical'/" \
  /var/lib/alloydbomni/inst1/postgresql.conf

# Append replication settings
sudo tee -a /var/lib/alloydbomni/inst1/postgresql.conf << EOF
wal_level = logical
max_replication_slots = 10
max_wal_senders = 10
max_worker_processes = 20
track_commit_timestamp = on
alloydb.enable_pglogical = on
alloydb.logical_decoding = on
EOF

Establece la configuración para inst2 que configuraste para inst1.

# Append pglogical to shared_preload_libraries
sudo sed -i \
  "s/\(shared_preload_libraries\s*=\s*'\)\([^']*\)'/\1\2,pglogical'/" \
  /var/lib/alloydbomni/inst2/postgresql.conf

# Append replication settings
sudo tee -a /var/lib/alloydbomni/inst2/postgresql.conf << EOF
wal_level = logical
max_replication_slots = 10
max_wal_senders = 10
max_worker_processes = 20
track_commit_timestamp = on
alloydb.enable_pglogical = on
alloydb.logical_decoding = on
EOF

Para aplicar los cambios de configuración, reinicia ambas instancias.

sudo systemctl restart alloydbomni18@inst1
sudo systemctl restart alloydbomni18@inst2

Configura roles y tablas de replicación

En inst1 (proveedor, puerto 5433), crea un rol de replicación y la tabla que se replicará.

/usr/lib/postgresql/18/bin/psql -h localhost -p 5433 \
  -U postgres -d postgres -c "
  DO \$\$
  BEGIN
    IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'app_owner') THEN
      CREATE ROLE app_owner WITH LOGIN PASSWORD 'Password123';
    END IF;
  END
  \$\$;
  GRANT ALL ON SCHEMA public TO app_owner;
  CREATE TABLE IF NOT EXISTS replication_test (
      id SERIAL PRIMARY KEY,
      data TEXT,
      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  );
  ALTER TABLE replication_test OWNER TO app_owner;
"

En inst2 (suscriptor, puerto 5434), crea el mismo rol y la misma estructura de tabla.

/usr/lib/postgresql/18/bin/psql -h localhost -p 5434 \
  -U postgres -d postgres -c "
  DO \$\$
  BEGIN
    IF NOT EXISTS (SELECT FROM pg_catalog.pg_roles WHERE rolname = 'app_owner') THEN
      CREATE ROLE app_owner WITH LOGIN PASSWORD 'Password123';
    END IF;
  END
  \$\$;
  GRANT ALL ON SCHEMA public TO app_owner;
  CREATE TABLE IF NOT EXISTS replication_test (
      id SERIAL PRIMARY KEY,
      data TEXT,
      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
  );
  ALTER TABLE replication_test OWNER TO app_owner;
"

Configura los nodos y la suscripción de pglogical

Inicializa el nodo proveedor de pglogical en inst1.

/usr/lib/postgresql/18/bin/psql -h localhost -p 5433 \
  -U postgres -d postgres -c "
  CREATE EXTENSION IF NOT EXISTS pglogical;
  SELECT pglogical.create_node(
      node_name := 'provider',
      dsn := 'host=127.0.0.1 port=5433 dbname=postgres user=postgres password=YourStrongPassword123!'
  );
  SELECT pglogical.replication_set_add_table('default', 'replication_test');
"

Inicializa el nodo suscriptor de pglogical y crea la suscripción en inst2.

/usr/lib/postgresql/18/bin/psql -h localhost -p 5434 \
  -U postgres -d postgres -c "
  CREATE EXTENSION IF NOT EXISTS pglogical;
  SELECT pglogical.create_node(
      node_name := 'subscriber',
      dsn := 'host=127.0.0.1 port=5434 dbname=postgres user=postgres password=YourStrongPassword123!'
  );
  SELECT pglogical.create_subscription(
      subscription_name := 'test_subscription',
      provider_dsn := 'host=127.0.0.1 port=5433 dbname=postgres user=postgres password=YourStrongPassword123!'
  );
"

Nota: Después de crear la suscripción, es posible que la sincronización inicial tarde un momento en completarse.

11. Verifica la replicación de pglogical

Verifica que la replicación funcione según lo esperado insertando datos en el proveedor y consultándolos en el suscriptor.

Verifica que la suscripción esté activa. La transición a replicating podría tardar unos segundos.

/usr/lib/postgresql/18/bin/psql -t -A -h localhost -p 5434 \
  -U postgres -d postgres -c "
  SELECT status FROM pglogical.show_subscription_status() WHERE subscription_name = 'test_subscription';
  "

Antes de continuar, confirma que el resultado muestre replicating.

Inserta una fila de prueba en el proveedor (inst1).

/usr/lib/postgresql/18/bin/psql -h localhost -p 5433 \
  -U postgres -d postgres -c "
  INSERT INTO replication_test (data) VALUES ('Hello from replication provider!');
"

Para verificar que los datos se hayan replicado, consulta la tabla en inst2.
```
/usr/lib/postgresql/18/bin/psql -h localhost -p 5434 \
  -U postgres -d postgres -c "SELECT * FROM replication_test;"
```
Confirma que puedes ver la fila insertada en inst1.

12. Limpieza

Limpia los recursos. Primero, destruye las instancias de AlloyDB Omni en la VM y, luego, borra los recursos de Google Cloud.

Destruye instancias de AlloyDB Omni

Antes de borrar la VM, puedes limpiar las instancias de AlloyDB Omni deteniendo y, luego, inhabilitando los servicios, y quitando su configuración y datos.

Detiene y deshabilita el servicio para inst1, y quita sus datos y configuración.

sudo systemctl stop alloydbomni18@inst1
sudo systemctl disable alloydbomni18@inst1
sudo rm -rf /var/lib/alloydbomni/inst1
sudo rm -f /etc/alloydbomni/inst1.conf

Detiene y deshabilita el servicio para inst2, y quita sus datos y configuración.

sudo systemctl stop alloydbomni18@inst2
sudo systemctl disable alloydbomni18@inst2
sudo rm -rf /var/lib/alloydbomni/inst2
sudo rm -f /etc/alloydbomni/inst2.conf

Vuelve a cargar la configuración del administrador de systemd y restablece las unidades con errores.
```
sudo systemctl daemon-reload
sudo systemctl reset-failed
```

Borra los recursos de Google Cloud

Después de limpiar las instancias, borra la VM de Compute Engine y otros recursos.

Desconéctate de la sesión de SSH.
```
exit
```

Borra la instancia de VM de Compute Engine.

gcloud compute instances delete $INSTANCE_NAME --zone=$ZONE --project=$PROJECT --quiet

Borra la regla de firewall.

gcloud compute firewall-rules delete allow-ssh-alloydb-omni --project=$PROJECT --quiet

Borra Cloud NAT y el router.

gcloud compute routers nats delete alloydb-omni-nat --router=alloydb-omni-router --region=$REGION --project=$PROJECT --quiet
gcloud compute routers delete alloydb-omni-router --region=$REGION --project=$PROJECT --quiet

Borra la ruta de Internet predeterminada.

gcloud compute routes delete default-internet-route --project=$PROJECT --quiet

13. Felicitaciones

Implementaste y configuraste correctamente varias instancias de AlloyDB Omni en una sola VM de Compute Engine.

Temas abordados

Cómo aprovisionar y preparar una VM de Compute Engine
Cómo instalar los RPM de AlloyDB Omni
Cómo configurar plantillas de systemd para varias instancias
Cómo inicializar, configurar e iniciar varios servicios independientes en diferentes puertos
Cómo verificar la independencia de cada instancia

Más información

Consulta la documentación de AlloyDB Omni para obtener más información sobre la instalación y la configuración.
Para obtener detalles sobre la extensión de replicación que se usa en este codelab, consulta la documentación de pglogical.