Memcached · 7 min read · Jan 20, 2026

Cómo: Instalar Memcached Con repcached "Replicación del Lado del Servidor Incorporada" En Debian Lenny

Cómo: Instalar Memcached Con repcached “Replicación del Lado del Servidor Incorporada” En Debian Lenny

Las personas probablemente conocen memcached ( http://memcached.org/) y su interfaz de caché de objetos en memoria basada en nombre-valor de alto rendimiento. Su principal propósito es proporcionar un motor de caché distribuido fácil de usar en un entorno multinodo. ¿Alguna vez has querido que memcached maneje la replicación?

Si deseas agregar capacidades de alta disponibilidad, se recomienda dejar que el cliente (-biblioteca) maneje la replicación de tus datos a través de todos los nodos. Supongamos que usar memcached como backend de almacenamiento para sesiones de php está configurado de la siguiente manera:

# configuración para el módulo php memcache
extension=memcache.so
session.save_handler = memcache
session.save_path = "tcp://192.168.168.61:11211?persistent=1,tcp://192.168.168.62:11211?persistent=1"

Ahora las sesiones se distribuyen (no se replican) a través de ambos nodos. En cuanto un nodo se cae, perderás todos esos datos. Mientras solo uses memcached como un potenciador de rendimiento y distribuidor de algunos datos “cacheables”, eso no debería doler: los datos perdidos se llenan como lo hicieron al crear las entradas de caché.

Para replicar tus datos de sesión necesitarás usar un controlador de sesión personalizado que se conecte a cada uno de estos nodos por su cuenta… para la replicación. Lo mismo si deseas escribir algunos objetos en caché propios en tu querido memcached. Aún así, tu aplicación necesita conocer todos los nodos a los que escribir.

Facilitar la replicación dejando que memcached lo resuelva como repcached

Estos problemas pueden confundir a los desarrolladores que solo quieren concentrarse en su aplicación y no quieren preocuparse tanto por HA, balanceo de carga y escalabilidad. Con repcached, al menos se puede configurar fácilmente y de manera transparente una solución HA de 2 nodos.

Un simple parche agrega una elegante replicación maestro-maestro a tu memcached. Ahora solo necesitarás conectarte a tu memcached local, que luego maneja la replicación por su cuenta.

Así que tu aplicación puede permanecer simple y tonta, usando tu sistema de archivos POSIX local (que podría ser replicado por DRBD, GlusterFS, etc.), tu base de datos local (adivinaste: “que maneja la replicación por su cuenta”) y conectándose a una instancia local de tu “clúster memcached”. Esa configuración abre algunas opciones más simples y transparentes para una escalabilidad HA fácil y ligera.

Instalación, configuración y prueba de un clúster de 2 nodos

Primero, obtén una copia del parche repcached o incluso descarga la fuente de memcached ya parcheada desde http://repcached.lab.klab.org/. Hay una dependencia de libevent que puede necesitar resolverse antes de la instalación.

root@ha-01 ~ # apt-get install libevent-dev

Ahora descomprime y entra en el directorio:

root@ha-01 ~ # tar xvf memcached-1.2.8-repcached-2.2.tar
root@ha-01 ~ # cd memcached-1.2.8-repcached-2.2/

Configura con la opción –enable-repcached.

root@ha-01 ~/memcached-1.2.8-repcached-2.2 # ./configure –enable-replication
root@ha-01 ~/memcached-1.2.8-repcached-2.2 # make
root@ha-01 ~/memcached-1.2.8-repcached-2.2 # make install

No te preocupes demasiado por un paquete memcached.dep previamente instalado. Esta instalación manual solo instalará un binario en /usr/local/bin/memcached dejando tu memcached “original” intacto en /usr/bin/memcached.

En contraste con el paquete de debian, es posible que desees proporcionar opciones de línea de comandos utilizando una simple configuración predeterminada en /etc/default/memcachedrep (rep => ‘replicación’), es decir:

configuración predeterminada

## opciones adicionales de línea de comandos para iniciar memcached en modo replicado
# -x < ip_addr > nombre de host o dirección IP del servidor maestro de replicación
# -X < num > número de puerto TCP del maestro (predeterminado: 11212)
DAEMON_ARGS="-m 64 -p 11211 -u root -P /var/run/memcachedrep.pid -d -x 192.168.168.2"

Con eso en su lugar, un script de inicio se configura bastante fácil utilizando y modificando el esqueleto de debian:

script de inicio

#! /bin/sh
### BEGIN INIT INFO
# Provides:             memcached
# Required-Start:       $syslog
# Required-Stop:        $syslog
# Should-Start:         $local_fs
# Should-Stop:          $local_fs
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
# Short-Description:    memcached - Daemon de caché en memoria replicado
# Description:          memcached - Daemon de caché en memoria replicado
### END INIT INFO
# Autor: Marcus Spiegel <[email protected]>
#
# Por favor, elimina las líneas "Autor" anteriores y reemplázalas
# con tu propio nombre si copias y modificas este script.
# No HAGAS "set -e"
# PATH solo debe incluir /usr/* si se ejecuta después del script mountnfs.sh
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="memcachedrep"
NAME=memcached
DAEMON=/usr/local/bin/$NAME
DAEMON_ARGS="--options args"
PIDFILE=/var/run/memcachedrep.pid
SCRIPTNAME=/etc/init.d/$DESC
VERBOSE="yes"
# Salir si el paquete no está instalado
[ -x "$DAEMON" ] || exit 0
# Leer el archivo de variables de configuración si está presente
[ -r /etc/default/$DESC ] && . /etc/default/$DESC
# Cargar la configuración VERBOSE y otras variables rcS
. /lib/init/vars.sh
# Definir funciones de registro LSB log_*.
# Depender de lsb-base (>= 3.0-6) para asegurar que este archivo esté presente.
. /lib/lsb/init-functions
#
# Función que inicia el daemon/servicio
#
do_start()
{
    # Retornar
    #   0 si el daemon ha sido iniciado
    #   1 si el daemon ya estaba en ejecución
    #   2 si el daemon no pudo ser iniciado
    start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
        || return 1
    start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
        $DAEMON_ARGS \
        || return 2
    # Agrega código aquí, si es necesario, que espera a que el proceso esté listo
    # para manejar solicitudes de servicios iniciados posteriormente que dependen
    # de este. Como último recurso, duerme por un tiempo.
}
#
# Función que detiene el daemon/servicio
#
do_stop()
{
    # Retornar
    #   0 si el daemon ha sido detenido
    #   1 si el daemon ya estaba detenido
    #   2 si el daemon no pudo ser detenido
    #   otro si ocurrió un fallo
    start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
    RETVAL="$?"
    [ "$RETVAL" = 2 ] && return 2
    # Esperar a que los hijos terminen también si este es un daemon que bifurca
    # y si el daemon solo se ejecuta desde este script de inicio.
    # Si las condiciones anteriores no se cumplen, agrega algún otro código
    # que espera a que el proceso libere todos los recursos que podrían ser
    # necesarios por servicios iniciados posteriormente. Un último recurso es
    # dormir por un tiempo.
    start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
    [ "$?" = 2 ] && return 2
    # Muchos daemons no eliminan sus archivos pid cuando salen.
    rm -f $PIDFILE
    return "$RETVAL"
}
#
# Función que envía un SIGHUP al daemon/servicio
#
do_reload() {
    #
    # Si el daemon puede recargar su configuración sin
    # reiniciar (por ejemplo, cuando se le envía un SIGHUP),
    # entonces implementa eso aquí.
    #
    start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
    return 0
}
case "$1" in
  start)
    [ "$VERBOSE" != no ] && log_daemon_msg "Iniciando $DESC" "$NAME"
    do_start
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  stop)
    [ "$VERBOSE" != no ] && log_daemon_msg "Deteniendo $DESC" "$NAME"
    do_stop
    case "$?" in
        0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 
        2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
    esac
    ;;
  #reload|force-reload)
    #
    # Si do_reload() no está implementado, entonces deja esto comentado
    # y deja 'force-reload' como un alias para 'restart'.
    #
    #log_daemon_msg "Recargando $DESC" "$NAME"
    #do_reload
    #log_end_msg $?
    #;;
  restart|force-reload)
    #
    # Si la opción "reload" está implementada, entonces elimina el
    # 'force-reload' alias
    #
    log_daemon_msg "Reiniciando $DESC" "$NAME"
    do_stop
    case "$?" in
      0|1)
        do_start
        case "$?" in
            0) log_end_msg 0 ;;
            1) log_end_msg 1 ;; # El proceso antiguo sigue en ejecución
            *) log_end_msg 1 ;; # Falló al iniciar
        esac
        ;;
      *)
        # Falló al detener
        log_end_msg 1
        ;;
    esac
    ;;
  *)
    #echo "Uso: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
    echo "Uso: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
    exit 3
    ;;
esac
:

Pruebas

Después de configurar repcached en ambos nodos, probablemente deberías probarlo. Puedes conectarte a memcached en cada nodo por telnet:

root@ha-01 ~ # telnet 127.0.0.1 11211

Intentando 127.0.0.1…
Conectado a 127.0.0.1.
El carácter de escape es ‘^]’.

Ahora emite un comando set para escribir algunos valores de prueba solo en un nodo:

set foo 0 0 3
bar
STORED

mueve al otro nodo, conéctate y trata de leer:

root@ha-02 ~ # telnet 127.0.0.1 11211

Intentando 127.0.0.1…
Conectado a 127.0.0.1.
El carácter de escape es ‘^]’.
get foo
VALUE foo 0 3
bar
END

Intenta eso al revés y diviértete! Y finalmente derriba uno de estos nodos después de haber empujado algunos valores más a la memoria. El nodo en funcionamiento sigue respondiendo con todos los datos - excelente.

La parte realmente divertida es que, tan pronto como inicies el nodo no disponible nuevamente, obtendrá todos los datos “perdidos” del otro maestro. Adelante, intenta por tu cuenta. Lo mismo sucederá si ahora derribas el otro nodo y lo vuelves a encender. Incluso los datos que se establecieron en un nodo mientras el otro nodo estaba caído se agregarán al nodo que se inicie después.

Esa configuración es capaz de un setup de replicación de 2 nodos solamente - aún. Piensa en construir un clúster de 4 nodos con una especie de configuración raid10 donde la replicación y distribución se combinan… o algo así. Bueno, al menos en esa configuración HA de 2 nodos, repcached funciona como un encanto.

Personalmente, me gustaría intentar un círculo de 3 nodos a continuación :) (quizás junto con heartbeat para cerrar cualquier falta en ese círculo).

Share: X/Twitter LinkedIn

Recibe nuevas publicaciones en tu bandeja de entrada.

No spam. Cancela la suscripción en cualquier momento.