Mijn IT-leerroadmap voor 5 jaar — van sysadmin naar infrastructure engineer

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski
Linux. Windows. Netwerken. Security. Observability. Automatisering. Cloud. Kubernetes. AI.
Maar bovenal:
Inhoud
🧠 Leren systemen te begrijpen — niet alleen ze te bedienen.
Ik heb behoorlijk wat nagedacht over waar ik mijn IT-skills de komende jaren naartoe wil brengen.
Mijn professionele achtergrond geeft me al een vrij brede basis:
- 🐧 Linux-systeembeheer
- 📊 Monitoring
- 🚨 Technisch eventmanagement
- 📝 Logmanagement
- 🌐 Netwerken
- 🔐 Security
Mijn huidige professionele focus ligt steeds meer op Graylog en logmanagement.
Buiten het werk heb ik ook veel interesse in:
- Windows Server
- Active Directory
- Docker
- Kubernetes
- Git
- Automatisering
- Besturingssystemen
- AI
Ik heb ook een behoorlijk capabel homelab met drie fysieke servers en twee tower-pc’s.
De vraag is dus eigenlijk niet:
“Welke technologie moet ik nu leren?”
De veel interessantere vraag is:
“Wat voor engineer wil ik de komende vijf jaar worden?”
🎯 Het doel
Mijn langetermijndoel is niet om degene te worden die de meeste commando’s kent.
Het is niet om certificeringen te verzamelen als Pokémon.
En het is al helemaal niet om elke nieuwe technologie te leren die elke dinsdag op Hacker News verschijnt. 😄
Ik wil me ontwikkelen tot iemand die:
- complexe infrastructuur begrijpt
- infrastructuur ontwerpt
- infrastructuur beheert
- infrastructuur troubleshoot
- infrastructuur automatiseert
- infrastructuur beveiligt
- infrastructuur monitort
- afhankelijkheden begrijpt
- storingen analyseert
- architectuurbeslissingen neemt
- technologiekeuzes beoordeelt
- AI effectief inzet als engineeringtool
Met andere woorden:
🏗️ Infrastructure engineering
met een stevige basis in Linux, Windows, netwerken, security, observability, automatisering, cloud en cloud-native technologieën.
🧠 Het belangrijkste deel: hoe ik wil leren
Dit is het fundament van de hele roadmap.
Mijn manier van leren beweegt bewust weg van puur uit het hoofd leren.
Moderne infrastructuur is simpelweg te complex om elk commando, elke API-parameter en elke configuratieoptie te onthouden.
En eerlijk gezegd:
man systemctl
man kubectl
Get-Help
documentation
Google
ChatGPT
Claude
...exist for a reason. 😎
Dus wil ik één abstractielaag omhoog.
❌ De oude aanpak
Problem
↓
Remember command
↓
Run command
↓
Hope
✅ De aanpak die ik wil ontwikkelen
Problem
↓
Define the problem
↓
Understand the architecture
↓
Identify components
↓
Understand dependencies
↓
Collect evidence
↓
Form hypotheses
↓
Test hypotheses
↓
Find root cause
↓
Design solution
↓
Automate
↓
Document
Het eigenlijke commando wordt maar één onderdeel van het proces.
Het commando is een tool. Het begrip is de skill.
📐 Mijn leermodel: de 20 / 30 / 30 / 20-regel
Voor de grote onderwerpen in deze roadmap wil ik ongeveer deze verdeling:
| Aandeel | Focus |
|---|---|
| 20% | Commando’s, syntax, tools en implementatiedetails |
| 30% | Architectuur, concepten, lagen en afhankelijkheden |
| 30% | Troubleshooting, faalscenario’s en praktijksituaties |
| 20% | Automatisering, AI-ondersteunde engineering en validatie |
Dit is geen rigide wiskundige formule.
Het is een geheugensteun voor waar de nadruk moet liggen.
Als ik een onderwerp afrond met kennis van 200 commando’s maar niet kan uitleggen hoe het systeem werkt, heb ik waarschijnlijk het verkeerde geleerd.
🔬 De leercyclus
Elke belangrijke technologie moet dezelfde cyclus doorlopen.
1️⃣ Begrijpen
Wat is de technologie?
2️⃣ Modelleren
Hoe is de architectuur?
3️⃣ Bouwen
Uitrollen in het homelab.
4️⃣ Observeren
Het gedrag monitoren en bekijken.
5️⃣ Breken
Bewust storingen veroorzaken.
6️⃣ Troubleshooten
Systematisch de oorzaak vinden.
7️⃣ Automatiseren
Repetitief werk omzetten in code.
8️⃣ Documenteren
Architectuurdocumentatie en runbooks maken.
9️⃣ Uitleggen
Het systeem aan een andere engineer kunnen uitleggen.
🔟 Valideren
Een certificering, praktijktest of echt project gebruiken als laatste checkpoint.
⏱️ Mijn realistische tijdsbudget per week
Ik wil niet dat deze roadmap nog een fulltime baan wordt.
Een realistisch gemiddelde is:
| Activiteit | Tijd / week |
|---|---|
| Gestructureerd leren | 2–3 uur |
| Homelab / praktijkwerk | 2–3 uur |
| Documentatie / Git | 0,5–1 uur |
| AI-ondersteund verkennen | 0,5–1 uur |
Doel: ongeveer 5–8 uur per week.
Vóór een certificering kan dit tijdelijk oplopen.
In drukke periodes kan het afnemen.
Waar het om gaat, is consistentie op de lange termijn.
🗺️ DE VIJFJARIGE ROADMAP
2026
│
├── Linux
├── Graylog
├── Git
└── Ansible
│
▼
2027
│
├── Advanced Linux
├── Windows Server
├── Active Directory
├── Security
└── Infrastructure Architecture
│
▼
2028
│
├── Terraform / OpenTofu
├── Infrastructure as Code
├── Kubernetes
└── GitOps
│
▼
2029
│
├── Azure
├── Entra ID
├── Hybrid Cloud
├── Multi-RZ
└── Disaster Recovery
│
▼
2030
│
├── Observability
├── OpenTelemetry
├── Platform Engineering
├── AI
└── AIOps
🐧 JAAR 1 — Linux, Graylog, Git & automatisering
📅 Doel: september 2026 – augustus 2027
Hoofddoel: een extreem solide basis in systemen en automatisering opbouwen.
Geschatte inspanning: 5–8 uur/week.
🐧 Fase 1 — Gevorderd Linux / systems engineering
Duur: ongeveer 6–9 maanden
Doel: 120–180 uur
Onderwerpen die ik wil beheersen
- Linux-architectuur
- bootproces
- systemd
- processen en threads
- signalen
- CPU-scheduling
- geheugenbeheer
- virtueel geheugen
- bestandssystemen
- LVM
- RAID
- ZFS
- netwerken
- DNS
- SSH
- rechten
- ACL’s
- journald
- logging
- performance-analyse
- kernel-basiskennis
- security hardening
Bijzonder belangrijk
Ik wil begrijpen waarom Linux zich gedraagt zoals het zich gedraagt.
Bijvoorbeeld:
Waarom is de server traag?
In plaats van meteen willekeurige commando’s uit te voeren, wil ik leren onderscheiden:
CPU?
RAM?
I/O?
Network?
Filesystem?
Process?
Kernel?
Application?
Dependency?
Configuration?
Certificeringsmijlpaal
🎓 LFCS — Linux Foundation Certified System Administrator.
Alternatief:
🎓 RHCSA, vooral als het Red Hat-ecosysteem professioneel belangrijker wordt.
Einddoel
Geef me een kapotte Linux-server en ik vind systematisch de root cause.
📊 Fase 2 — Graylog & logmanagement
Duur: doorlopend gedurende jaar 1
Prioriteit: ZEER HOOG
Dit is mijn huidige professionele specialisatie.
Onderwerpen
- Graylog-architectuur
- Graylog-nodes
- Data Nodes
- OpenSearch
- shards
- replica’s
- index sets
- streams
- pipelines
- parsers
- verwerking
- retentie
- journal
- Fluent Bit
- syslog
- GELF
- Fluent Forward
- relays
- HA
- capaciteitsplanning
- performance
- security logging
- eventdetectie
Architectuurdoel
Thousands of Servers
│
▼
Agents / Syslog
│
▼
Relay Tier
│
▼
Graylog
│
▼
OpenSearch
│
▼
Hot / Cold Storage
Ik wil kunnen berekenen
- dagelijkse ingestie
- opslagbehoefte
- replicatie-overhead
- retentie
- hot storage
- cold storage
- clustersizing
- faalscenario’s
Professionele mijlpaal
Een productierijpe, gecentraliseerde logging-architectuur kunnen ontwerpen en verdedigen.
🌱 Fase 3 — Git & Ansible
Duur: 4–6 maanden
Git
- repositories
- branching
- merging
- rebasing
- tags
- pull requests
- GitLab
- basis van CI/CD
Ansible
- inventory
- roles
- collections
- variabelen
- templates
- Jinja2
- Vault
- handlers
- idempotentie
- testen
- AWX
Doel
Manual configuration
↓
Ansible
↓
Git
↓
Version-controlled infrastructure
↓
Repeatable infrastructure
Ik wil op het punt komen waarop ik denk:
“Als ik dit twee keer handmatig moet configureren, doe ik het verkeerd.”
🪟 JAAR 2 — Windows Server, Active Directory & architectuur
📅 Doel: september 2027 – augustus 2028
Hoofddoel: uitbreiden van Linux-beheer naar enterprise-infrastructuur.
🪟 Fase 4 — Windows Server
Duur: 4–6 maanden
Onderwerpen
- Windows Server-architectuur
- roles en features
- PowerShell
- Windows-netwerken
- Windows-opslag
- Windows-clustering
- Windows Event Logs
- WinRM
- services
- performance-analyse
- security
🔐 Fase 5 — Active Directory
Duur: 5–7 maanden
Onderwerpen
- AD DS
- Forest
- Domain
- OU-ontwerp
- Domain Controllers
- FSMO-rollen
- AD-replicatie
- Sites & Services
- DNS
- Group Policy
- Kerberos
- LDAP
- SPN’s
- serviceaccounts
- gMSA
- AD CS
- PKI
- AD-security
Belangrijke koppeling met Linux
Active Directory
│
┌──────────┼──────────┐
│ │ │
DNS Kerberos LDAP
│ │ │
└──────────┼──────────┘
│
┌─────────┴─────────┐
│ │
Windows Linux
│ │
GPO SSSD / PAM
PowerShell Kerberos
WinRM LDAP
Het doel is niet om Windows-beheerder te worden in plaats van Linux-beheerder.
Het doel is beide werelden en de interfaces daartussen te begrijpen.
Certificeringsmijlpaal
🎓 Microsoft-certificeringstraject Windows Server / Hybrid Administration.
Het precieze examen kies ik bij de start van de fase, omdat Microsoft zijn certificeringsportfolio regelmatig bijwerkt.
🏗️ Fase 6 — Infrastructuurarchitectuur
Duur: 6–12 maanden
Dit is een van de belangrijkste fases van de hele roadmap.
Onderwerpen
- architectuurpatronen
- hiërarchie
- afhankelijkheden tussen services
- failure domains
- HA
- redundantie
- load balancing
- opslagarchitectuur
- netwerkarchitectuur
- Multi-RZ
- disaster recovery
- RPO
- RTO
- capaciteitsplanning
- schaalbaarheid
- back-uparchitectuur
- security-architectuur
- documentatie
Groot project
Een fictieve enterprise-infrastructuur ontwerpen voor:
- 5.000 servers
- Linux + Windows
- twee datacenters
- centrale logging
- centrale monitoring
- identity services
- security monitoring
- back-up
- HA
- DR
Opleveren:
- architectuurdiagrammen
- netwerkontwerp
- afhankelijkhedenkaart
- HA-concept
- DR-concept
- capaciteitsberekening
- securityconcept
- monitoringconcept
- loggingconcept
Deze oefening is bewust groter dan een normaal homelabproject.
Het doel is te leren denken als een infrastructuurarchitect.
☁️ JAAR 3 — Infrastructure as Code & Kubernetes
📅 Doel: september 2028 – augustus 2029
🏗️ Fase 7 — Terraform / OpenTofu
Duur: 4–6 maanden
Onderwerpen
- providers
- resources
- state
- modules
- variabelen
- outputs
- remote state
- secrets
- CI/CD
- levenscyclus van infrastructuur
Doel
Git
↓
Infrastructure as Code
↓
Provisioning
↓
Ansible
↓
Configuration
↓
Monitoring
↓
Logging
Ik wil het verschil helder begrijpen tussen:
- provisioning
- configuratiemanagement
- orchestratie
- applicatie-deployment
☸️ Fase 8 — Kubernetes
Duur: 8–12 maanden
Prioriteit: HOOG
Onderwerpen
- control plane
- API Server
- etcd
- scheduler
- controllers
- kubelet
- container runtime
- netwerken
- DNS
- Services
- Ingress
- opslag
- PVC’s
- RBAC
- Secrets
- Helm
- Operators
- GitOps
- Flux
- security
- troubleshooting
Certificeringsmijlpalen
🎓 CKA — Kubernetes-beheer.
Later:
🎓 CKS — Kubernetes-security.
De CKS is extra aantrekkelijk omdat die Kubernetes combineert met mijn bestaande securityachtergrond.
☁️ JAAR 4 — Azure, hybride cloud & Multi-RZ
📅 Doel: september 2029 – augustus 2030
☁️ Fase 9 — Azure
Duur: 6–9 maanden
Onderwerpen
- Azure-architectuur
- VNets
- subnetten
- routing
- NSG’s
- load balancing
- VM’s
- opslag
- identiteit
- security
- monitoring
- logging
- governance
- beschikbaarheid
- DR
Certificeringsmijlpaal
🎓 AZ-104 — Azure Administrator Associate
Die past goed in de roadmap, omdat hij Azure-compute, opslag, netwerken, identiteit en beheer combineert.
🔑 Fase 10 — Entra ID & hybride identiteit
Duur: 3–5 maanden
On-Prem AD
│
│ Hybrid Identity
▼
Microsoft Entra ID
│
▼
Azure
```
Onderwerpen:
- identiteitsarchitectuur
- authenticatie
- autorisatie
- federatie
- hybride identiteit
- conditional access
- RBAC
- service-identiteiten
- security
🏢 Fase 11 — Multi-RZ / datacenterarchitectuur
Duur: 4–6 maanden
Deze fase combineert veel eerdere onderwerpen.
Global Services
│
┌─────────────┴─────────────┐
│ │
DC1 DC2
│ │
┌──────┼──────┐ ┌──────┼──────┐
│ │ │ │ │ │
Compute Network Storage Compute Network Storage
│ │
└──────────────┬────────────┘
│
Services
│
Monitoring / Logging / IAM
Onderwerpen
- failure domains
- siteredundantie
- load balancing
- replicatie
- back-up
- RPO
- RTO
- DR
- split brain
- quorum
- netwerkpartitionering
- afhankelijkheden tussen services
- capaciteitsplanning
Hier wordt het eerdere architectuurwerk praktisch.
📡 JAAR 5 — Observability, platform engineering & AI
📅 Doel: september 2030 – augustus 2031
📊 Fase 12 — Moderne observability
Duur: 4–6 maanden
Observability
│
┌───────────┼───────────┐
│ │ │
Metrics Logs Traces
│ │ │
Prometheus Graylog OpenTelemetry
│ │ │
└───────────┼───────────┘
│
Grafana
Onderwerpen
- metrics
- logs
- traces
- correlatie
- gedistribueerde systemen
- Prometheus
- Grafana
- Graylog
- OpenTelemetry
- alerting
- incidentanalyse
Het doel is om te gaan van:
“De server is rood.”
naar:
“De klantgerichte service degradeerde omdat afhankelijkheid X latency had nadat component Y resource Z had uitgeput.”
🤖 Fase 13 — AI & AIOps
Duur: doorlopend
Onderwerpen
- LLM’s
- prompt engineering
- AI-API’s
- RAG
- embeddings
- vectordatabases
- lokale LLM’s
- AI-agents
- MCP
- AI-ondersteund troubleshooten
- AI-ondersteunde documentatie
- AI-ondersteunde automatisering
- incidentcorrelatie
- AIOps
Voorbeeld
Monitoring Alert
│
▼
Context Collection
│
▼
AI Analysis
│
▼
Possible Causes
│
▼
Diagnostic Tests
│
▼
Human Validation
│
▼
Automation
AI moet me sneller maken.
Het mag me niet intellectueel lui maken.
🏠 Het homelab — mijn praktische trainingsomgeving
Het homelab is een belangrijk onderdeel van de roadmap, maar heeft bewust minder prioriteit dan de eigenlijke leerdoelen.
Het leerplan komt eerst.
Het homelab bestaat om theorie om te zetten in praktijkervaring.
Mijn hardware:
- 🖥️ 3 fysieke servers
- 🖥️ 2 tower-pc’s
Dat is ruim genoeg voor een verrassend capabel infrastructuurlab.
🧪 Homelab-regel #1
Draai niet alleen services. Bouw scenario’s.
In plaats van:
“Ik heb een Kubernetes-cluster.”
wil ik:
“Ik heb een Kubernetes-cluster gebouwd, bewust een node gekild, de storing geobserveerd, het gedrag geanalyseerd en het herstel gedocumenteerd.”
Dat is een compleet andere leerervaring.
🖥️ Gebruik van het homelab per leerfase
| Leergebied | Homelab-oefening |
|---|---|
| Linux | Performance- en storingsanalyse |
| Graylog | Centraal loggingplatform |
| Windows | Windows Server-omgeving |
| AD | Active Directory met meerdere DC’s |
| Netwerken | Scenario’s met VLAN / routing / firewall |
| Ansible | De hele omgeving automatiseren |
| Git | Infrastructuurrepository |
| IaC | Reproduceerbare infrastructuur |
| Kubernetes | Cluster met meerdere nodes |
| Observability | Metrics + logs + traces |
| Security | Hardening en aanvalssimulaties |
| DR | Services vernietigen en herstellen |
| AI | AI-ondersteunde incidentanalyse |
💥 Het “breek het expres”-programma
Een van de belangrijkste onderdelen van het homelab wordt het bewust veroorzaken van storingen.
Voorbeelden:
- DNS breken
- een bestandssysteem vol laten lopen
- kritieke services stoppen
- certificaten breken
- netwerkconnectiviteit weghalen
- opslagstoringen simuleren
- Kubernetes-nodes killen
- RBAC breken
- Active Directory-replicatie breken
- Graylog-ingestie breken
- buitensporig veel logs genereren
- latency introduceren
- pakketverlies simuleren
Daarna:
Failure
↓
Symptoms
↓
Evidence
↓
Hypotheses
↓
Tests
↓
Root Cause
↓
Fix
↓
Prevention
↓
Documentation
Hier verwacht ik dat een groot deel van het echte leren gebeurt.
📚 Het homelab moet documentatie opleveren
Elk serieus project moet iets achterlaten.
homelab/
│
├── ansible/
├── terraform/
├── opentofu/
├── kubernetes/
├── monitoring/
├── logging/
├── security/
├── networking/
│
├── architecture/
│ ├── network.md
│ ├── storage.md
│ ├── logging.md
│ ├── kubernetes.md
│ └── disaster-recovery.md
│
└── incidents/
├── dns-failure.md
├── storage-failure.md
├── ad-failure.md
└── kubernetes-node-failure.md
Zo wordt het homelab een praktisch portfolio van engineeringwerk.
🤖 AI als onderdeel van het leerproces
ChatGPT en Claude worden alle vijf jaar onderdeel van de workflow.
Maar de workflow is belangrijk.
Slechte workflow
Problem
↓
Ask AI
↓
Copy solution
↓
Done
Betere workflow
Problem
↓
My own hypothesis
↓
AI challenge
↓
Alternative hypotheses
↓
Diagnostic tests
↓
Evidence
↓
My decision
↓
Implementation
↓
Validation
Een paar vragen die ik regelmatig wil gebruiken:
“Wat mis ik?”
“Wat zijn drie aannemelijke root causes?”
“Welke test zou deze hypotheses van elkaar onderscheiden?”
“Beoordeel je vorige antwoord kritisch.”
“Welke aannames doe je?”
Zo moet AI een technische sparringpartner worden in plaats van een commandogenerator.
🏆 Certificeringsstrategie
Certificeringen zijn nuttig, maar ze moeten de roadmap valideren en niet dicteren.
| Ong. periode | Doel | Waarom |
|---|---|---|
| 2026/27 | LFCS | Praktische Linux-basis |
| 2026/27 | RHCSA — optioneel alternatief | Enterprise Linux |
| 2027/28 | Windows Server / Hybrid Administration | Windows + AD + hybride |
| 2028/29 | CKA | Kubernetes-beheer |
| 2028/29 | CKS | Kubernetes-security |
| 2029/30 | AZ-104 | Azure-beheer |
| 2030/31 | AI- / security- / cloud-certificaat | Alleen als het echt nuttig is |
De regel is simpel:
Geen certificering alleen omdat die bestaat.
Een certificering moet:
- een echt kennisgat vullen
- structuur bieden
- praktische vaardigheden valideren
- professioneel nuttig zijn
Anders is het project zelf waarschijnlijk waardevoller.
📈 De vaardigheidsniveaus
Ik wil voortgang ook meten aan vaardigheid in plaats van alleen aan certificaten.
Niveau 1 — Operator
Ik kan documentatie volgen en het systeem bedienen.
Niveau 2 — Beheerder
Ik begrijp de configuratie en kan veelvoorkomende problemen oplossen.
Niveau 3 — Engineer
Ik begrijp architectuur, afhankelijkheden en faalscenario’s.
Niveau 4 — Ontwerper
Ik kan het systeem ontwerpen en architectuurbeslissingen onderbouwen.
Niveau 5 — Architect
Ik kan complexe systemen ontwerpen over meerdere technologieën en failure domains heen.
De vijfjarige roadmap gaat in wezen over de weg van:
Operator
↓
Administrator
↓
Engineer
↓
Designer
↓
Architect
🧠 Wat ik na vijf jaar wil kunnen
Stel dat iemand me dit probleem voorlegt:
“We beheren enkele duizenden Windows- en Linux-systemen verspreid over meerdere datacenters. We hebben gecentraliseerde identiteit, monitoring, logging, security, automatisering, high availability en disaster recovery nodig. Ontwerp het platform.”
Dan wil ik kunnen redeneren over:
- Linux
- Windows
- Active Directory
- DNS
- netwerken
- security
- opslag
- logging
- monitoring
- observability
- Kubernetes
- cloud
- identiteit
- automatisering
- HA
- DR
- capaciteit
- afhankelijkheden
- failure domains
En het allerbelangrijkste:
Ik wil begrijpen waarom de architectuur eruitziet zoals ze eruitziet.
🚀 De uiteindelijke filosofie
Er komt altijd weer een nieuwe technologie.
Weer een Kubernetes-release.
Weer een cloudplatform.
Weer een Linux-distributie.
Weer een monitoringsysteem.
Weer een AI-framework.
Weer een certificering.
En weer een commando dat ik morgenochtend vergeten ben.
Dat is oké.
Technologieën veranderen.
Engineeringprincipes veranderen veel langzamer.
Systemen hebben nog steeds:
- afhankelijkheden
- interfaces
- faalscenario’s
- securitygrenzen
- capaciteitslimieten
- beschikbaarheidseisen
- datastromen
- operationele beperkingen
Daar wil ik mijn leerinspanning in steken.
🐧 Minder commando’s stampen.
🏗️ Meer architectuur.
🔍 Meer troubleshooting.
🤖 Meer automatisering.
☁️ Meer denken in infrastructuur.
🧠 Meer begrip.
En ja...
Ik heb nog steeds tegelijk een terminal, een spiekbriefje, documentatie, ChatGPT en Claude open.
Want:
Een goede infrastructure engineer zijn betekent niet alles onthouden.
Het betekent weten wat ertoe doet, weten hoe je de rest vindt en weten hoe je bepaalt of het antwoord echt klopt.
