Artikkelen er oversatt i forkant av oppstarten av kurset .

Dersom du leser dette, har du sannsynligvis hørt om Kubernetes (og hvis ikke, hvordan havnet du her?). Men hva er egentlig Kubernetes? Dette er ? Или ? Что вообще это значит?
Ærlig talt er jeg ikke 100 % sikker. Men jeg synes det er interessant å dykke inn i detaljene og se hva som faktisk skjer i Kubernetes under de mange lagene av abstraksjoner. Så i nysgjerrighet, la oss ta en titt på hvordan et minimum av et «Kubernetes-klynge» egentlig ser ut. (Dette vil bli mye enklere enn .)
Jeg antar at du har grunnleggende kunnskap om Kubernetes, Linux og containere. Alt vi skal snakke om her er ment for utforskning/studie, ikke kjør noe av dette i produksjon!
Oversikt
Kubernetes inneholder mange komponenter. Ifølge , ser arkitekturen slik ut:

Her vises minst åtte komponenter, men de fleste av dem vil vi ignorere. Jeg vil påstå at det minste som med rimelighet kan kalles Kubernetes består av tre hovedkomponenter:
- kubelet
- kube-apiserver (som avhenger av etcd — databasen sin)
- container runtime (i dette tilfellet Docker)
La oss se hva dokumentasjonen sier om hver av dem (., ). Først kubelet:
Agenten som kjører på hver node i klyngen. Den sørger for at containere kjører i podden.
Det høres ganske enkelt ut. Hva med container runtime? (container runtime)?
Container runtime er et program som er laget for å kjøre containere.
Veldig informativt. Men hvis du er kjent med Docker, burde du ha en generell forståelse av hva det gjør. (Detaljene om ansvarsfordelingen mellom container runtime og kubelet er faktisk ganske subtile, og jeg vil ikke gå inn i dem her.)
Og API-server?
API-serveren er en komponent i Kubernetes-kontrollpanelet som presenterer Kubernetes API. API-serveren er klientdelen av Kubernetes-kontrollpanelet.
Alle som noen gang har jobbet med Kubernetes, har måttet interagere med API-en enten direkte eller via kubectl. Dette er hjertet av det som gjør Kubernetes til Kubernetes — hjernen som forvandler hauger av YAML, som vi alle kjenner og elsker (?), til fungerende infrastruktur. Det virker åpenbart at API-en må være til stede i vår minimale konfigurasjon.
Forutsetninger
- En Linux-maskin, enten virtuell eller fysisk, med root-tilgang (jeg bruker Ubuntu 18.04 på en virtuell maskin).
- Og det er alt!
Kjedelig installasjon
Docker må installeres på maskinen vi skal bruke. (Jeg skal ikke gå i detalj om hvordan Docker og containere fungerer; hvis du er interessert, finnes det ). La oss bare installere det med apt:
$ sudo apt install docker.io
$ sudo systemctl start docker Etter dette må vi skaffe Kubernetes-binærfilene. For å starte vår "klynge" trenger vi faktisk bare kubelet, ettersom vi kan bruke kubeletfor å kjøre de andre serverkomponentene. For å samhandle med klyngen vår etter at den er oppe og går, vil vi også bruke 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 Hva skjer hvis vi bare kjører kubelet?
$ ./kubelet
F0609 04:03:29.105194 4583 server.go:254] mkdir /var/lib/kubelet: permission denied kubelet den må kjøres som root. Det er ganske logisk, ettersom den må administrere hele noden. La oss se på alternativene:
$ ./kubelet -h
$ ./kubelet -h | wc -l
284Wow, så mange alternativer! Heldigvis vil vi bare trenge et par av dem. Her er et av alternativene som interesserer oss:
--pod-manifest-path stringSti til katalogen som inneholder filer for statiske pod-er, eller sti til fil med beskrivelse av statiske pod-er. Filer som begynner med punktum ignoreres. (UTDATERT: denne parameteren bør settes i konfigurasjonsfilen som sendes til Kubelet via opprøret —config. For mer informasjon, se .)
Denne parameteren lar oss kjøre — podder som ikke styres gjennom Kubernetes API. Statisk pod bruker sjelden, men de er veldig nyttige for raskt å sette opp en klynge, og det er nøyaktig det vi trenger. Vi vil ignorere denne høylytte advarselen (igjen, ikke kjør dette i produksjon!) og se om vi kan starte podden.
Først oppretter vi en katalog for statiske podder og starter kubelet:
$ mkdir pods
$ sudo ./kubelet --pod-manifest-path=podsDeretter, i et annet terminalvindu/tmux/andre steder, vil vi opprette manifestet for podden:
$ cat < pods/hello.yaml
apiVersion: v1
kind: Pod
metadata:
name: hello
spec:
containers:
- image: busybox
name: hello
command: ["echo", "hello world!"]
EOF kubelet begynner å skrive noen advarsler og det virker som om ingenting skjer. Men det er ikke tilfelle! La oss ta en titt på 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 leste manifestet for podden og ga Docker beskjed om å starte et par containere i henhold til spesifikasjonen vår. (Hvis du er interessert i å lære om 'pause'-containeren, så er dette et hack fra Kubernetes — se detaljer i .) Kubelet vil starte containeren vår busybox med den angitte kommandoen og vil starte den på nytt uendelig så lenge den statiske podden ikke blir slettet.
Gi deg selv et klapp på skulderen. Vi har nettopp oppfunnet en av de mest kompliserte måtene å skrive ut tekst til terminalen!
Starter etcd
Vårt endelige mål er å starte Kubernetes API, men for å gjøre det må vi først starte . La oss starte et minimalt etcd-klynge, ved å plassere konfigurasjonen i katalogen pods (for eksempel, 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-dataHvis du noen gang har jobbet med Kubernetes, bør slike YAML-filer være kjent for deg. Her er det bare to ting å merke seg:
Vi har montert vertsmappen /var/lib/etcd i en pod, slik at etcd-dataene lagres etter omstart (hvis ikke, vil tilstanden til klusteret bli slettet ved hver omstart av podden, noe som ikke er bra selv for en minimal Kubernetes-installasjon).
Vi har installert hostNetwork: true. Denne parameteren, ikke overraskende, konfigurerer etcd for å bruke vertsnetskapet i stedet for det interne nettverket til podden (dette vil gjøre det enklere for API-serveren å finne etcd-klusteret).
En enkel sjekk viser at etcd faktisk kjører på localhost og lagrer data til 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.walStarte API-serveren
Å starte Kubernetes API-serveren er enda enklere. Den eneste parameteren du må sende, --etcd-servers, gjør akkurat det du forventer:
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 Plasser denne YAML-filen i mappen pods, så vil API-serveren starte. Sjekker med wget viser at Kubernetes API lytter på port 8080 med full åpen tilgang — autentisering er ikke nødvendig!
$ curl localhost:8080/healthz
ok
$ curl localhost:8080/api/v1/pods
{
"kind": "PodList",
"apiVersion": "v1",
"metadata": {
"selfLink": "/api/v1/pods",
"resourceVersion": "59"
},
"items": []
}(Igjen, ikke kjør dette i produksjon! Jeg ble litt overrasket over at standardinnstillingen er så usikker. Men jeg antar at det er gjort for å lette utvikling og testing.)
Og en hyggelig overraskelse, kubectl fungerer umiddelbart uten noen ekstra innstillinger!
$ ./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.Problemet
Men hvis man graver litt dypere, ser det ut til at noe går galt:
$ ./kubectl get pod -n kube-system
No resources found in kube-system namespace.De statiske poddene vi opprettet, er borte! Faktisk blir ikke kubelet-noden vår oppdaget i det hele tatt:
$ ./kubectl get nodes
No resources found in default namespace.Hva er problemet? Hvis du husker, så kjørte vi kubelet med et ekstremt enkelt sett av kommandolinjeparametre for noen avsnitt siden, så kubelet vet ikke hvordan det skal kommunisere med API-serveren og informere den om sin tilstand. Ved å studere dokumentasjonen finner vi den relevante flagget:
--kubeconfig string
Stien til filen kubeconfig, som angir hvordan å koble til API-serveren. Tilgjengeligheten av --kubeconfig aktiverer API-servermodus, fraværet av --kubeconfig aktiverer selvstendig modus.
Hele tiden, uten å vite det, har vi kjørt kubelet i "selvstendig modus". (Hvis vi skulle være pedantiske, kunne man betrakte selvstendig modus for kubelet som "minimalt levedyktig Kubernetes", men det ville vært veldig kjedelig). For å få den "ekte" konfigurasjonen til å fungere, må vi gi kubelet kubeconfig-filen slik at den vet hvordan å kommunisere med API-serveren. Heldigvis er det ganske enkelt (siden vi ikke har problemer med autentisering eller sertifikater):
apiVersion: v1
kind: Config
clusters:
- cluster:
server: http://127.0.0.1:8080
name: mink8s
contexts:
- context:
cluster: mink8s
name: mink8s
current-context: mink8s Lagre dette som kubeconfig.yaml, drep prosessen kubelet og start på nytt med de nødvendige parameterne:
$ sudo ./kubelet --pod-manifest-path=pods --kubeconfig=kubeconfig.yaml(Forresten, hvis du prøver å få tilgang til API-en via curl når kubelet ikke kjører, vil du finne ut at den fortsatt er aktiv! Kubelet er ikke "forelderen" til sine pods, som Docker, det ligner mer på en "styrende dæmon". Containerne administrert av kubelet vil fortsette å kjøre inntil kubelet stopper dem.)
Om noen minutter kubectl bør vise oss pods og noder, akkurat som vi forventer:
$ ./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.6La oss virkelig gratulere oss selv denne gangen (jeg vet at jeg allerede har gratulert) – vi har fått et minimalt "klynge" Kubernetes som fungerer med en fullt funksjonell API!
Kjører pod
Nå skal vi se hva API-en kan gjøre. La oss begynne med en nginx-pod:
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
containers:
- image: nginx
name: nginxHer vil vi få en ganske interessant feil:
$ ./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.Her ser vi hvor utrolig ufullstendig Kubernetes-miljøet vårt er — vi har ingen tjenestekonti. La oss prøve igjen ved å opprette en tjenestekonto manuelt og se hva som skjer:
$ 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.Selv når vi har opprettet en tjenestekonto manuelt, blir ikke autentiseringstoken opprettet. Når vi fortsetter å eksperimentere med vår minimalistiske «klynge», vil vi oppdage at de fleste nyttige tingene som vanligvis skjer automatisk vil mangle. Kubernetes API-serveren er ganske minimalistisk, og mye av den tunge automatiseringen skjer i forskjellige kontrollere og bakgrunnsjobber som ennå ikke kjører.
Vi kan omgå dette problemet ved å sette alternativet automountServiceAccountToken for tjenestekontoen (siden vi uansett ikke vil bruke den):
$ 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 13mEndelig har poden dukket opp! Men den vil ikke starte, da vi ikke har (scheduler) — enda en viktig komponent av Kubernetes. Igjen ser vi at Kubernetes API er overraskende «dum» — når du oppretter en pod i API-en, registrerer den den, men prøver ikke å finne ut på hvilken node den skal kjøres.
Faktisk er ikke en planlegger nødvendig for å starte en pod. Du kan manuelt legge til noden i manifestet i parameteren nodeName:
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
containers:
- image: nginx
name: nginx
nodeName: mink8s
(Erstatt mink8s med navnet på noden.) Etter delete og apply ser vi at nginx har startet og lytter på den interne IP-adressen:
$ .\/kubectl slett pod nginx
pod "nginx" slettet
$ .\/kubectl apply -f nginx.yaml
pod/nginx opprettet
$ .\/kubectl get pods -owide
NAVN KLAR STATUS STARTINGER ALDER IP NODE NOMINERT NODE BEREDSKAPSGJERDER
nginx 1\/1 Kjøring 0 30s 172.17.0.2 mink8s <none> <none>
$ curl -s 172.17.0.2 | head -4
<!DOCTYPE html>
<html>
<head>
<title>Velkommen til nginx!</title>For å være sikker på at nettverket mellom podene fungerer riktig, kan vi kjøre curl fra en annen pod:
$ cat <<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>Velkommen til nginx!</title>Det er ganske interessant å dykke ned i dette miljøet og se hva som fungerer og hva som ikke gjør det. Jeg oppdaget at ConfigMap og Secret fungerer som forventet, mens Service og Deployment ikke gjør det.
Suksess!
Dette innlegget blir langt, så jeg skal kunngjøre vinneren og si at dette er en levedyktig konfigurasjon som kan kalles "Kubernetes". For å oppsummere: fire binære filer, fem kommandolinjeparametre og "bare" 45 linjer med YAML (ikke så mye etter Kubernetes-standarder) og vi har mange ting som fungerer.
- Podene styres via det vanlige Kubernetes API-et (med noen hacks).
- Det er mulig å laste opp offentlige kontainerbilder og administrere dem.
- Podene forblir aktive og startes automatisk på nytt.
- Nettverket mellom podene på en enkelt node fungerer ganske bra.
- ConfigMap, Secret, og den enkleste lagringsmonteringen fungerer som de skal.
Men mye av det som gjør Kubernetes virkelig nyttig, mangler fortsatt, for eksempel:
- Pod-planlegger.
- Autentisering / autorisasjon.
- Flere noder.
- Tjenestenettverk.
- Klyngeintern DNS.
- Kontrollere for tjenestekontoer, distribusjoner, integrering med skytilbydere og de fleste andre "godbitene" som Kubernetes bringer med seg.
Så hva har vi egentlig fått? Kubernetes API, som fungerer for seg selv, er faktisk bare en plattform for automatisering av containere.. Det gjør ikke mye — det er arbeidet til forskjellige kontrollere og operatører som bruker API-en — men det gir et konsistent miljø for automatisering.
Les mer:
Kilde: habr.com
