Hur man effektivt använder kubectl: en detaljerad guide

Låt oss titta på ett enkelt exempel:

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

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

Utdatan innehåller en kolumn med namnen på poddarna.

Uttrycket i alternativet väljer namnen på poddarna från fältet metadata.name. Detta beror på att poddavsnittets namn definieras i det underliggande fältet name i poddens resursbeskrivning. Du kan läsa mer i metadata API-dokumentationen eller skriva kommandot kubectl explain pod.metadata.name kubectl förklara pod.metadata.namn.

Anta så att du vill lägga till en extra kolumn i utdata, till exempel som visar noden som varje pod körs på. För att göra detta kan du helt enkelt lägga till den relevanta kolumnspecifikationen i alternativet för anpassade kolumner:

$ 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

Uttrycket väljer nodens namn från spec.nodeName — när en pod tilldelas en nod skrivs dess namn in i fältet spec.nodeName resursens specifikation för podden. Mer information kan ses i utdata från kubectl explain pod.spec.nodeName.

Observera att Kubernetes resursfält är skiftlägeskänsliga.

Du kan se vilket resursfält som helst som en kolumn. Titta bara på resursens specifikation och testa med vilka fält du vill.

Men först ska vi titta närmare på fältvaluttryck.

JSONPath-uttryck

Uttryck för att välja resursfält baseras på JSONPath.

JSONPath är ett språk för att hämta data från JSON-dokument. Att välja ett fält är det enklaste användningsfallet för JSONPath. Det har mycket mer funktionalitet, inklusive växlare, filter och så vidare.

Kubectl explain stöder ett begränsat antal JSONPath-funktioner. Nedan beskrivs funktionerna och exempel på deras användning:

# Выбрать все элементы списка
$ 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'

Operatören [] har en speciell betydelse. Många Kubernetes resursfält är listor, och denna operator gör det möjligt att välja element från dessa listor. Den används ofta med wildcard som [*] för att välja alla element i listan.

Tillämpningsexempel

Möjligheterna att använda anpassad kolumnutdataformat är oändliga, eftersom du kan visa vilket fält eller kombination av fält som helst i utdata. Här är några exempel på användningar, men tveka inte att utforska dem själv och hitta användningar som är användbara för dig.

1. Visa containerbilder för poddar:

   $ 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

   Detta kommando visar namnen på containerbilderna för varje pod.

   Kom ihåg att ett underlag kan innehålla flera containrar, då kommer bildnamnen att visas i en rad separerade med kommatecken.

2. Visning av zoner för tillgänglighet av noder:

   $ 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

   Detta kommando är praktiskt om din kluster är värd i en offentlig moln. Det visar tillgänglighetszonen för varje nod.

   En tillgänglighetszon är ett molnkonstrukt som begränsar replikeringszonen till ett geografiskt område.

   Tillgänglighetszoner för varje nod fårs genom en speciell etikett — failure-domain.beta.kubernetes.io/zone. Om klustret körs i ett offentligt moln, skapas denna etikett automatiskt och fylls med namnen på tillgänglighetszonerna för varje nod.

   Etiketter är inte en del av Kubernetes resurs specifikation, så du kommer inte att hitta information om dem i eller skriva kommandot. Men de kan ses (liksom alla andra etiketter) om du begär information om noder i YAML eller JSON-format:

   $ kubectl get nodes -o yaml
   # eller
   $ kubectl get nodes -o json

   Detta är ett utmärkt sätt att lära sig mer om resurser, utöver att studera resurs specifikationerna.

4. Lätt att växla mellan kluster och namnrymder

När kubectl gör en förfrågan till Kubernetes API, läser den kubeconfig-filen för att få alla nödvändiga parametrar för anslutning.

Som standard är kubeconfig-filen ~/.kube/config. Denna fil skapas eller uppdateras vanligtvis med ett särskilt kommando.

När du arbetar med flera kluster innehåller din kubeconfig-fil anslutningsparametrar för alla dessa kluster. Du behöver ett sätt att ange för kubectl vilket kluster du arbetar med.

Inom klustret kan du skapa flera namnrymder — en typ av virtuellt kluster inom ett fysiskt kluster. Kubectl bestämmer vilken namnrymd som ska användas baserat på uppgifterna i kubeconfig-filen. Det betyder att du också behöver ett sätt att ange för kubectl vilken namnrymd som ska användas.

I det här avsnittet kommer vi att förklara hur detta fungerar och hur du kan uppnå effektiv drift.

Observera att du kan ha flera kubeconfig-filer listade i miljövariabeln KUBECONFIG. I så fall kommer alla dessa filer att slås samman till en gemensam konfiguration under körning. Du kan också ändra den använda standardkubeconfig-filen genom att köra kubectl med parametern --kubeconfig. Se den officiella dokumentationen.

Kubeconfig-filer

Låt oss titta på vad kubeconfig-filen faktiskt innehåller:

Som du kan se innehåller kubeconfig-filen en uppsättning kontexter. En kontext består av tre element:

• Cluster — API-serverns URL för klustret.
• User — autentiseringsuppgifter för användaren i klustret.
• Namespace — namnutrymme som används vid anslutning till klustret.

I praktiken används ofta en kontext per kluster i din kubeconfig-fil. Du kan dock ha flera kontexter per kluster, som skiljer sig åt beroende på användare eller namnutrymme. Men en sådan konfiguration med flera kontexter förekommer sällan, så det finns vanligtvis en entydig koppling mellan kluster och kontexter.

Vid varje tidpunkt är en av kontexterna aktuell:

När kubectl läser konfigurationsfilen tas alltid information från den aktuella kontexten. I exemplet ovan kommer kubectl att ansluta till klustret Hare.

För att byta till ett annat kluster måste den aktuella kontexten i kubeconfig-filen ändras:

Nu kommer kubectl att ansluta till klustret Fox.

För att byta till ett annat namnutrymme i samma kluster måste värdet för elementet namespace för den aktuella kontexten ändras:

I det ovanstående exemplet kommer kubectl att använda namnutrymmet Prod för klustret Fox (tidigare var namnutrymmet Test inställt).

Observera att kubectl också tillhandahåller parametrar --cluster, --user, --namespace och --context, som gör att du kan skriva över individuella element och själva den aktuella kontexten, oavsett vad som är inställt i kubeconfig-filen. Se kubectl options.

Teoretiskt kan du manuellt ändra parametrarna i kubeconfig-filen. Men det är obekvämt. För att förenkla dessa operationer finns det olika verktyg som gör det möjligt att ändra parametrar automatiskt.

Använd kubectx

Ett mycket populärt verktyg för att växla mellan kluster och namnutrymmen.

Verktyget erbjuder kommandon kubectx och kubens för att ändra den aktuella kontexten och namnrymden därefter.

Som nämnts tidigare innebär att ändra den aktuella kontexten att ändra kluster om du har endast en kontext på klustret.

Här är ett exempel på att köra dessa kommandon:

I grund och botten redigerar dessa kommandon helt enkelt kubeconfig-filen, som beskrivits ovan.

För att installera kubectx, följ instruktionerna på Github.

Båda kommandona stöder autocompletion av namn på kontexter och namnrymder, vilket gör att du inte behöver skriva dem helt. Instruktioner för att ställa in autocompletion ). Ett typiskt exempel på användning:.

En annan användbar funktion kubectx denna funktion ett omslag runt modulen Crypt::UnixCrypt och utgör ingen fara, men i det levererade arkivet på Sourceforge anropas kod som direkt refererar till \/etc\/shadow, men gör det genom en shell-konstruktion. För att genomföra attacken räcker det med att ange tecknet "|" i fältet för det gamla lösenordet och koden efter detta kommer att köras med root-behörighet på servern. interaktivt läge. Det fungerar tillsammans med verktyget fzf, som måste installeras separat. Att installera fzf gör automatiskt det interaktiva läget tillgängligt i kubectx. I det interaktiva läget kan du välja kontext och namnrymd genom det interaktiva gränssnittet för fri sökning som fzf tillhandahåller.

Användning av kommandoradsalias

Du behöver inga separata verktyg för att ändra den aktuella kontexten och namnrymden, eftersom kubectl också tillhandahåller kommandon för detta. Så kommandot kubectl config tillhandahåller underkommandon för att redigera kubeconfig-filer.

Här är några av dem:

• kubectl config get-contexts: lista alla kontexter;
• kubectl config current-context: få den aktuella kontexten;
• kubectl config use-context: ändra den aktuella kontexten;
• kubectl config set-context: ändra kontextobjektet.

Men det är inte särskilt praktiskt att använda dessa kommandon direkt eftersom de är långa. Du kan skapa alias för kommandoraden som är lätta att köra.

Jag har skapat en uppsättning alias baserade på dessa kommandon som erbjuder funktionalitet liknande kubectx. Här kan du se dem i aktion:

Observera att aliasen använder fzf för att tillhandahålla ett interaktivt gränssnitt för fri sökning (som i det interaktiva läget kubectx). Detta innebär att du behöver installera fzf, för att använda dessa alias.

Här är själva definitionerna av aliasen:

# Получить текущий контекст
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/^..//")"'

För att installera dessa alias, lägg till de ovanstående definitionerna i din fil ~/.bashrc eller ~/.zshrc och starta om din shell.

Användning av plugins

Kubectl tillåter att ladda plugins som körs precis som huvudkommandona. Du kan till exempel installera pluginet kubectl-foo och köra det genom att utföra kommandot kubectl foo.

Det skulle vara praktiskt att byta kontext och namnrymd på det här sättet, till exempel köra kubectl ctx för att byta kontext och kubectl ns för att byta namnrymd.

Jag har skrivit två plugins som gör detta:

• kubectl-ctx
• kubectl-ns

Pluginernas funktionalitet baseras på alias från föregående avsnitt.

Så här fungerar de:

Observera att plugins använder fzf för att tillhandahålla ett interaktivt gränssnitt för fritt sökande (som i interaktivt läge kubectx). Det betyder att du behöver installera fzf, för att använda dessa alias.

För att installera plugins behöver du ladda ner skripten med namnen kubectl-ctx och kubectl-ns till valfri katalog i din PATH-variabel och göra dem körbara, till exempel med chmod +x. Direkt efter detta kan du använda kubectl ctx och kubectl ns.

5. Minska inmatningen med autoalias

Kommandoalias i skalet är ett bra sätt att snabba upp inmatningen. Projektet kubectl-aliases innehåller cirka 800 förkortningar för grundläggande kubectl-kommandon.

Du kanske undrar — hur minns man 800 alias? Men du behöver inte minnas dem alla, eftersom de bygger på ett enkelt mönster som beskrivs nedan:

Till exempel:

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

Som du ser består aliasen av komponenter, där varje komponent representerar en specifik del av kubectl-kommandot. Varje alias kan ha en komponent för grundkommandot, operationen och resursen samt flera komponenter för parametrar. Du "fyller" bara i dessa komponenter från vänster till höger enligt mönstret ovan.

Den aktuella detaljerade mallen finns på GitHub. Där kan du också hitta den fullständiga listan med alias.

Till exempel motsvarar aliaset kgpooyamlall kommandot kubectl get pods -o yaml --all-namespaces.

Den relativa ordningen av alternativen är inte viktig: kommandot kgpooyamlall är ekvivalent med kommandot kgpoalloyaml.

Du behöver inte använda alla komponenter som alias. Till exempel vågvektor, kg, klo, ksys, kgpo kan också användas. Dessutom kan du kombinera alias och vanliga kommandon eller alternativ i kommandoraden:

Till exempel:

1. Istället för kubectl proxy kan skrivas som k proxy.
2. Istället för kubectl get roles kan skrivas som kg roles (det finns för närvarande inget alias för resursen Roles).
3. För att få data om en specifik pod kan du använda kommandot kgpo my-pod — kubectl get pod my-pod.

Tänk på att vissa alias kräver ett argument i kommandoraden. Till exempel aliaset kgpol betyder kubectl get pods -l. Alternativet -l kräver ett argument – etikettens specifikation. Om du använder en alias ser den ut som kgpol app=ui.

Eftersom vissa av aliasen kräver argument måste aliasen a, f och l användas sist.

I allmänhet, när du väl behärskar detta mönster kan du intuitivt extrahera alias från de kommandon du vill köra och spara mycket tid på inmatning.

Installation

För att installera kubectl-aliases måste du ladda ner filen .kubectl_aliases från GitHub och inkludera den i filen ~/.bashrc eller ~/.zshrc:

source ~/.kubectl_aliases

Autokomplettering

Som vi redan har nämnt lägger du ofta till extra ord till aliaset i kommandoraden. Till exempel:

$ kgpooyaml test-pod-d4b77b989

Om du använder autokomplettering för kubectl, har du sannolikt använt autokomplettering för sådana saker som resursnamn. Men kan detta göras när du använder alias?

Detta är en mycket viktig fråga, eftersom om autokomplettering inte fungerar, tappar du en del av fördelarna med alias.

Svaret beror på vilken kommandoradstolk du använder:

1. För Zsh fungerar autokomplettering för alias 'ur lådan'.
2. Tyvärr, för Bash, krävs vissa åtgärder för att få autokompletteringen att fungera.

Aktivering av autokomplettering för alias i Bash

Problemet med Bash är att det försöker komplettera (när du trycker på Tab) aliaset, snarare än kommandot som aliaset refererar till (som Zsh gör). Eftersom du inte har kompletteringsskript för alla 800 alias fungerar inte autokomplettering.

Projektet complete-alias erbjuder en generell lösning på detta problem. Den ansluter sig till kompletteringsmekanismen för alias, kompletterar aliaset till kommandot och returnerar kompletteringsalternativ för det kompletterade kommandot. Detta innebär att kompletteringen för aliaset beter sig på samma sätt som för det fullständiga kommandot.

Näst kommer jag först att förklara hur du installerar complete-alias, och sedan hur du konfigurerar det för att aktivera komplettering för alla kubectl-alias.

Installation av complete-alias

Först och främst beror complete-alias på bash-completion. Därför måste du kontrollera att bash-completion är installerat innan du installerar complete-alias. Installationsanvisningarna gavs tidigare för Linux och MacOS.

Viktigt meddelande till MacOS-användare: precis som skriptet för autokomplettering kubectl, fungerar complete-alias inte med Bash 3.2, som är standard i MacOS. Specifikt beror complete-alias på bash-completion v2 (brew install bash-completion@2), som kräver minst Bash 4.1. Detta innebär att du måste installera en nyare version av Bash för att använda complete-alias på MacOS.

Du behöver ladda ner skriptet bash_completion.sh från från GitHub-repo och inkludera det i din fil ~/.bashrc:

source ~/bash_completion.sh

Efter omstart av kommandotolken kommer complete-alias att vara helt installerat.

Aktivering av autocompletion för kubectl-aliaser

Tekniskt sett tillhandahåller complete-alias en skalfunktion _complete_alias. Denna funktion kontrollerar aliaset och returnerar förslag för autocompletion av aliaskommandot.

För att koppla funktionen till ett specifikt alias behöver du använda Baashs inbyggda mekanism complete, för att ställa in _complete_alias som en autocompletionfunktion för aliaset.

Som exempel, låt oss ta aliaset k, som representerar kubectl-kommandot. För att ställa in _complete_alias som autocompletionfunktion för detta alias måste du köra följande kommando:

$ complete -F _complete_alias k

Resultatet av detta är att varje gång du autocompleterar aliaset k, anropas funktionen _complete_alias, som kontrollerar aliaset och returnerar förslag för kommandot kubectl.

Som ett andra exempel, låt oss ta aliaset kg, som representerar kubectl get:

$ complete -F _complete_alias kg

Precis som i det föregående exemplet, när du autocompleterar kg, får du samma förslag som du skulle fått för kubectl get.

Observera att complete-alias kan användas för vilket alias som helst i ditt system.

Därför, för att aktivera autocompletion för alla kubectl-aliaser, måste du köra ovanstående kommando för var och en av dem. Följande fragment gör just detta, förutsatt att du har installerat kubectl-aliases i ~/ .kubectl-aliases:

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

Denna kodbit måste placeras i din ~/.bashrc, starta om kommandotolken och autocompletion kommer att vara tillgänglig för alla 800 kubectl-aliaser.

6. Utvidgning av kubectl med hjälp av plugins

Från och med från version 1.12, kubectl stöder pluginmekanismen, som tillåter att funktionerna utvidgas med ytterligare kommandon.

Om du är bekant med pluginmekanismerna i Git, så är kubectl-plugins byggda på samma sätt.

I detta kapitel kommer vi att förklara hur man installerar plugins, var man hittar dem och hur man skapar egna plugins.

Installation av plugins

Kubectl-plugins distribueras i form av enkla körbara filer med ett namn som ser ut som kubectl-x. The prefix kubectl- är obligatoriskt, följt av en ny underkommandon kubectl som tillåter att anropa plugin.

Till exempel kommer pluginen hello att distribueras i form av en fil med namnet kubectl-hello.

För att installera pluginet behöver du kopiera filen kubectl-x till en valfri katalog i din PATH-variabel och göra den körbar, till exempel med hjälp av chmod +x. Direkt efter detta kan du anropa pluginet med hjälp av kubectl x.

Du kan använda följande kommando för att lista alla plugins som för närvarande är installerade i ditt system:

$ kubectl plugin list

Detta kommando visar också varningar om du har flera plugins med samma namn, eller om det finns en pluginfil som inte är körbar.

Sökning och installation av plugins med Krew

Kubectl-plugins är lämpliga för delad eller återanvändning liknande programvarupaket. Men var kan du hitta plugins som andra har delat?

Projektet Krew syftar till att erbjuda en enhetlig lösning för att dela, söka, installera och hantera kubectl-plugins. Projektet kallar sig själv "pakethanterare för kubectl-plugins" (Krew liknar Brew).

Krew är en lista över kubectl-plugins som du kan välja och installera. Dessutom är Krew också en plugin för kubectl.

Det betyder att installationen av Krew fungerar i praktiken som installation av vilken annan kubectl-plugin som helst. Du kan hitta detaljerade instruktioner på GitHub-sidan.

De viktigaste kommandona i Krew:

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

Tänk på att installation av plugins med Krew inte hindrar installation av plugins på det vanliga sättet som beskrivs ovan.

Observera att kommandot kubectl krew list visar endast de plugins som har installerats med Krew, medan kommandot kubectl plugin list listar alla plugins, det vill säga de som är installerade med Krew och de som är installerade på andra sätt.

Sökning av plugins på andra ställen

Krew är ett ungt projekt, för närvarande i dess lista ungefär 30 plugins. Om du inte kan hitta det du behöver, kan du söka efter plugins på andra ställen, till exempel på GitHub.

Jag rekommenderar att du kollar avsnittet GitHub kubectl-plugins. Där hittar du flera dussin tillgängliga plugins som är värda att titta på.

Skriva egna plugins

Du kan själv skapa plugins — det är inte svårt. Du behöver skapa en körbar fil som gör det som behövs, namnge den som kubectl-x och installera den som beskrivits ovan.

Filformatet kan vara ett bash-skript, ett python-skript eller en kompilerad go-applikation — det spelar ingen roll. Det enda kravet är att den ska kunna köras direkt på operativsystemet.

Låt oss skapa ett exempelplugin just nu. I föregående avsnitt använde du kommandot kubectl för att lista containrarna för varje pod. Det är enkelt att omvandla detta kommando till ett plugin som du kan kalla, till exempel, med kubectl img.

Skapa en fil kubectl-img med följande innehåll:

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

Nu gör filen körbar med chmod +x kubectl-img och flytta den till en katalog i din PATH. Direkt efter detta kan du använda pluginet kubectl img.

Som nämnts tidigare kan kubectl-plugins skrivas på vilket programmeringsspråk eller skriptspråk som helst. Om du använder skript från kommandoraden har du fördelen av att enkelt kunna anropa kubectl från pluginet. Men du kan skriva mer komplexa plugins på riktiga programmeringsspråk med hjälp av Kubernetes-klientbiblioteket. Om du använder Go kan du även använda cli-runtime-biblioteket, som finns speciellt för att skriva kubectl-plugins.

Hur man delar sina plugins

Om du tycker att dina plugins kan vara användbara för andra, tveka inte att dela dem på GitHub. Se till att lägga till dem i tråden kubectl-plugins.

Du kan också begära att din plugin läggs till i Krew-listan. Instruktioner om hur man gör detta finns i GitHub-repo.

Autocompletion av kommandon

För närvarande stöder plugins inte autocompletion. Det innebär att du måste skriva hela namnet på pluginet och hela namnen på argumenten.

Det finns en öppen förfrågani GitHub-repositoriet för kubectl för denna funktion. Så det är möjligt att denna funktion kommer att realiseras någon gång i framtiden.

Lycka till!!!

Vad mer att läsa om ämnet:

1. Tre nivåer av automatisk skalning i Kubernetes och hur man använder dem effektivt.
2. Kubernetes i piratanda med en implementeringsmall.
3. Vår kanal Om Kubernetes på Telegram.

Källa: habr.com