Valkey es un almacén clave-valor en memoria nacido en 2024 como fork de Redis 7.2.4, mantenido por la Linux Foundation con licencia BSD. Habla el mismo protocolo que Redis, así que las librerías cliente y los comandos existentes funcionan sin cambios. En este tutorial compilarás la última versión estable de Valkey en Ubuntu 24.04, la ejecutarás como servicio systemd con contraseña y persistencia en disco, y verás cómo migrar los datos de un Redis existente.

Requisitos previos

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
  • Un usuario no root con privilegios sudo.
  • Al menos 1 GB de RAM. Valkey guarda todo el conjunto de datos en memoria, así que dimensiona la RAM según el volumen que vayas a almacenar.

Paso 1: Instalar las dependencias de compilación

Compilar desde el código fuente te da la última versión estable, con soporte TLS e integración con systemd. Instala el compilador y las librerías de desarrollo de OpenSSL y systemd:

sudo apt update
sudo apt install build-essential pkg-config libssl-dev libsystemd-dev curl

Paso 2: Descargar y compilar Valkey

Consulta la última versión estable en la página de releases de Valkey y guárdala en una variable. En este ejemplo se usa la 9.1.2:

VALKEY_VERSION=9.1.2
cd /tmp
curl -fsSL -o valkey.tar.gz "https://github.com/valkey-io/valkey/archive/refs/tags/${VALKEY_VERSION}.tar.gz"
tar xzf valkey.tar.gz
cd "valkey-${VALKEY_VERSION}"

Compila con TLS integrado (BUILD_TLS=yes) y soporte para notificar a systemd cuando el servidor está listo (USE_SYSTEMD=yes):

make -j"$(nproc)" BUILD_TLS=yes USE_SYSTEMD=yes

La compilación tarda uno o dos minutos. Instala los binarios en /usr/local/bin:

sudo make install

Comprueba la versión:

valkey-server --version

Valkey server v=9.1.2 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=5b2f8c1e7a9d3c40

Paso 3: Crear el usuario y los directorios

Valkey debe ejecutarse con su propio usuario sin privilegios. Crea el usuario, el directorio de datos y el de configuración:

sudo useradd --system --home-dir /var/lib/valkey --shell /usr/sbin/nologin valkey
sudo install -d -o valkey -g valkey -m 0750 /var/lib/valkey
sudo install -d -o root -g valkey -m 0750 /etc/valkey

Copia la configuración de ejemplo que viene con el código fuente. Como contendrá la contraseña, solo root y el grupo valkey podrán leerla:

sudo install -o root -g valkey -m 0640 valkey.conf /etc/valkey/valkey.conf

Paso 4: Configurar Valkey

Genera una contraseña aleatoria y apúntala; la necesitarás en el archivo de configuración y en tus aplicaciones:

openssl rand -base64 32

Abre la configuración:

sudo nano /etc/valkey/valkey.conf

Busca cada una de estas directivas (con Ctrl+W en nano) y déjalas con estos valores. Sustituye your_strong_password por la contraseña generada:

bind 127.0.0.1 -::1
protected-mode yes
port 6379
supervised systemd
dir /var/lib/valkey
requirepass your_strong_password
appendonly yes
maxmemory 512mb
maxmemory-policy allkeys-lru
  • bind 127.0.0.1 -::1 hace que Valkey escuche solo en localhost, que es lo seguro si la aplicación está en el mismo servidor.
  • dir es donde se guardan los snapshots RDB y el directorio del AOF.
  • appendonly yes registra cada escritura en disco, de modo que tras un reinicio pierdes como mucho un segundo de datos (política appendfsync everysec por defecto).
  • maxmemory limita la memoria usada. Con allkeys-lru Valkey expulsa las claves menos usadas al llegar al límite, lo adecuado para una caché. Si Valkey guarda datos que no pueden perderse (colas, sesiones), usa noeviction: las escrituras fallarán al llenarse en lugar de borrar datos.

Paso 5: Ajustar el kernel

Valkey crea un proceso hijo al guardar a disco, y con la configuración por defecto de Linux esa operación puede fallar con poca memoria libre. Activa vm.overcommit_memory como recomienda el propio servidor al arrancar:

echo 'vm.overcommit_memory = 1' | sudo tee /etc/sysctl.d/60-valkey.conf
sudo sysctl --system

Comprueba el valor:

sysctl vm.overcommit_memory

vm.overcommit_memory = 1

Paso 6: Crear el servicio systemd

Crea la unidad basada en la que incluye Valkey en utils/:

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

[Unit]
Description=Valkey data structure server
Documentation=https://valkey.io/docs/
Wants=network-online.target
After=network-online.target

[Service]
Type=notify
User=valkey
Group=valkey
ExecStart=/usr/local/bin/valkey-server /etc/valkey/valkey.conf --supervised systemd --daemonize no
LimitNOFILE=10032
NoNewPrivileges=yes
UMask=0077
Restart=on-failure
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/var/lib/valkey

[Install]
WantedBy=multi-user.target

Type=notify hace que systemd espere a que Valkey haya cargado los datos antes de marcar el servicio como activo; por eso se compiló con USE_SYSTEMD=yes. Arranca el servicio:

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

● valkey.service - Valkey data structure server
     Loaded: loaded (/etc/systemd/system/valkey.service; enabled; preset: enabled)
     Active: active (running) since Fri 2026-09-25 10:20:41 UTC; 3s ago

Los mensajes del servidor van al journal: sudo journalctl -u valkey -n 30.

Paso 7: Probar la conexión

Conéctate con valkey-cli. La opción --askpass pide la contraseña sin que quede en el historial de la shell:

valkey-cli --askpass

Dentro de la consola, prueba algunas operaciones:

127.0.0.1:6379> PING
PONG
127.0.0.1:6379> SET saludo "hola desde valkey" EX 3600
OK
127.0.0.1:6379> GET saludo
"hola desde valkey"
127.0.0.1:6379> TTL saludo
(integer) 3597

Comprueba qué versión se reporta. Valkey mantiene el campo redis_version fijo en 7.2.4 para que los clientes que lo consultan sigan funcionando, y añade valkey_version:

127.0.0.1:6379> INFO server
# Server
redis_version:7.2.4
server_name:valkey
valkey_version:9.1.2

Sin contraseña, cualquier comando devuelve (error) NOAUTH Authentication required., lo que confirma que requirepass está activo.

Para scripts y aplicaciones, valkey-cli también lee la contraseña de la variable VALKEYCLI_AUTH (y de REDISCLI_AUTH, por compatibilidad). En tu aplicación basta con cambiar la URL de conexión a redis://:[email protected]:6379/0; los clientes de Redis funcionan igual.

Paso 8: Migrar datos desde Redis (opcional)

Valkey carga directamente los archivos RDB de Redis 7.2 y anteriores, que incluyen el Redis 7.0 del paquete redis-server de Ubuntu 24.04. Los RDB de Redis 7.4 o posterior usan un formato más nuevo que Valkey rechaza por defecto (directiva rdb-version-check strict); con rdb-version-check relaxed Valkey intenta cargarlos igualmente, pero falla si el archivo contiene tipos de datos que no conoce, así que pruébalo antes en una copia.

Si Redis corre en el mismo servidor, fuerza un snapshot con todos los datos y detén Redis para liberar el puerto 6379 (añade -a o --askpass si tu Redis tiene contraseña):

redis-cli SAVE
sudo systemctl disable --now redis-server

Detén Valkey y borra el AOF vacío que creó en el primer arranque; si lo dejas, Valkey lo cargaría en lugar del RDB:

sudo systemctl stop valkey
sudo rm -rf /var/lib/valkey/appendonlydir

Copia el snapshot de Redis con el propietario correcto:

sudo install -o valkey -g valkey -m 0640 /var/lib/redis/dump.rdb /var/lib/valkey/dump.rdb

Desactiva temporalmente el AOF para que Valkey arranque leyendo el RDB:

sudo sed -i 's/^appendonly yes/appendonly no/' /etc/valkey/valkey.conf
sudo systemctl start valkey

Compara el número de claves con el que tenía Redis (redis-cli DBSIZE antes de pararlo):

valkey-cli --askpass DBSIZE

(integer) 18342

Cuando cuadre, vuelve a activar el AOF en caliente (Valkey lo reconstruye a partir de los datos en memoria) y deja la configuración como estaba:

valkey-cli --askpass CONFIG SET appendonly yes
sudo sed -i 's/^appendonly no/appendonly yes/' /etc/valkey/valkey.conf

Revisa sudo journalctl -u valkey -n 20 y confirma que aparece un mensaje de reescritura del AOF completada. Si Redis estaba en otro servidor, copia su dump.rdb con scp y sigue los mismos pasos.

Paso 9: Permitir conexiones remotas (opcional)

Si tu aplicación está en otro servidor, lo más seguro es conectarla por una red privada. Añade la IP privada del servidor de Valkey (your_private_ip) a bind en /etc/valkey/valkey.conf:

bind 127.0.0.1 -::1 your_private_ip

Reinicia y permite el puerto solo desde la IP de la aplicación (your_app_ip):

sudo systemctl restart valkey
sudo ufw allow from your_app_ip to any port 6379 proto tcp

Nunca expongas el puerto 6379 a Internet sin filtrar, aunque tenga contraseña: es uno de los puertos más escaneados.

Solución de problemas

  • El servicio queda en activating y acaba fallando: el binario se compiló sin USE_SYSTEMD=yes, así que nunca avisa a systemd. Recompila con esa opción o cambia la unidad a Type=simple.
  • Can't open the append only file o Permission denied: /var/lib/valkey debe pertenecer a valkey. Corrígelo con sudo chown -R valkey:valkey /var/lib/valkey.
  • Address already in use: otro proceso (normalmente Redis) ocupa el 6379. Compruébalo con sudo ss -ltnp | grep 6379.
  • OOM command not allowed when used memory > 'maxmemory': se alcanzó el límite con la política noeviction. Sube maxmemory o revisa qué claves ocupan memoria con valkey-cli --askpass --bigkeys.

Conclusión

Valkey está funcionando en Ubuntu 24.04 como servicio systemd, protegido con contraseña, con persistencia AOF y compatible con tus clientes de Redis. Como siguientes pasos, activa TLS con las directivas tls-port, tls-cert-file y tls-key-file (el binario ya incluye soporte), sustituye requirepass por usuarios ACL con permisos por comando y, si necesitas alta disponibilidad, configura una réplica con replicaof.