Docker – czym jest, jak korzystać z kontenerów i obrazów?

Docker to jedno z najpopularniejszych narzędzi wykorzystywanych podczas tworzenia, testowania i wdrażania aplikacji. Dzięki konteneryzacji pozwala uruchamiać oprogramowanie w izolowanych środowiskach, eliminując wiele problemów związanych z różnicami w konfiguracji systemów.

W artykule wyjaśniono, czym jest Docker, jak działają obrazy i kontenery oraz czym różnią się od tradycyjnych maszyn wirtualnych. Przedstawiono również najważniejsze polecenia Dockera, tworzenie własnych obrazów za pomocą Dockerfile, zarządzanie sieciami i wolumenami oraz wykorzystanie Docker Compose do uruchamiania aplikacji Spring Boot wraz z bazą danych PostgreSQL.

Czym jest Docker?

Docker to platforma umożliwiająca tworzenie, uruchamianie i zarządzanie aplikacjami w izolowanych środowiskach nazywanych kontenerami (containers).

Kontener pozwala uruchomić aplikację wraz z jej zależnościami, bibliotekami i konfiguracją w przewidywalnym środowisku. Dzięki temu aplikacja może działać w taki sam sposób na komputerze programisty, serwerze testowym czy środowisku produkcyjnym, o ile zapewniona jest zgodność platformy i konfiguracji.

Jakie problemy rozwiązuje Docker?

Jednym z najczęstszych problemów podczas tworzenia oprogramowania są różnice pomiędzy środowiskami uruchomieniowymi.

Przykładowo aplikacja napisana w Javie może wymagać:

  • JDK w określonej wersji,
  • odpowiednich bibliotek i zależności,
  • określonej konfiguracji środowiska,
  • dostępu do dodatkowych usług, np. PostgreSQL lub Redis.

Tradycyjne podejście wymaga instalowania i konfigurowania tych elementów bezpośrednio na komputerze lub serwerze. Może to prowadzić do konfliktów wersji, problemów z konfiguracją i sytuacji, w której aplikacja działa lokalnie, ale nie uruchamia się na innym środowisku.

Docker rozwiązuje ten problem poprzez konteneryzację (containerization), czyli uruchamianie aplikacji w odizolowanych środowiskach tworzonych na podstawie przygotowanych wcześniej obrazów.

Najważniejsze zalety Dockera

  • Przenośność – ten sam obraz może zostać wykorzystany w różnych środowiskach obsługujących odpowiednią platformę kontenerową.
  • Izolacja – aplikacje działają w oddzielnych kontenerach, co ogranicza konflikty pomiędzy ich zależnościami.
  • Powtarzalność – kontenery można wielokrotnie tworzyć na podstawie tego samego obrazu.
  • Szybkość uruchamiania – kontenery zazwyczaj uruchamiają się szybciej niż tradycyjne maszyny wirtualne.
  • Efektywne wykorzystanie zasobów – kontenery współdzielą jądro systemu operacyjnego, dzięki czemu nie wymagają uruchamiania osobnego systemu dla każdej aplikacji.

Docker jest powszechnie wykorzystywany podczas tworzenia i testowania oprogramowania, wdrażania aplikacji oraz budowania architektury mikroserwisowej.

Kontenery a maszyny wirtualne

Zarówno kontenery, jak i maszyny wirtualne umożliwiają uruchamianie aplikacji w odizolowanych środowiskach. Różnią się jednak sposobem wykorzystania zasobów systemowych oraz poziomem izolacji.

Maszyny wirtualne (Virtual Machines)

Maszyna wirtualna (VM) to środowisko emulujące działanie fizycznego komputera. Każda maszyna wirtualna posiada własny system operacyjny, biblioteki oraz aplikacje.

Za zarządzanie maszynami wirtualnymi odpowiada hiperwizor (hypervisor), np. VMware ESXi, Hyper-V lub KVM.

Uruchomienie kilku maszyn wirtualnych oznacza konieczność uruchomienia kilku niezależnych systemów operacyjnych, co wiąże się z większym zużyciem pamięci RAM, przestrzeni dyskowej oraz zasobów procesora. Wynika to z faktu, że maszyny wirtualne nie współdzielą między sobią zasobów.

Kontenery (Containers)

Kontenery działają inaczej. Zamiast uruchamiać osobny system operacyjny dla każdej aplikacji, współdzielą jądro systemu operacyjnego hosta.

Każdy kontener posiada własną przestrzeń procesów, system plików oraz konfigurację sieciową, ale korzysta ze wspólnego jądra systemowego.

Izolacja kontenerów w systemie Linux opiera się przede wszystkim na mechanizmach:

  • Namespaces – zapewniają izolację procesów, sieci i innych zasobów systemowych.
  • Control Groups (cgroups) – umożliwiają kontrolowanie i ograniczanie wykorzystania zasobów, takich jak CPU czy pamięć RAM.

Dzięki temu kontenery są zazwyczaj lżejsze i uruchamiają się szybciej niż maszyny wirtualne.

Warto zaznaczyć, że Docker Desktop na Windows i macOS wykorzystuje maszynę wirtualną z systemem Linux do uruchamiania kontenerów linuksowych.

Najważniejsze różnice

CechaMaszyna wirtualnaKontener
System operacyjnyWłasny system operacyjnyWspółdzielone jądro systemu
IzolacjaNa poziomie maszyny wirtualnejNa poziomie procesów
Zużycie zasobówZazwyczaj większeZazwyczaj mniejsze
Czas uruchamianiaZwykle dłuższyZwykle krótszy
RozmiarZwykle liczony w GBCzęsto MB lub GB
PrzenośnośćZależna od platformy wirtualizacjiZależna od architektury i zgodności systemowej

Kiedy korzystać z kontenerów, a kiedy z maszyn wirtualnych?

Kontenery sprawdzają się szczególnie dobrze podczas tworzenia mikroserwisów, uruchamiania środowisk testowych oraz wdrażania aplikacji w procesach CI/CD.

Maszyny wirtualne są natomiast przydatne, gdy wymagane jest uruchomienie różnych systemów operacyjnych, silniejsza izolacja na poziomie systemowym lub pełna kontrola nad własnym jądrem systemu operacyjnego.

Obie technologie mogą również współpracować – w środowiskach chmurowych kontenery często uruchamiane są wewnątrz maszyn wirtualnych.

Architektura Dockera

Docker wykorzystuje architekturę klient-serwer (client-server), w której klient komunikuje się z usługą odpowiedzialną za tworzenie, uruchamianie i zarządzanie kontenerami.

Najważniejsze elementy architektury Dockera to Docker Engine, Docker Client, Docker Daemon oraz Docker Registry.

Docker Engine

Docker Engine to główny komponent Dockera odpowiedzialny za obsługę kontenerów. Działa w architekturze klient-serwer i składa się z trzech podstawowych elementów:

  • Docker Daemon – usługa zarządzająca kontenerami, obrazami, sieciami i wolumenami.
  • REST API – interfejs umożliwiający komunikację z Docker Daemon.
  • Docker CLI – narzędzie wiersza poleceń pozwalające użytkownikowi zarządzać Dockerem.

Docker Client

Docker Client to narzędzie umożliwiające komunikację z Docker Daemon. Najczęściej wykorzystywanym klientem jest Docker CLI, udostępniający polecenie docker.

Przykładowo:

docker ps

Polecenie wyświetla listę aktualnie uruchomionych kontenerów.

Docker Client nie zarządza kontenerami bezpośrednio. Wysyła żądania do Docker Daemon za pośrednictwem REST API.

Docker Daemon

Docker Daemon (dockerd) to proces działający w tle, który odpowiada za faktyczne wykonywanie operacji związanych z kontenerami.

Do jego najważniejszych zadań należą:

  • Tworzenie, uruchamianie i zatrzymywanie kontenerów.
  • Zarządzanie obrazami Dockera.
  • Konfigurowanie sieci kontenerów.
  • Zarządzanie wolumenami i przechowywaniem danych.

Docker Client i Docker Daemon mogą działać na tym samym komputerze lub komunikować się zdalnie.

Docker Registry i Docker Hub

Docker Registry to repozytorium służące do przechowywania i udostępniania obrazów Dockera. Możesz je rozumieć jako specjalne artefatory, podobne do maven central, ale takie, które przechowuje obrazy dockera a nie biblioteki do Javy.

Najpopularniejszym publicznym rejestrem jest Docker Hub, który udostępnia gotowe obrazy aplikacji i usług, takich jak PostgreSQL, Redis czy Nginx.

Docker umożliwia pobieranie obrazów z rejestru:

docker pull postgres

Możliwe jest również publikowanie własnych obrazów:

docker push username/my-app:1.0

Oprócz Docker Hub można korzystać z prywatnych rejestrów, takich jak Amazon ECR czy GitHub Container Registry.

Jak współpracują komponenty Dockera?

Przykładowo wykonanie polecenia:

docker run hello-world

Powoduje wykonanie następujących operacji:

  1. Docker Client wysyła żądanie do Docker Daemon.
  2. Docker Daemon sprawdza, czy obraz hello-world jest dostępny lokalnie.
  3. Jeśli obraz nie jest dostępny, zostaje pobrany z Docker Registry (domyślnie Docker Hub).
  4. Docker Daemon tworzy kontener na podstawie obrazu i uruchamia go.
  5. Kontener wykonuje swój program, wyświetla komunikat i kończy działanie.

Całym procesem zarządza Docker Daemon, natomiast Docker Client służy jako interfejs umożliwiający wydawanie poleceń.

Obrazy i kontenery

Podstawowymi elementami Dockera są obrazy (Docker Images) oraz kontenery (Docker Containers). Choć pojęcia te są ze sobą powiązane, pełnią różne funkcje.

Docker Image

Docker Image to niezmienny szablon zawierający wszystko, co jest potrzebne do uruchomienia aplikacji, m.in. jej kod, biblioteki, zależności oraz środowisko uruchomieniowe.

Przykładowo obraz aplikacji napisanej w Javie może zawierać:

  • Środowisko Java Runtime Environment (JRE).
  • Plik JAR aplikacji.
  • Wymagane biblioteki.
  • Konfigurację i instrukcję uruchomienia aplikacji.

Obrazy można pobierać z gotowych repozytoriów, takich jak Docker Hub, lub tworzyć samodzielnie za pomocą pliku Dockerfile.

Każdy obraz może posiadać nazwę oraz tag określający jego wariant lub wersję, np.:

docker pull nginx:alpine

W tym przypadku nginx oznacza nazwę repozytorium obrazu, natomiast alpine jest tagiem wskazującym wariant oparty na Alpine Linux. Tag możesz rozumieć jako wersję danego obrazu.

Docker Container

Docker Container to uruchamialna instancja obrazu Dockera. Kontener powstaje na podstawie obrazu i stanowi odizolowane środowisko, w którym wykonywana jest aplikacja.

Przykładowo:

docker run -d --name my-nginx -p 8080:80 nginx:alpine

Polecenie tworzy i uruchamia kontener na podstawie obrazu nginx:alpine.

  • -d – uruchamia kontener w tle.
  • --name my-nginx – nadaje kontenerowi nazwę.
  • -p 8080:80 – mapuje port 8080 hosta na port 80 kontenera.
  • nginx:alpine – określa obraz wykorzystywany do utworzenia kontenera.

Po uruchomieniu serwer Nginx będzie dostępny pod adresem http://localhost:8080, zakładając, że Docker działa lokalnie.

Na podstawie jednego obrazu można utworzyć wiele niezależnych kontenerów. Każdy z nich posiada własny stan i może działać niezależnie od pozostałych.

Cykl życia kontenera

Kontener może znajdować się w różnych stanach, zależnie od wykonywanych operacji.

Najważniejsze z nich to:

  • Created – kontener został utworzony, ale jeszcze nie został uruchomiony.
  • Running – kontener jest uruchomiony i wykonuje swój główny proces.
  • Paused – procesy kontenera zostały tymczasowo wstrzymane.
  • Exited – główny proces zakończył działanie lub kontener został zatrzymany.
  • Removed – kontener został usunięty i nie jest już dostępny.

Do zarządzania cyklem życia kontenera służą polecenia takie jak docker run, docker start, docker stop czy docker rm.

Warto pamiętać, że zatrzymanie kontenera nie oznacza jego usunięcia. Zatrzymiony kontener można ponownie uruchomić, zachowując jego konfigurację oraz dane zapisane w warstwie zapisywalnej.

Dockerfile – tworzenie własnych obrazów

Dockerfile to plik tekstowy zawierający zestaw instrukcji określających sposób budowania obrazu Dockera. Pozwala zdefiniować środowisko uruchomieniowe aplikacji, zainstalować wymagane zależności, skopiować pliki oraz określić polecenie wykonywane podczas uruchamiania kontenera.

Plik standardowo nosi nazwę Dockerfile (bez rozszerzenia) i umieszczany jest w głównym katalogu projektu. Jeśli kiedyś programowałeś w C++ na pewno kojarzysz pliki Makefile. Dockerfile jest podobnym typem pliku.

Najważniejsze instrukcje Dockerfile

Do najczęściej wykorzystywanych instrukcji należą:

  • FROM – określa obraz bazowy, na podstawie którego budowany jest nowy obraz.
  • WORKDIR – ustawia katalog roboczy dla kolejnych instrukcji.
  • COPY – kopiuje pliki i katalogi do obrazu.
  • RUN – wykonuje polecenie podczas budowania obrazu, np. instalację zależności.
  • ENV – definiuje zmienne środowiskowe.
  • EXPOSE – dokumentuje port, na którym aplikacja nasłuchuje połączeń.
  • CMD – określa domyślne polecenie lub argumenty wykonywane podczas uruchamiania kontenera.
  • ENTRYPOINT – definiuje główny program uruchamiany w kontenerze.

Istotna jest różnica pomiędzy RUN, CMD i ENTRYPOINT. Instrukcja RUN wykonywana jest podczas budowania obrazu, natomiast CMD i ENTRYPOINT określają zachowanie kontenera podczas jego uruchamiania.

W przypadku CMD domyślne polecenie można zastąpić argumentami przekazanymi do docker run. ENTRYPOINT służy natomiast do zdefiniowania głównego programu kontenera, do którego można przekazywać dodatkowe argumenty.

Przykład Dockerfile dla aplikacji Spring Boot

Przykładowy plik Dockerfile dla aplikacji Spring Boot działającej na Java 21 może wyglądać następująco:

FROM eclipse-temurin:21-jre

WORKDIR /app

COPY target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Poszczególne instrukcje odpowiadają za:

  • FROM eclipse-temurin:21-jre – wykorzystanie obrazu bazowego zawierającego środowisko Java 21.
  • WORKDIR /app – ustawienie katalogu roboczego na /app.
  • COPY target/*.jar app.jar – skopiowanie zbudowanego pliku JAR do obrazu pod nazwą app.jar (zakładając, że wzorzec wskazuje dokładnie jeden plik JAR).
  • EXPOSE 8080 – wskazanie, że aplikacja nasłuchuje na porcie 8080.
  • ENTRYPOINT – uruchomienie aplikacji za pomocą polecenia java -jar app.jar.

Warto pamiętać, że instrukcja EXPOSE nie udostępnia automatycznie portu na zewnątrz kontenera. W tym celu konieczne jest odpowiednie mapowanie portów podczas uruchamiania kontenera.

Budowanie i uruchamianie obrazu

Przed zbudowaniem obrazu należy przygotować plik JAR aplikacji, np. za pomocą Maven:

mvn clean package

Następnie, w katalogu zawierającym plik Dockerfile, można wykonać:

docker build -t spring-app:1.0 .

Parametry polecenia oznaczają:

  • docker build – rozpoczyna budowanie obrazu.
  • -t spring-app:1.0 – nadaje obrazowi nazwę spring-app oraz tag 1.0.
  • . – wskazuje bieżący katalog jako kontekst budowania (build context).

Po zakończeniu budowania obraz można wykorzystać do uruchomienia kontenera:

docker run -d -p 8080:8080 --name spring-container spring-app:1.0

Aplikacja będzie dostępna pod adresem http://localhost:8080, zakładając, że działa na porcie 8080 i nie wymaga dodatkowych usług.

Multi-stage build

Multi-stage build to technika umożliwiająca wykorzystanie kilku etapów podczas budowania jednego obrazu Dockera.

Pozwala oddzielić proces kompilacji aplikacji od jej uruchamiania. Dzięki temu końcowy obraz nie musi zawierać narzędzi wykorzystywanych wyłącznie podczas budowania, takich jak Maven czy kompilator Java.

Przykład:

# Etap 1 – budowanie aplikacji
FROM maven:3.9-eclipse-temurin-21 AS build

WORKDIR /app

COPY pom.xml .
COPY src ./src

RUN mvn clean package

# Etap 2 – uruchamianie aplikacji
FROM eclipse-temurin:21-jre

WORKDIR /app

COPY --from=build /app/target/*.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

W powyższym przykładzie:

  1. Pierwszy etap wykorzystuje obraz zawierający Maven oraz JDK 21 do skompilowania aplikacji i utworzenia pliku JAR.
  2. Drugi etap wykorzystuje lżejszy obraz ze środowiskiem JRE 21.
  3. Instrukcja COPY --from=build kopiuje gotowy plik JAR z etapu budowania do końcowego obrazu.

Największą zaletą multi-stage build jest zmniejszenie rozmiaru końcowego obrazu, ponieważ nie zawiera on narzędzi potrzebnych wyłącznie podczas kompilacji.

Dodatkowo kompilacja aplikacji odbywa się wewnątrz procesu budowania obrazu, dzięki czemu nie wymaga lokalnie zainstalowanego Mavena ani JDK.

Najważniejsze komendy Dockera

Docker udostępnia interfejs wiersza poleceń (Docker CLI), który umożliwia zarządzanie obrazami, kontenerami, sieciami oraz innymi zasobami.

Poniżej przedstawiono najważniejsze polecenia wykorzystywane podczas codziennej pracy z Dockerem.

Zarządzanie obrazami

Pobieranie obrazu z Docker Registry:

docker pull nginx:alpine

Polecenie pobiera obraz nginx z tagiem alpine z Docker Hub.

Wyświetlanie dostępnych obrazów:

docker images

Wyświetla listę obrazów przechowywanych lokalnie wraz z informacjami o ich nazwach, tagach, identyfikatorach oraz rozmiarach.

Usuwanie obrazu:

docker rmi nginx:alpine

Usuwa wskazany obraz z lokalnego środowiska, o ile nie jest on wykorzystywany przez kontenery uniemożliwiające jego usunięcie.

Zarządzanie kontenerami

Tworzenie i uruchamianie kontenera:

docker run -d --name my-nginx -p 8080:80 nginx:alpine

Polecenie tworzy kontener o nazwie my-nginx i uruchamia go w tle, udostępniając serwer Nginx na porcie 8080 hosta.

Wyświetlanie uruchomionych kontenerów:

docker ps

Aby wyświetlić również zatrzymane kontenery, należy dodać parametr -a:

docker ps -a

Zatrzymywanie kontenera:

docker stop my-nginx

Ponowne uruchamianie zatrzymanego kontenera:

docker start my-nginx

Restartowanie kontenera:

docker restart my-nginx

Usuwanie kontenera:

docker rm my-nginx

Polecenie usuwa zatrzymany kontener. Aby usunąć działający kontener, należy go wcześniej zatrzymać lub zastosować opcję -f, która wymusza usunięcie.

Warto pamiętać, że docker run tworzy nowy kontener, natomiast docker start uruchamia ponownie wcześniej utworzony kontener.

Logi i wykonywanie poleceń

Wyświetlanie logów kontenera:

docker logs my-nginx

Aby obserwować logi na bieżąco, można wykorzystać parametr -f:

docker logs -f my-nginx

Wykonywanie poleceń wewnątrz kontenera:

docker exec -it my-nginx sh

Polecenie uruchamia interaktywną powłokę sh wewnątrz działającego kontenera.

Parametry:

  • -i – utrzymuje otwarte standardowe wejście.
  • -t – przydziela pseudo-terminal.

Polecenie docker exec umożliwia również jednorazowe wykonywanie poleceń bez uruchamiania interaktywnej powłoki:

docker exec my-nginx ls /etc/nginx

W tym przypadku wyświetlona zostanie zawartość katalogu /etc/nginx wewnątrz kontenera.

Sieci i przechowywanie danych

Docker udostępnia mechanizmy umożliwiające komunikację między kontenerami oraz przechowywanie danych niezależnie od ich cyklu życia.

Mapowanie portów

Domyślnie porty kontenera nie są automatycznie udostępniane na hoście. Aby aplikacja działająca w kontenerze była dostępna z zewnątrz, można wykorzystać mapowanie portów (port mapping).

Przykład:

docker run -d -p 8080:80 nginx:alpine

Składnia parametru -p:

-p PORT_HOSTA:PORT_KONTENERA

W tym przypadku:

  • 8080 – port na komputerze hosta.
  • 80 – port, na którym Nginx nasłuchuje wewnątrz kontenera.

Dzięki temu serwer Nginx jest dostępny pod adresem http://localhost:8080.

Domyślnie Docker może udostępnić port na wszystkich interfejsach sieciowych hosta. Aby ograniczyć dostęp do lokalnego komputera, można zastosować:

docker run -d -p 127.0.0.1:8080:80 nginx:alpine

Docker Volumes

Kontenery mają własną warstwę zapisywalną, jednak dane zapisane w tej warstwie są usuwane wraz z kontenerem.

Aby zapewnić trwałość danych, Docker udostępnia mechanizm Volumes, umożliwiający przechowywanie danych poza warstwą zapisywalną kontenera.

Wolumenami zarządza Docker, a ich zawartość pozostaje dostępna nawet po usunięciu kontenera.

Przykładowo utworzenie wolumenu:

docker volume create postgres-data

Następnie uruchomienie PostgreSQL 17 z wykorzystaniem utworzonego wolumenu:

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=example \
  -v postgres-data:/var/lib/postgresql/data \
  postgres:17

Parametr -v określa miejsce montowania wolumenu:

-v NAZWA_WOLUMENU:ŚCIEŻKA_W_KONTENERZE

W tym przypadku PostgreSQL zapisuje dane w katalogu /var/lib/postgresql/data, który jest powiązany z wolumenem postgres-data.

Tu warto podkreślić,że Docker Image (obraz) i Docker Volume (wolumen) pełnią zupełnie inne funkcje.

  • Image – określa, co jest potrzebne do uruchomienia aplikacji.
  • Volume – przechowuje dane, które powinny przetrwać usunięcie kontenera.

Docker Compose

Docker Compose to narzędzie umożliwiające definiowanie i uruchamianie aplikacji składających się z wielu kontenerów Dockera.

Zamiast uruchamiać każdy kontener osobnym poleceniem docker run, można opisać całą konfigurację aplikacji w jednym pliku YAML, najczęściej o nazwie compose.yaml.

Docker Compose pozwala zarządzać:

  • Services – usługami działającymi w kontenerach.
  • Networks – sieciami umożliwiającymi komunikację między kontenerami.
  • Volumes – wolumenami przechowującymi dane niezależnie od cyklu życia kontenerów.
  • Environment Variables – zmiennymi środowiskowymi przekazywanymi do kontenerów.

Przykład – Spring Boot i PostgreSQL

Przykładowa aplikacja Spring Boot korzysta z bazy danych PostgreSQL. Do jej uruchomienia potrzebne są dwa kontenery: jeden dla aplikacji i drugi dla bazy danych.

W katalogu projektu można utworzyć plik compose.yaml:

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/appdb
      SPRING_DATASOURCE_USERNAME: app
      SPRING_DATASOURCE_PASSWORD: example
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:17
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: app
      POSTGRES_PASSWORD: example
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d appdb"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  postgres-data:

Konfiguracja definiuje dwie usługi:

Service app – aplikacja Spring Boot

  • build: . – buduje obraz na podstawie pliku Dockerfile znajdującego się w bieżącym katalogu.
  • ports – udostępnia aplikację na porcie 8080 hosta.
  • environment – przekazuje konfigurację połączenia z PostgreSQL do Spring Boot.
  • depends_on – określa zależność aplikacji od bazy danych.

Service db – baza danych PostgreSQL

  • image: postgres:17 – wykorzystuje gotowy obraz PostgreSQL.
  • environment – definiuje nazwę bazy danych, użytkownika i hasło.
  • volumes – podłącza wolumen przechowujący dane bazy.
  • healthcheck – sprawdza gotowość PostgreSQL do przyjmowania połączeń.

Dzięki condition: service_healthy Docker Compose uruchomi aplikację dopiero po uzyskaniu pozytywnego wyniku kontroli stanu bazy danych.

Warto zwrócić uwagę na adres:

jdbc:postgresql://db:5432/appdb

Zamiast localhost wykorzystana została nazwa db, ponieważ Docker Compose domyślnie tworzy wspólną sieć dla usług i pozwala im komunikować się za pomocą nazw usług.

Przykład zakłada, że aplikacja Spring Boot posiada odpowiednie zależności do komunikacji z PostgreSQL oraz plik Dockerfile opisany w poprzednim rozdziale. Hasło example służy wyłącznie do celów demonstracyjnych.

Uruchamianie Docker Compose

Aby zbudować obraz aplikacji i uruchomić wszystkie usługi, wystarczy wykonać:

docker compose up -d --build
  • up – tworzy i uruchamia usługi.
  • -d – uruchamia kontenery w tle.
  • --build – buduje obrazy usług posiadających konfigurację build.

Docker Compose automatycznie utworzy potrzebną sieć, wolumen i kontenery.

Do zarządzania uruchomionymi usługami służą polecenia:

# Lista kontenerów projektu
docker compose ps

# Logi aplikacji
docker compose logs -f app

# Zatrzymanie usług
docker compose stop

# Ponowne uruchomienie usług
docker compose start

# Zatrzymanie i usunięcie kontenerów oraz sieci projektu
docker compose down

Polecenie docker compose down domyślnie nie usuwa nazwanych wolumenów, dzięki czemu dane PostgreSQL pozostają zachowane.

Aby usunąć również wolumeny zadeklarowane w konfiguracji, można wykonać:

docker compose down -v

Uwaga: w przedstawionym przykładzie spowoduje to również usunięcie danych przechowywanych w wolumenie PostgreSQL.

Docker Compose jest szczególnie przydatny w lokalnych środowiskach programistycznych i testowych, gdzie pozwala uruchomić cały zestaw usług za pomocą jednego polecenia.

Dzięki mechanizmowi Externalized Configuration, Spring Boot pozwala pobierać konfigurację z różnych źródeł, między innymi ze zmiennych środowiskowych systemu operacyjnego. Dlatego też Spring może pobierać dane ustawione w Docker Compose .

Dobre praktyki

Podczas pracy z Dockerem warto stosować kilka zasad, które poprawiają bezpieczeństwo, wydajność oraz łatwość utrzymania aplikacji.

Minimalizacja rozmiaru obrazów

Obrazy Dockera powinny zawierać wyłącznie komponenty niezbędne do uruchomienia aplikacji.

W tym celu warto:

  • Korzystać z możliwie małych, zaufanych obrazów bazowych.
  • Stosować multi-stage build, aby oddzielić kompilację od uruchamiania aplikacji.
  • Unikać instalowania zbędnych narzędzi i bibliotek.
  • W przypadku aplikacji Java wykorzystywać obraz z JRE zamiast pełnego JDK, jeśli aplikacja nie wymaga kompilatora podczas działania.

Mniejsze obrazy zajmują mniej przestrzeni dyskowej, szybciej się pobierają i zazwyczaj zawierają mniej potencjalnie podatnych na ataki komponentów.

Wykorzystanie .dockerignore

Plik .dockerignore pozwala wykluczyć określone pliki i katalogi z kontekstu budowania obrazu.

Działa podobnie do pliku .gitignore wykorzystywanego przez Git.

Przykładowa zawartość dla projektu Java budowanego przy użyciu multi-stage build:

.git
.idea
target/
*.log
.env

Dzięki temu Docker nie przesyła niepotrzebnych plików do procesu budowania obrazu.

Uwaga: jeśli Dockerfile kopiuje gotowy plik JAR z lokalnego katalogu target, katalogu tego nie należy wykluczać w .dockerignore.

Bezpieczeństwo kontenerów

Kontenery powinny działać z minimalnymi niezbędnymi uprawnieniami.

Najważniejsze zalecenia:

  • Nie uruchamiać aplikacji jako root, jeśli nie jest to konieczne. W Dockerfile można wskazać użytkownika za pomocą instrukcji USER.
  • Nie umieszczać haseł i tokenów w obrazach – dane wrażliwe powinny być przekazywane za pomocą odpowiednich mechanizmów zarządzania sekretami, np. Docker Compose Secrets.
  • Regularnie aktualizować obrazy bazowe, aby ograniczać ryzyko wykorzystania znanych podatności.
  • Ograniczać dostępne porty – udostępniać na hoście wyłącznie te porty, które są rzeczywiście potrzebne.

Warto również stosować konkretne wersje obrazów zamiast tagu latest. W środowiskach wymagających pełnej powtarzalności można dodatkowo wskazać obraz za pomocą jego identyfikatora digest (sha256).

Wykorzystanie cache podczas budowania

Docker może wykorzystywać wcześniej zbudowane warstwy obrazów, co pozwala przyspieszyć kolejne procesy budowania.

W przypadku aplikacji Java warto odpowiednio uporządkować instrukcje w Dockerfile, np. kopiując najpierw plik pom.xml i pobierając zależności, a dopiero później kopiując kod źródłowy.

Dzięki temu zmiana kodu aplikacji nie musi powodować ponownego pobierania wszystkich zależności Maven, o ile odpowiednie warstwy pozostają w pamięci podręcznej.

Podsumowanie

Docker znacząco upraszcza proces tworzenia, uruchamiania i wdrażania aplikacji, zapewniając spójne i powtarzalne środowiska. Wykorzystanie obrazów i kontenerów pozwala ograniczyć problemy związane z konfiguracją oraz zależnościami, a jednocześnie efektywniej zarządzać zasobami systemowymi.

Dockerfile umożliwia automatyzację budowania obrazów, natomiast Docker Compose pozwala definiować i uruchamiać aplikacje składające się z wielu współpracujących kontenerów. Mechanizmy sieciowe i wolumeny zapewniają komunikację między usługami oraz trwałość przechowywanych danych

Źródła:

Docker – Overview
Oficjalna dokumentacja wyjaśniająca architekturę Dockera, działanie obrazów i kontenerów oraz podstawowe mechanizmy konteneryzacji.

Dockerfile Reference
Dokumentacja instrukcji Dockerfile, takich jak FROM, RUN, COPY, WORKDIR, CMD i ENTRYPOINT, wykorzystywanych podczas tworzenia obrazów.

Docker Compose – Getting Started
Praktyczny przewodnik po Docker Compose, obejmujący definiowanie usług, sieci, wolumenów oraz uruchamianie aplikacji składających się z wielu kontenerów.

Dodaj komentarz