0Pricing
Cloud & IT Cert Prep · Lezione

Creazione di una pipeline CI con Azure Pipelines

Definisca una pipeline YAML che si attivi sulle pull request, esegua i test unitari e produca un artefatto di compilazione, quindi analizzi i risultati dei test e la copertura del codice nel portale.

Creazione di una pipeline CI con Azure Pipelines è una lezione Cloud & IT Cert Prep gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Cloud & IT Cert Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Che cos'è l'integrazione continua?

La Continuous Integration (CI) è la pratica di unire frequentemente le modifiche al codice in un branch condiviso, attivando automaticamente una compilazione e un'esecuzione dei test a ogni unione. L'obiettivo è rilevare tempestivamente gli errori di integrazione, prima che si trasformino in problemi più estesi e difficili da risolvere. Una buona pipeline CI compila il codice, esegue i test unitari, misura la code coverage, esegue l'analisi statica e produce un artifact distribuibile in pochi minuti. Azure Pipelines fornisce il motore di automazione per questa pratica.

Struttura di una pipeline YAML

Le pipeline CI di Azure Pipelines sono definite in un file azure-pipelines.yml nella radice del repository. Il file YAML specifica i trigger (quando eseguire la pipeline), un pool (quale tipo di agent usare) e una gerarchia di stages, jobs e steps. Per impostazione predefinita, gli stages vengono eseguiti in sequenza. I jobs all'interno di uno stage vengono eseguiti in parallelo per impostazione predefinita. Gli steps all'interno di un job vengono eseguiti in sequenza. Questa struttura offre un controllo dettagliato sul flusso di esecuzione della pipeline.

# azure-pipelines.yml skeleton
trigger:
  branches:
    include:
    - main
    - 'feature/*'
  paths:
    exclude:
    - docs/**
    - '*.md'

pool:
  vmImage: ubuntu-latest

variables:
  buildConfiguration: Release
  nodeVersion: '18.x'

stages:
- stage: CI
  displayName: 'Build and Test'
  jobs:
  - job: Build
    displayName: 'Build Application'
    steps: []

Configurazione dei trigger

Azure Pipelines supporta diversi tipi di trigger. I trigger dei branch eseguono la pipeline quando il codice viene inviato a branch specifici. I trigger delle pull request (trigger PR) vengono attivati quando una PR viene aperta o aggiornata rispetto ai branch di destinazione: sono essenziali per convalidare il codice prima dell'unione. I trigger pianificati vengono eseguiti a un'ora prestabilita (ad esempio, per le build notturne). I trigger delle pipeline concatenano più pipeline. Specifichi trigger: none per disabilitare le esecuzioni automatiche e consentire solo l'esecuzione manuale.

# Branch trigger
trigger:
  branches:
    include: [main, develop]

# Pull request trigger
pr:
  branches:
    include: [main]
  autoCancel: true  # Cancel previous runs when PR is updated

# Scheduled trigger (nightly build at 02:00 UTC)
schedules:
- cron: '0 2 * * *'
  displayName: 'Nightly Build'
  branches:
    include: [main]
  always: true  # Run even if no new commits

Steps: script e task

Gli steps della pipeline sono costituiti da script (comandi bash o PowerShell) oppure da tasks (unità predefinite e parametrizzate disponibili nel marketplace di Azure DevOps). Task come NodeTool@0, DotNetCoreCLI@2 e Maven@3 incapsulano operazioni di build comuni. Utilizzi displayName in ogni step per ottenere log della pipeline leggibili. Ogni step viene eseguito in sequenza e la pipeline ha esito negativo se uno step restituisce un codice diverso da zero, a meno che non imposti continueOnError: true.

steps:
- task: NodeTool@0
  displayName: 'Install Node.js 18'
  inputs:
    versionSpec: '18.x'

- script: npm ci
  displayName: 'Install dependencies (clean install)'

- script: npm run lint
  displayName: 'Run ESLint'

- script: npm run build
  displayName: 'Build production bundle'

- script: npm test -- --ci --coverage
  displayName: 'Run unit tests with coverage'

Pubblicazione dei risultati dei test

Dopo aver eseguito i test, pubblichi i risultati in Azure DevOps utilizzando il task PublishTestResults. Azure Pipelines analizza i file dei risultati in formato JUnit, NUnit, XUnit o VSTest e mostra nell'interfaccia dell'esecuzione della pipeline il numero di test superati e non superati, la durata dell'esecuzione e i dettagli dei singoli test. La cronologia dei test viene monitorata nel tempo, consentendo di individuare test instabili e regressioni. Questo è essenziale per avere visibilità sulla qualità del codice all'interno del team.

# Example: Node.js project with Jest tests
steps:
- script: npm test -- --ci --reporters=jest-junit
  displayName: 'Run tests with JUnit reporter'
  env:
    JEST_JUNIT_OUTPUT_DIR: '$(Agent.TempDirectory)/test-results'

- task: PublishTestResults@2
  displayName: 'Publish test results'
  inputs:
    testResultsFormat: JUnit
    testResultsFiles: '$(Agent.TempDirectory)/test-results/**/*.xml'
  condition: succeededOrFailed()  # Publish even if tests fail

Pubblicazione della code coverage

Pubblichi i report di code coverage affinché Azure Pipelines mostri le percentuali e gli andamenti della coverage nell'interfaccia della pipeline. Il task PublishCodeCoverageResults accetta report nei formati Cobertura o JaCoCo. Lo abbini ai controlli sulla branch coverage: configuri una soglia minima e interrompa la build se la coverage scende al di sotto di tale soglia. Gli andamenti della coverage aiutano a individuare quando viene aggiunto nuovo codice senza test corrispondenti.

# Jest + coverage
- script: npm test -- --ci --coverage --coverageReporters=cobertura
  displayName: 'Run tests with coverage'

- task: PublishCodeCoverageResults@1
  displayName: 'Publish code coverage'
  inputs:
    codeCoverageTool: Cobertura
    summaryFileLocation: '$(System.DefaultWorkingDirectory)/coverage/cobertura-coverage.xml'
    reportDirectory: '$(System.DefaultWorkingDirectory)/coverage'

Variabili e gruppi di variabili della pipeline

Memorizzi la configurazione della pipeline in variables definite a livello di pipeline, stage o job nel file YAML. Per i valori sensibili (chiavi API, password), utilizzi secret variables: le imposti nella libreria della pipeline (interfaccia utente) o nei gruppi di variabili e vi faccia riferimento nel file YAML. I variable groups sono raccolte riutilizzabili di variabili condivise tra più pipeline. Colleghi un gruppo di variabili ad Azure Key Vault per sincronizzare automaticamente i secret da Key Vault alle variabili della pipeline.

# Reference a variable group in a pipeline
variables:
- group: 'Production-Secrets'  # Linked to Azure Key Vault
- name: buildConfiguration
  value: Release

# Use a variable
steps:
- script: echo 'Building $(buildConfiguration) configuration'
- script: az webapp deploy --src-path drop.zip
  env:
    AZURE_SUBSCRIPTION_ID: $(AZURE_SUBSCRIPTION_ID)  # From Key Vault
    APP_API_KEY: $(APP_API_KEY)  # Secret, not printed in logs

Artifacts: creazione del pacchetto dell'output della build

Dopo una build completata correttamente, impacchetti l'output in un pipeline artifact, così che gli stages successivi, ad esempio quello di distribuzione, possano accedervi. Utilizzi PublishPipelineArtifact per caricare i file dall'agent di build nell'archiviazione degli artifact di Azure DevOps. In uno stage o job successivo, utilizzi DownloadPipelineArtifact per recuperare l'artifact. In questo modo il job di build è disaccoppiato dai job di distribuzione, che possono essere eseguiti su agent diversi o in stages differenti.

# Publish build artifact
- task: PublishPipelineArtifact@1
  displayName: 'Publish build artifact'
  inputs:
    targetPath: '$(System.DefaultWorkingDirectory)/dist'
    artifactName: webapp-drop
    publishLocation: pipeline

# In a later deployment job, download the artifact
- task: DownloadPipelineArtifact@2
  inputs:
    artifactName: webapp-drop
    targetPath: '$(Pipeline.Workspace)/drop'

- script: ls -la $(Pipeline.Workspace)/drop

Job paralleli per build più veloci

Esegua le attività indipendenti in parallelo definendo più jobs all'interno di uno stage. Ad esempio, esegua contemporaneamente i test unitari e la scansione di sicurezza invece che in sequenza. I job paralleli richiedono minuti di build separati, ma possono ridurre notevolmente la durata complessiva della pipeline. Utilizzi la proprietà dependsOn per fare in modo che un job attenda il completamento di uno o più job prima di avviarsi, creando un grafo delle dipendenze all'interno dello stage.

stages:
- stage: CI
  jobs:
  - job: UnitTests
    displayName: 'Run unit tests'
    steps:
    - script: npm test

  - job: LintAndSecurity
    displayName: 'Lint and security scan'
    steps:
    - script: npm run lint
    - script: npm audit --audit-level=high

  - job: BuildArtifact
    displayName: 'Build and publish artifact'
    dependsOn: [UnitTests, LintAndSecurity]
    condition: succeeded('UnitTests') and succeeded('LintAndSecurity')
    steps:
    - script: npm run build

Convalida della build con le branch policy

Colleghi la pipeline CI a una branch policy in Azure Repos, affinché venga eseguita automaticamente come build validation check sulle pull request indirizzate a main. L'unione è bloccata finché la pipeline non viene completata correttamente. Combini più controlli: la pipeline CI deve avere esito positivo, almeno 2 revisori devono approvare, tutti i commenti devono essere risolti e deve esistere un work item collegato. In questo modo si crea un quality gate che impedisce di unire codice non funzionante al branch principale.

# Add build validation via CLI
az repos policy build create \
  --blocking true \
  --branch main \
  --branch-match-type exact \
  --build-definition-id <pipeline-id> \
  --display-name 'CI Build Validation' \
  --enabled true \
  --project MyProject \
  --repository-id <repo-id> \
  --queue-on-source-update-only true \
  --manual-queue-only false \
  --valid-duration 720  # Pipeline result expires after 12 hours

Lettura dei risultati dell'esecuzione della pipeline

Al termine dell'esecuzione di una pipeline, esamini i risultati nel portale di Azure DevOps. La scheda Summary mostra l'esito complessivo e i tempi. La scheda Tests elenca tutti i risultati dei test e consente di filtrarli in base all'esito. La scheda Code Coverage mostra la percentuale di coverage ed evidenzia le righe non coperte. Faccia clic su un job per visualizzare l'output del log step by step. Le pipeline non riuscite mostrano lo step che ha causato l'errore evidenziato in rosso, insieme all'output completo dell'errore per una diagnosi rapida.

# View pipeline run results via CLI
az pipelines runs list \
  --pipeline-ids <pipeline-id> \
  --project MyProject \
  --query '[].{id:id, status:status, result:result, startTime:startTime}' \
  -o table

# View logs from a specific run
az pipelines runs logs list \
  --run-id <run-id> \
  --project MyProject

Verifica rapida

Verifichi la Sua comprensione dei concetti di Microsoft Azure Fundamentals (AZ-900) trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che Azure Pipelines YAML definisce pipeline CI con stages, jobs e steps per la build, i test e la creazione degli artifact; i trigger PR e le branch policy applicano quality gate che bloccano l'unione di codice non funzionante; e i task PublishTestResults e PublishCodeCoverageResults rendono visibile la qualità dei test all'interno del team. Prossimamente vedremo la continuous deployment verso Azure.

Domande Frequenti

La lezione «Creazione di una pipeline CI con Azure Pipelines» è gratuita?

Sì — il testo completo di «Creazione di una pipeline CI con Azure Pipelines» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Cloud & IT Cert Prep, passa a CoddyKit PRO. Il corso Cloud & IT Cert Prep include 4 lezioni in totale.

Cosa imparerò in «Creazione di una pipeline CI con Azure Pipelines»?

Definisca una pipeline YAML che si attivi sulle pull request, esegua i test unitari e produca un artefatto di compilazione, quindi analizzi i risultati dei test e la copertura del codice nel portale. Eserciti Cloud & IT Cert Prep con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Cloud & IT Cert Prep?

Non è richiesta alcuna esperienza precedente. Cloud & IT Cert Prep su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Creazione di una pipeline CI con Azure Pipelines»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Cloud & IT Cert Prep?

Sì. Ogni lezione Cloud & IT Cert Prep include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Panoramica di Azure DevOps Services
  2. Creazione di una pipeline CI con Azure Pipelines
  3. Distribuzione continua in Azure
  4. GitHub Actions su Azure
← Torna a Cloud & IT Cert Prep