Una guida per principianti a Kubernetes

Cos'è Kubernetes?

Kubernetes o K8S è una piattaforma gratuita e open source per la gestione di ambienti e servizi di applicazioni containerizzati. Kubernetes consente di creare applicazioni portatili portatili e altamente estensibili che sono facili da distribuire e gestire. È comunemente usato insieme a Docker per sviluppare un migliore controllo di applicazioni e servizi containerizzati.

Caratteristiche di Kubernetes

Le seguenti sono le caratteristiche essenziali offerte da Kubernetes:

1. Implementati e rollback automatizzati in caso si verificano errori.
2. Infrastruttura scalabile automatica.
3. Ridimensionamento orizzontale
4. Bilanciatori di carico
5. Controlli sanitari automatizzati e capacità di auto-guarigione.
6. Infrastruttura altamente prevedibile
7. Supporti e sistema di archiviazione per eseguire applicazioni
8. Utilizzo efficiente delle risorse
9. Ogni unità Kubernetes è vagamente legata tra loro e ognuna può fungere da componente autonomo.
10. Gestione automatica di componenti di sicurezza, rete e rete.

Architettura Kubernetes

Comprendere l'architettura Kubernetes ti aiuterà a acquisire una conoscenza più profonda di come lavorare con Kubernetes.

Di seguito sono riportati i componenti hardware dell'architettura Kubernetes:

Un nodo è una rappresentazione di una singola macchina in un cluster Kubernetes. Il nodo rappresenta una singola macchina da lavoratore, in una macchina virtuale o hardware fisico.

Ogni nodo in Kubernetes comprende vari componenti software di Kubernetes come PODS, Kubulet, Kube-Proxy e il runtime dei container come Docker.

Un pod si riferisce a una o più applicazioni containerizzate in bundle insieme. Kubernetes gestisce i rispettivi baccelli anziché i contenitori e crea repliche se uno di essi fallisce. I pod forniscono risorse condivise come interfacce di rete e dispositivi di archiviazione.

Container/Container-Runtime

Un contenitore è un pacchetto software isolato e autonomo. Un contenitore contiene tutto ciò che è necessario per eseguire un'applicazione, tra cui codice, librerie di sistema e altre dipendenze. Una volta distribuito un contenitore, non è possibile modificare il codice in quanto sono immutabili. Per impostazione predefinita, il runtime di Kubernetes Container è fornito da Docker.

Kubelet

Il kubelet è una semplice applicazione che consente la comunicazione tra il nodo e il nodo principale. È responsabile della gestione dei pod e dei contenitori. Il nodo principale utilizza il kubectl per eseguire le azioni necessarie al nodo specifico.

Kube-Proxy

Kube-Proxy è un proxy di rete disponibile in tutti i nodi Kubernetes. Gestisce le comunicazioni di rete all'interno e all'esterno del cluster.

Grappolo

Un cluster è una raccolta di nodi di Kubernetes che aggregano le loro risorse per creare una macchina potente. Le risorse condivise dai nodi Kubernetes includono memoria, CPU e dischi.

Un cluster Kubernetes è composto da un nodo principale e da altri nodi slave. Il nodo principale controlla il cluster di Kubernetes, comprese le applicazioni di pianificazione e ridimensionamento, spingendo e applicando gli aggiornamenti e gestione degli stati del cluster.

Volumi persistenti

I volumi persistenti vengono utilizzati per archiviare i dati in un cluster Kubernetes. I volumi persistenti sono realizzati da vari volumi dai nodi del cluster. Una volta che un nodo nel cluster viene rimosso o aggiunto, il nodo principale distribuisce il lavoro in modo efficiente.

Ingresso

L'ingresso di Kubernetes è un oggetto API che consente l'accesso al servizio Kubernetes al di fuori del cluster. Ingress utilizza in genere il protocollo HTTP/HTTPS per esporre i servizi. Un ingresso è implementato su un cluster usando un controller di ingresso o un bilanciamento del carico.

Maestro

Il maestro, noto anche come piano di controllo, si riferisce al componente di controllo centrale per l'architettura Kubernetes. È responsabile della gestione del carico di lavoro e dell'interfaccia della comunicazione tra il cluster e i suoi membri.

Il maestro è composto da vari componenti. Questi includono:

1. Manager di controllo
2. Scheduler
3. Server API
4. Ecc

Manager di controllo

Il Control Manager o Kube-Control-Manager è responsabile della gestione e della gestione del cluster. Il demone di controllo raccoglie informazioni sul cluster e le riporta al server API.

Scheduler

Kube-Scheduler o semplicemente lo scheduler è responsabile della distribuzione del carico di lavoro. Svolge funzioni come determinare se il cluster è sano, creazione di contenitore e altro ancora.

Tiene traccia di risorse come memoria e CPU e pianifica i baccelli ai nodi di calcolo appropriati.

Server API

Kube-Apiserver è un'interfaccia front-end per il Master Kubernetes. Ti consente di parlare con il cluster Kubernetes. Una volta che il server API riceve una richiesta, determina se la richiesta è valida e la elabora se vera.

Per interagire con il server API, è necessario utilizzare le chiamate di riposo tramite gli strumenti di controllo della riga di comando come Kubectl o KubeADM.

Ecc

L'ETCD è un database di valore chiave responsabile dell'archiviazione dei dati di configurazione e delle informazioni sullo stato del cluster Kubernetes. Riceve comandi da altri componenti del cluster ed esegue le azioni necessarie.

Esecuzione di Kubernetes

Questa sezione copre come iniziare con Kubernetes. Questa illustrazione è testata su un sistema Debian.

Avvia il terminale e aggiorna il tuo sistema.

Sudo Apt-get Aggiornamento
SUDO APT-OPGRADO

Quindi, installa vari requisiti come mostrato nel comando seguente:

SUDO APT-get Installa Curl GNUPG CA-certificati APT-Transport-Https

Installa Docker

Successivamente, dobbiamo installare Docker poiché Kubernetes lo utilizzerà come runtime del contenitore. Le istruzioni seguenti sono per il sistema operativo Debian. Scopri come installare Docker sul tuo sistema.

Aggiungi la chiave GPG ufficiale Docker:

Curl -fssl https: // download.Docker.com/linux/debian/gpg | sudo
GPG--DEARMOR -O/USR/Share/Keyrings/Docker-Archive-Keyring.gpg

Successivamente, imposta i repository Docker alle fonti come mostrato nel comando:

eco \
"Deb [Arch = AMD64 firmato per.gpg] https: // download.Docker.com/linux/debian \
$ (lsb_release -cs) stabile "| sudo tee/etc/apt/fonti.elenco.D/Docker.Elenco> /dev /null

Quindi, aggiorna e installa docker:

Sudo Apt-get Update && sudo apt-get install Docker-ce Containerd.IO Docker-Ce-Cli

Infine, avvia e abilita il servizio Docker

sudo systemctl abilita docker.servizio
sudo systemctl avvia docker.servizio

Installa kubernetes

Successivamente, dobbiamo installare Kubernetes sul sistema. Allo stesso modo, le istruzioni in questa guida sono testate su un sistema Debian.

Scopri come installare Kubernetes sul tuo sistema

Inizia scaricando la chiave di firma di Google Cloud:

sudo curl -fsslo/usr/share/keyrings/kubernetes-archive-keyring.gpg https: // pacchetti.nuvola.Google.com/apt/doc/apt-key.gpg

Successivamente, aggiungi il repository di Kubernetes:

echo "deb [firmato per =/usr/share/keyrings/kubernetes-archive-keyring.gpg] https: // apt.Kubernetes.io/kubernetes-xenial main "| sudo tee/etc/apt/fonti.elenco.d/kubernetes.elenco

Infine, aggiorna e installa i componenti Kubernetes

Sudo Apt-get Aggiornamento

sudo apt-get installa kubectl kubelet kubeadm kubernetes kubernetes-cni

Nodo master inizialeaze kubernetes

Il prossimo passo è avviare il nodo master kubernetes. Prima di farlo, si consiglia di disattivare lo scambio.

Per fare questo, usa il comando:

sudo swapoff -a

Una volta disattivato lo scambio, inizializza il nodo principale con i comandi:

sudo kubeadm init

Una volta che il comando esegue correttamente, dovresti ottenere tre comandi.

Copia ed esegui i comandi come:

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

Distribuisci la rete POD

Il prossimo passo è distribuire una rete di pod. In questa guida, useremo il CNI AWS VPC per Kubernetes.

Usa il comando come:

sudo kubectl applicare -f https: // raw.githubusercontent.com/AWS/Amazon-VPC-CNI-K8S/V1.8.0/config/v1.8/AWS-K8S-CNI.Yaml

Al termine, assicurarsi che il cluster sia attivo e funzionante eseguendo il comando:

Sudo Kubectl Cluster-Info

Sarebbe meglio se avessi ottenuto l'output come mostrato:

Il piano di controllo Kubernetes è in esecuzione su https: // 192.168.43.29: 6443
Coredns è in esecuzione su https: // 192.168.43.29: 6443/API/v1/namespaces/kube-system/servizi/kube-dns: dns/proxy

Per mostrare tutti i nodi in esecuzione, usa il comando:

sudo kubectl ottieni nodi

Distribuire un'applicazione

Distribuiamo un'applicazione MySQL ed esponiamo il servizio sulla porta 3306. Usa il comando come mostrato:

sudo kubectl applicare -f https: // k8s.IO/Esempi/Applicazione/MySQL/MySQL-Diskingment.Yaml
sudo kubectl esponi la distribuzione mysql --port = 3306 --name = mysql-server

Per mostrare l'elenco delle distribuzioni, utilizzare il comando:

Kubectl ottiene distribuzioni

Per ottenere informazioni sui pod, utilizzare il comando:

sudo kubectl descrivi i baccelli

Per riassumere

Kubernetes è uno strumento di distribuzione e gestione dei contenitori robusti. Questo tutorial graffia solo la superficie di Kubernetes e le sue capacità.