L'argomento di oggi è uno di quelli di cui quasi tutti hanno sentito parlare, ma che in pochi sanno spiegare. GitOps. Probabilmente lo avrete sentito menzionare in annunci di lavoro, interventi a conferenze, nella documentazione di azione. Ma cos'è esattamente? È solo un altro termine di moda DevOps o è qualcosa di fondamentalmente diverso? Ecco la versione brev. GitOps è un modello operativo in cui Git diventa l'unica fonte di verità per l'intera infrastruttura. Non solo il codice dell'applicazione, ma tutto ciò che lo esegue. Alla fine di questo episodio capirai cos'è effettivamente GitOps, perché è diventato lo standard per la gestione di Kubernetes Azure e come rende i rollback semplici come un singolo comando. Il vecchio metodo è distribuzione manuale e la della configurazione. Iniziamo con il problema che GitOps risolve. L'immagine di gestire un cluster Kubernetes su Azure. Hai degli sviluppatori che eseguono il push del codice, una pipeline CI che crea immagini di container e qualcuno esegue il kubectl apply per distribuire tale immagini. Forse tu, forse un compagno di team, o clicchi su un pulsante in Azure DevOps e in entrambi i casi la distribuzione avviene. Funziona bene finché non succede più. Ecco cosa succede, dom. Qualcuno nel tuo team deve correggere un bug veloce, quindi si connette tramite SSH a un nodo, usa il portale di Azure o esegue kubectl edit direttamente su una distribuzione. Apporta una piccola modifica, come una modifica alla mappa di configurazione o una variabile di ambiente diversa, e sembra innocua. O almeno così pensa. Il problema è che quella modifica non è mai arrivata a Git, quindi il tuo cluster ora ha una configurazione che non corrisponde a quella presente nel tuo repository. Questo è chiamato spostamento della configurazione. Lo spostamento è un killer silenzioso perché funziona bene, fino alla distribuzione successiva, quando qualcuno esegue kubectl apply con il manifesto originale e sovrascrive quella correzione rapida. O peggio, lo spostamento causa un comportamento imprevisto che nessuno riesce a spiegare. Inizia il debug, controlla i registri, guardia il YAML in Git, e non sembra che ci sia nulla di sbagliato, ma il cluster sta facendo qualcosa di diverso. Non hai idea di cosa sia cambiato, quando sia cambiato, o chi lo abbia cambiato. Ho visto succedere una cosa del genere. Un compagno di squadra si connette tramite SSH a un nodo, modifica una configurazione per testare qualcosa, dimentica di ripristinare la tona a casa. Il giorno dopo, una distribuzione si interrompe, nessuno riesce a spiegarne il motivo. Il repository Git sembra pulito, ma il cluster è un disastro e rimani bloccato a passare ore a cercare di capire cosa sia successo. Ecco la domanda. C'era un modo per forzare il cluster a corrispondere sempre a ciò che si trova in Git. Se potessi garantire che tutto ciò che si trova nel tuo repository sia esattamente ciò che è in esecuzione e in produzione, questa è l'idea di base di GitOps. Cos'è in realtà GitOps? Quindi, cos'è esattamente GitOps? Ecco la definizione più semplice che posso dare. Git diventa la tua unica fonte di verità, non solo per il tuo codice, ma per tutto ciò di cui la tua infrastruttura ha bisogno per funzionare. Ogni configurazione, ogni manifesto di distribuzione, ogni variabile di ambiente, tutto risiede in Git, in Git. Niente viene eseguito sul tuo cluster, a meno che non sia definito lì. Ora, GitOps non è uno strumento che puoi acquistare. È un modello operativo come DevOps o DevSecOps. Un insieme di principi che guidano il modo in cui gestisci la tua infrastruttura. Lo standard OpenGitOps stabilisce quattro principi fondamentali. E voglio esaminarli tutti. Innanzitutto, il tuo sistema deve essere dichiarato. Ciò significa che descrivi lo stato finale, non i passaggi per arrivarci. Quindi, invece di scrivere uno script che dice Crea una distribuzione, scala la 5 repliche, esponi la porta 8080, scrivi un file YAM che dice Voglio 5 repliche sulla porta 8080 del sistema, capisce i passaggi. Questo è dichiarato. Deve essere sottoposto a controllo di versione. Ogni modifica portata allo stato del cluster è un commit in Git. Quindi è una cronologia completa di chi ha modificato cosa, quando e perché. Non dovrai più indovinare o cercare nei registri. Terzo luogo, le modifiche vengono estratte automatiche. Il cluster cerca di vedere cosa c'è di nuovo. Più avanti spiegherò perché questo è così importante. E quarto, il sistema viene continuamente riconciliato. C'è un agente software in esecuzione all'interno del cluster che confronta costantemente ciò che è in Git con ciò che è effettivamente in esecuzione. Se non corrispondono, corregge la differenza. Questo è il ciclo di riconciliazione. Pensalo in questo modo. Git è il progetto del tuo architetto. Descrive esattamente come dovrebbe apparire l'edificio. Kubernetes è il cantiere. E l'operatore GitOps è il capo squadra. Gira con il progetto controllando ogni muro, ogni trave, ogni finestra. Se qualcosa non corrisponde, lo corregge. Supponiamo che qualcuno del team apporti una modifica non autorizzata, la individua e la ripristina. Il progetto è sempre la fonte della verità. Ma è qui che avviene il vero cambiamento. Come funzionano effettivamente le distribuzioni? Nel CI CD tradizionale, modifiche vengono inviate al cluster. In GitOps il cluster le estrae, e questa differenza è più importante di quanto sembra. Distribuzioni basate su push? Parliamo di come funzionano effettivamente le distribuzioni, perché è qui che GitOps cambia tutto. Nel tradizionale modello basato su push, la pipeline CI fa tutto. Azure Pipelines Jenkins GitHub Actions. Crea il contenitore, esegue i test, e quindi esegue il push di quell'immagine direttamente nel cluster Kubernetes. La pipeline contiene le credenziali che le consentono di accedere direttamente al cluster. Di cerco la nuova distribuzione. Applicala ora. E funziona ma crea un problema di sicurezza. Il fatto è che se quella pipeline viene compromessa, qualcuno inserisce un passaggio dannoso, si verifica una perdita di token, una dipendenza viene dirottata. Quella pipeline ha una linea diretta con il cluster di produzione. Può distruggere le distribuzioni, eliminare gli spazi dei nomi, modificare le configurazioni, tutto con le autorizzazioni che lei ha concesso per svolgere suolo. Ora guarda il modello GitOps. Il flusso inizia allo stesso modo. CI crea il contenitore, lo esegue il push in un registro come Azure Container Registry. E qui che ci si interrompe. Non tocca il cluster. Invece, CI aggiorna un repository Git con il nuovo tag immagine, modifica una singola riga in un file YAML, la versione dell'immagine, e conferma tale modifica. Tutto qui. Nessun accesso direto al cluster. Quindi l'operatore GitOps in esecuzione all'interno del cluster rileva tale modifica. Estrà lo stato più recente da Git e lo applica. Il cluster si collega a Git, non viceversa. Questo è un modello basato su pull. Il cluster non espone mai la propria API a sistemi esterni. Attinge solo da Git. Se qualcuno compromette la pipeline CI, la cosa peggiore che può fare è modificare un manifesto in un repository. Non può toccare direttamente il cluster. L'operatore decide cosa applicare quando c'è anche un altro vantaggio. Si separa la creazione dalla distribuzione. CI fa ciò in cui è brava. Creazione, test, scansione. L'operatore GitOps gestisce la distribuzione. Ogni sistema si concentra su un'attività. Se la creazione non riesce, non cambia nulla nel cluster. Se la distribuzione non riesce, l'operatore riprova o ti avvisa. Non è netta separazione. Quindi invece di una pipeline che invia le modifiche al cluster, il cluster estrae lo stato desiderato da Git. Questa semplice inversione rende l'infrastruttura più sicura, più verificabile e più difficile da violare accidentalmente. Il ciclo di riconciliazione. Come fa l'operatore a sapere quando effettuare la giornata? Non attende una notifica. Esegue un ciclo continuo. Osserva Git confrontandolo con il cluster. Applica le modifiche se necessario. Quindi lo ripete all'infinito. Questo è chiamato ciclo di riconciliazione. Viene eseguito costantemente. Ogni pochi secondi o minuti, a seconda della configurazione. L'operatore non smette mai di controllare. Pensalo come un termostato in casa tua. Imposti la temperatura desiderata, diciamo 21 gradi CES. Termostato controlla costantemente la temperatura FD. Se scende sotto i 21 gradi CES, il riscaldamento si accende. Se sale sopra il riscaldamento si spegne. Continua a regolarsi per adattarsi alle tue impostazioni. L'operatore GitOps funziona allo stesso modo. Git mantiene lo stato desiderato, il cluster ha lo stato effettivo e l'operatore li confronta continuamente apportando modifiche. Quindi cosa succede quando qualcuno modifica manualmente una distribuzione del cluster? Forse esegue uno kubectl edit per modificare un conteggio di repliche. L'operatore rileva tale differenza nel ciclo di riconciliazione successivo. Il cluster ora ha tre repliche ma Git ne specifica cinque. Quindi l'operatore applica lo stato definito da Git e il cluster torna a cinque repliche. La modifica è notorizzata e scomparla. Cosa succede quando si esegue il push git? Stesso processo. L'operatore rileva la differenza e la applica. Uno sviluppatore unisce un APR che aggiorna la versione dell'immagine dalla versione 1.2 alla versione 1.3. L'operatore visualizza il nuovo manifesto, estrae la nuova immagine e avvia i nuovi pod. In pochi secondi il cluster corrisponde in nuovo a Git. Ora qui c'è una distinzione importante. Se un pod si arresta in modo anomalo, l'operatore non. Ha un lavoro di Kubernetes gestito dal controller del set di repliche. L'operatore GitOps si preoccupa solo della configurazione. Se il manifesto di distribuzione indica cinque repliche, immagine v1.3 e il cluster a cinque repliche in esecuzione sulla v1.3, l'operatore è soddisfatto. Non gli importa se un pod specifico è stato riavviato. Questo è il normale comportamento di Kubernetes. Tuttavia, se qualcuno modifica il manifesto in Git o se qualcuno modifica direttamente il cluster e crea una deviazione in deviazione, l'operatore intende. Ecco perché GitOps è autoriparante. Non si limita a distribuire le modifiche, ma impiedisce attivamente che la tua infrastruttura si allontani da quanto definito. Quindi ha bisogno di un operatore GitOps in esecuzione nel tuo cluster. È qui che entra in gioco Argo CD e Flux, Argo CD contro Flux. Quindi hai bisogno di un operatore GitOps e hai due scelte principali, entrambe eccellenti. Argo CD e Flux sono entrambi i progetti laureati CNCF, in che significa che hanno superato gli standard più elevati per stabilità, community e prontezza per la produzione. Ma affrontano lo stesso lavoro da angolazioni diverse. Argo CD è stato originamente creato da Intuit ed è dotato di un'interfaccia utente web. Quando installi Argo CD ottieni una dashboard in cui puoi vedere ogni applicazione, il suo stato di sincronizzazione, il suo stato di integrità e la cronologia delle distribuzioni. Puoi cliccare in giro, visualizzare le differenze tra Git e il cluster, attivare manualmente le cose, approvare le modifiche. È progettato per i team che desiderano dashboard visive e punti di controllo manuali. Flux deriva da WeWorks ed è più modulare. Non c'è un'interfaccia utente predefinita. Lavori dalla riga di comando e definisci tutto come risorse personalizzate di Kubernetes. Crea un oggetto repository Git che dice guarda questo repository. E un oggetto di personalizzazione che dice applica questo percorso. Flux lo rileva e lo riconcilia. Ti obbliga ad adottare flussi di lavoro nativi di Git perché non c'è una dashboard su cui ripiegare. Ecco cosa conta per gli utenti di Azure. Flux è l'opzione GitOps predefinita su Azure Kubernetes Service. Microsoft ha creato un'integrazione nativa attorno a Flux V2. Quando abiliti GitOps su un cluster HS tramite il portale di Azure, stai utilizzando Flux in background. Azure Arc utilizza anche Flux per la gestione multicluster. Quindi se sei un ingegnere di Azure, Flux è il punto di partenza naturale. Argo CD ha i suoi punti di forza. È più popolare per gli scenari di progettazione di piattaforme in cui si desidera un piano di controllo centrale per la gestione di più cluster. L'interfaccia utente semplifica le cose per i team che non hanno dimestichezza con la riga di comando. Inoltre si integra perfettamente con Argo Allouts per la distribuzione progressiva come distribuzioni canali, distribuzioni blue, berge e verdi simili. La differenza principale a livello di architettura è questa. Argo CD viene eseguito come applicazione autonoma con il proprio server IPA. Flux viene eseguito come un set di controlli a Kubernetes più profondamente integrati nel cluster stesso. Flux sembra parte del piano di controllo Kubernetes, mentre Argo CD sembra una piattaforma separata che si trova al di sopra di esso. Flux si basa inoltre in larga misura su Customize, uno strumento di creazione di modelli nativo di Kubernetes. Argo CD può utilizzare Customize, N o YAML semplice. Entrambi supportano Helm, ma Flux ha un controller Helm dedicato che gestisce le versioni di Helm in modo nativo. Non esiste una scelta sbagliata. Entrambi gli strumenti svolgono lo stesso. Ma per gli ingegneri di Azure, Flux è la strada più semplice. Puoi abilitare GitOps con Flux in pochi clic tramite il portale di Azure, indirizzarlo a un repository Git e avviare la sincronizzazione. Nessuna installazione aggiuntiva, nessun server separato da gestire. GitOps su Azure, HHS, Azure Arc e Azure DevOps. Quindi come appare effettivamente quando lo colleghi ad Azure? Iniziamo con HHS. Azure Kubernetes Service ha il supporto GitOps integrato tramite Flux V2. Nel portale di Azure vai al tuo cluster, trova la sezione GitOps e configuralo indirizzandolo a repository Git. Azure Repos Git Hub ovunque. Flux inizia a monitorare e qualsiasi manifesto inserisci in quel repository viene applicato automaticamente al tuo cluster. Ma HHS è solo un pezzo. Azure Arc estende GitOps ai cluster che non si trovano in Azure, in locale, in altri cloud e in periferia. Collegare l'Azur Arc e gestisci di tutti con la stessa configurazione GitOps. Un repository molti cluster, stato coerente ovunque. E cosa fa? Ora parliamo della pipeline? Azure DevOps si integra naturalmente con questo modello ed ecco lo schema comune. Il codice sorgente si trova in Azure Repos o GitHub e Azure Pipelines gestisce CI. Crea l'immagine del contenitore, esegui i test, esegui la scansione per rilevare le vulnerabilità ed esegui il push dell'immagine Azure Container Registry. Quindi la pipeline aggiorna i manifesti nel repository GitOps modificando il tag immagine da v1.2 a v1.3 esegue il comit di tale modifica e rese tutto qui. La pipeline non tocca mai il cluster. Flux in esecuzione all'interno di HHS rileva la modifica in Git. Estrae il nuovo manifesto, visualizza il tag immagine aggiornato e applica la distribuzione. Vengono avviati nuovi pod e il cluster viene conciliato. Se preferisci puoi usare GitHub Actions anziché Azure Pipelines. Il modello è lo stesso. CI gestisce la build, aggiorna i manifesti e l'operatore GitOps gestisce la distribuzione. Lo strumento non è importante, il modello sì. Ecco un dettaglio importante. Non archivi mai i segreti direttamente in Git, né chiavi AI, né stringhe di connessione, né certificati. Anche in un repository privato i segreti in Git rappresentano un rischio. Usa invece Azure Key Vault o un operatore di segreti esterni. Il manifesto fa riferimento al segreto in base al nome e l'operatore estrae il valore effettivo dal vault al momento della distribuzione. Puoi anche definire un criterio in cima. Azure Policy con Gatekeeper può applicare regole, come nessun contenitore privilegiato, o usare solo registri di contenitori approvati. Se qualcuno tenta di distribuire un manifesto che viola i criteri, Gatekeeper lo blocca prima che raggiunga il cluster. Vantaggio concreto in questo caso è la scalabilità. Con 50 cluster HHS non devi gestirli tutti singolarmente. Definisci lo stato desiderato in un singolo repository Git e ogni cluster si riconcilia con quello stato. Aggiungi un nuovo cluster, puntalo al repository e si configura da su. Devi aggiornare una configurazione in tutti i cluster? Modifica un file in Git e gli operatori gestiranno il resto. Questa è la promessa di GitOps su Azure. Un'unica fonte di verità, molti cluster, nessuna deviazione. Principale di vantaggio. Quindi tutto questo sembra buono in teoria, ma cosa significa concretamente per il tutorial? Cominciamo con quello che cattura l'attenzione di tutti. I rollback diventano banali. Viene eseguita una distribuzione errata, l'applicazione inizia a generare errori, gli utenti si lamentano. Nel vecchio mondo ti affannavi per trovare l'ultima configurazione valida nota, eseguivi una serie di comandi manuali e pregavi di non esserti perso qualcosa. In GitOps ripristini commit git. Tutto qui. Un comando. L'operatore vede il ripristino, recupera lo stato precedente e il cluster torna a ciò che funzionava prima. La traccia di controllo è integrata automaticamente. Ogni modifica è la tua infrastruttura, è un combi. Sai chi l'ha portata, quando l'ha portata e cosa ha cambiato esattamente. Non dovrai più indovinare se qualcuno ha modificato una distribuzione al 2D note e se dimensionarlo. La cronologia è lì, immutabile e revisionabile. L'autoriparazione è un'altra cosa che sembra magica finché non la vedi funzionare. Qualcuno modifica manomente una distribuzione nel cluster. Magari un ingegnere junior che cerca di risolvere qualcosa da lì. L'operatore rileva la deviazione nel ciclo di riconciliazione successivo e la ripristina. Il cluster si ripara da solo, non ti accorgi nemmeno che è successo a meno che tu non controlli i registri. La coerenza tra gli ambienti diventa automatica. Diviluppo, test, staging, produzione attingono tutti dallo stesso repository git. Rami o cartelle diversi, ma la stessa fonte di verità. Non funziona più sulla mia macchina perché il tuo cluster di staging si è allontanato dalla produzione settimane fa. La sicurezza migliora perché il cluster attinge da git anziché essere sottoposto a push. La pipeline CI non contiene mai credenziali che le consentono di accedere direttamente alla produzione. Se qualcuno compromette la pipeline e non può toccare il cluster, l'operatore decide cosa viene applicato e quando. Privilegio minimo progettazione. Ci sono anche dati a supporto di questo. Secondo la ricerca d'ora, i team che adottano GitOps registrano un calo di circa il 25% di errori di distribuzione e il tempo medio di ripristino scende a meno di ripristino scende a meno implementate. Questa non è teoria, è ciò che segnalano le organizzazioni. E c'è un vantaggio di collaborazione che è facile trascurare. Le modifiche all'infrastruttura passano attraverso richieste di pull, revisioni del codice e test automatizzati esattamente come il codice d'applicazione. Il team operativo e il team di sviluppo parlano la stessa lingua, Git. Niente più passaggi di consegne e niente più distribuisce questo però. Tutti lavorano allo stesso modo. Ma ci sono ancora alcuni malintesi comuni che vale la pena chiarire. Miti comuni e come iniziare. Iniziamo sfatando alcuni miti comuni su GitOps. Innanzitutto, molte persone pensano che GitOps sia solo per Kubernetes. Kubernetes è basato sullo stato dichiarativo e sulla riconciliazione, quindi una scelta naturale. Ma il fatto è che quegli stessi principi si applicano ovunque ci siano configurazioni dichiarative. Puoi usare GitOps con Terraform, Pullumi e persino Ansible. Basta archiviare quelle configurazioni in Git e far sì che una pipeline le applici. La parte di autoriparazione è più difficile al di fuori di Kubernetes, ma la disciplina della fonte della verità funziona ovunque. Un altro mito è che hai assolutamente bisogno di Argo CD o Flux per fare GitOps. Se vuoi un modello completo, la distribuzione è basata su Pull, la riconciliazione continua e il rilevamento delle derive, allora se hai bisogno di un qualche tipo di operatore GitOps. Ma puoi iniziare molto semplicemente inserendo tutti i tuoi manifesti in Git usando le richieste Pull per le modifiche. Questo da solo ti offre la maggior parte dei vantaggi di audit e collaborazione. Puoi sempre aggiungere un operatore in un secondo momento quando ti serve l'automazione. Infine c'è il mito secondo cui GitOps sostituisce completamente CSD. Sostituisce la parte CD. CAI continua a compilare il codice, segue test, esegue scansioni per rilevare vulnerabilità, invia immagini container a un registro. Tutto questo rimane uguale. Ciò che cambia è il modo in cui vengono distribuite tali immagini. Invece di essere la pipeline CI e inviarle nel cluster, l'operatore GitOps estrae i manifesti aggiornati da Git. Quindi c'è e GitOps funzionano insieme, non l'uno al posto dell'altro. Iniziare è davvero semplice. Scegli un piccolo cluster HS e abilita Flux tramite il portale di Azure. Bastano pochi clic. Quindi indirizzalo a un repository Git che contiene un semplice YAML di distribuzione, guardalo sincronizzarsi e sei pronto per iniziare. Prova a modificare un valore nello YAML, esegui il commit e guarda l'aggiornamento del cluster. Questo è il tuo primo flusso di lavoro GitOps. Da lì puoi aggiungere ambienti, imparare a personalizzarli dato che Flux ne fa un uso massiccio e impostare aggiornamenti automatici delle immagini con strumenti come Renovate o Dependabot. Ecco in sintesi GitOps. Trasforma la tua infrastruttura in un repository Git, rendendo tutto tracciabile, ripristinabile e autoriparante. Se gestisci Kubernetes o Azure, prova subito l'integrazione di GitOps in HKS. Ci vogliono 10 minuti per configurarla e cambierai il tuo modo di pensare a distribuzione. Iscriviti per ulteriori spiegazioni in inglese semplice degli strumenti gradi Microsoft.