Introductie
Containers zijn niet meer weg te denken uit het moderne IT landschap. Maar heel af en toe kom ik nog wel eens bij een bedrijf over de vloer waar ze containers nog niet kennen. Ik heb het dan niet over die grote stalen bakken die ze op schepen gebruiken, maar over docker- of software containers. In deze blog leg ik uit wat containers zijn, waar ze vandaan komen en welk probleem het gebruik van containers oplost. Om gelijk maar te beginnen met een definitie:
Containers zijn draagbare, geïsoleerde en gecontroleerde en omgevingen waarin software applicaties kunnen draaien.
Dat klinkt al gelijk lekker vaag, hè? Lees snel verder, want hieronder leg ik uit hoe dit er in de praktijk uit ziet.
Welk probleem lossen containers op?
Als je in de IT of met software ontwikkelaars werkt, dan herken je waarschijnlijk de volgende situatie: Je probeert een vers stukje software op je computer te installeren maar het werkt niet. Je krijgt het niet geïnstalleerd of de software doet iets heel anders dan verwacht. Wanneer je verhaal gaat halen bij de auteur van de code, krijg je de volgende reactie:
“Wat gek! Op mijn computer werkte het wèl.”
– Elke software ontwikkelaar op aarde
Voor je het weet beland je in een welles-nietes-discussie en begint het ongemakkelijke proces van uitzoeken wat er mis gaat (en wie de fout heeft gemaakt). En stel je dan eens voor dat dit niet bij jou, maar bij een klant gebeurt! Absoluut een situatie die je het liefst wilt voorkomen. Maar hoe?
Laten we nog even terug naar het probleem. Een stukje software wordt in bijna alle gevallen sterk beïnvloed door de context waarop hij draait. Vaak haalt hij afhankelijkheden (e.g. software-bibliotheken om bepaalde code te kunnen uitvoeren) uit het gastsysteem. Waarschijnlijk ziet jouw laptop er heel anders uit dan de laptop van je collega, laat staan van een willekeurige server in de Cloud. Wanneer er afhankelijkheden missen of verouderd zijn, kan het gebeuren dat de software zijn werk niet kan doen.
Een analogie
De naam van een ‘container’ doet al snel denken aan zo’n stalen bak die ze gebruiken om goederen te transporteren. Deze transportcontainer wordt vaak gebruikt als analogie, omdat het ook een geïsoleerde en draagbare omgeving is. Maar ik wil in deze blog eens een ander voorbeeld gebruiken.
Zo kun je software ook vergelijken met een trein. Een trein is afhankelijk van een rails om te kunnen rijden. Een trein op een rails krijgen is moeilijk. Een trein is zwaar en het oppervlak met de rails is klein. De rails is de context waarin de software draait in deze vergelijking. De rails is specifiek gemaakt voor de trein en ook kwetsbaar. Net zoals bij computers, kan er over tijd van alles mis gaan met de rails: Er is een wissel vastgevroren of er liggen er blaadjes op de weg. Dan rijdt de trein niet meer. Het aanleggen van een rails is duur en tijdrovend, net als het instellen van je hardware.
Door containers scheid je het hele concept ‘rails’ van de trein. Het is alsof je een set banden monteert aan de onderkant van de train waardoor de trein nu in één keer overal kan rijden, ongeacht of er rails ligt. De banden regelen het contact met de grond (de context), waar eerder de rails verantwoordelijk voor was. Hierdoor is een trein niet meer afhankelijk van de rails en kan deze rijden waar het ook maar enigszins begaanbaar is.
Waar komen containers vandaan?
Om te begrijpen wat containers zijn, moeten we eerst begrijpen waar containers vandaan komen. Het begint allemaal met een concept wat al heel oud is, maar wat pas 20 jaar geleden (met de opkomst van de moderne computer) een enorme vlucht heeft genomen: virtualisatie.
Op praktisch elke computer (e.g. laptop, PC, server) draait een besturingssysteem. Waarschijnlijk gebruik je Windows of iOS. Het besturingssysteem moet nauw samenwerken met de hardware. Tijdens de installatie van een besturingssysteem, wordt goed gekeken naar de onderliggende hardware en past het besturingssysteem zich hierop aan. Normaliter kan er maar één besturingssysteem tegelijkertijd gebruik maken van de hardware.
Door virtualisatie wordt de één-op-één relatie van de hardware met je software gescheiden. Hierdoor wordt het mogelijk om niet één, maar een onbeperkt aantal besturingssystemen op de hardware tegelijkertijd te draaien. Dit wordt gefaciliteerd door een zogenaamde hypervisor, een stuk software die dit voor je regelt zoals VMWare of Microsoft Hyper-v. Om terug te gaan naar onze analogie met de trein: de hypervisor zorgt voor een goed wegdek, zodat je trein(en) overal kunnen rijden.
Deze onafhankelijke besturingssystemen heten virtuele machines. Stel je eens voor dat je met 100 man tegelijkertijd met een verschillend besturingssysteem op dezelfde hardware aan het werk bent. Er draaien 100 virtuele machine op slechts één fysieke machine. Dat is op dit moment al de dagelijkse realiteit van de Cloud.
Het grote voordeel van virtuele machines is de draagbaarheid. Je kunt deze gewoon kopiëren of herstellen. Heb je wel eens een fout gemaakt op je computer die je niet gemakkelijk meer kon herstellen? Bijvoorbeeld door iets te de-installeren of te verwijderen? Een virtuele machine kun je gemakkelijk opslaan en herstellen naar een punt terug in tijd.
Een pakketje met afhankelijkheden
Maar wat heeft dit te maken met containers? Containers zijn voor applicaties wat virtuele machines zijn voor besturingssystemen. Containers scheidden applicaties van het besturingssysteem. Het besturingssysteem hoeft alleen maar te weten hoe hij een container kan draaien door middel van de container-runtime. De container regelt de rest.
Nog te vaag? Laten we het concreet maken.
Een container is eigenlijk een pakketje met slechts de benodigde afhankelijkheden van een stukje software en de software zelf. Wat je in de container stopt kun je helemaal zelf bepalen. Heb je een applicatie die draait op PHP? Dan kun je deze in een PHP image stoppen waarin alle software beschikbaar is om een PHP applicatie te draaien. Of wil je snel even gebruik maken van een CLI tool, zoals de Azure CLI, zonder deze te hoeven installeren? Dan kun je gebruik maken van de voorgebakken Azure CLI image
De software staat samen met alles wat hij nodig heeft om te draaien, op één plek (in de vorm van een blob/binary bestand). Je kunt een container direct opstarten met behulp van containersoftware, waarvan de meest bekende variant Docker is.
Voordelen van containers
Containers hebben bepaalde eigenschappen waardoor ze aantrekkelijk zijn. Ze zijn erg draagbaar. Je kunt ze namelijk overal draaien waar containers ondersteund worden. Daarnaast zijn ze erg vluchtig (ephemeral): ze houden geen staat bij. Dit maakt ze ‘goedkoop’. Wanneer een container over tijd kapot gaat kun je deze simpelweg verwijderen en weer een nieuwe starten. Door de manier waarop containers werken heb je een garantie dat de software weer werkt naar behoren.
Ook zijn containers veilig, omdat het geïsoleerde processen zijn op je computer. Binnen de container heeft de software alle mogelijke (admin) rechten, maar buiten de container, op het gastsysteem, weer niet. Daarnaast zijn containers erg snel. Als je al een container-runtime hebt geïnstalleerd, dan is er verder geen installatie nodig. Je kunt de container direct uitvoeren. Omdat containers geïsoleerde processen zijn, is er ook bijna geen opstarttijd nodig.
De toepassingen zijn eindeloos: je kunt een webapplicatie in een container draaien. Je kunt dezelfde webapplicatie meerdere keren naast elkaar of op verschillende servers draaien, zodat de bezoekerslast wordt verdeeld over verschillende hardware. Je kunt heel snel command-line tools gebruiken die bijv. kunnen interacteren met een API, zonder dat je die tool zelf op je computer hoeft te installeren. Je kunt in een paar seconde een Bitcoin miner starten, zonder dat je je zorgen hoeft te maken of de software die er in draait ook echt schadelijk is voor je gastsysteem.
Samenvattend
Het belangrijkste probleem dat een container oplost is het betrouwbaar en eenvoudig verplaatsen van een applicatie van de ene naar de andere omgeving. Als ik de container met software op mijn computer kan draaien, dan heb ik een garantie dat de container het ook op jouw computer doet. Het enige wat jij dus hoeft te doen, is een container runtime (e.g. Docker) op je computer te installeren, de container te downloaden en te starten. Die ongemakkelijke discussies behoren voor altijd tot het verleden.
Zo wordt het uitwisselen van software wel erg gemakkelijk.