Come installare un cluster Kubernetes con Kubeadm su Rocky Linux

Su questa pagina

Prerequisiti
Impostazione dei sistemi
Imposta il file /etc/hosts
Configurazione delle regole del firewall
Imposta SELinux e i moduli del kernel e disabilita SWAP
Installazione di Container Runtime: Containerd
Installazione dei pacchetti Kubernetes
Installazione del plug-in CNI: Flannel
Inizializzazione del piano di controllo Kubernetes
Aggiunta di nodi di lavoro a Kubernetes
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:

Impostazione dei sistemi, che include: installazione del file /etc/hosts, installazione di SELinux, abilitazione dei moduli del kernel e disabilitazione di SWAP.
Impostazione di Firewalld aggiungendo alcune porte necessarie per Kubernetes.
Installazione di containerd come runtime del contenitore per Kubernetes.
Installazione di pacchetti Kubernetes come kubelet, kubeadm e kubectl.
Installazione del plug-in di rete Flannel per i pod Kubernetes.
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 Rocky Linux.
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 Firewalld: per l'ambiente di produzione, si consiglia sempre di abilitare il firewall sia sul piano di controllo che sui nodi di lavoro.
Setup SELinux: per questo esempio, cambieremo la regola predefinita di SELinux in \permissive\.
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
-------------------------------------------------------
kube-master           192.168.5.10      control-plane
kube-kube-worker1     192.168.5.15      worker node
kube-kube-worker2     192.168.5.16      worker node

Esegui il comando hostnamectl seguente per impostare il nome host di sistema su ciascun server.

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

sudo hostnamectl set-hostname kube-master

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

# setup hostname kube-worker1
sudo hostnamectl set-hostname kube-worker1

# setup hostname kube-worker2
sudo hostnamectl set-hostname kube-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 kube-master
192.168.5.15 kube-worker1
192.168.5.16 kube-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 kube-master -c3
ping kube-worker1 -c3
ping kube-worker2 -c3

Configurazione delle regole del firewall

Kubernetes richiedeva che alcune porte fossero aperte su tutti i tuoi sistemi. Sul sistema predefinito basato su RHEL, Firewalld è l'applicazione firewall predefinita. Aggiungerai alcune porte al Firewalld 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

Sul nodo del piano di controllo \kube-master\, esegui il seguente comando firewall-cmd per aprire le porte del piano di controllo Kubernetes. Quindi, ricarica le regole di Firewalld e verifica l'elenco delle regole disponibili.

sudo firewall-cmd --add-port=6443/tcp --permanent
sudo firewall-cmd --add-port=2379-2380/tcp --permanent
sudo firewall-cmd --add-port=10250/tcp --permanent
sudo firewall-cmd --add-port=10259/tcp --permanent
sudo firewall-cmd --add-port=10257/tcp --permanent

sudo firewall-cmd --reload
sudo firewall-cmd --list-all

Sui nodi di lavoro \kube-worker1\ e \kube-worker2\, esegui il seguente comando firewall-cmd per aprire alcune porte di lavoro Kubernetes. Quindi, ricarica Firewalld e verifica l'elenco delle regole disponibili su Firewalld.

sudo firewall-cmd --add-port=10250/tcp --permanent
sudo firewall-cmd --add-port=30000-32767/tcp --permanent

sudo firewall-cmd --reload
sudo firewall-cmd --list-all

Configura SELinux e i moduli del kernel e disabilita SWAP

Per fare in modo che il servizio Kubernetes kubelet funzioni correttamente, dovrai modificare il valore predefinito di SELinux in \permissive\ oppure puoi disabilitare completamente SELinux. In questo esempio, cambierai la policy di SELinux da \enforcing\ a \permissive\, il che significa che riceverai notifiche solo da SELinux.

Esegui il comando seguente per modificare la policy SELinux predefinita in \permissive\. Quindi, controlla e verifica lo stato corrente della policy SELinux. Dovresti vedere che SELinux è ancora abilitato, ma con la policy \permissive\.

sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

sestatus

Successivamente, Kubernetes ha richiesto 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

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 questo esempio, useremo \containerd\ come contenitore per la nostra distribuzione Kubernetes. Quindi, installerai containerd su tutti i nodi Kubernetes. E ci sono diversi modi per installare containerd, il modo più semplice è utilizzare pacchetti binari predefiniti forniti dal repository Docker.

Prima di aggiungere il repository, eseguire il comando DNF seguente per installare strumenti aggiuntivi \dnf-utils\.

sudo dnf install dnf-utils

Ora esegui il seguente comando per aggiungere il repository Docker per i sistemi basati su CentOS.

sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Esegui il seguente comando per controllare e verificare i repository sui tuoi sistemi Rocky Linux. Quindi, genera una nuova cache dei metadati. Vedrai che il repository Docker viene aggiunto a Rocky Linux.

sudo dnf repolist
sudo dnf makecache

Successivamente, installa il pacchetto containerd utilizzando il comando DNF di seguito. Immettere Y per confermare l'installazione e premere INVIO e l'installazione avrà inizio. Quando ti viene chiesto di importare la chiave GPG di Docker, inserisci y per aggiungere.

sudo dnf install containerd.io

Al termine dell'installazione, eseguire il comando seguente per eseguire il backup della configurazione containerd predefinita e generare un nuovo file di configurazione containerd.

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.

Eseguire quindi il seguente comando systemctl per avviare e abilitare il servizio containerd. Questo aggiungerà il servizio containerd da eseguire automaticamente all'avvio del sistema.

sudo systemctl enable --now 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 dei pacchetti Kubernetes

Hai installato il runtime del contenitore containerd. Ora installerai i pacchetti Kubernetes su tutti i tuoi sistemi Rocky Linux. 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 Rocky Linux.

Eseguire il comando seguente per aggiungere il repository Kubernetes per i sistemi operativi basati su RHEL/CentOS.

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
enabled=1
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

Ora controlla l'elenco dei repository e genera una nuova cache dei metadati utilizzando il comando dnf di seguito. E dovresti vedere che il repository Kubernetes è stato aggiunto ai sistemi Rocky Linux.

sudo dnf repolist
sudo dnf makecache

Successivamente, installa i pacchetti Kubernetes utilizzando il seguente comando dnf. Immettere Y per confermare l'installazione e premere INVIO per continuare e l'installazione avrà inizio.

sudo dnf install kubelet kubeadm kubectl --disableexcludes=kubernetes

Al termine dell'installazione, esegui il seguente comando systemctl per avviare e abilitare il servizio kubelet. Quindi, controlla il servizio kubelet e assicurati che sia abilitato e in esecuzione su tutti i nodi.

Questo servizio è il servizio Kubernetes principale che attenderà qualsiasi evento quando inizializzi il cluster o unisci il nodo al cluster.

sudo systemctl enable --now kubelet

Installazione del plug-in CNI: 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 \kubem-master\ 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 ricevi 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 \kube-master\. Questo nodo \kube-master\ 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

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 che tutti i pod principali per Kubernetes, inclusi i pod Flannel, sono in esecuzione.

kubectl get pods --all-namespaces

Aggiunta di nodi di lavoro a Kubernetes

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

Passa al server \kube-worker1\ ed esegui il comando \kubeadm join\ seguente per aggiungere \kube-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 wlg23u.r5x2nxw2vdu95dvp \
        --discovery-token-ca-cert-hash sha256:71fd28ac2b8108a3d493648a9c702acd2e39a8a0e7efc07326d7b0384c929066

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

Successivamente, passa al server \kube-worker2\ ed esegui il comando \kubeadm join\ per aggiungere \kube-worker2\ a Kubernetes Grappolo.

kubeadm join 192.168.5.10:6443 --token wlg23u.r5x2nxw2vdu95dvp \
        --discovery-token-ca-cert-hash sha256:71fd28ac2b8108a3d493648a9c702acd2e39a8a0e7efc07326d7b0384c929066

Vedrai lo stesso messaggio di output al termine del processo.

Ora torna al server del piano di controllo kube-master\ ed esegui il seguente comando per controllare tutti i pod in esecuzione per tutti gli spazi dei nomi 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\ di seguito. Dovresti vedere che il server kube-master\ è in esecuzione come piano di controllo Kubernetes e \kube-worker1\ e\i server kube-worker2\ sono in esecuzione come nodo di lavoro.

kubectl get nodes -o wide

Conclusione

Durante questo tutorial, hai completato la distribuzione del cluster Kubernetes con tre server Rocky Linux. 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.