Naar de inhoud
maarten.
Hoog opgestapelde blauwe zeecontainers in een haven onder een heldere blauwe lucht.
Alle stories

Serverless of containers: wat kies je?

Maarten Soetens 13 min lezen

Serverless functies en containers kunnen dezelfde web- of AI-dienst uitvoeren, maar verschillen in levenscyclus, schaalgedrag en beheer. Lees welke eigenschappen bepalend zijn voor de runtimekeuze en waar applicaties in de praktijk tegenaan lopen.

Hoe serverless functies en containers code uitvoeren

Je triggert een serverless functie via een gebeurtenis. Dat kan een HTTP-call zijn, een bericht uit een queue of een update in opslag. Het platform regelt alle infrastructuur daarachter. Je weet dus niet precies wanneer een uitvoeromgeving wordt gestart, gerecycled of afgesloten. Jouw code moet passen binnen wat de gekozen runtime toestaat, denk aan max looptijd, RAM en welke systeemcalls je krijgt. Serverless draait gewoon op servers, je hoeft ze alleen niet zelf te beheren.

Met een container pak je je complete app plus dependencies samen in een image. Vervolgens start een containerdienst je image als een loslopend proces. Dat kan een webserver zijn, een queue worker, of bijvoorbeeld een script dat ML-inferencing doet. Je bepaalt dan zelf hoe en wanneer je app start of afsluit, welke poort ze opent, hoe PID’s omgaan met shutdown. Ook containers draaien ergens op hardware. Alleen worden sommige beheerlagen (denk aan VM-provisie of node-upgrades) door de dienst geregeld, niet door jou.

De applicatievorm bepaalt de vrijheid

Een serverless functie werkt goed voor afgebakende logica, iets wat begint en eindigt. Een container is handig wanneer je proces altijd klaar moet staan of wanneer je speciale systeembibliotheken gebruikt, of als er veel eigen init gebeurt. Problemen tref je als je doorlopende serverapplicaties in serverless probeert te proppen, of omgekeerd kleine event-jobs volwaardig als container draait. Kijk dus eerst naar het gedrag van je app (event based, langlevend, memory-hongerig?) voordat je een cloudproduct kiest.

Voor een maatwerkwebsite hoort runtimekeuze bij websiteontwikkeling.

Schaalgedrag, koude starts en responsietijd

Serverless schalen gebeurt op basis van events of aanvragen. Komen er veel binnen, dan kan het platform extra omgevingen starten zonder dat jij dat van tevoren instelt. Fijn voor wisselende vraag, maar schalen kost soms wat tijd. Heb je even geen actieve instantie, dan moet het platform eerst iets klaarzetten: zo'n koude start geeft extra vertraging. Zeker bij grotere packages, zware dependencies of met init die traag is.

Containers schalen op ingestelde instanties of met signalen als CPU, RAM of simpele metrics over requests. Autoscaling kan, maar ook dan moet een nieuwe container gestart en de image geladen worden. Een altijd actieve container is rap bereikbaar, maar als je minimum instanties te laag staan, krijg je alsnog delays bij piek. Alles hangt samen met hoeveel resources je neerzet én hoe snel de app zelf start.

Meet pieken en staartlatentie

Gemiddeldes zeggen weinig als je gebruikers bij een piek moeten wachten. Meet naast het gewone gemiddelde ook percentielen als p95, p99. Kijk naar gedrag bij koelbloedige situaties én bij koude starts. In een serverless model: stel concurrency en minimumcapaciteit af op wat je qua latency en backend nog aankunt. Bij containers is het cruciaal te voorkomen dat autoscaling ineens veel verbindingen naar één backend dumpt. Soms schaal je frontend strak, maar backend houdt dat tempo niet bij.

Wanneer achtergrondtaken en langlopende processen containers vragen

Serverless functies zijn handig voor korte, losstaande taken. Bijvoorbeeld een enkel bericht verwerken of een validatie uitvoeren. Moet je langer werk doen? Check dan goed de limieten voor looptijd en resources, het platform stopt je functie anders voortijdig. Je kunt grote jobs opsplitsen in kleinere, maar dan moet je wel nadenken over checkpointing, retries en foutafhandeling. Simpel opsplitsen is zelden zonder bijeffecten.

Containers komen beter uit de verf voor processen die blijven wachten op nieuwe berichten, chatverbindingen openhouden of werk uitvoeren waarvan de looptijd lastig te voorspellen is. Je bouwt dan een worker die zelf ophaaltempo, graceful shutdown en eigen retrylogica regelt. Dat vraagt wel discipline. Als je worker crasht, wil je immers geen opdracht missen of tweemaal uitvoeren. Opvang van signals, time-outs en terugplaatsen op de queue vraagt aandacht.

Ontwerp verwerking als herhaalbare stap

Of je nu serverless of containers kiest: een bericht hoort veilig opnieuw verwerkt te kunnen worden. Denk aan idempotentie, bevestigen van verwerking pas na commit, en fouten afhandelen via een apart errorpad. Serverless geeft snel toegang tot event-gedreven verwerking, de semantiek verander je er niet mee. Containers geven meer controle over de loop, maar je moet signalen en resource-verbruik echt zelf regelen. Praktisch gezien: ontwerp eerst hoe het werk hoort te verlopen, kies dan pas een runtime.

Configuratie, afhankelijkheden en reproduceerbare runtimes

Een serverless functie zit meestal apart verpakt en je wijst platforminstellingen toe zoals runtime, variabelen, geheugen, time-outs en rechten. Omdat een functie klein hoort te zijn, lijkt het overzichtelijk. Bij veel functies kan dat versnipperen, zeker als je in platformhandlers knoeit of libraries in versiebeheer mist. Pas op dat verschillen tussen staging en productie niet onzichtbaar ontstaan.

In een container zet je alles vast in je image: app, libraries en vaak een deel van OS-packages. Dat helpt voor consistentie tussen dev, staging en productie, als tenminste config en externe dependencies gelijk blijven. Prima als je native libs gebruikt of speciale tools nodig hebt. Je moet wel opletten dat je image bijhoudt: updates in je base layer en een goede strategie voor het beheer van secrets worden nu jouw verantwoordelijkheid. Zorg dat secrets niet in je image eindigen. Denk aan lekken via logs of per ongeluk gebouwde images. De image bundelt de bestanden, libraries en configuratie die nodig zijn om de container te draaien, zoals beschreven in de Docker-documentatie over containerimages.

Maak platformconfiguratie onderdeel van de code

Houd settings in je broncode of in versieerbare config, liefst onafhankelijk van runtime-keuze. Documenteer verplichte variabelen, geef aan wat per omgeving verschilt en maak duidelijk hoe defaults werken. Pin dependencies waar zinvol, check versies regelmatig. Bij serverless liggen verschillende brakke settings vaak verspreid over het platform, bij containers gebeurt het in images en startcommando's. Je omgeving is pas reproduceerbaar als je ziet wat er draait plus in welke context.

Ook bij PHP-ontwikkeling is de runtimekeuze relevant.

Serverless en containers voor AI-inferentie

Wil je simpele AI-inferencing doen? Dan kan een serverless functie het verzoek prima valideren en doorsturen naar een modelendpoint. Ook lichte modellen met beperkte init, zoals fastText of kleine embeddings, laten zich hier goed in passen. Het plaatje verandert bij modellen die veel geheugen gebruiken of die elke keer gewichten opnieuw moeten laden (bijvoorbeeld bij BERT-varianten). Dan beïnvloedt koude start je latency te sterk, een functie loodst dat niet netjes af.

In een container beheer je precies welke frameworks je draait, welke modelbestanden er klaar staan, welke libs nodig zijn en of je GPU-inzet toepast. Je modelserver in container laadt zijn model één keer en verwerkt daarna meerdere requests, batched of parallel, en houdt RAM vast. Zorg dan wel dat de concurrency niet je resources uitput. Laden van grote modellen bij elke start is een risico; een modelregistry en vaste versies plus readiness checks helpen om downtime en halve initialisaties te voorkomen.

Scheid inference van voorbereidende stappen

Een AI-pijplijn bestaat vaak uit kortdurende validatie, inference die even duurt en nabewerking. Die segmenten hoeven niet per se in dezelfde runtime. Je kunt bijvoorbeeld validatie en authenticatie vlot als functie doen en het zware inferencestuk als worker onderbrengen in containers. Bepaal per taak hoeveel hardware, laadtijd en requestvolume nodig is. Hou rekening met client- en gateway-timeouts: een model dat technisch werkt maar te laat antwoordt, is onbruikbaar. Wil je streamende responsen? Dan heb je een runtime nodig die dat netwerkpad ondersteunt en verbindingen lang open kan houden. Voor automatiseren met AI speelt diezelfde scheiding tussen korte taken en inference. Lees ook over AI-agents.

Netwerkverbindingen, status en toegang tot data

Serverless functies leven kort. Je kunt niet uitgaan van bewaarde status tussen invocations. Tijdelijke files beoefenen risico, want je weet nooit wanneer een omgeving stopt of wordt vervangen. Houd daarom sessies, voortgang en resultaten altijd extern: zet ze veilig in een database, objectstore of cache. Het is makkelijker te vervangen, maar extra netwerkafhankelijkheden zijn onvermijdelijk. Open geen verbindingen zonder tijdslimiet, en stel retries bewust in.

In containers mag je de lokale schijf en cache gebruiken zolang een specifieke instantie draait. Maar die data deel je niet vanzelf tussen instanties. Een restart of herschaling kán lokale data doen verdwijnen. Bij langdurige processes in containers moet je oppassen dat databaseverbindingen niet opstapelen. Start een autoscaler veel instanties tegelijk, dan creëer je snel een storm van nieuwe connecties naar je data. Zonder per-instantie limiet raakt je database snel overbelast en verergert het probleem zichzelf.

Beperk toegang en verbindingsdruk

Geef functies en containers zo min mogelijk rechten op netwerk en data. Geef ieder zijn eigen identiteit, minimaliseer publieke endpoints en werk met managed secrets rotation. Zet per connectie tijdslimieten, bepaal wat je wilt retryen en laat applicaties weten hoe ze omgaan met dienstuitval of lang uitblijvend antwoord. De keuze voor een runtime lost capaciteitsschaarste niet op, maar verandert wel de schaal en snelheid waarop verbindingen starten. Test je gedrag bij limits of glitches, niet alleen als alles lukt.

Logs, fouten en operationele zichtbaarheid per runtime

Bij serverless wordt elke run apart bijgehouden. Dat vergemakkelijkt fouten koppelen aan individuele events of requests. Maar je proces bestaat vaak uit een ketting van functies: zonder gedeelde correlatie-ID vind je lastig waar het spaak loopt. Logs horen context te geven, denk aan trace-ID, taak, maar geen privacygevoelige info of secrets. Houd metrics bij voor hoeveelheid errors, duur, time-outs, throttles. Daarmee signaleer je wanneer een functie zijn limieten nadert.

Bij containers schrijf je logs en metrics per proces of container. Dit helpt met debugging van geheugenlekken, herstarts en resourceproblemen. Draait de dienst op schaal? Dan log je tientallen korte instanties. Lokaal loggen is zinloos, alles naar een centrale plek. Healthchecks verschillen: alleen een proces dat draait zegt weinig, readiness geeft aan of een instantie echt requests kan handelen. Een goede liveness-check herstart een vastloper, readiness voorkomt dat je requests naar een niet-af zijnde instantie stuurt. Kubernetes beschrijft hoe readiness- en liveness-probes het verkeer en herstarts beïnvloeden.

Maak foutafhandeling zichtbaar

Definieer wat succes is en meet ook dependency-mislukkingen. Een function die steeds hetzelfde bericht probeert blokkeert de queue; een containerworker kan ongemerkt achterlopen zonder crashen. Monitor queue-lengte, oudste bericht, restarts naast gewone HTTP-metrics. Tracing maakt koppelingen tussen gateway, functie en worker inzichtelijk. Serverless vraagt focus op runtime-limieten en throttling, containers voeg daar instantiestatus en resourcegebruik aan toe. Bied zicht op incidenten en rapport aan als signalen afwijkend zijn; het model verschilt maar de principes zijn gelijk.

Een runtime kiezen op basis van applicatiegedrag

Je komt verder in je keuze als je een applicatie opdeelt in concrete taken. Een stateless endpoint voor losse, onregelmatige verzoeken werkt vaak vlot met serverless. Heb je een API met langdurige verbindingen, zware init of custom procestopologie? Dan is een container geschikter. Bij AI-diensten is het logisch je publieke verwerking los te trekken van je inference: validatie en aanvraagverwerking in het één, inferentie en modelbeheer in het ander.

Leg per component looptijd, piekconcurrentie, geheugenbeslag, opstartpad en externe dependencies vast. En niet te vergeten: wanneer is een fout acceptabel, kan iets veilig opnieuw, hoe verwerk je tijdelijke uitval? Met zulke gegevens zie je helder waar een runtime niet past. Blijft een functie tegen time-outs aanlopen, heroverweeg dan de indeling of runtime. Draait een container alleen af en toe, misschien is serverless daar dan beter.

Combineren vraagt om duidelijke grenzen

Een hybride aanpak werkt zolang je de grenzen scherp houdt: elk onderdeel een heldere taak, deployment, rechten en monitor. Voorkom dubbele logica tegelijk in functie en container. Stel heldere API’s en message contracts op, voer settings centraal aan en wijs incidentverantwoordelijkheid. Kies de oplossing na productieachtige tests op schaal en met fouten, niet alleen na lokale proof. Daarmee kom je erachter of latency, scaling en beheer ook in de praktijk passen bij je ontwerp.

Veelgestelde vragen

Hoe vergelijk je de totale kosten van serverless en containers?

Je vergelijkt de kosten het best over een realistisch gebruikspatroon, niet alleen via de prijs per invocation of container. Serverless is afhankelijk van aantallen calls, looptijd en geheugeninstelling. Bij containers speelt doorlooptijd per draaiende instantie en de gekozen resource-allocatie een rol. Kijk verder dan alleen de factuurregels van de runtime:

  • Kosten van dataoverdracht, netwerk en opslag.
  • Kosten voor monitoring, logging, of platformopties met prijskaartje.
  • Tijd en geld die je kwijt bent aan beheer, upgrades, incidentresponse, capaciteitsplanning.

Test en meet voor verschillende scenario’s: stil, normaal en bij piek. Zo krijg je zicht op hoe keuzes uitpakken als je patroon verandert.

Hoe voorkom je dat serverless-code moeilijk naar containers te verplaatsen is?

Dat los je op door je core-logica los te trekken van platformhandlers en infrastructuurspecifieke details. Een overstap is bijna nooit copy-paste, maar heldere grenzen helpen bij de overgang. Let hier specifiek op tijdens het bouwen:

  • Werk altijd met expliciete input- en outputvormen, geen verborgen platformvars.
  • Configuratie zet je buiten de code, afhankelijkheden maak je traceerbaar.
  • Scheid adapters voor events, fileopslag en identity af van de logica die je wilt meenemen.
  • Bouw tests die niet afhankelijk zijn van de cloudruntime, maar van gedrag van je code.

Check na migratie of time-outs, foutafhandeling en eventsemantiek blijven kloppen. Portabiliteit vraagt om bewuste architectuur en blijft begrensd door welke platform-diensten je gebruikt.

Hoe test je serverless functies en containers lokaal voordat je ze uitrolt?

Begin met lokale tests van je eigen logica. Daarna integreer je met de doelruntime en externe dependencies. Unit-tests vangen bugs vroeg, maar zeggen niks over issues met platformsettings of productiegedrag. Goede testaanpak werkt in laagjes:

  • Stuur representatieve events naar je functie en check alle uitkomsten: goed, fout, randgevallen.
  • Draai je container lokaal op dezelfde image en config als straks in productie.
  • Test de koppeling met externe diensten, zoals databases en queuing.
  • Draai eindtests (acceptatietest) in een geisoleerde cloudomgeving waar de live settings gelden.

Emulators zijn handig, maar testen in echte cloud is onmisbaar voor platform-specifiek gedrag.

Hoe rol je een nieuwe versie van een serverless functie of container veilig terug?

Maak rollback mogelijk door releases traceerbaar en immutable te houden en vooraf te bedenken hoe je verkeer terugleidt naar een vorige versie. Zorg dat database en eventformats tijdelijk door beide versies worden begrepen. Neem bijvoorbeeld deze checks op in je releaseproces:

  • Sla de gebruikte image, functieversie en relevante config direct bij de release op.
  • Schakel verkeer stapsgewijs om, hou errors, latency en je businessmetrics in de gaten.
  • Leg vast wie of wat een rollback triggert en wanneer.
  • Test rollbackprocedure vooraf inclusief eventuele datamigraties; alleen terug naar oude code is vaak niet genoeg.

Een rollback werkt alleen als alle afhankelijkheden tolerant zijn voor die tijdelijke overlap.

Welke kosten en risico's brengt serverless of containers met zich mee bij piekverkeer?

Bij piekverkeer kun je bij beide modellen verrast worden door extra kosten en operationele problemen, dus stel duidelijke grenzen in en test je hele keten op doorschieten. Groeit het aantal invocations of containers heel snel, dan kun je afhankelijkheden zoals databases overbelasten. Cloud-limieten kunnen dan verzoeken afremmen of weigeren. Leg dit vast in je piekscenario:

  • Stel alerts en limieten in voor budget en resource-gebruik.
  • Test reacties van je app als backend of queues volraken.
  • Bedenk vooraf welke requests eventueel vertraagd, geweigerd of herhaald mogen worden.
  • Check of een piek niet onverwacht veel netwerk-, opslag- of logkosten veroorzaakt.

Een belastingstest mét echte afhankelijkheden zegt meer over de risico’s en kosten dan een snelle local-only check.

Foto: Jan van der Wolf

Portret van Maarten

Maarten

Freelance developer in Nijmegen

Even kennismaken?

Vertel kort wat er speelt. Dan hoor je wat er kan, wat ik anders zou doen en waar AI bij jou wél en niet iets toevoegt. Vrijblijvend.

Het kantoor in Nijmegen
© 2026 maarten.online Sitemap Privacy Algemene voorwaarden
Het kantoor in Nijmegen

Maarten.

Freelance developer in Nijmegen. Liever direct contact? Dat kan ook.

Kennismaken

Laat je gegevens achter, dan kijken we of het klikt. Vrijblijvend en zonder verkooppraat.

Maarten

Stuur een bericht via WhatsApp

Hoi! Waar kan ik je mee helpen?

nu