🥇CRI-O as a replacement for Docker as the runtime environment for Kubernetes: setup on CentOS 8

Tere! Minu nimi on Sergei, ma olen DevOps Surfis. Surfis on DevOps-osakonna eesmärk mitte ainult luua koostööd spetsialistide vahel ja integreerida tööprotsesse, vaid ka aktiivselt uurida ja rakendada uusimaid tehnoloogiaid nii oma infrastruktuuri kui ka kliendi infrastruktuuri.

Allpool räägin natuke tehnoloogilise kihi muudatustest konteinerite osas, millega kohtusime distributsiooni uurimisel. CentOS 8 ja sellest, mis asi on CRI-O ja kuidas kiiresti seadistada sellega täitevkeskkond Kubernetes.

Miks Docker ei ole CentOS 8 standardsetes tarnetes

Pärast viimaseid suuri väljaandeid RHEL 8 või CentOS 8 ei saa mitte märkamatuks jääda, et nendes distributsioonides ja ametlikes hoidlatest puudub rakendus Docker, mida ideoloogiliselt ja funktsionaalselt asendavad pakid Podman, Buildah (mis on distributsioonis vaikimisi olemas) ja CRI-O. See on seotud standardite praktilise elluviimisega, mida arendavad sealhulgas ja Red Hat Open Container Initiative'i (OCI) raames.

OCI, mis on osa The Linux Foundationist, eesmärk on luua avatud tööstusstandardeid konteinerite formaatide ja täitevkeskkonna jaoks, mis lahendaksid mitmeid probleeme. Esiteks, nad ei tohiks olla vastuolus Linuxi filosoofiaga (näiteks et iga programm peaks tegema ainult ühte asja, ja Docker on justkui tegevuste kombain). Teiseks, nad peaksid olema võimelised kõrvaldamiseks kõiki tarkvara puudusi. DockerKolmandaks, nad peaksid olema täielikult ühilduvad juhtivate kaubandusplatvormide ärinõuetega, mis on esitatud konteineriseeritud rakenduste juurutamiseks, haldamiseks ja hooldamiseks (näiteks Red Hat OpenShift).

Puudused Docker ja uue tarkvara eelised on juba üsna põhjalikult kirjeldatud selles artiklis, ning projekti OCI raames pakutava tarkvara ja selle arhitektuuri eripära kohta saab lähemalt lugeda ametlikest dokumentatsioonidest ja artiklitest, nii Red Hat´ilt (hea artikkel Red Hat blogis) kui ka kolmandatelt osapooltelt. mainitakse.

Oluline on märkida, milliseid funktsioone pakutava kihi komponendid omavad:

Podman – otsene koostöö konteinerite ja pildihoidlate vahel läbi runC protsessi;
Buildah – piltide koostamine ja registrisse laadimine;
CRI-O – täitevkeskkond konteinerite orkestreerimissüsteemidele (näiteks Kubernetes).

Ma arvan, et kogu stacki komponentide vahelise suhtluse üldise skeemi mõistmiseks on mõistlik siin näidata sidemete skeemi Kubernetes c runC ja madalama taseme raamatukogudega kasutades CRI-O:

CRI-O ja Kubernetes peavad järgima sama väljaandmis- ja toetustsüklit (ühilduvuse maatriks on väga lihtne: suuremad versioonid Kubernetes ja CRI-O ühtivad), ja arvestades suunatud lähenemist kogu ja põhjaliku testimise tagamisel arendajate poolt, annab see meile õiguse oodata maksimaalselt saavutatavat stabiilsust igasugustes kasutusstsenaariumites (siin aitab ka suhteliselt kerge CRI-O võrreldes Docker funktsionaalsuse sihipärase piiramisest).

Paigaldamisel Kubernetes «õige tee» moel (OCI arvates, muidugi) kasutades CRI-O . Tundub, et CentOS 8 kohtasime väikeseid raskusi, kuid need suutsime edukalt ületada. Olen valmis jagama teiega installatsiooni ja seadistamise juhendit, mis kokku võtab vaid 10 minutit.

Kuidas käivitada Kubernetes CentOS 8-s kasutades CRI-O keskkonda

Eeltingimused: vähemalt ühe võõrustaja olemasolu (2 tuuma, 4 GB RAM, vähemalt 15 GB salvestusruumi), millel on installitud CentOS 8 (soovitatav on installiprofiil «Server»), samuti selle jaoks kirje kohalikus DNS-is (kui hädavajalik, saab kasutada kirjet /etc/hosts). Ja ärge unustage swap välja lülitada.

Kõiki toiminguid võõrustajas teostame root-kasutaja nime all, olge ettevaatlik.

Esimesel sammul seadistame operatsioonisüsteemi, installime ja seadistame CRI-O eeltingimused.
- Uuendame operatsioonisüsteemi:
```
dnf -y update
```
- Seejärel tuleb seadistada tulemüür ja SELinux. Siin sõltub kõik meie võõrustaja või võõrustajate töötamiskeskkonnast. Saate kas seadistada tulemüüri vastavalt soovitustele dokumentatsioon, või kui olete usaldusväärses võrgus või kasutate kolmanda osapoole tulemüüri, muuta vaikimisi tsooni usaldusväärseks või tulemüüri välja lülitada:
```
firewall-cmd --set-default-zone trusted

firewall-cmd --reload
```
  Tulemüüri väljalülitamiseks saate kasutada järgmist käsku:
```
systemctl disable --now firewalld
```
  SELinux tuleb välja lülitada või viia «permissive» režiimi:
```
setenforce 0

sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
- laadime vajalikke kernelimooduleid ja pakette ning seadistame moduliga «br_netfilter» automaatse laadimise süsteemi käivitamisel:
```
modprobe overlay

modprobe br_netfilter

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

dnf -y install iproute-tc
```
- Pakettide forwardimise aktiveerimiseks ja liikluse korrektseks töötlemiseks teeme vajalikud seaded:
```
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
```
  Rakendame tehtud seadeid:
```
sysctl --system
```
- Seame vajaliku versiooni CRI-O (peamine versioon CRI-O, nagu juba mainitud, vastab nõutavale versioonile Kubernetes), sest viimase stabiilse versiooni Kubernetes praegu on 1.18:
```
export REQUIRED_VERSION=1.18
```
  Lisame vajalikud hoidlad:
```
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
```
- Nüüd saame installida CRI-O:
```
dnf -y install cri-o
```
  Juhime tähelepanu esimesel nüansil, millega me installimise käigus kokku puutume: konfiguratsiooni redigeerimine on vajalik CRI-O enne teenuse käivitamist, kuna nõutud komponent conmon on teises asukohas:
```
sed -i 's//usr/libexec/crio/conmon//usr/bin/conmon/' /etc/crio/crio.conf
```
  Nüüd saab aktiveerida ja käivitada daemon'i CRI-O:
```
systemctl enable --now crio
```
  Saame kontrollida daemon'i staatust:
```
systemctl status crio
```
Installimine ja aktiveerimine Kubernetes.
- Lisame vajaliku hoidla:
```
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
```
  Nüüd saame installida Kubernetes (versioonid 1.18, nagu eelnevalt mainitud):
```
dnf install -y kubelet-1.18* kubeadm-1.18* kubectl-1.18* --disableexcludes=kubernetes
```
- Teine oluline nüanss: kuna me ei kasuta daemon'i Docker, vaid kasutame daemon'i CRI-O, enne käivitamist ja initsialiseerimist Kubernetes on vajalik teha vastavad seaded konfiguratsioonifailis /var/lib/kubelet/config.yaml, enne tuleb luua vajalik kataloog:
```
mkdir /var/lib/kubelet

cat < /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF
```
- Kolmas oluline punkt, millega me installimise käigus kokku puutume: hoolimata sellest, et oleme määranud kasutatava draiveri cgroup, ja selle seadistamine on argumentide kaudu, mis on edastatud kubelet aegunud (mis on otse dokumentatsioonis märgitud), peame faili lisama argumendid, vastasel juhul ei initsialiseeru meie klasster:
```
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
```
- Nüüd saame deemonit aktiveerida kubelet:
```
sudo systemctl enable --now kubelet
```
  Selle seadistamiseks kontrollplaan või töötlusmasin päringud vaid mõne minutiga, saate kasutada seda skripti.
On aeg meie klaster initsialiseerida.
- Klusteri initsialiseerimiseks käivitage käsk:
```
kubeadm init --pod-network-cidr=10.244.0.0/16
```
  Kohustuslik on üles kirjutada klastrisse liitumise käsk "kubeadm join …", mida pakutakse kasutada väljundi lõpus, või vähemalt antud tokenid.
- Paigaldame CNI plugina Pod võrgu tööks. Soovitan kasutada Calico. Võib-olla on populaarsem Flannel on ühilduvusprobleemidega nftables, ja Calico on ainus CNI rakendus, mida projekt soovitab ja mis on täielikult testitud Kubernetes:
```
kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 
```
- Töötlusmasina liitmiseks meie klastri peab selle seadistama vastavalt juhendile punktides 1 ja 2 või kasutama skripti, seejärel käivitage väljundis "kubeadm init …" käsk, mille kirjutasime eelmisel etapil:
```
kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
    --discovery-token-ca-cert-hash $TOKEN_HASH
```
- Kontrollime, kas meie klaster on initsialiseeritud ja töötab:
```
kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
```
Valmis! Saate juba oma K8s klastris kasulikku koormust paigutada.

Mis meid ees ootab

Loodan, et ülaltoodud juhend aitas teil kokku hoida veidi aega ja närve.
Tööstuses toimuva välja arenemine sõltub sageli sellest, kuidas peamine leibkond vastab lõppkasutajate ja muudelt tarkvaraarendajatelt sihtrühmas. Hetkel ei ole veel selge, kuhu OCI algatused mõne aasta pärast viivad, kuid me jälgime seda hea meelega. Oma arvamust saate jagada kohe kommentaarides.

Jälgige meid!

See artikkel ilmus tänu järgmistele allikatele: