🐳 Wprowadzenie do zarządzania kontenerami Docker Compose

Docker Compose to potężne narzędzie, które upraszcza zarządzanie wielokontenerowymi aplikacjami Docker. Zamiast uruchamiać każdy kontener oddzielnie z długimi poleceniami, możesz zdefiniować całą infrastrukturę w jednym pliku konfiguracyjnym i uruchomić ją jednym poleceniem. Ten przewodnik przeprowadzi Cię przez podstawy Docker Compose, od instalacji po tworzenie złożonych środowisk dla Twoich aplikacji.

⚡ Ekspresowe Podsumowanie:

Docker Compose to narzędzie do definiowania i uruchamiania wielokontenerowych aplikacji Docker.
Konfiguracja w pliku YAML pozwala deklaratywnie opisać całą infrastrukturę aplikacji.
Upraszcza zarządzanie sieciami, wolumenami i zależnościami między kontenerami.
Idealny dla środowisk deweloperskich, testowych i CI/CD, choć nie zawsze najlepszy wybór dla produkcji.

🗺️ Spis Treści - Twoja Mapa Drogowa

📚 Czym jest Docker Compose i dlaczego warto go używać?

Docker Compose to narzędzie do definiowania i uruchamiania wielokontenerowych aplikacji Docker. Pozwala używać pliku YAML do konfiguracji usług aplikacji, a następnie jednym poleceniem tworzyć i uruchamiać wszystkie usługi z tej konfiguracji.

Kluczowe zalety Docker Compose:

Uproszczona konfiguracja - zamiast długich poleceń Docker, używasz deklaratywnego pliku YAML
Pojedynczy plik konfiguracyjny - cała infrastruktura zdefiniowana w jednym miejscu
Łatwe zarządzanie zależnościami - definiujesz kolejność uruchamiania kontenerów
Izolowane środowiska - każdy projekt może mieć własne sieci, wolumeny i usługi
Łatwość współpracy - plik konfiguracyjny można dodać do kontroli wersji
Szybkie odtwarzanie środowiska - jedno polecenie do postawienia całej infrastruktury

Typowe zastosowania Docker Compose:

Środowiska deweloperskie - szybkie tworzenie lokalnych środowisk identycznych z produkcją
Automatyczne testy - spójne środowisko testowe dla CI/CD
Środowiska demonstracyjne - łatwe tworzenie demo aplikacji
Pojedyncze serwery produkcyjne - proste wdrożenia na mniejszą skalę

Uwaga: Docker Compose nie jest zazwyczaj pierwszym wyborem do orkiestracji kontenerów w dużych środowiskach produkcyjnych, gdzie lepiej sprawdzają się rozwiązania jak Kubernetes czy Docker Swarm. Jest jednak idealny dla mniejszych wdrożeń i środowisk deweloperskich.

🔧 Instalacja i konfiguracja Docker Compose

Zanim zaczniesz korzystać z Docker Compose, musisz zainstalować zarówno Docker Engine, jak i Docker Compose. Oto jak to zrobić na najpopularniejszych systemach operacyjnych.

Wymagania wstępne

Docker Engine zainstalowany na komputerze (minimum wersja 1.13.0)
Uprawnienia administratora lub dostęp do grupy docker

Instalacja Docker Compose na Linux

# Pobierz najnowszą stabilną wersję Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# Nadaj uprawnienia wykonywania
sudo chmod +x /usr/local/bin/docker-compose

# Sprawdź instalację
docker-compose --version

Instalacja Docker Compose na macOS

Jeśli używasz Docker Desktop dla Mac, Docker Compose jest już zainstalowany. W przeciwnym razie:

# Zainstaluj Homebrew, jeśli jeszcze nie masz
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Zainstaluj Docker Compose
brew install docker-compose

# Sprawdź instalację
docker-compose --version

Instalacja Docker Compose na Windows

Jeśli używasz Docker Desktop dla Windows, Docker Compose jest już zainstalowany. W przeciwnym razie:

Pobierz najnowszy instalator Docker Desktop ze strony Docker
Postępuj zgodnie z instrukcjami instalatora
Po instalacji otwórz terminal i sprawdź wersję: docker-compose --version

Aktualizacja Docker Compose

# Linux
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# macOS z Homebrew
brew upgrade docker-compose

# Windows
# Zaktualizuj Docker Desktop przez jego interfejs

✨ Pro Tip: Upewnij się, że używasz najnowszej wersji Docker Compose, aby mieć dostęp do wszystkich funkcji i poprawek bezpieczeństwa. Wersja 2.x wprowadza znaczące ulepszenia w porównaniu do serii 1.x.

🚀 Pierwszy projekt z Docker Compose

Zacznijmy od prostego przykładu, aby zrozumieć podstawy Docker Compose. Utworzymy prostą aplikację webową składającą się z serwera webowego i bazy danych.

Struktura projektu

Najpierw utwórz nowy folder dla projektu:

mkdir moj-pierwszy-projekt-compose
cd moj-pierwszy-projekt-compose

Tworzenie pliku docker-compose.yml

W katalogu projektu utwórz plik o nazwie docker-compose.yml i dodaj następującą zawartość:

version: '3'

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - db

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: testdb
    volumes:
      - db_data:/var/lib/mysql

volumes:
  db_data:

Tworzenie zawartości strony

Utwórz katalog html i dodaj plik index.html:

mkdir html
echo "<html><body><h1>Moja pierwsza aplikacja Docker Compose</h1><p>Działa!</p></body></html>" > html/index.html

Uruchamianie kontenerów

Teraz uruchom aplikację za pomocą Docker Compose:

docker-compose up

Aby uruchomić kontenery w tle (tryb detached):

docker-compose up -d

Testowanie aplikacji

Otwórz przeglądarkę i przejdź do adresu http://localhost:8080. Powinieneś zobaczyć stronę HTML, którą utworzyłeś.

Zatrzymywanie kontenerów

Aby zatrzymać kontenery, użyj:

# Jeśli uruchomiłeś w trybie interaktywnym, naciśnij Ctrl+C
# Jeśli uruchomiłeś w tle:
docker-compose down

Aby zatrzymać kontenery i usunąć wolumeny:

docker-compose down -v

✨ Pro Tip: Użyj docker-compose ps aby zobaczyć status kontenerów w twoim projekcie, a docker-compose logs aby zobaczyć ich logi.

📄 Anatomia pliku docker-compose.yml

Plik docker-compose.yml jest sercem każdego projektu Docker Compose. Przyjrzyjmy się szczegółowo jego strukturze i najważniejszym elementom.

Wersja Compose

version: '3.8'  # Określa wersję składni docker-compose

Określa wersję składni Docker Compose. Najnowsze projekty powinny używać wersji 3.x.

Usługi (services)

Usługi to kontenery aplikacji, które chcesz uruchomić:

services:
  webapp:  # Nazwa usługi
    image: nginx:alpine  # Obraz Dockera do użycia
    build: ./app  # Alternatywnie, ścieżka do Dockerfile
    container_name: moja-aplikacja  # Opcjonalna niestandardowa nazwa kontenera
    ports:
      - "8080:80"  # Mapowanie portów (host:kontener)
    environment:
      DB_HOST: database
      DEBUG: 'true'
    env_file: .env  # Plik ze zmiennymi środowiskowymi
    volumes:
      - ./app:/app  # Montowanie katalogów (host:kontener)
    depends_on:
      - database  # Zależności (kolejność uruchamiania)
    restart: always  # Polityka restartu
    networks:
      - frontend  # Sieci, do których należy kontener

Sieci (networks)

Definiują sposób komunikacji między kontenerami:

networks:
  frontend:  # Nazwa sieci
    driver: bridge  # Typ sieci
  backend:
    driver: bridge
    internal: true  # Sieć bez dostępu do internetu

Wolumeny (volumes)

Zarządzają trwałymi danymi:

volumes:
  db_data:  # Nazwa wolumenu
    driver: local  # Opcjonalny driver
  cache:
    external: true  # Używa istniejącego zewnętrznego wolumenu

Przykład pełnego pliku docker-compose.yml

Poniżej znajduje się bardziej złożony przykład, który pokazuje wiele funkcji:

version: '3.8'

services:
  webapp:
    build: 
      context: ./frontend
      dockerfile: Dockerfile.dev
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - API_URL=http://api:5000
    depends_on:
      - api
    networks:
      - frontend_net
    restart: unless-stopped

  api:
    build: ./backend
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=database
      - DB_USER=root
      - DB_PASSWORD_FILE=/run/secrets/db_password
    volumes:
      - ./backend:/app
    depends_on:
      - database
    networks:
      - frontend_net
      - backend_net
    secrets:
      - db_password

  database:
    image: postgres:13
    volumes:
      - db_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
      - POSTGRES_DB=myapp
    networks:
      - backend_net
    secrets:
      - db_password

networks:
  frontend_net:
  backend_net:
    internal: true

volumes:
  db_data:

secrets:
  db_password:
    file: ./secrets/db_password.txt

✨ Pro Tip: Twórz pliki docker-compose.yml w sposób modułowy i czytelny. Grupuj powiązane usługi razem i dodawaj komentarze, aby wyjaśnić nieoczywiste elementy konfiguracji.

🛠️ Zarządzanie wieloma środowiskami z Docker Compose

Docker Compose pozwala na elastyczne zarządzanie różnymi środowiskami - deweloperskimi, testowymi i produkcyjnymi - przy zachowaniu podstawowej konfiguracji.

Metoda 1: Wiele plików Docker Compose

Możesz używać wielu plików konfiguracyjnych dla różnych środowisk:

docker-compose.yml - konfiguracja bazowa
docker-compose.override.yml - automatycznie nakładany na bazowy (zwykle dla dev)
docker-compose.prod.yml - konfiguracja produkcyjna
docker-compose.test.yml - konfiguracja testowa

Przykład konfiguracji bazowej (docker-compose.yml):

version: '3'
services:
  web:
    image: myapp:latest
    build: .
    networks:
      - webnet

Konfiguracja deweloperska (docker-compose.override.yml):

services:
  web:
    volumes:
      - ./src:/app/src
    environment:
      - DEBUG=true
    command: ["npm", "run", "dev"]

Konfiguracja produkcyjna (docker-compose.prod.yml):

services:
  web:
    restart: always
    environment:
      - NODE_ENV=production
    command: ["npm", "run", "start"]

Uruchamianie z określoną konfiguracją:

# Środowisko deweloperskie (domyślne)
docker-compose up -d

# Środowisko produkcyjne
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Metoda 2: Zmienne środowiskowe

Używaj zmiennych środowiskowych w pliku docker-compose.yml do zmiany zachowania w zależności od środowiska:

version: '3'
services:
  web:
    image: myapp:${TAG:-latest}
    ports:
      - "${PORT:-3000}:3000"
    environment:
      - NODE_ENV=${NODE_ENV:-development}
      - API_KEY=${API_KEY}

Możesz ustawić te zmienne na kilka sposobów:

Bezpośrednio w linii poleceń:

PORT=8080 NODE_ENV=production docker-compose up -d

W pliku .env:

PORT=8080
NODE_ENV=production
TAG=v1.2.3
API_KEY=xxx

Używając różnych plików .env dla różnych środowisk:
```
docker-compose --env-file .env.prod up -d
```

Metoda 3: Kompozycja profilów

Docker Compose pozwala na definiowanie profilów, które można selektywnie aktywować:

version: '3.9'
services:
  app:
    image: myapp:latest

  db:
    image: postgres

  adminer:
    image: adminer
    profiles: ["debug"]

  redis:
    image: redis
    profiles: ["cache"]

Uruchamianie określonych profilów:

# Tylko podstawowe usługi
docker-compose up -d

# Z narzędziami debugowania
docker-compose --profile debug up -d

# Z cache
docker-compose --profile cache up -d

# Z oboma profilami
docker-compose --profile debug --profile cache up -d

✨ Pro Tip: Dla dużych projektów najlepszym podejściem jest połączenie wszystkich trzech metod - używaj wielu plików konfiguracyjnych dla głównych różnic między środowiskami, zmiennych środowiskowych dla drobnych ustawień i profilów dla opcjonalnych usług.

📈 Dobre praktyki Docker Compose

Przestrzeganie dobrych praktyk pomoże Ci tworzyć bardziej niezawodne, bezpieczne i łatwe w utrzymaniu projekty Docker Compose.

1. Organizacja plików projektu

Utrzymuj spójną strukturę plików:

projekt/
├── docker-compose.yml          # Konfiguracja główna
├── docker-compose.override.yml # Konfiguracja deweloperska
├── docker-compose.prod.yml     # Konfiguracja produkcyjna
├── .env.example                # Przykładowe zmienne środowiskowe 
├── .dockerignore               # Pliki ignorowane przez Docker
├── services/
│   ├── app/
│   │   ├── Dockerfile
│   │   └── src/
│   ├── db/
│   │   ├── Dockerfile
│   │   └── init/
│   └── nginx/
│       ├── Dockerfile
│       └── config/
└── volumes/                    # Lokalne dane trwałe (gitignored)
    ├── .gitkeep
    └── ...

2. Bezpieczeństwo

Nie przechowuj wrażliwych danych w repozytoriach - użyj .env (dodanego do .gitignore) lub zewnętrznych systemów zarządzania sekretami
Używaj tagów zamiast latest - zawsze określaj dokładne wersje obrazów
Ogranicz uprawnienia - użyj user aby uruchamiać kontenery jako nieuprzywilejowani użytkownicy
Ogranicz montowane wolumeny - montuj tylko niezbędne katalogi
Używaj sieci wewnętrznych - internal: true dla sieci, które nie potrzebują dostępu do internetu

Przykład:

services:
  app:
    image: myapp:1.2.3
    user: "1000:1000"
    volumes:
      - ./app/config:/app/config:ro  # tylko do odczytu

3. Wydajność i niezawodność

Ustaw ograniczenia zasobów - definiuj limity pamięci i CPU
Konfiguruj polityki restartu - używaj restart: unless-stopped lub restart: on-failure
Monitoruj stan kontenera - dodaj healthcheck do usług
Używaj wolumenów dla danych trwałych - nigdy nie przechowuj ważnych danych w samych kontenerach

services:
  app:
    image: myapp:1.2.3
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

4. Czytelność i utrzymanie

Używaj znaczących nazw dla usług, wolumenów i sieci
Grupuj powiązane elementy - usługi, które działają razem, powinny być blisko siebie w pliku
Dodawaj komentarze - wyjaśniaj nieoczywiste elementy
Używaj YAML anchors dla powtarzalnych fragmentów konfiguracji

# Bazowa konfiguracja dla wszystkich usług Node.js
x-node-defaults: &node-defaults
  restart: unless-stopped
  logging:
    driver: "json-file"
    options:
      max-size: "10m"
      max-file: "3"

services:
  # API serwis
  api:
    <<: *node-defaults
    build: ./api
    environment:
      - NODE_ENV=production

5. Przenośność i współpraca

Określaj wersje w pliku docker-compose.yml
Dodaj instrukcje w README.md jak używać projektu
Utwórz .env.example z przykładami wszystkich wymaganych zmiennych
Użyj Makefiles do uproszczenia typowych operacji:

.PHONY: up down restart logs clean

up:
    docker-compose up -d

down:
    docker-compose down

restart:
    docker-compose restart

logs:
    docker-compose logs -f

clean:
    docker-compose down -v --rmi local

✨ Pro Tip: Twórz swoje projekty Docker Compose tak, jakby miał je używać ktoś, kto nigdy wcześniej nie widział Twojego kodu. Dobra dokumentacja i czytelna struktura projektu są kluczowe dla długoterminowego utrzymania.

🚦 Zarządzanie zależnościami między usługami

W złożonych aplikacjach często mamy do czynienia z zależnościami - jedna usługa musi być gotowa przed uruchomieniem innej. Docker Compose oferuje kilka mechanizmów do zarządzania tymi zależnościami.

1. Dyrektywa depends_on

Najprostszym sposobem jest użycie depends_on, które określa kolejność uruchamiania usług:

services:
  web:
    image: nginx
    depends_on:
      - api
      - db

  api:
    image: my-api
    depends_on:
      - db

  db:
    image: postgres

W tym przykładzie:

Najpierw uruchomi się db
Po db, uruchomi się api
Po api i db, uruchomi się web

Uwaga: depends_on gwarantuje jedynie kolejność uruchamiania, ale nie czeka aż usługa będzie w pełni gotowa do pracy.

2. Oczekiwanie na gotowość usługi

Dla bardziej zaawansowanego oczekiwania na gotowość usługi, można użyć healthchecków:

services:
  web:
    image: nginx
    depends_on:
      db:
        condition: service_healthy
      api:
        condition: service_healthy

  api:
    image: my-api
    depends_on:
      db:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: postgres
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

W tym przykładzie:

web uruchomi się dopiero gdy db i api będą zdrowe według ich healthchecków
api uruchomi się dopiero gdy db będzie zdrowy

3. Skrypty pomocnicze

Czasami potrzebujesz bardziej złożonej logiki oczekiwania. Popularnym wzorcem jest użycie skryptu pomocniczego:

services:
  web:
    image: nginx
    depends_on:
      - api
    command: sh -c "wait-for api:8080 -t 60 -- nginx -g 'daemon off;'"
    volumes:
      - ./scripts/wait-for:/usr/local/bin/wait-for

  api:
    image: my-api
    depends_on:
      - db
    command: sh -c "wait-for db:5432 -t 60 -- node server.js"
    volumes:
      - ./scripts/wait-for:/usr/local/bin/wait-for

  db:
    image: postgres

Gdzie wait-for to skrypt sprawdzający dostępność usługi przed kontynuowaniem (można użyć gotowych skryptów jak wait-for-it.sh lub wait-for).

4. Inicjalizatory i migracje

Dla baz danych często potrzebujemy uruchomić migracje lub zainicjalizować dane. Można to zrobić poprzez oddzielną usługę:

services:
  app:
    image: myapp
    depends_on:
      - db
      - db-migrations

  db:
    image: postgres
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]

  db-migrations:
    image: myapp
    command: ["npm", "run", "migrate"]
    depends_on:
      db:
        condition: service_healthy
    profiles: ["setup"]

Uruchomienie:

# Najpierw uruchom migracje
docker-compose --profile setup up -d db-migrations

# Po zakończeniu migracji, uruchom aplikację
docker-compose up -d app

✨ Pro Tip: Jeśli masz bardzo złożone zależności, rozważ użycie narzędzi orkiestracji jak Kubernetes, które oferują bardziej zaawansowane mechanizmy zarządzania zależnościami i gotowością usług.

🔄 Typowe scenariusze użycia Docker Compose

Docker Compose świetnie sprawdza się w różnych scenariuszach. Oto kilka gotowych przykładów, które możesz zaadaptować do własnych potrzeb.

1. Stos WordPress z bazą danych

version: '3'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:5.7
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db_data:/var/lib/mysql

volumes:
  wordpress_data:
  db_data:

2. Aplikacja MERN Stack (MongoDB, Express, React, Node.js)

version: '3'

services:
  frontend:
    build: ./frontend
    ports:
      - "3000:3000"
    volumes:
      - ./frontend:/app
      - /app/node_modules
    environment:
      - REACT_APP_API_URL=http://localhost:5000/api
    depends_on:
      - backend

  backend:
    build: ./backend
    ports:
      - "5000:5000"
    volumes:
      - ./backend:/app
      - /app/node_modules
    environment:
      - MONGODB_URI=mongodb://db:27017/myapp
    depends_on:
      - db

  db:
    image: mongo:latest
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:

3. Usługa proxy z SSL (Nginx + Let's Encrypt)

version: '3'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/ssl:/etc/nginx/ssl
      - ./nginx/www:/var/www/html
      - certbot_webroot:/var/www/certbot
      - certbot_certs:/etc/letsencrypt
    depends_on:
      - app

  app:
    image: myapp:latest
    expose:
      - "3000"
    environment:
      - NODE_ENV=production

  certbot:
    image: certbot/certbot
    volumes:
      - certbot_webroot:/var/www/certbot
      - certbot_certs:/etc/letsencrypt
    command: certonly --webroot --webroot-path=/var/www/certbot --email your@email.com --agree-tos --no-eff-email -d example.com -d www.example.com

volumes:
  certbot_webroot:
  certbot_certs:

4. Stos monitoringu (Prometheus + Grafana)

version: '3'

services:
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    restart: unless-stopped

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=grafana
      - GF_USERS_ALLOW_SIGN_UP=false
    depends_on:
      - prometheus
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

5. Stos CI/CD (GitLab + GitLab Runner)

version: '3'

services:
  gitlab:
    image: gitlab/gitlab-ce:latest
    ports:
      - "80:80"
      - "443:443"
      - "22:22"
    volumes:
      - gitlab_config:/etc/gitlab
      - gitlab_logs:/var/log/gitlab
      - gitlab_data:/var/opt/gitlab
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'https://gitlab.example.com'
        gitlab_rails['gitlab_shell_ssh_port'] = 22
    restart: unless-stopped

  gitlab-runner:
    image: gitlab/gitlab-runner:latest
    volumes:
      - gitlab_runner_config:/etc/gitlab-runner
      - /var/run/docker.sock:/var/run/docker.sock
    restart: unless-stopped

volumes:
  gitlab_config:
  gitlab_logs:
  gitlab_data:
  gitlab_runner_config:

✨ Pro Tip: Te konfiguracje są punktem wyjścia i powinny być dostosowane do Twoich potrzeb. Zwróć szczególną uwagę na aspekty bezpieczeństwa, takie jak hasła i porty, gdy adaptujesz te przykłady do środowiska produkcyjnego.

❓ FAQ - Odpowiedzi na Twoje Pytania

Czy Docker Compose jest odpowiedni do środowisk produkcyjnych?
Docker Compose może być używany w mniejszych środowiskach produkcyjnych, ale dla większych wdrożeń lepszym wyborem są rozwiązania jak Kubernetes czy Docker Swarm. Compose jest idealny dla środowisk deweloperskich, testowych i demonstracyjnych.

Jak zarządzać sekretami w Docker Compose?
Najprostszym sposobem jest użycie plików .env, ale dla większego bezpieczeństwa warto użyć sekcji secrets w wersji 3.1+ lub zewnętrznego narzędzia do zarządzania sekretami.

Czy mogę używać Docker Compose z istniejącymi kontenerami?
Tak, możesz użyć external: true dla istniejących zasobów (sieci, wolumenów), a także odwołać się do zewnętrznych kontenerów poprzez zewnętrzne sieci.

Jak debugować problemy z Docker Compose?
Użyj docker-compose logs [usługa] aby sprawdzić logi, docker-compose ps aby zobaczyć status kontenerów, lub docker-compose config aby zobaczyć skompilowaną konfigurację po zastosowaniu wszystkich zmiennych środowiskowych.

Czy mogę używać Docker Compose razem z Dockerfiles?
Tak, możesz użyć opcji build zamiast image aby budować obrazy z Dockerfile w ramach tego samego projektu.

Jak zaktualizować kontenery bez przestojów?
Dla prostych aktualizacji użyj docker-compose up -d --no-deps --build [usługa]. Dla bardziej złożonych scenariuszy z wieloma instancjami, rozważ rozwiązania orkiestracyjne jak Kubernetes.

🏁 Podsumowanie - Twoja podróż z Docker Compose

Docker Compose znacząco upraszcza zarządzanie wielokontenerowymi aplikacjami, transformując złożone polecenia Docker w przejrzyste, deklaratywne pliki konfiguracyjne. Po przeczytaniu tego przewodnika powinieneś mieć solidne podstawy do:

Instalacji i konfiguracji Docker Compose na różnych systemach operacyjnych
Tworzenia plików docker-compose.yml dla własnych projektów
Zarządzania wieloma środowiskami (deweloperskim, testowym, produkcyjnym)
Definiowania zależności między usługami i poprawnej kolejności uruchamiania
Stosowania dobrych praktyk w tworzeniu konteneryzowanych aplikacji

Docker Compose jest idealnym narzędziem na początku Twojej podróży z konteneryzacją. Gdy Twoje potrzeby wzrosną, możesz z czasem przejść do bardziej zaawansowanych rozwiązań orkiestracyjnych jak Kubernetes, zabierając ze sobą zdobytą wiedzę o mikrousługach i kontenerach.

✅ Twoja Checklista Docker Compose:

🔍 Zainstaluj Docker i Docker Compose na swoim systemie
🔄 Utwórz podstawowy plik docker-compose.yml dla swojego projektu
🔒 Zastosuj dobre praktyki bezpieczeństwa, takie jak specyficzne wersje obrazów
🛡️ Skonfiguruj sieci i wolumeny odpowiednio do potrzeb aplikacji
📚 Zdefiniuj zależności między usługami używając depends_on i healthchecks
👁️ Ustaw odpowiednie ograniczenia zasobów i polityki restartu
🧪 Przetestuj swoją konfigurację w różnych środowiskach

🚀 Potrzebujesz profesjonalnego hostingu dla swoich aplikacji opartych o Dockera?

Sprawdź nasze usługi hostingowe VPS

Wydajne serwery VPS z pełną obsługą Dockera i Docker Compose, idealne do hostowania Twoich konteneryzowanych aplikacji.

Kategorie i tagi

Czy ten artykuł był pomocny?

Twoja strona WordPress działa wolno?

Sprawdź nasz hosting WordPress z ultraszybkimi dyskami NVMe i konfiguracją serwera zoptymalizowaną pod kątem wydajności. Doświadcz różnicy już dziś!

Sprawdź ofertę hostingu

30-dniowa gwarancja zwrotu pieniędzy

Wprowadzenie do zarządzania kontenerami Docker Compose - Przewodnik dla początkujących