Plik konfiguracyjny docker-compose.yml

Plik YAML, który pozwala uruchomić i skonfigurować całe środowisko dla aplikacji uruchamianych w Docker.
Poradnik: Plik konfiguracyjny docker-compose.yml

Wprowadzenie

Jeżeli planujesz uruchomić jakakolwiek aplikacje w modelu self-hosting na swoim domowym serwerze przy użyciu Dockera, to docker-compose.yml jest dokładnie tym miejscem, od którego wszystko się zaczyna. To tutaj definiujesz, co ma zostać uruchomione, w jaki sposób, z jakimi zależnościami oraz w jakim otoczeniu. Jeden plik pozwala opisać cala aplikacje — od serwera WWW, przez baze danych, aż po dodatkowe usługi — i uruchomić ja jednym poleceniem.

Plik docker-compose.yml to główny element każdego projektu opartego na Docker Compose. Jest to dokument zapisany w formacie YAML, który opisuje jak uruchamiać, konfigurować i łączyć ze sobą kontenery w ramach jednej aplikacji lub całego środowiska. To tutaj opisujesz, jakie obrazy mają zostać pobrane, jakie porty otwarte i jakie relacje zachodzą między poszczególnymi elementami systemu.

To właśnie w tym pliku definiujesz  jakie serwisy, obrazy, porty, wolumeny, sieci oraz zmienne środowiskowe, które decydują o tym, jak Twoja aplikacja zachowuje się po uruchomieniu.

W mniejszych projektach docker-compose.yml bywa krotki i czytelny, jednak wraz z rozwojem aplikacji bardzo szybko zaczyna rosnąc. Kilkadziesiąt, a czasem kilkaset linii konfiguracji to nic niezwykłego — zwłaszcza gdy projekt obsługuje bazę danych, cache, kolejki czy kilka środowisk uruchomieniowych.

Struktura i formatowanie YAML

Plik ten opiera się na specyficznej strukturze, która wymaga dużej precyzji. W przeciwieństwie do wielu innych formatów, YAML opiera się na wcięciach (spacjach), a nie na nawiasach.

Najważniejsze zasady

  • Wcięcia: Zawsze używaj spacji (zazwyczaj dwóch), nigdy tabulatora. Niepoprawne wcięcie sprawi, że cały plik będzie nieczytelny dla Dockera.
  • Dwukropki: Po każdym kluczu (np. image:) musi nastąpić spacja przed podaniem wartości.
  • Myślniki: Używamy ich do tworzenia list, na przykład przy definiowaniu wielu portów lub zmiennych środowiskowych.

Główne bloki pliku konfiguracyjnego

Każdy poprawnie skonstruowany plik Compose składa się z kilku kluczowych sekcji, które określają różne warstwy infrastruktury:

version: określa wersję formatu pliku. Odpowiada ona za to, jakie funkcje są dostępne. Obecnie najczęściej spotykana to "3.8" lub "3.9".

services: to najważniejsza część pliku. Pod tym kluczem wymieniasz wszystkie kontenery (np. bazę danych, aplikację backendową, panel administracyjny), które składają się na Twój projekt.

networks: opcjonalna sekcja na samym dole pliku, w której definiujesz niestandardowe sieci, aby na przykład odizolować bazę danych od publicznego internetu.

volumes: blok, w którym rejestrujesz nazwane wolumeny. Dzięki temu Docker wie, że ma zarezerwować miejsce na dysku, które nie zostanie wyczyszczone po usunięciu kontenera.

Dlaczego YAML?

Wybór formatu YAML nie jest przypadkowy. Został on stworzony tak, aby był czytelny dla człowieka (Human Friendly). Dzięki temu nawet osoba, która nie pisała danej konfiguracji, jest w stanie szybko zrozumieć, że np. usługa "db" korzysta z obrazu "postgres" i wystawia port "5432".

W kolejnych punktach przejdziemy przez każdą z tych sekcji linijka po linijce, abyś dokładnie wiedział, co wpisać w swoim pierwszym pliku konfiguracyjnym.

Wzorcowy plik YAML docker-compose.yml

Poniżej schemat wzorcowego pliku docker-compose.yml

YAML
version: "3.9"
services:
  <NAZWA_USLUGI>:
    # --- OBRAZ I URUCHAMIANIE ---
    image: <OBRAZ_Z_REJESTRU>:<TAG>
    container_name: <TWOJA_NAZWA_KONTENERA>
    restart: <OPCJA_RESTARTU>
    pull_policy: <POLITYKA_POBIERANIA>
    init: true

    # --- ŁĄCZNOŚĆ I SIECI ---
    ports:
      - "<PORT_HOSTA>:<PORT_KONTENERA>"
    expose:
      - "<PORT_TYLKO_DLA_SIECI_DOCKERA>"
    networks:
      <NAZWA_SIECI>:
        aliases:
          - <ALIAS_DNS>
    dns:
      - <ADRES_IP_DNS>
    extra_hosts:
      - "host.docker.internal:host-gateway"

    # --- KONFIGURACJA I SEKRETY ---
    environment:
      - <KLUCZ>=<WARTOSC>
    env_file:
      - <SCIEZKA_DO_PLIKU_ENV>
    secrets:
      - <NAZWA_SEKRETU>

    # --- DANE I PLIKI ---
    volumes:
      - <WOLUMEN>:<SCIEZKA_W_KONTENERZE>
      - <SCIEZKA_HOSTA>:<SCIEZKA_KONTENERA>:<OPCJA_DOSTEPU>
      - type: tmpfs
        target: <SCIEZKA_W_PAMIECI_RAM>

    # --- ZALEŻNOŚCI I KONTROLA STANU ---
    depends_on:
      <INNA_USLUGA>:
        condition: <WARUNEK_STARTU>

    healthcheck:
      test: [<KOMENDA_TESTUJACA>]
      interval: <CZAS>
      timeout: <CZAS>
      retries: <ILOSC_PROB>
      start_period: <CZAS_ROZRUCHU>

    # --- ZASOBY I LOGI ---
    deploy:
      resources:
        limits:
          cpus: '<WARTOSC>'
          memory: <WARTOSC>
        reservations:
          cpus: '<WARTOSC>'
          memory: <WARTOSC>
    logging:
      driver: "<STEROWNIK_LOGOW>"
      options:
        max-size: "<ROZMIAR>"
        max-file: "<ILOSC>"

networks:
  <NAZWA_SIECI>:
    driver: <TYP_STEROWNIKA>
    internal: <CZY_ODCIAC_INTERNET>
    name: <STALA_NAZWA_W_SYSTEMIE>

volumes:
  <WOLUMEN>:
    driver: local
    name: <STALA_NAZWA_W_SYSTEMIE>
  <INNY_WOLUMEN>:
    external: <CZY_ISTNIEJE_POZA_PLIKIEM>

secrets:
  <NAZWA_SEKRETU>:
    file: <SCIEZKA_DO_PLIKU_NA_DYSKU>

version:

To deklaracja wersji formatu pliku Compose. Wersja 3.9 jest jedną z najnowszych i najbardziej stabilnych w linii 3.x.

  • Co warto wiedzieć: W najnowszych wersjach narzędzia Docker Compose (V2, komenda docker compose bez myślnika), ten wpis jest opcjonalny, ale warto go zostawić dla jasności i kompatybilności ze starszymi systemami.

services:

To początek bloku, w którym definiujesz swoje kontenery. Każdy element pod tą sekcją będzie oddzielnym procesem.

<nazwa usługi>:

To wewnętrzny identyfikator w Twoim pliku.

  • Zastosowanie: Używasz tej nazwy, gdy chcesz, aby kontenery rozmawiały ze sobą. Jeśli nazwiesz bazę danych db, to Twoja aplikacja będzie się łączyć z hostem o nazwie db.
image:

image: <OBRAZ_Z_REJESTRU>:<TAG>

Wskazuje, jaki obraz ma zostać pobrany i uruchomiony.

  • Budowa: nazwa_obrazu:wersja (np. postgres:15.3).
  • Zasada działania: Docker najpierw szuka obrazu na Twoim komputerze. Jeśli go nie znajdzie, łączy się z rejestrem (domyślnie Docker Hub) i go pobiera.
  • Ważna uwaga: Zawsze unikaj tagu :latest. Jest on nieprzewidywalny. Lepiej wpisać konkretny numer wersji, aby Twoja aplikacja zawsze działała tak samo.
container_name:

container_name: <TWOJA_NAZWA_KONTENERA>

Pozwala nadać kontenerowi konkretną nazwę w systemie.

Warianty:

  • Jeśli podasz nazwę: Kontener będzie widoczny w docker ps jako np. moje_api.
  • Jeśli nie podasz: Docker sam wygeneruje nazwę według wzoru nazwa-projektu_nazwa-uslugi_numer (np. projekt_web_1).

Kiedy używać: Przydatne, gdy masz skrypty monitorujące, które szukają kontenera po konkretnej nazwie.

restart:

restart: <OPCJA_RESTARTU>

Definiuje zachowanie kontenera w sytuacjach awaryjnych lub po restarcie komputera.

Dostępne opcje:

  • no: (Domyślne) Jeśli kontener padnie, nie zostanie uruchomiony ponownie.
  • always: Docker zawsze spróbuje podnieść kontener. Nawet jeśli sam go wyłączysz, po restarcie usługi Docker kontener znów wystartuje.
  • on-failure: Restartuj tylko wtedy, gdy proces wewnątrz zakończył się błędem (kod wyjścia inny niż 0). Można ograniczyć liczbę prób: on-failure:5.
  • unless-stopped: Złoty standard. Restartuje kontener zawsze (nawet po restarcie całego serwera), chyba że użytkownik osobiście go zatrzymał komendą docker stop.
pull_policy:

pull_policy: <POLITYKA_POBIERANIA>

Określa, jak agresywnie Docker ma szukać nowych wersji obrazu w sieci.

Dostępne opcje:

  • always: Za każdym razem, gdy uruchamiasz up, Docker sprawdza w internecie, czy obraz pod Twoim tagiem się nie zmienił (nawet jeśli masz go już na dysku).
  • if_not_present: Pobiera obraz z sieci tylko wtedy, gdy nie masz go jeszcze w pamięci lokalnej.
  • never: Docker nigdy nie zagląda do internetu. Jeśli nie masz obrazu u siebie, wyrzuci błąd.
  • build: (Używane rzadziej przy gotowych obrazach) Wymusza budowanie z lokalnego pliku Dockerfile.
init:

init: true or false

To bardzo ważna, choć często pomijana opcja.

Co to robi: Docker uruchamia wewnątrz kontenera malutki proces "init" (zazwyczaj tini), który staje się procesem o numerze 1 (PID 1).

Dlaczego to ważne:

  • Sprzątanie: Wiele aplikacji nie potrafi poprawnie zarządzać "procesami zombie" (osieroconymi procesami podrzędnymi). init robi to za nie.
  • Sygnały: Kiedy wpiszesz docker stop, system wysyła sygnał SIGTERM. Wiele aplikacji go ignoruje. init przechwytuje ten sygnał i wymusza poprawne zamknięcie aplikacji, zamiast czekać 10 sekund i brutalnie ją zabijać.
ports:

To pole służy do tzw. publikowania portów. Tworzy ono "tunel" pomiędzy Twoim komputerem (hostem) a wnętrzem kontenera. Dzięki temu możesz uzyskać dostęp do aplikacji działającej w Dockerze za pomocą przeglądarki lub zewnętrznych narzędzi.

  • Składnia: "<PORT_HOSTA>:<PORT_KONTENERA>"
  • Zasada działania: Pierwsza wartość to port na Twoim fizycznym komputerze. Druga wartość to port, na którym aplikacja nasłuchuje wewnątrz kontenera.
  • Przykład: "8080:80" oznacza, że wpisując w przeglądarce localhost:8080, zostaniesz połączony z portem 80 w kontenerze.
  • Warianty:
    • "127.0.0.1:8080:80" – port będzie dostępny tylko dla Ciebie (bezpieczne).
    • "80" – Docker sam wybierze losowy, wolny port na Twoim komputerze i przypisze go do portu 80 kontenera.
expose:

W przeciwieństwie do ports, to pole nie udostępnia portu na zewnątrz dla Twojego komputera ani dla internetu. Służy ono wyłącznie do komunikacji wewnątrz wirtualnego świata Dockera.

  • Zastosowanie: Informuje inne kontenery w tej samej sieci, że dany kontener nasłuchuje na tych portach.
  • Bezpieczeństwo: To idealne rozwiązanie dla baz danych. Jeśli zadeklarujesz port w expose, Twoja aplikacja z nim pogada, ale nikt z internetu nie będzie mógł się włamać bezpośrednio do bazy, bo port nie jest "wystawiony" na Twoim komputerze.
networks:

Definiuje, do których sieci wirtualnych (zadeklarowanych na dole pliku w punkcie 6) ma należeć dany kontener. Pozwala to na logiczne grupowanie i izolowanie usług.

  • Izolacja: Kontenery w tej samej sieci widzą się nawzajem. Kontenery w różnych sieciach są dla siebie całkowicie niewidoczne, co zwiększa bezpieczeństwo.
  • Komunikacja po nazwie: Dzięki sieciom nie musisz znać adresów IP. Kontener o nazwie web połączy się z kontenerem db po prostu wpisując adres db.
aliases:

To dodatkowe, alternatywne nazwy DNS, pod którymi kontener jest dostępny dla innych członków tej samej sieci.

  • Zastosowanie: Jeśli Twoja usługa nazywa się produkcyjne-api-wersja-1, możesz nadać jej krótki alias api.
  • Wygoda: Inne kontenery mogą łączyć się pod prostym adresem http://api. Pozwala to na łatwą wymianę kontenerów bez konieczności zmiany ustawień w całym systemie.
dns:

Pozwala na ręczne wymuszenie konkretnych serwerów DNS dla kontenera, ignorując ustawienia Twojego domowego routera czy dostawcy internetu.

  • Przykład: 8.8.8.8 (Google) lub 1.1.1.1 (Cloudflare).
  • Kiedy używać: Gdy kontener ma problemy z połączeniem się z zewnętrznymi stronami lub gdy potrzebujesz specyficznego serwera do rozwiązywania nazw domenowych.
extra_hosts:

Pozwala ręcznie dodać wpisy do wirtualnego pliku /etc/hosts wewnątrz kontenera. Mapuje wybraną nazwę na konkretny adres IP.

  • Kluczowy wpis: "host.docker.internal:host-gateway"
  • Dlaczego to ważne: To specjalna flaga, która pozwala kontenerowi "zobaczyć" Twój główny komputer. Jest to niezbędne, jeśli kontener musi połączyć się z aplikacją lub bazą danych, która działa bezpośrednio na Twoim Windowsie/Linuxie, a nie w Dockerze.
environment:

To pole służy do bezpośredniego wstrzykiwania pojedynczych zmiennych środowiskowych do kontenera. Zmienne środowiskowe to podstawowy sposób na konfigurowanie aplikacji (np. ustawienie strefy czasowej, trybu pracy czy kluczy API).

  • Składnia: - <KLUCZ>=<WARTOSC> (np. - DEBUG=true)
  • Zasada działania: Docker tworzy te zmienne wewnątrz systemu operacyjnego kontenera. Aplikacja działająca w środku może je odczytać w dowolnym momencie.
  • Warianty:
    • Wpisanie na sztywno: - DB_PORT=5432 – wartość jest zawsze taka sama.
    • Pobranie z Twojego komputera: - API_KEY=${MY_LOCAL_KEY} – Docker pobierze wartość z Twojego systemu lub pliku .env na dysku.
  • Wada: Hasła wpisane tutaj są widoczne dla każdego, kto ma dostęp do pliku docker-compose.yml lub wpisze komendę docker inspect.
env_file:

To pole pozwala na zbiorcze wczytanie wielu zmiennych z zewnętrznego pliku (zazwyczaj o nazwie .env). Jest to znacznie czystsze rozwiązanie niż wpisywanie wszystkiego ręcznie w sekcji environment.

  • Składnia: - <SCIEZKA_DO_PLIKU_ENV> (np. - ./.env)
  • Dlaczego to lepsze:
    • Porządek: Zamiast pliku Compose, który ma 200 linii, masz krótki plik .env w formacie KLUCZ=WARTOSC.
    • Bezpieczeństwo: Plik .env możesz dodać do .gitignore, dzięki czemu Twoje prywatne klucze nie trafią do internetu (np. na GitHub), podczas gdy sam plik Compose pozostanie publiczny.
  • Ważne: Jeśli ta sama zmienna znajdzie się i w env_file, i w environment, to wartość z environment ma pierwszeństwo (nadpisuje tę z pliku).
Plik zmiennych (.env)

Plik zmiennych środowiskowych (.env)

Plik .env to zwykły plik tekstowy, który zazwyczaj znajduje się w tym samym folderze co docker-compose.yml. Docker Compose automatycznie wczytuje z niego wartości zmiennych.

Przykładowa zawartość pliku .env

Przykładowa zawartość pliku .env na potrzeby docker compose

Plaintext
# --- KONFIGURACJA OGOLNA ---
APP_PORT=8080
LOG_LEVEL=debug

# --- DANE BAZY DANYCH ---
DB_USER=admin
DB_NAME=moja_aplikacja

# --- LOKALNE SCIEZKI ---
DATA_PATH=./docker_data/db_files
    
Podstawowe zasady
  • Format: zawsze KLUCZ=WARTOSC
  • Nie używaj spacji wokół znaku =
  • Każda zmienna musi być w osobnej linii
  • Komentarze rozpoczynają się od znaku #
Spacje i cudzysłowy

Jeżeli wartość zawiera spacje, musi być ujęta w cudzysłowy:

Plaintext
NAZWA="moja wartosc"
NAZWA2='inna wartosc'
    
Rożnica miedzy " " a ' '

Podwójne cudzysłowy interpretują znaki specjalne oraz zmienne:

Plaintext
TEXT="linia1\nlinia2"
PATH_INFO="Sciezka: $HOME"
    

Pojedyncze apostrofy nie interpretują niczego:

Plaintext
TEXT='linia1\nlinia2'
PATH_INFO='$HOME'
    
Znaki specjalne i hasła

Jeżeli wartość zawiera znaki takie jak #, $, = lub spacje, zawsze używaj cudzysłowów:

Plaintext
DB_PASS='Super#Bezpieczne=Haslo$123'
    
Komentarze i znak #

Znak # poza cudzysłowami rozpoczyna komentarz:

Plaintext
PORT=8080 # port aplikacji
PASSWORD="abc#123"
    
Dobre praktyki
  • Hasła zapisuj w pojedynczych apostrofach
  • Nie commituj pliku .env do repozytorium
  • Dodaj .env do .gitignore
  • Używaj ${NAZWA_ZMIENNEJ} w docker-compose.yml
Użycie zmiennych z pliku .env

Docker Compose automatycznie wczytuje zmienne z pliku .env i pozwala używać ich w pliku docker-compose.yml za pomocą składni ${NAZWA_ZMIENNEJ}. Najczęściej spotkasz to w sekcji environment.

Format listy
YAML
environment:
  - DB_USER=${DB_USER}
  - DB_NAME=${DB_NAME}
    

Jest to składnia listy, często spotykana w prostszych plikach Compose. Każda linia mapuje zmienna kontenera na wartość pobrana z pliku .env.

Format mapy (zalecany)
YAML
environment:
  DB_USER: ${DB_USER}
  DB_NAME: ${DB_NAME}
    

Ten zapis jest bardziej czytelny, łatwiejszy do rozbudowy i polecany w większych projektach.

Brak zmiennej / niezdefiniowana

Jeżeli odwołujesz się do zmiennej, która nie została zdefiniowana w pliku .env ani w zmiennych środowiskowych systemu, Docker Compose wstawi pusty string.

YAML
${VAR}
    

Może to prowadzić do trudnych do wykrycia błędów, np. pustych haseł lub nazw hostów.

Wartości domyślne (fallback)

Aby zabezpieczyć się przed brakiem zmiennej, możesz zdefiniować wartość domyślna:

YAML
${VAR:-domyslna}
    

Jeżeli VAR nie istnieje lub jest pusta, Compose użyje wartości domyślna. Jest to dobra praktyka zwłaszcza dla portów, trybów pracy aplikacji oraz nazw środowisk.

secrets:

To najbezpieczniejszy sposób przekazywania wrażliwych danych, takich jak hasła do baz danych, klucze prywatne czy certyfikaty SSL.

  • Zasada działania: W przeciwieństwie do zmiennych środowiskowych, sekrety nie są "widoczne" w systemie jako tekst. Docker bierze plik wskazany w punkcie 6 na dole projektu i montuje go wewnątrz kontenera jako tymczasowy, wirtualny plik.
  • Gdzie ich szukać: Domyślnie każdy sekret znajdziesz w kontenerze pod ścieżką: /run/secrets/<NAZWA_SEKRETU>.
  • Zalety:
    • Brak śladów: Hasło nie pojawia się w logach, nie da się go podejrzeć komendami inspekcji.
    • Bezpieczny odczyt: Aplikacja musi zostać zaprogramowana tak, aby zamiast zmiennej PASSWORD, odczytała treść pliku w systemie plików kontenera.
    • Kontrola dostępu: Tylko konkretne usługi, którym nadasz dostęp w tej sekcji, będą widziały dany sekret.
Plik sekretu

Plik sekretu np. db_password.txt

W sekcji secrets wspomnieliśmy o plikach haseł. Musisz stworzyć taki plik fizycznie na dysku.

Plaintext
SuperTajneHaslo123!

Opis pliku sekretu:

Zawartość: Tylko samo hasło, bez żadnych dodatkowych znaków czy nazw zmiennych.

Zastosowanie w Docker Compose

W Docker Compose wskazujesz go w następujący sposób:

YAML
secrets:
db_password:
file: ./db_password.txt/pre>

W kontenerze: Aplikacja odczyta to hasło z pliku /run/secrets/db_password.

volumes:

volumes: Wolumeny i Mapowanie

W Dockerze kontenery są z natury "tymczasowe" – jeśli skasujesz kontener bez wolumenu, wszystkie dane wewnątrz (np. nowa baza danych czy przesłane zdjęcia) znikną na zawsze. Wolumeny to "zewnętrzne dyski", które ratują Twoje dane.

Nazwany wolumen

Nazwany wolumen (Named Volume)

Składnia: - <WOLUMEN>:<SCIEZKA_W_KONTENERZE>

  • Zasada działania: Używasz tu nazwy, którą zadeklarowałeś na samym dole pliku (w punkcie 6). Docker sam tworzy specjalny folder w swoich plikach systemowych i podpina go pod wskazaną ścieżkę w kontenerze.
  • Dlaczego warto go używać:
    • To najbezpieczniejszy sposób na bazy danych (np. MySQL, PostgreSQL).
    • Nie musisz martwić się o uprawnienia do plików (Docker zarządza nimi automatycznie).
    • Dane zostają na dysku, dopóki celowo nie usuniesz wolumenu komendą docker volume rm.
Mapowanie folderu

Mapowanie folderu (Bind Mount)

Składnia: - <SCIEZKA_HOSTA>:<SCIEZKA_KONTENERA>:<OPCJA_DOSTEPU>

  • Zasada działania: Bezpośrednio łączysz folder na Twoim komputerze (np. ./moje_pliki) z folderem wewnątrz kontenera.
  • Opcje dostępu:
    • rw (Read-Write): Domyślne. Kontener może czytać i zmieniać pliki w Twoim folderze.
    • ro (Read-Only): Kontener może tylko czytać pliki. Nie może ich usunąć ani edytować. Super bezpieczne dla plików konfiguracyjnych!
  • Dlaczego warto go używać:
    • Idealne, gdy chcesz edytować kod strony na swoim komputerze i od razu widzieć zmiany w działającym kontenerze.
    • Pozwala na łatwe podrzucenie kontenerowi gotowych plików konfiguracyjnych.
Folder w pamięci RAM

type: tmpfs (Folder w pamięci RAM)

To specjalny rodzaj montowania, który nie zapisuje niczego na dysku twardym, ale tworzy wirtualny folder w pamięci operacyjnej RAM Twojego komputera.

  • Składnia:
    type: tmpfs target: <SCIEZKA_W_PAMIECI_RAM>
  • Zasada działania: Wszystko, co zostanie tam zapisane, jest przechowywane w RAM-ie. Po zatrzymaniu kontenera te dane znikają bezpowrotnie.
  • Zalety:
    • Ekstremalna szybkość: Odczyt i zapis są tysiące razy szybsze niż na dysku SSD.
    • Bezpieczeństwo: Jeśli przechowujesz tam pliki tymczasowe, nie zostawiają one śladu na dysku.
    • Oszczędność dysku: Idealne na foldery /tmp lub pliki typu cache, które i tak nie muszą przetrwać restartu.
depends_on:

Zależności między usługami. W złożonych systemach kolejność ma znaczenie – nie chcesz, aby aplikacja próbowała połączyć się z bazą danych, która jeszcze się nie uruchomiła. depends_on służy do ustalania hierarchii startu.

  • <INNA_USLUGA>: To nazwa usługi (z sekcji services), na którą Twój kontener musi poczekać.
  • condition: <WARUNEK_STARTU>: To najważniejszy element, który określa, na jakim etapie musi być "sąsiad", aby Twój kontener ruszył.

Dostępne warianty warunków (condition):

  • service_started: (Podstawowy) Docker uruchomi Twój kontener natychmiast po tym, jak wyda komendę startu dla sąsiada. Nie sprawdza, czy sąsiad faktycznie już działa – wystarczy, że proces ruszył.
  • service_healthy: (Zalecany) Twój kontener poczeka, aż sąsiad przejdzie pomyślnie swój własny healthcheck. To daje pewność, że np. baza danych jest już w pełni gotowa do przyjmowania połączeń.
  • service_completed_successfully: Twój kontener poczeka, aż sąsiad wykona swoje zadanie i sam się wyłączy (idealne dla kontenerów wykonujących jednorazowe migracje danych lub konfigurację wstępną).
healthcheck:

Sam fakt, że kontener ma status "Running" (działa), nie oznacza, że aplikacja w środku nie zawisła. healthcheck to instrukcja dla Dockera, jak ma sprawdzać "zdrowie" programu.

  • test: [<KOMENDA_TESTUJACA>]: Polecenie wykonywane wewnątrz kontenera.
    • Przykład dla bazy: ["CMD", "pg_isready", "-U", "user"]
    • Przykład dla WWW: ["CMD", "curl", "-f", "http://localhost"]
    • Jeśli komenda zwróci sukces (kod 0), kontener jest "healthy" (zdrowy). Jeśli błąd – "unhealthy".
  • interval: <CZAS>: Jak często Docker ma powtarzać badanie (np. 30s). Zbyt częste testy mogą obciążyć procesor, zbyt rzadkie sprawią, że późno dowiesz się o awarii.
  • timeout: <CZAS>: Jak długo Docker ma czekać na odpowiedź z testu (np. 10s). Jeśli komenda testująca będzie trwać dłużej, zostanie uznana za nieudaną.
  • retries: <ILOSC_PROB>: Ile razy z rzędu test musi się nie udać, aby Docker oficjalnie uznał kontener za "unhealthy" (zepsuty). Zazwyczaj ustawia się 3 lub 5, aby uniknąć fałszywych alarmów.
  • start_period: <CZAS_ROZRUCHU>: (Bardzo ważne!) Czas na "rozgrzewkę" aplikacji (np. 20s). Podczas tego czasu testy są wykonywane, ale ich niepowodzenia nie są liczone do limitu retries.
deploy i resources:

deploy i resources: (Limity i rezerwacje mocy)

Ta sekcja odpowiada za zarządzanie zasobami fizycznymi Twojego serwera (procesor i RAM). Jest to kluczowe, gdy uruchamiasz wiele usług jednocześnie.

limits:

limits (granica nie do przekroczenia)

Określa maksymalną ilość zasobów, jaką kontener może „pożreć”. Jeśli kontener spróbuje wziąć więcej, Docker go ograniczy.

  • cpus: Maksymalna moc procesora.
    • Przykład: '0.5' oznacza połowę jednego rdzenia. '2.0' oznacza dwa pełne rdzenie.
  • memory: Maksymalna ilość pamięci RAM.
    • Przykład: 512M lub 1G.
    • Uwaga: Jeśli kontener przekroczy limit pamięci RAM, system go zabije (tzw. błąd OOM - Out Of Memory). Dlatego ustawiaj ten limit z lekkim zapasem.
reservations:

reservations (gwarantowane minimum)

Mówi Dockerowi: „Nie uruchamiaj tego kontenera, jeśli nie możesz zagwarantować mu tyle wolnych zasobów”.

  • Zastosowanie: Dzięki temu masz pewność, że np. baza danych zawsze będzie miała swoje 256MB RAM-u do sprawnego działania, a inne (mniej ważne) kontenery jej tego nie zabiorą.
logging:

logging: (Zarządzanie dziennikami zdarzeń)

Każdy kontener zapisuje to, co wypisuje w swojej konsoli (logi). Jeśli o to nie zadbasz, po kilku miesiącach plik z logami może urosnąć do kilkuset gigabajtów i całkowicie zapchać Twój dysk twardy.

driver:

driver: (Sterownik logów)

Określa, w jakim formacie i gdzie Docker ma zapisywać logi.

  • "json-file": (Standard) Logi są zapisywane jako pliki tekstowe na Twoim dysku. To najczęstszy wybór dla początkujących.
  • "syslog" / "fluentd": Używane w wielkich firmach do wysyłania logów na zewnętrzne serwery.
options:

options: (Ustawienia miejsca na dysku)

To tutaj dzieje się „magia”, która chroni Twój dysk przed zapchaniem:

  • max-size: Maksymalna wielkość pojedynczego pliku z logami (np. "10mb"). Gdy plik osiągnie tę wagę, Docker zaczyna pisać w nowym pliku.
  • max-file: Maksymalna liczba archiwalnych plików, które Docker ma trzymać (np. "3").
    • Przykład w praktyce: Jeśli ustawisz 10mb i 3 pliki, Docker nigdy nie zużyje więcej niż 30MB na logi tej usługi. Gdy powstanie czwarty plik, najstarszy zostanie automatycznie skasowany.

networks:

networks: (Zarządzanie siecią wirtualną)

Tutaj budujesz infrastrukturę, która pozwala Twoim kontenerom "rozmawiać" ze sobą.

driver:

driver: <TYP_STEROWNIKA>

Określa, jak sieć ma działać pod spodem.

  • bridge: (Standard) Najczęstszy wybór. Tworzy prywatną sieć wewnątrz Twojego komputera. Kontenery mogą się w niej komunikować po nazwach.
  • host: Usuwa izolację – kontener używa sieci Twojego komputera bezpośrednio (bardzo szybkie, ale mniej bezpieczne).
  • overlay: Używane, gdy kontenery działają na wielu różnych serwerach fizycznych jednocześnie (Docker Swarm).

internal:

Ustawienie widoczność kontenerów

  • true: Kontenery w tej sieci widzą się nawzajem, ale mają całkowity zakaz wyjścia do internetu. Nikt z zewnątrz też ich nie zobaczy. Idealne dla baz danych.
  • false: (Domyślne) Kontenery mają dostęp do świata zewnętrznego.

name:

name: <STALA_NAZWA_W_SYSTEMIE>:

Pozwala nadać sieci konkretną nazwę (np. produkcyjna_siec). Bez tego Docker sam wygeneruje nazwę typu folder_default.

volumes:

volumes: (Zarządzanie dyskami twardymi)

Tutaj definiujesz nazwane magazyny danych, które mają przetrwać nawet wtedy, gdy całkowicie skasujesz i od nowa uruchomisz projekt.

driver: local:

Mówi Dockerowi, że dane mają być składowane na dysku twardym Twojego komputera (w specjalnym folderze systemowym Dockera). Jest to najbardziej stabilna opcja.

name:

name: <STALA_NAZWA_W_SYSTEMIE>:

Podobnie jak w sieciach, nadaje wolumenowi stałą nazwę widoczną w systemie (np. po wpisaniu docker volume ls).

external:

external: <CZY_ISTNIEJE_POZA_PLIKIEM>:

  • false: (Domyślne) Docker sam stworzy ten wolumen przy pierwszym uruchomieniu projektu.
  • true: Mówi Dockerowi: "Ten wolumen już istnieje na komputerze (stworzyłem go wcześniej ręcznie), po prostu się do niego podepnij".

secrets:

To specjalny mechanizm do bezpiecznego przekazywania haseł i kluczy, o którym wspominaliśmy wcześniej.

file: <SCIEZKA_DO_PLIKU_NA_DYSKU>:

Tu wskazujesz ścieżkę do zwykłego pliku tekstowego na Twoim komputerze (np. ./haslo_bazy.txt), w którym zapisałeś tajne hasło.

Zasada działania: Docker odczytuje ten plik i "wstrzykuje" go do pamięci RAM kontenera jako plik tymczasowy. Dzięki temu hasło nigdy nie jest przesyłane jako tekst jawny w zmiennych środowiskowych, co chroni Cię przed wyciekiem danych.

Struktura folderów projektu

Aby wszystko działało, Twoja struktura plików na komputerze powinna wyglądać mniej więcej tak:

Plaintext
moj_projekt/
├── docker-compose.yml      # Główny plik konfiguracyjny
├── .env                    # Zmienne środowiskowe
├── db_password.txt         # Plik z tajnym hasłem (sekret)
└── folder_config/          # Folder do zmapowania (bind mount)
└── default.conf            # Twoja konfiguracja serwera

Kategoria: Usługi | Autor: Rafał Wójcik
Utworzono: 2025-10-22 14:54 | Ostatnia edycja: 2026-04-07 15:52

Pytania & Komentarze

Brak komentarzy. Bądź pierwszy!

Dodaj nowy komentarz