Moderne IT-infrastructuur, in vijf pillars

Moderne IT is geen product dat je koopt. Het is hoe hardware, software en de cloud interageren om een bedrijfsmissie te dragen, en die interactie is net waar de rommel zit. Gebruikers, suppliers, devices, services en data raken elkaar op manieren die geen enkel product-diagram ooit toont.

Dus ik ben gestopt met producten modelleren en begonnen met relaties modelleren. Eén regel ligt onder alles: behandel elke component als een CI (configuration item), en vanaf het moment dat die bestaat moet die aan minstens één andere CI hangen. Een login is geen login. Het is een identity, op een directory, op een operating system, op een virtual machine, op een hypervisor, op hardware. Niets zweeft. Zo geraak je aan een kaart in plaats van een inventaris, en elke CI op die kaart valt in één van vijf pillars.

Vijf pillars, vier foundations

Het frame is een letterlijk frame. Een miya-daiku, de timmerman die een Japanse tempel optrekt, zet heel de structuur in elkaar uit hout dat grijpt en amper nagels, zodat de sterkte in de joinery zit in plaats van in de bevestiging, en een goede verbinding trekt strakker naarmate het gebouw harder geduwd wordt. Rechte posts, tie-beams die er dwars doorheen lopen, en de verbindingen waar ze kruisen: dat is de eerlijke vorm van een IT-omgeving, en daarom bouw ik het model daarop.

Stel je een timber frame voor. De business missie is de nokbalk die alles moet dragen. Vijf posts houden het recht, dat zijn de pillars. Vier balken lopen dwars door elke post, dat zijn de foundations. De sterkte zit niet in nagels, ze zit in de verbindingen.

De pillars zijn waarmee je bouwt:

• Identities, wie of wat er handelt: gebruikers, service accounts, devices, AI-agents. Je access-control plane.
• Compute, waar workloads echt draaien: servers, VMs, containers, endpoints.
• Networking, hoe iets iets anders bereikt: switching, routing, firewalls, segmentation.
• Software, wat de functie levert: apps, APIs, SaaS, platform services.
• Data, de reden dat de rest bestaat: databases, files, backups, logs als assets.

De foundations zijn hoe je elke pillar eerlijk houdt, en ze lopen door alle vijf:

• Operations draait het: provisioning, patching, incidents, SLAs.
• Security beschermt het: hardening, least privilege, detectie, evidence.
• Governance bewijst het: ownership, change control, audit trails.
• Finance begroot het: kost, budget, right-sizing, run-rate. Je kunt niet groter timmeren dan je hout.

Mis je een foundation, dan hangt de pillar scheef. Een perfect gedraaide server zonder governance is een orphan die niemand wil claimen om 2 uur ‘s nachts; een goed beheerde die niemand gepatcht heeft is een breach met papierwerk; een vlekkeloze die niemand begroot heeft is de budgetverrassing van volgend jaar.

Niets staat op zichzelf

De pillars zijn hoe ik sorteer; de links ertussen zijn waar de echte engineering zit. Neem één saaie corporate login. De identity leeft in een IdP, dat is software, draaiend op een server, dat is compute, enkel bereikbaar via een network-pad, met toegang tot data, en elke stap wil operations, security, governance en finance errond. Eén triviale actie, vijf pillars, vier foundations.

Dat is net waarom je die links tekent: het is de enige manier om blast radius te zien voor die jou ziet. Verander je identity tiering-model, en je hebt net veranderd welke compute tiers er bestaan, welke network segments je nodig hebt, en wat je apps mogen aannemen. Moesten die CI’s niet gelinkt zijn, dan kom je dat te weten in de incident review in plaats van de design review.

Het is ook waar de vendor-vraag zit. Hou een pillar op een open standaard en de vendor eronder is swappable; fuseer je design in de private features van één product en de pillar wordt een gijzelaar. Dat is heel het argument in bouw alsof je moet vertrekken.

De loop die het eerlijk houdt

Een pillar is geen aankoop, het is een lifecycle. Elk framework dat ik bouw draait dezelfde gesloten loop: design het vooraf voor security en schaal, evaluate en adopt het met de operational en lock-in kost eerlijk afgewogen, operate het door het lange saaie midden waar de waarde echt zit, en audit het om te bewijzen dat de realiteit nog matcht met de intentie, en voer wat je geleerd hebt terug naar het volgende design. Geen waterfall. Een loop, en elke ronde zit strakker dan de vorige.

Sorteer elke component in een pillar, rijg de vier foundations door alle vijf, en link elke CI aan de volgende. De architectuur zit in de verbindingen, niet in de boxes.

Het volledige model (de 5 × 4 matrix, een maturity score, en de euro die elke gap waard is) staat op de pillar model referentiepagina. Deze post is de steiger waar ik de rest aan ophang: als ik schrijf over een AI-agent veilig de sleutels geven, of waarom mijn homelab achter VLANs leeft, dan is dat één pillar in close-up, rustend op diezelfde vier foundations en gelinkt aan de andere vier. Begin in pillars te denken en heel de boel stopt met een hoop producten te zijn en wordt een systeem waar je echt over kunt redeneren.