# Sådan bruger du Docker Compose til applikationer med flere containere

Compose gør det nemmere at skalere og implementere applikationer i Docker ved at automatisere **containerhåndteringen**. I vores vejledning ser vi nærmere på, hvordan du konfigurerer og bruger Docker Compose til at strømline implementeringen af dine applikationer.

## Hvad er Docker Compose?

Docker Compose bruges til at administrere applikationer og øge effektiviteten i containerudviklingen. Konfigurationerne defineres i en enkelt YAML-fil, hvilket gør det nemt at opbygge og skalere applikationer. Docker Compose bruges ofte til at opsætte et lokalt miljø. Det kan dog også indgå i et **Continuous Integration / Continuous Delivery (CI/CD)-arbejdsforløb**. Udviklere kan definere en specifik containerversion til test eller specifikke pipelinefaser. Dette gør det lettere at identificere problemer og rette fejl, inden applikationen går i produktion.

## Krav til Docker Compose

Til **containerorkestrering** skal du bruge både Docker Engine og Docker Compose. Sørg for, at du har en af følgende programmer installeret på din computer:

- **Docker Engine og Docker Compose**: Kan installeres som selvstændige binære filer.
- **Docker Desktop**: Udviklingsmiljø med grafisk brugergrænseflade, der inkluderer Docker Engine og Docker Compose.

Tip Se vores vejledninger for at finde ud af, hvordan du installerer Docker Compose på forskellige operativsystemer:

- [Installer Docker Compose på Ubuntu](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/docker-compose-paa-ubuntu/)
- [Installer Docker Compose på macOS](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/docker-compose-paa-mac/)
- [Installer Docker Compose på Windows](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/installer-docker-compose-paa-windows/)

## Trin-for-trin-vejledning i, hvordan man bruger Docker Compose

I det følgende viser vi, hvordan man bruger Docker Compose med en enkel **Python-webapplikation**, der benytter en besøgstæller. Til dette bruger vi Python-rammeværket Flask og in-memory-databasen Redis. Du behøver ikke at installere Python eller Redis, da de leveres som Docker-billeder.

### Trin 1: Opret projektfiler

Åbn terminalen, og opret en ny mappe til projektet.

```shell
$ mkdir composedemo
```

Skift til mappen.

```shell
$ cd composedemo
```

Opret filen *app.py* i denne mappe, og indsæt følgende kode i den:

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

I vores opsætning bruger vi `redis` som værtsnavn og standardporten `6379` til at oprette forbindelse til Redis-tjenesten. Derudover angiver vi, at funktionen `get_hit_count()` skal foretage flere forbindelsesforsøg til tjenesten. Dette anbefales, hvis Redis ikke er tilgængelig med det samme, når applikationen starter, eller hvis der kan opstå periodiske forbindelsesproblemer under kørsel.

Opret filen *requirements.txt* med afhængighederne:

```plaintext
flask
redis
```

### Trin 2: Opret en Dockerfile

**Dockerfilen** bruges til Docker-billedet. Den angiver alle de afhængigheder, som Python-applikationen kræver.

```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"]
```

Vi instruerer Docker om at bruge Python 3.7-billedet. Desuden indstiller vi de nødvendige miljøvariabler til **flask-kommandoen**. Ved hjælp af `apk add` installerer vi vigtige afhængigheder, herunder gcc. For at containeren kan overvåge port 5000, angiver vi `EXPOSE`. Ved hjælp af `COPY` overfører vi indholdet af den aktuelle mappe til arbejdsmappen */code* i containeren. Til sidst vælger vi `flask run` som standardkommando for containeren.

Kontroller, at Dockerfilen er gemt uden filtypenavn, da nogle tekstredigeringsprogrammer automatisk tilføjer filtypenavnet *.txt*.

### Trin 3: Opret en YAML-fil

I filen ***docker-compose.yml*** konfigurerer vi tjenesterne »redis« og »web«.

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

Webtjenesten er opbygget ved hjælp af det Docker-billede, der er oprettet med Dockerfile. Den knytter containeren og værtscomputeren til port 8000, mens **Flask-webserveren** kører på port 5000. Redis-billedet hentes derimod direkte fra den officielle Docker Hub.

### Trin 4: Kør applikationen med Compose

Start programmet fra din projektmappe.

```shell
docker compose up
```

Åbn *http://localhost:8000* i din browser. Du kan også indtaste *http://127.0.0.1:8000*.

Du bør se følgende meddelelse:

[![Billede: Docker Compose Application: Output the number of visits in the browser](https://www.ionos.com/da-dk/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/da-dk/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter.png) You’ll see the number of times you have visited the browser. Opdater siden. Antallet af visninger bør nu være steget med 1.

[![Billede: Calling the Docker Compose application again](https://www.ionos.com/da-dk/digitalguide/fileadmin/_processed_/7/8/csm_docker-compose-hit-counter-updated_58c6be39f6.webp "Calling the Docker Compose application again")](https://www.ionos.com/da-dk/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-updated.png) The number of visits increased by 1. Afslut programmet ved at:

```shell
$ docker compose down
```

For at afslutte programmet skal du blot trykke på `Ctrl` + `C` i terminalen.

### Trin 5: Opret en bind-mount

Hvis du vil tilføje en **bind-mount** til webservicen, kan du gøre det i *filen docker-compose.yml*.

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

Under afsnittet **»Volumes«** angiver vi, at den aktuelle projektmappe skal tilknyttes mappen */code* inde i containeren. Dette gør det muligt at foretage ændringer i koden uden problemer, uden at det er nødvendigt at genoprette billedet. Variablen `FLASK_DEBUG` angiver, at `flask run` skal køre i udviklingsmodus.

### Trin 6: Genkompiler og kør applikationen

Indtast følgende kommando i terminalen for at genopbygge Compose-filen:

```shell
docker compose up
```

### Trin 7: Opdater applikationen

Nu hvor du bruger en bind-mount til din applikation, kan du ændre din kode og automatisk se ændringerne uden at skulle genkompilere billedet.

Skriv en ny velkomsttest i ***app.py***.

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

Opdater browseren for at kontrollere, om ændringerne er blevet gemt.

[![Billede: Docker Compose application: modified welcome text](https://www.ionos.com/da-dk/digitalguide/fileadmin/_processed_/9/3/csm_docker-compose-hit-counter-text-modified_a210964afe.webp "Docker Compose application: modified welcome text")](https://www.ionos.com/da-dk/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-text-modified.png) The welcome text in the Python application has been modified ### Trin 8: Andre kommandoer

De `--help` tilgængelige Docker Compose-kommandoer:

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

For at køre Docker Compose i baggrunden kan du tilføje argumentet `-d`:

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

Brug `down` til at fjerne alle containere. Med indstilling `--volumes` slettes de diskenheder, der bruges af Redis-containeren.

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

Tip Hvis du vil komme i gang med Docker, kan du læse vores [Docker-vejledning](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/docker-vejledning-installation-og-de-foerste-skridt/) og vores oversigt over Docker-kommandoer.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/server/konfiguration/vejledning-i-docker-compose/](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/vejledning-i-docker-compose/) for AI/LLM consumption.