> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.

<CardGroup cols={3}>
  <Card title="Cache" icon="database" href="/de/cache">
    Redis als Cache-Treiber verwenden
  </Card>

  <Card title="Queues" icon="list" href="/de/queues">
    Redis als Queue-Treiber verwenden
  </Card>

  <Card title="Broadcasting" icon="radio" href="/de/broadcasting">
    Echtzeitkommunikation über Pub/Sub
  </Card>
</CardGroup>

## Was ist Redis

[Redis](https://redis.io) 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:

```mermaid theme={null}
flowchart LR
    A["Laravel-<br>Anwendung"] --> B["Redis"]

    subgraph uses ["Typische Einsatzgebiete"]
        C["Cache"]
        D["Session"]
        E["Queue"]
        F["Broadcasting"]
    end

    B --> C
    B --> D
    B --> E
    B --> F
```

## 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 |

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

## Konfiguration

### config/database.php

Die Redis-Konfiguration liegt im Array `redis` in `config/database.php`.

```php theme={null}
'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.

```ini theme={null}
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:

```php theme={null}
'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.

```php theme={null}
'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`.

```php theme={null}
'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`.

```shell theme={null}
composer require predis/predis
```

```ini theme={null}
REDIS_CLIENT=predis
```

Predis-spezifische [Verbindungsparameter](https://github.com/nrk/predis/wiki/Connection-Parameters) sind zusätzlich möglich.

```php theme={null}
'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.

```php theme={null}
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`.

```php theme={null}
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`

```php theme={null}
'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`.

```php theme={null}
'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.

```ini theme={null}
REDIS_HOST=/run/redis/redis.sock
REDIS_PORT=0
```

#### Serialisierung und Kompression

PhpRedis kann Serialisierung und Kompression konfigurieren.

```php theme={null}
'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 theme={null}
<?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.

```php theme={null}
use Illuminate\Support\Facades\Redis;

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

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

Mit `command` geben Sie Kommando und Argumente explizit an.

```php theme={null}
$values = Redis::command('lrange', ['name', 5, 10]);
```

### Mehrere Verbindungen

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

```php theme={null}
// 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.

```php theme={null}
use Redis;
use Illuminate\Support\Facades;

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

<Warning>
  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.
</Warning>

### 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.

```php theme={null}
$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.

```php theme={null}
use Redis;
use Illuminate\Support\Facades;

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

```mermaid theme={null}
sequenceDiagram
    participant App as Laravel-<br>Anwendung
    participant Redis

    Note over App,Redis: Normal (Roundtrip pro Kommando)
    App->>Redis: SET key:0 0
    Redis-->>App: OK
    App->>Redis: SET key:1 1
    Redis-->>App: OK

    Note over App,Redis: Pipeline (gesammelter Versand)
    App->>Redis: SET key:0 0 / SET key:1 1 / ...
    Redis-->>App: OK / OK / ...
```

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

## 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 theme={null}
<?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.

```php theme={null}
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.

```php theme={null}
// 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

<AccordionGroup>
  <Accordion title="Client-Wahl">
    * **Produktion**: PhpRedis (PECL-Erweiterung, hohe Performance)
    * **Entwicklung / Umgebungen ohne PECL**: Predis (Composer-Paket)
    * **Laravel Sail**: PhpRedis bereits enthalten
  </Accordion>

  <Accordion title="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
  </Accordion>

  <Accordion title="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)                          |
  </Accordion>
</AccordionGroup>


## Related topics

- [Cache](/de/cache.md)
- [Laravel Sail](/de/sail.md)
- [Rate Limiting anpassen](/de/advanced/rate-limiting.md)
- [Queues und Jobs](/de/queues.md)
- [Laravel Pulse](/de/pulse.md)