Definiowanie wieloserwisowego środowiska

1. Wprowadzenie

Nowoczesne aplikacje internetowe coraz częściej wykorzystują architekturę wieloserwisową (multi-service) — czyli taką, w której różne komponenty aplikacji działają w osobnych kontenerach Dockera, ale razem tworzą spójny system.

Typowy przykład to:

  • Frontend — aplikacja Angular, odpowiadająca za interfejs użytkownika,
  • Backend (API) — aplikacja Flask (Python) lub Node.js,
  • Baza danych — np. PostgreSQL lub MySQL.

Każda z tych części ma swoje zależności i środowisko uruchomieniowe, ale dzięki Docker Compose możemy nimi zarządzać w sposób prosty i zautomatyzowany.

2. Czym jest środowisko wieloserwisowe

Środowisko wieloserwisowe pozwala zdefiniować i uruchomić kilka usług (kontenerów) w jednym pliku konfiguracyjnym docker-compose.yml. Każda usługa jest niezależna, ale może współdzielić:

  • sieć (network) — umożliwiając komunikację między kontenerami po nazwach usług,
  • wolumeny (volumes) — zapewniające trwałość danych, nawet po restarcie.

Takie podejście pozwala:

  • szybciej uruchamiać środowisko deweloperskie,
  • zachować powtarzalność konfiguracji między zespołami,
  • skalować i wymieniać poszczególne komponenty bez wpływu na całość.

3. Struktura projektu

Poniższy przykład przedstawia kompletny projekt zawierający:

  • backend (Flask) – serwer API,
  • frontend (Angular) – aplikację użytkownika,
  • baza danych (PostgreSQL) – trwałe przechowywanie danych.

Struktura katalogów:

projekt/
│
├── backend/
│   ├── app.py
│   ├── requirements.txt
│   └── Dockerfile
│
├── frontend/
│   ├── package.json
│   ├── src/
│   └── Dockerfile
│
└── docker-compose.yml

4. Definicja poszczególnych usług

4.1 Backend – Flask (Python)

backend/Dockerfile:

backend/app.py:

backend/requirements.txt:

flask
psycopg2-binary

4.2 Frontend – Angular

frontend/Dockerfile:

frontend/package.json (fragment):

4.3 Baza danych – PostgreSQL

Nie wymaga własnego Dockerfile. Używamy gotowego obrazu: postgres:15.

5. Tworzenie pliku docker-compose.yml

Poniżej znajduje się kompletny plik Compose definiujący środowisko z trzema usługami.

6. Omówienie konfiguracji

Sekcja Opis
services Definiuje wszystkie usługi: backend, baza danych i frontend.
build Dla backendu i frontendu wskazuje katalog z plikiem Dockerfile.
image Dla bazy danych używa gotowego obrazu postgres:15.
ports Udostępnia porty aplikacji na hoście (4200 dla frontendu, 5000 dla backendu).
environment Przekazuje konfiguracje, np. dane logowania do bazy.
depends_on Zapewnia odpowiednią kolejność uruchamiania usług (backend czeka na bazę, frontend na backend).
volumes Utrwala dane PostgreSQL w wolumenie postgres_data.
networks Wszystkie kontenery działają we wspólnej sieci app-network, dzięki czemu komunikują się po nazwach usług (db, backend, frontend).

7. Ustawianie sieci i wolumenów w Docker Compose

7.1 Sieci (networks)

Docker Compose automatycznie tworzy domyślną sieć typu bridge, ale możemy ją też definiować samodzielnie.

W przykładzie:

  • Sieć bridge działa lokalnie i łączy kontenery w ramach jednego hosta.
  • Dzięki niej kontenery mogą się komunikować po nazwach usług — np. backend łączy się z bazą po adresie db:5432.

Inne możliwe typy sieci:

Typ Opis
bridge Domyślny typ, dobra dla większości projektów.
host Kontener korzysta bezpośrednio z sieci hosta (bez izolacji).
overlay Umożliwia komunikację kontenerów działających na różnych hostach (np. w Docker Swarm).

7.2 Wolumeny (volumes)

Wolumeny pozwalają utrwalać dane poza cyklem życia kontenera. Jeśli usuniesz kontener z bazą, dane w wolumenie nadal pozostaną.

W pliku:

  • Tworzy trwały wolumen o nazwie postgres_data.
  • Jest używany przez serwis db:

yaml volumes: - postgres_data:/var/lib/postgresql/data * Dane z katalogu /var/lib/postgresql/data (gdzie PostgreSQL przechowuje bazy) zostaną zapisane na dysku hosta.

Możesz sprawdzić istniejące wolumeny:

I usunąć nieużywane:

8. Uruchamianie środowiska

Uruchom cały zestaw usług jednym poleceniem:

Docker Compose:

  1. Zbuduje obrazy dla backendu i frontendu,
  2. Pobierze obraz PostgreSQL,
  3. Utworzy sieć app-network i wolumen postgres_data,
  4. Uruchomi wszystkie kontenery we właściwej kolejności.

9. Sprawdzanie i monitorowanie

Lista uruchomionych kontenerów:

Podgląd logów:

Zatrzymanie środowiska:

Po zatrzymaniu dane w bazie wciąż pozostaną, dzięki wolumenowi.

10. Dalsze rozszerzenia

Możesz rozbudować środowisko o:

  • pgAdmin – graficzny interfejs do zarządzania bazą danych,
  • Nginx reverse proxy – do obsługi ruchu między frontendem a backendem,
  • Redis – pamięć cache dla backendu,
  • Testy integracyjne w kontenerach (np. Postman CLI, Newman).

Przykład dodania pgAdmin:

Dostęp: http://localhost:8080

11. Dobre praktyki

  • Trzymaj wrażliwe dane (np. hasła, porty) w pliku .env.
  • Określ konkretne wersje obrazów (np. postgres:15.2, node:20.10-alpine).
  • Używaj nazw usług zamiast adresów IP w komunikacji między kontenerami.
  • Regularnie usuwaj nieużywane wolumeny i obrazy (docker system prune).
  • Wersjonuj docker-compose.yml w repozytorium — to dokumentacja środowiska.

12. Podsumowanie

W tej lekcji nauczyłeś się, jak:

  • zdefiniować wieloserwisowe środowisko składające się z backendu, frontendu (Angular) i bazy danych (PostgreSQL),
  • skonfigurować zależności między serwisami (depends_on),
  • ustawić sieć i wolumeny w Docker Compose,
  • uruchomić cały system jednym poleceniem (docker-compose up -d).

Dzięki temu podejściu zyskujesz w pełni przenośne, spójne i łatwe do zarządzania środowisko, które możesz wdrożyć zarówno lokalnie, jak i w chmurze — z zachowaniem identycznych ustawień dla całego zespołu.

Wróć do spisu lekcji