Docker dla początkujących: jak rozwiązuje problem „u mnie działa”

by Patryk

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

Może Cię również zainteresować

Dodaj komentarz