Co to jest Kubernetes i Do Czego Służy: Kompletny Przewodnik dla Początkujących

Wprowadzenie

Nauczyłeś się używać Dockera i kontenerów, ale teraz zastanawiasz się: “Jak zarządzać dziesiątkami lub setkami kontenerów w produkcji?”. Odpowiedzią jest Kubernetes, często skracany do K8s. W tym przewodniku wyjaśnię, czym jest, jak działa i kiedy warto go używać.

Czym jest Kubernetes?

Kubernetes to platforma open source do orkiestracji kontenerów. Została stworzona przez Google w 2014 roku, bazując na 15 latach doświadczenia w zarządzaniu kontenerami na dużą skalę, i jest teraz utrzymywana przez Cloud Native Computing Foundation (CNCF).

Ale co oznacza “orkiestracja”? Wyobraź sobie orkiestrę symfoniczną:

• Muzycy to twoje kontenery, każdy wie, jak grać na swoim instrumencie
• Dyrygent to Kubernetes, który koordynuje wszystkich muzyków
• Partytura to konfiguracja, która definiuje, jak mają grać razem

Bez dyrygenta każdy muzyk grałby na własną rękę. Z Kubernetes wszystkie kontenery pracują w harmonii, aby twoja aplikacja działała.

Nazwa Kubernetes

Nazwa pochodzi od greckiego κυβερνήτης (kybernetes), co oznacza “sternik” lub “pilot”. Logo z siedmioramiennym sterem reprezentuje tę koncepcję. Skrót K8s pochodzi od faktu, że między “K” a “s” jest 8 liter.

Dlaczego Potrzebujesz Kubernetes?

Docker rozwiązuje problem tworzenia i uruchamiania pojedynczych kontenerów. Ale w produkcji sprawy się komplikują:

• Co się dzieje, gdy kontener pada o 3 w nocy?
• Jak rozdzielasz ruch między 10 instancji tej samej aplikacji?
• Jak aktualizujesz aplikację bez przestoju?
• Jak zarządzasz 50 mikroserwisami, które muszą się ze sobą komunikować?

Kubernetes odpowiada na wszystkie te pytania.

Docker vs Kubernetes: To Nie Są Alternatywy

Częstym nieporozumieniem jest myślenie, że Kubernetes zastępuje Dockera. W rzeczywistości pracują razem:

Kubernetes może używać Dockera (lub innych runtime’ów jak containerd) do uruchamiania kontenerów. Nie musisz wybierać między nimi: używasz obu.

Do Czego Służy Kubernetes: 6 Problemów, Które Rozwiązuje

1. Self-Healing: Kontenery, Które Same Się Naprawiają

Jeśli kontener pada, Kubernetes wykrywa to i automatycznie uruchamia nowy. Nikt nie musi być przebudzony o 3 w nocy, żeby ręcznie restartować usługi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes gwarantuje zawsze 3 aktywne repliki
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # Jeśli jedna umiera, K8s tworzy nową
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Automatyczne Skalowanie

Masz szczyt ruchu? Kubernetes może automatycznie zwiększyć liczbę kontenerów. Ruch spada? Zmniejsza je, żeby oszczędzać zasoby.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Automatycznie skaluje między 2 a 10 replikami na podstawie CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Wbudowane Równoważenie Obciążenia

Kubernetes automatycznie rozdziela ruch między wszystkie dostępne kontenery. Jeśli kontener jest przeciążony lub nie odpowiada, ruch jest przekierowywany do innych.

4. Rolling Updates: Aktualizacje Bez Przestoju

Gdy wdrażasz nową wersję, Kubernetes:

1. Uruchamia nowe kontenery z zaktualizowaną wersją
2. Weryfikuje, czy działają poprawnie
3. Stopniowo przenosi ruch na nowe kontenery
4. Kończy stare kontenery

Jeśli coś pójdzie nie tak, może automatycznie wykonać rollback do poprzedniej wersji.

5. Service Discovery

W systemie z wieloma mikroserwisami, jak usługa A znajduje usługę B? Kubernetes dostarcza wewnętrzny system DNS: każda usługa ma nazwę, a Kubernetes tłumaczy ją na właściwy adres.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Usługa "database" będzie dostępna jako "database.default.svc.cluster.local"
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Zarządzanie Sekretami i Konfiguracją

Hasła, klucze API, konfiguracje: Kubernetes zarządza nimi bezpiecznie i wstrzykuje je do kontenerów bez hardkodowania ich w kodzie.

1
2
3
4
5
6
7
8
9

# Secret dla poświadczeń bazy danych
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # zakodowane w base64
  password: cGFzc3dvcmQ=  # zakodowane w base64

Podstawowe Koncepty Kubernetes

Pod

Pod to podstawowa jednostka Kubernetes. Zawiera jeden lub więcej kontenerów, które współdzielą sieć i storage. W większości przypadków Pod zawiera jeden kontener.

Node

Node to maszyna (fizyczna lub wirtualna), która uruchamia Pody. Klaster Kubernetes typowo ma wiele Node’ów, aby zapewnić wysoką dostępność.

Cluster

Cluster to zbiór wszystkich Node’ów zarządzanych przez Kubernetes. Obejmuje:

• Control Plane: “mózg”, który podejmuje decyzje (gdzie umieścić Pody, kiedy je skalować, itp.)
• Worker Nodes: maszyny, które faktycznie uruchamiają kontenery

Deployment

Deployment opisuje pożądany stan twojej aplikacji: jakiego obrazu użyć, ile replik, jak aktualizować. Kubernetes zapewnia, że stan rzeczywisty zawsze odpowiada stanowi pożądanemu.

Service

Service eksponuje Pody do sieci. Zapewnia stabilny adres IP i równoważenie obciążenia, nawet gdy Pody pod spodem się zmieniają.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs Docker Swarm

Docker ma własny wbudowany orkiestrator: Docker Swarm. Jaka jest różnica?

Kiedy wybrać Docker Swarm:

• Małe/średnie projekty
• Zespoły z małym doświadczeniem w orkiestracji
• Potrzeba szybkiego startu

Kiedy wybrać Kubernetes:

• Projekty enterprise lub rosnące
• Potrzeba zaawansowanych funkcji
• Zespół gotowy zainwestować w naukę
• Ważne wymagania dotyczące skalowania

Kiedy NIE Używać Kubernetes

Kubernetes nie zawsze jest właściwą odpowiedzią. Unikaj go, jeśli:

• Masz mało kontenerów: zarządzanie 2-3 kontenerami z K8s to jak używanie ciężarówki do zakupów
• Zespół jest mały: złożoność operacyjna może przewyższyć korzyści
• Aplikacja jest monolityczna: K8s błyszczy z mikroserwisami
• Nie masz wymagań dotyczących skalowania: jeśli ruch jest stały i przewidywalny, możesz go nie potrzebować
• Ograniczony budżet: klastry Kubernetes mają znaczące koszty operacyjne

Prostsze Alternatywy

Jak Zacząć z Kubernetes

Jeśli chcesz poznać Kubernetes bez zwariowania, oto stopniowa ścieżka:

1. Naucz Się Podstaw Dockera

Jeśli jeszcze tego nie zrobiłeś, zacznij od Dockera. Kubernetes orkiestruje kontenery, więc najpierw musisz wiedzieć, jak je tworzyć.

2. Eksperymentuj Lokalnie z Minikube

Minikube tworzy klaster Kubernetes na twoim komputerze. Idealny do nauki bez kosztów chmury.

1
2
3
4
5

# Zainstaluj Minikube i uruchom lokalny klaster
minikube start

# Sprawdź, czy działa
kubectl get nodes

3. Poznaj kubectl

kubectl to polecenie do interakcji z Kubernetes. Naucz się podstawowych operacji:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Zobacz uruchomione Pody
kubectl get pods

# Utwórz zasoby z pliku YAML
kubectl apply -f deployment.yaml

# Zobacz logi Poda
kubectl logs nazwa-poda

# Wejdź do kontenera
kubectl exec -it nazwa-poda -- /bin/bash

4. Wypróbuj Zarządzany Klaster

Gdy będziesz gotowy na produkcję, użyj zarządzanej usługi:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

Te usługi zarządzają Control Plane za ciebie, zmniejszając złożoność operacyjną.

Podsumowanie

Kubernetes to potężne narzędzie, które rozwiązuje realne problemy w zarządzaniu konteneryzowanymi aplikacjami na dużą skalę. Oferuje self-healing, automatyczne skalowanie, wdrożenia bez przestoju i wiele więcej.

Jednak przynosi ze sobą znaczącą złożoność. Przed jego adopcją zadaj sobie pytania:

• Czy naprawdę muszę orkiestrować wiele kontenerów?
• Czy mój zespół ma kompetencje (lub czas, żeby je zdobyć)?
• Czy korzyści uzasadniają dodaną złożoność?

Jeśli odpowiedź brzmi tak, Kubernetes może przekształcić sposób, w jaki zarządzasz swoimi aplikacjami. Jeśli nie, prostsze rozwiązania jak Docker Compose lub Docker Swarm mogą być lepszym wyborem.

Rada to zacząć od małego: eksperymentuj z Minikube, ćwicz podstawowe koncepty i stopniowo skaluj do bardziej złożonych klastrów, gdy naprawdę ich potrzebujesz.