Docker: Een stap-voor-stap gids

Deze handleiding behandelt de basisprincipes van Docker, enkele veelgebruikte commando’s, en hoe je een applicatie “dockerized” met een Dockerfile en docker-compose. Ook wordt een eenvoudig voorbeeldproject stap voor stap uitgelegd.

In deze guide:

1. Wat is Docker?
2. Veelgebruikte Docker-commando’s
3. Een applicatie “dockerizen”
4. Een simpel voorbeeldproject
5. Best Practices

1. Wat is Docker?

Docker is een platform voor het bouwen, verzenden en draaien van gedistribueerde applicaties. Het stelt je in staat om applicaties te verpakken met al hun afhankelijkheden in containers. Containers zijn lichtgewicht, geïsoleerde omgevingen die ervoor zorgen dat de applicatie consistent werkt, ongeacht de omgeving waarin ze draaien.

2. Veelgebruikte Docker-commando’s

Containers beheren

• docker ps

Lijst de actieve containers op.

• docker ps -a

Lijst alle containers op (inclusief gestopte containers).

• docker start [container_id]

Start een gestopte container.

• docker stop [container_id]

Stop een actieve container.

• docker rm [container_id]

Verwijder een gestopte container.

• docker-compose logs -f

Loggen van alle activiteiten. Handig voor debugging

• docker logs -f <container-id>

Loggen van activiteiten in een specifieke Docker container

Docker Images

Een Docker image is een blauwdruk of sjabloon waarmee je een Docker container kunt bouwen. Het is een immutable (onveranderbaar) bestand dat alle benodigde componenten bevat om een applicatie te draaien, zoals de code, configuratiebestanden, bibliotheken, en afhankelijkheden.

Belangrijke kenmerken van een Docker image

• Immutable: Een image is onveranderbaar; zodra het is aangemaakt, kan het niet meer worden gewijzigd. In plaats daarvan kun je een nieuw image maken met de gewenste wijzigingen.

• Lagen: Een Docker image bestaat uit een reeks lagen die op elkaar zijn gestapeld. Elke laag vertegenwoordigt een wijziging of update. Door lagen te hergebruiken kan Docker efficiënt met images omgaan, wat leidt tot kleinere opslaggroottes en snellere builds.

• Base image: Een Docker image begint vaak met een base image, zoals python:3.9-slim, ubuntu:20.04, of alpine, waarop je verder bouwt. Dit base image bevat de basisbesturingssysteem- of runtimeomgeving.

• Geen runtime state: Een image zelf bevat geen runtime state (bijvoorbeeld de data die je applicatie tijdens het draaien produceert). Het is een statische definitie.

Voorbeeld van een Docker image

Een Docker image kan bijvoorbeeld een eenvoudige Python-applicatie bevatten die gebruikmaakt van Flask. Dit image bevat dan:

• De basis (zoals een minimalistische versie van Linux).

• De Python-runtime en de Flask-bibliotheek.

• De applicatiecode zelf.

Hoe wordt een Docker image gemaakt?

Een Docker image wordt meestal gedefinieerd met een Dockerfile. In een Dockerfile beschrijf je de stappen die Docker moet nemen om het image te bouwen, zoals het installeren van afhankelijkheden en het kopiëren van de applicatiecode.

Voorbeeld van een Dockerfile:

# Gebruik een basisimage met Python
FROM python:3.9-slim

# Stel de werkdirectory in
WORKDIR /app

# Kopieer en installeer afhankelijkheden
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Kopieer de rest van de applicatiecode
COPY . .

# Specificeer het commando om de applicatie te starten
CMD ["python", "app.py"]

Met deze Dockerfile kun je een Docker image bouwen met het commando:

docker build -t my-flask-app .

Hiermee creëer je een image genaamd my-flask-app op basis van de stappen in de Dockerfile.

Met volgende commando haal je de images op:

docker images

Samenvatting

Een Docker image is dus een statisch bestand dat alles bevat wat nodig is om een applicatie consistent en onafhankelijk van de omgeving te draaien. Wanneer je een container start, gebruik je een Docker image als blauwdruk om die container op te zetten.

Volumes en netwerken

• docker volume ls

Lijst alle Docker-volumes op.

• docker network ls

Lijst alle Docker-netwerken op.

• docker volume rm [volume_name]

Verwijder een Docker-volume.

Basis Docker-commando’s

• docker run [image_name]

Start een nieuwe container op basis van het image [image_name].

• docker exec -it [container_id] /bin/bash

Open een interactieve shell in een draaiende container.

3. Een applicatie “dockerizen”

Om een applicatie in een Docker-container te draaien, heb je twee dingen nodig:

• Een Dockerfile: bevat instructies om een image te bouwen.

• Een docker-compose.yml: definieert hoe meerdere containers samenwerken (optioneel).

3.1 Dockerfile

De Dockerfile beschrijft de stappen om een Docker-image te bouwen. Het bevat instructies zoals welke basisimage te gebruiken, welke bestanden te kopiëren, en hoe de applicatie te starten.

Voorbeeld Dockerfile (Python-applicatie):

# Gebruik een officiële Python image als basis
FROM python:3.9-slim

# Stel de werkdirectory in binnen de container
WORKDIR /app

# Kopieer requirements en installeer afhankelijkheden
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Kopieer de rest van de applicatiecode
COPY . .

# Specificeer het commando om de applicatie te draaien
CMD ["python", "app.py"]

3.2 docker-compose.yml

docker-compose.yml wordt gebruikt om meerdere containers tegelijkertijd te beheren en te coördineren, bijvoorbeeld een applicatiecontainer en een databasecontainer.

Voorbeeld docker-compose.yml:

version: '3.9'
services:
  app:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase

Met dit bestand kun je eenvoudig alle gedefinieerde services starten door docker-compose up uit te voeren.

4. Een simpel voorbeeldproject: Een Python Flask API

Laten we een eenvoudige Python Flask API bouwen en deze “dockerizen”.

4.1 Bestandenstructuur

Maak de volgende bestanden en mappen aan:

my_flask_app/

│

├── app.py

├── Dockerfile

├── requirements.txt

└── docker-compose.yml

4.2 Code voor de bestanden

app.py

from flask import Flask

app = Flask(__name__)

@app.route('/')

def hello():

return "Hello, Docker!"

if __name__ == '__main__':

app.run(host='0.0.0.0', port=5000)

requirements.txt

flask

Dockerfile

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "app.py"]

docker-compose.yml

version: '3.9'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - .:/app

4.3 Applicatie opzetten en draaien

1. Bouw het Docker-image:

docker-compose build

2. Start de containers:

docker-compose up

3. Toegang tot de applicatie:

Open je browser en ga naar http://localhost:5000. Je zou “Hello, Docker!” moeten zien.

4. Container in de achtergrond draaien:

docker-compose up -d

5. Containers stoppen en verwijderen:

docker-compose down

5. Best Practices

1. Minimalistische basisimages gebruiken

Gebruik images zoals python:3.9-slim of alpine om de grootte van je container te minimaliseren.

2. Multistage builds toepassen

Gebruik multistage builds om afhankelijkheden en build-bestanden te scheiden van de uiteindelijke runtime.

3. Omgevingsvariabelen gebruiken

Definieer variabelen in de docker-compose.yml of gebruik .env bestanden om configuratie-informatie buiten de container te houden.

4. Persistentie met volumes

Maak gebruik van Docker-volumes voor het opslaan van gegevens, zodat data behouden blijft als je containers opnieuw start.

Met deze handleiding zou je een goed startpunt moeten hebben om Docker effectief te gebruiken. Door deze stappen te volgen, kun je je eigen applicaties eenvoudig “dockerizen” en beheren.