Karta ściągawki Docker Compose — najprzydatniejsze polecenia z przykładami

Oto notatka z Docker Compose z opisami przykładów, aby szybko opanować pliki i polecenia Compose.

Ten przewodnik jest częścią Narzędzia deweloperskie: Kompletny przewodnik po współczesnych workflow programistycznych.

Wymagania wstępne

Docker Engine musi być zainstalowany, zanim zaczniesz używać Compose. Na systemie Ubuntu, postępuj zgodnie z instrukcją Instalacja Dokera na Ubuntu, aby wybrać odpowiednią metodę instalacji i skonfigurować wtyczkę docker compose.

Referencja do pliku Compose: docker-compose.yml

Struktura główna:

version: '3'       # Compose file format version

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

networks:          # Custom network
  appnet:
    driver: bridge

volumes:           # Named volume
  db_data:

• services: Każdy kontener w aplikacji wielokontenerowej. W powyższym przykładzie mamy dwie usługi: web i db. W celu wykonania pojedynczych operacji na kontenerach, zobacz Notatkę z Dokera.
• networks & volumes: Definiują izolowane sieci i trwałe przechowywanie danych - tutaj mamy sieć appnet i wolumen db_data.

Przykłady

Pojedyncza usługa z mapowaniem portów

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

Eksponuje aplikację na porcie 8000 hosta i buduje ją na podstawie pliku Dockerfile w bieżącym katalogu.

Wielu serwisów z wspólnym wolumenem i niestandardową siecią

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:

Web i DB w tej samej sieci; DB używa trwałego nazwanego wolumenu - db_data.

Używanie kontekstu budowania i ścieżki do pliku Dockerfile

Możesz zbudować obraz Dokera na żądanie z pliku Dockerfile podanego w pliku docker-compose.yml.

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

Udostępnianie danych między usługami

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

volumes:
  shared_data:

Obie usługi uzyskują dostęp do tego samego wolumenu (dla plików statycznych lub wymiany danych) - shared_data.

Zaawansowane opcje pliku Compose

• environment: Ustawia zmienne środowiskowe dla kontenerów.
• depends_on: Kontroluje kolejność uruchamiania usług.
• deploy.replicas: Skaluje usługę w trybie Swarm.

Przykład:

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

Uruchamia 3 instancje web; kontroluje tylko kolejność uruchamiania (nie gotowości).

Niezbędne polecenia Docker Compose

Częste wzorce Compose

• Bazy danych z trwałymi danymi

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

  Dane DB są przechowywane w wolumenie mysql_data i przetrwają ponowne uruchomienie kontenera.

• Bind montowanie kodu w celu rozwoju

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

  Edytuj kod na żywo na hoście, zmiany są automatycznie odbite w kontenerze.

Przydatne flagi

• -d: Tryb odłączony (uruchamianie w tle).
• --build: Wymusza przebudowanie obrazów przed uruchomieniem.
• --force-recreate: Odtwarza kontenery nawet jeśli nie zostały zmienione.
• --remove-orphans: Usuwa kontenery niezdefiniowane w pliku Compose.

Definiowanie i dostosowywanie usług

Możesz zdefiniować i dostosować usługi, sieci i wolumeny w Docker Compose, wykorzystując plik docker-compose.yml, który centralizuje wszystkie potrzeby konfiguracji i orkiestracji Twojej aplikacji.

• Usługi są zdefiniowane pod kluczem services.
• Każda usługa reprezentuje konfigurację kontenera, w której można ustawić:
  • Image: Wybierz obraz z Docker Hub lub innego rejestru.
  • Ports: Zmapuj porty kontenera na porty hosta.
  • Environment variables: Przekaż wartości konfiguracyjne.
  • Volumes: Zachowuj dane lub udostępniaj pliki/katalogi hostowi lub innym usługom.
  • Networks: Kontroluj, do których sieci usługa może uzyskać dostęp.

Przykład:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Host port 8080:Container port 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

• Tutaj usługa web używa obrazu nginx, ustawia zmienną środowiskową, podłącza wolumen, otwiera port 80 jako 8080 na hoście i łączy się z siecią frontend. Usługa db robi coś podobnego dla PostgreSQL.

Dostosowywanie sieci

• Sieci kontrolują, które usługi mogą ze sobą komunikować. Compose tworzy domyślną sieć, ale możesz zdefiniować więcej, specyfikować niestandardowych sterowników, ustawiać opcje i określać, która usługa dołącza do której sieci, aby uzyskać precyzyjną izolację.
• Zdefiniuj sieci na najwyższym poziomie pod kluczem networks i wyszczególnij, do których sieci usługa powinna się podłączyć, używając klucza networks na poziomie usługi.

Przykład:

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

• Podłącz sieci do usług:

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

• Ta konfiguracja pozwala usłudze app uzyskać dostęp do użytkowników w sieciach frontend i backend, podczas gdy db jest dostępny tylko wewnątrz backend.

Dostosowywanie wolumenów

• Wolumeny są zdefiniowane pod kluczowym poziomem najwyższym volumes. Podłączaj je do kontenerów, używając klucza volumes pod daną usługą.
• Wolumeny mogą być nazwane, używać niestandardowych sterowników i być udostępniane między wieloma usługami w celu utrwalania i współdzielenia danych.

Przykład:

volumes:
  web_data:                # Named volume for web content
  db_data:                 # Named volume for database

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

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

• W tym przykładzie web_data jest utrwalane i dostępne dla każdego kontenera, który je zamontuje. db_data zapewnia, że dane bazy danych nie zostaną utracone przy odtworzeniu kontenera.
• Możesz zdefiniować bind-mounty z niestandardowymi opcjami sterownika dla zaawansowanych przypadków:

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

• Ta konfiguracja ustawia bind-montowanie ze ścieżki hosta /data/db_data do kontenera.

Podsumowanie dobrych praktyk:

• Używaj nazwy usługi jako nazwy hosta DNS do komunikacji międzyusługowej.
• Podłączaj usługi do wielu sieci w razie potrzeby, aby kontrolować dostęp.
• Używaj nazwanych wolumenów do trwałego przechowywania danych i współdzielenia danych.
• Definiuj wszystko przy użyciu YAML, umożliwiając kontrolę wersji i łatwe skrypty wdrożeniowe.
• W celu zarządzania i wizualizacji kontenerów, rozważ Instalację Portainera na Linuxie.

Wiele plików compose

Aby zorganizować złożone konfiguracje wielu serwisów w Docker Compose, możesz użyć wielu plików compose i plików nadpisywania (override), umożliwiając modularne, specyficzne dla środowiska i skalowalne konfiguracje. Oto jak to działa:

1. Struktura pliku bazowego i nadpisywania

• Utwórz plik bazowy (compose.yaml lub docker-compose.yml) zawierający wszystkie wspólne, domyślne definicje usług.
• Dodaj pliki nadpisywania specyficzne dla środowiska (np. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Przykładowa struktura plików:

/project-directory
|-- docker-compose.yml           # Base configuration
|-- docker-compose.override.yml  # Local/dev overrides (applied automatically)
|-- docker-compose.prod.yml      # Production overrides
|-- docker-compose.test.yml      # Test overrides (if needed)

Konfiguracja bazowa definiuje kluczowe usługi, podczas gdy każdy plik nadpisywania dostosowuje ustawienia dla konkretnego środowiska lub przypadku.

2. Jak działają nadpisywania plików

• Łączenie: Gdy wykonujesz docker compose up, Docker Compose łączy plik bazowy z jakimikolwiek nadpisaniami w kolejności; kolejne pliki nadpisują, rozszerzają lub dodają ustawienia z poprzednich plików.
• Nadpisywanie pól: Jeśli usługa lub pole są zdefiniowane w wielu plikach, używana jest wartość z pliku określonego jako ostatni. Nowe pola są dodawane.

Przykład łączenia:

• docker-compose.yml:

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

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Wynik: Usługa web używa zarówno bazowego obrazu i portu, jak i nadpisanej zmiennej środowiskowej DEBUG.

3. Użycie poleceń dla wielu plików

• Domyślne zachowanie: Jeśli istnieje, Docker Compose automatycznie ładuje docker-compose.override.yml wraz z docker-compose.yml przy wykonywaniu dowolnego polecenia.
• Ręczne specyfikowanie plików: Używaj flag -f, aby kontrolować, które pliki są łączone i w jakiej kolejności:

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

  • To ignoruje domyślne nadpisanie i używa ustawień specyficznych dla produkcji.

4. Praktyczne strategie organizacji

• Separacja środowisk: Używaj jednego pliku nadpisania na środowisko: dev, test, prod itp.
• Mikrousługi i zespoły: Podziel konfigurację na osobne pliki dla różnych usług lub zespołów i łącz je w razie potrzeby.
• Przełączniki funkcji: Dodatkowe pliki mogą wprowadzać lub usuwać opcjonalne usługi lub konfiguracje na czasowe potrzeby (np. compose.debug.yml dla dodatkowego logowania).

5. Korzyści

• Przejrzystość: Zachowuje poszczególne pliki małe i skupione na temacie.
• Skalowalność: Łatwo dodawaj nowe usługi, środowiska lub ustawienia.
• Łatwość utrzymania: Zmieniaj lub przeglądaj tylko związane sekcje dla danego wdrożenia.

6. Przykład: Przełączanie środowisk

Rozwój:

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

Produkcja:

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

Każde środowisko otrzymuje tylko konfigurowanie niezbędne dla niego, ze wspólną konfiguracją w pliku bazowym.

Organizowanie złożonych konfiguracji Compose za pomocą wielu plików - i wykorzystywanie systemu nadpisywania/łączenia - zapewnia modularność, specyficzne dla środowiska dostosowanie i łatwą skalowalność dla dużych, wielusługowych aplikacji Docker.

Dla wdrożenia produkcyjnego na pojedynczym hoście Linux — uruchamianie przy starcie, czyste wyłączenie, aktualizacje i rotacja logów — zobacz Uruchamianie Docker Compose jako usługi Linux z systemd. Dla porównania z Podman Quadlet, zobacz Podman Quadlet vs Docker Compose dla usług Linux.

Przydatne linki

• https://docs.docker.com/compose/
• Notatka z Dokera
• Notatka z Kubernetes
• Dockerization aplikacji Flutter Web z dockerized Flutter build i Nginx
• Instalacja Portainera na Linuxie
• Kopia zapasowa i przywracanie serwera Gitea