Docker en Kubernetes voor ontwikkelaars · Les

Applicaties met meerdere containers en Compose

Orkestreer meerdere Docker-containers, zoals een webapplicatie en een database, met Docker Compose voor lokale ontwikkeling.

Les 3 van 412 stappen

Applicaties met meerdere containers en Compose is een gratis Docker en Kubernetes voor ontwikkelaars-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Docker en Kubernetes voor ontwikkelaars. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Docker en Kubernetes voor ontwikkelaars bevat in totaal 4 lessen.

Waarom applicaties met meerdere containers?

In echte applicaties heb je zelden maar één onderdeel. Stel je een webapplicatie voor: je hebt een webserver nodig, zoals Nginx, een backendapplicatie, zoals Python Flask, en een database, zoals Redis of PostgreSQL.

Elk van deze onderdelen heeft eigen afhankelijkheden en configuratie. Als je ze afzonderlijk beheert en ervoor zorgt dat ze correct communiceren, kan dat al snel complex worden.

Maak kennis met Docker Compose

Docker Compose is een hulpprogramma dat is ontworpen om het definiëren en uitvoeren van Docker-applicaties met meerdere containers eenvoudiger te maken.

Je definieert alle services van je applicatie, oftewel containers, in één YAML-bestand.
Met één eenvoudige opdracht maakt en start Compose vervolgens alle services voor je.
Het is bijzonder handig voor lokale ontwikkel- en testomgevingen.

Het YAML-bestand van Compose

De kern van Docker Compose is het bestand docker-compose.yml. Dit YAML-bestand beschrijft de services, netwerken en volumes van je applicatie.

Het begint meestal met een sleutel version, gevolgd door de hoofdsectie services, waarin je elke container definieert die deel uitmaakt van je applicatie.

Services definiëren

Onder de sectie services vermeld je elk onderdeel van je applicatie. Elke service komt overeen met een Docker-container.

Belangrijke eigenschappen voor het definiëren van een service zijn:

image: geeft aan welke Docker-afbeelding moet worden gebruikt, bijvoorbeeld nginx:latest.
build: geeft het pad op naar een map met een Dockerfile om een aangepaste afbeelding te bouwen.
container_name: een optionele, vaste naam voor je container, zodat je er eenvoudiger naar kunt verwijzen.

Services beschikbaar maken en configureren

Vaak moet je je services beschikbaar maken voor de hostmachine of ze configureren met omgevingsvariabelen.

ports: koppelt poorten van de host aan de container, bijvoorbeeld "8080:80" koppelt hostpoort 8080 aan containerpoort 80.
environment: geeft omgevingsvariabelen door aan de container, bijvoorbeeld DB_HOST: "database".

Deze instellingen zijn essentieel voor communicatie en aanpassing.

Je services verbinden

Wanneer je Docker Compose gebruikt, maakt het automatisch een standaardnetwerk voor je applicatie. Alle services die in je bestand docker-compose.yml zijn gedefinieerd, maken deel uit van dit netwerk.

Daardoor kunnen services met elkaar communiceren via hun servicenamen als hostnamen. Een webapplicatieservice kan bijvoorbeeld verbinding maken met een databaseservice met de naam redis door eenvoudigweg redis als hostnaam te gebruiken.

Voorbeeld: Python + Redis

Laten we een eenvoudige applicatie met meerdere containers bouwen: een Python Flask-webapp die telt hoe vaak deze is bezocht en de teller opslaat in een Redis-database.

Deze opstelling laat duidelijk zien hoe een service voor het web kan communiceren met een databaseservice binnen één Compose-applicatie.

Code en Dockerfile van de webapp

Hier zie je onze eenvoudige Python Flask-applicatie (app.py) en de bijbehorende Dockerfile. De Flask-app maakt verbinding met de service redis en de Dockerfile verpakt alles.

# app.py
import time
import redis
from flask import Flask

app = Flask(__name__)
# Connects to 'redis' service in Compose network
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello from CoddyKit! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

# requirements.txt
# flask
# redis

# Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Je eerste Compose-bestand

Dit bestand docker-compose.yml brengt alles samen. Het definieert twee services: web, onze Python-app die vanuit de huidige map wordt gebouwd, en redis, die de officiële Redis-afbeelding gebruikt.

Probeer dit voorbeeld uit te voeren.

version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

Je Compose-app beheren

Om je applicatie met meerdere containers in losgekoppelde modus op te starten, dus op de achtergrond, ga je naar de map met je docker-compose.yml en ondersteunende bestanden en voer je het volgende uit:

docker compose up -d

Om de actieve services en hun status te bekijken:

docker compose ps

Om de containers, netwerken en volumes die door Compose zijn gemaakt te stoppen en te verwijderen:

docker compose down

Compose-configuratie controleren

Bekijk het volgende fragment uit docker-compose.yml:

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:80"
  database:
    image: "postgres:13"

Welke uitspraak over deze configuratie is WAAR?

Beantwoord dit in de interactieve les

Samenvatting: Docker Compose

Je hebt geleerd hoe Docker Compose het beheer van applicaties met meerdere containers voor lokale ontwikkeling vereenvoudigt.

Het gebruikt een bestand docker-compose.yml om al je services te definiëren.
Services kunnen met elkaar communiceren via hun servicenamen op een standaardnetwerk.
Met opdrachten zoals docker compose up en docker compose down beheer je eenvoudig de volledige applicatiestack.

Docker Compose is een essentieel hulpprogramma voor lokale ontwikkelopstellingen met meerdere Docker-containers.

Gratis beginnen

Leer Docker en Kubernetes voor ontwikkelaars met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Applicaties met meerdere containers en Compose” gratis?

Ja — de volledige tekst van “Applicaties met meerdere containers en Compose” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Docker en Kubernetes voor ontwikkelaars wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Docker en Kubernetes voor ontwikkelaars bevat in totaal 4 lessen.

Wat leer ik in “Applicaties met meerdere containers en Compose”?

Orkestreer meerdere Docker-containers, zoals een webapplicatie en een database, met Docker Compose voor lokale ontwikkeling. Je oefent met Docker en Kubernetes voor ontwikkelaars door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Docker en Kubernetes voor ontwikkelaars te beginnen?

Ervaring vooraf is niet nodig. Docker en Kubernetes voor ontwikkelaars op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Applicaties met meerdere containers en Compose”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Docker en Kubernetes voor ontwikkelaars?

Ja. Elke les over Docker en Kubernetes voor ontwikkelaars bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Dockerfiles voor images maken
Aangepaste Docker-images bouwen
Applicaties met meerdere containers en Compose
Gegevens persistent maken met Docker-volumes

← Terug naar Docker en Kubernetes voor ontwikkelaars