Simulatie, Emulatie, Virtualisatie en Containers: De Restaurant Metafoor

“Dus wat is het verschil tussen een container en een virtual machine?”

Ik krijg deze vraag vaak. En het antwoord bevat meestal termen als “hypervisor,” “kernel sharing,” en “hardware abstractie” — wat alleen maar meer vragen oplevert.

Maar er schuilt eigenlijk een diepere vraag achter: wat is het verschil tussen simulatie, emulatie, virtualisatie en containerisatie? Deze vier concepten worden vaak verward, maar het zijn fundamenteel verschillende benaderingen om hetzelfde probleem op te lossen: iets draaien in een omgeving waarvoor het oorspronkelijk niet is ontworpen.

Laat me het uitleggen met restaurants.

De Restaurant Metafoor

Stel je voor dat je Japans wilt eten. Je hebt vier opties:

1. Simulatie: De Kookshow

Je kijkt naar een Japanse kookshow. De chef demonstreert hoe je sushi maakt, legt de technieken uit, laat zien hoe ingrediënten worden gesneden en geassembleerd. Je kunt alles zien wat er zou gebeuren als je in een Japans restaurant zou eten.

Maar je eet eigenlijk niks. Er is geen echt eten. Het is een model van de ervaring — nuttig om te begrijpen, maar niet om honger te stillen.

Dat is simulatie: een model maken van iets om het gedrag te bestuderen, zonder het echte ding daadwerkelijk te draaien.

In technische termen: een vluchtsimulator modelleert hoe een vliegtuig zich gedraagt. Het is ongelooflijk nuttig voor het trainen van piloten, maar er is geen echt vliegtuig bij betrokken. Vergelijkbaar modelleert een circuitsimulator hoe elektronische componenten zich gedragen zonder echte elektronica.

2. Emulatie: Het Japanse Restaurant in Amsterdam

Je gaat naar een Japans restaurant in Amsterdam. De Nederlandse chef heeft authentieke Japanse technieken geleerd. Ze importeren Japanse ingrediënten. Ze hebben de Japanse keukenapparatuur nagemaakt. Ze serveren het eten op Japans aardewerk.

Alles is ontworpen om precies te gedragen als een Japans restaurant in Tokyo. Het resultaat zou niet te onderscheiden moeten zijn van het echte ding — dezelfde smaak, dezelfde presentatie, dezelfde ervaring.

Maar het is geen Japans restaurant in Japan. Het is iets anders dat doet alsof het dat ding is, door elk detail van hoe het origineel werkt na te bootsen.

Dat is emulatie: één systeem laten gedragen als een ander systeem door het gedrag in software te repliceren.

In technische termen: een Game Boy emulator draaien op je laptop. De laptop heeft geen Game Boy hardware, maar de emulator software repliceert het gedrag van elk Game Boy component — de CPU, de grafische chip, de geluidschip. Games kunnen het verschil niet zien. Ze denken dat ze op een echte Game Boy draaien.

3. Virtualisatie: Het Hotel Restaurant

Je verblijft in een hotel. Het hotel heeft meerdere restaurants: Japans, Italiaans, Frans, Indiaas. Elk restaurant opereert onafhankelijk — aparte keukens, aparte chefs, aparte menu’s.

Maar ze delen allemaal de infrastructuur van het hotel: het gebouw, de elektriciteit, het water, de ventilatie, het schoonmaakpersoneel. Het hotelmanagement wijst resources (ruimte, stroom, personeel) toe aan elk restaurant.

Elk restaurant is een echt, volledig functioneel restaurant. Ze doen niet alsof ze iets anders zijn. Ze delen alleen de onderliggende infrastructuur efficiënt.

Dat is virtualisatie: meerdere complete besturingssystemen draaien op gedeelde hardware, met een dunne managementlaag die resources toewijst.

In technische termen: Windows en Linux tegelijk draaien op dezelfde fysieke server. Elk krijgt zijn eigen complete besturingssysteem, maar ze delen de CPU, geheugen en opslag. De hypervisor (het hotelmanagement) zorgt ervoor dat ze elkaar niet storen.

4. Containers: De Food Court Keuken

Je gaat naar een food court. Er is één grote keuken achterin. Verschillende verkopers delen deze keuken — ze gebruiken dezelfde ovens, dezelfde werkbladen, dezelfde koelkasten.

Maar elke verkoper heeft zijn eigen sectie met zijn eigen ingrediënten, zijn eigen recepten, zijn eigen pannen en potten. De sushi-verkoper kan niet per ongeluk de ingrediënten van de pizza-verkoper gebruiken. Ze zijn van elkaar geïsoleerd, maar delen de keukeninfrastructuur.

Dit is efficiënter dan elke verkoper een eigen complete keuken geven. Ze hebben alleen hun eigen “spullen” nodig — de ingrediënten en gereedschap specifiek voor hun eten.

Dat is containerisatie: applicaties draaien in geïsoleerde ruimtes die dezelfde besturingssysteem kernel delen, elk met hun eigen dependencies en libraries.

In technische termen: Docker containers op een Linux server. Elke container heeft zijn eigen bestandssysteem, zijn eigen geïnstalleerde packages, zijn eigen applicatie. Maar ze delen allemaal dezelfde Linux kernel. De container runtime (het food court management) houdt ze geïsoleerd.

Vergelijkingstabel

Wanneer Wat Gebruiken

Simulatie

Gebruik wanneer:

• Je gedrag wilt begrijpen of voorspellen zonder het echte ding te draaien
• Testen gevaarlijk, duur of onmogelijk is (kernreactoren, ruimtemissies, epidemieën)
• Je iets ontwerpt dat nog niet bestaat

Gebruik niet wanneer:

• Je echte resultaten nodig hebt, niet gemodelleerde resultaten
• Je echte software moet draaien

Voorbeelden:

• Weermodellering
• Vluchtsimulatoren
• Circuit design tools
• Financiële modellering
• Fysica simulaties

Emulatie

Gebruik wanneer:

• Je software moet draaien van een compleet ander platform
• De originele hardware verouderd, zeldzaam of niet beschikbaar is
• Exacte gedragsreplicatie belangrijker is dan snelheid

Gebruik niet wanneer:

• Performance ertoe doet (emulatie is traag)
• Je virtualisatie kunt gebruiken (veel sneller)

Voorbeelden:

• Oude console games draaien (SNES, PlayStation)
• ARM software op x86 draaien (Apple Rosetta 2)
• Legacy software behouden wanneer hardware overlijdt
• Mobiele app development (Android emulator)

Virtualisatie

Gebruik wanneer:

• Je meerdere verschillende besturingssystemen op één machine moet draaien
• Volledige isolatie tussen omgevingen vereist is
• Je een ander OS moet draaien dan je host (Windows op Linux, etc.)
• Elke omgeving verschillende kernel versies nodig heeft

Gebruik niet wanneer:

• Al je workloads hetzelfde OS gebruiken (containers zijn efficiënter)
• Maximale performance kritiek is
• Resources erg beperkt zijn

Voorbeelden:

• Windows en Linux op dezelfde server draaien
• Development omgevingen die matchen met productie
• Testen op verschillende OS versies
• Multi-tenant hosting met volledige isolatie

Containers

Gebruik wanneer:

• Alle workloads dezelfde OS kernel kunnen delen
• Je lichtgewicht, snelle isolatie nodig hebt
• Je veel vergelijkbare applicaties deployt
• Resource-efficiëntie belangrijk is
• Snelle opstarttijden ertoe doen

Gebruik niet wanneer:

• Je een ander OS moet draaien (kan geen Windows containers op Linux kernel draaien)
• Je absolute security isolatie nodig hebt (VMs zijn meer geïsoleerd)
• Je software kernel modificaties vereist

Voorbeelden:

• Microservices architecturen
• CI/CD pipelines
• Lokale development omgevingen
• Kubernetes workloads
• Web applicaties schalen

De Gelaagde Realiteit

In de praktijk worden deze technologieën vaak gecombineerd:

flowchart TD
    subgraph layers["Technologie Lagen"]
        App["Jouw Applicatie<br/>(Container)"]
        Runtime["Container Runtime<br/>(Docker/containerd)"]
        GuestOS["Guest OS - Linux<br/>(Virtual Machine)"]
        Hypervisor["Hypervisor<br/>(Virtualisatie)"]
        HostOS["Host OS"]
        Hardware["Fysieke Hardware"]
        App --> Runtime
        Runtime --> GuestOS
        GuestOS --> Hypervisor
        Hypervisor --> HostOS
        HostOS --> Hardware
    end

Je zou containers kunnen draaien in virtual machines in fysieke servers. Elke laag voegt overhead toe, maar voegt ook mogelijkheden en isolatie toe.

Cloud providers doen dit constant: jouw “server” is een VM op hun hardware, en je draait containers in die VM.

Veelvoorkomende Verwarring

“Docker is een virtual machine”

Nee. Docker containers delen de kernel van de host. VMs hebben hun eigen kernel. Daarom starten Docker containers in seconden (geen kernel om te booten) terwijl VMs minuten duren.

“Emulatie is gewoon trage virtualisatie”

Nee. Ze lossen verschillende problemen op. Emulatie vertaalt één architectuur naar een andere (Game Boy → PC). Virtualisatie draait dezelfde architectuur efficiënter (x86 → x86).

Een PC kan Linux op Linux zeer efficiënt virtualiseren. Maar het moet een Game Boy emuleren — er is geen Game Boy hardware om te virtualiseren.

“Containers zijn veilige isolatie”

Gedeeltelijk. Containers bieden proces isolatie, maar ze delen een kernel. Een kernel kwetsbaarheid zou container escape mogelijk kunnen maken. VMs bieden sterkere isolatie omdat ze geen kernel delen.

Voor high-security workloads hebben VMs nog steeds de voorkeur. Voor typische workloads zijn containers prima.

“Simulatie en emulatie zijn hetzelfde”

Nee. Simulatie modelleert gedrag bij benadering. Emulatie repliceert gedrag exact.

Een vluchtsimulator simuleert vliegtuigfysica. Een Game Boy emulator emuleert exact hardwaregedrag — de games draaien echt.

De Bottom Line

Wanneer iemand je vraagt om deze concepten uit te leggen:

• Simulatie: Een kookshow — je ziet wat er zou gebeuren, maar er draait niks echt
• Emulatie: Een Japans restaurant in het buitenland — compleet repliceren hoe iets anders werkt
• Virtualisatie: Hotel restaurants — echte, complete, geïsoleerde restaurants die gebouwinfrastructuur delen
• Containers: Food court — geïsoleerde verkopers die één keuken delen

Elk heeft z’n plek. Simulaties voor modelleren. Emulatie voor het draaien van vreemde software. Virtualisatie voor het draaien van verschillende besturingssystemen. Containers voor het efficiënt draaien van veel vergelijkbare applicaties.

En nu kun je het aan iedereen uitleggen — geen hypervisor terminologie nodig.