Redis

webman/redis é uma extensão da illuminate/redis que adiciona a funcionalidade de pool de conexões, suportando ambientes de corrotina e não corrotina, com uma utilização semelhante ao Laravel.

Antes de usar illuminate/redis, você deve primeiro instalar a extensão redis para php-cli.

Atenção
Este manual é para a versão webman v2. Se você estiver usando a versão webman v1, consulte o manual da versão v1.
Este componente requer a instalação da extensão redis. Use o comando php -m | grep redis para verificar se o php-cli tem a extensão redis instalada.

Instalação

composer require -W webman/redis illuminate/events

Após a instalação, é necessário reiniciar (reload não é suficiente).

Configuração

O arquivo de configuração do redis está em config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
        'pool' => [ // Configuração do pool de conexões
            'max_connections' => 10,     // Número máximo de conexões no pool
            'min_connections' => 1,      // Número mínimo de conexões no pool
            'wait_timeout' => 3,         // Tempo máximo de espera para obter uma conexão do pool
            'idle_timeout' => 50,        // Tempo de inatividade para conexões no pool, após o qual serão fechadas, até que o número de conexões seja igual a min_connections
            'heartbeat_interval' => 50,  // Intervalo de verificação de atividade, não deve exceder 60 segundos
        ],
    ]
];

Sobre o pool de conexões

• Cada processo tem seu próprio pool de conexões, não há compartilhamento de pools entre processos.
• Quando as corrotinas não estão ativadas, as operações dentro do processo são executadas em fila, não gerando concorrência, então o pool terá no máximo uma conexão.
• Quando as corrotinas estão ativadas, as operações dentro do processo são executadas de forma concorrente, e o pool ajustará dinamicamente o número de conexões necessárias, sem exceder max_connections e não sendo inferior a min_connections.
• Como o número máximo de conexões no pool é max_connections, quando o número de corrotinas que operam o Redis excede max_connections, algumas corrotinas ficarão em fila aguardando, no máximo wait_timeout segundos; se exceder, uma exceção será disparada.
• Em situações de ociosidade (incluindo ambientes de corrotina e não corrotina), as conexões serão recuperadas após o tempo idle_timeout, até que o número de conexões atinja min_connections (min_connections pode ser 0).

Exemplo

<?php
namespace app\controller;

use support\Request;
use support\Redis;

class UserController
{
    public function db(Request $request)
    {
        $key = 'test_key';
        Redis::set($key, rand());
        return response(Redis::get($key));
    }
}

Interface do Redis

Redis::append($key, $value)
Redis::bitCount($key)
Redis::decr($key, $value)
Redis::decrBy($key, $value)
Redis::get($key)
Redis::getBit($key, $offset)
Redis::getRange($key, $start, $end)
Redis::getSet($key, $value)
Redis::incr($key, $value)
Redis::incrBy($key, $value)
Redis::incrByFloat($key, $value)
Redis::mGet(array $keys)
Redis::getMultiple(array $keys)
Redis::mSet($pairs)
Redis::mSetNx($pairs)
Redis::set($key, $value, $expireResolution = null, $expireTTL = null, $flag = null)
Redis::setBit($key, $offset, $value)
Redis::setEx($key, $ttl, $value)
Redis::pSetEx($key, $ttl, $value)
Redis::setNx($key, $value)
Redis::setRange($key, $offset, $value)
Redis::strLen($key)
Redis::del(...$keys)
Redis::exists(...$keys)
Redis::expire($key, $ttl)
Redis::expireAt($key, $timestamp)
Redis::select($dbIndex)

Equivalente a

$redis = Redis::connection('default');
$redis->append($key, $value)
$redis->bitCount($key)
$redis->decr($key, $value)
$redis->decrBy($key, $value)
$redis->get($key)
$redis->getBit($key, $offset)
...

Atenção
Use com cautela a interface Redis::select($db), pois o webman é um framework que permanece na memória. Se uma solicitação usar Redis::select($db) para trocar de banco de dados, isso afetará as solicitações subsequentes. Para múltiplos bancos de dados, recomenda-se configurar diferentes $db para diferentes configurações de conexão Redis.

Usando múltiplas conexões Redis

Por exemplo, no arquivo de configuração config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
    ],

    'cache' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 1,
    ],

]

A conexão padrão usa a configuração sob default, você pode usar o método Redis::connection() para escolher qual conexão redis usar.

$redis = Redis::connection('cache');
$redis->get('test_key');

Configuração de Cluster

Se sua aplicação utiliza um cluster de servidores Redis, você deve usar a chave clusters no arquivo de configuração do Redis para definir esses clusters:

return [
    'clusters' => [
        'default' => [
            [
                'host'     => 'localhost',
                'password' => null,
                'port'     => 6379,
                'database' => 0,
            ],
        ],
    ],

];

Por padrão, o cluster pode implementar o particionamento de clientes nos nós, permitindo que você tenha um pool de nós e crie uma grande quantidade de memória disponível. É importante notar que o compartilhamento de clientes não lida com falhas; portanto, essa funcionalidade é mais adequada para dados de cache obtidos de um banco de dados principal diferente. Se você quiser usar o cluster nativo do Redis, deve especificar a seguinte configuração na chave options do arquivo de configuração:

return[
    'options' => [
        'cluster' => 'redis',
    ],

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

Comandos de Pipeline

Quando você precisa enviar muitos comandos para o servidor em uma única operação, é recomendável usar comandos de pipeline. O método pipeline aceita um closure de uma instância Redis. Você pode enviar todos os comandos para a instância Redis, e eles serão executados em uma única operação:

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