Redis: qué es y para qué se usa en aplicaciones modernas

Cuando una aplicación crece, las consultas a la base de datos se vuelven el cuello de botella más común. Miles de usuarios haciendo la misma petición al mismo tiempo, consultas complejas que tardan segundos en ejecutarse, datos que prácticamente no cambian pero se recalculan una y otra vez. El rendimiento se degrada y la experiencia del usuario se resiente.

Redis es la herramienta que usan las aplicaciones más grandes del mundo para resolver exactamente ese problema. Lo usan Twitter, GitHub, Stack Overflow, Airbnb, Uber y cientos de miles de aplicaciones más. En este artículo aprenderás qué es Redis, cómo funciona, qué estructuras de datos ofrece y cuáles son sus casos de uso más importantes en el desarrollo moderno.

Qué es Redis

Redis (Remote Dictionary Server) es una base de datos que guarda todos sus datos en memoria RAM en lugar de en disco. Eso lo hace extremadamente rápido: puede procesar millones de operaciones por segundo con tiempos de respuesta medidos en microsegundos.

Fue creado por Salvatore Sanfilippo en 2009 y hoy es mantenido por Redis Ltd. Es de código abierto y tiene una comunidad enorme. Sus características principales son:

• Almacenamiento en memoria: todos los datos viven en RAM, lo que lo hace órdenes de magnitud más rápido que las bases de datos tradicionales en disco.
• Estructuras de datos ricas: no solo guarda strings simples, sino listas, conjuntos, mapas hash, conjuntos ordenados, streams y más.
• Persistencia opcional: aunque vive en memoria, puede guardar snapshots en disco para no perder datos ante un reinicio.
• Expiración de claves: puedes configurar que un dato se elimine automáticamente después de un tiempo determinado.
• Operaciones atómicas: cada operación se ejecuta de forma completa sin interferencias de otras operaciones concurrentes.
• Pub/Sub y Streams: soporta patrones de mensajería en tiempo real entre componentes de una aplicación.

Redis no es solo una caché

El error más común al describir Redis es llamarlo simplemente "una caché". Aunque ese es su uso más frecuente, Redis es una base de datos de estructuras de datos en memoria que sirve para mucho más: colas de mensajes, sesiones de usuario, tablas de clasificación en tiempo real, limitadores de tasa, contadores, geolocalización y mensajería pub/sub.

Pensar en Redis únicamente como caché es limitar una herramienta con mucho más potencial.

Cómo funciona Redis por dentro

Redis usa un modelo de datos de clave-valor. Cada dato se almacena con una clave única (un string) y un valor que puede ser de distintos tipos. Todo ocurre en memoria RAM, lo que elimina la latencia de acceso a disco.

El servidor de Redis funciona con un único hilo para procesar comandos, lo que evita los problemas de concurrencia y bloqueos de las bases de datos tradicionales. Esto puede parecer limitante, pero en la práctica es lo que le permite ser tan rápido: sin sincronización entre hilos, sin deadlocks, sin overhead de gestión de concurrencia.

Para no perder datos ante un reinicio, Redis ofrece dos mecanismos de persistencia:

• RDB (Redis Database): guarda snapshots completos de todos los datos en disco a intervalos configurables. Es eficiente para backups pero puede perder datos de los últimos minutos si el servidor cae.
• AOF (Append Only File): registra cada operación de escritura en un archivo de log. Es más seguro porque se puede configurar para sincronizar con disco en cada escritura, pero ocupa más espacio.

Instalación rápida

La forma más rápida de tener Redis funcionando es con Docker:

# Descargar e iniciar Redis con Docker
docker run --name mi-redis -p 6379:6379 -d redis

# Conectarse al cliente interactivo de Redis
docker exec -it mi-redis redis-cli

En sistemas Linux puedes instalarlo directamente:

# Ubuntu / Debian
sudo apt update
sudo apt install redis-server

# Iniciar el servicio
sudo systemctl start redis
sudo systemctl enable redis

# Conectarse al cliente
redis-cli

En macOS con Homebrew:

brew install redis
brew services start redis
redis-cli

Una vez en el cliente interactivo, puedes verificar que Redis funciona:

127.0.0.1:6379> PING
PONG

Las estructuras de datos de Redis

La gran diferencia de Redis frente a otras soluciones de caché es la variedad de estructuras de datos que ofrece. Cada una está diseñada para resolver un tipo específico de problema.

Strings: el tipo básico

Aunque se llaman strings, pueden almacenar texto, números enteros, números flotantes e incluso datos binarios como imágenes serializadas. Son el tipo más versátil y el punto de partida para entender Redis.

# Guardar y leer un valor
SET usuario:1:nombre "Ana García"
GET usuario:1:nombre
# "Ana García"

# Guardar con tiempo de expiración (en segundos)
SET sesion:abc123 "datos_de_sesion" EX 3600
TTL sesion:abc123   # segundos restantes
# 3599

# Expiración en milisegundos
SET token:xyz PX 60000

# Incrementar y decrementar contadores (atómico)
SET visitas:pagina:inicio 0
INCR visitas:pagina:inicio    # 1
INCR visitas:pagina:inicio    # 2
INCRBY visitas:pagina:inicio 10   # 12
DECR visitas:pagina:inicio    # 11

# Guardar solo si la clave no existe (NX = Not eXists)
SET clave "valor" NX   # OK (si no existía)
SET clave "nuevo"  NX  # nil (ya existía, no se sobreescribió)

# Guardar un objeto JSON serializado
SET producto:1 '{"id":1,"nombre":"Laptop","precio":1299.99}'
GET producto:1

Hashes: objetos con campos

Un hash almacena múltiples pares campo-valor bajo una sola clave. Es ideal para representar objetos con atributos, como un usuario, un producto o una sesión.

# Crear un hash con múltiples campos
HSET usuario:1 nombre "Ana García" email "ana@correo.com" edad 25 ciudad "Madrid"

# Leer un campo específico
HGET usuario:1 nombre
# "Ana García"

# Leer varios campos
HMGET usuario:1 nombre email
# 1) "Ana García"
# 2) "ana@correo.com"

# Leer todos los campos y valores
HGETALL usuario:1
# 1) "nombre"
# 2) "Ana García"
# 3) "email"
# 4) "ana@correo.com"
# 5) "edad"
# 6) "25"
# 7) "ciudad"
# 8) "Madrid"

# Incrementar un campo numérico
HINCRBY usuario:1 edad 1
# 26

# Verificar si un campo existe
HEXISTS usuario:1 telefono
# 0 (no existe)

# Eliminar un campo
HDEL usuario:1 ciudad

# Obtener solo las claves o solo los valores
HKEYS usuario:1
HVALS usuario:1

Lists: colas y pilas

Una lista en Redis es una secuencia de strings ordenados por inserción. Soporta inserciones y extracciones desde ambos extremos de forma muy eficiente, lo que las hace perfectas para implementar colas y pilas.

# Agregar elementos al inicio (izquierda)
LPUSH cola:tareas "tarea3"
LPUSH cola:tareas "tarea2"
LPUSH cola:tareas "tarea1"

# Agregar elementos al final (derecha)
RPUSH cola:tareas "tarea4"
RPUSH cola:tareas "tarea5"

# Ver todos los elementos (0 a -1 = todos)
LRANGE cola:tareas 0 -1
# 1) "tarea1"
# 2) "tarea2"
# 3) "tarea3"
# 4) "tarea4"
# 5) "tarea5"

# Extraer del inicio (FIFO: cola)
LPOP cola:tareas   # "tarea1"

# Extraer del final (LIFO: pila)
RPOP cola:tareas   # "tarea5"

# Longitud de la lista
LLEN cola:tareas   # 3

# BRPOP: extracción bloqueante (espera hasta que haya un elemento)
# Útil para workers que esperan trabajo
BRPOP cola:tareas 30   # espera hasta 30 segundos

Sets: conjuntos sin duplicados

Un set es una colección no ordenada de strings únicos. Soporta operaciones matemáticas de conjuntos como unión, intersección y diferencia de forma nativa y muy eficiente.

# Agregar elementos
SADD etiquetas:articulo:1 "javascript" "web" "frontend" "tutorial"
SADD etiquetas:articulo:2 "javascript" "nodejs" "backend" "api"

# Verificar si un elemento existe
SISMEMBER etiquetas:articulo:1 "web"   # 1 (sí existe)
SISMEMBER etiquetas:articulo:1 "api"   # 0 (no existe)

# Ver todos los elementos
SMEMBERS etiquetas:articulo:1

# Número de elementos
SCARD etiquetas:articulo:1   # 4

# Operaciones de conjuntos
SINTER etiquetas:articulo:1 etiquetas:articulo:2  # intersección: "javascript"
SUNION etiquetas:articulo:1 etiquetas:articulo:2  # unión: todos los tags únicos
SDIFF  etiquetas:articulo:1 etiquetas:articulo:2  # diferencia: tags solo en artículo 1

# Eliminar un elemento
SREM etiquetas:articulo:1 "tutorial"

# Elemento aleatorio (útil para sorteos)
SRANDMEMBER etiquetas:articulo:1

Sorted Sets: conjuntos ordenados por puntuación

Un sorted set (o ZSET) es como un set, pero cada elemento tiene asociada una puntuación numérica que determina su posición. Son el tipo de dato perfecto para tablas de clasificación (leaderboards), rankings y cualquier cosa que necesite orden por relevancia o puntuación.

# Agregar jugadores con su puntuación
ZADD ranking:juego 4500 "Ana"
ZADD ranking:juego 3800 "Luis"
ZADD ranking:juego 5200 "María"
ZADD ranking:juego 2900 "Carlos"
ZADD ranking:juego 6100 "Pedro"

# Ver el ranking de mayor a menor (ZREVRANGE)
ZREVRANGE ranking:juego 0 -1 WITHSCORES
# 1) "Pedro"  2) "6100"
# 3) "María"  4) "5200"
# 5) "Ana"    6) "4500"
# 7) "Luis"   8) "3800"
# 9) "Carlos" 10) "2900"

# Top 3
ZREVRANGE ranking:juego 0 2 WITHSCORES

# Posición de un jugador (0-indexed, de mayor a menor)
ZREVRANK ranking:juego "Ana"   # 2 (tercer lugar)

# Puntuación de un jugador
ZSCORE ranking:juego "María"   # 5200

# Incrementar puntuación
ZINCRBY ranking:juego 700 "Carlos"

# Jugadores entre dos puntuaciones
ZRANGEBYSCORE ranking:juego 3000 5000 WITHSCORES

Streams: log de eventos en tiempo real

Los streams son una estructura de datos avanzada para registrar y consumir eventos en orden temporal. Son similares a Kafka en concepto pero integrados directamente en Redis.

# Publicar un evento en el stream (el ID se genera automáticamente)
XADD eventos:pedidos * accion "nuevo_pedido" id_pedido "1001" id_cliente "42" total "299.99"
XADD eventos:pedidos * accion "pago_recibido" id_pedido "1001" metodo "tarjeta"
XADD eventos:pedidos * accion "pedido_enviado" id_pedido "1001" transportista "DHL"

# Leer los últimos N eventos
XREVRANGE eventos:pedidos + - COUNT 5

# Leer eventos desde un ID específico
XREAD COUNT 10 STREAMS eventos:pedidos 0

# Número de eventos en el stream
XLEN eventos:pedidos

Casos de uso en aplicaciones modernas

Ahora que conoces las estructuras de datos, veamos cómo se aplican en escenarios reales del desarrollo de software.

1. Caché de consultas a base de datos

El caso de uso más frecuente. En lugar de hacer una consulta costosa a MySQL o PostgreSQL cada vez, guardas el resultado en Redis con un tiempo de expiración. Las siguientes peticiones las sirves desde memoria.

# Patrón cache-aside (el más común):
# 1. La aplicación busca el dato en Redis
# 2. Si existe (cache hit), lo devuelve directamente
# 3. Si no existe (cache miss), consulta la base de datos,
#    guarda el resultado en Redis y lo devuelve

# Ejemplo con producto
GET producto:42
# Si devuelve nil → cache miss → consultar MySQL → guardar en Redis
SET producto:42 '{"id":42,"nombre":"Laptop","precio":1299.99}' EX 300
# Si devuelve datos → cache hit → devolver directamente

En términos de código Python usando la biblioteca redis-py:

import redis
import json

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

def obtener_producto(id_producto):
    clave = f"producto:{id_producto}"

    # Buscar en caché
    datos = r.get(clave)
    if datos:
        print("Cache HIT")
        return json.loads(datos)

    # Cache miss: consultar base de datos
    print("Cache MISS")
    producto = consultar_base_de_datos(id_producto)  # tu función de BD

    # Guardar en caché por 5 minutos
    r.setex(clave, 300, json.dumps(producto))

    return producto

2. Gestión de sesiones de usuario

Las sesiones de usuario son perfectas para Redis: datos que se necesitan frecuentemente, que deben expirar automáticamente y que no necesitan persistencia indefinida.

# Guardar sesión con expiración de 24 horas
HSET sesion:token_abc123 id_usuario 42 nombre "Ana García" rol "admin" ip "192.168.1.1"
EXPIRE sesion:token_abc123 86400

# Leer los datos de la sesión en cada petición
HGETALL sesion:token_abc123

# Renovar la sesión (reiniciar el contador de expiración)
EXPIRE sesion:token_abc123 86400

# Eliminar la sesión al cerrar sesión
DEL sesion:token_abc123

3. Limitador de tasa (Rate Limiter)

Controlar cuántas peticiones puede hacer un usuario en un período de tiempo es un requisito de seguridad común en APIs. Redis lo resuelve de forma elegante y atómica.

# Patrón sliding window con contadores por minuto
# Clave: ratelimit:{id_usuario}:{minuto_actual}

# Incrementar el contador y establecer expiración de 60 segundos
INCR ratelimit:usuario42:20240615:1430
EXPIRE ratelimit:usuario42:20240615:1430 60

# Si el contador supera el límite (ejemplo: 100 peticiones/minuto)
# rechazar la petición con HTTP 429 Too Many Requests

En código Python:

import redis
import time

r = redis.Redis(host='localhost', port=6379)

def verificar_rate_limit(id_usuario, limite=100, ventana=60):
    minuto_actual = int(time.time() // ventana)
    clave = f"ratelimit:{id_usuario}:{minuto_actual}"

    pipe = r.pipeline()
    pipe.incr(clave)
    pipe.expire(clave, ventana)
    resultados = pipe.execute()

    peticiones = resultados[0]

    if peticiones > limite:
        return False, limite - peticiones  # bloqueado
    return True, limite - peticiones       # permitido

4. Cola de trabajos (Job Queue)

Delegar tareas pesadas o de larga duración a procesos en segundo plano es una práctica fundamental. Redis con sus listas es la base de sistemas de colas como Celery (Python), Bull (Node.js) y Sidekiq (Ruby).

# Productor: agregar tareas a la cola
RPUSH cola:emails '{"to":"ana@correo.com","asunto":"Bienvenido","template":"welcome"}'
RPUSH cola:emails '{"to":"luis@correo.com","asunto":"Pedido enviado","id_pedido":1001}'

# Consumidor: extraer y procesar tareas
# BLPOP bloquea hasta que haya una tarea (timeout 0 = esperar indefinidamente)
BLPOP cola:emails 0
# Procesar el email...
# Si falla, puede volver a encolar o mover a una cola de errores

5. Tabla de clasificación en tiempo real (Leaderboard)

Los sorted sets hacen que los leaderboards sean triviales de implementar, incluso con millones de jugadores.

# Actualizar puntuación (ZINCRBY agrega a la puntuación existente)
ZINCRBY leaderboard:global 250 "jugador:ana"
ZINCRBY leaderboard:global 180 "jugador:luis"
ZINCRBY leaderboard:global 320 "jugador:maria"

# Top 10 global
ZREVRANGE leaderboard:global 0 9 WITHSCORES

# Posición de un jugador específico
ZREVRANK leaderboard:global "jugador:ana"

# Jugadores alrededor del usuario (su posición ± 2)
ZREVRANK leaderboard:global "jugador:ana"
# Con la posición, calcular el rango y usar ZREVRANGE

6. Publicación y suscripción (Pub/Sub)

Redis implementa el patrón pub/sub para comunicación en tiempo real entre componentes de una aplicación. Un publicador envía mensajes a un canal y todos los suscriptores los reciben al instante.

# En un cliente: suscribirse a un canal
SUBSCRIBE canal:notificaciones

# En otro cliente: publicar un mensaje
PUBLISH canal:notificaciones '{"tipo":"nuevo_pedido","id":1001,"usuario":"Ana"}'

# Suscribirse a múltiples canales con patrón
PSUBSCRIBE canal:*    # recibe todos los canales que empiezan con "canal:"

7. Contadores y estadísticas en tiempo real

# Contar visitas por página
INCR stats:visitas:inicio
INCR stats:visitas:productos
INCR stats:visitas:contacto

# Contar usuarios activos por hora
INCR stats:usuarios_activos:2024:06:15:14

# Contadores con ventana de tiempo
# Usuarios únicos por día con HyperLogLog (aproximación eficiente en memoria)
PFADD usuarios_unicos:2024:06:15 "usuario42" "usuario88" "usuario33"
PFADD usuarios_unicos:2024:06:15 "usuario42"  # duplicado, no se cuenta
PFCOUNT usuarios_unicos:2024:06:15   # aproximadamente 3

8. Bloqueos distribuidos

Cuando múltiples instancias de una aplicación compiten por ejecutar una tarea una sola vez (como enviar un correo de recordatorio o procesar un pago), necesitas un bloqueo distribuido. Redis lo implementa de forma atómica.

# Adquirir el bloqueo (NX = solo si no existe, EX = expirar en 30 segundos)
SET lock:proceso_critico "instancia_1" NX EX 30
# OK  → bloqueo adquirido, ejecutar la tarea
# nil → otra instancia ya tiene el bloqueo, no ejecutar

# Liberar el bloqueo (solo si somos los dueños)
# En producción se usa un script Lua para hacerlo atómico
DEL lock:proceso_critico

Redis con Python: ejemplo práctico completo

import redis
import json
import time
from datetime import datetime

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

class SistemaCache:

    def __init__(self, redis_client):
        self.r = redis_client

    # --- Caché de productos ---
    def guardar_producto(self, producto, ttl=300):
        clave = f"producto:{producto['id']}"
        self.r.setex(clave, ttl, json.dumps(producto))

    def obtener_producto(self, id_producto):
        clave = f"producto:{id_producto}"
        datos = self.r.get(clave)
        return json.loads(datos) if datos else None

    # --- Sesiones ---
    def crear_sesion(self, token, datos_usuario, ttl=86400):
        clave = f"sesion:{token}"
        self.r.hset(clave, mapping=datos_usuario)
        self.r.expire(clave, ttl)

    def obtener_sesion(self, token):
        clave = f"sesion:{token}"
        return self.r.hgetall(clave)

    def eliminar_sesion(self, token):
        self.r.delete(f"sesion:{token}")

    # --- Leaderboard ---
    def actualizar_puntuacion(self, juego, usuario, puntos):
        clave = f"leaderboard:{juego}"
        self.r.zincrby(clave, puntos, usuario)

    def obtener_top(self, juego, n=10):
        clave = f"leaderboard:{juego}"
        return self.r.zrevrange(clave, 0, n - 1, withscores=True)

    # --- Contador de visitas ---
    def registrar_visita(self, pagina):
        fecha = datetime.now().strftime('%Y:%m:%d')
        self.r.incr(f"visitas:{pagina}:{fecha}")

    def obtener_visitas(self, pagina):
        fecha = datetime.now().strftime('%Y:%m:%d')
        return self.r.get(f"visitas:{pagina}:{fecha}") or 0


# Uso
sistema = SistemaCache(r)

# Caché de productos
producto = {"id": 1, "nombre": "Laptop Pro", "precio": 1299.99}
sistema.guardar_producto(producto)
print(sistema.obtener_producto(1))

# Sesión de usuario
sistema.crear_sesion("token_xyz", {"id": "42", "nombre": "Ana", "rol": "admin"})
print(sistema.obtener_sesion("token_xyz"))

# Leaderboard
sistema.actualizar_puntuacion("batalla_naval", "ana", 500)
sistema.actualizar_puntuacion("batalla_naval", "luis", 320)
sistema.actualizar_puntuacion("batalla_naval", "maria", 680)
print(sistema.obtener_top("batalla_naval"))

# Visitas
sistema.registrar_visita("inicio")
sistema.registrar_visita("inicio")
sistema.registrar_visita("productos")
print(f"Visitas a inicio: {sistema.obtener_visitas('inicio')}")

Redis con Java: conexión básica con Jedis

// Dependencia Maven
// <dependency>
//   <groupId>redis.clients</groupId>
//   <artifactId>jedis</artifactId>
//   <version>5.1.0</version>
// </dependency>

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class EjemploRedisJava {

  public static void main(String[] args) {

    // Pool de conexiones (recomendado en producción)
    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxTotal(10);

    try (JedisPool pool = new JedisPool(config, "localhost", 6379)) {
      try (Jedis jedis = pool.getResource()) {

        // String básico
        jedis.set("mensaje", "Hola desde Java");
        System.out.println(jedis.get("mensaje"));

        // Con expiración
        jedis.setex("sesion:java123", 3600, "{\"usuario\":\"Ana\"}");
        System.out.println("TTL: " + jedis.ttl("sesion:java123"));

        // Hash
        jedis.hset("usuario:1", "nombre", "Ana García");
        jedis.hset("usuario:1", "email", "ana@correo.com");
        System.out.println(jedis.hgetAll("usuario:1"));

        // Incrementar contador
        jedis.incr("visitas:inicio");
        jedis.incr("visitas:inicio");
        System.out.println("Visitas: " + jedis.get("visitas:inicio"));

        // Sorted set - leaderboard
        jedis.zadd("ranking", 4500, "Ana");
        jedis.zadd("ranking", 3800, "Luis");
        jedis.zadd("ranking", 5200, "María");

        System.out.println("Top jugadores: " + jedis.zrevrangeWithScores("ranking", 0, 2));
      }
    }
  }
}

Comandos esenciales de Redis

Buenas prácticas

• Diseña las claves con cuidado. Usa un patrón jerárquico con dos puntos como separador: entidad:id:campo. Por ejemplo: usuario:42:sesion, producto:1:cache. Esto hace fácil identificar el propósito de cada clave.
• Siempre define una expiración para datos de caché. Sin TTL, los datos crecen indefinidamente y eventualmente llenan la memoria. Si un dato puede volverse obsoleto, ponle expiración.
• Nunca uses KEYS en producción. El comando KEYS bloquea el servidor mientras busca. Usa SCAN en su lugar, que es incremental y no bloquea.
• Usa un pool de conexiones. Crear y destruir conexiones para cada operación es costoso. Las bibliotecas cliente como Jedis (Java) y redis-py (Python) ofrecen pools de conexiones que debes usar siempre.
• Configura la política de evicción. Cuando Redis se queda sin memoria, necesita saber qué datos eliminar. La política allkeys-lru (elimina los datos menos usados recientemente) es la más adecuada para cachés.
• Monitoriza el uso de memoria. Redis vive en RAM, un recurso limitado y costoso. Usa el comando INFO memory regularmente y configura alertas cuando el uso supere cierto umbral.
• Prefiere pipelines para múltiples operaciones. Si necesitas ejecutar varias operaciones seguidas, agrúpalas en un pipeline para enviarlas en una sola petición de red y reducir la latencia.

# Pipeline: enviar múltiples comandos en una sola petición de red
# Ejemplo en Python
pipe = r.pipeline()
pipe.set("clave1", "valor1")
pipe.incr("contador")
pipe.hset("hash:1", "campo", "valor")
pipe.expire("clave1", 300)
resultados = pipe.execute()  # se ejecutan todos de una vez

Redis vs Memcached

Memcached es la otra gran solución de caché en memoria. La pregunta de cuál elegir es frecuente:

En la gran mayoría de los casos modernos, Redis es la elección correcta por su versatilidad. Memcached tiene sentido solo en escenarios muy específicos donde necesitas caché simple y máximo rendimiento multihilo con datos de gran tamaño.

Conclusión

Redis es una de las herramientas más versátiles y utilizadas en el ecosistema del desarrollo de software moderno. Su velocidad extrema, la variedad de estructuras de datos que ofrece y la simplicidad de su API lo hacen valioso no solo como caché, sino como motor de sesiones, colas de trabajos, leaderboards, limitadores de tasa y mensajería en tiempo real.

Entender Redis y saber cuándo usarlo es una habilidad que marca una diferencia real en la arquitectura de aplicaciones que necesitan escalar. Una vez que lo integras en tu stack, te resultará difícil imaginar cómo construiste aplicaciones sin él.

Para seguir profundizando en el ecosistema de bases de datos, te recomendamos leer nuestros artículos sobre qué es MongoDB y cómo funciona y sobre la diferencia entre SQL y NoSQL, que te darán una visión completa del panorama de bases de datos modernas.