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:

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.

$ mkdir composedemo
shell

Ga naar de map.

$ cd composedemo
shell

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

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)
python

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:

flask
redis
plaintext

Stap 2: Dockerfile instellen

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

# 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"]
shell

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’.

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

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.

docker compose up
shell

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
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
The number of visits increased by 1.

Stop de toepassing met behulp van:

$ docker compose down
shell

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.

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

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:

docker compose up
shell

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.

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

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

Afbeelding: Docker Compose application: modified welcome text
The welcome text in the Python application has been modified

Stap 8: andere commando’s

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

docker compose --help
shell

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

docker compose up -d
shell

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

docker compose down --volumes
shell
Ga naar hoofdmenu