---
title: "Cómo instalar Valkey en Ubuntu 24.04 y migrar desde Redis"
description: "Compila e instala Valkey, el fork open source de Redis, en Ubuntu 24.04 como servicio systemd con contraseña y persistencia AOF, y migra tus datos desde Redis."
category: "Bases de Datos Especializadas"
language: es
source: https://cubepath.com/es/docs/bases-de-datos-especializadas/instalacion-de-valkey-fork-de-redis
updated: 2026-09-25
---

# Cómo instalar Valkey en Ubuntu 24.04 y migrar desde Redis

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:

```bash
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](https://github.com/valkey-io/valkey/releases) y guárdala en una variable. En este ejemplo se usa la 9.1.2:

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

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

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

```bash
sudo make install
```

Comprueba la versión:

```bash
valkey-server --version
```

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

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

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

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

Abre la configuración:

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

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

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

Comprueba el valor:

```bash
sysctl vm.overcommit_memory
```

```output
vm.overcommit_memory = 1
```

## Paso 6: Crear el servicio systemd

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

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

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

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

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

```bash
valkey-cli --askpass
```

Dentro de la consola, prueba algunas operaciones:

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

```text
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://:your_strong_password@127.0.0.1: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):

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

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

Copia el snapshot de Redis con el propietario correcto:

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

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

```bash
valkey-cli --askpass DBSIZE
```

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

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

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

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