Docker voor Beginners: Een Praktische Gids voor Containers

Basisconcepten van Docker

Nu je Docker hebt geïnstalleerd, ben je misschien enthousiast om direct aan de slag te gaan en containers te draaien. Maar voordat we dat doen, is het belangrijk om een paar kernconcepten te begrijpen die de basis vormen van het functioneren van Docker. Deze concepten helpen je om Docker effectiever te navigeren en veelvoorkomende beginnersfouten te vermijden.

Het hart van Docker zijn afbeeldingen, die dienen als blauwdrukken voor containers; containers, de actieve instanties van deze afbeeldingen; en Docker Hub, een gecentraliseerd repository voor het delen en beheren van afbeeldingen.

Laten we elk van deze concepten meer in detail verkennen.

Docker-afbeeldingen

Docker-afbeeldingen zijn de fundamentele bouwstenen van containers. Ze zijn onveranderlijk, alleen-lezen sjablonen die alles bevatten wat nodig is om een applicatie uit te voeren, inclusief het besturingssysteem, toepassingscode, runtime en afhankelijkheden.

Afbeeldingen worden gebouwd met behulp van een Dockerfile, die de instructies definieert voor het maken van een afbeeldingslaag voor laag.

Afbeeldingen kunnen worden opgeslagen in en opgehaald worden uit containerregistries zoals Docker Hub.

Hier zijn enkele voorbeeldopdrachten voor het werken met afbeeldingen:

• docker pull nginx: Haal de nieuwste Nginx-afbeelding op van Docker Hub.
• docker images: Lijst alle beschikbare afbeeldingen op de lokale machine op.
• docker rmi nginx: Verwijder een afbeelding van de lokale machine.

Docker-containers

Een Docker-container is een draaiende instantie van een Docker-afbeelding. Containers bieden een geïsoleerde runtime-omgeving waarin applicaties kunnen worden uitgevoerd zonder elkaar of het host systeem te verstoren. Elke container heeft zijn eigen bestandssysteem, netwerk en procesruimte maar deelt de hostkernel.

Containers volgen een eenvoudige levenscyclus met creatie, starten, stoppen en verwijderen. Hier is een overzicht van veelvoorkomende opdrachten voor het beheer van containers:

1. Het maken van een container: docker create of docker run
2. Het starten van een container: docker start
3. Het stoppen van een container: docker stop
4. Het herstarten van een container: docker restart
5. Het verwijderen van een container: docker rm

Laten we een praktisch voorbeeld bekijken. Het volgende commando start een Nginx-container in detached modus (op de achtergrond), waarbij poort 80 binnen de container wordt toegewezen aan poort 8080 op de hostmachine:

docker run -d -p 8080:80 nginx

Na het uitvoeren van dit commando zal Docker de Nginx-image ophalen (indien nog niet beschikbaar), een container maken en starten.

Om alle actieve en gestopte containers te controleren:

docker ps -a

Dit zal een lijst weergeven van alle containers en details zoals hun status en toegewezen poorten.

Docker Hub

Docker Hub is een cloudgebaseerde registratiedienst voor het vinden, opslaan en distribueren van containerafbeeldingen. Gebruikers kunnen aangepaste afbeeldingen naar Docker Hub pushen en deze openbaar of privé delen.

Hier zijn enkele commando’s voor het werken met Docker Hub:

• docker login: Authenticeren met Docker Hub.
• docker push my-image: Een op maat gemaakte afbeelding uploaden naar Docker Hub.
• docker search ubuntu: Zoeken naar officiële en community-afbeeldingen.
• docker pull ubuntu: Een Ubuntu-afbeelding downloaden van Docker Hub.

Nieuw in containerisatie? Krijg een solide basis met de cursus Concepten van Containerisatie en Virtualisatie.

Je eerste Docker-container uitvoeren

Nu we de kernconcepten van Docker hebben behandeld, is het tijd om ze in de praktijk te brengen! Laten we beginnen met het uitvoeren van onze eerste container om ervoor te zorgen dat Docker correct is geïnstalleerd en werkt zoals verwacht.

Om je Docker-installatie te testen, open PowerShell (Windows) of Terminal (Mac en Linux) en voer uit:

docker run hello-world

Dit haalt de hello-world afbeelding op van DockerHub en voert deze uit in een container.

Voorbeeld van Docker hello-world afbeelding

Laten we nu een stap verder gaan en een real-world toepassing uitvoeren – een Nginx-webserver. Voer de volgende opdracht uit:

docker run -d -p 8080:80 nginx

De bovenstaande opdracht doet het volgende:

• De -d vlag voert de container uit in detached modus, wat betekent dat deze op de achtergrond draait.
• De -p 8080:80 vlag koppelt poort 80 in de container aan poort 8080 op uw lokale machine, waardoor u toegang heeft tot de webserver.

Zodra de opdracht succesvol wordt uitgevoerd, open een browser en bezoek: http://localhost:8080

Toegang tot de webserver op localhost:8080

U zou de standaard welkomstpagina van Nginx moeten zien, wat bevestigt dat uw webserver binnen een container draait!

U zult ook een container zien draaien in uw Docker Desktop:

Nginx-container draait op poort 8080

Het bouwen van uw eerste Docker-image

Tot nu toe hebben we vooraf gebouwde afbeeldingen van Docker Hub gebruikt. Maar wat als je een aangepaste omgeving nodig hebt die is afgestemd op jouw toepassing? Dat is waar het bouwen van je eigen Docker-image van pas komt.

Het maken van een Docker-image omvat het schrijven van een Dockerfile, een script dat het bouwen van de afbeelding automatiseert. Dit zorgt voor consistentie en draagbaarheid over verschillende omgevingen. Zodra een image is gebouwd, kan het worden uitgevoerd als een container om toepassingen in een geïsoleerde omgeving uit te voeren.

In dit gedeelte zullen we de basisprincipes leren van het schrijven van een Dockerfile, het bouwen van een aangepaste image en het uitvoeren ervan als een container.

Dockerfile basis

Een Dockerfile is een script dat een reeks instructies bevat die definiëren hoe een Docker-image wordt gebouwd. Het automatiseert het proces van het maken van de image, waardoor consistentie in verschillende omgevingen wordt gewaarborgd. Elke instructie in een Dockerfile creëert een nieuwe laag in de image. Hier is een uitsplitsing van een voorbeeld Dockerfile voor een eenvoudige Python Flask-app:

# Basisafbeelding met de Python-runtime
FROM python:3.9

# Stel de werkdirectory in binnen de container
WORKDIR /app

# Kopieer de applicatiebestanden van de host naar de container
COPY . /app

# Installeer de afhankelijkheden vermeld in requirements.txt
RUN pip install -r requirements.txt

# Definieer het commando om de Flask-app uit te voeren wanneer de container start
CMD ["python", "app.py"]

In het bovenstaande commando:

• -v my-volume:/app/data koppelt de opslag my-volume aan de directory /app/data binnen de container.
• Gegevens die zijn opgeslagen in /app/data blijven bestaan, zelfs als de container stopt of wordt verwijderd.

Uitsplitsing van de bovenstaande Dockerfile:

• FROM python:3.9: Geeft de basisimage aan met Python 3.9 vooraf geïnstalleerd.
• WORKDIR /app: Stelt /app in als de werkdirectory binnen de container.
• COPY . /app: Kopieert alle bestanden van de huidige map van de host naar /app in de container.
• RUN pip install -r requirements.txt: Installeert alle vereiste afhankelijkheden binnen de container.
• CMD ["python", "app.py"]: Definieert het commando dat moet worden uitgevoerd wanneer de container wordt gestart.

Het bouwen en uitvoeren van de image

Zodra de Dockerfile is gedefinieerd, kunt u het image bouwen en uitvoeren met behulp van de volgende commando’s:

Stap 1: Bouw het image

docker build -t my-flask-app .

Het bovenstaande commando:

• Gebruikt de huidige directory (.) als de build-context.
• Leest het Dockerfile en voert de instructies uit.
• Tagt (-t) het resulterende image als my-flask-app.

Stap 2: Voer het image uit als een container

docker run -d -p 5000:5000 my-flask-app

Het bovenstaande commando:

• Voert de container uit in detached mode (-d).
• Maakt poort 5000 binnen de container overeenkomstig met poort 5000 op de host (-p 5000:5000).

Als het eenmaal draait, kun je de Flask-toepassing openen door naar http://localhost:5000 te gaan in een browser.

Docker Volumes en Persistentie

Standaard is data binnen een Docker-container tijdelijk—zodra de container stopt of verwijderd wordt, verdwijnt de data. Om data persistent te houden bij het opnieuw starten van containers en om het te delen tussen meerdere containers, biedt Docker volumes, een ingebouwd mechanisme voor efficiënt beheer van persistent opslag.

In tegenstelling tot het opslaan van gegevens in het bestandssysteem van de container, worden volumes afzonderlijk beheerd door Docker, waardoor ze efficiënter, flexibeler en gemakkelijker te back-uppen zijn.

In het volgende gedeelte zullen we verkennen hoe we Docker-volumes kunnen maken en gebruiken om gegevenspersistentie in uw containers te waarborgen.

Docker-volumes maken en gebruiken

Stap 1: Maak een volume

Voordat we een volume kunnen gebruiken, moeten we er een maken. Voer de volgende opdracht uit:

docker volume create my-volume

Dit maakt een genoemd volume genaamd my-volume, dat Docker afzonderlijk zal beheren van een specifieke container.Stap 2: Gebruik het volume in een container

Nu gaan we een container starten en het volume erin koppelen:

docker run -d -v my-volume:/app/data my-app

In de bovenstaande opdracht:

• -v my-volume:/app/data koppelt de opslag my-volume aan de map /app/data binnen de container.
• Alle gegevens opgeslagen in /app/data blijven behouden, zelfs als de container stopt of wordt verwijderd.

Docker Compose voor Multi-Container Applicaties

Tot nu toe hebben we gewerkt met single-container applicaties, maar veel real-world applicaties vereisen meerdere containers die samenwerken. Bijvoorbeeld, een webapplicatie kan een backend server, een database en een caching laag nodig hebben—elke draaiend in zijn eigen container. Het handmatig beheren van deze containers met aparte docker run commando’s kan al snel vervelend worden.

Dat is waar Docker Compose van pas komt.

Wat is Docker Compose?

Docker Compose is een tool die het beheer van multi-container applicaties vereenvoudigt. In plaats van meerdere docker run commando’s uit te voeren, kun je een volledige applicatiestack definiëren met behulp van een docker-compose.yml bestand en implementeren met één enkel commando.

Het schrijven van een Docker Compose bestand

Latenn we nu een praktijkvoorbeeld creëren—een eenvoudige Node.js applicatie die verbinding maakt met een MongoDB database. In plaats van de twee containers afzonderlijk te beheren, zullen we ze definiëren in een docker-compose.yml bestand.

Zo definiëren we onze multi-container setup in Docker Compose:

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database
  database:
    image: mongo
    volumes:
      - db-data:/data/db
volumes:
  db-data:

Het bestand hierboven uitgesplitst:

• version: '3': Specificeert de Docker Compose versie.
• services:: Definieert individuele services (containers).
• web:: Definieert de Node.js webapplicatie.
• database:: Definieert de MongoDB database container.
• volumes:: Maakt een genoemde volume (db-data) aan voor MongoDB data persistentie.

Het draaien van multi-container applicaties

Zodra het docker-compose.yml bestand gereed is, kunnen we de volledige applicatiestack starten met één commando:

docker-compose up -d

Het vorige commando start zowel de web- als database containers in detached mode (-d).

Om alle services te stoppen, gebruik:

docker-compose down

Dit stopt en verwijdert alle containers terwijl volumes en netwerkinstellingen behouden blijven.

Docker Netwerk Basics

Tot nu toe hebben we ons gericht op het draaien van containers en het beheren van opslag, maar wat gebeurt er wanneer containers met elkaar moeten communiceren? In de meeste real-world toepassingen werken containers niet geïsoleerd – ze moeten gegevens uitwisselen, of het nu een webserver is die communiceert met een database of microservices die met elkaar interageren.

Docker biedt een scala aan netwerkmogelijkheden om verschillende use cases te accommoderen, van geïsoleerde interne netwerken tot extern toegankelijke configuraties.

Klaar om je Docker vaardigheden naar een hoger niveau te tillen? Schrijf je in voor Intermediate Docker om multi-stage builds, geavanceerde netwerkopties en meer te verkennen!

Wat is Docker networking?

Docker networking is een ingebouwde functie die containers in staat stelt om met elkaar te communiceren, zowel op dezelfde host als over meerdere hosts in een gedistribueerde omgeving. Het biedt netwerkisolatie, segmentatie en connectiviteitsopties die geschikt zijn voor verschillende implementatiescenario’s.

Docker ondersteunt meerdere netwerktypes, elk met verschillende use cases:

• Bridge (standaard): Containers op dezelfde host communiceren via een intern virtueel netwerk. Elke container krijgt zijn eigen privé-IP-adres binnen het bridge-netwerk, en ze kunnen elkaar bereiken via container namen.
• Voorbeeld: docker network create mijn-brug-netwerk
• Ideaal voor het uitvoeren van meerdere containers op één host die veilig moeten communiceren zonder externe services bloot te stellen.
• Host: Containers delen de netwerkstack van de host en gebruiken rechtstreeks het IP-adres en de poorten van de host.
• Voorbeeld: docker run --network host nginx
• Handig wanneer u hoge prestaties nodig heeft en geen netwerkisolatie vereist, zoals het uitvoeren van monitoringsagenten of toepassingen met lage latentie.
• Overlay: Maakt containercommunicatie op verschillende hosts mogelijk door een gedistribueerd netwerk te creëren.
• Voorbeeld: docker network create --driver overlay my-overlay-network
• Ontworpen voor georkestreerde implementaties zoals Docker Swarm, waar services zich over meerdere nodes uitstrekken.
• Macvlan: Kent aan elke container een uniek MAC-adres toe, waardoor deze lijkt op een fysiek apparaat in het netwerk.
• Voorbeeld: docker network create -d macvlan --subnet=192.168.1.0/24 my-macvlan
• Gebruikt wanneer containers directe netwerktoegang nodig hebben, zoals bij het integreren van legacy systemen of bij interactie met fysieke netwerken.

Containers uitvoeren op aangepaste netwerken

Laten we stap voor stap doorlopen hoe je een aangepast bridge-netwerk opzet voor containercommunicatie.

Stap 1: Maak een aangepast netwerk aan

Voordat we containers uitvoeren, moeten we eerst een toegewijd netwerk aanmaken:

docker network create my-custom-network

Deze opdracht maakt een geïsoleerd netwerk aan waar containers aan kunnen deelnemen voor onderlinge communicatie.

Stap 2: Voer containers uit op het netwerk

Nu gaan we twee containers starten en deze verbinden met ons nieuw aangemaakte netwerk:

docker run -d --network my-custom-network --name app1 my-app
docker run -d --network my-custom-network --name app2 my-app

• De --network my-custom-network vlag koppelt de container aan het gespecificeerde netwerk.
• De --name vlag wijst een unieke container naam toe, waardoor deze makkelijker te refereren is.

Zowel app11 als app2 kunnen nu communiceren met behulp van hun container namen. Je kunt de connectiviteit testen met het ping` commando binnen een van de containers:

docker exec -it app1 ping app2

Als alles correct is ingesteld, zult u een reactie zien die bevestigt dat de containers kunnen communiceren.

Het inspecteren van Docker-netwerken

Om netwerkconfiguraties en verbonden containers te controleren, gebruikt u:

docker network inspect my-custom-network

Deze opdracht geeft details over het netwerk, inclusief IP-bereiken, verbonden containers en configuraties.

Het blootleggen en publiceren van poorten

Wanneer u containers uitvoert die extern toegankelijk moeten zijn, kunt u specifieke poorten blootleggen.

Om bijvoorbeeld een Nginx-webserver uit te voeren en deze bloot te leggen op poort 8080 van uw lokale machine, gebruikt u:

docker run -d -p 8080:80 nginx

Dit koppelt poort 80 binnen de container aan poort 8080 op de host, waardoor de service toegankelijk is via http://localhost:8080.

Beste praktijken voor Docker-netwerken

• Gebruik aangepaste netwerken: Vermijd het gebruik van het standaard bridge-netwerk voor productie-implementaties om ongewenste toegang tussen containers te verminderen.
• Maak gebruik van DNS-gebaseerde ontdekking: In plaats van IP-adressen in de code te verankeren, gebruik container namen om dynamische service-ontdekking mogelijk te maken.
• Beperk externe blootstelling: Gebruik firewalls of netwerkbeleid om de toegang tot de service te regelen.
• Monitor verkeer: Gebruik tools zoals docker network inspect, Wireshark of Prometheus om netwerkverkeer te analyseren en afwijkingen te detecteren.
• Optimaliseer overlay-netwerken: Als je in een gedistribueerde setup implementeert, pas dan overlay-netwerken aan voor verminderde latentie door gebruik te maken van host-lokale routeringsopties.

Docker Beste Praktijken en Volgende Stappen

Nu je de basisprincipes van Docker hebt geleerd, is het tijd om je vaardigheden te verbeteren en beste praktijken aan te nemen die je helpen bij het bouwen van veilige, efficiënte en onderhoudbare containerapplicaties.

De volgende beste praktijken helpen je om je Docker-workflows te stroomlijnen en veelvoorkomende valkuilen te vermijden.

• Gebruik officiële basisafbeeldingen: Geef altijd de voorkeur aan officiële en goed onderhouden basisafbeeldingen om veiligheid en stabiliteit te garanderen. Officiële afbeeldingen zijn geoptimaliseerd, regelmatig bijgewerkt en minder vatbaar voor kwetsbaarheden.
• Houd afbeeldingen klein: Verklein de afbeeldingsgrootte door minimale basisafbeeldingen te kiezen (bijv. python:3.9-slim in plaats van python:3.9). Verwijder onnodige afhankelijkheden en bestanden om opslag en ophaaltijden te optimaliseren.
• Gebruik multi-stage builds: Optimaliseer Docker-bestanden door build- en runtime-afhankelijkheden te scheiden. Multi-stage builds zorgen ervoor dat alleen de noodzakelijke artefacten zijn opgenomen in de uiteindelijke afbeelding, waardoor de grootte en het aanvalsoppervlak worden verminderd.
• Tag afbeeldingen op de juiste manier: Gebruik altijd versie-tags (bijv., my-app:v1.0.0) in plaats van latest om onverwachte updates te vermijden bij het ophalen van afbeeldingen.
• Scan afbeeldingen op kwetsbaarheden: Gebruik beveiligingsscantechnologieën zoals docker scan, Trivy of Clair om beveiligingskwetsbaarheden in uw afbeeldingen te identificeren en op te lossen voordat u ze implementeert.
• Beheer omgevingsvariabelen op een veilige manier: Vermijd het opslaan van gevoelige referenties in afbeeldingen. Gebruik Docker-geheimen, omgevingsvariabelen of externe geheimbeheertools zoals AWS Secrets Manager of HashiCorp Vault.
• Gebruik .dockerignore-bestanden: Sluit onnodige bestanden uit (bijv. .git, node_modules, venv) om de buildcontextgrootte te verkleinen en te voorkomen dat gevoelige bestanden per ongeluk in afbeeldingen worden opgenomen.
• Schakel logging en monitoring in: Gebruik tools zoals Prometheus, Grafana en Fluentd voor containerlogs en monitoring. Inspecteer logs met docker logs en schakel gestructureerde logging in voor betere zichtbaarheid.

Wanneer je de basisprincipes van Docker onder de knie hebt, zijn er volop geavanceerde onderwerpen om te verkennen. Hier zijn een paar gebieden die het waard zijn om als volgende te verkennen:

• Docker Swarm & Kubernetes: Verken Docker Swarm (geïntegreerde clustering) en Kubernetes (enterprise-grade orkestratie met autoscaling en service discovery) voor productieklare orkestratie.
• Best practices voor containerbeveiliging: Om gecontaineriseerde applicaties te beveiligen, volg de richtlijnen van de CIS Docker Benchmark en implementeer Role-Based Access Control (RBAC).
• CI/CD-pijplijnen met Docker: Automatiseer het bouwen van afbeeldingen, beveiligingsscans en implementaties met behulp van GitHub Actions, GitLab CI of Jenkins.
• Cloud-native ontwikkeling: Maak gebruik van Docker met cloudplatforms zoals AWS ECS, Azure Container Instances en Google Cloud Run voor schaalbare en beheerde implementaties.
• Data persistentiestrategieën: Voor optimaal opslagbeheer, begrijp de verschillen tussen Docker-volumes, bind mounts en tmpfs.

Conclusie

Docker heeft de manier waarop ontwikkelaars toepassingen bouwen, verzenden en uitvoeren gerevolutioneerd, waardoor het een essentieel instrument is geworden voor moderne softwareontwikkeling.

In deze zelfstudie hebben we behandeld:

• Wat Docker is en waarom het belangrijk is
• Hoe je je eerste container installeert en uitvoert
• Kernconcepten zoals images, containers en netwerken
• Permanente opslag met Docker-volumes
• Multi-container applicaties met Docker Compose
• Best practices voor beveiliging, prestaties en schaalbaarheid

Maar dit is slechts het begin! Als je je Docker-kennis wilt verdiepen, kun je een beginner-niveau Inleiding tot Docker cursus volgen. Voor meer diepgaande kennis kun je een Intermediaire Docker cursus volgen die multi-stage builds, Docker netwerktools en Docker Compose behandelt. Ten slotte kun je ook Docker-certificering nastreven, kijk naar De Complete Docker Certificeringsgids (DCA) voor 2025 als je geïnteresseerd bent!