🥇Kuinka käyttää kubectlia tehokkaammin: yksityiskohtainen opas

Jos työskentelet Kubernetesin kanssa, kubectl on luultavasti yksi eniten käyttämistäsi apuohjelmista. Ja aina kun käytät paljon aikaa tietyn työkalun parissa työskentelemiseen, kannattaa tutkia sitä hyvin ja oppia käyttämään sitä tehokkaasti.

Joukkue Kubernetes aaS osoitteesta Mail.ru kääntänyt Daniel Weibelin artikkelin, josta löydät vinkkejä tehokkaaseen työskentelyyn kubectlin kanssa. Se auttaa myös sinua saamaan syvemmän ymmärryksen Kubernetesista.

Kirjoittajan mukaan artikkelin tavoitteena on tehdä päivittäisestä työstäsi Kuberneteksen kanssa paitsi tehokkaampaa, myös nautinnollisempaa!

Johdanto: Mikä on kubectl

Ennen kuin voit oppia käyttämään kubectlia tehokkaammin, sinun on saatava peruskäsitys siitä, mikä se on ja miten se toimii.

Käyttäjän näkökulmasta kubectl on ohjauspaneeli, jonka avulla voit suorittaa Kubernetes-toimintoja.

Teknisesti ottaen kubectl on Kubernetes API -asiakas.

Kubernetes API on HTTP REST API. Tämä API on todellinen Kubernetes-käyttöliittymä, jonka kautta sitä ohjataan täysin. Tämä tarkoittaa, että jokainen Kubernetes-toiminto paljastetaan API-päätepisteenä ja se voidaan tehdä HTTP-pyynnöllä kyseiseen päätepisteeseen.

Siksi kubectlin päätehtävä on tehdä HTTP-pyyntöjä Kubernetes API:lle:

Kubernetes on täysin resurssilähtöinen järjestelmä. Tämä tarkoittaa, että se ylläpitää resurssien sisäistä tilaa ja kaikki Kubernetes-toiminnot ovat CRUD-toimintoja.

Hallitset Kubernetesin täysin hallitsemalla näitä resursseja, ja Kubernetes selvittää, mitä tehdä resurssien nykyisen tilan perusteella. Tästä syystä Kubernetes API-viite on järjestetty luetteloksi resurssityypeistä ja niihin liittyvistä toiminnoista.

Katsotaanpa esimerkkiä.

Oletetaan, että haluat luoda ReplicaSet-resurssin. Voit tehdä tämän kuvailemalla ReplicaSetin tiedostossa nimellä replicaset.yamlja suorita sitten komento:

$ kubectl create -f replicaset.yaml

Tämä luo ReplicaSet-resurssin. Mutta mitä tapahtuu kulissien takana?

Kubernetesilla on ReplicaSet-luontitoiminto. Kuten kaikki muutkin toiminnot, se näkyy API-päätepisteenä. Tämän toiminnon erityinen API-päätepiste näyttää tältä:

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

API-päätepisteet kaikille Kubernetes-toiminnoille löytyvät osoitteesta API-viittaus (mukaan lukien yllä oleva päätepiste). Jos haluat tehdä varsinaisen pyynnön päätepisteelle, sinun on ensin lisättävä API-palvelimen URL-osoite API-viittauksessa lueteltuihin päätepistepolkuihin.

Siksi, kun suoritat yllä olevan komennon, kubectl lähettää HTTP POST -pyynnön yllä olevaan API-päätepisteeseen. Tiedostossa antamasi ReplicaSet-määritelmä replicaset.yaml, lähetetään pyynnön tekstiosassa.

Näin kubectl toimii kaikissa komentoissa, jotka ovat vuorovaikutuksessa Kubernetes-klusterin kanssa. Kaikissa näissä tapauksissa kubectl yksinkertaisesti tekee HTTP-pyyntöjä asianmukaisiin Kubernetes API -päätepisteisiin.

Huomaa, että voit hallita Kubernetesia täysin käyttämällä apuohjelmaa, kuten curllähettämällä HTTP-pyynnöt manuaalisesti Kubernetes API:lle. Kubectl yksinkertaisesti helpottaa Kubernetes API:n käyttöä.

Tämä on perusasiat siitä, mitä kubectl on ja miten se toimii. Mutta Kubernetes API:ssa on jotain muuta, joka jokaisen kubectl-käyttäjän pitäisi tietää. Katsotaanpa nopeasti Kubernetesin sisäistä maailmaa.

Kubernetesin sisäinen maailma

Kubernetes koostuu joukosta itsenäisiä komponentteja, jotka toimivat erillisinä prosesseina klusterin solmuissa. Jotkut komponentit toimivat pääsolmuissa, toiset työntekijäsolmuissa, ja jokainen komponentti suorittaa oman tehtävänsä.

Tässä ovat tärkeimmät komponentit pääsolmuissa:

säilytyspaikka - tallentaa resurssien määritelmät (yleensä se on jne).
API-palvelin - tarjoaa API:n ja hallitsee tallennustilaa.
Ohjaimen johtaja — Varmistaa, että resurssien tilat ovat eritelmien mukaisia.
Ajastin — ajoittaa podit työntekijäsolmuihin.

Ja tässä on yksi työntekijäsolmujen tärkein komponentti:

kubelet - hallitsee konttien käynnistämistä toimivassa solmussa.

Ymmärtääksemme, kuinka nämä komponentit toimivat yhdessä, katsotaanpa esimerkkiä.

Oletetaan, että olet juuri suorittanut kubectl create -f replicaset.yaml, jonka jälkeen kubectl teki HTTP POST -pyynnön osoitteeseen ReplicaSet API -päätepiste (läpäisee ReplicaSet-resurssimäärityksen).

Mitä klusterissa tapahtuu?

Tekemisen jälkeen kubectl create -f replicaset.yaml API-palvelin tallentaa ReplicaSet-resurssimäärittelysi tallennustilaan:
Seuraavaksi ReplicaSet-ohjain käynnistetään ohjaimen hallinnassa, joka käsittelee ReplicaSet-resurssien luomisen, muokkaamisen ja poistamisen:
ReplicaSet-ohjain luo pod-määrityksen jokaiselle ReplicaSet-replikalle (ReplicaSet-määritelmän pod-mallin mukaan) ja tallentaa ne tallennustilaan:
Ajoitus on käynnistetty, ja se seuraa podeja, joita ei ole vielä määritetty millekään työntekijäsolmulle:
Ajastin valitsee sopivan työntekijäsolmun jokaiselle ryhmälle ja lisää nämä tiedot myymälän pod-määritykseen:
Kubelet käynnistetään työntekijäsolmussa, jolle pod on määritetty, ja se seuraa tälle solmulle määritettyjä podeja:
Kubelet lukee pod-määrityksen tallennustilasta ja käskee säilön suoritusaikaa, kuten Dockeria, käynnistämään säilöjä solmussa:

Alla on tekstiversio tästä kuvauksesta.

API-palvelin käsittelee API-pyynnön ReplicaSet-luonnin päätepisteeseen. API-palvelin todentaa pyynnön ja tallentaa ReplicaSet-resurssimäärityksen tallennustilaan.

Tämä tapahtuma käynnistää ReplicaSet-ohjaimen, joka on ohjaimen hallintaohjelman aliprosessi. ReplicaSet-ohjain valvoo ReplicaSet-resurssien luomista, päivittämistä ja poistamista varastossa ja vastaanottaa tapahtumailmoituksen, kun tämä tapahtuu.

ReplicaSet-ohjaimen tehtävänä on varmistaa, että vaadittava määrä ReplicaSet-tyyppejä on olemassa. Esimerkissämme ei ole vielä podeja, joten ReplicaSet-ohjain luo nämä pod-määritykset (ReplicaSet-määritelmän pod-mallin mukaan) ja tallentaa ne tallennustilaan.

Uusien ryhmittymien luomisen käynnistää ajoitus, joka pitää kirjaa pod-määrityksistä, joita ei ole vielä ajoitettu työntekijäsolmuille. Ajoitus valitsee sopivan työntekijäsolmun kullekin ryhmälle ja päivittää pod-määritykset arkistossa.

Huomaa, että tähän asti työkuormituskoodia ei ollut käynnissä missään klusterissa. Kaikki mitä on tähän mennessä tehty - tämä on resurssien luomista ja päivittämistä pääsolmun arkistossa.

Viimeinen tapahtuma laukaisee Kubeletit, jotka valvovat työntekijöiden solmuille suunniteltuja podeja. Työntekijäsolmun, johon ReplicaSet-tyynyt on asennettu, Kubeletin on ohjeistettava säilön suoritusaikaa, kuten Dockeria, lataamaan vaaditut säilökuvat ja suorittamaan ne.

Tässä vaiheessa ReplicaSet-sovelluksesi on vihdoin käynnissä!

Kubernetes API:n rooli

Kuten edellisessä esimerkissä näit, Kubernetes-komponentit (lukuun ottamatta API-palvelinta ja tallennustilaa) tarkkailevat muutoksia tallennustilassa oleviin resursseihin ja muuttavat tietoja tallennustilassa olevista resursseista.

Nämä komponentit eivät tietenkään ole vuorovaikutuksessa tallennustilan kanssa suoraan, vaan vain Kubernetes API:n kautta.

Harkitse seuraavia esimerkkejä:

ReplicaSet-ohjain käyttää API-päätepistettä luettelo ReplicaSets parametrin kanssa watch seurataksesi ReplicaSet-resurssien muutoksia.
ReplicaSet-ohjain käyttää API-päätepistettä luo Pod (luo pod) luodaksesi paloja.
Scheduler käyttää API-päätepistettä patch pod (muokkaa ryhmää) päivittääksesi podit tiedoilla valitusta työntekijäsolmusta.

Kuten näet, tämä on sama API, jota kubectl käyttää. Saman API:n käyttö sisäisille komponenteille ja ulkoisille käyttäjille on Kubernetes-suunnittelun peruskonsepti.

Nyt voimme tehdä yhteenvedon siitä, kuinka Kubernetes toimii:

Tallennusvarastoissa ilmoitetaan, eli Kubernetes-resurssit.
API-palvelin tarjoaa käyttöliittymän tallennustilaan Kubernetes API:n muodossa.
Kaikki muut Kubernetes-komponentit ja -käyttäjät lukevat, tarkkailevat ja käsittelevät Kubernetes-tilaa (resursseja) API:n kautta.

Näiden käsitteiden tunteminen auttaa sinua ymmärtämään kubectlin paremmin ja saamaan siitä kaiken irti.

Katsotaanpa nyt joitain erityisiä vinkkejä ja temppuja, jotka auttavat parantamaan tuottavuuttasi kubectlin avulla.

1. Nopeuta syöttöä komennon suorittamisen avulla

Yksi hyödyllisimmistä, mutta usein huomiotta jätetyistä tekniikoista suorituskyvyn parantamiseksi kubectl:llä on komentojen suorittaminen.

Komennon täydennyksen avulla voit suorittaa automaattisesti osia kubectl-komennoista sarkainnäppäimellä. Tämä toimii alikomennoista, valinnoista ja argumenteista, mukaan lukien jotain niin monimutkaista kuin resurssien nimet.

Katso, kuinka kubectl-komennon viimeistely toimii:

Komennon suorittaminen toimii Bash- ja Zsh-kuorilla.

Virallinen ohje sisältää yksityiskohtaiset ohjeet automaattisen täydennyksen määrittämiseen, mutta alla annamme lyhyen otteen.

Kuinka komennon suorittaminen toimii

Command completion on komentotulkkiominaisuus, joka toimii täydennysskriptin avulla. Laajennuskomentosarja on komentotulkkikomentosarja, joka määrittää tietyn komennon laajennuksen toiminnan.

Kubectl luo ja tulostaa automaattisesti Bash- ja Zsh-laajennuskomentosarjat käyttämällä seuraavia komentoja:

$ kubectl completion bash

Или:

$ kubectl completion zsh

Teoriassa riittää, että näiden komentojen tulos yhdistetään sopivaan komentotulkoon, jotta kubectl voi täydentää komentoja.

Käytännössä yhteystapa on erilainen Bashille (mukaan lukien erot Linuxin ja MacOS:n välillä) ja Zsh:lle. Alla tarkastellaan kaikkia näitä vaihtoehtoja.

Bash Linuxissa

Bash Completion -skripti riippuu bash-completion -paketista, joten sinun on asennettava se ensin:

$ sudo apt-get install bash-completion

Или:

$ yum install bash-completion

Voit testata paketin asennuksen onnistuneesti käyttämällä seuraavaa komentoa:

$ type _init_completion

Jos tämä tulostaa shell-toimintokoodin, bash-completion on asennettu oikein. Jos komento antaa "Ei löydy" -virheen, sinun on lisättävä tiedostoon seuraava rivi ~ / .bashrc:

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

Onko tämä rivi tarpeen lisätä tiedostoon ~ / .bashrc vai ei, riippuu paketinhallinnasta, jota käytit bash-completionin asentamiseen. Tämä on välttämätöntä APT:lle, mutta ei YUM:lle.

Bash-completionin asentamisen jälkeen sinun on määritettävä kaikki niin, että kubectl-täydennysskripti on käytössä kaikissa shell-istunnoissa.

Yksi tapa tehdä tämä on lisätä tiedostoon seuraava rivi ~ / .bashrc:

source <(kubectl completion bash)

Toinen tapa on lisätä kubectl-laajennuskomentosarja hakemistoon /etc/bash_completion.d (luo se, jos sitä ei ole olemassa):

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

Kaikki luettelossa olevat lisäskriptit /etc/bash_completion.d sisällytetään automaattisesti bash-täydennykseen.

Molemmat vaihtoehdot ovat yhtä käyttökelpoisia.

Kun komentotulkki on käynnistetty uudelleen, kubectl-komennon suorittaminen toimii.

Bash MacOS:ssa

MacOS:ssa asennus on hieman monimutkaisempi. Tosiasia on, että MacOS käyttää oletuksena Bash-versiota 3.2, ja kubectl-automaattisen täydennyksen komentosarja vaatii Bash-version vähintään 4.1, eikä se toimi Bash 3.2:ssa.

Bashin vanhentuneen version käyttämiseen MacOS:ssa liittyy lisensointiongelmia. Bash-versio 4 on lisensoitu GPLv3:lla, jota Apple ei tue.

Jos haluat määrittää kubectl-automaattisen täydennyksen MacOS:ssa, sinun on asennettava uudempi Bash-versio. Voit myös asettaa päivitetyn Bashin oletuskuoriksi, mikä säästää sinua monilta ongelmilta tulevaisuudessa. Se ei ole vaikeaa, yksityiskohdat annetaan artikkelissa "Bashin päivittäminen MacOS:ssa'.

Ennen kuin jatkat, varmista, että käytät Bashin uusinta versiota (tarkista tulos bash --version).

Bash-skripti vaihtelee projektin mukaan bash-täydennys, joten sinun on asennettava se ensin.

Voit asentaa bash-completion käyttämällä Homebrew:

$ brew install bash-completion@2

Täällä @2 tarkoittaa bash-completion versiota 2. kubectl automaattinen täydennys vaatii bash-completion v2, ja bash-completion v2 vaatii vähintään Bash-version 4.1.

Komentolähtö brew-install sisältää Varoitukset-osion, joka määrittää, mitä tiedostoon on lisättävä ~/.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"

Suosittelen kuitenkin lisäämään näitä rivejä ~/.bash_profileja sisään ~/.bashrc. Tässä tapauksessa automaattinen täydennys on käytettävissä paitsi pää-, myös lapsikomentotulkeissa.

Kun olet käynnistänyt komentotulkin uudelleen, voit varmistaa, että asennus on oikein seuraavalla komennolla:

$ type _init_completion

Jos näet tulosteessa shell-toiminnon, kaikki on määritetty oikein.

Nyt meidän on varmistettava, että kubectl-automaattinen täydennys on käytössä kaikissa istunnoissa.

Yksi tapa on lisätä seuraava rivi omaan ~/.bashrc:

source <(kubectl completion bash)

Toinen tapa on lisätä kansioon automaattisen täydennyksen komentosarja /usr/local/etc/bash_completion.d:

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

Tämä menetelmä toimii vain, jos asensit bash-completion Homebrew'n avulla. Tässä tapauksessa bash-completion lataa kaikki komentosarjat tästä hakemistosta.

Jos olet asentanut kubectl käyttämällä Homebrew'ta, niin edellistä vaihetta ei tarvitse suorittaa, koska automaattisen täydennyksen komentosarja sijoitetaan automaattisesti kansioon /usr/local/etc/bash_completion.d asennuksen aikana. Tässä tapauksessa kubectl automaattinen täydennys alkaa toimia heti, kun asennat bash-completion.

Tämän seurauksena kaikki nämä vaihtoehdot ovat samanarvoisia.

zsh

Zsh:n automaattisen täydennyksen komentosarjat eivät vaadi riippuvuuksia. Sinun tarvitsee vain ottaa ne käyttöön, kun lataat komentotulkin.

Voit tehdä tämän lisäämällä rivin omaan ~/.zshrc tiedosto:

source <(kubectl completion zsh)

Jos saat virheilmoituksen not found: compdef Kun olet käynnistänyt kuoren uudelleen, sinun on otettava sisäänrakennettu toiminto käyttöön compdef. Voit ottaa sen käyttöön lisäämällä sen tiedoston alkuun ~/.zshrc seuraavat:

autoload -Uz compinit
compinit

2. Tarkastele nopeasti resurssitietoja

Kun luot YAML-resurssimäärityksiä, sinun on tiedettävä kentät ja niiden merkitys kyseisille resursseille. Yksi paikka etsiä näitä tietoja on API-viittauksessa, joka sisältää täydelliset tiedot kaikille resursseille.

Verkkoselaimeen vaihtaminen aina, kun sinun on etsittävä jotain, on kuitenkin hankalaa. Siksi kubectl tarjoaa komennon kubectl explain, joka näyttää kaikkien terminaalissasi olevien resurssien tekniset tiedot.

Komentomuoto on seuraava:

$ kubectl explain resource[.field]...

Komento tulostaa pyydetyn resurssin tai kentän määrityksen. Näytettävät tiedot ovat identtisiä API-oppaassa olevien tietojen kanssa.

Oletuksena kubectl explain näyttää vain ensimmäisen kenttien sisäkkäisen tason.

Katso miltä se näyttää Sen jälkeen voit.

Voit näyttää koko puun, jos lisäät vaihtoehdon --recursive:

$ kubectl explain deployment.spec --recursive

Jos et tiedä tarkalleen, mitä resursseja tarvitaan, voit näyttää ne kaikki seuraavalla komennolla:

$ kubectl api-resources

Tämä komento näyttää resurssien nimet monikkomuodossa, esim. deployments sen sijasta deployment. Se näyttää myös esimerkiksi lyhyen nimen deploy, niille resursseille, joilla se on. Älä välitä näistä eroista. Kaikki nämä nimeämisvaihtoehdot ovat vastaavia kubectlille. Eli voit käyttää mitä tahansa niistä kubectl explain.

Kaikki seuraavat komennot ovat vastaavia:

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

3. Käytä mukautettua sarakkeen tulostusmuotoa

Oletuskomennon tulostusmuoto 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

Tämä muoto on kätevä, mutta se sisältää rajoitetun määrän tietoa. Verrattuna täydelliseen resurssimäärittelymuotoon, vain muutama kenttä näytetään tässä.

Tässä tapauksessa voit käyttää mukautettua sarakkeen tulostusmuotoa. Sen avulla voit määrittää, mitä tietoja tulostetaan. Voit näyttää minkä tahansa resurssikentän erillisenä sarakkeena.

Mukautetun muodon käyttö määritetään seuraavilla vaihtoehdoilla:

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

Voit määrittää kunkin tulossarakkeen pariksi <header>:<jsonpath>Missä <header> on sarakkeen nimi ja <jsonpath> — lauseke, joka määrittää resurssikentän.

Katsotaanpa yksinkertaista esimerkkiä:

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

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

Tulos sisältää yhden sarakkeen, jossa on palojen nimet.

Vaihtoehtolauseke valitsee pod-nimet kentästä metadata.name. Tämä johtuu siitä, että ryhmän nimi on määritetty lapsen nimi -kentässä metadata podin resurssikuvauksessa. Tarkemmat tiedot löytyvät osoitteesta API-opas tai kirjoita komento kubectl explain pod.metadata.name.

Oletetaan nyt, että haluat lisätä tuotteeseen ylimääräisen sarakkeen, joka näyttää esimerkiksi solmun, jossa kukin pod on käynnissä. Voit tehdä tämän lisäämällä sopivan sarakemäärityksen mukautettujen sarakkeiden vaihtoehtoon:

$ 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

Lauseke valitsee solmun nimen spec.nodeName — kun pod on määritetty solmulle, sen nimi kirjoitetaan kenttään spec.nodeName pod-resurssimääritys. Tarkemmat tiedot löytyvät tulosteesta kubectl explain pod.spec.nodeName.

Huomaa, että Kubernetes-resurssikentät erottelevat isot ja pienet kirjaimet.

Voit tarkastella mitä tahansa resurssikenttää sarakkeena. Tarkista vain resurssitiedot ja kokeile sitä haluamillasi kentillä.

Mutta ensin tarkastellaan lähemmin kentän valintalausekkeita.

JSONPath-lausekkeet

Resurssikenttien valintalausekkeet perustuvat JSONPath.

JSONPath on kieli tietojen hakemiseen JSON-asiakirjoista. Yksittäisen kentän valitseminen on JSONPathin yksinkertaisin käyttötapa. Hänellä on paljon lisää mahdollisuuksia, mukaan lukien valitsimet, suodattimet ja niin edelleen.

Kubectl selittää tukee rajoitettua määrää JSONPath-ominaisuuksia. Alla on kuvattu mahdollisuudet ja esimerkkejä niiden käytöstä:

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

[]-operaattori on erityisen tärkeä. Monet Kubernetes-resurssikentät ovat luetteloita, ja tämän operaattorin avulla voit valita näiden luetteloiden jäseniä. Sitä käytetään usein jokerimerkin, kuten [*] kanssa, valitsemaan luettelon kaikki elementit.

Sovellusesimerkkejä

Mahdollisuudet mukautetun saraketulostusmuodon käyttämiseen ovat rajattomat, koska voit näyttää tulosteessa minkä tahansa kentän tai resurssikenttien yhdistelmän. Tässä on joitain esimerkkisovelluksia, mutta voit tutkia niitä itse ja löytää sinulle sopivia sovelluksia.

Näytetään säiliökuvia annoksille:

$ 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

Tämä komento näyttää kunkin ryhmän säilön kuvien nimet.

Muista, että pod voi sisältää useita säilöjä, jolloin kuvien nimet näkyvät yhdellä rivillä pilkuilla erotettuina.

Näytetään solmun saatavuusvyöhykkeet:
```
$ 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
```
Tämä komento on hyödyllinen, jos klusterisi on julkisessa pilvessä. Se näyttää kunkin solmun saatavuusvyöhykkeen.

Saatavuusvyöhyke on pilvikonsepti, joka rajoittaa replikointivyöhykkeen maantieteelliseen alueeseen.

Jokaisen solmun saatavuusalueet saadaan erityisellä tarralla - failure-domain.beta.kubernetes.io/zone. Jos klusteri on käynnissä julkisessa pilvessä, tämä tunniste luodaan automaattisesti ja täytetään kunkin solmun käytettävyysvyöhykkeiden nimillä.

Tunnisteet eivät kuulu Kubernetesin resurssimääritykseen, joten et löydä niistä tietoa API-opas. Ne voidaan kuitenkin nähdä (kuten muutkin tunnisteet), jos pyydät tietoja solmuista YAML- tai JSON-muodossa:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
Tämä on loistava tapa oppia lisää resursseista resurssien määrittelyjen oppimisen lisäksi.

4. Vaihda helposti klustereiden ja nimitilojen välillä

Kun kubectl tekee pyynnön Kubernetes API:lle, se lukee ensin kubeconfig-tiedoston saadakseen kaikki yhteyden edellyttämät parametrit.

Oletuksena kubeconfig-tiedosto on ~/.kube/config. Tyypillisesti tämä tiedosto luodaan tai päivitetään erityisellä komennolla.

Kun työskentelet useiden klustereiden kanssa, kubeconfig-tiedostosi sisältää asetukset yhteyden muodostamiseksi kaikkiin näihin klustereihin. Tarvitset tavan kertoa kubectl-komennolle, minkä klusterin kanssa työskentelet.

Voit luoda klusterin sisällä useita nimiavaruuksia – eräänlaisen virtuaalisen klusterin tyypin fyysisessä klusterissa. Kubectl määrittää myös käytettävän nimitilan kubeconfig-tiedoston perusteella. Tämä tarkoittaa, että tarvitset myös tavan kertoa kubectl-komennolle, minkä nimiavaruuden kanssa sitä tulee käyttää.

Tässä luvussa selitämme, miten se toimii ja miten se toimii tehokkaasti.

Huomaa, että KUBECONFIG-ympäristömuuttujassa voi olla useita kubeconfig-tiedostoja. Tässä tapauksessa kaikki nämä tiedostot yhdistetään yhdeksi yhteiseksi kokoonpanoksi suorituksen aikana. Voit myös muuttaa oletusarvoista kubeconfig-tiedostoa suorittamalla kubectl parametrilla --kubeconfig. Katso virallinen dokumentaatio.

kubeconfig-tiedostoja

Katsotaanpa, mitä kubeconfig-tiedosto tarkalleen sisältää:

Kuten näet, kubeconfig-tiedosto sisältää joukon konteksteja. Konteksti koostuu kolmesta elementistä:

Cluster — klusterin palvelimen API-URL-osoite.
Käyttäjä - käyttäjän todennustiedot klusterissa.
Nimiavaruus - nimiavaruus, jota käytetään klusteriin liittyessä.

Käytännössä he käyttävät usein yhtä kontekstia klusteria kohden kubeconfigissaan. Yhtä klusteria kohden voi kuitenkin olla useita konteksteja käyttäjän tai nimitilan mukaan. Tämä usean kontekstin kokoonpano on kuitenkin harvinainen, joten klusterien ja kontekstien välillä on yleensä yksi-yhteen-kartoitus.

Kulloinkin yksi konteksteista on ajankohtainen:

Kun kubectl lukee asetustiedoston, se ottaa aina tiedot nykyisestä kontekstista. Yllä olevassa esimerkissä kubectl muodostaa yhteyden Hare-klusteriin.

Vastaavasti vaihtaaksesi toiseen klusteriin sinun on muutettava nykyistä kontekstia kubeconfig-tiedostossa:

Nyt kubectl muodostaa yhteyden Fox-klusteriin.

Jos haluat vaihtaa eri nimiavaruuteen samassa klusterissa, sinun on muutettava nykyisen kontekstin nimiavaruuselementin arvoa:

Yllä olevassa esimerkissä kubectl käyttää Fox-klusterin Prod-nimiavaruutta (aiemmin Test-nimiavaruus oli asetettu).

Huomaa, että kubectl tarjoaa myös vaihtoehtoja --cluster, --user, --namespace и --context, joiden avulla voit ylikirjoittaa yksittäisiä elementtejä ja itse nykyisen kontekstin riippumatta siitä, mitä kubeconfigissa on asetettu. Katso kubectl options.

Teoriassa voit muuttaa asetuksia manuaalisesti kubeconfigissa. Mutta se on epämukavaa. Näiden toimintojen yksinkertaistamiseksi on olemassa useita apuohjelmia, joiden avulla voit muuttaa parametreja automaattisesti.

Käytä kubectx

Erittäin suosittu apuohjelma klustereiden ja nimitilojen välillä vaihtamiseen.

Apuohjelma tarjoaa komentoja kubectx и kubens muuttaaksesi nykyistä kontekstia ja nimiavaruutta vastaavasti.

Kuten mainittiin, nykyisen kontekstin muuttaminen tarkoittaa klusterin muuttamista, jos sinulla on vain yksi konteksti klusteria kohden.

Tässä on esimerkki näiden komentojen suorittamisesta:

Pohjimmiltaan nämä komennot yksinkertaisesti muokkaavat kubeconfig-tiedostoa yllä kuvatulla tavalla.

asentaa kubectx, seuraa ohjeita GitHub.

Molemmat komennot tukevat kontekstin ja nimitilan nimien automaattista täydentämistä, mikä eliminoi tarpeen kirjoittaa niitä kokonaan. Ohjeet automaattisen täydennyksen määrittämiseen täällä.

Toinen hyödyllinen ominaisuus kubectx on interaktiivinen tila. Se toimii yhdessä apuohjelman kanssa fzf, joka on asennettava erikseen. Kun fzf asennetaan, interaktiivinen tila on automaattisesti käytettävissä kubectx. Interaktiivisesti voit valita kontekstin ja nimitilan fzf:n tarjoaman interaktiivisen ilmaisen hakuliittymän kautta.

Shell-aliaksien käyttäminen

Et tarvitse erillisiä työkaluja nykyisen kontekstin ja nimitilan muuttamiseen, koska kubectl tarjoaa myös komentoja tähän. Kyllä, joukkue kubectl config tarjoaa alikomennot kubeconfig-tiedostojen muokkaamiseen.

Seuraavassa on joitain niistä:

kubectl config get-contexts: näyttää kaikki kontekstit;
kubectl config current-context: hanki nykyinen konteksti;
kubectl config use-context: muuta nykyistä kontekstia;
kubectl config set-context: Muuta kontekstielementtiä.

Näiden komentojen käyttäminen suoraan ei kuitenkaan ole kovin kätevää, koska ne ovat pitkiä. Voit tehdä niille shell-aliaksia, jotka on helppo suorittaa.

Loin joukon aliaksia näiden komentojen perusteella, jotka tarjoavat kubectx:n kaltaisia toimintoja. Täältä voit nähdä ne toiminnassa:

Huomaa, että aliakset käyttävät fzf:ää tarjotakseen interaktiivisen ilmaisen hakuliittymän (kuten kubectx:n interaktiivinen tila). Tämä tarkoittaa, että tarvitset asenna fzfkäyttää näitä aliaksia.

Tässä ovat itse aliasten määritelmät:

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

Näiden aliasten asettamiseksi sinun on lisättävä yllä olevat määritelmät tiedostoosi ~/.bashrc tai ~/.zshrc ja käynnistä kuori uudelleen.

Lisäosien käyttö

Kubectl antaa sinun ladata laajennuksia, jotka suoritetaan samalla tavalla kuin peruskomennot. Voit esimerkiksi asentaa kubectl-foo-laajennuksen ja suorittaa sen suorittamalla komennon kubectl foo.

Kontekstia ja nimiavaruutta olisi kätevä muuttaa tällä tavalla, esimerkiksi suorittamalla kubectl ctx muuttaa kontekstia ja kubectl ns muuttaaksesi nimiavaruutta.

Olen kirjoittanut kaksi laajennusta, jotka tekevät tämän:

Lisäosien toiminta perustuu edellisen osan aliaksiin.

Näin ne toimivat:

Huomaa, että liitännäiset käyttävät fzf:tä tarjotakseen interaktiivisen ilmaisen hakuliittymän (kuten kubectx:n interaktiivinen tila). Tämä tarkoittaa, että tarvitset asenna fzfkäyttää näitä aliaksia.

Lisäosien asentamiseksi sinun on ladattava komentotulkkikomentosarjat nimeltä kubectl-ctx и kubectl-ns mihin tahansa PATH-muuttujasi hakemistoon ja tee ne suoritettaviksi esim. chmod +x. Heti tämän jälkeen voit käyttää kubectl ctx и kubectl ns.

5. Vähennä syöttöä automaattisilla aliaksilla

Shell-aliakset ovat hyvä tapa nopeuttaa syöttöä. Projekti kubectl-aliakset sisältää noin 800 pikakuvaketta kubectl-peruskomentoille.

Saatat ihmetellä - kuinka muistat 800 aliasta? Mutta sinun ei tarvitse muistaa niitä kaikkia, koska ne on rakennettu yksinkertaisen kaavion mukaan, joka on annettu alla:

Esimerkiksi:

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

Kuten näet, aliakset koostuvat komponenteista, joista jokainen edustaa tiettyä kubectl-komennon elementtiä. Jokaisessa aliaksessa voi olla yksi komponentti peruskomentoa, -toimintoa ja -resurssia varten ja useita komponentteja parametreille. Sinun tarvitsee vain "täyttää" nämä komponentit vasemmalta oikealle yllä olevan kaavion mukaisesti.

Nykyinen yksityiskohtainen kaavio on osoitteessa GitHub. Sieltä löytyy myös täydellinen luettelo aliaksista.

Esimerkiksi alias kgpooyamlall vastaa komentoa kubectl get pods -o yaml --all-namespaces.

Vaihtoehtojen suhteellinen järjestys ei ole tärkeä: komento kgpooyamlall vastaa komentoa kgpoalloyaml.

Sinun ei tarvitse käyttää kaikkia komponentteja aliaksina. Esimerkiksi k, kg, klo, ksys, kgpo voidaan myös käyttää. Lisäksi voit yhdistää aliaksia ja tavallisia komentoja tai vaihtoehtoja komentorivillä:

Esimerkiksi:

Sen sijasta kubectl proxy sinä voit kirjoittaa k proxy.
Sen sijasta kubectl get roles sinä voit kirjoittaa kg roles (Roolit-resurssille ei tällä hetkellä ole aliasta).
Voit käyttää komentoa saadaksesi tietoja tietylle podille kgpo my-pod — kubectl get pod my-pod.

Huomaa, että jotkut aliakset vaativat komentoriviargumentin. Esimerkiksi alias kgpol välineet kubectl get pods -l. Vaihtoehto -l vaatii argumentin - etiketin määrityksen. Jos käytät aliasta, se näyttää tältä kgpol app=ui.

Koska jotkut aliakset vaativat argumentteja, aliaksia a, f ja l on käytettävä viimeisenä.

Yleensä, kun olet perehtynyt tähän järjestelmään, voit intuitiivisesti johtaa aliaksia komennoista, jotka haluat suorittaa, ja säästää paljon kirjoitusaikaa.

asennus

Jos haluat asentaa kubectl-aliakset, sinun on ladattava tiedosto .kubectl_aliases GitHubista ja sisällytä se tiedostoon ~/.bashrc tai ~/.zshrc:

source ~/.kubectl_aliases

Automaattinen täydennys

Kuten aiemmin sanoimme, lisäät usein muita sanoja aliakseen komentorivillä. Esimerkiksi:

$ kgpooyaml test-pod-d4b77b989

Jos käytät kubectl-komennon täydentämistä, olet todennäköisesti käyttänyt automaattista täydennystä esimerkiksi resurssien nimiin. Mutta voidaanko tämä tehdä, kun käytetään aliaksia?

Tämä on erittäin tärkeä kysymys, koska jos automaattinen täydennys ei toimi, menetät osan aliasten eduista.

Vastaus riippuu käyttämästäsi kuoresta:

Zsh:lle aliaksen viimeistely toimii heti.
Valitettavasti Bash vaatii jonkin verran työtä, jotta automaattinen täydennys toimisi.

Otetaan käyttöön automaattinen täydennys aliaksille Bashissa

Bashin ongelma on, että se yrittää täydentää (aina kun painat sarkainta) aliaksen, ei komentoa, johon alias viittaa (kuten esimerkiksi Zsh). Koska sinulla ei ole täydennysskriptejä kaikille 800 aliakselle, automaattinen täydennys ei toimi.

Hanke täydellinen alias tarjoaa yleisen ratkaisun tähän ongelmaan. Se muodostaa yhteyden aliaksen täydennysmekanismiin, laajentaa aliaksen sisäisesti komennon muotoon ja palauttaa valmiin komennon täydennysvaihtoehdot. Tämä tarkoittaa, että aliaksen täyte toimii täsmälleen samalla tavalla kuin täyden komennon.

Seuraavassa selitän ensin täydellisen aliaksen asentamisen ja sitten sen määrittämisen mahdollistamaan kaikkien kubectl-aliasten viimeistely.

Asennetaan täydellistä aliasta

Ensinnäkin täydellinen alias riippuu bash-täydennys. Siksi, ennen kuin asennat täydellisen aliaksen, sinun on varmistettava, että bash-completion on asennettu. Asennusohjeet on toimitettu aiemmin Linuxille ja MacOS:lle.

Tärkeä huomautus MacOS-käyttäjille: Kuten kubectl-automaattisen täydennyksen komentosarja, täydellinen alias ei toimi Bash 3.2:n kanssa, joka on MacOS:n oletusarvo. Erityisesti täydellinen alias riippuu bash-completion v2 (brew install bash-completion@2), joka vaatii vähintään Bash 4.1:n. Tämä tarkoittaa, että jos haluat käyttää täydellistä aliasta MacOS:ssa, sinun on asennettava uudempi Bash-versio.

Sinun on ladattava skripti bash_completion.sh ja GitHub-arkisto ja sisällytä se tiedostoosi ~/.bashrc:

source ~/bash_completion.sh

Shellin uudelleenkäynnistyksen jälkeen täydellinen alias asennetaan kokonaan.

Otetaan käyttöön automaattinen täydennys kubectl-aliaksille

Teknisesti täydellinen alias tarjoaa kääretoiminnon _complete_alias. Tämä toiminto tarkistaa aliaksen ja palauttaa vihjeitä alias-komennon suorittamiseen.

Jos haluat liittää funktion tiettyyn aliakseen, sinun on käytettävä sisäänrakennettua Bash-mekanismia täydellinen, asentaa _complete_alias aliaksen täydennysfunktiona.

Otetaan esimerkkinä alias k, joka tarkoittaa kubectl-komentoa. asentaa _complete_alias Tämän aliaksen täydennysfunktiona sinun tulee suorittaa seuraava komento:

$ complete -F _complete_alias k

Tämän seurauksena aina kun täydennät aliaksen k automaattisesti, funktiota kutsutaan _complete_alias, joka tarkistaa aliaksen ja palauttaa vihjeitä komennon suorittamiseen kubectl.

Otetaan toisena esimerkkinä alias kg, joka tarkoittaa kubectl get:

$ complete -F _complete_alias kg

Kuten edellisessä esimerkissä, kun täytät automaattisesti kg, saat samat täydennysvihjeet kuin kubectl get.

Huomaa, että voit käyttää täydellistä aliasta mille tahansa järjestelmässäsi olevalle aliakselle.

Siksi, jotta voit ottaa automaattisen täydennyksen käyttöön kaikille kubectl-aliaksille, sinun on suoritettava yllä oleva komento jokaiselle niistä. Seuraava koodinpätkä tekee juuri tämän, jos olet asettanut kubectl-aliakset ~/.kubectl-aliases:

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

Tämä koodinpätkä on sijoitettava omaan ~/.bashrc, käynnistä komentotulkki uudelleen ja automaattinen täydennys tulee saataville kaikille 800 kubectl-aliakselle.

6. Kubectl:n laajentaminen laajennuksilla

Alkaen versio 1.12, kubectl tukee plugin mekanismi, jonka avulla voit laajentaa sen toimintoja lisäkomennoilla.

Jos olet perehtynyt Git-laajennusmekanismit, silloin kubectl-laajennukset rakennetaan samalla periaatteella.

Tässä luvussa kerromme, miten laajennuksia asennetaan, mistä ne löytyvät ja miten voit luoda omia laajennuksia.

Lisäosien asentaminen

Kubectl-laajennukset jaetaan yksinkertaisina suoritettavina tiedostoina, joiden nimi on kuten kubectl-x. Etuliite kubectl- vaaditaan, ja sen jälkeen uusi kubectl-alikomento, jonka avulla voit kutsua laajennusta.

Esimerkiksi hello-laajennus jaetaan tiedostona nimeltä kubectl-hello.

Jotta voit asentaa laajennuksen, sinun on kopioitava tiedosto kubectl-x mihin tahansa hakemistoon polkussasi ja tee siitä suoritettava, esimerkiksi kanssa chmod +x. Välittömästi tämän jälkeen voit soittaa laajennukseen kubectl x.

Voit käyttää seuraavaa komentoa listataksesi kaikki järjestelmääsi tällä hetkellä asennetut laajennukset:

$ kubectl plugin list

Tämä komento näyttää myös varoituksia, jos sinulla on useita samannimiä laajennuksia tai jos on laajennustiedosto, joka ei ole suoritettava.

Lisäosien etsiminen ja asentaminen Krew:n avulla

Kubectl-laajennuksia voidaan jakaa tai käyttää uudelleen kuten ohjelmistopaketteja. Mutta mistä voit löytää muiden jakamia laajennuksia?

Projekti Krew tavoitteena on tarjota yhtenäinen ratkaisu kubectl-laajennusten jakamiseen, etsimiseen, asentamiseen ja hallintaan. Projekti kutsuu itseään "kubectl-laajennusten paketinhallintaohjelmaksi" (Krew on samanlainen kuin Hautua).

Krew on luettelo kubectl-laajennuksista, jotka voit valita ja asentaa. Samaan aikaan Krew on myös kubectlin laajennus.

Tämä tarkoittaa, että Krew:n asentaminen toimii periaatteessa kuten minkä tahansa muun kubectl-laajennuksen asentaminen. Tarkemmat ohjeet löydät osoitteesta GitHub-sivu.

Tärkeimmät Krew-komennot ovat:

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

Huomaa, että lisäosien asentaminen Krew'n avulla ei häiritse laajennuksien asentamista yllä kuvatulla vakiomenetelmällä.

Huomaa, että komento kubectl krew list näyttää vain lisäosat, jotka on asennettu Krew:lla, kun taas komento kubectl plugin list luettelee kaikki laajennukset, eli ne, jotka on asennettu Krew'lla ja ne, jotka on asennettu muilla tavoilla.

Lisäosien etsiminen muualta

Krew on nuori projekti, joka on parhaillaan käynnissä luettelo vain noin 30 lisäosaa. Jos et löydä tarvitsemaasi, voit etsiä laajennuksia muualta, kuten GitHubista.

Suosittelen katsomaan GitHub-osiota kubectl-liitännäiset. Sieltä löydät kymmeniä saatavilla olevia laajennuksia, jotka kannattaa tarkistaa.

Omien lisäosien kirjoittaminen

voit itse luoda laajennuksia - Se ei ole vaikeaa. Sinun on luotava suoritettava tiedosto, joka tekee mitä tarvitset, nimeä se kuten kubectl-x ja asenna yllä kuvatulla tavalla.

Tiedosto voi olla bash-skripti, python-skripti tai käännetty GO-sovellus – sillä ei ole väliä. Ainoa ehto on, että se voidaan suorittaa suoraan käyttöjärjestelmässä.

Luodaan nyt esimerkkilaajennus. Edellisessä osiossa käytit kubectl-komentoa kunkin ryhmän säilöjen luetteloimiseen. Tämä komento on helppo muuttaa pluginiksi, jota voit kutsua esim. kubectl img.

Luo tiedosto kubectl-img seuraava sisältö:

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

Tee tiedostosta nyt suoritettava chmod +x kubectl-img ja siirrä se mihin tahansa hakemistoon polkussasi. Heti tämän jälkeen voit käyttää laajennusta kubectl img.

Kuten mainittiin, kubectl-laajennukset voidaan kirjoittaa millä tahansa ohjelmointi- tai komentosarjakielellä. Jos käytät shell-skriptejä, etuna on mahdollisuus kutsua kubectl helposti laajennuksen sisältä. Voit kuitenkin kirjoittaa monimutkaisempia laajennuksia oikeilla ohjelmointikielillä käyttämällä Kubernetes-asiakaskirjasto. Jos käytät Goa, voit myös käyttää cli-runtime kirjasto, joka on olemassa erityisesti kubectl-laajennusten kirjoittamista varten.

Kuinka jaat laajennuksiasi

Jos uskot, että liitännäisistäsi voi olla hyötyä muille, voit jakaa ne GitHubissa. Muista lisätä ne aiheeseen kubectl-liitännäiset.

Voit myös pyytää, että laajennus lisätään Krew lista. Ohjeet tämän tekemiseen löytyvät GitHub-arkistot.

Komennon suorittaminen

Laajennukset eivät tällä hetkellä tue automaattista täydennystä. Eli sinun on syötettävä laajennuksen koko nimi ja argumenttien täydelliset nimet.

Tämän toiminnon GitHub kubectl -varastossa on avoin pyyntö. Joten on mahdollista, että tämä ominaisuus otetaan käyttöön joskus tulevaisuudessa.

Onnea!

Mitä muuta luettavaa aiheesta:

Lähde: will.com

Kuinka käyttää kubectlia tehokkaammin: yksityiskohtainen opas