Configuración de Replicación PostgreSQL: Guía Completa de Replicación en Streaming

Introducción

La replicación de PostgreSQL es una característica crítica para construir sistemas de bases de datos altamente disponibles y escalables que proporcionan redundancia de datos, capacidades de recuperación ante desastres y rendimiento de lectura mejorado. A diferencia de los métodos tradicionales de respaldo, la replicación crea copias en vivo de tu base de datos que permanecen sincronizadas con el servidor primario en tiempo real, asegurando una pérdida mínima de datos y máxima disponibilidad para tus aplicaciones.

PostgreSQL ofrece múltiples métodos de replicación, siendo la replicación en streaming el enfoque más popular y confiable. La replicación en streaming funciona enviando continuamente registros de Write-Ahead Log (WAL) desde el servidor primario a uno o más servidores en espera, donde se reproducen para mantener las bases de datos sincronizadas. Este mecanismo proporciona capacidades de conmutación por error casi instantáneas y permite consultas de solo lectura en servidores en espera, distribuyendo efectivamente la carga de la base de datos entre múltiples servidores.

Comprender la replicación de PostgreSQL es esencial para administradores de bases de datos que gestionan entornos de producción donde el tiempo de inactividad es costoso y la integridad de los datos es primordial. Esta guía completa cubre todo, desde la configuración básica de replicación en streaming hasta configuraciones avanzadas que incluyen replicación sincrónica, replicación en cascada y mecanismos de conmutación por error automatizada. Ya sea que estés construyendo una configuración simple maestro-espera o una topología de replicación multinivel compleja, esta guía proporciona el conocimiento y los pasos prácticos necesarios para una implementación exitosa.

Requisitos Previos

Antes de configurar la replicación de PostgreSQL, asegúrate de tener lo siguiente:

Requisitos del Servidor

• Dos o más servidores Linux (Ubuntu 20.04+, CentOS 8+ o Debian 11+)
• Un servidor designado como primario (maestro)
• Uno o más servidores designados como servidores en espera (réplica)
• Conectividad de red entre todos los servidores con baja latencia
• Relojes del sistema sincronizados usando NTP

Instalación de PostgreSQL

• PostgreSQL 12+ instalado en todos los servidores (PostgreSQL 14+ recomendado)
• Versiones idénticas de PostgreSQL en todos los servidores
• Servicio PostgreSQL ejecutándose en el servidor primario
• Acceso root o sudo a todos los servidores

Requisitos del Sistema

• Al menos 2GB de RAM por servidor (4GB+ recomendado para producción)
• Espacio en disco suficiente para archivos WAL y almacenamiento de base de datos
• E/S de disco rápida (SSD recomendado para almacenamiento WAL)
• Direcciones IP estáticas o nombres DNS confiables

Requisitos de Red

• Puerto 5432 (predeterminado de PostgreSQL) abierto entre servidores
• Acceso SSH (puerto 22) para configuración inicial y administración
• Ancho de banda suficiente para streaming WAL (mínimo 10Mbps)

Requisitos de Conocimiento

• Fundamentos de administración de PostgreSQL
• Dominio de línea de comandos Linux
• Comprensión de SQL y conceptos de bases de datos
• Conocimientos básicos de redes

Comprensión de la Replicación PostgreSQL

Arquitectura de Replicación

La replicación en streaming de PostgreSQL utiliza un enfoque basado en Write-Ahead Log (WAL):

1. Servidor Primario: Escribe todos los cambios en archivos WAL
2. Proceso WAL Sender: Transmite registros WAL a servidores en espera
3. Servidores en Espera: Reciben registros WAL a través de procesos receptores WAL
4. Reproducción WAL: Los servidores en espera aplican continuamente registros WAL
5. Hot Standby: Los servidores en espera pueden aceptar consultas de solo lectura

Tipos de Replicación

Replicación Física: Replicación a nivel de bytes del clúster de base de datos completo. Más común y eficiente, pero requiere arquitecturas de hardware idénticas.

Replicación Lógica: Replicación a nivel de tabla que replica cambios de datos a nivel lógico. Más flexible pero con mayor sobrecarga.

Replicación en Streaming: Streaming continuo de WAL desde primario a espera (enfoque de esta guía).

Envío de WAL Basado en Archivos: Transferencia periódica de archivos WAL completados. Simple pero con mayor retraso que el streaming.

Modos de Sincronización

Replicación Asíncrona: El primario confirma transacciones sin esperar confirmación del espera. Más rápido pero puede perder transacciones recientes en caso de fallo.

Replicación Sincrónica: El primario espera que al menos un espera confirme la recepción de WAL antes de confirmar. Más lento pero garantiza la seguridad de los datos.

Sincrónico Basado en Quórum: Requiere confirmación de un número específico de esperas antes de confirmar.

Configuración Paso a Paso

Paso 1: Configurar el Servidor Primario

Conéctate a tu servidor primario y edita el archivo de configuración de PostgreSQL:

sudo nano /etc/postgresql/14/main/postgresql.conf

Agrega o modifica los siguientes parámetros:

# --- CONFIGURACIÓN DE REPLICACIÓN ---

# Habilitar archivado WAL para replicación
wal_level = replica

# Número de servidores en espera concurrentes
max_wal_senders = 10

# Número de slots de replicación (uno por espera)
max_replication_slots = 10

# Retención WAL para recuperación de espera
wal_keep_size = 1GB

# Configuración de archivo (opcional pero recomendado)
archive_mode = on
archive_command = 'test ! -f /var/lib/postgresql/14/archive/%f && cp %p /var/lib/postgresql/14/archive/%f'

# Configuración hot standby
hot_standby = on

# Tiempo de espera para conexiones de replicación
wal_sender_timeout = 60s

# Para replicación sincrónica (opcional)
# synchronous_commit = on
# synchronous_standby_names = 'standby1,standby2'

# Escuchar en todas las interfaces
listen_addresses = '*'

# Configuración de conexión
max_connections = 100

Crea el directorio de archivo WAL:

sudo mkdir -p /var/lib/postgresql/14/archive
sudo chown postgres:postgres /var/lib/postgresql/14/archive
sudo chmod 700 /var/lib/postgresql/14/archive

Paso 2: Configurar Autenticación Basada en Host

Edita el archivo pg_hba.conf para permitir conexiones de replicación:

sudo nano /etc/postgresql/14/main/pg_hba.conf

Agrega las siguientes líneas:

# TYPE  DATABASE        USER            ADDRESS                 METHOD

# Conexiones de replicación
host    replication     replication     192.168.1.0/24          scram-sha-256
host    replication     replication     standby_server_ip/32    scram-sha-256

# Permitir conexiones desde servidores en espera
host    all             all             192.168.1.0/24          scram-sha-256

Reemplaza 192.168.1.0/24 con tu rango de red real y standby_server_ip con la dirección IP de tu servidor en espera.

Paso 3: Crear Usuario de Replicación

Conéctate a PostgreSQL en el servidor primario:

sudo -u postgres psql

Crea un usuario dedicado de replicación:

-- Crear usuario de replicación
CREATE ROLE replication WITH REPLICATION LOGIN PASSWORD 'StrongPassword123!';

-- Otorgar privilegios necesarios
ALTER ROLE replication WITH CONNECTION LIMIT 10;

-- Verificar que el usuario fue creado
\du replication

Salir de psql:

\q

Paso 4: Reiniciar Servidor PostgreSQL Primario

Aplicar los cambios de configuración:

sudo systemctl restart postgresql

Verificar que PostgreSQL esté ejecutándose:

sudo systemctl status postgresql

Verificar que la configuración de replicación esté activa:

sudo -u postgres psql -c "SHOW wal_level;"
sudo -u postgres psql -c "SHOW max_wal_senders;"

Paso 5: Crear Respaldo Base para Espera

En el servidor primario, crea un respaldo base usando pg_basebackup:

# Detener PostgreSQL en el servidor en espera primero (si está ejecutándose)
# ssh standby_server "sudo systemctl stop postgresql"

# Crear directorio de respaldo en espera
ssh standby_server "sudo mkdir -p /var/lib/postgresql/14/main"
ssh standby_server "sudo chown postgres:postgres /var/lib/postgresql/14/main"

# Desde el primario, crear respaldo base directamente al espera
sudo -u postgres pg_basebackup \
    -h primary_server_ip \
    -D /tmp/pgbackup \
    -U replication \
    -P \
    -v \
    -R \
    -X stream \
    -C -S standby1_slot

Explicación de parámetros:

• -D: Directorio destino para respaldo
• -U: Usuario de replicación
• -P: Mostrar progreso
• -v: Salida detallada
• -R: Crear standby.signal y escribir información de conexión
• -X stream: Incluir archivos WAL en respaldo
• -C: Crear slot de replicación
• -S: Nombre del slot de replicación

Alternativamente, respaldar a un archivo tar y transferir:

# Crear respaldo como tar
sudo -u postgres pg_basebackup \
    -h localhost \
    -D - \
    -U replication \
    -Ft \
    -z \
    -P \
    > /tmp/pgbackup.tar.gz

# Transferir al servidor en espera
scp /tmp/pgbackup.tar.gz standby_server:/tmp/

Paso 6: Configurar el Servidor en Espera

En el servidor en espera, preparar el directorio de datos de PostgreSQL:

# Detener PostgreSQL si está ejecutándose
sudo systemctl stop postgresql

# Respaldar directorio de datos existente
sudo mv /var/lib/postgresql/14/main /var/lib/postgresql/14/main.backup

# Crear nuevo directorio de datos
sudo mkdir -p /var/lib/postgresql/14/main
sudo chown postgres:postgres /var/lib/postgresql/14/main
sudo chmod 700 /var/lib/postgresql/14/main

Si creaste un respaldo tar, extráelo:

sudo -u postgres tar -xzf /tmp/pgbackup.tar.gz -C /var/lib/postgresql/14/main

O sincronizar el directorio de respaldo desde el primario:

sudo rsync -av --delete \
    root@primary_server:/tmp/pgbackup/ \
    /var/lib/postgresql/14/main/

sudo chown -R postgres:postgres /var/lib/postgresql/14/main

Paso 7: Crear Configuración de Espera

Si no usaste la bandera -R con pg_basebackup, crea manualmente la configuración de espera:

sudo -u postgres nano /var/lib/postgresql/14/main/standby.signal

Este archivo puede estar vacío; su presencia indica modo de espera.

Crear o editar postgresql.auto.conf:

sudo -u postgres nano /var/lib/postgresql/14/main/postgresql.auto.conf

Agregar información de conexión:

primary_conninfo = 'host=primary_server_ip port=5432 user=replication password=StrongPassword123! application_name=standby1'
primary_slot_name = 'standby1_slot'

Para mejor seguridad, usar un archivo de contraseñas en su lugar:

# Crear archivo .pgpass
sudo -u postgres nano /var/lib/postgresql/.pgpass

Agregar:

primary_server_ip:5432:replication:replication:StrongPassword123!

Asegurar el archivo:

sudo chmod 600 /var/lib/postgresql/.pgpass
sudo chown postgres:postgres /var/lib/postgresql/.pgpass

Actualizar postgresql.auto.conf para eliminar contraseña:

primary_conninfo = 'host=primary_server_ip port=5432 user=replication application_name=standby1'
primary_slot_name = 'standby1_slot'

Paso 8: Configurar Opciones PostgreSQL del Espera

Editar el postgresql.conf del espera:

sudo nano /etc/postgresql/14/main/postgresql.conf

Agregar o modificar:

# Configuración hot standby
hot_standby = on
hot_standby_feedback = on

# Configuración del receptor WAL
wal_receiver_status_interval = 10s
wal_receiver_timeout = 60s

# Consultas en espera
max_standby_streaming_delay = 30s
max_standby_archive_delay = 30s

# Configuración de recuperación
restore_command = 'cp /var/lib/postgresql/14/archive/%f %p'
recovery_target_timeline = 'latest'

Paso 9: Iniciar Servidor en Espera

Iniciar PostgreSQL en el servidor en espera:

sudo systemctl start postgresql

Verificar el estado:

sudo systemctl status postgresql

Verificar modo de espera:

sudo -u postgres psql -c "SELECT pg_is_in_recovery();"

Debería devolver t (verdadero) indicando modo de espera.

Paso 10: Verificar Estado de Replicación

En el servidor primario, verificar el estado de replicación:

sudo -u postgres psql

-- Verificar esperas conectadas
SELECT * FROM pg_stat_replication;

-- Ver slots de replicación
SELECT * FROM pg_replication_slots;

-- Verificar procesos enviadores WAL
SELECT pid, state, application_name, client_addr, sent_lsn, write_lsn, flush_lsn, replay_lsn
FROM pg_stat_replication;

En el servidor en espera:

-- Verificar si está en modo de recuperación
SELECT pg_is_in_recovery();

-- Ver estado de reproducción
SELECT pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn(),
       pg_last_xact_replay_timestamp();

-- Calcular retraso de replicación
SELECT EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())) AS lag_seconds;

Prueba de Replicación

Probar Replicación de Datos

En el servidor primario, crear datos de prueba:

-- Crear base de datos de prueba
CREATE DATABASE replication_test;
\c replication_test

-- Crear tabla de prueba
CREATE TABLE test_replication (
    id SERIAL PRIMARY KEY,
    test_data VARCHAR(100),
    created_at TIMESTAMP DEFAULT NOW()
);

-- Insertar datos de prueba
INSERT INTO test_replication (test_data)
VALUES ('Test data 1'), ('Test data 2'), ('Test data 3');

-- Ver datos
SELECT * FROM test_replication;

En el servidor en espera, verificar la replicación:

-- Conectar a base de datos de prueba
\c replication_test

-- Consultar datos replicados
SELECT * FROM test_replication;

-- Verificar que no puedes escribir (debería fallar)
INSERT INTO test_replication (test_data) VALUES ('This should fail');

Monitorear Retraso de Replicación

Crear una consulta de monitoreo:

-- En el primario
SELECT client_addr, state,
       sent_lsn,
       write_lsn,
       flush_lsn,
       replay_lsn,
       sent_lsn::text::pg_lsn - replay_lsn::text::pg_lsn AS byte_lag
FROM pg_stat_replication;

-- En el espera
SELECT pg_is_in_recovery() AS is_standby,
       pg_last_wal_receive_lsn() AS receive_lsn,
       pg_last_wal_replay_lsn() AS replay_lsn,
       pg_last_wal_receive_lsn()::text::pg_lsn -
       pg_last_wal_replay_lsn()::text::pg_lsn AS replay_lag_bytes,
       EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())) AS lag_seconds;

Configuración Avanzada

Implementar Replicación Sincrónica

Para cero pérdida de datos, configurar replicación sincrónica.

En el primario, editar postgresql.conf:

synchronous_commit = on
synchronous_standby_names = 'FIRST 1 (standby1, standby2)'

Opciones para synchronous_standby_names:

• 'standby1' - Un solo espera debe confirmar
• 'FIRST 1 (standby1, standby2)' - El primer espera disponible debe confirmar
• 'ANY 1 (standby1, standby2)' - Cualquier espera debe confirmar
• '2 (standby1, standby2, standby3)' - Dos esperas deben confirmar

Recargar configuración:

sudo systemctl reload postgresql

Verificar replicación sincrónica:

SELECT application_name, sync_state, sync_priority
FROM pg_stat_replication;

Configurar Replicación en Cascada

Configurar un espera para replicar desde otro espera.

En el espera intermedio, editar postgresql.conf:

# Habilitar envío WAL desde espera
max_wal_senders = 5
wal_level = replica
hot_standby = on

En el espera en cascada, configurar para conectar al intermedio:

primary_conninfo = 'host=intermediate_standby_ip port=5432 user=replication application_name=cascading_standby'

Implementar Slots de Replicación

Los slots de replicación previenen la eliminación de WAL antes del consumo por espera:

En el primario:

-- Crear slot de replicación
SELECT * FROM pg_create_physical_replication_slot('standby1_slot');

-- Ver slots existentes
SELECT * FROM pg_replication_slots;

-- Eliminar slot si es necesario
SELECT pg_drop_replication_slot('standby1_slot');

En espera, configurar para usar el slot:

primary_slot_name = 'standby1_slot'

Monitoreo con pg_stat_wal_receiver

En servidores en espera, monitorear el receptor WAL:

SELECT * FROM pg_stat_wal_receiver;

Esto muestra el estado de conexión, último LSN recibido e información de línea de tiempo.

Scripts de Monitoreo Automatizado

Crear Script de Verificación de Salud de Replicación

sudo nano /usr/local/bin/check_pg_replication.sh

#!/bin/bash

# Script de Verificación de Salud de Replicación PostgreSQL
LOG_FILE="/var/log/postgresql/replication-check.log"
PRIMARY_IP="primary_server_ip"

log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

# Verificar si está ejecutándose como espera
IS_STANDBY=$(sudo -u postgres psql -t -c "SELECT pg_is_in_recovery();")

if [ "$IS_STANDBY" = " t" ]; then
    log_message "Ejecutándose como servidor ESPERA"

    # Verificar retraso de replicación
    LAG=$(sudo -u postgres psql -t -c "SELECT EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp()));")

    if [ -z "$LAG" ]; then
        log_message "ERROR: No se puede determinar el retraso de replicación"
        exit 2
    fi

    LAG_INT=$(echo "$LAG" | cut -d. -f1)

    if [ "$LAG_INT" -gt 300 ]; then
        log_message "ADVERTENCIA: El retraso de replicación es de ${LAG_INT} segundos"
        exit 1
    else
        log_message "OK: El retraso de replicación es de ${LAG_INT} segundos"
        exit 0
    fi
else
    log_message "Ejecutándose como servidor PRIMARIO"

    # Verificar esperas conectadas
    STANDBY_COUNT=$(sudo -u postgres psql -t -c "SELECT count(*) FROM pg_stat_replication;")

    if [ "$STANDBY_COUNT" -eq 0 ]; then
        log_message "ADVERTENCIA: No hay servidores en espera conectados"
        exit 1
    else
        log_message "OK: $STANDBY_COUNT servidor(es) en espera conectado(s)"

        # Mostrar detalles de espera
        sudo -u postgres psql -c "SELECT application_name, client_addr, state, sync_state FROM pg_stat_replication;"
        exit 0
    fi
fi

Hacer ejecutable:

sudo chmod +x /usr/local/bin/check_pg_replication.sh

Programar con cron:

sudo crontab -e

Agregar:

# Verificar replicación cada 5 minutos
*/5 * * * * /usr/local/bin/check_pg_replication.sh

Crear Script de Monitoreo de Retraso

sudo nano /usr/local/bin/monitor_replication_lag.sh

#!/bin/bash

# Monitorear y registrar retraso de replicación
LOGFILE="/var/log/postgresql/replication-lag.log"

LAG_BYTES=$(sudo -u postgres psql -t -c "
SELECT
    COALESCE(
        pg_wal_lsn_diff(pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn()),
        0
    )::bigint;
")

LAG_TIME=$(sudo -u postgres psql -t -c "
SELECT
    COALESCE(
        EXTRACT(EPOCH FROM (now() - pg_last_xact_replay_timestamp())),
        0
    )::int;
")

echo "$(date '+%Y-%m-%d %H:%M:%S'),$LAG_BYTES,$LAG_TIME" >> "$LOGFILE"

# Alertar si el retraso excede los umbrales
if [ "$LAG_TIME" -gt 60 ]; then
    echo "ALERTA: El retraso de replicación es de ${LAG_TIME} segundos" | \
        mail -s "Alerta de Retraso de Replicación PostgreSQL" [email protected]
fi

Solución de Problemas

La Replicación No se Inicia

Problema: El servidor en espera no se conecta al primario.

Solución: Verificar conectividad y autenticación:

# Probar conectividad de red
telnet primary_server_ip 5432

# Probar conexión de replicación
psql "host=primary_server_ip port=5432 user=replication dbname=replication" -c "IDENTIFY_SYSTEM;"

# Verificar registros de PostgreSQL
sudo tail -f /var/log/postgresql/postgresql-14-main.log

# Verificar que pg_hba.conf permita replicación
sudo grep replication /etc/postgresql/14/main/pg_hba.conf

Alto Retraso de Replicación

Problema: El espera se está quedando atrás del primario.

Solución: Investigar y optimizar:

-- Verificar retraso actual
SELECT pg_wal_lsn_diff(pg_last_wal_receive_lsn(), pg_last_wal_replay_lsn()) AS lag_bytes;

-- Verificar consultas de larga duración en espera
SELECT pid, usename, query_start, state, query
FROM pg_stat_activity
WHERE state = 'active';

-- Terminar consultas bloqueantes
SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE ...;

Optimizar rendimiento del espera:

# Aumentar buffer del receptor WAL
wal_receiver_status_interval = 1s

# Ajustar configuración de retraso de espera
max_standby_streaming_delay = 30s
hot_standby_feedback = on

Inflamación de Slot de Replicación

Problema: El slot de replicación consume espacio en disco excesivo.

Solución: Monitorear y gestionar slots:

-- Verificar estado del slot
SELECT slot_name,
       pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)) AS retained_wal
FROM pg_replication_slots;

-- Eliminar slots inactivos
SELECT pg_drop_replication_slot('slot_name');

-- Monitorear archivos WAL
SELECT count(*) FROM pg_ls_waldir();

Segmento WAL No Encontrado

Problema: Error: "el segmento WAL solicitado ya ha sido eliminado"

Solución: Aumentar retención WAL o reconstruir espera:

# Aumentar retención WAL
wal_keep_size = 2GB

# O usar slots de replicación
max_replication_slots = 5

Si el espera está muy atrasado, reconstruir desde respaldo base:

# Detener espera
sudo systemctl stop postgresql

# Eliminar datos antiguos
sudo rm -rf /var/lib/postgresql/14/main/*

# Crear nuevo respaldo base
sudo -u postgres pg_basebackup -h primary_ip -D /var/lib/postgresql/14/main -U replication -P -R

# Iniciar espera
sudo systemctl start postgresql

Problemas de Historial de Línea de Tiempo

Problema: Error: "el ID de línea de tiempo no coincide"

Solución: Restablecer espera a línea de tiempo correcta:

# Eliminar standby.signal
sudo rm /var/lib/postgresql/14/main/standby.signal

# Crear nuevo respaldo base
sudo -u postgres pg_basebackup -h primary_ip -D /tmp/newbackup -U replication -P -R

# Reemplazar directorio de datos
sudo systemctl stop postgresql
sudo rm -rf /var/lib/postgresql/14/main/*
sudo cp -a /tmp/newbackup/* /var/lib/postgresql/14/main/
sudo chown -R postgres:postgres /var/lib/postgresql/14/main
sudo systemctl start postgresql

Mejores Prácticas

1. Usar Slots de Replicación

Usar siempre slots de replicación para prevenir la eliminación de WAL antes del consumo por espera. Esto evita que los esperas se queden muy atrás.

2. Monitorear Salud de Replicación

Implementar monitoreo integral:

• Retraso de replicación (tiempo y bytes)
• Conteo de esperas conectadas
• Estado del slot de replicación
• Uso de disco WAL
• Retroalimentación hot standby

3. Pruebas Regulares de Conmutación por Error

Probar procedimientos de conmutación por error trimestralmente:

• Promover espera a primario
• Redirigir tráfico de aplicación
• Reconstruir antiguo primario como nuevo espera
• Documentar lecciones aprendidas

4. Asegurar Conexiones de Replicación

Usar SSL/TLS para tráfico de replicación:

# En pg_hba.conf
hostssl replication replication 0.0.0.0/0 scram-sha-256

# En postgresql.conf
ssl = on
ssl_cert_file = '/etc/postgresql/server.crt'
ssl_key_file = '/etc/postgresql/server.key'

5. Implementar Monitoreo Apropiado

Usar herramientas de monitoreo como:

• pgBadger para análisis de registros
• pg_stat_statements para rendimiento de consultas
• Prometheus + Grafana para visualización de métricas
• Nagios/Icinga para alertas

6. Documentar Tu Configuración

Mantener documentación que incluya:

• Roles y direcciones IP de servidores
• Diagrama de topología de replicación
• Procedimientos de conmutación por error
• Procedimientos de recuperación
• Información de contacto

7. Planificar Capacidad Apropiadamente

Monitorear y planificar para:

• Espacio en disco para archivos WAL
• Requisitos de ancho de banda de red
• Capacidad de E/S para reproducción
• CPU para consultas hot standby

8. Usar Replicación Sincrónica para Datos Críticos

Para requisitos de cero pérdida de datos, usar replicación sincrónica con al menos dos esperas para redundancia.

9. Implementar Conmutación por Error Automatizada

Considerar usar herramientas como:

• Patroni para conmutación por error automática
• repmgr para gestión de replicación
• Pgpool-II para agrupación de conexiones y balanceo de carga

10. Mantener PostgreSQL Actualizado

Actualizar regularmente PostgreSQL para beneficiarse de:

• Mejoras de rendimiento
• Correcciones de errores
• Parches de seguridad
• Nuevas características de replicación

Conclusión

La replicación en streaming de PostgreSQL proporciona una solución robusta y de alto rendimiento para alta disponibilidad y escalabilidad de bases de datos. Siguiendo esta guía completa, has aprendido cómo configurar la replicación física en streaming desde la configuración asíncrona básica hasta configuraciones sincrónicas y en cascada avanzadas.

La implementación cubrió la configuración de replicación en streaming basada en WAL, la creación y gestión de usuarios y slots de replicación, la configuración de servidores primarios y en espera, la implementación de sistemas de monitoreo y alerta, y la solución de problemas comunes de replicación. También has aprendido las mejores prácticas para mantener un entorno de replicación saludable y asegurar la consistencia de datos en tu infraestructura PostgreSQL.

La replicación mejora significativamente la resiliencia y el rendimiento de la infraestructura de tu base de datos, pero requiere mantenimiento y monitoreo continuos. Continúa probando tus procedimientos de conmutación por error regularmente, monitoreando métricas de retraso y salud de replicación, manteniendo espacio en disco adecuado para archivos WAL, manteniendo PostgreSQL actualizado con los últimos parches, y documentando todos los cambios de configuración y procedimientos.

A medida que tus necesidades evolucionen, considera implementar replicación lógica para replicación selectiva de tablas, usar soluciones de agrupación de conexiones como PgBouncer o Pgpool-II, implementar soluciones de conmutación por error automatizada como Patroni, o integrar con servicios PostgreSQL nativos de la nube. La base que has construido con esta guía te servirá bien a medida que escales y mejores tu infraestructura de replicación PostgreSQL para satisfacer demandas crecientes y complejidad en aumento.