Replicación

Arquitectura Master-Replica

        ┌─────────┐
        │  Master │  (Escrituras)
        └────┬────┘
             │
     ┌───────┼───────┐
     ▼       ▼       ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│Replica 1│ │Replica 2│ │Replica 3│  (Lecturas)
└─────────┘ └─────────┘ └─────────┘

Beneficios:

• Escalabilidad de lectura: Distribuir carga
• Alta disponibilidad: Failover automático
• Backup: Replicas como respaldo

Configuración básica

En la réplica

# replica.conf
port 6380
replicaof 192.168.1.100 6379

# Autenticación al master
masterauth password_del_master

# La réplica puede responder consultas
replica-read-only yes

# Mantener datos si pierde conexión
replica-serve-stale-data yes

Comandos de replicación

# Convertir en réplica
REPLICAOF 192.168.1.100 6379

# Dejar de ser réplica
REPLICAOF NO ONE

# Ver información de replicación
INFO replication
# role:slave
# master_host:192.168.1.100
# master_port:6379
# master_link_status:up

Docker Compose

# docker-compose.yml
services:
  master:
    image: valkey/valkey:latest
    ports:
      - "6379:6379"
    command: valkey-server --appendonly yes

  replica1:
    image: valkey/valkey:latest
    ports:
      - "6380:6379"
    command: valkey-server --replicaof master 6379
    depends_on:
      - master

  replica2:
    image: valkey/valkey:latest
    ports:
      - "6381:6379"
    command: valkey-server --replicaof master 6379
    depends_on:
      - master

docker-compose up -d

# Verificar
docker exec -it valkey-master valkey-cli INFO replication

Sentinel para Alta Disponibilidad

Sentinel monitorea y realiza failover automático.

Configuración de Sentinel

# sentinel.conf
port 26379
sentinel monitor mymaster 192.168.1.100 6379 2
sentinel auth-pass mymaster password
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1

Parámetros:

• monitor: Nombre, IP, puerto, quorum (mínimo de sentinels para failover)
• down-after-milliseconds: Tiempo para considerar nodo caído
• failover-timeout: Timeout del proceso de failover
• parallel-syncs: Réplicas sincronizando simultáneamente

Docker Compose con Sentinel

services:
  master:
    image: valkey/valkey:latest
    ports:
      - "6379:6379"

  replica1:
    image: valkey/valkey:latest
    command: valkey-server --replicaof master 6379

  replica2:
    image: valkey/valkey:latest
    command: valkey-server --replicaof master 6379

  sentinel1:
    image: valkey/valkey:latest
    ports:
      - "26379:26379"
    command: valkey-sentinel /etc/valkey/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/valkey/sentinel.conf

  sentinel2:
    image: valkey/valkey:latest
    command: valkey-sentinel /etc/valkey/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/valkey/sentinel.conf

  sentinel3:
    image: valkey/valkey:latest
    command: valkey-sentinel /etc/valkey/sentinel.conf
    volumes:
      - ./sentinel.conf:/etc/valkey/sentinel.conf

Comandos Sentinel

# Conectar a sentinel
valkey-cli -p 26379

# Información del master
SENTINEL master mymaster

# Listar réplicas
SENTINEL replicas mymaster

# Listar sentinels
SENTINEL sentinels mymaster

# IP del master actual
SENTINEL get-master-addr-by-name mymaster

# Forzar failover
SENTINEL failover mymaster

Conexión desde aplicaciones

Python con Sentinel

from valkey.sentinel import Sentinel

sentinel = Sentinel([
    ('localhost', 26379),
    ('localhost', 26380),
    ('localhost', 26381)
], socket_timeout=0.1)

# Obtener master para escrituras
master = sentinel.master_for('mymaster', socket_timeout=0.1)
master.set('clave', 'valor')

# Obtener réplica para lecturas
replica = sentinel.slave_for('mymaster', socket_timeout=0.1)
valor = replica.get('clave')

Node.js con Sentinel

import Redis from 'ioredis';

const redis = new Redis({
    sentinels: [
        { host: 'localhost', port: 26379 },
        { host: 'localhost', port: 26380 },
        { host: 'localhost', port: 26381 }
    ],
    name: 'mymaster'
});

await redis.set('clave', 'valor');
const valor = await redis.get('clave');

Replicación asíncrona

Por defecto, la replicación es asíncrona:

# En master: comandos para sincronización
WAIT 2 1000  # Esperar que 2 réplicas confirmen, timeout 1s

# Info de lag
INFO replication
# slave0:ip=...,offset=12345,lag=0

Configurar sincronización

# En master
min-replicas-to-write 1     # Mínimo de réplicas para aceptar escrituras
min-replicas-max-lag 10     # Lag máximo permitido en segundos

Monitoreo

# Estado de replicación
INFO replication

# Métricas importantes:
# - master_link_status: up/down
# - master_last_io_seconds_ago: segundos desde última comunicación
# - master_sync_in_progress: 1 si está sincronizando
# - slave_repl_offset: offset actual de la réplica

Script de monitoreo

#!/bin/bash
# check_replication.sh

MASTER=$(valkey-cli -p 26379 SENTINEL get-master-addr-by-name mymaster)
REPLICAS=$(valkey-cli -p 26379 SENTINEL replicas mymaster | grep -c "flags=slave")

echo "Master: $MASTER"
echo "Réplicas activas: $REPLICAS"

# Verificar lag
valkey-cli INFO replication | grep "slave.*lag"

Ejercicios

1. Configura un master con dos réplicas
2. Implementa failover con Sentinel
3. Crea un script que distribuya lecturas entre réplicas

Resumen

• REPLICAOF convierte un nodo en réplica
• Las réplicas son read-only por defecto
• Sentinel proporciona failover automático
• Usar WAIT para escrituras síncronas cuando sea crítico
• Monitorear lag entre master y réplicas

Navegación