Come installare Kubernetes su Ubuntu

L’implementazione manuale dei contenitori Docker su più server può richiedere molto tempo, monopolizzando l’agenda di qualsiasi amministratore di sistema incaricato di svolgere tale compito. Nel settore IT moderno, la popolarità dei cloud, dei microservizi e dei contenitori continua a crescere e, per questo motivo, sono state sviluppate soluzioni come Kubernetes.Kubernetes è una soluzione open source per la gestione e l’orchestrazione dei contenitori che consente di creare un cluster per facilitare l’implementazione dei contenitori in ambienti distribuiti e fornire un’elevata disponibilità per le applicazioni containerizzate. L’obiettivo di questo post sul blog è quello di esplorare come installare Kubernetes su Ubuntu per eseguire applicazioni in contenitori Docker.

NAKIVO for VMware vSphere Backup

Complete data protection for VMware vSphere VMs and instant recovery options. Secure backup targets onsite, offsite and in the cloud. Anti-ransomware features.

DISCOVER SOLUTION

Requisiti e configurazione di sistema per l’installazione di Kubernetes su Ubuntu

Il cluster Kubernetes è composto da nodi master e nodi worker. La configurazione hardware dipende dalle vostre esigenze e dalle applicazioni che intendete eseguire nei contenitori Docker. I requisiti hardware minimi per l’installazione di Kubernetes su Ubuntu sono:

• Almeno una CPU (unità di elaborazione centrale) x86/x64 a 2 core
• 2 GB di RAM (memoria ad accesso casuale) o superiore
• Accesso a Internet

Porte che devono essere aperte per installare Kubernetes su Ubuntu:

Per impostazione predefinita, il firewall iptables è installato su Ubuntu, ma non ci sono regole di blocco “pronte all’uso”. Pertanto, se stai installando Ubuntu per provare Kubernetes, non è necessario modificare le regole del firewall. Kube-proxy posiziona prima le sue catene iptables, quindi inserisce due regole iptables. Queste regole sono KUBE-EXTERNAL-SERVICES e KUBE-FIREWALL, che vengono inserite nella parte superiore della catena INPUT.L’installazione di Kubernetes su Ubuntu può essere eseguita sia su macchine fisiche che su VM. La raccomandazione generale è di utilizzare l’ultima versione di Ubuntu Linux a 64 bit. Il post del blog di oggi spiega come installare Kubernetes su Ubuntu 18.04 LTS in esecuzione su macchine virtuali VMware. Il primo tipo di implementazione di Kubernetes spiegato è con un nodo master e due nodi worker utilizzati per il cluster Kubernetes. Vedere la tabella seguente per visualizzare il numero condizionale di nodi, i ruoli dei nodi, i nomi host e gli indirizzi IP delle macchine utilizzate nell’esempio considerato.

È possibile utilizzare VM in esecuzione su Host VMware ESXi se si utilizza VMware vSphere, oppure è possibile eseguire VM su VMware Workstation installato sul proprio personal computer con Linux o Windows. Nell’esempio odierno utilizziamo VM in esecuzione su VMware Workstation. Le VM utilizzano il NAT. rete con accesso a Internet, e se preferisci VirtualBox a VMware, è possibile utilizzarlo.L’indirizzo IP della macchina host: 10.10.10.53L’indirizzo IP del gateway virtuale per la rete NAT (VMNet8): 192.168.101.2Lo stesso utente Linux esiste su tutte le macchine Ubuntu: kubernetes-utenteConfigurazione VM: 2 CPU, 4 GB di RAM, disco virtuale da 20 GBÈ possibile modificare gli indirizzi IP di VMnet8 andando su Edit > Virtual Network Editor en VMware Workstation.Para una mejor comprensión, en el ejemplo de hoy todos los componentes se instalarán manualmente en Linux sin herramientas de automatización como Ansible.

Implementazione della VM Ubuntu

Crea una nuova VM con il nome is docker-nakivo21.Installa Ubuntu 64-bit sulla prima macchina e imposta il nome host e il nome utente.Nome della VM: docker-nakivo21Nome utente: kubernetes-utenteInstalla VMware Tools dopo il primo accesso al sistema operativo installato. Se utilizzi macchine fisiche, non è necessario utilizzare VMware Tools e puoi saltare questo passaggio.Nota: Il $ Il carattere all’inizio indica che un comando viene eseguito come utente normale (kubernetes-utente in questo caso). Se la stringa inizia con il carattere # carattere, il comando deve essere eseguito come radice. Il sudo Il comando (substitute user do o utente con privilegi avanzati do) consente di eseguire comandi come un altro utente, incluso root. È possibile digitare sudo -i per ottenere i privilegi di root nella console. Premere Ctrl+D per uscire dalla modalità root.È possibile installare VMware Tools dall’immagine ISO fornita con l’hypervisor VMware o dai repository Linux (come spiegato di seguito).$ sudo apt-get install open-vm-toolsSe hai bisogno di un’esperienza desktop avanzata come gli appunti condivisi, trascinamento & per rilasciare file ecc., eseguire:$ sudo apt-get install open-vm-tools-desktopRiavvia la VM.$ init 6

Configura il tuo computer Ubuntu prima di installare Kubernetes

Prima di installare Kubernetes su macchine Ubuntu è necessario effettuare alcuni preparativi. Innanzitutto, è necessario configurare l’indirizzo IP statico e il nome host per qualsiasi server normale.

Imposta l’indirizzo IP statico

Come per qualsiasi altro tipo di cluster, si consiglia vivamente di utilizzare indirizzi IP statici sui nodi.Installare gli strumenti di rete Linux prima di impostare l’indirizzo IP.$ sudo apt-get install net-toolsTipo ifconfig per verificare l’indirizzo IP corrente della tua VM Ubuntu.È possibile vedere che l’indirizzo IP viene ottenuto automaticamente tramite DHCP. Ricordare il nome dell’interfaccia di rete. Nell’esempio attuale questo nome è ens33. Il nome della prima interfaccia di rete Ethernet è solitamente eth0 per macchine fisiche.È necessario un editor di testo per modificare i file di configurazione. Installare vim come editor di testo.$ sudo apt-get install vimNelle ultime versioni di Ubuntu, la configurazione di rete è impostata nel file yaml. Apri il file yaml di configurazione di rete in vim.$ sudo vim /etc/netplan/01-network-manager-all.yamlLa visualizzazione predefinita del file di configurazione è:Modifica questo file di configurazione di rete come mostrato di seguito:network: version: 2 renderer: networkd ethernets: ens33: dhcp4: no addresses: [192.168.101.21/24] gateway4: 192.168.101.2 nameservers: addresses: [192.168.101.2,8.8.8.8]Salva le modifiche e esci.:wq$ sudo netplan tryPremere INVIO per accettare la nuova configurazione.Verificare se la configurazione di rete è stata modificata e provare a eseguire il ping, ad esempio, nakivo.com.$ ifconfig$ ping nakivo.com

Configurare un nome host

Controlla il tuo nome host attuale.$ hostnamectlCome ricorderete, il nome host della prima VM è docker-nakivo21 è già stato configurato durante l’installazione. Per modificare il nome host, procedere come segue (ciò sarà necessario per configurare la seconda e la terza VM dopo la clonazione. Queste due VM sono destinate a essere configurate come nodi di lavoro):Ad esempio, se è necessario modificare il nome host in docker-nakivo21 sulla prima VM, eseguire:$ sudo hostnamectl set-hostname docker-nakivo21Verificare che sia stato applicato un nuovo nome host.$ less /etc/hostnameModifica il host file.$ sudo vim /etc/hostsIl contenuto del file host deve essere simile al seguente:127.0.0.1 localhost127.0.1.1 docker-nakivo21Riavviare la macchina.$ init 6

Disabilita un file di swap

L’uso di un file di swap (partizione di swap) non è supportato da Kubernetes ed è necessario disabilitare lo swappiness per installare correttamente Kubernetes su Ubuntu.Disabilita un file di swap per evitare un elevato utilizzo della CPU da parte di kubelet.$ sudo swapoff -aModifica /etc/fstab e commentare la stringa utilizzando il # carattere.$ sudo vim /etc/fstab#/swapfile nessuno swap sw 0 0Puoi fare lo stesso con sed con un solo comando:$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstabDisabilita swap in sysctl.conf$ sudo echo \"vm.swappiness=0\" | sudo tee --append /etc/sysctl.confDove 0 è la percentuale di swapiness. In questo caso lo swap può essere utilizzato solo se si esaurisce la RAM (per impostazione predefinita lo swap viene utilizzato quando più del 60% della RAM è piena).Applica le modifiche alla configurazione senza riavviare.$ sudo sysctl -pNota: Se la partizione di swap non è disabilitata, il kswapd0 Il processo di Ubuntu Linux che esegue Kubernetes può consumare una grande quantità di risorse della CPU sul computer, causando il blocco delle applicazioni e il blocco del sistema. Ciò accade quando il sistema operativo esaurisce la memoria e le vecchie pagine di memoria vengono spostate nello swap da un processo di sistema del kernel Linux. Per motivi sconosciuti, a volte qualcosa va storto e si verifica un ciclo infinito che consuma tutte le risorse della CPU. Nello screenshot qui sotto, è possibile vedere l’elevato consumo della CPU da parte di kswapd0 processo quando Kubernetes è installato su Ubuntu. Il valore medio di carico è eccessivamente alto.Se kswapd0 continua a sovraccaricare la CPU, esegui il seguente comando per invalidare tutte le cache di memoria e interrompere kswapd0 (eseguire come root).# echo 1 > /proc/sys/vm/drop_cachesSpegnere la VM.$ init 0Questa VM parzialmente configurata (docker-nakivo21) sta per essere utilizzato come nodo master. Creare due macchine da utilizzare come nodi di lavoro. Se si utilizzano macchine fisiche, ripetere manualmente i passaggi precedenti (oppure utilizzare strumenti di automazione come Ansible per configurare più macchine Linux contemporaneamente tramite SSH). Poiché nell’esempio corrente vengono utilizzate VM, è possibile clonarle per risparmiare tempo durante la preparazione dell’ambiente per l’installazione di Kubernetes su macchine Ubuntu.

Clona la VM

Clona la tua prima VM. Se utilizzi VMware ESXi, puoi utilizzare la funzione di clonazione integrata. Scopri di più su questo argomento leggendo il nostro post sul blog all’indirizzo clonazione di VM utilizzando modelli di VM. Se utilizzi VMware Workstation, puoi anche clonare le VM utilizzando due metodi (strumento di clonazione integrato e manualmente). Puoi fare clic su VM > Manage > Clone per creare un clone collegato. Creiamo un clone completo della prima VM e copiamo manualmente i file della VM. In questo caso i file vengono copiati da docker-nakivo21 directory a docker-nakivo31. Le directory devono essere create manualmente prima di copiare i file VM.Modifica il file VMX, poiché il nome della VM e il percorso del file del disco virtuale sono stati modificati.displayName = \"docker-nakivo31\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo31.vmdk\"nvram = \"docker-nakivo31.nvram\"La VM che verrà utilizzata come primo nodo di lavoro è stata creata. Clona nuovamente la prima VM per preparare il secondo nodo di lavoro del cluster Kubernetes.Modifica il file VMX per la terza VM (il secondo nodo di lavoro), come hai fatto in precedenza.displayName = \"docker-nakivo32\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo32.vmdk\"nvram = \"docker-nakivo32.nvram\"Apri i cloni VM in VMware Workstation (File> Open e selezionare il file VMX della VM), oppure fare doppio clic sul file VMX della VM. Accendere tre VM (la VM di origine e due cloni della VM). Fare clic su L’ho copiato, quando richiesto.Nota: Se utilizzi VM, modifica l’indirizzo IP e il nome host su ogni clone VM una volta che le VM sono state clonate. Se utilizzi macchine fisiche, segui tutti i passaggi precedenti in base agli indirizzi IP e ai nomi host di ciascuna macchina.

Configurazione degli indirizzi IP e dei nomi host sulle VM

Modifica l’indirizzo IP e il nome host su docker-nakivo31 e docker-nakivo32 VM (come mostrato sopra).Ripetere i passaggi spiegati nelle sezioni precedenti per configurare gli indirizzi IP statici e i nomi host.L’indirizzo IP deve essere: 192.168.101.31 e 192.168.101.32; i nomi host devono essere docker-nakivo31 e docker-nakivo32 di conseguenza sui nodi worker.Tutte le macchine devono essere configurate per risolvere i nomi host dei nodi in indirizzi IP. È possibile configurare un server DNS o modificare manualmente il file host file su ogni macchina. Modifichiamo host.Aggiungi le seguenti stringhe al file host file su ogni macchina (docker-nakivo21, docker-nakivo31, docker-nakivo32).$ sudo vim /etc/hostsAggiungi queste righe al file host file:192.168.101.21 docker-nakivo21192.168.101.31 docker-nakivo31192.168.101.32 docker-nakivo32Eseguire il ping di altri host da ciascun host per assicurarsi che i nomi host siano risolti:$ ping docker-nakivo21$ ping docker-nakivo31$ ping docker-nakivo32

Configurare l’accesso SSH su tutti gli host (VM)

Configurare l’accesso SSH su tutti gli host. Installare il server OpenSSH eseguendo i comandi su ciascuna macchina.$ sudo apt-get install openssh-serverVai alla directory home di kubernetes-utente e generare la coppia di chiavi SSH (un insieme di chiavi crittografiche composto da una chiave privata e una chiave pubblica). Le coppie di chiavi SSH possono essere utilizzate per accedere alla console Linux remota tramite SSH senza utilizzare password. La chiave pubblica può essere copiata su un computer dal quale è necessario connettersi in remoto, mentre la chiave privata è altamente riservata e deve essere memorizzata sul computer al quale è necessario connettersi.$ ssh-keygenNon è necessario inserire la password per la generazione delle chiavi (la password è facoltativa).Copiare le chiavi su altre macchine Ubuntu:$ ssh-copy-id kubernetes-user@192.168.101.31$ ssh-copy-id kubernetes-user@192.168.101.32Inserisci la tua password utente per confermare la copia delle chiavi.Prova a connetterti alla seconda macchina (docker-nakivo31) come kubernetes-utente (ovvero un utente regolare).$ ssh 'kubernetes-user@192.168.101.31'Quindi eseguire il test della connessione alla terza macchina (docker-nakivo32).$ ssh 'kubernetes-user@192.168.101.32'Dopo aver effettuato correttamente la connessione, vedrai il nome del computer remoto nel prompt dei comandi della tua console.Premere Ctrl+D per uscire dalla console remota.

Come posso copiare la chiave per la connessione tramite SSH come utente root?

Poiché in Kubernetes sono necessari i privilegi di root, creiamo delle chiavi per configurare l’accesso SSH per root. Esegui i seguenti comandi su tutte le macchine (docker-nakivo21, docker-nakivo31 e docker-nakivo32) a cui è necessario accedere tramite SSH come utente root.$ sudo -iModifica il file di configurazione del server SSH.# vim /etc/ssh/sshd_configAggiungi/modifica la seguente stringa a questo file.PermitRootLogin yesRiavvia il demone del server SSH.# /etc/init.d/ssh stop# /etc/init.d/ssh startImposta la password di root (password per l’utente root).# passwd$ cd /home/kubernetes-user/$ sudo ssh-keygen -t rsaCopiare la chiave pubblica per poter effettuare il login in remoto tramite SSH come utente root (la chiave è memorizzata nella directory home dell’utente regolare poiché il comando precedente è stato eseguito da quella directory).$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1Se la chiave è salvata nella directory home dell’utente root, copiare la chiave con questo comando:# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1Conferma questa operazione e inserisci la tua password.Ripeti l’operazione, copiando la chiave da ogni macchina alle altre macchine. Ad esempio, su docker-nakivo21 esecuzione macchina:# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.31# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.32Rendi autorizzata la chiave pubblica.# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keysVerifica se puoi accedere come root tramite SSH sul computer locale.$ sudo ssh root@127.0.0.1Prova a connetterti da/alla macchina remota senza inserire una password.$ sudo ssh root@192.168.101.21$ sudo ssh root@192.168.101.31$ sudo ssh root@192.168.101.32Nota: La connessione come utente root potrebbe non essere sicura. Non connettersi come utente root se non è necessario: è preferibile connettersi tramite SSH come utente normale e utilizzare il comando sudo comando.

Installazione di Docker

Docker è la piattaforma di contenitori per applicazioni aziendali più popolare supportata da Kubernetes. Installa Docker su tutte le macchine. Esegui i comandi riportati di seguito su docker-nakivo21, docker-nakivo31, docker-nakivo32.Tuttavia, non c’è bisogno di affrettarsi. Per una prima occhiata, è sufficiente installare Docker utilizzando il solito comando:$ sudo apt-get install -y docker.ioTuttavia, in questo caso, la versione di Docker utilizzata potrebbe non essere quella più recente. Rimediamo installando l’ultima versione di Docker.Innanzitutto, installa i pacchetti obbligatori.$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-commonCurl è uno strumento compatto universale progettato per trasferire dati da/verso un host senza l’interazione dell’utente utilizzando uno dei protocolli supportati (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET ecc.).Aggiungi la chiave GPG per il repository ufficiale Docker al tuo sistema Ubuntu:$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -L’output della console deve essere OK.Aggiungi il repository ufficiale Docker al tuo gestore di pacchetti apt:$ sudo add-apt-repository \"deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable\"Aggiorna il database del gestore dei pacchetti dopo aver apportato modifiche manuali con il comando precedente.$ sudo apt-get updateControlla la versione del pacchetto Docker disponibile nel repository ufficiale.$ apt-cache policy docker-ceInstalla Docker.$ sudo apt-get install docker-ceÈ possibile verificare la versione di Docker dopo l’installazione.$ docker --versionIn questo caso il risultato è: Docker versione 18.09.6, build 481bc77.Avvia Docker e imposta il suo demone in modo che venga caricato automaticamente all’avvio del sistema.$ sudo systemctl start docker$ sudo systemctl enable dockerUna volta installato Docker su tutte le macchine, puoi passare direttamente alla fase di installazione di Kubernetes su Ubuntu.

Installazione di Kubernetes su Ubuntu e inizializzazione del cluster

Ora nulla ti impedisce di installare i componenti principali di Kubernetes.Esegui i comandi come root su tutte le macchine da includere nel cluster Kubernetes.$ sudo -iAggiungi la chiave GPG per il repository ufficiale Docker al tuo sistema Ubuntu:# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -Aggiungi il repository ufficiale di Kubernetes al database dei repository di pacchetti disponibili per il tuo gestore di pacchetti apt.# cat </etc/apt/sources.list.d/kubernetes.listdeb http://apt.kubernetes.io/ kubernetes-xenial mainEOFIn alternativa, è possibile aggiungere il repository con questo comando:# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.listDove maglietta è uno strumento che legge l’input standard e scrive i dati di input nell’output standard e nei file definiti.Aggiorna l’elenco dei pacchetti dei repository disponibili sul tuo sistema Ubuntu.# apt-get updateInstallazione in corso kubectl, kubeadm e kubectl È fondamentale installare Kubernetes su Ubuntu.# apt-get install -y kubelet kubeadm kubectlInstalla keepalived.# apt-get install keepalived# systemctl enable keepalived && systemctl start keepalivedVerifica se il valore è 1 per la funzionalità di Kubernetes installato su Ubuntu.# sysctl net.bridge.bridge-nf-call-iptablesPer impostare questo valore su 1 esegui il comando:sysctl net.bridge.bridge-nf-call-iptables=1Modifica il file di configurazione kubeadm.# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.confAggiungi la stringa dopo la stringa Ambiente esistente:Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”I cgroup sono gruppi di controllo che isolano l’utilizzo delle risorse quali processore, memoria, input/output del disco, rete.Sul nodo master (docker-nakivo21) Esegui il comando per inizializzare il cluster Kubernetes su Ubuntu.# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21Dove–pod-network-cidr è obbligatorio per il driver Flannel. CIDR (Classless Inter-Domain Routing) definisce l’indirizzo della rete overlay (come Flannel) che verrà configurata in seguito. La maschera di rete definisce anche il numero di pod che possono essere eseguiti per ogni nodo. L’indirizzo di rete CIDR e l’indirizzo di rete utilizzato per Flannel devono essere uguali.–apiserver-advertise-address=192.168.101.21 definisce l’indirizzo IP che sarà pubblicizzato da Kubernetes come suo server API.Leggi i comandi di output e salvataggio visualizzati alla fine del testo. Questo è un punto importante. Il token generato è obbligatorio per aggiungere nodi di lavoro al cluster Kubernetes.Esegui i seguenti comandi come utente che ha eseguito kubeadm initIn questo caso, i comandi vengono eseguiti come root.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configSe non esegui questi comandi, Kubernetes restituirà l’errore: La connessione al server localhost:8080 è stata rifiutata – hai specificato l’host o la porta corretti?Kubernetes non copia questo config file nella directory utente automaticamente. È necessario eseguire questa operazione manualmente.Controlla i nodi aggiunti al cluster# kubectl get nodesÈ possibile vedere un nodo master che ha il Non pronto stato nel cluster Kubernetes che viene installato su Ubuntu. Ciò è dovuto al fatto che la rete overlay non è stata configurata. Configurare Flannel per risolvere il problema. Non pronto Stato del nodo master Kubernetes. Creare la directory in cui memorizzare i file yaml per Docker e Kunernetes, ad esempio /home/kubernetes-user/kubernetes/YAML (Yet Another Markup Language) offre una maggiore praticità nella creazione di pod e implementazioni in Kubernetes. È possibile definire tutti i parametri dei contenitori che devono essere distribuiti nel file di configurazione YAML invece di eseguire manualmente ogni comando nella console Linux. I file YAML sono anche denominati file manifest nel contesto di Kubernetes.Creare il file di configurazione yaml con il seguente contenuto:kube-flannel.ymlEsegui il comando# kubectl apply -f ./kube-flannel.ymlIn alternativa, su GitHub sono disponibili esempi gratuiti già pronti di configurazioni di implementazione YAML per Kubernetes.kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.ymlControlla i nodi aggiunti al cluster Kubernetes che stai implementando su Ubuntu:# kubectl get nodesLo stato del nodo master ora è Pronto.Assicurati che Flannel sia stato configurato correttamente:# kubectl get pods --all-namespacesÈ possibile vedere che il pod Flannel è in esecuzione. Questo pod è composto da due contenitori: il daemon Flannel e initContainer, utilizzato per l’implementazione della configurazione CNI in una ubicazione leggibile da Kubernetes.A volte, quando si installa Kubernetes su Ubuntu, può verificarsi il seguente errore:Impossibile connettersi al server: net/http: timeout handshake TLS.Come risolvere questo problema? Attendere qualche secondo e riprovare: spesso è sufficiente.I namespace sono entità logiche nel cluster Kubernetes che rappresentano le risorse del cluster e possono essere considerati cluster virtuali. Un cluster fisico può essere suddiviso logicamente in più cluster virtuali. I namespace predefiniti di Kubernetes sono Predefinito, Kube-pubblico, e Sistema KubeÈ possibile ottenere l’elenco degli spazi dei nomi:# kubectl get namespacesCome ricorderete, l’unità di implementazione di base in Kubernetes è un pod, ovvero un insieme di contenitori che condividono la rete e il namespace di montaggio. Tutti i contenitori del pod sono pianificati sullo stesso nodo Kubernetes. Controllate i pod disponibili:# kubectl -n kube-system get podsSe desideri ripristinare/interrompere il cluster, esegui:# kubeadm resetTutto è OK sul nodo master. Ciò significa che ora puoi continuare a installare Kubernetes su Ubuntu e passare all’aggiunta di nodi worker al cluster.Sui nodi worker (docker-nakivo31, docker-nakivo32) esegui il comando:# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z \ --discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79Il token e l’hash sono stati annotati dopo l’inizializzazione del cluster con il comando kubeadm init comando, come ricorderete.Sul nodo master, controllate nuovamente lo stato del cluster.# kubectl get nodesOra è possibile vedere un nodo master e due nodi worker nel cluster Kubernetes in esecuzione su macchine Ubuntu.È possibile verificare la configurazione di Kubernetes:# kubectl cluster-info

Implementazione di un pod in Kubernetes

Ora è possibile effettuare l’implementazione di un pod con contenitori nel cluster Kubernetes. Come si ricorderà, i contenitori sono inclusi nei pod in Kubernetes. Se si utilizzano file yaml, creare una directory in cui memorizzare tali file per maggiore comodità. Passare a tale directory ed eseguire i comandi come kubectl apply -f test.yamlTale directory è già stata creata durante la configurazione di Flannel – /home/kubernetes-user/kubernetes/È ora di distribuire un nuovo pod. Per prima cosa è necessario creare un’implementazione. L’implementazione è un concetto di controller utilizzato per fornire aggiornamenti dichiarativi a pod e set di repliche. È possibile creare un’implementazione con un singolo comando o utilizzando file yaml.

Esempio 1 – Implementazione di MySQL

Creiamo un file yaml in questo esempio. Il nome del file è mysql-implementazione.yamlPer visualizzare la configurazione, consultare il file allegato.# vim mysql-deployment.yamlEsistono due approcci diffusi per la gestione delle risorse con kubectlQual è la differenza tra kubectl crea e kubectl applica? Quando si utilizza kubectl crea, si comunica a Kubernetes cosa si desidera creare, sostituire o eliminare; questo comando sovrascrive tutte le modifiche. In alternativa, kubectl applica apporta modifiche incrementali e questo comando può essere utilizzato per salvare le modifiche applicate a un oggetto attivo.Creare un’implementazione:# kubectl apply -f ./mysql-deployment.yamlKubernetes può visualizzare informazioni sulla tua implementazione.# kubectl describe deployment mysqlControlla i pod:# kubectl get pooppure# kubectl get podsoppure# kubectl get pods -l app=mysqlSe vedi lo stato “in sospeso” per il pod, potrebbe significare che non ci sono risorse di calcolo sufficienti. Prova ad aggiungere un po’ di capacità di CPU e memoria per risolvere lo stato “in sospeso” del pod in Kubernetes.Se necessario, è possibile eliminare il servizio:# kubectl delete service È anche possibile eliminare un pod:# kubectl delete pod mysql-7b9b7999d8-nz5tm

Esempio 2 – Implementazione di nginx

Implementiamo nginx utilizzando un altro metodo senza file yaml.Creiamo un’implementazione.# kubectl create deployment nginx --image=nginxVerificare che l’implementazione sia stata creata.# kubectl get deploymentsCrea un servizio.# kubectl create service nodeport nginx --tcp=80:80È possibile creare un servizio utilizzando i seguenti tipi di servizio: ClusterIP, NodePort, LoadBalance ed ExternalName. Se si utilizza il tipo NodePort, viene assegnata una porta casuale compresa nell’intervallo 30000-32767 per accedere ai servizi forniti. Il traffico inviato a questa porta viene inoltrato al servizio necessario.Verificare che il servizio sia stato creato e sia in ascolto sulla porta definita.# kubectl get svcRicordare il numero della porta (in questo caso 31453).Verificare che il servizio sia in fase di implementazione e disponibile (in questo esempio il comando viene eseguito sul nodo master). Utilizzare il nome host del nodo e la porta ricordati nel passaggio precedente.# curl docker-nakivo31:31453È inoltre possibile verificare che il servizio sia accessibile nel browser di qualsiasi nodo. Nella barra degli indirizzi del browser web provare a visitare le pagine:http:// 10.101.235.90oppurehttp://docker-nakivo31:31453http://docker-nakivo32:31453Se tutto è OK, vedrai la pagina di benvenuto di nginx.È anche possibile visitare la pagina di test nginx da qualsiasi macchina che abbia accesso alla rete a cui sono connessi i nodi Kubernetes—(192.168.101.0/24) in questo caso. Ad esempio, è possibile visitare le pagine web con il proprio browser:http://192.168.101.21:31453/http://192.168.101.31:31453/http://192.168.101.32:31453/

Configurare l’interfaccia web per il monitoraggio di Kubernetes

L’installazione di Kubernetes su Ubuntu è quasi completa, ma è anche possibile installare la dashboard di Kubernetes per maggiore comodità. La dashboard di Kubernetes è un’interfaccia web per la gestione e il monitoraggio di Kubernetes. Per installare la dashboard, creare il file kubernetes-dashboard.yaml file, proprio come hai fatto in precedenza prima di eseguire i comandi.# kubectl create -f ./kubernetes-dashboard.yaml# kubectl apply -f ./kubernetes-dashboard.yamlControlla i pod.# kubectl get pods -o wide --all-namespacesAvvia il proxy al server API Kubernetes.# kubectl proxyPer inserire i comandi successivi nella console, aprire un’altra finestra della console. In caso contrario, il processo verrà interrotto.Nel browser Web sul nodo master, accedere alla pagina:http://localhost:8001Puoi vedere la pagina del test.Inserisci l’indirizzo completo nella barra degli indirizzi del browser web.http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/Crea una dashboard con un account di servizio eseguendo i comandi nella nuova finestra della console.# kubectl create serviceaccount dashboard -n default# kubectl create clusterrolebinding dashboard-admin -n default \ --clusterrole=cluster-admin \ --serviceaccount=default:dashboard# kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath=\"{.secrets[0].name}\") -o jsonpath=\"{.data.token}\" | base64 –decodeOra puoi vedere il token generato:Copia il token generato e incollalo nella sezione token dell’interfaccia web per accedere alla dashboard.Nello screenshot qui sotto è possibile vedere l’interfaccia web della dashboard di Kubernetes. È possibile visualizzare lo stato dei nodi, delle implementazioni e dei pod, nonché controllare i ruoli, le classi di storage e altri componenti.

Configurazione dello strumento di monitoraggio Heapster per il monitoraggio

Installa Heapster per ampliare le opzioni di monitoraggio della dashboard di Kubernetes aggiungendo CPU, memoria e altri parametri di monitoraggio. Crea un file manifest con il nome heapster.yaml.# vim heapster.yamlNell’azione successiva, effettua l’implementazione di Heapster.# kubectl create -f heapster.yamlModifica il ruolo RBAC (Controllo degli accessi basato sui ruoli) di Heapster e aggiungi le autorizzazioni per accedere alle statistiche dei nodi.# kubectl edit clusterrole system:heapsterVerificare che le metriche della CPU e della memoria possano essere misurate nella console.# kubectl top nodeOra è possibile aprire l’interfaccia web della dashboard di Kubernetes e vedere che sono state aggiunte alcune sezioni, tra cui i grafici relativi all’utilizzo della CPU e della memoria.Il tuo cluster Kubernetes è ora configurato e attivo.

Implementazione di un cluster Kubernetes ad alta disponibilità con più master su Ubuntu

Avere un cluster Kubernetes con un nodo master e un paio di nodi worker è una buona opzione, ma a volte l’unico nodo master può guastarsi per motivi quali problemi hardware o interruzioni di corrente. Per una maggiore tolleranza ai guasti del cluster Kubernetes distribuito sui nodi Ubuntu, è meglio considerare la distribuzione del cluster Kubernetes ad alta disponibilità con più nodi master. L’utilizzo di questo modello di implementazione del cluster Kubernetes consente di evitare un singolo punto di guasto. Si consiglia di utilizzare un numero dispari di nodi master; il numero minimo di nodi master in grado di fornire tolleranza ai guasti è tre. Se si utilizzano più di tre nodi master e il numero di nodi è pari, la tolleranza ai guasti dell’intero cluster non aumenta. Vedere la tabella seguente per confrontare il valore della tolleranza ai guasti in base al numero di nodi master nel cluster Kubernetes. Ad esempio, se si dispone di un cluster con 5 nodi master, il cluster può sopravvivere a un guasto di 2 nodi master perché tre nodi master rimangono attivi (3 su 5 è più del 50% e costituisce la maggioranza). La dimensione del cluster si riferisce al numero di nodi master nel cluster.

Questa sezione del post del blog di oggi illustra come installare Kubernetes sui nodi Ubuntu nel contesto dell’implementazione di un cluster Kubernetes ad alta disponibilità, un proxy HA e alcuni nodi di lavoro. Nella tabella sottostante sono riportati gli indirizzi IP, i nomi host e i ruoli degli host utilizzati per l’installazione del cluster HA Kubernetes sui nodi Ubuntu nel laboratorio di prova illustrato in questo esempio.

Alcuni comandi sono gli stessi utilizzati per l’installazione di Kubernetes su Ubuntu utilizzando il modello a nodo master singolo. Per questo motivo, i commenti relativi ad alcuni comandi non vengono ripetuti. È possibile scorrere questa pagina verso l’alto per rileggere la spiegazione dei comandi.Preparare tutte le macchine (proxy HA, nodi master e nodi worker) per l’installazione di Kubernetes procedendo come segue:

• Configurare gli indirizzi IP statici.
• Imposta i nomi host. I nomi di tutti gli host devono essere risolti in indirizzi IP.
• L’accesso SSH deve essere abilitato e configurato utilizzando certificati.
• Lo swap deve essere disabilitato.

Questi passaggi devono essere eseguiti prima di avviare l’installazione di Docker su ciascuna macchina, proprio come descritto nella sezione precedente relativa all’installazione di Kubernetes su Ubuntu utilizzando un nodo master. Una volta preparate tutte le macchine, andare su (192.168.101.19).

Configurazione del bilanciatore di carico HA Proxy

Il bilanciatore di carico HA Proxy viene utilizzato per distribuire il traffico in ingresso tra i nodi Kubernetes. Il bilanciatore di carico viene implementato davanti ai nodi master. Aprire la console del ha-proxy19 macchina ed eseguire le azioni indicate di seguito.

Installa cfssl

Cfssl (Cloud Flare SSL) è un toolkit utilizzato per generare diversi certificati, tra cui catene di certificati TLS/SSL.Scarica i file binari dal repository ufficiale.# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64Rendi eseguibili i file binari scaricati.# chmod +x cfssl*Sposta questi file binari in /usr/local/bin/# mv cfssl_linux-amd64 /usr/local/bin/cfssl# mv cfssljson_linux-amd64 /usr/local/bin/cfssljsonVerifica l’installazione controllando la versione di cfssl installata.# cfssl versionAggiorna l’albero del repository.# apt-get updateInstalla HA proxy.# apt-get install haproxyCrea e modifica il haproxy.cfg file.# vim /etc/haproxy/haproxy.cfgAggiungi queste righe alla fine del file di configurazione.frontend kubernetesbind 192.168.101.19:6443option tcplogmode tcpdefault_backend kubernetes-master-nodesbackend kubernetes-master-nodesmode tcpbalance roundrobinoption tcp-checkserver docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2Riavvia il servizio.# systemctl restart haproxy

Generare certificati TSL

È possibile continuare a utilizzare la console della macchina proxy HA. Creare il file di configurazione dell’autorità di certificazione, con il nome ca-config.json.# vim ca-config.jsonAggiungi il seguente contenuto a questo file di configurazione:{ \"signing\": { \"default\": { \"expiry\": \"8760h\" }, \"profiles\": { \"kubernetes\": { \"usages\": [\"signing\", \"key encipherment\", \"server auth\", \"client auth\"], \"expiry\": \"8760h\" } } }}Creare il file di configurazione della richiesta di firma dell’autorità di certificazione.# vim ca-csr.jsonAggiungi il contenuto a questo file come mostrato di seguito:{ “CN”: “Kubernetes”, “key”: { “algo”: “rsa”, “size”: 2048 }, “names”: [ { “C”: “GB”, “L”: “London”, “O”: “Kubernetes”, “OU”: “CA”, “ST”: “Nakivo” } ]}Dove:C – Paese, ad esempio GB (Gran Bretagna).L – ubicazione come città o paese.O – organizzazione.OU – unità organizzativa (ad esempio, un reparto definito come proprietario della chiave).ST – lo stato o la provincia.Ora genera la chiave pubblica e quella privata.# cfssl gencert -initca ca-csr.json | cfssljson -bare caVerifica che il ca-key.pem e il ca.pem Le chiavi sono state generate.# ls -al

Creazione del certificato per il cluster Etcd

Etcd supporta la comunicazione da server a server/cluster utilizzando l’autenticazione tramite certificati client. È necessario disporre di un certificato CA e di una coppia di chiavi firmate per un membro del cluster.Creare il file di configurazione della richiesta di firma del certificato.# vim kubernetes-csr.json{ \"CN\": \"kubernetes\", \"key\": { \"algo\": \"rsa\", \"size\": 2048 }, \"names\": [ { \"C\": \"GB\", \"L\": \"London\", \"O\": \"Kubernetes\", \"OU\": \"Kubernetes\", \"ST\": \"Nakivo\" } ]}Successivamente, genera il certificato e la chiave privata.# cfssl gencert \-ca=ca.pem \-ca-key=ca-key.pem \-config=ca-config.json \-hostname=192.168.101.21,192.168.101.22,192.168.101.23,192.168.101.19,127.0.0.1,kubernetes.default \-profile=kubernetes kubernetes-csr.json | \cfssljson -bare kubernetesElenca i file nella tua directory per verificare che il kubernetes-chiave.pem e il kubernetes.pem Il file è stato generato.# ls -alCopiare il certificato creato su ciascun nodo.# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.21:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.22:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.23:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.31:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.32:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.33:~Dove ~ è una directory home di kubernetes-utente su host Ubuntu.

Preparazione dei nodi Ubuntu per l’installazione di Kubernetes

Esegui i comandi mostrati in questa sezione su tutti i nodi master e sui nodi worker. Installa Docker, quindi installa Kubernetes sulle macchine Ubuntu che saranno incluse nel cluster Kubernetes. Iniziamo dalla preparazione del 192.168.101.21 nodo master.Installa Docker.# apt-get install apt-transport-https ca-certificates curl software-properties-common# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -# add-apt-repository \"deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable\"# apt-get update# apt-get install docker-ceDocker è ora installato. Cubeadm, kublet e cubectl sono i componenti Kubernetes obbligatori per installare Kubernetes su Ubuntu.Installa i componenti Kubernetes: kubeadm, kublet e kubectl.# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list# apt-get update# apt-get install -y kubelet kubeadm kubectlUna volta preparati tutti i nodi e installati Docker, kubelet, kubeadm e kubectl, è necessario installare e configurare etcd sui nodi master.

Installazione e configurazione di etcd sui nodi master Ubuntu

Etcd è un archivio coerente e altamente disponibile, destinato alla memorizzazione delle chiavi e al backup di tutti i dati del cluster. Il cluster etcd deve essere configurato prima di configurare il cluster HA Kubernetes con più nodi master. Iniziamo dalla configurazione del 192.168.101.21 nodo master.Installing and configuring etcd on the 192.168.101.21 machineCrea una directory di configurazione per etcd.# mkdir /etc/etcd /var/lib/etcdVai alla directory in cui sono stati copiati i certificati. Si tratta della directory home dell’utente kubernetes, in questo caso – /home/kubernetes-user/Copiare i certificati nella directory di configurazione etcd.# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcdVerifica che i file siano stati copiati.# ls -al /etc/etcdTorna alla directory precedente# cd -Scarica i file binari etcd dal repository.# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gzEstrai l’archivio etcd.# tar xvzf etcd-v3.3.9-linux-amd64.tar.gzOra sposta i file binari etcd in /usr/local/bin/# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/Crea un file di unità systemd etcd.# vim /etc/systemd/system/etcd.serviceAggiungi le stringhe riportate di seguito a questo file.[Unit]Description=etcdDocumentation=https://github.com/coreos[Service]ExecStart=/usr/local/bin/etcd \ --name 192.168.101.21 \ --cert-file=/etc/etcd/kubernetes.pem \ --key-file=/etc/etcd/kubernetes-key.pem \ --peer-cert-file=/etc/etcd/kubernetes.pem \ --peer-key-file=/etc/etcd/kubernetes-key.pem \ --trusted-ca-file=/etc/etcd/ca.pem \ --peer-trusted-ca-file=/etc/etcd/ca.pem \ --peer-client-cert-auth \ --client-cert-auth \ --initial-advertise-peer-urls https://192.168.101.21:2380 \ --listen-peer-urls https://192.168.101.21:2380 \ --listen-client-urls https://192.168.101.21:2379,http://127.0.0.1:2379 \ --advertise-client-urls https://192.168.101.21:2379 \ --initial-cluster-token etcd-cluster-0 \ --initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \ --initial-cluster-state new \ --data-dir=/var/lib/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.targetRicaricare la configurazione di systemd manager per acquisire le configurazioni modificate dal file system e rigenerare gli alberi delle dipendenze.# systemctl daemon-reloadInizia etcd all’avvio del sistema.# systemctl enable etcdInizia etcd.# systemctl start etcdEseguire le stesse azioni sul secondo nodo master (docker-nakivo22 – 192.168.101.21 e docker-nakivo23 – 192.168.101.22). L’unica differenza nelle azioni necessarie per questi nodi master consiste nella modifica del file etcd.service file di configurazione. Definire gli indirizzi IP corretti per ciascun nodo master. Ad esempio, il etcd.service Il file di configurazione deve essere il seguente per il secondo nodo master (192.168.101.22) dell’attuale laboratorio di test Kubernetes.[Unit]Description=etcdDocumentation=https://github.com/coreos[Service]ExecStart=/usr/local/bin/etcd \ --name 192.168.101.22 \ --cert-file=/etc/etcd/kubernetes.pem \ --key-file=/etc/etcd/kubernetes-key.pem \ --peer-cert-file=/etc/etcd/kubernetes.pem \ --peer-key-file=/etc/etcd/kubernetes-key.pem \ --trusted-ca-file=/etc/etcd/ca.pem \ --peer-trusted-ca-file=/etc/etcd/ca.pem \ --peer-client-cert-auth \ --client-cert-auth \ --initial-advertise-peer-urls https://192.168.101.22:2380 \ --listen-peer-urls https://192.168.101.22:2380 \ --listen-client-urls https://192.168.101.22:2379,http://127.0.0.1:2379 \ --advertise-client-urls https://192.168.101.22:2379 \ --initial-cluster-token etcd-cluster-0 \ --initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \ --initial-cluster-state new \ --data-dir=/var/lib/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.target

Inizializzazione dei nodi master nel cluster HA Kubernetes

Ora è possibile inizializzare i nodi master nel cluster HA Kubernetes installato su macchine Ubuntu.

Inizializzazione del nodo master 192.168.101.21

Sul primo nodo master, eseguire le operazioni descritte di seguito.Creare il file di configurazione yaml per kubeadm.# vim config.yamlAggiungi i parametri di configurazione a questo file:apiVersion: kubeadm.k8s.io/v1alpha3kind: ClusterConfigurationkubernetesVersion: stableapiServerCertSANs:- 192.168.101.19controlPlaneEndpoint: \"192.168.101.19:6443\"etcd: external: endpoints: - https://192.168.101.21:2379 - https://192.168.101.22:2379 - https://192.168.101.23:2379 caFile: /etc/etcd/ca.pem certFile: /etc/etcd/kubernetes.pem keyFile: /etc/etcd/kubernetes-key.pemnetworking: podSubnet: 10.244.0.0/16apiServerExtraArgs: apiserver-count: \"3\"La rete definita come podSubnet (10.244.0.0/16) deve essere la stessa indicata nel kube-flannel.yml file.Inizializza la macchina Ubuntu come nodo master.# kubeadm init --config=config.yamlA volte è possibile visualizzare un’avvertenza relativa alla versione precedente di un file di configurazione:Il file di configurazione utilizza una specifica API obsoleta: “kubeadm.k8s.io/v1alpha3”. Utilizzare ‘kubeadm config migrate –old-config old.yaml –new-config new.yaml’, che scriverà la nuova specifica simile utilizzando una versione API più recente.Aggiornare la versione del file di configurazione con il comando:# kubeadm config migrate --old-config config.yaml --new-config config1.yamlUn altro errore può verificarsi quando si inizializza un nodo di un cluster Kubernetes multi-master se etcd non è in esecuzione:[ERROR ExternalEtcdVersion]: Ottieni https://192.168.101.21:2379/versione: componi tcp 192.168.101.21:2379: connettiti: connessione rifiutataControlla se il tuo etcd è in esecuzione. È possibile eseguire etcd manualmente:# systemctl start etcdDopo aver inizializzato con successo il nodo master nel cluster Kubernetes in esecuzione su Ubuntu, viene visualizzato il seguente messaggio, come mostrato nella schermata.Il risultato dell’esecuzione corretta di questo comando contiene un suggerimento su come iniziare a utilizzare il cluster, nonché i comandi che contengono un token e un hash del certificato necessari per aggiungere nodi al cluster. Salva queste stringhe importanti perché ti serviranno presto. Sono contrassegnate in giallo nella schermata e sono riportate di seguito.Ora è possibile unire un numero qualsiasi di nodi del piano di controllo copiando le autorità di certificazione. e le chiavi dell’account di servizio su ciascun nodo, quindi eseguendo quanto segue come root:kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca \ --experimental-control-planeQuindi è possibile unire un numero qualsiasi di nodi di lavoro eseguendo quanto segue su ciascuno di essi come root:kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302caEsegui i comandi per iniziare a utilizzare il nodo inizializzato nel cluster.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configControlla i nodi aggiunti al cluster.# kubectl get nodesCopiare i certificati sugli altri due nodi master# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.22:~# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.23:~

Inizializzazione del nodo master 192.168.101.22

Eseguire i comandi sul secondo nodo master (192.168.101.22).Rimuovere il apiserver.crt e apiserver.key che hanno la loro ubicazione nella directory home (~) del kubernetes-utente.$ rm ~/pki/apiserver.*Sposta i certificati memorizzati nella directory home nella directory /etc/kubernetes/ directory.$ sudo mv ~/pki /etc/kubernetes/Crea il file di configurazione yaml per kubeadm.# vim config.yamlIl contenuto di questo file yaml è lo stesso del primo nodo master (192.168.101.21). Vedere la configurazione per l’inizializzazione del primo nodo master sopra. È possibile copiare il file già creato utilizzato sul primo nodo master del cluster HA Kubernetes installato sulle macchine Ubuntu.Inizializzare il secondo nodo master.# kubeadm config migrate --old-config config.yaml --new-config config1.yaml# kubeadm init --config=config1.yamlL’output è lo stesso di quello visualizzato dopo la prima inizializzazione del nodo master nel cluster HA Kubernetes:Allo stesso modo, eseguire i comandi per iniziare a utilizzare il nodo inizializzato nel cluster.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configControlla i nodi aggiunti al cluster.# kubectl get nodesDue nodi master su tre sono stati aggiunti al cluster. Rimane da aggiungere un nodo master.

Inizializzazione del terzo nodo master (192.168.101.23)

Ripeti gli stessi passaggi che hai eseguito per inizializzare il secondo nodo (192.168.101.22) nel cluster.Non dimenticare di annotare i comandi con token e hash per aggiungere nodi al cluster che vengono visualizzati dopo l’inizializzazione del nodo master.Verifica che tutti e tre i nodi master siano stati aggiunti correttamente al cluster.# kubectl get nodes

Installazione di Flannel per correggere lo stato NotReady dei nodi master in Kubernetes

Installiamo Flannel. A differenza del primo esempio, in cui avete imparato come installare Kubernetes su Ubuntu per creare un cluster master singolo, in questo esempio Flannel verrà installato utilizzando il file yaml.Eseguite il comando per installare Flannel e correggere il Non pronto stato dei nodi visualizzato, poiché non è ancora stata configurata alcuna rete sovrapposta. Creare il kube-flannel.yaml file con l’editor di testo vim, ad esempio, sul primo nodo master.# kubectl apply -f kube-flannel.ymlRicordare l’indirizzo della podSubnet definita nel config.yaml file. L’indirizzo di rete deve essere lo stesso nel kube-flannel.yaml file.Controlla i tuoi nodi e il loro stato.# kubectl get nodesOra tutti i nodi master funzionano correttamente.

Aggiunta di nodi worker al cluster

Una volta inizializzati tutti i nodi master, è possibile aggiungere nodi worker al cluster Kubernetes. Aggiungiamo il primo nodo worker (192.168.101.31) al cluster HA Kubernetes distribuito su macchine Ubuntu. Utilizzare il comando visualizzato dopo l’inizializzazione dei nodi master (il comando che contiene token e hash) per aggiungere il nodo worker al cluster. Eseguire il comando su 192.168.101.31 macchina.# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45 \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302caControlla i nodi del cluster HA Kubernetes per assicurarti che il nodo worker sia stato aggiunto. Ora puoi anche vedere la macchina proxy HA nell’elenco dei nodi.# kubectl get nodesAllo stesso modo, aggiungi altri nodi di lavoro al cluster Kubernetes High Availability installato sulle macchine Ubuntu. Puoi aggiungere altri nodi di lavoro in qualsiasi momento, a seconda delle tue esigenze. A questo punto, il tutorial di oggi termina.

Conclusione

Installare Kubernetes su Ubuntu non è così difficile come potrebbe sembrare a prima vista. È necessario impegnarsi un po’ per l’implementazione del cluster Kubernetes, ma in cambio si ottengono molti vantaggi, come una gestione centralizzata più semplice, un’elevata scalabilità e il bilanciamento del carico. Il tipo più semplice di implementazione di Kubernetes è quello a master singolo: è necessario installare Kubernetes sui nodi Ubuntu, inclusi i nodi master e worker.Se avete bisogno di un’infrastruttura più affidabile per eseguire applicazioni containerizzate, prendete in considerazione l’implementazione di un Kubernetes multi-master, noto come cluster Kubernetes High Availability. Questo tipo di implementazione di Kubernetes esclude un singolo punto di errore e il vostro cluster può sopravvivere anche se alcuni dei nodi master smettono di funzionare.Per entrambi i tipi di implementazione, è necessario configurare l’accesso SSH, impostare indirizzi IP statici e nomi host, installare Docker, disabilitare l’uso della partizione di swap e, infine, installare i componenti Kubernetes come kubeadm, kubectl, kubelet e configurare Flannel per il networking overlay. Nel caso dell’implementazione del cluster HA Kubernetes, è inoltre necessario configurare il proxy HA su una macchina autonoma, generare certificati e configurare il cluster etcd. La maggior parte delle fasi di configurazione di Kubernetes, creazione di implementazioni ed esecuzione di pod può essere eseguita con due metodi: eseguendo manualmente i comandi forniti dall’interfaccia della riga di comando e utilizzando i file di configurazione yaml. L’utilizzo dei file yaml consente di creare una struttura più complessa e rende il processo di amministrazione più conveniente.È possibile installare Kubernetes su Ubuntu, in esecuzione su macchine fisiche e VM. Se Kubernetes è installato su VM in esecuzione in vSphere, è possibile eseguire una protezione aggiuntiva utilizzando Cluster VMware ad alta disponibilità con la funzione Fault Tolerance. Le logiche di implementazione di Kubernetes illustrate in questo post del blog possono essere utilizzate anche per installare Kubernetes su altre distribuzioni Linux.

Try NAKIVO Backup & Replication

Get a free trial to explore all the solution’s data protection capabilities. 15 days for free. Zero feature or capacity limitations. No credit card required.

Try for Free