Welche Variablen und Ausdrücke kann ich beim Binden von Pipelineaufgaben in Code Stream verwenden?

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 Code Stream-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 Code Stream 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 Code Stream 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 Code Stream-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:

Die JSON-Ausgabe enthält eine Pfadsuche, in der Sie nach Begriffen wie address suchen können, und Code Stream zeigt die vollständige Definition für die Bindung an.

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 Code Stream-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 Code Stream 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: