🥇A kubectl hatékonyabb használata: részletes útmutató

Ha a Kubernetes-szel dolgozik, akkor a kubectl valószínűleg az egyik leggyakrabban használt segédprogram. És amikor sok időt tölt egy adott eszközzel, érdemes alaposan tanulmányoznia azt, és megtanulnia hatékonyan használni.

Csapat Kubernetes aaS a Mail.ru webhelyről lefordította Daniel Weibel cikkét, amelyben tippeket és trükköket találhat a kubectl hatékony használatához. Ez is segít a Kubernetes mélyebb megértésében.

A szerző szerint a cikk célja, hogy a Kubernetes-szel végzett mindennapi munkát ne csak hatékonyabbá, de élvezetesebbé is tegye!

Bevezetés: Mi az a kubectl

Mielőtt megtanulná a kubectl hatékonyabb használatát, alapvető ismereteket kell szereznie arról, hogy mi az, és hogyan működik.

A felhasználó szemszögéből a kubectl egy olyan vezérlőpult, amely lehetővé teszi a Kubernetes-műveletek végrehajtását.

Technikailag a kubectl egy Kubernetes API-kliens.

A Kubernetes API egy HTTP REST API. Ez az API a valódi Kubernetes felhasználói felület, amelyen keresztül teljes mértékben vezérelhető. Ez azt jelenti, hogy minden Kubernetes-művelet API-végpontként jelenik meg, és HTTP-kéréssel lehet végrehajtani az adott végponthoz.

Ezért a kubectl fő feladata az, hogy HTTP-kéréseket küldjön a Kubernetes API-nak:

A Kubernetes egy teljesen erőforrás-orientált rendszer. Ez azt jelenti, hogy fenntartja az erőforrások belső állapotát, és minden Kubernetes-művelet CRUD-művelet.

Az erőforrások kezelésével teljes mértékben Ön irányítja a Kuberneteset, és a Kubernetes az erőforrások jelenlegi állapota alapján kitalálja, mit kell tennie. Emiatt a Kubernetes API hivatkozás az erőforrástípusok listájaként van megszervezve a hozzájuk tartozó műveletekkel.

Nézzünk egy példát.

Tegyük fel, hogy szeretne létrehozni egy ReplicaSet erőforrást. Ehhez név szerint írja le a ReplicaSet-et egy fájlban replicaset.yaml, majd futtassa a parancsot:

$ kubectl create -f replicaset.yaml

Ezzel létrehoz egy ReplicaSet erőforrást. De mi történik a színfalak mögött?

A Kubernetes rendelkezik egy ReplicaSet létrehozási művelettel. Mint minden más művelet, ez is API-végpontként jelenik meg. A művelet konkrét API-végpontja így néz ki:

POST /apis/apps/v1/namespaces/{namespace}/replicasets

Az összes Kubernetes-művelet API-végpontjai a következő címen találhatók: API hivatkozás (beleértve a a fenti végpont). Ha tényleges kérést szeretne küldeni egy végponthoz, először hozzá kell adnia az API-kiszolgáló URL-címét az API-hivatkozásban felsorolt végpont elérési útjaihoz.

Ezért a fenti parancs végrehajtásakor a kubectl HTTP POST kérést küld a fenti API-végpontra. A fájlban megadott ReplicaSet definíció replicaset.yaml, a kérelem szövegében kerül elküldésre.

Így működik a kubectl minden olyan parancsnál, amely kölcsönhatásba lép a Kubernetes-fürttel. Ezekben az esetekben a kubectl egyszerűen HTTP-kérelmeket küld a megfelelő Kubernetes API-végpontokhoz.

Kérjük, vegye figyelembe, hogy a Kubernetes teljes körűen kezelhető olyan segédprogramokkal, mint pl curlHTTP-kérések manuális küldésével a Kubernetes API-nak. A Kubectl egyszerűen megkönnyíti a Kubernetes API használatát.

Ez a kubectl alapjai és működése. De van még valami a Kubernetes API-val kapcsolatban, amit minden kubectl felhasználónak tudnia kell. Vessünk egy pillantást a Kubernetes belső világába.

Kubernetes belső világa

A Kubernetes független komponensek halmazából áll, amelyek különálló folyamatokként futnak a fürtcsomópontokon. Egyes összetevők főcsomópontokon, mások munkacsomópontokon futnak, és mindegyik összetevő a saját meghatározott feladatát végzi el.

Íme a fő csomópontok legfontosabb összetevői:

Boltozat - tárolja az erőforrás definíciókat (általában ez stb).
API szerver — API-t biztosít és kezeli a tárhelyet.
Controller Manager — Biztosítja, hogy az erőforrások állapota megfeleljen az előírásoknak.
Ütemező — ütemezi a sorba rendezéseket a dolgozói csomópontokon.

És itt van a dolgozói csomópontok egyik legfontosabb összetevője:

kubelet — kezeli a konténerek indítását a működő csomóponton.

Hogy megértsük, hogyan működnek együtt ezek az összetevők, nézzünk meg egy példát.

Tegyük fel, hogy most fejezte be kubectl create -f replicaset.yaml, ami után a kubectl HTTP POST kérést küldött a címre ReplicaSet API végpont (átadva a ReplicaSet erőforrás-definíciót).

Mi történik a klaszterben?

Miután megtette kubectl create -f replicaset.yaml Az API-kiszolgáló a tárhelyen tárolja a ReplicaSet erőforrás-definícióját:
Ezután a vezérlőkezelőben elindul a ReplicaSet vezérlő, amely kezeli a ReplicaSet erőforrások létrehozását, módosítását és törlését:
A ReplicaSet vezérlő létrehoz egy pod definíciót minden ReplicaSet replikához (a ReplicaSet definícióban található pod sablonnak megfelelően), és eltárolja azokat a tárolóban:
Elindul az ütemező, amely nyomon követi azokat a sorba rendezéseket, amelyek még nincsenek hozzárendelve egyetlen dolgozó csomóponthoz sem:
Az ütemező minden egyes podhoz kiválaszt egy megfelelő dolgozó csomópontot, és hozzáadja ezt az információt a tárolóban található pod definícióhoz:
A munkavégző csomóponton, amelyhez a pod hozzá van rendelve, elindul a Kubelet, amely nyomon követi az ehhez a csomóponthoz rendelt podokat:
A Kubelet beolvassa a poddefiníciót a tárolóból, és utasít egy konténer futtatókörnyezetet, például a Dockert, hogy indítson konténereket a csomóponton:

Az alábbiakban a leírás szöveges változata látható.

A ReplicaSet létrehozási végponthoz intézett API-kérelmet az API-kiszolgáló dolgozza fel. Az API-kiszolgáló hitelesíti a kérést, és a tárolóban tárolja a ReplicaSet erőforrás-definíciót.

Ez az esemény elindítja a ReplicaSet vezérlőt, amely a vezérlőkezelő egy alfolyamata. A ReplicaSet vezérlő figyeli a ReplicaSet erőforrások létrehozását, frissítését és törlését az áruházban, és értesítést kap az eseményről, ha ez megtörténik.

A ReplicaSet vezérlő feladata annak biztosítása, hogy a szükséges számú ReplicaSet pod létezik. Példánkban még nem léteznek pod-ok, ezért a ReplicaSet vezérlő létrehozza ezeket a pod-definíciókat (a ReplicaSet definícióban található pod-sablonnak megfelelően), és eltárolja őket a tárolóban.

Az új sorba rendezések létrehozását egy ütemező indítja el, amely nyomon követi a munkavégző csomópontokhoz még nem ütemezett pod-definíciókat. Az ütemező minden egyes podhoz kiválaszt egy megfelelő munkavégző csomópontot, és frissíti a pod definíciókat a lerakatban.

Vegye figyelembe, hogy eddig a pontig egyetlen munkaterhelési kód sem futott a fürtben. Minden, ami eddig megtörtént - ez az erőforrások létrehozása és frissítése a fő csomópont lerakatában.

Az utolsó esemény elindítja a Kubeleteket, amelyek figyelik a dolgozói csomópontokhoz ütemezett podokat. A munkavégző csomópont Kubeletjének, amelyre a ReplicaSet pod-ok telepítve vannak, utasítania kell a tároló futtatókörnyezetét, például a Dockert, hogy töltse le és futtassa le a szükséges tárolóképeket.

Ezen a ponton a ReplicaSet alkalmazás végre fut!

A Kubernetes API szerepe

Ahogy az előző példában láthatta, a Kubernetes-összetevők (az API-kiszolgáló és a tárhely kivételével) figyelik a tárolóban lévő erőforrások változásait, és módosítják a tárolóban lévő erőforrásokkal kapcsolatos információkat.

Természetesen ezek az összetevők nem közvetlenül, hanem csak a Kubernetes API-n keresztül lépnek kapcsolatba a tárolóval.

Tekintsük a következő példákat:

A ReplicaSet vezérlő az API-végpontot használja a ReplicaSets listája paraméterrel watch a ReplicaSet erőforrások változásainak figyeléséhez.
A ReplicaSet vezérlő az API-végpontot használja Pod létrehozása (doboz létrehozása) a hüvelyek létrehozásához.
Az ütemező API-végpontot használ patch pod (edit pod) a sorba rendezések frissítéséhez a kiválasztott munkavégző csomópontra vonatkozó információkkal.

Amint láthatja, ez ugyanaz az API, amelyhez a kubectl hozzáfér. Ugyanannak az API-nak a használata a belső komponensekhez és a külső felhasználókhoz a Kubernetes tervezésének alapvető koncepciója.

Most összefoglalhatjuk a Kubernetes működését:

A tárolótárak kimondják, vagyis a Kubernetes erőforrásokat.
Az API-kiszolgáló interfészt biztosít a tárolóhoz a Kubernetes API formájában.
Az összes többi Kubernetes-összetevő és felhasználó az API-n keresztül olvassa, figyeli és kezeli a Kubernetes állapotát (erőforrásait).

Ezen fogalmak ismerete segít jobban megérteni a kubectl-t, és a legtöbbet kihozni belőle.

Most pedig nézzünk meg néhány konkrét tippet és trükköt, amelyek segítenek javítani a kubectl-lel végzett termelékenységet.

1. Gyorsítsa fel a bevitelt a parancskiegészítés segítségével

Az egyik leghasznosabb, de gyakran figyelmen kívül hagyott technika a kubectl teljesítményének javítására a parancskiegészítés.

A parancskiegészítés lehetővé teszi a kubectl parancsok egyes részeinek automatikus befejezését a Tab billentyűvel. Ez az alparancsok, opciók és argumentumok esetében működik, beleértve az olyan összetett dolgokat is, mint az erőforrásnevek.

Nézze meg, hogyan működik a kubectl parancskifejezés:

A parancskiegészítés működik Bash és Zsh shelleknél.

Hivatalos útmutató részletes utasításokat tartalmaz az automatikus kiegészítés beállításához, de az alábbiakban egy rövid kivonatot közölünk.

Hogyan működik a parancskitöltés

A Command Completion egy shell-szolgáltatás, amely befejezési parancsfájl használatával működik. A kiterjesztés szkript egy shell szkript, amely egy adott parancs kiterjesztésének viselkedését határozza meg.

A Kubectl automatikusan generálja és kiadja a Bash és Zsh kiterjesztés szkriptjeit a következő parancsokkal:

$ kubectl completion bash

vagy:

$ kubectl completion zsh

Elméletileg elegendő ezen parancsok kimenetét a megfelelő parancshéjhoz csatlakoztatni, hogy a kubectl kiegészíthesse a parancsokat.

A gyakorlatban a csatlakozási mód más a Bash esetében (beleértve a Linux és a MacOS közötti különbségeket is) és a Zsh-t. Az alábbiakban mindezeket a lehetőségeket megvizsgáljuk.

Bash Linuxon

A Bash befejezési szkript a bash-completion csomagtól függ, ezért először telepítenie kell:

$ sudo apt-get install bash-completion

vagy:

$ yum install bash-completion

A csomag sikeres telepítését a következő paranccsal ellenőrizheti:

$ type _init_completion

Ha ez shell funkciókódot ad ki, akkor a bash-completion megfelelően van telepítve. Ha a parancs „Nem található” hibát ad, akkor a következő sort kell hozzáadnia a fájlhoz ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

Szükséges-e hozzáadni ezt a sort a fájlhoz ~ / .bashrc A bash-completion telepítéséhez használt csomagkezelőtől függ, vagy sem. Ez szükséges az APT-hez, de nem a YUM-hoz.

A bash-completion telepítése után mindent úgy kell beállítani, hogy a kubectl befejező parancsfájl minden shell-munkamenetben engedélyezve legyen.

Ennek egyik módja a következő sor hozzáadása a fájlhoz ~ / .bashrc:

source <(kubectl completion bash)

Egy másik módszer a kubectl kiterjesztés szkript hozzáadása a könyvtárhoz /etc/bash_completion.d (ha nem létezik, hozza létre):

$ kubectl completion bash >/etc/bash_completion.d/kubectl

A katalógusban található összes kiegészítő szkript /etc/bash_completion.d automatikusan szerepelnek a bash-kiegészítésben.

Mindkét lehetőség egyformán alkalmazható.

A shell újraindítása után a kubectl parancs befejezése működni fog.

Bash a MacOS rendszeren

MacOS-en a beállítás egy kicsit bonyolultabb. A helyzet az, hogy a MacOS alapértelmezés szerint a Bash 3.2-es verzióját használja, és a kubectl automatikus kiegészítési szkripthez legalább 4.1-es Bash-verzió szükséges, és a Bash 3.2-ben nem működik.

A Bash elavult verziójának MacOS rendszeren való használata esetén licencelési problémák merülnek fel. A Bash 4-es verziója GPLv3 licenc alatt áll, amelyet az Apple nem támogat.

A kubectl automatikus kiegészítés konfigurálásához MacOS rendszeren telepítenie kell a Bash egy újabb verzióját. A frissített Bash-t is beállíthatja alapértelmezett shellként, ami sok problémától kíméli meg a jövőben. Nem nehéz, a részleteket a cikk tartalmazza "A Bash frissítése MacOS rendszeren".

Mielőtt folytatná, győződjön meg arról, hogy a Bash legújabb verzióját használja (ellenőrizze a kimenetet bash --version).

A Bash befejezési szkript projektenként eltérő bash-befejezés, ezért először telepítenie kell.

A bash-completion a segítségével telepítheti Homebrew:

$ brew install bash-completion@2

Itt @2 a bash-completion 2-es verzió rövidítése. A kubectl automatikus kiegészítéséhez bash-completion v2, a bash-completion v2-hez pedig legalább a Bash 4.1-es verziója szükséges.

Parancs kimenet brew-install tartalmaz egy Figyelmeztetések szakaszt, amely meghatározza, hogy mit kell hozzáadni a fájlhoz ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

Azt javaslom azonban, hogy ezeket a sorokat ne adja hozzá ~/.bash_profile, és be ~/.bashrc. Ebben az esetben az automatikus kiegészítés nem csak a fő, hanem a gyermek parancshéjakban is elérhető lesz.

A parancshéj újraindítása után a következő paranccsal ellenőrizheti a telepítés helyességét:

$ type _init_completion

Ha shell függvényt lát a kimenetben, akkor minden megfelelően van beállítva.

Most biztosítanunk kell, hogy a kubectl automatikus kiegészítése minden munkamenetben engedélyezve legyen.

Az egyik módja az, hogy hozzáadja a következő sort a sajátjához ~/.bashrc:

source <(kubectl completion bash)

A második módszer egy automatikus kiegészítõ szkript hozzáadása a mappához /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

Ez a módszer csak akkor működik, ha a Homebrew segítségével telepítette a bash-completion funkciót. Ebben az esetben a bash-completion az összes szkriptet betölti ebből a könyvtárból.

Ha telepítette kubectl a Homebrew használatával, akkor nincs szükség az előző lépés végrehajtására, mivel az automatikus kiegészítési szkript automatikusan a mappába kerül /usr/local/etc/bash_completion.d telepítés során. Ebben az esetben a kubectl automatikus kiegészítés a bash-completion telepítése után azonnal működésbe lép.

Ennek eredményeként ezek a lehetőségek egyenértékűek.

zsh

A Zsh automatikus kiegészítési szkriptjei nem igényelnek függőséget. Mindössze annyit kell tennie, hogy engedélyezze őket a parancshéj betöltésekor.

Ezt úgy teheti meg, hogy hozzáad egy sort a sajátjához ~/.zshrc fájl:

source <(kubectl completion zsh)

Ha hibaüzenetet kap not found: compdef a shell újraindítása után engedélyeznie kell a beépített funkciót compdef. Engedélyezheti, ha hozzáadja a fájl elejéhez ~/.zshrc a következő:

autoload -Uz compinit
compinit

2. Gyorsan megtekintheti az erőforrás-specifikációkat

Amikor YAML-erőforrás-definíciókat hoz létre, ismernie kell a mezőket és azok jelentését ezekhez az erőforrásokhoz. Ezt az információt az API-referenciában lehet keresni, amely az összes erőforrás teljes specifikációját tartalmazza.

Azonban kényelmetlen a webböngészőre váltani minden alkalommal, amikor keresni kell valamit. Ezért a kubectl biztosítja a parancsot kubectl explain, amely az összes erőforrás specifikációját mutatja közvetlenül a terminálon.

A parancs formátuma a következő:

$ kubectl explain resource[.field]...

A parancs a kért erőforrás vagy mező specifikációját adja ki. A megjelenített információk megegyeznek az API-kézikönyvben foglaltakkal.

Alapértelmezésben kubectl explain csak a mezők egymásba ágyazásának első szintjét mutatja.

Nézze meg, hogyan néz ki Akkor majd.

A teljes fa megjeleníthető, ha hozzáadja a lehetőséget --recursive:

$ kubectl explain deployment.spec --recursive

Ha nem tudja pontosan, hogy mely erőforrásokra van szüksége, az összeset megjelenítheti a következő paranccsal:

$ kubectl api-resources

Ez a parancs többes számban jeleníti meg az erőforrásneveket, pl. deployments helyett deployment. Megjeleníti például a rövid nevet is deploy, azoknak a forrásoknak, amelyek rendelkeznek vele. Ne aggódjon ezek miatt a különbségek miatt. Mindezek az elnevezési beállítások egyenértékűek a kubectl esetében. Vagyis bármelyikre használhatod kubectl explain.

A következő parancsok mindegyike egyenértékű:

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. Használjon egyéni oszlopkimeneti formátumot

A parancs alapértelmezett kimeneti formátuma kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

Ez a formátum kényelmes, de korlátozott mennyiségű információt tartalmaz. A teljes erőforrás-definíciós formátumhoz képest itt csak néhány mező jelenik meg.

Ebben az esetben egyéni oszlopkimeneti formátumot használhat. Lehetővé teszi annak meghatározását, hogy milyen adatokat kell kiadni. Bármely erőforrásmezőt külön oszlopként is megjeleníthet.

Az egyéni formátum használatát a következő beállítások határozzák meg:

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

Minden kimeneti oszlopot egy párként határozhat meg <header>:<jsonpath>Ahol <header> az oszlop neve, és <jsonpath> — egy erőforrásmezőt meghatározó kifejezés.

Nézzünk egy egyszerű példát:

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

A kimenet egy oszlopot tartalmaz a hüvelyek nevével.

Az opciókifejezés kiválasztja a mezőből a podneveket metadata.name. Ennek az az oka, hogy a pod neve a gyermeknév mezőben van megadva metadata a pod forrásleírásában. További részletek a címen találhatók API útmutató vagy írja be a parancsot kubectl explain pod.metadata.name.

Tegyük fel, hogy egy további oszlopot szeretne hozzáadni a kimenethez, például azt a csomópontot, amelyen minden pod fut. Ehhez egyszerűen hozzáadhatja a megfelelő oszlopspecifikációt az egyéni oszlopok beállításhoz:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

A kifejezés kiválasztja a csomópont nevét spec.nodeName — ha egy pod hozzá van rendelve egy csomóponthoz, a neve beírásra kerül a mezőbe spec.nodeName pod erőforrás specifikáció. Részletesebb információ a kimenetben található kubectl explain pod.spec.nodeName.

Felhívjuk figyelmét, hogy a Kubernetes erőforrásmezők megkülönböztetik a kis- és nagybetűket.

Bármely erőforrásmezőt megtekinthet oszlopként. Csak tekintse át az erőforrás-specifikációt, és próbálja ki tetszőleges mezővel.

De először nézzük meg közelebbről a mezőkijelölési kifejezéseket.

JSONPath kifejezések

Az erőforrásmezők kiválasztására szolgáló kifejezések alapja JSONPath.

A JSONPath egy nyelv a JSON-dokumentumokból való adatok lekérésére. Egyetlen mező kiválasztása a JSONPath legegyszerűbb használati esete. Neki sok van nagyobb hang, beleértve a választókat, szűrőket és így tovább.

A Kubectl magyarázat korlátozott számú JSONPath szolgáltatást támogat. Az alábbiakban ismertetjük a lehetőségeket és a felhasználási példákat:

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

A [] operátor különösen fontos. Sok Kubernetes-erőforrásmező lista, és ez az operátor lehetővé teszi a listák tagjainak kiválasztását. Gyakran használják helyettesítő karakterekkel, például [*]-val a lista összes elemének kijelöléséhez.

Alkalmazási példák

Az egyéni oszlopkimeneti formátum használatának lehetőségei végtelenek, mivel bármilyen mezőt vagy erőforrásmezők kombinációját megjelenítheti a kimenetben. Íme néhány példaalkalmazás, de nyugodtan fedezze fel őket, és találjon megfelelő alkalmazásokat.

Tárolóképek megjelenítése hüvelyekhez:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

NAME                        IMAGES
engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
web-ui-6db964458-8pdw4      wordpress

Ez a parancs megjeleníti az egyes podokhoz tartozó tárolóképneveket.

Ne feledje, hogy egy sor több tárolót is tartalmazhat, ekkor a képek nevei egy sorban jelennek meg, vesszővel elválasztva.

A csomópontok elérhetőségi zónáinak megjelenítése:
```
$ kubectl get nodes 
  -o 
custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'

NAME                          ZONE
ip-10-0-118-34.ec2.internal   us-east-1b
ip-10-0-36-80.ec2.internal    us-east-1a
ip-10-0-80-67.ec2.internal    us-east-1b
```
Ez a parancs akkor hasznos, ha a fürt nyilvános felhőben található. Megjeleníti az egyes csomópontok elérhetőségi zónáját.

Az elérhetőségi zóna egy felhőalapú koncepció, amely a replikációs zónát egy földrajzi régióra korlátozza.

Az egyes csomópontok elérhetőségi zónái egy speciális címkén keresztül érhetők el - failure-domain.beta.kubernetes.io/zone. Ha a fürt nyilvános felhőben fut, akkor ez a címke automatikusan létrejön, és az egyes csomópontok elérhetőségi zónáinak nevével töltődik fel.

A címkék nem részei a Kubernetes erőforrás-specifikációnak, így nem talál róluk információkat API útmutató. Azonban láthatók (mint bármely más címkék), ha információkat kér a csomópontokról YAML vagy JSON formátumban:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
Ez egy nagyszerű módja annak, hogy többet tudjon meg az erőforrásokról, az erőforrás-specifikációk elsajátítása mellett.

4. Könnyen válthat a fürtök és a névterek között

Amikor a kubectl kérést intéz a Kubernetes API-hoz, először beolvassa a kubeconfig fájlt, hogy megkapja a kapcsolathoz szükséges összes paramétert.

Alapértelmezés szerint a kubeconfig fájl ~/.kube/config. Ezt a fájlt általában egy speciális parancs hozza létre vagy frissíti.

Ha több fürttel dolgozik, a kubeconfig fájl tartalmazza az összes fürthöz való csatlakozás beállításait. Meg kell adnia a kubectl parancsnak, hogy melyik fürttel dolgozik.

Egy fürtön belül több névteret is létrehozhat – egyfajta virtuális fürtöt a fizikai fürtön belül. A Kubectl azt is meghatározza, hogy melyik névteret használja a kubeconfig fájl alapján. Ez azt jelenti, hogy meg kell adnia a kubectl parancsnak, hogy milyen névtérrel dolgozzon.

Ebben a fejezetben elmagyarázzuk, hogyan működik, és hogyan lehet hatékonyan működni.

Vegye figyelembe, hogy a KUBECONFIG környezeti változóban több kubeconfig fájl is szerepelhet. Ebben az esetben ezek a fájlok egyetlen közös konfigurációban egyesülnek futás közben. Az alapértelmezett kubeconfig fájlt úgy is módosíthatja, hogy a kubectl parancsot a paraméterrel futtatja --kubeconfig. Néz hivatalos dokumentáció.

kubeconfig fájlokat

Lássuk, mit is tartalmaz pontosan a kubeconfig fájl:

Mint látható, a kubeconfig fájl kontextuskészletet tartalmaz. A kontextus három elemből áll:

Fürt — A fürtkiszolgáló API URL-je.
Felhasználó – felhasználói hitelesítési adatok a fürtben.
Névtér – a fürthöz való csatlakozáskor használt névtér.

A gyakorlatban gyakran egy kontextust használnak fürtönként a kubeconfig-jukban. Fürtenként azonban több kontextus is lehet, felhasználó vagy névtér szerint megkülönböztetve. Ez a többkontextusos konfiguráció azonban nem gyakori, ezért általában egy-egy leképezés van a fürtök és a kontextusok között.

Bármikor az egyik kontextus aktuális:

Amikor a kubectl beolvas egy konfigurációs fájlt, mindig az aktuális környezetből vesz információkat. A fenti példában a kubectl a Hare-fürthöz fog csatlakozni.

Ennek megfelelően, ha másik fürtre szeretne váltani, meg kell változtatnia az aktuális környezetet a kubeconfig fájlban:

Most a kubectl csatlakozik a Fox-fürthöz.

Ha ugyanabban a fürtben egy másik névtérre szeretne váltani, módosítania kell a névtér elem értékét az aktuális környezethez:

A fenti példában a kubectl a Fox-fürt Prod névterét fogja használni (korábban a Test névteret beállították).

Vegye figyelembe, hogy a kubectl opciókat is biztosít --cluster, --user, --namespace и --context, amelyek lehetővé teszik az egyes elemek és az aktuális kontextus felülírását, függetlenül attól, hogy mi van beállítva a kubeconfigban. Néz kubectl options.

Elméletileg manuálisan is módosíthatja a beállításokat a kubeconfigban. De ez kényelmetlen. E műveletek egyszerűsítésére különféle segédprogramok állnak rendelkezésre, amelyek lehetővé teszik a paraméterek automatikus módosítását.

Használj kubectx-et

Nagyon népszerű segédprogram a fürtök és a névterek közötti váltáshoz.

A segédprogram parancsokat ad kubectx и kubens az aktuális környezet és névtér módosításához.

Mint említettük, az aktuális kontextus megváltoztatása a fürt módosítását jelenti, ha fürtönként csak egy kontextus van.

Íme egy példa a parancsok futtatására:

Lényegében ezek a parancsok egyszerűen szerkesztik a kubeconfig fájlt a fent leírtak szerint.

üzembe helyezni kubectx, kövesse az utasításokat GitHub.

Mindkét parancs támogatja a kontextus- és névtérnevek automatikus kiegészítését, így nincs szükség a teljes beírásra. Útmutató az automatikus kiegészítés beállításához itt.

Egy másik hasznos funkció kubectx a interaktív mód. A segédprogrammal együtt működik fzf, amelyet külön kell telepíteni. Az fzf telepítése automatikusan elérhetővé teszi az interaktív módot kubectx. Interaktív módon kiválaszthatja a környezetet és a névteret az fzf által biztosított interaktív ingyenes keresőfelületen keresztül.

Shell álnevek használata

Nincs szükség külön eszközökre az aktuális kontextus és névtér megváltoztatásához, mert a kubectl parancsokat is biztosít ehhez. Igen, csapat kubectl config alparancsokat biztosít a kubeconfig fájlok szerkesztéséhez.

Вот некоторые из них:

kubectl config get-contexts: az összes kontextus megjelenítése;
kubectl config current-context: aktuális kontextus lekérése;
kubectl config use-context: az aktuális kontextus megváltoztatása;
kubectl config set-context: A kontextus elem módosítása.

Ezeknek a parancsoknak a közvetlen használata azonban nem túl kényelmes, mert hosszúak. Könnyen végrehajtható shell-álneveket készíthetsz nekik.

E parancsok alapján létrehoztam egy álneveket, amelyek a kubectx-hez hasonló funkcionalitást biztosítanak. Itt láthatod őket működés közben:

Vegye figyelembe, hogy az álnevek az fzf-et használják interaktív, ingyenes keresési felület biztosítására (mint például a kubectx interaktív módja). Ez azt jelenti, hogy szüksége van telepítse az fzfhogy ezeket az álneveket használjuk.

Íme maguknak az álneveknek a meghatározása:

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

Ezen álnevek beállításához hozzá kell adnia a fenti definíciókat a fájlhoz ~/.bashrc vagy ~/.zshrc és indítsa újra a shelljét.

Beépülő modulok használata

A Kubectl lehetővé teszi olyan beépülő modulok betöltését, amelyek az alapvető parancsokhoz hasonlóan futnak le. Telepítheti például a kubectl-foo beépülő modult, és a parancs végrehajtásával futtathatja kubectl foo.

Kényelmes lenne a kontextust és a névteret ilyen módon megváltoztatni, például futtatással kubectl ctx kontextus megváltoztatására és kubectl ns a névtér megváltoztatásához.

Írtam két plugint, amelyek ezt teszik:

A beépülő modulok működése az előző rész álneveire épül.

Így működnek:

Ne feledje, hogy a beépülő modulok az fzf-et használják interaktív ingyenes keresési felület biztosítására (mint a kubectx interaktív módja). Ez azt jelenti, hogy szüksége van telepítse az fzfhogy ezeket az álneveket használjuk.

A bővítmények telepítéséhez le kell töltenie a shell szkripteket kubectl-ctx и kubectl-ns a PATH változó bármely könyvtárába, és végrehajthatóvá tegye őket pl. chmod +x. Ezt követően azonnal használhatja kubectl ctx и kubectl ns.

5. Csökkentse a bevitelt automatikus álnevekkel

A shell álnevek jó módja a bevitel felgyorsításának. Projekt kubectl-álnevek körülbelül 800 gyorsbillentyűt tartalmaz az alapvető kubectl parancsokhoz.

Kíváncsi lehet – hogyan emlékszik 800 álnévre? De nem kell mindegyikre emlékeznie, mert egy egyszerű séma szerint épülnek fel, amelyet az alábbiakban adunk meg:

Például:

kgpooyaml - kubectl get pods oyaml
ksysgsvcw — kubectl -n kube-system get svc w
ksysrmcm -kubectl -n kube-system rm cm
kgdepallsl - kubectl get deployment all sl

Mint látható, az álnevek összetevőkből állnak, amelyek mindegyike a kubectl parancs egy-egy elemét képviseli. Minden álnév egy összetevőt tartalmazhat az alapparancshoz, művelethez és erőforráshoz, valamint több összetevőt a paraméterekhez. Ezeket a komponenseket egyszerűen balról jobbra "be kell tölteni" a fenti diagramnak megfelelően.

A jelenlegi részletes diagram a GitHub. Ott is lehet találni az álnevek teljes listája.

Például a kgpooyamlall álnév megegyezik a paranccsal kubectl get pods -o yaml --all-namespaces.

Az opciók egymáshoz viszonyított sorrendje nem fontos: parancs kgpooyamlall egyenértékű a paranccsal kgpoalloyaml.

Nem kell minden összetevőt álnévként használnia. Például k, kg, klo, ksys, kgpo is használható. Ezenkívül kombinálhatja az álneveket és a szokásos parancsokat vagy opciókat a parancssorban:

Például:

Helyett kubectl proxy tudsz írni k proxy.
Helyett kubectl get roles tudsz írni kg roles (jelenleg nincs álneve a Szerepkörök erőforrásnak).
Egy adott pod adatainak lekéréséhez használhatja a parancsot kgpo my-pod — kubectl get pod my-pod.

Kérjük, vegye figyelembe, hogy egyes álnevekhez parancssori argumentum szükséges. Például alias kgpol eszközök kubectl get pods -l. választási lehetőség -l argumentumot igényel – címkespecifikációt. Ha álnevet használ, az így fog kinézni kgpol app=ui.

Mivel egyes álnevek argumentumokat igényelnek, az a, f és l álneveket utoljára kell használni.

Általánosságban elmondható, hogy amint megismeri ezt a sémát, intuitív módon álneveket származtathat a végrehajtani kívánt parancsokból, és sok gépelési időt takaríthat meg.

telepítés

A kubectl-aliases telepítéséhez le kell töltenie a fájlt .kubectl_aliases a GitHubból, és belefoglalja a fájlba ~/.bashrc vagy ~/.zshrc:

source ~/.kubectl_aliases

Automatikus kiegészítés

Ahogy korábban is mondtuk, gyakran ad hozzá további szavakat egy aliashoz a parancssorban. Például:

$ kgpooyaml test-pod-d4b77b989

Ha a kubectl parancskiegészítést használja, valószínűleg használta az automatikus kiegészítést például az erőforrásnevekhez. De megtehető ez álnevek használatakor?

Ez egy nagyon fontos kérdés, mert ha az automatikus kiegészítés nem működik, elveszíti az álnevek előnyeit.

A válasz attól függ, hogy melyik shellt használja:

A Zsh esetében az alias-kiegészítés azonnal működik.
A Bash esetében sajnos némi munkára van szükség ahhoz, hogy az automatikus kiegészítés működjön.

Az álnevek automatikus kiegészítésének engedélyezése a Bash-ban

A Bash-val az a probléma, hogy az aliast próbálja befejezni (minden alkalommal, amikor megnyomja a Tab billentyűt), nem azt a parancsot, amelyre az alias hivatkozik (mint például a Zsh). Mivel nem rendelkezik befejező szkriptekkel mind a 800 álnévhez, az automatikus kiegészítés nem működik.

Terv teljes-alias általános megoldást nyújt erre a problémára. Csatlakozik az álnevek befejezési mechanizmusához, belsőleg kibővíti az álnevet egy parancsra, és visszaadja a befejezett parancs befejezési opcióit. Ez azt jelenti, hogy az álnév kitöltése pontosan ugyanúgy viselkedik, mint a teljes parancsé.

A következőkben először elmagyarázom, hogyan kell telepíteni a teljes álnevet, majd hogyan konfigurálható úgy, hogy az összes kubectl alias esetében engedélyezze a befejezést.

Teljes álnév telepítése

Először is, a teljes álnév attól függ bash-befejezés. Ezért a teljes álnév telepítése előtt meg kell győződnie arról, hogy a bash-completion telepítve van. A telepítési utasításokat korábban már biztosítottuk Linux és MacOS rendszerhez.

Fontos megjegyzés MacOS-felhasználók számára: A kubectl automatikus kiegészítési szkripthez hasonlóan a teljes álnév sem működik a Bash 3.2-vel, amely az alapértelmezett MacOS. Különösen a teljes álnév függ a bash-completion v2 (brew install bash-completion@2), amelyhez legalább Bash 4.1 szükséges. Ez azt jelenti, hogy a teljes álnév használatához MacOS rendszeren telepítenie kell a Bash újabb verzióját.

Le kell töltenie a szkriptet bash_completion.sh A GitHub adattár és vegye fel a fájljába ~/.bashrc:

source ~/bash_completion.sh

A shell újraindítása után a teljes álnév teljesen telepítve lesz.

Automatikus kiegészítés engedélyezése kubectl álnevekhez

A technikailag teljes álnév wrapper funkciót biztosít _complete_alias. Ez a függvény ellenőrzi az álnevet, és az alias parancs befejezésére vonatkozó tippeket ad vissza.

Ha egy függvényt egy adott aliashoz szeretne rendelni, akkor a beépített Bash mechanizmust kell használnia teljes, üzembe helyezni _complete_alias alias-kiegészítő függvényként.

Példaként vegyük a k álnevet, amely a kubectl parancsot jelöli. telepíteni _complete_alias Ennek az álnévnek a kiegészítéseként a következő parancsot kell futtatnia:

$ complete -F _complete_alias k

Ennek az az eredménye, hogy amikor automatikusan kiegészít egy k álnevet, a függvény meghívásra kerül _complete_alias, amely ellenőrzi az álnevet, és a parancs befejezésére vonatkozó tippeket ad vissza kubectl.

Második példaként vegyük az álnevet kg, ami azt jelöli kubectl get:

$ complete -F _complete_alias kg

Csakúgy, mint az előző példában, amikor automatikusan kitölti a kg-ot, ugyanazokat a befejezési tippeket kapja, amelyeket kubectl get.

Ne feledje, hogy a teljes álnevet használhatja a rendszer bármely álnevéhez.

Ezért az összes kubectl álnév automatikus kiegészítésének engedélyezéséhez mindegyikhez le kell futnia a fenti parancsot. A következő kódrészlet pontosan ezt teszi, feltéve, hogy a kubectl-aliases értéket állította be ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

Ezt a kódrészletet el kell helyezni a ~/.bashrc, indítsa újra a parancshéjat, és az automatikus kiegészítés elérhető lesz mind a 800 kubectl álnévhez.

6. A kubectl bővítése bővítményekkel

-Tól kezdve 1.12. verzió, kubectl támogatja plugin mechanizmus, amely lehetővé teszi funkcióinak további parancsokkal való bővítését.

Ha ismeri Git plugin mechanizmusok, akkor a kubectl bővítmények ugyanezen az elven épülnek fel.

Ebben a fejezetben bemutatjuk, hogyan telepítsünk bővítményeket, hol találjuk meg őket, és hogyan hozhatunk létre saját beépülő modulokat.

Beépülő modulok telepítése

A Kubectl beépülő modulok egyszerű végrehajtható fájlokként vannak terjesztve, hasonló néven kubectl-x. Előtag kubectl- szükséges, amit egy új kubectl alparancs követ, amely lehetővé teszi a beépülő modul meghívását.

Például a hello plugin nevű fájlként kerül terjesztésre kubectl-hello.

A bővítmény telepítéséhez át kell másolnia a fájlt kubectl-x a PATH tetszőleges könyvtárába, és végrehajthatóvá tegye, például a következővel chmod +x. Közvetlenül ezután hívhatja a bővítményt kubectl x.

A következő paranccsal listázhatja a rendszerére jelenleg telepített összes bővítményt:

$ kubectl plugin list

Ez a parancs akkor is figyelmeztetéseket jelenít meg, ha több azonos nevű beépülő modulja van, vagy ha van olyan beépülő modul, amely nem futtatható.

Bővítmények keresése és telepítése a Krew segítségével

A Kubectl beépülő modulok szoftvercsomagokhoz hasonlóan megoszthatók vagy újrafelhasználhatók. De hol találhat olyan bővítményeket, amelyeket mások megosztottak?

Projekt Krew célja, hogy egységes megoldást nyújtson a kubectl bővítmények megosztására, keresésére, telepítésére és kezelésére. A projekt a "kubectl bővítmények csomagkezelőjének" nevezi magát (a Krew hasonló a Sörfőzés).

A Krew a kiválasztható és telepíthető kubectl beépülő modulok listája. Ugyanakkor a Krew a kubectl beépülő modulja is.

Ez azt jelenti, hogy a Krew telepítése lényegében úgy működik, mint bármely más kubectl beépülő modul telepítése. Részletes utasításokat a címen találhat GitHub oldal.

A legfontosabb Krew parancsok a következők:

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

Kérjük, vegye figyelembe, hogy a bővítmények Krew segítségével történő telepítése nem zavarja a beépülő modulok fent leírt szabványos módszerrel történő telepítését.

Felhívjuk figyelmét, hogy a parancs kubectl krew list csak azokat a bővítményeket jeleníti meg, amelyeket a Krew segítségével telepítettek, míg a parancsot kubectl plugin list listázza az összes bővítményt, azaz a Krew-val telepítetteket és a más módszerekkel telepítetteket.

Bővítmények keresése máshol

A Krew egy fiatal projekt, jelenleg folyamatban van a listát csak körülbelül 30 plugin. Ha nem találja azt, amire szüksége van, máshol találhat bővítményeket, például a GitHubot.

Azt javaslom, hogy nézze meg a GitHub részt kubectl-plugins. Ott tucatnyi elérhető bővítményt talál, amelyeket érdemes megnézni.

Saját pluginok írása

Meg tudod magad bővítmények létrehozása - Nem nehéz. Létre kell hoznia egy végrehajtható fájlt, ami azt csinálja, amire szüksége van, nevezze el így kubectl-x és telepítse a fent leírtak szerint.

A fájl lehet bash szkript, python szkript vagy lefordított GO alkalmazás – ez nem számít. Az egyetlen feltétel az, hogy közvetlenül végrehajtható legyen az operációs rendszerben.

Most hozzunk létre egy példa plugint. Az előző szakaszban a kubectl parancsot használta az egyes podokhoz tartozó tárolók listázásához. Ezt a parancsot könnyű pluginná alakítani, amit pl. kubectl img.

Hozzon létre egy fájlt kubectl-img a következő tartalom:

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

Most tegye a fájlt végrehajthatóvá a következővel chmod +x kubectl-img és helyezze át a PATH bármely könyvtárába. Közvetlenül ezután használhatja a plugint kubectl img.

Mint említettük, a kubectl beépülő modulok bármilyen programozási vagy szkriptnyelven írhatók. Ha shell-szkripteket használ, annak az az előnye, hogy könnyen hívhatja a kubectl-t a bővítményen belül. A segítségével azonban összetettebb bővítményeket írhat valódi programozási nyelveken Kubernetes ügyfélkönyvtár. Ha Go-t használ, akkor is használhatja cli-runtime könyvtár, amely kifejezetten a kubectl bővítmények írásához létezik.

Hogyan lehet megosztani a bővítményeket

Ha úgy gondolja, hogy beépülő moduljai mások számára hasznosak lehetnek, nyugodtan ossza meg a GitHubon. Feltétlenül adja hozzá őket a témához kubectl-plugins.

Azt is kérheti, hogy adják hozzá bővítményét Krew lista. Ennek végrehajtására vonatkozó utasítások itt találhatók GitHub adattárak.

A parancs teljesítése

A beépülő modulok jelenleg nem támogatják az automatikus kiegészítést. Vagyis meg kell adnia a bővítmény teljes nevét és az argumentumok teljes nevét.

A függvény GitHub kubectl tárháza rendelkezik nyílt kérés. Így lehetséges, hogy ezt a funkciót valamikor a jövőben bevezetik.

Sok szerencsét!

Mit kell még olvasni a témában:

Forrás: will.com

A kubectl hatékonyabb használata: részletes útmutató