Azure DevOps Tutorial: Build, Test, and Deploy Applications

Configurare il tuo ambiente Azure DevOps

Per accedere all'ambiente Azure DevOps, devi prima configurare tutto per favorire la collaborazione del team e il processo di sviluppo end-to-end.

Creare un account Azure DevOps

Prima di usare Azure DevOps, devi creare un account. Ecco come iniziare:

• Visita il sito web di Azure DevOps: Vai su Azure DevOps per iniziare la procedura di registrazione. Clicca Get Started with Azure.

• Accedi con il tuo account Microsoft: Se hai già un account Microsoft (ad esempio, Outlook, Xbox, Office 365), puoi usarlo per accedere. Altrimenti, dovrai creare un account Microsoft gratuito.
• Clicca Sign in o Create one! (Sign up).
• Usa le tue credenziali Microsoft o altre opzioni di accesso per effettuare il login.
• Clicca Next.

• Avvia la procedura di configurazione: Clicca sulla casella di spunta e su Continue. Dopo l’accesso, ti verrà chiesto di creare una nuova organizzazione. I tuoi team e progetti Azure DevOps saranno ospitati all’interno di questa organizzazione. 

Creare un'organizzazione in Azure DevOps

Un'organizzazione in Azure DevOps è il luogo in cui vivono tutti i tuoi progetti e repository. Qui gestisci anche team, autorizzazioni e fatturazione.

• Dai un nome alla tua organizzazione: Scegli un nome univoco per la tua organizzazione. È importante perché apparirà come parte dell’URL di Azure DevOps (ad es., https://dev.azure.com/yourorganization ).
• Scegli la tua area geografica: Azure DevOps richiede la selezione di un'area in cui i tuoi dati saranno archiviati. L'area predefinita dovrebbe andare bene per la maggior parte, ma se hai esigenze specifiche, come conformità, puoi scegliere un'altra area più vicina alla tua base utenti (ad es., Stati Uniti).
• Conferma e continua: Dopo aver inserito questi dettagli, clicca Continue. La tua organizzazione è pronta e verrai indirizzato al portale principale di Azure DevOps!

Esplorare l'interfaccia di Azure DevOps

Dopo aver creato la tua organizzazione, verrai portato al portale Azure DevOps. Le sezioni principali dei servizi sono Overview, Boards, Repos, Pipelines, Test Plans e Artifacts.

Questa interfaccia utente può sembrare opprimente all’inizio, ma le funzioni core di Azure DevOps si possono ridurre a controllo versione, CI/CD e project management.

Creare un nuovo progetto

Ora che il tuo account e l'organizzazione sono configurati, creiamo il tuo primo progetto per Azure DevOps.

Configurare un nuovo progetto

• Clicca su "New Project": Nel portale Azure DevOps, clicca il pulsante New Project. Ti permetterà di configurare il tuo primo progetto.
• Compila i dettagli del progetto:
• Nome del progetto: Scegli un nome per il tuo progetto (ad es., “yourproject”).
• Descrizione (Opzionale): Descrivi brevemente di cosa tratta questo progetto.
• Visibilità: Scegli se vuoi che il tuo progetto sia pubblico o privato. I progetti pubblici sono visibili a chiunque, ottimi per l’open source. I progetti privati sono protetti e accessibili solo a chi inviti al progetto.
• Crea il progetto: Dopo aver inserito i dettagli del progetto e selezionato il sistema di controllo versione, clicca Create project. Il tuo progetto è ora configurato e pronto!

• Sistema di controllo versione: Azure DevOps offre due tipi di sistemi di controllo versione: Git e Team Foundation Version Control (TFVC).
• Git è un sistema di controllo versione distribuito, più moderno e ampiamente usato nella community degli sviluppatori. È la scelta migliore per la maggior parte dei progetti.
• TFVC è un sistema di controllo versione centralizzato, meno comune e spesso usato in progetti legacy.

Per esperienza, ti consiglio di scegliere Git se stai iniziando o non hai motivi specifici per scegliere TFVC.

Pronto a prendere il controllo del tuo codice? Impara Git e inizia a gestire i tuoi progetti come un pro.

Usare Azure Repos per il controllo versione

Ora che hai configurato il progetto, approfondiamolo ed esploriamo alcune delle sue funzionalità chiave.

Configurare un repository Git

• Vai su Repos: Dal menu a sinistra, seleziona la scheda Repos. Qui gestirai il tuo codice.

• Clona il repository: Puoi clonare il repository sul tuo computer locale usando l'URL nella sezione Repos. Es.

# This command clones the specified Git repository from Azure DevOps to your local machine.
git clone https://yourorganization@dev.azure.com/yourorganization/yourproject/_git/yourrepo

Scomponiamo il comando sopra in blocchi:

• Sostituisci yourorganization con il nome della tua organizzazione.
• Sostituisci yourproject con il nome del tuo progetto.
• Sostituisci yourrepo con il nome del tuo repository.

Di seguito c’è l’URL nella mia sezione Repos:

• Esegui il push del tuo codice: Una volta clonato in locale il repository, puoi aggiungere il tuo codice ed eseguire il push su Azure DevOps.

git add .
git commit -m "my first commit"
git push origin main

Congratulazioni! Hai appena fatto il tuo primo commit in Azure Repos.

Branching e merge

Nello sviluppo software, il branching ti consente di lavorare su funzionalità o fix separatamente dal progetto principale. Il merge è il processo di portare le modifiche da un branch a un altro.

• Crea un branch in locale: Per iniziare a lavorare su una feature, crea un nuovo branch: 

git checkout -b feature-branch

• Esegui il push del branch su Azure DevOps: Dopo aver apportato modifiche nel tuo nuovo branch, esegui il push su Azure DevOps:

git push origin feature-branch

Passare tra i branch

Per passare tra i branch, usa il seguente comando:

git checkout main

Oppure per passare a un branch diverso:

git checkout feature-branch

Eliminare un branch

Una volta che una feature è stata fusa, puoi eliminare il branch sia in locale che in remoto:

• Per eliminare il branch locale: 

git branch -d feature-branch

• Per eliminare il branch remoto:

git push origin --delete feature-branch

Eseguire merge tramite pull request

• Crea una pull request: Quando il tuo feature branch è pronto per essere fuso con il branch principale, vai alla sezione Pull Requests in Azure DevOps e clicca su New Pull Request.

• Revisiona e unisci: Rivedi le modifiche e clicca Complete per unire le modifiche nel branch principale.
• Risolvi i conflitti: Se ci sono conflitti di merge (cioè modifiche nella stessa parte di codice), dovrai risolverli manualmente. Azure DevOps ti guiderà in questo processo evidenziando le aree in conflitto.

Gestire le pull request

Le pull request sono essenziali per il code review e la collaborazione. Consentono ai membri del team di revisionare il codice prima che venga unito al branch principale.

Creare una pull request

• Crea la pull request: Dopo aver fatto il push del tuo feature branch, vai su Pull Requests e clicca su New Pull Request. Scegli il branch di origine (ad es., feature-branch) e il branch di destinazione (ad es., main).
• Descrivi la pull request: Fornisci una descrizione chiara delle modifiche incluse nella pull request. Aiuta i revisori a capire cosa cercare.

Revisionare e approvare le pull request

• Richiedi revisioni: Aggiungi revisori dal tuo team che controlleranno le modifiche al codice.
• Approva e unisci: Una volta approvata la pull request, clicca Complete per fonderla nel branch principale.

Creare e gestire pipeline CI/CD

Azure DevOps include anche Pipelines per automatizzare i processi di build, test e deployment.

Che cos'è una pipeline in Azure DevOps?

Una pipeline in Azure DevOps è un insieme di processi automatizzati che ti aiutano a:

• Compilare il tuo codice (build pipeline)
• Testarlo
• Distribuirlo in diversi ambienti (release pipeline)

Queste pipeline garantiscono che il tuo codice sia sempre pronto per la distribuzione e possa essere testato automaticamente.

Creare una build pipeline

• Vai su Pipelines: Nel tuo progetto Azure DevOps, clicca New Pipeline nella sezione Pipelines.

• Scegli una fonte: Seleziona Azure Repos Git come fonte e scegli il tuo repository.

• Configura la pipeline: Puoi configurare la pipeline utilizzando il YAML editor o il Classic editor. Scegliamo YAML, un modo basato sul codice per definire la pipeline.

Prendiamo come esempio un'applicazione Node.js di base. Il nostro file azure-pipelines.yml qui sotto contiene il codice YAML che Azure DevOps ha creato automaticamente. 

# 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'

• Salva ed esegui: salva la pipeline ed eseguila per vedere se tutto funziona correttamente.

Eseguire la build pipeline

Una volta configurata la build pipeline, puoi eseguirla manualmente cliccando Run Pipeline. La pipeline passerà attraverso diverse fasi, come “installazione delle dipendenze”, “esecuzione dei test” e “build”.

Puoi controllare i log di ogni passaggio per risolvere eventuali build fallite. Azure DevOps fornisce log dettagliati per aiutarti a capire cosa non ha funzionato.

Configurare il continuous deployment (CD)

• Vai su Releases: Nella sezione Pipelines, clicca su Releases e poi su New Pipeline.

• Aggiungi un Artifact: Collega l'artifact dalla tua build pipeline come sorgente per la release pipeline.

• Distribuisci negli ambienti: Configura ambienti come Staging e Production in cui vuoi che la tua applicazione venga distribuita.

Automatizzare le distribuzioni

Azure DevOps può distribuire automaticamente la tua applicazione ogni volta che viene avviata una nuova build. Puoi configurarlo aggiungendo trigger e definendo task per il deploy su piattaforme come Azure, AWS, ecc.

Gestire i work item con Azure Boards

Azure Boards è il cuore del project management in Azure DevOps. Aiuta i team a pianificare, tracciare e discutere il lavoro lungo l'intero ciclo di vita dello sviluppo software tramite funzionalità come Tasks, Bugs, User Stories ed Epics. 

Che tu segua Scrum o Kanban, Azure Boards ti permette di visualizzare, dare priorità e gestire il lavoro in modo efficiente.

Vediamolo passo dopo passo.

Creare e gestire i work item

Azure Boards ti permette di gestire attività, bug e funzionalità usando i work item.

• Crea un work item: Vai su Boards, seleziona Work items e clicca su New Work Item.

Puoi creare:

• Epic: Un progetto ampio o un lavoro esteso che copre più parti più piccole.
• Issue: Un problema specifico o bug da correggere.
• Task: Un singolo elemento di lavoro azionabile da svolgere.

• Selezioniamo Epic. 
• Inserisci un Title, Description, Priority, Start Date e Target Date. Clicca su Save.

• Assegna i work item
• Apri il work item che hai appena creato. 
• Nel campo Assign people, seleziona un membro del team. 
• Seleziona Add tag per una migliore categorizzazione. Clicca su Save.

• Monitora i progressi
• Usa il campo State per aggiornare lo stato (ad es., New, Active, Resolved, Closed). 
• Aggiungi commenti o allegati per fornire aggiornamenti o contesto.

Per esperienza, i team restano responsabili e concentrati quando vengono assegnati owner chiari e scadenze ragionevoli.

Impostare sprint e backlog

Gli sprint agili e i backlog sono essenziali per lo sviluppo iterativo. Ecco come configurarli:

• Crea Sprint: Gli sprint sono iterazioni di lavoro a tempo. Puoi configurarli andando su Boards > Sprints e aggiungendo nuovi sprint (ad es., “Sprint 1”).

• Clicca su Configure Team Settings e definisci la durata dello sprint (ad es., 2 settimane).

• Aggiungi le date di inizio e fine dello sprint.

• Gestisci i product backlog: Nella vista Backlog, puoi organizzare i work item per priorità. Vai su Boards > Backlogs. 

• Trascina e rilascia i work item nel backlog per dare loro priorità. 

• Visualizza i progressi: Azure DevOps ti aiuta a visualizzare i work item e a spostarli tra fasi (ad es., To Do, Doing, Done). Usa la Board view per vedere i work item in colonne. 

• Personalizza le colonne per allinearle al workflow del tuo team.

Per esperienza, seguire questo approccio riduce i tempi morti e la confusione se il backlog è ben organizzato e chiaro su cosa va fatto dopo.

Collegare i work item ai commit

Collegare i work item ai commit aiuta a tracciare le modifiche al codice per ciascuna attività o bug. Ecco come:

• Collega a un commit: Si può fare in due modi: tramite la console di Azure DevOps o il tuo ambiente di sviluppo locale.
• Console di Azure DevOps: Nel messaggio di commit Git, includi il  #WorkItemID (ad es., #1). Clicca Commit. Azure DevOps collega automaticamente il commit al work item.

• Ambiente di sviluppo locale:
• Nel tuo ambiente di sviluppo locale, apri il terminale o prompt dei comandi. Apporta le modifiche al codice e preparati a fare il commit.
• Nel messaggio di commit, includi l'ID del work item con un cancelletto (ad es., Fixed bug in login analytics #1).
• Completa il commit eseguendo il comando appropriato:

git commit -m "Fixed bug in login analytics #1"

• Esegui il push del commit sul repository remoto (Azure Repo):

git push origin feature-branch

• Collega a una pull request:
  • Quando crei una pull request, menziona l'ID del work item nella Description. 
  • Clicca Create. Azure DevOps collegherà automaticamente la pull request al work item.

In my experience, this linkage provides full traceability, making it easy to see which code changes addressed specific tasks or bugs. Remember, you can see linked commits and PRs in the Development section of the work item.

Integrazione con altri strumenti

Azure DevOps dà il meglio quando è integrato con altri strumenti come GitHub e piattaforme cloud. Vediamo come configurarlo.

Integrare Azure DevOps con GitHub

Collegare Azure DevOps a GitHub semplifica la collaborazione e l'automazione CI/CD. Ecco come: 

• Connetti GitHub ad Azure Pipelines: 
• Vai su Pipelines > Create Pipeline. 

• Seleziona GitHub come fonte. 

• Autorizza Azure DevOps ad accedere ai tuoi repository GitHub.

Nuovo su GitHub? Scopri come collaborare, tracciare le modifiche e contribuire a progetti open source con il corso sui concetti di GitHub. 

• Configura una pipeline 
  • Scegli un repository e configura il tuo file YAML della pipeline. 

• Definisci i passaggi di build e deployment. Esempio di YAML:

# Set up the trigger for the pipeline
trigger:  
  # Specify the branches to include
  branches:  
    include:  
      # Include the main branch
      - main  

# Define the jobs for the pipeline
jobs:  
  # Create a job named 'Build'
  - job: Build  
    # List the steps for the 'Build' job
    steps:  
      # Add a script step to print a message
      - script: echo "Building the project..." 

Per esperienza, questa integrazione garantisce automaticamente aggiornamenti e distribuzioni del codice senza intoppi, riducendo il lavoro manuale.

Collegare Azure DevOps ad Azure e ad altre piattaforme cloud

Azure DevOps si integra nativamente con servizi Azure come Azure Web Apps, Azure Kubernetes Services (AKS) e molti altri. Vediamo come collegare il nostro Azure DevOps ad Azure Web Apps.

• Collega ai servizi Azure:
  • 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 
  • 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. Esempio di Task YAML:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1  
  inputs:  
    # Specify your Azure subscription service connection
    azureSubscription: 'Your-Service-Connection'  
    # Specify the name of your web app
    appName: 'Your-Web-App' 

Scomponiamo il comando sopra in blocchi: 

• Sostituisci Your-Service-Connection con il nome della service connection con accesso alla tua sottoscrizione Azure.
• Sostituisci Your-Web-App con il nome effettivo della tua web app in Azure.

Per esperienza, questa connessione rende semplici i deployment, permettendoti di concentrarti soprattutto sulla creazione di ottimo software.

Monitoraggio e reporting in Azure DevOps

Monitoraggio e reporting sono processi chiave per mantenere in salute il tuo progetto in Azure DevOps. Vediamo come svolgerli in modo efficace.

Visualizzare le metriche delle pipeline

Le metriche delle pipeline fanno luce sulle prestazioni di build e deployment. Ecco come accedervi.

• Monitora lo stato della pipeline 
  • Vai su Pipelines > Analytics.
  • Visualizza metriche come tasso di successo della pipeline, tasso di successo dei test e durata della pipeline.

• Individua i colli di bottiglia 
  • Per trovare fasi di errore e build lente, usa il report Pipeline Runs.

• • Vai alle Organization Settings di Azure DevOps > Pipelines > Parallel jobs per utilizzare job parallelizzati, migliorare le prestazioni e ottimizzare le attività. 

Per esperienza, mettere in cache le dipendenze, suddividere i job e ottimizzare la struttura della pipeline può ridurre in modo significativo i tempi di build e i tassi di fallimento.

Usare i report di Azure DevOps

Azure DevOps offre strumenti di reporting solidi per tracciare la produttività del team e l'avanzamento del progetto.

• Accedi ai report 
  • Vai su Analytics > Reports. 
  • Scegli tra report predefiniti come Cumulative Flow Diagram, Velocity o Burndown.

• Personalizza i report 
  • Usa Power BI per creare dashboard personalizzate. Per farlo, usa il Power BI Data Connector, naviga su Power BI Online e accedi al tuo account.
  • Clicca sull'icona Home in alto a sinistra, quindi seleziona Get Data dal ribbon.
  • Vedrai un elenco di origini dati nella finestra Get Data. Seleziona Online Services > Azure DevOps (Boards only) come connettore dati.

• Inserisci i dettagli del tuo account, come Organization e Team project, per sincronizzare i tuoi dati.

• Esporta i dati per ulteriori analisi.

Per esperienza, con questi report analitici puoi prendere decisioni basate sui dati, che offrono insight pratici.

Best practice per Azure DevOps

Ora che abbiamo imparato i servizi core di Azure DevOps e molto altro, vediamo come ottenere il massimo da Azure DevOps seguendo queste best practice.

Best practice per il controllo versione

• Usa strategie di branching 
• Adottando Git Flow o GitHub Flow per il branching. 
• Mantieni sempre stabile il branch main e usa feature branch per lo sviluppo.
• Scrivi messaggi di commit chiari 
• Usa il formato: type(scope): description (ad es., feat(login): add user authentication).
• Revisiona le pull request 
• Richiedi almeno un reviewer prima di fare il merge delle tue pull request. 
• Usa i commenti per suggerire miglioramenti.

Buone pratiche di controllo versione portano a un codebase pulito e riutilizzabile.

Ottimizzare le pipeline

• Usa la cache delle dipendenze: Scaricare ripetutamente le stesse dipendenze può far perdere molto tempo quando si lavora con i package manager. Azure DevOps supporta meccanismi di caching, come il task Cache, che consente di memorizzare nella cache le dipendenze tra le esecuzioni della pipeline. 

Esempio di task di cache YAML:

# Define the cache task
- task: Cache@2  
  inputs:  
    # Set the cache key using npm, the OS, and package-lock.json
    key: 'npm | "$(Agent.OS)" | package-lock.json'  
    # Specify the path to the node_modules directory
    path: 'node_modules'

• Spezza i job: Suddividi job enormi in task più piccoli e paralleli. Considera un carico di lavoro enorme che richiede molto tempo per essere completato. Suddividendolo in attività separate, puoi eseguirle in parallelo, velocizzando l’operazione complessiva.

Esempio di YAML per i job:

jobs:
  # Define the first build job
  - job: BuildJob1
    displayName: 'Build Job 1'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project A
      - script: echo "Building Project A"
        displayName: 'Build Project A'

  # Define the second build job
  - job: BuildJob2
    displayName: 'Build Job 2'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Building Project B
      - script: echo "Building Project B"
        displayName: 'Build Project B'

  # Define the test job
  - job: TestJob
    displayName: 'Run Tests'
    # Specify that this job depends on the completion of BuildJob1 and BuildJob2
    dependsOn: 
      - BuildJob1
      - BuildJob2
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      # Add a script step to print a message for Running Tests
      - script: echo "Running Tests"
        displayName: 'Run Tests'

• Usa i template: Crea template di pipeline riutilizzabili per i task più comuni. In questo modo non devi riscrivere lo stesso codice ogni volta. Creiamo un semplice template per un task di build:

Esempio di template YAML:

# Define parameters for the pipeline
parameters:
  # Specify a parameter for the build configuration
  - name: buildConfiguration
    type: string
    default: 'Release'

# List the steps for the pipeline
steps:
  # Add a task to run the .NET Core CLI
  - task: DotNetCoreCLI@2
    inputs:
      # Set the command to 'build'
      command: 'build'
      # Pass the build configuration as an argument
      arguments: '--configuration $(buildConfiguration)'

I've found that pipeline optimization consistently results in time and resource savings.

Managing secrets and security

• Use Azure Key Vault: Store sensitive information like API keys in Azure Key Vault. To do this, go to the Azure Portal, create a new Key Vault, and add your secrets (e.g., API keys).

• Go back to Azure DevOps and create a service connection to your Azure subscription so your pipeline can access the Key Vault.

• Go to Pipelines > Library in Azure DevOps and create a new variable group. 

• Link the variable group to your Key Vault to automatically fetch the secrets.
• Reference secrets in your pipelines using variable groups. Example YAML:

# azure-pipelines.yml
trigger:
- main

variables:
- group: my-variable-group  # Reference the variable group that links to the Key Vault

jobs:
- job: BuildJob
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: echo "Using secret from Key Vault."
    env:
      MY_API_KEY: $(my-secret)  # Reference the secret from the variable group
    displayName: 'Print Secret'

From the example above: The my-variable-group variable group is referenced, which contains secrets from the Key Vault. The script step echoes a message, using the variable group's secret $(my-secret) as an environment variable.

• Restrict Permissions 
  • Always remember to limit access to pipelines and repositories based on roles.

One essential practice in modern software development is Security. Security is non-negotiable and can’t be compromised because of the consequences at stake. 

Conclusion

This tutorial taught us how to set up an Azure DevOps environment, use Azure Repos for version control, create and manage CI/CD pipelines, track and manage work items with Azure Boards, integrate Azure DevOps with other tools, best practices for Azure DevOps, and more.

Consistency is the secret to success. Review your processes frequently, get feedback, and make adjustments. Mastering these can unlock your full potential as a data professional in software development. Explore Azure DevOps, try out these tools, and see how much more productive your team is.

To dive deeper into Microsoft Azure, check out the following courses: 

• Understanding Microsoft Azure – Build a strong foundation in Microsoft Azure and unlock the power of cloud computing.
• Microsoft Azure Fundamentals (AZ-900) – Get exam-ready with this beginner-friendly track covering all key Azure fundamentals.
• Understanding Microsoft Azure Architecture and Services – Learn how Azure’s architecture and services work together to power cloud solutions.