TL;DR Simulatie modelleert iets zonder het te draaien. Emulatie draait het door de hardware in software na te bouwen. Virtualisatie draait meerdere complete besturingssystemen op één machine. Containers draaien meerdere apps op één kernel. Hieronder per term een restaurant, een tabel, en de vier verwarringen die ik het vaakst hoor.
“Dus wat is nou het verschil tussen een container en een virtual machine?”
Die vraag krijg ik vaak. Meestal van iemand die slim genoeg is om in vergaderingen mee te knikken en niet zo goed wil toegeven dat het vaag is. Eerlijk? De meeste uitleg maakt het erger. Die begint met “hypervisor”, “kernel sharing” en “hardware-abstractie”, en nu heeft die persoon vier nieuwe termen om over in de war te zijn in plaats van één.
Achter de container-versus-VM-vraag zit een grotere. Wat is het verschil tussen simulatie, emulatie, virtualisatie en containerisatie? Mensen gooien die vier voortdurend op één hoop, en het zijn vier verschillende antwoorden op hetzelfde probleem, namelijk iets draaien in een omgeving waar het nooit voor gebouwd is.
Dat onderscheid kan me wat schelen omdat ik wil snappen wat ik draai. Kun je niet zeggen welke van de vier een tool doet, dan kun je ook niks zeggen over de performance, de isolatie, of wat er stukgaat als het omvalt. Dus hier is de versie waarmee het bij mij eindelijk bleef hangen. Er komen restaurants in voor.
De restaurant-metafoor
Stel, je wilt Japans eten. Je hebt vier opties.
Simulatie is de kookshow
Je kijkt een Japanse kookshow. De chef maakt sushi, legt de techniek uit, laat zien hoe de vis gesneden wordt en de rolletjes in elkaar gaan. Je ziet alles wat er zou gebeuren als je in een Japans restaurant zat.
Alleen eet je niks. Er is geen eten. Wat je hebt is een model van de ervaring. Je weet nu hoe sushi gemaakt wordt en je hebt nog steeds honger.
Dat is simulatie. Je bouwt een model van iets om te bestuderen hoe het zich gedraagt, en het echte ding draai je nooit.
Een vluchtsimulator modelleert hoe een vliegtuig zich gedraagt. Prima om piloten mee te trainen, en er zit nergens een vliegtuig in de keten. Een circuitsimulator doet hetzelfde voor elektronica. Hij voorspelt hoe de componenten zich zouden gedragen, met niks op de werkbank. Wat je van een simulatie wilt is de voorspelling.
Emulatie is het Japanse restaurant in Amsterdam
Je gaat naar een Japans restaurant in Amsterdam. De Nederlandse chef heeft de technieken in Japan geleerd, importeert de ingrediënten, heeft de keukenapparatuur nagebouwd en serveert op Japans aardewerk.
Alles is ingericht om zich precies te gedragen als een restaurant in Tokyo. Goed gedaan proef je het verschil niet. Zelfde smaak, zelfde opmaak.
Je staat alleen nog steeds in Amsterdam. Eén systeem doet trouw alsof het een ander is, door elk detail van het origineel na te bouwen.
Dat is emulatie. Je laat één systeem zich precies gedragen als een ander door het gedrag in software na te bouwen.
Draai een Game Boy-emulator op je laptop. Er zit nergens Game Boy-hardware in die laptop, dus de emulator staat in voor elk onderdeel van de Game Boy, de CPU, de grafische chip, de geluidschip. De games merken er niks van. Wat hen betreft draaien ze op een Game Boy, en ze draaien ook echt, en dát is het verschil met een model.
Virtualisatie is het hotel met meerdere restaurants
Je verblijft in een hotel met meerdere restaurants onder één dak. Japans, Italiaans, Frans, Indiaas. Elk draait op zichzelf, met een eigen keuken en een eigen chef.
Wat ze delen is het gebouw. De elektriciteit, het water, de ventilatie, de schoonmaakploeg. Het hotelmanagement deelt de resources uit en bepaalt hoeveel ruimte, stroom en personeel elk restaurant krijgt.
Elk van die restaurants is een compleet, werkend restaurant. Geen ervan doet alsof het iets anders is. Ze verdelen het gebouw onder elkaar.
Dat is virtualisatie. Je draait meerdere complete besturingssystemen op één set hardware, met een dunne laag eronder die de resources uitdeelt.
Draai Windows en Linux tegelijk op één fysieke server. Elk krijgt z’n eigen volledige besturingssysteem, en ze delen de CPU, het geheugen en de opslag. De hypervisor is hier het hotelmanagement. Die deelt uit en houdt de twee uit elkaar.
Containers zijn de food court
Je gaat naar een food court. Eén grote keuken achterin, en een rij verkopers die hem delen. Dezelfde ovens, dezelfde werkbladen, dezelfde koelkasten.
Elke verkoper heeft nog steeds een eigen hoek, met eigen ingrediënten en eigen pannen. De sushi-verkoper kan niet in de mise en place van de pizza-verkoper graaien. Ze zitten van elkaar afgeschermd en delen de keuken.
Dat is goedkoper dan voor elke verkoper een eigen keuken bouwen. Het enige wat een verkoper nodig heeft zijn z’n eigen spullen, de ingrediënten en het gereedschap voor z’n eigen eten.
Dat is containerisatie. Applicaties draaien in geïsoleerde ruimtes bovenop één gedeelde kernel van het besturingssysteem, elk met eigen dependencies en libraries.
Docker-containers op een Linux-server, zeg. Elke container heeft een eigen bestandssysteem, eigen geïnstalleerde packages, een eigen app. Ze delen allemaal die ene Linux-kernel. De containerruntime is het food court-management. Die houdt elke verkoper in z’n eigen hoek.
De vier naast elkaar
| Aspect | Simulatie | Emulatie | Virtualisatie | Containers |
|---|---|---|---|---|
| Restaurant analogie | Kookshow | Buitenlands restaurant | Hotel restaurants | Food court keuken |
| Wat wordt gedeeld | Niets (alleen model) | Niets (volledige replica) | Alleen hardware | OS kernel + hardware |
| Wat is geïsoleerd | N.v.t. | Alles | Alles | App + dependencies |
| Performance | Varieert (vaak traag) | Traag (alles vertalen) | Bijna-native | Native |
| Compatibiliteit | Hoog (modelleert alles) | Hoog (repliceert alles) | Beperkt (zelfde CPU arch) | Beperkt (zelfde OS kernel) |
| Resource gebruik | Laag | Hoog | Medium | Laag |
Welke wanneer
Simulatie past als je gedrag wilt begrijpen of voorspellen zonder het echte ding te draaien. Ook als echt testen gevaarlijk, duur of onmogelijk is, denk aan kernreactoren, ruimtemissies en epidemieën, en als je iets ontwerpt dat nog niet bestaat. Het is het verkeerde gereedschap zodra je echte resultaten nodig hebt in plaats van gemodelleerde, of echte software moet draaien. Weermodellen, vluchtsimulatoren, circuitontwerptools, financiële modellen en natuurkundesimulaties horen hier allemaal.
Emulatie past als je software van een heel ander platform moet draaien, als de originele hardware verouderd, zeldzaam of weg is, en als exact gedrag belangrijker is dan snelheid. Laat het liggen als performance ertoe doet, en ook als virtualisatie volstaat, want dat is veel sneller. De gebruikelijke gevallen zijn oude consolegames op SNES- en PlayStation-emulators, ARM-software op x86 via Apple’s Rosetta 2, de Android-emulator voor mobiele development, en legacy software die in leven blijft nadat de hardware is overleden. Traag, ja. Maar zonder emulator draait die game helemaal niet.
Virtualisatie past als je meerdere verschillende besturingssystemen op één machine moet draaien, als omgevingen volledig van elkaar geïsoleerd moeten zijn, als het gast-OS een ander is dan de host, Windows op Linux bijvoorbeeld, of als elke omgeving een eigen kernelversie nodig heeft. Laat het liggen als al je workloads hetzelfde OS draaien, want dan zijn containers efficiënter. Ook als maximale performance kritiek is, of als de resources krap zijn. Windows en Linux op dezelfde server, developmentomgevingen die matchen met productie, testen op verschillende OS-versies, multi-tenant hosting met volledige isolatie.
Containers passen als alle workloads één kernel kunnen delen, als je lichte, snelle isolatie wilt, als je veel vergelijkbare applicaties deployt, en als resource-efficiëntie en opstarttijd tellen. Laat ze liggen als je een ander OS nodig hebt, want Windows-containers draaien niet op een Linux-kernel. Ook als je de sterkst mogelijke isolatie nodig hebt, want een VM isoleert harder, en als je software kernelaanpassingen vereist. Microservices, CI/CD-pipelines, lokale developmentomgevingen, Kubernetes-workloads, webapplicaties schalen.
Ze stapelen
In de praktijk worden ze gecombineerd.
Containers in virtual machines in fysieke servers. Elke laag kost je wat overhead en levert je capaciteit en isolatie terug, en het is goed om te weten welke ruil je op welke verdieping maakt.
Cloudproviders stapelen het precies zo. Jouw “server” is een VM op hun hardware, en je containers draaien in die VM. Die stapeling is waarom ik die vier scherp in m’n hoofd wil hebben. Piekt de latency, dan wil ik weten van welke verdieping het komt.
Wat mensen verkeerd hebben
“Docker is een virtual machine”
Nee. Docker-containers delen de kernel van de host en VMs nemen hun eigen mee. Dat ene verschil is waarom een container in seconden start, zonder kernel om te booten, terwijl een VM minuten nodig heeft om op te komen.
“Emulatie is gewoon trage virtualisatie”
Nee, ze lossen verschillende problemen op. Emulatie vertaalt de ene architectuur naar de andere, Game Boy naar PC. Virtualisatie draait dezelfde architectuur efficiënter, x86 op x86.
Een PC virtualiseert Linux op Linux heel efficiënt. Een Game Boy moet hij emuleren, want er zit geen Game Boy-hardware in om te virtualiseren.
“Containers zijn veilige isolatie”
Deels. Containers geven je procesisolatie, maar ze delen een kernel, en een kernelkwetsbaarheid kan een container escape worden. VMs isoleren harder, juist omdat ze die kernel niet delen.
Voor high-security of untrusted workloads pak ik nog steeds een VM. Voor het meeste wat ik draai zijn containers prima, en die keuze maak ik bewust, elke keer.
“Simulatie en emulatie zijn hetzelfde”
Nee. Simulatie modelleert gedrag bij benadering. Emulatie bouwt het exact na.
Een vluchtsimulator simuleert vliegtuigfysica om te voorspellen en om te leren. Een Game Boy-emulator kopieert het exacte hardwaregedrag, en de games erop draaien echt.
Waarom ik de moeite neem
Elk van de vier verdient z’n plek. Simulatie als je iets wilt modelleren zonder het te draaien. Emulatie als je vreemde software moet draaien op hardware die er nooit voor bedoeld was. Virtualisatie als je verschillende besturingssystemen naast elkaar nodig hebt. Containers als je veel vergelijkbare apps wilt draaien zonder per stuk voor een heel OS te betalen.
Ik houd ze uit elkaar omdat welke ik draai me vertelt wat ik kan verwachten als het stukgaat, en op hardware die van mij is, is er niemand anders om het aan te vragen.
De volgende keer dat iemand me de containervraag stelt, begin ik bij de food court en het hotel, en het woord hypervisor laat ik erbuiten.