Slik installerer du en Kubernetes-klynge på CentOS 8

Prosessen med å installere en Kubernetes-klynge på CentOS 8 er nesten lik den for CentOS 7 (som du kan gå gjennom her), men prosessen her har noen endringer. Disse endringene dreier seg for det meste om installasjonen av Docker.

Fra og med CentOS 8 (og i forlengelsen RHEL 8), har docker nå blitt erstattet av podman og buildah som er verktøy fra Redhat. Faktisk er docker-pakken nå fjernet fra standardpakkelageret.

Med dette trekket har Redhat-teamet som mål å forenkle prosessen med å lage og bruke containere, uten å trenge spesielle tillatelser, samtidig som de opprettholder kompatibilitet med docker-bilder og betjener dem uten å trenge en demon. Podman lover å tilby mer fleksibilitet når du kjører på Kubernetes-miljøer, men juryen forblir der ute.

For denne artikkelen vil vi kjøre gjennom prosessen med å installere Kubernetes på en CentOS 8-plattform som kjører på Docker-CE (Community utgave). I en senere artikkel vil vi også kjøre gjennom en lignende installasjon, ved å bruke podman for våre containere.

Forutsetninger

Tre servere som kjører CentOS 8 – 1 Master Node og 2 Worker Node.
Det anbefales at nodene dine skal ha minst 2 CPUer med 2 GB RAM eller mer per maskin. Dette er ikke et strengt krav, men er i stor grad drevet av behovene til applikasjonen du har tenkt å kjøre.
Internett-tilkobling på alle nodene dine. Vi vil hente Kubernetes og docker-pakker fra depotet. På samme måte må du sørge for at DNF-pakkebehandleren er installert som standard og kan hente pakker eksternt.
Alle nodene dine skal også kunne kobles til hverandre, enten på et privat eller offentlig nettverk, avhengig av hva som er tilgjengelig.
Du trenger også tilgang til en konto med sudo- eller root-rettigheter. I denne opplæringen vil jeg bruke root-kontoen min.

Forholdsregler

De fleste noder kommer vanligvis med unike MAC-adresser, men i noen unike tilfeller kan noen virtuelle maskiner ha identiske MAC-adresser. Det anbefales derfor at du bekrefter at Product_UUID og MAC-adressen ikke er identiske i noen av nodene.

Kubernetes bruker disse verdiene til å identifisere nodene i klyngen unikt. Hvis disse verdiene ikke er unike for hver node, kan installasjonsprosessen mislykkes.

For å sjekke MAC-adressen til nettverksgrensesnittet og sammenligne den.

ip link

For å sjekke product_uuid og sammenligne, kjør følgende kommando.

cat /sys/class/dmi/id/product_uuid

Logisk arkitektur

Installasjonen vår er designet for å ha Master-Node som kontrollerer Worker Node. På slutten av denne installasjonen vil vår logiske arkitektur se omtrent slik ut.

Master Node – Denne maskinen fungerer vanligvis som kontrollplanet og kjører klyngedatabasen og API-serveren (som kubectl CLI kommuniserer med).

Vår 3-node Kubernetes Cluster vil se omtrent slik ut:

Installasjon av Kubernetes Cluster på Master-Node

For at Kubernetes skal fungere, trenger du en containeriseringsmotor. Som nevnt kommer vi til å bruke Docker-CE.

Følgende institusjoner vil bli utført på CentOS 8 Master-Node.

Trinn 1: Forbered vertsnavn, brannmur og SELinux

På CentOS 8 Master-Node angir du systemvertsnavnet og oppdaterer DNS i /etc/hosts-filen.

hostnamectl set-hostname master-node
cat <<EOF>> /etc/hosts
192.168.0.47 master-node
192.168.0.48 node-1 worker-node-1
192.168.0.49 node-2 worker-node-2
EOF

Ping deretter worker-node-1 og worker-node-2 for å sjekke om den oppdaterte vertsfilen din fungerer som den skal ved å bruke ping-kommandoen.

ping 192.168.0.48
ping 192.168.0.49

Deaktiver deretter Selinux, da dette er nødvendig for å tillate containere å få tilgang til vertsfilsystemet, som er nødvendig av pod-nettverk og andre tjenester.

setenforce 0

Å sette setenforce til 0 setter effektivt SELinux til permissive, noe som effektivt deaktiverer SELinux til neste omstart. For å deaktivere den helt, bruk kommandoen nedenfor og start på nytt.

sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
reboot

Kubernetes bruker ulike porter for kommunikasjon og tilgang, og disse portene må være tilgjengelige for Kubernetes og ikke begrenset av brannmuren.

Konfigurer brannmurreglene på portene.

firewall-cmd --permanent --add-port=6443/tcp
firewall-cmd --permanent --add-port=2379-2380/tcp
firewall-cmd --permanent --add-port=10250/tcp
firewall-cmd --permanent --add-port=10251/tcp
firewall-cmd --permanent --add-port=10252/tcp
firewall-cmd --permanent --add-port=10255/tcp
firewall-cmd --reload
modprobe br_netfilter
echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables

Trinn 2: Installer Docker-CE på CentOS 8

Du må legge til Docker-depotet først, siden det ikke lenger er i standardpakkelisten ved å bruke følgende dnf config-manager-kommando.

dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo

Installer også containerd.io-pakken som er tilgjengelig som en demon som administrerer hele containerlivssyklusen til vertssystemet, fra bildeoverføring og lagring til containerkjøring og tilsyn til lavnivålagring til nettverksvedlegg og mer. .

dnf install https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm

Installer nå den nyeste versjonen av en docker-ce-pakke.

dnf install docker-ce

Du kan nå aktivere og starte docker-tjenesten.

systemctl enable docker
systemctl start docker

Trinn 3: Installer Kubernetes (Kubeadm) på CentOS 8

Deretter må du legge til Kubernetes-depoter manuelt, siden de ikke er installert som standard på CentOS 8.

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
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
EOF

Kubeadm hjelper deg med å starte opp en minimum levedyktig Kubernetes-klynge som er i samsvar med beste praksis. Med kubeadm bør klyngen din bestå Kubernetes-konformitetstestene.

Kubeadm støtter også andre klyngelivssyklusfunksjoner, for eksempel oppgraderinger, nedgradering og administrasjon av bootstrap-tokens. Kubeadm er også integreringsvennlig med andre orkestreringsverktøy som Ansible og Terraform.

Med pakkerepoen nå klar, kan du gå videre og installere kubeadm-pakken.

dnf install kubeadm -y

Når installasjonen er fullført, aktiver og start tjenesten.

systemctl enable kubelet
systemctl start kubelet

Trinn 4: Lag en kontroll-plan Master med kubeadm

Kubernetes-masteren, som fungerer som kontrollplanet for klyngen, kjører noen få kritiske tjenester som er nødvendige for klyngen. Som sådan vil initialiseringsprosessen gjøre en rekke forhåndskontroller for å sikre at maskinen er klar til å kjøre Kubernetes. Disse forhåndskontrollene avslører advarsler og avslutter ved feil. kubeadm init laster deretter ned og installerer klyngekontrollplankomponentene.

Nå er det på tide å initialisere Kubernetes master, men før det må du deaktivere swap for å kjøre kommandoen "kubeadm init".

swapoff -a

Initialisering av Kubernetes master er en fullstendig automatisert prosess som kontrolleres av kommandoen «kubeadm init» som vist.

kubeadm init

Deretter kopierer du følgende kommando og lagrer den et sted, siden vi krevde å kjøre denne kommandoen på arbeidernodene senere.

kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5  \ --discovery-token-ca-cert-hash ha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314683478hjmf7

Tips: Noen ganger kan kommandoen ovenfor gi feil om argumentene som sendes, så for å unngå feil må du fjerne tegnet '\' og din siste kommando vil se slik ut.

kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5 –discovery token-ca-cert-hash sha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314683478hjmf7

Når Kubernetes er initialisert, må du aktivere brukeren din til å begynne å bruke klyngen. I vårt scenario vil vi bruke root-brukeren. Du kan også starte klyngen ved å bruke sudo-bruker som vist.

For å bruke root, kjør:

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config

For å bruke en sudo-aktivert bruker, kjør:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Bekreft nå at kubectl-kommandoen er aktivert.

kubectl get nodes

På dette tidspunktet vil du se statusen til hovednoden er «Ikke klar». Dette er fordi vi ennå ikke har distribuert pod-nettverket til klyngen.

Pod-nettverket er overleggsnettverket for klyngen, som er distribuert på toppen av det nåværende nodenettverket. Den er designet for å tillate tilkobling på tvers av poden.

Trinn 5: Konfigurer Pod-nettverket ditt

Distribusjon av nettverksklyngen er en svært fleksibel prosess avhengig av dine behov, og det er mange tilgjengelige alternativer. Siden vi ønsker å holde installasjonen vår så enkel som mulig, vil vi bruke Weavenet-plugin som ikke krever noen konfigurasjon eller ekstra kode og den gir én IP-adresse per pod som er bra for oss. Hvis du vil se flere alternativer, vennligst sjekk her.

Disse kommandoene vil være viktige for å få satt opp pod-nettverket.

export kubever=$(kubectl version | base64 | tr -d '\n')
kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$kubever"

Hvis du nå sjekker statusen til hovednoden din, bør den være «Klar».

kubectl get nodes

Deretter legger vi til arbeidernodene i klyngen.

Legger til arbeidernoder i Kubernetes-klyngen

Følgende instruksjoner vil bli utført på hver arbeidernode når du blir med i Kubernetes-klyngen.

Trinn 1: Forbered vertsnavn, brannmur og SELinux

Angi først vertsnavnet på worker-node-1 og worker-node-2, og legg deretter til vertsoppføringene i /etc/hosts > fil.

hostnamectl set-hostname 'node-1'
cat <<EOF>> /etc/hosts
192.168.0.47 master-node
192.168.0.48 node-1 worker-node-1
192.168.0.49 node-2 worker-node-2
EOF

Ping deretter hovednoden fra arbeidernodene for å bekrefte at den oppdaterte vertsfilen din fungerer bra ved å bruke ping-kommandoen.

192.168.0.47

Deaktiver deretter SElinux og oppdater brannmurreglene.

setenforce 0
sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
firewall-cmd --permanent --add-port=6783/tcp
firewall-cmd --permanent --add-port=10250/tcp
firewall-cmd --permanent --add-port=10255/tcp
firewall-cmd --permanent --add-port=30000-32767/tcp
firewall-cmd --reload
echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables

Trinn 2: Konfigurer Docker-CE og Kubernetes Repo

Legg først til Docker-depotet ved å bruke DNF config-manager.

dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo

Deretter legger du til containerd.io-pakken.

dnf install https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm

Med disse to pakkene installert, installer den nyeste versjonen av docker-ce.

dnf install docker-ce

Aktiver og start docker-tjenesten.

systemctl enable docker
systemctl start docker

Du må legge til Kubernetes-depoter manuelt, siden de ikke er forhåndsinstallert på CentOS 8.

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
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
EOF

Trinn 3: Installer Kubeadm på CentOS 8

Med pakkerepoen nå klar, kan du gå videre og installere kubeadm.

dnf install kubeadm -y

Start og aktiver tjenesten.

systemctl enable kubelet
systemctl start kubelet

Trinn 4: Bli med arbeidernoden til Kubernetes-klyngen

Vi krever nå tokenet som kubeadm init genererte, for å bli med i klyngen. Du kan kopiere og lime den inn til node-1 og node-2 hvis du hadde kopiert den et sted.

kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5  --discovery-token-ca-cert-hash sha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314683478hjmf78

Som foreslått på den siste linjen, gå tilbake til hovednoden og kontroller om arbeider node-1 og arbeider node-2 har sluttet seg til klynge ved å bruke følgende kommando.

kubectl get nodes

Hvis alle trinnene kjører vellykket, bør du se node-1 og node-2 i klar-status på master-noden. På dette tidspunktet har du nå implementert en Kubernetes-klynge på CentOS 8.

Anbefalt lesning: Slik distribuerer du Nginx på en Kubernetes-klynge

Noen begrensninger

Klyngen vi har opprettet her har en enkelt Master-node, og som sådan, hvis Master-noden mislykkes, kan klyngen miste data og må kanskje gjenskapes fra bunnen av.

Av denne grunn anbefaler jeg et svært tilgjengelig oppsett.