Kubernetes

20th Nov 2026

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.

Používateľ alebo CI/CD zapíše požadovaný stav do Kubernetes API, ktoré spúšťa Pody na workeroch

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.

Reconciliation loop: porovnanie požadovaného a aktuálneho stavu a vykonanie zmeny

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
  • apiVersion určuje skupinu a verziu API,
  • kind určuje typ objektu,
  • metadata obsahuje názov, namespace, labely a ďalšie identifikačné údaje,
  • spec opisuje 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.

Architektúra klastra: control plane s API serverom a etcd, worker uzly s kubeletom a Podmi

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

  1. Overte, že oba uzly sú Ready.
  2. Nájdite Pody kube-apiserver a etcd a vysvetlite, prečo bežia na control plane.
  3. 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).

Klient pristupuje cez DNS názov k Service, ktorá rozdeľuje prevádzku na Pody

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:

  • ClusterIP sprístupní službu iba v klastri a je predvoleným typom,
  • NodePort otvorí rovnaký port na každom uzle,
  • LoadBalancer požiada podporované prostredie o externý load balancer,
  • ExternalName vytvorí 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.

Ingress controller Traefik smeruje požiadavky podľa cesty na Services frontend a backend

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:

  1. zhodu hostname a cesty v Ingress,
  2. existenciu správnej IngressClass,
  3. Service a jeho port,
  4. EndpointSlices a zhodu label selectorov,
  5. pripravenosť Podov,
  6. 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.

  • emptyDir existuje 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.

Pod používa PVC naviazaný na PV, ktorý môže dynamicky vytvoriť StorageClass

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

  1. Zistite predvolenú StorageClass klastra.
  2. Vytvorte PVC a sledujte prechod stavov Pending → Bound.
  3. Zapíšte súbor do pripojeného zväzku, odstráňte Pod a overte ho v náhradnom Pode.
  4. Vysvetlite rozdiel medzi politikami Retain a Delete.

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.

Helm vytvorí z chartu a hodnôt release, ktorý cez API vytvorí objekty

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.

Controller sleduje vlastný zdroj WebApp, vytvára Deployment a Service a aktualizuje status

Obrázok 5.8: Operator pattern: controller spravuje vlastný zdroj

Pre objekt portal by controller mohol:

  1. načítať spec.image a spec.replicas,
  2. vytvoriť alebo upraviť Deployment a Service,
  3. nastaviť owner reference, aby Kubernetes poznal vlastníctvo objektov,
  4. zapisovať pozorovaný stav do status.availableReplicas,
  5. 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

  1. Aplikujte CRD a objekt WebApp a overte nové API cez kubectl api-resources.
  2. Skúste nastaviť replicas: 0 a vysvetlite chybu validácie.
  3. Overte, že nevznikol žiadny Deployment, a určte, ktorá chýbajúca súčasť by ho vytvorila.
  4. 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

  1. Vytvorte namespace kurz.
  2. Nasaďte Deployment s tromi replikami, requests, limits a probes.
  3. Sprístupnite Pody cez ClusterIP Service a overte EndpointSlices.
  4. Nainštalujte Traefik cez Helm a vytvorte Ingress s hostom mojweb.test.
  5. Otestujte smerovanie pomocou curl s hlavičkou Host.
  6. 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.
  7. Zmeňte obraz Deploymentu, sledujte rollout a vykonajte rollback.
  8. 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

Previous Post Next Post

Kubernetes