Ciao, e benvenuto nella prima puntata della quindicesima stagione di questo podcast. Nelle ultime stagioni abbiamo esplorato tre strumenti fondamentali dello sviluppo moderno: Git, per versionare il codice; Docker, per impacchettarlo in container; e Kubernetes, per farlo girare su tante macchine. Oggi cominciamo la stagione che, in un certo senso, li lega tutti insieme, il cerchio che si chiude: come si automatizza il viaggio del codice, dal momento in cui lo scrivi fino al momento in cui gira davvero, nelle mani degli utenti. È la stagione su ciò che chiamiamo integrazione e distribuzione continua, e sulle pipeline. Oggi, come sempre, partiamo dal problema.
Partiamo da una verità che chi programma scopre presto, spesso con sorpresa: scrivere il codice è solo metà del lavoro. L'altra metà, spesso sottovalutata, è portare quel codice fino agli utenti, farlo arrivare dal tuo computer al luogo dove gira per il mondo, in modo che le persone possano finalmente usarlo. E questa seconda metà, storicamente, è stata sorprendentemente difficile, lenta e piena di insidie. Un conto è far funzionare il codice sul tuo computer; un altro, molto diverso, è consegnarlo al mondo in modo affidabile. Il divario tra queste due cose è enorme, ed è il tema di questa stagione.
Facciamo un salto indietro, a come si faceva prima che tutto questo fosse automatizzato, perché il contrasto rende vivido il problema. Immagina il momento del rilascio, quando una nuova versione del programma doveva andare in produzione. Era un evento raro, temuto, quasi cerimoniale. Qualcuno, spesso di notte per disturbare meno gli utenti, prendeva il nuovo codice e lo installava a mano sui server, seguendo una lunga lista di passi delicati, digitati uno per uno, sperando di non dimenticarne nessuno e di non commettere errori. Era un rito ansioso, in cui un solo passo sbagliato poteva mandare tutto in tilt. Il giorno del rilascio era il giorno della paura.
Fermiamoci a capire perché questo modo di fare fosse così problematico, perché racchiude tutti i mali che l'automazione verrà a curare. Primo: era lento e faticoso, un lavoro manuale che rubava tempo prezioso. Secondo: era soggetto a errori umani, perché fare a mano tanti passi delicati, magari stanchi e di notte, è una ricetta perfetta per gli sbagli. Terzo: siccome era doloroso, si tendeva a farlo di rado, accumulando tantissime modifiche in ogni rilascio, il che rendeva ogni rilascio ancora più grande, rischioso e difficile da districare quando qualcosa andava storto. Era un circolo vizioso: doloroso, quindi raro, quindi enorme, quindi ancora più doloroso.
Voglio soffermarmi su quest'ultimo punto, perché è più profondo di quanto sembri e prepara tutta la stagione. Quando rilasciare è doloroso, si finisce per rilasciare grandi quantità di modifiche tutte insieme, di rado. E questo è pericoloso: se in un rilascio enorme, con cento cambiamenti, qualcosa si rompe, come fai a capire quale dei cento cambiamenti è il colpevole? È come cercare un ago in un pagliaio. Al contrario, se rilasciassi piccole modifiche, una alla volta, spesso, e qualcosa si rompesse, sapresti subito qual è la causa: l'unica piccola cosa che hai appena cambiato. Ma rilasciare spesso e in piccolo è possibile solo se rilasciare è facile e automatico. Ed è proprio qui che entra in gioco la nostra stagione.
Perché la soluzione a tutti questi mali è una sola idea, semplice e potente, che ti anticipo: automatizzare l'intero viaggio del codice, dalla scrittura alla produzione. Invece di far compiere a mano, con fatica e ansia, tutti i passi necessari per verificare, impacchettare e rilasciare il codice, costruiamo una macchina automatica che li esegue al posto nostro, sempre allo stesso modo, senza stancarsi e senza sbagliare. Ogni volta che scriviamo del codice nuovo, questa macchina lo prende, lo controlla, lo prepara e lo porta fino agli utenti, tutto da sola, in modo affidabile e ripetibile. Questa macchina automatica, e la filosofia che le sta dietro, sono il cuore di questa stagione.
Voglio darti fin da subito il legame con le stagioni precedenti, perché questa stagione è la loro sintesi. Ricorda cosa abbiamo imparato: con Git salvi e condividi il codice, con Docker lo impacchetti in un'immagine, con Kubernetes lo fai girare su un cluster. Ebbene, la macchina automatica di cui parliamo unisce tutti questi pezzi in un unico flusso: parte da un tuo salvataggio in Git, costruisce un'immagine con Docker, e la distribuisce nel cluster con Kubernetes, senza che tu debba fare nulla a mano. È il filo che cuce insieme tutti gli strumenti che abbiamo studiato, trasformandoli da pezzi separati in un'unica linea di produzione automatica e fluida. Per questo è la stagione che chiude il cerchio.
Per oggi ci fermiamo qui. Scrivere il codice è solo metà del lavoro; l'altra metà è portarlo fino agli utenti, e storicamente questo era lento, manuale e pieno di insidie, con il rilascio vissuto come un rito ansioso e raro. Ma rilasciare di rado e in grande è pericoloso, perché rende difficile capire cosa si è rotto; rilasciare spesso e in piccolo sarebbe meglio, ma è possibile solo se rilasciare è facile e automatico. La soluzione è automatizzare l'intero viaggio del codice, dalla scrittura alla produzione, unendo in un unico flusso Git, Docker e Kubernetes. Nella prossima puntata capiamo cosa significano davvero le sigle di questa stagione. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.