Installera Kubernetes-kluster på Ubuntu med kubeadm

I den här guiden kommer jag att gå igenom stegen för att installera och konfigurera ett fungerande 3-nodigt Kubernetes-kluster på Ubuntu Linux. Kubernetes är ett öppet källkodsbaserat container-orchestration-system som används för att automatisera distribuering, hantering och skalning av containeriserade applikationer.

I den här artikeln delar vi i detalj processen för:

Förbereda Kubernetes-noder
Inställning av arkiv
Installera container-runtime-motor
Installera Kubernetes-komponenter
Starta upp din kluster
installerar nätverksplugin för Kubernetes
Lägga till nya arbetarnoder i klustret

Låt oss sätta igång!

Den ultimata handboken för Ubuntu-skrivbordet

Bemästra Ubuntu som ett proffs – från vacker skrivbordsanpassning till kraftfull terminalautomatisering. Perfekt för utvecklare, systemadministratörer och avancerade användare som vill ha total kontroll över sin arbetsyta.

Steg 1: Systemschema

Denna uppställning är baserad på följande diagram:

Låt oss konfigurera systemets värdnamn innan vi kan gå vidare till nästa steg:

På master-noden:

Ställ in värdnamn som nedan:

sudo hostnamectl set-hostname k8s-master.example.com

På arbetarnod 01:

Ställ in värdnamnet med hostamectl kommandoradsverktyg.

sudo hostnamectl set-hostname k8s-node-01.example.com

På Worker Node 02:

Ställ också in värdnamn för Kubernetes-arbetarnod 02.

sudo hostnamectl set-hostname k8s-node-02.example.com

När korrekt värdnamn har konfigurerats på varje värd, fyll i varje nod med de konfigurerade värdena.

$ sudo vim /etc/hosts
192.168.2.2 k8s-master.example.com    k8s-master
192.168.2.3 k8s-node-01.example.com  k8s-node-01
192.168.2.4 k8s-node-02.example.com  k8s-node-02

Logga ut och logga in igen för att använda det nya konfigurerade värdnamnet.

exit||logout

Steg 2: Skapa administratörsanvändare

Innan vi gör några Kubernetes-specifika konfigurationer, låt oss säkerställa att alla beroenden är uppfyllda. Här kommer vi att göra en systemuppdatering och skapa en Kubernetes-användare.

Uppdatera systempaketen till den senaste versionen på alla noder:

sudo apt update && sudo apt upgrade -y
[ -e /var/run/reboot-required ] && sudo reboot

Lägg till användare för att hantera Kubernetes-klustret:

sudo useradd -s /bin/bash -m k8s-admin
sudo passwd k8s-admin
sudo usermod -aG sudo k8s-admin
echo "k8s-admin ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/k8s-admin

Om du föredrar att ange sudo-lösenordet när du kör sudo-kommandon som användaren k8s-admin, kan du ignorera den sista raden. Du kan testa om det inte kommer upp något lösenordsmeddelande för sudo:

$ su - k8s-admin
k8s-admin@k8s-master:~$ sudo su -
root@k8s-master:~# exit

Allt ser bra ut, låt oss gå vidare och installera Docker-motorn.

Steg 3: Installera Containerd

Kubernetes kräver en containerkörmotor för att köra containrar. I den här artikeln kommer vi att använda Containerd som containermotor.

Se till att Docker inte är installerat. Om det är det, avinstallera det.

sudo apt remove docker docker-engine docker.io

Installera beroenden:

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common

Importera Docker-förrådets GPG-nyckel:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/docker-archive-keyring.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Installera Docker-motor.

sudo apt update && sudo apt install containerd.io

Tjänsten startas automatiskt.

$ systemctl status containerd.service
● containerd.service - containerd container runtime
   Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
   Active: active (running) since  Sun 2024-07-14 21:22:30 UTC; 34min ago
     Docs: https://containerd.io
  Process: 4265 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
 Main PID: 4270 (containerd)
    Tasks: 8
   CGroup: /system.slice/containerd.service
           └─4270 /usr/bin/containerd

Du kan också kontrollera vilken version som är installerad:

containerd --version

Steg 4: Installera Kubernetes-komponenter

Installera beroende verktyg.

sudo apt install apt-transport-https ca-certificates curl gpg -y

Ange versionen av Kubernetes som du vill installera.

k8s_ver=1.30

Ladda ner den offentliga signeringsnyckeln för Kubernetes paketförråd

curl -fsSL https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/Release.key | \
 sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/k8s.gpg

Lägg till den officiella Kubernetes APT-förvaret.

echo "deb https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Uppdatera apt-paketindex:

sudo apt update

Installera Kubernetes-komponenter

Installera kubectl, kubelet, kubernetes-cni och kubeadm Kubernetes masterkomponenter:

sudo apt install kubectl kubelet kubeadm kubernetes-cni

Bekräfta att alla paketbinärer finns på filsystemet.

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Om swap är på, stäng av det.

sudo swapoff -a
sudo sed -i.bak -r 's/(.+ swap .+)/#\1/' /etc/fstab

Ladda nödvändiga moduler.

sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

För att ladda vid körning, kör:

sudo modprobe overlay
sudo modprobe br_netfilter

Ange även sysctl-konfigurationer.

sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

Ladda konfigurationerna.

sudo sysctl --system

Konfigurera containerd och starta om tjänsten

sudo mkdir -p /etc/containerd
sudo containerd config default|sudo tee /etc/containerd/config.toml
sudo systemctl restart containerd

Aktivera kubelet-tjänsten

sudo systemctl enable kubelet

Steg 5: Bootstrap av k8s kontrollplan

Alla kommandon som kommer att köras i denna sektion är avsedda att köras på masternoden. Kör inga av kommandona på Kubernetes worker-noder. Kubernetes Master-komponenter tillhandahåller klustrets kontrollplan – API-server, Scheduler, Controller Manager. De fattar globala beslut om klustret, t.ex. schemaläggning samt att upptäcka och reagera på klusterhändelser.

Bekräfta att containerd fungerar genom att hämta Kubernetes-basbilder.

$ sudo kubeadm config images pull
[config/images] Pulled registry.k8s.io/kube-apiserver:v1.30.2
[config/images] Pulled registry.k8s.io/kube-controller-manager:v1.30.2
[config/images] Pulled registry.k8s.io/kube-scheduler:v1.30.2
[config/images] Pulled registry.k8s.io/kube-proxy:v1.30.2
[config/images] Pulled registry.k8s.io/coredns/coredns:v1.11.1
[config/images] Pulled registry.k8s.io/pause:3.9
[config/images] Pulled registry.k8s.io/etcd:3.5.12-0

Om du har flera CRI-socklar, använd --cri-socket för att välja en:

# Containerd
sudo kubeadm config images pull --cri-socket unix:///run/containerd/containerd.sock

# For CRI-O
sudo kubeadm config images pull --cri-socket unix:///var/run/crio/crio.sock

Bootstrap (enkel kontrollplan-nod) – ingen delad endpoint

För att starta en kluster utan att använda DNS-slutpunkt, kör:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --cri-socket unix:///run/containerd/containerd.sock

Bootstrap med delad endpoint (DNS-namn för kontrollplans-API)

Detta är idealiskt för flera kontrollplanesnoder.

Ange klustrets slutpunkts-DNS-namn eller lägg till en post i /etc/hosts-filen.

$ sudo vim /etc/hosts
172.29.20.5 k8s-cluster.computingforgeeks.com

Skapa kluster:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --upload-certs \
  --control-plane-endpoint=k8s-cluster.computingforgeeks.com

Var :

k8s-cluster.computingforgeeks.com pekar på en LB-IP för dina k8s-kontrollplansnoder.

Om allt går bra bör du få ett framgångsmeddelande med instruktioner om vad du ska göra härnäst:

---
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.2.2:6443 --token 9y4vc8.h7jdjle1xdovrd0z --discovery-token-ca-cert-hash sha256:cff9d1444a56b24b4a8839ff3330ab7177065c90753ef3e4e614566695db273c

Konfigurera åtkomst för `k8s-admin`-användaren på masterservern

Byt till k8s-admin och kopiera Kubernetes-konfigurationsfilen med klusterinformation.

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

Validera distributionen genom att kontrollera klusterinformation.

$ kubectl cluster-info
Kubernetes control plane is running at https://192.168.2.2:6443
CoreDNS is running at https://192.168.2.2:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

Steg 6: Installera CNI-plugin

I den här guiden kommer vi att använda Calico. Du kan välja vilken annan stödd nätverksplugin som helst.

Ladda ner operatörs- och anpassade resursfiler. Se sidan för utgåvor för den senaste versionen.

Hämta den senaste versionen:

VERSION=$(curl --silent "https://api.github.com/repos/projectcalico/calico/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')

Ladda ner installationsresurser.

curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/tigera-operator.yaml
curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/custom-resources.yaml

Först, installera operatören på din kluster.

k8s-admin@k8s-master:~$ kubectl create -f tigera-operator.yaml
namespace/tigera-operator created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpfilters.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/apiservers.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/imagesets.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/installations.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/tigerastatuses.operator.tigera.io created
serviceaccount/tigera-operator created
clusterrole.rbac.authorization.k8s.io/tigera-operator created
clusterrolebinding.rbac.authorization.k8s.io/tigera-operator created
deployment.apps/tigera-operator created

Låt oss också uppdatera Calico IP-poolen.

sed -ie 's/192.168.0.0/172.24.0.0/g' custom-resources.yaml

Applicera sedan manifestkonfigurationerna.

k8s-admin@k8s-master:~$  kubectl create -f custom-resources.yaml
installation.operator.tigera.io/default created
apiserver.operator.tigera.io/default created

Vänta på att Calico Pod är i körbart tillstånd.

k8s-admin@k8s-master:~$ kubectl get pods --all-namespaces
NAMESPACE          NAME                                             READY   STATUS    RESTARTS   AGE
calico-apiserver   calico-apiserver-5476c484c4-rmmts                1/1     Running   0          37s
calico-apiserver   calico-apiserver-5476c484c4-z9phf                1/1     Running   0          37s
calico-system      calico-kube-controllers-6945f87bd4-2xwx4         1/1     Running   0          80s
calico-system      calico-node-tkwtv                                1/1     Running   0          80s
calico-system      calico-typha-65f575c9fc-xx8m8                    1/1     Running   0          81s
calico-system      csi-node-driver-kngdn                            2/2     Running   0          80s
kube-system        coredns-5dd5756b68-77x77                         1/1     Running   0          11m
kube-system        coredns-5dd5756b68-plpd6                         1/1     Running   0          11m
kube-system        etcd-k8s-master.example.com                      1/1     Running   0          11m
kube-system        kube-apiserver-k8s-master.example.com            1/1     Running   0          11m
kube-system        kube-controller-manager-k8s-master.example.com   1/1     Running   0          11m
kube-system        kube-proxy-bxq4x                                 1/1     Running   0          11m
kube-system        kube-scheduler-k8s-master.example.com            1/1     Running   0          11m
tigera-operator    tigera-operator-94d7f7696-xls25                  1/1     Running   0          3m20s

Noden bör nu vara redo.

k8s-admin@k8s-master:~$ kubectl get nodes
NAME                     STATUS   ROLES           AGE   VERSION
k8s-master.example.com   Ready    control-plane   20m   v1.30.2

Steg 7: Konfigurera arbetsnoder

När Kubernetes-klustret har initierats och masternoden är online, börja konfigurera arbetsnoder. En nod är en arbetsmaskin i Kubernetes och kan vara en virtuell maskin eller en fysisk maskin. Varje nod hanteras av mastern och har de tjänster som behövs för att köra pods – Docker, kubelet, kube-proxy.

1) Se till att Containerd-runtime är installerat (täckt)

Följ stegen som anges i den här artikeln för att installera containerd

2) Lägg till Kubernetes-förråd (behandlat)

Se till att lagringsplatsen för Kubernetes-paket läggs till i systemet.

3) Installera Kubernetes-komponenter (Steg 4)

När du har lagt till Kubernetes-förrådet, installera komponenterna med:

sudo apt install kubelet kubeadm kubectl kubernetes-cni

4) Lägg till noden i klustret:

Använd join-kommandot som ges efter att Kubernetes-klustret har initierats. Du kan skriva ut kommandona med:

kubeadm token create --print-join-command

När du är klar, kontrollera nodernas status på master:

k8s-admin@k8s-master:~$ kubectl get nodes
NAME          STATUS    ROLES     AGE       VERSION
k8s-master    Ready     master    35m       v1.30.2
k8s-node-01   Ready     <none>    2m        v1.30.2
k8s-node-02   Ready     <none>    1m        v1.30.2

Steg 8: Validera Kubernetes-installationen

Skapa ett testnamnrymd:

$ kubectl create namespace test
namespace/test created

Distribuera testapplikation

kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.39 -- /agnhost netexec --http-port=8080

Visa befintliga distributioner:

$ kubectl get deployments
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m

Se körande pods

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m

För att rensa upp resurser, kör:

kubectl delete deployment hello-node

Steg 9: Konfigurera kubectl-komplettering

Aktivera shell-autokomplettering för kubectl-kommandon. kubectl har stöd för autokomplettering, vilket kan spara mycket skrivande! För att aktivera shellautokomplettering i din nuvarande session, kör:

source <(kubectl completion bash)

För att lägga till kubectl-autokomplettering till din profil, så att den automatiskt laddas i framtida skal, kör:

echo "source <(kubectl completion bash)" >> ~/.bashrc

Om du använder zsh, redigera filen ~/.zshrc och lägg till följande kod för att aktivera kubectl-autokomplettering:

if [ $commands[kubectl] ]; then
source <(kubectl completion zsh)
fi

Eller när du använder Oh-My-Zsh, redigera filen ~/.zshrc och uppdatera raden plugins= för att inkludera kubectl-pluginen.

source <(kubectl completion zsh)

Även relevant är kommandot top för container-mätvärden

Kubernetes-mästarkursmaterial:

Bästa studieböckerna om Kubernetes

Slutsats

Vi har framgångsrikt distribuerat en Kubernetes-kluster med 3 noder på Ubuntu LTS-servrar. Våra kommande guider kommer att täcka Kubernetes HA, Kubernetes-övervakning, hur man konfigurerar extern lagring och mer intressanta saker. Håll er uppdaterade!