Redis - Knowledge of Laravel

Redis es un almacén clave-valor en memoria que se usa como backend en muchas funcionalidades de Laravel. Explicamos su uso en Laravel: configuración, operaciones y Pub/Sub.

Caché

Usar Redis como driver de caché

Colas

Usar Redis como driver de colas

Broadcasting

Comunicación en tiempo real con Pub/Sub

¿Qué es Redis?

Redis es un almacén clave-valor rápido de código abierto. Soporta múltiples estructuras de datos (strings, hashes, listas, sets, sorted sets, etc.) y se conoce también como “servidor de estructuras de datos”. En Laravel, Redis se usa para:

Elección de cliente

Laravel soporta dos clientes: PhpRedis (extensión de PHP) y Predis (paquete PHP).

Aspecto	PhpRedis	Predis
Implementación	Extensión de PHP en C	Paquete PHP puro
Instalación	Requiere extensión PECL	Solo con `composer require`
Rendimiento	Alto	Un poco menor que PhpRedis
Laravel Sail	Ya incluido por defecto	Instalación adicional
Recomendado en	Producción	Desarrollo o entornos donde no puedas instalar la extensión

En Laravel 13 el cliente por defecto es PhpRedis. En producción se recomienda PhpRedis. Con Laravel Sail, PhpRedis ya viene instalado.

Configuración

config/database.php

La configuración de Redis se gestiona en el array redis de config/database.php.

'redis' => [

    'client' => env('REDIS_CLIENT', 'phpredis'),

    'options' => [
        'cluster' => env('REDIS_CLUSTER', 'redis'),
        'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_database_'),
    ],

    'default' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'username' => env('REDIS_USERNAME'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_DB', '0'),
    ],

    'cache' => [
        'url' => env('REDIS_URL'),
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'username' => env('REDIS_USERNAME'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', '6379'),
        'database' => env('REDIS_CACHE_DB', '1'),
    ],

],

Variables de entorno

Configura la conexión en .env.

REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PORT=6379
REDIS_PASSWORD=null
REDIS_DB=0
REDIS_CACHE_DB=1

También puedes indicarla con formato URL.

'default' => [
    'url' => 'tcp://127.0.0.1:6379?database=0',
],

'cache' => [
    'url' => 'tls://user:[email protected]:6380?database=1',
],

Conexión TLS / SSL

Para cifrado TLS, indica la opción scheme.

'default' => [
    'scheme' => 'tls',
    'url' => env('REDIS_URL'),
    'host' => env('REDIS_HOST', '127.0.0.1'),
    'username' => env('REDIS_USERNAME'),
    'password' => env('REDIS_PASSWORD'),
    'port' => env('REDIS_PORT', '6379'),
    'database' => env('REDIS_DB', '0'),
],

Clustering

Para usar varios servidores Redis como cluster, utiliza la clave clusters.

'redis' => [

    'client' => env('REDIS_CLIENT', 'phpredis'),

    'options' => [
        'cluster' => env('REDIS_CLUSTER', 'redis'),
        'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_database_'),
    ],

    'clusters' => [
        'default' => [
            [
                'url' => env('REDIS_URL'),
                'host' => env('REDIS_HOST', '127.0.0.1'),
                'username' => env('REDIS_USERNAME'),
                'password' => env('REDIS_PASSWORD'),
                'port' => env('REDIS_PORT', '6379'),
                'database' => env('REDIS_DB', '0'),
            ],
        ],
    ],

],

Por defecto, options.cluster es redis, es decir, se usa el clustering nativo de Redis. Como gestiona el failover automáticamente, es la configuración recomendada en producción. Para usar client-side sharding con Predis, elimina options.cluster. Pero el client-side sharding no gestiona failover, así que solo es adecuado para datos temporales como caché.

Configuración de Predis

Para usar Predis, instala el paquete predis/predis y cambia REDIS_CLIENT a predis.

composer require predis/predis

REDIS_CLIENT=predis

Puedes añadir parámetros de conexión específicos de Predis.

'default' => [
    'url' => env('REDIS_URL'),
    'host' => env('REDIS_HOST', '127.0.0.1'),
    'username' => env('REDIS_USERNAME'),
    'password' => env('REDIS_PASSWORD'),
    'port' => env('REDIS_PORT', '6379'),
    'database' => env('REDIS_DB', '0'),
    'read_write_timeout' => 60,
],

Configuración de reintentos de Predis

Desde Predis 3.4.0 hay reintentos y backoff integrados. Con max_retries indicas el número de reintentos y con retry la estrategia de backoff. retry acepta un array cuya clave es una de las clases NoBackoff, EqualBackoff o ExponentialBackoff.

use Predis\Retry\Strategy\ExponentialBackoff;

'default' => [
    'url' => env('REDIS_URL'),
    // ...
    'retry' => [
        ExponentialBackoff::class => [
            env('REDIS_BACKOFF_BASE', 100),
            env('REDIS_BACKOFF_CAP', 1000),
            true, // Activa jitter
        ],
    ],
    'max_retries' => env('REDIS_MAX_RETRIES', 3),
],

Con Redis cluster y Predis, configura los reintentos en la opción parameters de la configuración del cluster.

use Predis\Retry\Strategy\NoBackoff;

'clusters' => [
    'default' => [
        // ...
    ],
],

'options' => [
    'cluster' => env('REDIS_CLUSTER', 'redis'),
    'parameters' => [
        'retry' => [
            NoBackoff::class => [],
        ],
        'max_retries' => env('REDIS_MAX_RETRIES', 3),
    ],
],

Configuración de PhpRedis

PhpRedis se instala vía PECL (ya viene en Laravel Sail). PhpRedis admite estas opciones adicionales: name, persistent, persistent_id, prefix, read_timeout, retry_interval, max_retries, backoff_algorithm, backoff_base, backoff_cap, timeout, context.

'default' => [
    'url' => env('REDIS_URL'),
    'host' => env('REDIS_HOST', '127.0.0.1'),
    'username' => env('REDIS_USERNAME'),
    'password' => env('REDIS_PASSWORD'),
    'port' => env('REDIS_PORT', '6379'),
    'database' => env('REDIS_DB', '0'),
    'read_timeout' => 60,
    'context' => [
        // 'auth' => ['username', 'secret'],
        // 'stream' => ['verify_peer' => false],
    ],
],

Reintentos y backoff

Configura el comportamiento de reintentos ante fallos de conexión. Algoritmos soportados: default, decorrelated_jitter, equal_jitter, exponential, uniform, constant.

'default' => [
    'url' => env('REDIS_URL'),
    'host' => env('REDIS_HOST', '127.0.0.1'),
    'username' => env('REDIS_USERNAME'),
    'password' => env('REDIS_PASSWORD'),
    'port' => env('REDIS_PORT', '6379'),
    'database' => env('REDIS_DB', '0'),
    'max_retries' => env('REDIS_MAX_RETRIES', 3),
    'backoff_algorithm' => env('REDIS_BACKOFF_ALGORITHM', 'decorrelated_jitter'),
    'backoff_base' => env('REDIS_BACKOFF_BASE', 100),
    'backoff_cap' => env('REDIS_BACKOFF_CAP', 1000),
],

Conexión con socket Unix

Si conectas a un Redis en el mismo servidor, usa un socket Unix para reducir la sobrecarga de TCP.

REDIS_HOST=/run/redis/redis.sock
REDIS_PORT=0

Serialización y compresión

En PhpRedis puedes configurar la serialización y el algoritmo de compresión.

'redis' => [

    'client' => env('REDIS_CLIENT', 'phpredis'),

    'options' => [
        'cluster' => env('REDIS_CLUSTER', 'redis'),
        'prefix' => env('REDIS_PREFIX', Str::slug(env('APP_NAME', 'laravel'), '_').'_database_'),
        'serializer' => Redis::SERIALIZER_MSGPACK,
        'compression' => Redis::COMPRESSION_LZ4,
    ],

],

Serializadores soportados:

Constante	Descripción
`Redis::SERIALIZER_NONE`	Sin serialización (por defecto)
`Redis::SERIALIZER_PHP`	Serialización de PHP
`Redis::SERIALIZER_JSON`	JSON
`Redis::SERIALIZER_IGBINARY`	igbinary
`Redis::SERIALIZER_MSGPACK`	MessagePack

Algoritmos de compresión soportados:

Constante	Descripción
`Redis::COMPRESSION_NONE`	Sin compresión (por defecto)
`Redis::COMPRESSION_LZF`	LZF
`Redis::COMPRESSION_ZSTD`	Zstandard
`Redis::COMPRESSION_LZ4`	LZ4

Operaciones con Redis

Fachada Redis

Con la fachada Redis puedes ejecutar cualquier comando de Redis. La fachada reenvía los comandos al servidor usando métodos mágicos.

<?php

namespace App\Http\Controllers;

use Illuminate\Support\Facades\Redis;
use Illuminate\View\View;

class UserController extends Controller
{
    public function show(string $id): View
    {
        return view('user.profile', [
            'user' => Redis::get('user:profile:'.$id)
        ]);
    }
}

Los argumentos de los comandos se pasan tal cual al método.

use Illuminate\Support\Facades\Redis;

Redis::set('name', 'Taylor');

$values = Redis::lrange('names', 5, 10);

También puedes usar command para indicar explícitamente el nombre del comando y sus argumentos.

$values = Redis::command('lrange', ['name', 5, 10]);

Uso de varias conexiones

Define varias conexiones Redis en config/database.php y cambia con connection().

// Obtiene una conexión con nombre
$redis = Redis::connection('connection-name');

// Obtiene la conexión por defecto
$redis = Redis::connection();

Transacciones

El método transaction() envuelve los comandos MULTI/EXEC de Redis. Todos los comandos dentro del closure se ejecutan de forma atómica.

use Redis;
use Illuminate\Support\Facades;

Facades\Redis::transaction(function (Redis $redis) {
    $redis->incr('user_visits', 1);
    $redis->incr('total_visits', 1);
});

Dentro de una transacción no puedes obtener valores de Redis. El closure completo se ejecuta y después EXEC los ejecuta todos.

Scripts Lua

Con eval() ejecutas un script Lua de forma atómica. Es más flexible que las transacciones porque puedes leer y actualizar valores de Redis dentro del script.

$value = Redis::eval(<<<'LUA'
    local counter = redis.call("incr", KEYS[1])

    if counter > 5 then
        redis.call("incr", KEYS[2])
    end

    return counter
LUA, 2, 'first-counter', 'second-counter');

Orden de los argumentos: script Lua → número de claves → nombres de claves… → argumentos adicionales… KEYS[1], KEYS[2] son los nombres de las claves; ARGV[1] en adelante son los argumentos adicionales.

Pipeline

Envía muchos comandos de una vez para reducir los round trips de red.

use Redis;
use Illuminate\Support\Facades;

Facades\Redis::pipeline(function (Redis $pipe) {
    for ($i = 0; $i < 1000; $i++) {
        $pipe->set("key:$i", $i);
    }
});

El pipeline solo agrupa comandos en el envío; no es atómico. Si necesitas atomicidad, usa transacciones o scripts Lua.

Pub / Sub

Con los comandos publish / subscribe puedes intercambiar mensajes a través de canales.

Suscriptor

subscribe() es un proceso de larga duración, así que se invoca dentro de un comando Artisan.

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Redis;

class RedisSubscribe extends Command
{
    protected $signature = 'redis:subscribe';

    protected $description = 'Subscribe to a Redis channel';

    public function handle(): void
    {
        Redis::subscribe(['test-channel'], function (string $message) {
            echo $message;
        });
    }
}

Publicador

Publica desde otra solicitud o proceso.

use Illuminate\Support\Facades\Redis;

Route::get('/publish', function () {
    Redis::publish('test-channel', json_encode([
        'name' => 'Adam Wathan'
    ]));
});

Suscripción con comodines

Con psubscribe() puedes suscribirte a patrones.

// Se suscribe a todos los canales
Redis::psubscribe(['*'], function (string $message, string $channel) {
    echo $message;
});

// Se suscribe a los canales que coincidan con users.*
Redis::psubscribe(['users.*'], function (string $message, string $channel) {
    echo $message;
});

Resumen

Elección de cliente

Producción: PhpRedis (extensión PECL, alto rendimiento)
Desarrollo o entornos donde no puedas instalar la extensión: Predis (paquete Composer)
Laravel Sail: ya trae PhpRedis por defecto

Puntos de configuración de la conexión

Define varias conexiones Redis en config/database.php según el uso (default / cache, etc.)
En clusters, usa la clave clusters
En producción, considera TLS y configuración de credenciales

Cuándo usar cada operación

Operación	Uso
Métodos de la fachada	Comandos Redis habituales
`transaction()`	Ejecución atómica de varios comandos (no se pueden leer valores)
`eval()`	Script Lua (operación atómica con lecturas incluidas)
`pipeline()`	Envío rápido de muchos comandos (no atómico)
`subscribe()` / `publish()`	Mensajería por canales (Pub/Sub)

Caché

Colas

Broadcasting

​¿Qué es Redis?

​Elección de cliente

​Configuración

​config/database.php

​Variables de entorno

​Conexión TLS / SSL

​Clustering

​Configuración de Predis

​Configuración de reintentos de Predis

​Configuración de PhpRedis

​Reintentos y backoff

​Conexión con socket Unix

​Serialización y compresión

​Operaciones con Redis

​Fachada Redis

​Uso de varias conexiones

​Transacciones

​Scripts Lua

​Pipeline

​Pub / Sub

​Suscriptor

​Publicador

​Suscripción con comodines

​Resumen

¿Qué es Redis?

Elección de cliente

Configuración

config/database.php

Variables de entorno

Conexión TLS / SSL

Clustering

Configuración de Predis

Configuración de reintentos de Predis

Configuración de PhpRedis

Reintentos y backoff

Conexión con socket Unix

Serialización y compresión

Operaciones con Redis

Fachada Redis

Uso de varias conexiones

Transacciones

Scripts Lua

Pipeline

Pub / Sub

Suscriptor

Publicador

Suscripción con comodines

Resumen