Docker Compose CheatSheet - De meest nuttige opdrachten met voorbeelden

Hier is een
Docker Compose naslagblad
met aangegeven voorbeelden om je snel te helpen Compose-bestanden en -opdrachten te beheersen.

Compose-bestandsverwijzing: 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:          # Aangepaste netwerk
  appnet:
    driver: bridge

volumes:           # Genoemd volume
  db_data:

• services: Elke container in je meervoudige containerapplicatie. In het hierboven genoemde voorbeeld hebben we twee services: web en db.
• networks & volumes: Definieer geïsoleerde netwerken en aanhoudende opslag – hier hebben we het netwerk appnet en het volume db_data.

Voorbeelden

Enkele service met poorttoewijzing

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

Laat de app op hostpoort 8000 zien en bouw vanuit de Dockerfile in de huidige map.

Meervoudige service met gedeelde 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 aangehouden genoemd volume – db_data.

Gebruik van buildcontext en Dockerfile-pad

Je kunt docker image bouwen op aanvraag van het in docker-compose.yml opgegeven Dockerfile.

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

Delen van gegevens 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 gegevensuitwisseling) – shared_data.

Geavanceerde Compose-bestandsopties

• environment: Stel omgevingsvariabelen in voor containers.
• depends_on: Beheer de opstartvolgorde van services.
• deploy.replicas: Schaal service in Swarm-modus.

Voorbeeld:

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

Start 3 webinstanties; beheert alleen de opstartvolgorde (niet de gereedheid).

Essentiële Docker Compose-opdrachten

Vaak voorkomende Compose patronen

• Databases met aanhoudende gegevens

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

  DB-gegevens blijven behouden in het volume mysql_data bij herstart van containers.

• Bind mounten van code voor ontwikkeling

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

  Livebewerken van code op de host, automatisch weerspiegeld in de container.

Nuttige vlaggen

• -d: Afgeleide modus (uitvoeren in de achtergrond).
• --build: Forceer opnieuw bouwen van beelden voor het starten.
• --force-recreate: Hercreëer containers zelfs als ze onveranderd zijn.
• --remove-orphans: Verwijder containers die niet zijn gedefinieerd in het Compose-bestand.

Definiëren en aanpassen van services

Je kunt services, netwerken en volumes definiëren en aanpassen in Docker Compose door gebruik te maken van het docker-compose.yml-bestand, dat alle configuratie- en orkestratiebehoeften van je toepassing centraliseert.

• Services worden gedefinieerd onder de services-sleutel.
• Elke service vertegenwoordigt een containerconfiguratie, waarin je kunt instellen:
  • Image: Kies een beeld uit Docker Hub of een ander register.
  • Ports: Koppel containerpoorten aan hostpoorten.
  • Omgevingsvariabelen: Geef configuratiewaarden door.
  • Volumes: Bewaar gegevens of deel bestanden/mappen met de host of andere services.
  • Netwerken: Beheer 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 het nginx-beeld, stelt een omgevingsvariabele in, koppelt een volume, opent poort 80 als 8080 op de host en verbindt met het frontend-netwerk. De db-service doet iets vergelijkbaars voor PostgreSQL.

Aanpassen van netwerken

• Netwerken bepalen welke services met elkaar kunnen communiceren. Compose maakt een standaardnetwerk aan, maar je kunt er meer definiëren, aangepaste drivers specificeren, opties instellen en bepalen welke service welk netwerk moet gebruiken voor fijnmazige isolatie.
• Definieer netwerken op het hoogste niveau onder networks, en geef aan welke netwerken een service moet bijvoegen met de networks-sleutel op service-niveau.

Voorbeeld:

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

• Voeg netwerken toe aan services:

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

• Deze instelling laat de app-service toegang krijgen tot gebruikers op zowel het frontend- als backend-netwerk, terwijl db alleen beschikbaar is binnen het backend-netwerk.

Aanpassen van volumes

• Volumes worden gedefinieerd onder de volumes-sleutel op het hoogste niveau. Monteer ze in containers met de volumes-sleutel onder een service.
• Volumes kunnen genoemd worden, aangepaste drivers gebruiken en gedeeld worden tussen meerdere services voor aanhoudende opslag en gegevensdeling.

Voorbeeld:

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

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

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

• In dit voorbeeld is web_data aangehouden en beschikbaar voor elke container die het monteert. db_data zorgt ervoor dat databasegegevens nooit verloren gaan bij hercreatie van containers.
• Je kunt bindmounts 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 zet een bindmount op vanaf de hostpad /data/db_data naar binnen de container.

Samenvatting van best practices:

• Gebruik de servicenaam als DNS-hostnaam voor communicatie tussen services.
• Voeg services toe aan meerdere netwerken indien nodig om toegang te beheren.
• Gebruik genoemde volumes voor aanhoudende opslag en gegevensdeling.
• Definieer alles met YAML, wat versiebeheer en eenvoudige implementatiescripts mogelijk maakt.

Meerdere Compose-bestanden

Om complexere meervoudige serviceconfiguraties in Docker Compose te organiseren, kun je meerdere Compose-bestanden en override-bestanden gebruiken, wat modulaire, omgevingsspecifieke en schaalbare configuraties mogelijk maakt. Hier is hoe dat werkt:

1. Basis- en overridebestandsstructuur

• Maak een basisbestand (compose.yaml of docker-compose.yml) met alle algemene, standaard service definities.
• Voeg omgevingsspecifieke overridebestanden toe (bijvoorbeeld docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Voorbeeldbestandsstructuur:

/project-directory
|-- docker-compose.yml           # Basisconfiguratie
|-- docker-compose.override.yml  # Lokale/ontwikkelingsoverrides (automatisch toegepast)
|-- docker-compose.prod.yml      # Productieoverrides
|-- docker-compose.test.yml      # Testoverrides (indien nodig)

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

2. Hoe bestandsoverrides werken

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

Voorbeeld van 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 het basisbeeld en de poort als de overschreven DEBUG-omgevingsvariabele.

3. Opdrachtgebruik voor meerdere bestanden

• Standaardgedrag: Als aanwezig, laadt Docker Compose automatisch docker-compose.override.yml samen met docker-compose.yml wanneer je elke opdracht uitvoert.
• Bestanden handmatig specificeren: Gebruik -f-vlaggen om te bepalen welke bestanden worden samengevoegd en in welke volgorde:

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

  • Dit negeert de standaardoverride en gebruikt productiespecifieke instellingen.

4. Praktische organisatiestrategieën

• Omgevingsafzondering: Gebruik één override per omgeving: dev, test, prod, etc.
• Microservices en teams: Breng configuratie op in aparte bestanden voor verschillende services of teams en combineer indien nodig.
• Functionele schakelaars: Extra bestanden kunnen optionele services of configuratie toevoegen of verwijderen voor tijdelijke behoeften (bijvoorbeeld een compose.debug.yml voor extra logboekregistratie).

5. Voordelen

• Duidelijkheid: Houd individuele bestanden klein en gericht.
• Schaalbaarheid: Voeg gemakkelijk nieuwe services, omgevingen of instellingen toe.
• Onderhoudbaarheid: Pas alleen relevante secties aan 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.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.

Organiseren van complexe Compose-instellingen met meerdere bestanden – en het gebruik van de override/merge-systeem – zorgt voor modulariteit, omgevingsspecifieke aanpassingen en eenvoudige schaalbaarheid voor grote, meervoudige Docker-applicaties.

Nuttige links

• https://docs.docker.com/compose/
• Docker Naslagblad
• Kubernetes Naslagblad
• Dockeriseer Flutter Web app met gedockerde Flutter build en Nginx
• Installeer Portainer op Linux