Docker Compose Cheatsheet - De mest användbara kommandona med exempel

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

Compose File Reference: docker-compose.yml

Kärnstruktur:

version: '3'       # Compose filformat version

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Host port 8080:Container port 80
  db:
    image: postgres
    environment:            # Miljövariabler
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Anpassad 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.
• networks & volumes: Definierar isolerade nätverk och permanent lagring - vi har appnet nätverk och db_data volym här.

Exempel

Enkel tjänst med portmappning

services:
  app:
    build: .
    ports:
      - "8000:80"   # Host port 8000:Container port 80

Exponerar app på host port 8000 och bygger från Dockerfile i aktuell katalog.

Multi-tjänst 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 permanent namngiven volym - db_data.

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

Du kan bygga docker image på begäran från den i docker-compose.yam angivna Dockerfile.

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 har åtkomst till samma volym (för statiska filer eller datautbyte) - shared_data.

Avancerade Compose File Alternativ

• environment: Ställ in MILJÖ-variabler för containrar.
• depends_on: Kontrollera tjänstens startordning.
• 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 beredskap).

Grundläggande Docker Compose Kommandon

Vanliga Compose Mönster

• Databaser med permanent 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 vid containrarbörjar om.

• Bind-mounta kod för utveckling

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

  Live-redigera kod på värden, automatiskt speglas i containern.

Användbara Flaggor

• -d: Bakgrundsläge (kör i bakgrunden).
• --build: Tvinga ombygga bilder innan start.
• --force-recreate: Skapa om containrar även om oförändrade.
• --remove-orphans: Ta bort containrar som inte är definierade i Compose fil.

Definiera och Anpassa Tjänster

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

• 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 annat register.
  • Ports: Mappa containerns portar till värdens portar.
  • Miljövariabler: Skicka konfigureringsvärden.
  • Volymer: Bevara data eller dela filer/mappar med värden eller andra tjänster.
  • Nätverk: Kontrollera vilka nätverk tjänsten kan komma åt.

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, bifogar 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 flera, ange anpassade drivrutiner, ställa in alternativ och bestämma vilken tjänst som ansluter till vilket nätverk för finjustering av isolering.
• Definiera nätverk på toppnivå under networks, och lista vilka nätverk en tjänst ska ansluta till med tjänstenivån networks nyckel.

Exempel:

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

• Anslut nätverk till tjänster:

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

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

Anpassa Volymer

• Volymer definieras under toppnivån volumes. Montera dem till containrar med volumes nyckeln under en tjänst.
• Volymer kan ha namn, använda anpassade drivrutiner och delas mellan flera tjänster för permanent lagring och delning av data.

Exempel:

volumes:
  web_data:                # Namngiven volym för webbinnehåll
  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 är web_data permanent och tillgänglig för vilken container som helst som monterar den. db_data säkerställer att databasen inte går förlorad vid containrarbörjar om.
• 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ärdsökvägen /data/db_data in i containern.

Sammanfattning av bästa praxis:

• Använd tjänstnamnet som DNS-värdnamn för kommunikation mellan tjänster.
• Anslut tjänster till flera nätverk efter behov för att kontrollera åtkomst.
• Använd namngivna volymer för permanent lagring och delning av data.
• Definiera allt med YAML, vilket möjliggör versionskontroll och enkla distributionsskript.

Flera compose-filer

För att organisera komplexa fler-tjänst-uppsättningar i Docker Compose kan du använda flera compose-filer och överskriftsfiler, vilket tillåter modulära, miljöspecifika och skalbara konfigurationer. Här är hur detta fungerar:

1. Grund- och överskriftsfilstruktur

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

Exempel på filstruktur:

/projekt-katalog
|-- docker-compose.yml           # Grundkonfiguration
|-- docker-compose.override.yml  # Lokala/dev-överskrifter (appliceras automatiskt)
|-- docker-compose.prod.yml      # Produktionsöverskrifter
|-- docker-compose.test.yml      # Testöverskrifter (om behövligt)

Grundkonfigurationen definierar kärntjänster, medan varje överskrift anpassar inställningar för en specifik miljö eller fall.

2. Hur filöverskrifter fungerar

• Sammanfogning: När du kör docker compose up, sammanfogar Docker Compose grundfilen med eventuella överskrifter i ordning; efterföljande filer överskriver, utökar eller lägger till inställningar i tidigare filer.
• Överskrivning av fält: Om en tjänst eller ett fält definieras i flera filer, används värdet från den sist angivna 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: Tjänsten web använder både grundbilden och porten plus den överskrivna DEBUG-miljövariabeln.

3. Kommandon för flera filer

• Standardbeteende: Om den finns, laddar Docker Compose automatiskt docker-compose.override.yml tillsammans med docker-compose.yml när du kör något kommando.
• Manuell specificering: 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överskriften och använder produktionsspecifika inställningar.

4. Praktiska organisationsstrategier

• Miljöseparation: Använd en överskrift 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 efter behov.
• Funktionstogglar: Ytterligare filer kan introducera eller ta bort valfria tjänster eller konfigurationer för tillfälliga behov (t.ex., en compose.debug.yml för extra loggning).

5. Fördelar

• Klarsynthet: Håller individuella filer små och fokuserade.
• Skalbarhet: Lätt att lägga till nya tjänster, miljöer eller inställningar.
• Underhållbarhet: Endast ändra eller granska 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 är nödvändig för den, med all gemensam konfiguration i grundfilen.

Organisera komplexa Compose-uppsättningar med flera filer - och utnyttja överskrifts/sammanfogningssystemet - säkerställer modularitet, miljöspecifik anpassning och enkel skalbarhet för stora, fler-tjänst-Docker-applikationer.

Användbara länkar

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