🥇CRI-O jako náhrada Dockeru jako prostředí pro spuštění Kubernetes: nastavení na CentOS 8

Ahoj! Jmenuji se Sergej, jsem DevOps ve společnosti Surf. DevOps oddělení ve společnosti Surf si klade za cíl nejen zajištění spolupráce mezi specialisty a integraci pracovních procesů, ale také aktivní výzkum a zavádění aktuálních technologií jak do vlastní infrastruktury, tak do infrastruktury zákazníka.

Níže vám trochu přiblížím změny v technologickém stacku pro kontejnery, které jsme zaznamenali při studiu distribuce CentOS 8 a o tom, co je to CRI-O a jak rychle nastavit s jeho pomocí vykonávací prostředí pro Kubernetes.

Proč Docker chybí ve standardní verzi CentOS 8

Po instalaci posledních velkých verzí RHEL 8 nebo CentOS 8 nelze si nevšimnout: v těchto distribucích a oficiálních repozitářích chybí aplikace Docker, které ideologicky a funkčně nahrazují balíčky Podman, Buildah (jsou přítomny ve výchozí distribuci) a CRI-O. To souvisí s praktickou realizací standardů, které byly vyvinuty, mimo jiné, společností Red Hat v rámci projektu Open Container Initiative (OCI).

Cílem OCI, což je součástí The Linux Foundation, je vytváření otevřených průmyslových standardů pro formáty a vykonávací prostředí kontejnerů, které by splnily několik úkolů. Za prvé, neměly by být v rozporu s filosofií Linuxu (například v té její části, že každá aplikace by měla vykonávat nějakou jednu činnost, a Docker představuje cosi jako kombinovaný nástroj vše v jednom). Za druhé, měly by odstranit všechny existující nedostatky v softwaru Docker. Za třetí, měly by být plně kompatibilní s obchodními požadavky, které kladou přední komerční platformy pro nasazení, správu a údržbu kontejnerizovaných aplikací (například Red Hat OpenShift).

Nevýhody Docker a výhody nového softwaru byly již poměrně podrobně popsány v tomto článku, a s podrobným popisem všeho nabízeného v rámci projektu OCI a jeho architektonických zvláštností lze seznámit v oficiální dokumentaci a článcích jak od samotného Red Hat (dobrý neaktuální statistika v Red Hat blogu), tak v externích recenzích.

Je důležité zdůraznit, jakou funkcionalitu mají komponenty nabízeného stacku:

Podman — přímá interakce s kontejnery a úložištěm obrazů přes proces runC;
Buildah — sestavení a nahrání obrazů do registru;
CRI-O — vykonávací prostředí pro systémy orchestrace kontejnerů (například Kubernetes).

Myslím, že pro pochopení celkové schéma interakce mezi komponenty stacku je rozumné uvést zde schéma vazeb Kubernetes s runC a nízkoúrovňovými knihovnami za použití CRI-O:

CRI-O a Kubernetes dodržují stejný cyklus vydávání a podpory (matice kompatibility je velmi jednoduchá: major verze Kubernetes a CRI-O se shodují), a to, s ohledem na orientaci na kompletní a komplexní testování práce tohoto stacku vývojáři, nám dává právo očekávat maximální dosažitelnou stabilitu v provozu při jakýchkoli scénářích použití (zde může být na prospěch i relativní lehkost CRI-O ve srovnání s Docker díky cílenému omezení funkcionality).

Při instalaci Kubernetes "right way" způsobem (podle OCI, samozřejmě) za použití CRI-O na CentOS 8 jsme se setkali s malými obtížemi, které jsme však úspěšně překonali. Budu rád, že se s vámi mohu podělit o pokyny k instalaci a nastavení, které v souhrnu zabere maximálně 10 minut.

Jak nasadit Kubernetes na CentOS 8 s použitím prostředí CRI-O

Předpoklady: mít alespoň jeden host (2 jádra, 4 GB RAM, úložiště minimálně 15 GB) s nainstalovanou CentOS 8 (doporučuje se profil instalace "Server"), stejně jako záznam pro něj v místním DNS (v krajním případě lze použít záznam v /etc/hosts). A nezapomeňte vypnout swap.

Všechny operace na hostu provádíme jménem uživatele root, buďte opatrní.

V prvním kroku nastavíme OS, nainstalujeme a nastavíme předběžné závislosti pro CRI-O.
- Aktualizujeme OS:
```
dnf -y update
```
- Dále je nutné nastavit firewall a SELinux. Zde záleží na prostředí, ve kterém budou pracovat náš host nebo hosty. Můžete buď nastavit firewall podle doporučení z dokumentaci, nebo pokud jste ve důvěryhodné síti nebo používáte externí firewall, změnit výchozí zónu na důvěryhodnou nebo firewall vypnout:
```
firewall-cmd --set-default-zone trusted

firewall-cmd --reload
```
  Pro vypnutí firewallu můžete použít následující příkaz:
```
systemctl disable --now firewalld
```
  SELinux je nutné vypnout nebo přepnout do režimu "permissive":
```
setenforce 0

sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
- načteme potřebné jádrové moduly a balíčky, nastavíme automatické načítání modulu "br_netfilter" při spuštění systému:
```
modprobe overlay

modprobe br_netfilter

echo "br_netfilter" >> /etc/modules-load.d/br_netfilter.conf

dnf -y install iproute-tc
```
- Pro aktivaci přesměrování paketů a správné zpracování provozu provedeme příslušná nastavení:
```
cat > /etc/sysctl.d/99-kubernetes-cri.conf <<EOF
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
```
  Aplikujeme provedená nastavení:
```
sysctl --system
```
- Nastavíme požadovanou verzi CRI-O (hlavní verze CRI-O, jak již bylo zmíněno, odpovídají požadované verzi Kubernetes), protože poslední stabilní verze Kubernetes v současné době je 1.18:
```
export REQUIRED_VERSION=1.18
```
  Přidáme potřebné repozitáře:
```
dnf -y install 'dnf-command(copr)'

dnf -y copr enable rhcontainerbot/container-selinux

curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable/CentOS_8/devel:kubic:libcontainers:stable.repo

curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo
```
- Nyní můžeme nainstalovat CRI-O:
```
dnf -y install cri-o
```
  Všimněte si prvního detailu, s nímž se setkáváme během instalace: je potřeba upravit konfiguraci CRI-O před spuštěním služby, protože požadovaná komponenta conmon má odlišné umístění než je uvedeno:
```
sed -i 's//usr/libexec/crio/conmon//usr/bin/conmon/' /etc/crio/crio.conf
```
  Nyní lze aktivovat a spustit démon CRI-O:
```
systemctl enable --now crio
```
  Můžete zkontrolovat stav démonu:
```
systemctl status crio
```
Instalace a aktivace Kubernetes.
- Přidáme požadovaný repozitář:
```
cat < /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-$basearch
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
exclude=kubelet kubeadm kubectl
EOF
```
  Nyní můžeme nainstalovat Kubernetes (verze 1.18, jak již bylo uvedeno výše):
```
dnf install -y kubelet-1.18* kubeadm-1.18* kubectl-1.18* --disableexcludes=kubernetes
```
- Druhý důležitý detail: protože nepoužíváme démon Docker, ale používáme démon CRI-O, před spuštěním a inicializací Kubernetes je potřeba provést příslušná nastavení v konfiguračním souboru /var/lib/kubelet/config.yaml, přičemž je třeba nejprve vytvořit požadovaný adresář:
```
mkdir /var/lib/kubelet

cat < /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF
```
- Třetí důležitý moment, se kterým se setkáváme během instalace: přestože jsme uvedli používaný ovladač cgroup, a jeho nastavení prostřednictvím argumentů předávaných kubelet je zastaralé (což je výslovně uvedeno v dokumentaci), musíme do souboru přidat argumenty, jinak se náš cluster nebuď inicializován:
```
cat /dev/null > /etc/sysconfig/kubelet

cat < /etc/sysconfig/kubelet
KUBELET_EXTRA_ARGS=--container-runtime=remote --cgroup-driver=systemd --container-runtime-endpoint='unix:///var/run/crio/crio.sock'
EOF
```
- Nyní můžeme aktivovat démon kubelet:
```
sudo systemctl enable --now kubelet
```
  Abychom nakonfigurovali řídicí uzel nebo pracovníky uzly za pár minut, můžete využít tento skript.
Je čas inicializovat náš klastr.
- Pro inicializaci klastru spusťte příkaz:
```
kubeadm init --pod-network-cidr=10.244.0.0/16
```
  Určitě si poznamenejte příkaz pro připojení ke klastru „kubeadm join ...“, který se nabízí na konci výstupu, nebo alespoň uvedené tokeny.
- Nainstalujeme plugin (CNI) pro práci s Pod sítí. Doporučuji použít Calico. Možná populárnější Flannel má problémy s kompatibilitou s nftables, a to je Calico — jediná implementace CNI, doporučená a plně testovaná projektem Kubernetes:
```
kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 
```
- Pro připojení pracovní uzlu k našemu klastru je nutné jej nastavit podle bodů 1 a 2, nebo využít skript, poté spusťte příkaz z výstupu „kubeadm init ...“, který jsme si poznamenali v předchozím kroku:
```
kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
    --discovery-token-ca-cert-hash $TOKEN_HASH
```
- Ověříme, že náš klastr byl inicializován a začal fungovat:
```
kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
```
Hotovo! Již můžete nasazovat na vašem K8s klastru zátěž.

Co nás čeká dál

Doufám, že tento návod vám pomohl ušetřit trochu času a nervů.
Vývoj procesů v odvětví často závisí na tom, jak je přijímá většina koncových uživatelů a vývojářů dalšího softwaru v dané oblasti. Není ještě jasné, k jakému výsledku vedou iniciativy OCI za několik let, ale rádi se na to podíváme. Svůj názor můžete sdílet hned teď v komentářích.

Zůstaňte na příjmu!

Tento článek vznikl díky následujícím zdrojům: