Teilen über

Pipelineausführungen

  • Artikel

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

In diesem Artikel wird die Abfolge von Aktivitäten in der Azure Pipelines-Pipeline ausgeführt. Das Ausführen stellt jeweils eine Ausführung einer Pipeline dar. Sowohl kontinuierliche Integration (CI) als auch Cd-Pipelines (Continuous Delivery) bestehen aus Laufläufen. Während einer Ausführung verarbeitet Azure Pipelines die Pipeline, und Agents verarbeiten einen oder mehrere Aufträge, Schritte und Aufgaben.

Diagramm mit einer Pipelineübersicht.

Für jede Ausführung: Azure-Pipelines:

  • Verarbeitet die Pipeline.
  • Fordert einen oder mehrere Agents an, Aufträge auszuführen.
  • Übergibt Aufträge an Agenten und sammelt die Ergebnisse.

Für jeden Auftrag:

  • Bereitet sich auf den Auftrag vor.
  • Führt jeden Schritt im Auftrag aus.
  • Melden der Ergebnisse

Aufträge können erfolgreich sein, fehlschlagen, abgebrochen oder nicht abgeschlossen werden. Das Verständnis dieser Ergebnisse kann Ihnen bei der Behandlung von Problemen helfen.

In den folgenden Abschnitten wird der Pipelineausführungsprozess ausführlich beschrieben.

Pipelineverarbeitung

Diagramm, das das Erweitern von YAML-Vorlagen zeigt.

Um eine Pipeline für eine Ausführung zu verarbeiten, führen Sie zuerst Azure-Pipelines aus:

  1. Erweitert Vorlagen und wertet Vorlagenausdrücke aus.
  2. Wertet Abhängigkeiten auf Stufesebene aus, um die erste auszuführende Phase zu wählen.

Für jede Phase, die sie für die Ausführung auswählt, werden Azure-Pipelines:

  1. Sammelt und überprüft alle Auftragsressourcen für die Ausführung .
  2. Wertet Abhängigkeiten auf Auftragsebene aus, um den ersten auszuführenden Auftrag zu wählen.

Azure Pipelines führt die folgenden Aktivitäten für jeden Auftrag aus, den er für die Ausführung auswählt:

  1. Erweitert YAML strategy: matrix oder strategy: parallel Multikonfigurationen in mehrere Laufzeitaufträge.
  2. Wertet Bedingungen aus, um zu entscheiden, ob der Auftrag zur Ausführung berechtigt ist.
  3. Fordert einen Agenten für jeden berechtigten Auftrag an.

Nach Abschluss von Laufzeitaufträgen überprüft Azure Pipelines, ob neue Aufträge ausgeführt werden können. Ebenso überprüft Azure Pipelines nach Abschluss der Phasen, ob weitere Stufen vorhanden sind.

Variablen

Das Verständnis der Verarbeitungsreihenfolge verdeutlicht, warum Sie bestimmte Variablen in Vorlagenparametern nicht verwenden können. Der erste Vorlagenerweiterungsschritt wird nur für den Text der YAML-Datei ausgeführt. Laufzeitvariablen sind während dieses Schritts noch nicht vorhanden. Nach diesem Schritt werden vorlagenparameter bereits aufgelöst.

Sie können auch keine Variablen verwenden, um Dienstverbindungs- oder Umgebungsnamen aufzulösen, da die Pipeline Ressourcen autorisiert, bevor eine Phase mit der Ausführung beginnen kann. Variablen auf Stufe- und Auftragsebene sind noch nicht verfügbar. Variable Gruppen sind selbst eine Ressource, die der Autorisierung unterliegt, sodass ihre Daten beim Überprüfen der Ressourcenautorisierung nicht verfügbar sind.

Sie können Variablen auf Pipelineebene verwenden, die explizit in der Pipelineressourcendefinition enthalten sind. Weitere Informationen finden Sie unter Metadaten der Pipelineressource als vordefinierte Variablen.

Agents

Wenn Azure Pipelines einen Auftrag ausführen muss, fordert sie einen Agent aus dem Pool an. Der Prozess funktioniert für von Microsoft gehostete und selbst gehostete Agentpools unterschiedlich.

Hinweis

Serveraufträge verwenden keinen Pool, da sie auf dem Azure Pipelines-Server selbst ausgeführt werden.

Diagramm, das die Poolauswahl zeigt.

Parallelaufträge

Zuerst überprüft Azure Pipelines die parallelen Aufträge Ihrer Organisation. Der Dienst addiert alle laufenden Aufträge für alle Agents und vergleicht diese mit der Anzahl der parallelen Aufträge, die gewährt oder erworben wurden.

Wenn keine parallelen Slots verfügbar sind, muss der Auftrag warten, bis ein Slot frei wird. Sobald ein paralleler Steckplatz verfügbar ist, leitet der Auftrag an den entsprechenden Agenttyp weiter.

Von Microsoft gehostete Agents

Konzeptionell ist der von Microsoft gehostete Pool ein globaler Pool von Computern, obwohl es physisch viele verschiedene Pools ist, die nach Geografie und Betriebssystemtyp aufgeteilt sind. Basierend auf dem angeforderten NAMEN des YAML vmImage - oder klassischen Editorpools wählt Azure Pipelines einen Agent aus.

Alle Agents im Microsoft-Pool sind neu, neue virtuelle Computer (VMs), die nie Pipelines ausgeführt haben. Nach Abschluss des Auftrags wird die Agent-VM verworfen.

Selbstgehostete Agents

Sobald ein paralleler Steckplatz verfügbar ist, untersucht Azure Pipelines den selbst gehosteten Pool für einen kompatiblen Agent. Selbst gehostete Agents bieten Funktionen, die angeben, dass bestimmte Software installiert ist oder Einstellungen konfiguriert sind. Die Pipeline weist Anforderungen auf, d. h. erforderliche Fähigkeiten zum Ausführen des Auftrags.

Wenn Azure Pipelines keinen kostenlosen Agent finden können, dessen Funktionen den Anforderungen der Pipeline entsprechen, wartet der Auftrag weiterhin. Wenn im Pool keine Agents vorhanden sind, deren Funktionen den Anforderungen entsprechen, schlägt der Auftrag fehl.

Selbstgehostete Agents werden in der Regel zwischen den Ausführungen wiederverwendet. Bei selbst gehosteten Agents kann ein Pipelineauftrag Nebenwirkungen haben, z. B. das Aufwärmen von Caches oder die meisten Commits, die bereits im lokalen Repository verfügbar sind.

Arbeitsvorbereitung

Sobald ein Agent einen Auftrag akzeptiert, führt er die folgenden Vorbereitungsarbeiten durch:

  1. Lädt alle Aufgaben herunter, die zum Ausführen des Auftrags erforderlich sind, und speichert sie für die zukünftige Verwendung zwischen.
  2. Erstellt Speicherplatz auf dem Datenträger, um den Quellcode, Artefakte und Ausgaben zu speichern, die in der Ausführung verwendet werden.

Schrittausführung

Der Agent führt schritte sequenziell in der Reihenfolge aus. Bevor ein Schritt gestartet werden kann, müssen alle vorherigen Schritte abgeschlossen oder übersprungen werden.

Diagramm, das die Ausführung der einzelnen Aufgaben zeigt.

Schritte werden von Aufgaben implementiert, die Node.js, PowerShell oder andere Skripts sein können. Das Aufgabensystem leitet Eingaben und Ausgaben an die unterstützenden Skripts weiter. Aufgaben stellen auch allgemeine Dienste bereit, z. B. das Ändern des Systempfads und das Erstellen neuer Pipelinevariablen.

Jeder Schritt wird in einem eigenen Prozess ausgeführt, wobei seine Umgebung aus den vorherigen Schritten isoliert wird. Aufgrund dieses Prozess-pro-Schritt-Modells werden Umgebungsvariablen zwischen den Schritten nicht beibehalten. Aufgaben und Skripts können jedoch einen Mechanismus verwenden, der als Protokollierungsbefehle bezeichnet wird, um mit dem Agent zu kommunizieren. Wenn eine Aufgabe oder ein Skript einen Protokollierungsbefehl in die Standardausgabe schreibt, führt der Agent jede Aktion aus, die der Befehl anfordert.

Sie können einen Protokollierungsbefehl verwenden, um neue Pipelinevariablen zu erstellen. Pipelinevariablen werden im nächsten Schritt automatisch in Umgebungsvariablen konvertiert. Ein Skript kann eine neue Variable myVar mit folgendem Wert myValue festlegen:

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

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

Ergebnisberichterstellung und -sammlung

Jeder Schritt kann Warnungen, Fehler und Ausfälle melden. Der Schritt meldet Fehler und Warnungen auf der Pipelinezusammenfassungsseite, indem die Vorgänge als erfolgreich mit Problemen gekennzeichnet werden, oder Fehler gemeldet werden, indem der Vorgang als fehlgeschlagen markiert wird. Ein Schritt schlägt fehl, wenn entweder explizit ein Fehler mithilfe eines ##vso Befehls gemeldet wird oder das Skript mit einem Nichtzero-Beendigungscode beendet wird.

Während der Ausführung der Schritte sendet der Agent ständig Ausgabezeilen an Azure-Pipelines, sodass Sie einen Livefeed der Konsole sehen können. Am Ende jedes Schritts wird die gesamte Ausgabe des Schritts als Protokolldatei hochgeladen. Sie können das Protokoll herunterladen, sobald die Pipeline abgeschlossen ist.

Diagramm, das zeigt, wie Protokolle und Ergebnisse vom Agent zum Dienst fließen.

Der Agent kann auch Artefakte und Testergebnisse hochladen, die auch nach Abschluss der Pipeline verfügbar sind.

Status und Bedingungen

Der Agent verfolgt den Erfolg oder Fehler jedes Schritts nach. Bei erfolgreichen Schritten mit Problemen oder Fehlern wird der Status des Auftrags aktualisiert. Der Job spiegelt immer das schlechteste Ergebnis der einzelnen Schritte wider. Wenn ein Schritt fehlschlägt, schlägt der Auftrag ebenfalls fehl.

Bevor der Agent einen Schritt ausführt, überprüft er die Bedingung dieses Schritts, um zu bestimmen, ob der Schritt ausgeführt werden soll. Standardmäßig wird ein Schritt nur ausgeführt, wenn der Status des Auftrags erfolgreich war oder probleme erfolgreich war, aber Sie können andere Bedingungen festlegen.

Viele Aufträge verfügen über Bereinigungsschritte, die unabhängig davon ausgeführt werden müssen, was sonst geschieht, damit sie eine Bedingung angeben always()können. Bereinigungen oder andere Schritte können auch so festgelegt werden, dass sie nur beim Abbruch ausgeführt werden.

Ein erfolgreicher Bereinigungsschritt kann den Auftrag nicht vor einem Fehler speichern. Aufträge können nie wieder zum Erfolg zurückkehren, nachdem sie fehlschlagen.

Timeouts und Trennungen

Jeder Auftrag weist ein Timeout auf. Wenn der Auftrag in der angegebenen Zeit nicht abgeschlossen wird, bricht der Server den Auftrag ab. Der Server versucht, den Agent anzuhalten, und markiert den Auftrag als abgebrochen. Auf der Agent-Seite bedeutet abbruch, alle verbleibenden Schritte abzubrechen und alle verbleibenden Ergebnisse hochzuladen.

Aufträge haben eine Nachfrist namens "Cancel Timeout", in der alle Stornierungsarbeiten abgeschlossen werden sollen. Sie können auch Schritte markieren, die auch beim Abbruch ausgeführt werden sollen. Nach einem Auftragstimeout und einem Abbruchtimeout kennzeichnet der Server den Auftrag als Fehler, wenn der Agent nicht meldet, dass die Arbeit beendet wird.

Agent-Computer können nicht mehr auf den Server reagieren, wenn der Hostcomputer des Agents Strom verliert oder ausgeschaltet ist oder wenn ein Netzwerkfehler auftritt. Als Hilfe beim Erkennen dieser Bedingungen sendet der Agent einmal pro Minute eine Heartbeatnachricht, um den Server darüber zu informieren, dass er noch in Betrieb ist.

Wenn der Server keinen Takt für fünf aufeinander folgende Minuten empfängt, wird davon ausgegangen, dass der Agent nicht zurückkommt. Der Auftrag wird als fehlerhaft markiert, sodass Benutzer*innen wissen, dass sie die Pipeline wiederholen müssen.

Verwalten von Vorgängen über die Azure DevOps CLI

Sie können Pipelineausführungen mithilfe von Az-Pipelines in der Azure DevOps CLI verwalten. Informationen zu den ersten Schritten finden Sie unter Erste Schritte mit der Azure DevOps-CLI. Eine vollständige Befehlsreferenz finden Sie unter Azure DevOps CLI-Befehlsreferenz.

Die folgenden Beispiele zeigen, wie Sie die Azure DevOps CLI verwenden, um die Pipelineausführung in Ihrem Projekt auflisten, Details zu einer bestimmten Ausführung anzuzeigen und Tags für Pipelineausführungen zu verwalten.

Voraussetzungen

  • Azure CLI mit der Azure DevOps CLI-Erweiterung installiert, wie in "Erste Schritte mit Azure DevOps CLI" beschrieben. Melden Sie sich mit Azure an az login.
  • Die standardmäßige Organisation, die mithilfe von az devops configure --defaults organization=<YourOrganizationURL>.

Auflisten von Pipelineausführungen

Listen Sie die Pipelineausführungen in Ihrem Projekt mit dem Befehl az pipelines runs list auf.

Der folgende Befehl listet die ersten drei Pipelineausführungen auf, die den Status completed (abgeschlossen) und das Ergebnis succeeded (erfolgreich) aufweisen, und gibt das Ergebnis im Tabellenformat zurück.

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

Anzeigen von Details zur Pipelineausführung

Zeigen Sie die Details für eine Pipelineausführung in Ihrem Projekt mit dem Befehl az pipelines runs show an.

Der folgende Befehl zeigt Details für die Pipelineausführung mit der ID 123, gibt die Ergebnisse im Tabellenformat zurück und öffnet Ihren Webbrowser auf der Seite mit den Buildergebnissen von 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

Hinzufügen eines Tags zur Pipelineausführung

Fügen Sie einer Pipelineausführung in Ihrem Projekt mit dem Befehl az pipelines runs tag add ein Tag hinzu.

Der folgende Befehl fügt das Tag YAML der Pipelineausführung mit der ID 123 hinzu und gibt das Ergebnis im JSON-Format zurück.

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

[
  "YAML"
]

Auflisten von Pipelineausführungs-Tags

Listen Sie die Tags für eine Pipelineausführung in Ihrem Projekt mit dem Befehl az pipelines runs tag list an. Der folgende Befehl listet die Tags für die Pipelineausführung mit der ID 123 an und gibt die Ergebnisse im Tabellenformat zurück.

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

Tags
------
YAML

Löschen eines Tags aus einer Pipelineausführung

Löschen Sie ein Tag aus einer Pipelineausführung in Ihrem Projekt mit dem Befehl az pipelines runs tag delete. Der folgende Befehl löscht das Tag YAML aus der Pipelineausführung mit der ID 123.

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

Zugehöriger Inhalt