Welke variabelen en expressies kan ik gebruiken bij het binden van pijplijntaken in Code Stream?

Pijplijnen kunnen eenvoudige of complexe softwareleveringsoplossingen uitvoeren

Wanneer u pijplijntaken aan elkaar bindt, kunt u standaard- en complexe expressies opnemen. Als gevolg hiervan kan uw pijplijn eenvoudige of complexe softwareleveringsoplossingen uitvoeren.

Als u de parameters in uw pijplijn wilt maken, klikt u op het tabblad Invoer of Uitvoer en voegt u een variabele toe door het dollarteken $ en een expressie in te voeren. Deze parameter wordt bijvoorbeeld gebruikt als taakinvoer die een URL aanroept: ${Stage0.Task3.input.URL}.

De indeling voor variabele bindingen maakt gebruik van syntaxisonderdelen die scopes en sleutels worden genoemd. De SCOPE definieert de context als invoer of uitvoer en de KEY definieert de details. In het voorbeeld van de parameter ${Stage0.Task3.input.URL} is de input de SCOPE en de URL de KEY.

Uitvoereigenschappen van elke taak kunnen worden omgezet in elk aantal geneste niveaus van een variabelebinding.

Zie Hoe gebruik ik variabele bindingen in Code Stream-pijplijnen? voor meer informatie over het gebruik van variabele bindingen in pijplijnen.

Dollarexpressies gebruiken met bereiken en sleutels om pijplijntaken te binden

U kunt pijplijntaken samenbinden door expressies in dollartekenvariabelen te gebruiken. U voert expressies in als ${SCOPE.KEY.<PATH>}.

Om het gedrag van een pijplijntaak te bepalen, is in elke expressie SCOPE de context die Code Stream gebruikt. Het bereik zoekt naar een KEY, waarbij de details worden gedefinieerd voor de actie die de taak uitvoert. Wanneer de waarde voor KEY een genest object is, kunt u een optioneel PATH opgeven.

In deze voorbeelden worden SCOPE en KEY beschreven, en wordt uitgelegd hoe u ze in uw pijplijn kunt gebruiken.

Tabel 1. SCOPE en KEY gebruiken
SCOPE	Doel van expressie en voorbeeld	KEY	Hoe u SCOPE en KEY in uw pijplijn kunt gebruiken
invoer	Invoereigenschappen van een pijplijn: `${input.input1}`	Naam van de invoereigenschap	Als u wilt verwijzen naar de invoereigenschap van een pijplijn in een taak gebruikt u de volgende indeling: tasks: mytask: type: REST input: url: ${input.url} action: get input: url: https://www.vmware.com
uitvoer	Uitvoereigenschappen van een pijplijn: `${output.output1}`	Naam van de uitvoereigenschap	Als u wilt verwijzen naar een uitvoereigenschap voor het verzenden van een melding, gebruikt u deze indeling: notifications: email: - endpoint: MyEmailEndpoint subject: "Deployment Successful" event: COMPLETED to: - [email protected] body: \| Pipeline deployed the service successfully. Refer ${output.serviceURL}
taakinvoer	Taakinvoer: `${MY_STAGE.MY_TASK.input.SOMETHING}`	Geeft de invoer van een taak in een melding aan	Wanneer een Jenkins-taak wordt gestart, kan deze verwijzen naar de naam van de taak die wordt geactiveerd op basis van de taakinvoer. In dit geval verzendt u een melding met de volgende indeling: 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}.
taakuitvoer	Taakuitvoer: `${MY_STAGE.MY_TASK.output.SOMETHING}`	Geeft de uitvoer van een taak in een volgende taak aan	Als u wilt verwijzen naar de uitvoer van pijplijntaak 1 in taak 2, gebruikt u de volgende indeling: 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	Variabele: `${var.myVariable}`	Verwijst naar variabele in een eindpunt	Als u wilt verwijzen naar een geheime variabele in een eindpunt voor een wachtwoord, gebruikt u de volgende indeling: --- project: MyProject kind: ENDPOINT name: MyJenkinsServer type: jenkins properties: url: https://jenkins.example.com username: jenkinsUser password: ${var.jenkinsPassword}
var	Variabele: `${var.myVariable}`	Verwijzen naar variabele in een pijplijn	Als u naar de variabele in een pijplijn-URL wilt verwijzen, gebruikt u de volgende indeling: tasks: task1: type: REST input: action: get url: ${var.MY_SERVER_URL}
taakstatus	Status van een taak: `${MY_STAGE.MY_TASK.status}` `${MY_STAGE.MY_TASK.statusMessage}`
fasestatus	Status van een fase: `${MY_STAGE.status}` `${MY_STAGE.statusMessage}`

Standaardexpressies

U kunt variabelen met expressies gebruiken in uw pijplijn. Deze samenvatting bevat de standaardexpressies die u kunt gebruiken.


Expressie	Beschrijving
`${comments}`	Opmerkingen die worden geleverd bij de aanvraag voor pijplijnuitvoering.
`${duration}`	Duur van de uitvoering van de pijplijn.
`${endTime}`	Eindtijd van de pijplijnuitvoering in UTC, indien voltooid.
`${executedOn}`	Hetzelfde als de begintijd: begintijd van de pijplijnuitvoering in UTC.
`${executionId}`	ID van de uitvoering van de pijplijn.
`${executionUrl}`	URL die naar de pijplijn wordt uitgevoerd in de gebruikersinterface.
`${name}`	Naam van de pijplijn.
`${requestBy}`	Naam van de gebruiker die de uitvoering heeft aangevraagd.
`${stageName}`	Naam van de huidige fase, wanneer deze wordt gebruikt in het bereik van een fase.
`${startTime}`	Begintijd van de pijplijnuitvoering in UTC.
`${status}`	Status van de uitvoering.
`${statusMessage}`	Statusbericht van de uitvoering van de pijplijn.
`${taskName}`	Naam van de huidige taak, wanneer deze wordt gebruikt bij een taakinvoer of -melding.

SCOPE en KEY gebruiken in pijplijntaken

U kunt expressies gebruiken met een van de ondersteunde pijplijntaken. In deze voorbeelden ziet u hoe u SCOPE en KEY kunt definiëren en de syntaxis kunt bevestigen. De codevoorbeelden gebruiken MY_STAGE en MY_TASK als de pijplijnfase en taaknamen.

Zie Welke typen taken zijn beschikbaar in Code Stream voor meer informatie over beschikbare taken.

Tabel 2. Gating-taken
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
Gebruikersbewerking
	Input	`summary`: samenvatting van de aanvraag voor de gebruikersbewerking `description`: beschrijving van de aanvraag voor de gebruikersbewerking `approvers`: lijst met e-mailadressen van goedkeurder, waarbij elke vermelding een variabele met een komma kan zijn of een puntkomma voor afzonderlijke e-mails kan gebruiken `approverGroups`: lijst met adressen van goedkeurdersgroep voor het platform en de identiteit `sendemail`: stuurt desgewenst een e-mailmelding op aanvraag of antwoord wanneer dit is ingesteld op waar `expirationInDays`: aantal dagen dat de vervaltijd van de aanvraag vertegenwoordigt	`${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`: hexadecimale tekenreeks van 6 cijfers die de aanvraag vertegenwoordigt `respondedBy`: accountnaam van de persoon die de Gebruikersbewerking heeft goedgekeurd/afgewezen `respondedByEmail`: e-mailadres van de persoon die heeft gereageerd `comments`: opmerkingen opgegeven tijdens reactie	`${MY_STAGE.MY_TASK.output.index}` `${MY_STAGE.MY_TASK.output.respondedBy}` `${MY_STAGE.MY_TASK.output.respondedByEmail}` `${MY_STAGE.MY_TASK.output.comments}`
Voorwaarde
	Input	`condition`: voorwaarde om te evalueren. Wanneer de voorwaarde resulteert in waar, wordt de taak als voltooid gemarkeerd, terwijl andere antwoorden de taak laten mislukken	`${MY_STAGE.MY_TASK.input.condition}`
	Output	`result`: resultaat bij evaluatie	`${MY_STAGE.MY_TASK.output.response}`

Tabel 3. Pijplijntaken
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
Pijplijn
	Input	`name`: naam van de pijplijn die moet worden uitgevoerd `inputProperties`: invoereigenschappen die worden doorgegeven aan de uitvoering van de geneste pijplijn	`${MY_STAGE.MY_TASK.input.name}` `${MY_STAGE.MY_TASK.input.inputProperties}` # verwijzen naar alle eigenschappen `${MY_STAGE.MY_TASK.input.inputProperties.input1}` # verwijzen naar de waarde van input1
	Output	`executionStatus`: status van de pijplijnuitvoering `executionIndex`: index van de uitvoering van de pijplijn `outputProperties`: uitvoereigenschappen van de uitvoering van de pijplijn	`${MY_STAGE.MY_TASK.output.executionStatus}` `${MY_STAGE.MY_TASK.output.executionIndex}` `${MY_STAGE.MY_TASK.output.outputProperties}` # verwijzen naar alle eigenschappen `${MY_STAGE.MY_TASK.output.outputProperties.output1}` # verwijzen naar de waarde van output1

Tabel 4. Taken voor continue integratie automatiseren
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
CI
	Input	`steps`: een reeks tekenreeksen, waarmee opdrachten worden weergegeven die moeten worden uitgevoerd `export`: omgevingsvariabelen die behouden moeten worden na het uitvoeren van de stappen `artifacts`: paden van artefacten die behouden moeten blijven in het gedeelde pad `process`: reeks configuratie-elementen voor JUnit-, JaCoCo-, Checkstyle-, FindBugs-verwerking	`${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}` # verwijzen naar het pad van de eerste configuratie
	Output	`exports`: sleutelwaardepaar, dat de geëxporteerde omgevingsvariabelen van de invoer `export` vertegenwoordigt `artifacts`: pad van goed bewaarde artefacten `processResponse`: reeks verwerkte resultaten voor de invoer `process`	`${MY_STAGE.MY_TASK.output.exports}` # verwijzen naar alle export `${MY_STAGE.MY_TASK.output.exports.myvar}` # verwijzen naar de waarde van `myvar` `${MY_STAGE.MY_TASK.output.artifacts}` `${MY_STAGE.MY_TASK.output.processResponse}` `${MY_STAGE.MY_TASK.output.processResponse[0].result}` # resultaat van de eerste procesconfiguratie
Custom
	Input	`name`: naam van de custom integratie `version`: een versie van de custom integratie, vrijgegeven of verouderd `properties`: eigenschappen die naar de custom integratie worden verzonden	`${MY_STAGE.MY_TASK.input.name}` `${MY_STAGE.MY_TASK.input.version}` `${MY_STAGE.MY_TASK.input.properties}` # verwijzen naar alle eigenschappen `${MY_STAGE.MY_TASK.input.properties.property1}` # verwijzen naar waarde property1
	Output	`properties`: uitvoereigenschappen van de custom integratiereactie	`${MY_STAGE.MY_TASK.output.properties}` # verwijzen naar alle eigenschappen `${MY_STAGE.MY_TASK.output.properties.property1}` # verwijzen naar waarde property1

Tabel 5. Taken voor continue implementatie automatiseren: cloudsjabloon
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
Cloudsjabloon
	Input	`action`: een van createDeployment, updateDeployment, deleteDeployment, rollbackDeployment `blueprintInputParams`: gebruikt voor de acties Implementatie maken en Implementatie bijwerken `allowDestroy`: machines kunnen worden vernietigd tijdens het updateproces voor implementaties. CREATE_DEPLOYMENT `blueprintName`: naam van de cloudsjabloon `blueprintVersion`: versie van de cloudsjabloon OF `fileUrl`: URL van de externe cloudsjabloon-YAML, na het selecteren van een GIT-server. UPDATE_DEPLOYMENT Een van deze combinaties: `blueprintName`: naam van de cloudsjabloon `blueprintVersion`: versie van de cloudsjabloon OF `fileUrl`: URL van de externe cloudsjabloon-YAML, na het selecteren van een GIT-server. `------` `deploymentId`: ID van de implementatie OF `deploymentName`: naam van de implementatie `------` DELETE_DEPLOYMENT `deploymentId`: ID van de implementatie OF `deploymentName`: naam van de implementatie ROLLBACK_DEPLOYMENT Een van deze combinaties: `deploymentId`: ID van de implementatie OF `deploymentName`: naam van de implementatie `------` `blueprintName`: naam van de cloudsjabloon `rollbackVersion`: versie waarnaar moet worden teruggedraaid
	Output		Parameters die kunnen worden gebonden aan andere taken of aan de uitvoer van een pijplijn: Implementatienaam kan worden benaderd als `${Stage0.Task0.output.deploymentName}` Implementatie-id kan worden benaderd als `${Stage0.Task0.output.deploymentId}` Implementatiedetails is een complex object en interne details kunnen worden geopend met behulp van de JSON-resultaten. Om toegang te krijgen tot een eigenschap, gebruikt u de puntoperator om de JSON-hiërarchie te volgen. Als u bijvoorbeeld toegang wilt tot het adres van resource Cloud_Machine_1[0], is de $-binding als volgt: `${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].address}` Op dezelfde manier is de $-binding voor soort als volgt: `${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].flavor}` In de gebruikersinterface van Code Stream kunt u de $-bindingen voor elke eigenschap verkrijgen. Klik in het eigenschapsgebied voor taakuitvoer op Uitvoer-JSON weergeven. Als u de $-binding wilt vinden, voert u een eigenschap in. Klik op het zoekpictogram, waarin de bijbehorende $-binding wordt weergegeven.

Voorbeeld van JSON-uitvoer:

De JSON-uitvoer bevat een padzoekfunctie waar u naar termen kunt zoeken zoals adres en Code Stream geeft de volledige definitie voor de binding weer.

Voorbeeld van het object Implementatiedetails:

{
	"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"
}

Tabel 6. Taken voor continue implementatie automatiseren: Kubernetes
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
Kubernetes
	Input	`action`: een van GET, CREATE, APPLY, DELETE, ROLLBACK `timeout`: algemene time-out voor acties `filterByLabel`: extra label waarop moet worden gefilterd voor de actie `GET` met behulp van K8S labelSelector: GET, CREATE, DELETE, APPLY `yaml`: inline YAML voor verwerking en verzending naar Kubernetes `parameters`: paar SLEUTEL, WAARDE - vervang `$$KEY` door `WAARDE` in het inline YAML-invoergebied `filePath`: het relatieve pad van het SCM Git-eindpunt, indien opgegeven, vanwaar de YAML moet worden opgehaald `scmConstants`: paar SLEUTEL, WAARDE - vervang `$${KEY}` door `WAARDE` in de YAML die is opgehaald via SCM. `continueOnConflict`: wanneer dit is ingesteld op “waar”, wordt de taak voortgezet als er al een resource is. ROLLBACK `resourceType`: resourcetype om terug te draaien `resourceName`: resourcenaam om terug te draaien `namespace`: naamruimte waar de terugdraaiactie moet worden uitgevoerd `revision`: herziening waarnaar moet worden teruggedraaid	`${MY_STAGE.MY_TASK.input.action}` # Bepaalt de actie die moet worden uitgevoerd. `${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`: hiermee wordt het volledige antwoord vastgelegd `response.<RESOURCE>`: resource komt overeen met configMaps, implementaties, eindpunten, ingresses, taken, naamruimten, pods, replicaSets, replicationControllers, geheimen, services, statefulSets, knooppunten, loadBalancers. `response.<RESOURCE>.<KEY>`: de sleutel komt overeen met een van apiVersion, soort, metagegevens, specificatie	`${MY_STAGE.MY_TASK.output.response}` `${MY_STAGE.MY_TASK.output.response.}`

Tabel 7. Ontwikkelings-, test- en implementatieapplicaties integreren
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
Bamboo
	Input	`plan`: naam van het plan `planKey`: plansleutel `variables`: variabelen die moeten worden doorgegeven aan het plan `parameters`: parameters die moeten worden doorgegeven aan het plan	`${MY_STAGE.MY_TASK.input.plan}` `${MY_STAGE.MY_TASK.input.planKey}` `${MY_STAGE.MY_TASK.input.variables}` `${MY_STAGE.MY_TASK.input.parameters}` # verwijzen naar alle parameters `${MY_STAGE.MY_TASK.input.parameters.param1}` # verwijzen naar de waarde van param1
	Output	`resultUrl`: URL van de resulterende build `buildResultKey`: sleutel van de resulterende build `buildNumber`: buildnummer `buildTestSummary`: samenvatting van de uitgevoerde tests `successfulTestCount`: testresultaat geslaagd `failedTestCount`: testresultaat mislukt `skippedTestCount`: testresultaat overgeslagen `artifacts`: artefacten van de 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}` # verwijzen naar alle resultaten `${MY_STAGE.MY_TASK.output.successfulTestCount}` # verwijzen naar de specifieke testtelling `${MY_STAGE.MY_TASK.output.buildNumber}`
Jenkins
	Input	`job`: naam van de Jenkins-taak `parameters`: parameters die aan de taak moeten worden doorgegeven	`${MY_STAGE.MY_TASK.input.job}` `${MY_STAGE.MY_TASK.input.parameters}` # verwijzen naar alle parameters `${MY_STAGE.MY_TASK.input.parameters.param1}` # verwijzen naar de waarde van een parameter
	Output	`job`: naam van de Jenkins-taak `jobId`: ID van de resulterende taak, zoals 1234 `jobStatus`: status in Jenkins `jobResults`: resultaten van de verzameling van test- en codedekking `jobUrl`: URL van de resulterende taakuitvoering	`${MY_STAGE.MY_TASK.output.job}` `${MY_STAGE.MY_TASK.output.jobId}` `${MY_STAGE.MY_TASK.output.jobStatus}` `${MY_STAGE.MY_TASK.output.jobResults}` # verwijzen naar alle resultaten `${MY_STAGE.MY_TASK.output.jobResults.junitResponse}` # verwijzen naar JUnit-resultaten `${MY_STAGE.MY_TASK.output.jobResults.jacocoRespose}` # verwijzen naar JaCoCo-resultaten `${MY_STAGE.MY_TASK.output.jobUrl}`
TFS
	Input	`projectCollection`: projectverzameling vanuit TFS `teamProject`: geselecteerd project uit de beschikbare verzameling `buildDefinitionId`: definitie-id van de build om uit te voeren	`${MY_STAGE.MY_TASK.input.projectCollection`} `${MY_STAGE.MY_TASK.input.teamProject}` `${MY_STAGE.MY_TASK.input.buildDefinitionId}`
	Output	`buildId`: resulterende build-ID `buildUrl`: URL om samenvatting van build te bezoeken `logUrl`: URL om te bezoeken voor logboeken `dropLocation`: locatie van eventuele artefacten laten vallen	`${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 van de werkstroom die moet worden uitgevoerd `parameters`: parameters die moeten worden doorgegeven aan de werkstroom	`${MY_STAGE.MY_TASK.input.workflowId}` `${MY_STAGE.MY_TASK.input.parameters}`
	Output	`workflowExecutionId`: ID van de uitvoering van de werkstroom `properties`: uitvoereigenschappen van de uitvoering van de werkstroom	`${MY_STAGE.MY_TASK.output.workflowExecutionId}` `${MY_STAGE.MY_TASK.output.properties}`

Tabel 8. Andere applicaties integreren met behulp van een API
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
REST
	Input	`url`: URL die moet worden uitgevoerd `action`: HTTP-methode die moet worden gebruikt `headers`: HTTP-kopteksten om door te geven `payload`: nettolading aanvragen `fingerprint`: vingerafdruk om te koppelen als de URL https is `allowAllCerts`: wanneer ingesteld op Waar, kan elk certificaat zijn met een URL van https	`${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-reactiecode `responseHeaders`: HTTP-reactiekopteksten `responseBody`: indeling tekenreeks van ontvangen reactie `responseJson`: traversable-reactie als het inhoudstype application/json is	`${MY_STAGE.MY_TASK.output.responseCode}` `${MY_STAGE.MY_TASK.output.responseHeaders}` `${MY_STAGE.MY_TASK.output.responseHeaders.header1}` # verwijzen naar de reactiekoptekst 'header1' `${MY_STAGE.MY_TASK.output.responseBody}` `${MY_STAGE.MY_TASK.output.responseJson}` # verwijzen naar reactie als JSON `${MY_STAGE.MY_TASK.output.responseJson.a.b.c}` # verwijzen naar het geneste object na het a.b.c JSON-pad in de reactie
Poll
	Input	`url`: URL die moet worden uitgevoerd `headers`: HTTP-kopteksten om door te geven `exitCriteria`: criteria waaraan moet worden voldaan om de taak te laten slagen of mislukken Een sleutelwaardepaar van 'geslaagd' → Expressie, 'fout' → Expressie `pollCount`: aantal iteraties dat moet worden uitgevoerd. Een Code Stream-beheerder kan het aantal polls instellen op een maximum van 10.000. `pollIntervalSeconds`: aantal seconden dat moet worden gewacht tussen elke iteratie. Het pollinginterval moet 60 seconden of meer zijn. `ignoreFailure`: als dit is ingesteld op waar, worden tussenliggende reactiefouten genegeerd `fingerprint`: vingerafdruk om te koppelen als de URL https is `allowAllCerts`: wanneer ingesteld op Waar, kan elk certificaat zijn met een URL van https	`${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-reactiecode `responseBody`: indeling tekenreeks van ontvangen reactie `responseJson`: traversable-reactie als het inhoudstype application/json is	`${MY_STAGE.MY_TASK.output.responseCode}` `${MY_STAGE.MY_TASK.output.responseBody}` `${MY_STAGE.MY_TASK.output.responseJson} # Refer to response as JSON`

Tabel 9. Externe en door de gebruiker gedefinieerde scripts uitvoeren
Taak	Scope	Key	Hoe kan ik het SCOPE en de KEY in de taak gebruiken?
PowerShell Om een PowerShell-taak uit te voeren, moet u het volgende doen: Een actieve sessie met een externe Windows-host hebben. Als u van plan bent een base64 PowerShell-opdracht in te voeren, berekent u eerst de algemene opdrachtlengte. Zie Welke typen taken zijn beschikbaar in Code Stream voor meer informatie.
	Invoer	`host`: IP-adres of hostnaam van de machine `username`: gebruikersnaam die moet worden gebruikt voor de verbinding `password`: wachtwoord dat moet worden gebruikt om verbinding te maken `useTLS`: https-verbinding proberen `trustCert`: als dit is ingesteld op Waar, vertrouwt u zelfondertekende certificaten `script`: uit te voeren script `workingDirectory`: mappad waarnaar moet worden geschakeld voordat het script wordt uitgevoerd `environmentVariables`: een sleutelwaardepaar van de omgevingsvariabele die u wilt instellen `arguments`: argumenten om aan het script door te geven	`${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}`
	Uitvoer	`response`: inhoud van het bestand $SCRIPT_RESPONSE_FILE `responseFilePath`: waarde van $SCRIPT_RESPONSE_FILE `exitCode`: afsluitcode van het proces `logFilePath`: pad naar bestand met stdout `errorFilePath`: pad naar bestand met 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}`
Secure Shell
	Input	`host`: IP-adres of hostnaam van de machine `username`: gebruikersnaam die moet worden gebruikt voor de verbinding `password`: wachtwoord dat u wilt gebruiken om verbinding te maken (optioneel: privateKey kan ook worden gebruikt) `privateKey`: PrivateKey gebruiken om verbinding te maken `passphrase`: optionele wachtwoordzin om privateKey te ontgrendelen `script`: uit te voeren script `workingDirectory`: mappad waarnaar moet worden geschakeld voordat het script wordt uitgevoerd `environmentVariables`: sleutelwaardepaar van de omgevingsvariabele die moet worden ingesteld	`${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`: inhoud van het bestand $SCRIPT_RESPONSE_FILE `responseFilePath`: waarde van $SCRIPT_RESPONSE_FILE `exitCode`: afsluitcode van het proces `logFilePath`: pad naar bestand met stdout `errorFilePath`: pad naar bestand met 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}`

Een variabelebinding tussen taken gebruiken

In dit voorbeeld ziet u hoe u variabelebindingen in uw pijplijntaken kunt gebruiken.

Tabel 10. Voorbeelden van syntaxisindelingen
Voorbeeld	Syntaxis
Een taakuitvoerwaarde gebruiken voor pijplijnmeldingen en uitvoereigenschappen van de pijplijn	`${<Stage Key>.<Task Key>.output.<Task output key>}`
Als u wilt verwijzen naar de vorige taakuitvoerwaarde als invoer voor de huidige taak	`${<Previous/Current Stage key>.<Previous task key not in current Task group>.output.<task output key>}`

Meer informatie

Voor meer informatie over het binden van variabelen in taken zie: