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
| Cecha | Maszyna wirtualna | Kontener |
|---|---|---|
| System operacyjny | Własny system operacyjny | Współdzielone jądro systemu |
| Izolacja | Na poziomie maszyny wirtualnej | Na poziomie procesów |
| Zużycie zasobów | Zazwyczaj większe | Zazwyczaj mniejsze |
| Czas uruchamiania | Zwykle dłuższy | Zwykle krótszy |
| Rozmiar | Zwykle liczony w GB | Często MB lub GB |
| Przenośność | Zależna od platformy wirtualizacji | Zależ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:
- Docker Client wysyła żądanie do Docker Daemon.
- Docker Daemon sprawdza, czy obraz
hello-worldjest dostępny lokalnie. - Jeśli obraz nie jest dostępny, zostaje pobrany z Docker Registry (domyślnie Docker Hub).
- Docker Daemon tworzy kontener na podstawie obrazu i uruchamia go.
- 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ą poleceniajava -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-apporaz tag1.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:
- Pierwszy etap wykorzystuje obraz zawierający Maven oraz JDK 21 do skompilowania aplikacji i utworzenia pliku JAR.
- Drugi etap wykorzystuje lżejszy obraz ze środowiskiem JRE 21.
- Instrukcja
COPY --from=buildkopiuje 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 plikuDockerfileznajdują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.
