🥇Plnohodnotný Kubernetes od základov na Raspberry Pi

Len nedávno jedna známa spoločnosť oznámila, že presúva svoj rad notebookov na architektúru ARM. Keď som počul túto správu, spomenul som si: pri opätovnom pohľade na ceny EC2 v AWS som si všimol Gravitóny s veľmi dobrou cenou. Háčik bol samozrejme v tom, že išlo o ARM. Vtedy mi ani nenapadlo, že ARM to myslí celkom vážne...

Pre mňa bola táto architektúra vždy doménou mobilných a iných vecí IoT. “Skutočné” servery na ARM sú akosi nezvyčajné, v niektorých smeroch až divoké... V hlave mi však utkvela nová myšlienka, a tak som sa jedného víkendu rozhodol skontrolovať, čo by sa dnes dalo na ARM spustiť. A preto som sa rozhodol začať s niečím blízkym a drahým - klastrom Kubernetes. A nie len nejaký ten konvenčný „klaster“, ale všetko „dospelácky“, aby to bolo čo najviac také, ako to zvyknem vídať vo výrobe.

Klaster by mal byť podľa mojej predstavy prístupný z internetu, mala by v ňom bežať nejaká webová aplikácia a mal by tam byť aspoň monitoring. Na realizáciu tejto myšlienky budete potrebovať pár (alebo viac) Raspberry Pi minimálne model 3B+. AWS sa mohlo stať platformou pre experimenty, ale mňa zaujali „maliny“ (ktoré stále nečinne stáli). Nasadíme teda klaster Kubernetes s Ingress, Prometheus a Grafana.

Príprava "malín"

Inštalácia OS a SSH

S výberom operačného systému na inštaláciu som sa príliš neobťažoval: vzal som si najnovší Raspberry Pi OS Lite oficiálne stránky. K dispozícii tam inštalačnú dokumentáciu, všetky akcie, z ktorých sa musia vykonať na všetkých uzloch budúceho klastra. Ďalej budete musieť vykonať nasledujúce manipulácie (aj na všetkých uzloch).

Po pripojení monitora a klávesnice musíte najprv nakonfigurovať sieť a SSH:

Aby klaster fungoval, musí mať hlavný server statickú IP adresu a pracovné uzly musia mať statickú IP adresu. Pre jednoduché nastavenie som uprednostňoval statické adresy.
Statická adresa môže byť nakonfigurovaná v OS (v súbore /etc/dhcpcd.conf existuje vhodný príklad) alebo stanovením prenájmu v DHCP serveri použitého (v mojom prípade domáceho) smerovača.
ssh-server je jednoducho zahrnutý v raspi-config (možnosti rozhrania → ssh).

Potom sa môžete prihlásiť cez SSH (predvolené prihlásenie je pia heslo je raspberry alebo ten, ktorý ste zmenili) a pokračujte v nastaveniach.

Iné nastavenia

Nastavíme názov hostiteľa. V mojom príklade použijú pi-control и pi-worker.
Skontrolujte, či je súborový systém rozšírený tak, aby pokryl celý disk (df -h /). V prípade potreby je možné ho rozšíriť pomocou raspi-config.
Zmeňme predvolené heslo používateľa v raspi-config.
Vypnime swap súbor (to je požiadavka Kubernetes; ak vás zaujímajú podrobnosti o tejto téme, viď. vydanie #53533):
```
dphys-swapfile swapoff
systemctl disable dphys-swapfile
```
Poďme aktualizovať balíčky na najnovšie verzie:
```
apt-get update && apt-get dist-upgrade -y
```

Nainštalujte Docker a ďalšie balíčky:

apt-get install -y docker docker.io apt-transport-https curl bridge-utils iptables-persistent

Pri inštalácii iptables-persistent budete musieť uložiť nastavenia iptables pre ipv4 a do súboru /etc/iptables/rules.v4 - pridať pravidlá do reťazca FORWARD, Páči sa ti to:

# Generated by xtables-save v1.8.2 on Sun Jul 19 00:27:43 2020
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -s 10.1.0.0/16  -j ACCEPT
-A FORWARD -d 10.1.0.0/16  -j ACCEPT
COMMIT

Zostáva len reštartovať.

Teraz ste pripravení nainštalovať svoj klaster Kubernetes.

Inštalácia Kubernetes

V tejto fáze som zámerne odložil všetok svoj a náš firemný vývoj na automatizáciu inštalácie a konfigurácie klastra K8s. Namiesto toho použite oficiálnu dokumentáciu s kubernetes.io (mierne doplnené komentármi a skratkami).

Pridajme úložisko Kubernetes:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
cat <<EOF | sudo tee /etc/apt/sources.list.d/kubernetes.list
deb https://apt.kubernetes.io/ kubernetes-xenial main
EOF
sudo apt-get update

Ďalej v dokumentácii sa odporúča nainštalovať CRI (container runtime interface). Keďže Docker je už nainštalovaný, poďme ďalej a nainštalujte hlavné komponenty:

sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni

V kroku inštalácie hlavných komponentov som okamžite pridal kubernetes-cni, ktorý je potrebný na fungovanie klastra. A tu je dôležitý bod: balík kubernetes-cni z nejakého dôvodu nevytvára predvolený adresár pre nastavenia rozhrania CNI, takže som ho musel vytvoriť manuálne:

mkdir -p /etc/cni/net.d

Aby backend siete fungoval, o čom sa bude diskutovať nižšie, musíte nainštalovať doplnok pre CNI. Vybral som si portmap plugin, ktorý je mi známy a zrozumiteľný (úplný zoznam nájdete v časti dokumentáciu):

curl -sL https://github.com/containernetworking/plugins/releases/download/v0.7.5/cni-plugins-arm-v0.7.5.tgz | tar zxvf - -C /opt/cni/bin/ ./portmap

Konfigurácia Kubernetes

Uzol s riadiacou rovinou

Inštalácia samotného klastra je pomerne jednoduchá. A na urýchlenie tohto procesu a overenie dostupnosti obrázkov Kubernetes môžete najskôr spustiť:

kubeadm config images pull

Teraz vykonáme samotnú inštaláciu - inicializujte riadiacu rovinu klastra:

kubeadm init --pod-network-cidr=10.1.0.0/16 --service-cidr=10.2.0.0/16 --upload-certs

Upozorňujeme, že podsiete pre služby a moduly by sa nemali prekrývať navzájom ani s existujúcimi sieťami.

Na konci sa nám zobrazí správa, že je všetko v poriadku, a zároveň nám povedia, ako pripojiť pracovné uzly k riadiacej rovine:

Your Kubernetes control-plane has initialized successfully!
To start using your cluster, you need to run the following as a regular user:
 mkdir -p $HOME/.kube
 sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
 sudo chown $(id -u):$(id -g) $HOME/.kube/config
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
 https://kubernetes.io/docs/concepts/cluster-administration/addons/
You can now join any number of the control-plane node running the following command on each as root:
 kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 
   --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050 
   --contrl-plane --certificate-key 72a3c0a14c627d6d7fdade1f4c8d7a41b0fac31b1faf0d8fdf9678d74d7d2403
Please note that the certificate-key gives access to cluster sensitive data, keep it secret!
As a safeguard, uploaded-certs will be deleted in two hours; If necessary, you can use
"kubeadm init phase upload-certs --upload-certs" to reload certs afterward.
Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 
   --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050

Postupujte podľa odporúčaní na pridanie konfigurácie pre používateľa. Zároveň odporúčam okamžite pridať automatické dopĺňanie pre kubectl:

 kubectl completion bash > ~/.kube/completion.bash.inc
 printf "
 # Kubectl shell completion
 source '$HOME/.kube/completion.bash.inc'
 " >> $HOME/.bash_profile
 source $HOME/.bash_profile

V tejto fáze už vidíte prvý uzol v klastri (hoci ešte nie je pripravený):

root@pi-control:~# kubectl get no
NAME         STATUS     ROLES    AGE   VERSION
pi-control   NotReady   master   29s   v1.18.6

Konfigurácia siete

Ďalej, ako je uvedené v správe po inštalácii, budete musieť nainštalovať sieť do klastra. Dokumentácia ponúka na výber Calico, Cilium, contiv-vpp, Kube-router a Weave Net... Tu som sa odklonil od oficiálnych pokynov a zvolil som pre mňa známejšiu a zrozumiteľnejšiu možnosť: flanel v režime host-gw (viac informácií o dostupných backendoch nájdete na projektovej dokumentácie).

Inštalácia do klastra je pomerne jednoduchá. Najprv si stiahnite manifesty:

wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Potom zmeňte typ pomocou v nastaveniach vxlan na host-gw:

sed -i 's/vxlan/host-gw/' kube-flannel.yml

... a podsieť pods - z predvolenej hodnoty na hodnotu zadanú počas inicializácie klastra:

sed -i 's#10.244.0.0/16#10.1.0.0/16#' kube-flannel.yml

Potom vytvoríme zdroje:

kubectl create -f kube-flannel.yml

Pripravený! Po určitom čase sa prvý uzol K8 prepne do stavu Ready:

NAME         STATUS   ROLES    AGE   VERSION
pi-control   Ready    master   2m    v1.18.6

Pridanie pracovného uzla

Teraz môžete pridať pracovníka. Ak to chcete urobiť - po inštalácii samotného Kubernetes podľa scenára opísaného vyššie - stačí spustiť predtým prijatý príkaz:

kubeadm join 192.168.88.30:6443 --token a485vl.xjgvzzr2g0xbtbs4 
    --discovery-token-ca-cert-hash sha256:9da6b05aaa5364a9ec59adcc67b3988b9c1b94c15e81300560220acb1779b050

V tomto bode môžeme predpokladať, že klaster je pripravený:

root@pi-control:~# kubectl get no
NAME         STATUS   ROLES    AGE    VERSION
pi-control   Ready    master   28m    v1.18.6
pi-worker    Ready    <none>   2m8s   v1.18.6

Mal som po ruke len dva Raspberry Pis, takže jedno z nich darujem iba Nechcel som to mať pod riadiacou rovinou. Takže som odstránil automaticky nainštalovanú škvrnu z uzla pi-control spustením:

root@pi-control:~# kubectl edit node pi-control

...a odstránenie riadkov:

 - effect: NoSchedule
   key: node-role.kubernetes.io/master

Naplnenie klastra požadovaným minimom

V prvom rade potrebujeme kormidlo. Samozrejme, všetko zvládnete aj bez neho, ale Helm vám umožňuje doslova prispôsobiť niektoré komponenty podľa vlastného uváženia bez úpravy súborov. A v skutočnosti je to len binárny súbor, ktorý si „nepýta chlieb“.

Poďme teda na helm.sh do sekcie dokumenty/inštalácia a odtiaľ spustite príkaz:

curl -s https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

Potom pridajte úložisko grafov:

helm repo add stable https://kubernetes-charts.storage.googleapis.com/

Teraz nainštalujte komponenty infraštruktúry podľa plánu:

Kontrolér vstupu;
Prometheus;
Grafana;
cert-manager.

Kontrolér vstupu

Prvým komponentom je Kontrolér vstupu - Inštalácia je pomerne jednoduchá a pripravená na použitie hneď po vybalení. Ak to chcete urobiť, prejdite na holého kovu na mieste a odtiaľ spustite príkaz install:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v0.34.1/deploy/static/provider/baremetal/deploy.yaml

V tomto momente sa však „malina“ začala namáhať a narážať na diskové IOPS. Faktom je, že spolu s regulátorom Ingress je nainštalovaný veľký počet zdrojov, robí sa veľa požiadaviek na API, a preto sa veľa údajov zapisuje do atď. Vo všeobecnosti platí, že buď pamäťová karta triedy 10 nie je príliš produktívna, alebo SD karta v podstate na takúto záťaž nestačí. Asi po 5 minútach sa však všetko rozbehlo.

Bol vytvorený priestor názvov a objavil sa v ňom ovládač a všetko, čo potreboval:

root@pi-control:~# kubectl -n ingress-nginx get pod
NAME                                        READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-2hwdx        0/1     Completed   0          31s
ingress-nginx-admission-patch-cp55c         0/1     Completed   0          31s
ingress-nginx-controller-7fd7d8df56-68qp5   1/1     Running     0          48s

Prometheus

Nasledujúce dva komponenty sa dajú celkom jednoducho nainštalovať cez Helm z repo grafov.

Nájdeme to Prometheus, vytvorte menný priestor a nastavte ho na:

helm search repo stable | grep prometheus
kubectl create ns monitoring
helm install prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"}

Štandardne si Prometheus objednáva 2 disky: pre samotné dáta Prometheus a pre dáta AlertManager. Keďže v klastri nebola vytvorená trieda úložiska, disky nebudú usporiadané a moduly sa nespustia. Pri holých kovových inštaláciách Kubernetes zvyčajne používame Ceph rbd, ale v prípade Raspberry Pi je to zjavne prehnané.

Preto si vytvorme jednoduché lokálne úložisko na hostpath. Manifesty PV (persistent volume) pre prometheus-server a prometheus-alertmanager sú spojené do súboru prometheus-pv.yaml в Repozitáre Git s príkladmi pre článok. Adresár pre PV je povinný vopred vytvoríme na disku uzla, ku ktorému chceme pripojiť Prometheus: v príklade je napísané nodeAffinity podľa názvu hostiteľa pi-worker a vytvárajú sa na ňom adresáre /data/localstorage/prometheus-server и /data/localstorage/prometheus-alertmanager.

Stiahnite si (naklonujte) manifest a pridajte ho do Kubernetes:

kubectl create -f prometheus-pv.yaml

V tejto fáze som sa prvýkrát stretol s problémom architektúry ARM. Kube-state-metrics, ktorá je štandardne nainštalovaná v grafe Prometheus, sa odmietla spustiť. Vypísalo to chybu:

root@pi-control:~# kubectl -n monitoring logs prometheus-kube-state-metrics-c65b87574-l66d8
standard_init_linux.go:207: exec user process caused "exec format error"

Faktom je, že kube-state-metrics používa obrázok projektu CoreOS, ktorý nie je zostavený pre ARM:

kubectl -n monitoring get deployments.apps prometheus-kube-state-metrics -o=jsonpath={.spec.template.spec.containers[].image}
quay.io/coreos/kube-state-metrics:v1.9.7

Musel som trochu googliť a nájsť napr. tento obrázok. Ak ho chcete použiť, aktualizujme vydanie, aby ste určili, ktorý obrázok sa má použiť pre metriku kube-state-meter:

helm upgrade prometheus --namespace monitoring stable/prometheus --set server.ingress.enabled=True --set server.ingress.hosts={"prometheus.home.pi"} --set kube-state-metrics.image.repository=carlosedp/kube-state-metrics --set kube-state-metrics.image.tag=v1.9.6

Skontrolujte, či sa všetko začalo:

root@pi-control:~# kubectl -n monitoring get po
NAME                                             READY   STATUS              RESTARTS   AGE
prometheus-alertmanager-df65d99d4-6d27g          2/2     Running             0          5m56s
prometheus-kube-state-metrics-5dc5fd89c6-ztmqr   1/1     Running             0          5m56s
prometheus-node-exporter-49zll                   1/1     Running             0          5m51s
prometheus-node-exporter-vwl44                   1/1     Running             0          4m20s
prometheus-pushgateway-c547cfc87-k28qx           1/1     Running             0          5m56s
prometheus-server-85666fd794-z9qnc               2/2     Running             0          4m52s

Grafana a cert-manager

Pre grafy a dashboardy sme nastavili grafana:

helm install grafana --namespace monitoring stable/grafana  --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}

Na konci výstupu sa nám ukáže, ako získať prístupové heslo:

kubectl get secret --namespace monitoring grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

Na objednávku certifikátov nainštalujeme cert-manager. Ak ho chcete nainštalovať, pozrite si dokumentáciu, ktorý ponúka zodpovedajúce príkazy pre Helm:

helm repo add jetstack https://charts.jetstack.io

helm install 
  cert-manager jetstack/cert-manager 
  --namespace cert-manager 
  --version v0.16.0 
  --set installCRDs=true

Pre certifikáty s vlastným podpisom na domáce použitie je to úplne postačujúce. Ak potrebujete získať to isté Zašifrovať, potom musíte tiež nakonfigurovať vydavateľa klastra. Podrobnosti o tom nájdete v našom článku “SSL certifikáty od Let's Encrypt s cert-managerom v Kubernetes".

Sám som sa rozhodol pre možnosť od príklad v dokumentáciis rozhodnutím, že inscenačná možnosť LE by bola dostatočná. V príklade zmeníme e-mail, uložíme ho do súboru a pridáme do klastra (cert-manager-cluster-issuer.yaml):

kubectl create -f cert-manager-cluster-issuer.yaml

Teraz si môžete objednať certifikát napríklad pre Grafana. To si bude vyžadovať doménu a prístup ku klastru zvonku. Mám doménu a nakonfiguroval som prenos presmerovaním portov 80 a 443 na mojom domácom smerovači v súlade s vytvorenou službou ingress-controller:

kubectl -n ingress-nginx get svc
NAME                                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             NodePort    10.2.206.61    <none>        80:31303/TCP,443:30498/TCP   23d

V tomto prípade sa port 80 preloží na 31303 a port 443 na 30498. (Porty sú generované náhodne, takže vaše budú iné.)

Tu je príklad certifikátu (cert-manager-grafana-certificate.yaml):

apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
  name: grafana
  namespace: monitoring
spec:
  dnsNames:
    - grafana.home.pi
  secretName: grafana-tls
  issuerRef:
    kind: ClusterIssuer
    name: letsencrypt-staging

Pridajte ho do klastra:

kubectl create -f cert-manager-grafana-certificate.yaml

Potom sa objaví zdroj Ingress, prostredníctvom ktorého prebehne overenie Let's Encrypt:

root@pi-control:~# kubectl -n monitoring get ing
NAME                        CLASS    HOSTS                        ADDRESS         PORTS   AGE
cm-acme-http-solver-rkf8l   <none>   grafana.home.pi      192.168.88.31   80      72s
grafana                     <none>   grafana.home.pi      192.168.88.31   80      6d17h
prometheus-server           <none>   prometheus.home.pi   192.168.88.31   80      8d

Po dokončení overenia uvidíme, že zdroj certificate pripravený a vo vyššie uvedenom tajomstve grafana-tls - certifikát a kľúč. Okamžite môžete skontrolovať, kto vydal certifikát:

root@pi-control:~# kubectl -n monitoring get certificate
NAME      READY   SECRET        AGE
grafana   True    grafana-tls   13m

root@pi-control:~# kubectl -n monitoring get secrets grafana-tls -ojsonpath="{.data['tls.crt']}" | base64 -d | openssl x509 -issuer -noout
issuer=CN = Fake LE Intermediate X1

Vráťme sa ku Grafane. Budeme musieť mierne opraviť jeho vydanie Helm zmenou nastavení TLS tak, aby zodpovedali vygenerovanému certifikátu.

Ak to chcete urobiť, stiahnite si graf, upravte ho a aktualizujte ho z miestneho adresára:

helm pull --untar stable/grafana

Úprava v súbore grafana/values.yaml Parametre TLS:

  tls:
    - secretName: grafana-tls
      hosts:
        - grafana.home.pi

Tu môžete okamžite nakonfigurovať nainštalovaný Prometheus ako datasource:

datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Prometheus
      type: prometheus
      url: http://prometheus-server:80
      access: proxy
      isDefault: true

Teraz aktualizujeme graf Grafana z miestneho adresára:

helm upgrade grafana --namespace monitoring ./grafana  --set ingress.enabled=true --set ingress.hosts={"grafana.home.pi"}

Kontrola, čo je v Ingress grafana bol pridaný port 443 a existuje prístup cez HTTPS:

root@pi-control:~# kubectl -n monitoring get ing grafana
NAME      CLASS    HOSTS                     ADDRESS         PORTS     AGE
grafana   <none>   grafana.home.pi           192.168.88.31   80, 443   63m

root@pi-control:~# curl -kI https://grafana.home.pi
HTTP/2 302
server: nginx/1.19.1
date: Tue, 28 Jul 2020 19:01:31 GMT
content-type: text/html; charset=utf-8
cache-control: no-cache
expires: -1
location: /login
pragma: no-cache
set-cookie: redirect_to=%2F; Path=/; HttpOnly; SameSite=Lax
x-frame-options: deny
strict-transport-security: max-age=15724800; includeSubDomains

Ak chcete predviesť Grafana v akcii, môžete si ju stiahnuť a pridať dashboard pre metriky kube-state. Takto to vyzerá:

Odporúčam tiež pridať dashboard pre exportér uzlov: zobrazí podrobne, čo sa deje s „malinami“ (zaťaženie CPU, pamäť, sieť, využitie disku atď.).

Po tomto si myslím klaster je pripravený prijímať a spúšťať aplikácie!

Poznámka k montáži

Existujú minimálne dve možnosti vytvárania aplikácií pre architektúru ARM. Po prvé, môžete stavať na zariadení ARM. Po zhliadnutí aktuálnej likvidácie dvoch Raspberry Pis som si však uvedomil, že by neprežili ani montáž. Objednal som si preto nový Raspberry Pi 4 (je výkonnejší a má až 4 GB pamäte) - plánujem na ňom stavať.

Druhou možnosťou je postaviť multi-oblúkový obraz Dockera na výkonnejšom stroji. Pre toto existuje rozšírenie docker buildx. Ak je aplikácia v kompilovanom jazyku, bude potrebná krížová kompilácia pre ARM. Nebudem popisovať všetky nastavenia pre túto cestu, pretože... To si bude vyžadovať samostatný článok. Implementáciou tohto prístupu je možné dosiahnuť „univerzálne“ obrázky: Docker spustený na stroji ARM si sám automaticky stiahne obrázok zodpovedajúci architektúre.

Záver

Experiment prekonal všetky moje očakávania: [aspoň] „vanilkový“ Kubernetes s potrebným základom sa na ARM cíti dobre a s jeho konfiguráciou vzniklo len niekoľko nuancií.

Samotné Raspberry Pi 3B+ udržujú záťaž na CPU, no ich SD karty sú jasnou prekážkou. Kolegovia navrhli, že v niektorých verziách je možné zaviesť systém z USB, kde môžete pripojiť SSD: potom sa situácia s najväčšou pravdepodobnosťou zlepší.

Tu je príklad zaťaženia CPU pri inštalácii Grafany:

Na experimenty a „vyskúšanie“ podľa môjho názoru klaster Kubernetes na „malinách“ sprostredkuje pocit z prevádzky oveľa lepšie ako rovnaký Minikube, pretože všetky komponenty klastra sú nainštalované a fungujú „ako dospelý“.

V budúcnosti existuje myšlienka pridať do klastra celý cyklus CI/CD, implementovaný výlučne na Raspberry Pi. Budem tiež rád, ak sa niekto podelí o svoje skúsenosti s nastavovaním K8 na AWS Gravitons.

PS Áno, „výroba“ môže byť bližšie, ako som si myslel: