---
title: "Cómo instalar Dragonfly en Ubuntu 24.04 con systemd"
description: "Instala Dragonfly en Ubuntu 24.04 como servicio systemd, con contraseña, límite de memoria y snapshots, y prueba su compatibilidad con Redis y Memcached."
category: "Caché y CDN"
language: es
source: https://cubepath.com/es/docs/caché-y-cdn/instalacion-de-dragonfly-almacen-en-memoria
updated: 2026-09-25
---

# Cómo instalar Dragonfly en Ubuntu 24.04 con systemd

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:

```bash
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:

```bash
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:

```bash
dragonfly --version
```

```output
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:

```bash
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:

```bash
openssl rand -base64 32
```

Crea el archivo de configuración:

```bash
sudo nano /etc/dragonfly/dragonfly.conf
```

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

```ini
--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:

```bash
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:

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

```ini
[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:

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

```output
● 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:

```bash
 export REDISCLI_AUTH='your_strong_password'
```

Lanza un `PING`:

```bash
redis-cli ping
```

```output
PONG
```

Prueba algunos tipos de datos habituales:

```bash
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
```

```output
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:

```bash
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`:

```ini
--memcached_port=11211
```

Reinicia el servicio:

```bash
sudo systemctl restart dragonfly
```

Prueba el protocolo de texto de Memcached con `nc`:

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

```output
STORED
VALUE saludo 0 4
hola
END
```

> Advertencia: el protocolo Memcached no tiene autenticación y `--requirepass` no lo protege. Mantén `--bind` en `127.0.0.1` o en una IP privada si activas este puerto.

## Paso 7: Medir el rendimiento

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

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

```output
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:

```bash
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:

```bash
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:

```bash
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://:your_strong_password@127.0.0.1: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`.