Kubernetes co to jest – to pytanie zadaje sobie coraz więcej programistów i administratorów systemów, stojących przed wyzwaniem zarządzania aplikacjami kontenerowymi. W dzisiejszym świecie, gdzie aplikacje stają się coraz bardziej złożone, tradycyjne metody wdrażania i zarządzania już nie wystarczają.

Co to jest Kubernetes: Podstawowe pojęcia i zastosowania

Definicja i pochodzenie nazwy Kubernetes

Kubernetes to otwarte oprogramowanie automatyzujące wdrażanie, skalowanie i zarządzanie aplikacjami kontenerowymi. Nazwa pochodzi z greckiego i oznacza "sternika" lub "pilota" – trafna metafora dla systemu sterującego kontenerami w klastrze.

Projekt został opracowany przez Google, bazując na wewnętrznym systemie Borg. W 2014 roku Google udostępnił Kubernetes jako projekt open source, przekazując go pod opiekę Cloud Native Computing Foundation (CNCF).

W praktyce, Kubernetes to system pozwalający uruchamiać wiele kontenerów na wielu maszynach fizycznych lub wirtualnych, zapewniając mechanizmy do wdrażania, utrzymania i skalowania aplikacji.

Dlaczego Kubernetes stał się standardem w orkiestracji kontenerów

Kubernetes rozwiązuje kluczowe problemy zarządzania kontenerami w środowisku produkcyjnym:

Automatyczne skalowanie – system automatycznie zwiększa lub zmniejsza liczbę kontenerów zależnie od obciążenia
Samonaprawianie – monitoring i automatyczny restart kontenerów w razie awarii
Równoważenie obciążenia – automatyczna dystrybucja ruchu sieciowego między kontenery
Aktualizacje bez przestojów – możliwość aktualizacji aplikacji bez przerywania jej działania
Deklaratywna konfiguracja – zamiast definiować kroki, określasz pożądany stan systemu

Kubernetes działa w różnych środowiskach – od lokalnych klastrów po chmury publiczne, co pozwala uniknąć uzależnienia od jednego dostawcy.

Porównanie z innymi narzędziami (Docker Swarm, Apache Mesos)

Docker Swarm:

Zalety: łatwy w konfiguracji, zintegrowany z Docker, niski próg wejścia
Wady: mniej zaawansowane funkcje, ograniczona skalowalność

Docker Swarm wybierano do mniejszych projektów, ale wraz z rosnącymi wymaganiami wiele organizacji przechodzi na Kubernetes.

Apache Mesos:

Zalety: wysoka skalowalność, obsługa różnych frameworków
Wady: bardziej złożona konfiguracja, wyższy próg wejścia

Mesos obsługuje większą różnorodność obciążeń niż Kubernetes, który koncentruje się głównie na kontenerach. Jednak Kubernetes oferuje równowagę między mocą a użytecznością oraz bogatszy ekosystem narzędzi.

Architektura klastra Kubernetes dla początkujących

Węzły master i worker – różnice i zadania

Klaster Kubernetes składa się z węzłów master (kontrolnych) i worker (roboczych).

Węzły master pełnią funkcję "mózgu" klastra, podejmując globalne decyzje o wdrożeniach, skalowaniu i zarządzaniu zasobami. W środowisku produkcyjnym zazwyczaj istnieje wiele węzłów master dla zapewnienia wysokiej dostępności.

Węzły worker wykonują faktyczną pracę – na nich uruchamiane są kontenery z aplikacjami. Zawierają narzędzia do komunikacji z master oraz zarządzania kontenerami.

Różnica jest zatem prosta: węzły master zarządzają, węzły worker wykonują zadania.

Kluczowe komponenty klastra (etcd, API Server, Scheduler)

API Server stanowi centralny punkt komunikacji w klastrze. Wszystkie instrukcje, zapytania i komunikacja między komponentami przechodzą przez niego, obsługując zarówno żądania wewnętrzne, jak i zewnętrzne od użytkowników.

etcd to rozproszona baza danych typu klucz-wartość przechowująca wszystkie dane klastra. Można ją porównać do "rejestru stanu" – zawiera informacje o wszystkich obiektach Kubernetes, ich konfiguracji i statusie.

Scheduler odpowiada za przydzielanie podów do odpowiednich węzłów worker. Analizuje wymagania zasobów, bieżące obciążenie węzłów oraz ograniczenia, aby podjąć optymalną decyzję.

Dodatkowo, w control plane działają:

Controller Manager – monitoruje stan klastra i reaguje na zmiany
Cloud Controller Manager – integruje klaster z usługami dostawcy chmury

Na węzłach worker działają:

Kubelet – agent zarządzający kontenerami
Kube-proxy – zarządza sieciami i regułami przekierowania
Container Runtime – oprogramowanie wykonujące kontenery (np. Docker)

Przestrzenie nazw (Namespaces) i ich praktyczne zastosowanie

Przestrzenie nazw pozwalają podzielić jeden fizyczny klaster Kubernetes na wiele wirtualnych klastrów. Jest to szczególnie przydatne, gdy wiele zespołów lub projektów korzysta z tego samego klastra.

Praktyczne zastosowania:

Izolacja środowisk – oddzielne przestrzenie dla deweloperskich, testowych i produkcyjnych
Podział zasobów – każdej przestrzeni można przypisać limity zasobów (CPU, pamięć)
Kontrola dostępu – zdefiniowanie, którzy użytkownicy mają dostęp do konkretnych przestrzeni

Przestrzenie nazw działają doskonale w dużych organizacjach, gdzie administrator może nadać uprawnienia poszczególnym zespołom tylko do ich przestrzeni, bez ryzyka kolizji nazw zasobów czy wpływu na inne aplikacje.

Pamiętajmy, że nie wszystkie obiekty Kubernetes są ograniczone do przestrzeni nazw – niektóre, jak węzły czy trwałe woluminy, są globalne dla całego klastra.

Przygotowanie środowiska do instalacji pierwszego klastra

Wymagania sprzętowe i programowe

Aby uruchomić klaster Kubernetes, nawet w wersji lokalnej i testowej, potrzebujemy:

Zasoby sprzętowe:

Procesor: 2 rdzenie CPU (4 rdzenie zalecane)
Pamięć RAM: minimum 2 GB dedykowane dla Kubernetes (4 GB lub więcej zalecane)
Dysk: minimum 20 GB wolnej przestrzeni
Łącze internetowe: do pobrania komponentów

To są wymagania dla środowiska deweloperskiego z minikube. Klastry produkcyjne wymagają znacznie więcej zasobów.

Wymagania programowe:

System operacyjny: Linux, macOS lub Windows 10/11
Włączona wirtualizacja: VT-x/AMD-v w BIOS/UEFI
Menedżer wirtualizacji: Hyperkit (macOS), Hyper-V (Windows), KVM (Linux) lub VirtualBox

Instalacja niezbędnych narzędzi (kubectl, minikube)

Kubectl to narzędzie wiersza poleceń służące do komunikacji z klastrem Kubernetes. Działa jak most między użytkownikiem a API Kubernetes.

Instalacja na Linux (Ubuntu/Debian):

sudo apt update
sudo apt install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update
sudo apt install -y kubectl

Na macOS (z Homebrew):

brew install kubectl

Na Windows (z Chocolatey):

choco install kubernetes-cli

Minikube pozwala utworzyć jednowęzłowy klaster Kubernetes na lokalnym komputerze. Jest doskonałym narzędziem do nauki, testowania i rozwoju aplikacji.

Instalacja na Linux:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

Na macOS:

brew install minikube

Na Windows:

choco install minikube

Po instalacji warto sprawdzić poprawność:

kubectl version --client
minikube version

Konfiguracja systemu operacyjnego

Przed uruchomieniem klastra Kubernetes:

Włączenie wirtualizacji – upewnij się, że wirtualizacja jest włączona w BIOS/UEFI
Konfiguracja zapory sieciowej – dodaj wyjątki dla portów używanych przez Kubernetes (zazwyczaj 6443 dla API serwera oraz porty 30000-32767 dla NodePort)
Docker (opcjonalnie) – chociaż minikube może używać containerd, instalacja Dockera ułatwia pracę:

sudo apt install docker.io
sudo usermod -aG docker $USER

Parametry systemowe dla Linux:

# Wyłączenie swap
sudo swapoff -a

# Włączenie przekazywania pakietów
echo "net.bridge.bridge-nf-call-iptables=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl --system

Dla Windows 10/11, należy upewnić się, że funkcja Hyper-V jest włączona lub zainstalować VirtualBox.

Tworzenie lokalnego klastra Kubernetes krok po kroku

Uruchomienie minikube i weryfikacja działania

Uruchamiamy minikube:

minikube start

To polecenie tworzy wirtualną maszynę i konfiguruje pojedynczy węzeł klastra. Proces może potrwać kilka minut ze względu na pobieranie potrzebnych obrazów kontenerów.

Po zakończeniu weryfikujemy, czy klaster działa:

kubectl cluster-info

Sprawdzamy stan węzłów:

kubectl get nodes

Powinniśmy zobaczyć jeden węzeł o statusie "Ready", oznaczający gotowość klastra do przyjmowania zadań.

Konfiguracja pierwszego Deploymentu

Kubernetes deployment definiuje pożądany stan dla podów oraz określa, ile replik aplikacji powinno działać.

Tworzymy plik first-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-kubernetes
  template:
    metadata:
      labels:
        app: hello-kubernetes
    spec:
      containers:
      - name: hello-kubernetes
        image: paulbouwer/hello-kubernetes:1.8
        ports:
        - containerPort: 8080

Wdrażamy aplikację:

kubectl apply -f first-deployment.yaml

Sprawdzamy stan:

kubectl get deployments
kubectl get pods

Ekspozycja aplikacji przy użyciu Service

Aby uzyskać dostęp do aplikacji, musimy ją wyeksponować za pomocą obiektu Service.

Tworzymy plik hello-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: hello-kubernetes

Wdrażamy usługę:

kubectl apply -f hello-service.yaml

Aby uzyskać adres URL:

minikube service hello-kubernetes --url

Otrzymamy adres, pod którym aplikacja jest dostępna. Używając przeglądarki, możemy odwiedzić ten adres i zobaczyć działającą aplikację.

Właśnie stworzyliśmy działający klaster Kubernetes z uruchomioną aplikacją. Ten przykład pokazuje podstawowy przepływ pracy: uruchomienie klastra, wdrożenie aplikacji i udostępnienie jej użytkownikom.

Zarządzanie aplikacjami w klastrze Kubernetes

Skalowanie aplikacji przy użyciu ReplicaSet

ReplicaSet zapewnia utrzymanie stałej liczby podów danej aplikacji. Skalowanie sprowadza się do zmiany liczby replik:

kubectl scale deployment hello-kubernetes --replicas=5

To zwiększy liczbę podów do pięciu. Można również skonfigurować automatyczne skalowanie na podstawie obciążenia:

kubectl autoscale deployment hello-kubernetes --min=2 --max=10 --cpu-percent=80

Teraz klaster samodzielnie dostosuje liczbę podów w zależności od wykorzystania CPU.

Aktualizacja aplikacji bez przestojów

Jedną z głównych zalet Kubernetes jest możliwość aktualizacji aplikacji bez przerywania jej działania – proces zwany rolling update:

kubectl set image deployment/hello-kubernetes hello-kubernetes=paulbouwer/hello-kubernetes:1.9

Alternatywnie, można zaktualizować plik YAML deploymentu:

kubectl apply -f updated-deployment.yaml

Kubernetes stopniowo zastępuje stare pody nowymi, utrzymując dostępność aplikacji.

Monitorowanie stanu klastra i aplikacji

Do monitorowania klastra Kubernetes wykorzystujemy podstawowe komendy:

kubectl get pods        # Lista podów
kubectl get services    # Lista usług
kubectl get deployments # Lista wdrożeń

Szczegółowe informacje o podzie:

kubectl describe pod [nazwa-poda]

Podgląd logów aplikacji:

kubectl logs [nazwa-poda]

Dla bardziej zaawansowanego monitorowania warto rozważyć narzędzia takie jak Prometheus i Grafana.

Rozwiązywanie podstawowych problemów

Podczas pracy z klastrem Kubernetes możemy napotkać typowe problemy:

Pod w stanie "Pending" – zazwyczaj oznacza brak wystarczających zasobów. Sprawdź dostępność zasobów:

kubectl describe node

Pod w stanie "CrashLoopBackOff" – aplikacja ulega awarii i jest ponownie uruchamiana. Sprawdź logi:

kubectl logs [nazwa-poda]

Problemy z połączeniem sieciowym – sprawdź konfigurację serwisów:

kubectl get svc
kubectl describe svc [nazwa-usługi]

Problemy z obrazami kontenerów – upewnij się, że obraz jest dostępny i poprawnie oznaczony. Możesz spróbować pobrać go ręcznie na węźle.

W zarządzaniu aplikacjami w klastrze Kubernetes kluczowa jest znajomość podstawowych komend i zrozumienie działania zasobów platformy.

Wnioski

Podsumowując naszą podróż przez świat Kubernetes, przedstawiliśmy kompleksowy obraz tej potężnej platformy orkiestracji kontenerów. Poznaliśmy fundamentalne pojęcia, architekturę klastra, komponenty kontrolne, a także praktyczne aspekty wdrażania aplikacji.

Praktyczne doświadczenie z utworzeniem pierwszego klastra wykazało, że Kubernetes, mimo złożoności, staje się przystępny przy odpowiednim podejściu krok po kroku. Szczególną uwagę poświęciliśmy narzędziom kubectl i minikube, stanowiącym punkt wejścia do pracy z tą technologią.

Zgłębiliśmy kluczowe aspekty zarządzania aplikacjami, włączając skalowanie, aktualizacje bez przestojów oraz rozwiązywanie typowych problemów. Wiedza ta pozwala efektywnie wykorzystywać możliwości Kubernetes w codziennej pracy deweloperskiej.

Kubernetes stał się standardem nie bez powodu – jego elastyczność, skalowalność i bogaty ekosystem narzędzi sprawiają, że świetnie sprawdza się zarówno w małych projektach, jak i dużych wdrożeniach produkcyjnych. Jeśli potrzebujesz pomocy przy wdrożeniu Kubernetes lub automatyzacji procesów DevOps, skontaktuj się z nami. W FoxLink Automation pomagamy firmom w konteneryzacji aplikacji i zarządzaniu infrastrukturą.

Kubernetes Co To Jest: Od Zera do Pierwszego Klastra [Krok po Kroku]