Kubernetes a gyakorlatban: az első alkalmazásod telepítése

Üdv a jövőben! A modern alkalmazásfejlesztés világában a rugalmasság, skálázhatóság és megbízhatóság kulcsfontosságú. Itt jön képbe a Kubernetes, a Google által kifejlesztett, nyílt forráskódú konténer-orkesztrációs platform, amely forradalmasította az alkalmazások telepítésének és kezelésének módját. Lehet, hogy már hallottál róla, talán kicsit tartasz is tőle a komplexitása miatt, de ne aggódj! Ez a cikk egy gyakorlati útikönyv lesz számodra, amely lépésről lépésre vezet végig az első alkalmazásod Kubernetes clusterre történő telepítésének folyamatán. Készen állsz egy izgalmas utazásra a konténer-orkesztráció világába?

Miért éppen Kubernetes?

A konténerizáció – főként a Docker révén – egyre népszerűbbé vált, hiszen egységes környezetet biztosít az alkalmazások futtatásához, függetlenül az alapul szolgáló infrastruktúrától. Egyetlen konténer azonban nem oldja meg a komplex rendszerek kihívásait: hogyan indítunk el egyszerre több száz konténert? Hogyan osztjuk el a terhelést? Mi történik, ha egy konténer leáll? Hogyan frissítjük az alkalmazásainkat állásidő nélkül? A Kubernetes pontosan ezekre a kérdésekre ad választ. Automatizálja a konténerek telepítését, skálázását, felügyeletét és hálózati kezelését, lehetővé téve a fejlesztők számára, hogy a kódra, ne pedig az infrastruktúrára koncentráljanak.

Előfeltételek: Mire lesz szükséged?

Mielőtt belevágnánk a gyakorlati részbe, győződj meg róla, hogy a következő eszközök telepítve vannak a gépeden:

Docker: Szükséged lesz rá az alkalmazásod konténerbe csomagolásához. Telepítsd a Docker Desktopot (Windows/macOS) vagy a Docker Engine-t (Linux).
kubectl: Ez a Kubernetes parancssori eszköze, amellyel kommunikálni tudsz a Kubernetes clusterrel. Telepítési útmutatót találsz a hivatalos Kubernetes dokumentációban.
Egy Kubernetes cluster:
- Minikube (ajánlott helyi fejlesztéshez): Egy könnyű Kubernetes implementáció, amely egy virtuális gépen vagy közvetlenül a gépeden futtat egy egycsomópontos clustert. Ideális a tanuláshoz és a helyi fejlesztéshez.
- Docker Desktop beépített Kubernetes-e: Ha Docker Desktopot használsz, bekapcsolhatod a beépített Kubernetes funkcionalitását, ami szintén egy egycsomópontos clustert biztosít.
- Felhőalapú szolgáltatás (pl. GKE, EKS, AKS): Egy élesebb környezet szimulálásához használhatsz egy felhőszolgáltató által menedzselt Kubernetes clustert is, de kezdetnek a Minikube vagy Docker Desktop elegendő.

Ha a Minikube-ot választottad, a telepítés után indítsd el a clustert a következő paranccsal: minikube start.

Kubernetes alapfogalmak, amikkel találkozni fogsz

Mielőtt az első YAML fájl megírásához látnánk, ismerkedjünk meg néhány alapvető Kubernetes fogalommal, amelyekre az egész rendszer épül:

Pod: A Kubernetes legkisebb telepíthető egysége. Egy Pod egy vagy több konténert (pl. Docker konténert), tárolókat, IP-címet és konfigurációs beállításokat tartalmaz. Minden Pod saját IP-címmel rendelkezik.
Deployment: Ez egy kontroller, amely biztosítja, hogy a Podok egy adott számban futva legyenek, és frissítéseket vagy visszaállításokat hajtson végre rajtuk. A Deploymentek segítségével deklaratívan leírhatjuk az alkalmazásunk kívánt állapotát.
Service: Lehetővé teszi a hálózati hozzáférést a Podokhoz. Mivel a Podok IP-címe dinamikus lehet, a Service egy állandó IP-címet és DNS nevet biztosít, amelyen keresztül elérhetőek a Podok. Különböző típusai vannak, mint a ClusterIP (csak clusteren belül), NodePort (a cluster node-jainak portjain keresztül elérhető), és LoadBalancer (külső terheléselosztóval elérhető).
Namespace: A cluster erőforrásainak logikai elkülönítésére szolgál, több csapat vagy projekt számára.
kubectl: A parancssori eszköz a Kubernetes clusterrel való interakcióhoz.
YAML: A Kubernetes konfigurációs fájlok általában YAML (vagy JSON) formátumban íródnak. Deklaratív módon írjuk le bennük az erőforrások kívánt állapotát.

Az első alkalmazásod: Egy egyszerű webalkalmazás telepítése

Telepítsünk egy egyszerű „Hello World” típusú Node.js alapú webalkalmazást. Ez az alkalmazás egy alapértelmezett porton fog figyelni, és válaszol minden bejövő kérésre egy egyszerű üdvözlettel.

1. Az alkalmazás konténerizálása (Docker Image létrehozása)

Mivel a Kubernetes konténereket orkesztrál, az első lépés az alkalmazásunk konténerbe csomagolása. Képzeljünk el egy nagyon egyszerű Node.js alkalmazást, ami a 3000-es porton hallgat. Ennek az alkalmazásnak a Docker image-ét már elkészítettük, és feltöltöttük egy nyilvános registry-re (pl. Docker Hub). Ehhez a példához a gcr.io/google-samples/node-hello:1.0 image-et fogjuk használni, ami egy egyszerű „Hello Kubernetes!” üzenetet ad vissza.

Ha saját alkalmazást szeretnél konténerizálni, a következő lépéseket követnéd:

Írj egy egyszerű alkalmazást (pl. app.js Node.js-ben).
Készíts egy Dockerfile-t, ami leírja, hogyan kell felépíteni a konténer image-et.
Építsd fel az image-et: docker build -t your-username/your-app:1.0 .
Töltsd fel az image-et egy konténer registry-re: docker push your-username/your-app:1.0.

Mi most feltételezzük, hogy ez a lépés már megtörtént, és készen állunk a Kubernetes-es telepítésre.

2. Deployment konfiguráció: Az alkalmazás futtatása

A Deployment felelős az alkalmazásunk Podjainak létrehozásáért és kezeléséért. Hozz létre egy deployment.yaml nevű fájlt a következő tartalommal:


apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-deployment
  labels:
    app: hello-kubernetes
spec:
  replicas: 2 # Hány Podot szeretnénk futtatni?
  selector:
    matchLabels:
      app: hello-kubernetes
  template:
    metadata:
      labels:
        app: hello-kubernetes
    spec:
      containers:
      - name: hello-kubernetes
        image: gcr.io/google-samples/node-hello:1.0 # A Docker image neve
        ports:
        - containerPort: 8080 # Az alkalmazásunk ezen a porton hallgat a konténeren belül

Magyarázat:

apiVersion: apps/v1: Megadja a használt Kubernetes API verziót.
kind: Deployment: Ez egy Deployment típusú erőforrás.
metadata.name: A Deployment egyedi neve.
metadata.labels: Címkék, amelyek segítik az erőforrások rendszerezését és kiválasztását.
spec.replicas: 2: Azt mondja meg a Kubernetesnek, hogy mindig 2 példányt (Podot) tartson futva az alkalmazásból. Ha az egyik leáll, a Kubernetes automatikusan újraindít egy másikat.
spec.selector.matchLabels: Meghatározza, mely Podokat kezeli ez a Deployment. A címkéknek egyezniük kell a Pod template-ben lévőkkel.
spec.template: Ez írja le a Podokat, amelyeket a Deployment létrehoz.
spec.template.metadata.labels: A Podokhoz rendelt címkék.
spec.template.spec.containers: A Podban futó konténerek listája.
name: hello-kubernetes: A konténer neve.
image: gcr.io/google-samples/node-hello:1.0: A futtatni kívánt Docker image.
ports.containerPort: 8080: A konténeren belül az alkalmazás által használt port. Fontos, hogy ez nem a cluster külső portja, csak a konténer belső portja.

3. Service konfiguráció: Az alkalmazás elérhetővé tétele

Most, hogy van egy Deploymentünk, amely futtatja az alkalmazásunk Podjait, szükségünk van egy módszerre, hogy ezeket a Podokat elérhetővé tegyük a külső világból (vagy legalábbis a clusteren belülről). Erre szolgál a Service. Hozz létre egy service.yaml nevű fájlt a következő tartalommal:


apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes-service
spec:
  selector:
    app: hello-kubernetes # Ez a selector kapcsolja össze a Service-t a Deployment Podjaival
  ports:
    - protocol: TCP
      port: 80 # A Service ezen a porton fog figyelni
      targetPort: 8080 # A Pod belső portja, amire a Service továbbítja a kéréseket
  type: NodePort # A Service típusa

Magyarázat:

apiVersion: v1: A Service API verziója.
kind: Service: Ez egy Service típusú erőforrás.
metadata.name: A Service egyedi neve.
spec.selector.app: hello-kubernetes: Ez a kulcsfontosságú rész köti össze a Service-t a Deployment Podjaival. Bármely Pod, amelynek app: hello-kubernetes címkéje van, a Service mögé kerül.
ports.protocol: TCP: A használt protokoll.
ports.port: 80: A Service ezen a porton lesz elérhető.
ports.targetPort: 8080: A Podon belül ez az a port, amire a Service a forgalmat továbbítja. Fontos, hogy ez egyezzen a Deploymentben megadott containerPort-tal.
type: NodePort: Ez a Service típus arra utasítja a Kubernetes-t, hogy nyisson meg egy portot a cluster minden node-ján (VM-jén), és ezen keresztül tegye elérhetővé az alkalmazást. Helyi teszteléshez ez a legkényelmesebb. Éles környezetben gyakran használnak LoadBalancer típust.

4. Telepítés és ellenőrzés

Most, hogy elkészítettük a konfigurációs fájlokat, telepítsük őket a Kubernetes clusterünkre!

Alkalmazás telepítése:
```
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
        
```
A kubectl apply -f parancs létrehozza vagy frissíti a Kubernetes erőforrásokat a megadott YAML fájl alapján.
Erőforrások ellenőrzése:
Nézd meg a futó Podjaidat:
```
kubectl get pods
        
```
Látnod kell két Podot Running (futó) állapotban.

Ellenőrizd a Deployment állapotát:
```
kubectl get deployments
        
```
Látnod kell a hello-kubernetes-deployment-et, 2/2 ready Poddal.

Ellenőrizd a Service-t:
```
kubectl get services
        
```
Látnod kell a hello-kubernetes-service-t a hozzárendelt IP-címmel és porttal. Ha NodePort típust használsz, látsz egy extra portot a NodePort oszlopban (pl. 80:3XXXX/TCP). A 3XXXX lesz a NodePort.
Alkalmazás elérése:
Ha Minikube-ot használsz, a legegyszerűbb módja az alkalmazás elérésének:
```
minikube service hello-kubernetes-service
        
```
Ez automatikusan megnyitja a böngésződet az alkalmazás URL-jénél. Ha NodePort-ot használsz Docker Desktop esetén, akkor a localhost:NodePort címen érheted el (pl. localhost:30000, ahol a 30000 a NodePort értéke).

Ha minden jól ment, egy „Hello Kubernetes!” üzenetnek kell megjelennie a böngésződben. Gratulálok, sikeresen telepítetted az első alkalmazásodat Kubernetesre!

5. Takarítás (Erőforrások törlése)

Amikor már nincs szükséged az alkalmazásodra, egyszerűen törölheted a létrehozott erőforrásokat:


kubectl delete -f service.yaml
kubectl delete -f deployment.yaml

Ez eltávolítja a Service-t és a Deploymentet, valamint az összes hozzá tartozó Podot.

További lépések és jó gyakorlatok

Ez a „Hello World” bevezető csak a felszínét karcolja a Kubernetes tudásának. Íme néhány terület, amit érdemes tovább kutatni:

Függőségek és Erőforrások:
- ConfigMaps és Secrets: Az alkalmazás konfigurációs adataihoz és érzékeny információkhoz (jelszavak, API kulcsok) történő kezelésére.
- Persistent Volumes (PV) és Persistent Volume Claims (PVC): Állandó tárolók biztosítására az adatbázisokhoz vagy más állapotalapú alkalmazásokhoz, hogy az adatok ne vesszenek el, ha egy Pod újraindul vagy áthelyeződik.
Skálázhatóság:
- Horizontal Pod Autoscaler (HPA): Automatikusan skálázza a Podok számát a CPU kihasználtság vagy más metrikák alapján.
- Vertical Pod Autoscaler (VPA): Ajánlásokat tesz (vagy automatikusan beállítja) a Podok CPU és memória igényeire.
Frissítések és Visszaállítások:
- A Deploymentek támogatják a „rolling update” stratégiát, ami állásidő nélkül teszi lehetővé az alkalmazások frissítését. Lehetőség van a korábbi verzióra való egyszerű visszaállításra is.
Hálózat és Ingress:
- Ingress: Egy API objektum, amely külső hozzáférést biztosít a clusterben lévő szolgáltatásokhoz HTTP és HTTPS útválasztással. Az Ingress Controllerek, mint az Nginx Ingress vagy Traefik, valósítják meg az Ingress szabályokat.
Monitoring és Logolás:
- Integráció a Prometheus/Grafana vagy ELK (Elasticsearch, Logstash, Kibana) stackkel a cluster és az alkalmazások állapotának figyelésére.
CI/CD integráció:
- Automatizáld a konténer image-ek építését, tesztelését és Kubernetesre történő telepítését olyan eszközökkel, mint a Jenkins, GitLab CI, GitHub Actions vagy ArgoCD.

Gyakori hibák és hibaelhárítás

A Kubernetes tanulása során valószínűleg találkozni fogsz hibákkal. Íme néhány gyakori probléma és azok megoldása:

ImagePullBackOff: A Kubernetes nem tudja letölteni a Docker image-et.
- Ellenőrizd az image nevét és tag-jét a YAML fájlban (pl. myrepo/myimage:latest).
- Győződj meg róla, hogy az image létezik a megadott registry-ben.
- Ha privát registry-t használsz, ellenőrizd, hogy a Kubernetes rendelkezik-e a szükséges hitelesítő adatokkal (imagePullSecrets).
CrashLoopBackOff: A Pod elindul, majd azonnal leáll és újraindul.
- Ez azt jelenti, hogy az alkalmazásod hibával leállt a konténeren belül.
- Használd a kubectl logs <pod-name> parancsot a konténer logjainak megtekintéséhez.
- Használd a kubectl describe pod <pod-name> parancsot, hogy részletesebb információt kapj a Pod állapotáról.
Service nem elérhető: Nem tudod elérni az alkalmazást a Service-en keresztül.
- Ellenőrizd a Service selector-ját és a Deployment Podjainak címkéit, hogy azok egyezzenek.
- Ellenőrizd, hogy a Service targetPort-ja egyezik-e a Deployment konténerének containerPort-jával.
- Győződj meg róla, hogy a megfelelő IP-címet és portot használod az alkalmazás eléréséhez.
`kubectl describe` és `kubectl logs`: Ez a két parancs a legjobb barátod lesz a hibaelhárítás során. Rengeteg hasznos információt szolgáltatnak az erőforrások állapotáról és a konténerek belső működéséről.

Záró gondolatok

Gratulálok! Megtetted az első lépést a Kubernetes világában, és sikeresen telepítetted az első alkalmazásodat. Ez egy hatalmas lépés, de ne feledd, a Kubernetes egy mély és összetett ökoszisztéma. Ne ijedj meg a kezdeti kihívásoktól; minden új technológia tanulása időt és türelmet igényel. Kísérletezz, olvass dokumentációkat, és építs folyamatosan a megszerzett tudásodra. A Kubernetes elsajátítása rendkívül értékes készség a mai technológiai környezetben, és megnyitja az utat a modern, skálázható és rugalmas alkalmazások fejlesztése előtt. Jó szórakozást a konténer-orkesztrációhoz!