Creare la prima pipeline

Questa è una guida dettagliata all'uso di Azure Pipelines per compilare un'applicazione di esempio da un repository Git. Questa guida usa le pipeline YAML configurate con l'editor di pipeline YAML. Se invece si vogliono usare le pipeline classiche, vedere Definire la pipeline classica. Per indicazioni sull'uso di TFVC, vedere Creare repository TFVC.

Prerequisiti - Azure DevOps

Assicurarsi di avere quanto segue:

• Un account GitHub in cui è possibile creare un repository. Crearne una gratuitamente.

• Un'organizzazione di Azure DevOps. Crearne una gratuitamente. Se il team ne ha già uno, assicurarsi di essere un amministratore del progetto Azure DevOps che si vuole usare.

• Possibilità di eseguire pipeline su agenti ospitati da Microsoft. Per usare gli agenti ospitati da Microsoft, l'organizzazione Azure DevOps deve avere accesso ai processi paralleli ospitati da Microsoft. È possibile acquistare un processo parallelo oppure richiedere una concessione gratuita.

Creare la prima pipeline

https://github.com/MicrosoftDocs/pipelines-java

https://github.com/MicrosoftDocs/pipelines-dotnet-core

https://github.com/Microsoft/python-sample-vscode-flask-tutorial

https://github.com/Azure-Samples/js-e2e-express-server

Visualizzare e gestire le pipeline

È possibile visualizzare e gestire le pipeline scegliendo Pipeline dal menu a sinistra per passare alla pagina di destinazione delle pipeline.

Dalla pagina di destinazione delle pipeline è possibile visualizzare pipeline e esecuzioni di pipeline, creare e importare pipeline, gestire la sicurezza ed eseguire il drill-down nella pipeline ed eseguire i dettagli dell'esecuzione.

Scegliere Recenti per visualizzare le pipeline di esecuzione di recente (visualizzazione predefinita) o scegliere Tutti per visualizzare tutte le pipeline.

Selezionare una pipeline per gestire la pipeline e visualizzare le esecuzioni. Selezionare il numero di build per l'ultima esecuzione per visualizzare i risultati della compilazione, selezionare il nome del ramo per visualizzare il ramo per l'esecuzione oppure selezionare il menu di scelta rapida per eseguire la pipeline ed eseguire altre azioni di gestione.

Selezionare Esecuzioni per visualizzare tutte le esecuzioni della pipeline. Facoltativamente, è possibile filtrare le esecuzioni visualizzate.

Selezionare un'esecuzione della pipeline per visualizzare le informazioni sull'esecuzione.

È possibile scegliere Di mantenere o eliminare un'esecuzione dal menu di scelta rapida. Per altre informazioni sulla conservazione delle esecuzioni, vedere Creare e rilasciare i criteri di conservazione.

Visualizzare i dettagli della pipeline

La pagina dei dettagli per una pipeline consente di visualizzare e gestire la pipeline.

Scegliere Modifica per modificare la pipeline. Per altre informazioni, vedere Editor di pipeline YAML. È anche possibile modificare la pipeline modificando il file azure-pipelines.yml direttamente nel repository che ospita la pipeline.

Visualizzare i dettagli dell'esecuzione della pipeline

Dal riepilogo dell'esecuzione della pipeline è possibile visualizzare lo stato dell'esecuzione, sia durante l'esecuzione che al termine.

Dal riquadro di riepilogo è possibile visualizzare i dettagli del processo e della fase, scaricare gli artefatti e passare a commit collegati, risultati dei test ed elementi di lavoro.

Processi e fasi

Nel riquadro processi viene visualizzata una panoramica dello stato delle fasi e dei processi. Questo riquadro può avere più schede a seconda che la pipeline abbia fasi e processi o solo processi. In questo esempio la pipeline ha due fasi denominate Build and Deploy. È possibile eseguire il drill-down nei passaggi della pipeline scegliendo il processo dal riquadro Fasi o Processi .

Scegliere un processo per visualizzare i passaggi per il processo.

Dalla visualizzazione dei passaggi è possibile esaminare lo stato e i dettagli di ogni passaggio. Dalle altre azioni è possibile attivare o disattivare i timestamp o visualizzare un log non elaborato di tutti i passaggi della pipeline.

Annullare ed eseguire di nuovo una pipeline

Se la pipeline è in esecuzione, è possibile annullarla scegliendo Annulla. Se l'esecuzione è stata completata, è possibile eseguire nuovamente la pipeline scegliendo Esegui nuovo.

Menu Esegui altre azioni della pipeline

Dal menu Altre azioni è possibile scaricare i log, aggiungere tag, modificare la pipeline, eliminare l'esecuzione e configurare la conservazione per l'esecuzione.

Aggiungere una notifica di stato al repository

A molti sviluppatori piace dimostrare di mantenere alta la qualità del codice visualizzando una notifica di stato nel proprio repository.

Per copiare il badge di stato negli Appunti:

1. In Azure Pipelines passare alla pagina Pipelines per visualizzare l'elenco delle pipeline. Selezionare la pipeline creata nella sezione precedente.

2. Selezionare e quindi selezionare Notifica stato.

3. Selezionare Notifica stato.

4. Copiare l'esempio Markdown dalla sezione Sample markdown .

Ora con il badge Markdown negli Appunti, seguire questa procedura in GitHub:

1. Passare all'elenco dei file e selezionare Readme.md. Seleziona l'icona raffigurante una matita per apportare modifiche.

2. Incollare il badge di stato Markdown all'inizio del file.

3. Eseguire il commit della modifica nel main ramo .

4. Si noti che il badge di stato viene visualizzato nella descrizione del repository.

Per configurare l'accesso anonimo alle notifiche per i progetti privati:

1. Passare a Impostazioni progetto nell'angolo inferiore sinistro della pagina

2. Aprire la scheda Impostazioni in Pipeline

3. Attivare o disattivare il dispositivo di scorrimento Disabilita accesso anonimo alle notifiche in Generale

Poiché il Readme.md file è stato appena modificato in questo repository, Azure Pipelines compila automaticamente il codice, in base alla configurazione nel azure-pipelines.yml file nella radice del repository. Tornare in Azure Pipelines, osservare che viene visualizzata una nuova esecuzione. Ogni volta che si apporta una modifica, Azure Pipelines avvia una nuova esecuzione.

Verrà illustrato come usare l'editor classico in Azure DevOps Server 2019 per creare una build e una versione che stampa "Hello world".

Prerequisiti

• Un agente Windows self-hosted.

Inizializzare il repository

Se nel progetto è già presente un repository, è possibile passare al passaggio successivo: Ignorare l'aggiunta di uno script al repository

1. Passare ad Azure Repos. (L'oggetto Hub del codice nel riquadro di spostamento precedente)

   

2. Se il progetto è vuoto, verrà visualizzata una schermata che consente di aggiungere codice al repository. Scegliere la scelta inferiore per inizializzare il repository con un readme file:

   

Aggiungere uno script al repository

Creare uno script di PowerShell che stampa Hello world.

1. Passare ad Azure Repos.

2. Aggiungere un file.

   

3. Nella finestra di dialogo assegnare un nome al nuovo file e crearlo.

   HelloWorld.ps1
   

4. Copiare e incollare questo script.

   Write-Host "Hello world"
   

5. Eseguire il commit (salvare) il file.

In questa esercitazione, l'attenzione riguarda CI/CD, quindi la parte del codice viene semplificata. Si sta lavorando in un repository Git Di Azure Repos direttamente nel Web browser.

Quando si è pronti per iniziare a creare e distribuire un'app reale, è possibile usare un'ampia gamma di client e servizi di controllo della versione con le build CI di Azure Pipelines. Altre informazioni.

Creazione di una pipeline di compilazione

Creare una pipeline di compilazione che stampa "Hello world".

1. Selezionare Azure Pipelines. Verrà visualizzata automaticamente la pagina Compilazioni.

   

2. Crea una nuova pipeline.

   

   Per i nuovi utenti di Azure DevOps, si passerà automaticamente all'esperienza di creazione della pipeline YAML. Per accedere all'editor classico e completare questa guida, è necessario disattivare la funzionalità di anteprima per l'esperienza di creazione della nuova pipeline YAML:

   

   

3. Assicurarsi che l'origine, il progetto, il repository e il ramo predefinito corrispondano al percorso in cui è stato creato lo script.

4. Iniziare con un processo vuoto.

5. Sul lato sinistro selezionare Pipeline e specificare il nome che si vuole usare. Per il pool di agenti selezionare Vs2017 ospitato.

6. Sul lato sinistro selezionare il segno più ( + ) per aggiungere un'attività al processo 1. Sul lato destro selezionare la categoria Utilità , selezionare l'attività di PowerShell dall'elenco e quindi scegliere Aggiungi.

   

7. Sul lato sinistro selezionare la nuova attività script di PowerShell .

8. Per l'argomento Percorso script selezionare il pulsante per esplorare il repository e selezionare lo script creato.

   

9. Selezionare Salva e accoda e quindi Salva.

Una pipeline di compilazione è l'entità tramite cui si definisce la pipeline di compilazione automatizzata. Nella pipeline di compilazione si compone un set di attività, ognuna delle quali esegue un passaggio nella compilazione. Il catalogo attività offre un set completo di attività da iniziare. È anche possibile aggiungere script di PowerShell o shell alla pipeline di compilazione.

Pubblicare un artefatto dalla compilazione

Una compilazione tipica produce un artefatto che può quindi essere distribuito in varie fasi in una versione. Qui per illustrare la funzionalità in modo semplice, lo script verrà semplicemente pubblicato come artefatto.

1. Nella scheda Attività selezionare il segno più ( + ) per aggiungere un'attività al processo 1.

2. Selezionare la categoria Utilità , selezionare l'attività Pubblica elementi di compilazione e quindi selezionare Aggiungi.

   

   Percorso di pubblicazione: selezionare il pulsante per esplorare e selezionare lo script creato.

   Nome artefatto: immettere drop.

   Percorso di pubblicazione artefatto: selezionare Azure Artifacts/TFS.

Gli artefatti sono i file da produrre per la compilazione. Gli artefatti possono essere quasi tutto ciò che il team deve testare o distribuire l'app. Ad esempio, sono disponibili un .DLL e .EXE file eseguibili e . File di simboli PDB di un'app Windows C# o C++ .NET.

Per consentire di produrre artefatti, vengono forniti strumenti come la copia con criteri di ricerca e una directory di staging in cui è possibile raccogliere gli artefatti prima di pubblicarli. Vedere Artefatti in Azure Pipelines.

Abilitare l'integrazione continua (CI)

1. Selezionare la scheda Trigger.

2. Abilitare l'integrazione continua.

Un trigger di integrazione continua in una pipeline di compilazione indica che il sistema deve accodarsi automaticamente una nuova compilazione ogni volta che viene eseguito il commit di una modifica del codice. È possibile rendere il trigger più generale o più specifico e anche pianificare la compilazione (ad esempio, su base notturna). Vedere Trigger di compilazione.

Salvare e accodare la compilazione

Salvare e accodare una compilazione manualmente e testare la pipeline di compilazione.

1. Selezionare Salva e coda e quindi salva e coda.

2. Nella finestra di dialogo selezionare Salva e coda ancora una volta.

   In questo modo viene accodato una nuova build sull'agente ospitato da Microsoft.

3. Viene visualizzato un collegamento alla nuova build nella parte superiore della pagina.

   

   Scegliere il collegamento per controllare la nuova compilazione man mano che si verifica. Dopo aver allocato l'agente, si inizierà a visualizzare i log in tempo reale della compilazione. Si noti che lo script di PowerShell viene eseguito come parte della compilazione e che "Hello world" viene stampato nella console.

   

4. Passare al riepilogo della compilazione. Nella scheda Artefatti della compilazione si noti che lo script viene pubblicato come artefatto.

   

Aggiungere alcune variabili ed eseguire il commit di una modifica allo script

Verranno passate alcune variabili di compilazione allo script per rendere la pipeline un po' più interessante. Si eseguirà quindi il commit di una modifica a uno script e si osserverà l'esecuzione automatica della pipeline CI per convalidare la modifica.

1. Modificare la pipeline di compilazione.

2. Nella scheda Attività selezionare l'attività script di PowerShell.

3. Aggiungere questi argomenti.

Argomenti

-greeter "$(Build.RequestedFor)" -trigger "$(Build.Reason)"

Infine, salvare la pipeline di compilazione.

Successivamente si aggiungeranno gli argomenti allo script.

1. Passare a File in Azure Repos (hub del codice nel riquadro di spostamento precedente e TFS).

2. Selezionare il file HelloWorld.ps1 e quindi Modificare il file.

3. Modificare lo script come segue:

   Param(
   [string]$greeter,
   [string]$trigger
   )
   Write-Host "Hello world" from $greeter
   Write-Host Trigger: $trigger
   

4. Eseguire il commit (salvare) lo script.

Ora è possibile visualizzare i risultati delle modifiche. Passare ad Azure Pipelines e selezionare Accodato. Si noti che nella sezione In coda o in esecuzione una compilazione viene attivata automaticamente dalla modifica di cui è stato eseguito il commit.

1. Selezionare la nuova compilazione creata e visualizzarne il log.

2. Si noti che la persona che ha modificato il codice ha il nome stampato nel messaggio di saluto. Si noterà anche che si tratta di una compilazione CI.

In questi passaggi è stato appena introdotto il concetto di variabili di compilazione. È stato stampato il valore di una variabile che viene automaticamente predefinita e inizializzata dal sistema. È anche possibile definire variabili personalizzate e usarle negli argomenti delle attività o come variabili di ambiente all'interno degli script. Per altre informazioni sulle variabili, vedere Variabili di compilazione.

È disponibile una pipeline di compilazione. Passaggi successivi

È stata creata una pipeline di compilazione che compila e convalida automaticamente il codice archiviato dal team. A questo punto, è possibile continuare con la sezione successiva per informazioni sulle pipeline di versione. In alternativa, se si preferisce, è possibile passare direttamente alla creazione di una pipeline di compilazione per l'app.

Creazione di una pipeline di rilascio

Definire il processo per l'esecuzione dello script in due fasi.

1. Passare alla scheda Pipeline e quindi selezionare Versioni.

2. Selezionare l'azione per creare una nuova pipeline. Se è già stata creata una pipeline di versione, selezionare il segno più ( + ) e quindi selezionare Crea una pipeline di versione.

3. Selezionare l'azione per iniziare con un processo vuoto.

4. Denominare il controllo di qualità della fase.

5. Nel pannello Artefatti selezionare + Aggiungi e specificare un'origine (pipeline di compilazione). Selezionare Aggiungi.

6. Selezionare il bolt Lightning per attivare la distribuzione continua e quindi abilitare il trigger di distribuzione continua a destra.

   

7. Selezionare la scheda Attività e selezionare la fase di controllo di qualità .

8. Selezionare il segno più ( + ) per il processo per aggiungere un'attività al processo.

9. Nella finestra di dialogo Aggiungi attività selezionare Utilità, individuare l'attività di PowerShell e quindi selezionare il pulsante Aggiungi .

10. Sul lato sinistro selezionare la nuova attività script di PowerShell .

11. Per l'argomento Percorso script selezionare il pulsante per esplorare gli artefatti e selezionare lo script creato.

12. Aggiungere gli argomenti seguenti:

    -greeter "$(Release.RequestedFor)" -trigger "$(Build.DefinitionName)"
    

13. Nella scheda Pipeline selezionare la fase qa e selezionare Clona.

    

14. Rinominare la fase clonata Production.

15. Rinominare la pipeline di versione Hello world.

    

16. Salvare la pipeline di versione.

Una pipeline di versione è una raccolta di fasi in cui vengono distribuiti gli artefatti di compilazione dell'applicazione. Definisce anche la pipeline di distribuzione effettiva per ogni fase, nonché il modo in cui gli artefatti vengono alzati di livello da una fase a un'altra.

Si noti anche che sono state usate alcune variabili negli argomenti dello script. In questo caso, sono stati usati variabili di rilascio anziché le variabili di compilazione usate per la pipeline di compilazione.

Distribuire una versione

Eseguire lo script in ogni fase.

1. Creare una nuova versione.

   

   Quando viene visualizzata l'opzione Crea nuova versione , selezionare Crea.

2. Aprire la versione creata.

   

3. Visualizzare i log per ottenere dati in tempo reale sulla versione.

   

È possibile tenere traccia dello stato di avanzamento di ogni versione per verificare se è stato distribuito in tutte le fasi. È possibile tenere traccia dei commit che fanno parte di ogni versione, degli elementi di lavoro associati e dei risultati di tutte le esecuzioni di test aggiunte alla pipeline di versione.

Modificare il codice e controllarlo automaticamente per la distribuzione nell'ambiente di produzione

Verrà apportata un'altra modifica allo script. Questa volta verrà compilata automaticamente e quindi distribuita fino alla fase di produzione.

1. Passare alla scheda Hub del codice , File , modificare il file HelloWorld.ps1 e modificarlo come segue:

   Param(
   [string]$greeter,
   [string]$trigger
   )
   Write-Host "Hello world" from $greeter
   Write-Host Trigger: $trigger
   Write-Host "Now that you've got CI/CD, you can automatically deploy your app every time your team checks in code."
   

2. Eseguire il commit (salvare) lo script.

3. Selezionare la scheda Compilazioni per visualizzare la compilazione in coda ed eseguire.

4. Al termine della compilazione, selezionare la scheda Versioni , aprire la nuova versione e quindi passare a Log.

Il nuovo codice viene distribuito automaticamente nella fase di controllo di qualità e quindi nella fase di produzione .

In molti casi, è probabile che si voglia modificare la pipeline di versione in modo che la distribuzione di produzione venga eseguita solo dopo alcuni test e approvazioni. Vedere Panoramica delle approvazioni e dei controlli.

Si è appreso come creare la prima pipeline in Azure. Altre informazioni sulla configurazione delle pipeline nel linguaggio preferito:

• .NET Core
• Go
• Java
• Node.js
• Python
• Contenitori

In alternativa, è possibile procedere alla personalizzazione della pipeline creata.

Per eseguire la pipeline in un contenitore, vedere Processi del contenitore.

Per informazioni dettagliate sulla creazione di repository GitHub, vedere Creare repository GitHub.

Per informazioni su come pubblicare gli artefatti della pipeline, vedere Pubblicare artefatti della pipeline.

Per informazioni sulle altre operazioni che è possibile eseguire nelle pipeline YAML, vedere Informazioni di riferimento sullo schema YAML.

Eseguire la pulizia

Se sono state create pipeline di test, è facile eliminarle al termine dell'operazione.

az pipelines list [--detect {false, true}]
                  [--folder-path]
                  [--name]
                  [--org]
                  [--project]
                  [--query-order {ModifiedAsc, ModifiedDesc, NameAsc, NameDesc, None}]
                  [--repository]
                  [--repository-type {bitbucket, git, github, githubenterprise, svn, tfsgit, tfsversioncontrol}]
                  [--top]

az pipelines delete --id
                    [--detect {false, true}]
                    [--org]
                    [--project]
                    [--yes]

az pipelines list --output table

ID    Path    Name           Status    Default Queue
----  ------  -------------  --------  ------------------
6     \       FabrikamFiber  enabled   Hosted Ubuntu 1604

az pipelines delete --id 6

Are you sure you want to delete this pipeline? (y/n): y
Pipeline 6 was deleted successfully.

Sono state apprese le nozioni di base per la creazione e l'esecuzione di una pipeline. A questo momento è possibile configurare la pipeline di compilazione per il linguaggio di programmazione in uso. Procedere e creare una nuova pipeline di compilazione e questa volta usare uno dei modelli seguenti.

• Client

  • Visual Studio Code per Windows, macOS e Linux
  • Visual Studio con Git per Windows o Visual Studio per Mac
  • Eclipse
  • Xcode
  • IntelliJ
  • Riga di comando

• Servizi

  • Azure Pipelines
  • Provider di servizi Git come Git Repos di Azure, GitHub e Bitbucket Cloud
  • Subversion

• Client

  • Visual Studio Code per Windows, macOS e Linux
  • Visual Studio con Git per Windows o Visual Studio per Mac
  • Visual Studio con TFVC
  • Eclipse
  • Xcode
  • IntelliJ
  • Riga di comando

• Servizi

  • Azure Pipelines
  • Provider di servizi Git, ad esempio GitHub e Bitbucket Cloud
  • Subversion

Ricerca per categorie replicare una pipeline?

Se la pipeline ha un modello che si vuole replicare in altre pipeline, clonarlo, esportarlo o salvarlo come modello.

Dopo aver clonato una pipeline, è possibile apportare modifiche e quindi salvarla.

Dopo aver esportato una pipeline, è possibile importarla dalla scheda Tutte le pipeline.

Dopo aver creato un modello, i membri del team possono usarlo per seguire il modello nelle nuove pipeline.

Ricerca per categorie lavorare con le bozze?

Se si sta modificando una pipeline di compilazione e si vogliono testare alcune modifiche non ancora pronte per l'ambiente di produzione, è possibile salvarla come bozza.

È possibile modificare e testare la bozza in base alle esigenze.

Quando si è pronti, è possibile pubblicare la bozza per unire le modifiche nella pipeline di compilazione.

In alternativa, se si decide di eliminare la bozza, è possibile eliminarla dalla scheda Tutte le pipeline illustrata sopra.

Quali altre operazioni è possibile eseguire quando si accoda una compilazione?

È possibile accodamento delle compilazioni automaticamente o manualmente.

Quando si accoda manualmente una compilazione, è possibile, per una singola esecuzione della compilazione:

• Specificare il pool in cui viene inserita la compilazione.

• Aggiungere e modificare alcune variabili.

• Aggiungere richieste.

• In un repository Git

  • Creare un ramo o un tag.

  • Compilare un commit.

• In un repository TFVC

  • Specificare la versione di origine come etichetta o insieme di modifiche.

  • Eseguire una compilazione privata di un set di scaffali. (È possibile usare questa opzione in uno dei due Agente ospitato da Microsoft o agente self-hosted.

È possibile accodamento delle compilazioni automaticamente o manualmente.

Quando si accoda manualmente una compilazione, è possibile, per una singola esecuzione della compilazione:

• Specificare il pool in cui viene inserita la compilazione.

• Aggiungere e modificare alcune variabili.

• Aggiungere richieste.

• In un repository Git

  • Creare un ramo o un tag.

  • Compilare un commit.

Per altre informazioni sulle impostazioni della pipeline, vedere:

• Recupero di origini
• Attività
• Variabili
• Trigger
• Conservazione
• Cronologia

Ricerca per categorie creare una pipeline di compilazione a livello di codice?

Informazioni di riferimento sull'API REST: Creare una pipeline di compilazione