Een Docker-image als container uitvoeren: een praktische gids voor beginners

Als je je afvraagt hoe je een Docker-image draait, ben je niet de enige. Of je nu net een image van Docker Hub hebt binnengehaald of er zelf een hebt gebouwd, het uitvoeren ervan is de sleutelstap die je applicatie tot leven brengt.

Deze tutorial is je beginnersvriendelijke gids voor het docker run-commando en meer. Je leert:

• Wat Docker-images en -containers precies zijn.
• Hoe je een image uitvoert met verschillende opties.
• En hoe je containers stopt, verwijdert en troubleshoott als een pro.

Aan het einde kun je vol vertrouwen je eigen containers starten en precies begrijpen wat er onder de motorkap gebeurt.

Docker-images en -containers begrijpen

Voordat we naar commandovoorbeelden gaan, laten we Docker-images en -containers in eenvoudige bewoordingen verduidelijken.

Als je deze termen al kent, voel je vrij om naar de volgende sectie te springen!

Wat is een Docker-image?

Een Docker-image is een onveranderlijk blauwdruk voor je app. Het definieert alles wat je container nodig heeft: de code, libraries, omgeving en configuraties. Zodra je een image hebt, kun je er één container of honderd mee opstarten. Het blijft elke keer consistent.

Waar komen images vandaan? Dockerfiles bouwen ze. In een Dockerfile bepaal je welke basisimage je gebruikt, welke afhankelijkheden je installeert en hoe je app moet draaien.

Zodra je Dockerfile klaar is, voer je het commando docker build uit. Dit commando volgt de stappen in het bestand en zet ze om in een herbruikbaar image.

Wat is een Docker-container?

Een Docker-container is de actieve versie van een Docker-image. Hij laat je applicatie draaien in een eigen geïsoleerde omgeving, waardoor consistent gedrag is gegarandeerd, ongeacht het hostsysteem. 

Het volgt het principe “één keer bouwen, overal draaien”, zodat je de omgeving niet elke keer handmatig hoeft in te richten. 

Image versus container

De onderstaande tabel zet een image en een container naast elkaar:

Ben je helemaal nieuw met containerization, dan laat onze Introduction to Docker-cursus je stap voor stap de kernconcepten zien met hands-on voorbeelden.

Het docker run-commando

Wanneer je het commando docker run uitvoert, zeg je tegen Docker om een nieuwe container op te starten op basis van een image.

Simpel gezegd: je start een programma binnen een geïsoleerde omgeving. Dat programma kan van alles zijn, van een simpele webapp tot een volwaardige service met meerdere processen. 

Basis-syntaxis

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

• [OPTIONS] - Extra flags om te bepalen hoe de container draait
• IMAGE - De naam van het Docker-image 
• [COMMAND] - (Optioneel) Overschrijft het standaardcommando in het image.
• [ARG...]- (Optioneel) Argumenten.

Veelgebruikte flags en opties

• -d: Detached-modus: draait containers op de achtergrond
• -p: Poortkoppeling: om een dienst (zoals een API of webapp) vanuit je browser te benaderen, moet je een poort exposen. Voorbeeld: -p 3000:3000 koppelt poort 3000 van je machine aan poort 3000 van de container.
• --name: Docker geeft de container standaard een naam, maar met deze flag kun je hem zelf een naam geven.
• -v:  Gebruik dit om data los te koppelen van de container zelf, zodat deze blijft bestaan, zelfs als de container wordt gestopt of verwijderd.
• --rm: Als de container stopt, verwijdert deze flag hem automatisch.
• -e: Gebruik dit om databasewachtwoorden of API-sleutels door te geven zonder ze hard te coderen in je app.

Interactieve versus detached containers draaien

Docker draait containers op twee manieren: interactieve modus (-it) en detached-modus (-d). Elke modus heeft specifieke use-cases afhankelijk van je doel. 

• -it: Interactieve modus: als je rechtstreeks in een container wilt werken via de terminal, gebruik je de -it-flag. Dit zet de container in interactieve modus, zodat je commando’s kunt typen, de output ziet en realtime kunt werken.
• -i: Houdt de invoer open zodat je commando’s in de container kunt typen
• -t: Geeft je een terminalachtige interface binnen de container
• -d: Detached-modus: draait de container op de achtergrond, zodat je terminal vrij is voor andere taken. 

Houd belangrijke commando’s en best practices bij de hand met onze Docker for Data Science Cheat Sheet.

Docker-images ophalen en uitvoeren

Nu je de syntaxis van het docker run-commando kent, laat deze sectie zien hoe je custom images maakt en draait.

Images van Docker Hub gebruiken

Docker Hub is als een online bibliotheek voor containerimages. Je kunt voorgebouwde images gebruiken of die van jou uploaden om te delen met anderen. Het ondersteunt zowel publieke als private repositories, zodat je images open kunt delen met de community of toegangscontrole kunt instellen voor je interne teams.

Aangepaste images draaien 

Om een Docker-image te draaien, moet je het eerst bouwen met een Dockerfile. Daarna kun je het lokaal draaien of naar Docker Hub pushen om het te delen. 

Laten we dus eerst een Dockerfile maken. Hier is een voorbeeld:

# Use official Python base image
FROM python:3.11-slim
# Set working directory in the container
WORKDIR /app
# Copy requirements file and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy the rest of the app code
COPY . .
EXPOSE 5000
# Set default command
CMD ["python", "app.py"]

Wat betekent de bovenstaande Dockerfile?

• FROM python:3.11-slim: basisimage met Python-versie 3.11
• WORKDIR /app: Stelt /app in als de werkdirectory binnen de container.
• COPY requirements.txt . : verplaatst alle afhankelijkheden van de lokale machine naar de appdirectory van de container.
• RUN pip install --no-cache-dir -r requirements.txt: installeert afhankelijkheden uit requirements.txt.
• COPY . . : kopieert de code van de huidige werkdirectory (apps, configbestanden en andere) naar de appdirectory van de container.
• CMD ["python", "app.py"]: draait app.py bij het starten van een container van dit image.

Stap 1. Dockerfile bouwen 

Laten we kijken wat er gebeurt wanneer je deze Dockerfile bouwt.

• Voer het volgende commando uit:

docker build -t my-python-app .

Let op: om dit commando te laten werken, moet Docker eerst op je systeem zijn ingesteld; deze gids helpt je daarbij.

Dit gebeurt er achter de schermen wanneer je het build-commando uitvoert:

1. Docker leest de Dockerfile
2. Het Python-basisimage wordt opgehaald van Docker Hub
3. De werkdirectory wordt ingesteld op /app.
4. Het requirements.txt-bestand wordt naar de container gekopieerd.
5. Afhankelijkheden worden geïnstalleerd met pip install.
6. De rest van je code wordt gekopieerd naar /app.
7. Het uiteindelijke image krijgt de tag my-python-app.

Stap 2: Dockerfile draaien

Zodra je image is gebouwd, kun je het uitvoeren met:

docker run -p 5000:5000 my-python-app

Dit is wat er gebeurt wanneer je het draait: 

• Er wordt een nieuwe container gemaakt van je aangepaste image, my-python-app.
• Poort 5000 op je machine wordt gekoppeld aan poort 5000 in de container (-p 5000:5000).
• De CMD ["python", "app.py"] wordt uitgevoerd en start de app.
• De container draait op de achtergrond vanwege de optie -d (detached-modus).

Op dit punt kun je in je browser naar http://localhost:5000 gaan en iets als het volgende zien, wat betekent dat je applicatie draait:

Als je in machine learning werkt, kunnen deze top Docker-images voor ML en AI je omgevingssetup versnellen.

Images draaien met configuratie

Voor sommige applicaties moet je images met een specifieke configuratie draaien. Hier zijn twee veelvoorkomende voorbeelden.

Data behouden

Containers slaan data tijdelijk op. Verwijder je ze, dan is de data weg. Een volume is een manier om data buiten de container op te slaan zodat deze blijft bestaan, zelfs als de container wordt verwijderd of herstart.

Om een volume te mounten, voer je een commando als het volgende uit:

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

De data die wordt geschreven naar /app/data blijft in het volume bewaard, ook nadat de container is verwijderd.

Omgevingsvariabelen doorgeven

Omgevingsvariabelen geven configuratie-instellingen door aan een Docker-container tijdens runtime. Zo kun je je Docker-containers aanpassen zonder je Docker-images te wijzigen. 

Je hebt twee manieren om omgevingsvariabelen door te geven: 

1. Je kunt omgevingsvariabelen doorgeven met de parameter -e. Hier is een voorbeeldcommando:

docker run -e ENV=production -e DEBUG=False my-image

2. Je kunt een .env-bestand maken met alle omgevingsvariabelen en dit meegeven aan het commando. Voorbeeld:

docker run --env-file .env my-image

Voorbeeld van een .env-bestand:

ENV=staging
DEBUG=True
SECRET_KEY=mysecret

Draaiende containers beheren

Zodra een container draait, kun je hem bekijken, stoppen en benaderen. Zo doe je dat.

Actieve containers bekijken

Om alle actieve Docker-containers op je systeem te tonen, voer je het commando docker ps of docker container ls uit. Dit commando toont de container-ID, het image, het commando, de poort, de status en andere details.

docker ps
# or
docker container ls

Om alle containers op te nemen — niet alleen de draaiende — zoals containers die zijn gestopt of aangemaakt maar niet gestart, gebruik je de -a-flag:

docker ps -a

Om alleen de meest recent aangemaakte container te bekijken, gebruik je de -l (laatste) flag:

docker ps -l

Als je alle containers gesorteerd op aanmaaktijd wilt zien, met de meest recente eerst, voer dan uit:

docker ps -a --sort=created

Containers stoppen en verwijderen

Om een specifieke draaiende container te stoppen, gebruik je het commando docker stop gevolgd door de container-ID of -naam:

docker stop <container_id_or_name>

Om alle draaiende containers te stoppen, gebruik je:

docker stop $(docker ps -q)

• $(docker ps -q) geeft een lijst met alle draaiende container-ID’s terug.

Zodra een container is gestopt, kun je hem verwijderen met:

docker rm <container_id_or_name>

Om alle gestopte containers te verwijderen, voer je uit:

docker container prune

Wil je verder gaan en ongebruikte containers, volumes, netwerken en images verwijderen, bekijk dan de Docker prune-gids.

Containerlogs en -shell benaderen

• docker logs - Het commando docker logs haalt in één keer de logs op die op dat moment beschikbaar zijn.
• docker exec - docker exec laat je een nieuw commando uitvoeren in een al draaiende container zonder hem te stoppen of te herstarten. Zie het als een nieuwe terminal openen binnen je container — zodat je kunt rondkijken, scripts draaien, logs checken of debuggen.
• docker attach - docker attach verbindt je terminal direct met het hoofdproces van een draaiende container. Zo zie je de liveoutput (logs, prompts, etc.) en kun je ermee interacteren als het proces invoer accepteert.

Veelvoorkomende problemen oplossen

Eenvoudige oplossingen voor vaak voorkomende problemen. Hier zijn enkele veelvoorkomende fouten bij het draaien van Docker-images en hoe je ze kunt aanpakken. 

Fout 1: “Error response from daemon: pull access denied for alpine-python, repository does not exist or may require ‘docker login’: denied: requested access to the resource is denied.”

• Wat het betekent: Docker probeerde een image te pullen, in dit geval het alpine-python-image van Docker Hub, maar het image bestaat niet of is privé en je bent niet geauthenticeerd.
• Oplossing:
  • Controleer de imagenaam en tag op Docker Hub.
  • Als het een privéimage is, voer docker login uit om je te authenticeren.
  • Zorg dat het image bestaat als je uit een eigen registry pulled.

Fout 2: “No such image found: <image-name>:<tag>”

• Wat het betekent: Je probeerde lokaal een image te draaien of te taggen, maar het image (of de opgegeven tag) is niet beschikbaar op je systeem.
• Oplossing:
  • Gebruik docker images om te checken welke images beschikbaar zijn.
  • Pull het image expliciet:

docker pull <image-name>:<tag>

Fout 3: “manifest for <image>:<tag> not found: manifest unknown: The named manifest is not known to the registry.”

• Wat het betekent: Deze fout treedt waarschijnlijk op wanneer het opgegeven image of de tag niet bestaat.
• Mogelijke oplossingen: Deze tips lossen de meeste veelvoorkomende fouten op: 
• Controleer de juiste image- en tagnamen.
• Raadpleeg de tags van het image op Docker Hub of je eigen registry.
• Gebruik docker pull <image>:<tag> om een geldige versie op te halen.
• Als je lokaal bouwt, gebruik dan een correcte Dockerfile en bouw het image met:

docker build -t <image>:<tag> .

Poortconflicten en bind-fouten

Poortconflicten treden op wanneer meerdere containers of een container en een andere applicatie dezelfde poort proberen te gebruiken.

• Oplossing:
• Gebruik een andere hostpoort wanneer je je container draait:

docker run -p 8081:80 <image>

• Stop de service die de poort momenteel gebruikt.
• Achterhaal wat een poort (bijv. 8080) gebruikt met:

lsof -i :8080

Conclusie 

Een Docker-image draaien is een van de belangrijkste en meest empowerende stappen bij het gebruik van containers, of je nu een eenvoudige webserver opstart of een complexe applicatie uitrolt. Met slechts een paar commando’s zoals docker run, docker ps en docker stop kun je nu vol vertrouwen containers starten, beheren en troubleshooten.

Klaar voor de volgende stap? Probeer je eigen image te bouwen met een Dockerfile, verken geavanceerde docker run-flags of leer meerdere containers te beheren met Docker Compose.

Bekijk deze cursussen om je Docker-reis voort te zetten:

• Intermediate Docker: Leer geavanceerd imagemanagement, volumes en multi-containerapplicaties.
• Containerization and Virtualization Concepts: Begrijp de theorie achter containers en hoe ze verschillen van virtuele machines.
• Containerization and Virtualization with Docker and Kubernetes: Een volledige leertrack om Docker te beheersen en te starten met Kubernetes.