W poprzednich lekcjach pracowaliśmy z Gitem i GitHubem. Na naszej maszynie Debian utworzyliśmy repozytorium devops-lab, zapisywaliśmy w nim skrypty i pliki konfiguracyjne, pracowaliśmy na osobnych gałęziach i przygotowywaliśmy Pull Requesty.
Git pozwolił nam uporządkować historię projektu. Dzięki niemu możemy wrócić do wcześniejszej wersji pliku, sprawdzić, kto wprowadził zmianę, i pobrać kod na innym komputerze. Ale pojawia się kolejny problem.
Znasz ten moment, kiedy wszystko działa idealnie na Twoim komputerze, zapisałeś wszystkie pliki w Git i wysłałeś je na GitHuba. Druga osoba klonuje repozytorium, próbuje uruchomić projekt i nagle okazuje się, że nic nie działa?
Dzieje się tak dlatego, że aplikacja zależy od środowiska, a Twoje środowisko to często znacząco różni się od środowiska innych osób. Na Twoim komputerze może być zainstalowana konkretna wersja Pythona lub Node.js. Korzystasz z bibliotek, które dodawałeś kilka miesięcy temu, masz ustawione zmienne środowiskowe i odpowiednio skonfigurowany system.
Więc kiedy ktoś inny próbuje uruchomić Twój projekt, to nie odpala tylko kodu – instaluje też cały zestaw zależności, bibliotek i wersji, które u Ciebie akurat się zgadzają a u tej osoby niekoniecznie.
Właśnie tutaj przydaje się Docker. W tym artykule poznamy podstawy konteneryzacji, różnice między obrazem a kontenerem oraz najważniejsze pojęcia związane z Dockerem. W kolejnej lekcji wrócimy na naszego Debiana i uruchomimy pierwsze kontenery.
Czym jest Docker
Wyobraź sobie, że masz dwa projekty na komputerze
- Projekt A: działa na Node 16
- Projekt B: potrzebuje Node 20
Ze względu na różnice w zależnościach projekty te nie dogadują się ze sobą. Z Dockerem każdy projekt ma swój kontener, czyli własne “pudełko” z odpowiednimi wersjami i zależnościami. Wkładasz więc wszystkie zależności każdego projektu do osobnego pudełka. Projekt A wkładasz do jednego pudełka a projekt B do drugiego. W ten sposób nie projekty nie wchodzą sobie w drogę i nie wpływają na Twoje środowisko systemowe. W jednym kontenerze aplikacja może korzystać z Node.js 20, a w drugim z Node.js 24. Nie musimy instalować obu wersji bezpośrednio na naszym Debianie.
Przydatne jest to, że możesz zabrać te pudełka i przenosić je w różne miejsca, na przykład na komputer znajomego, a wszystkie zależności pozostaną w swoich pudełkach, niepomieszane z jego aplikacjami w systemie. W obrazowym skrócie na tym polega działanie dockera.
Docker to platforma do budowania, uruchamiania i zarządzania aplikacjami w kontenerach. Kontener Dockera to lekki, samodzielny pakiet wykonywalny. Kontenery korzystają z zasobów systemu gospodarza, ale mają odseparowane środowiska procesów, systemy plików i konfigurację sieciową.
Czasy sprzed konteneryzacji
I tu dochodzimy do klasycznego problemu sprzed czasów kontenerów. Zespół programistów tworzył aplikację, która wymagała zainstalowania i ręcznego skonfigurowania dodatkowych usług bezpośrednio w systemie operacyjnym. Przykładowo przy aplikacji w Javie zwykle potrzebne były komponenty takie jak PostgreSQL czy Redis. Nagle każdy programista musiał osobno: pobrać pliki binarne, zainstalować, skonfigurować, ustawić odpowiednie porty i jeszcze upewnić się, że wszystko odpala się w odpowiedniej wersji. Problem polegał na tym, że na Windowsie, macOS i Linuksie instalacja oraz konfiguracja przebiegały inaczej, co prowadziło do rozbieżności między środowiskami i strat czasu.
Docker mocno to uprościł. Z Dockerem można zdefiniować, z jakich obrazów mają korzystać poszczególne usługi i jak powinny zostać uruchomione. Zamiast instalować PostgreSQL i Redis bezpośrednio w systemie, uruchamiamy je jako kontenery. Jeżeli potrzebujemy konkretnej wersji PostgreSQL, wskazujemy ją w konfiguracji. Inna osoba może później skorzystać z tych samych ustawień.
Co Git ma wspólnego z Dockerem?
W naszym dotychczasowym laboratorium Git przechowywał głównie skrypty Bash, pliki konfiguracyjne i dokumentację.
Repozytorium wyglądało mniej więcej tak:
devops-lab/
├── README.md
├── configs/
└── scripts/
Kiedy zaczniemy tworzyć obrazy kontenerów, w repozytorium będziemy mogli zapisywać również Dockerfile, kod aplikacji i pliki Docker Compose.
Przykładowo:
devops-lab/
├── README.md
├── configs/
├── scripts/
└── docker/
├── nginx-demo/
├── node-app/
└── compose.yaml
Git będzie przechowywał historię zmian w kodzie i konfiguracji. Docker wykorzysta odpowiednie pliki do zbudowania obrazu oraz uruchomienia aplikacji. Dzięki temu możemy zachować w repozytorium informację, jak aplikacja ma być przygotowana, zamiast polegać wyłącznie na ręcznej konfiguracji konkretnego komputera.
Gotowych obrazów ani danych przechowywanych w wolumenach nie musimy dodawać do Git. Obrazy możemy publikować w rejestrach kontenerowych, a dane aplikacji przechowywać oddzielnie.
W późniejszych lekcjach połączymy oba narzędzia z CI/CD. Zmiana wysłana na GitHuba będzie mogła uruchomić automatyczne testy i budowanie obrazu Dockera.
Docker nie jest maszyną wirtualną
Do tej pory cały nasz kurs wykonywaliśmy na maszynie wirtualnej z Debianem. Skoro korzystamy już z VM, po co nam jeszcze Docker? Docker często myli się z wirtualkami, ale różnica jest prosta:
- VM (maszyna wirtualna) uruchamia cały osobny system operacyjny (jest cięższa i startuje wolniej).
- Kontener Dockera uruchamia aplikację z jej zależnościami, korzystając z jądra systemu hosta (jest lżejszy i startuje szybciej).
Efekt? Kontenery startują szybko, zajmują mniej miejsca i świetnie nadają się do testowania, uruchamiania aplikacji.
Czy można uruchomić Dockera na maszynie wirtualnej?
Jak najbardziej możemy i to będziemy robić w naszym laboratorium.
Schemat wygląda następująco:
Komputer fizyczny
|
v
Maszyna wirtualna Debian
|
v
Docker Engine
|
+---- Kontener Nginx
|
+---- Kontener Node.js
|
+---- Kontener PostgreSQL
Debian pozostaje naszym systemem laboratoryjnym. Instalujemy na nim Dockera, a następnie uruchamiamy potrzebne usługi w kontenerach. Nie musimy przygotowywać nowej maszyny wirtualnej dla każdej aplikacji.
Kluczowe pojęcia związane z Dockerem i konteneryzacją
Przed uruchomieniem pierwszego kontenera warto poznać kilka nazw, które będą pojawiały się w kolejnych ćwiczeniach.
Dockerfile
Plik Dockerfile to skrypt będący instrukcją dotyczącą tworzenia obrazu Dockera. Określamy w nim między innymi obraz bazowy, katalog roboczy, pliki kopiowane do obrazu, instalowane zależności i domyślne polecenie uruchamiające aplikację.
Przykładowy Dockerfile dla prostej aplikacji Node.js może wyglądać tak:
FROM node:16
WORKDIR /app
COPY . /app
RUN npm install
CMD ["node", "app.js"]
FROM: Użyj oficjalnego środowiska uruchomieniowego node jako obrazu nadrzędnego.WORKDIR: Ustaw katalog roboczy w kontenerze.COPY: Skopiuj bieżącą zawartość katalogu do kontenera w /app.RUN: Zainstaluj wszystkie niezbędne pakiety.CMD: Uruchom app.py po uruchomieniu kontenera.
To uproszczony przykład. Zakłada, że projekt zawiera odpowiedni package.json oraz plik app.js. W prawdziwej aplikacji dopracujemy również sposób instalowania zależności, uruchamianie procesu bez uprawnień root i dobór obrazu bazowego.
Image (obraz Dockera)
Obraz Dockera to przygotowany zestaw plików i informacji potrzebnych do uruchomienia kontenera. Ma w sobie wszystko, co jest potrzebne do uruchomienia aplikacji, między innymi kod źródłowy, zależności, pliki konfiguracyjne. Obrazy często buduje się na podstawie Dockerfile, ale można również pobierać gotowe obrazy z rejestrów.
Warto zauważyć, że sam obraz nie jest jeszcze uruchomioną aplikacją. Możemy przechowywać go lokalnie, skopiować do rejestru albo wykorzystać do uruchomienia jednego lub kilku kontenerów. Przykładowo z tego samego obrazu Nginx możemy uruchomić kilka niezależnych kontenerów.
Container (kontener)
Kontener Dockera to działająca instancja obrazu Dockera. W kontenerze uruchomiona jest aplikacja, która ma własny system plików, ustawienia sieci i przestrzeń dyskową. Kontener może uruchamiać serwer WWW, aplikację Node.js albo pojedyncze polecenie. Nie każdy kontener musi działać bez przerwy. Niektóre wykonują określone zadanie i kończą pracę.
Docker Hub
Docker Hub to internetowy rejestr obrazów kontenerowych. Możemy znaleźć tam gotowe obrazy popularnych usług, takich jak Nginx, Redis czy PostgreSQL. Przypomina to trochę korzystanie z GitHuba, ale zamiast repozytoriów z historią plików przechowujemy i udostępniamy obrazy kontenerów.
W Docker Hub dostępne są zarówno obrazy oficjalne, jak i publikowane przez różnych użytkowników oraz organizacje. Dlatego przed wykorzystaniem obrazu warto sprawdzić jego pochodzenie, wersję i sposób utrzymania.
Docker Compose
Jest to narzędzie do definiowania i uruchamiania aplikacji wielokontenerowych za pomocą jednego pliku YAML i kilku prostych komend, którymi uruchamiasz wszystkie aplikacje z pliku.
Jedna aplikacja może wymagać kilku usług. Na przykład aplikacja internetowa korzysta z bazy PostgreSQL i pamięci podręcznej Redis. Możemy uruchamiać każdy kontener osobno, ale wraz z rozwojem projektu pojawia się coraz więcej ustawień: portów, wolumenów, zmiennych środowiskowych i sieci. Zamiast ręcznie wpisywać długie polecenia dla każdej usługi, przygotowujemy ich konfigurację i uruchamiamy cały zestaw przez Compose.
Docker volume
Kontenery można zatrzymywać, usuwać i tworzyć ponownie, co jest bardzo wygodne, dopóki wewnątrz kontenera nie przechowujemy danych, które powinny przetrwać jego usunięcie. Wyobraź sobie bazę PostgreSQL uruchomioną w kontenerze. Jeżeli ważne dane zapisujesz wyłącznie w zapisywalnej warstwie kontenera, możesz stracić je po jego usunięciu.
Wolumeny Dockera to trwały mechanizm pamięci masowej przeznaczony do przechowywania danych generowanych i wykorzystywanych przez kontenery Dockera. Jest to niezbędne w przypadku baz danych, przechowywania plików i innych aplikacji wymagających trwałego przechowywania.
Jak wygląda workflow podczas pracy z dockerem

Podstawowy sposób pracy z Dockerem można opisać za pomocą czterech operacji: pull, build, run i push. Nie zawsze wykonujemy wszystkie. Jeśli korzystamy z gotowego obrazu, możemy go pobrać i uruchomić. Jeśli przygotowujemy własną aplikację, najpierw budujemy obraz.
1) Pull – pobieranie obrazu
Potrzebujesz Postgresa, Redisa albo Nginxa? Najczęściej nie kombinujesz i nie budujesz tego sam. Po prostu pobierasz gotowy obraz z registry (np. Docker Hub) i odpalasz kontener. To jest jak instalacja aplikacji, tylko zamiast instalować w systemie dostajesz izolowane pudełko.
Przykładowo w poniższym poleceniu Docker pobierze obraz i zapiszę go lokalnie.
docker pull nginx
2) Build – budowanie własnego obrazu
Masz swój kod? To robisz własne pudełko. Opisujesz w Dockerfile wszystko co należy zainstalować, skonfigurować i uruchomić a następnie Docker na podstawie tego buduje obraz czyli gotową paczkę. Taki obraz odpala się na każdym komputerze tak samo.
Przykładowo wydając poniższe polecenie Docker wykorzysta Dockerfile z bieżącego katalogu i utworzy obraz oznaczony nazwą devops-app.
docker build -t devops-app .
3) Run – uruchamianie kontenera
Obraz sam z siebie nie działa. Dopiero gdy go uruchomisz, powstaje kontener (czyli aplikacja faktycznie startuje.
Uruchamiając kontener, zwykle ustawiasz rzeczy takie jak:
- porty (żeby wejść przez przeglądarkę),
- zmienne środowiskowe,
- dane w volume (żeby nie znikały po restarcie).
Przykładowo poniższe polecenie uruchamia kontener Nginx w tle, nadaje mu nazwę web i mapuje port 8080 systemu gospodarza na port 80 kontenera.
docker run -d --name web -p 8080:80 nginx
Dzięki temu możemy połączyć się z serwerem przez port udostępniony na naszej maszynie Debian, o ile pozwalają na to ustawienia sieci i zapory. W praktycznej lekcji wykonamy takie polecenia i sprawdzimy, jak dostać się do działającej usługi z przeglądarki.
4) Push – publikowanie obrazu
Gdy obraz jest gotowy, możesz go chcieć się nim podzielić. Możesz to zrobić wrzucając go do rejestru publicznego albo firmowego. Zamiast wysyłać komuś listę „zainstaluj to i tamto”, wysyłasz po prostu gotowy obraz.
Przykładowe polecenie wygląda tak:
docker push TWOJ_LOGIN/devops-app:1.0
Następny krok: W kolejnej lekcji zainstalujemy Dockera na Debianie i uruchomimy pierwsze kontenery. Sprawdzimy podstawowe polecenia, mapowanie portów i wolumeny. Uruchomimy też Nginx, zbudujemy obraz własnej aplikacji Node.js i poznamy Docker Compose.
Przejdź do następnej lekcji: Docker w praktyce na Debianie →
← Poprzednia lekcja: Git rebase, amend i cherry-pick – praca z commitami · Wróć do spisu kursu DevOps