Docker Compose Cheat Sheet - De meest gebruikte commando's met voorbeelden

Hier is een Docker Compose cheatsheet met geannoteerde voorbeelden om u te helpen Compose-bestanden en -commando’s snel te beheersen.

Deze gids is onderdeel van Ontwikkeltools: De complete gids voor moderne ontwikkelworkflows.

Vereisten

Docker Engine moet geïnstalleerd zijn voordat u Compose kunt gebruiken. Volg op Ubuntu Docker installeren op Ubuntu om de juiste installatiemethode te kiezen en de docker compose-plugin in te stellen.

Compose-bestandsreferentie: docker-compose.yml

Kernstructuur:

version: '3'       # Compose-bestandsformaatversie

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Hostpoort 8080:Containerpoort 80
  db:
    image: postgres
    environment:            # Omgevingsvariabelen
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Aangepast netwerk
  appnet:
    driver: bridge

volumes:           # Genoemde volume
  db_data:

• services: Elke container in uw multi-container-applicatie. In het bovenstaande voorbeeld hebben we twee services: web en db. Voor individuele containeroperaties, zie de Docker Cheatsheet.
• networks & volumes: Definieer geïsoleerde netwerken en persistente opslag - hier hebben we appnet-netwerk en db_data-volume.

Voorbeelden

Enkele service met poortmapping

services:
  app:
    build: .
    ports:
      - "8000:80"   # Hostpoort 8000:Containerpoort 80

Maakt de app beschikbaar op hostpoort 8000 en bouwt vanaf het Dockerfile in de huidige map.

Multi-service met gedeeld volume en aangepast netwerk

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web en DB op hetzelfde netwerk; DB gebruikt een persistent genoemde volume - db_data.

Gebruik van build-context en Dockerfile-pad

U kunt een docker-image bouwen op verzoek vanuit de in docker-compose.yml gespecificeerde Dockerfile.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Delen van data tussen services

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Beide services hebben toegang tot hetzelfde volume (voor statische bestanden of data-uitwisseling) - shared_data.

Geavanceerde Compose-bestandsopties

• environment: Stel ENV-variabelen in voor containers.
• depends_on: Controleer de startvolgorde van services.
• deploy.replicas: Schaal service op in Swarm-modus.

Voorbeeld:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Start 3 web-instanties; controleert alleen de startvolgorde (niet de gereedheid).

Essentiële Docker Compose-commando’s

Veelvoorkomende Compose-patronen

• Databases met persistente data

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  DB-data blijft behouden in het mysql_data-volume bij het opnieuw starten van containers.

• Bind-mounten van code voor ontwikkeling

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Live-edit code op de host, automatisch weerspiegeld in de container.

Nuttige vlaggen

• -d: Detach-modus (draaien op de achtergrond).
• --build: Forceer het opnieuw bouwen van images voordat u start.
• --force-recreate: Maak containers opnieuw aan, zelfs als ze niet zijn veranderd.
• --remove-orphans: Verwijder containers die niet in het Compose-bestand zijn gedefinieerd.

Services definiëren en aanpassen

U kunt services, netwerken en volumes definiëren en aanpassen in Docker Compose door gebruik te maken van het docker-compose.yml-bestand, waarin al uw applicatieconfiguratie- en orchestratiebehoeften worden gecentraliseerd.

• Services worden gedefinieerd onder de services-sleutel.
• Elke service vertegenwoordigt een containerconfiguratie, waar u het volgende kunt instellen:
  • Image: Selecteer een image van Docker Hub of een ander register.
  • Ports: Map containerpoorten naar hostpoorten.
  • Environment variables: Geef configuratiewaarden door.
  • Volumes: Bewaar data of deel bestanden/mappen met de host of andere services.
  • Networks: Controleer welke netwerken de service kan bereiken.

Voorbeeld:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Hostpoort 8080:Containerpoort 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Hier gebruikt de web-service de nginx-image, stelt een omgevingsvariabele in, koppelt een volume, opent poort 80 als 8080 op de host en maakt verbinding met het frontend-netwerk. De db-service doet iets vergelijkbaars voor PostgreSQL.

Netwerken aanpassen

• Networks controleren welke services met elkaar kunnen communiceren. Compose maakt een standaard netwerk, maar u kunt er meer definiëren, aangepade drivers specificeren, opties instellen en bepalen welke service bij welk netwerk hoort voor fijnmazige isolatie.
• Definieer netwerken op het topniveau onder networks, en lijst welke netwerken een service moet aansluiten met de service-niveau networks-sleutel.

Voorbeeld:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Koppel netwerken aan services:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Deze opstelling stelt de app-service in staat om toegang te krijgen tot zowel de frontend als de backend-netwerken, terwijl db alleen toegankelijk is binnen de backend.

Volumes aanpassen

• Volumes worden gedefinieerd onder de top-level volumes-sleutel. Mount ze naar containers met behulp van de volumes-sleutel onder een service.
• Volumes kunnen een naam hebben, aangepaste drivers gebruiken en worden gedeeld tussen meerdere services voor data-persistentie en -deling.

Voorbeeld:

volumes:
  web_data:                # Genoemde volume voor webinhoud
  db_data:                 # Genoemde volume voor database

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• In dit voorbeeld wordt web_data bewaard en is het beschikbaar voor elke container die het monteert. db_data zorgt ervoor dat databasegegevens niet verloren gaan bij het opnieuw aanmaken van containers.
• U kunt bind-mounts definiëren met aangepaste driveropties voor geavanceerde gevallen:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Deze configuratie stelt een bind-mount in van het hostpad /data/db_data naar de container.

Samenvatting van best practices:

• Gebruik de servicenaam als DNS-hostnaam voor communicatie tussen services.
• Koppel services aan meerdere netwerken indien nodig om toegang te controleren.
• Gebruik genoemde volumes voor persistente opslag en datadeling.
• Definieer alles met YAML, wat versiebeheer en eenvoudige implementatiescripts mogelijk maakt.
• Voor containerbeheer en visualisatie, overweeg Portainer installeren op Linux.

Meerdere compose-bestanden

Om complexe multi-service-opstellingen in Docker Compose te organiseren, kunt u meerdere compose-bestanden en override-bestanden gebruiken, wat modulaire, omgeving-specifieke en schaalbare configuraties mogelijk maakt. Hier is hoe dit werkt:

1. Structuur van basis- en override-bestand

• Maak een basisbestand (compose.yaml of docker-compose.yml) met alle gemeenschappelijke, standaard service-definities.
• Voeg omgeving-specifieke override-bestanden toe (bijv. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Voorbeeldbestandsstructuur:

/project-directory
|-- docker-compose.yml           # Basisconfiguratie
|-- docker-compose.override.yml  # Lokale/dev-overrides (automatisch toegepast)
|-- docker-compose.prod.yml      # Productie-overrides
|-- docker-compose.test.yml      # Test-overrides (indien nodig)

De basisconfiguratie definieert kernservices, terwijl elke override instellingen aanpast voor een specifieke omgeving of geval.

2. Hoe bestandsoverrides werken

• Samenvoegen: Wanneer u docker compose up uitvoert, voegt Docker Compose de basis samen met eventuele overrides in volgorde; latere bestanden overschrijven, uitbreiden of toevoegen aan instellingen in eerdere bestanden.
• Veldoverriden: Als een service of veld in meerdere bestanden is gedefinieerd, wordt de waarde van het laatst gespecificeerde bestand gebruikt. Nieuwe velden worden toegevoegd.

Voorbeeld samenvoegen:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Resultaat: De web-service gebruikt zowel de basisimage en poort als de overriden DEBUG-omgevingsvariabele.

3. Commandogebruik voor meerdere bestanden

• Standaardgedrag: Indien aanwezig, laadt Docker Compose docker-compose.override.yml automatisch samen met docker-compose.yml wanneer u een commando uitvoert.
• Handmatig specificeren van bestanden: Gebruik -f-vlaggen om te controleren welke bestanden worden samengevoegd en in welke volgorde:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
  

  • Dit negeert de standaard override en gebruikt de productiespecifieke instellingen.

4. Praktische organisatiestrategieën

• Omgevingscheiding: Gebruik één override per omgeving: dev, test, prod, etc.
• Microservices en teams: Breek de configuratie op in aparte bestanden voor verschillende services of teams, en combineer ze indien nodig.
• Feature toggles: Aanvullende bestanden kunnen optionele services of configuratie introduceren of verwijderen voor tijdelijke behoeften (bijv. een compose.debug.yml voor extra logging).

5. Voordelen

• Duidelijkheid: Houdt afzonderlijke bestanden klein en gericht.
• Schaalbaarheid: Voeg eenvoudig nieuwe services, omgevingen of instellingen toe.
• Onderhoudbaarheid: Wijzig of review alleen relevante secties voor een bepaalde implementatie.

6. Voorbeeld: Omgevingen wisselen

Ontwikkeling:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Productie:

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Elke omgeving krijgt alleen de configuratie die nodig is, met alle gedeelde configuratie in het basisbestand.

Het organiseren van complexe Compose-opstellingen met meerdere bestanden - en het benutten van het override/samenvoegsysteem - zorgt voor modulariteit, omgeving-specifieke aanpassing en eenvoudige schaalbaarheid voor grote, multi-service Docker-applicaties.

Voor productie-implementatie op een enkele Linux-host — opstarten bij het opstarten, schone shutdown, updates en logrotatie — zie Docker Compose uitvoeren als Linux-service met systemd.

Nuttige links

• https://docs.docker.com/compose/
• Docker Cheatsheet
• Kubernetes Cheatsheet
• Flutter Web-app Dockeriseren met gedockeriseerde Flutter-build en Nginx
• Portainer installeren op Linux