Redis

Konfiguration und Nutzung von Redis in Laravel-Anwendungen – für Cache, Sessions, Queues und Pub/Sub.

Redis ist ein In-Memory-Key-Value-Store und dient als Backend für viele Laravel-Funktionen. Diese Seite behandelt Konfiguration, Nutzung und Pub/Sub mit Redis in Laravel.

Cache

Redis als Cache-Treiber verwenden

Queues

Redis als Queue-Treiber verwenden

Broadcasting

Echtzeitkommunikation über Pub/Sub

​

Was ist Redis

Redis ist ein schneller Open-Source-Key-Value-Store. Er unterstützt vielfältige Datenstrukturen (Strings, Hashes, Listen, Sets, sortierte Sets) und wird deshalb auch „Data Structure Server“ genannt.

In Laravel wird Redis unter anderem für Folgendes verwendet:

​

Client-Wahl

Laravel unterstützt zwei Clients: PhpRedis (PHP-Erweiterung) und Predis (PHP-Paket).

Punkt	PhpRedis	Predis
Implementierung	PHP-Erweiterung in C	Reines PHP-Paket
Installation	PECL-Erweiterung erforderlich	Nur composer require
Performance	Schnell	Etwas langsamer als PhpRedis
Laravel Sail	Standardmäßig enthalten	Muss extra installiert werden
Empfohlen für	Produktion	Entwicklung, Umgebungen ohne PECL

In Laravel 13 ist PhpRedis der Standard-Client. In Produktion wird PhpRedis empfohlen. In Laravel Sail ist PhpRedis bereits installiert.

​

Konfiguration

​

config/database.php

Die Redis-Konfiguration liegt im Array redis in 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'),
    ],

],

​

Umgebungsvariablen

In der .env legen Sie die Verbindungsziele fest.

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

Alternativ per URL:

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

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

​

TLS-/SSL-Verbindung

Für TLS-Verschlüsselung geben Sie die Option scheme an.

'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

Für einen Cluster aus mehreren Redis-Servern verwenden Sie den Schlüssel 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'),
            ],
        ],
    ],

],

Standardmäßig ist options.cluster auf redis gesetzt und nutzt das native Redis-Clustering. Da Failover automatisch übernommen wird, ist das für Produktion empfohlen.

Um Client-Side-Sharding mit Predis zu verwenden, entfernen Sie options.cluster. Client-Side-Sharding kümmert sich jedoch nicht um Failover und eignet sich daher nur für kurzlebige Daten wie Caches.

​

Predis konfigurieren

Um Predis zu nutzen, installieren Sie das Paket predis/predis und setzen REDIS_CLIENT auf predis.

composer require predis/predis

REDIS_CLIENT=predis

Predis-spezifische Verbindungsparameter sind zusätzlich möglich.

'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,
],

​

Retry-Einstellungen in Predis

Ab Predis 3.4.0 gibt es eingebaute Retry- und Backoff-Konfigurationen. Über max_retries setzen Sie die Retry-Anzahl, über retry die Backoff-Strategie. Für retry übergeben Sie ein Array mit einem der Klassennamen NoBackoff, EqualBackoff oder ExponentialBackoff als Schlüssel.

use Predis\Retry\Strategy\ExponentialBackoff;

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

Für Predis mit Redis-Cluster setzen Sie die Retries in der Cluster-Konfiguration unter parameters.

use Predis\Retry\Strategy\NoBackoff;

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

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

​

PhpRedis konfigurieren

PhpRedis installieren Sie über PECL (in Laravel Sail bereits vorhanden). PhpRedis unterstützt zusätzliche Optionen: 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],
    ],
],

​

Retries und Backoff

Legt fest, wie sich der Client bei Verbindungsfehlern erneut verbindet. Unterstützte Backoff-Algorithmen: 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),
],

​

Verbindung über Unix-Socket

Läuft Redis auf demselben Server, spart ein Unix-Socket den TCP-Overhead.

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

​

Serialisierung und Kompression

PhpRedis kann Serialisierung und Kompression konfigurieren.

'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,
    ],

],

Unterstützte Serialisierer:

Konstante	Beschreibung
Redis::SERIALIZER_NONE	Keine Serialisierung (Standard)
Redis::SERIALIZER_PHP	PHP-Serialisierung
Redis::SERIALIZER_JSON	JSON
Redis::SERIALIZER_IGBINARY	igbinary
Redis::SERIALIZER_MSGPACK	MessagePack

Unterstützte Kompressionsalgorithmen:

Konstante	Beschreibung
Redis::COMPRESSION_NONE	Keine Kompression (Standard)
Redis::COMPRESSION_LZF	LZF
Redis::COMPRESSION_ZSTD	Zstandard
Redis::COMPRESSION_LZ4	LZ4

​

Redis nutzen

​

Redis-Fassade

Über die Redis-Fassade führen Sie jedes Redis-Kommando aus. Sie leitet Aufrufe per Magic-Methoden an den Server weiter.

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

Argumente der Kommandos werden einfach als Methodenargumente übergeben.

use Illuminate\Support\Facades\Redis;

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

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

Mit command geben Sie Kommando und Argumente explizit an.

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

​

Mehrere Verbindungen

In config/database.php definieren Sie mehrere Redis-Verbindungen und wechseln mit connection().

// Benannte Verbindung holen
$redis = Redis::connection('connection-name');

// Standardverbindung
$redis = Redis::connection();

​

Transaktionen

Die Methode transaction() kapselt die Redis-Kommandos MULTI/EXEC. Alle Kommandos innerhalb der Closure werden atomar ausgeführt.

use Redis;
use Illuminate\Support\Facades;

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

Innerhalb einer Transaktion können Sie keine Werte aus Redis lesen. Die gesamte Closure wird zuerst ausgeführt und die Kommandos anschließend mit EXEC gesammelt gesendet.

​

Lua-Skripte

Mit eval() führen Sie Lua-Skripte atomar aus. Da Sie im Skript Werte lesen und schreiben können, sind Lua-Skripte flexibler als reine Transaktionen.

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

Reihenfolge der Argumente: Lua-Skript → Anzahl Keys → Key-Namen … → zusätzliche Argumente …

KEYS[1] und KEYS[2] sind die Key-Namen, ARGV[1] und folgende sind zusätzliche Argumente.

​

Pipelines

Über Pipelines senden Sie viele Kommandos auf einmal und sparen Netzwerk-Roundtrips.

use Redis;
use Illuminate\Support\Facades;

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

Pipelines bündeln nur den Versand – sie sind nicht atomar. Für atomare Operationen verwenden Sie Transaktionen oder Lua-Skripte.

​

Pub/Sub

Mit den Redis-Kommandos publish und subscribe tauschen Sie Nachrichten über Kanäle aus.

​

Subscriber

subscribe() ist ein langlaufender Prozess und wird üblicherweise in einem Artisan-Befehl aufgerufen.

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

​

Publisher

Aus einem anderen Request oder Prozess senden Sie eine Nachricht.

use Illuminate\Support\Facades\Redis;

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

​

Wildcard-Subscriptions

Mit psubscribe() abonnieren Sie Muster.

// Alle Kanäle abonnieren
Redis::psubscribe(['*'], function (string $message, string $channel) {
    echo $message;
});

// Alle Kanäle, die dem Muster users.* entsprechen
Redis::psubscribe(['users.*'], function (string $message, string $channel) {
    echo $message;
});

​

Zusammenfassung

Client-Wahl

• Produktion: PhpRedis (PECL-Erweiterung, hohe Performance)
• Entwicklung / Umgebungen ohne PECL: Predis (Composer-Paket)
• Laravel Sail: PhpRedis bereits enthalten

Wichtige Punkte zur Konfiguration

• Mehrere Redis-Verbindungen in config/database.php je nach Einsatz definieren (default, cache etc.)
• Im Cluster-Setup den Schlüssel clusters verwenden
• In Produktion TLS-Verbindungen und Authentifizierung einrichten

Wann welche Operation?

Operation	Einsatz
Fassaden-Methoden	Normale Redis-Kommandos
transaction()	Atomare Ausführung mehrerer Kommandos (kein Lesen möglich)
eval()	Lua-Skript (atomar mit Lesezugriffen)
pipeline()	Massenversand von Kommandos (nicht atomar)
subscribe() / publish()	Nachrichten über Kanäle (Pub/Sub)