Share variables across stages in Azure DevOps Pipelines

What is important to mention stageDependencies is not available in condition at stage level. It is aviable in jobs, but not in stage directly (at least at the moment).

stages:
- stage: A
  jobs:
  - job: JA
    steps:
    - script: |
        echo "This is job Foo."
        echo "##vso[task.setvariable variable=doThing;isOutput=true]Yes" #The variable doThing is set to true
      name: DetermineResult
    - script: echo $(DetermineResult.doThing)
      name: echovar
  - job: JA_2
    dependsOn: JA
    condition: eq(dependencies.JA.outputs['DetermineResult.doThing'], 'Yes')
    steps:
    - script: |
        echo "This is job Bar."

#stage B runs if DetermineResult task set doThing variable n stage A
- stage: B
  dependsOn: A
  jobs:
  - job: JB
    condition: eq(stageDependencies.A.JA.outputs['DetermineResult.doThing'], 'Yes') #map doThing and check if true
    variables:
      varFromStageA: $[ stageDependencies.A.JA.outputs['DetermineResult.doThing'] ]
    steps:
    - bash: echo "Hello world stage B first job"
    - script: echo $(varFromStageA)

Jobs can now access variables from previous stages

Output variables are still produced by steps inside of jobs. Instead of referring to dependencies.jobName.outputs['stepName.variableName'], stages refer to stageDependencies.stageName.jobName.outputs['stepName.variableName'].

https://learn.microsoft.com/en-us/azure/devops/release-notes/2020/sprint-168-update#azure-pipelines-1

This is available as of May 4th 2020

Jobs can access output variables from previous stages:

Output variables may now be used across stages in a YAML-based pipeline. This helps you pass useful information, such as a go/no-go decision or the ID of a generated output, from one stage to the next. The result (status) of a previous stage and its jobs is also available.

Output variables are still produced by steps inside of jobs. Instead of referring to dependencies.jobName.outputs['stepName.variableName'], stages refer to stageDependencies.stageName.jobName.outputs['stepName.variableName'].

Note

By default, each stage in a pipeline depends on the one just before it in the YAML file. Therefore, each stage can use output variables from the prior stage. You can alter the dependency graph, which will also alter which output variables are available. For instance, if stage 3 needs a variable from stage 1, it will need to declare an explicit dependency on stage 1.

For stage conditions on Azure DevOps Version Dev17.M153.5 with Agent Version 2.153.1 the following works:

stages:
- stage: A
  jobs:
  - job: JA
    steps:
    - script: |
        echo "This is job Foo."
        echo "##vso[task.setvariable variable=doThing;isOutput=true]Yes" #The variable doThing is set to 'Yes'
      name: DetermineResult

#stage B runs if DetermineResult task set doThing variable on stage A
- stage: B
  dependsOn: A
  condition: eq(dependencies.A.outputs['JA.DetermineResult.doThing'], 'Yes')
  jobs:
  - job: JB
    steps:
    - bash: echo "Hello world stage B first job"

Note: The layout of properties is different on stage compared to job:

dependencies.{stage name}.outputs['{job name}.{script name}.{variable name}']

Note: The expression with 'stageDependencies' failed with the following error message:

An error occurred while loading the YAML build pipeline. Unrecognized value: 'stageDependencies'. Located at position XX within expression: and(always(), eq(stageDependencies.A.outputs['JA.DetermineResult.doThing'], 'Yes')). For more help, refer to https://go.microsoft.com/fwlink/?linkid=842996

Bonus:

See the following documentation on how to access the status of the dependent stages: link

Corresponding documentations:

• Use output variables from tasks
• Stage to stage dependencies

To use the output from a different stage, you must use the syntax depending on whether you're at the stage or job level:

• At the stage level, the format for referencing variables from a different stage is dependencies.STAGE.outputs['JOB.TASK.VARIABLE']. You can use these variables in conditions.
• At the job level, the format for referencing variables from a different stage is stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']

Note: By default, each stage in a pipeline depends on the one just before it in the YAML file. If you need to refer to a stage that isn't immediately prior to the current one, you can override this automatic default by adding a dependsOn section to the stage.

important notice to the solution:

it is only suitable for 1 directly following stage.

assuming you have:

• stageA - sets variable X
• stageB - consumes variable X over stageDependencies - works
• stageC - can't consume variable X unless you specify the dependsOn stageA and stageB.

this is a gotcha i faced recently, the value of variable X consumed by stageC was empty. when you specify dependsOn, you can't just add stageA, it then becomes a parallel stage (what?), so you need to add both stageA and stageB. but such pipeline looks silly.

so i suggest to use artifacts instead. looks like a more robust solution for me.

Yes this is possible, you need stageDependencies like below:

stages:
- stage: Build
  displayName: Build stage
  jobs:
  - job: VersionCheck
    pool:
      vmImage: 'ubuntu-latest'
    displayName: Version Check
    continueOnError: false
    steps:

      - script: |
          echo "##vso[task.setvariable variable=curProjVersion;isOutput=true]1.4.5"
        name: setCurProjVersion
        displayName: "Collect Application Version ID"

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  variables:
    curProjVersion1: $[ stageDependencies.Build.VersionCheck.outputs['setCurProjVersion.curProjVersion'] ]
  jobs:
  - job: 
    steps: 
      - script: |
          echo $(curProjVersion1)

Note that I have changed

$[ dependencies.Build.VersionCheck.outputs['setCurProjVersion.curProjVersion'] ]

TO

$[ stageDependencies.Build.VersionCheck.outputs['setCurProjVersion.curProjVersion'] ]

source: https://jimferrari.com/2023/01/05/pass-variables-across-jobs-and-stages-in-azure-devops-pipelines/

As an update for anyone seeing this question, it seems passing variables between stages has been implemented and should be released in the next couple of weeks.

You can define a global variable and use a Powershell to assign the value of the stage variable to the global variable.

Write-Output ("##vso[task.setvariable variable=globalVar;]$stageVar")

Global variables can either be defined in the yaml itself or in variable groups. Initialise the var with an empty value.

E.g. yaml

  variables:
    globalVar: ''