# Hoe Docker Compose te gebruiken voor applicaties met meerdere containers

Compose vereenvoudigt het schalen en implementeren van applicaties in Docker door **het beheer van containers** te automatiseren. In onze tutorial gaan we dieper in op het instellen en gebruiken van Docker Compose om het implementatieproces van uw applicaties te stroomlijnen.

## Wat is Docker Compose?

Docker Compose wordt gebruikt om applicaties te beheren en de efficiëntie bij de ontwikkeling van containers te verhogen. Configuraties worden gedefinieerd in één YAML-bestand, waardoor applicaties eenvoudig te bouwen en te schalen zijn. Docker Compose wordt vaak gebruikt om een lokale omgeving in te richten. Het kan echter ook deel uitmaken van een **Continuous Integration / Continuous Delivery (CI/CD)-workflow**. Ontwikkelaars kunnen een specifieke containerversie definiëren voor het testen of voor specifieke pijplijnfasen. Dit maakt het gemakkelijker om problemen te identificeren en bugs te verhelpen voordat de applicatie in productie gaat.

## Vereisten voor Docker Compose

Voor **containerorkestratie** hebt u zowel Docker Engine als Docker Compose nodig. Zorg ervoor dat een van de volgende programma’s op uw systeem is geïnstalleerd:

- **Docker Engine en Docker Compose**: kunnen als zelfstandige binaire bestanden worden geïnstalleerd.
- **Docker Desktop**: ontwikkelomgeving met grafische gebruikersinterface, inclusief Docker Engine en Docker Compose.

Tip Ontdek hoe u Docker Compose op verschillende besturingssystemen kunt installeren in onze tutorials:

- [Docker Compose installeren op Ubuntu](https://www.ionos.com/nl-be/digitalguide/server/configuratie/docker-compose-op-ubuntu/)
- [Docker Compose installeren op macOS](https://www.ionos.com/nl-be/digitalguide/server/configuratie/docker-compose-op-mac/)
- [Docker Compose installeren op Windows](https://www.ionos.com/nl-be/digitalguide/server/configuratie/installeer-docker-compose-op-windows/)

## Stapsgewijze handleiding voor het gebruik van Docker Compose

Hieronder laten we zien hoe je Docker Compose kunt gebruiken met een eenvoudige **Python-webapplicatie** die gebruikmaakt van een hitcounter. Hiervoor gebruiken we het Python Flask-framework en de Redis-database in het geheugen. Je hoeft Python of Redis niet te installeren, omdat deze worden geleverd als Docker-images.

### Stap 1: Projectbestanden aanmaken

Start de terminal en maak een nieuwe map voor het project aan.

```shell
$ mkdir composedemo
```

Ga naar de map.

```shell
$ cd composedemo
```

Maak het bestand *app.py* in deze map aan en voeg de volgende code toe:

```python
import time
import redis
from flask import Flask
app = Flask(__name__)
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 World! I was here {} times.\n'.format(count)
```

In onze configuratie gebruiken we `redis` als hostnaam en de standaardpoort `6379` voor verbinding met de Redis-service. Daarnaast specificeren we dat de functie `get_hit_count()` meerdere verbindingspogingen met de service moet doen. Dit wordt aanbevolen wanneer Redis mogelijk niet onmiddellijk beschikbaar is wanneer de applicatie start of wanneer er tijdens de uitvoering van de applicatie af en toe verbindingsproblemen kunnen optreden.

Maak het bestand *requirements.txt* aan met de afhankelijkheden:

```plaintext
flask
redis
```

### Stap 2: Dockerfile instellen

Het **Dockerfile** wordt gebruikt voor de Docker-image. Hierin worden alle afhankelijkheden gespecificeerd die de Python-applicatie nodig heeft.

```shell
# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
```

We geven Docker de opdracht om de Python 3.7-image te gebruiken. Verder stellen we de benodigde omgevingsvariabelen in voor het **flask-commando**. Met behulp van `apk add` installeren we essentiële afhankelijkheden, waaronder gcc. Om de container poort 5000 te laten monitoren, specificeren we `EXPOSE`. Met behulp `COPY` zetten we de inhoud van de huidige map over naar de werkdirectory */code* binnen de container. Ten slotte kiezen we `flask run` als standaardcommando voor de container.

Controleer of het Dockerfile zonder bestandsextensie is opgeslagen, aangezien sommige editors automatisch de extensie *.txt* toevoegen.

### Stap 3: Maak een YAML-bestand aan

In ***docker-compose.yml*** configureren we de services ‘redis’ en ‘web’.

```yaml
version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
    redis:
        image: "redis:alpine"
```

De webservice is gebouwd met behulp van de Docker-image die is gemaakt door het Dockerfile. Deze koppelt de container en de hostcomputer aan poort 8000, terwijl de **Flask-webserver** op poort 5000 draait. De Redis-image wordt daarentegen rechtstreeks verkregen van de officiële Docker Hub.

### Stap 4: Voer de applicatie uit met Compose

Start de applicatie vanuit uw projectmap.

```shell
docker compose up
```

Ga naar *http://localhost:8000* in uw browser. U kunt ook *http://127.0.0.1:8000* invoeren.

U zou het volgende bericht moeten zien:

[![Afbeelding: Docker Compose Application: Output the number of visits in the browser](https://www.ionos.com/nl-be/digitalguide/fileadmin/_processed_/d/1/csm_docker-compose-hit-counter_f6e8af7148.webp "Docker Compose Application: Output the number of visits in the browser")](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter.png) You’ll see the number of times you have visited the browser. Ververs de pagina. Het aantal weergaven zou nu met 1 moeten zijn toegenomen.

[![Afbeelding: Calling the Docker Compose application again](https://www.ionos.com/nl-be/digitalguide/fileadmin/_processed_/7/8/csm_docker-compose-hit-counter-updated_58c6be39f6.webp "Calling the Docker Compose application again")](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-updated.png) The number of visits increased by 1. Stop de toepassing met behulp van:

```shell
$ docker compose down
```

Om de applicatie te stoppen, kunt u gewoon `Ctrl` + `C` indrukken in de terminal.

### Stap 5: Voeg een bindmount toe

Als u een **bind mount** voor de webservice wilt toevoegen, kunt u dit doen in *docker-compose.yml*.

```yaml
version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
        volumes:
            - .:/code
        environment:
            FLASK_DEBUG: "true"
    redis:
        image: "redis:alpine"
```

Onder het gedeelte **Volumes** specificeren we de koppeling van de huidige projectmap aan de map */code* in de container. Hierdoor kunnen codewijzigingen naadloos worden doorgevoerd zonder dat de image opnieuw hoeft te worden aangemaakt. De variabele `FLASK_DEBUG` geeft `flask run` de opdracht om in de ontwikkelingsmodus te draaien.

### Stap 6: Bouw de applicatie opnieuw op en voer deze uit

Voer de volgende opdracht in de terminal in om het Compose-bestand opnieuw op te bouwen:

```shell
docker compose up
```

### Stap 7: Werk de applicatie bij

Nu u een bind mount voor uw applicatie gebruikt, kunt u uw code aanpassen en automatisch wijzigingen zien zonder de image opnieuw te bouwen.

Schrijf een nieuwe welkomsttest in ***app.py***.

```python
return 'Hello from Docker! I was here {} times.\n'.format(count)
```

Vernieuw de browser om te controleren of de wijzigingen zijn doorgevoerd.

[![Afbeelding: Docker Compose application: modified welcome text](https://www.ionos.com/nl-be/digitalguide/fileadmin/_processed_/9/3/csm_docker-compose-hit-counter-text-modified_a210964afe.webp "Docker Compose application: modified welcome text")](https://www.ionos.com/nl-be/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-text-modified.png) The welcome text in the Python application has been modified ### Stap 8: andere commando’s

De `--help` optielijsten bevatten beschikbare Docker Compose-opdrachten:

```shell
docker compose --help
```

Om Docker Compose op de achtergrond uit te voeren, kunt u het argument `-d` toevoegen:

```shell
docker compose up -d
```

Gebruik `down` om alle containers te verwijderen. De optie `--volumes` verwijdert de volumes die door de Redis-container worden gebruikt.

```shell
docker compose down --volumes
```

Tip Om aan de slag te gaan met Docker, bekijk onze [Docker-handleiding](https://www.ionos.com/nl-be/digitalguide/server/configuratie/docker-handleiding-installatie-en-eerste-stappen/) en ons overzicht van Docker-opdrachten.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/server/configuratie/docker-compose-handleiding/](https://www.ionos.com/nl-be/digitalguide/server/configuratie/docker-compose-handleiding/) for AI/LLM consumption.