Konteneryzacja aplikacji za pomocą Dockera: poradnik dla deweloperów

Konteneryzacja aplikacji stała się jednym z kluczowych elementów nowoczesnego tworzenia oprogramowania. Docker, jako wiodąca platforma w tej dziedzinie, umożliwia deweloperom tworzenie, wdrażanie i uruchamianie aplikacji w izolowanych środowiskach, zwanych kontenerami. Ten poradnik przybliży Ci tajniki Docker, wyjaśniając, dlaczego warto go stosować i jak zacząć z niego korzystać.

Czym jest konteneryzacja i dlaczego jest tak ważna?

Konteneryzacja to proces pakowania aplikacji wraz z jej zależnościami (bibliotekami, plikami konfiguracyjnymi, środowiskiem uruchomieniowym) w jeden, przenośny pakiet – kontener. Dzięki temu aplikacja działa tak samo niezależnie od środowiska, w którym zostanie uruchomiona – czy to będzie laptop dewelopera, serwer testowy, czy środowisko produkcyjne w chmurze.

Główne korzyści płynące z konteneryzacji to:

• Spójność środowisk: Eliminuje problem „u mnie działa”, gwarantując, że aplikacja będzie działać identycznie wszędzie.
• Szybkość wdrażania: Kontenery uruchamiają się w ciągu sekund, co znacząco przyspiesza procesy CI/CD (Continuous Integration/Continuous Deployment).
• Izolacja: Każdy kontener działa w swoim własnym, izolowanym środowisku, co zapobiega konfliktom między zależnościami różnych aplikacji.
• Efektywne wykorzystanie zasobów: Kontenery są lżejsze od tradycyjnych maszyn wirtualnych, co pozwala na uruchomienie większej liczby aplikacji na tym samym sprzęcie.
• Przenośność: Kontenery można łatwo przenosić między różnymi platformami i chmurami.

Podstawowe pojęcia w świecie Dockera: obrazy i kontenery

Zrozumienie dwóch kluczowych elementów Dockera – obrazów (images) i kontenerów (containers) – jest fundamentem do efektywnego korzystania z tej technologii.

• Obraz (Image): Jest to szablon tylko do odczytu, który zawiera instrukcje dotyczące tworzenia kontenera. Obraz zawiera wszystko, co potrzebne do uruchomienia aplikacji: kod, środowisko uruchomieniowe, biblioteki, zmienne środowiskowe i pliki konfiguracyjne. Obrazy są tworzone na podstawie Dockerfile.
• Kontener (Container): Jest to uruchomiona instancja obrazu. Kontener zawiera system plików, procesy i sieć, które są izolowane od systemu hosta i innych kontenerów. Można myśleć o kontenerze jako o lekkiej, przenośnej maszynie, na której działa nasza aplikacja.

Tworzenie pierwszego obrazu Docker: Dockerfile

Kluczowym narzędziem do definiowania sposobu budowania obrazu Docker jest Dockerfile. Jest to plik tekstowy zawierający sekwencję poleceń, które Docker wykonuje krok po kroku, aby stworzyć obraz.

Oto przykład prostego Dockerfile dla aplikacji Node.js:

# Używamy oficjalnego obrazu Node.js jako bazowego
FROM node:18-alpine

# Ustawiamy katalog roboczy w kontenerze
WORKDIR /app

# Kopiujemy pliki package.json i package-lock.json
COPY package*.json ./

# Instalujemy zależności aplikacji
RUN npm install

# Kopiujemy resztę plików aplikacji do katalogu roboczego
COPY . .

# Wystawiamy port, na którym aplikacja będzie działać
EXPOSE 3000

# Definiujemy polecenie, które zostanie uruchomione po starcie kontenera
CMD ["npm", "start"]

Po utworzeniu pliku Dockerfile w katalogu głównym projektu, można zbudować obraz za pomocą polecenia:

docker build -t moja-aplikacja-node .

• docker build: Polecenie do budowania obrazu.
• -t moja-aplikacja-node: Nadaje obrazowi tag (nazwę) moja-aplikacja-node.
• .: Wskazuje, że Dockerfile znajduje się w bieżącym katalogu.

Uruchamianie i zarządzanie kontenerami Docker

Po zbudowaniu obrazu, możemy uruchomić z niego kontener:

docker run -p 8080:3000 moja-aplikacja-node

• docker run: Polecenie do uruchomienia kontenera.
• -p 8080:3000: Mapuje port 8080 na hoście do portu 3000 w kontenerze (gdzie nasza aplikacja Node.js nasłuchuje).
• moja-aplikacja-node: Nazwa obrazu, z którego chcemy uruchomić kontener.

Aby zobaczyć listę uruchomionych kontenerów, użyj polecenia:

docker ps

Aby zobaczyć wszystkie kontenery (również te zatrzymane):

docker ps -a

Zatrzymanie kontenera:

docker stop <id_kontenera_lub_nazwa>

Usunięcie kontenera:

docker rm <id_kontenera_lub_nazwa>

Docker Compose: Orchestracja wielu kontenerów

W przypadku bardziej złożonych aplikacji, które składają się z wielu usług (np. aplikacja webowa, baza danych, kolejka komunikatów), Docker Compose staje się nieocenionym narzędziem. Pozwala on na definiowanie i zarządzanie wielokontenerowymi aplikacjami w jednym pliku konfiguracyjnym docker-compose.yml.

Przykładowy plik docker-compose.yml dla aplikacji Node.js i bazy danych PostgreSQL:

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:3000"
    depends_on:
      - db

  db:
    image: postgres:14-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Aby uruchomić aplikację zdefiniowaną w docker-compose.yml, wystarczy wykonać polecenie w tym samym katalogu:

docker-compose up -d

• docker-compose up: Tworzy i uruchamia kontenery.
• -d: Uruchamia kontenery w tle (detached mode).

Docker Compose znacząco ułatwia zarządzanie całym ekosystemem aplikacji, zapewniając spójność i łatwość konfiguracji.