🚢 Wprowadzenie do zarządzania kontenerami Kubernetes

Kubernetes to obecnie najpopularniejsza platforma do orkiestracji kontenerów, która rewolucjonizuje sposób wdrażania i zarządzania aplikacjami. Automatyzując procesy związane z skalowaniem, rozmieszczaniem i zarządzaniem kontenerami, Kubernetes (K8s) radykalnie upraszcza operacje DevOps. Niezależnie od tego, czy pracujesz z niewielkimi projektami, czy z rozbudowanymi aplikacjami produkcyjnymi, zrozumienie fundamentów Kubernetes staje się kluczową umiejętnością w nowoczesnym IT.

⚡ Ekspresowe Podsumowanie:

Czym jest Kubernetes - platforma do zarządzania kontenerami zautomatyzowanego wdrażania, skalowania i utrzymania aplikacji.
Architektura - poznaj master node, worker node, kubelet i inne kluczowe komponenty Kubernetes.
Podstawowe obiekty - Pods, Deployments, Services i inne elementy niezbędne do pracy z K8s.
Pierwsze kroki - jak zainstalować Minikube i kubectl oraz wdrożyć swoją pierwszą aplikację.

🗺️ Spis Treści - Twoja Mapa Drogowa

🔍 Czym jest Kubernetes?

Kubernetes (często skracany do K8s) to otwartoźródłowa platforma do automatyzacji wdrażania, skalowania i zarządzania aplikacjami kontenerowymi. Projekt został zapoczątkowany przez Google w 2014 roku, a następnie przekazany do Cloud Native Computing Foundation (CNCF).

Dlaczego Kubernetes jest tak ważny?

Kontenery zrewolucjonizowały sposób pakowania aplikacji, ale same w sobie nie rozwiązują wszystkich problemów związanych z uruchamianiem aplikacji w środowisku produkcyjnym. Oto gdzie wkracza Kubernetes:

Orkiestracja - zarządzanie wieloma kontenerami w różnych środowiskach
Samonaprawianie - automatyczne restartowanie lub zastępowanie wadliwych kontenerów
Skalowanie horyzontalne - łatwe zwiększanie lub zmniejszanie liczby instancji aplikacji
Równoważenie obciążenia - dystrybucja ruchu sieciowego do odpowiednich kontenerów
Wdrażanie bez przestojów - aktualizacja aplikacji bez przerw w dostępności
Zarządzanie konfiguracją - oddzielenie konfiguracji od kodu aplikacji
Zarządzanie stanem - narzędzia do pracy z aplikacjami stanowymi

Jak Kubernetes różni się od Dockera?

Często spotykamy się z mylnym rozumieniem relacji między Dockerem a Kubernetes:

Docker to technologia umożliwiająca tworzenie, uruchamianie i zarządzanie kontenerami.
Kubernetes to system orkiestracji, który zarządza wieloma kontenerami (niekoniecznie tylko Dockerowymi) i zapewnia środowisko do ich uruchamiania.

Analogia:

Docker to samochód
Kubernetes to system zarządzania flotą samochodów, zajmujący się trasami, harmonogramami, serwisem itp.

🏗️ Architektura Kubernetes

Zrozumienie architektury Kubernetes jest kluczowe do efektywnej pracy z tym narzędziem.

Klaster Kubernetes

Klaster Kubernetes składa się z co najmniej jednego węzła master (control plane) i wielu węzłów roboczych (worker nodes).

Control Plane (Master Node)

Control Plane zawiera komponenty odpowiedzialne za zarządzanie klastrem:

kube-apiserver - API, przez które komunikują się wszystkie komponenty klastra
etcd - rozproszony magazyn danych przechowujący stan klastra
kube-scheduler - przypisuje nowe Pody do węzłów
kube-controller-manager - monitoruje stan klastra i reaguje na zmiany
cloud-controller-manager - integruje się z API dostawcy chmury

Worker Nodes

Worker nodes to maszyny wykonujące zadania przydzielone przez control plane:

kubelet - agent działający na każdym węźle, zapewniający uruchamianie kontenerów
kube-proxy - utrzymuje reguły sieciowe umożliwiające komunikację z Podami
Container Runtime - oprogramowanie odpowiedzialne za uruchamianie kontenerów (np. containerd, CRI-O)

Sieć w Kubernetes

Kubernetes używa modelu sieciowego, który zapewnia, że:

Każdy Pod ma unikalny adres IP
Pody na tym samym węźle mogą komunikować się bez NAT
Pody na różnych węzłach mogą komunikować się bez NAT
Agenci na węźle mogą komunikować się ze wszystkimi Podami na tym węźle

Do implementacji tych wymagań używa się rozwiązań sieciowych takich jak Calico, Flannel, Cilium i innych.

🧩 Podstawowe obiekty Kubernetes

Kubernetes operuje na wielu rodzajach obiektów, które reprezentują stan systemu. Oto najważniejsze z nich:

Pod

Pod to najmniejsza jednostka wdrożeniowa w Kubernetes. Może zawierać jeden lub więcej kontenerów, które współdzielą przestrzeń sieciową, storage i specyfikację sposobu uruchamiania.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx:1.25.0
    ports:
    - containerPort: 80

✨ Pro Tip: Pody są efemeryczne - nie należy polegać na ich trwałości. Zamiast tego, używaj kontrolerów wyższego poziomu jak Deployments.

Deployment

Deployment zapewnia deklaratywne aktualizacje dla Podów. Definiujesz pożądany stan, a Kubernetes Controller zmienia aktualny stan na pożądany.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.0
        ports:
        - containerPort: 80

Service

Service to abstrakcja, która definiuje logiczny zestaw Podów i politykę dostępu do nich. Rozwiązuje problem odkrywania usług i równoważenia obciążenia.

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Typy Services:

ClusterIP - eksponuje service wewnątrz klastra (domyślny)
NodePort - eksponuje service na każdym Node na statycznym porcie
LoadBalancer - używa zewnętrznego load balancera
ExternalName - mapuje service na DNS name

Namespace

Namespace zapewnia sposób dzielenia zasobów klastra między wiele użytkowników, zespołów lub projektów.

apiVersion: v1
kind: Namespace
metadata:
  name: development

ConfigMap i Secret

ConfigMap i Secret służą do oddzielenia konfiguracji od kodu aplikacji:

ConfigMap - przechowuje nieszyfrowane dane konfiguracyjne
Secret - przechowuje wrażliwe informacje (hasła, tokeny, klucze)

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_URL: "postgres://user:password@localhost:5432/db"
  LOG_LEVEL: "info"

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  API_KEY: SGVsbG8gZnJvbSBJUUhvc3QhCg==  # Base64 encoded
  DB_PASSWORD: UGFzc3dvcmQxMjMhCg==

Volume

Volume zapewnia trwałe przechowywanie danych poza cyklem życia Poda.

apiVersion: v1
kind: Pod
metadata:
  name: data-pod
spec:
  containers:
  - name: data-container
    image: busybox
    volumeMounts:
    - name: data-volume
      mountPath: /data
  volumes:
  - name: data-volume
    persistentVolumeClaim:
      claimName: data-pvc

🚀 Pierwsze kroki z Kubernetes

Instalacja środowiska lokalnego

Minikube to narzędzie, które pozwala uruchomić lokalny klaster Kubernetes na Twoim komputerze.

Instalacja Minikube

Na macOS z Homebrew:

brew install minikube

Na Windows z Chocolatey:

choco install minikube

Na Linux:

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

Uruchomienie klastra Minikube

minikube start

Instalacja kubectl

kubectl to narzędzie wiersza poleceń służące do komunikacji z klastrem Kubernetes.

Na macOS:

brew install kubectl

Na Windows:

choco install kubernetes-cli

Na Linux:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

Pierwszy Deployment

Utwórzmy pierwszy Deployment Kubernetes:

Stwórz plik nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.0
        ports:
        - containerPort: 80

Zastosuj Deployment:

kubectl apply -f nginx-deployment.yaml

Sprawdź status Deploymentu:

kubectl get deployments

Sprawdź Pody utworzone przez Deployment:

kubectl get pods

Ekspozycja aplikacji

Utwórzmy Service, aby udostępnić naszą aplikację:

Stwórz plik nginx-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: NodePort

Zastosuj Service:

kubectl apply -f nginx-service.yaml

Sprawdź status Service:

kubectl get services

Uzyskaj URL aplikacji w Minikube:

minikube service nginx-service --url

Otwórz URL w przeglądarce, aby zobaczyć działającą aplikację.

✨ Pro Tip: Użyj kubectl get pods -o wide, aby wyświetlić dodatkowe informacje o Podach, w tym node, na którym są uruchomione.

📊 Zarządzanie aplikacjami w Kubernetes

Aktualizacja aplikacji

Aktualizacja aplikacji w Kubernetes jest prosta - wystarczy zmienić specyfikację Deploymentu:

Edytuj nginx-deployment.yaml i zmień wersję obrazu, np. na nginx:1.25.1
Zastosuj zmiany:

kubectl apply -f nginx-deployment.yaml

Kubernetes automatycznie zaktualizuje aplikację, zastępując stare Pody nowymi w sposób stopniowy (rolling update).

Skalowanie aplikacji

Skalowanie aplikacji może być wykonane na kilka sposobów:

Edycja pliku YAML i zmiana replicas:

spec:
  replicas: 5

Użycie polecenia kubectl:

kubectl scale deployment nginx-deployment --replicas=5

Konfiguracja autoskalowania (HPA - Horizontal Pod Autoscaler):

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

Monitorowanie stanu aplikacji

Podstawowe polecenia do monitorowania:

kubectl get pods
kubectl get deployments
kubectl get services
kubectl get nodes

Dla bardziej szczegółowych informacji:

kubectl describe pod <nazwa-poda>
kubectl logs <nazwa-poda>
kubectl exec -it <nazwa-poda> -- /bin/bash

Debugging aplikacji

Gdy pojawią się problemy z aplikacją w Kubernetes:

Sprawdź status Poda:
```
kubectl get pods
```
Jeśli Pod nie jest w stanie Running, sprawdź szczegóły:
```
kubectl describe pod <nazwa-poda>
```
Sprawdź logi aplikacji:
```
kubectl logs <nazwa-poda>
```

Uruchom terminal w kontenerze:

kubectl exec -it <nazwa-poda> -- /bin/bash

🌐 Networking w Kubernetes

Service Discovery

Kubernetes zapewnia wbudowany mechanizm odkrywania usług. Każdy Service otrzymuje wpis DNS w formie:

<service-name>.<namespace>.svc.cluster.local

Na przykład Service nginx-service w przestrzeni nazw default będzie dostępny pod adresem nginx-service.default.svc.cluster.local.

Ingress

Ingress to API obiekt zarządzający zewnętrznym dostępem do usług w klastrze, zazwyczaj poprzez HTTP/HTTPS:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

Aby Ingress działał, musisz mieć zainstalowany Ingress Controller, np. Nginx Ingress Controller lub Traefik.

Network Policies

Network Policies określają, jak Pody mogą komunikować się między sobą i z innymi punktami końcowymi sieci:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-access
spec:
  podSelector:
    matchLabels:
      app: nginx
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 80

📦 Zarządzanie stanem i danymi

Persistent Volumes (PV) i Persistent Volume Claims (PVC)

PV to kawałek pamięci w klastrze, który został udostępniony przez administratora lub dynamicznie dostarczony przez Storage Class.

PVC to żądanie takiej pamięci przez użytkownika.

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-example
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: standard
  hostPath:
    path: /data/pv0001

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-example
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
  storageClassName: standard

StatefulSets

StatefulSet to kontroler podobny do Deployment, ale zapewniający gwarancje dotyczące kolejności wdrażania i unikalności Podów:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx"
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.0
        ports:
        - containerPort: 80

StatefulSets są używane dla aplikacji, które wymagają:

Stabilnych, unikalnych identyfikatorów sieciowych
Stabilnego, trwałego przechowywania
Uporządkowanego wdrażania i skalowania
Uporządkowanego automatycznego rolowania aktualizacji

Typowe przypadki użycia to bazy danych, kolejki wiadomości i inne aplikacje stanowe.

🔐 Bezpieczeństwo Kubernetes

Role-Based Access Control (RBAC)

RBAC to mechanizm kontroli dostępu oparty na rolach:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Secrets Management

Poza wbudowanym obiektem Secret, dla bezpieczniejszego zarządzania sekretami warto rozważyć:

HashiCorp Vault
AWS Secrets Manager
Azure Key Vault
Google Secret Manager
Sealed Secrets dla Kubernetes

Security Context

Security Context określa uprawnienia i ustawienia bezpieczeństwa dla Poda lub kontenera:

apiVersion: v1
kind: Pod
metadata:
  name: security-context-demo
spec:
  securityContext:
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
  containers:
  - name: sec-ctx-demo
    image: busybox
    command: [ "sh", "-c", "sleep 1h" ]
    securityContext:
      allowPrivilegeEscalation: false
      capabilities:
        drop:
        - ALL

🔄 CI/CD z Kubernetes

GitOps

GitOps to podejście do automatyzacji ciągłej dostawy, które wykorzystuje Git jako pojedyncze źródło prawdy dla infrastruktury i aplikacji:

Wszystkie zmiany infrastruktury są wprowadzane poprzez Pull Requesty do repozytorium Git
Automatyzacja pobiera zmiany z Git i stosuje je do środowiska
System ciągle porównuje pożądany stan (Git) z aktualnym stanem i synchronizuje różnice

Popularne narzędzia GitOps:

ArgoCD
Flux CD
Jenkins X

Helm - menedżer pakietów dla Kubernetes

Helm to "menedżer pakietów" dla Kubernetes, który pomaga w definiowaniu, instalowaniu i aktualizowaniu aplikacji:

# Dodanie repozytorium
helm repo add bitnami https://charts.bitnami.com/bitnami

# Instalacja aplikacji
helm install my-wordpress bitnami/wordpress

# Aktualizacja aplikacji
helm upgrade my-wordpress bitnami/wordpress --set replicaCount=3

🌈 Opcje wdrażania Kubernetes

Kubernetes zarządzany przez dostawców chmury

Wiodący dostawcy chmury oferują zarządzane usługi Kubernetes:

Google Kubernetes Engine (GKE) - zarządzane przez Google Cloud
Amazon Elastic Kubernetes Service (EKS) - zarządzane przez AWS
Azure Kubernetes Service (AKS) - zarządzane przez Microsoft Azure
DigitalOcean Kubernetes - zarządzane przez DigitalOcean

Kubernetes on-premise

Samodzielne wdrożenie Kubernetes w środowisku lokalnym:

kubeadm - oficjalne narzędzie do tworzenia klastrów Kubernetes
kubespray - narzędzie oparte na Ansible do wdrażania produkcyjnych klastrów
k3s - lekki Kubernetes dla urządzeń brzegowych i IoT

Kubernetes distros

Istnieje wiele dystrybucji Kubernetes rozszerzających funkcjonalność:

OpenShift - dystrybucja enterprise od Red Hat
Rancher - kompletna platforma do zarządzania kontenerami
Tanzu Kubernetes Grid - dystrybucja od VMware

🔍 Monitorowanie i logowanie

Prometheus i Grafana

Prometheus to system monitorowania i alertowania, a Grafana to platforma wizualizacji:

Instalacja Prometheus i Grafana za pomocą Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack

Dostęp do Grafana:

kubectl port-forward svc/prometheus-grafana 3000:80

EFK/ELK Stack

EFK (Elasticsearch, Fluentd, Kibana) lub ELK (Elasticsearch, Logstash, Kibana) to popularne stosy do zbierania i analizy logów:

Instalacja EFK za pomocą Helm:

helm repo add elastic https://helm.elastic.co
helm install elasticsearch elastic/elasticsearch
helm install kibana elastic/kibana
helm install fluentd fluent/fluentd

Dostęp do Kibana:

kubectl port-forward svc/kibana-kibana 5601:5601

Kiali dla monitorowania service mesh

Jeśli używasz Istio jako service mesh, możesz zainstalować Kiali do monitorowania i wizualizacji:

kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.20/samples/addons/kiali.yaml

❓ FAQ - Odpowiedzi na Twoje Pytania

Czy Kubernetes jest odpowiedni dla małych projektów?
Dla małych projektów Kubernetes może być nadmiarowy. Jeśli nie potrzebujesz zaawansowanych funkcji orkiestracji, rozważ prostsze rozwiązania jak Docker Compose. Jednak nauka Kubernetes jest wartościową inwestycją, nawet jeśli zaczynasz od małych wdrożeń.

Jak Kubernetes radzi sobie z awariami węzłów?
Kubernetes ciągle monitoruje stan węzłów i Podów. Gdy węzeł przestaje działać, Kubernetes automatycznie przenosi Pody z tego węzła na działające węzły, zapewniając wysoką dostępność aplikacji. Jest to jedna z kluczowych zalet Kubernetes — samonaprawianie.

Czy mogę migrować istniejącą aplikację do Kubernetes?
Tak, ale stopień trudności zależy od architektury aplikacji. Aplikacje bezstanowe (stateless) są łatwiejsze do migracji. Aplikacje stanowe (stateful) wymagają dodatkowych rozważań związanych z trwałością danych. Warto rozważyć podejście stopniowe, zaczynając od mniej krytycznych komponentów.

Jak Kubernetes różni się od Docker Swarm?
Obie technologie służą do orkiestracji kontenerów, ale Kubernetes oferuje znacznie więcej funkcjonalności i elastyczności, co przekłada się na większą złożoność. Docker Swarm jest prostszy w konfiguracji i zarządzaniu, ale ma ograniczone możliwości w porównaniu do Kubernetes, zwłaszcza dla dużych, złożonych wdrożeń.

Jakie są typowe problemy przy wdrażaniu Kubernetes?
Najczęstsze wyzwania to:

Złożoność początkowej konfiguracji
Zarządzanie siecią i problemy z łącznością
Zarządzanie trwałym przechowywaniem danych
Monitorowanie i rozwiązywanie problemów w rozproszonym środowisku
Bezpieczeństwo i kontrola dostępu

🏁 Podsumowanie - Twoja podróż z Kubernetes

Kubernetes to potężne narzędzie, które zrewolucjonizowało sposób wdrażania aplikacji i zarządzania nimi. Na początek warto zapamiętać:

Fundament: Kubernetes to platforma do orkiestracji kontenerów, zapewniająca automatyczne skalowanie, samouzdrawianie i zarządzanie.
Struktura: System składa się z master nodes (control plane) i worker nodes, z różnymi komponentami odpowiedzialnymi za różne aspekty zarządzania.
Abstrakcje: Podstawowe obiekty jak Pods, Deployments, Services i ConfigMaps tworzą warstwę abstrakcji, która upraszcza wdrażanie i zarządzanie.
Nauka: Najlepszym sposobem nauki jest praktyka - zacznij od Minikube lokalnie, potem rozważ klaster w chmurze.
Ewolucja: Kubernetes szybko się rozwija, więc regularne śledzenie zmian i najlepszych praktyk jest ważne.

Nauka Kubernetes może początkowo wydawać się przytłaczająca, ale stopniowe podejście i regularna praktyka prowadzą do opanowania tego potężnego narzędzia.

🚀 Potrzebujesz zarządzanego środowiska Kubernetes?

Sprawdź ofertę hostingu zarządzanego IQHost

W IQHost oferujemy zarządzane platformy kontenerowe oparte na Kubernetes, które pozwalają skupić się na rozwoju aplikacji bez konieczności zarządzania infrastrukturą. Skontaktuj się z nami, aby dowiedzieć się więcej o naszych rozwiązaniach dla deweloperów i zespołów DevOps.

Kategorie i tagi

Czy ten artykuł był pomocny?

Twoja strona WordPress działa wolno?

Sprawdź nasz hosting WordPress z ultraszybkimi dyskami NVMe i konfiguracją serwera zoptymalizowaną pod kątem wydajności. Doświadcz różnicy już dziś!

Sprawdź ofertę hostingu

30-dniowa gwarancja zwrotu pieniędzy

Wprowadzenie do zarządzania kontenerami Kubernetes - Kompleksowy przewodnik