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.

Wenn Sie Pipeline-Aufgaben aneinander binden, können Sie Standard- und komplexe Ausdrücke einschließen, damit 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.

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.

In jedem Ausdruck ist SCOPE der Kontext, den Code Stream verwendet, um das Verhalten einer Pipeline-Aufgabe zu ermitteln. 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.

Diese Beispiele beschreiben SCOPE und KEY und zeigen Ihnen, 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 sich auf eine Ausgabeeigenschaft zu beziehen, sodass die Pipeline eine Benachrichtigung senden kann, verwenden Sie folgendes 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 Kennwortfeld 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 beim Anfordern der Ausführung angegeben wurden.
${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-Aufgabentypen

Sie können Ausdrücke mit einem der unterstützten Pipeline-Aufgabentypen verwenden. Verwenden Sie diese Beispiele als Referenz, um zu sehen, wie Sie SCOPE und KEY definieren, und prüfen Sie die Syntax. Diese Codebeispiele verwenden MY_STAGE und MY_TASK in den Bereitstellungs- und Aufgabennamen der Pipeline.

Weitere Informationen zu den verfügbaren Aufgabentypen finden Sie unter In VMware Code Stream verfügbare Aufgabentypen.

Tabelle 2. Weitergeben von Aufgaben
Aufgabentyp 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: 6-stellige 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
Aufgabentyp 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 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
Aufgabentyp 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. Integrieren von Entwicklungs-, Test-und Bereitstellungsanwendungen
Aufgabentyp 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 6. Integrieren anderer Anwendungen über eine API
Aufgabentyp Scope Key Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
REST
Input

url: URL zum Aufrufen

action: Zu verwendende HTTP-Methode

headers: Zu übergebende HTTP-Header

payload: Anforderungsnutzlast

fingerprint: Abzugleichender Fingerabdruck, wenn die URL vom Typ „https“ ist

allowAllCerts: Wenn auf „true“ festgelegt, wird jedes Zertifikat zugelassen, wenn die URL vom Typ „https“ ist

${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: URL zum Aufrufen

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

pollIntervalSeconds: Anzahl der zu wartenden Sekunden zwischen jeder Iteration

ignoreFailure: Wenn auf „true“ festgelegt, werden Fehler der Zwischenantwort ignoriert

fingerprint: Abzugleichender Fingerabdruck, wenn die URL vom Typ „https“ ist

allowAllCerts: Wenn auf „true“ festgelegt, ist jedes Zertifikat zulässig, wenn die URL vom Typ „https“ ist

${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 7. Ausführen von Remote-Skripts und benutzerdefinierten Skripts
Aufgabentyp Scope Key Vorgehensweise zum Verwenden von SCOPE und KEY in der Aufgabe
PowerShell
Input

host: IP-Adresse oder Hostname des Computers

username: Benutzername für die Verbindung

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}

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}

SSH
Input

host: IP-Adresse oder Hostname des Computers

username: Benutzername für die Verbindung

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 8. 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 finden Sie unter: