🥇CRI-O als vervanging voor Docker als runtime-omgeving voor Kubernetes: configureren op CentOS 8

Hallo! Mijn naam is Sergei, ik ben DevOps bij Surf. De DevOps-afdeling bij Surf heeft als doel niet alleen de samenwerking tussen specialisten te verbeteren en werkprocessen te integreren, maar ook actief onderzoek te doen en relevante technologieën in te voeren, zowel in onze eigen infrastructuur als in die van de klant.

Hieronder zal ik kort de veranderingen in de technologie-stack voor containers beschrijven, waarmee we werden geconfronteerd tijdens het bestuderen van de distributie. CentOS 8 en wat CRI-O is en hoe je snel een uitvoeringsomgeving kunt instellen met behulp daarvan. Kubernetes.

Waarom Docker niet in de standaardlevering van CentOS 8 is opgenomen.

Na het installeren van de nieuwste grote releases RHEL 8 of CentOS 8 kan men niet om het feit heen: in deze distributies en officiële repositories ontbreekt de applicatie Docker, die ideologisch en functioneel wordt vervangen door de pakketten Podman, Buildah (aanwezig in de distributie als standaard) en CRI-O. Dit is te wijten aan de praktische implementatie van standaarden die onder andere door Red Hat worden ontwikkeld in het kader van het Open Container Initiative (OCI).

Het doel van OCI, dat deel uitmaakt van The Linux Foundation, is het creëren van open industriestandaarden voor containerformaten en uitvoeringsomgevingen die meerdere doelen dienen. Ten eerste, ze mogen niet in tegenspraak zijn met de filosofie van Linux (bijvoorbeeld in die zin dat elk programma een specifieke taak moet uitvoeren, terwijl Docker het een soort alles-in-één oplossing is). Ten tweede zouden ze alle bestaande tekortkomingen in software moeten verhelpen. DockerTen derde zouden ze volledig compatibel moeten zijn met de zakelijke eisen die door toonaangevende commerciële platforms worden gesteld voor de implementatie, het beheer en de ondersteuning van gecontaineriseerde applicaties (bijvoorbeeld Red Hat OpenShift).

Nadelen Docker en de voordelen van de nieuwe software zijn al vrij gedetailleerd beschreven in dit artikel, en een gedetailleerde beschrijving van alles wat wordt aangeboden binnen het OCI-project en de architectonische kenmerken ervan zijn te vinden in de officiële documentatie en artikelen, zowel van Red Hat zelf (redelijk goede artikel op de Red Hat blog), als van externe worden vermeld.

Het is belangrijk op te merken welke functionaliteit de componenten van de aangeboden stack hebben:

Podman — directe interactie met containers en image-opslag via het proces runC;
Buildah — het bouwen en uploaden van images naar de registry;
CRI-O — een uitvoeringsomgeving voor containerorkestratiesystemen (bijvoorbeeld Kubernetes).

Ik denk dat het zinvol is hier een overzicht te geven van de interacties tussen de componenten van de stack. Kubernetes c runC en low-level bibliotheken met behulp van CRI-O:

CRI-O en Kubernetes dezelfde release- en ondersteuningscyclus aanhouden (de compatibiliteitsmatrix is heel eenvoudig: de majeure versies Kubernetes en CRI-O komen overeen), en dat geeft ons het recht om maximale stabiliteit in alle gebruiksscenario's te verwachten (hier komt de relatieve lichtheid CRI-O vergeleken met Docker vanwege de doelgerichte beperking van functionaliteit).

Bij de installatie van Kubernetes de 'juiste manier' (tenzij OCI natuurlijk iets anders zegt) met behulp van CRI-O en een werkende opdracht krijgen. CentOS 8 we hebben enkele kleine problemen ondervonden, maar die hebben we succesvol overwonnen. Ik deel graag de installatie- en configuratie-instructies met u, die in totaal maximaal 10 minuten in beslag nemen.

Hoe Kubernetes te implementeren op CentOS 8 met behulp van de CRI-O omgeving

Vereisten: minimaal één host (2 cores, 4 GB RAM, opslag van minimaal 15 GB) met geïnstalleerde CentOS 8 (de installatieprofiel 'Server' wordt aanbevolen), evenals een record daarvoor in de lokale DNS (in het ergste geval kunt u een record in /etc/hosts gebruiken). Vergeet niet swap uit te schakelen..

Voer alle bewerkingen op de host uit als gebruiker root, wees voorzichtig.

In de eerste stap configuren we het besturingssysteem, installeren en configureren we de vereiste afhankelijkheden voor CRI-O.
- We werken het besturingssysteem bij:
```
dnf -y update
```
- Vervolgens moet de firewall en SELinux worden ingesteld. Hier hangt alles af van de omgeving waarin onze host of hosts zullen draaien. U kunt de firewall configureren op basis van de aanbevelingen uit de documentatie, of als u zich in een vertrouwd netwerk bevindt of een externe firewall gebruikt, de standaardzone wijzigen naar vertrouwd of de firewall uitschakelen:
```
firewall-cmd --set-default-zone trusted

firewall-cmd --reload
```
  Om de firewall uit te schakelen kunt u de volgende opdracht gebruiken:
```
systemctl disable --now firewalld
```
  SELinux moet worden uitgeschakeld of in de 'permissive' modus worden gezet:
```
setenforce 0

sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
- we laden de benodigde kernelmodules en pakketten, en configureren de automatische invoer van de module 'br_netfilter' bij het opstarten van het systeem:
```
modprobe overlay

modprobe br_netfilter

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

dnf -y install iproute-tc
```
- Om packet forwarding te activeren en het verkeer correct te verwerken, zullen we de bijbehorende instellingen maken:
```
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
```
  We passen de gemaakte instellingen toe:
```
sysctl --system
```
- We stellen de vereiste versie in CRI-O (hoofdversie CRI-O, zoals eerder vermeld, komt overeen met de vereiste versie Kubernetes), aangezien de laatste stabiele versie Kubernetes op dit moment 1.18 is:
```
export REQUIRED_VERSION=1.18
```
  We voegen de vereiste repositories toe:
```
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
```
- Nu kunnen we installeren CRI-O:
```
dnf -y install cri-o
```
  Let op het eerste punt dat we tegenkomen tijdens de installatie: het is nodig om de configuratie aan te passen CRI-O voordat we de service starten, omdat het vereiste onderdeel conmon op een andere locatie is dan opgegeven:
```
sed -i 's//usr/libexec/crio/conmon//usr/bin/conmon/' /etc/crio/crio.conf
```
  Nu kunnen we de daemon activeren en starten CRI-O:
```
systemctl enable --now crio
```
  We kunnen de status van de daemon controleren:
```
systemctl status crio
```
Installatie en activatie Kubernetes.
- We voegen de vereiste repository toe:
```
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
```
  Nu kunnen we installeren Kubernetes (versies 1.18, zoals eerder vermeld):
```
dnf install -y kubelet-1.18* kubeadm-1.18* kubectl-1.18* --disableexcludes=kubernetes
```
- Een tweede belangrijk punt: aangezien we de daemon niet gebruiken Docker, maar de daemon CRI-O, voordat we starten en initialiseren Kubernetes moeten we de juiste instellingen in het configuratiebestand /var/lib/kubelet/config.yaml aanbrengen, nadat we de benodigde directory hebben aangemaakt:
```
mkdir /var/lib/kubelet

cat < /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF
```
- Een derde belangrijk punt dat we tegenkomen tijdens de installatie: hoewel we de gebruikte driver hebben opgegeven cgroup, en de configuratie via meegegeven argumenten kubelet verouderd is (wat duidelijk in de documentatie staat), moeten we argumenten aan het bestand toevoegen, anders wordt ons cluster niet geinitialiseerd:
```
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
```
- Nu kunnen we de daemon activeren kubelet:
```
sudo systemctl inschakelen --nu kubelet
```
  Om te configureren besturingselement of werknemer knooppunten in enkele minuten, kunt u gebruikmaken van dit script.
Het is tijd om ons cluster te initialiseren.
- Voer de volgende opdracht uit om het cluster te initialiseren:
```
kubeadm init --pod-network-cidr=10.244.0.0/16
```
  Zorg ervoor dat je de opdracht voor het aansluiten bij het cluster "kubeadm join …" noteert die wordt aangeboden aan het einde van de uitvoer, of op zijn minst de vermelde tokens.
- Laten we een plug-in (CNI) installeren voor de werking van het Pod-netwerk. Ik raad aan om , dat de standaard API-set van Kubernetes aanzienlijk uitbreidt op het gebied van netwerkinstellingen.. Mogelijk heeft de meer populaire Flannel compatibiliteitsproblemen met nftables, en , dat de standaard API-set van Kubernetes aanzienlijk uitbreidt op het gebied van netwerkinstellingen. is de enige implementatie van CNI die wordt aanbevolen en volledig getest door het project Kubernetes:
```
kubectl --kubeconfig /etc/kubernetes/admin.conf toepassen -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 
```
- Om de werkerknooppunt aan ons cluster te verbinden, moet het worden geconfigureerd volgens de instructies 1 en 2, of gebruikmaken van script, voer vervolgens de opdracht uit uit de uitvoer "kubeadm init …" die we in de vorige stap hebben genoteerd:
```
kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
    --discovery-token-ca-cert-hash $TOKEN_HASH
```
- Laten we controleren of ons cluster is geïnitialiseerd en operationeel is:
```
kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
```
Klaar! Je kunt al workloads op je K8s-cluster plaatsen.

Wat wacht ons te wachten

Ik hoop dat de bovenstaande instructie je wat tijd en zenuwen heeft bespaard.
De uitkomsten van de processen in de industrie hangen vaak af van hoe ze worden ontvangen door de meerderheid van de eindgebruikers en ontwikkelaars van andere software in de desbetreffende niche. Het is nog niet helemaal duidelijk tot welke uitkomst de OCI-initiatieven in enkele jaren zullen leiden, maar we zullen dit met plezier volgen. Je kunt nu meteen je mening delen in de comments.

Blijf op de hoogte!

Dit artikel is ontstaan dankzij de volgende bronnen: