In de wereld van de moderne softwareontwikkeling zijn efficiëntie en consistentie essentieel. Ontwikkelaars en operationele teams hebben oplossingen nodig die hen helpen bij het beheren, implementeren en uitvoeren van toepassingen naadloos over verschillende omgevingen.

Containers en Docker zijn technologieën die hebben gerevolutioneerd hoe software wordt gebouwd, getest en geïmplementeerd.

Of je nu nieuw bent in de wereld van technologie of gewoon de basisprincipes van Docker wilt begrijpen, zal dit artikel je door de essentie leiden.

Inhoudsopgave

Wat zijn containers?

Voordat we ons verdiepen in Docker, laten we eerst containers begrijpen. Stel je voor dat je aan een project werkt en je toepassing perfect werkt op je laptop. Maar wanneer je dezelfde toepassing probeert uit te voeren op een ander apparaat, mislukt het. Dit komt vaak door verschillen in omgevingen: verschillende besturingssystemen, geïnstalleerde softwareversies of configuraties.

Containers lossen dit probleem op door een toepassing en al zijn afhankelijkheden zoals bibliotheken, frameworks en configuratiebestanden te verpakken in een enkele, gestandaardiseerde eenheid. Hierdoor wordt gegarandeerd dat de toepassing overal hetzelfde draait, of het nu op je laptop, een server of in de cloud is.

Kenmerken van containers:

  • Lichtgewicht: Containers delen de kernel van het hostbesturingssysteem, in tegenstelling tot virtuele machines (VM’s) die aparte OS-instanties vereisen, waardoor ze sneller en efficiënter zijn.

  • Verplaatsbaar: Eenmaal gebouwd kan een container consistent draaien in verschillende omgevingen.

  • Geïsoleerd: Containers draaien in geïsoleerde processen, wat betekent dat ze niet interfereren met andere applicaties die op hetzelfde systeem draaien.

Wat is Docker?

Nu we containers begrijpen, laten we het hebben over Docker, het platform dat containers mainstream heeft gemaakt.

Docker is een open-source tool ontworpen om het proces van het maken, beheren en implementeren van containers te vereenvoudigen. Gelanceerd in 2013, is Docker snel de standaardoplossing voor containerisatie geworden vanwege het gebruiksgemak, de communityondersteuning en het krachtige ecosysteem van tools.

Kernconcepten in Docker

  1. Docker Images: Denk aan een Docker image als een blauwdruk voor je container. Het bevat alles wat nodig is om de applicatie uit te voeren, inclusief code, bibliotheken en systeemafhankelijkheden. Images worden gebouwd vanuit een reeks instructies geschreven in een Dockerfile.

  2. Docker Containers: Een container is een draaiend exemplaar van een Docker-image. Wanneer je een container maakt en start, lanceert Docker het image in een geïsoleerde omgeving waar je applicatie kan draaien.

  3. Dockerfile: Dit is een tekstbestand dat de stappen bevat die nodig zijn om een Docker-image te maken. Hiermee bepaal je hoe je container eruit zal zien, inclusief het basisimage, applicatiecode en eventuele aanvullende afhankelijkheden.

  4. Docker Hub: Docker Hub is een openbaar register waar ontwikkelaars vooraf gebouwde images kunnen delen en openen. Als je werkt aan een veelvoorkomende applicatie of technologiestack, is de kans groot dat er al een image beschikbaar is op Docker Hub, wat je tijd bespaart.

  5. Docker Compose: Voor toepassingen die meerdere containers vereisen (bijvoorbeeld een webserver en een database), maakt Docker Compose het mogelijk om meerdere-containeromgevingen te definiëren en beheren met behulp van een eenvoudig YAML-bestand.

Waarom Docker?

De populariteit van Docker komt voort uit zijn vermogen om verschillende uitdagingen aan te pakken waar ontwikkelaars vandaag de dag mee te maken hebben:

  • Consistentie tussen omgevingen: Ontwikkelaars kunnen “build once, run anywhere” toepassen, waardoor dezelfde toepassing op dezelfde manier werkt in verschillende omgevingen, van lokale ontwikkeling tot productie.

  • Snelheid: Docker-containers starten en stoppen snel, waardoor ze ideaal zijn voor test- en implementatiepijplijnen.

  • Efficiënt gebruik van resources: Aangezien containers de resources van het host systeem effectiever delen dan virtuele machines, verminderen ze overhead en zorgen ze voor een grotere dichtheid in implementaties.

  • Versiebeheer voor Uw Applicaties: Docker stelt u in staat om versiebeheer toe te passen op niet alleen uw code maar ook de omgeving waarin uw code wordt uitgevoerd. Dit is met name handig voor het terugzetten naar eerdere versies of het oplossen van problemen in productie.

Docker Architectuur

Wanneer u voor het eerst Docker gaat gebruiken, kunt u het behandelen als een “kant-en-klaar” oplossing. Hoewel dat prima is om te beginnen, zal een dieper inzicht in de architectuur van Docker u helpen bij het oplossen van problemen, het optimaliseren van prestaties en het nemen van geïnformeerde beslissingen over uw containerisatiestrategie.

De architectuur van Docker is ontworpen om efficiëntie, flexibiliteit en schaalbaarheid te waarborgen. Het bestaat uit verschillende componenten die samenwerken om containers te maken, beheren en uit te voeren. Laten we elk van deze componenten eens nader bekijken.

Docker Architectuur: Belangrijkste Componenten

De architectuur van Docker is opgebouwd rond een client-servermodel dat de volgende componenten omvat

  • Docker Client

  • Docker Daemon (dockerd)

  • Docker Engine

  • Docker Images

  • Docker Containers

  • Docker Registries

1. Docker Client

De Docker Client is de primaire manier waarop gebruikers met Docker communiceren. Het is een opdrachtregelhulpmiddel dat instructies naar de Docker Daemon (waar we het zo meteen over zullen hebben) stuurt via REST API’s. Opdrachten zoals docker build, docker pull en docker run worden uitgevoerd vanuit de Docker Client.

Wanneer je een opdracht typt zoals docker run nginx, vertaalt de Docker Client dit naar een verzoek dat de Docker Daemon kan begrijpen en waarop kan reageren. De Docker Client fungeert in feite als een front-end voor de interactie met de meer complexe backend-onderdelen van Docker.

2. Docker Daemon (dockerd)

De Docker Daemon, ook bekend als dockerd, is het brein van de gehele Docker-operatie. Het is een achtergrondproces dat luistert naar verzoeken van de Docker Client en Docker-objecten zoals containers, images, netwerken en volumes beheert.

Dit is waar de Docker Daemon verantwoordelijk voor is

  • Containers bouwen en uitvoeren: Wanneer de client een opdracht stuurt om een container uit te voeren, haalt de daemon het image op, maakt de container aan en start deze.

  • Het beheren van Docker-resources: De daemon behandelt taken zoals netwerkconfiguraties en volumemanagement.

  • De Docker Daemon draait op de hostmachine en communiceert met de Docker Client via een REST API, Unix-sockets of een netwerkinterface. Het is ook verantwoordelijk voor de interactie met container runtimes, die de daadwerkelijke uitvoering van containers afhandelen.

3. Docker Engine

De Docker Engine is het kernonderdeel van Docker. Het is wat het hele platform laat werken, waarbij de client, daemon en container-runtime worden gecombineerd. Docker Engine kan draaien op verschillende besturingssystemen, waaronder Linux, Windows en macOS.

Er zijn twee versies van de Docker Engine

  • Docker CE (Community Edition): Dit is de gratis, open-source versie van Docker die veel wordt gebruikt voor persoonlijke en kleinschalige projecten.

  • Docker EE (Enterprise Edition): De betaalde, zakelijke versie van Docker wordt geleverd met extra functies zoals verbeterde beveiliging, ondersteuning en certificering.

De Docker Engine vereenvoudigt de complexiteiten van containerorchestratie door de verschillende componenten te integreren die nodig zijn om containers te bouwen, uit te voeren en te beheren.

4. Docker Images

Een Docker Image is een alleen-lezen sjabloon dat alles bevat wat uw toepassing nodig heeft om te draaien – code, bibliotheken, afhankelijkheden en configuraties. Images zijn de bouwstenen van containers. Wanneer u een container uitvoert, maakt u in feite een beschrijfbare laag bovenop een Docker-image.

Docker Images worden meestal gebouwd vanuit Dockerfiles, dit zijn tekstbestanden met instructies over hoe het image moet worden gebouwd. Bijvoorbeeld, een basis Dockerfile kan beginnen met een basismodel zoals nginx of ubuntu en opdrachten bevatten om bestanden te kopiëren, afhankelijkheden te installeren of omgevingsvariabelen in te stellen.

Hier is een eenvoudig voorbeeld van een Dockerfile

dockerfileCopy codeFROM nginx:latest
COPY ./html /usr/share/nginx/html
EXPOSE 80

In dit voorbeeld gebruiken we het officiële Nginx-image als basis en kopiëren we onze lokale HTML-bestanden naar de webdirectory van de container.

Zodra het image is gebouwd, kan het worden opgeslagen in een Docker Registry en gedeeld worden met anderen.

5. Docker Containers

Een Docker Container is een draaiende instantie van een Docker Image. Het is lichtgewicht en geïsoleerd van andere containers, maar het deelt de kernel van het hostbesturingssysteem. Elke container heeft zijn eigen bestandssysteem, geheugen, CPU-toewijzing en netwerkinstellingen, wat het draagbaar en reproduceerbaar maakt.

Containers kunnen worden gemaakt, gestart, gestopt en vernietigd, en ze kunnen zelfs worden behouden tussen herstarts. Omdat containers zijn gebaseerd op images, zorgen ze ervoor dat applicaties zich overal hetzelfde gedragen.

Enkele belangrijke kenmerken van Docker-containers:

  • Isolatie: Containers zijn geïsoleerd van elkaar en de host, maar ze delen nog steeds hetzelfde OS-kernel.

  • Portabiliteit: Containers kunnen overal worden uitgevoerd, of het nu op uw lokale machine, een virtuele machine of een cloudprovider is.

6. Docker-registers

Een Docker-register is een centrale plaats waar Docker-images worden opgeslagen en gedistribueerd. Het meest populaire register is Docker Hub, dat miljoenen openbaar beschikbare images host. Organisaties kunnen ook privé-registers opzetten om hun eigen images veilig op te slaan en te distribueren.

Docker-registers bieden verschillende belangrijke functies:

  • Image-versiebeheer: Images worden versiebeheerd met tags, waardoor het gemakkelijk is om verschillende versies van een applicatie te beheren.

  • Toegangscontrole: Registries kunnen openbaar of privé zijn, met op rollen gebaseerde toegangscontrole om te beheren wie afbeeldingen kan ophalen of pushen.

  • Distributie: Afbeeldingen kunnen worden opgehaald uit een registry en overal worden ingezet, waardoor het gemakkelijk wordt om gecontaineriseerde toepassingen te delen en hergebruiken.

Container Runtime van Docker: containerd

Een belangrijke recente ontwikkeling in de architectuur van Docker is het gebruik van containerd. Docker had vroeger zijn eigen container runtime, maar maakt nu gebruik van containerd, een container runtime die de industriestandaarden volgt en ook wordt gebruikt door andere platforms zoals Kubernetes.

  1. containerd is verantwoordelijk voor

    • Starten en stoppen van containers

    • Beheren van opslag en netwerken voor containers

    • Afbeeldingen van containers ophalen uit registries

Door de container-runtime te scheiden van de hoger niveau-functionaliteit van Docker, is Docker modulairder geworden, waardoor andere tools containerd kunnen gebruiken terwijl Docker zich richt op gebruikersgerichte functies.

Hoe je een eenvoudige container maakt met behulp van Docker

Haal de Linux Image op

Begin met het ophalen van de alpine image van Docker Hub. De alpine image is een minimale Linux distributie, ontworpen om lichtgewicht en snel te zijn.

Voer het volgende commando uit:

docker pull alpine

Dit zal de alpine image downloaden naar je lokale systeem.

Start de Container

Maak en start een container met behulp van de alpine image. We zullen ook een terminalsessie binnen de container starten.

docker run -it alpine /bin/sh

Dit is wat elke optie betekent:

  • docker run: Maakt een nieuwe container aan en start deze.

  • -it: Hiermee kun je communiceren met de container (interactieve modus + terminal).

  • alpine: Specificeert de te gebruiken image.

  • /bin/sh: Specificeert het commando dat binnen de container moet worden uitgevoerd (een shell-sessie in dit geval).

Verken de Container

Zodra de container draait, zie je een shell-prompt die er ongeveer zo uitziet

/ #

Dit geeft aan dat je binnenin de Alpine Linux-container bent. Je kunt nu Linux-opdrachten uitvoeren. Bijvoorbeeld:

Controleer de huidige directory:

pwd

Bestanden in de directory weergeven:

ls

Uitvoer: Een minimale directorystructuur, omdat Alpine een lichte image is.

Je kunt ook een pakket installeren (Alpine gebruikt apk als pakketbeheerder):

apk add curl

Verlaat de Container

Als je klaar bent met verkennen, typ je exit om de sessie te sluiten en de container te stoppen

bashCopy codeexit

Toegang tot de Container Nadat Deze Gestopt Is

Als je de container opnieuw wilt benaderen nadat je deze hebt gestopt, kun je deze opdracht gebruiken om alle containers (inclusief gestopte) weer te geven:

docker ps -a

Je ziet een lijst met containers met hun ID’s en statussen, en vervolgens kun je de gestopte container starten:

docker start <container-id>

Je kunt verbinding maken met de shell van de container met deze opdracht:

docker exec -it <container-id> /bin/sh

Als je de container niet meer nodig hebt, kun je deze verwijderen

  1. Stop de container (indien deze nog steeds actief is):

     docker stop <container-id>

  2. Verwijder de container:

     docker rm <container-id>

Belangrijkste Docker-commando’s overzicht

Commando Beschrijving
docker pull alpine Downloadt het Alpine Linux-image.
docker run -it alpine /bin/sh Creëert en start een interactieve container.
docker ps -a Geeft een lijst van alle containers (draaiend en gestopt).
docker start <container-id> Start een gestopte container.
docker exec -it <container-id> Koppelt aan een draaiende container.
docker stop <container-id> Stopt een draaiende container.
docker rm <container-id> Verwijdert een gestopte container.

Samenvatting

Nu je een basisbegrip hebt, is het tijd om je kennis in de praktijk te brengen. Begin met experimenteren met Docker, bouw je eerste container en verken zijn uitgebreide ecosysteem.

Je zult al snel zien waarom Docker een hoeksteen is geworden van moderne DevOps en software engineering.

Je kunt me volgen op