🥇CRI-O als Ersatz für Docker als Ausführungsumgebung für Kubernetes: Einrichtung auf CentOS 8

Hallo! Mein Name ist Sergey, ich bin DevOps bei Surf. Das DevOps-Team bei Surf hat sich nicht nur die Kommunikation zwischen den Spezialisten und die Integration von Arbeitsprozessen zur Aufgabe gemacht, sondern führt auch aktive Forschungen und implementiert aktuelle Technologien sowohl in unsere Infrastruktur als auch in die Infrastruktur der Kunden.

Im Folgenden werde ich etwas über die Änderungen im technologischen Stack für Container erzählen, auf die wir bei der Untersuchung der Distribution gestoßen sind. CentOS 8 und was CRI-O ist und wie man damit schnell eine Ausführungsumgebung für Kubernetes.

Warum Docker in der Standardauslieferung von CentOS 8 fehlt

Nach der Installation der letzten großen Releases RHEL 8 oder CentOS 8 fällt auf, dass in diesen Distributionen und offiziellen Repositories die Anwendung Dockerfehlt, die ideologisch und funktional durch die Pakete ersetzt werden Podman, Buildah (die standardmäßig in der Distribution vorhanden sind) und CRI-O. Dies hängt mit der praktischen Umsetzung der Standards zusammen, die unter anderem von Red Hat im Rahmen des Open Container Initiative (OCI)-Projekts entwickelt werden.

Ziel von OCI, einem Teil der Linux Foundation, ist die Schaffung offener Industriestandards für Containerformate und -laufumgebungen, die mehrere Aufgaben gleichzeitig lösen. Erstens sollten sie der Philosophie von Linux nicht widersprechen (zum Beispiel in der Hinsicht, dass jedes Programm eine einzige Aufgabe erfüllen sollte, und Docker im Grunde genommen eine Art All-in-One-Lösung darstellen). Zweitens sollten sie alle bestehenden Mängel in der Software beseitigen Docker. Drittens sollten sie vollständig mit den geschäftlichen Anforderungen übereinstimmen, die von führenden kommerziellen Plattformen zur Bereitstellung, Verwaltung und Wartung containerisierter Anwendungen gestellt werden (zum Beispiel Red Hat OpenShift).

Nachteile Docker Die Vorzüge der neuen Software wurden bereits recht detailliert in in diesem Artikel, und eine detaillierte Beschreibung des gesamten im Rahmen des OCI-Projekts angebotenen Software-Stacks sowie seiner architektonischen Besonderheiten finden Sie in der offiziellen Dokumentation und in Artikeln sowohl von Red Hat selbst (eine gute Artikel im Red Hat Blog), als auch von Drittanbietern In Rezensionen.

Es ist wichtig zu beachten, welche Funktionalität die Komponenten des angebotenen Stacks haben:

Podman — direkte Interaktion mit Containern und Image-Speichern über den runC-Prozess;
Buildah — Erstellen und Hochladen von Images in ein Registry;
CRI-O — Ausführungsumgebung für Container-Orchestrierungssysteme (z. B. Kubernetes).

Ich denke, es ist sinnvoll, hier ein Diagramm der Verbindungen zwischen den Komponenten des Stacks zur besseren Verständlichkeit zu zeigen. Kubernetes c runC und Low-Level-Bibliotheken unter Verwendung von CRI-O:

CRI-O und Kubernetes halten sich an denselben Veröffentlichungs- und Unterstützungskreislauf (die Kompatibilitätsmatrix ist sehr einfach: Hauptversionen Kubernetes und CRI-O stimmen überein), und das, zusammen mit dem Ziel einer umfassenden und vollständigen Testung der Funktionalität dieses Stacks durch die Entwickler, gibt uns das Recht, die maximal erreichbare Stabilität in der Nutzung unter allen Anwendungsszenarien zu erwarten (hier kommt auch das relative Leichtgewicht CRI-O im Vergleich zu Docker zum Tragen, bedingt durch die gezielte Einschränkung der Funktionalität).

Bei der Installation von Kubernetes auf die "richtige Art" (zumindest nach Meinung der OCI) unter Verwendung von CRI-O findet man CentOS 8 Wir sind auf einige kleine Schwierigkeiten gestoßen, die wir jedoch erfolgreich überwunden haben. Ich freue mich darauf, Ihnen eine Anleitung zur Installation und Konfiguration zur Verfügung zu stellen, die insgesamt nicht länger als 10 Minuten in Anspruch nehmen wird.

So richten Sie Kubernetes auf CentOS 8 mit der CRI-O-Umgebung ein

Voraussetzungen: mindestens ein Host (2 Kerne, 4 GB RAM, Speicher mit mindestens 15 GB) mit installiertem CentOS 8 (empfohlen wird das Installationsprofil „Server“), sowie Einträge für ihn im lokalen DNS (im Notfall kann auch ein Eintrag in /etc/hosts genügen). Und vergessen Sie nicht, Swap zu deaktivieren..

Alle Operationen auf dem Host werden als Benutzer root ausgeführt, bitte seien Sie vorsichtig.

Im ersten Schritt richten wir das Betriebssystem ein und installieren sowie konfigurieren die erforderlichen Abhängigkeiten für CRI-O.
- Wir aktualisieren das Betriebssystem:
```
dnf -y update
```
- Als Nächstes müssen Sie die Firewall und SELinux konfigurieren. Hier hängt alles von der Umgebung ab, in der unser Host oder unsere Hosts arbeiten werden. Sie können entweder die Firewall gemäß den Empfehlungen aus Dokumentation., oder, falls Sie sich in einem vertrauenswürdigen Netzwerk befinden oder eine externe Firewall verwenden, die Standardzone auf vertrauenswürdig ändern oder die Firewall deaktivieren:
```
firewall-cmd --set-default-zone trusted

firewall-cmd --reload
```
  Um die Firewall zu deaktivieren, können Sie den folgenden Befehl verwenden:
```
systemctl disable --now firewalld
```
  SELinux muss entweder deaktiviert oder in den Modus „permissive“ versetzt werden:
```
setenforce 0

sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
- Wir laden die erforderlichen Kernel-Module und Pakete herunter und konfigurieren das automatische Laden des Moduls „br_netfilter“ beim Systemstart:
```
modprobe overlay

modprobe br_netfilter

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

dnf -y install iproute-tc
```
- Um die Weiterleitung von Paketen zu aktivieren und den Datenverkehr korrekt zu verarbeiten, nehmen wir die entsprechenden Einstellungen vor:
```
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
```
  Wir wenden die vorgenommene Einstellungen an:
```
sysctl --system
```
- Wir legen die benötigte Version fest CRI-O (Hauptversion CRI-O, wie bereits erwähnt, entspricht der erforderlichen Version Kubernetes), da die letzte stabile Version Kubernetes derzeit 1.18 beträgt:
```
export REQUIRED_VERSION=1.18
```
  Wir fügen die erforderlichen Repositorys hinzu:
```
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
```
- Jetzt können wir installieren CRI-O:
```
dnf -y install cri-o
```
  Beachten Sie den ersten Punkt, der während der Installation auftritt: Es ist erforderlich, die Konfiguration zu bearbeiten. CRI-O vor dem Start des Dienstes, da der erforderliche Bestandteil conmon einen anderen Speicherort hat als angegeben:
```
sed -i 's//usr/libexec/crio/conmon//usr/bin/conmon/' /etc/crio/crio.conf
```
  Jetzt kann der Daemon aktiviert und gestartet werden CRI-O:
```
systemctl enable --now crio
```
  Der Status des Daemons kann überprüft werden:
```
systemctl status crio
```
Installation und Aktivierung Kubernetes.
- Fügen wir das erforderliche Repository hinzu:
```
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
```
  Jetzt können wir installieren Kubernetes (Versionen 1.18, wie oben angegeben):
```
dnf install -y kubelet-1.18* kubeadm-1.18* kubectl-1.18* --disableexcludes=kubernetes
```
- Ein weiterer wichtiger Punkt: da wir keinen Daemon verwenden Docker, sondern einen Daemon verwenden CRI-O, vor dem Start und der Initialisierung Kubernetes müssen die entsprechenden Einstellungen in die Konfigurationsdatei /var/lib/kubelet/config.yaml eingetragen werden, nachdem das erforderliche Verzeichnis erstellt wurde:
```
mkdir /var/lib/kubelet

cat < /var/lib/kubelet/config.yaml
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
EOF
```
- Ein dritter wichtiger Punkt, auf den wir bei der Installation stoßen: obwohl wir den verwendeten Treiber angegeben haben cgroup, und seine Konfiguration über übergebene Argumente kubelet ist veraltet (was in der Dokumentation ausdrücklich angegeben ist). Wir müssen dem Datei Argumente hinzufügen, sonst wird unser Cluster nicht initialisiert:
```
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
```
- Jetzt können wir den Daemon aktivieren kubelet:
```
sudo systemctl enable --now kubelet
```
  Um zu konfigurieren control-plane oder worker Nodes in wenigen Minuten, können Sie dieses Skript verwenden dieses Skript.
Es ist Zeit, unser Cluster zu initialisieren.
- Um das Cluster zu initialisieren, führen Sie den Befehl aus:
```
kubeadm init --pod-network-cidr=10.244.0.0/16
```
  Notieren Sie sich unbedingt den Befehl, um dem Cluster beizutreten „kubeadm join …“, der am Ende der Ausgabe angeboten wird, oder zumindest die angegebenen Token.
- Wir installieren das Plugin (CNI) für die Pod-Netzwerkfunktion. Ich empfehle, Calico. Möglicherweise hat das beliebteste Flannel. Kompatibilitätsprobleme mit nftables, und außerdem Calico ist die einzige vom Projekt empfohlene und vollständig getestete CNI-Implementierung Kubernetes:
```
kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 
```
- Um einen Worker-Knoten mit unserem Cluster zu verbinden, muss er gemäß den Anweisungen 1 und 2 konfiguriert werden, oder Sie können Skript, und dann den Befehl aus der Ausgabe „kubeadm init …“ ausführen, den wir in der vorherigen Phase notiert haben:
```
kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
    --discovery-token-ca-cert-hash $TOKEN_HASH
```
- Lassen Sie uns überprüfen, ob unser Cluster initialisiert wurde und läuft:
```
kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
```
Fertig! Sie können jetzt Lasten auf Ihrem K8s-Cluster bereitstellen.

Was uns erwartet

Ich hoffe, dass die obige Anleitung Ihnen geholfen hat, ein wenig Zeit und Nerven zu sparen.
Die Ergebnisse der Prozesse in der Branche hängen oft davon ab, wie sie von der Mehrheit der Endbenutzer und Entwicklern anderer Software in dem entsprechenden Bereich angenommen werden. Es ist noch unklar, welches Ergebnis die Initiativen von OCI in einigen Jahren bringen werden, aber wir werden dies gerne verfolgen. Sie können Ihre Meinung jetzt in den Kommentaren mitteilen.

Bleiben Sie dran!

Dieser Artikel entstand durch folgende Quellen: