Tutorial su Azure Pipelines: una guida CI/CD completa per principianti

Se la tua pipeline CI/CD continua a rompersi o sembra lenta e macchinosa, non sei solo. Mi sono scontrato con build fallite, ambienti non allineati e colleghi che sovrascrivevano per sbaglio il mio lavoro. Azure Pipelines elimina queste frustrazioni con un servizio cloud-hosted che può creare, testare e distribuire quasi qualsiasi progetto su qualsiasi piattaforma.

Ecco perché in questo tutorial ti mostrerò come:

1. Creare la tua prima Azure Pipeline
2. Effettuare la build del tuo progetto nel cloud
3. Aggiungere test automatici per intercettare gli errori in anticipo
4. Distribuire in staging o produzione con un solo push
5. Monitorare e ottimizzare la pipeline per velocità e affidabilità
6. Seguire le best practice collaudate su progetti reali

Iniziamo!

Che cos’è Azure Pipelines?

Azure Pipelines è una soluzione cloud che semplifica lo sviluppo, il test e la distribuzione delle applicazioni. 

È un componente della toolkit di Azure DevOps, che supporta l’intero ciclo di vita dello sviluppo software. È anche un’opzione flessibile per team di tutte le dimensioni perché supporta varie piattaforme e linguaggi di programmazione. Si integra con GitHub, Azure Repos e altri noti sistemi di controllo versione. 

Le funzionalità principali di Azure Pipelines includono: 

Per la mia esperienza, Azure Pipelines è utile per chiunque voglia avere una propria CI/CD all’interno del team. È flessibile, scalabile e si integra bene con altri servizi Azure.

Architettura di Azure Pipelines (Fonte: Microsoft).

Se cerchi una visione più ampia di Azure DevOps oltre le pipeline, questo tutorial su Azure DevOps illustra l’intero ciclo di vita CI/CD dall’inizio alla fine.

Configurare la tua prima Azure Pipeline

Per lavorare con l’ambiente Azure Pipelines, dobbiamo prima configurare tutto per favorire un processo end-to-end di build, test e distribuzione.

Prerequisiti

Prima di creare la tua prima pipeline, assicurati di avere quanto segue:

1. Account Azure DevOps e organizzazione configurati: Iscriviti a un account Azure DevOps se non ne hai già uno. Crea un’organizzazione per gestire i tuoi progetti. 
2. Repository: Ti serve un repository di codice con un progetto di esempio. Può essere ospitato su Azure Repos o GitHub. Per questo tutorial useremo un semplice progetto Node.js.
3. Accesso al portale Azure: Ti servirà anche l’accesso al portale di Azure quando vorrai distribuire su servizi Azure come Azure Kubernetes Service (AKS) e molti altri.

Se vuoi ripassare l’ecosistema Azure nel suo complesso, ti consiglio di dare un’occhiata al corso Understanding Microsoft Azure. 

Creare un nuovo progetto e repository

Ora che il tuo account Azure DevOps e l’organizzazione sono pronti, creiamo il nostro primo progetto e repository.

• Crea un nuovo progetto:
  • Accedi al tuo account Azure DevOps.
  • Clicca su New Project, assegnagli un nome (ad es. "AzureDevOps-DataCamp-Tutorial"), e scegli la visibilità (pubblica o privata).
  • Clicca su Create Project.

• Configura un repository:
  • Se usi Azure Repos, vai alla sezione Repos e inizializza un nuovo repository.
  • In alternativa, puoi collegare un repository GitHub esistente selezionando Import Repository.
  • Assegna un nome al repository, scegli il Repository type (Git o TFVC), incolla l’URL del repository clonato e clicca su Import.

• Se usi GitHub, puoi collegare il tuo account GitHub ad Azure DevOps andando in basso a sinistra nell’interfaccia del progetto e selezionando Project Settings > GitHub Connections > Connect your GitHub account.

Per questo tutorial, useremo Azure Repos come repository del codice. Se stai iniziando o non hai un motivo specifico per scegliere TFVC, ti consiglio di optare per Git.

Creare la tua prima pipeline

È il momento di creare la nostra prima pipeline. Segui i passaggi seguenti:

• Nella sezione Pipelines, clicca su Create Pipeline.

• Seleziona Azure Repos Git come sorgente e scegli il tuo repository.

• Puoi configurare la pipeline usando l’editor YAML o Classic. Scegliamo YAML, un modo basato su codice per definire la pipeline.
• Salva la pipeline ed eseguila per verificare che tutto funzioni correttamente.

Scegliere YAML vs Classic Editor

Azure Pipelines offre due modi per definire le pipeline:

• Pipeline YAML: Un modo basato su codice per descrivere la tua pipeline. Sono definite in un file .yaml o .yml nel tuo repository sorgente, abilitando versionamento e migliore collaborazione.
• Classic Editor: Classic Editor è un’interfaccia visiva drag-and-drop facile da usare, ma meno flessibile negli scenari complessi.

Per la mia esperienza, le pipeline YAML offrono maggiore flessibilità e sono migliori per i team che seguono pratiche di Infrastructure as Code (IaC). Ma il Classic Editor è perfetto per i neofiti che preferiscono un approccio più visivo. 

Tuttavia, per la scalabilità a lungo termine, le pipeline YAML sono raccomandate rispetto al Classic Editor.

Build con Azure Pipelines

Ora vediamo come effettuare la build con Azure Pipelines. 

In questa sezione specificheremo i passaggi che Azure Pipelines esegue per creare il tuo codice, come installare le dipendenze, compilare ed eseguire i test. Esprimeremo questi passaggi in un file di configurazione nel nostro repository del codice sorgente usando YAML, un modo semplice e leggibile per descrivere passaggi in una “ricetta”.

Sintassi delle pipeline YAML

Ecco un semplice esempio di pipeline YAML:

# This section defines the trigger(s) for the pipeline.
# 'main' specifies that the pipeline will run whenever changes are pushed to the 'main' branch.
trigger:
- main  # automatically triggers this pipeline when changes are made to the 'main' branch.

# This defines the pool where the pipeline will run.
# 'ubuntu-latest' specifies the virtual machine image for executing tasks.
pool:
  vmImage: 'ubuntu-latest'  # This uses the latest Ubuntu image provided by Azure DevOps.

# Steps contain the individual tasks or actions that the pipeline will execute.
steps:
- script: echo Hello, world!  # A script task to run shell commands. This one prints "Hello, world!".
  displayName: 'Run my first pipeline script'  # A friendly name for this step, making it easier to identify in the pipeline logs.

Analizziamo il codice passo per passo:

• trigger: specifica il branch che attiva la pipeline (ad es., main).
• pool: definisce l’agente di build (ad es., ubuntu-latest).
• steps: elenca le attività da eseguire, come l’installazione delle dipendenze e l’esecuzione di uno script di build.

Configurare i passaggi di build

Per aggiungere passaggi di build alla tua pipeline YAML, devi definire lo ‘script’ nella sezione ‘steps’.

Per una semplice applicazione Node.js, ad esempio, il nostro file azure-pipelines.yml qui sotto contiene codice creato automaticamente da Azure DevOps.

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

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

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

Vediamo i steps di build nella pipeline YAML sopra: 

1. Installa Node.js: usa il task NodeTool@0 per specificare la versione di Node.js. 
2. Installa le dipendenze: esegui npm install per installare le dipendenze del progetto. 
3. Compila il codice (build del progetto): esegui npm run build per compilare il codice. 

Esecuzione della pipeline

La nostra pipeline può essere attivata manualmente o impostata per l’esecuzione automatica quando si verificano eventi come i push sul branch.

• Trigger manuale: clicca su Run Pipeline nell’interfaccia di Azure DevOps per avviare manualmente la pipeline.

• Trigger automatico: imposta i trigger basati sugli eventi del repository in modo che i push sul branch main attivino automaticamente la pipeline. Ecco un esempio:

trigger:
- main

Dopo aver eseguito la pipeline, puoi visualizzare i log e risolvere eventuali problemi.

Per accedere ai log, vai al riepilogo dell’esecuzione della pipeline e seleziona il job o il task specifico. Verranno mostrati i log per quel passaggio; come nell’immagine seguente, puoi scegliere qualsiasi job (Build, Push o Update) per visualizzare i log grezzi.

Per risolvere i problemi comuni, puoi verificare la pipeline per problemi frequenti come timeout, vincoli di risorse o errori di configurazione.

Aggiungere test alla tua pipeline

Aggiungi i test alla pipeline per garantire la qualità del codice e intercettare i problemi nelle prime fasi di sviluppo. In Azure Pipelines puoi integrare unit test, test di integrazione o altri test aggiungendo passaggi nella configurazione della pipeline.

Configurare i passaggi di test

Includi passaggi di test nella pipeline per garantire la qualità del codice. Puoi usare framework popolari come Jest, Mocha o NUnit. Ad esempio, ecco come aggiungere unit test con Jest:

- script: |
    npm test
  displayName: 'Run unit tests with Jest'

Visualizzare i risultati dei test

Azure Pipelines include reportistica test integrata. Puoi configurare la pubblicazione dei risultati dei test per un tracciamento più semplice e visualizzare i risultati nei log della pipeline. Ecco come fare:

• Innanzitutto, vai su Builds > Test Results.
• Per pubblicare i risultati dei test, usa il task PublishTestResults@2 per mostrarli. Questo rende più semplice il tracciamento complessivo. Ad esempio:

- task: PublishTestResults@2
  inputs:
    testResultsFiles: '**/test-results.xml'
    testRunTitle: 'Unit Tests'

Distribuire con Azure Pipelines

Nei passaggi di deployment del tuo file YAML di Azure Pipeline, puoi distribuire automaticamente la tua applicazione in diversi ambienti, come test, staging e produzione. In questa sezione esamineremo alcuni modi per distribuire con Azure Pipelines.

Distribuire su Azure Web Apps

Azure Web Apps è un servizio nel portale Azure che consente di sviluppare, distribuire e gestire applicazioni web su larga scala. 

Per distribuire su Azure Web Apps, devi collegare i due servizi. Ecco come fare:

• In basso a sinistra del tuo progetto, vai su Project Settings e clicca su Service Connections nella sezione Pipelines. 

• Clicca su New Service Connection e scegli Azure Resource Manager. 

• Autenticati con il tuo account Azure.
• Distribuisci su Azure App Service:
  • Torna alle tue Pipelines e configura la pipeline.
  • Nella pipeline, aggiungi un task per distribuire su Azure.
  • Specifica il resource group e i dettagli del servizio. 

Ecco un esempio di pipeline YAML di deployment per una semplice app Node.js su Azure App Service:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1
  inputs:
    # This specifies your Azure subscription service connection
    azureSubscription: 'your-azure-subscription'
    # This specifies the name of your web app
    appName: 'your-app-name'
    # This specifies the location of the app package or files to be deployed
    package: '$(Build.ArtifactStagingDirectory)'

Analizziamo il codice sopra, così potrai adattarlo al tuo caso d’uso:

• Sostituisci your-azure-subscription con il nome della service connection che fornisce l’accesso alla tua sottoscrizione Azure.
• Sostituisci your-app-name con il nome effettivo della tua web app in Azure. 
• Sostituisci $(Build.ArtifactStagingDirectory) con la directory in cui inserire il pacchetto o i file della web app per la distribuzione. $(Build.ArtifactStagingDirectory) — Questa variabile punta alla cartella in cui si trovano gli artifact di build (i file della tua app) dopo la compilazione.

Impostare la distribuzione continua (CD)

Una volta che tutto il nostro codice supera test e verifiche, il passo successivo è impostare la distribuzione continua. Segui i passaggi descritti di seguito.

Modello di distribuzione della release pipeline di Azure (Fonte: Microsoft)

• Crea una release pipeline:
• Vai su Pipelines > Releases e clicca su New Pipeline.

• Seleziona il template Azure App Service Deployment.

• Configura gli ambienti:
• Aggiungi e configura gli ambienti Dev, Staging, QA e Production in cui vuoi distribuire la tua applicazione.

• Collega l’artifact dalla tua build pipeline come sorgente per la release pipeline selezionando Add an artifact.

• Configura approvazioni e gate:
• È necessario impostare approvazioni pre-distribuzione per gli ambienti sensibili, come la produzione. Ad esempio, potrebbe essere richiesta l’approvazione di un team lead. Puoi anche aggiungere gate come test automatici o controlli di monitoraggio per assicurarti che la distribuzione soddisfi gli standard di qualità.

Per la mia esperienza, questa fase è necessaria per mantenere la stabilità in ambienti di sviluppo impegnativi. Approvazioni e gate forniscono controllo e garantiscono che solo codice di alta qualità arrivi in produzione.

Distribuire su Kubernetes

Kubernetes semplifica l’esecuzione di applicazioni containerizzate affidabili e scalabili. Usando Azure Kubernetes Service (AKS), ottieni un ambiente gestito che semplifica distribuzione e operazioni. In questa sezione ti mostrerò come distribuire la tua applicazione su AKS usando Azure Pipelines.

Prepara il tuo cluster AKS

Puoi creare un cluster AKS usando il portale Azure o la CLI. Ecco un semplice comando Bash CLI per effettuare il provisioning del cluster:

az aks create \
  --resource-group <ResourceGroupName> \
  --name <AKSClusterName> \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

Analizziamo il comando sopra:

• --resource-group: indica il resource group di Azure in cui verrà creato il cluster AKS.
• --name: si riferisce al nome del tuo cluster AKS.
• --node-count: imposta il numero di nodi nel cluster (ad es., 3 in questo esempio).
• --enable-addons monitoring: abilita monitoraggio e analisi con Azure Monitor for Containers.
• --generate-ssh-keys: genera automaticamente le chiavi SSH per un accesso sicuro ai nodi, se non fornite.

Non dimenticare di sostituire <ResourceGroupName> e <AKSClusterName> con i nomi effettivi del tuo resource group e cluster.

Dopo aver configurato il cluster AKS, è necessario configurare kubectl. Questo assicura che l’agente della pipeline o il tuo computer locale possano usare kubectl per comunicare con il cluster.

Puoi velocizzare le attività su Azure usando strumenti da riga di comando—questo cheat sheet di Azure CLI è un pratico riferimento.

Crea un file YAML di deployment 

Prendiamo un file YAML di deployment di base per distribuire un’immagine Docker su Kubernetes come esempio:

# This defines the API version and the kind of Kubernetes resource we are creating.
# 'apps/v1' is the API version, and 'Deployment' is the resource type.
apiVersion: apps/v1
kind: Deployment

# Metadata contains information to identify the resource uniquely.
# 'name' specifies the name of the Deployment.
metadata:
  name: my-app  # Name of the Deployment, used for identification.

# "spec" specifies the intended deployment state.
spec:
  # Number of replicas/pods we want for this Deployment.
  replicas: 3  # Ensures high availability by running three app replicas.

  # Selector is used to define the labels that this Deployment will manage.
  selector:
    matchLabels:
      app: my-app  # This ensures that only Pods with the label 'app: my-app' are managed by this Deployment.

  # Template specifies the blueprint for the pods created by the Deployment.
  template:
    metadata:
      labels:
        app: my-app  # Labels for the Pods, matching the selector above.

    # A specification for the containers of the Pods.
    spec:
      containers:
      - name: my-app  # Name of the container. This is useful for linking to the container in logs, etc.
        image: mycontainerregistry.azurecr.io/my-app:latest  # Pull the container image you will call from your container registry.
        ports:
        - containerPort: 80  # The container listens on port 80.

Distribuire usando Azure Pipelines

Nella tua pipeline YAML, includi un task per distribuire su AKS.

# This defines a task for deploying Kubernetes manifests within an Azure DevOps pipeline.
- task: KubernetesManifest@0  # Task type for working with Kubernetes manifest files.
  inputs:
    # This configures what to do with the Kubernetes manifest files.
    action: 'deploy'  # 'deploy' action ensures the Kubernetes manifests are applied to the cluster.

    # This defines the namespace where the Kubernetes resources will be deployed.
    namespace: 'default'  # 'default' is the namespace for deploying resources. Change if needed.

    # All this does is point to the manifest files that define the desired state of your Kubernetes resources.
    manifests: '$(Build.ArtifactStagingDirectory)/manifests/*.yaml'
    # The 'manifests' variable points to the location of all the YAML files (e.g., Deployment, Service, etc.) that will be applied during the deployment.

    # To access private container registry images, use the image pull secret.
    imagePullSecrets: 'my-registry-secret'
    # This instructs Kubernetes on which secret to use when pulling images from a private container registry.
    # Ensure that 'my-registry-secret' exists in the namespace before the deploy

Fai commit e push del file YAML per attivare il deployment.

AKS semplifica l’orchestrazione dei container, facilitando la gestione di scaling, aggiornamenti e rollback. Per la mia esperienza, è imprescindibile per le moderne applicazioni cloud-native.