Ciao, e benvenuto nella terza puntata della quindicesima stagione. Nella scorsa puntata abbiamo capito le due metà dell'automazione: verificare il codice e consegnarlo. Ma con quale strumento concreto si realizza tutto questo? Come si costruisce, praticamente, questa macchina automatica che prende il codice e lo porta fino agli utenti? Oggi conosciamo il protagonista pratico di tutta la stagione, il meccanismo che esegue l'automazione: la pipeline. E scopriamo che ha molto in comune con qualcosa che conosciamo tutti: una catena di montaggio.
Partiamo dall'immagine della catena di montaggio, perché spiega la pipeline meglio di ogni definizione. Pensa a una fabbrica di automobili. C'è un nastro trasportatore lungo il quale l'automobile prende forma, passando attraverso una serie di stazioni successive. Alla prima stazione si monta il telaio, alla seconda il motore, alla terza le portiere, poi la verniciatura, poi i controlli, e così via. Ogni stazione fa una cosa sola e ben precisa, e poi passa il lavoro alla stazione successiva. L'automobile avanza lungo la linea, stazione dopo stazione, e alla fine esce completa e pronta. È un flusso ordinato, automatico, ripetibile.
La pipeline è esattamente questo, ma per il tuo codice. È una sequenza automatica di stazioni, o fasi, attraverso cui il tuo codice passa nel suo viaggio verso la produzione. Il codice entra da un capo, grezzo e appena scritto, e avanza lungo la linea attraverso una serie di fasi successive, ciascuna che compie un'operazione precisa su di esso. Alla fine della linea, se tutto è andato bene, il codice esce dall'altro capo, verificato, impacchettato e pronto per gli utenti, o già consegnato. La pipeline è la catena di montaggio automatica che trasforma il codice appena scritto in software funzionante in produzione.
Vediamo quali sono, tipicamente, queste fasi, perché conoscerle dà la struttura di tutta la stagione. Le fasi variano da progetto a progetto, ma seguono più o meno sempre lo stesso schema logico. Una prima fase costruisce il codice, trasformandolo da testo sorgente in qualcosa di eseguibile e impacchettato. Una seconda fase lo mette alla prova con dei controlli automatici, per verificare che funzioni e non abbia rotto nulla. Una terza fase lo porta in un ambiente di prova, per vederlo funzionare in condizioni realistiche. E una fase finale lo rilascia in produzione, fino agli utenti. Costruire, verificare, provare, rilasciare: le stazioni tipiche della catena di montaggio del software, che approfondiremo una a una nelle prossime puntate.
C'è un elemento cruciale che devo spiegarti, perché è ciò che dà vita alla pipeline: cosa la mette in moto. La pipeline non parte a caso: parte in risposta a un evento, tipicamente un tuo salvataggio del codice in Git. Ricordi la stagione su Git: ogni volta che fai un commit e lo mandi al deposito comune, quel gesto può far scattare automaticamente la pipeline. È come se il tuo salvataggio suonasse un campanello che dice alla catena di montaggio comincia. Da quel momento, senza che tu debba fare altro, la pipeline si avvia e comincia a lavorare sul tuo codice, facendolo scorrere lungo le sue fasi. Il tuo semplice atto di salvare il codice innesca l'intero viaggio automatico.
C'è poi una regola d'oro che governa come scorre il lavoro lungo la pipeline, ed è importantissima: se una fase fallisce, la linea si ferma. Se, in una qualsiasi stazione, qualcosa va storto, se la costruzione non riesce, o un controllo non passa, la pipeline si arresta immediatamente e non prosegue oltre. Il codice difettoso non avanza verso le fasi successive, e soprattutto non arriva in produzione. È come una catena di montaggio che si blocca se un pezzo è difettoso, impedendogli di proseguire e diventare un prodotto finito guasto. Questa regola, fermarsi al primo problema, è ciò che protegge la produzione: solo il codice che supera tutte le fasi arriva fino in fondo.
Voglio farti apprezzare perché fermarsi al primo problema è una cosa così preziosa, perché è il cuore della sicurezza della pipeline. Significa che un difetto viene intercettato il prima possibile, nella fase in cui si manifesta, e bloccato lì, prima che possa fare danni agli utenti. Invece di scoprire il problema in produzione, quando è già troppo tardi e gli utenti ne soffrono, lo scopri subito, nella pipeline, dove correggerlo è facile e indolore. La pipeline agisce come una serie di filtri successivi: ogni fase è un controllo che il codice deve superare per proseguire, e i difetti vengono catturati sempre più presto, prima che raggiungano il mondo reale. È una barriera protettiva a più strati.
Per oggi ci fermiamo qui. La pipeline è la catena di montaggio automatica del software: una sequenza di fasi successive attraverso cui il codice passa nel viaggio verso la produzione, come un'automobile lungo il nastro di una fabbrica. Le fasi tipiche sono costruire, verificare, provare e rilasciare, ognuna con un compito preciso. La pipeline si avvia in risposta a un evento, tipicamente un tuo salvataggio in Git, e segue una regola d'oro: se una fase fallisce, la linea si ferma, impedendo al codice difettoso di avanzare fino agli utenti. Così i difetti vengono catturati presto, prima che facciano danni. Nella prossima puntata approfondiamo la prima metà, l'integrazione continua. Nelle note trovi qualche spunto. Se ti è utile, condividila. Grazie per l'ascolto, e ci sentiamo alla prossima.