Saját Kubernetes fürt építése bare metal szervereken

Üdvözöllek, tech-rajongó és felhőinfrastruktúra-építő! Képzeld el, hogy teljes kontrollt gyakorolsz a konténerizált alkalmazásaid felett, anélkül, hogy drága felhőszolgáltatókra lennél utalva. Elérhető teljesítmény, maximális testreszabhatóság és egy mélyreható tanulási élmény – mindez lehetséges, ha belemerülsz a bare metal Kubernetes fürt építésének izgalmas világába. Ebben a cikkben részletesen végigvezetünk téged ezen a komplex, mégis rendkívül kifizetődő úton, hogy te is büszkén elmondhasd: „Ez az én Kubernetesem!”

Miért éppen Bare Metal Kubernetes? A Teljes Kontroll Varázsa

Sokan választják a nagy felhőszolgáltatók (AWS, Azure, GCP) menedzselt Kubernetes szolgáltatásait (EKS, AKS, GKE) a kényelem miatt. Ez valóban remek megoldás, ha gyorsan szeretnél indulni, és nem akarsz az infrastruktúrával bajlódni. De miért mennél a nehezebb úton, és építenél saját fürtöt fizikai szerverekre? Íme néhány nyomós érv:

Költséghatékonyság: Hosszú távon, ha már rendelkezel saját szerverekkel, vagy olcsón be tudsz szerezni használt hardvert, a bare metal megoldás jelentősen olcsóbb lehet, mint a folyamatos felhőalapú erőforrások bérlése. Nincsenek óradíjak, sávszélesség-díjak vagy rejtett költségek.
Teljesítmény: A fizikai szerverek közvetlenül, virtualizációs réteg nélkül kínálnak nyers CPU, RAM és I/O teljesítményt. Ez kritikus lehet nagy teljesítményigényű alkalmazások, adatbázisok vagy gépi tanulási feladatok esetén.
Testreszabhatóság és Kontroll: Te döntesz mindenről! A hálózati beállításoktól kezdve, a tárolási megoldásokon át, egészen az operációs rendszerig és a Kubernetes komponensek verziójáig. Nincsenek korlátok, amelyeket egy felhőszolgáltató szabna.
Biztonság: A saját infrastruktúrád feletti teljes kontroll lehetővé teszi, hogy a legszigorúbb biztonsági irányelveket is alkalmazhasd, anélkül, hogy egy külső szolgáltató biztonsági modelljére kellene támaszkodnod.
Tudás és Tapasztalat: Ez a projekt egyedülálló tanulási lehetőséget kínál. Mélyrehatóan megismered a Kubernetes architektúráját, a hálózatépítést, a tárolási mechanizmusokat és a Linux operációs rendszert. Ez a tudás felbecsülhetetlen értékű a karriered szempontjából.

Előkészületek és Tervezés: A Fundamentumok Letétele

Mielőtt beleugranánk a mélyvízbe, alaposan meg kell tervezni a projektet. A gondos előkészítés a siker záloga!

Hardverkövetelmények: Mire lesz szükséged?

Szerverek: Minimum két, de ideális esetben három vagy több fizikai szerverre lesz szükséged. Egy lesz a kontroll sík (master node), a többi pedig a munkás csomópont (worker node). Magas rendelkezésre állás (HA) érdekében érdemes legalább három kontroll sík csomópontot tervezni.
CPU és RAM: A kontroll sík csomópontoknak minimum 2 CPU magra és 2 GB RAM-ra van szükségük (ez a Kubernetes minimális követelménye, de 4 GB ajánlott). A munkás csomópontok teljesítménye az alkalmazásaid igényeitől függ, de itt is a 2 CPU mag és 4 GB RAM az ajánlott kiindulópont.
Tárolás: Minden szerverhez egy SSD meghajtó ajánlott az operációs rendszernek és a konténerképeknek. A perzisztens tárolás (Persistent Storage) számára különálló meghajtókra vagy egy hálózati tárolási megoldásra (NFS, Ceph) is szükség lehet.
Hálózat: Legalább egy Gigabites Ethernet port minden szerverhez. Egy megbízható switch és a megfelelő hálózati kábelezés elengedhetetlen. Statikus IP-címek kiosztása minden szervernek erősen ajánlott.

Szoftverek és Operációs Rendszer: Az Alapok

Operációs Rendszer: Valamilyen Linux disztribúcióra lesz szükséged. Az Ubuntu Server (LTS verzió) a legnépszerűbb és leginkább dokumentált választás a Kubernetes-hez, de a Debian vagy CentOS is szóba jöhet.
Konténer Futtatókörnyezet: A Kubernetes-nek szüksége van egy konténer futtatókörnyezetre (Container Runtime). A Docker egykor standard volt, de ma már a containerd vagy a CRI-O az ajánlott megoldás. A containerd könnyebb és közvetlenül a Kubernetes CRI (Container Runtime Interface) API-ját használja.
Kubernetes Eszközök: A kubeadm, kubelet és kubectl binárisokra lesz szükséged. Ezek segítik a fürt telepítését, kezelését és kommunikációját.

Hálózati Terv: Statikus IP-k és DNS

Készíts egy táblázatot a szervereidről, a hozzájuk rendelt IP-címekről (mindegyik statikus legyen!) és a hosztnevekről. Például:

| Szerep        | Hosztnév     | IP-cím       |
|---------------|--------------|--------------|
| Kontroll Sík 1| k8s-master-01| 192.168.1.100|
| Munkás Csomópont 1| k8s-worker-01| 192.168.1.101|
| Munkás Csomópont 2| k8s-worker-02| 192.168.1.102|

Győződj meg róla, hogy az összes szerver lássa egymást a hálózaton, és fel tudja oldani egymás hosztneveit (akár a /etc/hosts fájlban, akár egy DNS szerveren keresztül).

A Kubernetes Fürt Építése: Lépésről Lépésre

Most, hogy mindent előkészítettünk, jöhet a tényleges munka!

1. Minden Szerver Előkészítése

Ezeket a lépéseket minden egyes szerveren végre kell hajtanod (kontroll sík és munkás csomópontokon is).

1.1. Operációs Rendszer Telepítése és Frissítése

Telepítsd a választott Linux disztribúciót (pl. Ubuntu Server LTS). Győződj meg róla, hogy minden naprakész:

sudo apt update && sudo apt upgrade -y

1.2. Hálózat Konfigurálása

Állítsd be a statikus IP-címeket, ha még nem tetted meg az OS telepítésekor. Győződj meg róla, hogy a szerverek fel tudják oldani egymás hosztneveit.

1.3. Swap Letiltása

A Kubernetes nem szereti a swap-et, ezért minden szerveren tiltsd le:

sudo swapoff -a
sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab

1.4. Kernel Modulok és Sysctl Beállítások

A Kubernetes hálózati funkcióinak megfelelő működéséhez be kell tölteni bizonyos kernel modulokat és módosítani kell a sysctl beállításokat. Ez lehetővé teszi a konténerek számára, hogy a bridge hálózaton keresztül kommunikáljanak.

# Kernel modulok betöltése
sudo modprobe overlay
sudo modprobe br_netfilter

# Állandósítás
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

# Sysctl paraméterek beállítása
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

1.5. Konténer Futtatókörnyezet Telepítése (pl. containerd)

A containerd telepítése és konfigurálása:

# Telepítés
sudo apt update
sudo apt install -y ca-certificates curl gnupg lsb-release

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

echo 
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu 
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y containerd.io

# Alapértelmezett konfiguráció generálása
sudo containerd config default | sudo tee /etc/containerd/config.toml >/dev/null

# Rendszerd meghajtó használatának beállítása (cgroup driver)
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

# A containerd újraindítása
sudo systemctl restart containerd
sudo systemctl enable containerd

1.6. kubeadm, kubelet, kubectl Telepítése

Ezek az eszközök elengedhetetlenek a Kubernetes fürt kezeléséhez.

# GPG kulcs hozzáadása
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

# Kubernetes repository hozzáadása
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

2. A Kontroll Sík Inicializálása (Csak a Master Csomóponton)

Most jön a legizgalmasabb rész: a Kubernetes kontroll sík elindítása az első master csomóponton (pl. k8s-master-01).

sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.1.100

--pod-network-cidr: Ez a Pod hálózat CIDR-je. Fontos, hogy ezt a tartományt ne használja semmi más a hálózatodon. A 10.244.0.0/16 a Flannel CNI plugin alapértelmezett tartománya. Ha más CNI-t használsz, ellenőrizd az ajánlott CIDR-t.
--apiserver-advertise-address: Itt a master csomópont statikus IP-címét kell megadnod.

Sikeres inicializálás után a kubeadm kiír néhány fontos parancsot. Jegyezd fel őket! Különösen a következőket:

A kubectl konfigurálásához szükséges parancsok a felhasználói fiókod számára (ezeket a parancsokat futtasd a master csomóponton a saját felhasználód nevében):
```
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
A munkás csomópontok csatlakozásához szükséges kubeadm join parancs. Ezt egyből másold is ki magadnak! Valahogy így fog kinézni:
```
sudo kubeadm join 192.168.1.100:6443 --token abcdef.0123456789abcdef 
    --discovery-token-ca-cert-hash sha256:72c841e7f59d5b0c9a9d2d0b5e0c5d2e0f5d0c0b0a0f0d0e0c0f0d0e0c0f0d0e
```
Ha véletlenül elfelejted, a sudo kubeadm token create --print-join-command paranccsal újra lekérheted.

3. Hálózati Plugin (CNI) Telepítése

A Podok közötti kommunikációhoz szükség van egy CNI (Container Network Interface) pluginra. Enélkül a Podok nem tudnak egymással beszélni, és a fürt nem lesz Ready állapotban.

Az egyik legnépszerűbb és könnyen telepíthető CNI a Calico vagy a Flannel. A kubeadm init során megadott CIDR alapján érdemes választani. Ha 10.244.0.0/16-ot adtál meg, a Flannel jó választás:

# Flannel telepítése
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

Ha Calico-t szeretnél:

# Calico telepítése
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

(Ellenőrizd a Calico dokumentációját a legfrissebb YAML fájl linkért!)

Pár perc múlva ellenőrizheted a Podok állapotát:

kubectl get pods --all-namespaces

Látnod kell a kube-flannel-ds-* (vagy calico-node-*) Podokat futni, és a coredns-* Podoknak is el kell indulniuk. Ezután a kubectl get nodes parancsra a master csomópontnak Ready állapotban kell lennie.

4. Munkás Csomópontok Csatlakoztatása

Most térj át a munkás csomópontokra (pl. k8s-worker-01, k8s-worker-02). Minden munkás csomóponton futtasd a korábban kimásolt kubeadm join parancsot:

sudo kubeadm join 192.168.1.100:6443 --token abcdef.0123456789abcdef 
    --discovery-token-ca-cert-hash sha256:72c841e7f59d5b0c9a9d2d0b5e0c5d2e0f5d0c0b0a0f0d0e0c0f0d0e

Pár perc múlva a master csomóponton futtatott kubectl get nodes paranccsal látnod kell, hogy a munkás csomópontok is Ready állapotba kerültek.

kubectl get nodes

Gratulálok! A bare metal Kubernetes fürtöd most már működik!

Fejlesztések és Fontos Megfontolások

Egy alap fürt működik, de a valós életben ennél többre van szükséged.

Magas Rendelkezésre Állás (HA)

Egyetlen kontroll sík csomópont meghibásodása esetén az egész fürt leáll. HA fürt létrehozásához legalább három kontroll sík csomópontra van szükség, egy külső terheléselosztóval (Load Balancer), amely a kube-apiserver elé van beállítva. Ehhez bonyolultabb kubeadm init parancs és beállítások szükségesek (pl. kubeadm init --control-plane-endpoint "LOAD_BALANCER_IP:LOAD_BALANCER_PORT" --upload-certs), valamint egy külső vagy belső terheléselosztó (pl. HAProxy, Keepalived).

Perzisztens Tárolás (Persistent Storage)

A Podok efemer természetűek. Ha leállnak, az adataik elvesznek. A perzisztens tárolás elengedhetetlen az állapotot tároló alkalmazásokhoz (adatbázisok, fájlrendszerek). Bare metal környezetben a leggyakoribb megoldások:

NFS (Network File System): Egy külső NFS szerverre támaszkodva oszt meg tárolót. Egyszerűen beállítható.
Ceph: Egy elosztott, skálázható tárolási megoldás, amely komplexebb, de robusztusabb.
Rook: A Ceph-et menedzseli Kubernetesen belül, egyszerűsítve a telepítést.
Local Path Provisioner: Tesztelésre alkalmas, ahol a Podok a csomópontok helyi fájlrendszerén tárolnak adatokat.

Terheléselosztás (Load Balancing) a Szolgáltatásokhoz

Hogyan éred el kívülről a Kubernetesen futó alkalmazásaidat? A felhőben az LoadBalancer típusú Service automatikusan kap egy külső IP-címet. Bare metal esetén ehhez szükség van egy extra komponensre, mint például a MetalLB. A MetalLB lefoglal IP-címeket a fürtöd hálózati tartományából, és hirdeti azokat ARP vagy BGP protokollon keresztül, így a Service-eid elérhetővé válnak a külső hálózat számára.

Monitoring és Loggolás

Monitoring: A Prometheus és Grafana kombinációja iparági standard. Segítségükkel valós időben figyelheted a fürtöd és az alkalmazásaid metrikáit.
Loggolás: Az ELK Stack (Elasticsearch, Logstash, Kibana) vagy a Loki+Grafana kombinációja segíti a konténerlogok gyűjtését, elemzését és vizualizálását.

Biztonság

Ne feledkezz meg a tűzfalról (ufw), a RBAC (Role-Based Access Control) megfelelő beállításáról, valamint a hálózati policy-k (Network Policies) alkalmazásáról a Podok közötti forgalom szabályozására.

Mentés és Helyreállítás

Az etcd adatbázis tartalmazza a Kubernetes fürt összes állapotinformációját. Rendszeres mentése létfontosságú! A kubeadm backup parancsot vagy külső eszközöket (pl. Velero) használhatsz erre.

Hibaelhárítás és Tippek

Ellenőrizd a Logokat: A sudo journalctl -u kubelet és kubectl logs <pod-name> -n <namespace> parancsok aranyat érnek.
Podok Állapota: A kubectl get pods -o wide --all-namespaces parancs segít látni, melyik Pod hol fut, és mi az állapota. A kubectl describe pod <pod-name> részletesebb információt ad a Pod hibáiról.
Csomópontok Állapota: A kubectl get nodes és kubectl describe node <node-name> segít diagnosztizálni a csomópontokkal kapcsolatos problémákat.
Hálózati Problémák: Győződj meg róla, hogy a tűzfalak engedik a szükséges portokat (6443, 10250, 2379-2380, 10257, 10259). Használd a ping és nc (netcat) eszközöket a kapcsolódási problémák tesztelésére.

Összefoglalás: A Saját Felhőd a Kezedben

A saját bare metal Kubernetes fürt építése nem egyszerű feladat, de a belőle származó tudás és kontroll felbecsülhetetlen értékű. Ez egy utazás, amely során mélyen megismered a modern konténerizált alkalmazások működését, a hálózati infrastruktúra finomságait és a Linux operációs rendszer mélységeit. Büszkén mutathatod meg a barátaidnak, kollégáidnak, vagy akár a jövőbeli munkaadóidnak, hogy képes vagy valami igazán összetettet és erőteljeset felépíteni a nulláról. Ne félj a kihívásoktól, kísérletezz, tanulj a hibáidból, és élvezd a saját, személyre szabott Kubernetes univerzumodat!

Sok sikert a projekthez!