Redis

• Introducción
• Configuración
  • Clusters
  • Predis
  • PhpRedis
• Interacción con Redis
  • Transacciones
  • Pipelining de comandos
• Pub / Sub

#Introducción

Redis es un almacén avanzado de clave-valor de código abierto. A menudo se le denomina servidor de estructuras de datos ya que las claves pueden contener strings, hashes, lists, sets y sorted sets.

Antes de usar Redis con Laravel, le recomendamos instalar y usar la extensión PHP PhpRedis vía PECL. La extensión es más compleja de instalar en comparación con los paquetes PHP "user-land", pero puede ofrecer mejor rendimiento para aplicaciones que hacen un uso intensivo de Redis. Si está usando Laravel Sail, esta extensión ya está instalada en el contenedor Docker de su aplicación.

Si no puede instalar la extensión PhpRedis, puede instalar el paquete predis/predis vía Composer. Predis es un cliente Redis escrito completamente en PHP y no requiere extensiones adicionales:

composer require predis/predis

#Configuración

Puede configurar los ajustes de Redis de su aplicación mediante el archivo de configuración config/database.php. Dentro de este archivo, verá un arreglo redis que contiene los servidores Redis utilizados por su aplicación:

'redis' => [

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

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

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

],

Cada servidor Redis definido en su archivo de configuración debe tener un nombre, host y puerto, a menos que defina una URL única para representar la conexión Redis:

'redis' => [

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

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

    'cache' => [
        'url' => 'tls://user:password@127.0.0.1:6380?database=1',
    ],

],

#Configuración del esquema de conexión

Por defecto, los clientes Redis usan el esquema tcp al conectarse a sus servidores Redis; sin embargo, puede usar cifrado TLS / SSL especificando la opción de configuración scheme en el arreglo de configuración del servidor Redis:

'redis' => [

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

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

],

#Clusters

Si su aplicación utiliza un clúster de servidores Redis, debe definir estos clústeres dentro de una clave clusters en la configuración de Redis. Esta clave no existe por defecto, por lo que deberá crearla en el archivo config/database.php de su aplicación:

'redis' => [

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

    'clusters' => [
        'default' => [
            [
                'host' => env('REDIS_HOST', 'localhost'),
                'password' => env('REDIS_PASSWORD'),
                'port' => env('REDIS_PORT', 6379),
                'database' => 0,
            ],
        ],
    ],

],

Por defecto, los clústeres realizan sharding del lado del cliente entre sus nodos, permitiéndole agrupar nodos y crear una gran cantidad de RAM disponible. Sin embargo, el sharding del lado del cliente no maneja failover; por lo tanto, está principalmente indicado para datos en caché transitorios que están disponibles desde otra fuente de datos primaria.

Si desea usar clustering nativo de Redis en lugar de sharding del lado del cliente, puede especificarlo configurando el valor options.cluster a redis en el archivo config/database.php de su aplicación:

'redis' => [

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

    'options' => [
        'cluster' => env('REDIS_CLUSTER', 'redis'),
    ],

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

],

#Predis

Si desea que su aplicación interactúe con Redis mediante el paquete Predis, debe asegurarse de que la variable de entorno REDIS_CLIENT tenga el valor predis:

'redis' => [

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

    // ...
],

Además de las opciones de configuración predeterminadas host, port, database y password, Predis soporta parámetros adicionales de conexión que pueden definirse para cada uno de sus servidores Redis. Para usar estas opciones adicionales, agréguelas a la configuración del servidor Redis en el archivo config/database.php de su aplicación:

'default' => [
    'host' => env('REDIS_HOST', 'localhost'),
    'password' => env('REDIS_PASSWORD'),
    'port' => env('REDIS_PORT', 6379),
    'database' => 0,
    'read_write_timeout' => 60,
],

#Alias del Facade Redis

El archivo de configuración config/app.php de Laravel contiene un arreglo aliases que define todos los alias de clase que serán registrados por el framework. Por defecto, no se incluye un alias Redis porque entraría en conflicto con el nombre de la clase Redis proporcionada por la extensión PhpRedis. Si usa el cliente Predis y desea agregar un alias Redis, puede añadirlo al arreglo aliases en el archivo config/app.php de su aplicación:

'aliases' => Facade::defaultAliases()->merge([
    'Redis' => Illuminate\Support\Facades\Redis::class,
])->toArray(),

#PhpRedis

Por defecto, Laravel usará la extensión PhpRedis para comunicarse con Redis. El cliente que Laravel usará para comunicarse con Redis está determinado por el valor de la opción de configuración redis.client, que típicamente refleja el valor de la variable de entorno REDIS_CLIENT:

'redis' => [

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

    // Resto de la configuración de Redis...
],

Además de las opciones predeterminadas scheme, host, port, database y password, PhpRedis soporta los siguientes parámetros adicionales de conexión: name, persistent, persistent_id, prefix, read_timeout, retry_interval, timeout y context. Puede agregar cualquiera de estas opciones a la configuración de su servidor Redis en el archivo config/database.php:

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

#Serialización y compresión en PhpRedis

La extensión PhpRedis también puede configurarse para usar varios serializadores y algoritmos de compresión. Estos algoritmos pueden configurarse mediante el arreglo options en la configuración de Redis:

'redis' => [

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

    'options' => [
        'serializer' => Redis::SERIALIZER_MSGPACK,
        'compression' => Redis::COMPRESSION_LZ4,
    ],

    // Resto de la configuración de Redis...
],

Los serializadores actualmente soportados incluyen: Redis::SERIALIZER_NONE (por defecto), Redis::SERIALIZER_PHP, Redis::SERIALIZER_JSON, Redis::SERIALIZER_IGBINARY y Redis::SERIALIZER_MSGPACK.

Los algoritmos de compresión soportados incluyen: Redis::COMPRESSION_NONE (por defecto), Redis::COMPRESSION_LZF, Redis::COMPRESSION_ZSTD y Redis::COMPRESSION_LZ4.

#Interacción con Redis

Puede interactuar con Redis llamando a varios métodos en el facade Redis. El facade Redis soporta métodos dinámicos, lo que significa que puede llamar a cualquier comando Redis en el facade y el comando será enviado directamente a Redis. En este ejemplo, llamaremos al comando Redis GET usando el método get en el facade Redis:

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Redis;
use Illuminate\View\View;

class UserController extends Controller
{
    /**
     * Mostrar el perfil del usuario dado.
     */
    public function show(string $id): View
    {
        return view('user.profile', [
            'user' => Redis::get('user:profile:'.$id)
        ]);
    }
}

Como se mencionó antes, puede llamar a cualquiera de los comandos de Redis en el facade Redis. Laravel usa métodos mágicos para pasar los comandos al servidor Redis. Si un comando Redis espera argumentos, debe pasarlos al método correspondiente del facade:

use Illuminate\Support\Facades\Redis;

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

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

Alternativamente, puede enviar comandos al servidor usando el método command del facade Redis, que acepta el nombre del comando como primer argumento y un arreglo de valores como segundo argumento:

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

#Uso de múltiples conexiones Redis

El archivo de configuración config/database.php de su aplicación le permite definir múltiples conexiones / servidores Redis. Puede obtener una conexión a una conexión Redis específica usando el método connection del facade Redis:

$redis = Redis::connection('connection-name');

Para obtener una instancia de la conexión Redis por defecto, puede llamar al método connection sin argumentos adicionales:

$redis = Redis::connection();

#Transacciones

El método transaction del facade Redis proporciona un envoltorio conveniente alrededor de los comandos nativos MULTI y EXEC de Redis. El método transaction acepta un closure como único argumento. Este closure recibirá una instancia de conexión Redis y podrá emitir cualquier comando que desee a esta instancia. Todos los comandos Redis emitidos dentro del closure se ejecutarán en una única transacción atómica:

use Redis;
use Illuminate\Support\Facades;

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

#Scripts Lua

El método eval ofrece otra forma de ejecutar múltiples comandos Redis en una única operación atómica. Sin embargo, el método eval tiene la ventaja de poder interactuar e inspeccionar los valores de las claves Redis durante esa operación. Los scripts Redis se escriben en el lenguaje de programación Lua.

El método eval puede parecer intimidante al principio, pero exploraremos un ejemplo básico para romper el hielo. El método eval espera varios argumentos. Primero, debe pasar el script Lua (como cadena) al método. Segundo, debe pasar el número de claves (como entero) con las que el script interactúa. Tercero, debe pasar los nombres de esas claves. Finalmente, puede pasar cualquier otro argumento adicional que necesite acceder dentro de su script.

En este ejemplo, incrementaremos un contador, inspeccionaremos su nuevo valor e incrementaremos un segundo contador si el valor del primer contador es mayor que cinco. Finalmente, devolveremos el valor del primer contador:

$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');

#Pipelining de comandos

A veces puede necesitar ejecutar decenas de comandos Redis. En lugar de hacer un viaje de red a su servidor Redis por cada comando, puede usar el método pipeline. El método pipeline acepta un argumento: un closure que recibe una instancia Redis. Puede emitir todos sus comandos a esta instancia Redis y todos serán enviados al servidor Redis al mismo tiempo para reducir los viajes de red al servidor. Los comandos aún se ejecutarán en el orden en que fueron emitidos:

use Redis;
use Illuminate\Support\Facades;

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

#Publicar / Suscribirse

Laravel proporciona una interfaz conveniente para los comandos Redis publish y subscribe. Estos comandos Redis le permiten escuchar mensajes en un "canal" dado. Puede publicar mensajes en el canal desde otra aplicación, o incluso usando otro lenguaje de programación, permitiendo una comunicación sencilla entre aplicaciones y procesos.

Primero, configuremos un escuchador de canal usando el método subscribe. Colocaremos esta llamada dentro de un comando Artisan ya que llamar al método subscribe inicia un proceso de larga duración:

<?php

namespace App\Console\Commands;

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

class RedisSubscribe extends Command
{
    /**
     * El nombre y firma del comando de consola.
     *
     * @var string
     */
    protected $signature = 'redis:subscribe';

    /**
     * La descripción del comando de consola.
     *
     * @var string
     */
    protected $description = 'Suscribirse a un canal Redis';

    /**
     * Ejecutar el comando de consola.
     */
    public function handle(): void
    {
        Redis::subscribe(['test-channel'], function (string $message) {
            echo $message;
        });
    }
}

Ahora podemos publicar mensajes en el canal usando el método publish:

use Illuminate\Support\Facades\Redis;

Route::get('/publish', function () {
    // ...

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

#Suscripciones con comodines

Usando el método psubscribe, puede suscribirse a un canal con comodines, lo cual puede ser útil para capturar todos los mensajes en todos los canales. El nombre del canal será pasado como segundo argumento al closure proporcionado:

Redis::psubscribe(['*'], function (string $message, string $channel) {
    echo $message;
});

Redis::psubscribe(['users.*'], function (string $message, string $channel) {
    echo $message;
});