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 VMware 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:
   - user@example.org
   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:
    - user@example.org
    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 VMware 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.

  1. Klicken Sie im Eigenschaftsbereich der Aufgabenausgabe auf JSON-AUSGABE ANZEIGEN.
  2. Um die $-Bindung zu finden, geben Sie eine beliebige Eigenschaft ein.
  3. 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": "user@vmware.com",
	"lastUpdatedAt": "2020-08-27T13:52:50.674957Z",
	"lastUpdatedBy": "user@vmware.com",
	"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 VMware 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: