In de wereld van softwareontwikkeling kun je al snel de indruk krijgen dat een moderne applicatie uit microservices moet bestaan. Een aparte service voor gebruikersbeheer, een aparte voor bestellingen, nog een voor betalingen en weer een andere voor meldingen. Elk onderdeel kan onafhankelijk worden ontwikkeld, apart worden uitgerold en worden opgeschaald wanneer dat echt nodig is.
Op een diagram ziet dat er perfect uit. De afzonderlijke onderdelen van het systeem hebben hun eigen taken, teams kunnen parallel werken en een storing in één service zou niet de hele applicatie moeten stilleggen.
Het probleem begint wanneer het diagram werkelijkheid wordt. In plaats van één applicatie beheert het team tientallen services, verschillende communicatiemechanismen, talrijke uitrolprocessen en extra logs, monitoring, toegangsrechten en configuraties. Voor een eenvoudige bedrijfsproces is communicatie tussen meerdere componenten nodig. Testen wordt moeilijker en om de oorzaak van een fout te vinden, moet de volledige stroom door het systeem worden gevolgd.
Betekent dit dat microservices een slechte oplossing zijn? Nee. Onder de juiste omstandigheden kunnen ze de manier waarop grote producten worden ontwikkeld aanzienlijk verbeteren. Ze zijn echter geen automatische fase in de volwassenwording van een applicatie en bieden geen garantie op betere schaalbaarheid.
Een goede architectuur is niet de architectuur met het grootste aantal services. Het is de architectuur waarmee je een product kunt ontwikkelen zonder de kosten, risico's en complexiteit onnodig te verhogen.
Daarom is het belangrijk om voordat je een beslissing neemt te begrijpen waarin een monoliet, een modulaire monoliet en microservices van elkaar verschillen, welke problemen ze oplossen en welke nieuwe verplichtingen ze met zich meebrengen.
Wat is een monoliet eigenlijk?
Een monoliet is een applicatie waarvan de belangrijkste onderdelen als één geheel worden ontwikkeld en uitgerold. De applicatie kan veel modules bevatten, verschillende bedrijfsprocessen ondersteunen en gebruikmaken van een uitgebreide interne architectuur. Het feit dat een systeem een monoliet is, betekent dus niet dat alle code in één bestand staat of dat de applicatie chaotisch is.
Een voorbeeld is een systeem voor de afhandeling van verkoop, klanten, producten, bestellingen, betalingen en rapportages. Al deze functies kunnen onderdeel zijn van één applicatie die een gedeelde database gebruikt en als één product wordt uitgerold.
Deze opzet heeft concrete voordelen. In veel gevallen is de applicatie eenvoudiger te starten, te testen en uit te rollen. Aanroepen tussen modules kunnen rechtstreeks binnen het applicatieproces plaatsvinden, zonder dat verzoeken via het netwerk hoeven te worden verstuurd. Transacties die meerdere onderdelen van het systeem omvatten, zijn eenvoudiger te realiseren wanneer ze een gedeelde database gebruiken.
Een monoliet kan ook het aantal infrastructuuronderdelen beperken dat beheerd moet worden. Het is niet nodig om voor elke kleine functie een apart uitrolproces, monitoring en communicatie in te richten.
Natuurlijk heeft een monoliet ook beperkingen. Als er jarenlang nieuwe functies worden toegevoegd zonder de afhankelijkheden te beheersen, wordt de code steeds moeilijker te begrijpen. Een wijziging op de ene plek kan problemen op een andere plek veroorzaken, en voor de uitrol van een kleine functie moet de hele applicatie worden getest en gepubliceerd.
Dat is echter geen onvermijdelijk kenmerk van een monoliet. Vaak zit het probleem niet in de manier waarop de applicatie wordt uitgerold, maar in de interne structuur ervan.
De ene monoliet is de andere niet
In discussies over architectuur worden alle monolithische applicaties vaak op één hoop gegooid. Toch bestaat er een belangrijk verschil tussen een systeem waarvan de modules duidelijke grenzen hebben en een applicatie waarin elk onderdeel naar believen naar andere onderdelen kan verwijzen.
In het eerste geval hebben we een geordende structuur. In het tweede kan een zogenaamde big ball of mud ontstaan: een systeem met onduidelijke grenzen, talrijke afhankelijkheden en logica die moeilijk te achterhalen is.
Stel je een verkoopapplicatie voor waarin de modules voor klanten, producten, bestellingen en betalingen elk hun eigen verantwoordelijkheid hebben. De bestellingsmodule gebruikt een specifieke interface van de klantenmodule, in plaats van willekeurige onderdelen van de interne implementatie ervan. Wijzigingen in het ene onderdeel zouden geen ongecontroleerde aanpassingen in het hele systeem moeten vereisen.
Als daarentegen elke module de gegevens van andere modules rechtstreeks wijzigt, hun interne klassen gebruikt en uitgaat van de details van hun werking, verliest de applicatie geleidelijk haar structuur.
Precies daar komt de modulaire monoliet in beeld.
De modulaire monoliet: een compromis dat het overwegen waard is
Een modulaire monoliet blijft één applicatie die als geheel wordt uitgerold, maar de binnenkant is verdeeld in duidelijk afgebakende modules. Elke module is verantwoordelijk voor een specifiek bedrijfsdomein, heeft duidelijk gedefinieerde grenzen en biedt andere delen van het systeem een gecontroleerde manier om samen te werken.
In de praktijk kan dat modules betekenen voor klanten, de productcatalogus, bestellingen, afrekeningen of meldingen. Elke module heeft zijn eigen logica en de toegang tot de interne mechanismen ervan is beperkt.
Het belangrijkste verschil is dat logische grenzen niet noodzakelijk infrastructuurgrenzen hoeven te zijn. Modules kunnen in de code goed van elkaar gescheiden zijn, terwijl de applicatie nog steeds als één geheel wordt uitgevoerd en uitgerold.
Dit model maakt het mogelijk verantwoordelijkheden te ordenen, afhankelijkheden te beperken en het systeem voor te bereiden op verdere ontwikkeling, zonder alle kosten van een gedistribueerde architectuur te introduceren.
Een modulaire monoliet kan bijzonder geschikt zijn wanneer:
-
één team of meerdere nauw samenwerkende teams het product ontwikkelen;
-
de bedrijfsgrenzen van het systeem nog vorm krijgen;
-
de meeste functies dezelfde gegevens gebruiken en de consistentie ervan moeten behouden;
-
de verschillende onderdelen niet onafhankelijk hoeven te worden opgeschaald;
-
het huidige uitrolproces goed genoeg werkt;
-
het bedrijf de mogelijkheid wil behouden om bepaalde modules later af te splitsen.
Dat laatste is bijzonder belangrijk. Beginnen met een modulaire monoliet hoeft de weg naar microservices niet af te sluiten. Als de modulegrenzen goed zijn ontworpen en de zakelijke behoeften veranderen, kan een specifiek onderdeel in de toekomst worden afgesplitst tot een aparte service.
Dit is echter geen automatische migratie met één klik. Je moet rekening houden met de manier waarop gegevens worden opgeslagen, met afhankelijkheden en transacties, met communicatie en met de verantwoordelijkheid voor het beheer van de nieuwe component. Een goede modulariteit kan dit proces echter aanzienlijk vereenvoudigen.
Microservices: wat leveren ze werkelijk op?
Een microservicesarchitectuur verdeelt een applicatie in kleinere services die specifieke bedrijfsfuncties uitvoeren en onafhankelijk kunnen worden ontwikkeld en uitgerold. De services communiceren met elkaar via gedefinieerde interfaces, vaak via API's, berichten of gebeurtenissen.
Daardoor kan het team één service aanpassen zonder de hele applicatie te hoeven uitrollen. Afzonderlijke componenten kunnen ook andere technologieën gebruiken of onafhankelijk worden geschaald, als hun belasting en vereisten daadwerkelijk verschillen.
Een e-commerceplatform kan bijvoorbeeld een afzonderlijke productzoekservice hebben, waarvan de belasting veel sneller toeneemt dan die van de module voor gebruikersaccountbeheer. In een microservicesarchitectuur kunnen de resources van de zoekservice worden uitgebreid zonder alle andere onderdelen van het systeem te hoeven schalen.
Een vergelijkbare situatie kan zich voordoen wanneer één productgebied bijzonder vaak moet worden uitgerold, een ander aparte beschikbaarheidseisen heeft en weer een ander door een onafhankelijk team wordt ontwikkeld.
Microservices kunnen dus op enkele concrete gebieden helpen:
Onafhankelijke implementaties. Een wijziging in één service hoeft niet te betekenen dat alle andere componenten ook moeten worden uitgebracht, zolang hun contracten compatibel blijven.
Onafhankelijk schalen. Alleen de services die het nodig hebben kunnen meer resources krijgen, in plaats van het hele systeem te schalen.
Afzonderlijke verantwoordelijkheden van teams. Teams kunnen specifieke productgebieden zelfstandig ontwikkelen, als de grenzen van hun verantwoordelijkheden daadwerkelijk goed zijn ontworpen.
Isolatie van bepaalde problemen. Een goed ontworpen service kan de impact van sommige storingen op de rest van het systeem beperken. Dat gebeurt echter niet automatisch. Als de overige componenten niet zonder een niet-beschikbare service kunnen werken, kan het probleem nog steeds een groot deel van de applicatie treffen.
Technologische flexibiliteit. Afzonderlijke services kunnen worden afgestemd op verschillende technische behoeften, al verhoogt het onderhouden van meerdere technologieën ook de kosten.
Het is goed om te beseffen dat geen van deze voordelen uitsluitend voortvloeit uit het aantal services. Ze vereisen passende architectuurgrenzen, automatisering, monitoring, een testproces en de juiste expertise binnen het team.
De prijs van het opsplitsen van een systeem: wat staat er niet op het diagram?
De grootste fout bij het plannen van microservices is om ze uitsluitend te vergelijken op basis van de codestructuur. Het opsplitsen van een applicatie verandert namelijk niet alleen de manier waarop deze wordt geïmplementeerd, maar ook de manier waarop deze wordt uitgevoerd, getest, uitgerold en problemen worden opgespoord.
In een monoliet kan een functie een andere functie aanroepen binnen hetzelfde proces. In een gedistribueerd systeem betekent samenwerking tussen services vaak netwerkcommunicatie, die vertraging kan oplopen, kan mislukken of op een onverwacht moment kan worden onderbroken.
Dat roept nieuwe vragen op. Wat moet je doen als service A een bewerking heeft uitgevoerd, maar service B geen antwoord heeft ontvangen? Zorgt het opnieuw versturen van het verzoek er niet voor dat dezelfde bewerking twee keer wordt uitgevoerd? Wat gebeurt er als een deel van een proces slaagt, maar de overige onderdelen de wijziging niet registreren?
Dit zijn geen zeldzame, theoretische problemen. In systemen voor betalingen, bestellingen, reserveringen of voorraadbeheer kunnen ze leiden tot daadwerkelijke zakelijke discrepanties.
Daar komen nog de onderhoudskosten bij:
-
meer componenten om te monitoren;
-
afzonderlijke configuraties en uitrolprocessen;
-
verzoeken volgen die door meerdere services lopen;
-
extra mechanismen voor communicatie en foutafhandeling;
-
integratie- en contracttests;
-
beheer van API-versies;
-
toegangscontrole tussen componenten;
-
meer potentiële storingspunten;
-
behoefte aan expertise op het gebied van gedistribueerde systemen.
Dat betekent niet dat microservices altijd duurder zijn gedurende hun volledige levenscyclus. In een voldoende groot systeem kunnen ze de coördinatiekosten verlagen en de ontwikkeling versnellen. De initiële operationele kosten zijn echter reëel en moeten worden meegewogen in de beslissing.
Als een bedrijf geen implementatieautomatisering, goede monitoring en procedures voor het reageren op storingen heeft, kan het opsplitsen van de applicatie de complexiteit sneller vergroten dan voordelen opleveren.
Wanneer beginnen microservices zinvol te worden?
Er is geen universeel aantal gebruikers, verzoeken of ontwikkelaars waarna je moet overstappen op microservices. De beslissing hangt af van het soort product, de belasting, de organisatiestructuur en de daadwerkelijke beperkingen van de huidige architectuur.
Er zijn echter situaties waarin het de moeite waard is om het opsplitsen van een deel van het systeem serieus te overwegen.
1. Verschillende gebieden hebben duidelijk verschillende belastingsprofielen.
Als één functie aanzienlijk meer rekenkracht vereist dan de andere, kan onafhankelijk schalen meetbare voordelen opleveren. Je moet echter eerst nagaan of het probleem niet met eenvoudigere methoden kan worden opgelost, bijvoorbeeld door query's te optimaliseren, een cache of taakwachtrij te gebruiken, of de resources van de hele applicatie uit te breiden.
2. Teams moeten verschillende gebieden onafhankelijk kunnen ontwikkelen.
In een grote organisatie kunnen een gedeelde codebase en één releaseproces het werk van veel teams bemoeilijken. Het afbakenen van verantwoordelijkheden kan de autonomie vergroten, mits de services stabiele grenzen en duidelijk gedefinieerde contracten hebben.
3. Verschillende functies hebben uiteenlopende beschikbaarheidseisen.
Sommige productgebieden moeten bijzonder goed bestand zijn tegen storingen, terwijl andere tijdelijk niet beschikbaar kunnen zijn zonder de belangrijkste processen stil te leggen. Onafhankelijke services maken het mogelijk om de strategie voor schaling, implementatie en herstel af te stemmen op een specifiek gebied.
4. Eén module vereist een andere technologie of verwerkingsmethode.
Soms stelt een specifieke taak gerechtvaardigde eisen waaraan in de hoofdapplicatie niet efficiënt kan worden voldaan. Door de taak af te splitsen, kan de impact van deze eisen op de rest van het product worden beperkt. Houd er echter rekening mee dat een extra technologiestack ook extra verantwoordelijkheid voor het onderhoud met zich meebrengt.
5. De zakelijke grenzen zijn al goed in kaart gebracht.
Als duidelijk is waar de verantwoordelijkheid van het ene gebied eindigt en die van het andere begint, is het eenvoudiger om onafhankelijke services te ontwerpen. Wanneer de grenzen onduidelijk zijn en vaak veranderen, kan het te vroeg vastleggen ervan leiden tot kostbare afhankelijkheden en voortdurende wijzigingen aan interfaces.
De belangrijkste regel luidt: splits een service af omdat deze een concreet probleem oplost, niet omdat een extra element op het diagram er modern uitziet.
Wanneer is een modulaire monoliet een betere keuze?
Een modulaire monoliet is vaak de betere keuze wanneer een bedrijf de applicatie wil structureren, maar er nog geen reden is om deze op te splitsen in meerdere onafhankelijke services.
Dit kan bijvoorbeeld het geval zijn bij een nieuw product waarvan het bedrijfsmodel nog in ontwikkeling is. In het begin is het moeilijk te voorspellen welke functies het zwaarst belast zullen worden, welke onafhankelijk moeten kunnen worden uitgerold en waar de grenzen van verantwoordelijkheden uiteindelijk zullen liggen.
Hetzelfde geldt voor een middelgroot bedrijfssysteem waarin de meeste bewerkingen betrekking hebben op gedeelde gegevens. De logica opsplitsen in meerdere services kan extra problemen met gegevensconsistentie en transacties veroorzaken, zonder daar voldoende onafhankelijkheid voor terug te krijgen.
Een modulaire monoliet is ook het overwegen waard wanneer een bedrijf beperkte operationele middelen heeft. Eén implementatieproces en een eenvoudiger monitoringmodel kunnen een verstandiger oplossing zijn dan het onderhouden van een tiental services, die elk hun eigen configuratie en procedures vereisen.
Het gaat er daarbij niet om alles zonder toekomstplan in één applicatie te laten staan. Een goed ontworpen modulaire monoliet vereist discipline: duidelijke modulegrenzen, gecontroleerde toegang tot gegevens en het beperken van onnodige afhankelijkheden.
Als deze principes worden nageleefd, kan het bedrijf profiteren van een eenvoudiger implementatiemodel en tegelijkertijd het systeem voorbereiden op het eventueel afzonderlijk onderbrengen van geselecteerde functies in de toekomst.
Schaalbaarheid draait niet alleen om het aantal servers
Een van de meest voorkomende argumenten voor microservices is schaalbaarheid. Het is echter goed om twee verschillende kwesties van elkaar te onderscheiden: technische schaalbaarheid en het vermogen van een organisatie om het product verder te ontwikkelen.
Technische schaalbaarheid betekent dat een systeem meer belasting kan verwerken. In veel gevallen kan een monolithische applicatie op meerdere instanties draaien, met load balancing, caching, taakwachtrijen en een goed ontworpen database. Zo'n systeem kan veel verkeer verwerken zonder dat het in tientallen services hoeft te worden opgesplitst.
Natuurlijk kan niet elke monoliet op elke gewenste manier worden geschaald. Problemen kunnen voortkomen uit het opslaan van status in het procesgeheugen, een gedeelde database, kostbare synchrone bewerkingen of beperkingen van een specifieke component. Toch is het verstandig om eerst vast te stellen wat daadwerkelijk het knelpunt vormt.
Organisatorische schaalbaarheid is een andere kwestie. Als veel teams aan een product werken en elkaar bij wijzigingen en implementaties regelmatig blokkeren, kan het verdelen van verantwoordelijkheden voordelen opleveren, zelfs wanneer de systeemprestaties toereikend zijn.
In de praktijk is het daarom verstandig om de beslissing op metingen te baseren. Heeft de applicatie prestatieproblemen? Duren implementaties te lang? Moeten teams elke wijziging met elkaar afstemmen? Heeft een specifieke functie andere middelen nodig? Hebben storingen in één module gevolgen voor de rest?
De antwoorden helpen om een architectuurprobleem te onderscheiden van een probleem met de infrastructuur, de codekwaliteit of de werkorganisatie.
Migratie naar microservices: waarom je niet alles in één keer moet opsplitsen
Als de huidige applicatie de productontwikkeling daadwerkelijk begint te belemmeren, hoeft een migratie naar microservices niet te betekenen dat het hele systeem in één keer wordt herschreven.
Een geleidelijke aanpak waarbij specifieke onderdelen worden afgesplitst, is vaak veiliger. Eerst moet worden vastgesteld welke module een voldoende duidelijk afgebakende verantwoordelijkheid heeft, welke gegevens deze verwerkt en hoe deze samenwerkt met de overige delen van de applicatie.
Vervolgens kan een communicatiegrens worden ontworpen, kunnen tests worden voorbereid en kan de verantwoordelijkheid geleidelijk naar de nieuwe service worden overgebracht. Zo kunnen aannames op een beperkt gebied worden getoetst voordat het bedrijf tot verdere wijzigingen besluit.
Een verkoopsysteem kan bijvoorbeeld aanvankelijk een module voor het genereren van rapporten bevatten, die de database zwaar belast en gebruikersbewerkingen vertraagt. In plaats van het hele systeem op te splitsen, kan eerst worden onderzocht of de rapportage naar een afzonderlijk proces of een aparte service kan worden verplaatst, eventueel met gebruik van gegevens die asynchroon worden voorbereid.
Zo'n afsplitsing is zinvol als deze de belasting van de hoofdapplicatie daadwerkelijk vermindert of het mogelijk maakt de rapportage onafhankelijk te ontwikkelen en te schalen. Als de rapporten echter eenvoudig zijn en de belasting gering is, kan een extra service overbodig zijn.
Daarom moet een migratie beginnen bij het probleem en het gewenste resultaat, niet bij de aanname dat alle modules uiteindelijk microservices moeten worden.
Het is ook belangrijk om te bedenken dat het afsplitsen van een service niet ophoudt bij het verplaatsen van de code. Er moeten oplossingen komen voor gegevens, communicatie, autorisatie, monitoring, implementaties, tests en verantwoordelijkheid voor storingen. Pas dan wordt de nieuwe component daadwerkelijk een onafhankelijk onderdeel van de architectuur.
Hoe neem je een beslissing? Een praktische vragenlijst
Voordat je een architectuur kiest, is het verstandig om een aantal vragen te beantwoorden. Ze vervangen geen technische analyse, maar helpen de beslissing te structureren.
1. Welk concreet probleem willen we oplossen? Gaat het om prestaties, de implementatietijd, afhankelijkheden tussen teams, beschikbaarheid of de moeilijkheid om de code te onderhouden? Als we het probleem niet kunnen benoemen, is het lastig te beoordelen of microservices de juiste oplossing zijn.
2. Is het probleem daadwerkelijk het gevolg van de architectuur? Een trage applicatie heeft misschien optimalisatie van query's nodig, terwijl moeilijke implementaties kunnen voortkomen uit een gebrek aan tests en automatisering. Een architectuurwijziging vervangt deze maatregelen niet.
3. Zijn de bedrijfsgrenzen duidelijk genoeg? Als modules voortdurend elkaars interne gegevens en regels gebruiken, kan het afsplitsen ervan tot onafhankelijke services een onjuiste indeling bestendigen.
4. Hebben we onafhankelijke schaalbaarheid of implementaties nodig? Als alle delen van het systeem op vergelijkbare wijze worden gewijzigd en belast, kan de winst van onafhankelijkheid gering zijn.
5. Hebben we de tools en vaardigheden om een gedistribueerd systeem te onderhouden? Monitoring, logs, het traceren van verzoeken, geautomatiseerde implementaties en procedures voor het afhandelen van storingen zijn belangrijke onderdelen van deze beslissing.
6. Hoe worden gegevens en transacties beheerd? Het afsplitsen van een service kan het moeilijker maken om de atomiciteit te waarborgen van bewerkingen die meerdere gebieden omvatten. Er moet worden gepland wat er gebeurt als een deel van het proces slaagt en een ander deel niet.
7. Rechtvaardigen de voordelen de totale kosten? Houd niet alleen rekening met de implementatiekosten, maar ook met infrastructuur, monitoring, beveiliging, testen, onderhoud en de ontwikkeling van vaardigheden.
8. Kunnen we met een kleinere wijziging beginnen? Soms volstaat het om de modules beter te structureren, een asynchroon proces af te splitsen of de implementatieautomatisering te verbeteren. De kleinste wijziging die het probleem effectief oplost, is vaak het beste uitgangspunt.
De meest voorkomende fouten bij het kiezen van een architectuur
De eerste fout is moderniteit gelijkstellen aan het aantal services. Microservices zijn een specifieke manier om een systeem te organiseren, geen doel op zich.
De tweede fout is een architectuur ontwerpen op basis van voorspellingen die nog niet door de daadwerkelijke werking van het product zijn bevestigd. Het is verstandig ruimte voor verdere ontwikkeling te laten en onderdelen pas af te splitsen wanneer daar een gegronde behoefte aan ontstaat.
De derde fout is een systeem opsplitsen zonder de bedrijfsgrenzen vast te stellen. Als services sterk van elkaar afhankelijk zijn, ontstaat er een gedistribueerde architectuur die de problemen van een monoliet behoudt, maar daar de kosten van netwerkcommunicatie aan toevoegt.
De vierde fout is de operationele kant van de oplossing over het hoofd zien. Elke nieuwe service moet worden geïmplementeerd, gemonitord, beveiligd en gediagnosticeerd. Zonder geschikte processen kan een groeiend aantal componenten de betrouwbaarheid verlagen in plaats van verbeteren.
De vijfde fout is proberen organisatorische problemen uitsluitend met technologie op te lossen. Microservices kunnen de onafhankelijkheid van teams ondersteunen, maar vervangen geen duidelijke verdeling van verantwoordelijkheden, communicatie en goed productbeheer.
Ten zesde is een monolithische architectuur behandelen als een tijdelijke oplossing die zo snel mogelijk moet worden vervangen. Een goed ontworpen monolithische applicatie kan jarenlang de juiste keuze blijven. Het is niet nodig om de architectuur ingewikkelder te maken zonder een concreet voordeel.
De architectuur moet meegroeien met het product
Er bestaat niet één architectuur die voor elke applicatie de beste is. Een klein product dat door een team van enkele mensen wordt ontwikkeld, heeft andere behoeften dan een platform dat meerdere onafhankelijke bedrijfsdomeinen ondersteunt en door tientallen teams wordt ontwikkeld.
Een monoliet kan zorgen voor eenvoudige implementatie en eenvoudiger operationeel beheer. Een modulaire monoliet helpt de applicatiestructuur te ordenen en die eenvoud te behouden. Microservices kunnen daarentegen onafhankelijke ontwikkeling, implementatie en schaalbaarheid bieden als het product en de organisatie daadwerkelijk zo'n model nodig hebben.
Het belangrijkste is vaststellen met welk probleem het bedrijf te maken heeft. Het is niet verstandig om tientallen services in te voeren alleen omdat populaire platforms er zo uitzien. Het is evenmin verstandig om koste wat kost vast te houden aan een monoliet als de beperkingen ervan de productontwikkeling belemmeren en er concrete voordelen zijn aan te wijzen bij het afsplitsen van een deel van het systeem.
Een goede architectuurbeslissing draait niet om het voorspellen van alle toekomstige behoeften. Het gaat om het bouwen van een oplossing die aan de huidige eisen voldoet, zonder de weg naar redelijke veranderingen in de toekomst af te sluiten.
Controleer voordat je de applicatie opsplitst in microservices of je echt onafhankelijke services nodig hebt, of vooral een beter georganiseerde systeemstructuur. Dat verschil kan niet alleen de architectuur bepalen, maar ook de kosten en het tempo van de productontwikkeling.
Bronnen en verder lezen
-
AWS Well-Architected Framework: Kies hoe je je workload segmenteert - afwegingen tussen monolithische en microservicesarchitectuur.
-
Microsoft Azure Architecture Center: Microservicesarchitectuur - complexiteit, communicatie, testen en gegevensbeheer in gedistribueerde systemen.
-
microservices.io: Hoe modulair kan je monoliet worden? - een monoliet organiseren rond bedrijfsdomeinen.
Gerelateerde artikelen van Web24
-
Je applicatie is 5 jaar oud. Is ze nog geschikt voor verdere ontwikkeling?
-
Waarom kost een nieuwe functie in een oude applicatie steeds meer?
-
Je applicatie werkt. Maar kun je die veilig 100 keer per dag implementeren?
De bovenstaande links verwijzen naar artikelen over onderwerpen die verband houden met modernisering, ontwikkelkosten en het implementatieproces. Ze zijn geen vervanging voor een afzonderlijke analyse van de architectuurkeuze.
Veel leesplezier.



