Docker Compose-gids: vereenvoudig ontwikkeling met meerdere containers

Docker Compose vereenvoudigt het beheer van Docker-applicaties met meerdere containers, zodat ontwikkelaars moeiteloos complexe apps kunnen schrijven en uitvoeren.

Intermediate DevOps-engineers, backend-ontwikkelaars en cloud-native ontwikkelaars, vooral wie werken aan microservices of architecturen met meerdere services, krijgen vaak te maken met de uitdaging om talloze onderling verbonden containers te beheren. Docker Compose pakt deze complexiteit aan en stroomlijnt ontwikkel- en testworkflows. 

In dit artikel leer je alles wat je nodig hebt om Docker Compose te gebruiken. Bekijk onze Docker voor beginners-gids als je net begint met Docker. 

Wat is Docker Compose?

Docker Compose is een tool voor het definiëren en orkestreren van Docker-applicaties met meerdere containers via één YAML-configuratiebestand. 

Met Compose kun je eenvoudig services, netwerken, volumes, omgevingsinstellingen en afhankelijkheden specificeren. Het is ideaal voor lokale ontwikkeling, testopstellingen, snelle prototyping en kleinere productieomgevingen.

Veelvoorkomende use-cases van Docker Compose zijn het creëren van lokale omgevingen die echte systemen weerspiegelen, zoals microservicesarchitecturen. Door interacties tussen componenten duidelijk te definiëren, biedt Compose consistentie, gebruiksgemak en snellere iteratiecycli.

Je vraagt je misschien af waarom je niet gewoon Kubernetes zou gebruiken. Ten eerste is dat overkill voor kleine projecten en lokaal testen. Zoals je zult ontdekken in onze Kubernetes vs. Docker-tutorial, is Kubernetes beter geschikt voor het beheren van meerdere containers over clusters. Onze cursus Containerization and Virtualization with Docker and Kubernetes gaat dieper in op het bouwen en deployen van applicaties met Docker en Kubernetes. 

Waarom Docker Compose gebruiken vs. handmatige Docker-commando's?

Het individueel beheren van meerdere containers kan snel chaotisch worden door:

• Complexe afhankelijkheidsvolgordes, 
• Onconsistente omgevingen, en 
• Schaalbaarheidsproblemen. 

Met handmatige commando's loop je risico op menselijke fouten, configuratiedrift en inefficiënte workflows. 

Docker Compose helpt deze problemen op te lossen door alle applicatieservices en afhankelijkheden in één YAML-bestand te definiëren. Dit zorgt voor consistentie, schaalbaarheid en eenvoudig afhankelijkheidsbeheer, wat fouten aanzienlijk vermindert en de productiviteit verhoogt.

Compose is sneller dan het handmatig aanmaken en koppelen van containers. Bovendien maakt Compose een standaardnetwerk aan voor communicatie tussen alle containers. Daarnaast beheert het volumes en zorgt het voor automatische heraankoppeling bij het vervangen of herstarten van services. 

Je kunt leren hoe je machinelearningapplicaties containeriseert met Docker en Kubernetes in onze tutorial How to Containerize an Application Using Docker. 

Wat is het verschil tussen Docker en Docker Compose?

Waar Docker het platform is voor het bouwen, draaien en beheren van containers, is Docker Compose de tool die het eenvoudig maakt om meerdere containers te definiëren en te beheren met een YAML-bestand, meestal docker-compose.yml. 

Docker behandelt losse containers, maar met Docker Compose kun je ze stapelen tot één service. Bijvoorbeeld een applicatie met een backend, frontend, database, caching, enzovoort. 

Je kunt je containers bouwen en draaien zonder Docker Compose. Maar door alles te encapsuleren in één docker-compose.yml-bestand wordt het makkelijker om meerdere containers te beheren. Het maakt het ook mogelijk om je applicatie in elke omgeving met één commando op te starten. 

Inzicht in Docker en Docker Compose is cruciaal om je komende sollicitaties te halen. Zorg dat je klaar bent met de Top 26 Docker Interview Questions and Answers for 2025. 

Basisprincipes van Docker Compose

Voordat je in de praktijk duikt, is het essentieel om de kernprincipes en syntaxis van Docker Compose te begrijpen. Zorg er vóór gebruik van Compose voor dat je Docker hebt geïnstalleerd volgens de instructies in onze gids Install Docker on Ubuntu: From Setup to First Container. 

Conceptueel kader

Docker Compose abstraheert de complexiteit van containerorkestratie voor lokale ontwikkeling en eenvoudigere deployments. Met een YAML-geformatteerd compose-bestand declareer je welke services je nodig hebt, definieer je hun afhankelijkheden, specificeer je netwerken, volumes, omgevingsvariabelen en meer. Compose beheert het starten, stoppen, schalen en onderling verbinden van deze services efficiënt.

Kernsyntaxis van Compose

Docker Compose draait om een eenvoudige YAML-syntaxis. Kernonderdelen zijn onder meer:

• services voor het definiëren van gecontaineriseerde applicaties
• images of build-contexten om containers te specificeren
• ports voor het exposen van services
• volumes voor persistente opslag
• networks voor communicatie tussen services

Servicedefinitie en applicatiearchitectuur

Compose-bestanden vertegenwoordigen de services en verbindingen van de applicatie.

Services definiëren

Services zijn de kern van een Compose-bestand. Je kunt meerdere services (zoals webfrontends, databases en cachingservices) duidelijk definiëren en benoemen, en afhankelijkheden specificeren via eenvoudige sleutelwoorden zoals depends_on om de opstartvolgorde van containers te sturen.

Netwerkbasis

Docker Compose maakt automatisch standaardnetwerken aan om communicatie tussen gedefinieerde services te faciliteren. Ontwikkelaars kunnen ook aangepaste netwerken specificeren voor extra isolatie of fijnmazige netwerkvereisten.

Volumebeheer

Volumes maken datapersistentie mogelijk voorbij de levenscyclus van containers. Je kunt benoemde volumes specificeren of hostmappen in containers mounten, zodat databases, logs of andere stateful data consistent behouden blijven.

Omgevingsvariabelen

Compose vereenvoudigt het veilig doorgeven van omgevingsvariabelen en secrets aan containers. Het ondersteunt directe declaraties onder services en het refereren aan variabelen die zijn opgeslagen in env -bestanden naast compose-bestanden, om gevoelige waarden gescheiden en beveiligd te houden van Docker-definities.

Docker Compose schalen en orkestratie

Docker Compose stroomlijnt ook basis-schaalbaarheid en orkestratie, wat vooral handig is voor snelle loadtests of het evalueren van parallelle services.

Services schalen

De Compose-vlag "--scale" laat je snel meerdere kopieën van services opstarten. Dit maakt tests zoals het evalueren van load balancing of het afhandelen van gelijktijdige requests eenvoudig.

Zo kun je bijvoorbeeld een Flask-applicatiecontainer schalen met één commando:

docker-compose up --scale flaskapp=4

Docker Compose vs Docker Swarm en Kubernetes

Hoewel Docker Compose uitblinkt in lokale ontwikkeling en kleinschalige setups, is het beperkt voor multi-host orkestratie op productieschaal. Voor complexe, productieklare scenario's over meerdere hosts zijn robuustere orkestrators zoals Docker Swarm of Kubernetes geschikter, met krachtige load balancing, self-healing, geavanceerde netwerken en grootschalige schaalbaarheid die niet beschikbaar zijn in Compose.

Onze blogpost Docker Compose vs. Kubernetes gaat dieper in op de belangrijkste verschillen tussen Docker Compose en Kubernetes.  

Optimalisatietechnieken voor efficiënt Compose-gebruik

Efficiënt gebruik van Docker Compose omvat het optimaliseren van builds, het toevoegen van healthchecks en het beheren van serviceresources. In deze sectie leer je meer over deze optimalisatietechnieken.

Efficiënte buildstrategieën

Het gebruik van multi-stage builds in Dockerfiles helpt de grootte van Docker-images te verkleinen, terwijl expliciet gebruik van buildcaching de ontwikkel- en CI-processen aanzienlijk versnelt.

Healthchecks en herstartbeleid

Met Compose kun je expliciete healthchecks voor containers definiëren om de betrouwbaarheid van applicaties te behouden. Herstartbeleid zorgt ervoor dat mislukte containers automatisch opnieuw starten, wat de veerkracht vergroot.

Resource-limieten beheren

Het instellen van CPU- en geheugenlimieten rechtstreeks in Compose YAML-definities helpt je resource-toewijzingen te beheersen, wat de voorspelbaarheid en resource-efficiëntie verbetert.

Een voorbeeldsnippet voor resource-limieten:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Praktisch voorbeeld: applicatie met meerdere containers

Hier is een vereenvoudigd praktijkvoorbeeld met een Python Flask-applicatie gekoppeld aan Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

Het Docker Compose-bestand definieert een app met meerdere containers met drie services:

1. redis
2. web (Flask-app met Gunicorn)
3. worker (Celery-worker)

Voor de redis-service:

• Gebruikt de officiële Redis 7-image.
• Stelt de containernaam in op redis.
• Mapt poort 6379 in de container naar 6379 op de host.
• Start altijd opnieuw op als hij crasht (restart: always).
• Definieert een healthcheck die elke 30 seconden redis-cli ping uitvoert, na 5 seconden timeout en 3 keer opnieuw probeert voordat de container als ongezond wordt aangemerkt.

Voor de webservice:

• Bouwt de image vanuit de huidige map (build: .).
• Geeft de container de naam flask_app.
• Voert het commando uit gunicorn app:app met gevent-workers, bindt aan 0.0.0.0:5000, met een lange timeout van 3000 seconden
• Mapt containerpoort 5000 naar 5000 op de host.
• Declareert een afhankelijkheid van de redis-service, zodat Redis eerst start.
• Stelt een omgevingsvariabele REDIS_URL in die verwijst naar de interne Redis-container.
• Laadt extra omgevingsvariabelen uit het .env-bestand.
• Mount drie lokale mappen in de container:
• ./shorts naar /app/shorts,
• ./temp_uploads naar /app/temp_uploads 
• ./uploads naar /app/uploads
• Geconfigureerd om altijd opnieuw te starten bij een crash.

Voor de worker-service:

• Bouwt de image ook vanuit de huidige map (build: .), en hergebruikt hetzelfde Dockerfile als de web-service.
• Geeft de container de naam: celery_worker.
• Voert het commando celery -A celery_worker.celery worker --loglevel=info uit, waarmee een Celery-worker wordt gestart om achtergrondtaken te verwerken.
• Declareert een afhankelijkheid van de redis-service, zodat Redis eerst start.
• Stelt dezelfde REDIS_URL-omgevingsvariabele in om verbinding te maken met de Redis-broker.
• Laadt andere omgevingsvariabelen uit het .env-bestand.
• Mount dezelfde drie mappen als de web-service, zodat zowel de webapp als de worker bestanden en uploads kunnen delen.
• Geconfigureerd om altijd opnieuw te starten bij een crash.

Ontdek meer Docker-projectideeën in onze tutorial 10 Docker Project Ideas. 

Applicaties met meerdere containers bouwen en draaien

Docker Compose biedt een eenvoudige toolset voor routinetaken met containers:

Images bouwen

Gebruik docker compose build om containerimages te genereren volgens je gedefinieerde Dockerfiles. We behandelen meer informatie over het bouwen van Docker-images in onze tutorial How to Learn Docker from Scratch: A Guide for Data Professionals. 

Services draaien

Met docker compose up start je alle gedefinieerde services in het compose-bestand. Voor detached mode gebruik je docker compose up -d. Onze cursus Introduction to Docker gaat dieper in op het draaien van een container op de achtergrond. 

Draaiende containers bekijken

Gebruik docker compose ps om actieve containers en hun status te bekijken en alle draaiende services te tonen.

Services stoppen

Gebruik docker compose down om de draaiende services te stoppen. 

Logs bekijken

Gebruik docker compose logs om de logs te controleren. Je kunt een container specificeren om logs van te bekijken met docker logs container_name. Om de logs te streamen, gebruik je docker compose -f container_name. 

Onze gids Top 18 Docker Commands to Build, Run, and Manage Containers licht meer Docker-commando's toe, zodat je applicaties met vertrouwen kunt beheren over verschillende omgevingen. 

Geavanceerde use-cases voor Docker Compose 

Compose-workflows passen zich aan aan complexere ontwikkelopstellingen of verschillende omgevingsconfiguraties.

Multi-omgevingconfiguratie

Meerdere Compose-bestanden of override-bestanden faciliteren verschillende omgevingsopstellingen (development, testing, productie). Dit houdt definities onderhoudbaar en leesbaar, en maakt snelle aanpassingen mogelijk zonder rommelige configuraties.

Afhankelijkheidsbeheer

Hoewel depends_on basisopstartvolgorde afhandelt, kunnen complexere scenario's initialisatiescripts (zoals "wait-for-it") opnemen, zodat containers pas starten nadat aan specifieke voorwaarden is voldaan, zoals de gereedheid van een database.

Integratie met CI/CD

Compose integreert moeiteloos in continuous integration-workflows en automatiseert volledige omgevingsopstellingen voor testen. Platforms zoals GitLab CI en GitHub Actions bieden native of eenvoudige aanpakken voor Compose-integratie, wat geautomatiseerd testen stroomlijnt.

Best practices en veelvoorkomende uitdagingen

Je kunt valkuilen vermijden en onderhoudbare configuraties bouwen door Compose-definities doordacht te organiseren en structureren.

Compose-bestandsorganisatie

Houd je Compose-bestanden duidelijk en modulair. Voor eenvoudigere projecten is één bestand vaak voldoende, maar voor grotere applicaties kun je overwegen om de configuratie op te splitsen in meerdere Compose-bestanden met de override-functie. Dit maakt het mogelijk om:

• Logische scheiding van componenten (bijv. docker-compose.backend.yml, docker-compose.frontend.yml)
• Eenvoudiger lokale vs. productie-omgevingsaanpassing
• Gestroomlijnd versiebeheer en samenwerking, omdat wijzigingen aan één service niet het hele bestand beïnvloeden

Gebruik betekenisvolle servicenamen en consistente inspringing om bestanden makkelijker leesbaar en navigeerbaar te maken.

Mogelijke valkuilen

Wees je bewust van deze veelvoorkomende misstappen:

• Gebruik van latest-tags voor images: Dit zorgt voor onvoorspelbaarheid, omdat de daadwerkelijke imageversie in de tijd kan veranderen. Pin imageversies altijd expliciet (bijv. postgres:15.1) om consistentie over omgevingen te waarborgen.
• Secrets hardcoden: Neem nooit gevoelige data (bijv. API-sleutels, wachtwoorden) rechtstreeks op in Compose-bestanden. Gebruik in plaats daarvan omgevingsvariabelen, .env-bestanden (uitgesloten van versiebeheer), of secretmanagementtools zoals Docker Secrets voor veilige omgang.
• Te complexe servicedefinities: Weersta de neiging om te veel logica of verantwoordelijkheid in één container te proppen. Volg het single responsibility-principe en kies waar mogelijk voor eenvoud.
• Expliciet netwerkbeheer negeren: Definieer aangepaste netwerken in Compose in plaats van te vertrouwen op standaardgedrag. Dit biedt betere controle over servicecommunicatie, vermindert poortconflicten en verbetert beveiligingsgrenzen.

Door deze praktijken te hanteren, worden je Compose-gebaseerde workflows robuuster, veiliger en gemakkelijker te onderhouden in samenwerkende of veranderende omgevingen.

Conclusie

Docker Compose vereenvoudigt het bouwen, beheren en draaien van applicaties met meerdere containers aanzienlijk voor ontwikkelaars. De duidelijke, op YAML gebaseerde definities, het gemak van orkestratie en het eenvoudige schalen maken het van onschatbare waarde voor lokale ontwikkelscenario's en eenvoudigere deploymentarchitecturen. Hoewel geavanceerde orkestrators zoals Docker Swarm en Kubernetes geschikter zijn voor grootschalige productie-workloads, blijft Compose een essentieel startpunt om de basis van containerorkestratie te begrijpen en ontwikkelworkflows te verbeteren.

Bekijk onze Docker-cursussen om te leren:

• Containerization and Virtualization with Docker and Kubernetes 
• Intermediate Docker