Kubernetes
Kubernetes je platforma na automatizované nasadzovanie, škálovanie a správu kontajnerizovaných aplikácií. Docker alebo iný kontajnerový runtime spustí kontajner na jednom počítači; Kubernetes koordinuje kontajnery v celom klastri. Sleduje požadovaný stav, vyberá uzly pre aplikácie, nahrádza zlyhané inštancie a poskytuje spoločné mechanizmy pre sieť, konfiguráciu a úložisko. Základné vlastnosti platformy zhŕňa oficiálny Kubernetes Overview.
Kubernetes sa niekedy označuje ako operačný systém klastra. Nenahrádza však Linux na jednotlivých uzloch. Predstavuje riadiacu vrstvu nad skupinou serverov. Základný princíp znázorňuje obrázok 5.1.
Obrázok 5.1: Kubernetes udržiava požadovaný stav Podov na pracovných uzloch
História a distribúcie
Kubernetes vychádza zo skúseností spoločnosti Google so systémami Borg a Omega. Projekt bol zverejnený v roku 2014 a v roku 2015 sa stal prvým projektom organizácie Cloud Native Computing Foundation (CNCF), čo dokumentuje história projektu CNCF. Názov pochádza z gréckeho slova pre kormidelníka; skratka K8s nahrádza osem písmen medzi K a s.
Samotný Kubernetes je open-source projekt. V praxi sa s ním stretávame v rôznych podobách:
| Podoba | Príklady | Typické použitie |
|---|---|---|
| upstream nástroje | kubeadm |
vlastný klaster a výučba komponentov |
| lokálne prostredie | kind, minikube | vývoj a krátke experimenty |
| ľahká distribúcia | k3s | edge, laboratóriá, menšie inštalácie |
| podniková platforma | Red Hat OpenShift | Kubernetes doplnený o nástroje a podporu |
| spravovaná služba | AKS, EKS, GKE | control plane prevádzkuje poskytovateľ klaudu |
Distribúcie používajú rovnaké základné Kubernetes API, ale líšia sa spôsobom inštalácie, aktualizácií, sieťovania, úložiska a podpory. Manifest Deployment je preto spravidla prenositeľný, zatiaľ čo StorageClass alebo Service typu LoadBalancer závisia od konkrétneho prostredia.
Deklaratívny model
Kubernetes pracuje prevažne deklaratívne. Používateľ neopisuje sériu príkazov, ale požadovaný stav. Controllery porovnávajú požadovaný a aktuálny stav a opakovane ich približujú. Tento proces sa nazýva reconciliation loop; jeho princíp opisuje dokumentácia Kubernetes controllers.
Ak má mať Deployment tri repliky a jeden Pod zlyhá, controller vytvorí náhradu. Kubernetes neopravuje pôvodný kontajner; vytvorí nový objekt podľa deklarácie. Tento cyklus znázorňuje obrázok 5.2.
Obrázok 5.2: Reconciliation loop
Každý objekt odosielaný do API má štyri základné časti:
apiVersion: v1
kind: Pod
metadata:
name: web
namespace: kurz
labels:
app: web
spec:
containers:
- name: nginx
image: nginx:1.27-alpine
ports:
- containerPort: 80
apiVersionurčuje skupinu a verziu API,kindurčuje typ objektu,metadataobsahuje názov, namespace, labely a ďalšie identifikačné údaje,specopisuje požadovaný stav.
Mnohé objekty majú aj časť status. Tú spravidla zapisuje Kubernetes a zobrazuje pozorovaný stav objektu.
Konfiguráciu možno vytvárať imperatívnymi príkazmi alebo deklaratívne pomocou súborov:
kubectl create namespace kurz
kubectl apply -f aplikacia.yaml
kubectl get pods -n kurz
kubectl describe pod web -n kurz
kubectl delete -f aplikacia.yaml
Deklaratívne manifesty možno verzovať v Git repozitári a opakovane aplikovať. Príkaz apply preto uprednostňujeme pri správe aplikácií.
Architektúra klastra
Klaster tvoria uzly riadiacej vrstvy (control plane) a pracovné uzly (worker nodes). Aktuálny prehľad úloh jednotlivých komponentov je v dokumentácii Kubernetes Components. Hlavné komponenty klastra znázorňuje obrázok 5.3.
Obrázok 5.3: Architektúra klastra Kubernetes
Komponenty control plane
- kube-apiserver poskytuje Kubernetes API, overuje požiadavky a je centrálnym bodom komunikácie.
- etcd je distribuované key-value úložisko stavu klastra. Jeho záloha je zásadná pre obnovu vlastného klastra.
- kube-scheduler vyberá vhodný uzol pre nový Pod podľa zdrojov a pravidiel plánovania.
- kube-controller-manager spúšťa controllery, ktoré udržiavajú požadovaný stav.
- cloud-controller-manager prepája klaster s API poskytovateľa klaudu, ak ho prostredie používa.
Komponenty pracovného uzla
- kubelet sleduje Pody pridelené uzlu a komunikuje s container runtime cez CRI.
- container runtime, napríklad
containerd, sťahuje obrazy a spúšťa kontajnery. - kube-proxy alebo funkčne zodpovedajúca implementácia zabezpečuje smerovanie pre Services.
- CNI plugin vytvára sieť Podov. Kubernetes API definuje sieťový model, ale dátovú vrstvu musí dodať plugin.
Namespace, label a selector
Namespace logicky rozdeľuje objekty v jednom klastri. Nie je sám osebe úplnou bezpečnostnou hranicou, ale pomáha oddeliť tímy a prostredia.
apiVersion: v1
kind: Namespace
metadata:
name: kurz
Label je dvojica kľúč–hodnota pripojená k objektu. Selector podľa labelov vyberá objekty. Deployment aj Service v ďalších príkladoch používajú label app: web; nezhoda selectorov je častým dôvodom nefunkčnej služby.
kubectl apply -f namespace.yaml
kubectl get pods -n kurz -l app=web
Inštalácia klastra pomocou kubeadm
Nasledujúce praktické cvičenie vytvorí vzdelávací klaster s jedným control-plane a jedným worker uzlom. Nie je to produkčný návrh s vysokou dostupnosťou.
Predpoklady praktického cvičenia
- dve virtuálne zariadenia s Ubuntu Server 24.04 LTS,
- aspoň 2 CPU a 2 GiB RAM pre control plane,
- vzájomná sieťová dostupnosť a unikátne hostname,
- prístup používateľa cez
sudo, - Kubernetes 1.37.x a zapnuté cgroups v2.
Príklady používajú názvy k8s-control a k8s-worker. Podsieť Podov 192.168.0.0/16 sa nesmie prekrývať so sieťou hostiteľov.
1. Príprava oboch uzlov
Kubelet štandardne vyžaduje vypnutý swap:
sudo swapoff -a
Trvalé vypnutie swapu sa robí úpravou /etc/fstab; pred zmenou treba vytvoriť zálohu a zakomentovať iba riadok používaného swapu.
Zapneme preposielanie IPv4 paketov a načítame moduly, ktoré sieťovanie kontajnerov bežne potrebuje:
sudo modprobe overlay
sudo modprobe br_netfilter
sudo tee /etc/modules-load.d/k8s.conf >/dev/null <<'EOF'
overlay
br_netfilter
EOF
sudo tee /etc/sysctl.d/k8s.conf >/dev/null <<'EOF'
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --system
Na oboch uzloch nainštalujte a nastavte containerd:
sudo apt-get update
sudo apt-get install -y containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd
Balíky Kubernetes sa inštalujú z repozitára príslušnej minor verzie. Na oboch uzloch:
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key \
| sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /' \
| sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
Verzie overte:
kubeadm version
kubectl version --client
containerd --version
2. Inicializácia control plane
Na uzle k8s-control:
sudo kubeadm init --pod-network-cidr=192.168.0.0/16
Po úspešnom dokončení nakonfigurujeme kubectl pre bežného používateľa:
mkdir -p "$HOME/.kube"
sudo cp -i /etc/kubernetes/admin.conf "$HOME/.kube/config"
sudo chown "$(id -u):$(id -g)" "$HOME/.kube/config"
Príkaz kubeadm init vypíše príkaz kubeadm join. Obsahuje bootstrap token, preto ho nezverejňujeme. Nový príkaz možno vytvoriť na control plane:
kubeadm token create --print-join-command
3. Inštalácia siete Podov
Bez CNI pluginu zostane CoreDNS v stave Pending a uzol nemusí byť Ready. Pri praktickom cvičení použite Calico 3.32.2 s predvoleným rozsahom 192.168.0.0/16:
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.32.2/manifests/calico.yaml
kubectl get pods -n kube-system -l k8s-app=calico-node
Manifest je pripnutý na konkrétnu verziu, aby bolo praktické cvičenie opakovateľné. Pred neskorším použitím treba v dokumentácii Calico overiť podporované verzie Kubernetes. Zmenu Pod CIDR v kubeadm init treba premietnuť aj do konfigurácie CNI.
4. Pripojenie worker uzla
Na uzle k8s-worker spustite príkaz vygenerovaný control plane:
sudo kubeadm join <CONTROL_PLANE_IP>:6443 \
--token <TOKEN> \
--discovery-token-ca-cert-hash sha256:<HASH>
Na control plane overte klaster:
kubectl get nodes -o wide
kubectl get pods -A
kubectl cluster-info
Úspešný výsledok obsahuje oba uzly v stave Ready a systémové Pody v stave Running. Pri problémoch pomôžu kubectl describe node <NAZOV>, sudo journalctl -u kubelet a kontrola prekrytia sieťových rozsahov.
Príkaz sudo kubeadm reset odstraňuje lokálnu konfiguráciu klastra. Používa sa iba na testovacích uzloch, ktorých dáta už nepotrebujeme; nemusí automaticky odstrániť konfiguráciu CNI ani používateľský kubeconfig.
Kontrolná úloha
- Overte, že oba uzly sú
Ready. - Nájdite Pody
kube-apiserveraetcda vysvetlite, prečo bežia na control plane. - Nájdite CoreDNS a skontrolujte jeho logy.
Pody a správa aplikácie
Pod
Pod je najmenšia plánovateľná jednotka. Jeden Pod môže obsahovať viac kontajnerov, ktoré zdieľajú sieťový namespace a komunikujú cez localhost. Bežne obsahuje jeden hlavný aplikačný kontajner a prípadne pomocné kontajnery.
Samostatný Pod nie je vhodný na produkčné nasadenie: po odstránení ho žiadny vyšší controller neobnoví. Používa sa najmä na experimenty a diagnostiku.
Deployment a ReplicaSet
Deployment spravuje ReplicaSet a ten udržiava požadovaný počet Podov. Deployment navyše podporuje riadené aktualizácie a návrat na predchádzajúcu revíziu.
apiVersion: apps/v1
kind: Deployment
metadata:
name: web
namespace: kurz
spec:
replicas: 3
selector:
matchLabels:
app: web
template:
metadata:
labels:
app: web
spec:
containers:
- name: nginx
image: nginx:1.27-alpine
ports:
- name: http
containerPort: 80
resources:
requests:
cpu: 50m
memory: 32Mi
limits:
cpu: 200m
memory: 128Mi
readinessProbe:
httpGet:
path: /
port: http
initialDelaySeconds: 2
periodSeconds: 5
livenessProbe:
httpGet:
path: /
port: http
initialDelaySeconds: 10
periodSeconds: 10
requests pomáhajú scheduleru vybrať uzol, limits obmedzujú spotrebu a probes rozlišujú pripravenosť prijímať prevádzku od potreby reštartovať kontajner.
kubectl apply -f deployment.yaml
kubectl get deployment,replicaset,pods -n kurz
kubectl scale deployment web --replicas=5 -n kurz
kubectl set image deployment/web nginx=nginx:1.28-alpine -n kurz
kubectl rollout status deployment/web -n kurz
kubectl rollout history deployment/web -n kurz
kubectl rollout undo deployment/web -n kurz
Zmena vykonaná príkazom scale alebo set image sa stratí po opätovnom aplikovaní manifestu so starými hodnotami. Zdroj pravdy preto treba upravovať v Git repozitári.
Konfigurácia aplikácie
ConfigMap uchováva necitlivú konfiguráciu. Secret je určený pre citlivé hodnoty, ale jeho hodnoty v YAML sú iba kódované pomocou Base64, nie automaticky šifrované.
apiVersion: v1
kind: ConfigMap
metadata:
name: web-config
namespace: kurz
data:
APP_MODE: production
---
apiVersion: v1
kind: Secret
metadata:
name: web-secret
namespace: kurz
type: Opaque
stringData:
API_TOKEN: zmen-ma
Skutočné tajomstvá neukladáme do Git repozitára. Produkcia vyžaduje RBAC s minimálnymi oprávneniami, šifrovanie dát v etcd a vhodný systém správy tajomstiev.
Sieťovanie a Service
Každý Pod dostane vlastnú IP adresu, ktorá sa môže po nahradení Podu zmeniť. Service poskytuje stabilnú virtuálnu IP a DNS názov nad meniacou sa skupinou Podov. EndpointSlice eviduje aktuálne backendy vybrané selectorom (obrázok 5.4).
Obrázok 5.4: Service ako stabilný sieťový bod pred skupinou Podov
apiVersion: v1
kind: Service
metadata:
name: web
namespace: kurz
spec:
selector:
app: web
ports:
- name: http
port: 80
targetPort: http
type: ClusterIP
Typy Service:
ClusterIPsprístupní službu iba v klastri a je predvoleným typom,NodePortotvorí rovnaký port na každom uzle,LoadBalancerpožiada podporované prostredie o externý load balancer,ExternalNamevytvorí DNS alias na externý názov.
LoadBalancer sám o sebe nezaručí externú IP v lokálnom alebo bare-metal klastri. Tú musí dodať cloud controller alebo samostatná implementácia, napríklad MetalLB.
kubectl apply -f service.yaml
kubectl get service,endpointslice -n kurz
kubectl port-forward service/web 8080:80 -n kurz
curl http://localhost:8080
Kontrolná úloha
Odstráňte jeden Pod Deploymentu, sledujte vznik náhrady a overte, že DNS názov a Service zostali rovnaké.
Ingress a Ingress controller
Ingress je Kubernetes API objekt s pravidlami pre HTTP a HTTPS. Ingress controller je bežiaci program, ktorý tieto pravidlá sleduje a realizuje. Vytvorenie samotného objektu Ingress bez controllera prevádzku nesprístupní. Smerovanie požiadaviek znázorňuje obrázok 5.5.
Obrázok 5.5: Smerovanie HTTP požiadaviek cez Ingress controller
Ingress môže poskytovať smerovanie podľa hostname a cesty, TLS termináciu a zdieľanie jedného vstupného bodu viacerými službami. Ľubovoľné TCP/UDP protokoly štandardný Ingress nerieši.
IngressClass
V klastri môže bežať viac controllerov. IngressClass a pole ingressClassName určujú, ktorý z nich spracuje konkrétny Ingress. Controller pritom môže vytvárať alebo konfigurovať proxy, edge router či klaudový load balancer.
Praktické cvičenie s Traefikom
Ingress NGINX bol v marci 2026 vyradený a už nedostáva bezpečnostné opravy. V nových inštaláciách ho preto nepoužívame. Praktické cvičenie využíva udržiavaný Traefik nainštalovaný oficiálnym Helm chartom:
helm version
helm repo add traefik https://traefik.github.io/charts
helm repo update
helm install traefik traefik/traefik \
--namespace traefik \
--create-namespace \
--wait
kubectl get pods,service -n traefik
kubectl get ingressclass
Pred vytvorením pravidiel pripravte dve jednoduché testovacie služby:
kubectl create deployment frontend --image=traefik/whoami -n kurz
kubectl expose deployment frontend --port=80 --target-port=80 -n kurz
kubectl create deployment backend --image=traefik/whoami -n kurz
kubectl expose deployment backend --port=80 --target-port=80 -n kurz
kubectl rollout status deployment/frontend -n kurz
kubectl rollout status deployment/backend -n kurz
Konkrétny spôsob prístupu k Traefiku závisí od prostredia. V klaude môže jeho Service získať externú IP; v klastri kubeadm bez implementácie LoadBalancer spustite na pracovnej stanici presmerovanie portu:
kubectl port-forward service/traefik 8080:80 -n traefik
Nasledujúci Ingress smeruje dve URL cesty na dve Services, ktoré musia existovať v rovnakom namespace:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: aplikacia
namespace: kurz
spec:
ingressClassName: traefik
rules:
- host: mojweb.test
http:
paths:
- path: /api
pathType: Prefix
backend:
service:
name: backend
port:
number: 80
- path: /
pathType: Prefix
backend:
service:
name: frontend
port:
number: 80
Pravidlo Prefix porovnáva celé segmenty cesty. Pri viacerých zhodách má prednosť najdlhšia zodpovedajúca cesta a následne presnejší typ zhody.
kubectl apply -f ingress.yaml
kubectl get ingress -n kurz
kubectl describe ingress aplikacia -n kurz
curl -H 'Host: mojweb.test' http://localhost:8080/
curl -H 'Host: mojweb.test' http://localhost:8080/api
Pre HTTPS Ingress odkazuje na Secret typu kubernetes.io/tls:
spec:
tls:
- hosts:
- mojweb.test
secretName: mojweb-tls
Certifikát musí byť v rovnakom namespace ako Ingress. V produkcii sa jeho vydávanie a obnova často automatizujú samostatným controllerom, napríklad cert-managerom.
Pri diagnostike kontrolujeme:
- zhodu hostname a cesty v Ingress,
- existenciu správnej
IngressClass, - Service a jeho port,
- EndpointSlices a zhodu label selectorov,
- pripravenosť Podov,
- logy Ingress controllera.
Ingress a Gateway API
Ingress API je stabilné a zostáva podporované, ale je zmrazené. Kubernetes odporúča pre nové pokročilé riešenia Gateway API. To oddeľuje infraštruktúru (GatewayClass, Gateway) od aplikačných trás (HTTPRoute) a ponúka rozšíriteľnejší model oprávnení a routovania. Nie každý klaster má Gateway API nainštalované; ide o rodinu CRD, ktoré musí dodať implementácia.
Úložisko
Zapisovateľná vrstva kontajnera a väčšina dát viazaných na Pod sú dočasné. Trvalé dáta preto oddeľujeme od životného cyklu Podu.
emptyDirexistuje počas života Podu a môže ho zdieľať viac kontajnerov v Pode,- PersistentVolume (PV) reprezentuje úložnú kapacitu v klastri,
- PersistentVolumeClaim (PVC) je požiadavka aplikácie na kapacitu,
- StorageClass opisuje spôsob dynamického vytvorenia úložiska,
- CSI driver prepája Kubernetes s konkrétnym úložným systémom.
PV je objekt platný pre celý klaster, zatiaľ čo PVC patrí do namespace aplikácie. Pod môže použiť iba PVC zo svojho namespace. Vzťah týchto objektov znázorňuje obrázok 5.6.
Obrázok 5.6: Pod, PersistentVolumeClaim, PersistentVolume a StorageClass
Statické pridelenie
Administrátor najprv vytvorí PV a aplikácia následne PVC s kompatibilnou kapacitou, access mode a triedou. hostPath v príklade je vhodný iba pre jednouzlový lab: viaže dáta na konkrétny uzol.
apiVersion: v1
kind: PersistentVolume
metadata:
name: kurz-pv
spec:
capacity:
storage: 1Gi
accessModes:
- ReadWriteOnce
persistentVolumeReclaimPolicy: Retain
storageClassName: manual
hostPath:
path: /srv/kurz-data
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: kurz-pvc
namespace: kurz
spec:
accessModes:
- ReadWriteOnce
storageClassName: manual
resources:
requests:
storage: 1Gi
ReadWriteOnce znamená pripojenie na zápis z jedného uzla, nie nevyhnutne jedného Podu. Dostupné režimy a správanie závisia od CSI drivera. Reclaim policy Retain ponechá PV a dáta po odstránení PVC; Delete môže odstrániť aj pridelené úložisko.
Dynamické pridelenie
Pri dynamickom pridelení vytvorí provisioner PV podľa StorageClass:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: databaza-data
namespace: kurz
spec:
accessModes:
- ReadWriteOnce
storageClassName: standard
resources:
requests:
storage: 5Gi
Názov standard je iba príklad. Dostupné triedy overte príkazom kubectl get storageclass; kubeadm sám StorageClass ani CSI driver neinštaluje. V čistom klastri kubeadm preto použite statický PV alebo najprv podľa dokumentácie prostredia nainštalujte vhodný CSI provisioner.
StatefulSet
StatefulSet je určený pre aplikácie, ktoré potrebujú stabilnú identitu, usporiadané operácie alebo samostatné zväzky pre jednotlivé repliky. Neznamená automaticky, že databáza je správne replikovaná alebo zálohovaná.
apiVersion: v1
kind: Service
metadata:
name: data
namespace: kurz
spec:
clusterIP: None
selector:
app: data
ports:
- name: http
port: 80
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: data
namespace: kurz
spec:
serviceName: data
replicas: 2
selector:
matchLabels:
app: data
template:
metadata:
labels:
app: data
spec:
containers:
- name: app
image: nginx:1.27-alpine
volumeMounts:
- name: obsah
mountPath: /usr/share/nginx/html
volumeClaimTemplates:
- metadata:
name: obsah
spec:
accessModes:
- ReadWriteOnce
storageClassName: standard
resources:
requests:
storage: 1Gi
Pody dostanú stabilné názvy data-0, data-1 a každý vlastný PVC. Pre stabilné DNS identity StatefulSetu sa bežne vytvára headless Service (clusterIP: None).
Kontrolná úloha
- Zistite predvolenú StorageClass klastra.
- Vytvorte PVC a sledujte prechod stavov
Pending→Bound. - Zapíšte súbor do pripojeného zväzku, odstráňte Pod a overte ho v náhradnom Pode.
- Vysvetlite rozdiel medzi politikami
RetainaDelete.
Helm
Helm je správca balíkov pre Kubernetes. Chart obsahuje šablóny manifestov, predvolené hodnoty a metadata. Konkrétna inštalácia chartu sa nazýva release.
Praktické cvičenie predpokladá Helm 4.x. Klienta nainštalujte podľa aktuálneho postupu pre operačný systém z oficiálnej dokumentácie Helm a verziu overte príkazom helm version.
Vzťah chartu, hodnôt a release znázorňuje obrázok 5.7.
Obrázok 5.7: Nasadenie aplikácie pomocou Helm chartu
Základný pracovný postup:
helm repo add <NAZOV> <URL_REPOZITARA>
helm repo update
helm search repo <NAZOV_BALIKA>
helm show values <REPOZITAR>/<CHART>
helm install moja-aplikacia <REPOZITAR>/<CHART> \
--namespace kurz --create-namespace -f values.yaml --wait
helm list -n kurz
helm upgrade moja-aplikacia <REPOZITAR>/<CHART> \
--namespace kurz -f values.yaml --wait
helm history moja-aplikacia -n kurz
helm rollback moja-aplikacia 1 -n kurz
helm uninstall moja-aplikacia -n kurz
Pred inštaláciou cudzieho chartu skontrolujte jeho zdroj, hodnoty, vytvárané oprávnenia a CRD. Renderované manifesty možno prezrieť bez inštalácie:
helm template moja-aplikacia <REPOZITAR>/<CHART> -f values.yaml
Helm neodstraňuje automaticky všetky dáta aplikácie a CRD majú osobitný životný cyklus. Pred uninstall preto treba skontrolovať PVC, reclaim policy a dokumentáciu chartu.
CustomResourceDefinition a operátory
Kubernetes API možno rozšíriť vlastnými typmi. CustomResourceDefinition (CRD) zaregistruje nový typ; jeho konkrétny objekt je custom resource (CR).
Príklad CRD
Nasledujúci CRD pridá namespaced typ WebApp. OpenAPI schéma overí povinné polia a povolené hodnoty.
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: webapps.studium.example
spec:
group: studium.example
scope: Namespaced
names:
plural: webapps
singular: webapp
kind: WebApp
shortNames:
- wa
versions:
- name: v1
served: true
storage: true
schema:
openAPIV3Schema:
type: object
required:
- spec
properties:
spec:
type: object
required:
- image
properties:
image:
type: string
minLength: 1
replicas:
type: integer
minimum: 1
maximum: 10
default: 1
status:
type: object
properties:
availableReplicas:
type: integer
subresources:
status: {}
additionalPrinterColumns:
- name: Image
type: string
jsonPath: .spec.image
- name: Replicas
type: integer
jsonPath: .spec.replicas
Po registrácii možno vytvoriť vlastný objekt podobne ako vstavané objekty:
apiVersion: studium.example/v1
kind: WebApp
metadata:
name: portal
namespace: kurz
spec:
image: nginx:1.27-alpine
replicas: 3
kubectl apply -f webapp-crd.yaml
kubectl apply -f webapp.yaml
kubectl get webapps -n kurz
kubectl describe webapp portal -n kurz
kubectl api-resources --api-group=studium.example
CRD zabezpečí uloženie, validáciu a sprístupnenie objektu cez Kubernetes API. Samotné CRD však nevytvorí Deployment ani Pody.
Controller a Operator pattern
Custom controller sleduje objekty a zosúlaďuje ich stav. Operator kombinuje CRD s controllerom a zapisuje do automatizácie prevádzkové znalosti, ktoré by inak vykonával človek: nasadenie, aktualizáciu, zálohu, obnovu alebo zmenu konfigurácie. Spoluprácu controllera s vlastným zdrojom znázorňuje obrázok 5.8.
Obrázok 5.8: Operator pattern: controller spravuje vlastný zdroj
Pre objekt portal by controller mohol:
- načítať
spec.imageaspec.replicas, - vytvoriť alebo upraviť Deployment a Service,
- nastaviť owner reference, aby Kubernetes poznal vlastníctvo objektov,
- zapisovať pozorovaný stav do
status.availableReplicas, - operáciu bezpečne opakovať pri každej udalosti.
Controller musí počítať s opakovaným spustením a dosiahnuť rovnaký výsledok aj po prerušení. Potrebuje iba nevyhnutné RBAC oprávnenia. CRD nie je vhodné používať ako databázu aplikačných dát alebo monitorovacích udalostí.
Operator Framework a jeho Operator SDK pomáhajú vytvárať, testovať a baliť operátory. Nie každý Helm chart je operátor: chart rendruje a nasadzuje objekty, zatiaľ čo operátor nepretržite reaguje na zmeny a riadi životný cyklus aplikácie.
Kontrolná úloha
- Aplikujte CRD a objekt
WebAppa overte nové API cezkubectl api-resources. - Skúste nastaviť
replicas: 0a vysvetlite chybu validácie. - Overte, že nevznikol žiadny Deployment, a určte, ktorá chýbajúca súčasť by ho vytvorila.
- Pred odstránením CRD odstráňte testovacie custom resources. Odstránenie CRD odstráni aj všetky uložené objekty daného typu.
Súhrnný scenár praktického cvičenia
- Vytvorte namespace
kurz. - Nasaďte Deployment s tromi replikami, requests, limits a probes.
- Sprístupnite Pody cez ClusterIP Service a overte EndpointSlices.
- Nainštalujte Traefik cez Helm a vytvorte Ingress s hostom
mojweb.test. - Otestujte smerovanie pomocou
curls hlavičkouHost. - Pripojte statický PVC z príkladu v praktickom cvičení alebo PVC dostupnej StorageClass a overte pretrvanie dát po nahradení Podu na uzle s daným úložiskom.
- Zmeňte obraz Deploymentu, sledujte rollout a vykonajte rollback.
- Vytvorte CRD
WebApp, jeho inštanciu a vysvetlite, prečo bez controllera nevznikne aplikácia.
Za úspešný výsledok sa považuje stav Ready na oboch uzloch, dostupné Pody, Service s neprázdnym EndpointSlice, funkčná odpoveď cez Ingress a PVC v stave Bound.
Zhrnutie
Kubernetes udržiava deklarovaný stav aplikácií pomocou API a controllerov. Deployment rieši bezstavové repliky a aktualizácie, Service poskytuje stabilný sieťový bod, Ingress controller realizuje HTTP/HTTPS pravidlá a PV/PVC oddeľujú dáta od životného cyklu Podov. Helm balí a nasadzuje súvisiace objekty. CRD rozširuje Kubernetes API a spolu s controllerom vytvára Operator pattern pre automatizáciu zložitej prevádzky.
Pri produkčnom návrhu treba nad rámec tejto kapitoly riešiť vysokú dostupnosť control plane, RBAC, NetworkPolicy, správu tajomstiev, zálohy etcd a dát, monitoring, aktualizácie a obnovu po havárii. RBAC, správe tajomstiev, NetworkPolicy a Pod Security sa venuje kapitola Bezpečnosť a správa identít.
Odporúčaná literatúra
- Dokumentácia Kubernetes
- CNCF: Kubernetes – project overview
- Vytvorenie klastra pomocou kubeadm
- Ingress a Ingress controllers
- Custom resources
- Dokumentácia Helm
- Dokumentácia Calico
- Traefik na Kubernetes
- Brendan Burns, Joe Beda, Kelsey Hightower, Lachlan Evenson: Kubernetes: Up and Running, 3. vydanie, O'Reilly Media, 2022
- Bilgin Ibryam, Roland Huß: Kubernetes Patterns, 2. vydanie, O'Reilly Media, 2023