Modernizzare lo sviluppo di software con l'integrazione continua

Man mano che il codice viene sviluppato, aggiornato o anche rimosso, con un metodo intuitivo e sicuro per integrare queste modifiche nel ramo di codice principale consente agli sviluppatori di fornire valore.

In qualità di sviluppatore, puoi apportare piccole modifiche al codice, eseguirne il push in un repository di codice e ottenere un feedback quasi istantaneo su qualità, copertura dei test e bug introdotti. Questo processo ti consente di lavorare più velocemente, con maggiore sicurezza e meno rischi.

L'integrazione continua (CI) è una pratica in cui i sistemi di controllo del codice sorgente e le pipeline di distribuzione software sono integrati per fornire meccanismi automatizzati di compilazione, test e feedback per i team di sviluppo software.

Il processo di integrazione continua inizia quando un tecnico crea una richiesta pull GitHub per segnalare al sistema CI che le modifiche al codice sono pronte per essere integrate. Idealmente, il processo di integrazione convalida il codice rispetto a diverse baseline e test. Fornisce quindi un feedback al tecnico richiedente sullo stato di questi test.

Se i controlli di base e i test vanno bene, il processo di integrazione produce e prepara gli asset che implementeranno il software aggiornato. Queste risorse includono codice compilato e immagini del contenitore.

Per fornire software di alta qualità più rapidamente con l'integrazione continua:

• Esegui test automatizzati sul codice per fornire il rilevamento tempestivo di modifiche che causano un'interruzione.
• Esegui l'analisi del codice per garantire standard, qualità e configurazione del codice.
• Eseguire controlli di conformità e sicurezza per assicurarsi che il software non abbia vulnerabilità note.
• Esegui test di accettazione o funzionali per garantire che il software funzioni come previsto.
• Fornisci un feedback rapido sui problemi rilevati.
• Ove applicabile, produci risorse o pacchetti distribuibili che includano il codice aggiornato.

Automatizzare l'integrazione continua con le pipeline

Per ottenere l'integrazione continua, usare soluzioni software per gestire, integrare e automatizzare il processo. Una pratica comune consiste nell'usare una pipeline di integrazione continua.

Una pipeline di integrazione continua prevede un componente software (spesso ospitato nel cloud) che fornisce:

• Piattaforma per l'esecuzione di test automatizzati.
• Analisi di conformità.
• Creazione di report.
• Tutti gli altri componenti che costituiscono il processo di integrazione continua.

Nella maggior parte dei casi, il software della pipeline viene collegato al controllo del codice sorgente in modo che quando vengono create richieste pull o che il software venga unito in un ramo specifico, viene eseguita la pipeline di integrazione continua. L'integrazione del controllo del codice sorgente offre inoltre l'opportunità di fornire feedback CI direttamente sulle richieste pull.

Molte soluzioni, come Azure Pipelines o GitHub Actions, forniscono le funzionalità delle pipeline di integrazione continua.

Integrare pipeline con il controllo del codice sorgente

L'integrazione della pipeline di integrazione continua con il sistema di controllo del codice sorgente è fondamentale per consentire contributi di codice rapidi e self-service.

La pipeline CI viene eseguita su una richiesta pull appena creata. La pipeline include tutti i test, le valutazioni della sicurezza e altri controlli. I risultati dei test CI vengono visualizzati direttamente nella richiesta pull per consentire un feedback quasi in tempo reale sulla qualità.

Un'altra pratica diffusa è la creazione di piccoli report o badge che possono essere presentati nel controllo del codice sorgente per rendere visibili gli stati di compilazione correnti.

L'immagine seguente mostra l'integrazione tra GitHub e una pipeline Azure DevOps. In questo esempio la creazione di una richiesta pull attiva una pipeline di Azure DevOps. Lo stato della pipeline viene visualizzato nella richiesta pull.

Incorporare test automatizzati

Un elemento chiave dell'integrazione continua è la creazione e il test continui del codice man mano che gli sviluppatori forniscono contributi di codice. Il test delle richieste di pull appena create offre un feedback rapido che il commit non ha introdotto modifiche che causano problemi. Il vantaggio è che i test nella pipeline di integrazione continua possono essere gli stessi test eseguiti durante lo sviluppo basato sui test.

Il frammento di codice seguente mostra un passaggio di test da una pipeline di Azure DevOps. Il passaggio ha due attività:

• La prima attività usa un framework di test Python diffuso per eseguire test CI. Questi test si trovano nel controllo del codice sorgente insieme al codice Python. I risultati del test passano a un file denominato test-results.xml.
• La seconda attività usa i risultati del test e li pubblica nella pipeline di Azure DevOps come report integrato.

- script: |
    pip3 install pytest
    pytest azure-vote/azure-vote/tests/ --junitxml=junit/test-results.xml
    continueOnError: true

- task: PublishTestResults@2
    displayName: 'Publish Test Results'
    inputs:
    testResultsFormat: 'JUnit'
    testResultsFiles: '**/test-results.xml'
    failTaskOnFailedTests: true
    testRunTitle: 'Python $(python.version)'

L'immagine seguente mostra i risultati dei test visualizzati nel portale di Azure DevOps.

Test non superati

I test non riusciti devono bloccare temporaneamente una distribuzione e portare a un'analisi più approfondita di ciò che è accaduto. I test non riusciti devono anche portare a un perfezionamento dei test o a un miglioramento del cambiamento che ha causato il fallimento dei test.

Pubblica lo stato della compilazione

Molti sviluppatori mostrano che la qualità del codice è elevata visualizzando una notifica di stato nel repository. L'immagine seguente mostra un badge di Azure Pipelines visualizzato nel file readme per un progetto open source su GitHub.

Ottimizzare i tempi di compilazione

Per eseguire compilazioni più veloci, è possibile:

• Scegliere gli agenti che soddisfano i requisiti di prestazioni: velocizzare le compilazioni selezionando i computer di compilazione corretti. Le macchine veloci possono fare la differenza tra ore e minuti. Se le pipeline si trovano in Azure Pipelines, è possibile eseguire i processi usando un agente ospitato da Microsoft. Quando si usano agenti ospitati da Microsoft, la manutenzione e gli aggiornamenti vengono presi in considerazione automaticamente. Per altre informazioni, vedere Agenti ospitati da Microsoft.

• Ottimizzare il percorso del server di compilazione: quando si compila il codice, i dati vengono inviati attraverso la rete. Gli input per le compilazioni vengono recuperati da un repository di controllo del codice sorgente e dal repository degli artefatti. L'output del processo di compilazione deve essere copiato, inclusi gli artefatti compilati, i report di test, i risultati della copertura del codice e i simboli di debug. È importante che queste azioni di copia vengano eseguite rapidamente. Se usi il tuo server di build, assicurati che il server sia situato nelle vicinanze delle sorgenti e di una destinazione. Caricamenti rapidi e download possono ridurre il tempo di compilazione complessivo.

• Server di compilazione con scalabilità orizzontale: un singolo server di compilazione potrebbe essere sufficiente per un piccolo prodotto. Man mano che le dimensioni e l'ambito del prodotto e il numero di team che lavorano sul prodotto aumenta, un singolo server potrebbe non essere sufficiente. Ridimensionare l'infrastruttura orizzontalmente su più computer quando si raggiunge il limite. Per altre informazioni, vedere Creare e gestire pool di agenti.

• Ottimizzare la compilazione:

  • Aggiungere processi paralleli per velocizzare il processo di compilazione. Per ulteriori informazioni, vedere Configura e paga per i processi paralleli.

  • Abilitare le esecuzioni parallele del gruppo di test, che spesso consentono di risparmiare molto tempo, soprattutto quando si eseguono test di integrazione e interfaccia utente. Per ulteriori informazioni, consultare Eseguire test in parallelo con qualsiasi esecutore di test.

  • Utilizzare il concetto di moltiplicatore, dove è possibile distribuire le compilazioni su più agenti di build. Per ulteriori informazioni, consultare Specificare i lavori nella pipeline.

  • Considerare lo spostamento dei test di integrazione, interfaccia utente e test di fumo in una pipeline di rilascio. Il passaggio a una pipeline di versione migliora la velocità di compilazione e la velocità del ciclo di feedback della compilazione.

  • Pubblicare gli artefatti di compilazione in una soluzione di gestione dei pacchetti, ad esempio NuGet o Maven. La pubblicazione in una soluzione di gestione dei pacchetti consente di riutilizzare più facilmente l'artefatto di compilazione.

Implementare i tipi di build per adattarli ai flussi di lavoro

L'organizzazione potrebbe scegliere di creare diversi tipi di compilazioni per ottimizzare i tempi di compilazione. Le compilazioni possibili includono:

• Compilazione integrazione continua (CI): lo scopo di questa compilazione è garantire che il codice sia compilato e che vengano eseguiti unit test. Questa compilazione viene attivata a ogni commit. Funge da heartbeat del progetto e fornisce feedback di qualità al team im_imagestely. Per altre informazioni, vedere Specificare gli eventi che attivano le pipeline.

• Compilazione notturna: lo scopo di una compilazione notturna non è solo compilare il codice, ma anche per garantire che tutti i gruppi di test più grandi che siano inefficienti vengano eseguiti a cadenza regolare per ogni compilazione. In genere, questi test includono integrazione, interfaccia utente o smoke test. Per altre informazioni, vedere Configurare le pianificazioni per le pipeline.

• Build di rilascio: oltre alla compilazione e all'esecuzione dei test, questa compilazione include anche la documentazione dell'API, i report di conformità, la firma del codice e altri passaggi che non sono necessari ogni volta che viene compilato il codice. Questa compilazione fornisce la copia definitiva che viene trasferita alla pipeline di rilascio per essere infine distribuita nell'ambiente di produzione.

I tipi di compilazioni necessari per la vostra organizzazione dipendono da fattori che includono la maturità del team e dell'organizzazione, il tipo di prodotto su cui si sta lavorando e la strategia di implementazione.

Collegamenti correlati

Informazioni su come creare una pipeline di integrazione continua usando GitHub o Azure DevOps:

• Crea la tua prima pipeline
• Usare i flussi di lavoro di avvio

Impara a visualizzare i badge nei tuoi repository:

• Aggiungere un badge di stato di Azure Pipelines al repository
• Aggiungere un badge di stato del workflow GitHub al tuo repository