Bij synchrone verwerking wacht een gebruiker op het resultaat terwijl de applicatie een taak uitvoert. Met een job queue kan de applicatie werk overdragen aan een achtergrondworker; dat verandert de responstijd, foutafhandeling en manier waarop je taakstatus bijhoudt. Lees welke afwegingen bepalen welk model bij een proces past.
Wat synchrone verwerking betekent voor een webverzoek
In een synchrone aanpak pakt je applicatie een taak direct op zodra het verzoek binnenkomt. Je klant klikt op "verzenden", jouw server verwerkt het formulier, zet gegevens in de database en misschien wordt er nog een rapportje uitgedraaid, alles voor er een antwoord volgt. Dat betekent: één verzoek, alles netjes op volgorde afgehandeld, de gebruiker krijgt direct een reactie of foutmelding. Die aanpak is overzichtelijk. Je hoeft niet met losse statuspagina's te werken of taken te volgen in aparte schermen.
Toch: synchrone verwerking werkt lekker zolang een taak vlot afloopt en het resultaat voorspelbaar is. Een simpele update in een tabel of een snelle rekensom? Geen probleem. Komen er onvoorspelbare vertragingen bij, bijvoorbeeld als je op een externe API wacht, met flinke bestanden werkt, of grote aantallen data moet verwerken? Dan wordt het lastiger. De verbinding blijft bezet, serverresources raken vast en misschien krijg je een timeout voordat het klaar is. De gebruiker krijgt dan geen flauw idee of de actie nog loopt of ergens is vastgelopen na een afgebroken verbinding.
Let op: synchroon zegt niks over transacties of processen. Je kunt gerust een berg services aanroepen, maar zolang het uiteindelijke antwoord pas terugkomt als al die stappen afgerond zijn, blijft alles synchroon. Kijk dus verder dan het gemiddelde: juist de variatie in doorlooptijd, onverwachte fouten en piekmomenten bepalen of direct verwerken zinvol blijft. Voor maatwerk in PHP kun je ook terecht bij een PHP developer.
Gebruikerservaring en responstijd bij lang werk
Zie je dat een scherm in de browser aan het laden blijft zonder duidelijkheid? Dat gebeurt snel als een verzoek lang duurt. Soms is dat acceptabel, bijvoorbeeld omdat de klant direct het resultaat nodig heeft. Maar als het blijft hangen zonder feedback, gaan dingen mis. Verzoeken kunnen worden afgebroken door de browser, een wegvallende verbinding of een tussenliggende proxy die een maximumtijd hanteert. Je weet dan niet: liep het nog, is het af, moet je opnieuw beginnen? Het werk aan de serverkant kan gewoon doorlopen of juist direct stoppen zonder dat de gebruiker het merkt.
Met een achtergrondtaak speel je dat anders. Je bevestigt direct dat de opdracht ontvangen is en geeft bijvoorbeeld een taaknummer terug. De gebruiker hoeft daarin niet te wachten en wordt later op de hoogte gebracht of kijkt zelf een status na. Je front-end moet daar wel op ingericht zijn: duidelijke meldingen, en alleen voortgang tonen als die betrouwbaar is vast te stellen. Een wild bewegende voortgangsbalk zonder echte betekenis doet vaak meer kwaad dan goed.
Denk niet dat een queue werk per se versnelt. Je haalt alleen het zware deel uit de wachttijd van de gebruiker. Door wachtrijen of zwaar belaste workers kan het resultaat juist trager binnenkomen. Wees scherp op het verschil tussen "opdracht in behandeling" en "werk afgerond", zeker als je een API uitwerkt.
Wanneer een achtergrondtaak en job queue passend zijn
Een job queue is handig als een klus niet hoeft te gebeuren terwijl de gebruiker staat te wachten en je die los kunt uitvoeren. Bijvoorbeeld: grote uploads verwerken, exportbestanden genereren, bulkberichten versturen of synchronisatie met een externe partij. Je applicatie zet dan een taak op de queue en een worker pakt het later op. Het webproces is dan klaar zodra het verzoek ontvangen is, niet pas als het resultaat bekend is.
Niet elke langzame actie hoort in een queue. Moet je iets weten voordat de gebruiker verder kan klikken? Dan voegt een achtergrondtaak alleen maar extra gedoe toe. Koppel je meerdere handelingen waar de uitkomst van de één het begin van een volgende bepaalt, dan vraagt dat om slimme orkestratie. Soms is een mix handig: een kleine validatie direct verwerken, daarna overdracht naar de queue voor het zware werk. Voor zulke processen kan automatisering met API-koppelingen passend zijn.
Stel jezelf de vraag: als de verbinding wegvalt, is het dan logisch dat het werk alsnog doorgaat? Kan iemand het resultaat later ophalen of opnieuw aanmaken zonder problemen? Zijn die antwoorden lastig, kijk dan eerst kritisch naar de procesinrichting in plaats van meteen een wachtrij toe te voegen.
Taakstatus ontwerpen voor API en gebruikersinterface
Voer je werk uit via een queue, dan betekent "geaccepteerd" niet meer automatisch "afgerond". Je API geeft direct een bevestiging met een taaknummer en vaak een status zoals 'in wachtrij'. Dat nummer gebruik je om later de status op te vragen, bijvoorbeeld via een endpoint of met een automatische melding. De HTTP 202-status betekent dat een verzoek is geaccepteerd voor verwerking, maar nog niet is afgerond. Het is zaak om glashelder te zijn over wat de statussen betekenen; als je daar onduidelijk over bent, denkt een client bij "geaccepteerd" soms dat het werk al gedaan is.
Je statusmodel heeft stadia als wachten, bezig, geslaagd en mislukt. Misschien komen annuleren of blokkeren er ook bij, afhankelijk van je processen. Beschrijf duidelijk wanneer een status verandert en wat er na afloop zichtbaar blijft. Lever bij een fout technische details aan beheer, maar laat aan de eindgebruiker een begrijpelijke melding zien zonder bijvoorbeeld stacktraces.
Polling (regelmatig status opvragen) werkt redelijk eenvoudig, maar zorgt wel voor extra verkeer en moet een goede frequentie hebben. Webhooks of server push zijn efficiënter, maar leveren weer eigen uitdagingen: meldingen kunnen gemist of dubbel ontvangen worden. Zorg er altijd voor dat de statusinformatie genoeg bewaard blijft voor client én beheer, maar laat oude taken uiteindelijk opruimen. Lees ook over de afweging tussen webhooks of pollen.
Wachtrijsemantiek: dubbele uitvoering en idempotentie
Zet je werk in een queue? Weet dan dat niet elk systeem garandeert dat een taak exact één keer wordt uitgevoerd. Stel: de worker doet het werk en valt om voordat het resultaat geregistreerd is, dan kan de taak gewoon opnieuw worden opgepakt. Ook een gebruiker die niet ziet of een verzoek lukt, stuurt soms dubbel in. Ontwerp dus op basis van mogelijke dubbele uitvoer, tenzij je zeker weet dat je volledige stack écht iets anders belooft. De documentatie over RabbitMQ-bevestigingen en herlevering beschrijft hoe berichten opnieuw kunnen worden aangeboden.
Idempotentie betekent dat iets herhaald kan worden zonder nieuwe bij-effecten. Stel je hebt een rapportage die steeds hetzelfde bestand overschrijft aan de hand van een rapport-ID, dat is meestal geen probleem. Lastiger wordt het bij betalingen of externe wijzigingen: daar moet je vaak met een unieke idempotentiesleutel werken, verwerken welke opdrachten er al zijn geweest en goed controleren wat de huidige status is voor je iets nogmaals doet. Interne database-transacties dekken niet automatisch herhaalde externe acties.
Denk ook aan het moment waarop een taak op de queue belandt. Eerst data schrijven en daarna de queue niet kunnen bereiken betekent dat het werk onvolledig in het systeem staat. Doe je die volgorde andersom, dan kan het proces al starten zonder dat de data klaar staan. Een transactionele outbox (data en taak samen wegschrijven) beperkt dat soort gaten, maar voegt complexiteit toe. Je legt hiermee de overgang van datalaag naar queue expliciet vast.
Retries, mislukte taken en dead-letter queues
Sommige fouten zijn tijdelijk (denk aan een korte netwerkstoring), andere structureel (zoals verkeerde invoer). Als je niet goed onderscheid maakt, kan een worker taken blijven herhalen zonder dat het ooit goedkomt. Markeer daarom taken als tijdelijk of definitief fout waar dat kan. Tijdelijke fouten kun je een paar keer opnieuw proberen met bijvoorbeeld oplopende wachttijden, definitieve fouten stoppen direct bij een errorstatus. De Celery-documentatie over retries beschrijft onder meer limieten en oplopende wachttijden.
Wees voorzichtig: bulk retries op hetzelfde moment zorgen voor piekbelasting of verstoren externe systemen. Met spreiding of een maximum aan pogingen beperk je dat. Niet alle taken kun je veilig herhalen. Zonder idempotentie loop je het risico dat berichten dubbel worden gestuurd of acties meerdere keren op een externe dienst terechtkomen.
Haalt een taak de retrylimiet, dan kun je die doorzetten naar een dead-letter queue of vergelijkbare foutopslagplek. Maar daar mag je het niet laten liggen. Taken moeten traceerbaar zijn, beheerders moeten weten waarom iets is misgegaan en taken moeten opnieuw uitvoerbaar blijven zodra het probleem verholpen is. Sla geen persoonlijke gegevens op in foutberichten en kijk uit met herstarten: voorkom dat je onbedoeld in één keer een bulk oude fouten opnieuw activeert. Leg vast wie controleert en welke context nodig is voor veilig herstel. Lees ook over logging en foutafhandeling bij automatiseringen.
Worker-capaciteit, wachtrijgroei en terugdruk
Met een queue koppel je instroom en verwerking van opdrachten los. Korte pieken vang je zo op, maar als de werkdruk structureel te hoog is, groeit de queue langzaam vol. Dat de queue leeg lijkt, zegt weinig zonder te kijken naar de oudste taak, de afhandelingssnelheid en hoeveel opdrachten mislukken.
Extra workers kunnen soms de doorvoer verhogen, maar niet als de database of externe diensten daar niet in meegaan. Bij bijvoorbeeld veel gelijktijdige exporttaken kun je tegen limieten aanlopen en zelfs méér fouten krijgen door te veel parallelliteit. Geef daarom elk soort werk z’n eigen limieten en eventueel aparte queues, zodat niet één zware opdracht de rest ophoudt.
Terugdruk (throttling) is de manier om te voorkomen dat systemen overbelast raken. Blijft er werk binnenkomen terwijl de capaciteit vol zit, dan kun je nieuwe opdrachten weigeren, lagere prioriteit geven of laten wachten. Laat nooit een queue onbegrensd groeien: opslag en monitoring lopen vast en herstel wordt bijna onmogelijk. Met prioriteiten moet je opletten: blijven er alleen hoge prioriteitsopdrachten binnenkomen, dan raken andere nooit aan de beurt. Houd dus niet alleen het totaal bij, maar ook de spreiding en wachttijden per type taak.
Langlopende taken, voortgang en veilige uitvoering
Taken die lang duren, van minuten tot uren, vragen om iets anders dan gewone background jobs. Het is weinig verstandig een worker onbeperkt aan zo'n taak te binden: servers kunnen rebooten, een proces kan crashen of tijdens onderhoud gestopt worden. Breek waar het kan werk op in kleinere stukken. Sla tussenresultaten duidelijk op en noteer welke stappen al klaar zijn, zodat je niet alles opnieuw hoeft te doen bij een onderbreking.
Voortgang laat zich alleen goed tonen als je weet wat er nog moet gebeuren. Een export met duizend regels is makkelijk bij te houden; een taak waarvan de omvang pas tijdens het uitvoeren blijkt, levert meestal een grove inschatting op. Beter om "bezig" te melden dan een percentage dat nergens op slaat. Houd rekening met kleine vertragingen; statusopslag loopt soms net achter op wat de worker doet.
Annuleren? Dat is geen magische stopknop. Je worker moet daar bewust op letten, meestal aan het eind van een stap. Externe API-calls laten zich zelden halverwege afbreken. Wees dus duidelijk: wat gebeurt er met al verwerkte data als iemand annuleert? Baken de rechten van workers af tot wat echt nodig is. Grote payloads zijn gebruikelijk bij lange taken; als een eenvoudige verwijzing volstaat, sla dan geen volledige blobs in de queue op.
Veelgestelde vragen
Welke gegevens moet ik in een job queue-bericht opnemen?
Plaats vooral stabiele identificatievelden in het queue-bericht en haal tijdens de verwerking de actuele gegevens op. Een order-ID werkt meestal beter dan een volledige orderkopie, want die laatste kan verouderen en zo houd je gevoelige informatie buiten de queue en eventuele logs.
- Zorg dat je taaktype en noodzakelijke ID's meestuurt.
- Vul alleen waarden aan die je niet elders betrouwbaar kunt ophalen.
- Leg vast hoe je omgaat met verwijderde of gewijzigde data als de taak later start.
- Voeg een berichtversie toe als het formaat kan veranderen.
Hoe kies ik tussen een databasewachtrij en een aparte message broker?
Kies voor een databasequeue als je taken klein en overzichtelijk zijn en simpel beheer wilt. Een message broker is handiger bij hogere volumes, als je meerdere systemen samen laat werken of als je specifieke routing en afhandelingsopties gebruikt. Wat technisch kan is één ding, wat je team stabiel kan beheren is minstens zo belangrijk.
- Kijk naar hoeveel berichten je verwacht en de pieken daarin.
- Begrijp wat een systeem aan garanties en beperkingen heeft.
- Denk goed na over beheer, logging, back-ups en herstel.
- Probeer met realistische tests in plaats van alleen capaciteit op papier te beoordelen.
Hoe test ik achtergrondtaken betrouwbaar in CI?
Test je background jobs in CI op verschillende lagen: de taak zelf én of de queue-integratie het bericht juist verwerkt. Unit-tests controleren de logica, maar zeggen niets over bijvoorbeeld workerconfiguratie of juiste berichtverwerking. Gebruik waar het kan dezelfde soort queue als in productie.
- Gebruik vaste tijden, gegevens en afhankelijkheden voor voorspelbare tests.
- Beoordeel niet alleen het resultaat maar ook de bijwerkingen.
- Test foutafhandeling en scenario's met verouderde data.
- Voorkom dat er oude berichten in een testqueue blijven hangen die uitkomsten beïnvloeden.
Hoe voorkom ik dat een deployment oude queue-taken breekt?
Je voorkomt problemen bij deployment door nieuwe workers tijdelijk berichten te laten verwerken die volgens het oude formaat zijn aangemaakt. Een queuebericht leeft langer dan een web request: een andere veldnaam of betekenis breekt zonder maatregelen direct oude taken.
- Maak veranderingen aan berichtformaten achterwaarts compatibel als het kan.
- Voeg velden optioneel toe, haal oude pas weg als je zeker weet dat alles is omgezet.
- Gebruik berichtversies als het anders te vaag wordt.
- Plan databaseaanpassingen zo dat oude én nieuwe workers naast elkaar kunnen draaien tijdens een uitrol.
Hoe beveilig ik een API waarmee gebruikers de status van achtergrondtaken bekijken?
Zorg bij een status-API dat bij elk verzoek gecontroleerd wordt of de ingelogde gebruiker toegang heeft tot de taak. Een taak-ID raden is vaak niet lastig genoeg. Zonder extra controle kan iemand zo bij de status of foutinfo van andermans taak.
- Koppel taken aan een gebruiker, organisatie of ander logisch domein.
- Check dit bij elk status- en resultaatverzoek.
- Toon aan gebruikers alleen foutinformatie die voor hen zinvol en veilig is.
- Zet limieten op het aantal verzoeken en log relevante toegangspogingen.
Foto: Jonathan David