Come installare il cluster Kubernetes (k8s) su RHEL 8

Conosciuto anche come k8s, Kubernetes è una piattaforma di orchestrazione di container opensource e portatile per automatizzare la distribuzione e la gestione di applicazioni containerizzate. Kubernetes è stato originariamente creato da Google nel linguaggio di programmazione Go. Attualmente è gestito da Cloud Native Computing Foundation.

In questa guida, ti illustreremo passo dopo passo come installare un cluster Kubernetes su RHEL 8. Lo dimostreremo utilizzando un nodo principale e un nodo di lavoro che aggiungeremo al nostro cluster.

Configurazione del laboratorio

• Nodo principale:        master-node-k8        10.128.15.228
• Nodo di lavoro:      nodo di lavoro-1-k8     10.128.15.230

NOTA:i passaggi da 1 a 6 devono essere applicati sia al nodo principale che al nodo di lavoro.

Passaggio 1) Disabilita lo spazio di scambio

Per prestazioni ottimali, Kubernetes richiede che lo scambio sia disabilitato sul sistema host. Questo perché lo scambio di memoria può portare a instabilità e degrado delle prestazioni in modo significativo.

Per disabilitare lo spazio di scambio, esegui il comando:

$ sudo swapoff -a

Per rendere persistenti le modifiche, modifica il file /etc/fstab e rimuovi o commenta la riga con la voce di scambio e salva le modifiche.

Passaggio 2) Disabilita SELinux

Inoltre, dobbiamo disabilitare SELinux e impostarlo su "permissivo" per consentire una comunicazione fluida tra i nodi e i pod.

Per ottenere ciò, apri il file di configurazione di SELinux.

$ sudo vi /etc/selinux/config

Modificare il valore SELINUX da vincolante a permissivo.

SELINUX=permissivo

In alternativa, puoi usare il comando sed come segue.

$ sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissivo/' /etc/selinux/config

Fase 3) Configura la rete nel nodo master e di lavoro

È necessaria una configurazione di rete aggiuntiva per consentire ai nodi master e di lavoro di comunicare in modo efficace. Su ciascun nodo, modifica il file  /etc/hosts.

$ sudo vi /etc/hosts

Quindi, aggiorna le voci come mostrato

10.128.15.228 master-node-k8 // Per il nodo Master10.128.15.230 worker-node-1-k8 // Per il nodo di lavoro

Salva ed esci dal file di configurazione. Quindi, installa il pacchetto di utilità di controllo del traffico:

$ sudo dnf install -y iproute-tc

Passaggio 4) Consenti regole firewall per k8s

Per una comunicazione senza interruzioni tra il nodo principale e quello di lavoro, è necessario configurare il firewall e consentire alcune porte e servizi pertinenti come descritto di seguito.

Sul nodo Master, consenti le seguenti porte,

$ sudo firewall-cmd --permanent --add-port=6443/tcp$ sudo firewall-cmd --permanent --add-port=2379-2380/tcp$ sudo firewall-cmd --permanent --add -port=10250/tcp$ sudo firewall-cmd --permanent --add-port=10251/tcp$ sudo firewall-cmd --permanent --add-port=10252/tcp$ sudo firewall-cmd --reload

Sul nodo di lavoro, consenti le seguenti porte,

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

Passaggio 5) Installa il runtime del contenitore CRI-O

Kubernetes richiede un runtime del contenitore per l'esecuzione dei pod. Kubernetes 1.23 e versioni successive richiedono l'installazione di un runtime del contenitore che confermi con l'interfaccia di runtime del contenitore.

Un Container Runtime è un'applicazione che supporta l'esecuzione di container. Kubernetes supporta il seguente Container Runtime:

• Contenitore
• CRI-O
• Motore Docker
• Runtime del contenitore Mirantis

In questa guida installeremo CRI-O che è un runtime di container di alto livello. Per farlo, dobbiamo abilitare due moduli fondamentali del kernel:overlay e br_netfilter.

Per ottenere ciò, dobbiamo configurare i prerequisiti come segue:

Innanzitutto, crea un file di configurazione dei moduli per Kubernetes.

$ sudo vi /etc/modules-load.d/k8s.conf

Aggiungi queste righe e salva le modifiche

overlaybr_netfilter

Quindi carica entrambi i moduli usando il comando modprobe.

$ sudo modprobe overlay$ sudo modprobe br_netfilter

Quindi, configura i parametri sysctl richiesti come segue

$ sudo vi /etc/sysctl.d/k8s.conf

Aggiungi le seguenti righe:

net.bridge.bridge-nf-call-iptables  =1net.ipv4.ip_forward                =1net.bridge.bridge-nf-call-ip6tables =1

Salva le modifiche ed esci. Per confermare che le modifiche sono state applicate, esegui il comando:

$ sudo sysctl --system

Per installare CRI-O, imposta la variabile di ambiente $VERSION in modo che corrisponda alla tua versione CRI-O. Ad esempio, per installare CRI-O versione 1.21, impostare $VERSION come mostrato:

$ export VERSION=1.21

Quindi, esegui i seguenti comandi:

$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable /CentOS_8/devel:kubic:libcontainers:stable.repo

$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo https://download.opensuse.org/repositories/devel:kubic :libcontainers:stable:cri-o:$VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo

Quindi usa il gestore di pacchetti DNF per installare CRI-O:

$ sudo dnf install cri-o

Quindi, abilita CRI-O all'avvio e avvialo:

$ sudo systemctl abilita cri-o$ sudo systemctl avvia cri-o

Passaggio 6) Installa i pacchetti Kubernetes

Con tutto il necessario per il funzionamento di Kubernetes installato, andiamo avanti e installiamo i pacchetti Kubernetes come kubelet, kubeadm e kubectl. Crea un file di repository Kubernetes.

$ sudo vi /etc/yum.repos.d/kubernetes.repo

E aggiungi le seguenti righe.

[kubernetes]name=Kubernetesbaseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64enabled=1gpgcheck=1repo_gpgcheck=1gpgkey=https://packages.cloud.google.com/ yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpgexclude=kubelet kubeadm kubectl

Salva le modifiche ed esci. Infine, installa il pacchetto k8s come segue.

$ sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

Una volta installato, assicurati di abilitare e avviare il servizio Kubelet.

$ sudo systemctl abilita kubelet$ sudo systemctl avvia kubelet

A questo punto, siamo pronti per installare il cluster Kubernetes.

Passaggio 7)  Crea un cluster Kubernetes

Inizializzeremo un cluster Kubernetes usando il comando kubeadm come segue. Questo inizializza un piano di controllo nel nodo master.

$ sudo kubeadm init --pod-network-cidr=192.168.10.0/16

Una volta creato il piano di controllo, ti verrà richiesto di eseguire alcuni comandi aggiuntivi per iniziare a utilizzare il cluster.

Pertanto, esegui i comandi, in sequenza.

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

Alla fine dell'output, ti verrà dato il comando da eseguire sui nodi di lavoro per entrare a far parte del cluster. Ci arriveremo più avanti nel passaggio successivo.

Inoltre, assicurati di rimuovere le contaminazioni dal nodo master:

$ kubectl taint nodes –all node-role.kubernetes.io/master-

Passaggio 8) Installa il componente aggiuntivo Calico Pod Network

Il prossimo passo è installare Calico CNI (Container Network Interface). È un progetto opensource utilizzato per fornire sicurezza e networking di container. Dopo aver installato Calico CNI, lo stato dei nodi passerà allo stato Pronto, il servizio DNS all'interno del cluster sarà funzionante e i container potranno iniziare a comunicare tra loro.

Calico offre scalabilità, prestazioni elevate e interoperabilità con i carichi di lavoro Kubernetes esistenti. Può essere distribuito in locale e su tecnologie cloud popolari come Google Cloud, AWS e Azure.

Per installare Calico CNI, esegui il seguente comando dal nodo master

$ kubectl create -f https://docs.projectcalico.org/manifests/tigera-operator.yaml

Una volta completato, esegui questo.

$ kubectl create -f https://docs.projectcalico.org/manifests/custom-resources.yaml

Per confermare se i pod sono stati avviati, esegui il comando:

$ watch kubectl get pods -n calico-system

Dovresti vedere che ogni pod è "PRONTO" e ha lo stato "IN ESECUZIONE" come mostrato nella terza colonna.

Per verificare la disponibilità del nodo master nel cluster, eseguire il comando:

$ kubectl ottieni nodi

Inoltre, puoi recuperare più informazioni usando le opzioni -o wide.

$ kubectl get nodes -o wide

L'output di cui sopra conferma che il nodo master è pronto. Inoltre, puoi controllare gli spazi dei nomi del pod:

$ kubectl get pods --all-namespaces

Passaggio 9) Aggiunta del nodo di lavoro al cluster

Per aggiungere il nodo di lavoro al cluster Kubernetes, segui il passaggio 1 fino al passaggio 6.  Al termine, esegui il comando generato dal nodo master per unire un nodo di lavoro al cluster. Nel nostro caso, questo sarà:

$ sudo kubeadm join 10.128.15.228:6443 --token cqb8vy.iicmmqrb1m8u9cob --discovery-token-ca-cert-hash sha256:79748a56f603e6cc57f67bf90b7db5aebe090107d540d6cc8a8f654b785>3 

 Se tutto va bene, dovresti ricevere la notifica che il nodo si è unito al cluster. Ripeti la stessa procedura per altri nodi nel caso tu abbia più nodi di lavoro
 

 
 

 Ora torna al nodo master e, ancora una volta, verifica i nodi nel tuo cluster. Questa volta, il nodo di lavoro apparirà nell'elenco dei nodi nel cluster
 
$ kubectl ottieni nodi
 

 
 
Conclusione
 

 Questa è stata una panoramica su come installare un cluster Kubernetes su RHEL 8. Il tuo feedback su questa guida è il benvenuto.