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

Hallo! Ich heiße Sergey, ich bin DevOps bei Surf. Die DevOps-Abteilung bei Surf hat sich zum Ziel gesetzt, nicht nur die Interaktion zwischen Spezialisten zu optimieren und Arbeitsabläufe zu integrieren, sondern auch aktiv Forschungsarbeiten durchzuführen und relevante Technologien sowohl in die eigene Infrastruktur als auch in die Infrastruktur der Kunden einzuführen.

Nachfolgend werde ich ein wenig über die Änderungen im Technologie-Stack für Container berichten, die wir bei der Untersuchung der Distributionen festgestellt haben CentOS 8 und darüber, 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 Versionen RHEL 8 oder CentOS 8 fällt auf: In diesen Distributionen und offiziellen Repositories fehlt die Anwendung Docker, die ideologisch und funktional durch Pakete ersetzt, Podman, Buildah (die standardmäßig in der Distribution enthalten sind) und CRI-O. Dies steht im Zusammenhang mit der praktischen Umsetzung von Standards, die unter anderem von der Firma Red Hat im Rahmen des Projekts Open Container Initiative (OCI) entwickelt wurden.

Das Ziel der OCI, die Teil der Linux Foundation ist, besteht darin, offene Branchenstandards für Formate und Ausführungsumgebungen von Containern zu schaffen, die mehrere Aufgaben gleichzeitig lösen. Erstens, sie sollten nicht im Widerspruch zur Philosophie von Linux stehen (zum Beispiel in der Hinsicht, dass jedes Programm eine bestimmte Aufgabe erfüllen sollte, während Docker es eine Art All-in-One-Kombination darstellt). Zweitens sollten sie alle bestehenden Mängel in der Software beseitigen Docker. Drittens sollten sie vollständig kompatibel mit den geschäftlichen Anforderungen sein, die von führenden kommerziellen Plattformen für die Bereitstellung, Verwaltung und Wartung containerisierter Anwendungen gestellt werden (zum Beispiel Red Hat OpenShift).

Nachteile Docker Die Vorteile neuer Software wurden bereits ziemlich detailliert in diesem Artikel, und detaillierte Informationen über den gesamten im Rahmen des Projekts OCI angebotenen Software-Stack und seine architektonischen Eigenheiten können in der offiziellen Dokumentation und in Artikeln sowohl von Red Hat selbst (guter Artikel im Red Hat Blog), als auch in externen werden.

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

Podman — direkte Interaktion mit Containern und dem Image-Repository über den Prozess runC;
Buildah — Erstellen und Hochladen von Images in das Repository;
CRI-O — Ausführungsumgebung für Container-Orchestrierungssysteme (zum Beispiel Kubernetes).

Ich denke, dass es sinnvoll ist, hier ein Schema der Wechselwirkungen zwischen den Komponenten des Stacks zu geben, um das allgemeine Schema zu verstehen. Kubernetes c runC und niedrigstufigen Bibliotheken unter Verwendung von CRI-O:

CRI-O und Kubernetes den gleichen Veröffentlichungs- und Supportzyklen folgen (die Kompatibilitätsmatrix ist sehr einfach: Hauptversionen Kubernetes und CRI-O stimmen überein), und in Anbetracht des Ziels eines vollständigen und umfassenden Tests dieser Stack-Funktionalität durch die Entwickler haben wir das Recht, maximal erreichbare Stabilität unter allen Nutzungsszenarien zu erwarten (hier kommt auch das vergleichsweise geringe Gewicht CRI-O im Vergleich zu Docker aufgrund der gezielten Einschränkung der Funktionalität).

Bei der Installation von Kubernetes auf die „richtige Art“ (natürlich nach Ansicht von OCI) unter Verwendung von CRI-O auf CentOS 8 wir sind auf einige kleinere Schwierigkeiten gestoßen, die wir jedoch erfolgreich überwunden haben. Ich freue mich, Ihnen eine Installations- und Konfigurationsanleitung zur Verfügung zu stellen, die zusammen nicht länger als 10 Minuten dauern sollte.

Wie man Kubernetes auf CentOS 8 unter Verwendung von CRI-O bereitstellt

Voraussetzungen: Mindestens ein Host (2 Kerne, 4 GB RAM, Speicherplatz von mindestens 15 GB) mit installiertem CentOS 8 (die Installation des Profils „Server“ wird empfohlen), sowie Einträge für ihn im lokalen DNS (im schlimmsten Fall kann ein Eintrag in /etc/hosts ausreichen). Und vergessen Sie nicht, den Swap zu deaktivieren..

Alle Operationen auf dem Host führen wir als Benutzer root durch, seien Sie vorsichtig.

Im ersten Schritt konfigurieren wir das Betriebssystem, installieren und konfigurieren die erforderlichen Abhängigkeiten für CRI-O.
- Wir aktualisieren das Betriebssystem:
```
dnf -y update
```
- Als Nächstes müssen wir 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 wenn Sie sich in einem vertrauenswürdigen Netzwerk befinden oder eine Drittanbieter-Firewall verwenden, die Standardzone auf vertrauenswürdig ändern oder die Firewall deaktivieren:
```
firewall-cmd --set-default-zone trusted

firewall-cmd --reload
```
  Um die Firewall auszuschalten, 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 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 das Forwarding von Paketen zu aktivieren und den Verkehr 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 vorgenommenen Einstellungen an:
```
sysctl --system
```
- Wir legen die erforderliche Version fest CRI-O (Major-Version CRI-O, wie bereits erwähnt, stimmt mit der erforderlichen Version überein Kubernetes), da die letzte stabile Version Kubernetes momentan 1.18 ist:
```
export REQUIRED_VERSION=1.18
```
  Wir fügen die erforderlichen Repositories 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 im Installationsprozess auftritt: die Konfiguration muss bearbeitet werden CRI-O vor dem Start des Dienstes, da das erforderliche Element conmon an einem anderen Ort installiert ist 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.
- Wir fügen 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 (Version 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 den Daemon nicht verwenden Docker, sondern den Daemon CRI-O, müssen vor dem Start und der Initialisierung Kubernetes die entsprechenden Einstellungen in die Konfigurationsdatei /var/lib/kubelet/config.yaml eingefügt werden, nachdem das benötigte 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, dem wir bei der Installation begegnen: obwohl wir den verwendeten Treiber angegeben haben cgroup, und seine Einstellung über die übergebenen Argumente Kubelet veraltet ist (was in der Dokumentation ausdrücklich erwähnt wird), müssen wir Argumente in die Datei einfü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 Knoten 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 zum Hinzufügen zum Cluster „kubeadm join …“, der am Ende der Ausgabe vorgeschlagen wird, oder mindestens die angegebenen Token.
- Wir installieren das Plugin (CNI) für das Funktionieren des Pod-Netzwerks. Ich empfehle, CalicoEs gibt möglicherweise ein beliebteres Flannel hat Kompatibilitätsprobleme mit nftables, und Calico ist die einzige CNI-Implementierung, die vom Projekt empfohlen und umfassend getestet wurde. Kubernetes:
```
kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 
```
- Um den Worker-Knoten mit unserem Cluster zu verbinden, muss er gemäß den Anweisungen 1 und 2 konfiguriert werden oder Sie können Skript, dann führen Sie den Befehl aus der Ausgabe „kubeadm init …“ aus, den wir in der vorherigen Phase notiert haben:
```
kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
    --discovery-token-ca-cert-hash $TOKEN_HASH
```
- Überprüfen wir, ob unser Cluster initialisiert und aktiv ist:
```
kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
```
Fertig! Sie können bereits Ihre Lasten im K8s-Cluster bereitstellen.

Was uns erwartet

Ich hoffe, dass die obigen Anweisungen Ihnen geholfen haben, etwas Zeit und Nerven zu sparen.
Der Ausgang der Prozesse, die in der Branche stattfinden, hängt oft davon ab, wie sie von der Mehrheit der Endbenutzer und Entwicklern anderer Software in der entsprechenden Nische angenommen werden. Es ist noch unklar, zu welchem Ergebnis die OCI-Initiativen in ein paar Jahren führen werden, aber wir werden das mit Freude verfolgen. Sie können Ihre Meinung jetzt in den Kommentaren teilen.

Bleiben Sie dran!

Dieser Artikel entstand dank folgender Quellen: