Come installare Kubernetes su Ubuntu
L’implementazione manuale dei contenitori Docker su più server può richiedere molto tempo, occupando gran parte dell’agenda di qualsiasi amministratore di sistema incaricato di tale compito. Nel settore IT moderno, la popolarità del 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 semplificare l’implementazione dei contenitori in ambienti distribuiti, oltre a garantire un’elevata disponibilità per le applicazioni containerizzate. L’obiettivo di questo articolo è illustrare come installare Kubernetes su Ubuntu per eseguire applicazioni in contenitori Docker.
Requisiti e configurazione di sistema per l’installazione di Kubernetes su Ubuntu
Il cluster Kubernetes è costituito da nodi master e nodi worker. La configurazione hardware dipende dalle vostre esigenze e dalle applicazioni che intendete eseguire in contenitori Docker. I requisiti hardware minimi per l’installazione di Kubernetes su Ubuntu sono:
- Almeno una CPU (Central Processor Unit) x86/x64 a 2 core
- 2 GB di RAM (Random Access Memory) o più
- Accesso a Internet
Porte che devono essere aperte per l’installazione di Kubernetes su Ubuntu:
| Protocollo e intervallo di porte | Origine | Scopo | Direzione |
| TCP 443 | Nodi worker, utenti finali, richieste API | Server API di Kubernetes | In entrata verso il nodo master |
| TCP 10250 | Nodi master | Porta per il controllo di integrità di Kubelet sul nodo worker | In entrata verso il nodo worker |
| TCP 30000-32767 | Client di applicazioni esterne | Intervallo di porte predefinito per la fornitura di servizi esterni | |
| UDP 8285 | Nodi worker | Backend UDP della rete overlay Flannel | |
| UDP 8472 | Nodi worker | Backend VXLAN della rete overlay Flannel | |
| TCP 179 | Nodi worker | Obbligatorio solo se si utilizza la rete BGP Calico | |
| TCP 2379-2380 | Nodi master | API client del server etcd | Traffico in entrata verso il nodo etcd |
| TCP 2379-2380 | Nodi worker | API client del server etcd obbligatoria se si utilizza Flannel o Calico |
Per impostazione predefinita, il firewall iptables è installato su Ubuntu, ma non sono presenti regole di blocco “pronte all’uso”. Pertanto, se si installa Ubuntu per provare Kubernetes, non è necessario modificare le regole del firewall. Kube-proxy inserisce prima le proprie catene iptables, quindi aggiunge due regole iptables. Queste regole sono KUBE-EXTERNAL-SERVICES e KUBE-FIREWALL, che vengono inserite all’inizio della catena INPUT.
L’installazione di Kubernetes su Ubuntu può essere effettuata sia su macchine fisiche che su VM. In generale, si consiglia di utilizzare l’ultima versione di Ubuntu Linux a 64 bit. Il post di oggi sul blog spiega come installare Kubernetes su Ubuntu 18.04 LTS in esecuzione su macchine virtuali VMware. Il primo tipo di implementazione di Kubernetes illustrato prevede un nodo master e due nodi worker per il cluster Kubernetes. Si veda la tabella sottostante per conoscere il numero condizionale di nodi, i ruoli dei nodi, i nomi host e gli indirizzi IP delle macchine utilizzate nell’esempio in questione.
| N. | Ruolo del nodo | Indirizzo IP | Nome host |
| 1 | Master | 192.168.101.21 | docker-nakivo21 |
| 2 | Worker | 192.168.101.31 | docker-nakivo31 |
| 3 | Worker | 192.168.101.32 | docker-nakivo32 |
È possibile utilizzare VM in esecuzione su Host VMware ESXi se si utilizza VMware vSphere, oppure è possibile eseguire VM su VMware Workstation installato sul proprio computer personale con sistema operativo Linux o Windows. Nell’esempio di oggi utilizzeremo macchine virtuali in esecuzione su VMware Workstation. Le macchine virtuali utilizzano la rete NAT rete con accesso a Internet; se si preferisce VirtualBox a VMware, è possibile utilizzarlo.
L’indirizzo IP della macchina host: 10.10.10.53
L’indirizzo IP del gateway virtuale per la rete NAT (VMNet8): 192.168.101.2
Lo stesso utente Linux è presente su tutte le macchine Ubuntu: kubernetes-user
Configurazione della VM: 2 CPU, 4 GB di RAM, disco virtuale da 20 GB
È possibile modificare gli indirizzi IP di VMnet8 accedendo a Edit > Virtual Network Editor in VMware Workstation.
Per una migliore comprensione, nell’esempio odierno tutti i componenti verranno installati su Linux manualmente, senza strumenti di automazione come Ansible.
Implementazione della macchina virtuale Ubuntu
Creare una nuova VM denominata docker-nakivo21 .
Installare Ubuntu a 64 bit sulla prima macchina e impostare il nome host e il nome utente.
Nome della VM: docker-nakivo21
Nome utente: kubernetes-user
Installare VMware Tools dopo il primo accesso al sistema operativo installato. Se si utilizzano macchine fisiche, non è necessario utilizzare VMware Tools e si può saltare questo passaggio.
Nota : Il carattere $ all’inizio indica che un comando viene eseguito come utente normale ( kubernetes-user in questo caso). Se la stringa inizia con il carattere # , il comando deve essere eseguito come root . Il comando sudo (sostituire con l’utente desiderato o con utente con privilegi avanzati) 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-tools
Se è necessaria un’esperienza desktop avanzata, come gli appunti condivisi, il trascinamento dei file ecc., eseguire:
$ sudo apt-get install open-vm-tools-desktop
Riavviare la macchina virtuale.
$ init 6
Configurare la macchina Ubuntu prima di installare Kubernetes
È necessario effettuare alcuni preparativi prima di installare Kubernetes su macchine Ubuntu. Innanzitutto, è necessario configurare l’indirizzo IP statico e il nome host come per qualsiasi server standard.
Imposta l’indirizzo IP statico
Come per qualsiasi altro tipo di cluster, si raccomanda vivamente di utilizzare indirizzi IP statici sui nodi.
Installa gli strumenti di rete di Linux prima di impostare l’indirizzo IP.
$ sudo apt-get install net-tools
Digita ifconfig per verificare l’indirizzo IP corrente della tua macchina virtuale Ubuntu.
Puoi notare che l’indirizzo IP viene ottenuto automaticamente tramite DHCP. Ricorda il nome dell’interfaccia di rete. Nell’esempio attuale questo nome è ens33 . Il nome della prima interfaccia di rete Ethernet è solitamente eth0 per le macchine fisiche.
È necessario un editor di testo per modificare i file di configurazione. Installa vim come editor di testo.
$ sudo apt-get install vim
Nelle ultime versioni di Ubuntu, la configurazione di rete viene impostata nel file yaml. Apri il file yaml di configurazione di rete in vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
La 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 ed esci.
:wq
$ sudo netplan try
Premere 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
Verificare il nome host corrente.
$ hostnamectl
Come ricorderete, il nome host per la prima VM, ovvero docker-nakivo21 , è già stato configurato durante l’installazione. Per modificare il nome host, procedere come segue (questo 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-nakivo21
Verificare che il nuovo nome host sia stato applicato.
$ less /etc/hostname
Modifica il file hosts .
$ sudo vim /etc/hosts
Il contenuto del file hosts deve essere simile al seguente:
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Riavviare la macchina.
$ init 6
Disabilitare 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.
Disabilitare un file di swap per evitare un elevato utilizzo della CPU da parte di kubelet.
$ sudo swapoff -a
Modificare /etc/fstab e commentare la riga utilizzando il carattere # .
$ sudo vim /etc/fstab
#/swapfile nessuno swap sw 0 0
È possibile ottenere lo stesso risultato con sed utilizzando un unico comando:
$ sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab
Disabilitare lo swap in sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Dove 0 rappresenta 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 è occupata).
Applica le modifiche alla configurazione senza riavviare il sistema.
$ sudo sysctl -p
Nota : Se la partizione di swap non è disabilitata, il processo kswapd0 di Ubuntu Linux su cui è in esecuzione Kubernetes può consumare una grande quantità di risorse della CPU sulla macchina, 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 inspiegabili, a volte qualcosa va storto e si verifica un ciclo infinito che consuma tutte le risorse della CPU. Nello screenshot qui sotto, si nota un elevato consumo di CPU da parte del processo kswapd0 quando Kubernetes è installato su Ubuntu. Il valore medio del carico è eccessivamente alto.
Se kswapd0 continua a sovraccaricare la CPU, eseguire il seguente comando per invalidare tutte le cache di memoria e arrestare kswapd0 (eseguire come root).
# echo 1 > /proc/sys/vm/drop_caches
Spegnere la VM.
$ init 0
Questa VM parzialmente configurata ( docker-nakivo21 ) sta per essere utilizzata come nodo master. Creare due VM da utilizzare come nodi worker. 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 attuale si utilizzano macchine virtuali, è possibile clonarle per risparmiare tempo durante la preparazione dell’ambiente per l’installazione di Kubernetes su macchine Ubuntu.
Clonare la macchina virtuale
Clonare la prima macchina virtuale. Se si utilizza VMware ESXi, è possibile utilizzare la funzione di clonazione integrata. Per scoprire di più su questo argomento, leggi il nostro articolo sul blog all’indirizzo clonazione di VM tramite modelli di VM. Se utilizzi VMware Workstation, puoi clonare le VM in due modi (tramite lo strumento di clonazione integrato o manualmente). Clicca 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 dalla directory docker-nakivo21 alla directory docker-nakivo31. Le directory devono essere create manualmente prima di copiare i file della 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:VirtualKUBERNETESdocker-nakivo31docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
La VM che verrà utilizzata come primo nodo di lavoro è ora stata creata. Clonare nuovamente la prima VM, per preparare il secondo nodo di lavoro del cluster Kubernetes.
Modificare il file VMX della terza VM (il secondo nodo di lavoro), come fatto in precedenza.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Aprire i cloni della VM in VMware Workstation (File> Open e selezionare il file VMX della VM), oppure fare semplicemente doppio clic sul file VMX della VM. Accendere le tre VM (la VM di origine e i due cloni della VM). Fare clic su I Copied It , quando richiesto.
Nota : se si utilizzano VM, modificare l’indirizzo IP e il nome host su ciascun clone della VM una volta che le VM sono state clonate. Se si utilizzano macchine fisiche, seguire 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
Modificare l’indirizzo IP e il nome host sulle VM docker-nakivo31 e docker-nakivo32 (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 di lavoro.
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 hosts su ciascuna macchina. Modifichiamo il file hosts .
Aggiungere le seguenti stringhe al file hosts su ciascuna macchina ( docker-nakivo21 , docker-nakivo31 , docker-nakivo32 ).
$ sudo vim /etc/hosts
Aggiungere queste righe al file hosts :
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Eseguire il ping degli altri host da ciascun host per assicurarsi che i nomi host vengano 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-server
Accedere alla directory home di kubernetes-user 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 una macchina dalla quale è necessario connettersi in remoto, mentre la chiave privata è altamente riservata e deve essere conservata sulla macchina a cui ci si deve connettere.
$ ssh-keygen
Non è 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.32
Inserire la password utente per confermare la copia delle chiavi.
Provare a connettersi alla seconda macchina ( docker-nakivo31 ) come kubernetes-user (ovvero un utente normale).
$ ssh 'kubernetes-user@192.168.101.31'
Esegui test della connessione alla terza macchina ( docker-nakivo32 ).
$ ssh 'kubernetes-user@192.168.101.32'
Una volta stabilita la connessione, nel prompt dei comandi della console verrà visualizzato il nome della macchina remota.
Premere Ctrl+D per uscire dalla console remota.
Come si copia la chiave per connettersi tramite SSH come utente root?
Poiché in Kubernetes sono necessari i privilegi di root, creiamo le 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 devi accedere tramite SSH come utente root.
$ sudo -i
Modifica il file di configurazione del server SSH.
# vim /etc/ssh/sshd_config
Aggiungi/modifica la seguente stringa in questo file.
PermitRootLogin yes
Riavvia il demone del server SSH.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Imposta la password di root (password per l’utente root).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Copia la chiave pubblica per poter effettuare l’accesso remoto tramite SSH come root (la chiave è memorizzata nella directory home dell’utente normale poiché il comando precedente è stato eseguito da quella directory).
$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1
Se la chiave è salvata nella directory home dell’utente root, copiarla con questo comando:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Confermare l’operazione e inserire la password.
Ripetere l’operazione, copiando la chiave da ciascuna macchina alle altre. Ad esempio, sulla macchina docker-nakivo21 eseguire:
# 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.32
Autorizzare la chiave pubblica.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Verifica se è possibile effettuare l’accesso come root tramite SSH sulla macchina locale. $ sudo ssh root@127.0.0.1
Prova a connetterti da/verso la 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.32
Nota : La connessione come utente root potrebbe non essere sicura. Non connetterti come root se non è necessario: è preferibile connettersi tramite SSH come utente normale e utilizzare il comando sudo .
Installazione di Docker
Docker è la piattaforma di contenitori per applicazioni aziendali più diffusa supportata da Kubernetes. Installa Docker su tutte le macchine. Eseguire i comandi riportati di seguito su docker-nakivo21 , docker-nakivo31 , docker-nakivo32 .
Tuttavia, non c’è bisogno di affrettarsi. Per un primo approccio, è possibile installare semplicemente Docker utilizzando il comando standard:
$ sudo apt-get install -y docker.io
Tuttavia, in questo caso, la versione di Docker utilizzata potrebbe non essere quella più recente. Rimediamo a questo installando l’ultima versione di Docker.
Per prima cosa, installiamo i pacchetti obbligatori.
$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
Curl è uno strumento universale e compatto 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 del repository ufficiale di 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 di 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 di pacchetti dopo aver effettuato le modifiche manuali con il comando precedente.
$ sudo apt-get update
Verifica la versione del pacchetto Docker disponibile nel repository ufficiale.
$ apt-cache policy docker-ce
Installa Docker.
$ sudo apt-get install docker-ce
Puoi verificare la versione di Docker dopo l’installazione.
$ docker --version
In questo caso l’output è: Docker versione 18.09.6, build 481bc77 .
Avvia Docker e imposta il caricamento automatico del suo daemon all’avvio del sistema.
$ sudo systemctl start docker
$ sudo systemctl enable docker
Una 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.
Eseguire i comandi come root su tutte le macchine da includere nel cluster Kubernetes.
$ sudo -i
Aggiungere la chiave GPG del repository ufficiale di Docker al sistema Ubuntu:
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
Aggiungere il repository ufficiale di Kubernetes al database dei repository di pacchetti disponibili per il gestore di pacchetti apt.
# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
In 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.list
Dove tee è uno strumento che legge l’input standard e scrive i dati di input sull’output standard e su file specificati.
Aggiorna l’elenco dei pacchetti dei repository disponibili sul tuo sistema Ubuntu.
# apt-get update
L’installazione di kubectl , kubeadm e kubectl è fondamentale per installare Kubernetes su Ubuntu.
# apt-get install -y kubelet kubeadm kubectl
Installa keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Verifica che il valore sia 1 per il corretto funzionamento di Kubernetes installato su Ubuntu.
# sysctl net.bridge.bridge-nf-call-iptables
Per impostare questo valore su 1 eseguire il comando:
sysctl net.bridge.bridge-nf-call-iptables=1
Modifica il file di configurazione di kubeadm.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Aggiungere la stringa dopo la stringa Environment esistente:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
I cgroup sono gruppi di controllo che isolano l’utilizzo delle risorse quali processore, memoria, I/O del disco e rete.
Sul nodo master ( docker-nakivo21 ) eseguire 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.21
Dove
–pod-network-cidr è obbligatorio per il driver Flannel. Il CIDR (Classless Inter-Domain Routing) definisce l’indirizzo della rete overlay (come Flannel) che verrà configurata in seguito. Anche la maschera di rete definisce quanti pod possono essere eseguiti per nodo. L’indirizzo di rete CIDR e l’indirizzo di rete utilizzato per Flannel devono essere gli stessi.
–apiserver-advertise-address=192.168.101.21 definisce l’indirizzo IP che verrà pubblicizzato da Kubernetes come suo server API.
Leggi l’output e salva i comandi 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 init. In 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/config
Se 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 automaticamente questo file di configurazione nella directory dell’utente. Devi eseguire questa operazione manualmente.
Controlla i nodi aggiunti al cluster
# kubectl get nodes
Nel cluster Kubernetes in fase di installazione su Ubuntu è visibile un nodo master con lo stato NotReady . Ciò è dovuto al fatto che la rete overlay non è stata configurata. Configura Flannel per risolvere lo stato NotReady del nodo master di Kubernetes. Crea la directory in cui archiviare i file YAML per Docker e Kubernetes, ad esempio /home/kubernetes-user/kubernetes/
Il linguaggio YAML (Yet Another Markup Language) offre maggiore praticità nella creazione di pod e implementazioni in Kubernetes. È possibile definire tutti i parametri dei contenitori da distribuire nel file di configurazione YAML, invece di eseguire manualmente ogni comando nella console Linux. I file YAML sono anche denominati file di manifesto nel contesto di Kubernetes.
Creare il file di configurazione YAML con il seguente contenuto:
Eseguire il comando
# kubectl apply -f ./kube-flannel.yml
In alternativa, su GitHub è possibile trovare esempi gratuiti già pronti di configurazioni di implementazione YAML per Kubernetes.
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml
Verificare i nodi aggiunti al cluster Kubernetes che si sta distribuendo su Ubuntu:
# kubectl get nodes
Lo stato del nodo master ora è Ready.
Assicurati che Flannel sia stato configurato correttamente:
# kubectl get pods --all-namespaces
Puoi vedere che il pod di Flannel è in esecuzione. Questo pod è composto da due contenitori: il daemon di Flannel e l’initContainer utilizzato per effettuare 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 dell’handshake TLS.
Come si può 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 unico cluster fisico può essere suddiviso logicamente in più cluster virtuali. I namespace predefiniti di Kubernetes sono Default , Kube-public e Kube-system . È possibile ottenere l’elenco dei namespace:
# kubectl get namespaces
Come ricorderete, l’unità di implementazione di base in Kubernetes è un pod, ovvero un insieme di contenitori che condividono lo spazio dei nomi di rete e di montaggio. Tutti i contenitori del pod vengono pianificati sullo stesso nodo Kubernetes. Verificate i pod disponibili:
# kubectl -n kube-system get pods
Se desiderate reimpostare/arrestare il cluster, eseguite:
# kubeadm reset
Tutto è a posto sul nodo master. Ciò significa che ora è possibile continuare con l’installazione di Kubernetes su Ubuntu e passare all’aggiunta dei nodi worker al cluster.
Sui nodi worker ( docker-nakivo31 , docker-nakivo32 ) eseguire il comando:
# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z
--discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79
Il token e l’hash sono stati annotati dopo l’inizializzazione del cluster con il comando kubeadm init , come forse ricorderete.
Sul nodo master, verificare nuovamente lo stato del cluster. # kubectl get nodes
Ora puoi vedere un nodo master e due nodi worker nel cluster Kubernetes in esecuzione su macchine Ubuntu.
Puoi verificare la configurazione di Kubernetes:
# kubectl cluster-info
Implementazione di un pod in Kubernetes
Ora puoi implementare un pod con contenitori nel tuo cluster Kubernetes. Come ricorderai, in Kubernetes i contenitori sono inclusi nei pod. Se utilizzi file YAML, crea una directory in cui salvarli per maggiore comodità. Accedete a quella directory ed eseguite comandi come kubectl apply -f test.yaml
Una directory di questo tipo è 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 replica set. È possibile creare un’implementazione con un singolo comando o utilizzando file YAML.
Esempio 1 – Implementazione di MySQL
In questo esempio creiamo un file YAML. Il nome del file è mysql-deployment.yaml
Consulta il file allegato per visualizzare la configurazione.
# vim mysql-deployment.yaml
Esistono due approcci diffusi per la gestione delle risorse con kubectl . Qual è la differenza tra kubectl create e kubectl apply ? Quando si utilizza kubectl create , si indica a Kubernetes cosa si desidera creare, sostituire o eliminare; questo comando sovrascrive tutte le modifiche. In alternativa, kubectl apply apporta modifiche incrementali e questo comando può essere utilizzato per salvare le modifiche applicate a un oggetto attivo.
Crea un’implementazione:
# kubectl apply -f ./mysql-deployment.yaml
Kubernetes può visualizzare informazioni sulla tua implementazione.
# kubectl describe deployment mysql
Controlla i pod:
# kubectl get po
oppure
# kubectl get pods
oppure
# kubectl get pods -l app=mysql
Se il pod risulta in stato “pending”, ciò può significare che le risorse di calcolo disponibili non sono sufficienti. Prova ad aggiungere un po’ di capacità di CPU e memoria per risolvere lo stato “pending” del pod in Kubernetes.
Se necessario, puoi eliminare il servizio:
# kubectl delete service <service_name>
Puoi anche eliminare un pod:
# kubectl delete pod mysql-7b9b7999d8-nz5tm
Esempio 2 – Distribuzione di nginx
Distribuiamo nginx utilizzando un altro metodo senza file YAML.
Crea un’implementazione.
# kubectl create deployment nginx --image=nginx
Verificare che l’implementazione sia stata creata.
# kubectl get deployments
Creare 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 nell’intervallo 30000-32767 per l’accesso ai servizi forniti. Il traffico inviato a questa porta viene inoltrato al servizio corrispondente.
Verifica che il servizio sia stato creato e che sia in ascolto sulla porta definita.
# kubectl get svc
Prendi nota del numero della porta (31453 in questo caso).
Verifica se il tuo servizio è implementato e disponibile (in questo esempio il comando viene eseguito sul nodo master). Utilizza il nome host del nodo e la porta che hai annotato nel passaggio precedente.
# curl docker-nakivo31:31453
Puoi anche verificare che il servizio sia accessibile dal browser di qualsiasi nodo. Nella barra degli indirizzi del browser web prova a visitare le pagine:
http:// 10.101.235.90
o
http://docker-nakivo31:31453
http://docker-nakivo32:31453
Se tutto è a posto, vedrai la pagina di benvenuto di nginx.
È inoltre possibile visitare la pagina di test di nginx da qualsiasi macchina che abbia accesso alla rete a cui sono collegati 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/
Configurazione dell’interfaccia web per il monitoraggio di Kubernetes
L’installazione di Kubernetes su Ubuntu è quasi completata, ma è possibile installare anche la dashboard di Kubernetes per una 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 , proprio come fatto in precedenza prima di eseguire i comandi.
# kubectl create -f ./kubernetes-dashboard.yaml
# kubectl apply -f ./kubernetes-dashboard.yaml
Controllare i pod.
# kubectl get pods -o wide --all-namespaces
Avvia il proxy per il server API di Kubernetes.
# kubectl proxy
Per inserire i comandi avanti nella console, apri un’altra finestra della console. In caso contrario, il processo verrebbe interrotto.
Nel browser web sul nodo master, vai alla pagina:
http://localhost:8001
Potrai visualizzare la pagina di 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 –decode
Ora puoi visualizzare il token generato:
Copia il token generato e incollalo nella sezione token dell’interfaccia web per accedere alla dashboard.
Nello screenshot qui sotto puoi vedere l’interfaccia web della dashboard di Kubernetes. Puoi visualizzare lo stato dei nodi, delle implementazioni e dei pod, nonché controllare i ruoli, le classi di storage e altri componenti. 
Configurazione di Heapster, lo strumento di monitoraggio
Installare Heapster per ampliare le opzioni di monitoraggio della dashboard di Kubernetes aggiungendo CPU, memoria e altri parametri di monitoraggio. Creare un file manifest denominato heapster.yaml .
# vim heapster.yaml
Nell’azione successiva, distribuire Heapster.
# kubectl create -f heapster.yaml
Modificare il ruolo RBAC (Controllo degli accessi basato sui ruoli) di Heapster e aggiungere le autorizzazioni per accedere alle statistiche dei Nodi.
# kubectl edit clusterrole system:heapster
Verificare che le metriche relative alla CPU e alla memoria siano misurabili nella console.
# kubectl top node
Ora è possibile aprire l’interfaccia web della dashboard di Kubernetes e notare che sono state aggiunte alcune sezioni, tra cui i grafici relativi all’utilizzo della CPU e della memoria.
Il cluster Kubernetes è ora configurato e pronto all’uso.
Distribuzione di un cluster Kubernetes ad alta disponibilità con più nodi master su Ubuntu
Disporre di un cluster Kubernetes con un unico nodo master e un paio di nodi worker è una buona opzione, ma a volte l’unico nodo master può subire un guasto a causa di problemi hardware o interruzioni di corrente. Per una maggiore tolleranza ai guasti del cluster Kubernetes distribuito su nodi Ubuntu, è preferibile considerare la distribuzione di un 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 raccomanda di utilizzare un numero dispari di nodi master; il numero minimo di nodi master in grado di garantire la 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. Consultare la tabella sottostante per un confronto del livello di 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 al guasto di 2 nodi master poiché tre nodi master rimangono attivi (3 su 5 è superiore al 50% e costituisce la maggioranza). La dimensione del cluster si riferisce al numero di nodi master presenti nel cluster.
| Dimensione del cluster | Maggioranza | Tolleranza ai guasti |
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 2 | 1 |
| 4 | 3 | 1 |
| 5 | 3 | 2 |
| 6 | 4 | 2 |
| 7 | 4 | 3 |
| 8 | 5 | 3 |
| 9 | 5 | 4 |
Questa sezione del post di oggi sul blog illustra come installare Kubernetes su nodi Ubuntu nell’ambito dell’implementazione di un cluster Kubernetes ad alta disponibilità (HA), di un proxy HA e di 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 Kubernetes HA sui nodi Ubuntu nel laboratorio di prova illustrato in questo esempio.
| № | Ruolo del nodo | Indirizzo IP | Nome host |
| 1 | Master | 192.168.101.21 | docker-nakivo21 |
| 2 | Master | 192.168.101.22 | docker-nakivo22 |
| 3 | Master | 192.168.101.23 | docker-nakivo23 |
| 4 | HA Proxy | 192.168.101.19 | ha-proxy19 |
| 5 | worker | 192.168.101.31 | docker-nakivo31 |
| 6 | worker | 192.168.101.32 | docker-nakivo32 |
Alcuni comandi sono gli stessi utilizzati per l’installazione di Kubernetes su Ubuntu con il modello a nodo master singolo. Per questo motivo, le note relative ad alcuni comandi non vengono ripetute. È possibile scorrere la pagina verso l’alto per rivedere 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.
- Impostare 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 in cui è stata spiegata l’installazione di Kubernetes su Ubuntu utilizzando un unico 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 distribuito a monte dei nodi master. Apri la console del computer ha-proxy19 ed esegui le azioni indicate di seguito.
Installa cfssl
Cfssl (CloudFlare SSL) è un toolkit utilizzato per generare diversi certificati, comprese le catene di certificati TLS/SSL.
Scaricare 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-amd64
Rendere eseguibili i file binari scaricati.
# chmod +x cfssl*
Spostare questi file binari in /usr/local/bin/
# mv cfssl_linux-amd64 /usr/local/bin/cfssl
# mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
Verifica l’installazione controllando la versione di cfssl installata.
# cfssl version
Aggiornare l’albero del repository.
# apt-get update
Installare HA Proxy.
# apt-get install haproxy
Creare e modificare il file haproxy.cfg .
# vim /etc/haproxy/haproxy.cfg
Aggiungere queste righe alla fine del file di configurazione.
frontend kubernetes
bind 192.168.101.19:6443
option tcplog
mode tcp
default_backend kubernetes-master-nodes
backend kubernetes-master-nodes
mode tcp
balance roundrobin
option tcp-check
server docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2
server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2
server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2
Riavvia il servizio.
# systemctl restart haproxy
Genera i certificati TLS
Puoi continuare a utilizzare la console del server HAProxy. Crea il file di configurazione dell’autorità di certificazione, denominato ca-config.json .
# vim ca-config.json
Aggiungi il seguente contenuto a questo file di configurazione:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": ["signing", "key encipherment", "server auth", "client auth"],
"expiry": "8760h"
}
}
}
}
Crea il file di configurazione della richiesta di firma dell’autorità di certificazione.
# vim ca-csr.json
Aggiungere il contenuto a questo file come mostrato di seguito:
{
“CN”: “Kubernetes”,
“key”: {
“algo”: “rsa”,
“dimensione”: 2048
},
“names”: [
{
“C”: “GB”,
“L”: “London”,
“O”: “Kubernetes”,
“OU”: “CA”,
“ST”: “Nakivo”
}
]
}
Dove:
C – paese, ad esempio GB (Gran Bretagna).
L – ubicazione, come una città o un paese.
O – organizzazione.
OU – unità organizzativa (ad esempio, un dipartimento definito come proprietario della chiave).
ST – lo stato o la provincia.
Ora generare la chiave pubblica e quella privata.
# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
Verifica che le chiavi ca-key.pem e ca.pem siano 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 firmata 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, generare 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 kubernetes
Elencare i file presenti nella directory per verificare che i file kubernetes-key.pem e kubernetes.pem siano stati generati.
# ls -al
Copiare 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 ~ è la directory home di kubernetes-user sugli host Ubuntu.
Preparazione dei nodi Ubuntu per l’installazione di Kubernetes
Eseguire i comandi indicati in questa sezione su tutti i nodi master e worker. Installare Docker, quindi installare Kubernetes sulle macchine Ubuntu che saranno incluse nel cluster Kubernetes. Iniziamo dalla preparazione del 192.168.101.21 nodo master.
Installare 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-ce
Docker è ora installato. Cubeadm, kublet e cubectl sono i componenti di Kubernetes obbligatori per installare Kubernetes su Ubuntu.
Installare i componenti di Kubernetes: kubeadm, kubelet 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 kubectl
Una 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 di Ubuntu
Etcd è un sistema di archiviazione 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 Kubernetes ad alta disponibilità (HA) con più nodi master. Iniziamo dalla configurazione del 192.168.101.21 nodo master.
Installing and configuring etcd on the 192.168.101.21 machine.
Creare una directory di configurazione per etcd.
# mkdir /etc/etcd /var/lib/etcd
Passare alla directory in cui sono stati copiati i certificati. Questa è la directory home dell’utente kubernetes, in questo caso – /home/kubernetes-user/
Copiare i certificati nella directory di configurazione di etcd.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Verifica che i file siano stati copiati.
# ls -al /etc/etcd
Tornare alla directory precedente
# cd -
Scarica i binari di etcd dal repository.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Estrai l’archivio di etcd.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Ora sposta i file binari di etcd in /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Crea un file di unità systemd per etcd.
# vim /etc/systemd/system/etcd.service
Aggiungi le stringhe riportate di seguito a questo file.
[Unit]
Description=etcd
Documentation=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/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Ricarica la configurazione del gestore systemd per applicare le modifiche apportate al file system e rigenerare gli alberi delle dipendenze.
# systemctl daemon-reload
Fai in modo che etcd inizi all’avvio del sistema.
# systemctl enable etcd
Avvia etcd. # systemctl start etcd
Eseguire 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 di configurazione etcd.service . Definire gli indirizzi IP corretti per ciascun altro nodo master. Ad esempio, il file di configurazione etcd.service deve essere il seguente per il secondo nodo master ( 192.168.101.22 ) dell’attuale laboratorio di test Kubernetes.
[Unit]
Description=etcd
Documentation=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/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Inizializzazione dei nodi master nel cluster HA di Kubernetes
Ora è possibile inizializzare i nodi master nel proprio cluster HA di 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.yaml
Aggiungere i parametri di configurazione a questo file:
apiVersion: kubeadm.k8s.io/v1alpha3
kind: ClusterConfiguration
kubernetesVersion: stable
apiServerCertSANs:
- 192.168.101.19
controlPlaneEndpoint: "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.pem
networking:
podSubnet: 10.244.0.0/16
apiServerExtraArgs:
apiserver-count: "3"
La rete definita come podSubnet (10.244.0.0/16) deve corrispondere a quella presente nel file kube-flannel.yml
Inizializzare la macchina Ubuntu come nodo master.
# kubeadm init --config=config.yaml
A volte è possibile visualizzare un’avvertenza relativa alla versione precedente di un file di configurazione:
Il file di configurazione utilizza una specifica API deprecata: “kubeadm.k8s.io/v1alpha3”. Utilizza ‘kubeadm config migrate –old-config old.yaml –new-config new.yaml’, che scriverà la nuova specifica, simile, utilizzando una versione più recente dell’API.
Aggiorna la versione del file di configurazione con il comando:
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
Un altro errore potrebbe verificarsi quando si inizializza un nodo di un cluster Kubernetes multi-master se etcd non è in esecuzione:
[ERROR ExternalEtcdVersion]: https://192.168.101.21:2379/versione: dial tcp 192.168.101.21:2379: connetti: connessione rifiutata
Verifica se il tuo etcd è in esecuzione. È possibile avviare manualmente etcd :
# systemctl start etcd
Dopo l’inizializzazione riuscita del nodo master nel cluster Kubernetes in esecuzione su Ubuntu, viene visualizzato il seguente messaggio, come mostrato nella schermata. 
L’output dell’esecuzione corretta di questo comando contiene un suggerimento su come iniziare a utilizzare il cluster, oltre ai comandi che includono un token e l’hash del certificato necessari per aggiungere i nodi al cluster. Salva queste stringhe importanti perché ti serviranno a breve. Sono evidenziate in giallo nella schermata e sono riportate di seguito.
Ora è possibile aggiungere 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-plane
Successivamente, è possibile aggiungere 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:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
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/config
Verificare i nodi aggiunti al cluster.
# kubectl get nodes
Copiare 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 i file apiserver.crt e apiserver.key che hanno come ubicazione la directory home (~) dell’utente kubernetes-user .
$ rm ~/pki/apiserver.*
Spostare i certificati memorizzati nella directory home nella directory /etc/kubernetes/ .
$ sudo mv ~/pki /etc/kubernetes/
Creare il file di configurazione YAML per kubeadm.
# vim config.yaml
Il 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 riportata. È possibile copiare il file già creato utilizzato sul primo nodo master del cluster HA di 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.yaml
L’output è lo stesso di quello visualizzato dopo l’inizializzazione del primo nodo master nel cluster HA di Kubernetes:
Analogamente, eseguire i comandi per avviare l’utilizzo del 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/config
Verificare i nodi aggiunti al cluster.
# kubectl get nodes
Tre nodi master su tre sono stati aggiunti al cluster. Resta da aggiungere un nodo master.
Inizializzazione del terzo nodo master (192.168.101.23)
Ripetere gli stessi passaggi eseguiti per l’inizializzazione del secondo nodo (192.168.101.22) nel cluster. Non dimenticare di prendere nota dei comandi con token e hash per l’aggiunta dei nodi al cluster, 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 risolvere lo stato “NotReady” dei nodi master in Kubernetes
Installiamo Flannel. A differenza del primo esempio, in cui avete imparato a installare Kubernetes su Ubuntu per creare un cluster con un unico master, in questo esempio Flannel verrà installato utilizzando il file YAML.
Eseguite il comando per installare Flannel e risolvere lo stato “NotReady” dei nodi visualizzato, poiché non è ancora stata configurata alcuna rete overlay. Create il file kube-flannel.yaml con l’editor di testo vim, ad esempio sul primo nodo master.
# kubectl apply -f kube-flannel.yml
Ricordate l’indirizzo del podSubnet definito nel file config.yaml . L’indirizzo di rete deve essere lo stesso nel file kube-flannel.yaml .
Controllate i vostri nodi e il loro stato.
# kubectl get nodes
Ora tutti i nodi master funzionano correttamente.
Aggiunta di nodi worker al cluster
Una volta inizializzati tutti i nodi master, potete aggiungere nodi worker al vostro cluster Kubernetes. Aggiungiamo il primo nodo worker ( 192.168.101.31 ) al cluster Kubernetes HA distribuito su macchine Ubuntu. Utilizzate il comando visualizzato dopo l’inizializzazione dei nodi master (il comando che contiene token e hash) per far entrare il nodo worker nel cluster. Eseguite il comando sulla macchina 192.168.101.31 .
# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Controlla i nodi del cluster Kubernetes HA per assicurarti che il nodo worker sia stato aggiunto. Ora puoi vedere anche la macchina proxy HA nell’elenco dei nodi.
# kubectl get nodes
Allo stesso modo, aggiungi altri nodi worker al cluster Kubernetes ad alta disponibilità installato su macchine Ubuntu. Puoi aggiungere altri nodi worker 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 dedicare un po’ di tempo all’implementazione del cluster Kubernetes, ma, di conseguenza, si ottengono numerosi vantaggi quali una gestione centralizzata più semplice, un’elevata scalabilità e il bilanciamento del carico. Il tipo più semplice di implementazione di Kubernetes è un’implementazione con un unico master: è 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 cluster Kubernetes multi-master, noto come cluster Kubernetes ad alta disponibilità. Questo tipo di implementazione di Kubernetes elimina il singolo punto di guasto e il vostro cluster può continuare a funzionare anche in caso di guasto di alcuni nodi master.
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 swap e, infine, installare i componenti di Kubernetes quali kubeadm, kubectl, kubelet e configurare Flannel per la rete overlay. Nel caso dell’implementazione del cluster Kubernetes HA, è inoltre necessario configurare il proxy HA su una macchina autonoma, generare certificati e configurare il cluster etcd. La maggior parte delle fasi relative alla configurazione di Kubernetes, alla creazione di implementazioni e all’esecuzione dei pod può essere eseguita con due metodi: l’esecuzione manuale dei comandi forniti dall’interfaccia a riga di comando e l’utilizzo di file di configurazione YAML. L’uso dei file YAML consente di creare strutture più complesse e rende il processo di amministrazione più pratico.
È possibile installare Kubernetes su Ubuntu, sia su macchine fisiche che VM. Se Kubernetes è installato su VM in esecuzione su vSphere, è possibile garantire una protezione aggiuntiva utilizzando Cluster VMware ad alta disponibilità con la funzione Fault Tolerance. La logica di implementazione di Kubernetes illustrata in questo articolo del blog può essere utilizzata anche per installare Kubernetes su altre distribuzioni Linux.
