Alle Artikel
Laravel4 min

Laravel Queues Tutorial – Background Jobs optimal nutzen

Laravel Queues gehören zu den mächtigsten Features des Frameworks. Sie ermöglichen es dir, zeitintensive Aufgaben in den Hintergrund zu verschieben und so die Response-Zeit deiner Webanwendung drastisch zu verbessern. In diesem Laravel Queues Tutorial zeige ich dir, wie du Background Jobs richtig implementierst, konfigurierst und in Produktion bringst.

Warum Laravel Queues verwenden?

Stell dir vor, ein Nutzer registriert sich in deiner App. Dabei müssen mehrere Dinge passieren:

  • Eine Willkommens-E-Mail versenden
  • Das Profilbild verarbeiten
  • Einen Eintrag im CRM-System anlegen
  • Analytics-Events tracken

Ohne Queues würde der User warten, bis alle diese Aufgaben abgeschlossen sind – das können leicht 5-10 Sekunden sein. Mit Laravel Queues antwortest du sofort und erledigst diese Tasks im Hintergrund.

Queue-Treiber konfigurieren

Laravel unterstützt verschiedene Queue-Treiber. Für dieses Laravel Queues Tutorial nutzen wir Redis, da es performant und in den meisten Hosting-Umgebungen verfügbar ist.

Installiere zunächst die Redis-Extension für PHP und den Predis-Client:

composer require predis/predis

Konfiguriere dann in .env:

QUEUE_CONNECTION=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

Für lokale Entwicklung kannst du auch database als Driver verwenden:

QUEUE_CONNECTION=database
php artisan queue:table
php artisan migrate

Deinen ersten Job erstellen

Laravel macht es einfach, Jobs zu erstellen. Nutze den Artisan-Befehl:

php artisan make:job SendWelcomeEmail

Das erstellt eine Job-Klasse in app/Jobs/SendWelcomeEmail.php:

<?php

namespace App\Jobs;

use App\Models\User;
use App\Mail\WelcomeMail;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Mail;

class SendWelcomeEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(
        public User $user
    ) {}

    public function handle(): void
    {
        Mail::to($this->user->email)
            ->send(new WelcomeMail($this->user));
    }
}

Das Interface ShouldQueue signalisiert Laravel, dass dieser Job asynchron ausgeführt werden soll.

Jobs dispatchen

Um einen Job in die Queue zu schieben, nutzt du die dispatch()-Methode:

use App\Jobs\SendWelcomeEmail;

// Im Controller nach erfolgreicher Registrierung
public function register(Request $request)
{
    $user = User::create($request->validated());
    
    // Job in Queue einstellen
    SendWelcomeEmail::dispatch($user);
    
    return response()->json([
        'message' => 'Registrierung erfolgreich'
    ]);
}

Der User erhält sofort eine Antwort, während die E-Mail im Hintergrund versendet wird.

Queue Worker starten

Jobs werden nicht automatisch abgearbeitet. Du musst einen Queue Worker starten:

php artisan queue:work

Für Entwicklung mit automatischem Reload bei Code-Änderungen:

php artisan queue:work --tries=3 --timeout=60

In Produktion solltest du einen Process-Manager wie Supervisor verwenden. Erstelle /etc/supervisor/conf.d/laravel-worker.conf:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /pfad/zu/deiner/app/artisan queue:work redis --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=4
redirect_stderr=true
stdout_logfile=/pfad/zu/deiner/app/storage/logs/worker.log
stopwaitsecs=3600

Fortgeschrittene Queue-Konzepte

Job-Chains für abhängige Tasks

Manchmal müssen Jobs in einer bestimmten Reihenfolge ablaufen:

use Illuminate\Support\Facades\Bus;
use App\Jobs\ProcessUpload;
use App\Jobs\OptimizeImage;
use App\Jobs\GenerateThumbnail;

Bus::chain([
    new ProcessUpload($file),
    new OptimizeImage($file),
    new GenerateThumbnail($file),
])->dispatch();

Delayed Jobs

Du kannst Jobs verzögert ausführen:

// In 10 Minuten ausführen
SendReminderEmail::dispatch($user)
    ->delay(now()->addMinutes(10));

Job-Prioritäten mit mehreren Queues

Definiere verschiedene Queues für unterschiedliche Prioritäten:

// Hohe Priorität
SendWelcomeEmail::dispatch($user)
    ->onQueue('high');

// Niedrige Priorität
GenerateReport::dispatch($data)
    ->onQueue('low');

Starte Worker für spezifische Queues:

php artisan queue:work --queue=high,default,low

Error Handling und Retries

Laravel wiederholt fehlgeschlagene Jobs automatisch. Du kannst das Verhalten steuern:

class SendWelcomeEmail implements ShouldQueue
{
    // Maximale Versuche
    public $tries = 3;
    
    // Timeout in Sekunden
    public $timeout = 120;
    
    // Exponential Backoff
    public function backoff(): array
    {
        return [1, 5, 10];
    }
    
    // Was bei finalem Fehler passiert
    public function failed(\Throwable $exception): void
    {
        Log::error('Welcome email failed', [
            'user_id' => $this->user->id,
            'error' => $exception->getMessage()
        ]);
        
        // Optional: Admin benachrichtigen
    }
}

Job-Batching für Massenoperationen

Für größere Operationen nutzt du Batches:

use Illuminate\Bus\Batch;
use Illuminate\Support\Facades\Bus;

$users = User::where('active', true)->get();

$batch = Bus::batch(
    $users->map(fn($user) => new SendNewsletterEmail($user))
)->then(function (Batch $batch) {
    // Wird ausgeführt wenn alle Jobs erfolgreich
    Log::info('Newsletter an alle User versendet');
})->catch(function (Batch $batch, \Throwable $e) {
    // Wird ausgeführt bei erstem Fehler
})->finally(function (Batch $batch) {
    // Wird immer ausgeführt
})->dispatch();

Migriere zuerst die Batch-Tabelle:

php artisan queue:batches-table
php artisan migrate

Monitoring und Debugging

Failed Jobs analysieren

Laravel speichert fehlgeschlagene Jobs in der failed_jobs-Tabelle:

# Tabelle erstellen
php artisan queue:failed-table
php artisan migrate

# Fehlgeschlagene Jobs anzeigen
php artisan queue:failed

# Job erneut versuchen
php artisan queue:retry {id}

# Alle fehlgeschlagenen Jobs erneut versuchen
php artisan queue:retry all

Queue-Status überwachen

In deinem Monitoring-Dashboard kannst du Queue-Metriken tracken:

use Illuminate\Support\Facades\Queue;

// Anzahl pending Jobs
$pending = Queue::size('default');

// In Kombination mit Laravel Horizon für Redis

Für produktive Anwendungen empfehle ich Laravel Horizon – ein Dashboard für Redis-Queues mit Echtzeit-Monitoring.

Performance-Optimierungen

Job-Serialisierung minimieren

Übergebe nur IDs statt komplette Eloquent-Models:

// Nicht optimal
SendInvoice::dispatch($order); // Serialisiert komplettes Model

// Besser
SendInvoice::dispatch($order->id);

// Im Job dann:
public function handle(): void
{
    $order = Order::find($this->orderId);
    // ...
}

Queue-Verbindungen poolen

In config/queue.php kannst du Connection-Pools konfigurieren:

'redis' => [
    'driver' => 'redis',
    'connection' => 'default',
    'queue' => env('REDIS_QUEUE', 'default'),
    'retry_after' => 90,
    'block_for' => 5,
],

Fazit

Mit diesem Laravel Queues Tutorial hast du alle Grundlagen, um Background Jobs professionell einzusetzen. Du weißt jetzt:

  • Wie du Jobs erstellst und dispatcht
  • Wie Queue-Worker konfiguriert werden
  • Wie du Error-Handling implementierst
  • Wie du komplexe Job-Chains und Batches nutzt

Laravel Queues sind essentiell für skalierbare Webanwendungen. Sie verbessern nicht nur die User Experience, sondern ermöglichen auch den Aufbau robuster, wartbarer Systeme.

Du arbeitest an einem Laravel-Projekt mit komplexen Background-Prozessen? Ich helfe dir gerne bei der Implementierung einer performanten Queue-Architektur.

Laravel Queues TutorialLaravelFreelancerWebentwicklungDüsseldorf
Anfrage senden