Met variabelen en expressies kunt u invoerparameters en uitvoerparameters met uw pijplijntaken gebruiken. De parameters die u invoert, binden uw pijplijntaak aan een of meer variabelen, expressies of voorwaarden en bepalen het pijplijngedrag wanneer dit wordt uitgevoerd.
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 Automation Pipelines-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 Automation Pipelines 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 Automation Pipelines 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 cloudsjabloonblueprintVersion: 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 cloudsjabloonblueprintVersion: 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 cloudsjabloonrollbackVersion: 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 Automation Pipelines 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:
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 actiesfilterByLabel: 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 Kubernetesparameters: paar SLEUTEL, WAARDE - vervang $$KEY door WAARDE in het inline YAML-invoergebiedfilePath: het relatieve pad van het SCM Git-eindpunt, indien opgegeven, vanwaar de YAML moet worden opgehaaldscmConstants: 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 draaienresourceName: resourcenaam om terug te draaiennamespace: naamruimte waar de terugdraaiactie moet worden uitgevoerdrevision: 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 Automation Pipelines-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:
|
|
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:
