De laatste jaren lees je van alles over microservices en over het algemeen wordt dat dan afgezet als oplossing voor al die oude monolieten die we hebben gemaakt. Want de monoliet is natuurlijk kwaadaardig. Tegelijk is de microservice zeker niet de oplossing voor alles, en laten we wel zijn… dat we van onze monoliet vaak een rommeltje hebben gemaakt, betekent nog niet dat alle monolieten slecht zijn. En eerlijk gezegd, als ik met mijn team een rommeltje heb gemaakt van mijn monoliet, wat geeft me dan de overtuiging dat ik het met microservices wel goed zou doen.

In de praktijk zijn veel teams en applicaties misschien beter gediend door hun monoliet beter en modulair op te zetten.

Wat is een modulaire monoliet?

Een modulaire monoliet is een software-architectuur waarbij een applicatie als één geheel wordt ontwikkeld en gedeployed, maar intern is opgedeeld in goed gescheiden modules. Elke module heeft een duidelijke verantwoordelijkheid en is zoveel mogelijk onafhankelijk van de andere modules. Dit betekent dat je de voordelen van een monoliet behoudt (zoals eenvoud in deployment en minder operationele overhead), maar tegelijkertijd profiteert van een betere structuur en onderhoudbaarheid binnen de applicatie.

In tegenstelling tot een klassieke monoliet, waar alle functionaliteit door elkaar heen loopt, zijn de modules in een modulaire monoliet strikt gescheiden. Ze communiceren via goed gedefinieerde interfaces en zijn vaak gebaseerd op domeinen of business capabilities. Dit maakt het mogelijk om teams verantwoordelijk te maken voor specifieke modules en om delen van de applicatie onafhankelijk te ontwikkelen en testen.

Kenmerken van een modulaire monoliet

  • Eén deployment unit: De applicatie wordt als één geheel uitgerold, in tegenstelling tot microservices die elk apart worden gedeployed.
  • Strikte modulegrenzen: Functionaliteit is opgesplitst in modules met duidelijke grenzen en verantwoordelijkheden.
  • Interne modulariteit: Modules zijn losjes gekoppeld en communiceren via interfaces, maar draaien binnen hetzelfde proces en delen vaak dezelfde database.
  • Betere onderhoudbaarheid: Door de modulaire opzet is het eenvoudiger om nieuwe functionaliteit toe te voegen, bugs te verhelpen en de codebase te begrijpen.
  • Makkelijker te testen: Modules kunnen afzonderlijk getest worden, wat de kwaliteit van de software ten goede komt.

Wanneer kies je voor een modulaire monoliet?

Een modulaire monoliet is vooral geschikt voor applicaties die:

  • Nog niet de schaal of complexiteit hebben die microservices rechtvaardigt.
  • Door één of enkele teams worden beheerd.
  • Wel behoefte hebben aan duidelijke scheiding van verantwoordelijkheden en domeinen.
  • Snel willen kunnen ontwikkelen en uitrollen, zonder de operationele complexiteit van microservices.

Het is ook een goede keuze als je wilt voorkomen dat je te vroeg overstapt naar microservices, met alle extra complexiteit van distributed systems, service discovery, monitoring en security van dien. Een modulaire monoliet kan bovendien dienen als een solide basis om later (gefaseerd) delen van de applicatie om te zetten naar microservices, mocht dat nodig zijn.

Verschil met microservices

Het belangrijkste verschil met microservices is dat een modulaire monoliet één applicatie blijft, terwijl microservices uit meerdere, zelfstandig te deployen services bestaan. Microservices bieden maximale onafhankelijkheid en schaalbaarheid per service, maar brengen ook veel extra complexiteit met zich mee (denk aan netwerkcommunicatie, data-integriteit, monitoring, security, enzovoorts). Een modulaire monoliet biedt een middenweg: duidelijke interne structuur en scheiding, maar zonder de overhead van een gedistribueerd systeem.

Voordelen

  • Eenvoudige deployment en minder operationele overhead.
  • Betere code-organisatie en onderhoudbaarheid.
  • Snellere ontwikkeling en minder kans op “spaghetti code”.
  • Makkelijker te migreren naar microservices indien nodig.

Nadelen

  • Minder schaalbaar dan microservices als de applicatie extreem groot wordt.
  • Modules zijn niet volledig onafhankelijk te deployen.
  • Kan alsnog complex worden als modulegrenzen niet goed bewaakt worden.