Redis vs Memcached: cuál elegir para tu aplicación en 2026

Redis y Memcached son las dos opciones más populares para cache in-memory. Esta guía te ayuda a elegir la correcta para tu caso.

—

TL;DR

• Usa Redis (90% de los casos): más features, persistencia, tipos de datos avanzados
• Usa Memcached: solo si necesitas caché ultra-simple con máximo rendimiento de lectura/escritura de strings

—

¿Qué son?

Redis

Redis (Remote Dictionary Server) es un almacén de datos in-memory que soporta múltiples tipos de datos: strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, geospatial indexes. Tiene persistencia opcional en disco.

Memcached

Memcached es un sistema de caché distribuido in-memory. Solo soporta strings (binarios opacos). No tiene persistencia. Diseñado para ser simple y rápido.

—

Comparativa técnica

Feature	Redis 7.x	Memcached 1.6
Tipos de datos	9+ (string, hash, list, set, sorted set, …)	Solo string
Persistencia	Sí (RDB snapshots, AOF log)	No
Replicación	Sí (master-replica)	No (solo cluster)
Cluster	Sí (hash slots, 16384 nodos)	Sí (hash consistente)
Pub/Sub	Sí	No
Lua scripting	Sí	No
Transacciones	Sí (MULTI/EXEC)	No
Streams	Sí (Redis 5+)	No
Memory limit	Por config (maxmemory)	Por defecto (RAM disponible)
Protocolo	RESP (text + binary)	Solo text
Throughput típico	100K-1M ops/seg	200K-2M ops/seg

—

¿Cuándo usar Redis?

1. Cache + estructura de datos compleja

Si necesitas cache que no son solo strings:

• Sessions con objetos anidados
• Leaderboards (sorted sets)
• Contadores en tiempo real
• Colas de tareas (lists)

2. Persistencia

Si quieres que el cache sobreviva a reinicios:

• Configuración de aplicación cacheada
• Resultados de queries costosas
• Rate limiting persistente

3. Pub/Sub

Si necesitas mensajería en tiempo real:

• Chat
• Notificaciones
• WebSockets

4. Lua scripting

Si necesitas operaciones atómicas complejas en el servidor.

5. Como base de datos

Redis puede ser DB principal para casos de baja latencia. Con RedisJSON, RedisGraph, RedisTimeSeries es más versátil que nunca.

—

¿Cuándo usar Memcached?

1. Cache HTTP de objetos simple

Si cacheas HTML responses, JSON serializado, o cualquier blob binario.

2. Multi-threaded por defecto

A diferencia de Redis (single-threaded para comandos, aunque Redis 6+ usa I/O threads para network), Memcached usa múltiples threads por defecto, lo cual ayuda en máquinas con muchos cores.

3. Cero administración

Memcached es super simple: install, run, forget. No requiere configurar persistencia, replicación, etc.

4. Cuando ya tienes Memcached en producción

Si tu sistema actual usa Memcached y funciona bien, no hay razón fuerte para migrar.

—

Benchmarks reales (2026)

Operaciones por segundo (single instance, AWS Graviton 4):

Operación	Redis 7.4	Memcached 1.6
GET string 1KB	180K ops/s	350K ops/s
SET string 1KB	170K ops/s	320K ops/s
INCR counter	220K ops/s	N/A
HGET hash	200K ops/s	N/A
List push (LPUSH)	195K ops/s	N/A

Memcached gana en velocidad pura para strings. Redis gana en variedad.

Memoria (mismo workload, mismo hardware):

• Redis: ~85% eficiente (overhead de estructuras internas)
• Memcached: ~95% eficiente (almacena strings opacos)

—

Instalación rápida

Redis

El paquete redis-server en Debian/Ubuntu es el server oficial mantenido por Redis Inc. Incluye redis-cli, redis-benchmark y las herramientas de diagnóstico. Habilitar el servicio lo deja arrancando en cada boot (enable), start lo arranca ahora; verificar con redis-cli ping te asegura que el protocolo RESP está vivo — si responde PONG, el server está aceptando conexiones en localhost:6379.

# Ubuntu/Debian
sudo apt install redis-server
# Habilitar y arrancar
sudo systemctl enable redis-server
sudo systemctl start redis-server
# Verificar
redis-cli ping
# PONG

Troubleshooting: si redis-cli ping se queda colgado o da Could not connect, el server probablemente no está escuchando en 127.0.0.1:6379. Revisa /etc/redis/redis.conf y verifica que la línea bind 127.0.0.1 ::1 esté descomentada (Redis 6+ viene con bind 127.0.0.1 -::1 * por defecto, lo cual lo expone a internet — peligro crítico). Si systemctl start falla con Job for redis-server.service failed because a configured resource limit was exceeded, suele ser un conflicto de puerto con otro Redis ya corriendo (ss -tlnp | grep 6379). Para producción, cambiá el supervised a systemd y configura requirepass con una contraseña fuerte — sin esto, cualquiera con acceso a localhost puede escribir en tu cache.

Memcached

memcached se distribuye como binario único en el paquete del mismo nombre. Por defecto escucha en localhost:11211 con 64 MB de RAM y todas las interfaces loopback. El protocolo es texto plano ASCII (stats, set, get, delete); puedes probarlo con nc o telnet sin instalar cliente adicional.

# Ubuntu/Debian
sudo apt install memcached
# Habilitar y arrancar
sudo systemctl enable memcached
sudo systemctl start memcached
# Probar
echo "stats" | nc localhost 11211

Troubleshooting: si echo "stats" | nc no devuelve nada, verifica que el puerto 11211 esté abierto en loopback con ss -tlnp | grep 11211. Memcached en Ubuntu/Debian por defecto escucha en 127.0.0.1 (configurado en /etc/memcached.conf), pero versiones viejas de la imagen Docker y algunas distros derivadas lo dejaban en 0.0.0.0 — esto es un riesgo de seguridad grave (hubo exploits remotos de amplificación en el pasado). Si necesitas ajustar memoria, modificá -m 256 en /etc/memcached.conf (en MB) y reiniciá. Si systemctl status muestra Address already in use, otro memcached está corriendo en ese puerto; matalo con pkill memcached o cambiá -p en la config.

—

Cómo migrar de Memcached a Redis (si decides hacerlo)

La mayoría de aplicaciones usan get/set que son compatibles. Si usas features avanzadas (TTL diferente por key, list ops, etc), necesitas refactor.

Python (con redis-py):

# Memcached
from pymemcache.client.base import Client
mc = Client(('localhost', 11211))
mc.set('key', 'value', expire=300)
# Redis (mismo API para get/set básico)
import redis
r = redis.Redis(host='localhost', port=6379)
r.set('key', 'value', ex=300)

—

Patrones comunes de uso

Redis: Session store

import redis
import json
r = redis.Redis(host='localhost', port=6379)
# Guardar sesión
session_id = 'user_123'
session_data = {'user_id': 123, 'role': 'admin', 'last_seen': '2026-08-02'}
r.setex(f'session:{session_id}', 3600, json.dumps(session_data))
# Recuperar sesión
session = json.loads(r.get(f'session:{session_id}'))

Redis: Rate limiting

import redis
import time
r = redis.Redis(host='localhost', port=6379)
def is_allowed(user_id, max_requests=100, window=60):
    key = f'rate:{user_id}:{int(time.time() // window)}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current <= max_requests

Memcached: HTTP response cache

from pymemcache.client.base import Client
import json
mc = Client(('localhost', 11211))
def get_cached_response(url):
    cached = mc.get(f'response:{url}')
    if cached:
        return json.loads(cached)
    return None
def cache_response(url, data, ttl=300):
    mc.set(f'response:{url}', json.dumps(data), expire=ttl)

---

Combinación: ambos a la vez

Hay arquitecturas donde conviven:

• Redis para sesiones, rate limiting, pub/sub
• Memcached para cache HTTP de páginas

Cada uno en su nicho. No es o/una, son complementarios.

---

Mi recomendación

Empieza con Redis. Cubre el 90% de los casos y es más versátil. Si después tienes un cuello de botella muy específico con strings puros, considera Memcached para esa parte.

---

Lee también: PostgreSQL 17 en Ubuntu 24.04 para persistencia, o Ansible desde cero para automatizar deploys.

Preguntas frecuentes

Lee también

• Guía Fedora 44: Novedades, Instalación y Upgrade para Sysadmins Linux
• Configura VLANs en Linux con nmcli: Guía paso a paso para sysadmins
• Protege tu SSH: Guía esencial para configurar Fail2ban en Linux
• Guía Definitiva: Configura Kubernetes con kubeadm en Ubuntu para Sysadmins Linux
• Configura Prometheus y Grafana: Guía DevOps para SysAdmins Linux