2026.07.21.
Weboldal fejlesztés és SEO

Background feladatok bevezetése üzenetsorokkal.

Temesvári László

A türelmetlen web: háttérfeladatok és üzenetsorok a hosszú műveletek kiszolgálására

Ha már valaha is fejlesztettél egy olyan webalkalmazást, ahol a felhasználónak meg kell várnia, amíg egy szerveroldali folyamat befejeződik – például egy nagy fájl feldolgozása, komplex riport generálása vagy e-mailek küldése –, akkor tudod, milyen frusztráló lehet ez mindkét fél számára. A felhasználó megállítja a lapot, mert azt hiszi, lefagyott, te pedig azon aggódsz, hogy a HTTP kérés időtúllépés miatt megszakad. Itt jönnek képbe a háttérfeladatok és üzenetsorok – az elasztikus, skálázható alkalmazásépítés egyik alapköve.

Miért nem lehet mindent szinkronban lefuttatni?

A web alapvetően kérés-válasz alapú. A felhasználó csinál valamit, a böngésző elküldi a kérést, a szerver dolgozik rajta, és visszaküldi az eredményt. Ez remek működik gyors műveleteknél. Amikor azonban egy művelet több másodpercig, percekig, vagy akár órákig is eltarthat, ez a modell összeomlik. A böngészők és a szerverek (pl. Apache, Nginx) beépített timeout korlátokkal rendelkeznek. Ha a válasz túlságosan késik, egyszerűen megszakítják a kapcsolatot.

Itt válik kulcsfontosságúvá az architektúra átgondolása. A cél az, hogy a felhasználói interakciót minél gyorsabban lezárjuk, és a nehéz, hosszú munkát „kiszervezzük” egy olyan rendszerbe, amely arra van specializálódva. Ez a kétfázisú megközelítés lényegében a szakács és a pincér kapcsolata: a pincér (webszerver) azonnal elfogadja a rendelést és visszajelzi, hogy „rendben”, a szakács (háttérfeldolgozó) pedig a konyhán elkészíti az ételt.

Az architektúra kulcselemei: Queue, Worker, Job

Ez az egész rendszer három fő komponensen nyugszik:

1. Üzenetsor (Queue): Egy megbízható tároló, amely a végrehajtandó feladatokat (job-okat) várólistában tartja. Legegyszerűbb formájában ez egy adatbázistábla is lehet, de gyakran használnak erre specializált rendszereket, mint a Redis, RabbitMQ vagy AWS SQS. A lényeg, hogy megbízhatóan tárolja a feladat leírását. 2. Feladat (Job/Background Job): Ez egy önálló adagolható munkaegység. Tartalmazza az összes információt, ami a végrehajtásához kell: pl. „generálj egy PDF riportot user_id=123 adataiból, és küldd el email@example.com címre”. 3. Feldolgozó (Worker): Egy folyamatosan futó, különálló folyamat (vagy folyamatok csoportja), amelynek egyetlen feladata van: figyelni a sort, kivenni belőle a következő feladatot, és végrehajtani. Ha a feladat véget ért, a munkavégző törli a sort, vagy jelzi a sikerességet.

Egy egyszerű PHP háttérrendszer vázlata

Képzelj el egy Laravel/Symfony szerű keretrendszert, ahol a felhasználó megnyom egy „Riport generálása” gombot.

1. A feladat felvétele a sorba (Controller szinten):

// ReportController.php
public function generateReport(Request $request)
{
    $userId = Auth::id();
    $email = Auth::user()->email;

    // Itt nem végezzük el a hosszú műveletet!
    // Ehelyett felvesszük egy háttérfeladatot a sorba.
    GenerateReportJob::dispatch($userId, $email);

    // Azonnal visszajelzünk a felhasználónak
    return response()->json([
        'message' => 'A riportgenerálás elindult. E-mailben küldjük, ha kész.',
        'job_id' => $jobId // Opcionálisan, nyomonkövetéshez
    ]);
}

2. A feladat osztálya (a tényleges munka):

// GenerateReportJob.php
class GenerateReportJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $userId;
    protected $email;

    public function __construct($userId, $email)
    {
        $this->userId = $userId;
        $email = $email;
    }

    public function handle()
    {
        // Ez a rész fut le a háttérben, akár percekig is
        $data = DB::table('big_table')->where('user_id', $this->userId)->get();
        $pdf = $this->buildComplexPdf($data); // Hosszú művelet

        // Például fájlként elmentjük vagy...
        Storage::put("reports/report_{$this->userId}.pdf", $pdf);

        // ... közvetlenül e-mail mellékletként elküldjük
        Mail::to($this->email)->send(new ReportReadyMail($pdf));
    }
}

A szépség ez az, hogy a GenerateReportJob::dispatch() hívás azonnal visszatér. A feladatot egy sorba (pl. Redis) helyezi, és a Controller végez. A felhasználó kap egy azonnali, barátságos visszajelzést.

A felhasználói élmény finomhangolása frontend oldalon

A visszajelzés nem szűkülhet csupán egy „Kész lesz majd” feliratra. Használjunk JavaScript-et (esetünkben jQuery) a folyamat interaktívabbá tételéhez. Bootstrap komponensekkel könnyen készíthetünk állapotjelzőt.

// report.js - jQuery példa
$('#generateReportBtn').on('click', function() {
    var $btn = $(this);
    $btn.prop('disabled', true).html('<span class="spinner-border spinner-border-sm" role="status"></span> Feldolgozás...');

    $.ajax({
        url: '/generate-report',
        method: 'POST',
        dataType: 'json',
        success: function(response) {
            // A háttérfeladat elindult
            $btn.html('Generálás alatt...');
            // Megjelenítünk egy Bootstrap értesítést
            $('#alertContainer').html(
                '<div class="alert alert-info alert-dismissible fade show" role="alert">' +
                response.message +
                '<button type="button" class="btn-close" data-bs-dismiss="alert"></button>' +
                '</div>'
            );
            // Opcionálisan: periodikus poll a feladat állapotáról
            // startPollingJobStatus(response.job_id);
        },
        error: function() {
            $btn.prop('disabled', false).html('Riport generálása');
            $('#alertContainer').html('<div class="alert alert-danger">Hiba történt!</div>');
        }
    });
});

A megfelelő stílusért (CSS/SCSS) érdemes az állapotváltozásokat hangsúlyozni.

// _report.scss
#generateReportBtn {
    transition: all 0.3s ease;

    &.processing {
        background-color: $gray-400;
        border-color: $gray-400;
        cursor: wait;
    }
}

.alert {
    box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);

    // SCSS beágyazással
    &-info {
        border-left: 4px solid theme-color("info");
    }
}

Gyakori buktatók és tanulságok

* Idempotencia: Egy feladatot többször is végrehajthatnak (pl. mert a munkavégző összeomlott, és újraindult). Tervezd úgy a feladataidat, hogy akár duplán lefuttatva is biztonságosak és ugyanazt az eredményt adják. * Figyelés: A háttérrendszert látnod kell. Kötelező elem a feladatok sikeres/végrehajtás alatt/sikertelen állapotának naplózása, és alert beállítása, ha a sor hossza kritikussá válik. * Erőforrás-korlátok: A munkavégzők memóriát és processzort használnak. Ha túl sokat indítasz el, leterhelheted a szervert. Dinamikus skálázás vagy a worker-ek számának korlátozása fontos. * Sorrend és prioritás: Nem minden feladat egyenlő. Lehet, hogy az e-mail kiküldés nem sürgős, de a fizetés feldolgozása az. Több sorból álló, prioritásos rendszerek segíthetnek.

Összegzés

A háttérfeladatok és üzenetsorok használata nem csak egy technikai trükk a timeout-ok kijátszására. Ez egy filozófiai váltás az alkalmazás-építésben: az azonnali válaszadás és a megbízható, aszinkron háttérmunka szétválasztásáról szól. Megvédi a felhasználói élményt, növeli az alkalmazás rugalmasságát és megbízhatóságát, és lehetővé teszi a munka szétosztását több szerverre is. A következő alkalommal, amikor egy „Generate” gombra kattintva több másodpercnél tovább tartó folyamatot indítanál, gondolj a sorokra – ők a türelmes, megbízható munkások a webes világ gyors ütemében.

Kapcsolódó cikkek