# Slik bruker du Docker Compose til applikasjoner med flere containere

Compose forenkler skalering og distribusjon av applikasjoner i Docker ved å automatisere **containeradministrasjonen**. I denne veiledningen går vi grundig gjennom hvordan du konfigurerer og bruker Docker Compose for å effektivisere distribusjonsprosessen for applikasjonene dine.

## Hva er Docker Compose?

Docker Compose brukes til å administrere applikasjoner og øke effektiviteten i containerutvikling. Konfigurasjonene defineres i én enkelt YAML-fil, noe som gjør det enkelt å bygge og skalere applikasjoner. Docker Compose brukes ofte til å sette opp et lokalt miljø. Det kan imidlertid også inngå i en **arbeidsflyt for kontinuerlig integrasjon og kontinuerlig levering (CI/CD)**. Utviklere kan definere en spesifikk containerversjon for testing eller bestemte faser i rørledningen. Dette gjør det enklere å identifisere problemer og fikse feil før applikasjonen settes i produksjon.

## Krav til Docker Compose

For **containerorkestrering** trenger du både Docker Engine og Docker Compose. Sørg for at du har installert ett av følgende på systemet ditt:

- **Docker Engine og Docker Compose**: Kan installeres som frittstående binærfiler.
- **Docker Desktop**: Utviklingsmiljø med grafisk brukergrensesnitt som inkluderer Docker Engine og Docker Compose.

Tip Finn ut hvordan du installerer Docker Compose på ulike operativsystemer i våre veiledninger:

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

## Trinnvis veiledning i bruk av Docker Compose

Nedenfor viser vi hvordan du bruker Docker Compose med en enkel **Python-webapplikasjon** som benytter en besøksteller. Til dette bruker vi Python-rammeverket Flask og minnedatabasen Redis. Du trenger ikke å installere Python eller Redis, da disse leveres som Docker-bilder.

### Trinn 1: Opprett prosjektfiler

Start terminalen og opprett en ny mappe for prosjektet.

```shell
$ mkdir composedemo
```

Gå til katalogen.

```shell
$ cd composedemo
```

Opprett filen *app.py* i denne mappen, og legg til 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 vårt oppsett bruker vi `redis` som vertsnavn og standardporten `6379` for å koble til Redis-tjenesten. I tillegg angir vi at funksjonen `get_hit_count()` skal foreta flere tilkoblingsforsøk til tjenesten. Dette anbefales dersom Redis ikke er umiddelbart tilgjengelig når applikasjonen starter, eller dersom det kan oppstå sporadiske tilkoblingsproblemer under kjøring.

Opprett filen *requirements.txt* med avhengighetene:

```plaintext
flask
redis
```

### Trinn 2: Opprett Dockerfile

**Dockerfilen** brukes til Docker-bildet. Den angir alle avhengighetene som Python-applikasjonen trenger.

```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 ber Docker om å bruke Python 3.7-bildet. Videre angir vi de nødvendige miljøvariablene for **flask-kommandoen**. Ved å bruke `apk add` installerer vi viktige avhengigheter, blant annet gcc. For at containeren skal kunne overvåke port 5000, angir vi `EXPOSE`. Ved hjelp av `COPY` overfører vi innholdet i den gjeldende mappen til arbeidskatalogen */code* inne i containeren. Til slutt velger vi `flask run` som standardkommando for containeren.

Kontroller at Dockerfile-filen er lagret uten filtype, da enkelte tekstredigeringsprogrammer automatisk legger til filtypen *.txt*.

### Trinn 3: Opprett en YAML-fil

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

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

Nettjenesten er bygget ved hjelp av Docker-bildet som er opprettet av Dockerfile. Den knytter containeren og vertsdatamaskinen til port 8000, mens **Flask-nettserveren** kjører på port 5000. Redis-bildet hentes derimot direkte fra den offisielle Docker Hub.

### Trinn 4: Kjør applikasjonen med Compose

Start programmet fra prosjektmappen din.

```shell
docker compose up
```

Gå til *http://localhost:8000* i nettleseren din. Du kan også skrive inn *http://127.0.0.1:8000*.

Du bør se følgende melding:

[![Image: Docker Compose Application: Output the number of visits in the browser](https://www.ionos.com/nb-no/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/nb-no/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter.png) You’ll see the number of times you have visited the browser. Oppdater siden. Antall visninger bør nå ha økt med 1.

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

```shell
$ docker compose down
```

For å avslutte programmet kan du ganske enkelt trykke på `Ctrl` + `C` i terminalen.

### Trinn 5: Opprett en bind-montering

Hvis du vil legge til en **bind-mount** for webtjenesten, kan du gjøre dette i *docker-compose.yml*.

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

Under delen **«Volumes»** angir vi at den gjeldende prosjektmappen skal kobles til katalogen */code* inne i containeren. Dette gjør det mulig å foreta endringer i koden uten å måtte opprette bildet på nytt. Variabelen `FLASK_DEBUG` angir at `flask run` skal kjøres i utviklingsmodus.

### Trinn 6: Kompiler og kjør applikasjonen

Skriv inn følgende kommando i terminalen for å kompilere Compose-filen på nytt:

```shell
docker compose up
```

### Trinn 7: Oppdater applikasjonen

Nå som du bruker en bind-mount for applikasjonen din, kan du endre koden og automatisk se endringene uten å måtte bygge bildet på nytt.

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

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

Oppdater nettleseren for å sjekke om endringene er tatt i bruk.

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

De `--help` alternativene viser tilgjengelige Docker Compose-kommandoer:

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

For å kjøre Docker Compose i bakgrunnen kan du legge til argumentet `-d`:

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

Bruk `down` for å fjerne alle containere. Alternativet `--volumes` sletter volumene som brukes av Redis-containeren.

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

Tip For å komme i gang med Docker, kan du ta en titt på vår [Docker-veiledning](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/docker-veiledning-installasjon-og-foerste-skritt/) og oversikten vår over Docker-kommandoer.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/veiledning-i-docker-compose/](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/veiledning-i-docker-compose/) for AI/LLM consumption.