Hogyan hozzunk létre Kubernetes-fürtöt Kubeadm használatával Ubuntu 18.04-en

Ez az útmutató segítséget nyújt egy Kubernetes fürt alapoktól történő beállításában az Ansible és Kubeadm használatával, majd egy konténerizált Nginx alkalmazás telepítésében.

Bevezetés

Kubernetes (más néven k8s vagy “kube”) egy nyílt forráskódú konténer-orkesztrációs platform, amely automatizálja a konténerizált alkalmazások telepítésével, kezelésével és skálázásával kapcsolatos számos manuális folyamatot. A Kubernetes gyorsan növekvő nyílt forráskódú közösséggel rendelkezik, amely aktívan hozzájárul a projekthez. Tekintse meg blogbejegyzésünket, amely bemutat mindent, amit a Kubernetes platform alapjairól tudni kell.

Kubeadm egy olyan eszköz, amely számos integrált elemet, részt és összetevőt konfigurál, mint például az API-szerver, a Controller Manager és a Kube DNS. Segít az automatizált telepítésben is. Azonban nem hoz létre felhasználókat, nem kezeli az operációs rendszer szintű függőségek telepítését és konfigurálását, és nem tudja kiépíteni az infrastruktúrát.

Az Ansible egy nyílt forráskódú eszköz szoftverek telepítésére és alkalmazások üzembe helyezésére. Saltstack egy eseményvezérelt informatikai automatizálásra szolgáló nyílt forráskódú szoftver. Ez az a két eszköz, amely a további fürtök létrehozását vagy a meglévő fürtök újbóli létrehozását kevésbé teszi kitetté a hibáknak, és használható ezekre az előzetes feladatokra.

Célok:

A fürt a következő fizikai erőforrásokat fogja tartalmazni:

1. Egy master csomópont:

A master csomópont egy olyan csomópont, amely vezérli és kezeli a worker csomópontok (munkaterhelések futtatókörnyezete) csoportját, és egy fürtöt alkot a Kubernetes-ben. Tartalmazza a csomópont erőforrástervét is, hogy meghatározza a kiváltott eseményre adandó megfelelő választ. Ezen fut az etcd, egy nyílt forráskódú, elosztott kulcs-érték tároló, amelyet a fürtadatok tárolására és kezelésére használnak azon összetevők között, amelyek a munkaterheléseket a worker csomópontokhoz ütemezik.

Például az ütemező határozza meg, hogy melyik worker csomópont fogja kiszolgálni az újonnan ütemezett POD-ot.

2. Két worker csomópont:

A worker csomópontok azok a csomópontok, amelyek az ütemezés befejezése után akkor is folytatják a kijelölt munkájukat, ha a master csomópont leáll. A worker csomópontok azok a szerverek, amelyeken a munkaterhelések (azaz a konténerizált alkalmazások és szolgáltatások) futni fognak. A fürt kapacitását további worker csomópontok hozzáadásával is növelheti.

Az útmutató elvégzése után egy teljesen működőképes fürttel fog rendelkezni, amely készen áll a munkaterhelések (azaz konténerizált alkalmazások és szolgáltatások) futtatására, feltéve, hogy a fürtben lévő szerverek elegendő CPU- és RAM-erőforrással rendelkeznek az alkalmazások futtatásához. A fürt sikeres beállítása után szinte bármilyen hagyományos UNIX-alkalmazást futtathat. Ez konténerizálható a fürtön, beleértve a webalkalmazásokat, adatbázisokat, démonokat és parancssori eszközöket.

Maga a fürt csomópontonként körülbelül 300-500 MB memóriát és 10% CPU-t fog fogyasztani.

Előfeltételek:

1. Rendelkeznie kell egy SSH-kulcspárral a helyi Linux gépén, és tudnia kell, hogyan kell használni az SSH-kulcsokat. Ha azonban még nem használt SSH-kulcsokat, ez az útmutató segíthet az SSH-kulcsok beállításában a helyi gépen.
2. Három Ubuntu 18.04-et futtató szerver, egyenként legalább 4 GB RAM-mal és 4 vCPU-val. Képesnek kell lennie arra, hogy SSH-n keresztül root felhasználóként lépjen be mindegyik szerverre az SSH-kulcspárjával. Kövesse ezt az útmutatót az Ubuntu szerver telepítéséhez.
3. A helyi gépre telepített Ansible.
4. Ismernie kell az Ansible playbookokat is.
5. Azt is tudnia kell, hogyan indítson el egy konténert egy Docker-képfájlból. Tekintse meg az “5. lépés — Docker-képfájlok használata Ubuntun” részt a Hogyan telepítsük és használjuk a Dockert Ubuntu 18.04-en című útmutatóban, ha ismétlésre van szüksége.

1. lépés — A munkaterület-könyvtár és az Ansible Inventory fájl beállítása

Először be kell állítania az Ansible-t a helyi gépén. Ez segíteni fog a parancsok végrehajtásában a távoli szerveren. Az automatizálás révén a manuális telepítési munkát is megkönnyíti. Ehhez létre kell hoznia egy könyvtárat a helyi gépén, amely ideiglenes digitális tárhelyként (munkaterületként) fog szolgálni.

Miután létrehozta a könyvtárat, létre kell hoznia egy hosts fájl az egyes szerverek IP-címeivel és csoportjaival kapcsolatos összes információ tárolására szolgál. Segít az inventory információk tárolásában. Ahogy korábban említettük, három szerver lesz: egy master és két worker. A master szerver lesz a master, amelynek IP-címe a következőként jelenik meg: master_ip. A másik két szerver worker lesz, és az IP-címük a következő lesz: worker_1_ip és worker_2_ip.

Létre kell hoznia egy ~/kube-cluster nevű könyvtárat a helyi gép saját (home) könyvtárában, majd be kell lépnie a könyvtárba a cd paranccsal:

A ~/kube-cluster könyvtár ideiglenes digitális tárhelyként (munkaterületként) fog szolgálni, amelyen belül futtatni fogja az összes helyi parancsot a Kubernetes fürt kubeadm segítségével történő létrehozásához. A könyvtár tartalmazni fogja az összes Ansible playbookot, és a bemutató hátralévő részében ezt fogja használni.

A Hosts fájl létrehozása

Hozzon létre egy ~/kube-cluster/hosts nevű fájlt a nano vagy a kedvenc szövegszerkesztője segítségével:

Most hozzá kell adnia a következő szöveget, amely megadja a fürt logikai felépítésére vonatkozó információkat:

Mint említettük, ez az inventory fájl segít tárolni a szerverek IP-címeivel és az egyes szerverek csoportjaival kapcsolatos összes információt. ~/kube-cluster/hosts lesz az Ön inventory fájlja, és a (masters és workers) lesz az a két Ansible csoport, amelyet hozzáadott, meghatározva a fürt logikai felépítését.

A Master csoport az a csoport, amely meghatározza, hogy az Ansible-nek root felhasználóként kell futtatnia a távoli parancsokat. Felsorolja továbbá a master csomópont IP-címét (master_ip) amelyet a “master” nevű szerverbejegyzés határoz meg. Hasonlóképpen, a Workers csoport két bejegyzést tartalmaz a worker szerverekhez (worker_1_ip és worker_2_ip) amelyek szintén a(z) ansible_user-t adják meg root-ként.

A fájl utolsó sora arra utasítja az Ansible-t, hogy a távoli szerverek Python 3 értelmezőit használja a felügyeleti műveletekhez. Végül a szöveg hozzáadása után el kell mentenie és be kell zárnia a fájlt. A munkaterület-könyvtár és az Ansible inventory fájl beállítása után lépjünk tovább a következő lépésre, az operációs rendszer szintű függőségek telepítésére és a konfigurációs beállítások létrehozására.

2. lépés — Nem root felhasználó létrehozása az összes távoli szerveren

Ebben a lépésben megtanulhatja, hodyan hozhat létre sudo jogosultságokkal rendelkező, nem root felhasználót az összes szerveren, így manuálisan, nem privilegizált felhasználóként léphet be rájuk SSH-n keresztül.

Ez hasznos lehet a fürt fenntartásához gyakran végzett műveletek során. Ezenkívül ez a lépés segít a feladat pontosabb és kevésbé hibalehetőséget rejtő elvégzésében, csökkentve a fontos fájlok véletlen módosításának vagy törlésének esélyét. Ha módosítani szeretné a root tulajdonában lévő fájlok beállításait, vagy rendszerinformációkat szeretne megtekinteni olyan parancsokkal, mint a top/htop és meg szeretné tekinteni a futó konténerek listáját, a következő lépés segít mindezen feladatok elvégzésében.

A Playbook létrehozása

Hozzon létre egy ~/kube-cluster/initial.yml nevű fájlt a munkaterületen:

Ezután hozzá kell adnia a következő play-t. Az Ansible-ben a play a végrehajtandó lépések gyűjteménye, amelyek meghatározott szervereket és csoportokat céloznak meg. Egy playbookban egy vagy több play is lehet.

A következő play egy nem root sudo felhasználót fog létrehozni:

Az alábbiakban részletezzük, mit csinál a playbookunk:

1. Ez a playbook létrehozza a nem-root ubuntu.
2. Mivel a sudo parancsokat jelszóbekérés nélkül kell futtatnia, ez a play úgy konfigurálja a sudoers fájlt, hogy lehetővé tegye az ubuntu felhasználó számára ezt.
3. A fenti feladat fő célja az volt, hogy lehetővé tegye az SSH-bejelentkezést minden szerverre ubuntu felhasználóként. Ez a playbook hozzáadja a helyi gép nyilvános kulcsát (általában ~/.ssh/id_rsa.pub) a távoli ubuntu felhasználó engedélyezett kulcsainak listájához.

Most, a szöveg hozzáadása után, el kell mentenie és be kell zárnia a fájlt.

A playbook futtatása

Ezt követően végre kell hajtanunk a playbookunkat, amely létrehozza a nem-root ubuntu felhasználót, egyszerűen a helyi gépen futtatva:

A parancs végrehajtása eltart egy ideig, ami után a következő kimenetet fogja látni:

Miután ez a lépés befejeződött, a következő lépésben rátérhet a Kubernetes-specifikus függőségek telepítésére.

3. lépés — A Kubernetes’ függőségeinek telepítése

Ebben a lépésben megtanulhatja, hogyan telepítheti a Kubernetes által megkövetelt operációsrendszer-szintű csomagokat az Ubuntu csomagkezelőjével.

Ezek a csomagok a következők:

1. Docker: A Docker egy platform és eszköz Docker-konténerek készítésére, terjesztésére és futtatására. Könnyen beállíthatja a Dockert a következő útmutatónkat követve: hogyan telepítsük & üzemeltessük a Dockert Ubuntun a nyilvános felhőben. Azonban más futtatókörnyezetek, például a rkt támogatása aktív fejlesztés alatt áll a Kubernetesben.
2. Kubeadm: kubeadm egy CLI eszköz, amely elvégzi a minimálisan működőképes klaszter beindításához szükséges műveleteket. Ez segít a klaszter különböző összetevőinek szabványos módon történő telepítésében és felépítésében.
3. kubelet: A kubelet az elsődleges “csomópont-ágens”, amely minden csomóponton fut, és a csomópont-szintű műveleteket kezeli.
4. kubectl: kubectl szintén egy CLI eszköz, amely kommunikál a klaszterrel, és parancsokat ad ki annak API szerverén keresztül.

A playbook létrehozása

Hozzon létre egy ~/kube-cluster/kube-dependencies.yml nevű fájlt a munkaterületen:

Most hozzá kell adnia a következő play-eket a fájlhoz, hogy telepítse az alábbi csomagokat a szervereire:

A playbook első része (play) a következőket végzi el:

1. Ez a play segít az operációs rendszer szintű csomagok, valamint a Docker – a konténer-futtatókörnyezet telepítésében.
2. Telepíti a(z) apt-transport-https csomagot, amely lehetővé teszi külső HTTPS források hozzáadását az APT forráslistához.
3. Hozzáadja a Kubernetes APT repozitórium apt-kulcsát a kulcsellenőrzéshez.
4. Hozzáadja a Kubernetes APT repozitóriumot a távoli szerverek APT forráslistájához.
5. Telepíti a(z) kubelet és kubeadm.

A második play egy fontos és önálló feladatot hajt végre, amely magában foglalja a(z) kubectl telepítését a master csomóponton. Most, a szöveg hozzáadása után el kell mentenie és be kell zárnia a fájlt.

A playbook futtatása

Ezt követően végre kell hajtanunk a playbookot, egyszerűen futtatva a helyi gépeken:

Ezen parancs végrehajtása eltart egy ideig, ami után a következő kimenetet fogja látni:

A végrehajtás után a Docker, a(z) kubeadm és a(z) kubelet telepítve lesz az összes távoli szerveren. A kubectl nem kötelező összetevő, és csak a fürtparancsok végrehajtásához szükséges. Csak a master csomópontra történő telepítése ebben a kontextusban ésszerű, mivel a(z) kubectl parancsokat csak a masterről fogja futtatni. Vegye figyelembe azonban, hogy a(z) kubectl parancsok futtathatók bármelyik worker csomópontról, vagy bármely olyan gépről, amelyre telepítve van és konfigurálva van, hogy egy klaszterre mutasson.

Minden rendszerfüggőség telepítve van. Állítsuk be a master csomópontot, és inicializáljuk a klasztert.

4. lépés — A Master csomópont beállítása

Ebben a lépésben megismerkedhet néhány fogalommal, mint például a Podok és Pod hálózati beépülő modulok mivel a klaszter mindkettőt tartalmazni fogja, miután beállította a master csomópontot.

A Podok a legkisebb, legalapvetőbb telepíthető objektumok a Kubernetes-ben. A Podok egy vagy több konténert tartalmaznak, például Docker konténereket. Ha egy Pod több konténert futtat, a konténereket egyetlen entitásként kezelik, és megosztják a Pod’s erőforrásait.

Minden pod saját IP-címmel rendelkezik, és az egyik csomóponton lévő podnak képesnek kell lennie elérni egy másik csomóponton lévő podot a pod’s IP-címének használatával. A podok közötti kommunikáció azonban összetettebb. Szükség van egy külön összetevőre, amely transzparens módon képes átirányítani a forgalmat az egyik csomóponton lévő podról a másikra. Erre a funkcióra a pod hálózati beépülő modulokat használják. Számos pod hálózati beépülő modul érhető el, de mi a Flannel-t fogjuk használni, mivel ez egy stabil és hatékony opció.

A Playbook létrehozása

Hozzon létre egy Ansible playbookot master.yml névvel a helyi gépén:

Továbbá hozzá kell adnia a következő play-t a fájlhoz a klaszter inicializálásához és a Flannel telepítéséhez:

Íme a play részletes bemutatása:

1. A play első feladata a fürt beállítását végzi el a következő futtatásával: kubeadm init. A pod IP-címekhez hozzárendelendő privát alhálózat megadásához a következő argumentumot adjuk át: --pod-network-cidr=10.244.0.0/16. A Flannel alapértelmezés szerint a fenti alhálózatot használja. Ezt arra használjuk, hogy megmondjuk a kubeadm számára, hogy ugyanazt az alhálózatot használja.
2. A második feladat egy .kube könyvtár létrehozására szolgál itt: /home/ubuntu. Ez a könyvtár fogja tárolni a konfigurációs információkat, például az adminisztrátori kulcsfájlokat, amelyek a fürthöz való csatlakozáshoz szükségesek, valamint a fürt API-címét.
3. A harmadik feladat a /etc/kubernetes/admin.conf fájl másolására szolgál, amelyet a kubeadm init hozott létre, a nem-root felhasználó saját könyvtárába. Ez lehetővé teszi, hogy a kubectl parancsot használja az újonnan létrehozott fürt eléréséhez.
4. Az utolsó feladat a kubectl apply parancsot futtatja a Flannel. kubectl apply -f descriptor.[yml|json] a szintaxis arra, hogy megmondjuk a kubectl számára, hogy hozza létre a descriptor.[yml|json] fájlban leírt objektumokat. A kube-flannel.yml fájl tartalmazza a Flannel beállításához szükséges objektumok leírását a fürtben.

Most, a szöveg hozzáadása után el kell mentenie és be kell zárnia a fájlt.

Running the Playbook

Ezután végre kell hajtania a playbookunkat, egyszerűen futtatva a helyi gépeken:

E parancs végrehajtása eltart egy ideig, ami után a következő kimenetet fogja látni:

Most lépjen be SSH-val a következő paranccsal a master csomópont állapotának ellenőrzéséhez:

Miután belépett a master csomópontba, futtassa a következőt:

Most a következő kimenetet fogja látni:

A fenti kimenet megjelenésekor kijelentheti, hogy a master csomópont az összes beállítási feladatot elvégezte, és elkezdheti fogadni a worker csomópontokat és végrehajtani a feladatokat, amint Ready (Kész) állapotba kerül. Most már hozzáadhatja a worker csomópontokat a helyi gépéről.

5. lépés — A Worker csomópontok beállítása

A master csomópont beállítása után továbbléphetünk a következő lépésre, a worker csomópontok beállítására. A worker csomópontok hozzáadása a fürthöz egyszerűen elvégezhető egyetlen parancs végrehajtásával minden egyes worker szerveren. Ez a parancs tartalmazza a fontos információkat, például az IP-címet, a master API-szerverének portját és egy biztonságos tokent. Bár vegye figyelembe, hogy nem minden csomópont tud majd csatlakozni a fürthöz, csak azok a csomópontok tudnak csatlakozni, amelyek átadják a biztonságos tokent.

A playbook létrehozása

Ez a parancs segít visszanavigálni a munkaterületére, és létrehozni egy workers.yml:

Adja hozzá a következő szöveget a fájlhoz a worker csomópontok fürthöz való hozzáadásához:

A playbook a következőket teszi. A fenti kódban két play található:

1. Az első play a worker csomópontokon futtatandó csatlakozási parancs lekérésére szolgál. A parancs formátuma a következő lesz: kubeadm join --token sha256:<hash><token><master-ip>:<master-port> --discovery-token-ca-cert-hash sha256:<hash>;. A feladatnak meg kell kapnia a helyes token és hash értékeket. Amint megkapja a helyes bemenetet, a feladat tényként (fact) állítja be azt, hogy a második play hozzáférhessen ehhez az információhoz.
2. A második play kizárólag egyetlen feladat végrehajtására íródott – arra, hogy a két worker csomópontot a fürt részévé tegye a csatlakozási parancs egyszerű futtatásával az összes worker csomóponton.

A szöveg hozzáadása után el kell mentenie és be kell zárnia a fájlt.

A playbook futtatása

Ezt követően végre kell hajtanunk a playbookunkat a következő parancs futtatásával a worker gépeken:

E parancs végrehajtása eltart egy ideig, ami után a következő kimenetet fogja látni:

Most már a Kubernetes-fürtje teljesen be van állítva és működőképes, a worker csomópontok pedig készen állnak a munkaterhelések futtatására. Mielőtt továbblépne a következő lépésre, ellenőrizzük, hogy a fürt a tervek szerint működik-e.

6. lépés — A fürt ellenőrzése

Előfordulhatnak olyan esetek, amikor a fürt meghibásodik a telepítés során. Ennek oka lehet a master és a worker közötti hálózati hiba, vagy egy csomópont-probléma. Ezért az alkalmazások ütemezése előtt ellenőriznünk kell a fürtöt, és biztosítanunk kell, hogy ne lépjen fel működési hiba. Ehhez ellenőriznie kell a fürt aktuális állapotát a master csomópontról, hogy megbizonyosodjon a csomópontok készenlétéről. Ha a csomópontok nem állnak készen, vagy megszakad a kapcsolat, a következő paranccsal állíthatja vissza a kapcsolatot:

A fürt állapotának lekéréséhez használja a következő parancsokat:

E parancs végrehajtása eltart egy ideig, ami után a következő kimenetet fogja látni:

 

 

 

 

Ellenőriznie kell, hogy a fürt részét képező összes csomópont Ready állapotban van-e. Ha néhány csomópontnál a Not Ready szerepel mint STATUS, az azt mutatja, hogy a worker csomópontok még nem fejezték be a beállításukat. Azonban a kubectl get nodes újbóli futtatása és a frissített kimenet ellenőrzése előtt várjon még öt-tíz percet. Ha néhány csomópont állapota továbbra is Not Ready állapotot mutat, ellenőriznie kell az előző lépéseket, és újra le kell futtatnia a parancsokat. A csomópontok csak akkor részei a fürtnek és készek a munkaterhelések futtatására, ha a STATUS értéke Ready. A 6. lépés sikeres végrehajtása után a fürt ellenőrzése megtörtént. Most ütemezzünk be egy példa Nginx alkalmazást a fürtön.

7. lépés — Alkalmazás futtatása a fürtön

Deployment létrehozása

A fürt sikeres létrehozása után bármilyen konténerizált alkalmazást telepíthet a fürtre. Ha a master csomóponton belül van, az alábbi parancsokat használhatja más konténerizált alkalmazásokhoz is. Ezután futtassa a következő parancsot egy nginx :

Meg kell változtatnia a Docker-rendszerkép nevét és a vonatkozó jelzőket (például portokat és köteteket). Hogy a dolgok ismerősek maradjanak, telepítheti az Nginx-et deploymentek és service-ek használatával, hogy lássa, hogyan telepíthetők alkalmazások a fürtre.

A Kubernetes deployment egy olyan erőforrás-objektum a Kubernetes-ben, amely deklaratív frissítéseket biztosít az alkalmazásokhoz. A deployment lehetővé teszi az alkalmazás életciklusának leírását, mint például a konténerkép (container image), a replikák és a frissítési stratégia. A deployment biztosítja, hogy a kívánt számú pod fusson és mindig elérhető legyen. Ha egy pod összeomlik a fürt élettartama alatt, újra létrehozza azt. A frissítési folyamat szintén teljes mértékben rögzítésre és verziózásra kerül, a szüneteltetés, a folytatás és a korábbi verziókra való visszaállítás lehetőségeivel. A fenti parancs egy Nginx nevű deployment létrehozására segít egy olyan pod telepítésében, amely egy konténerrel rendelkezik a Docker registry Nginx Docker Image-éből.

Node Port beállítása

Ezután létre kell hoznunk egy NodePort. NodePort egy nyitott port a fürt minden csomópontján. A Kubernetes transzparens módon irányítja a bejövő forgalmat a NodePort porton a szolgáltatásához, még akkor is, ha az alkalmazás egy másik csomóponton fut. Ehhez a következő paranccsal hozhatunk létre egy Nginx nevű NodePort erőforrást, amely nyilvánosan elérhetővé teszi az alkalmazást:

A service egy másik Kubernetes objektum, amely felelős az interfész közzétételéért ezekhez a podokhoz, ami lehetővé teszi a hálózati hozzáférést a fürtön belülről vagy a külső folyamatok és a szolgáltatás között. Úgy határozható meg, mint egy absztrakció a pod felett, amely egyetlen IP-címet és DNS-nevet biztosít, amelyen keresztül a podok elérhetők. A service segítségével nagyon egyszerű a terheléselosztási konfiguráció kezelése.

Futtassa a következő parancsot:

Ez a következőhöz hasonló szöveget fog eredményezni:

A kimenet lekérése után a Kubernetes automatikusan hozzárendel egy véletlenszerű portot, amely nagyobb, mint 30000, miközben arról is gondoskodik, hogy a hozzárendelt portot ne foglalja már el egy másik szolgáltatás. A fenti kimenet harmadik sora segít lekérni azt a portot, amelyen az Nginx fut.

A működés ellenőrzéséhez látogasson el a http://worker_1_ip:nginx_port vagy http://worker_2_ip:nginx_port címre a helyi gépén lévő böngészőn keresztül. Meg fogja látni az Nginx megszokott üdvözlőoldalát.

Deployment eltávolítása

Ha el szeretné távolítani az Nginx alkalmazást, először törölnie kell az nginx szolgáltatást a master csomópontról:

Annak ellenőrzéséhez, hogy az alkalmazás valóban törlődött-e, futtassa ezt a parancsot:

A következő kimenetet fogja kapni:

Ezt követően a következő paranccsal kell törölnie a deploymentet:

Ezzel a paranccsal ellenőrizheti, hogy a deployment végül törlésre került-e:

Összegzés:

Ez az útmutató segít a fürt megfelelő beállításában Ubuntu 18.04-en a Kubeadm és az Ansible használatával. Most, hogy a fürt be van állítva, könnyen elkezdheti saját alkalmazásainak és szolgáltatásainak telepítését.

Itt található a további részleteket tartalmazó linkek listája, amelyek segítenek a folyamat során:

1. Alkalmazások dockerizálása – Ez a link olyan példákat tartalmaz, amelyek bemutatják, hogyan tölthet be alkalmazásokat Docker használatával. Például a PostgreSQL, egy CouchDB szolgáltatás stb. dockerizálását.
2. Pod áttekintés – Ez a link részletesen bemutatja a podok használatát, működését, és azt, hogyan kapcsolódnak a podok más Kubernetes objektumokhoz. A podok a Kubernetes fontos részét képezik, így megértésük segíteni fog a feladat sikeres elvégzésében.
3. Deployments áttekintés – Segít megismerni a deploymenteket. A deployment deklaratív frissítéseket biztosít a Podok és ReplicaSetek számára. Megtanulhatja, hogyan kell frissíteni, átgördíteni és visszaállítani egy deploymentet.
4. Services áttekintés - Ez a link bemutatja a szolgáltatásokat (services), amelyek egy másik gyakran használt objektumot jelentenek a Kubernetes fürtökben. A Kubernetes-ben a service egy olyan absztrakció, amely meghatározza a Podok egy logikai halmazát és az elérésükre vonatkozó szabályzatot. A szolgáltatástípusok és a hozzájuk tartozó opciók megértése elengedhetetlen mind az állapotmentes (stateless), mind az állapotnyilvántartó (stateful) alkalmazások futtatásához.

Továbbá tekintse meg a Dockerrel és Kubernetes-szel foglalkozó egyéb útmutatóinkat, amelyeket a blogunkon találhat meg:

• Ismerkedés a Kubernetes-szel
• Docker-erőforrások tisztítása – képek, konténerek és kötetek
• Hogyan futtassunk Dockert a CloudSigma-n (CloudInit használatával) Frissítve
• A Docker telepítése és beállítása CentOS 7 rendszeren
• Hogyan telepítsük & üzemeltessük a Dockert Ubuntu-n a nyilvános felhőben

Számos más fontos koncepció is létezik, mint például a Kötetek, Ingressek, és a Titkok , amelyeket éles alkalmazások telepítése során használhat.

Kellemes számítógéphasználatot!