Introducción

Redis es una base de datos clave‑valor en memoria extremadamente rápida que podés usar como caché, cola de mensajes o repositorio de datos principal para aplicaciones en tiempo real. Saber cómo ejecutar una instancia local de Redis es una habilidad esencial para cualquier desarrollador, DevOps o ingeniero de datos.

En esta guía detallada, vas a aprender a instalar y ejecutar Redis en tu máquina local usando tres enfoques diferentes:

1. Homebrew (brew) en macOS – el método preferido para usuarios de macOS.
2. apt en Ubuntu/Debian – la opción estándar para sistemas Linux.
3. Docker Compose – una forma portátil y aislada de ejecutar Redis junto con el resto de tu stack de desarrollo.

Para cada enfoque, vas a ver los comandos exactos que querés ejecutar junto con la salida esperada, además de algunos ejemplos prácticos para asegurarte de que Redis funciona correctamente. Al finalizar, vas a tener un laboratorio local de Redis completamente funcional que podés usar durante el desarrollo, pruebas o experimentación.

Para quién es esta guía

• Desarrolladores web que necesitan una caché rápida para aplicaciones Node.js, Python, Ruby, etc.
• Ingenieros de datos que quieren probar pipelines de ingesta o algoritmos de machine learning con un almacén rápido.
• Profesionales de DevOps que están acostumbrados a usar herramientas de gestión de paquetes del sistema operativo y contenedores.
• Estudiantes o entusiastas que quieren una forma sencilla y bien documentada de experimentar con Redis sin complicaciones.

Si alguna vez te encontraste con la necesidad de ejecutar redis-server en una máquina nueva, esta guía te dará un punto de partida sólido y reproducible.

Qué vas a aprender

• Instalar Redis usando brew en macOS.
• Instalar Redis usando apt en Ubuntu/Debian.
• Escribir un docker‑compose.yml limpio que inicie un contenedor de Redis y lo exponga a tu app.
• Verificar que una instancia local de Redis esté funcionando con redis‑cli ping y comandos de clave‑valor básicos.
• Entender las diferencias entre las tres formas (nativa vs. contenedorizada) y cuándo elegir cada una.
• Seguir buenos prácticas para seguridad, persistencia y monitoreo.

Todos los bloques de comandos incluyen los comandos que ejecutás y la salida que esperas ver (mostrada como comentarios dentro de los bloques de código). Podés copiar pegar cada segmento directamente en tu terminal.

1️⃣ Instalación de Redis con Homebrew (macOS)

Homebrew es el gestor de paquetes por defecto para macOS. Usarlo es generalmente más sencillo que compilar desde el código fuente y evita dependencias del sistema operativo.

1.1 Instalar Homebrew (si todavía no lo tenés)

Si no tenés Homebrew, podés instalarlo con el script oficial de GitHub.

# Ejecutar en Terminal
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Salida esperada (fragmento)

/home/linuxbrew/.linuxbrew/bin/brew install --cask terminal
Ejecutando `sudo chown -R $(whoami):admin /usr/local`
# … mensajes de progreso …
"Bienvenido a Homebrew!"

Nota: El script agregará /home/linuxbrew/.linuxbrew/bin a tu $PATH. Reiniciá la terminal o ejecutá echo "$PATH" para confirmar.

1.2 Instalar Redis

Ahora que Homebrew está listo, installá la versión estable más reciente.

# Actualizar la fórmula para obtener las últimas versiones y parches
h brew update

# Instalar Redis (esto descarga el binario, la documentación y un script de inicio de servicio)
brew install redis

Salida esperada (resumen de la instalación)

==> Descargando https://homebrew.bintray.com/casks/redis.rb
==> Descargando https://homebrew.bintray.com/casks/redis.rb
==> Verificando integridades SHA‑256…  ✓  1234abcd…
==> Descargando redis‑6.2.5‑macos‑arm64 …
==> Instalando…
/usr/local/bin/redis‑server -> /opt/homebrew/Cellar/redis/6.2.5/bin/redis‑server
… (archivos adicionales, documentación, etc.)

1.3 Iniciar Redis

Homebrew viene con un script de fondo /opt/homebrew/opt/redis/bin/redis‑server que usa launchd. Podés iniciar el servicio con:

brew services start redis

Salida esperada

bazzzi@MacBookPro ~ % brew services start redis
=> Iniciando `redis` con `launchctl`…
=> `redis` se ha iniciado con éxito

1.4 Verificar que Redis está funcionando

Ahora podés usar el cliente CLI redis‑cli que installó Homebrew. El comando más básico es ping:

redis‑cli ping

Salida esperada

$ redis‑cli ping
PONG

Si ves PONG, tenés una instancia local de Redis completamente funcional.

1.5 Inspeccionar la configuración (opcional)

El archivo de configuración predeterminado se encuentra en /opt/homebrew/etc/redis.conf. Podés ver algunos ajustes clave con cat:

cat /opt/homebrew/etc/redis.conf | head -n 20

Salida esperada (fragmento)

# Servidor TCP – escucha en localhost:6379 por defecto
host: 127.0.0.1
port: 6379
# …

1.6 Detener / Reiniciar el servicio

Si más adelante necesitás detener Redis administrado por Homebrew:

brew services stop redis

O para reiniciarlo (útil después de cambios de configuración):

brew services restart redis

2️⃣ Instalación de Redis con apt (Ubuntu / Debian)

Para sistemas basados en Debian, podés usar apt para instalar Redis. Esto generalmente se integra con el gestor de servicios del sistema operativo (systemd), lo cual facilita el control de su ciclo de vida.

2.1 Actualizar el índice de paquetes

sudo apt update

Salida esperada (fragmento)

Hit http://archive.ubuntu.com/ubuntu focal InRelease
Hit http://archive.ubuntu.com/ubuntu focal/main amd64 Packages
…
Obteniendo listas de paquetes…
0 upgrades recargados, 0 upgrades disponibles.

2.2 Instalar Redis Server

sudo apt install redis-server

Salida esperada (resumen)

Leyendo lista de paquetes…
... 
Seleccionando el paquete redis-server (6.2.5-1ubuntu1) …
Instalando redis-server (6.2.5-1ubuntu1) …
Procesando dependencias …
... 
¿Querés ejecutar redis‑server al iniciar el sistema? (recomendado)
[SI/YES]

Durante la instalación, se te preguntará si quieres habilitar redis-server para que inicie automáticamente al arrancar el sistema. Es recomendable aceptar.

2.3 Verificar el estado del servicio

Ubuntu/Debian usan systemd. Verificá que el servicio esté activo:

sudo systemctl status redis-server

Salida esperada (servicio activo)

● redis-server.service - Redis persistent server
   Carga: cargado; activado: habilitado (ver motivo)
   Proceso: 12345 /usr/bin/redis-server (code=exit-status=0)
   Tareas: 1 (ejecutándose)
   Memoria: 2.5M
   24 de jun. 22:14:33 localhost.localdomain.local redis-server[12345]: Listo para aceptar conexiones en 127.0.0.1:6379

Si el servicio no está activo, podés iniciarlo manualmente con:

sudo systemctl start redis-server

2.4 Probar con redis‑cli

Al igual que en macOS, podés usar redis‑cli (instalado como parte del paquete) para enviar comandos. El comando de salud ping:

redis-cli ping

Salida esperada

$ redis-cli ping
PONG

2.5 Inspeccionar la configuración

El archivo de configuración principal en sistemas Debian es /etc/redis/redis.conf. Podés editarlo con un editor de texto (sudo nano /etc/redis/redis.conf) o mostrar fragmentos:

sudo grep -E "^(bind|port|protected-mode)" /etc/redis/redis.conf

Salida esperada (predeterminada)

bind 127.0.0.1
port 6379
protected-mode yes

Estos valores hacen que Redis escuche solo en localhost (seguro para desarrollo local).

2.6 Deshabilitar / Reiniciar el servicio

Si necesitás detener Redis:

sudo systemctl stop redis-server

Para reiniciarlo con una nueva configuración:

sudo systemctl restart redis-server

3️⃣ Ejecutar Redis con Docker Compose

Docker Compose ofrece un entorno aislado y reproducible que puede ser versionado junto con el resto del código. Es especialmente útil cuando querés ejecutar múltiples contenedores (por ejemplo, una aplicación web + Redis) y necesitas un control preciso sobre las versiones.

3.1 Instalar Docker (si todavía no lo tenés)

Ubuntu/Debian (ejemplo para Ubuntu 20.04+):

sudo apt update
sudo apt install -y docker.io docker-compose

macOS (usando Homebrew):

brew install --cask docker

Después de la instalación, asegurá que el daemon de Docker esté corriendo:

docker --version && docker compose version

Salida esperada

Docker version 24.0.5, build ce273b5
Docker Compose version v2.23.3

3.2 Escribir un docker-compose.yml simple

Crea un nuevo directorio (por ejemplo, redis-demo) y dentro un archivo docker-compose.yml:

d services:
  redis:
    image: redis:7.2
    container_name: redis-local
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: ["redis-server", "--appendonly", "yes"]

volumes:
  redis-data:

Explicación

• image: redis:7.2 → Usá la imagen estable más reciente.
• container_name da un identificador predecible.
• ports expone el puerto 6379 en la máquina host (útil para redis-cli desde el host).
• volumes asegura que los datos sobrevivan a la eliminación del contenedor.
• command habilita la escritura del registro de acceso (appendonly yes) para persistencia.

3.3 Iniciar el contenedor de Redis

Asegurate de estar en el directorio que contiene docker-compose.yml y luego ejecutá:

docker compose up -d

Salida esperada

bazzzi@ubuntu ~ % docker compose up -d
[+] Construyendo 0/0 (sin cambios)
[+] Ejecutando 1/1
▶ Ejecutando 822c7c9c5b1e con ID 822c7c9c5b1e

Ahora podés ver la lista de contenedores:

docker compose ps

Salida esperada

NOMBRE               IMAGEN                PUERTOS                                       ESTADO              NOMBRE DEL SERVICIO
redis-local         redis:7.2           0.0.0.0:6379->6379/tcp                     Ejecutándose          redis

3.4 Conectarse al Redis de Docker desde el host

Dado que mapeamos el puerto 6379, podés usar redis-cli directamente desde la terminal del host:

redis-cli -h 127.0.0.1 -p 6379 ping

Salida esperada

$ redis-cli -h 127.0.0.1 -p 6379 ping
PONG

3.5 Probar operaciones de clave‑valor

Para una demostración rápida, creá una clave, asignale un valor y luego leéla:

redis-cli -x set mykey "Hola desde Docker!"

Salida esperada

$ redis-cli -x set mykey "Hola desde Docker!"
"Hola desde Docker!"

Ahora obtené el valor:

redis-cli get mykey

Salida esperada

$ redis-cli get mykey
"Hola desde Docker!"

Puedes inspeccionar las claves con keys * (tené cuidado con las bases de datos de producción, esto es solo para una demo):

redis-cli keys '*'

Salida esperada

$ redis-cli keys '*'
1) "mykey"

3.6 Inspeccionar los logs del contenedor

Si necesitás ver los registros de acceso de Redis (gracias a appendonly yes), podés verlos con:

docker compose logs -f redis

Salida esperada (fragmento)

► redis | 1:L 2024-06-25 22:32:10.123 * Conectado al sistema de archivos de datos, listo para aceptar conexiones

Presioná Ctrl+C para detener la visualización de los logs.

3.7 Reiniciar el contenedor

Si actualizás la imagen de Redis o editás la configuración, puedes reiniciar el servicio:

docker compose restart redis

Salida esperada

redis-local_restarting

3.8 Eliminar el contenedor y el volumen (cuando sea necesario)

Para limpiar completamente:

docker compose down -v

Salida esperada

docker compose down -v
[+] Ejecutando 0/0 (sin cambios)
Eliminando redis-local

El flag -v también elimina el volumen redis-data, borrando todos los datos persistidos.

4️⃣ Operaciones básicas con Redis (demostración rápida)

Independientemente del método de instalación, una demostración práctica ayuda a afianzar los conceptos. Aquí tenés algunos comandos típicos con su salida esperada.

4.1 Configuración inicial

# Establecer un valor simple
redis-cli set session:123 user "alice"

# Obtener el valor
redis-cli get session:123

# Incrementar un contador
redis-cli incr page_views

# Listas – agregar elementos a una lista (pila)
redis-cli rpush todo "comprar leche" "comprar café"

# Obtener todos los elementos de la lista
redis-cli lrange todo 0 -1

# Conjuntos – agregar miembros únicos
redis-cli sadd active_users 5 10 15

# Verificar la pertenencia
redis-cli sismember active_users 10

# Eliminar claves
redis-cli del session:123 todo

Salida esperada (cada comando, en orden)

$ redis-cli set session:123 user "alice"
$redis-cli get session:123
"user"
$ redis-cli incr page_views
:integer 1
$ redis-cli rpush todo "comprar leche" "comprar café"
:integer 2
$ redis-cli lrange todo 0 -1
1) "comprar leche"
2) "comprar café"
$ redis-cli sadd active_users 5 10 15
:integer 3
$ redis-cli sismember active_users 10
:integer 1
$ redis-cli del session:123 todo
:integer 0

Explicación – Los ceros y unos indican diferentes tipos de respuestas. Redis devuelve una respuesta para cada comando; para los comandos SET/GET devuelve OK o el valor, INCR devuelve el nuevo entero, RPUSH devuelve el nuevo longitud, y DEL devuelve el número de claves eliminadas.

4.2 Uso de un cliente Python (opcional)

Si estás construyendo una aplicación, probablemente querrás interactuar con Redis desde dentro de tu código. Instalá redis-py (requiere pip):

pip install redis

Guarda el siguiente script (demo.py) en tu máquina:

try:
    import redis
    r = redis.Redis(host='localhost', port=6379, db=0)
    r.ping()
    r.set('demo_key', 'desde Python')
    value = r.get('demo_key')
    print('Ping:', r.ping())
    print('Set demo_key:', value.decode())
except Exception as e:
    print('Error:', e)

Ejecutalo:

python demo.py

Salida esperada

Ping: True
Set demo_key: desde Python

Este ejemplo demuestra un cliente nativo de Python, pero el mismo patrón funciona para Node.js (redis npm), Ruby (redis), Go (go-redis) y muchos otros lenguajes.

5️⃣ Guías de mejores prácticas

5.1 Seguridad

• Restringí el acceso por red: Por defecto, Redis escucha en 127.0.0.1. Si necesitás aceptar conexiones desde contenedores externos, cambiá bind 127.0.0.1 a bind 0.0.0.0 y protegé el servicio con una contraseña (requirepass) o usá un firewall.
• Usa requirepass: Establece una contraseña fuerte, por ejemplo, redis-cli config set requirepass MyS3cr3tP@ss.
• Evita exporlo a internet: Nunca publiques un contenedor de Redis en un host público sin autenticación.

5.2 Persistencia

• Registro de acceso (appendonly yes): Agrega appendonly yes y appenddirname "append" a redis.conf para una durabilidad más fuerte.
• Instantáneas (save 900 1): Ajusta las condiciones de save según la tolerancia a pérdida de datos vs. rendimiento.
• Volúmenes de Docker: Cuando uses Docker Compose, los volúmenes (redis-data) mantienen los datos incluso después de eliminar el contenedor.

5.3 Monitoreo

• Métrica integrada: redis-cli info despliega estadísticas como memoria, hits, misses, connected_clients.
• Exportador Prometheus: Instalá redis_exporter (docker pull oliver006/redis_exporter) y configurá Prometheus para scrapearlo.
• Alertas: Configurá umbrales para used_memory o instantaneous_ops_per_sec para evitar problemas de memoria.

5.4 Rendimiento

• Ajusta maxmemory: Define una política de expiración (maxmemory-policy allkeys-lru) para forzar la limpieza automática de entradas menos usadas.
• Usa claves de lectura intensiva en caché: Evita operaciones costosas en KEYS en producción; en su lugar, usa SCAN para iterar de forma segura.
• Optimiza el número de conexiones: Para aplicaciones de alta concurrencia, considerá usar hilos o un pool de conexiones.

5.5 Prácticas recomendadas para contenedores

• Usa imágenes oficiales: Siempre optá por imágenes de redis oficiales (redis:<tag>) de Docker Hub.
• Evita modificar el sistema de archivos dentro del contenedor: Monte volúmenes en /data (o donde definas dir en redis.conf).
• Versiona tu docker-compose.yml: Incluí la versión exacta de la imagen (por ejemplo, redis:6.2.5) para evitar sorpresas por cambios no intencionales.

6️⃣ Problemas comunes y soluciones

Si encontrás un error fuera de estos, verifica los registros (docker compose logs redis, redis-server --logfile o los registros del sistema) para obtener pistas.

7️⃣ Conclusión

Ejecutar Redis localmente es una tarea esencial para el desarrollo y pruebas. Este artículo te guió a través de tres enfoques populares:

1. Homebrew en macOS – una instalación rápida del sistema de gestión de paquetes nativo.
2. apt en Ubuntu/Debian – una integración perfecta con systemd.
3. Docker Compose – un método contenedorizado y reproducible que se integra bien con pipelines de CI/CD y stacks de múltiples contenedores.

Ahora tenés un laboratorio local de Redis completamente funcional. Pruébalo con redis-cli ping, experimentá con algunos comandos básicos (SET, GET, INCR, listas, conjuntos), y después elegí la forma que mejor se adapte a tu flujo de trabajo.

Recordá seguir las guías de mejores prácticas (seguridad, persistencia, monitoreo, rendimiento) para mantener un entorno de Redis estable y seguro. Con un Redis local bien configurado, podés iterar más rápido, escribir mejores pruebas y crear aplicaciones más confiables.

8️⃣ Próximos pasos

• Automatización: Agregá una entrada en tu script de configuración de host (.cfg, .sh, .ps1) para instalar automáticamente Redis usando el método preferido.
• Integración continua: Agregá redis como un servicio en tu pipeline de CI (por ejemplo, docker compose up -d redis).
• Escalado: Cuando tu aplicación crezca, considerá usar redis-cluster o Redis Enterprise para distribuir la carga.

¡Feliz programación, y que tus claves siempre devuelvan valores!

9️⃣ Notas finales

Este artículo es una guía práctica, sin rodeos. Usá los bloques de comandos copy‑paste tal cual, verifica la salida esperada, y podés confiar en que tu instancia local de Redis está configurada correctamente.

Si necesitás soporte para un sistema operativo específico, una versión de imagen diferente o trucos avanzados (por ejemplo, TLS, ACL o replicación), avísame y puedo ampliar la guía con esos temas especializados.

¡Que te diviertas explorando Redis! 🚀

---

## 10️⃣ Referencias y recursos útiles

- Página oficial de descarga de Redis: https://redis.io/download
- Documentación de Homebrew: https://brew.sh
- Documentación de Docker Compose: https://docs.docker.com/compose/overview
- Guía de inicio rápido de redis‑py: https://redis-py.readthedocs.io/en/stable/

---

## 11️⃣ Política de privacidad / contacto

Si tenés sugerencias, encontraste algún error o querés más profundizar en temas específicos (por ejemplo, cluster, scripts de administración o migraciones), no dudes en contactarme. ¡Estoy feliz de ayudar!