Alle Artikel
Laravel5 min

Laravel Redis Tutorial: Sessions, Cache & Performance

Redis ist eine der besten Möglichkeiten, um die Performance deiner Laravel-Anwendung drastisch zu verbessern. In diesem Laravel Redis Tutorial zeige ich dir, wie du Redis für Sessions, Cache und Queues einrichtest und optimal nutzt.

Was ist Redis und warum solltest du es verwenden?

Redis ist ein In-Memory-Datenbank-System, das extrem schnell ist. Im Gegensatz zu klassischen Datenbanken speichert Redis Daten im RAM, was Zugriffe um den Faktor 100-1000 beschleunigt. Für Laravel-Entwickler bedeutet das:

  • Schnellere Sessions: Authentifizierung und Session-Handling in Millisekunden
  • Effizienter Cache: Datenbankabfragen cachen und Ladezeiten reduzieren
  • Performante Queues: Background-Jobs zuverlässig verarbeiten
  • Rate Limiting: API-Anfragen kontrollieren

Redis in Laravel installieren

Für dieses Laravel Redis Tutorial benötigst du zunächst Redis auf deinem Server und die PHP-Extension phpredis oder das Composer-Package predis.

Redis Server installieren

Auf Ubuntu/Debian:

sudo apt update
sudo apt install redis-server
sudo systemctl enable redis-server
sudo systemctl start redis-server

Überprüfe die Installation:

redis-cli ping
# Sollte "PONG" zurückgeben

Laravel-Dependencies installieren

Installiere Predis über Composer:

composer require predis/predis

Alternativ kannst du die PHP-Extension phpredis verwenden, die noch etwas performanter ist:

sudo pecl install redis

Redis in Laravel konfigurieren

Öffne deine .env-Datei und konfiguriere die Redis-Verbindung:

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
REDIS_CLIENT=predis

CACHE_DRIVER=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

Die Konfiguration in config/database.php sollte so aussehen:

'redis' => [
    'client' => env('REDIS_CLIENT', 'predis'),
    
    'default' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', 6379),
        'database' => 0,
    ],
    
    'cache' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', 6379),
        'database' => 1,
    ],
    
    'session' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', 6379),
        'database' => 2,
    ],
],

Beachte: Wir nutzen unterschiedliche Datenbanken (0, 1, 2) für verschiedene Zwecke, um Namenskonflikte zu vermeiden.

Redis für Sessions nutzen

Sessions mit Redis sind deutlich schneller als file- oder datenbankbasierte Sessions. Die Konfiguration haben wir bereits in der .env gesetzt:

SESSION_DRIVER=redis
SESSION_CONNECTION=session

In config/session.php kannst du zusätzliche Optionen setzen:

'connection' => env('SESSION_CONNECTION', 'session'),
'lifetime' => 120,
'expire_on_close' => false,

Laravel nutzt nun automatisch Redis für alle Session-Operationen:

// Session schreiben
session(['user_preference' => 'dark_mode']);

// Session lesen
$preference = session('user_preference');

// In Controllern
$request->session()->put('key', 'value');
$value = $request->session()->get('key');

Performance-Vergleich

In einem typischen Laravel-Projekt mit 1000 gleichzeitigen Sessions:

  • File-Sessions: ~50-100ms Zugriffszeit
  • Redis-Sessions: ~2-5ms Zugriffszeit

Caching mit Redis

Der Cache ist einer der größten Performance-Hebel in Laravel. Mit diesem Laravel Redis Tutorial lernst du die wichtigsten Caching-Patterns.

Basis-Caching

use Illuminate\Support\Facades\Cache;

// Wert für 1 Stunde cachen
Cache::put('user_count', 1234, 3600);

// Wert abrufen
$count = Cache::get('user_count');

// Mit Default-Wert
$count = Cache::get('user_count', 0);

// Prüfen ob Schlüssel existiert
if (Cache::has('user_count')) {
    // ...
}

Remember-Pattern

Das Remember-Pattern ist extrem praktisch für Datenbankabfragen:

use App\Models\Product;

$products = Cache::remember('featured_products', 3600, function () {
    return Product::where('featured', true)
        ->with('category')
        ->get();
});

Der Closure wird nur ausgeführt, wenn der Wert nicht im Cache ist. Beim zweiten Aufruf kommt das Ergebnis direkt aus Redis.

Tags für gruppierten Cache

Redis unterstützt Cache-Tags, um zusammenhängende Daten zu gruppieren:

// Mit Tags cachen
Cache::tags(['products', 'featured'])->put('product_list', $products, 3600);

// Abrufen
$products = Cache::tags(['products', 'featured'])->get('product_list');

// Alle Produkt-Caches löschen
Cache::tags('products')->flush();

Real-World Beispiel: API-Response cachen

namespace App\Http\Controllers\Api;

use App\Models\Product;
use Illuminate\Support\Facades\Cache;

class ProductController extends Controller
{
    public function index()
    {
        $cacheKey = 'api_products_' . request('page', 1);
        
        $products = Cache::tags(['products', 'api'])
            ->remember($cacheKey, 600, function () {
                return Product::with(['category', 'images'])
                    ->paginate(20);
            });
        
        return response()->json($products);
    }
    
    public function update($id)
    {
        // Produkt aktualisieren...
        
        // Alle Produkt-Caches invalidieren
        Cache::tags(['products'])->flush();
    }
}

Queues mit Redis

Redis ist ideal für Laravel Queues, da es sehr schnell ist und Persistenz bietet.

QUEUE_CONNECTION=redis

Jobs erstellen und dispatchen

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProcessOrder implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    public function __construct(
        public int $orderId
    ) {}
    
    public function handle(): void
    {
        // Order verarbeiten
        // E-Mail senden
        // PDF generieren
    }
}

Job dispatchen:

ProcessOrder::dispatch($order->id);

// Mit Delay
ProcessOrder::dispatch($order->id)->delay(now()->addMinutes(5));

// Auf spezifischer Queue
ProcessOrder::dispatch($order->id)->onQueue('emails');

Queue Worker starten:

php artisan queue:work redis --queue=default,emails --tries=3

Rate Limiting mit Redis

Laravel nutzt Redis auch für Rate Limiting:

use Illuminate\Support\Facades\RateLimiter;

// Rate Limit definieren
RateLimiter::for('api', function (Request $request) {
    return Limit::perMinute(60)->by($request->user()?->id ?: $request->ip());
});

// In Routes verwenden
Route::middleware(['throttle:api'])->group(function () {
    // API Routes
});

Custom Rate Limiting

use Illuminate\Support\Facades\Redis;

public function checkRateLimit($key, $maxAttempts = 5, $decayMinutes = 1)
{
    $attempts = Redis::incr($key);
    
    if ($attempts === 1) {
        Redis::expire($key, $decayMinutes * 60);
    }
    
    return $attempts <= $maxAttempts;
}

Performance-Tipps für Redis in Laravel

  1. Pipeline Commands: Mehrere Redis-Operationen bündeln
Redis::pipeline(function ($pipe) {
    $pipe->set('key1', 'value1');
    $pipe->set('key2', 'value2');
    $pipe->set('key3', 'value3');
});

  1. Cache-Keys strukturiert benennen:

    • products:featured:v1
    • user:123:profile
    • api:response:products:page:1

  2. TTL sinnvoll setzen: Nicht zu kurz (mehr DB-Load), nicht zu lang (veraltete Daten)

  3. Redis Monitoring:

redis-cli info stats
redis-cli --stat

Fazit

Dieses Laravel Redis Tutorial hat dir gezeigt, wie du Redis für Sessions, Cache und Queues nutzt. Die Performance-Verbesserungen sind enorm – gerade bei wachsenden Anwendungen mit vielen Usern.

Wichtigste Takeaways:

  • Redis als Session-Driver für schnellere Authentifizierung
  • Cache-Remember-Pattern für Datenbankabfragen
  • Redis-Queues für asynchrone Jobs
  • Rate Limiting für API-Schutz

Du arbeitest an einem Laravel-Projekt und möchtest Redis optimal einsetzen? Ich helfe dir gerne bei der Implementierung und Performance-Optimierung.

Laravel Redis TutorialLaravelFreelancerWebentwicklungDüsseldorf
Anfrage senden