Co to jest Docker Compose i po co go używać?

Question

Accepted Answer

**Docker Compose** to narzędzie do definiowania i uruchamiania **aplikacji wielokontenerowych** przy użyciu jednego pliku YAML. Zamiast ręcznie uruchamiać wiele poleceń `docker run`, opisujesz wszystkie swoje usługi (aplikacja, baza danych, cache) w pliku `docker-compose.yml` i uruchamiasz je razem jednym poleceniem.

## Problem, który rozwiązuje Compose

```text
A real app often has MULTIPLE containers: a web app + a database + a cache + ...
  → manually running each with docker run (ports, networks, volumes, env, dependencies)
    is tedious, error-prone, and hard to reproduce/share
→ Compose defines the WHOLE stack in one file → start it all with one command.
```

## Plik docker-compose.yml

```yaml
services:
  web:
    build: .                    # build from the local Dockerfile
    ports:
      - "3000:3000"             # map ports
    environment:
      - DATABASE_URL=postgres://db:5432/myapp
    depends_on:
      - db                       # start db before web
  db:
    image: postgres:16           # use a prebuilt image
    environment:
      - POSTGRES_PASSWORD=secret
    volumes:
      - dbdata:/var/lib/postgresql/data   # persist the database
volumes:
  dbdata:
```

Jeden plik definiuje wszystkie usługi, ich obrazy/buildy, porty, zmienne środowiskowe, wolumeny i zależności — a wszystkie one udostępniają sieć (mogą się do siebie zwracać po nazwie usługi, np. `db`).

## Uruchamianie stosu

```bash
docker compose up -d        # build and start ALL services (in the background)
docker compose ps           # list the running services
docker compose logs -f      # view logs from all services
docker compose down         # stop and remove everything
docker compose down -v      # also remove volumes
```

## Dlaczego to ważne

Zrozumienie Docker Compose jest cenne, ponieważ rzeczywiste aplikacje prawie zawsze obejmują **wiele kontenerów**, a Compose jest standardowym narzędziem do ich zarządzania, dlatego stanowi ważną wiedzę praktyczną.

Problem, który rozwiązuje, jest rzeczywisty: typowa aplikacja ma kilka usług (aplikacja webowa, baza danych, cache, być może kolejka wiadomości), a ręczne uruchamianie każdej z oddzielnymi poleceniami `docker run` — konfigurowanie portów, sieci, wolumenów, zmiennych środowiskowych i kolejności uruchamiania — jest żmudne, podatne na błędy i trudne do reprodukcji lub udostępnienia. **Compose** rozwiązuje ten problem przez zdefiniowanie **całego stosu wielokontenerowego w jednym deklaratywnym pliku YAML** i uruchomienie go wszystkiego jednym poleceniem (`docker compose up`), co sprawia, że aplikacje wielokontenerowe są łatwe do uruchamiania, reprodukcji i udostępniania.

Zrozumienie struktury `docker-compose.yml` (definiowanie usług z ich obrazami/buildami, portami, zmiennymi środowiskowymi, wolumenami i zależnościami, z automatyczną siecią i dostępnością usług po nazwie) oraz kluczowych poleceń (`up`, `down`, `ps`, `logs`) to praktyczna, codziennie stosowana wiedza dla programowania i uruchamiania aplikacji wielousługowych.

Compose jest szczególnie cenny dla **lokalnych środowisk deweloperskich** (uruchomienie aplikacji z jej bazą danych i zależnościami jednym poleceniem) i do deklaratywnego definiowania stosów aplikacyjnych.

Ponieważ rzeczywiste aplikacje typowo składają się z wielu kontenerów, a Docker Compose jest standardowym, powszechnie używanym narzędziem do ich definiowania i uruchamiania w prosty sposób (zastępując żmudną ręczną orchestrację jednym plikiem deklaratywnym i poleceniem), zrozumienie Docker Compose — tego, jaki problem rozwiązuje, struktury pliku compose i poleceń — jest cenną, często stosowaną wiedzą do pracy z aplikacjami wielokontenerowymi, niemal niezbędnym uzupełnieniem Docker dla każdej nietrywialnej aplikacji konteneryzowanej i wszechobecnym narzędziem w przepływach pracy deweloperskich.