Ricerca nel sito web

Come configurare il cluster Kubernetes con Kubeadm su Ubuntu 22.04

Su questa pagina

  1. Prerequisiti
  2. Impostazione dei sistemi
  3. Imposta il file /etc/hosts
  4. Configurazione del firewall UFW
  5. Abilita moduli kernel e disabilita SWAP
  6. Installazione di Container Runtime: Containerd
  7. Installazione del pacchetto Kubernetes
  8. Installazione del plug-in CNI (Container Network Interface): Flannel
  9. Inizializzazione del piano di controllo Kubernetes
  10. Aggiunta di nodi di lavoro a Kubernetes
  11. Conclusione

Kubernetes o k8s è una piattaforma open source per l'orchestrazione dei container che automatizza le distribuzioni, la gestione e il ridimensionamento delle applicazioni containerizzate. Kubernetes è un'orchestrazione di container creata da Google e ora è diventata un progetto open source e diventa uno standard per le moderne piattaforme di distribuzione di applicazioni e elaborazione.

Kubernetes è la soluzione per la moderna era di distribuzione dei container. Fornisce rilevamento e bilanciamento del carico dei servizi, orchestrazione dell'archiviazione, rollout e rollback automatizzati, servizio di riparazione automatica, gestione dei segreti e della configurazione. Kubernetes consente uno sviluppo nativo del cloud a costi contenuti.

In questo tutorial, configurerai il cluster Kubernetes:

  1. Impostazione dei sistemi, che include: installazione del file /etc/hosts, abilitazione dei moduli del kernel e disabilitazione di SWAP.
  2. Impostazione del firewall UFW aggiungendo alcune porte necessarie per Kubernetes.
  3. Installazione di containerd come runtime del contenitore per Kubernetes.
  4. Installazione di pacchetti Kubernetes come kubelet, kubeadm e kubectl.
  5. Installazione del plug-in di rete Flannel per i pod Kubernetes.
  6. Inizializzazione di un nodo del piano di controllo e aggiunta di due nodi di lavoro.

Prerequisiti

Per completare questo tutorial, avrai bisogno dei seguenti requisiti:

  • Tre o più server Ubuntu 22.04.
  • Un utente non root con privilegi di root/amministratore.

Installazione di sistemi

Prima di iniziare a installare qualsiasi pacchetto per la distribuzione di Kubernetes, dovrai configurare tutti i tuoi sistemi come richiesto per la distribuzione di Kubernetes. Ciò include le seguenti configurazioni:

  • Imposta il file /etc/hosts corretto: ogni nome host del server deve essere risolto nell'indirizzo IP corretto. Questo può essere fatto in diversi modi, ma il più facile e semplice è usare il file /etc/hosts su tutti i server.
  • Imposta firewall UFW: per l'ambiente di produzione, è sempre consigliabile abilitare il firewall sia sul piano di controllo che sui nodi di lavoro.
  • Abilita i moduli del kernel: Kubernetes richiedeva l'abilitazione di alcuni moduli del kernel sul sistema Linux. I moduli del kernel \overlay\ e \br_netfilter\ sono necessari per consentire a iptables di vedere i traffici con bridge.
  • Disabilita SWAP: questo è obbligatorio, devi disabilitare SWAP su tutti i nodi Kubernetes, sia sul piano di controllo che sui nodi di lavoro. In caso contrario, il servizio kubelet verrà eseguito con problemi.

Imposta il file /etc/hosts

In questo primo passaggio, imposterai il nome host del sistema e il file /etc/hosts su tutti i tuoi server. Per questa dimostrazione, utilizzeremo i seguenti server.

Hostname    IP Address        Used as
--------------------------------------------
cplane1     192.168.5.10      control-plane
worker1     192.168.5.25      worker node
worker2     192.168.5.26      worker node

Eseguire il seguente comando hostnamectl di seguito per configurare il nome host del sistema su ciascun server.

Per il nodo del piano di controllo, esegui il seguente comando per impostare il nome host del sistema su \cplane1\.

sudo hostnamectl set-hostname cplane1

Per i nodi di lavoro Kubernetes, esegui il seguente comando hostnamectl.

# setup hostname worker1
sudo hostnamectl set-hostname worker1

# setup hostname worker2
sudo hostnamectl set-hostname worker2

Successivamente, modifica il file /etc/hosts su tutti i server utilizzando il seguente comando.

sudo nano /etc/hosts

Aggiungere la seguente configurazione al file. Assicurati che ogni nome host punti all'indirizzo IP corretto.

192.168.5.10 cplane1
192.168.5.25 worker1
192.168.5.26 worker2

Salva e chiudi il file quando hai finito.

Infine, se esegui il comando ping su ciascun nome host, verrai indirizzato all'indirizzo IP corretto come definito nel file /etc/hosts.

ping cplane1 -c3
ping worker1 -c3
ping worker2 -c3

Configurazione del firewall UFW

Kubernetes ha richiesto l'apertura di alcune porte su tutti i tuoi sistemi. Sul sistema Ubuntu predefinito, il firewall UFW viene utilizzato come firewall predefinito. Aggiungerai alcune porte al firewall UFW per la distribuzione di Kubernetes.

Per il piano di controllo Kubernetes, devi aprire le seguenti porte:

Protocol  Direction Port Range  Purpose Used By
-----------------------------------------------
TCP       Inbound   6443        Kubernetes API server All
TCP       Inbound   2379-2380   etcd server client API  kube-apiserver, etcd
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   10259       kube-scheduler  Self
TCP       Inbound   10257       kube-controller-manager Self

Per i nodi di lavoro Kubernetes, devi aprire le seguenti porte:

Protocol  Direction Port Range  Purpose Used By
--------------------------------------------------
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   30000-32767 NodePort Services†  All

Prima di aggiungere le regole UFW, assicurati di aggiungere l'applicazione OpenSSH al firewall utilizzando il comando seguente. Quindi, abilita il firewall UFW. Quando viene richiesta la conferma, immettere \y\ per abilitare ed eseguire il firewall UFW.

sudo ufw allow "OpenSSH"
sudo ufw enable

Sul nodo del piano di controllo \cplane1\, esegui il seguente comando ufw per aprire le porte.

sudo ufw allow 6443/tcp
sudo ufw allow 2379:2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10259/tcp
sudo ufw allow 10257/tcp

sudo ufw status

Sui nodi di lavoro \worker1\ e \worker2\, esegui il seguente comando ufw per aprire alcune porte.

sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp

sudo ufw status

Abilita i moduli kernel e disabilita SWAP

Kubernetes richiedeva che i moduli del kernel \overlay\ e \br_netfilter\ fossero abilitati su tutti i server. Ciò consentirà agli iptbales di vedere i traffici con bridge. Inoltre, dovrai abilitare il port forwarding e disabilitare lo SWAP.

Eseguire il seguente comando per abilitare i moduli del kernel \overlay\ e \br_netfilter\.

sudo modprobe overlay
sudo modprobe br_netfilter

Per renderlo permanente, crea il file di configurazione in \/etc/modules-load.d/k8s.conf\. Ciò consentirà ai sistemi Linux di abilitare i moduli del kernel durante l'avvio del sistema.

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

Successivamente, crea i parametri systemctl richiesti utilizzando il seguente comando.

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

Per applicare la nuova configurazione sysctl senza riavviare, utilizzare il seguente comando. Dovresti ottenere l'elenco dei parametri sysctl predefiniti sul tuo sistema e assicurarti di ottenere i parametri sysctl che hai appena aggiunto nel file \k8s.conf\.

sudo sysctl --system

Per disabilitare SWAP, dovrai commentare la configurazione di SWAP nel file \/etc/fstab\. Questo può essere fatto utilizzando il singolo comando tramite sed (editor di stream) o modificando manualmente il file /etc/fstab.

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

o

sudo nano /etc/fstab

Ora disattiva lo SWAP sulla sessione corrente utilizzando il comando seguente. Quindi, verifica che lo SWAP sia disattivato utilizzando il comando \free -m\. Dovresti vedere che lo SWAP ha valori \0\, il che significa che ora è disabilitato.

sudo swapoff -a
free -m

Installazione di Container Runtime: Containerd

Per configurare Kubernetes Cluster, devi installare il runtime del container su tutti i server in modo che i pod possano essere eseguiti. È possibile utilizzare più runtime di container per le distribuzioni di Kubernetes come containerd, CRI-O, Mirantis Container Runtime e Docker Engine (tramite cri-dockerd).

In questa dimostrazione, utilizzeremo il \containerd\ come contenitore per il nostro deployment Kubernetes. Quindi, installerai containerd su tutti i server, il piano di controllo e i nodi di lavoro.

Esistono diversi modi per installare containerd, il modo più semplice è utilizzare pacchetti binari predefiniti forniti dal repository Docker.

Ora esegui il seguente comando per aggiungere il repository Docker e la chiave GPG.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aggiorna e aggiorna l'indice del pacchetto sul tuo sistema Ubuntu usando il comando seguente.

sudo apt update

Ora installa il pacchetto containerd usando il comando apt di seguito. E l'installazione inizierà.

sudo apt install containerd.io

Al termine dell'installazione, eseguire il comando seguente per arrestare il servizio containerd.

sudo systemctl stop containerd

Eseguire il backup della configurazione containerd predefinita e generarne una nuova utilizzando il seguente comando.

sudo mv /etc/containerd/config.toml /etc/containerd/config.toml.orig
sudo containerd config default > /etc/containerd/config.toml

Ora modifica il file di configurazione containerd \/etc/containerd/config.toml\ usando il seguente comando.

sudo nano /etc/containerd/config.toml

Modificare il valore del driver cgroup \SystemdCgroup=false\ in \SystemdCgroup=true\. Ciò abiliterà il driver cgroup systemd per il runtime del contenitore containerd.

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  ...
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

Quando hai finito, salva e chiudi il file.

Successivamente, esegui il seguente comando systemctl per avviare il servizio containerd.

sudo systemctl start containerd

Infine, controlla e verifica il servizio containerd utilizzando il comando seguente. Dovresti vedere che containerd è abilitato e verrà eseguito automaticamente all'avvio del sistema. E lo stato attuale del servizio containerd è in esecuzione.

sudo systemctl is-enabled containerd
sudo systemctl status containerd

Installazione del pacchetto Kubernetes

Hai installato il runtime del contenitore containerd. Ora installerai i pacchetti Kubernetes su tutti i tuoi sistemi Ubuntu. Ciò include kubeadm per il bootstrap del cluster Kubernetes, kubelet il componente principale del cluster Kubernetes e kubectl l'utilità della riga di comando per la gestione del cluster Kubernetes.

In questo esempio, installeremo i pacchetti Kubernetes utilizzando il repository fornito da Kubernetes. Quindi, aggiungerai il repository Kubernetes a tutti i tuoi sistemi Ubuntu.

Eseguire il seguente comando apt per installare alcune dipendenze del pacchetto.

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

Ora aggiungi il repository Kubernetes e la chiave GPG utilizzando il seguente comando.

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Aggiorna e aggiorna il tuo repository Ubuntu e l'indice dei pacchetti.

sudo apt update

Al termine dell'aggiornamento, installa i pacchetti Kubernetes utilizzando il seguente comando apt. Immettere Y per confermare l'installazione e premere INVIO per continuare e l'installazione avrà inizio.

sudo apt install kubelet kubeadm kubectl

Al termine dell'installazione, esegui il comando seguente per bloccare la versione corrente dei pacchetti Kubernetes. Ciò impedirà l'aggiornamento automatico dei pacchetti Kubernetes e la differenza di versione tra i pacchetti Kubernetes.

sudo apt-mark hold kubelet kubeadm kubectl

Installazione del plug-in CNI (Container Network Interface): Flannel

Kubernetes supporta vari plug-in di rete di container come AWS VPC per Kubernetes, Azure CNI, Cilium, Calico, Flannel e molti altri. In questo esempio, utilizzeremo Flannel come plug-in CNI per la distribuzione di Kubernetes. E questo richiedeva l'installazione del file binario di Flannel tra i nodi Kubernetes.

Esegui il comando seguente per creare una nuova directory \/opt/bin\. Quindi, scarica il file binario di Flannel al suo interno.

mkdir -p /opt/bin/
sudo curl -fsSLo /opt/bin/flanneld https://github.com/flannel-io/flannel/releases/download/v0.19.0/flanneld-amd64

Ora rendi eseguibile il file binario \flanneld\ modificando i permessi del file usando il comando seguente. Questo file binario \flanneld\ verrà eseguito automaticamente quando configuri il componente aggiuntivo della rete Pod.

sudo chmod +x /opt/bin/flanneld

Inizializzazione del piano di controllo Kubernetes

Hai completato tutte le dipendenze e i requisiti per la distribuzione del cluster Kubernetes. Ora avvierai il cluster Kubernetes inizializzando il nodo del piano di controllo per la prima volta. In questo esempio, Kubernetes Control Plane verrà installato sul server \cplane1\ con l'indirizzo IP \192.168.5.10\.

Prima di inizializzare il nodo Control Plane, eseguire il seguente comando per verificare che i moduli del kernel \br_netfilter\ siano abilitati. Se ottieni un output dal comando, significa che il modulo \br_netfilter\ è abilitato.

lsmod | grep br_netfilter

Successivamente, esegui il comando seguente per scaricare le immagini necessarie per il cluster Kubernetes. Questo comando scaricherà tutte le immagini del contenitore necessarie per la creazione del cluster Kubernetes come coredns, kube-api server, etcd, kube-controller, kube-proxy e l'immagine del contenitore di pausa.

sudo kubeadm config images pull

Al termine del download, esegui il seguente comando \kubeadm init\ per inizializzare il cluster Kubernetes sul server \cplane1\. Questo nodo \cplane1\ verrà selezionato automaticamente come piano di controllo Kubernetes perché questa è la prima volta che inizializza il cluster.

  • Inoltre, in questo esempio, specifichiamo la rete per i pod su \10.244.0.0/16\, che è l'intervallo di rete predefinito per il plug-in Flannel CNI.
  • \--apiserver-advertise-address\ determina in quale indirizzo IP verrà eseguito il server API Kubernetes, questo esempio utilizza l'indirizzo IP interno \192.168.5.10\.
  • Per l'opzione \--cri-socket\ qui, specifichiamo il socket CRI al socket di runtime del contenitore che è disponibile su \/run/containerd/containerd.sock\ . Se stai utilizzando Container Runtime diverso, devi modificare il percorso del file socket oppure puoi semplicemente rimuovere questa opzione \--cri-socket\ perché kubeadm rileverà automaticamente il socket Container Runtime. 

sudo kubeadm init --pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=192.168.5.10 \
--cri-socket=unix:///run/containerd/containerd.sock

Di seguito è riportato l'output quando si inizializza il cluster Kubernetes sul server \cplane1\.

Al termine dell'inizializzazione, puoi visualizzare un messaggio del tipo \Il tuo piano di controllo Kubernetes è stato inizializzato correttamente!\ con alcuni importanti messaggi di output per l'impostazione delle credenziali Kubernetes e la distribuzione del componente aggiuntivo di rete Pod, la procedura per aggiungere il nodo di lavoro al tuo cluster Kubernetes.

Prima di iniziare a utilizzare il cluster Kubernetes, dovrai configurare le credenziali Kubernetes. Esegui il comando seguente per configurare le credenziali Kubernetes.

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

Ora puoi utilizzare il comando \kubectl\ per interagire con il tuo cluster Kubernetes. Esegui il seguente comando \kubectl\ per verificare le informazioni sul cluster Kubernetes. E dovresti vedere il piano di controllo Kubernetes e i core in esecuzione.

kubectl cluster-info

Per ottenere informazioni complete sul tuo Kubernetes, puoi utilizzare l'opzione dump, quindi \kubectl cluster-info dump\.

Dopo che Kubernetes Control Plane è in esecuzione, esegui il seguente comando per installare il plug-in di rete Flannel Pod. Questo comando eseguirà automaticamente il file binario \flanneld\ ed eseguirà alcuni baccelli di flanella.

kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

Controlla l'elenco dei pod in esecuzione sul tuo Kubernetes utilizzando il seguente comando. se l'installazione di Kubernetes ha esito positivo, dovresti vedere tutti i pod principali per Kubernetes in esecuzione.

kubectl get pods --all-namespaces

Aggiunta di nodi di lavoro a Kubernetes

Dopo aver inizializzato il piano di controllo Kubernetes sul server \cplane1\, aggiungerai i nodi di lavoro \worker1\ e \worker2\ al cluster Kubernetes.

Passa al server \worker1\ ed esegui il comando \kubeadm join\ seguente per aggiungere \worker1\ al cluster Kubernetes. Potresti avere token e hash ca-cert diversi, puoi vedere i dettagli di queste informazioni sul messaggio di output quando inizializzi il nodo del piano di controllo.

kubeadm join 192.168.5.10:6443 --token po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

Nel seguente output, puoi vedere che il server \worker1\ è unito dal cluster Kubernetes.

Successivamente, passa al server \worker2\ ed esegui il comando \kubeadm join\ per aggiungere \worker2\ al cluster Kubernetes.

kubeadm join 192.168.5.10:6443 --token po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

Vedrai lo stesso messaggio di output al termine del processo.

Ora torna al server del piano di controllo cplane1\ ed esegui il seguente comando per controllare tutti i pod in esecuzione sul cluster Kubernetes. Dovresti vedere che ci sono pod aggiuntivi su ogni componente Kubernetes.

kubectl get pods --all-namespaces

Infine, controlla e verifica tutti i nodi disponibili sul cluster Kubernetes utilizzando il comando kubectl\ riportato di seguito. Dovresti vedere che il server cplane1\ è in esecuzione come piano di controllo Kubernetes e il server \worker1\ e i server \worker2\ sono in esecuzione come nodo di lavoro.

kubectl get nodes -o wide

Conclusione

Durante questo tutorial, hai terminato la distribuzione del cluster Kubernetes con server Ubuntu 22.04 a tre nodi. Il cluster Kubernetes è in esecuzione con un piano di controllo e due nodi di lavoro. È in esecuzione con containerd come container runtime per il tuo cluster Kubernetes e il plug-in di rete Flannel per il collegamento in rete dei pod sul tuo cluster. Hai configurato Kubernetes Cluster completamente, puoi iniziare a distribuire le tue applicazioni nel cluster Kubernetes o provare a installare Kubernetes Dashboard per saperne di più sul tuo ambiente Kubernetes.