De keuze tussen een monoliet en microservices bepaalt meer dan hoe code is ingedeeld: ze beïnvloedt releases, gegevensbeheer, foutafhandeling en samenwerking tussen teams. Lees welke afwegingen daarbij spelen en waarom een opgesplitste architectuur niet vanzelf eenvoudiger te schalen of te onderhouden is.
Deployment bij een monoliet en bij microservices
In een monoliet bouw je onderdelen veelal samen en zet je die als één pakket in productie. Een wijziging in een kleine functie leidt dan vaak toch tot een release van de hele applicatie, zelfs als elders niets is aangepast. Dat betekent: goed opletten bij regressietesten en een releaseproces dat de samenhang begrijpt. Maar het deploymentpad blijft overzichtelijk. Eén artefact, weinig omgevingscomponenten, en alles tegelijk uitrollen.
Heb je microservices? Dan kun je onderdelen los van elkaar deployen, maar alleen wanneer die technische en organisatorische onafhankelijkheid echt bestaat. Elke service vraagt haar eigen build, configuratie en monitoring. En releases van verschillende versies moeten tegelijk kunnen draaien zonder storing. Dus wordt het letten op compatibele API-wijzigingen, experimenteren met feature flags en kiezen voor beheerste uitrolstrategieën als canary releases belangrijk.
Mensen verwarren het aantal services soms met deploymentvrijheid. Maar als je alles handmatig tegelijk moet bijwerken, bestaat de vrijheid vooral op papier. Kijk liever of een team een wijziging zelfstandig kan uitrollen zonder op een ander te wachten. Zelf software laten ontwikkelen? Lees over een freelance developer.
Gegevensbeheer en consistentie tussen services
Een monolithische applicatie stopt gewoonlijk meerdere domeinen samen in één database. Daardoor zijn transacties over modulegrenzen heen eenvoudig uit te voeren en laten integriteitsregels zich afdwingen. Tegelijk raken modules snel vervlochten als ze onderling elkaars tabellen gebruiken. Aanpassingen in het datamodel kunnen daardoor onverwacht effect hebben, zelfs waar het niet de bedoeling was.
Bij microservices hoort de data toe aan een service zelf. Andere services vragen gegevens via een API op of luisteren naar gepubliceerde gebeurtenissen. Hierdoor raak je minder verstikt in koppelingen, maar wordt data management ook lastiger. Waar je eerst één consistente transactie had, bestaat dat proces nu uit meerdere losse stappen. Fout in stap twee? Dan zijn compenserende acties, hernieuwde pogingen of expliciete statussen nodig; anders kun je niet herstellen. Werk je aan automatisering met API-koppelingen, dan spelen deze keuzes ook mee. De keuze tussen berichten en periodiek ophalen hangt samen met webhooks of pollen.
Hierdoor ontstaat vaak eventual consistency. Overal direct bijgewerkte data kan je niet garanderen. Dus is het zaak dat gebruikersschermen en rapportages met verouderde of vertraagde status overweg kunnen. Elke service een eigen database geven voorkomt geen fouten of inconsistentie. Spreek daarom expliciet af wie welke bron beheert en herken vertragingen, dubs of rare volgordes in binnenkomende berichten.
Foutisolatie en storingen die zich verspreiden
Een monoliet draait meestal als één proces, of meerdere keer precies hetzelfde. Een fout in één onderdeel kan zo alle resources opslokken. Bijvoorbeeld door een memory leak, een hangende query of meer verkeer dan verwacht. Toch blijft het volgen van interne aanroepen makkelijker dan via het netwerk; je krijgt geen netwerkfouten, geen time-outs, geen problemen met service discovery erbij.
Microservices brengen scheidslijnen aan. Daarbinnen kun je fouten isoleren, als de architectuur en de runtime daarvoor zijn ingericht. Maar simpelweg code splitsen is niet genoeg. Een service die wacht op iets traags blokkeert namelijk snel haar eigen resources en kan zo weer andere services ophouden. Synchronous chaining maakt dat erger. Daarom: gebruik time-outs, circuit breakers, limieten op wachtrijen en zorg dat elk component zijn eigen grenzen kent. Elke bescherming heeft consequenties (soms is de functionaliteit tijdelijk niet bereikbaar).
Foutisolatie vraagt daarnaast om goede diagnose. Je moet kunnen zien of er een probleem is in de eigen service of juist in wat er achter hangt. Duidelijke logging, relevante metrics en trace-informatie zijn daarvoor onmisbaar. Zonder die context wordt het vinden van oorzaken in een verzameling services snel lastiger dan bij een monoliet.
Schaalbaarheid per onderdeel en de kosten van distributie
Microservices staan vooral bekend om het afzonderlijk kunnen opschalen van losse stukken. Dit is handig zodra je bijvoorbeeld een zoekcomponent hebt met sterk wisselende belasting. Die geef je dan meer instanties zonder dat je de rest meetrekt. Maar het werkt alleen bij inzicht in resources, drukte per service en hoe afhankelijkheden precies lopen. Anders schaal je misschien het verkeerde onderdeel op of los je een bottleneck niet op.
Een monoliet kun je ook horizontaal schalen door extra instanties te starten. Dat voldoet vaak prima, zolang je geen data of sessies koppelt aan specifieke servers. Soms is niet de applicatie, maar juist de database je beperking. Door in services te knippen wordt die niet per se opgelost. Sterker: een netwerk vol services kan de database extra belasten door meer verzoeken of herhaalde queries vanuit verschillende hoeken.
Extra netwerkverkeer, discovery, securitymaatregelen en resourceverbruik komen allen kijken bij microservices. Je moet dus de voordelen afzetten tegen deze nieuwe operationele kosten. Pas als verschillende domeinen écht andere eisen hebben aan schaal, beschikbaarheid en uitroltempo, kan verdelen in services echt effect opleveren.
Onderhoudbaarheid en de operationele oppervlakte
Een monoliet kan intern sterk zijn opgedeeld, zelfs al draait alles samen uit. Met strikte modules, duidelijke afhankelijkheden en expliciete interfaces voorkom je dat elke wijziging steeds alles raakt. Dan blijft netwerkinfrastructuur overbodig, zolang je binnen de grenzen blijft. Zonder die discipline groeit een monoliet uit tot een systeem dat elk team met elk domein laat interfereren.
Bij microservices verschuift een deel van de complexiteit naar alles daaromheen. Je bouwt, rolt uit, beveiligt en monitort niet alleen code, maar ook alle omgevingen eromheen. Denk aan API-versies, secrets management, dashboards, procedure bij incidenten en je lokale ontwikkelsetup. Zelfs minimale services voeden het beheer; een eigen build pipeline en runtime zijn soms al genoeg.
Testen verandert ook. In een monoliet kun je meerdere modules ineens toetsen met integratietests, al duurt zo’n testreeks vaak wel langer. Bij services heb je behoefte aan contracttests voor de beloftes tussen afnemers en leveranciers, maar die vangen niet alles af. Lokaal kun je alles correct krijgen, terwijl je toch faalt op versieverschillen, externe configuratie of gedrag van een afhankelijk systeem. Of iets onderhoudbaar blijft, hangt vooral af van hoe makkelijk je een verandering van A naar productie brengt, niet alleen van de grootte per service.
Teamafhankelijkheden en eigenaarschap van services
De softwarestructuur bepaalt hoe teams elkaar in de weg zitten of juist ontlasten. Eén team kan een monoliet goed beheren als modules helder zijn afgescheiden. Met meer teams komen er sneller gedeelde code, conflicterende commits en afspraken nodig precies rond releases. Onduidelijk eigenaarschap maakt het lastig te weten wie een module mag aanpassen, wie incidenten meldt, wie kwaliteitsverantwoordelijk is.
Microservices schakelen dat soms om. Verschillende domeinen komen toe aan verschillende teams, die zelf mogen deployen. Dit werkt pas wanneer het team zo’n service volledig zelf kan beheren én wanneer de dienstgrens logisch aansluit op de business. Kom je voor elke gebruikersstap nog steeds bij vijf teams tegelijk uit, dan verandert er weinig aan je afhankelijkheden. Ook platformteams kunnen een hindernis zijn, wanneer ieder wijziging door hen moet.
Eigenaarschap is meer dan je naam op een overzicht. Het betekent zorg voor API-contracten, data-integriteit, security, performance en incidentrespons. Teams hebben gezamenlijke standaarden nodig voor logging, monitoring en uitrol, maar mogen juist intern techniek kiezen die past. Sla je door naar alles afdwingen, dan wordt het log en onbeweeglijk; laat je elk team alles zelf bepalen, dan verlies je grip en gezamenlijke kennis.
Wanneer een monoliet opsplitsen in microservices
Opsplitsen is zinvol wanneer je tegen concrete blokkades aanloopt: releases slibben dicht omdat alles elkaar raakt, onderdelen hebben duidelijk verschillende eisen, één functie vraagt om een andersoortige schaalaanpak. Of je hebt een domein dat zo helder is afgebakend dat het prima door één team zelfstandig kan worden beheerd en ontwikkeld. Zulke signalen wegen zwaarder dan algemene overtuigingen over architectuur; je merkt aan alles dat de oude indeling knelt.
Verhuis niet zomaar code. Maak eerst zichtbaar wie wat gebruikt: tabellen die door meerdere modules live aangepast worden, gedeelde libraries vol kernlogica of onuitgesproken transactiesomstandigheden. Haal je een service los uit zo'n wirwar zonder die afhankelijkheden op te lossen, dan wordt het lastig: je verplaatst koppelingen alleen maar van intern naar extern (API, events, gedeelde databases). De complexiteit verhuist simpelweg.
Begin klein. Zet een duidelijk functie eerst achter een interface, zodat productie en consument loskomen. Pas daarna kun je bepalen of het zinvol is zo’n service zelfstandig verder te delen. Dat vraagt om scherpe keuzes: wie beheert de data, wat gebeurt er bij fouten, hoe wil je uitrollen en wie is het aanspreekpunt? Zonder dit overzicht kan je intern beter je grenzen versterken, in plaats van te versnipperen. Bij bestaande PHP-applicaties kan een PHP developer helpen bij die afweging.
Observability en testen in een verdeeld systeem
In een monoliet kun je verzoeken vaak makkelijk volgen binnen één proces, al heb je daar ook logging en metrics nodig om gedrag in productie te vatten. In een microservicesysteem loopt een request dwars door meerdere processen en berichtenplatforms heen. Correlatie-ID’s en distributed tracing zijn dan geen luxe meer, maar nodig om problemen te vinden. Logs moeten context tonen, bijvoorbeeld voor welk request een melding geldt, maar mogen daarbij geen gevoelige data loggen.
Metrics helpen om goed zicht te houden. Responstijden, foutpercentages, wachtrijen, aantal retries, dat soort cijfers geven aan waar het stokt. Maar: alleen servicebeschikbaarheid meten is niet genoeg. Er kan nog steeds een gebroken keten zijn terwijl elk component op zich werkt. Dus koppel signalen op service- én businessprocesniveau. Alerts moeten aangeven waar het misgaat én welk symptoom je ziet.
De testaanpak hoort bij de architectuur. Unit- en moduletests dekken regels en gedrag lokaal, contracttests borgen dat afnemers en aanbieders elkaar blijven snappen en integratietests checken de combinatie. End-to-endtests blijven nodig, maar leggen snel teveel vast en missen bij veranderingen grip. Let bij asynchrone flows expliciet op dubbels, vertragingen en herhalingen. Test zo of je idempotent werkt en of je proactief herstelt na een gedeeltelijke storing. Zie ook logging en foutafhandeling bij automatiseringen.
Veelgestelde vragen
Wat is een modulaire monoliet en wanneer is die een goede keuze?
Een modulaire monoliet is één applicatie, opgebouwd uit losse modules met zo min mogelijk onderling contact. Je kiest hiervoor als je logisch wilt scheiden, maar nog geen dringende reden hebt om alles technisch apart te draaien. Je hoeft maar één keer te deployen en hebt geen last van netwerk- of beheercomplexiteit van microservices. Sterke modulegrenzen zijn hier direct nuttig en maken het later eenvoudiger om een deel eventueel los te trekken.
Kunnen een monoliet en microservices naast elkaar bestaan?
Ja, dat kan prima. Denk aan bestaande functionaliteit in een monoliet die je combineert met nieuwe, duidelijk omschreven delen als aparte service. Je noemt dat meestal een hybride architectuur. Spreek wel af wie data beheert en hoe je onderling praat, want zonder die discipline krijg je verwarring en extra afhankelijkheden. Bekijk bij elk onderdeel of de voorspelbare voordelen van los deployen en schaalbaarheid de extra beheerkosten rechtvaardigen, het hoeft niet alles via één mal.
Hoe migreer je een monoliet naar microservices zonder een big bang?
Je migreert stapsgewijs door voor één stuk functionaliteit tegelijk de verbinding losser te maken, terwijl het bestaande systeem blijft draaien. Leg eerst vast welke code, data en processen dat onderdeel raakt. Zet vervolgens een duidelijke interface neer, zodat je precies ziet welk verkeer naar waar gaat. Vergelijk het resultaat en zorg altijd voor een fallback. Verwijder pas oude code als de nieuwe route zich bewezen heeft.
Hoe bereken je de totale kosten van microservices?
Neem voor een realistisch kostenplaatje niet alleen infra mee, maar ook ontwikkeluren, beheer en afstemming in het dagelijks werk. Reken het aantal pipelines, runtimeomgevingen, monitorings- en beveiligingstools, afspraken met beheer, extra testwerk, incidenten en API-aanpassingen. Zet die lasten af tegen de winst of besparing: makkelijker releasen, minder knelpunten, preciezer gebruik van capaciteit. Baseer je waar mogelijk op cijfers uit je eigen praktijk en toets je aannames met een beperkte proefopstelling.
Hoe ontwikkel en test je microservices lokaal op een laptop?
Je werkt lokaal door een reproduceerbare setup aan te bieden waarin de benodigde services en hun afhankelijkheden makkelijk te starten zijn. Dat kan via containers, testdoubles voor externe systemen of gedeelde ontwikkelomgevingen; wat je kiest hangt af van resources en koppelingen tussen services. Documenteer je config en startcommando’s bij de code en gebruik alleen veilige testdata. Lokaal test je vooral gedrag en contracten van je eigen service, terwijl geïntegreerde CI-omgevingen automatisch het hele samenspel toetsen.
Foto: Jan van der Wolf