Dragonfly es un almacén de datos en memoria compatible con los protocolos de Redis y Memcached. A diferencia de Redis, reparte los datos entre todos los núcleos de la CPU con una arquitectura multihilo, por lo que un solo proceso aprovecha servidores grandes sin montar un clúster. En este tutorial instalarás Dragonfly en Ubuntu 24.04 como servicio de systemd, lo configurarás con contraseña, límite de memoria y snapshots periódicos, y comprobarás que funciona con clientes de Redis y Memcached.

Requisitos previos

  • Un servidor con Ubuntu 24.04 LTS de 64 bits (x86_64 o arm64), por ejemplo un VPS de CubePath, con al menos 2 vCPU y 2 GB de RAM.
  • Un usuario no root con privilegios sudo.
  • curl y redis-tools para descargar el binario y probar la conexión. Se instalan en el paso 1.

Ubuntu 24.04 usa el kernel 6.8, que incluye io_uring, la interfaz de E/S asíncrona que Dragonfly utiliza por defecto.

Paso 1: Descargar el binario de Dragonfly

Dragonfly publica binarios precompilados en GitHub. Instala las herramientas necesarias:

sudo apt update
sudo apt install curl redis-tools

redis-tools aporta redis-cli y redis-benchmark, que funcionan sin cambios contra Dragonfly.

Descarga la última versión estable para tu arquitectura. Para x86_64:

cd /tmp
curl -fsSLO https://github.com/dragonflydb/dragonfly/releases/latest/download/dragonfly-x86_64.tar.gz
tar -xzf dragonfly-x86_64.tar.gz
sudo install -m 0755 dragonfly-x86_64 /usr/local/bin/dragonfly

En un servidor arm64, usa dragonfly-aarch64.tar.gz y el binario dragonfly-aarch64.

Comprueba que el binario se ejecuta:

dragonfly --version

dragonfly v1.x.x-...

Paso 2: Crear el usuario y los directorios

Dragonfly no necesita privilegios de root. Crea un usuario de sistema sin shell ni directorio personal, y el directorio de configuración:

sudo useradd --system --no-create-home --shell /usr/sbin/nologin dragonfly
sudo mkdir -p /etc/dragonfly

El directorio de datos lo creará systemd con los permisos adecuados en el paso 4.

Paso 3: Escribir el archivo de configuración

Dragonfly se configura con opciones de línea de comandos, que también se pueden leer de un archivo con --flagfile, una opción por línea. Genera una contraseña larga y aleatoria:

openssl rand -base64 32

Crea el archivo de configuración:

sudo nano /etc/dragonfly/dragonfly.conf

Pega este contenido y sustituye your_strong_password por la contraseña generada:

--bind=127.0.0.1
--port=6379
--requirepass=your_strong_password
--dir=/var/lib/dragonfly
--dbfilename=dump
--snapshot_cron=0 * * * *
--maxmemory=1gb
--cache_mode=true
--logtostderr

Qué hace cada opción:

  • --bind=127.0.0.1 acepta conexiones solo desde el propio servidor. Cámbialo por una IP privada si tus aplicaciones están en otras máquinas.
  • --requirepass exige autenticación con AUTH a cualquier cliente de Redis.
  • --dir y --dbfilename fijan dónde se guardan los snapshots. --snapshot_cron programa un snapshot al inicio de cada hora con sintaxis de cron.
  • --maxmemory limita la memoria de datos. Déjalo por debajo de la RAM disponible, con margen para el sistema y los snapshots.
  • --cache_mode=true hace que Dragonfly expulse las claves menos útiles al llegar a maxmemory, como allkeys-lru en Redis. Si guardas datos que no deben perderse, quita esta línea: Dragonfly devolverá un error de memoria llena en lugar de borrar claves.
  • --logtostderr envía los logs a la salida estándar, que systemd guarda en el journal.

Por defecto Dragonfly usa un hilo por núcleo. Si compartes el servidor con otros servicios, puedes limitarlo añadiendo --proactor_threads=2.

Restringe los permisos del archivo porque contiene la contraseña:

sudo chown root:dragonfly /etc/dragonfly/dragonfly.conf
sudo chmod 640 /etc/dragonfly/dragonfly.conf

Paso 4: Crear el servicio de systemd

Crea la unidad del servicio:

sudo nano /etc/systemd/system/dragonfly.service

[Unit]
Description=Dragonfly in-memory data store
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=dragonfly
Group=dragonfly
ExecStart=/usr/local/bin/dragonfly --flagfile=/etc/dragonfly/dragonfly.conf
StateDirectory=dragonfly
WorkingDirectory=/var/lib/dragonfly
LimitNOFILE=65535
LimitMEMLOCK=infinity
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

StateDirectory=dragonfly hace que systemd cree /var/lib/dragonfly con el usuario dragonfly como propietario. LimitMEMLOCK=infinity evita errores de io_uring al reservar memoria bloqueada.

Carga la unidad, habilítala y arráncala:

sudo systemctl daemon-reload
sudo systemctl enable --now dragonfly
sudo systemctl status dragonfly --no-pager

● dragonfly.service - Dragonfly in-memory data store
     Loaded: loaded (/etc/systemd/system/dragonfly.service; enabled; preset: enabled)
     Active: active (running)

Si el estado no es active (running), consulta los últimos mensajes con sudo journalctl -u dragonfly -n 50.

Paso 5: Probar la compatibilidad con Redis

Para no escribir la contraseña en cada comando ni dejarla en el historial de la shell, redis-cli la lee de la variable REDISCLI_AUTH. Expórtala en la sesión actual; el espacio inicial evita que Bash la guarde en el historial con la configuración por defecto de Ubuntu:

 export REDISCLI_AUTH='your_strong_password'

Lanza un PING:

redis-cli ping

PONG

Prueba algunos tipos de datos habituales:

redis-cli set sesion:42 "datos" EX 3600
redis-cli hset producto:1 nombre "VPS" precio 12
redis-cli hgetall producto:1
redis-cli zadd ranking 1500 ana 2300 luis
redis-cli zrevrange ranking 0 -1 withscores

OK
(integer) 2
1) "nombre"
2) "VPS"
3) "precio"
4) "12"
(integer) 2
1) "luis"
2) "2300"
3) "ana"
4) "1500"

Comprueba la versión y la memoria configurada:

redis-cli info server | grep -i version
redis-cli info memory | grep -E 'used_memory_human|maxmemory_human'

Las librerías cliente de Redis (redis-py, ioredis, go-redis, Jedis) funcionan sin cambios: apunta tu aplicación a 127.0.0.1:6379 con la contraseña configurada.

Paso 6 (opcional): Activar el protocolo Memcached

Dragonfly también puede atender clientes de Memcached en otro puerto. Añade esta línea a /etc/dragonfly/dragonfly.conf:

--memcached_port=11211

Reinicia el servicio:

sudo systemctl restart dragonfly

Prueba el protocolo de texto de Memcached con nc:

printf 'set saludo 0 60 4\r\nhola\r\nget saludo\r\nquit\r\n' | nc 127.0.0.1 11211

STORED
VALUE saludo 0 4
hola
END

Paso 7: Medir el rendimiento

Lanza redis-benchmark con 50 conexiones concurrentes y pipelining, pasándole la contraseña desde la variable que exportaste:

redis-benchmark -h 127.0.0.1 -p 6379 -a "$REDISCLI_AUTH" -t set,get -n 500000 -c 50 -P 16 --threads 2 -q

SET: 1250000.00 requests per second, p50=0.575 msec
GET: 1515151.50 requests per second, p50=0.471 msec

Las cifras dependen del número de núcleos y de si el benchmark comparte CPU con Dragonfly. Para mediciones fiables, ejecútalo desde otra máquina de la misma red privada y cambia --bind a la IP privada del servidor. Mientras se ejecuta, top -H -p "$(pgrep -x dragonfly)" muestra la carga repartida entre los hilos.

Paso 8: Migrar datos desde Redis

Dragonfly puede cargar al arrancar un snapshot RDB generado por Redis. En el servidor Redis de origen, fuerza un guardado y comprueba que ha terminado:

redis-cli -h redis_server_ip -a 'redis_password' --no-auth-warning bgsave
redis-cli -h redis_server_ip -a 'redis_password' --no-auth-warning info persistence | grep rdb_bgsave_in_progress

Cuando rdb_bgsave_in_progress valga 0, copia el archivo al servidor de Dragonfly (en Ubuntu, Redis lo guarda en /var/lib/redis/dump.rdb). Después, en el servidor de Dragonfly, para el servicio, coloca el archivo con el nombre configurado en --dbfilename y arranca de nuevo:

sudo systemctl stop dragonfly
sudo install -o dragonfly -g dragonfly -m 0640 /tmp/dump.rdb /var/lib/dragonfly/dump.rdb
sudo systemctl start dragonfly

Compara el número de claves en origen y destino:

redis-cli dbsize

Las escrituras que se hagan en Redis después del BGSAVE no estarán en Dragonfly, así que programa la migración en una ventana de mantenimiento o detén las escrituras antes del guardado. Prueba siempre el proceso primero en un entorno que no sea de producción.

Solución de problemas

El servicio no arranca y el journal menciona io_uring o memlock. Comprueba que la unidad tiene LimitMEMLOCK=infinity y ejecuta sudo systemctl daemon-reload antes de reiniciar. En entornos que bloquean io_uring, añade --force_epoll al archivo de configuración.

NOAUTH Authentication required. El cliente no envía la contraseña. En aplicaciones, revisa la cadena de conexión, por ejemplo redis://:[email protected]:6379/0. En la terminal, comprueba que REDISCLI_AUTH está exportada en la sesión actual.

Errores -OOM al escribir. Se ha alcanzado --maxmemory sin --cache_mode=true. Aumenta el límite si hay RAM libre o activa el modo caché si los datos se pueden regenerar.

El servidor usa swap. maxmemory es demasiado alto para la RAM real. Comprueba el consumo con free -h y bájalo: un almacén en memoria que pasa a swap pierde toda su ventaja.

Conclusión

Dragonfly ya funciona en Ubuntu 24.04 como servicio de systemd, protegido con contraseña, con límite de memoria y snapshots cada hora, y compatible con tus clientes de Redis y Memcached. Como siguientes pasos puedes copiar periódicamente los snapshots de /var/lib/dragonfly a otro servidor, configurar una réplica con REPLICAOF en un segundo nodo Dragonfly o exponer sus métricas en formato Prometheus, que Dragonfly publica en http://127.0.0.1:6379/metrics.