DevOps dla Java Developera: Jak zacząć z Dockerem i Kubernetes?

Dlaczego Java Developer powinien znać DevOps?

Do niedawna praca programisty sprowadzała się do pisania kodu i ewentualnie testów jednostkowych. Następnie skompilowany kod trafiał dalej. Uruchomieniem aplikacji zajmował się dział wdrożeniowy lub administratorzy po stronie klienta. Dziś wygląda to zupełnie inaczej. Wraz z popularyzacją chmury, konteneryzacji i podejścia DevOps granice między „tym, kto pisze kod”, a „tym, kto go uruchamia”, zaczęły się zacierać.

Coraz częściej oczekuje się, że programista będzie wiedział, jak zapakować aplikację w kontener i jak nią zarządzać. Nie wynika to z lenistwa administratorów, lecz z konieczności. W czasach mikroserwisów, gdy często trzeba uruchomić środowisko lokalne, napisać testy integracyjne czy wdrożyć CI/CD, programista powinien znać choćby podstawy konteneryzacji.

W tym artykule przyjrzymy się pierwszym krokom z Dockerem i Kubernetes z perspektywy programisty Java.

Docker, VM i Kubernetes – podstawy dla programisty Java

Serwer – fizyczny komputer udostępniający zasoby, takie jak aplikacje. Tradycyjnie aplikację Java wdrażano bezpośrednio na serwer, co prowadziło do konfliktów z zależnościami i trudności w utrzymaniu środowiska. 

Maszyna wirtualna (VM) – odizolowane środowisko działające na serwerze. Dzięki wirtualizacji można uruchamiać wiele systemów operacyjnych na jednym serwerze. VM to osobne środowiska z własnym systemem i bibliotekami, więc aplikacje nie kolidują ze sobą. Wadą jest większe obciążenie serwera i wolniejszy start. 

Docker / Kontener – lekkie i szybkie środowiska uruchomieniowe. Dzielą system operacyjny, więc są bardziej wydajne niż VM. Kontener zawiera jedynie to, co potrzebne do działania – np. JDK, biblioteki i aplikację. Zużywa tylko niezbędne zasoby i uruchamia się błyskawicznie. Dzięki temu na jednym serwerze można uruchomić znacznie więcej kontenerów niż VM. Jednak duża ich liczba może utrudniać zarządzanie. 

Kubernetes – orkiestrator kontenerów. Automatycznie uruchamia, monitoruje, restartuje i skaluje kontenery, co zmniejsza potrzebę ręcznej pracy i zwiększa niezawodność środowiska.

Docker w DevOps: Jak uprościć wdrażanie aplikacji Java?

Wyobraźmy sobie aplikację Spring Boot. Normalnie uruchamiamy ją lokalnie przez Mavena: mvn spring-boot:run, a na produkcji administrator konfiguruje serwer i uruchamia aplikację. W Dockerze tworzymy gotowy obraz, który uruchamiamy lokalnie, testowo lub produkcyjnie.

Docker zmienia sposób wdrażania aplikacji:

• Powtarzalność środowiska – aplikacje działają tak samo na komputerze dewelopera, w testach i na produkcji. 
• Szybkość wdrożenia – zamiast kopiować pliki JAR/WAR i konfigurować serwer, wystarczy uruchomić kontener. 
• Izolacja i bezpieczeństwo – kontenery działają w odizolowanym środowisku, co minimalizuje konflikty. 
• Skalowalność i DevOps – kontenery są lekkie i łatwe do uruchomienia w wielu instancjach, co ułatwia automatyzację.

Tworzenie obrazu Dockera dla aplikacji Spring Boot

Zamiast skupiać się na definicjach, zobaczmy, jak wygląda typowy workflow: 

• Budowanie obrazu – mamy aplikację Spring Boot w Mavenie i generujemy JAR lub WAR w katalogu target/. 
• Dockerfile – w katalogu głównym tworzymy plik Dockerfile. Wybieramy obraz z Javą (np. wersja 17), ustawiamy katalog roboczy, kopiujemy JAR-a i definiujemy polecenie uruchamiające aplikację. 
• Budowanie obrazu – komenda docker build tworzy obraz Dockera. 
• Uruchamianie kontenera – docker run -p 8080:8080 uruchamia aplikację i mapuje porty. 

W ten sposób aplikacja działa w kontenerze.

Dlaczego Kubernetes jest niezbędny w nowoczesnym DevOps?

Docker sprawdza się przy pojedynczym kontenerze. Ale co, jeśli aplikacja musi się skalować lub działa w tysiącach kopii, z których jedna ulegnie awarii? Tu z pomocą przychodzi Kubernetes.

Kubernetes znany również pod skrótem K8s jest to system orkiestracji kontenerów. Do jego zadań należy między innymi skalowanie, zarządzanie konfiguracją, sekretami, automatyczne restarty. Można powiedzieć, że Docker to pojedyncza paczka, a Kubernetes to cały system logistyczny, który zarządza tysiącami paczek.

Jak wdrożyć aplikację Java w Kubernetes? – krok po kroku

• Budowanie aplikacji – jak wcześniej, tworzymy aplikację Spring Boot z Mavenem. 
• Tworzenie obrazu Dockera – przygotowujemy środowisko uruchomieniowe. 
• Uruchamianie kontenera.
• Orkiestracja w Kubernetes – gdy aplikacja działa poprawnie, Kubernetes może uruchomić wiele jej instancji. Gdy ruch rośnie – dodaje instancje, gdy spada – usuwa.

Kubernetes dla początkujących – kluczowe komponenty

• Pod – najmniejsza jednostka w Kubernetes, może zawierać kilka kontenerów. 
• Deployment – opisuje sposób uruchamiania aplikacji. 
• Service – udostępnia aplikację na zewnątrz i równoważy ruch między Podami. 
• ConfigMap i Secret – przechowują konfigurację i dane wrażliwe. 
• Ingress – kontroler wystawiający aplikację pod adresem HTTP.

Minikube i pierwsze kroki z Kubernetes lokalnie

Aby rozpocząć pracę z Kubernetes, potrzebny jest serwer – to kosztowne. Z pomocą przychodzi Minikube, który pozwala uruchomić mały klaster lokalnie.

DevOps mindset: aplikacja to nie tylko kod

Ważne, by myśleć o aplikacji jak o pakiecie – liczy się nie tylko kod, ale też sposób jego uruchamiania. Testy w kontenerze zwiększają szansę, że aplikacja zadziała tak samo na innych serwerach. Ułatwia to automatyzację – zamiast ręcznie uruchamiać polecenia, tworzymy skrypty i pipeline’y CI/CD.

Podsumowanie: Co powinien umieć Java Developer w świecie DevOps?

Docker i Kubernetes zmieniają sposób pracy programistów. Programista to już nie tylko autor kodu, ale też administrator systemu, który stworzył. Dzięki tym technologiom łatwo pakować aplikacje, przenosić je między środowiskami i skalować. Coraz częściej, by zdobyć dobrze płatną pracę, nie wystarczy znać język programowania – wymagana jest też znajomość tych narzędzi. Mam nadzieję, że po lekturze łatwiej będzie postawić pierwsze kroki.

AUTOR: Sebastian Pieróg, Fullstack Developer, ALTEN Polska

Powiązane artykuły