Hur man installerar och använder Docker Compose på Ubuntu

Introduktion

Docker förenklar processen att hantera applikationsprocesser i containrar. Även om containrar på vissa sätt liknar virtuella maskiner, är de mer lätta och resurssnåla. Detta gör det möjligt för utvecklare att dela upp en applikationsmiljö i flera isolerade tjänster.

För applikationer som är beroende av flera tjänster kan det snabbt bli oöverskådligt att koordinera alla containrar för att starta, kommunicera och stänga ner tillsammans. Docker Compose är ett verktyg som låter dig köra applikationsmiljöer med flera containrar baserat på definitioner som anges i en YAML-fil. Det använder tjänstedefinitioner för att bygga fullt anpassningsbara miljöer med flera containrar som kan dela nätverk och datavolymer.

Denna guide visar dig hur du installerar Docker Compose på en Ubuntu-server och kör en enkel container. Därefter kommer du att lära dig att bygga en miljö med flera tjänster med en WordPress-applikation och en MySQL-databas. Vi kommer även att gå igenom mer avancerade ämnen, inklusive att skala tjänster, definiera egna nätverk och använda modulära include-direktiv. Slutligen innehåller denna artikel en migrationsguide från den äldre docker-compose (v1) till den moderna docker compose (v2) samt ett detaljerat avsnitt om felsökning av vanliga problem som portkonflikter och behörighetsfel.

Förutsättningar

För att följa denna artikel behöver du:

• Tillgång till en lokal Ubuntu-maskin eller utvecklingsserver som en icke-root-användare med sudo-behörigheter. Om du använder en fjärrserver är det rekommenderat att ha en aktiv brandvägg installerad. För att konfigurera detta, vänligen se vår guide för Initial Server Setup för Ubuntu.
• Docker installerat på din server eller lokala maskin, enligt Steg 1 och 2 i Hur man installerar Docker på Ubuntu – Steg-för-steg-guide.

Steg 1 — Installera Docker Compose

Det finns två sätt att installera Docker Compose på Ubuntu:

• Installera med hjälp av arkivet
• Installera manuellt

Vi kommer att diskutera båda sätten i det här avsnittet.

Installera Docker Compose med hjälp av apt-arkivet

Först, låt oss ställa in Docker apt-förrådet.

# 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 kan du installera Docker Compose med följande kommando:

sudo apt install docker-compose-plugin

Docker Compose är nu installerat på ditt system. För att bekräfta att installationen lyckades kan du köra:

docker compose version

Du kommer att se ett resultat som liknar detta:

Docker Compose version v2.3.3

Installera Docker Compose manuellt

För att säkerställa att du får den mest uppdaterade stabila versionen av Docker Compose, kommer du att ladda ner denna programvara från dess officiella Github-repo.

Först, bekräfta den senaste versionen som finns på deras sida för släpp. Vid tiden för denna skrivning är den mest aktuella stabila versionen v2.40.2.

Använd följande kommando för att ladda ner:

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

Nästa steg är att ställa in rätt behörigheter så att kommandot docker compose kan köras:

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

I nästa avsnitt kommer du att se hur man ställer in en docker-compose.yml-fil och får en containeriserad miljö igång med detta verktyg.

Steg 2 — Ställa in en docker-compose.yml-fil

För att visa hur man ställer in en docker-compose.yml-fil och arbetar med Docker Compose, kommer du att skapa en webbservermiljö med den officiella Nginx-bilden från Docker Hub, den offentliga Docker-registret. Denna containeriserade miljö kommer att leverera en enda statisk HTML-fil.

Börja med att skapa en ny katalog i din hemmapp och gå sedan in i den:

mkdir ~/compose-demo

cd ~/compose-demo

I den här katalogen, skapa en applikationsmapp som ska fungera som dokumentrot för din Nginx-miljö:

mkdir app

Använd din föredragna textredigerare för att skapa en ny index.html-fil i app-mappen:

nano app/index.html

Placera följande innehåll i den här filen:

<!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>

Spara och stäng filen när du är klar. Om du använder nano kan du göra det genom att trycka CTRL+X, sedan Y och ENTER för att bekräfta.

Skapa sedan filen docker-compose.yml:

nano docker-compose.yml

Infoga följande innehåll i din docker-compose.yml-fil:

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

I modern Docker Compose är fältet version valfritt och ofta utelämnat, eftersom Compose automatiskt kan känna igen konfigurationsversionen. Exemplet ovan inkluderar inte ett version-fält, vilket är den rekommenderade metoden för de flesta nya projekt. Du behöver bara ange version för bakåtkompatibilitet.

Du har då services-blocket, där du ställer in de tjänster som ingår i den här miljön. I ditt fall har du en enda tjänst som heter web. Denna tjänst använder bilden nginx:alpine och ställer in en portomdirigering med ports-direktivet. Alla förfrågningar på port 8000 på värdmaskinen (systemet från vilket du kör Docker Compose) kommer att omdirigeras till web-containern på port 80, där Nginx kommer att köras.

Direktivet volumes kommer att skapa en delad volym mellan värdmaskinen och containern. Detta kommer att dela den lokala mappen app med containern, och volymen kommer att vara placerad på /usr/share/nginx/html inuti containern, vilket sedan kommer att skriva över standarddokumentroten för Nginx.

Spara och stäng filen.

Du har skapat en demonstrationssida och en docker-compose.yml-fil för att skapa en containeriserad webbservermiljö som kommer att leverera den. I nästa steg kommer du att starta upp denna miljö med Docker Compose.

Steg 3 — Köra Docker Compose

Med docker-compose.yml-filen på plats kan du nu köra Docker Compose för att starta din miljö. Följande kommando kommer att ladda ner de nödvändiga Docker-bilderna, skapa en container för web-tjänsten och köra den containeriserade miljön i bakgrundsläge:

docker compose up -d

Docker Compose kommer först att leta efter det definierade bildnamnet på ditt lokala system, och om den inte kan hitta bilden kommer den att ladda ner bilden från Docker Hub. Du kommer att se en utskrift som denna:

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}

Efter att ha kört detta kommando behöver du logga ut och sedan logga in igen för att gruppändringarna ska träda i kraft. Du kan också aktivera ändringarna för den nuvarande terminalsessionen genom att skriva:

newgrp docker

Detta kommando bör åtgärda eventuella behörighetsfel relaterade till Docker-socketen. För en fullständig genomgång, vänligen se Steg 2 i Så här installerar du Docker på Ubuntu – Steg-för-steg-guide.

Din miljö är nu igång i bakgrunden. För att kontrollera att containern är aktiv kan du köra:

docker compose ps

Detta kommando visar information om de körande containrarna och deras status, samt eventuella portomdirigeringar som för närvarande är aktiva:

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

Du kan nu komma åt demoapplikationen genom att peka din webbläsare till antingen localhost:8000 om du kör denna demo på din lokala dator, eller din_server_domän_eller_IP:8000 om du kör denna demo på en fjärrserver.

Du kommer att se en sida som den här:

Den delade volymen som du har ställt in i docker-compose.yml-filen håller dina app-mappfiler synkroniserade med containerens dokumentrot. Om du gör några ändringar i index.html-filen kommer de automatiskt att plockas upp av containern och därmed visas i din webbläsare när du laddar om sidan.

I nästa steg kommer du att se hur du hanterar din containeriserade miljö med Docker Compose-kommandon.

Steg 4 — Bli bekant med Docker Compose-kommandon

Du har sett hur man ställer in en docker-compose.yml-fil och startar din miljö med docker compose up. Nu kommer du att se hur man använder Docker Compose-kommandon för att hantera och interagera med din containeriserade miljö.

För att kontrollera loggarna som produceras av din Nginx-container kan du använda kommandot logs:

docker compose logs

Du kommer att se en output som liknar detta:

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

Om du vill pausa miljöns körning utan att ändra det nuvarande tillståndet för dina containrar kan du använda:

docker compose pause

Pausing compose-demo_web_1 ... done

För att återuppta körningen efter att ha startat en paus:

docker compose unpause

Unpausing compose-demo_web_1 ... done

Kommandot stop kommer att avsluta körningen av containern, men det kommer inte att radera någon data som är kopplad till dina containrar:

docker compose stop

Stopping compose-demo_web_1 ... done

Om du vill ta bort containrarna, nätverken och volymerna som är kopplade till denna containeriserade miljö, använd kommandot down:

docker compose down

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

Observera att detta inte tar bort basbilden som Docker Compose använder för att starta din miljö (i ditt fall, nginx:alpine). På så sätt, när du startar upp din miljö igen med docker compose up, kommer processen att gå mycket snabbare eftersom bilden redan finns på ditt system.

Om du också vill ta bort basbilden från ditt system kan du använda:

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

Steg 5 — Bygga en applikation med flera tjänster

Den verkliga styrkan med Docker Compose ligger i att hantera flera tjänster som arbetar tillsammans. Nginx-exemplet var en enskild tjänst. Låt oss skapa en mer praktisk, flertjänstapplikation: en WordPress-webbplats ansluten till en MySQL-databas.

Denna uppsättning involverar två tjänster: wordpress (som kör applikationen) och db (som kör databasen). Vi kommer också att använda Docker-volymer för att säkerställa att databasens data behålls även om containern tas bort.

Låt oss skapa en ny katalog för denna applikation:

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

För det här exemplet behöver vi inga lokala filer, eftersom bilderna kommer att innehålla all nödvändig programvara.

Skapa en ny docker-compose.yml-fil:

nano docker-compose.yml

Klistra in följande konfiguration. Den här filen är mer komplex, så vi kommer att granska varje del.

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:

Spara och stäng filen. Kom ihåg att ersätta <^...^>-platshållarna med starka, säkra lösenord.

Låt oss gå igenom de nya direktiven i den här filen:

• services: Detta block definierar fortfarande våra containrar. Vi har nu två: db och wordpress.
• image: Vi använder mysql:8.0 för databasen och wordpress:latest-bilden för applikationen.
• container_name: Detta anger ett specifikt, lättförståeligt namn för containern, vilket är lättare att referera till än de automatiskt genererade namnen.
• environment: Detta är en lista över miljövariabler som skickas in i containern. mysql-bilden använder dessa för att ställa in root-lösenordet och skapa en initial databas och användare. wordpress-bilden använder dem för att veta hur den ska ansluta till sin databas.

• volymer (tjänstenivå):

  • För db-tjänsten mappar db_data:/var/lib/mysql en Docker-hanterad volym med namnet db_data till MySQL:s datakatalog inne i containern. Detta håller dina data säkra.
  • För tjänsten wordpress mappar ./wp_content:/var/www/html/wp-content en lokal katalog (wp_content) till WordPress innehållskatalog. Detta gör att du direkt kan redigera teman och plugins från din värddator.
• depends_on: Detta talar om för Compose att starta db-tjänsten innan den startar wordpress-tjänsten. Detta är viktigt, eftersom WordPress kommer att misslyckas om det inte hittar sin databas vid uppstart.
• volumes (översta nivån): Det här blocket definierar de namngivna volymerna. db_data: skapar en Docker-hanterad volym, vilket är det föredragna sättet att hantera beständiga data.

Nu, starta denna mångtjänstapplikation:

docker compose up -d

Compose kommer att hämta både mysql och wordpress-bilderna och sedan skapa containrarna, och startar db-tjänsten först.

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

Du kan nu komma åt din nya WordPress-sida genom att gå till localhost:8001 eller <^ditt_serverdomän_eller_IP<^>:8001 i din webbläsare. Du bör se WordPress installationsskärmen. För ett mer detaljerat exempel, kolla in vår artikel om Hur man installerar WordPress med Docker Compose

Steg 6 — Använda Docker Compose för AI/ML-utveckling

Utöver webbapplikationer är Docker Compose ett mycket användbart verktyg för att skapa reproducerbara miljöer för datavetenskap och maskininlärning (AI/ML). AI/ML-projekt är kända för sina komplexa beroenden, inklusive specifika Python-versioner, bibliotek som TensorFlow eller PyTorch, och systemnivådrivrutiner som NVIDIA CUDA Toolkit. Docker Compose fångar hela denna miljö i konfigurationsfiler, vilket löser problemet med "det fungerar på min dator", vilket är avgörande för reproducerbar forskning.

I det här exemplet kommer du att skapa en fler-tjänst AI/ML-miljö som består av:

• JupyterLab: En miljö för interaktiv utveckling, byggd från en anpassad Dockerfile.
• PostgreSQL: En databaskontainer för att lagra experimentresultat och metadata.
• GPU-åtkomst: JupyterLab-containern kommer att konfigureras för att få åtkomst till värddatorns NVIDIA-GPU, ett vanligt krav för modellträning.

Filstruktur

Först, skapa en katalog för ditt projekt. Inuti den kommer du att skapa en docker-compose.yml-fil, en jupyter-katalog, en Dockerfile för Jupyter och en requirements.txt-fil. Strukturen bör se ut ungefär så här:

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

Skapa komponentfilerna

1. Filen requirements.txt

Den här filen listar Python-paketen för din data science-miljö.

nano jupyter/requirements.txt

Lägg till de paket du behöver. I det här exemplet kommer vi att inkludera bibliotek för datamanipulation, databasanslutning och ett ramverk för djupinlärning.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Spara och stäng filen.

2. Dockerfile

Denna fil definierar din anpassade JupyterLab-tjänst. Den använder en officiell Jupyter-bild som bas och installerar paketen från requirements.txt.

nano jupyter/Dockerfile

Klistra in följande innehåll:

# 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

Den här filen instruerar Docker att använda jupyter/scipy-notebook som utgångspunkt, kopiera din requirements.txt till containern och sedan använda pip för att installera paketen.

Definiera miljön med docker-compose.yml

Skapa nu huvudfilen docker-compose.yml. Denna fil kommer att orkestrera både db-tjänsten och din anpassade jupyter-tjänst.

nano docker-compose.yml

Klistra in följande konfiguration och ersätt platshållarna <^...^> med dina egna säkra referenser.

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

Denna konfigurationsfil introducerar flera viktiga begrepp:

• build: ./jupyter: Detta talar om för Docker Compose att bygga en anpassad bild för jupyter-tjänsten. Den letar efter en Dockerfile inne i den angivna ./jupyter-katalogen.
• volumes: - ./notebooks:/home/jovyan/work: Detta bind-montera en lokal katalog som heter notebooks in i containern. Detta säkerställer att alla Jupyter-notebooks du skapar sparas direkt på din värddator, vilket gör att de behålls även efter att containern tas bort.
• healthcheck: Som ses i felsökningsavsnittet, validerar denna kontroll att db-tjänsten inte bara är aktiv, utan redo att ta emot anslutningar innan andra tjänster startar.
• depends_on: ... condition: service_healthy: Detta talar om för jupyter-tjänsten att vänta tills db-hälsokontrollen lyckas innan den startar.

• deploy.resources.reservations.devices: Detta är blocket som begär åtkomst till GPU.

  • driver: nvidia: Anger vilken värddrivrutin som ska användas.
  • count: 1: Begär ett GPU.
  • capabilities: [gpu]: Säkerställer att containern har de nödvändiga kapaciteterna för att använda GPU:n.

Att driva AI/ML-miljön

Med dina filer på plats är du redo att bygga och köra tjänsterna.

1. Från din ai-project-katalog, kör kommandot docker compose up. Du måste lägga till flaggan --build första gången för att tala om för Compose att bygga din anpassade jupyter-bild.

   docker compose up -d --build

2. Compose kommer först att bygga jupyter-bilden (vilket kan ta några minuter eftersom den laddar ner TensorFlow), sedan hämta postgres-bilden och slutligen starta båda containrarna.

   [+] 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. Du kan nu komma åt JupyterLab-gränssnittet genom att gå till http://localhost:8888 (eller <^din_server_ip^>:8888) i din webbläsare. Du kommer att bli ombedd att ange en token, som du kan få från containerloggarna:

   docker compose logs jupyter

   Sök efter en rad som liknar http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

4. Inuti en Jupyter-notebook kan du nu ansluta till din databas med värdnamnet db och de uppgifter du angav. Din miljö har också åtkomst till värdens GPU för modellträning.

Skalning av tjänster och användning av anpassade nätverk

Docker Compose innehåller funktioner för att skala tjänster och hantera de nätverk de kommunicerar på.

Tjänstskalning med repliker

Föreställ dig att din Nginx-webbserver från Steg 2 får för mycket trafik. Du kan skala web-tjänsten för att köra flera containerinstanser. Docker Compose kan hantera detta automatiskt.

Det finns två huvudsakliga sätt att skala en tjänst.

1. Använda replicas-nyckeln (Föredras i v2)

Du kan ange önskat antal instanser direkt i din docker-compose.yml-fil genom att använda deploy och replicas-nycklarna. Denna funktion var ursprungligen en del av Docker Swarm men finns nu tillgänglig för standardkompositioner.

Ändra din Nginx docker-compose.yml från Steg 2:

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

När du kör docker compose up -d kommer Compose att skapa tre web-containrar. Men du kommer att ha ett problem: alla tre kommer att försöka binda till värdport 8000. Detta kommer att orsaka ett felmeddelande "port är redan tilldelad" för den andra och tredje containern. För att lösa detta i en produktionsmiljö skulle du ta bort ports-mappningen från web-tjänsten. På så sätt är webcontainrarna endast åtkomliga inom Docker-nätverket. En separat lastbalanserare skulle vara den enda med en publik port. Den skulle sedan fördela trafiken till de tre webreplikerna.

Ett exempel på konfiguration skulle se ut så här (detta är ett avancerat exempel):

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:

I den här konfigurationen lyssnar load_balancer på port 80 och vidarebefordrar förfrågningar till web_1, web_2 och web_3 internt.

Den här replicas-nyckeln är mest användbar när den används med en reverse proxy (som Traefik eller en annan Nginx-instans) som kan lastbalansera förfrågningar mellan replikerna inom Docker-nätverket, utan att varje replik behöver exponera en port på värden.

2. Använda --scale-flaggan

En vanlig metod för skalning är flaggan --scale, en kvarleva från Compose v1. Denna flagga används vid körning och åsidosätter alla replicas-nycklar.

Du måste dock vara försiktig med portdefinitioner. Om din tjänst definierar en fast hostport-mappning (t.ex. "8000:80"), kommer körning av docker compose up --scale att orsaka ett fel för den andra och tredje containern eftersom alla försöker binda till samma hostport.

För att använda --scale för tjänster som exponerar portar, får du inte använda en fast värdportmappning.

• Alternativ 1: Kartlägg till slumpmässiga värdportar (Bra för utveckling)

  Du kan ändra din docker-compose.yml för att endast ange containerporten. Detta talar om för Docker att mappa port 80 i varje container till en slumpmässig, tillgänglig port på din värddator.

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

  Nu, när du kör kommandot scale:

  docker compose up -d --scale web=3

  Kör docker compose ps för att se resultatet. Varje container kommer att köras på en annan, slumpmässigt tilldelad värdport:

        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 - Korrekt för --scale

• Alternativ 2: Använd en omvänd proxy (Bra för produktion)

  Den andra lösningen, som nämnts i replicas-avsnittet, är att ta bort ports-direktivet helt från web-tjänsten. Du skulle då använda en separat lastbalanserare-container (som har den enda publika porten) för att hantera och fördela trafik till de skalade kopiorna inom Docker-nätverket.

  För att stoppa och ta bort alla tre containrarna är kommandot fortfarande detsamma:

  docker compose down

Anpassad nätverkskonfiguration

Som standard skapar Docker Compose ett enda bridge-nätverk för din applikation. Varje tjänst i filen är ansluten till det, vilket är hur wordpress-containern kunde hitta db-containern enbart genom att använda dess tjänstnamn (db).

Du kan dock definiera egna anpassade nätverk för bättre isolering och kontroll.

Låt oss ändra WordPress-exemplet för att använda ett anpassat bridge-nätverk.

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

Här är vad vi lade till:

• nätverk (översta nivå): Detta definierar ett nytt nätverk med namnet app_net och anger att det ska använda standarddrivrutinen bridge.
• nätverk (tjänstenivå): Under både db och wordpress kopplar denna nyckel dem till vårt app_net-nätverk.

Om du hade en tredje tjänst (som ett analysverktyg) som du inte kopplade till app_net, skulle den vara helt isolerad och inte kunna kommunicera med db eller wordpress-containrarna.

För multi-host-klustring med Docker Swarm skulle du ändra driver från bridge till overlay. Bridge-drivrutinen är för kommunikation mellan containrar på en enda värd, vilket är standard för de flesta Docker Compose-användningsfall.

Använda modulära konfigurationsfiler

När dina applikationer växer kan din docker-compose.yml-fil bli stor och svår att hantera. Docker Compose stöder en include-direktiv, som låter dig dela upp din konfiguration över flera filer.

Tänk dig att du vill separera dina WordPress- och databaskonfigurationer, och kanske ha en gemensam docker-compose.override.yml för utvecklingsspecifika inställningar (som att binda en port på databasen).

Din mappstruktur kan se ut så här:

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

Denna fil kommer endast att definiera db-tjänsten.

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:

Denna fil kommer endast att definiera wordpress-tjänsten.

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 blir din huvudfil docker-compose.yml mycket enkel. Den använder bara include för att hämta de andra filerna.

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

När du kör docker compose up -d kommer Compose att läsa alla tre filer, slå samman konfigurationerna och starta db och wordpress-tjänsterna precis som om de var definierade i en enda fil. Detta tillvägagångssätt gör din konfiguration mycket mer modulär och återanvändbar.

Migrera från docker-compose (v1) till docker compose (v2)

Kommandot docker compose som du installerade i Steg 1 är „Compose v2.“ Det är ett Go-baserat tillägg som är inbyggt direkt i Docker CLI.

Den ursprungliga versionen, „Compose v1“, var ett separat Python-verktyg som anropades med docker-compose (med bindestreck). Från och med juli 2023 stöds inte längre Compose v1 och har blivit föråldrad.

Nyckelförändringar och bakåtkompatibilitet

• Kommandot: Den mest uppenbara förändringen är kommandot. Bindestrecket (docker-compose) är nu ett mellanslag (docker compose).
• Installation: v1 installerades med pip. v2 ingår i Docker Desktop eller installeras som ett CLI-plugin, precis som du gjorde i Steg 1.
• YAML-filer: Dina docker-compose.yml-filer är nästan 100% bakåtkompatibla. Compose v2 stödjer fullt ut filversioner 3.x. Du behöver inte ändra dina YAML-filer för migreringen, bara dina kommandon.
• --project-name flagga: -p flaggan fungerar fortfarande, men den fullständiga flaggan är nu --project-name istället för --project_name.

Kommandomigrationsguide

De flesta kommandon är identiska, bara att bindestrecket har tagits bort. Här är en tabell som jämför vanliga v1-kommandon med deras v2-ekvivalenter.

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

Som du kan se, för de flesta dagliga användningar är den enda förändringen docker-compose -> docker compose. Om du använder skript kan du uppdatera dem genom att helt enkelt ta bort bindestrecket.

Om du fortfarande har den gamla docker-compose v1 installerad kan du ta bort den för att undvika förvirring:

sudo pip3 uninstall docker-compose

Eller, om det installerades med apt:

sudo apt remove docker-compose

Felsökning av vanliga problem med Docker Compose

När du arbetar med Docker Compose kan du stöta på problem relaterade till filsintax, behörigheter eller konflikter i containerkörningen. De flesta problem kan diagnostiseras och lösas genom att systematiskt kontrollera din konfiguration, behörigheter och containerloggar.

Låt oss titta på några av de vanligaste felen och deras lösningar.

Behörighet nekad (Docker-socket)

Detta är ett av de vanligaste felen för nya Docker-användare. Du kör docker compose up och ser ett felmeddelande om Docker-daemonens socket.

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

• Problem: Din icke-root-användare har inte behörighet att kommunicera med Docker-daemonen, som körs som root.

• Lösning: Du måste lägga till din användare i docker-gruppen, som skapades under installationen av Docker.

  1. Lägg till din användare i docker-gruppen:

     sudo usermod -aG docker ${USER}

  2. För att det nya gruppmedlemskapet ska träda i kraft måste du logga ut och sedan logga in igen.

  3. Alternativt kan du aktivera gruppändringarna för din nuvarande terminalsession genom att skriva:

     newgrp docker

  Detta bör åtgärda eventuella behörighetsfel relaterade till Docker-socketen.

YAML-syntax och indenteringsfel

Docker Compose kan inte köras och rapporterar att din docker-compose.yml-fil är ogiltig.

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

Eller :

mapping values are not allowed in this context at line 5

• Problem: Filen docker-compose.yml är beroende av strikt YAML-syntax. Det vanligaste misstaget är felaktig indragning. YAML använder mellanslag, inte tabbar, för att definiera struktur.

• Lösning: Kontrollera noggrant indragningen i din docker-compose.yml-fil.

  • Standarden är två mellanslag för varje nivå av indrag.
  • Se till att alla nycklar på samma nivå (som version, services, volumes) börjar i samma kolumn.
  • Se till att alla undernycklar (som image, ports, volumes under en tjänst) är indragna två mellanslag mer än deras överordnade tjänst (t.ex. web).
  • Använd en kodredigerare med en YAML-lint för att automatiskt markera syntaxfel.

Portkonflikter

Du försöker starta din miljö, men kommandot misslyckas med ett felmeddelande om att adressen redan används.

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

• Problem: En annan process på din värddator lyssnar redan på porten du försöker mappa (i det här fallet port 8000). Detta är ofta en annan Docker-container eller en lokal utvecklingsserver.

• Lösning: Du har två alternativ:

  1. Stoppa den andra processen. Du kan hitta processen som använder porten med detta kommando:

     sudo lsof -i :8000

     Om det är en annan Docker-container, stoppa den med docker stop <container_id>.

  2. Ändra värdporten i din docker-compose.yml-fil. Detta är ofta den enklaste lösningen. Ändra ports-mappningen från "8000:80" till en annan port, till exempel "8001:80".

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

  docker-compose.yml

Tjänsten misslyckas med Connection Refused (depends_on)

I en applikation med flera tjänster (som WordPress och MySQL-exemplet) startar wordpress-containern men dess loggar visar Connection refused eller MySQL server has gone away när den försöker ansluta till db-tjänsten.

• Problem: Du har använt depends_on, men denna direktiv väntar endast på att db-containern ska starta. Den väntar inte på att MySQL-applikationen inuti containern ska vara fullt initialiserad och redo att ta emot anslutningar.

• Lösning: Applikationen (i det här fallet WordPress) måste konfigureras för att försöka ansluta igen. De flesta moderna bilder har denna återanslutningslogik inbyggd. För bilder som inte har det måste du implementera en hälsokontroll.

  Du kan lägga till en healthcheck för din db-tjänst. wordpress-tjänstens depends_on kan då konfigureras att vänta på att databasen är "hälsosam", inte bara "startad".

Exempel på hälsokontroll för 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
    ...

Fel med volymer och bind-mounts

Du kan stöta på behörighetsfel i dina containerloggar eller upptäcka att din containers datakatalog är tom.

Fil-/mappbehörigheter

• Problem: Containern körs som en specifik användare (t.ex. www-data med användar-ID 33), men den monterade katalogen på värden ägs av din användare (t.ex. ubuntu med användar-ID 1000). Containerns användare har inte behörighet att skriva till värdkatalogen.

• Lösning: Byt ägarskap på värdkatalogen så att det matchar användar-ID:t inne i containern. Du kan hitta containerns användar-ID genom att köra docker compose exec <service_name> id. Till exempel, om ID:t är 33 (vanligt för www-data):

  sudo chown -R 33:33 ./wp_content

Problem med relativa sökvägar

• Problem: Din docker-compose.yml använder en relativ sökväg som ./app, men din index.html-fil serveras inte.

• Lösning: Docker Compose tolkar relativa sökvägar utifrån den katalog där du kör kommandot docker compose up. Kör alltid Compose-kommandon från samma katalog som innehåller din docker-compose.yml-fil.

Nätverkande och tjänsteupptäckt

Dina applikationscontainerloggar visar Host not found eller Could not resolve host: db.

• Problem: Din wordpress-container kan inte hitta db-containern på nätverket.

• Lösning: Som standard skapar Docker Compose ett nätverk och ansluter alla tjänster till det. Tjänster kan hitta varandra med hjälp av sina tjänstnamn.

  1. Kontrollera tjänstenamn: Se till att värdnamnet i din applikationskonfiguration (t.ex. miljövariabeln WORDPRESS_DB_HOST) är exakt samma som tjänstenamnet i din docker-compose.yml (t.ex. db).

  2. Inspektera nätverket: Använd docker compose ps för att hitta ditt projekts namn (t.ex. compose-demo). Sedan inspekterar du standardnätverket:

     docker network inspect compose-demo_default

     JSON-utdata kommer att lista alla behållare som är anslutna till detta nätverk. Om en av dina tjänster saknas, kontrollera din docker-compose.yml för eventuella anpassade networks-konfigurationer som kan isolera den.

Kommandoöverensstämmelse saknas (v1 vs. v2)

Du skriver docker-compose up (med bindestreck) och ser ett felmeddelande om "kommando hittades inte".

docker-compose: command not found

• Problem: Du försöker använda kommandot för Compose v1, som är ett föråldrat Python-verktyg. Denna guide installerar Compose v2, som är ett plugin som är integrerat direkt i Docker CLI.
• Lösning: Använd korrekt kommando genom att ersätta bindestrecket (-) med ett mellanslag.

Använd alltid docker compose (med mellanslag) när du följer denna guide.

Vanliga frågor

1. Vad används Docker Compose till?

Docker Compose är ett verktyg för att definiera och köra Docker-applikationer med flera containrar.

Det använder en enda YAML-fil (standard är docker-compose.yml) för att konfigurera alla komponenter i din applikation, som kallas tjänster. Denna fil definierar också de nätverk som gör att tjänsterna kan kommunicera med varandra och de volymer som används för beständiga data.

Med denna enda fil kan du hantera hela din applikationsstack med enkla kommandon:

• docker compose up startar och kör hela din applikation, inklusive alla specificerade containrar, nätverk och volymer.
• docker compose down stoppar och tar bort alla containers, nätverk och volymer som skapats av din applikation.

Det är mest användbart för att hantera applikationer som kräver flera komponenter, såsom en webbplats som behöver en webbserver (som Nginx), en applikationsbackend (som WordPress) och en databas (som MySQL).

2. Hur installerar jag Docker Compose på Ubuntu?

Den rekommenderade metoden är att installera Docker Compose som ett plugin för Docker CLI. Detta görs genom att installera paketet docker-compose-plugin från Dockers officiella apt-förråd.

1. Först, se till att du har följt den officiella Docker-dokumentationen för att ställa in Dockers apt-förråd på ditt Ubuntu-system.

2. Uppdatera din paketlista:

   sudo apt update

3. Installera Docker Compose-tillägget:

   sudo apt install docker-compose-plugin

4. Verifiera installationen genom att kontrollera versionen. Kommandot använder ett blanksteg, inte ett bindestreck.

   docker compose version

3. Hur uppdaterar jag Docker Compose till den senaste versionen?

Eftersom Docker Compose (v2) är installerat som ett systempaket med apt, kan du uppdatera det med den vanliga programuppdateringsprocessen i Ubuntu.

1. Uppdatera ditt lokala paketindex:

   sudo apt update

2. Kör en systemomfattande uppgradering, som kommer att inkludera Compose-pluginet:

   sudo apt upgrade

   Alternativt, om du bara vill uppdatera själva pluginet, kan du köra:

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

4. Kan Docker Compose användas i produktionsmiljöer?

Ja, Docker Compose används ofta i produktion, särskilt för applikationer som körs på en enkel värd.

Det ger ett enkelt sätt att definiera, distribuera och hantera livscykeln för din applikations tjänster, nätverk och volymer. För en distribution på en enda server är det en mycket effektiv och lätthanterlig lösning.

För mer komplexa scenarier som kräver att man koordinerar containrar över flera värdar (ett kluster) är andra verktyg vanligare. Dessa inkluderar Docker Swarm (som använder en liknande Compose-filsyntax) och Kubernetes (som är branschstandarden för storskalig containerorkestrering).

5. Vad är skillnaden mellan Docker och Docker Compose?

Den här tabellen beskriver de huvudsakliga skillnaderna mellan Docker CLI och Docker Compose CLI.

Kort sagt använder du docker för att interagera med en enskild container. Du använder docker compose för att hantera hela din applikationsstack (t.ex. web, app, db) på en gång.

6. Hur kör jag flera containrar med Docker Compose?

Du kör flera containrar genom att definiera dem som tjänster i din docker-compose.yml-fil.

1. Skapa en fil med namnet docker-compose.yml.

2. Inuti den här filen, använd services:-nyckeln för att definiera varje container du vill köra.

   Här är ett praktiskt exempel som definierar och kör två containrar: en WordPress-webbplats och en MySQL-databas.

   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. Spara filen och öppna en terminal i samma mapp.

4. Kör ett enda kommando för att starta båda containrarna:

   docker compose up -d

Docker Compose kommer att läsa filen, skapa ett delat nätverk för tjänsterna, hämta både mysql och wordpress-bilderna och starta en container för varje tjänst.

7. Varför använda Docker Compose för utveckling?

Docker Compose är ett standardverktyg för utvecklingsmiljöer eftersom det löser flera vanliga problem.

• Konsekventa miljöer: Det säkerställer att varje utvecklare i ett team kör exakt samma tjänster (databas, cache, webbserver) med exakt samma versioner och konfigurationer. Detta definieras i docker-compose.yml-filen, som sparas i versionshanteringen. Detta eliminerar problemet med "det fungerar på min dator".

• Enkelhet: Det ersätter komplexa installationsskript och långa docker run-kommandon. En utvecklare behöver bara köra docker compose up för att starta hela applikationsstacken och docker compose down för att stoppa den.

• Tjänsteisolering: Utvecklare kan arbeta på flera projekt på samma dator utan beroendekonflikter. Projekt A kan använda PostgreSQL 9.6 och Projekt B kan använda PostgreSQL 14, eftersom varje databas körs i en isolerad container som hanteras av sin egen Compose-fil.

• Enkel integrationstestning: Eftersom Compose startar alla en applikations beroenden tillsammans, skapar det en perfekt lokal miljö för att köra integrationstester som verifierar hur tjänster interagerar med varandra.

Slutsats

I den här guiden installerade du Docker Compose och konfigurerade en komplett applikation med flera containrar. Du började med en grundläggande docker-compose.yml-fil för en Nginx-webbserver och gick vidare till en mer komplex, realistisk stack som involverar en WordPress-applikation och en MySQL-databas. Du har lärt dig att hantera hela applikationens livscykel, från att bygga och köra tjänster till att stoppa och ta bort dem.

Du är nu bekant med nyckelkoncept för att effektivt hantera applikationer, inklusive tjänsteskalning, anpassade nätverksdefinitioner och att dela upp din konfiguration i modulära filer med hjälp av include-direktivet. Genom att följa migrationsguiden och felsökningsstegen kan du även lösa vanliga problem som portkonflikter, "Permission denied"-fel och YAML-syntaxfel. De färdigheter som täcks här gör att du kan bygga konsekventa, reproducerbara utvecklingsmiljöer och distribuera applikationer på en enskild värd med självförtroende.

För en komplett referens över alla tillgängliga docker compose-kommandon, se den officiella dokumentationen.

För fler handledningar om Docker, kolla in följande artiklar:

• Hur man installerar Docker på Ubuntu – Steg-för-steg guide
• Hur man installerar WordPress med Docker Compose

Tack för att du lär dig tillsammans med Linux-Console.net-communityn.