Redis

webman/redis aggiunge funzionalità di pool di connessione basate su illuminate/redis, supportando ambienti sia coroutine che non coroutine, con un utilizzo simile a Laravel.

Prima di utilizzare illuminate/redis, è necessario installare l'estensione Redis per php-cli.

Attenzione
Questo manuale è per la versione v2 di webman. Se stai utilizzando la versione v1 di webman, consulta il manuale della versione v1.
Questa componente richiede l'installazione dell'estensione Redis. Usa il comando php -m | grep redis per verificare se php-cli ha installato l'estensione Redis.

Installazione

composer require -W webman/redis illuminate/events

Dopo l'installazione, è necessario riavviare (il reload non è efficace).

Configurazione

Il file di configurazione Redis si trova in config/redis.php

return [
    'default' => [
        'host'     => '127.0.0.1',
        'password' => null,
        'port'     => 6379,
        'database' => 0,
        'pool' => [ // configurazione del pool di connessione
            'max_connections' => 10,     // numero massimo di connessioni nel pool
            'min_connections' => 1,      // numero minimo di connessioni nel pool
            'wait_timeout' => 3,         // tempo massimo di attesa per ottenere una connessione dal pool
            'idle_timeout' => 50,        // tempo di inattività dopo il quale una connessione viene chiusa, fino a quando il numero di connessioni è `min_connections`
            'heartbeat_interval' => 50,  // intervallo di controllo del heartbeat, non deve superare i 60 secondi
        ],
    ]
];

Riguardo il Pool di Connessione

• Ogni processo ha il proprio pool di connessione, i pool di connessione non vengono condivisi tra processi.
• Se le coroutine non sono abilitate, le operazioni nel processo vengono eseguite in coda senza concorrenza, quindi il pool di connessione avrà al massimo 1 connessione.
• Abilitando le coroutine, le operazioni vengono eseguite in modo concorrente nel processo e il pool di connessione si adatta dinamicamente al numero di connessioni richieste, senza superare max_connections e senza scendere sotto min_connections.
• Poiché il numero massimo di connessioni nel pool è max_connections, quando il numero di coroutine che operano su Redis è maggiore di max_connections, alcune coroutine saranno in attesa, massimo per wait_timeout secondi. Superato questo limite, verrà generata un'eccezione.
• In condizioni di inattività (sia in ambienti coroutine che non coroutine), le connessioni verranno recuperate dopo il tempo idle_timeout, fino a quando il numero di connessioni non sarà min_connections (min_connections può essere 0).

Esempio

<?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));
    }
}

Interfaccia 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)

equivale 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)
...

Attenzione
Fare attenzione all'uso dell'interfaccia Redis::select($db), poiché webman è un framework con memoria persistente. Se una richiesta utilizza Redis::select($db) per cambiare il database, questo influenzerà le richieste successive. Per più database, si consiglia di configurare i diversi $db come diverse configurazioni di connessione Redis.

Utilizzare più connessioni Redis

Ad esempio, il file di configurazione 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,
    ],

]

La connessione di default utilizza la configurazione sotto default, puoi utilizzare il metodo Redis::connection() per scegliere quale connessione Redis utilizzare.

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

Configurazione Cluster

Se la tua applicazione utilizza un cluster di server Redis, dovresti utilizzare la chiave clusters nel file di configurazione Redis per definire questi cluster:

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

];

Per impostazione predefinita, i cluster possono implementare lo sharding client sui nodi, consentendo di realizzare un pool di nodi e di creare una grande quantità di memoria disponibile. Si noti che la condivisione client non gestirà i casi di errore; pertanto, questa funzionalità è principalmente adatta per i dati cache ottenuti da un altro database master. Se si desidera utilizzare un cluster nativo Redis, è necessario specificare quanto segue nella chiave options del file di configurazione:

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

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

Comandi Pipelined

Quando hai bisogno di inviare molti comandi al server in un'unica operazione, si consiglia di utilizzare i comandi pipelined. Il metodo pipeline accetta una closure di un'istanza Redis. Puoi inviare tutti i comandi all'istanza Redis e verranno eseguiti tutti in una sola operazione:

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