Condividi tramite

Esecuzioni della pipeline

  • Articolo

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

Questo articolo illustra la sequenza di attività nelle esecuzioni della pipeline di Azure Pipelines. Un'esecuzione rappresenta un'esecuzione di una pipeline. Le pipeline di integrazione continua (CI) e recapito continuo (CD) sono costituite da esecuzioni. Durante un'esecuzione, Azure Pipelines elabora la pipeline e gli agenti elaborano uno o più processi, passaggi e attività.

Diagramma che mostra una panoramica della pipeline.

Per ogni esecuzione, Azure Pipelines:

  • Elabora la pipeline.
  • Richiede a uno o più agenti di eseguire processi.
  • Distribuisce i processi agli agenti e raccoglie i risultati.

Per ogni processo, un agente:

  • Prepara il processo.
  • Esegue ogni passaggio del processo.
  • Restituisce i risultati.

I processi potrebbero avere esito positivo, non riuscire, annullare o non completare. La comprensione di questi risultati consente di risolvere i problemi.

Le sezioni seguenti descrivono in dettaglio il processo di esecuzione della pipeline.

Elaborazione della pipeline

Diagramma che mostra l'espansione dei modelli YAML.

Per elaborare una pipeline per un'esecuzione, Azure Pipelines prima di tutto:

  1. Espande i modelli e valuta le espressioni modello.
  2. Valuta le dipendenze a livello di fase per selezionare la prima fase da eseguire.

Per ogni fase selezionata per l'esecuzione, Azure Pipelines:

  1. Raccoglie e convalida tutte le risorse del processo per l'autorizzazione da eseguire.
  2. Valuta le dipendenze a livello di processo per selezionare il primo processo da eseguire.

Azure Pipelines esegue le attività seguenti per ogni processo selezionato per l'esecuzione:

  1. Espande YAML strategy: matrix o strategy: parallel più configurazioni in più processi di runtime.
  2. Valuta le condizioni per decidere se il processo è idoneo per l'esecuzione.
  3. Richiede un agente per ogni processo idoneo.

Al termine dei processi di runtime, Azure Pipelines verifica se sono disponibili nuovi processi idonei per l'esecuzione. Analogamente, al termine delle fasi, Azure Pipelines verifica se sono presenti altre fasi.

Variabili

Comprendere l'ordine di elaborazione spiega perché non è possibile usare determinate variabili nei parametri del modello. Il primo passaggio di espansione del modello opera solo sul testo del file YAML. Le variabili di runtime non esistono ancora durante tale passaggio. Dopo questo passaggio, i parametri del modello sono già stati risolti.

Non è anche possibile usare le variabili per risolvere i nomi di connessione al servizio o di ambiente, perché la pipeline autorizza le risorse prima che una fase possa iniziare l'esecuzione. Le variabili a livello di fase e di processo non sono ancora disponibili. I gruppi di variabili sono stessi una risorsa soggetta all'autorizzazione, quindi i dati non sono disponibili quando si controlla l'autorizzazione delle risorse.

È possibile usare variabili a livello di pipeline incluse in modo esplicito nella definizione della risorsa della pipeline. Per altre informazioni, vedere Metadati delle risorse della pipeline come variabili predefinite.

Agenti

Quando Azure Pipelines deve eseguire un processo, richiede un agente dal pool. Il processo funziona in modo diverso per i pool di agenti ospitati da Microsoft e self-hosted.

Nota

I processi server non usano un pool perché vengono eseguiti nel server Azure Pipelines stesso.

Diagramma che mostra la selezione del pool.

Processi in parallelo

Prima di tutto, Azure Pipelines controlla i processi paralleli dell'organizzazione. Il servizio aggiunge tutti i processi in esecuzione su tutti gli agenti e confronta il numero di processi paralleli concessi o acquistati.

Se non sono disponibili slot paralleli, il processo deve attendere in uno slot per liberare. Quando è disponibile uno slot parallelo, il processo viene instradato al tipo di agente appropriato.

Agenti ospitati da Microsoft

Concettualmente, il pool ospitato da Microsoft è un pool globale di computer, anche se è fisicamente molti pool diversi suddivisi per tipo di geografia e sistema operativo. In base al nome del pool di editor YAML vmImage o classico richiesto, Azure Pipelines seleziona un agente.

Tutti gli agenti nel pool Microsoft sono nuove macchine virtuali (VM) che non hanno mai eseguito pipeline. Al termine del processo, la macchina virtuale dell'agente viene rimossa.

Agenti self-hosted

Quando è disponibile uno slot parallelo, Azure Pipelines esamina il pool self-hosted per un agente compatibile. Gli agenti self-hosted offrono funzionalità che indicano che un particolare software è installato o configurato. La pipeline richiede, ovvero le funzionalità necessarie per eseguire il processo.

Se Azure Pipelines non riesce a trovare un agente gratuito le cui funzionalità corrispondono alle richieste della pipeline, il processo continua ad attendere. Se nel pool non sono presenti agenti le cui funzionalità corrispondono alle richieste, il processo ha esito negativo.

Gli agenti self-hosted vengono in genere riutilizzati dall'esecuzione per l'esecuzione. Per gli agenti self-hosted, un processo della pipeline può avere effetti collaterali, ad esempio il riscaldamento delle cache o la disponibilità della maggior parte dei commit nel repository locale.

Preparazione del processo

Quando un agente accetta un processo, esegue le operazioni di preparazione seguenti:

  1. Scarica tutte le attività necessarie per eseguire il processo e le memorizza nella cache per un uso futuro.
  2. Crea spazio di lavoro su disco per contenere il codice sorgente, gli artefatti e gli output usati nell'esecuzione.

Esecuzione dei passaggi

L'agente esegue i passaggi in sequenza in ordine. Prima che un passaggio possa iniziare, tutti i passaggi precedenti devono essere completati o ignorati.

Diagramma che mostra l'esecuzione di ogni attività.

I passaggi vengono implementati dalle attività, che possono essere Node.js, PowerShell o altri script. Il sistema di attività instrada input e output agli script di backup. Le attività forniscono anche servizi comuni, ad esempio la modifica del percorso di sistema e la creazione di nuove variabili della pipeline.

Ogni passaggio viene eseguito nel proprio processo, isolando l'ambiente dai passaggi precedenti. A causa di questo modello in base al processo, le variabili di ambiente non vengono mantenute tra i passaggi. Tuttavia, le attività e gli script possono usare un meccanismo denominato comandi di registrazione per comunicare con l'agente. Quando un'attività o uno script scrive un comando di registrazione nell'output standard, l'agente esegue qualsiasi azione richiesta dal comando.

È possibile usare un comando di registrazione per creare nuove variabili della pipeline. Le variabili della pipeline vengono convertite automaticamente in variabili di ambiente nel passaggio successivo. Uno script può impostare una nuova variabile myVar con il valore myValue seguente:

echo '##vso[task.setVariable variable=myVar]myValue'

Write-Host "##vso[task.setVariable variable=myVar]myValue"

Creazione di report e raccolta dei risultati

Ogni passaggio può segnalare avvisi, errori ed errori. Il passaggio segnala errori e avvisi nella pagina di riepilogo della pipeline contrassegnando le attività come riuscite con problemi o segnalando errori contrassegnando l'attività come non riuscita. Un passaggio ha esito negativo se segnala in modo esplicito un errore usando un ##vso comando o termina lo script con un codice di uscita diverso da zero.

Durante l'esecuzione dei passaggi, l'agente invia costantemente le righe di output ad Azure Pipelines, in modo da visualizzare un feed live della console. Al termine di ogni passaggio, l'intero output del passaggio viene caricato come file di log. È possibile scaricare il log al termine della pipeline.

Diagramma che mostra il flusso dei log e dei risultati dall'agente al servizio.

L'agente può anche caricare artefatti e risultati di test, che sono disponibili anche al termine della pipeline.

Stato e condizioni

L'agente tiene traccia dell'esito positivo o negativo di ogni passaggio. Man mano che i passaggi hanno esito positivo o negativo, lo stato del processo viene aggiornato. Il processo riflette sempre il risultato peggiore di ognuno dei relativi passaggi. Se un passaggio ha esito negativo, anche il processo ha esito negativo.

Prima che l'agente esegua un passaggio, verifica la condizione del passaggio per determinare se il passaggio deve essere eseguito. Per impostazione predefinita, un passaggio viene eseguito solo quando lo stato del processo è riuscito o ha esito positivo con problemi, ma è possibile impostare altre condizioni.

Molti processi dispongono di passaggi di pulizia che devono essere eseguiti indipendentemente dal resto, in modo da poter specificare una condizione di always(). La pulizia o altri passaggi possono anche essere impostati per l'esecuzione solo in caso di annullamento.

Un passaggio di pulizia riuscito non può salvare il processo in caso di errore. I processi non possono mai tornare al successo dopo aver immesso un errore.

Timeout e disconnessioni

Ogni processo ha un timeout. Se il processo non viene completato nel tempo specificato, il server annulla il processo. Il server tenta di segnalare l'arresto dell'agente e contrassegna il processo come annullato. Sul lato agente, l'annullamento significa annullare tutti i passaggi rimanenti e caricare i risultati rimanenti.

I processi hanno un periodo di tolleranza denominato timeout di annullamento in cui completare qualsiasi operazione di annullamento. È anche possibile contrassegnare i passaggi da eseguire anche in caso di annullamento. Dopo un timeout del processo più un timeout di annullamento, se l'agente non segnala che il lavoro è stato arrestato, il server contrassegna il processo come errore.

I computer agente possono interrompere la risposta al server se il computer host dell'agente perde l'alimentazione o è spento o se si verifica un errore di rete. Per rilevare queste condizioni, l'agente invia un messaggio heartbeat una volta al minuto per informare il server che è ancora operativo.

Se il server non riceve un heartbeat per cinque minuti consecutivi, presuppone che l'agente non venga restituito. Il processo è contrassegnato come errore, consentendo all'utente di sapere che deve ripetere la pipeline.

Gestire le esecuzioni tramite l'interfaccia della riga di comando di Azure DevOps

È possibile gestire le esecuzioni della pipeline usando az pipelines runs nell'interfaccia della riga di comando di Azure DevOps. Per iniziare, vedere Introduzione all'interfaccia della riga di comando di Azure DevOps. Per informazioni di riferimento complete sul comando, vedere Informazioni di riferimento sul comando dell'interfaccia della riga di comando di Azure DevOps.

Gli esempi seguenti illustrano come usare l'interfaccia della riga di comando di Azure DevOps per elencare le esecuzioni della pipeline nel progetto, visualizzare i dettagli su un'esecuzione specifica e gestire i tag per le esecuzioni della pipeline.

Prerequisiti

  • Interfaccia della riga di comando di Azure con l'estensione dell'interfaccia della riga di comando di Azure DevOps installata come descritto in Introduzione all'interfaccia della riga di comando di Azure DevOps. Accedere ad Azure con az login.
  • L'organizzazione predefinita impostata tramite az devops configure --defaults organization=<YourOrganizationURL>.

Elencare le esecuzioni della pipeline

Elencare le esecuzioni della pipeline nel progetto con il comando az pipelines runs list .

Il comando seguente elenca le prime tre esecuzioni della pipeline con stato completato e il risultato è riuscito e restituisce il risultato in formato tabella.

az pipelines runs list --status completed --result succeeded --top 3 --output table

Run ID    Number      Status     Result     Pipeline ID    Pipeline Name               Source Branch    Queued Time                 Reason
--------  ----------  ---------  ---------  -------------  --------------------------  ---------------  --------------------------  ------
125       20200124.1  completed  succeeded  12             Githubname.pipelines-java  master           2020-01-23 18:56:10.067588  manual
123       20200123.2  completed  succeeded  12             Githubname.pipelines-java  master           2020-01-23 11:55:56.633450  manual
122       20200123.1  completed  succeeded  12             Githubname.pipelines-java  master           2020-01-23 11:48:05.574742  manual

Visualizzare i dettagli dell'esecuzione della pipeline

Visualizzare i dettagli per un'esecuzione della pipeline nel progetto con il comando az pipelines runs show .

Il comando seguente mostra i dettagli per l'esecuzione della pipeline con ID 123, restituisce i risultati in formato tabella e apre il Web browser alla pagina dei risultati della compilazione di Azure Pipelines.

az pipelines runs show --id 122 --open --output table

Run ID    Number      Status     Result     Pipeline ID    Pipeline Name               Source Branch    Queued Time                 Reason
--------  ----------  ---------  ---------  -------------  --------------------------  ---------------  --------------------------  --------
123       20200123.2  completed  succeeded  12             Githubname.pipelines-java  master           2020-01-23 11:55:56.633450  manual

Aggiungere tag all'esecuzione della pipeline

Aggiungere un tag a un'esecuzione della pipeline nel progetto con il comando az pipelines runs tag add .

Il comando seguente aggiunge il tag YAML all'esecuzione della pipeline con l'ID 123 e restituisce il risultato in formato JSON.

az pipelines runs tag add --run-id 123 --tags YAML --output json

[
  "YAML"
]

Elencare i tag di esecuzione della pipeline

Elencare i tag per un'esecuzione della pipeline nel progetto con il comando az pipelines runs tag list . Il comando seguente elenca i tag per l'esecuzione della pipeline con ID 123 e restituisce il risultato in formato tabella.

az pipelines runs tag list --run-id 123 --output table

Tags
------
YAML

Eliminare tag dall'esecuzione della pipeline

Eliminare un tag da un'esecuzione della pipeline nel progetto con il comando az pipelines runs tag delete . Il comando seguente elimina il tag YAML dall'esecuzione della pipeline con ID 123.

az pipelines runs tag delete --run-id 123 --tag YAML

Contenuto correlato