Docker Compose-minnesanteckningar – De mest användbara kommandona med exempel

Här är ett Docker Compose-fuskort med kommenterade exempel för att hjälpa dig att behärska Compose-filer och kommandon snabbt.

Den här guiden är en del av Utvecklarverktyg: Den kompletta guiden till moderna utvecklingsarbetsflöden.

Förutsättningar

Docker Engine måste vara installerad innan du kan använda Compose. På Ubuntu, följ Installera Docker på Ubuntu för att välja rätt installationsmetod och sätta upp docker compose-pluginet.

Referens för Compose-fil: docker-compose.yml

Grundstruktur:

version: '3'       # Version av Compose-filformatet

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Värdport 8080:Containerport 80
  db:
    image: postgres
    environment:            # Miljövariabler
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Anpassat nätverk
  appnet:
    driver: bridge

volumes:           # Namngiven volym
  db_data:

• services: Varje container i din multi-container-app. I exemplet ovan har vi två tjänster: web och db. För enskilda containeroperationer, se Docker-fuskort.
• networks & volumes: Definiera isolerade nätverk och bestående lagring - vi har appnet-nätverket och db_data-volymen här.

Exempel

Enstaka tjänst med portmappning

services:
  app:
    build: .
    ports:
      - "8000:80"   # Värdport 8000:Containerport 80

Publicerar appen på värdport 8000 och bygger från Dockerfile i aktuell katalog.

Multi-service med delad volym och anpassat nätverk

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Webb och DB på samma nätverk; DB använder bestående namngiven volym - db_data.

Använda build-kontext och Dockerfile-sökväg

Du kan bygga docker-image vid behov från den Dockerfile som anges i docker-compose.yml.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Dela data mellan tjänster

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Båda tjänsterna får tillgång till samma volym (för statiska filer eller datautbyte) - shared_data.

Avancerade alternativ för Compose-fil

• environment: Ställ in ENV-variabler för containrar.
• depends_on: Kontrollera startordningen för tjänster.
• deploy.replicas: Skala tjänst i Swarm-läge.

Exempel:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Startar 3 webbinstanser; kontrollerar endast startordning (inte redo).

Viktiga Docker Compose-kommandon

Vanliga Compose-mönster

• Databaser med bestående data

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  DB-data bevaras i mysql_data-volymen över containeromstartar.

• Bindmontering av kod för utveckling

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Redigera kod live på värden, automatiskt speglad i containern.

Användbara flaggor

• -d: Avkopplingsläge (kör i bakgrunden).
• --build: Tvinga ombyggnad av bilder innan start.
• --force-recreate: Återuppställ containrar även om de är oförändrade.
• --remove-orphans: Ta bort containrar som inte definieras i Compose-filen.

Definiera och anpassa tjänster

Du kan definiera och anpassa tjänster, nätverk och volymer i Docker Compose genom att utnyttja docker-compose.yml-filen, som centraliserar all din applikations konfiguration och orkestrering.

• Tjänster definieras under nyckeln services.
• Varje tjänst representerar en containerkonfiguration, där du kan ställa in:
  • Image: Välj en bild från Docker Hub eller ett annat register.
  • Ports: Mappa containerportar till värdportar.
  • Environment variables: Överför konfigurationsvärden.
  • Volumes: Bevara data eller dela filer/mappar med värdet eller andra tjänster.
  • Networks: Kontrollera vilka nätverk tjänsten kan få tillgång till.

Exempel:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Värdport 8080:Containerport 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Här använder web-tjänsten nginx-bilden, ställer in en miljövariabel, fäster en volym, öppnar port 80 som 8080 på värden och ansluter till frontend-nätverket. db-tjänsten gör något liknande för PostgreSQL.

Anpassa nätverk

• Nätverk kontrollerar vilka tjänster som kan kommunicera. Compose skapar ett standardnätverk, men du kan definiera fler, specificera anpassade drivrutiner, ställa in alternativ och avgöra vilken tjänst som ansluter till vilket nätverk för finmaskerad isolering.
• Definiera nätverk på toppnivå under networks, och lista vilka nätverk en tjänst ska ansluta till med networks-nyckeln på tjänstenivå.

Exempel:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Fäst nätverk på tjänster:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Denna konfiguration tillåter app-tjänsten att få tillgång till både användare på frontend- och backend-nätverken, medan db endast är tillgänglig inom backend.

Anpassa volymer

• Volymer definieras under nyckeln volumes på toppnivå. Montera dem på containrar med hjälp av volumes-nyckeln under en tjänst.
• Volymer kan vara namngivna, använda anpassade drivrutiner och delas mellan flera tjänster för databestånd och delning.

Exempel:

volumes:
  web_data:                # Namngiven volym för webbcontent
  db_data:                 # Namngiven volym för databas

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• I detta exempel bevaras web_data och är tillgänglig för alla containrar som monterar den. db_data säkerställer att databasdata aldrig förloras vid containeråterställning.
• Du kan definiera bind-mounts med anpassade drivrutinsalternativ för avancerade fall:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Denna konfiguration sätter upp en bind-mount från värdvägen /data/db_data in i containern.

Sammanfattning av bästa praxis:

• Använd tjänstnamnet som DNS-värdnamn för inter-servicekommunikation.
• Anslut tjänster till flera nätverk vid behov för att kontrollera åtkomst.
• Använd namngivna volymer för bestående lagring och datadelning.
• Definiera allt med YAML, vilket möjliggör versionskontroll och enkla distributionscript.
• För containerhantering och visualisering, överväg Installera Portainer på Linux.

Flera compose-filer

För att organisera komplexa multi-service-installationer i Docker Compose kan du använda flera compose-filer och override-filer, vilket möjliggör modulära, miljöspecifika och skalbara konfigurationer. Så här fungerar det:

1. Struktur för bas- och override-fil

• Skapa en basfil (compose.yaml eller docker-compose.yml) som innehåller alla gemensamma, standardiserade tjänstdefinitioner.
• Lägg till miljöspecifika override-filer (t.ex. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Exempel på filstruktur:

/project-directory
|-- docker-compose.yml           # Bas konfiguration
|-- docker-compose.override.yml  # Lokala/dev-överriddningar (lägs automatiskt till)
|-- docker-compose.prod.yml      # Produktionsöverriddningar
|-- docker-compose.test.yml      # Testöverriddningar (vid behov)

Bas-konfigurationen definierar kärntjänster, medan varje override anpassar inställningar för en specifik miljö eller fall.

2. Hur filöverriddningar fungerar

• Sammanfogning: När du kör docker compose up, sammanfogar Docker Compose basen med alla override-filer i ordning; efterföljande filer överrider, utökar eller lägger till inställningar i tidigare filer.
• Överridda fält: Om en tjänst eller ett fält definieras i flera filer används värdet från den senast specificerade filen. Nya fält läggs till.

Exempel på sammanfogning:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Resultat: web-tjänsten använder både basbilden och porten samt den överridna DEBUG-miljövariabeln.

3. Kommandonanvändning för flera filer

• Standardbeteende: Om de finns, läser Docker Compose automatiskt in docker-compose.override.yml tillsammans med docker-compose.yml när du kör något kommando.
• Specificera filer manuellt: Använd -f-flaggor för att kontrollera vilka filer som sammanfogas och i vilken ordning:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
  

  • Detta ignorerar standardöverriddningen och använder de produktionsspecifika inställningarna.

4. Praktiska organisationsstrategier

• Miljöseparation: Använd en override per miljö: dev, test, prod, etc.
• Mikrotjänster och team: Dela upp konfigurationen i separata filer för olika tjänster eller team, och kombinera vid behov.
• Fungeringsbrytare: Ytterligare filer kan introducera eller ta bort valfria tjänster eller konfiguration för tillfälliga behov (t.ex. en compose.debug.yml för extra loggning).

5. Fördelar

• Tydlighet: Håller individuella filer små och fokuserade.
• Skalbarhet: Lätt att lägga till nya tjänster, miljöer eller inställningar.
• Underhåll: Ändra eller granska endast relevanta avsnitt för en given distribution.

6. Exempel: Byta miljöer

Utveckling:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Produktion:

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Varje miljö får endast den konfiguration som krävs för den, med all delad konfiguration i basfilen.

Att organisera komplexa Compose-installationer med flera filer - och utnyttja override/sammanfogningssystemet - säkerställer modularitet, miljöspecifik anpassning och enkel skalbarhet för stora, multi-service Docker-applikationer.

För distributionsdistribution på en enskild Linux-värd — start vid uppstart, ren nedstängning, uppdateringar och loggrotation — se Kör Docker Compose som en Linux-tjänst med systemd.

Användbara länkar

• https://docs.docker.com/compose/
• Docker-fuskort
• Kubernetes-fuskort
• Dockerisera Flutter Web-app med dockeriserad Flutter-byggprocess och Nginx
• Installera Portainer på Linux