Ciao a tutti.
E bentornati.
Ora, nel video precedente, abbiamo avuto una grande introduzione al motore di orchestrazione dei container.
Abbiamo già detto che esistono diversi motori di orchestrazione.
Quindi ci sono Docker swarm, missili Apache, Kubernetes e vari altri.
Di conseguenza, Kubernetes è uno dei motori di orchestrazione di container più diffusi e disponibili.
Nel video di oggi, avremo un'introduzione di alto livello a Kubernetes, seguita da alcune brevi
dimostrazioni.
Ora, Kubernetes è un motore di orchestrazione di container open source, sviluppato da Google.
Kubernetes è stato completamente sviluppato e mantenuto da Google, per poi passare alla C
e ZF, la Cloud Native Computing Foundation, che attualmente lo gestisce.
Quindi Kubernetes è anche indicato come k8s in forma abbreviata.
Il motivo per cui si ha k8 è che tra la K e la S ci sono otto caratteri.
Ed è per questo motivo che viene chiamata K.
Si parla ora dell'architettura di Kubernetes.
Qui c'è un master Kubernetes e ci sono i nodi worker.
Quindi i nodi worker sono fondamentalmente i server fisici o le macchine virtuali in cui vengono eseguiti
i container.
Il master Kubernetes è colui che gestirà i container.
Quindi il master Kubernetes riceverà fondamentalmente i comandi dagli utenti.
Ora, la domanda è: come riceverà i comandi?
Quindi può ricevere i comandi via API, via CLI e via UI.
Quindi avete API CLA e GI attraverso le quali gli utenti potranno inviare i comandi al master Kubernetes
e il master Kubernetes elaborerà le cose che sono menzionate nei comandi.
Cerchiamo di capirlo con una semplice analogia.
Supponiamo di avere un comando chiamato "Voglio lanciare l'applicazione A".
Questo è il comando che si dà a Kubernetes, master.
Ora il master di Kubernetes controllerà quanti nodi ha.
Attualmente ci sono tre nodi associati al master Kubernetes.
Quindi si avvierà l'applicazione in uno dei nodi.
Ora, esistono vari algoritmi in base ai quali viene selezionato un nodo specifico, quindi non è detto
che il nodo A abbia attualmente il 100% del carico della CPU.
Quindi, in questo caso, Kubernetes master non invierà realmente l'applicazione a Node one.
Lo invierà al nodo che ha più risorse disponibili.
Ci sono quindi molte cose che stanno accadendo dietro le quinte, ma al momento stiamo solo guardando
una panoramica di alto livello qui.
Va bene.
Quindi attualmente il comando fornito dall'utente Kubernetes è master lo ha preso e ha
lanciato il contenitore in uno dei nodi worker.
Ora, diciamo che per qualche motivo questo nodo worker ha smesso di funzionare.
Il motivo per cui il server ha smesso di funzionare può essere un problema di alimentazione, di connettività di rete,
di kernel e altri ancora.
Quindi ora, una volta che questo nodo worker ha smesso di funzionare, Kubernetes master lo rileverà automaticamente.
Quindi rileva automaticamente che il nodo worker non funziona bene e migra il contenitore su
un altro nodo worker in esecuzione.
Per questo motivo si parla anche di verbale d'intenti.
Questo è il record di intenti in una panoramica di alto livello.
Quindi la registrazione dell'intento è generalmente fornita dall'utente, che dichiara di voler lanciare un'applicazione in un contenitore.
Questo è il contenitore dell'applicazione.
E come utente dico all'OC di Kubernetes: voglio lanciare il contenitore dell'applicazione, e questo è tutto.
Ora non devo fare nient'altro.
Kubernetes si occuperà sia del lancio del container che della sua gestione a lungo termine.
Quindi, come stavamo discutendo, non si tratta solo di lanciare il contenitore una volta sola.
Si tratta anche di un controllo dello stato di salute.
Il master Kubernetes non solo può rilevare che il nodo è inattivo, ma anche che l'applicazione non funziona correttamente.
E se il contenitore di app non funziona correttamente, può riavviare automaticamente il contenitore di app.
Può migrare automaticamente il contenitore dell'applicazione su diversi nodi worker e altri.
Quindi ci sono molte cose che stanno accadendo dietro le quinte.
Nel video di oggi, quindi, ci siamo concentrati soprattutto sull'introduzione.
Quindi stiamo solo guardando una panoramica di alto livello su come funzionano le cose.
Vediamo quindi di passare rapidamente alla demo per capirne di più.
Sono nella mia classe e facciamo rapidamente un cubo.
Ottenere i nodi.
Attualmente ho un nodo disponibile.
Durante la fase architettonica abbiamo parlato di un master Kubernetes e
di più nodi worker.
Quindi i nodi worker sono fondamentalmente il luogo in cui vengono distribuiti i container.
Quindi i nodi lavoratori possono essere uno, 100 o 1000.
Quindi dipende molto da questo.
Quindi, per la nostra demo, abbiamo un nodo worker, che è attualmente disponibile.
Ora, nella diapositiva successiva, abbiamo parlato della registrazione delle intenzioni, dove attraverso uno dei mezzi di comunicazione
può essere chiara l'API, abbiamo fornito una registrazione delle intenzioni.
Quindi il record di intenti era: voglio lanciare un'applicazione in un contenitore, quindi proviamola.
Quindi dirò che verrà eseguito, lo chiamerò Motore X e lo lancerò dall'immagine del Motore X.
Ora non è necessario preoccuparsi di quali siano questi comandi.
Ne parleremo in dettaglio nel prossimo video.
Questo video specifico serve solo a dare un'idea di Kubernetes.
Quindi, una volta eseguito, viene detto che il motore di distribuzione è stato creato.
E ora se si fa un cubo, si ottengono porte.
Si vedrà che c'è un pod che è attualmente in fase di creazione.
Cosa è successo esattamente?
Abbiamo detto a Kubernetes che vogliamo lanciare un container dall'immagine del motore X.
Questa è la parte che abbiamo fatto e che è stata fornita al master Kubernetes.
Ora, il master di Kubernetes esaminerà i nodi worker e lancerà quel pod specifico in uno dei
nodi worker.
Quindi, per cominciare, si può parlare di pod come di un contenitore.
In pratica Kubernetes ha lanciato il contenitore in uno dei nodi worker.
Se si aggiorna, si vedrà che lo stato di questa scheda è in esecuzione.
Quindi ora questo pod è in esecuzione nel mio server, dove stiamo eseguendo i comandi CLI.
Quindi, se faccio un pezzo Docker sul motore X, in effetti, lasciatemi copiare questo nome.
Vedrete che avete un contenitore di motore funzionante.
Quindi ora facciamo una cosa.
Fermiamo questo contenitore e vediamo cosa succede esattamente.
Perciò dirò: Docker, fermati.
Seguito dal contenitore.
Ora, se si esegue un'analisi di Docker, si dovrebbe vedere che il primo contenitore che avevamo fermato
non è più presente qui.
Quindi, ora si sta esaminando l'architettura.
Quindi abbiamo detto a Kubernetes di lanciare un container dall'immagine del motore X.
Kubernetes è andato avanti e ha creato il contenitore.
Quindi, invece di cancellare il nodo, abbiamo fermato manualmente il contenitore.
Oppure si può dire che abbiamo ucciso il contenitore.
In questo modo Kubernetes sarà in grado di rilevare che questo contenitore non funziona più e potrà avviarlo
automaticamente o avviare automaticamente un nuovo contenitore in un nodo diverso.
Quindi, se volete vedere di nuovo, fate un pezzo di Docker e vedrete che è stato lanciato un altro contenitore.
Quindi questo contenitore è stato lanciato prima di 53 secondi.
Questa è una delle caratteristiche principali di un tipico motore di orchestrazione, che nel nostro caso è Kubernetes.
Spero che ad alto livello tutti voi abbiate capito cos'è Kubernetes.
Anche in questo caso, si tratta solo di uno degli esempi che abbiamo preso.
Ora, Kubernetes ha molte caratteristiche e ne parleremo nel corso del corso.
Ora, prima di concludere questo video, vorrei mostrarvi un'altra cosa.
Abbiamo quindi discusso dei tre modi in cui è possibile fornire i comandi a Kubernetes.
Master, avete l'API, avete il ClA e avete l'interfaccia utente.
Quindi il comando CTL che stavamo eseguendo in questa dimostrazione era un esempio di CLI.
Inoltre, avete la caratteristica dell'interfaccia utente.
Quindi, se volete vedere come appare esattamente Java, questa è la dashboard dell'interfaccia utente di Kubernetes.
Attualmente, se vedete qui, tra i nodi, è indicato che c'è un nodo lavoratore disponibile.
Mostra anche le specifiche della CPU e della memoria di quello specifico nodo worker.
Oltre a questo, può anche mostrare varie informazioni sui container correnti che stanno
eseguendo i set di demoni, le distribuzioni e così via. Si tratta quindi di una grande IG disponibile, che aiuta
davvero a capire le cose in modo più rapido, perché l'interfaccia utente è sempre il modo più veloce per dimostrare le cose.
Questo è l'IG.
Abbiamo anche esaminato la CLI e sicuramente è possibile fornire comandi anche tramite API.
Questa è la panoramica di alto livello su Kubernetes.
Anche in questo caso, nel video di oggi abbiamo avuto una panoramica di alto livello.
Spero che abbiate capito cos'è Kubernetes e quali sono le cose che può fare.
Nei prossimi video approfondiremo Kubernetes e analizzeremo molte caratteristiche
del motore di orchestrazione Kubernetes.
Con ciò si conclude questo video.
Spero che questo video sia stato istruttivo per voi e vi do appuntamento al prossimo video.