Ściągnik Docker Compose – Najprzydatniejsze komendy z przykładami

Oto szkolenie z Docker Compose z objaśnionymi przykładami, które pomogą Ci szybko opanować pliki i polecenia Compose.

Ten przewodnik jest częścią Narzędzia deweloperskie: Kompletny przewodnik po nowoczesnych przepływach pracy.

Wymagania wstępne

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

Podręcznik pliku Compose: docker-compose.yml

Struktura rdzeniowa:

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:          # Dedykowane sieci
  appnet:
    driver: bridge

volumes:           # Nazwane wolumeny
  db_data:

• services: Każdy kontener w aplikacji wielokontenerowej. W powyższym przykładzie mamy dwie usługi: web i db. Aby uzyskać informacje na temat operacji na pojedynczych kontenerach, zobacz Szkolenie z Dockera.
• networks & volumes: Definiuj izolowane sieci i trwałe magazyny danych - tutaj mamy sieć appnet i wolumen db_data.

Przykłady

Pojedyncza usługa z mapowaniem portów

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

Eksponuje aplikację na porcie hosta 8000 i buduje obraz z Dockerfile w bieżącym katalogu.

Wieloskładnikowa usługa z udostępnionym wolumenem i własną 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 Dockerfile

Możesz zbudować obraz docker na żądanie ze wskazanej w docker-compose.yml ścieżki do 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 tego samego wolumenu (dla plików statycznych lub wymiany danych) - shared_data.

Zaawansowane opcje pliku Compose

• environment: Ustawia zmienne ENV 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ść).

Podstawowe polecenia Docker Compose

Popularne wzorce Compose

• Bazy danych z trwałą pamięcią

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

  Dane bazy danych są przechowywane w wolumenie mysql_data przez restarty kontenerów.

• Montowanie kodu z hosta do rozwoju

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

  Edytuj kod na hostie w czasie rzeczywistym, zmiany są automatycznie odzwierciedlane w kontenerze.

Przydatne flagi

• -d: Tryb odłączania (uruchomienie w tle).
• --build: Wymusza ponowne zbudowanie obrazów przed uruchomieniem.
• --force-recreate: Przebudowuje kontenery nawet jeśli nie uległy zmianie.
• --remove-orphans: Usuwa kontenery nieokreślone w pliku Compose.

Definiowanie i dostosowywanie usług

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

• Usługi są zdefiniowane pod kluczem 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.
  • Environment variables: Przekazuj wartości konfiguracyjne.
  • Volumes: Przechowuj dane lub udostępniaj pliki/foldery z hostem lub innymi usługami.
  • Networks: Kontroluj, do których sieci usługa może uzyskać dostęp.

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ą, podłącza wolumen, otwiera port 80 jako 8080 na hostcie 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 domyślną sieć, ale możesz zdefiniować więcej, określić własne sterowniki, ustawić opcje i określić, która usługa dołącza do której sieci dla drobniejszej izolacji.
• Definiuj sieci na najwyższym poziomie pod networks, i określ, które sieci usługa powinna dołą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 na dostęp zarówno do użytkowników w sieciach frontend i backend, podczas gdy db jest dostępna tylko wewnątrz backend.

Dostosowywanie wolumenów

• Wolumeny są zdefiniowane pod najwyższym poziomem klucza volumes. Montuj je do kontenerów używając klucza volumes pod usługą.
• Wolumeny mogą być nazwane, używać własnych sterowników i być udostępniane między wieloma usługami dla trwałości danych i współdzielenia.

Przykład:

volumes:
  web_data:                # Nazwany wolumen dla treści webowych
  db_data:                 # Nazwany wolumen 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 przechowywane i dostępne dla każdego kontenera, który je zamontuje. db_data zapewnia, że dane bazy danych nie zostaną utracone przy ponownym tworzeniu kontenera.
• Możesz zdefiniować montowania bind-mount z własnymi opcjami sterownika dla zaawansowanych przypadków:

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

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

Podsumowanie najlepszych praktyk:

• Używaj nazwy usługi jako nazwy hosta DNS do komunikacji międzyusługowej.
• Podłączaj usługi do wielu sieci według potrzeby, aby kontrolować dostęp.
• Używaj nazwanych wolumenów dla trwałego magazynu i udostępniania danych.
• Definiuj wszystko używając YAML, co umożliwia kontrolę wersji i łatwe skrypty wdrożeniowe.
• Dla zarządzania kontenerami i wizualizacji, rozważ Instalację Portainera na Linuxie.

Wielokrotne pliki Compose

Aby zorganizować złożone konfiguracje wieloskładnikowe w Docker Compose, możesz użyć wielu plików Compose i plików nadpisujących, co pozwala na modułowe, specyficzne dla środowiska i skalowalne konfiguracje. Oto jak to działa:

1. Struktura pliku bazowego i nadpisującego

• Stwórz plik bazowy (compose.yaml lub docker-compose.yml) zawierający wszystkie wspólne, domyślne definicje usług.
• Dodaj pliki nadpisujące 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           # Konfiguracja bazowa
|-- docker-compose.override.yml  # Nadpisywania lokalne/dev (zastosowane automatycznie)
|-- docker-compose.prod.yml      # Nadpisywania produkcyjne
|-- docker-compose.test.yml      # Nadpisywania testowe (jeśli potrzebne)

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

2. Jak działają nadpisywania plików

• Łączenie: Gdy uruchamiasz docker compose up, Docker Compose łączy bazowy plik z wszelkimi nadpisaniami w kolejności; kolejne pliki nadpisują, rozszerzają lub dodają ustawienia z poprzednich plików.
• Nadpisywanie pól: Jeśli usługa lub pole jest zdefiniowane 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 zarówno obrazu bazowego 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 razem z docker-compose.yml przy uruchomieniu dowolnego polecenia.
• Określanie plików ręcznie: 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 nadpisywanie i używa ustawień specyficznych dla produkcji.

4. Praktyczne strategie organizacji

• Oddzielenie środowisk: Używaj jednego 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 według potrzeby.
• Przełączniki funkcjonalne: Dodatkowe pliki mogą wprowadzać lub usuwać opcjonalne usługi lub konfiguracje dla tymczasowych potrzeb (np. compose.debug.yml dla dodatkowego logowania).

5. Korzyści

• Czystość: Trzyma pojedyncze pliki małe i skupione.
• Skalowalność: Łatwo dodawaj nowe usługi, środowiska lub ustawienia.
• Łatwość utrzymania: Zmieniaj lub przeglądaj tylko odpowiednie 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 konfigurację niezbędną dla niego, ze wszystkimi wspólnymi konfiguracjami w pliku bazowym.

Organizacja złożonych konfiguracji Compose z wieloma plikami - i wykorzystywanie systemu nadpisania/łączenia - zapewnia modułowość, dostosowanie specyficzne dla środowiska i łatwą skalowalność dla dużych, wieloskładnikowych aplikacji Docker.

Aby uzyskać informacje na temat 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.

Przydatne linki

• https://docs.docker.com/compose/
• Szkolenie z Dockera
• Szkolenie z Kubernetes
• Dockerising Flutter Web app with dockerised Flutter build and Nginx
• Instalacja Portainera na Linuxie