Docker Compose - Najważniejsze polecenia z przykładami

Oto Docker Compose cheatshet z opisanymi przykładami, które pomogą Ci szybko opanować pliki i polecenia Compose.

Odwołanie do pliku Compose: docker-compose.yml

Podstawowa struktura:

version: '3'       # Wersja formatu pliku Compose

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port hosta 8080:Port kontenera 80
  db:
    image: postgres
    environment:            # Zmienne środowiskowe
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Sieć niestandardowa
  appnet:
    driver: bridge

volumes:           # Objętość nazwana
  db_data:

• services: Każdy kontener w aplikacji wielokontenerowej. W powyższym przykładzie mamy dwa usługi: web i db.
• networks & volumes: Definiowanie izolowanych sieci i trwałego magazynu danych – tutaj mamy sieć appnet i objętość db_data.

Przykłady

Jedna usługa z mapowaniem portów

services:
  app:
    build: .
    ports:
      - "8000:80"   # Port hosta 8000:Port kontenera 80

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

Wiele usług z udostępnioną objętością 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:

Usługa sieciowa i baza danych na tej samej sieci; baza danych korzysta z trwałej objętości nazwanej – db_data.

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

Możesz zbudować obraz docker na żądanie z określonego w pliku docker-compose.yml pliku Dockerfile.

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 mają dostęp do tej samej objętości (dla plików statycznych lub wymiany danych) – shared_data.

Zaawansowane opcje pliku Compose

• environment: Ustaw zmienne środowiskowe dla kontenerów.
• depends_on: Kontroluj kolejność uruchamiania usług.
• deploy.replicas: Skaluj usługę w trybie Swarm.

Przykład:

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

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

Kluczowe polecenia Docker Compose

Typowe 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 bazy danych są przechowywane w objętości mysql_data po ponownym uruchomieniu kontenera.

• Przypinanie kodu do rozwoju

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

  Edytuj kod na hostowaniu, automatycznie odzwierciedlany w kontenerze.

Przydatne flagi

• -d: Tryb oddzielony (uruchamianie w tle).
• --build: Wymuszenie ponownego budowania obrazów przed uruchomieniem.
• --force-recreate: Ponowne tworzenie kontenerów nawet jeśli nie zmieniły się.
• --remove-orphans: Usuwanie kontenerów niezdefiniowanych w pliku Compose.

Definiowanie i dostosowywanie usług

Możesz zdefiniować i dostosować usługi, sieci i objętości w Docker Compose, korzystając z pliku docker-compose.yml, który centralnie koncentruje wszystkie potrzeby konfiguracji i orchestracji aplikacji.

• Usługi są definiowane w kluczu services.
• Każda usługa reprezentuje konfigurację kontenera, gdzie możesz ustawić:
  • Image: Wybierz obraz z Docker Hub lub innego rejestru.
  • Ports: Mapuj porty kontenera na porty hosta.
  • Zmienne środowiskowe: Przekaż wartości konfiguracji.
  • Objętości: Trwałe dane lub udostępnianie plików/folderów z hosta lub innych usług.
  • Sieci: Kontroluj, które sieci może uzyskać usługa.

Przykład:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port hosta 8080:Port kontenera 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ą, dołącza objętość, otwiera port 80 jako 8080 na hostowaniu i łączy się z siecią frontend. Usługa db robi coś podobnego dla PostgreSQL.

Dostosowywanie sieci

• Sieci kontrolują, które usługi mogą się komunikować. Compose tworzy sieć domyślną, ale możesz zdefiniować więcej, określić niestandardowe sterowniki, ustawić opcje i określić, które usługa dołącza do której sieci dla szczegółowej izolacji.
• Definiuj sieci na poziomie górnym w networks, a następnie wylicz, które sieci powinna dołączyć usługa za pomocą 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"

• Dołącz sieci do usług:

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

• Taka konfiguracja pozwala usłudze app na dostęp do użytkowników w sieciach frontend i backend, podczas gdy db jest dostępna tylko w sieci backend.

Dostosowywanie objętości

• Objętości są definiowane w górnym poziomie w volumes. Montuj je do kontenerów za pomocą klucza volumes w usłudze.
• Objętości mogą być nazwane, używać niestandardowych sterowników i być udostępniane wielu usługom dla trwałości danych i udostępniania.

Przykład:

volumes:
  web_data:                # Nazwana objętość dla treści sieciowych
  db_data:                 # Nazwana objętość dla bazy danych

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

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

• W tym przykładzie web_data jest przechowywana i dostępna dla każdego kontenera, który ją montuje. db_data zapewnia, że dane bazy danych nigdy nie zostaną utracone po ponownym utworzeniu kontenera.
• Możesz zdefiniować bind-montaże 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 tworzy bind-montaż z lokalnej ścieżki /data/db_data do kontenera.

Podsumowanie najlepszych praktyk:

• Użyj nazwy usługi jako nazwy hosta DNS do komunikacji między usługami.
• Dołącz usługi do wielu sieci, jeśli to konieczne, aby kontrolować dostęp.
• Używaj nazwanych objętości do trwałego magazynowania i udostępniania danych.
• Definiuj wszystko za pomocą YAML, umożliwiając kontrolę wersji i łatwe skrypty wdrażania.

Wiele plików compose

Aby zorganizować złożone konfiguracje wielu usług w Docker Compose, możesz użyć wielu plików compose i plików nadpisujących, umożliwiając modularne, środowiskowe i skalowalne konfiguracje. Oto jak to działa:

1. Struktura pliku podstawowego i nadpisującego

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

Przykład struktury plików:

/project-directory
|-- docker-compose.yml           # Konfiguracja podstawowa
|-- docker-compose.override.yml  # Nadpisywanie lokalne/rozwijanie (automatycznie ładowane)
|-- docker-compose.prod.yml      # Nadpisywanie produkcyjne
|-- docker-compose.test.yml      # Nadpisywanie testowe (jeśli potrzebne)

Podstawowa konfiguracja definiuje podstawowe usługi, podczas gdy każdy nadpisuje ustawienia dla określonego środowiska lub przypadku.

2. Jak działają nadpisywanie plików

• Łączenie: Gdy uruchamiasz docker compose up, Docker Compose łączy plik podstawowy z dowolnymi nadpisami w kolejności; późniejsze pliki nadpisują, rozszerzają lub dodają ustawienia z wcześniejszych plików.
• Nadpisywanie pól: Jeśli usługa lub pole jest zdefiniowana w wielu plikach, wartość z ostatniego określonego pliku jest używana. 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 obrazu i portu z podstawowego pliku oraz nadpisanej zmiennej środowiskowej DEBUG.

3. Użycie polecenia dla wielu plików

• Domyślne zachowanie: Jeśli istnieje, Docker Compose automatycznie ładowa docker-compose.override.yml wraz z docker-compose.yml, gdy uruchamiasz dowolne polecenie.
• Ręczne określanie plików: Użyj 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 nadpisywanie i używa ustawień specyficznych dla środowiska produkcyjnego.

4. Praktyczne strategie organizacji

• Oddzielanie środowisk: Użyj jednego nadpisu na środowisko: dev, test, prod itd.
• Usługi i zespoły: Podziel konfigurację na osobne pliki dla różnych usług lub zespołów i łączonej w razie potrzeby.
• Przełączniki funkcji: Dodatkowe pliki mogą wprowadzać lub usuwać opcjonalne usługi lub konfigurację dla tymczasowych potrzeb (np. compose.debug.yml dla dodatkowego logowania).

5. Zalety

• Jasność: Zmniejsza rozmiar i skupia się na pojedynczych plikach.
• Skalowalność: Łatwo dodawać nowe usługi, środowiska lub ustawienia.
• Utrzymanie: Zmieniać lub przeglądać tylko odpowiednie sekcje dla 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开头

Każde środowisko otrzymuje tylko konfigurację potrzebną dla niego, z wszystkimi wspólnymi ustawieniami w pliku podstawowym.

Organizacja złożonych konfiguracji Compose za pomocą wielu plików – oraz wykorzystanie systemu nadpisania/łączenia – zapewnia modularyzację, dostosowanie do konkretnego środowiska i łatwą skalowalność dla dużych aplikacji wielu usług w Dockerze.

Przydatne linki

• https://docs.docker.com/compose/
• Docker Cheatshet
• Kubernetes Cheatshet
• Dockerising Flutter Web app with dockerised Flutter build and Nginx
• Instalacja Portainera na Linux