Minimāli dzīvotspējīgs Kubernetes

Raksta tulkojums sagatavots kursa uzsākŔanas priekŔvakarā «DevOps prakse un rīki».

Minimāli dzīvotspējīgs Kubernetes

Ja, ja to lasāt, visticamāk, esat dzirdējuÅ”i par Kubernetes (un, ja nē, tad kā jÅ«s Å”eit nokļuvojāt?) Bet kas patiesÄ«bā ir Kubernetes? Tas ir ā€žRÅ«pnieciski lÄ«menis konteineru orÄ·estrācijaā€œ? Или ā€žMākoņu pamatdarbÄ«bas sistēmaā€œ? Что вообще ŃŃ‚Š¾ значит?

GodÄ«gi sakot, es neesmu 100% pārliecināts. Bet domāju, ka bÅ«tu interesanti iepazÄ«ties ar to, kā patiesÄ«bā notiek Kubernetes iekÅ”ienē un ko mēs redzam zem tā daudziem abstrakciju slāņiem. Tāpēc, lai gÅ«tu interesi, aplÅ«kosim, kā patiesÄ«bā izskatās minimālais ā€žKubernetes klasterisā€œ. (Tas bÅ«s daudz vieglāk nekā Kubernetes GrÅ«ti Ceļi.)

Es pieņemu, ka jums ir pamatzināŔanas par Kubernetes, Linux un konteineriem. Viss, par ko mēs Å”eit runāsim, ir domāts tikai izpētei/mācÄ«bām, nekad neveiciet to ražoÅ”anā!

Pārskats

Kubernetes satur daudz komponentu. Saskaņā ar Vikipēdiju, arhitektÅ«ra izskatās Ŕādi:

Minimāli dzīvotspējīgs Kubernetes

Šeit ir parādīti vismaz astoņi komponenti, bet lielāko daļu no tiem mēs ignorēsim. Vēlos apgalvot, ka minimālā lieta, ko var pamatoti dēvēt par Kubernetes, ir trīs galvenās sastāvdaļas:

  • kubelet
  • kube-apiserver (kas ir atkarÄ«gs no etcd — tā datu bāzes)
  • konteineru izpildes vide (Å”ajā gadÄ«jumā Docker)

Paskatīsimies, ko par katru no tiem saka dokumentācija (rus., eng). Sākumā kubelet:

Aģents, kas darbojas katrā mezglā klasterī. Tas uzrauga, lai konteineri tiktu palaisti podā.

Izskatās diezgan vienkārŔi. Ko par konteineru izpildes vidi (container runtime)?

Konteineru izpildes vide ir programma, kas paredzēta konteineru izpildei.

Ä»oti informatÄ«vi. Bet, ja jums ir zināŔanas par Docker, tad jums vajadzētu bÅ«t vispārējai izpratnei par to, ko tas dara. (AtbildÄ«bas sadalÄ«juma detaļas starp konteineru izpildes vidi un kubelet ir patieŔām diezgan smalkas un Å”eit es neskaidroÅ”u.)

un API-serveris?

API-serveris ir Kubernetes vadības paneļa komponents, kas nodroŔina Kubernetes API. API-serveris ir klients, kas attiecas uz Kubernetes vadības paneli.

Ikvienam, kas kādreiz ir veicis jebko ar Kubernetes, vajadzēja mijiedarboties ar API vai nu tieÅ”i, vai caur kubectl. Tas ir sirds tam, kas padara Kubernetes par Kubernetes — smadzenes, kas pārvērÅ” milzÄ«gas YAML, kuras mēs visi pazÄ«stam un mÄ«lam (?), par funkcionālu infrastruktÅ«ru. Izskatās acÄ«mredzami, ka API ir jābÅ«t mÅ«su minimālajā konfigurācijā.

PriekŔnosacījumi

  • Virtuāla vai fiziska Linux maŔīna ar root piekļuvi (es izmantoju Ubuntu 18.04 virtuālajā maŔīnā).
  • Un tas arÄ« viss!

Garlaicīga instalācija

Uz maŔīnas, ko mēs izmantosim, nepiecieÅ”ams instalēt Docker. (Es neplānoju detalizēti aprakstÄ«t, kā darbojas Docker un tvertnes; ja jums interesē, ir brÄ«niŔķīgi raksti). VienkārÅ”i instalēsim to, izmantojot apt:

$ sudo apt install docker.io
$ sudo systemctl start docker

Pēc tam mums jāiegÅ«st Kubernetes binārie faili. PatiesÄ«bā, mÅ«su ā€œklasteraā€ sākotnējai palaiÅ”anai mums nepiecieÅ”ama tikai kubelet, jo citu servera sastāvdaļu palaiÅ”anai varēsim izmantot kubelet. Lai mijiedarbotos ar mÅ«su klasteri, kad tas sāks darboties, mēs arÄ« izmantosim kubectl.

$ curl -L https://dl.k8s.io/v1.18.5/kubernetes-server-linux-amd64.tar.gz > server.tar.gz
$ tar xzvf server.tar.gz
$ cp kubernetes/server/bin/kubelet .
$ cp kubernetes/server/bin/kubectl .
$ ./kubelet --version
Kubernetes v1.18.5

Ko mēs redzēsim, ja vienkārÅ”i palaidÄ«sim kubelet?

$ ./kubelet
F0609 04:03:29.105194 4583 server.go:254] mkdir /var/lib/kubelet: atļauja noraidīta

kubelet jādarbojas no root. Pietiekami loģiski, jo tam ir jāvada viss mezgls. Apskatīsim tā parametrus:

$ ./kubelet -h

$ ./kubelet -h | wc -l
284

Ak, cik daudz opciju! Par laimi, mums bÅ«s nepiecieÅ”amas tikai dažas no tām. Å eit ir viens no parametriem, kas mÅ«s interesē:

--pod-manifest-path string

CeļŔ uz katalogu, kas satur statisko podu failus, vai ceļŔ uz failu, kas satur statisko podu aprakstu. Faili, kas sākas ar punktu, tiek ignorēti. (NOVECOJIS: Å”o parametru vajadzētu iestatÄ«t konfigurācijas failā, ko nodod Kubelet ar opciju —config. Papildinformāciju skatiet. kubernetes.io/docs/tasks/administer-cluster/kubelet-config-file .)

Å is parametrs ļauj mums palaist statiskos podus — podus, kuri netiek pārvaldÄ«ti caur Kubernetes API. Statiskie podi tiek izmantoti reti, taču tie ir ļoti ērti, lai ātri uzsāktu klasteri, kas ir tieÅ”i tas, kas mums nepiecieÅ”ams. Mēs ignorēsim Å”o skaļo brÄ«dinājumu (atkal, nerosiniet to ražoÅ”anā!) un redzēsim, vai mēs varam palaist podu.

Vispirms izveidosim katalogu statiskajiem podiem un palaidīsim kubelet:

$ mkdir pods
$ sudo ./kubelet --pod-manifest-path=pods

Tad citā terminālā/logā tmux/vēl kaut kur, mēs izveidosim poda manifestu:

$ cat < pods/hello.yaml
apiVersion: v1
kind: Pod
metadata:
  name: hello
spec:
  containers:
  - image: busybox
    name: hello
    command: ["echo", "hello world!"]
EOF

kubelet sāk uzrādīt dažādus brīdinājumus un Ŕķiet, ka nekas nenotiek. Taču tā nav taisnība! Apskatīsim Docker:

$ sudo docker ps -a
CONTAINER ID        IMAGE                  COMMAND                 CREATED             STATUS                      PORTS               NAMES
8c8a35e26663        busybox                "echo 'hello world!'"   36 seconds ago      Exited (0) 36 seconds ago                       k8s_hello_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_4
68f670c3c85f        k8s.gcr.io/pause:3.2   "pause"                2 minutes ago       Up 2 minutes                                    k8s_POD_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_0
$ sudo docker logs k8s_hello_hello-mink8s_default_ab61ef0307c6e0dee2ab05dc1ff94812_4
hello world!

kubelet izlasÄ«ja poda manifestu un deva Docker komandai palaist pāris konteinerus saskaņā ar mÅ«su specifikāciju. (Ja jÅ«s interesē konteineru ā€œpauseā€, tad tas ir Kubernetes triks — sÄ«kāk skatiet Å”ajā emuārā.) Kubelet palaidÄ«s mÅ«su konteineru busybox ar norādÄ«to komandu un turpinās to pārstartēt bezgalÄ«gi, kamēr statiskais pods netiks dzēsts.

Apsveicam jÅ«s. Mēs tieÅ”i izdomājām vienu no vispretrunÄ«gākajiem veidiem, kā izvadi tekstu terminālÄ«!

Palaidīsim etcd

Mūsu galvenais mērķis ir palaist Kubernetes API, bet pirms tam mums vispirms jāpalaiž etcd. Apskatīsim minimālo etcd klasteri, novietojot tā konfigurāciju pods katalogā (piemēram, pods/etcd.yaml):

apiVersion: v1
kind: Pod
metadata:
  name: etcd
  namespace: kube-system
spec:
  containers:
  - name: etcd
    command:
    - etcd
    - --data-dir=/var/lib/etcd
    image: k8s.gcr.io/etcd:3.4.3-0
    volumeMounts:
    - mountPath: /var/lib/etcd
      name: etcd-data
  hostNetwork: true
  volumes:
  - hostPath:
      path: /var/lib/etcd
      type: DirectoryOrCreate
    name: etcd-data

Ja jÅ«s kādreiz esat strādājuÅ”i ar Kubernetes, tad Ŕādi YAML faili jums jābÅ«t pazÄ«stamiem. Å eit jāatzÄ«mē divi aspekti:

Mēs pievienojām mitināŔanas mapi /var/lib/etcd podam, lai etcd dati saglabātos pēc pārstartēŔanas (ja to nedarÄ«siet, klastera stāvoklis tiks dzēsts pie katras poda pārstartēŔanas, kas pat minimālai Kubernetes instalācijai nebÅ«s labi).

Mēs esam iestatÄ«juÅ”i hostNetwork: true. Å is parametrs, kā paredzēts, konfigurē etcd, lai izmantotu mitināŔanas tÄ«klu nevis iekŔējo tÄ«klu podā (tas atvieglos API-servera atraÅ”anu etcd klasterÄ«).

VienkārŔa pārbaude parāda, ka etcd patieŔām darbojas localhost un saglabā datus diskā:

$ curl localhost:2379/version
{"etcdserver":"3.4.3","etcdcluster":"3.4.0"}
$ sudo tree /var/lib/etcd/
/var/lib/etcd/
└── member
    ā”œā”€ā”€ snap
    │   └── db
    └── wal
        ā”œā”€ā”€ 0.tmp
        └── 0000000000000000-0000000000000000.wal

API-servera palaiŔana

Palai API server Kubernetes vēl vienkārŔāk. VienÄ«gais parametrs, kas jums jānodod, --etcd-servers, dara to, ko sagaidāt:

apiVersion: v1
kind: Pod
metadata:
  name: kube-apiserver
  namespace: kube-system
spec:
  containers:
  - name: kube-apiserver
    command:
    - kube-apiserver
    - --etcd-servers=http://127.0.0.1:2379
    image: k8s.gcr.io/kube-apiserver:v1.18.5
  hostNetwork: true

Ievietojiet Å”o YAML failu katalogā pods, un API serveris tiks palaists. Pārbaudot ar curl parāda, ka Kubernetes API klausās uz porta 8080 ar pilnÄ«gu piekļuvi — autentifikācija nav nepiecieÅ”ama!

$ curl localhost:8080/healthz
ok
$ curl localhost:8080/api/v1/pods
{
  "kind": "PodList",
  "apiVersion": "v1",
  "metadata": {
    "selfLink": "/api/v1/pods",
    "resourceVersion": "59"
  },
  "items": []
}

(Atkal, neražojiet to! Es biju nedaudz pārsteigts, ka noklusējuma iestatÄ«jums ir tik nedroÅ”s. Bet es pieņemu, ka tas ir izdarÄ«ts, lai atvieglotu izstrādi un testēŔanu.)

Un, patīkams pārsteigums, kubectl darbojas uzreiz bez jebkādām papildu iestatījumiem!

$ ./kubectl version
Client Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.5", GitCommit:"e6503f8d8f769ace2f338794c914a96fc335df0f", GitTreeState:"clean", BuildDate:"2020-06-26T03:47:41Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"18", GitVersion:"v1.18.5", GitCommit:"e6503f8d8f769ace2f338794c914a96fc335df0f", GitTreeState:"clean", BuildDate:"2020-06-26T03:39:24Z", GoVersion:"go1.13.9", Compiler:"gc", Platform:"linux/amd64"}
$ ./kubectl get pod
No resources found in default namespace.

Problēma

Bet, ja padziļināsiet, izskatās, ka kaut kas neiet tā, kā vajag:

$ ./kubectl get pod -n kube-system
No resources found in kube-system namespace.

Statiskie podi, kurus mēs izveidojām, ir pazuduÅ”i! PatiesÄ«bā mÅ«su kubelet mezgls vispār nav konstatēts:

$ ./kubectl get nodes
No resources found in default namespace.

Kas notiek? Ja atceraties, pirms dažiem teikumiem mēs palaidām kubelet ar ļoti vienkārÅ”u komandrindas parametru kopumu, tāpēc kubelet nezina, kā sazināties ar API serveri un paziņot tam par savu stāvokli. Pētot dokumentāciju, mēs atrodam atbilstoÅ”o zÄ«mi:

--kubeconfig string

CeļŔ uz failu kubeconfig, kurā ir norādīts, kā savienoties ar API serveri. Klātbūtne --kubeconfig iekļauj API servera režīmu, neesamība --kubeconfig iekļauj autonomo režīmu.

Visu Å”o laiku, paÅ”i to nezinot, mēs palaidām kubelet "autonoma režīmā". (Ja mēs bÅ«tu pedanti, mēs varētu uzskatÄ«t autonomo režīmu kubelet kā "minimāli dzÄ«votspējÄ«gu Kubernetes", bet tas bÅ«tu ļoti garlaicÄ«gi). Lai aktivizētu "Ä«sto" konfigurāciju, mums jānodod kubeconfig fails kubelet, lai tas zinātu, kā runāt ar API serveri. Par laimi, tas ir diezgan vienkārÅ”i (jo mums nav problēmu ar autentifikāciju vai sertifikātiem):

apiVersion: v1
kind: Config
clusters:
- cluster:
    server: http://127.0.0.1:8080
  name: mink8s
contexts:
- context:
    cluster: mink8s
  name: mink8s
current-context: mink8s

Saglabājiet to kā kubeconfig.yaml, nogaliniet procesu kubelet un restartējiet ar nepiecieÅ”amajiem parametriem:

$ sudo ./kubelet --pod-manifest-path=pods --kubeconfig=kubeconfig.yaml

(Starp citu, ja jūs mēģināsiet piekļūt API caur curl, kad kubelet nedarbojas, jūs atklāsiet, ka tas joprojām darbojas! Kubelet nav "vecākais" saviem podiem, līdzīgi kā Docker, tas vairāk atgādina "pārvaldītāju dēmonu". Konteineri, ko pārvalda kubelet, darbosies, kamēr kubelet tos nenosaka.)

Pēc dažām minūtēm kubectl jāparāda mums podi un mezgli, kā mēs sagaidījām:

$ ./kubectl get pods -A
NAMESPACE     NAME                    READY   STATUS             RESTARTS   AGE
default       hello-mink8s            0/1     CrashLoopBackOff   261        21h
kube-system   etcd-mink8s             1/1     Running            0          21h
kube-system   kube-apiserver-mink8s   1/1     Running            0          21h
$ ./kubectl get nodes -owide
NAME     STATUS   ROLES    AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION       CONTAINER-RUNTIME
mink8s   Ready       21h   v1.18.5   10.70.10.228           Ubuntu 18.04.4 LTS   4.15.0-109-generic   docker://19.3.6

Lai Å”oreiz sevi patieŔām apsveikt (es zinu, ka jau sveicu) — mums ir izveidojies minimāls "klasteris" Kubernetes, kas darbojas ar pilnvērtÄ«gu API!

Palaižam podu

Tagad paskatīsimies, ko spēj API. Sāksim ar podu nginx:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx

Šeit mēs saņemsim diezgan interesantu kļūdu:

$ ./kubectl apply -f nginx.yaml
Error from server (Forbidden): error when creating "nginx.yaml": pods "nginx" is
forbidden: error looking up service account default/default: serviceaccount
"default" not found
$ ./kubectl get serviceaccounts
No resources found in default namespace.

Å eit mēs redzam, cik Å”ausmÄ«gi nepilnÄ«ga ir mÅ«su Kubernetes vide — mums nav pakalpojuma kontu. Mēģināsim vēlreiz, izveidojot pakalpojuma kontu manuāli, un paskatÄ«simies, kas notiks:

$ cat <<EOS | ./kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: default
EOS
serviceaccount/default created
$ ./kubectl apply -f nginx.yaml
Error from server (ServerTimeout): error when creating "nginx.yaml": No API
token found for service account "default", retry after the token is
automatically created and added to the service account

Pat even tad, kad mēs manuāli izveidojām pakalpojuma kontu, autentifikācijas tokens netiek izveidots. Turpinot eksperimentēt ar mÅ«su minimālistisko "klasteri", mēs secināsim, ka lielākā daļa noderÄ«go lietu, kas parasti notiek automātiski, bÅ«s trÅ«kstoÅ”as. Kubernetes API servers ir diezgan minimālistisks, lielākā daļa smago automātisko iestatÄ«jumu notiek dažādos kontrolieros un fonu uzdevumos, kas joprojām nav izpildÄ«ti.

Mēs varam apiet Å”o problēmu, iestatot opciju automountServiceAccountToken pakalpojuma kontam (jo mums tas tik un tā nebÅ«s jādara):

$ cat <<EOS | ./kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: default
automountServiceAccountToken: false
EOS
serviceaccount/default configured
$ ./kubectl apply -f nginx.yaml
pod/nginx created
$ ./kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   0/1     Pending   0          13m

Visbeidzot, pods parādÄ«jās! Bet patiesÄ«bā tas nesāks darboties, jo mums nav plānotāja (scheduler) — vēl viena svarÄ«ga Kubernetes sastāvdaļa. Atkal mēs redzam, ka Kubernetes API ir pārsteidzoÅ”i "muļķīgs" — kad jÅ«s izveidojat podu API, tas to reÄ£istrē, bet nemēģina noskaidrot, uz kāda mezgla to palaist.

Patiesībā, lai palaistu podu, plānotājs nav nepiecieŔams. Varat manuāli pievienot mezglu manifestā opcijā nodeName:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - image: nginx
    name: nginx
  nodeName: mink8s

(Aizvietojiet mink8s ar mezgla nosaukumu.) Pēc dzēŔanas un piemēroÅ”anas mēs redzam, ka nginx ir palaists un klausās iekŔējo IP adresi:

$ .\/kubectl dzēst pod nginx
pod "nginx" dzēsts
$ .\/kubectl lietot -f nginx.yaml
pod/nginx izveidots
$ .\/kubectl iegūt podus -owide
VĀRDS    GATAVS   STATUSS    ATJAUNOJUMI   VECUMS   IP           DOMAINS     NORAKSTÄŖTAIS DOMAINS   GATAVAS IEBRAUKŠANAS VĀRTI
nginx   1\/1     Darbojas   0          30s   172.17.0.2   mink8s   <none>           <none>
$ curl -s 172.17.0.2 | head -4
<!DOCTYPE html>
<html>
<head>
<title>Laipni lūdzam nginx!</title>

Lai pārliecinātos, ka tīkls starp podiem darbojas pareizi, mēs varam palaist curl no cita poda:

$ cat &lt;&lt;EOS | .\/kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: curl
spec:
  containers:
  - image: curlimages\/curl
    name: curl
    command: ["curl", "172.17.0.2"]
  nodeName: mink8s
EOS
pod\/curl created
$ .\/kubectl logs curl | head -6
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
<!DOCTYPE html>
<html>
<head>
<title>Laipni lūdzam nginx!</title>

Visai interesanti ir izpētÄ«t Å”o vidi un redzēt, kas darbojas, bet kas nē. Es atklāju, ka ConfigMap un Secret darbojas tā, kā gaidÄ«ts, bet Service un Deployment nē.

Veiksmīgi!

Å is ieraksts kļūst garÅ”, tāpēc es plānoju paziņot par uzvaru un apgalvot, ka Ŕī ir dzÄ«votspējÄ«ga konfigurācija, ko var saukt par ā€œKubernetes". Rezumējot: četri binārie faili, piecas komandrindas opcijas un ā€œtikaiā€ 45 YAML rindiņas (ne pārāk daudz Kubernetes standartiem), un mums ir daudz ko darÄ«t:

  • Podus tiek pārvaldÄ«ts ar parasto Kubernetes API (ar dažiem trikiem)
  • Varat augÅ”upielādēt publiskos konteineru attēlus un pārvaldÄ«t tos
  • Podus paliek dzÄ«vi un automātiski tiek restartēti
  • TÄ«kls starp podiem viena mezgla ietvaros darbojas diezgan labi
  • ConfigMap, Secret un vienkārŔā glabātuves montēŔana darbojas kā paredzēts

Tomēr liela daļa no tā, ko Kubernetes tieŔām dara noderÄ«gu, joprojām trÅ«kst, piemēram:

  • Podu plānotājs
  • Autentifikācija / autorizācija
  • Vairāki mezgli
  • Pakalpojumu tÄ«kls
  • Klastra iekŔējais DNS
  • Kontrolieri pakalpojumu kontiem, izvietojumiem, integrācijai ar mākonis piegādātājiem un gandrÄ«z visām citām 'priekÅ”rocÄ«bām', ko sniedz Kubernetes

Tātad, ko mēs patiesÄ«bā ieguvām? Kubernetes API, kas darbojas pats par sevi, patiesÄ«bā ir tikai platforma konteineru automatizācijai. Tas nedara daudz — tas ir dažādu kontrolieru un operatoru darbs, kas izmanto API — bet tas nodroÅ”ina konsekventu vidi automatizācijai.

Uzziniet vairāk par kursu bezmaksas vebinārā.

Lasīt vēl:

Avots: habr.com

Iegādājieties uzticamu tÄ«mekļa hostingu ar DDoS aizsardzÄ«bu, VPS VDS serveriem šŸ”„ Iegādājieties uzticamu tÄ«mekļa hostingu ar DDoS aizsardzÄ«bu, VPS VDS serveriem | ProHoster