Hoe Docker Compose op Ubuntu te installeren en te gebruiken

Inleiding

Docker vereenvoudigt het proces van het beheren van applicatieprocessen in containers. Hoewel containers op bepaalde manieren lijken op virtuele machines, zijn ze lichter en meer middelenbesparend. Dit stelt ontwikkelaars in staat om een applicatieomgeving op te splitsen in meerdere geïsoleerde diensten.

Voor toepassingen die afhankelijk zijn van meerdere diensten, kan het snel onoverzichtelijk worden om alle containers samen op te starten, te laten communiceren en weer af te sluiten. Docker Compose is een tool waarmee je multi-container applicatieomgevingen kunt draaien op basis van definities in een YAML-bestand. Het gebruikt servicedefinities om volledig aanpasbare omgevingen te bouwen met meerdere containers die netwerken en datavolumes kunnen delen.

Deze gids begeleidt je bij het installeren van Docker Compose op een Ubuntu-server en het uitvoeren van een eenvoudige container. Vervolgens leer je een omgeving met meerdere services op te bouwen met een WordPress-toepassing en een MySQL-database. We behandelen ook meer geavanceerde onderwerpen, waaronder het schalen van services, het definiëren van aangepaste netwerken en het gebruik van modulaire include-richtlijnen. Tot slot biedt dit artikel een migratiehandleiding van de oudere docker-compose (v1) naar de moderne docker compose (v2) en een gedetailleerde sectie over het oplossen van veelvoorkomende problemen zoals poortconflicten en machtigingsfouten.

Vereisten

Om dit artikel te volgen, heb je het volgende nodig:

• Toegang tot een lokale Ubuntu-machine of ontwikkelserver als een niet-rootgebruiker met sudo-rechten. Als je een externe server gebruikt, is het aan te raden om een actieve firewall geïnstalleerd te hebben. Raadpleeg voor het instellen hiervan onze Gids voor de Initiële Serveropzet voor Ubuntu.
• Docker geïnstalleerd op je server of lokale machine, volgens Stap 1 en 2 van Hoe Docker te installeren op Ubuntu – Stapsgewijze handleiding.

Stap 1 — Docker Compose installeren

Er zijn twee manieren om Docker Compose op Ubuntu te installeren:

• Installeren via de repository
• Handmatig installeren

We zullen beide manieren in deze sectie bespreken.

Docker Compose installeren met de apt-repository

Laten we eerst de Docker apt-repository instellen.

# Add Docker's official GPG key:

sudo apt-get update

sudo apt-get install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc



# Add the repository to Apt sources:

echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \

  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Nu kunt u Docker Compose installeren met het volgende commando:

sudo apt install docker-compose-plugin

Docker Compose is nu succesvol op uw systeem geïnstalleerd. Om te controleren of de installatie succesvol was, kunt u het volgende uitvoeren:

docker compose version

Je zult uitvoer zien die hierop lijkt:

Docker Compose version v2.3.3

Docker Compose handmatig installeren

Om ervoor te zorgen dat je de meest bijgewerkte stabiele versie van Docker Compose krijgt, download je deze software van de officiële GitHub-repository.

Bevestig eerst de nieuwste versie die beschikbaar is op hun releases-pagina. Op het moment van schrijven is de meest recente stabiele versie v2.40.2.

Gebruik het volgende commando om te downloaden:

mkdir -p ~/.docker/cli-plugins/

curl -SL https://github.com/docker/compose/releases/download/v2.40.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Stel vervolgens de juiste machtigingen in zodat het docker compose-commando uitvoerbaar is:

chmod +x ~/.docker/cli-plugins/docker-compose

In de volgende sectie zul je zien hoe je een docker-compose.yml-bestand instelt en een gecontaineriseerde omgeving opzet en laat draaien met dit hulpmiddel.

Stap 2 — Een docker-compose.yml-bestand instellen

Om te laten zien hoe je een docker-compose.yml-bestand kunt opzetten en met Docker Compose kunt werken, maak je een webserveromgeving met behulp van de officiële Nginx-image van Docker Hub, de openbare Docker-registry. Deze gecontaineriseerde omgeving zal één statisch HTML-bestand serveren.

Begin met het maken van een nieuwe map in je thuisfolder en ga er vervolgens naartoe:

mkdir ~/compose-demo

cd ~/compose-demo

Maak in deze directory een applicatiemap aan die als document root voor je Nginx-omgeving zal dienen:

mkdir app

Gebruik je favoriete teksteditor om een nieuw index.html-bestand te maken in de app-map:

nano app/index.html

Plaats de volgende inhoud in dit bestand:

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Sla het bestand op en sluit het wanneer je klaar bent. Als je nano gebruikt, kun je dat doen door CTRL+X te typen, vervolgens Y en ENTER om te bevestigen.

Maak vervolgens het docker-compose.yml-bestand aan:

nano docker-compose.yml

Plaats de volgende inhoud in uw docker-compose.yml bestand:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

In modern Docker Compose is het version-veld optioneel en wordt het vaak weggelaten, omdat Compose automatisch de configuratieversie kan detecteren. Het bovenstaande voorbeeld bevat geen version-veld, wat de aanbevolen aanpak is voor de meeste nieuwe projecten. Je hoeft version alleen op te geven voor legacy-compatibiliteit.

Je hebt dan het services blok, waar je de services instelt die deel uitmaken van deze omgeving. In jouw geval heb je een enkele service genaamd web. Deze service gebruikt het nginx:alpine image en stelt een poortomleiding in met de ports directive. Alle verzoeken op poort 8000 van de host machine (het systeem van waaruit je Docker Compose uitvoert) worden doorgestuurd naar de web container op poort 80, waar Nginx zal draaien.

De volumes-directive maakt een gedeeld volume tussen de hostmachine en de container. Dit zal de lokale app-map delen met de container, en het volume zal zich bevinden op /usr/share/nginx/html binnen de container, wat vervolgens de standaard documentroot voor Nginx zal overschrijven.

Sla het bestand op en sluit het.

Je hebt een demopagina en een docker-compose.yml bestand opgezet om een gecontaineriseerde webserveromgeving te creëren die deze zal serveren. In de volgende stap zet je deze omgeving op met Docker Compose.

Stap 3 — Docker Compose uitvoeren

Met het docker-compose.yml-bestand op zijn plaats, kunt u nu Docker Compose uitvoeren om uw omgeving op te starten. Het volgende commando zal de benodigde Docker-images downloaden, een container voor de web-service aanmaken en de gecontaineriseerde omgeving op de achtergrond uitvoeren:

docker compose up -d

Docker Compose zal eerst op je lokale systeem naar de gedefinieerde image zoeken, en als het de image niet kan vinden, zal het de image van Docker Hub downloaden. Je zult output zoals deze zien:

Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

sudo usermod -aG docker ${USER}

Na het uitvoeren van dit commando moet u uitloggen en weer inloggen zodat de groepswijzigingen van kracht worden. U kunt de wijzigingen ook activeren voor de huidige terminalsessie door te typen:

newgrp docker

Dit commando zou eventuele machtigingsfouten met betrekking tot de Docker-socket moeten oplossen. Voor een volledige handleiding verwijzen we u naar Stap 2 van Hoe Docker op Ubuntu te installeren – Stapsgewijze gids.

Je omgeving draait nu op de achtergrond. Om te controleren of de container actief is, kun je het volgende uitvoeren:

docker compose ps

Met dit commando wordt informatie weergegeven over de actieve containers en hun status, evenals eventuele poortomleidingen die momenteel van kracht zijn:

       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Je kunt nu toegang krijgen tot de demo-applicatie door je browser te richten op localhost:8000 als je deze demo op je lokale machine uitvoert, of your_server_domain_or_IP:8000 als je deze demo op een externe server uitvoert.

Je zult een pagina zoals deze zien:

Het gedeelde volume dat je hebt ingesteld in het docker-compose.yml-bestand houdt de bestanden in je app-map gesynchroniseerd met de documentroot van de container. Als je wijzigingen aanbrengt in het index.html-bestand, worden deze automatisch door de container opgepikt en dus weergegeven in je browser wanneer je de pagina herlaadt.

In de volgende stap zie je hoe je je gecontaineriseerde omgeving kunt beheren met Docker Compose-commando's.

Stap 4 — Vertrouwd raken met Docker Compose-commando's

Je hebt gezien hoe je een docker-compose.yml-bestand kunt opzetten en je omgeving kunt starten met docker compose up. Je zult nu zien hoe je Docker Compose-commando's kunt gebruiken om je gecontaineriseerde omgeving te beheren en ermee te communiceren.

Om de logs die door je Nginx-container worden geproduceerd te controleren, kun je het logs-commando gebruiken:

docker compose logs

Je zult een uitvoer zien die hierop lijkt:

Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Als je de uitvoering van de omgeving wilt pauzeren zonder de huidige status van je containers te wijzigen, kun je het volgende gebruiken:

docker compose pause

Pausing compose-demo_web_1 ... done

Om de uitvoering te hervatten na het onderbreken:

docker compose unpause

Unpausing compose-demo_web_1 ... done

Het stop-commando zal de uitvoering van de container beëindigen, maar het zal geen gegevens die aan je containers zijn gekoppeld verwijderen:

docker compose stop

Stopping compose-demo_web_1 ... done

Als je de containers, netwerken en volumes die aan deze gecontaineriseerde omgeving zijn gekoppeld wilt verwijderen, gebruik dan het down-commando:

docker compose down

Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Merk op dat dit de basisafbeelding die door Docker Compose wordt gebruikt om je omgeving op te starten (in jouw geval nginx:alpine) niet zal verwijderen. Op deze manier, wanneer je je omgeving opnieuw opstart met een docker compose up, zal het proces veel sneller zijn omdat de afbeelding al op je systeem staat.

Als je de basisafbeelding ook van je systeem wilt verwijderen, kun je het volgende gebruiken:

docker image rm nginx:alpine

Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Stap 5 — Het bouwen van een applicatie met meerdere diensten

De echte kracht van Docker Compose ligt in het beheren van meerdere services die samenwerken. Het Nginx-voorbeeld was een enkele service. Laten we een meer praktische, multi-service applicatie maken: een WordPress-website die is verbonden met een MySQL-database.

Deze setup omvat twee diensten: wordpress (die de applicatie draait) en db (die de database draait). We zullen ook Docker-volumes gebruiken om ervoor te zorgen dat de databasegegevens behouden blijven, zelfs als de container wordt verwijderd.

Laten we een nieuwe map voor deze applicatie aanmaken:

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

Voor dit voorbeeld hebben we geen lokale bestanden nodig, aangezien de afbeeldingen alle benodigde software bevatten.

Maak een nieuw docker-compose.yml-bestand aan:

nano docker-compose.yml

Plak de volgende configuratie. Dit bestand is complexer, dus we zullen elk onderdeel bekijken.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

volumes:
  db_data:

Sla het bestand op en sluit het. Vergeet niet de <^...^> plaatsaanduidingen te vervangen door sterke, veilige wachtwoorden.

Laten we de nieuwe richtlijnen in dit bestand doornemen:

• services: Dit blok definieert nog steeds onze containers. We hebben er nu twee: db en wordpress.
• image: We gebruiken mysql:8.0 voor de database en de wordpress:latest afbeelding voor de applicatie.
• container_name: Hiermee wordt een specifieke, voor mensen leesbare naam voor de container ingesteld, die gemakkelijker te verwijzen is dan de automatisch gegenereerde namen.
• environment: Dit is een lijst met omgevingsvariabelen die aan de container worden doorgegeven. De mysql-image gebruikt deze om het root-wachtwoord in te stellen en een initiële database en gebruiker aan te maken. De wordpress-image gebruikt ze om te weten hoe verbinding te maken met zijn database.

• volumes (serviceniveau):

  • Voor de db-service koppelt db_data:/var/lib/mysql een door Docker beheerd volume genaamd db_data aan de MySQL-datamap binnen de container. Dit houdt je gegevens veilig.
  • Voor de wordpress service koppelt ./wp_content:/var/www/html/wp-content een lokale map (wp_content) aan de WordPress-contentmap. Hierdoor kun je thema's en plugins direct vanaf je hostmachine bewerken.
• depends_on: Dit vertelt Compose om de db-service te starten voordat het de wordpress-service start. Dit is belangrijk, omdat WordPress zal falen als het bij het opstarten de database niet kan vinden.
• volumes (topniveau): Dit blok definieert de benoemde volumes. db_data: maakt een door Docker beheerd volume aan, wat de aanbevolen manier is om blijvende gegevens te beheren.

Breng nu deze multi-service applicatie op:

docker compose up -d

Compose zal zowel de mysql als de wordpress afbeeldingen ophalen en vervolgens de containers aanmaken, waarbij de db service als eerste wordt gestart.

Creating network "compose-demo_default" with the default driver
Creating volume "compose-demo_db_data" with default driver
Pulling db (mysql:8.0)...
...
Pulling wordpress (wordpress:latest)...
...
Creating mysql_db        ... done
Creating wordpress_app ... done

Je kunt nu toegang krijgen tot je nieuwe WordPress-site door naar localhost:8001 of <^your_server_domain_or_IP<^>:8001 in je browser te gaan. Je zou het WordPress-installatiescherm moeten zien. Voor een uitgebreider voorbeeld, bekijk ons artikel over Hoe WordPress te Installeren met Docker Compose.

Stap 6 — Docker Compose gebruiken voor AI/ML-ontwikkeling

Naast webapplicaties is Docker Compose een uiterst handig hulpmiddel voor het creëren van reproduceerbare omgevingen voor datascience en machine learning (AI/ML). AI/ML-projecten staan bekend om hun complexe afhankelijkheden, waaronder specifieke versies van Python, bibliotheken zoals TensorFlow of PyTorch en systeemniveau-drivers zoals de NVIDIA CUDA Toolkit. Docker Compose legt deze hele omgeving vast in configuratiebestanden, waardoor het probleem van 'het werkt op mijn computer' wordt opgelost, wat essentieel is voor reproduceerbaar onderzoek.

In dit voorbeeld maak je een AI/ML-omgeving met meerdere services die bestaat uit:

• JupyterLab: Een omgeving voor interactieve ontwikkeling, gebouwd met een aangepaste Dockerfile.
• PostgreSQL: Een databasecontainer voor het opslaan van experimentresultaten en metadata.
• GPU-toegang: De JupyterLab-container wordt geconfigureerd om toegang te krijgen tot de NVIDIA GPU van de hostmachine, een veelvoorkomende vereiste voor het trainen van modellen.

Bestandsstructuur

Maak eerst een directory voor je project. Binnenin maak je een docker-compose.yml bestand, een jupyter directory, een Dockerfile voor Jupyter en een requirements.txt bestand. De structuur zou er ongeveer zo uit moeten zien:

ai-project/
├── docker-compose.yml
└── jupyter/
    ├── Dockerfile
    └── requirements.txt

Het maken van de componentbestanden

1. Het requirements.txt-bestand

Dit bestand bevat de Python-pakketten voor je datawetenschapsomgeving.

nano jupyter/requirements.txt

Voeg de benodigde pakketten toe. Voor dit voorbeeld zullen we bibliotheken opnemen voor datamanipulatie, databaseverbinding en een deep learning-framework.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Sla het bestand op en sluit het.

2. Het Dockerfile

Dit bestand definieert uw aangepaste JupyterLab-service. Het gebruikt een officiële Jupyter-image als basis en installeert de pakketten uit requirements.txt.

nano jupyter/Dockerfile

Plak de volgende inhoud:

# Start from a base image that includes Jupyter and scientific libraries
FROM jupyter/scipy-notebook:latest

# Copy our local requirements file into the container
COPY requirements.txt /tmp/requirements.txt

# Install the Python packages
RUN pip install --no-cache-dir -r /tmp/requirements.txt

Dit bestand geeft Docker de instructie om jupyter/scipy-notebook als uitgangspunt te gebruiken, je requirements.txt in de container te kopiëren en vervolgens pip te gebruiken om de pakketten te installeren.

Het definiëren van de omgeving met docker-compose.yml

Maak nu het hoofd docker-compose.yml bestand aan. Dit bestand zal zowel de db service als je aangepaste jupyter service orkestreren.

nano docker-compose.yml

Plak de volgende configuratie en vervang de <^...^>-plaatsaanduidingen door je eigen veilige gegevens.

services:
  db:
    image: postgres:15-alpine
    container_name: ai_postgres_db
    environment:
      POSTGRES_USER: <^your_db_user^>
      POSTGRES_PASSWORD: <^your_db_pass^>
      POSTGRES_DB: experiments
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U <^your_db_user^> -d experiments"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - ai_net

  jupyter:
    build: ./jupyter
    container_name: ai_jupyter_lab
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_USER=<^your_db_user^>
      - POSTGRES_PASSWORD=<^your_db_pass^>
      - POSTGRES_DB=experiments
    restart: unless-stopped
    networks:
      - ai_net
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  postgres_data:
    name: ai_project_data

networks:
  ai_net:
    driver: bridge

Dit configuratiebestand introduceert verschillende belangrijke concepten:

• build: ./jupyter: Dit vertelt Docker Compose om een aangepaste afbeelding te bouwen voor de jupyter-service. Het zoekt naar een Dockerfile in de opgegeven ./jupyter map.
• volumes: - ./notebooks:/home/jovyan/work: Dit koppelt een lokale map genaamd notebooks aan de container. Dit zorgt ervoor dat alle Jupyter-notebooks die je maakt direct op je host-machine worden opgeslagen, zodat ze behouden blijven, zelfs nadat de container is verwijderd.
• healthcheck: Zoals te zien in de sectie voor probleemoplossing, controleert deze test of de db-service niet alleen draait, maar ook klaar is om verbindingen te accepteren voordat andere services starten.
• depends_on: ... condition: service_healthy: Dit geeft de jupyter-service aan dat deze moet wachten totdat de db-healthcheck is geslaagd voordat hij start.

• deploy.resources.reservations.devices: Dit is het blok dat toegang tot de GPU aanvraagt.

  • driver: nvidia: Geeft de hostdriver aan die gebruikt moet worden.
  • count: 1: Vraagt om één GPU.
  • capabilities: [gpu]: Zorgt ervoor dat de container de nodige mogelijkheden heeft om de GPU te gebruiken.

Het AI/ML-omgeving beheren

Met je bestanden op hun plaats ben je klaar om de services te bouwen en uit te voeren.

1. Ga vanuit je ai-project map naar de opdracht docker compose up. Je moet de --build vlag de eerste keer toevoegen om Compose te vertellen je aangepaste jupyter afbeelding te bouwen.

   docker compose up -d --build

2. Compose zal eerst de jupyter-afbeelding bouwen (wat een paar minuten kan duren omdat TensorFlow wordt gedownload), vervolgens de postgres-afbeelding ophalen, en tot slot beide containers starten.

   [+] Building 5.8s (9/9) FINISHED
    => [internal] load build definition from Dockerfile
   ...
   [+] Running 3/3
    ✔ Network ai-project_ai_net        Created
    ✔ Container ai_postgres_db         Started
    ✔ Container ai_jupyter_lab         Started

3. Je kunt nu toegang krijgen tot de JupyterLab-interface door in je browser naar http://localhost:8888 (of <^your_server_ip^>:8888) te navigeren. Er wordt om een token gevraagd, dat je kunt verkrijgen uit de containerlogboeken:

   docker compose logs jupyter

   Zoek naar een regel die lijkt op http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

4. In een Jupyter-notebook kun je nu verbinding maken met je database met de hostnaam db en de opgegeven inloggegevens. Je omgeving heeft ook toegang tot de GPU van de host voor het trainen van modellen.

Schaalbare diensten en het gebruik van aangepaste netwerken

Docker Compose bevat functies voor het schalen van services en het beheren van de netwerken waarop ze communiceren.

Service schalen met replicas

Stel je voor dat je Nginx-webserver uit Stap 2 te veel verkeer krijgt. Je kunt de web-service schalen om meerdere containerinstanties te laten draaien. Docker Compose kan dit automatisch beheren.

Er zijn twee primaire manieren om een dienst op te schalen.

1. Het gebruik van de replicas-sleutel (Voorkeur in v2)

Je kunt het gewenste aantal instanties rechtstreeks definiëren in je docker-compose.yml-bestand met behulp van de deploy- en replicas-sleutels. Deze functie was oorspronkelijk onderdeel van Docker Swarm, maar is nu beschikbaar voor standaard Compose-implementaties.

Pas je Nginx docker-compose.yml uit stap 2 aan:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3

Wanneer je docker compose up -d uitvoert, zal Compose drie web containers aanmaken. Je krijgt echter een probleem: allemaal zullen ze proberen te binden aan hostpoort 8000. Dit zal een foutmelding "poort is al toegewezen" veroorzaken voor de tweede en derde container. Om dit op te lossen in een productieomgeving, zou je de ports-mapping uit de web-service verwijderen. Op deze manier zijn de webcontainers alleen toegankelijk binnen het Docker-netwerk. Een aparte load balancer-service zou de enige zijn met een publieke poort. Deze zou het verkeer dan verdelen over de drie webreplica's.

Een voorbeeldconfiguratie zou er als volgt uitzien (dit is een geavanceerd voorbeeld):

services:
  web:
    image: nginx:alpine
    # No 'ports' mapping here.
    # The service is only accessible inside the 'web-net' network.
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3
    networks:
      - web-net

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80" # The load_balancer is the only service with a public port.
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf # A config file that load balances to 'web'.
    networks:
      - web-net
    depends_on:
      - web

networks:
  web-net:

In deze opstelling luistert de load_balancer op poort 80 en stuurt intern verzoeken door naar web_1, web_2 en web_3.

Deze replicas-sleutel is het meest nuttig wanneer deze wordt gebruikt met een reverse proxy (zoals Traefik of een andere Nginx-instantie) die verzoeken kan load-balancen tussen de replicas binnen het Docker-netwerk, zonder dat elke replica een poort op de host hoeft bloot te stellen.

2. Het gebruik van de --scale vlag

Een veelgebruikte methode om te schalen is de --scale-vlag, een overblijfsel van Compose v1. Deze vlag wordt tijdens de uitvoering toegepast en overschrijft elke replicas-sleutel.

Je moet echter voorzichtig zijn met poortdefinities. Als je service een vaste hostpoorttoewijzing definieert (bijvoorbeeld "8000:80"), zal het uitvoeren van docker compose up --scale een fout veroorzaken voor de tweede en derde containers, omdat ze allemaal proberen zich aan dezelfde hostpoort te binden.

Om --scale te gebruiken voor services die poorten blootstellen, mag je geen vaste hostpoorttoewijzing gebruiken.

• Optie 1: Toewijzen aan willekeurige hostpoorten (Goed voor ontwikkeling)

  Je kunt je docker-compose.yml aanpassen om alleen de containerpoort op te geven. Dit vertelt Docker om poort 80 in elke container te koppelen aan een willekeurige, beschikbare poort op je hostmachine.

  services:
    web:
      image: nginx:alpine
      ports:
        - "80" # No fixed host port
      volumes:
        - ./app:/usr/share/nginx/html

  Nu, wanneer je het schaalcommando uitvoert:

  docker compose up -d --scale web=3

  Voer docker compose ps uit om het resultaat te zien. Elke container draait op een andere, willekeurig toegewezen poort van de host:

        Name                     Command               State          Ports        
  ----------------------------------------------------------------------------------
  compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49154->80/tcp
  compose-demo-web_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49155->80/tcp
  compose-demo-web_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49156->80/tcp

docker-compose.yml - Correct voor --scale

• Optie 2: Gebruik een reverse proxy (Goed voor productie)

  De andere oplossing, zoals vermeld in de replicas-sectie, is om de ports-directive volledig uit de web-service te verwijderen. Je zou dan een aparte load balancer-container gebruiken (die de enige publieke poort heeft) om het verkeer te beheren en te verdelen naar de geschaalde replicas binnen het Docker-netwerk.

  Om alle drie de containers te stoppen en te verwijderen, blijft het commando hetzelfde:

  docker compose down

Aangepaste Netwerkconfiguratie

Standaard maakt Docker Compose een enkel bridge-netwerk voor je applicatie. Elke service in het bestand is hiermee verbonden, waardoor de wordpress-container de db-container kon vinden enkel door de servicenaam (db) te gebruiken.

U kunt echter uw eigen aangepaste netwerken definiëren voor betere isolatie en controle.

Laten we het WordPress-voorbeeld aanpassen om een aangepast bridge-netwerk te gebruiken.

services:
  db:
    image: mysql:8.0
    ...
    networks:
      - app_net

  wordpress:
    image: wordpress:latest
    ...
    ports:
      - "8001:80"
    depends_on:
      - db
    networks:
      - app_net

volumes:
  db_data:

networks:
  app_net:
    driver: bridge

Dit hebben we toegevoegd:

• networks (topniveau): Dit definieert een nieuw netwerk genaamd app_net en geeft aan dat het de standaard bridge-driver moet gebruiken.
• netwerken (serviceniveau): Onder zowel db als wordpress koppelt deze sleutel ze aan ons app_net-netwerk.

Als je een derde dienst had (zoals een analysetool) die je niet koppelde aan app_net, zou deze volledig geïsoleerd zijn en niet in staat zijn om te communiceren met de db of wordpress-containers.

Voor multi-host clustering met Docker Swarm zou je de driver wijzigen van bridge naar overlay. De bridge driver is bedoeld voor communicatie tussen containers op één enkele host, wat de standaard is voor de meeste Docker Compose-gebruiksscenario's.

Het gebruik van modulaire configuratiebestanden

Naarmate je toepassingen groeien, kan je docker-compose.yml bestand groot en moeilijk te beheren worden. Docker Compose ondersteunt een include instructie, waarmee je je configuratie over meerdere bestanden kunt verdelen.

Stel je voor dat je je WordPress- en databasedefinities wilt scheiden, en misschien een gemeenschappelijke docker-compose.override.yml wilt hebben voor ontwikkelingsspecifieke instellingen (zoals het koppelen van een poort aan de database).

Je mapstructuur kan er ongeveer zo uitzien:

compose-demo/
├── docker-compose.yml
├── docker-compose.db.yml
├── docker-compose.web.yml

Dit bestand zal alleen de db-service definiëren.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

volumes:
  db_data:

Dit bestand zal alleen de wordpress-service definiëren.

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

Nu wordt je hoofd-docker-compose.yml-bestand heel eenvoudig. Het gebruikt gewoon include om de andere bestanden binnen te halen.

include:
  - docker-compose.db.yml
  - docker-compose.web.yml

Wanneer je docker compose up -d uitvoert, zal Compose alle drie de bestanden lezen, de configuraties samenvoegen en de db en wordpress services starten alsof ze in één enkel bestand waren gedefinieerd. Deze aanpak maakt je configuratie veel modularer en herbruikbaarder.

Migreren van docker-compose (v1) naar docker compose (v2)

De docker compose-opdracht die je in Stap 1 hebt geïnstalleerd is "Compose v2." Het is een op Go gebaseerde plugin die direct in de Docker CLI is ingebouwd.

De originele versie, „Compose v1,” was een apart Python-gereedschap dat werd aangeroepen met docker-compose (met een koppelteken). Sinds juli 2023 wordt Compose v1 niet langer ondersteund en is het verouderd.

Belangrijke wijzigingen en achterwaartse compatibiliteit

• Het Commando: De meest voor de hand liggende verandering is het commando. Het koppelteken (docker-compose) is nu een spatie (docker compose).
• Installatie: v1 werd geïnstalleerd met pip. v2 is inbegrepen bij Docker Desktop of geïnstalleerd als een CLI-plug-in, zoals je deed in Stap 1.
• YAML-bestanden: Uw docker-compose.yml-bestanden zijn vrijwel 100% backward compatible. Compose v2 ondersteunt volledig bestandsversies 3.x. U hoeft uw YAML-bestanden niet te wijzigen voor de migratie, alleen uw opdrachten.
• --project-name vlag: De -p vlag werkt nog steeds, maar de volledige vlag is nu --project-name in plaats van --project_name.

Handleiding voor Command-migratie

De meeste opdrachten zijn identiek, alleen is het streepje verwijderd. Hier is een tabel waarin de veelgebruikte v1-opdrachten worden vergeleken met hun v2-equivalenten.

docker-compose up -d

docker compose up -d

docker-compose down

docker compose down

docker-compose ps

docker compose ps

docker-compose logs

docker compose logs

docker-compose stop

docker compose stop

docker-compose build

docker compose build

docker-compose exec web bash

docker compose exec web bash

docker-compose run web bash

docker compose run web bash

docker-compose up --scale web=3

docker compose up --scale web=3

Zoals je kunt zien, is voor het dagelijks gebruik de enige wijziging docker-compose -> docker compose. Als je scripts gebruikt, kun je ze bijwerken door simpelweg het koppelteken te verwijderen.

Als je nog de oude docker-compose v1 geïnstalleerd hebt, kun je deze verwijderen om verwarring te voorkomen:

sudo pip3 uninstall docker-compose

Of, als het was geïnstalleerd met apt:

sudo apt remove docker-compose

Veelvoorkomende problemen met Docker Compose oplossen

Wanneer je met Docker Compose werkt, kun je problemen tegenkomen met betrekking tot bestandsindeling, rechten of conflicten bij het uitvoeren van containers. De meeste problemen kunnen worden gediagnosticeerd en opgelost door systematisch je configuratie, rechten en containerlogboeken te controleren.

Laten we eens kijken naar enkele van de meest voorkomende fouten en hun oplossingen.

Toestemming Geweigerd (Docker-socket)

Dit is een van de meest voorkomende fouten bij nieuwe Docker-gebruikers. Je voert docker compose up uit en ziet een foutmelding over de Docker daemon-socket.

permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

• Probleem: Uw niet-rootgebruiker heeft geen toestemming om te communiceren met de Docker-daemon, die wordt uitgevoerd als root.

• Oplossing: Je moet je gebruiker toevoegen aan de docker-groep, die tijdens de installatie van Docker is aangemaakt.

  1. Voeg uw gebruiker toe aan de docker-groep:

     sudo usermod -aG docker ${USER}

  2. Om het lidmaatschap van de nieuwe groep van kracht te laten worden, moet u uitloggen en opnieuw inloggen.

  3. Als alternatief kunt u de groepswijzigingen voor uw huidige terminalsessie activeren door te typen:

     newgrp docker

  Dit zou alle machtigingsfouten met betrekking tot de Docker-socket moeten oplossen.

YAML-syntaxis- en inspringfouten

Docker Compose kan niet worden uitgevoerd en meldt dat uw docker-compose.yml-bestand ongeldig is.

ERROR: The Compose file './docker-compose.yml' is invalid because:
services.web.ports contains an invalid type, it should be a list

Of :

mapping values are not allowed in this context at line 5

• Probleem: Het docker-compose.yml-bestand is afhankelijk van strikte YAML-syntaxis. De meest voorkomende fout is onjuiste inspringing. YAML gebruikt spaties, geen tabs, om de structuur te definiëren.

• Oplossing: Controleer zorgvuldig de inspringing van je docker-compose.yml-bestand.

  • De standaard is twee spaties voor elk niveau van inspringing.
  • Zorg ervoor dat alle sleutels op hetzelfde niveau (zoals version, services, volumes) in dezelfde kolom beginnen.
  • Zorg ervoor dat alle sub-sleutels (zoals image, ports, volumes onder een service) twee spaties verder ingesprongen zijn dan hun bovenliggende service (bijvoorbeeld web).
  • Gebruik een code-editor met een YAML-linter om automatisch syntaxfouten te markeren.

Havenconflicten

Je probeert je omgeving te starten, maar het commando faalt met een foutmelding dat het adres al in gebruik is.

Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use

• Probleem: Een ander proces op uw hostmachine luistert al naar de poort die u probeert te koppelen (in dit geval poort 8000). Dit is vaak een andere Docker-container of een lokale ontwikkelserver.

• Oplossing: Je hebt twee opties:

  1. Stop het andere proces. Je kunt het proces dat de poort gebruikt vinden met dit commando:

     sudo lsof -i :8000

     Als het een andere Docker-container is, stop deze dan met docker stop <container_id>.

  2. Wijzig de hostpoort in uw docker-compose.yml-bestand. Dit is vaak de eenvoudigste oplossing. Wijzig de ports-mapping van "8000:80" naar een andere poort, bijvoorbeeld "8001:80".

     ...
     ports:
       - "8001:80" # Changed from 8000
     ...

  docker-compose.yml

Service faalt met Verbinding Geweigerd (depends_on)

In een applicatie met meerdere services (zoals het WordPress- en MySQL-voorbeeld), start de wordpress-container, maar tonen de logs Connection refused of MySQL server has gone away wanneer geprobeerd wordt om verbinding te maken met de db-service.

• Probleem: Je hebt depends_on gebruikt, maar deze instructie wacht alleen tot de db container start. Het wacht niet tot de MySQL applicatie binnen de container volledig is geïnitialiseerd en klaar is om verbindingen te accepteren.

• Oplossing: De applicatie (in dit geval WordPress) moet worden geconfigureerd om de verbinding opnieuw te proberen. De meeste moderne images hebben deze retry-logica ingebouwd. Voor images die dit niet hebben, moet je een healthcheck implementeren.

  Je kunt een healthcheck toevoegen aan je db-service. De depends_on van de wordpress-service kan vervolgens worden ingesteld om te wachten tot de database “gezond” is, en niet alleen “gestart”.

Voorbeeld gezondheidscontrole voor MySQL:

services:
  db:
    image: mysql:8.0
    ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p<^your_root_password_here<^>"]
      interval: 10s
      timeout: 5s
      retries: 5

  wordpress:
    image: wordpress:latest
    ...
    depends_on:
      db:
        condition: service_healthy # This now waits for the healthcheck
    ...

Fouten met volumes en bind-mounts

Je kunt fouten tegenkomen met betrekking tot machtigingen in je containerlogboeken, of merken dat de datamap van je container leeg is.

Bestands-/Mapmachtigingen

• Probleem: De container draait als een specifieke gebruiker (bijvoorbeeld www-data met gebruikers-ID 33), maar de map die je op de host hebt gekoppeld is eigendom van jouw gebruiker (bijvoorbeeld ubuntu met gebruikers-ID 1000). De gebruiker van de container heeft geen permissie om naar de hostmap te schrijven.

• Oplossing: Verander de eigendom van de hostdirectory zodat deze overeenkomt met de gebruikers-ID binnen de container. Je kunt de gebruikers-ID van de container vinden door docker compose exec <service_name> id uit te voeren. Bijvoorbeeld, als de ID 33 is (gebruikelijk voor www-data):

  sudo chown -R 33:33 ./wp_content

Problemen met relatieve paden

• Probleem: Je docker-compose.yml gebruikt een relatieve pad zoals ./app, maar je index.html-bestand wordt niet geserveerd.

• Oplossing: Docker Compose interpreteert relatieve paden vanaf de map waar je het docker compose up commando uitvoert. Voer Compose-commando's altijd uit vanuit dezelfde map die je docker-compose.yml bestand bevat.

Netwerken en Dienstontdekking

De logboeken van uw applicatiecontainer tonen Host niet gevonden of Kan host niet oplossen: db.

• Probleem: Je wordpress container kan de db container niet op het netwerk vinden.

• Oplossing: Standaard maakt Docker Compose een netwerk aan en koppelt alle services eraan. Services kunnen elkaar vinden met hun service namen.

  1. Controleer servicenames: Zorg ervoor dat de hostnaam in de configuratie van je applicatie (bijv. de WORDPRESS_DB_HOST omgevingsvariabele) exact hetzelfde is als de servicenaam in je docker-compose.yml (bijv. db).

  2. Controleer het netwerk: Gebruik docker compose ps om de naam van je project te vinden (bijv. compose-demo). Controleer vervolgens het standaardnetwerk:

     docker network inspect compose-demo_default

     De JSON-uitvoer zal alle containers tonen die aan dit netwerk zijn gekoppeld. Als een van je services ontbreekt, controleer dan je docker-compose.yml op een eventuele aangepaste networks-configuratie die deze mogelijk isoleert.

Commando komt niet overeen (v1 vs. v2)

Je typt docker-compose up (met een koppelteken) en ziet een foutmelding 'command not found'.

docker-compose: command not found

• Probleem: U probeert het commando voor Compose v1 te gebruiken, een verouderde Python-tool. Deze gids installeert Compose v2, een plugin die rechtstreeks in de Docker CLI is geïntegreerd.
• Oplossing: Gebruik het juiste commando door het koppelteken (-) te vervangen door een spatie.

Gebruik altijd docker compose (spatie) bij het volgen van deze gids.

Veelgestelde vragen

1. Waar wordt Docker Compose voor gebruikt?

Docker Compose is een hulpmiddel voor het definiëren en uitvoeren van multi-container Docker-toepassingen.

Het gebruikt één enkele YAML-bestand (standaard docker-compose.yml) om alle componenten van je applicatie te configureren, die services worden genoemd. Dit bestand definieert ook de netwerken die de services in staat stellen met elkaar te communiceren en de volumes die worden gebruikt voor persistente gegevens.

Met dit ene bestand kunt u uw volledige applicatiestack beheren met eenvoudige opdrachten:

• docker compose up start en draait je hele applicatie, inclusief alle opgegeven containers, netwerken en volumes.
• docker compose down stopt en verwijdert alle containers, netwerken en volumes die door jouw applicatie zijn aangemaakt.

Het is vooral nuttig voor het beheren van applicaties die meerdere componenten vereisen, zoals een website die een webserver nodig heeft (zoals Nginx), een applicatieback-end (zoals WordPress) en een database (zoals MySQL).

2. Hoe installeer ik Docker Compose op Ubuntu?

De aanbevolen methode is om Docker Compose te installeren als een plugin voor de Docker CLI. Dit wordt gedaan door het docker-compose-plugin-pakket te installeren vanuit de officiële apt-repository van Docker.

1. Zorg er eerst voor dat je de officiële Docker-documentatie hebt gevolgd om de apt-repository van Docker op je Ubuntu-systeem in te stellen.

2. Werk uw pakketlijst bij:

   sudo apt update

3. Installeer de Docker Compose-plug-in:

   sudo apt install docker-compose-plugin

4. Controleer de installatie door de versie te controleren. De opdracht gebruikt een spatie, geen streepje.

   docker compose version

3. Hoe werk ik Docker Compose bij naar de nieuwste versie?

Omdat Docker Compose (v2) als een systeempakket is geïnstalleerd met apt, kunt u het bijwerken via het standaard software-updateproces van Ubuntu.

1. Vernieuw je lokale pakketindex:

   sudo apt update

2. Voer een systeemwijde upgrade uit, inclusief de Compose-plug-in:

   sudo apt upgrade

   Als je echter alleen de plugin zelf wilt bijwerken, kun je het volgende uitvoeren:

   sudo apt install --only-upgrade docker-compose-plugin

4. Kan Docker Compose worden gebruikt in productieomgevingen?

Ja, Docker Compose wordt vaak gebruikt in productie, vooral voor applicaties die op een enkele host draaien.

Het biedt een eenvoudige manier om de services, netwerken en volumes van uw applicatie te definiëren, implementeren en beheren. Voor een enkele-serverimplementatie is het een zeer effectieve en eenvoudig te beheren oplossing.

Voor complexere scenario's waarbij containers over meerdere hosts (een cluster) moeten worden gecoördineerd, worden vaker andere tools gebruikt. Deze omvatten Docker Swarm (die een vergelijkbare Compose-bestandsyntaxis gebruikt) en Kubernetes (wat de industriestandaard is voor grootschalige containerorkestratie).

5. Wat is het verschil tussen Docker en Docker Compose?

Deze tabel geeft de belangrijkste verschillen weer tussen de Docker CLI en de Docker Compose CLI.

Kortom, je gebruikt docker om met een enkele container te communiceren. Je gebruikt docker compose om je gehele applicatiestack (bijv. web, app, db) in één keer te beheren.

6. Hoe kan ik meerdere containers uitvoeren met Docker Compose?

Je draait meerdere containers door ze als services te definiëren in je docker-compose.yml-bestand.

1. Maak een bestand genaamd docker-compose.yml.

2. Gebruik in dit bestand de sleutel services: om elke container te definiëren die je wilt uitvoeren.

   Hier is een praktisch voorbeeld dat twee containers definieert en uitvoert: een WordPress-site en een MySQL-database.

   services:
     db:
       # This is the first service (container)
       image: mysql:8.0
       environment:
         MYSQL_ROOT_PASSWORD: <^your_password_here<^>
         MYSQL_DATABASE: wordpress
       volumes:
         - db_data:/var/lib/mysql
   
     wordpress:
       # This is the second service (container)
       image: wordpress:latest
       ports:
         - "8001:80"
       environment:
         WORDPRESS_DB_HOST: db
         WORDPRESS_DB_PASSWORD: <^your_password_here<^>
       depends_on:
         - db
   
   volumes:
     db_data:

docker-compose.yml

3. Sla het bestand op en open een terminal in dezelfde map.

4. Voer één enkele opdracht uit om beide containers te starten:

   docker compose up -d

Docker Compose zal het bestand lezen, een gedeeld netwerk voor de services aanmaken, zowel de mysql- als de wordpress-images ophalen en een container voor elke service starten.

7. Waarom Docker Compose gebruiken voor ontwikkeling?

Docker Compose is een standaardtool voor ontwikkelomgevingen omdat het verschillende veelvoorkomende problemen oplost.

• Consistente Omgevingen: Het zorgt ervoor dat elke ontwikkelaar in een team exact dezelfde diensten (database, cache, webserver) draait met precies dezelfde versies en configuraties. Dit wordt gedefinieerd in het docker-compose.yml-bestand, dat wordt vastgelegd in versiebeheer. Dit elimineert het "werkt het alleen op mijn machine"-probleem.

• Eenvoud: Het vervangt complexe installatiescripts en lange docker run-commando's. Een ontwikkelaar hoeft alleen docker compose up uit te voeren om de gehele applicatiestack te starten en docker compose down om deze te stoppen.

• Service-isolatie: Ontwikkelaars kunnen aan meerdere projecten op dezelfde machine werken zonder afhankelijkheidsconflicten. Project A kan PostgreSQL 9.6 gebruiken en Project B kan PostgreSQL 14 gebruiken, aangezien elke database draait in een geïsoleerde container die wordt beheerd door zijn eigen Compose-bestand.

• Omdat Compose alle afhankelijkheden van een applicatie samen opstart, creëert het een perfecte lokale omgeving voor het uitvoeren van integratietests die verifiëren hoe services met elkaar samenwerken.

Conclusie

In deze gids heb je Docker Compose geïnstalleerd en een complete multi-containerapplicatie geconfigureerd. Je begon met een basis docker-compose.yml-bestand voor een Nginx-webserver en ging verder naar een complexere, realistische stack met een WordPress-applicatie en een MySQL-database. Je hebt geleerd om de volledige levenscyclus van de toepassing te beheren, van het bouwen en uitvoeren van services tot het stoppen en verwijderen ervan.

Je bent nu vertrouwd met de belangrijkste concepten voor het effectief beheren van applicaties, inclusief service-scaling, aangepaste netwerkdefinities en het opsplitsen van je configuratie in modulaire bestanden met behulp van de include-instructie. Door de migratiehandleiding en de stappen voor probleemoplossing te volgen, kun je ook veelvoorkomende problemen oplossen, zoals poortconflicten, "Toegang geweigerd"-fouten en YAML-syntaxisfouten. De hier behandelde vaardigheden stellen je in staat om consistente, reproduceerbare ontwikkelomgevingen te bouwen en met vertrouwen single-host-applicaties uit te rollen.

Voor een complete referentie van alle beschikbare docker compose-opdrachten, raadpleeg de officiële documentatie.

Voor meer Docker-gerelateerde tutorials, bekijk de volgende artikelen:

• Hoe Docker op Ubuntu te installeren – Stapsgewijze handleiding
• Hoe WordPress te installeren met Docker Compose

Bedankt dat je hebt geleerd met de Linux-Console.net Community.