Welche Variablen und Ausdrücke kann ich beim Binden von Pipelineaufgaben in Automation Pipelines verwenden?

Mit Variablen und Ausdrücken können Sie Eingabe- und Ausgabeparameter in Ihren Pipeline-Aufgaben verwenden. Die von Ihnen eingegeben Parameter binden die Pipeline-Aufgabe an eine oder mehrere Variablen, Ausdrücke oder Bedingungen und bestimmen das Verhalten der Pipeline, wenn sie ausgeführt wird.

Pipelines können einfache oder komplexe Softwarebereitstellungslösungen ausführen

Bei der Bindung von Pipeline-Aufgaben können Sie Standardausdrücke und komplexe Ausdrücke aufnehmen. Dies führt dazu, dass Ihre Pipeline einfache oder komplexe Softwarebereitstellungslösungen ausführen kann.

Um die Parameter in Ihrer Pipeline zu erstellen, klicken Sie auf die Registerkarte Eingabe oder Ausgabe und fügen Sie eine Variable hinzu, indem Sie das Dollarzeichen $ und einen Ausdruck eingeben. Beispielsweise wird dieser Parameter als Aufgabeneingabe verwendet, die eine URL aufruft: ${Stage0.Task3.input.URL}.

Das Format für Variablenbindungen verwendet Syntaxkomponenten, die als „scopes“ und „keys“ bezeichnet werden. SCOPE definiert den Kontext als Eingabe oder Ausgabe, und KEY definiert die Details. Im Parameterbeispiel ${Stage0.Task3.input.URL} ist input der SCOPE und der KEY die URL.

Die Ausgabeeigenschaften einer beliebigen Aufgabe können zu einer beliebigen Anzahl an geschachtelten Ebenen mit variabler Bindung aufgelöst werden.

Weitere Informationen zur Verwendung von Variablenbindungen in Pipelines finden Sie unter Vorgehensweise zum Verwenden von Variablenbindungen in Automation Pipelines-Pipelines.

Verwenden von Dollarausdrücken mit Geltungsbereichen und Schlüsseln zum Binden von Pipeline-Aufgaben

Sie können Pipeline-Aufgaben aneinander binden, indem Sie Ausdrücke in Variablen mit Dollarzeichen verwenden. Sie geben Ausdrücke als ${SCOPE.KEY.<PATH>} ein.

Zur Bestimmung des Verhaltens einer Pipeline-Aufgabe zu bestimmen, wird in jedem Ausdruck SCOPE als der von Automation Pipelines verwendete Kontext verwendet. SCOPE sucht nach einem KEY, der die Einzelheiten der von der Aufgabe durchgeführten Aktion definiert. Wenn der Wert für KEY ein verschachteltes Objekt ist, können Sie einen optionalen PATH bereitstellen.

In diesen Beispielen werden SCOPE und KEY beschrieben und es wird gezeigt, wie Sie sie in Ihrer Pipeline verwenden.

Tabelle 1. Verwenden von SCOPE und KEY

SCOPE	Zweck des Ausdrucks und Beispiel	KEY	Verwenden von SCOPE und KEY in Ihrer Pipeline
input	Eingabeeigenschaften einer Pipeline: ${input.input1}	Name der Eingabeeigenschaft	Um auf die Eingabeeigenschaft einer Pipeline in einer Aufgabe zu verweisen, verwenden Sie folgendes Format: tasks: mytask: type: REST input: url: ${input.url} action: get input: url: https://www.vmware.com
output	Ausgabeeigenschaften einer Pipeline: ${output.output1}	Name der Ausgabeeigenschaft	Um auf eine Ausgabeeigenschaft zum Senden einer Benachrichtigung zu verweisen, verwenden Sie das folgende Format: notifications: email: - endpoint: MyEmailEndpoint subject: "Deployment Successful" event: COMPLETED to: - [email protected] body: | Pipeline deployed the service successfully. Refer ${output.serviceURL}
task input	Eingabe für eine Aufgabe: ${MY_STAGE.MY_TASK.input.SOMETHING}	Gibt die Eingabe einer Aufgabe in einer Benachrichtigung an	Wenn ein Jenkins-Auftrag gestartet wird, kann er auf den Namen des Auftrags verweisen, der von der Aufgabeneingabe ausgelöst wurde. Senden Sie in diesem Fall eine Benachrichtigung in folgendem Format: notifications: email: - endpoint: MyEmailEndpoint stage: MY_STAGE task: MY_TASK subject: "Build Started" event: STARTED to: - [email protected] body: | Jenkins job ${MY_STAGE.MY_TASK.input.job} started for commit id ${input.COMMITID}.
task output	Ausgabe einer Aufgabe: ${MY_STAGE.MY_TASK.output.SOMETHING}	Gibt die Ausgabe einer Aufgabe in einer nachfolgenden Aufgabe an	Um auf die Ausgabe der Pipeline-Aufgabe 1 in Aufgabe 2 zu verweisen, verwenden Sie folgendes Format: taskOrder: - task1 - task2 tasks: task1: type: REST input: action: get url: https://www.example.org/api/status task2: type: REST input: action: post url: https://status.internal.example.org/api/activity payload: ${MY_STAGE.task1.output.responseBody}
var	Variable: ${var.myVariable}	Auf Variable in einem Endpoint verweisen	Verwenden Sie dieses Format, um auf eine geheime Variable in einem Endpoint für ein Kennwort zu verweisen: --- project: MyProject kind: ENDPOINT name: MyJenkinsServer type: jenkins properties: url: https://jenkins.example.com username: jenkinsUser password: ${var.jenkinsPassword}
var	Variable: ${var.myVariable}	Auf eine Variable in einer Pipeline verweisen	Verwenden Sie dieses Format, um auf eine Variable in einer Pipeline-URL zu verweisen: tasks: task1: type: REST input: action: get url: ${var.MY_SERVER_URL}
task status	Status einer Aufgabe: ${MY_STAGE.MY_TASK.status} ${MY_STAGE.MY_TASK.statusMessage}
stage status	Status einer Phase: ${MY_STAGE.status} ${MY_STAGE.statusMessage}

Standardausdrücke

Sie können Variablen mit Ausdrücken in Ihrer Pipeline verwenden. Diese Übersicht enthält die Standardausdrücke, die Sie verwenden können.

Ausdruck	Beschreibung
${comments}	Kommentare, die bei der Pipeline-Ausführungsanforderung bereitgestellt werden.
${duration}	Dauer der Pipeline-Ausführung.
${endTime}	Endzeit der Pipeline-Ausführung in UTC, sofern abgeschlossen.
${executedOn}	Entspricht der Startzeit – Startzeit der Pipeline-Ausführung in UTC.
${executionId}	ID der Pipeline-Ausführung.
${executionUrl}	URL, die zur Pipeline-Ausführung in der Benutzeroberfläche navigiert.
${name}	Name der Pipeline.
${requestBy}	Name des Benutzers, der die Ausführung angefordert hat.
${stageName}	Name der aktuellen Phase, wenn sie im „scope“ einer Phase verwendet wird.
${startTime}	Startzeit der Pipeline-Ausführung in UTC.
${status}	Status der Ausführung.
${statusMessage}	Statusmeldung der Pipeline-Ausführung.
${taskName}	Name der aktuellen Aufgabe, wenn sie bei der einer Aufgabeneingabe oder Benachrichtigung verwendet wird.

Verwenden von SCOPE und KEY in den Pipeline-Aufgaben

Sie können Ausdrücke mit allen unterstützten Pipeline-Aufgaben verwenden. In diesen Beispielen wird gezeigt, wie Sie SCOPE und KEY definieren und die Syntax bestätigen. In den Codebeispielen werden MY_STAGE und MY_TASK als Bereitstellungs- und Aufgabennamen der Pipeline verwendet.

Weitere Informationen zu den verfügbaren Aufgaben finden Sie unter In Automation Pipelines verfügbare Aufgabentypen.

Tabelle 2. Weitergeben von Aufgaben

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
Benutzervorgang
	Input	summary: Zusammenfassung der Anforderung für den Benutzervorgang description: Beschreibung der Anforderung für den Benutzervorgang approvers: Liste der Genehmiger-E-Mail-Adressen, wobei jeder Eintrag eine mit Komma getrennte Variable sein kann (bzw. durch Semikolon getrennte E-Mail-Adressen) approverGroups: Liste der Genehmiger-Gruppenadressen für die Plattform und Identität sendemail: Sendet auf Anfrage oder Antwort optional eine E-Mail-Benachrichtigung, wenn auf „true“ festgelegt expirationInDays: Anzahl der Tage, die die Ablaufzeit der Anforderung darstellt	${MY_STAGE.MY_TASK.input.summary} ${MY_STAGE.MY_TASK.input.description} ${MY_STAGE.MY_TASK.input.approvers} ${MY_STAGE.MY_TASK.input.approverGroups} ${MY_STAGE.MY_TASK.input.sendemail} ${MY_STAGE.MY_TASK.input.expirationInDays}
	Output	index: sechsstellige hexadezimale Zeichenfolge, die die Anforderung darstellt respondedBy: Kontoname der Person, die den Benutzervorgang genehmigt bzw. abgelehnt hat respondedByEmail: E-Mail-Adresse der Person, die geantwortet hat comments: Während der Antwort bereitgestellte Kommentare	${MY_STAGE.MY_TASK.output.index} ${MY_STAGE.MY_TASK.output.respondedBy} ${MY_STAGE.MY_TASK.output.respondedByEmail} ${MY_STAGE.MY_TASK.output.comments}
Bedingung
	Input	condition: Auszuwertende Bedingung. Wenn die Bedingung „true“ zurückgibt, wird die Aufgabe als abgeschlossen markiert, während die Aufgabe bei anderen Antworten fehlschlägt	${MY_STAGE.MY_TASK.input.condition}
	Output	result: Ergebnis bei Auswertung	${MY_STAGE.MY_TASK.output.response}

Tabelle 3. Pipeline-Aufgaben

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
Pipeline
	Input	name: Name der auszuführenden Pipeline inputProperties: Eingabeeigenschaften, die an die verschachtelte Pipeline-Ausführung übergeben werden	${MY_STAGE.MY_TASK.input.name} ${MY_STAGE.MY_TASK.input.inputProperties} # Siehe alle Eigenschaften ${MY_STAGE.MY_TASK.input.inputProperties.input1} # Siehe Wert von input1
	Output	executionStatus: Status der Pipeline-Ausführung executionIndex: Index der Pipeline-Ausführung outputProperties: Ausgabeeigenschaften der Pipeline-Ausführung	${MY_STAGE.MY_TASK.output.executionStatus} ${MY_STAGE.MY_TASK.output.executionIndex} ${MY_STAGE.MY_TASK.output.outputProperties} # Siehe alle Eigenschaften ${MY_STAGE.MY_TASK.output.outputProperties.output1} # Siehe Wert von output1

Tabelle 4. Automatisieren fortlaufender Integrationsaufgaben

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
CI
	Input	steps: Eine Reihe von Zeichenfolgen, die auszuführende Befehle darstellen export: Beizubehaltende Umgebungsvariablen nach dem Ausführen der Schritte artifacts: Pfade von Artefakten, die im gemeinsam genutzten Pfad beibehalten werden sollen process: Reihe von Konfigurationselementen für die Verarbeitung mit JUnit, JaCoCo, Checkstyle, FindBugs	${MY_STAGE.MY_TASK.input.steps} ${MY_STAGE.MY_TASK.input.export} ${MY_STAGE.MY_TASK.input.artifacts} ${MY_STAGE.MY_TASK.input.process} ${MY_STAGE.MY_TASK.input.process[0].path} # Siehe Pfad der ersten Konfiguration
	Output	exports: Schlüssel-Wert-Paar, das die exportierten Umgebungsvariablen aus der Eingabe darstellt export artifacts: Pfad der erfolgreich beibehaltenen Artefakte processResponse: Satz verarbeiteter Ergebnisse für die Eingabe process	${MY_STAGE.MY_TASK.output.exports} # Siehe alle Exporte ${MY_STAGE.MY_TASK.output.exports.myvar} # Siehe Wert von myvar ${MY_STAGE.MY_TASK.output.artifacts} ${MY_STAGE.MY_TASK.output.processResponse} ${MY_STAGE.MY_TASK.output.processResponse[0].result} # Ergebnis der ersten Prozesskonfiguration
Benutzerdefiniert
	Input	name: Name der benutzerdefinierten Integration version: Eine Version der benutzerdefinierten Integration, freigegeben oder veraltet properties: An die benutzerdefinierte Integration zu sendende Eigenschaften	${MY_STAGE.MY_TASK.input.name} ${MY_STAGE.MY_TASK.input.version} ${MY_STAGE.MY_TASK.input.properties} # Siehe alle Eigenschaften ${MY_STAGE.MY_TASK.input.properties.property1} # Siehe Wert von property1
	Output	properties: Ausgabeeigenschaften aus der Antwort der benutzerdefinierten Integration	${MY_STAGE.MY_TASK.output.properties} # Siehe alle Eigenschaften ${MY_STAGE.MY_TASK.output.properties.property1} # Siehe Wert von property1

Tabelle 5. Automatisieren kontinuierlicher Bereitstellungsaufgaben: Cloud-Vorlagen

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
Cloud-Vorlage
	Input	action: Hierzu gehören createDeployment, updateDeployment, deleteDeployment, rollbackDeployment blueprintInputParams: wird für die Aktionen create deployment und update deployment verwendet allowDestroy: Maschinen können bei der Bereitstellungsaktualisierung gelöscht werden. CREATE_DEPLOYMENT blueprintName: Name der Cloud-Vorlage blueprintVersion: Version der Cloud-Vorlage ODER fileUrl: URL der Remote-Cloud-Vorlagen-YAML nach Auswahl eines GIT-Servers. UPDATE_DEPLOYMENT Alle der folgenden Kombinationen: blueprintName: Name der Cloud-Vorlage blueprintVersion: Version der Cloud-Vorlage ODER fileUrl: URL der Remote-Cloud-Vorlagen-YAML nach Auswahl eines GIT-Servers. ------ deploymentId: ID der Bereitstellung ODER deploymentName: Name der Bereitstellung ------ DELETE_DEPLOYMENT deploymentId: ID der Bereitstellung ODER deploymentName: Name der Bereitstellung ROLLBACK_DEPLOYMENT Alle der folgenden Kombinationen: deploymentId: ID der Bereitstellung ODER deploymentName: Name der Bereitstellung ------ blueprintName: Name der Cloud-Vorlage rollbackVersion: Version, auf die das Rollback durchgeführt werden soll
	Output		Parameter, die an andere Aufgaben oder an die Ausgabe einer Pipeline gebunden werden können: Der Bereitstellungsname kann als ${Stage0.Task0.output.deploymentName} aufgerufen werden Auf die Bereitstellungs-ID kann als ${Stage0.Task0.output.deploymentId} zugegriffen werden Die Bereitstellungsdetails sind ein komplexes Objekt, und auf interne Details kann mithilfe der JSON-Ergebnisse zugegriffen werden. Für den Zugriff auf eine beliebige Eigenschaft verwenden Sie den Punkt-Operator, um der JSON-Hierarchie zu folgen. Um beispielsweise auf die Adresse der Ressource Cloud_Machine_1[0] zuzugreifen, lautet die $-Bindung: ${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].address} Ähnlich gilt für die Konfiguration die $-Bindung: ${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].flavor} In der Automation Pipelines-Benutzeroberfläche können Sie die $-Bindungen für jede Eigenschaft abrufen. Klicken Sie im Eigenschaftsbereich der Aufgabenausgabe auf JSON-AUSGABE ANZEIGEN. Um die $-Bindung zu finden, geben Sie eine beliebige Eigenschaft ein. Klicken Sie auf das Suchsymbol, das die entsprechende $-Bindung anzeigt.

JSON-Beispielausgabe:

Beispielobjekt für Bereitstellungsdetails:

{
	"id": "6a031f92-d0fa-42c8-bc9e-3b260ee2f65b",
	"name": "deployment_6a031f92-d0fa-42c8-bc9e-3b260ee2f65b",
	"description": "Pipeline Service triggered operation",
	"orgId": "434f6917-4e34-4537-b6c0-3bf3638a71bc",
	"blueprintId": "8d1dd801-3a32-4f3b-adde-27f8163dfe6f",
	"blueprintVersion": "1",
	"createdAt": "2020-08-27T13:50:24.546215Z",
	"createdBy": "[email protected]",
	"lastUpdatedAt": "2020-08-27T13:52:50.674957Z",
	"lastUpdatedBy": "[email protected]",
	"inputs": {},
	"simulated": false,
	"projectId": "267f8448-d26f-4b65-b310-9212adb3c455",
	"resources": {
		"Cloud_Machine_1[0]": {
			"id": "/resources/compute/1606fbcd-40e5-4edc-ab85-7b559aa986ad",
			"name": "Cloud_Machine_1[0]",
			"powerState": "ON",
			"address": "10.108.79.33",
			"resourceLink": "/resources/compute/1606fbcd-40e5-4edc-ab85-7b559aa986ad",
			"componentTypeId": "Cloud.vSphere.Machine",
			"endpointType": "vsphere",
			"resourceName": "Cloud_Machine_1-mcm110615-146929827053",
			"resourceId": "1606fbcd-40e5-4edc-ab85-7b559aa986ad",
			"resourceDescLink": "/resources/compute-descriptions/1952d1d3-15f0-4574-ae42-4fbf8a87d4cc",
			"zone": "Automation / Vms",
			"countIndex": "0",
			"image": "ubuntu",
			"count": "1",
			"flavor": "small",
			"region": "MYBU",
			"_clusterAllocationSize": "1",
			"osType": "LINUX",
			"componentType": "Cloud.vSphere.Machine",
			"account": "bha"
		}
	},
	"status": "CREATE_SUCCESSFUL",
	"deploymentURI": "https://api.yourenv.com/automation-ui/#/deployment-ui;ash=/deployment/6a031f92-d0fa-42c8-bc9e-3b260ee2f65b"
}

Tabelle 6. Automatisieren kontinuierlicher Bereitstellungsaufgaben: Kubernetes

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
Kubernetes
	Input	action: Hierzu gehören GET, CREATE, APPLY, DELETE, ROLLBACK timeout: Gesamtzahl der Zeitüberschreitungen für eine beliebige Aktion filterByLabel: Zusätzliche Kennzeichnung zum Filtern für Aktion GET mithilfe von K8S labelSelector: GET, CREATE, DELETE, APPLY yaml: Inline-YAML zum Verarbeiten und Senden an Kubernetes parameters: KEY, VALUE-Paar - Ersetzen von $$KEY durch VALUE im Eingabebereich der Inline-YAML filePath: Relativer Pfad des SCM Git-Endpoints (falls angegeben), aus dem die YAML abgerufen wird scmConstants: KEY, VALUE-Paar - Ersetzen von $${KEY} durch VALUE in der über SCM abgerufenen YAML: continueOnConflict: Wenn diese Option auf „True“ festgelegt ist, wird die Aufgabe bei einer bereits vorhandenen Ressource fortgesetzt. ROLLBACK resourceType: Ressourcentyp für das Rollback resourceName: Ressourcenname für das Rollback namespace: Namespace, in dem das Rollback durchgeführt werden muss revision: Revision, auf die das Rollback erfolgen soll	${MY_STAGE.MY_TASK.input.action} #Bestimmt die durchzuführende Aktion. ${MY_STAGE.MY_TASK.input.timeout} ${MY_STAGE.MY_TASK.input.filterByLabel} ${MY_STAGE.MY_TASK.input.yaml} ${MY_STAGE.MY_TASK.input.parameters} ${MY_STAGE.MY_TASK.input.filePath} ${MY_STAGE.MY_TASK.input.scmConstants} ${MY_STAGE.MY_TASK.input.continueOnConflict} ${MY_STAGE.MY_TASK.input.resourceType} ${MY_STAGE.MY_TASK.input.resourceName} ${MY_STAGE.MY_TASK.input.namespace} ${MY_STAGE.MY_TASK.input.revision}
	Output	response: Erfasst die vollständige Antwort response.<RESOURCE>: Ressource entspricht configMaps, Bereitstellungen, Endpoints, Dateieingängen, Jobs, Namespaces, Pods, replicaSets, replicationControllers, geheimen Schlüsseln, Diensten, statefulSets, Knoten, loadBalancers. response.<RESOURCE>.<KEY>: Schlüssel entspricht entweder apiVersion, Art, Metadaten oder Spezifikation	${MY_STAGE.MY_TASK.output.response} ${MY_STAGE.MY_TASK.output.response.}

Tabelle 7. Integrieren von Entwicklungs-, Test-und Bereitstellungsanwendungen

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
Bamboo
	Input	plan: Name des Plans planKey: Planschlüssel variables: Variablen, die an den Plan übergeben werden parameters: Parameter, die an den Plan übergeben werden	${MY_STAGE.MY_TASK.input.plan} ${MY_STAGE.MY_TASK.input.planKey} ${MY_STAGE.MY_TASK.input.variables} ${MY_STAGE.MY_TASK.input.parameters} # Siehe alle Parameter ${MY_STAGE.MY_TASK.input.parameters.param1} # Siehe Wert von param1
	Output	resultUrl: URL des resultierenden Build buildResultKey: Schlüssel des resultierenden Build buildNumber: Build-Nummer buildTestSummary: Übersicht über die ausgeführten Tests successfulTestCount: Testergebnis übergeben failedTestCount: Testergebnis fehlgeschlagen skippedTestCount: Testergebnis übersprungen artifacts: Artefakte aus dem Build	${MY_STAGE.MY_TASK.output.resultUrl} ${MY_STAGE.MY_TASK.output.buildResultKey} ${MY_STAGE.MY_TASK.output.buildNumber} ${MY_STAGE.MY_TASK.output.buildTestSummary} # Siehe alle Ergebnisse ${MY_STAGE.MY_TASK.output.successfulTestCount} # Siehe spezifische Testanzahl ${MY_STAGE.MY_TASK.output.buildNumber}
Jenkins
	Input	job: Name des Jenkins-Auftrags parameters: Parameter, die an den Auftrag übergeben werden sollen	${MY_STAGE.MY_TASK.input.job} ${MY_STAGE.MY_TASK.input.parameters} # Siehe alle Parameter ${MY_STAGE.MY_TASK.input.parameters.param1} # Siehe Wert eines Parameters
	Output	job: Name des Jenkins-Auftrags jobId: ID des resultierenden Auftrags, z. B. 1234 jobStatus: Status in Jenkins jobResults: Erfassung von Test-/Codeabdeckungsergebnissen jobUrl: URL der resultierenden Auftragsausführung	${MY_STAGE.MY_TASK.output.job} ${MY_STAGE.MY_TASK.output.jobId} ${MY_STAGE.MY_TASK.output.jobStatus} ${MY_STAGE.MY_TASK.output.jobResults} # Siehe alle Ergebnisse ${MY_STAGE.MY_TASK.output.jobResults.junitResponse} # Siehe JUnit-Ergebnisse ${MY_STAGE.MY_TASK.output.jobResults.jacocoRespose} # Siehe JaCoCo-Ergebnisse ${MY_STAGE.MY_TASK.output.jobUrl}
TFS
	Input	projectCollection: Projektsammlung aus TFS teamProject: Ausgewähltes Projekt aus der verfügbaren Erfassung buildDefinitionId: Auszuführende Build-Definitions-ID	${MY_STAGE.MY_TASK.input.projectCollection} ${MY_STAGE.MY_TASK.input.teamProject} ${MY_STAGE.MY_TASK.input.buildDefinitionId}
	Output	buildId: Resultierende Build-ID buildUrl: URL zur Build-Übersicht logUrl: URL zu Protokollen dropLocation: Ablagespeicherort der Artefakte, falls vorhanden	${MY_STAGE.MY_TASK.output.buildId} ${MY_STAGE.MY_TASK.output.buildUrl} ${MY_STAGE.MY_TASK.output.logUrl} ${MY_STAGE.MY_TASK.output.dropLocation}
vRO
	Input	workflowId: ID des auszuführenden Workflows parameters: Parameter, die an den Workflow übergeben werden sollen	${MY_STAGE.MY_TASK.input.workflowId} ${MY_STAGE.MY_TASK.input.parameters}
	Output	workflowExecutionId: ID der Workflow-Ausführung properties: Ausgabeeigenschaften aus der Workflow-Ausführung	${MY_STAGE.MY_TASK.output.workflowExecutionId} ${MY_STAGE.MY_TASK.output.properties}

Tabelle 8. Integrieren anderer Anwendungen über eine API

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
REST
	Input	url: aufzurufende URL action: Zu verwendende HTTP-Methode headers: Zu übergebende HTTP-Header payload: Anforderungsnutzlast fingerprint: Abzugleichender Fingerabdruck, wenn die URL vom Typ „https“ ist allowAllCerts: Wenn „true“ festgelegt ist, kann es sich um ein beliebiges Zertifikat mit einer HTTPS-URL handeln	${MY_STAGE.MY_TASK.input.url} ${MY_STAGE.MY_TASK.input.action} ${MY_STAGE.MY_TASK.input.headers} ${MY_STAGE.MY_TASK.input.payload} ${MY_STAGE.MY_TASK.input.fingerprint} ${MY_STAGE.MY_TASK.input.allowAllCerts}
	Output	responseCode: HTTP-Antwortcodes responseHeaders: HTTP-Antwort-Header responseBody: Zeichenfolgenformat der empfangenen Antwort responseJson: Praktikable Antwort, wenn der „content-type“ application/json lautet	${MY_STAGE.MY_TASK.output.responseCode} ${MY_STAGE.MY_TASK.output.responseHeaders} ${MY_STAGE.MY_TASK.output.responseHeaders.header1} # Siehe Antwortkopfzeile „header1“ ${MY_STAGE.MY_TASK.output.responseBody} ${MY_STAGE.MY_TASK.output.responseJson} # Siehe Antwort als JSON ${MY_STAGE.MY_TASK.output.responseJson.a.b.c} # Siehe verschachteltes Objekt im a.b.c JSON-Pfad in der Antwort
Abfrage
	Input	url: aufzurufende URL headers: Zu übergebende HTTP-Header exitCriteria: Kriterien, die erfüllt werden müssen, damit die Aufgabe erfolgreich ist oder fehlschlägt. Ein Schlüssel-Wert-Paar aus „success“ → Ausdruck, „failure“ → Ausdruck: pollCount: Anzahl der auszuführenden Iterationen. Ein Automation Pipelines-Administrator kann die Abrufanzahl auf maximal 10000 festlegen. pollIntervalSeconds: Anzahl der zu wartenden Sekunden zwischen jeder Iteration. Das Abfrageintervall muss größer oder gleich 60 Sekunden sein. ignoreFailure: Wenn auf „true“ festgelegt, werden Fehler der Zwischenantwort ignoriert fingerprint: Abzugleichender Fingerabdruck, wenn die URL vom Typ „https“ ist allowAllCerts: Wenn „true“ festgelegt ist, kann es sich um ein beliebiges Zertifikat mit einer HTTPS-URL handeln	${MY_STAGE.MY_TASK.input.url} ${MY_STAGE.MY_TASK.input.headers} ${MY_STAGE.MY_TASK.input.exitCriteria} ${MY_STAGE.MY_TASK.input.pollCount} ${MY_STAGE.MY_TASK.input.pollIntervalSeconds} ${MY_STAGE.MY_TASK.input.ignoreFailure} ${MY_STAGE.MY_TASK.input.fingerprint} ${MY_STAGE.MY_TASK.input.allowAllCerts}
	Output	responseCode: HTTP-Antwortcodes responseBody: Zeichenfolgenformat der empfangenen Antwort responseJson: Praktikable Antwort, wenn der „content-type“ application/json lautet	${MY_STAGE.MY_TASK.output.responseCode} ${MY_STAGE.MY_TASK.output.responseBody} ${MY_STAGE.MY_TASK.output.responseJson} # Refer to response as JSON

Tabelle 9. Ausführen von Remote-Skripts und benutzerdefinierten Skripts

Aufgabe	Scope	Key	Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
PowerShell Um eine PowerShell-Aufgabe ausführen zu können, benötigen Sie Folgendes: Eine aktive Sitzung mit einem Remote-Windows-Host. Wenn Sie beabsichtigen, einen base64-PowerShell-Befehl einzugeben, berechnen Sie zuerst die Gesamtlänge des Befehls. Weitere Informationen finden Sie unter In Automation Pipelines verfügbare Aufgabentypen.
	Eingabe	host: IP-Adresse oder Hostname des Computers username: Benutzername, der zur Verbindung verwendet werden soll password: Kennwort für die Verbindung useTLS: Versuch, eine HTTPS-Verbindung herzustellen trustCert: Wenn auf „true“ festgelegt, wird selbstsignierten Zertifikaten vertraut script: Auszuführendes Skript workingDirectory: Verzeichnispfad, in den vor Skriptausführung gewechselt wird environmentVariables: Ein Schlüssel-Wert-Paar der festzulegenden Umgebungsvariable arguments: Argumente, die an das Skript übergeben werden	${MY_STAGE.MY_TASK.input.host} ${MY_STAGE.MY_TASK.input.username} ${MY_STAGE.MY_TASK.input.password} ${MY_STAGE.MY_TASK.input.useTLS} ${MY_STAGE.MY_TASK.input.trustCert} ${MY_STAGE.MY_TASK.input.script} ${MY_STAGE.MY_TASK.input.workingDirectory} ${MY_STAGE.MY_TASK.input.environmentVariables} ${MY_STAGE.MY_TASK.input.arguments}
	Ausgabe	response: Inhalt der Datei $SCRIPT_RESPONSE_FILE responseFilePath: Wert von $SCRIPT_RESPONSE_FILE exitCode: Exit-Code verarbeiten logFilePath: Pfad zur Datei mit stdout errorFilePath: Pfad zur Datei mit stderr	${MY_STAGE.MY_TASK.output.response} ${MY_STAGE.MY_TASK.output.responseFilePath} ${MY_STAGE.MY_TASK.output.exitCode} ${MY_STAGE.MY_TASK.output.logFilePath} ${MY_STAGE.MY_TASK.output.errorFilePath}
SSH
	Input	host: IP-Adresse oder Hostname des Computers username: Benutzername, der zur Verbindung verwendet werden soll password: Kennwort zur Verbindung (kann optional privateKey verwenden) privateKey: Für die Verbindung zu verwendender privateKey passphrase: Optionale Passphrase zum Entsperren von privateKey script: Auszuführendes Skript workingDirectory: Verzeichnispfad, in den vor Skriptausführung gewechselt wird environmentVariables: Schlüssel-Wert-Paar der festzulegenden Umgebungsvariable	${MY_STAGE.MY_TASK.input.host} ${MY_STAGE.MY_TASK.input.username} ${MY_STAGE.MY_TASK.input.password} ${MY_STAGE.MY_TASK.input.privateKey} ${MY_STAGE.MY_TASK.input.passphrase} ${MY_STAGE.MY_TASK.input.script} ${MY_STAGE.MY_TASK.input.workingDirectory} ${MY_STAGE.MY_TASK.input.environmentVariables}
	Output	response: Inhalt der Datei $SCRIPT_RESPONSE_FILE responseFilePath: Wert von $SCRIPT_RESPONSE_FILE exitCode: Exit-Code verarbeiten logFilePath: Pfad zur Datei mit stdout errorFilePath: Pfad zur Datei mit stderr	${MY_STAGE.MY_TASK.output.response} ${MY_STAGE.MY_TASK.output.responseFilePath} ${MY_STAGE.MY_TASK.output.exitCode} ${MY_STAGE.MY_TASK.output.logFilePath} ${MY_STAGE.MY_TASK.output.errorFilePath}

Vorgehensweise beim Verwenden einer Variablenbindung zwischen Aufgaben

Dieses Beispiel zeigt, wie Sie Variablenbindungen in Ihren Pipeline-Aufgaben verwenden.

Tabelle 10. Syntax-Formatbeispiele

Beispiel	Syntax
Zum Verwenden eines Aufgabenausgabewerts für Pipeline-Benachrichtigungen und Pipeline-Ausgabeeigenschaften	${<Stage Key>.<Task Key>.output.<Task output key>}
Zum Verweisen auf den Wert der vorherigen Aufgabenausgabe als Eingabe für die aktuelle Aufgabe.	${<Previous/Current Stage key>.<Previous task key not in current Task group>.output.<task output key>}

Weitere Informationen

Weitere Informationen zum Binden von Variablen in Aufgaben finden Sie unter:

• Vorgehensweise zum Verwenden von Variablenbindungen in Automation Pipelines-Pipelines
• Vorgehensweise zum Verwenden von Variablenbindungen in einer Bedingungsaufgabe zum Ausführen oder Anhalten einer Pipeline in Automation Pipelines
• In Automation Pipelines verfügbare Aufgabentypen