Avec les variables et les expressions, vous pouvez utiliser des paramètres d'entrée et de sortie avec vos tâches de pipeline. Les paramètres que vous entrez lient votre tâche de pipeline à une ou plusieurs variables, expressions ou conditions, et déterminent le comportement du pipeline lors de son exécution.

Lorsque vous liez des tâches de pipeline, vous pouvez inclure des expressions par défaut et complexes afin que votre pipeline puisse exécuter des solutions de livraison de logiciel simples ou complexes. Pour créer les paramètres dans votre pipeline, cliquez sur l'onglet Entrée ou Sortie et ajoutez une variable en entrant le symbole dollar $ et une expression. Par exemple, ce paramètre est utilisé comme une entrée de tâche qui appelle une URL : ${Stage0.Task3.input.URL}.

Le format des liaisons de variables utilise des composants de syntaxe appelés portées et clés. SCOPE définit le contexte comme entrée ou sortie, et KEY définit les détails. Dans l'exemple de paramètre ${Stage0.Task3.input.URL}, input est SCOPE et l'URL est KEY.

Les propriétés de sortie d'une tâche peuvent être résolues en n'importe quel nombre de niveaux imbriqués de liaison de variable.

Pour en savoir plus sur l'utilisation de liaisons de variables dans des pipelines, consultez Utilisation des liaisons de variables dans les pipelines VMware Code Stream.

Utilisation d'expressions en dollars avec des étendues et des clés pour lier des tâches de pipeline

Vous pouvez lier des tâches de pipeline en utilisant des expressions dans des variables à symbole de dollar. Vous entrez des expressions en tant que ${SCOPE.KEY.<PATH>}.

Dans chaque expression, SCOPE est le contexte que Code Stream utilise pour déterminer le comportement d'une tâche de pipeline. La portée recherche une KEY qui définit les détails de l'action effectuée par la tâche. Lorsque la valeur de KEY est un objet imbriqué, vous pouvez fournir un PATH facultatif.

Ces exemples décrivent SCOPE et KEY, et vous montrent comment les utiliser dans votre pipeline.

Tableau 1. Utilisation de SCOPE et de KEY
SCOPE Objet de l'expression et exemple KEY Utilisation de SCOPE et KEY dans votre pipeline
input

Propriétés d'entrée d'un pipeline :

${input.input1}

Nom de la propriété d'entrée

Pour faire référence à la propriété d'entrée d'un pipeline dans une tâche, utilisez ce format :

tasks:
  mytask:
    type: REST
    input:
      url: ${input.url}
      action: get
input:
  url: https://www.vmware.com
output

Propriétés de sortie d'un pipeline :

${output.output1}

Nom de la propriété de sortie

Pour faire référence à une propriété de sortie afin que le pipeline puisse envoyer une notification, utilisez ce 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

Entrée d'une tâche :

${MY_STAGE.MY_TASK.input.SOMETHING}

Indique l'entrée d'une tâche dans une notification

Lorsqu'un travail Jenkins démarre, il peut faire référence au nom de la tâche déclenchée à partir de l'entrée de la tâche. Dans ce cas, envoyez une notification à l'aide de ce 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

Sortie d'une tâche :

${MY_STAGE.MY_TASK.output.SOMETHING}

Indique la sortie d'une tâche dans une tâche suivante

Pour faire référence à la sortie de la tâche de pipeline 1 dans la tâche 2, utilisez ce 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}

Faire référence à une variable dans un point de terminaison

Pour faire référence à une variable secrète dans un point de terminaison pour mot de passe, utilisez ce format :

---
project: MyProject
kind: ENDPOINT
name: MyJenkinsServer
type: jenkins
properties:
 url: https://jenkins.example.com
 username: jenkinsUser
 password: ${var.jenkinsPassword}
var

Variable :

${var.myVariable}

Faire référence à une variable dans un pipeline

Pour faire référence à une variable dans une URL de pipeline, utilisez ce format :

tasks:
 task1:
  type: REST
  input:
   action: get
   url: ${var.MY_SERVER_URL}
task status

État d'une tâche :

${MY_STAGE.MY_TASK.status}

${MY_STAGE.MY_TASK.statusMessage}

stage status

État d'une étape :

${MY_STAGE.status}

${MY_STAGE.statusMessage}

Expressions par défaut

Vous pouvez utiliser des variables avec des expressions dans votre pipeline. Ce résumé inclut les expressions par défaut que vous pouvez utiliser.

Expression Description
${comments} Commentaires fournis lorsque l'exécution a été demandée.
${duration} Durée de l'exécution du pipeline.
${endTime} Heure de fin de l'exécution du pipeline en UTC, si conclue.
${executedOn} Identique à l'heure de début, l'heure de début de l'exécution du pipeline en UTC.
${executionId} ID de l'exécution du pipeline.
${executionUrl} URL qui permet d'accéder à l'exécution du pipeline dans l'interface utilisateur.
${name} Nom du pipeline.
${requestBy} Nom de l'utilisateur qui a demandé l'exécution.
${stageName} Nom de l'étape actuelle, lorsqu'elle est utilisée dans l'étendue d'une étape.
${startTime} Heure de début de l'exécution du pipeline en UTC.
${status} État de l'exécution.
${statusMessage} Message d'état de l'exécution du pipeline.
${taskName} Nom de la tâche actuelle, lorsqu'elle est utilisée au niveau d'une entrée de tâche ou d'une notification.

Utilisation de SCOPE et KEY dans les types de tâche de pipeline

Vous pouvez utiliser des expressions avec n'importe quel type de tâche de pipeline pris en charge. Utilisez ces exemples comme référence pour voir comment définir SCOPE et KEY, et vérifier la syntaxe. Ces exemples de code utilisent MY_STAGE et MY_TASK comme étape de pipeline et noms de tâches.

Pour en savoir plus sur les types de tâches disponibles, reportez-vous à Types de tâche disponibles dans VMware Code Stream.

Tableau 2. Assemblage de tâches
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
Opération de l'utilisateur
Input

summary : résumé de la demande d'opération d'utilisateur

description : description de la demande d'opération d'utilisateur

approvers : liste des adresses e-mail de l'approbateur, dans lesquelles chaque entrée peut être une variable avec une virgule ou utiliser un point-virgule pour les e-mails séparés

approverGroups : liste des adresses des groupes d'approbateurs pour la plate-forme et l'identité

sendemail : envoie éventuellement une notification par e-mail lors de la demande ou de la réponse lorsqu'elle est définie sur true

expirationInDays : nombre de jours qui représente le délai d'expiration de la demande

${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 : chaîne hexadécimale à 6 chiffres qui représente la demande

respondedBy : nom du compte de la personne qui a approuvé/refusé l'opération d'utilisateur

respondedByEmail : adresse e-mail de la personne qui a répondu

comments : commentaires fournis lors de la réponse

${MY_STAGE.MY_TASK.output.index}

${MY_STAGE.MY_TASK.output.respondedBy}

${MY_STAGE.MY_TASK.output.respondedByEmail}

${MY_STAGE.MY_TASK.output.comments}

Condition
Input

condition : condition à évaluer. Lorsque la condition est évaluée sur true, elle indique que la tâche est terminée, tandis que d'autres réponses font échouer la tâche

${MY_STAGE.MY_TASK.input.condition}

Output

result : résultat lors de l'évaluation

${MY_STAGE.MY_TASK.output.response}

Tableau 3. Tâches de pipeline
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
Pipeline
Input

name : nom du pipeline à exécuter

inputProperties : propriétés d'entrée à transmettre à l'exécution de pipeline imbriquée

${MY_STAGE.MY_TASK.input.name}

${MY_STAGE.MY_TASK.input.inputProperties} # Faire référence à toutes les propriétés

${MY_STAGE.MY_TASK.input.inputProperties.input1} # Faire référence à la valeur de input1

Output

executionStatus : état de l'exécution du pipeline

executionIndex : index de l'exécution du pipeline

outputProperties : propriétés de sortie de l'exécution du pipeline

${MY_STAGE.MY_TASK.output.executionStatus}

${MY_STAGE.MY_TASK.output.executionIndex}

${MY_STAGE.MY_TASK.output.outputProperties} # Faire référence à toutes les propriétés

${MY_STAGE.MY_TASK.output.outputProperties.output1} # Faire référence à la valeur d'output1

Tableau 4. Automatiser les tâches d'intégration continue
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
CI
Input

steps : ensemble de chaînes, qui représentent les commandes à exécuter

export : variables d'environnement à conserver après l'exécution des étapes

artifacts : chemins d'artefacts à conserver dans le chemin partagé

process : ensemble d'éléments de configuration pour le traitement de 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} # Faire référence au chemin d'accès de la première configuration

Output

exports : paire clé-valeur, qui représente les variables d'environnement exportées depuis l'entrée export

artifacts : chemin d'artefacts correctement conservés

processResponse : ensemble de résultats traités pour le process d'entrée

${MY_STAGE.MY_TASK.output.exports} # Faire référence à toutes les exportations

${MY_STAGE.MY_TASK.output.exports.myvar} # Faire référence à la valeur de myvar

${MY_STAGE.MY_TASK.output.artifacts}

${MY_STAGE.MY_TASK.output.processResponse}

${MY_STAGE.MY_TASK.output.processResponse[0].result} # Résultat de la configuration du premier processus

Personnalisé
Input

name : nom de l'intégration personnalisée

version : version de l'intégration personnalisée, publiée ou déconseillée

properties : propriétés à envoyer à l'intégration personnalisée

${MY_STAGE.MY_TASK.input.name}

${MY_STAGE.MY_TASK.input.version}

${MY_STAGE.MY_TASK.input.properties} # Faire référence à toutes les propriétés

${MY_STAGE.MY_TASK.input.properties.property1} # Faire référence à la valeur de property1

Output

properties : propriétés de sortie de la réponse d'intégration personnalisée

${MY_STAGE.MY_TASK.output.properties} # Faire référence à toutes les propriétés

${MY_STAGE.MY_TASK.output.properties.property1} # Faire référence à la valeur de property1

Tableau 5. Automatiser les tâches de déploiement continue : modèle de cloud
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
Modèle de cloud
Input

action : un des éléments createDeployment, updateDeployment, deleteDeployment, rollbackDeployment

blueprintInputParams : utilisé pour les actions Créer un déploiement et Mettre à jour le déploiement

allowDestroy : des machines peuvent être détruites lors du processus de déploiement de la mise à jour.

CREATE_DEPLOYMENT

  • blueprintName : nom du modèle de cloud
  • blueprintVersion : version du modèle de cloud

OU

  • fileUrl : URL du modèle de cloud distant YAML, après la sélection d'un serveur GIT.

UPDATE_DEPLOYMENT

Une de ces combinaisons :

  • blueprintName : nom du modèle de cloud
  • blueprintVersion : version du modèle de cloud

OU

  • fileUrl : URL du modèle de cloud distant YAML, après la sélection d'un serveur GIT.

------

  • deploymentId : ID du déploiement

OU

  • deploymentName: nom du déploiement

------

DELETE_DEPLOYMENT

  • deploymentId : ID du déploiement

OU

  • deploymentName: nom du déploiement

ROLLBACK_DEPLOYMENT

Une de ces combinaisons :

  • deploymentId : ID du déploiement

OU

  • deploymentName: nom du déploiement

------

  • blueprintName : nom du modèle de cloud
  • rollbackVersion : version à restaurer
Output

Paramètres pouvant être liés à d'autres tâches ou à la sortie d'un pipeline :

  • Le nom du déploiement est accessible en tant que ${Stage0.Task0.output.deploymentName}
  • L'ID de déploiement est accessible en tant que ${Stage0.Task0.output.deploymentId}
  • Les détails du déploiement constituent un objet complexe et les détails internes sont accessibles à l'aide des résultats JSON.

Pour accéder à n'importe quelle propriété, utilisez l'opérateur point pour suivre la hiérarchie JSON. Par exemple, pour accéder à l'adresse de la ressource Cloud_Machine_1[0], la liaison $ est :

${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].address}

De même, pour le type, la liaison $ est :

${Stage0.Task0.output.deploymentDetails.resources['Cloud_Machine_1[0]'].flavor}

Dans l'interface utilisateur de Code Stream, vous pouvez obtenir les liaisons $ pour n'importe quelle propriété.

  1. Dans la zone de la propriété de sortie de la tâche, cliquez sur EXAMINER LE RÉSULTAT JSON.
  2. Pour trouver la liaison $, entrez n'importe quelle propriété.
  3. Cliquez sur l'icône de recherche, qui affiche la liaison $ correspondante.

Exemple de sortie JSON :

Exemple d'objet de détails de déploiement :

{
	"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"
}
Tableau 6. Automatiser les tâches de déploiement continues : Kubernetes
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
Kubernetes
Input

action : une des opérations GET, CREATE, APPLY, DELETE, ROLLBACK

  • timeout : délai d'expiration global d'une action
  • filterByLabel : étiquette supplémentaire pour filtrer l'action GET avec K8S labelSelector

GET, CREATE, DELETE, APPLY

  • yaml : YAML en ligne à traiter et à envoyer à Kubernetes
  • parameters : paire KEY, VALUE - Remplacer $$KEY par VALUE dans la zone d'entrée YAML en ligne
  • filePath : chemin d'accès relatif à partir du point de terminaison Git SCM, s'il est fourni, à partir duquel extraire le YAML
  • scmConstants : paire KEY, VALUE - Remplacer $${KEY} par VALUE dans le YAML extrait sur SCM.
  • continueOnConflict : lorsqu'elle est définie sur true, si une ressource est déjà présente, la tâche se poursuit.

ROLLBACK

  • resourceType : type de ressource à restaurer
  • resourceName : nom de la ressource à restaurer
  • namespace : espace de noms dans lequel la restauration doit être effectuée
  • revision : révision à restaurer

${MY_STAGE.MY_TASK.input.action} #Détermine l'action à effectuer.

${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 : capture la réponse complète

response.<RESOURCE> : ressource correspond à configMaps, deployments, endpoints, ingresses, jobs, namespaces, pods, replicaSets, replicationControllers, secrets, services, statefulSets, nodes, loadBalancers.

response.<RESOURCE>.<KEY> : la clé correspond à apiVersion, kind, metadata, spec

${MY_STAGE.MY_TASK.output.response}

${MY_STAGE.MY_TASK.output.response.}

Tableau 7. Intégrer des applications de développement, de test et de déploiement
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
Bamboo
Input

plan : nom du plan

planKey : clé du plan

variables : variables à transmettre au plan

parameters : paramètres à transmettre au 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} # Faire référence à tous les paramètres

${MY_STAGE.MY_TASK.input.parameters.param1} # Faire référence à la valeur de param1

Output

resultUrl : URL de la build résultante

buildResultKey : clé de la build résultante

buildNumber : numéro de la build

buildTestSummary : résumé de l'exécution des tests

successfulTestCount : résultat du test transmis

failedTestCount : résultat du test ayant échoué

skippedTestCount : résultat du test ignoré

artifacts: artifacts de la 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} # Faire référence à tous les résultats

${MY_STAGE.MY_TASK.output.successfulTestCount} # Faire référence à un nombre de tests spécifique

${MY_STAGE.MY_TASK.output.buildNumber}

Jenkins
Input

job : nom du travail Jenkins

parameters : paramètres à transmettre à la tâche

${MY_STAGE.MY_TASK.input.job}

${MY_STAGE.MY_TASK.input.parameters} # Faire référence à tous les paramètres

${MY_STAGE.MY_TASK.input.parameters.param1} # Faire référence à la valeur d'un paramètre

Output

job : nom du travail Jenkins

jobId : ID du travail résultant, tel que 1234

jobStatus : état dans Jenkins

jobResults : collecte des résultats de la couverture de test/code

jobUrl : URL de l'exécution de la tâche résultante

${MY_STAGE.MY_TASK.output.job}

${MY_STAGE.MY_TASK.output.jobId}

${MY_STAGE.MY_TASK.output.jobStatus}

${MY_STAGE.MY_TASK.output.jobResults} # Faire référence à tous les résultats

${MY_STAGE.MY_TASK.output.jobResults.junitResponse} # Faire référence aux résultats JUnit

${MY_STAGE.MY_TASK.output.jobResults.jacocoRespose} # Faire référence aux résultats JaCoCo

${MY_STAGE.MY_TASK.output.jobUrl}

TFS
Input

projectCollection : collection de projets depuis TFS

teamProject : projet sélectionné dans la collection disponible

buildDefinitionId : ID de définition de build à exécuter

${MY_STAGE.MY_TASK.input.projectCollection}

${MY_STAGE.MY_TASK.input.teamProject}

${MY_STAGE.MY_TASK.input.buildDefinitionId}

Output

buildId : ID de build résultant

buildUrl : URL pour consulter le résumé de la build

logUrl : URL pour consulter les journaux

dropLocation : emplacement cible des artefacts, le cas échéant

${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 du workflow à exécuter

parameters : paramètres à transmettre au workflow

${MY_STAGE.MY_TASK.input.workflowId}

${MY_STAGE.MY_TASK.input.parameters}

Output

workflowExecutionId : ID de l'exécution du workflow

properties : propriétés de sortie de l'exécution du workflow

${MY_STAGE.MY_TASK.output.workflowExecutionId}

${MY_STAGE.MY_TASK.output.properties}

Tableau 8. Intégrer d'autres applications via une API
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
REST
Input

url : URL à appeler

action : méthode HTTP à utiliser

headers : en-têtes HTTP à transmettre

payload : charge utile de la demande

fingerprint : empreinte digitale à faire correspondre si l'URL est https

allowAllCerts : lorsque la valeur est définie sur true, il peut s'agir de n'importe quel certificat disposant de l'URL 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 : codes de réponse HTTP

responseHeaders : en-têtes de réponse HTTP

responseBody : format de chaîne de la réponse reçue

responseJson : réponse transversale si content-type est application/json

${MY_STAGE.MY_TASK.output.responseCode}

${MY_STAGE.MY_TASK.output.responseHeaders}

${MY_STAGE.MY_TASK.output.responseHeaders.header1} # Faire référence à l'en-tête de réponse « header1 »

${MY_STAGE.MY_TASK.output.responseBody}

${MY_STAGE.MY_TASK.output.responseJson} # Faire référence à la réponse JSON

${MY_STAGE.MY_TASK.output.responseJson.a.b.c} # Faire référence à l'objet imbriqué suivant le chemin d'accès a.b.c JSON dans la réponse

Interrogation
Input

url : URL à appeler

headers : en-têtes HTTP à transmettre

exitCriteria : critères à respecter pour que la tâche aboutisse ou échoue. Une paire clé-valeur de « success » → expression, « failure » → Expression :

pollCount : nombre d'itérations à effectuer

pollIntervalSeconds : nombre de secondes à attendre entre chaque itération

ignoreFailure : lorsque la valeur est définie sur true, ignore les échecs de réponse intermédiaire

fingerprint : empreinte digitale à faire correspondre si l'URL est https

allowAllCerts : lorsque la valeur est définie sur true, il peut s'agir de n'importe quel certificat disposant de l'URL 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 : codes de réponse HTTP

responseBody : format de chaîne de la réponse reçue

responseJson : réponse transversale si content-type est application/json

${MY_STAGE.MY_TASK.output.responseCode}

${MY_STAGE.MY_TASK.output.responseBody}

${MY_STAGE.MY_TASK.output.responseJson} # Refer to response as JSON

Tableau 9. Exécuter des scripts distants et définis par l'utilisateur
Type de tâche Scope Key Utilisation de SCOPE et KEY dans la tâche
PowerShell
Input

host : adresse IP ou nom de domaine complet de la machine

username : nom d'utilisateur à utiliser pour la connexion

password : mot de passe à utiliser pour se connecter

useTLS : tentative de connexion https

trustCert : lorsque la valeur est définie sur true, approuve les certificats auto-signés

script : script à exécuter

workingDirectory : chemin d'accès au répertoire vers lequel basculer avant d'exécuter le script

environmentVariables : paire clé-valeur de variable d'environnement à définir

arguments : arguments à passer au script

${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 : contenu du fichier $SCRIPT_RESPONSE_FILE

responseFilePath : valeur de $SCRIPT_RESPONSE_FILE

exitCode : code de sortie du processus

logFilePath : chemin d'accès au fichier contenant stdout

errorFilePath : chemin d'accès au fichier contenant 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 : adresse IP ou nom de domaine complet de la machine

username : nom d'utilisateur à utiliser pour la connexion

password : mot de passe à utiliser pour se connecter (si vous le souhaitez, vous pouvez utiliser privateKey)

privateKey : PrivateKey à utiliser pour se connecter

passphrase : phrase secrète facultative pour déverrouiller privateKey

script : script à exécuter

workingDirectory : chemin d'accès au répertoire vers lequel basculer avant d'exécuter le script

environmentVariables : paire clé-valeur de la variable d'environnement à définir

${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 : contenu du fichier $SCRIPT_RESPONSE_FILE

responseFilePath : valeur de $SCRIPT_RESPONSE_FILE

exitCode : code de sortie du processus

logFilePath : chemin d'accès au fichier contenant stdout

errorFilePath : chemin d'accès au fichier contenant 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}

Utilisation d'une liaison de variable entre des tâches

Cet exemple montre comment utiliser des liaisons de variables dans vos tâches de pipeline.

Tableau 10. Exemples de formats de syntaxe
Exemple Syntaxe
Pour utiliser une valeur de sortie de tâche pour les notifications de pipeline et les propriétés de sortie de pipeline ${<Stage Key>.<Task Key>.output.<Task output key>}
Pour faire référence à la valeur de sortie de la tâche précédente comme entrée de la tâche actuelle ${<Previous/Current Stage key>.<Previous task key not in current Task group>.output.<task output key>}

Pour en savoir plus

Pour plus d'informations sur la liaison de variables, reportez-vous à :