Installare un cluster Kubernetes su Ubuntu usando kubeadm

In questa guida, ti guiderò attraverso i passaggi per installare e configurare un cluster Kubernetes funzionante a 3 nodi su Ubuntu Linux. Kubernetes è un sistema di orchestrazione di container open-source utilizzato per automatizzare il deployment, la gestione e la scalabilità delle applicazioni containerizzate.

In questo articolo condividiamo in dettaglio il processo di:

Preparazione dei nodi Kubernetes
Impostazione dei repository
Installazione del motore di runtime dei container
Installazione dei componenti di Kubernetes
Inizializzare il tuo cluster
installazione del plugin di rete per Kubernetes
Unire nuovi nodi di lavoro al cluster

Iniziamo!

La Guida Definitiva al Desktop Ubuntu

Diventa un esperto di Ubuntu - dalla splendida personalizzazione del desktop alla potente automazione del terminale. Perfetto per sviluppatori, amministratori di sistema e utenti esperti che vogliono il controllo totale del loro ambiente di lavoro.

Fase 1: Diagramma dei sistemi

Questa configurazione si basa sul seguente diagramma:

Configuriamo i nomi host del sistema prima di poter procedere ai passaggi successivi:

Sul Nodo Master:

Imposta il nome host come segue:

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

Su Nodo Lavoratore 01:

Imposta il nome host usando lo strumento da riga di comando hostnamectl.

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

Su Worker Node 02:

Imposta anche il nome host per il nodo worker 02 di Kubernetes.

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

Una volta configurato correttamente il nome host su ciascun host, popolare ogni nodo con i valori configurati.

$ 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

Esci e accedi di nuovo per utilizzare il nuovo nome host configurato.

exit||logout

Passo 2: Crea utente amministratore

Prima di effettuare qualsiasi configurazione specifica di Kubernetes, assicuriamoci che tutte le dipendenze siano soddisfatte. Qui eseguiremo un aggiornamento del sistema e creeremo un utente Kubernetes.

Aggiorna i pacchetti di sistema all'ultima versione su tutti i nodi:

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

Aggiungi utente per gestire il cluster Kubernetes:

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

Se preferisci inserire la password sudo quando esegui comandi sudo come utente k8s-admin, allora puoi ignorare l'ultima riga. Puoi testare se non viene richiesta la password per sudo:

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

Tutto sembra a posto, procediamo con l'installazione del motore Docker.

Passo 3: Installare Containerd

Kubernetes richiede un motore di runtime per container per eseguire i container. In questo articolo useremo Containerd come motore per i container.

Assicurati che Docker non sia installato. In caso contrario, disinstallalo.

sudo apt remove docker docker-engine docker.io

Installa le dipendenze:

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

Importa la chiave GPG del repository Docker:

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"

Installa Docker Engine.

sudo apt update && sudo apt install containerd.io

Il servizio viene avviato automaticamente.

$ 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

Puoi anche controllare la versione installata:

containerd --version

Fase 4: Installare i componenti di Kubernetes

Installa gli strumenti dipendenti.

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

Imposta la versione di Kubernetes che desideri installare.

k8s_ver=1.30

Scarica la chiave pubblica per la firma dei repository dei pacchetti Kubernetes

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

Aggiungi il repository APT ufficiale di Kubernetes.

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

Aggiorna l'indice dei pacchetti apt:

sudo apt update

Installa i componenti di Kubernetes

Installa kubectl, kubelet, kubernetes-cni e kubeadm componenti master di Kubernetes:

sudo apt install kubectl kubelet kubeadm kubernetes-cni

Conferma che tutti i file binari del pacchetto siano presenti nel file system.

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Se lo swap è attivo, spegnilo.

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

Carica i moduli richiesti.

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

Per caricare a runtime eseguire:

sudo modprobe overlay
sudo modprobe br_netfilter

Imposta anche le configurazioni sysctl.

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

Carica le configurazioni.

sudo sysctl --system

Configura containerd e riavvia il servizio

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

Abilita il servizio kubelet

sudo systemctl enable kubelet

Passo 5: Avviare il Control Plane di k8s

Tutti i comandi che verranno eseguiti in questa sezione devono essere eseguiti sul nodo master. Non eseguire nessuno dei comandi sui nodi worker di Kubernetes. I componenti Master di Kubernetes forniscono il piano di controllo del cluster – API Server, Scheduler, Controller Manager. Essi prendono decisioni globali sul cluster, ad esempio la pianificazione e il rilevamento e la gestione degli eventi del cluster.

Conferma che containerd funziona eseguendo il pull delle immagini di base di Kubernetes.

$ 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

Se hai più socket CRI, utilizza --cri-socket per selezionarne uno:

# 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 (nodo del piano di controllo singolo) – nessun endpoint condiviso

Per avviare un cluster senza utilizzare l'endpoint DNS, esegui:

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

Avvio con endpoint condiviso (nome DNS per l'API del piano di controllo)

Questo è ideale per più nodi del piano di controllo.

Imposta il nome DNS del endpoint del cluster o aggiungi un record al file /etc/hosts.

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

Crea cluster:

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

Dove :

k8s-cluster.computingforgeeks.com punta a un IP di bilanciamento del carico per i nodi del piano di controllo k8s.

Se tutto va bene, dovresti ricevere un messaggio di successo con le istruzioni su cosa fare dopo:

---
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

Configura l'accesso per l'utente `k8s-admin` sul server Master

Passa a k8s-admin e copia il file di configurazione di Kubernetes con le informazioni del cluster.

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

Convalida il deployment controllando le informazioni del cluster.

$ 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'.

Fase 6: Installa il plugin CNI

In questa guida useremo Calico. Puoi scegliere qualsiasi altro plugin di rete supportato.

Scarica i file dell'operatore e delle risorse personalizzate. Vedi la pagina dei rilasci per l'ultima versione.

Scarica l'ultima versione:

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

Scarica le risorse di installazione.

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

Per prima cosa, installa l'operatore sul tuo cluster.

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

Aggiorniamo anche il pool IP di Calico.

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

Quindi applica le configurazioni del manifesto.

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

Attendere che il Pod Calico sia nello stato in esecuzione.

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

Il nodo dovrebbe essere ora Pronto.

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

Passo 7: Configurare i nodi di lavoro

Quando il cluster Kubernetes è stato inizializzato e il nodo master è online, avvia la configurazione dei nodi Worker. Un nodo è una macchina di lavoro in Kubernetes, può essere una VM o una macchina fisica. Ogni nodo è gestito dal master e dispone dei servizi necessari per eseguire i pod – docker, kubelet, kube-proxy.

1) Assicurati che il runtime Containerd sia installato (coperto)

Segui i passaggi forniti in questo articolo per installare containerd

2) Aggiungi il repository di Kubernetes (coperto)

Assicurati che il repository per i pacchetti Kubernetes sia aggiunto al sistema.

3) Installare i componenti di Kubernetes (Passo 4)

Una volta aggiunto il repository di Kubernetes, installa i componenti usando:

sudo apt install kubelet kubeadm kubectl kubernetes-cni

4) Unire il Nodo al Cluster:

Usa il comando join fornito dopo l'inizializzazione del cluster Kubernetes. Puoi stampare i comandi usando:

kubeadm token create --print-join-command

Quando hai finito, controlla lo stato dei nodi sul 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

Passo 8: Convalidare la configurazione di Kubernetes

Crea un namespace di test:

$ kubectl create namespace test
namespace/test created

Distribuire l'applicazione di test

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

Visualizza le distribuzioni esistenti:

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

Vedi pod in esecuzione

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

Per liberare le risorse, esegui:

kubectl delete deployment hello-node

Fase 9: Configurare il completamento di kubectl

Abilita il completamento automatico della shell per i comandi kubectl. Kubectl include il supporto al completamento automatico, che può farti risparmiare molto tempo di digitazione!. Per abilitare il completamento della shell nella sessione corrente, esegui:

source <(kubectl completion bash)

Per aggiungere il completamento automatico di kubectl al tuo profilo, in modo che venga caricato automaticamente nelle future shell, esegui:

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

Se stai usando zsh, modifica il file ~/.zshrc e aggiungi il seguente codice per abilitare l'autocompletamento di kubectl:

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

Oppure, quando si utilizza Oh-My-Zsh, modifica il file ~/.zshrc e aggiorna la riga plugins= per includere il plugin kubectl.

source <(kubectl completion zsh)

Rilevante è anche il comando Top per le metriche dei container

Materiali di formazione sulla padronanza di Kubernetes:

I migliori libri di studio su Kubernetes

Conclusione

Abbiamo distribuito con successo un cluster Kubernetes a 3 nodi su server Ubuntu LTS. Le nostre prossime guide tratteranno Kubernetes HA, il monitoraggio di Kubernetes, come configurare lo storage esterno e altre cose interessanti. Restate sintonizzati!