Minimum levedyktig Kubernetes

Artikkelen er oversatt i forkant av oppstarten av kurset “DevOps Practices and Tools”.

Minimum levedyktig Kubernetes

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 «Container orchestration på industrielt nivå»? Или «Cloud-Native Operativsystem»? Что вообще это значит?

Æ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 Kubernetes The Hard Way.)

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 Wikipedia, ser arkitekturen slik ut:

Minimum levedyktig Kubernetes

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 (rus., eng). 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 fantastiske artikler). 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
284

Wow, så mange alternativer! Heldigvis vil vi bare trenge et par av dem. Her er et av alternativene som interesserer oss:

--pod-manifest-path string

Sti 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 kubernetes.io/docs/tasks/administer-cluster/kubelet-config-file .)

Denne parameteren lar oss kjøre statiske pod-er — 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=pods

Deretter, 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 denne bloggen.) 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 etcd. 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-data

Hvis 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.wal

Starte 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.6

La 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: nginx

Her 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          13m

Endelig har poden dukket opp! Men den vil ikke starte, da vi ikke har planlegger (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 &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>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.

Lær mer om kurset på det gratis webinaret.

Les mer:

Kilde: habr.com

Kjøp pålitelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere 🔥 Kjøp pålitelig hosting for nettsteder med DDoS-beskyttelse, VPS VDS-servere | ProHoster