Definiera variabler

I det vanligaste fallet anger du variablerna och använder dem i YAML-filen. På så sätt kan du spåra ändringar i variabeln i versionskontrollsystemet. Du kan också definiera variabler i användargränssnittet för pipelineinställningar (se fliken Klassisk) och referera till dem i YAML.

Här är ett exempel som visar hur du anger två variabler configuration och platformoch använder dem senare i steg. Om du vill använda en variabel i en YAML-instruktion omsluter du den i $(). Variabler kan inte användas för att definiera en repository i en YAML-instruktion.

# Set variables once
variables:
  configuration: debug
  platform: x64

steps:

# Use them once
- task: MSBuild@1
  inputs:
    solution: solution1.sln
    configuration: $(configuration) # Use the variable
    platform: $(platform)

# Use them again
- task: MSBuild@1
  inputs:
    solution: solution2.sln
    configuration: $(configuration) # Use the variable
    platform: $(platform)

Variabelomfång

I YAML-filen kan du ange en variabel i olika omfång:

• På rotnivå gör du det tillgängligt för alla jobb i pipelinen.
• För att göra den endast tillgänglig för ett visst stadium på fasnivå.
• På jobbnivå gör du det endast tillgängligt för ett visst jobb.

När du definierar en variabel överst i en YAML är variabeln tillgänglig för alla jobb och steg i pipelinen och är en global variabel. Globala variabler som definierats i en YAML visas inte i användargränssnittet för pipelineinställningar.

Variabler på jobbnivå åsidosätter variabler på rot- och stegnivå. Variabler på fasnivå åsidosätter variabler på rotnivå.

variables:
  global_variable: value    # this is available to all jobs

jobs:
- job: job1
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    job_variable1: value1    # this is only available in job1
  steps:
  - bash: echo $(global_variable)
  - bash: echo $(job_variable1)
  - bash: echo $JOB_VARIABLE1 # variables are available in the script environment too

- job: job2
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    job_variable2: value2    # this is only available in job2
  steps:
  - bash: echo $(global_variable)
  - bash: echo $(job_variable2)
  - bash: echo $GLOBAL_VARIABLE

Utdata från båda jobben ser ut så här:

# job1
value 
value1
value1

# job2
value
value2
value

Ange variabler

I föregående exempel följs nyckelordet variables av en lista över nyckel/värde-par. Nycklarna är variabelnamnen och värdena är variabelvärdena.

Det finns en annan syntax som är användbar när du vill använda mallar för variabler eller variabelgrupper.

Med mallar kan variabler definieras i en YAML och ingå i en annan YAML-fil.

Variabelgrupper är en uppsättning variabler som du kan använda i flera pipelines. De gör att du kan hantera och organisera variabler som är gemensamma för olika faser på ett och samma ställe.

Använd den här syntaxen för variabelmallar och variabelgrupper på rotnivån för en pipeline.

I den här alternativa syntaxen tar nyckelordet variables en lista över variabelspecificerare. Variabelspecificerarna är name för en vanlig variabel, group för en variabelgrupp och template för att inkludera en variabelmall. I följande exempel visas alla tre.

variables:
# a regular variable
- name: myvariable
  value: myvalue
# a variable group
- group: myvariablegroup
# a reference to a variable template
- template: myvariabletemplate.yml

Läs mer om återanvändning av variabler med mallar.

Få åtkomst till variabler via miljön

Observera att variabler också görs tillgängliga för skript via miljövariabler. Syntaxen för att använda dessa miljövariabler beror på skriptspråket.

Namnet är versaler och . ersätts med _. Detta infogas automatiskt i processmiljön. Nedan följer några exempel:

• Batch-skript: %VARIABLE_NAME%
• PowerShell-skript: $env:VARIABLE_NAME
• Bash-skript: $VARIABLE_NAME

Med Hjälp av Azure DevOps CLI kan du skapa och uppdatera variabler för pipelinekörningarna i projektet. Du kan också ta bort variablerna om du inte längre behöver dem.

Skapa en variabel | Uppdatera en variabel | Ta bort en variabel

Förutsättningar

• Du har installerat Azure DevOps CLI-tillägget enligt beskrivningen i Kom igång med Azure DevOps CLI.
• Logga in på Azure DevOps med .az login
• För exemplen i den här artikeln anger du standardorganisationen med hjälp av az devops configure --defaults organization=YourOrganizationURL.

Skapa en variabel

Du kan skapa variabler i pipelinen med kommandot az pipelines variable create . Kom igång genom att läsa Kom igång med Azure DevOps CLI.

az pipelines variable create --name
                             [--allow-override {false, true}]
                             [--org]
                             [--pipeline-id]
                             [--pipeline-name]
                             [--project]
                             [--secret {false, true}]
                             [--value]

Parametrar

• name: Krävs. Namnet på variabeln.
• allow-override: Valfritt. Anger om värdet kan anges vid kötid. Godkända värden är falska och sanna.
• org: Url för Azure DevOps-organisationen. Du kan konfigurera standardorganisationen med .az devops configure -d organization=ORG_URL Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config. Exempel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Krävs om pipeline-name inte anges. ID för pipelinen.
• pipeline-name: Krävs om pipeline-ID inte tillhandahålls, men ignoreras om pipeline-id har angetts. Namnet på pipeline.
• project: Projektets namn eller ID. Du kan konfigurera standardprojektet med .az devops configure -d project=NAME_OR_ID Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config.
• hemlighet: Valfritt. Anger om variabelns värde är en hemlighet. Godkända värden är falska och sanna.
• värde: Krävs för icke-hemlig variabel. Variabelns värde. För hemliga variabler, om värdeparametern inte anges, väljs den från miljövariabelns prefix med AZURE_DEVOPS_EXT_PIPELINE_VAR_ eller användaren uppmanas att ange den via standardindata. En variabel med namnet MySecret kan till exempel matas in med hjälp av miljövariabeln AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecret.

Exempel

Följande kommando skapar en variabel i MyFirstProject med namnet Configuration med värdeplattformen i pipelinen med ID 12. Den visar resultatet i tabellformat.

az pipelines variable create --name Configuration --pipeline-id 12 --value platform --project MyFirstProject --output table

Name        Allow Override    Is Secret    Value
----------  ----------------  -----------  --------
Configuration  False             False        platform

Uppdatera en variabel

Du kan uppdatera variabler i pipelinen med kommandot az pipelines variable update . Kom igång genom att läsa Kom igång med Azure DevOps CLI.

az pipelines variable update --name
                             [--allow-override {false, true}]
                             [--new-name]
                             [--org]
                             [--pipeline-id]
                             [--pipeline-name]
                             [--project]
                             [--prompt-value {false, true}]
                             [--secret {false, true}]
                             [--value]

Parametrar

• name: Krävs. Ursprungligt namn på variabeln.
• allow-override: Valfritt. Anger om värdet kan anges vid kötid. Godkända värden är falska och sanna.
• new-name: Valfritt. Ange för att ändra namnet på variabeln.
• org: Url för Azure DevOps-organisationen. Du kan konfigurera standardorganisationen med .az devops configure -d organization=ORG_URL Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config. Exempel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Krävs om pipeline-name inte anges. ID för pipelinen.
• pipeline-name: Krävs om pipeline-ID inte tillhandahålls, men ignoreras om pipeline-id har angetts. Namnet på pipeline.
• project: Projektets namn eller ID. Du kan konfigurera standardprojektet med .az devops configure -d project=NAME_OR_ID Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config.
• prompt-value: Ställ in på true för att uppdatera värdet för en hemlig variabel med hjälp av miljövariabeln eller fråga via standardindata. Godkända värden är falska och sanna.
• hemlighet: Anger om variabelns värde är en hemlighet. Godkända värden är falska och sanna.
• värde: Uppdaterar värdet för variabeln. För hemliga variabler använder du parametern prompt-value för att uppmanas att ange den via standardindata. För icke-interaktiva konsoler kan den hämtas från miljövariabeln med prefixet AZURE_DEVOPS_EXT_PIPELINE_VAR_. En variabel med namnet MySecret kan till exempel matas in med hjälp av miljövariabeln AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecret.

Exempel

Följande kommando uppdaterar konfigurationsvariabeln med det nya värdet config.debug i pipelinen med ID 12. Den anger att variabeln inte är en hemlighet och visar resultatet i tabellformat.

az pipelines variable update --name Configuration --pipeline-id 12 --secret false --value config.debug --output table

Name           Allow Override    Is Secret    Value
-------------  ----------------  -----------  ------------
Configuration  False             False        config.debug

Ta bort en variabel

Du kan ta bort variabler i pipelinen med kommandot az pipelines variable delete . Kom igång genom att läsa Kom igång med Azure DevOps CLI.

az pipelines variable delete --name
                             [--org]
                             [--pipeline-id]
                             [--pipeline-name]
                             [--project]
                             [--yes]

Parametrar

• name: Krävs. Namnet på variabeln som du vill ta bort.
• org: Url för Azure DevOps-organisationen. Du kan konfigurera standardorganisationen med .az devops configure -d organization=ORG_URL Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config. Exempel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Krävs om pipeline-name inte anges. ID för pipelinen.
• pipeline-name: Krävs om pipeline-ID inte tillhandahålls, men ignoreras om pipeline-id har angetts. Namnet på pipeline.
• project: Projektets namn eller ID. Du kan konfigurera standardprojektet med .az devops configure -d project=NAME_OR_ID Krävs om det inte är konfigurerat som standard eller hämtas med hjälp av git config.
• Ja: Valfritt. Uppmanar inte till bekräftelse.

Exempel

Följande kommando tar bort konfigurationsvariabeln från pipelinen med ID 12 och ber inte om bekräftelse.

az pipelines variable delete --name Configuration --pipeline-id 12 --yes

Deleted variable 'Configuration' successfully.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

Ange inte hemliga variabler i YAML-filen. Operativsystem loggar ofta kommandon för de processer som de kör, och du vill inte att loggen ska innehålla en hemlighet som du skickade som indata. Använd skriptets miljö eller mappa variabeln variables i blocket för att skicka hemligheter till din pipeline.

Du måste ange hemliga variabler i pipelineinställningarnas användargränssnitt för din pipeline. Dessa variabler är begränsade till pipelinen där de anges. Du kan också ange hemliga variabler i variabelgrupper.

Följ dessa steg för att ange hemligheter i webbgränssnittet:

1. Gå till sidan Pipelines , välj lämplig pipeline och välj sedan Redigera.
2. Leta upp variablerna för den här pipelinen.
3. Lägg till eller uppdatera variabeln.
4. Välj alternativet för att behålla den här värdehemligheten för att lagra variabeln på ett krypterat sätt.
5. Spara pipelinen.

Hemliga variabler krypteras i vila med en 2048-bitars RSA-nyckel. Hemligheter är tillgängliga på agenten för uppgifter och skript som ska användas. Var försiktig med vem som har åtkomst till att ändra din pipeline.

Till skillnad från en normal variabel dekrypteras de inte automatiskt till miljövariabler för skript. Du måste uttryckligen mappa hemliga variabler.

I följande exempel visas hur du mappar och använder en hemlig variabel som heter mySecret i PowerShell- och Bash-skript. Två globala variabler definieras. GLOBAL_MYSECRET tilldelas värdet för en hemlig variabel mySecretoch GLOBAL_MY_MAPPED_ENV_VAR tilldelas värdet för en icke-hemlig variabel nonSecretVariable. Till skillnad från en vanlig pipelinevariabel finns det ingen miljövariabel som heter MYSECRET.

PowerShell-aktiviteten kör ett skript för att skriva ut variablerna.

• $(mySecret): Detta är en direkt referens till den hemliga variabeln och fungerar.
• $env:MYSECRET: Detta försöker komma åt den hemliga variabeln som en miljövariabel, vilket inte fungerar eftersom hemliga variabler inte automatiskt mappas till miljövariabler.
• $env:GLOBAL_MYSECRET: Detta försöker komma åt den hemliga variabeln via en global variabel, vilket inte heller fungerar eftersom hemliga variabler inte kan mappas på det här sättet.
• $env:GLOBAL_MY_MAPPED_ENV_VAR: Detta kommer åt den icke-hemliga variabeln via en global variabel, som fungerar.
• $env:MY_MAPPED_ENV_VAR: Detta kommer åt den hemliga variabeln via en aktivitetsspecifik miljövariabel, vilket är det rekommenderade sättet att mappa hemliga variabler till miljövariabler.

variables:
 GLOBAL_MYSECRET: $(mySecret) # this will not work because the secret variable needs to be mapped as env
 GLOBAL_MY_MAPPED_ENV_VAR: $(nonSecretVariable) # this works because it's not a secret.

steps:

- powershell: |
    Write-Host "Using an input-macro works: $(mySecret)"
    Write-Host "Using the env var directly does not work: $env:MYSECRET"
    Write-Host "Using a global secret var mapped in the pipeline does not work either: $env:GLOBAL_MYSECRET"
    Write-Host "Using a global non-secret var mapped in the pipeline works: $env:GLOBAL_MY_MAPPED_ENV_VAR" 
    Write-Host "Using the mapped env var for this task works and is recommended: $env:MY_MAPPED_ENV_VAR"
  env:
    MY_MAPPED_ENV_VAR: $(mySecret) # the recommended way to map to an env variable

- bash: |
    echo "Using an input-macro works: $(mySecret)"
    echo "Using the env var directly does not work: $MYSECRET"
    echo "Using a global secret var mapped in the pipeline does not work either: $GLOBAL_MYSECRET"
    echo "Using a global non-secret var mapped in the pipeline works: $GLOBAL_MY_MAPPED_ENV_VAR" 
    echo "Using the mapped env var for this task works and is recommended: $MY_MAPPED_ENV_VAR"
  env:
    MY_MAPPED_ENV_VAR: $(mySecret) # the recommended way to map to an env variable

Utdata från båda aktiviteterna i föregående skript skulle se ut så här:

Using an input-macro works: ***
Using the env var directly does not work:
Using a global secret var mapped in the pipeline does not work either:
Using a global non-secret var mapped in the pipeline works: foo
Using the mapped env var for this task works and is recommended: ***

Du kan också använda hemliga variabler utanför skript. Du kan till exempel mappa hemliga variabler till aktiviteter med hjälp av variables definitionen. Det här exemplet visar hur du använder hemliga variabler $(vmsUser) och $(vmsAdminPass) i en Azure-filkopieringsaktivitet.

variables:
  VMS_USER: $(vmsUser)
  VMS_PASS: $(vmsAdminPass)

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: AzureFileCopy@4
  inputs:
    SourcePath: 'my/path'
    azureSubscription: 'my-subscription'
    Destination: 'AzureVMs'
    storage: 'my-storage'
    resourceGroup: 'my-rg'
    vmsAdminUserName: $(VMS_USER)
    vmsAdminPassword: $(VMS_PASS)

Referenshemlighetsvariabler i variabelgrupper

Det här exemplet visar hur du refererar till en variabelgrupp i YAML-filen och hur du lägger till variabler i YAML. Det finns två variabler som används från variabelgruppen: user och token. Variabeln token är hemlig och mappas till miljövariabeln $env:MY_MAPPED_TOKEN så att den kan refereras till i YAML.

Denna YAML gör ett REST-anrop för att hämta en lista över versioner och matar ut resultatet.

variables: 
- group: 'my-var-group' # variable group
- name: 'devopsAccount' # new variable defined in YAML
  value: 'contoso'
- name: 'projectName' # new variable defined in YAML
  value: 'contosoads'

steps:
- task: PowerShell@2
  inputs:
    targetType: 'inline'
    script: |
        # Encode the Personal Access Token (PAT)
        # $env:USER is a normal variable in the variable group
        # $env:MY_MAPPED_TOKEN is a mapped secret variable
        $base64AuthInfo = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes(("{0}:{1}" -f $env:USER,$env:MY_MAPPED_TOKEN)))

        # Get a list of releases
        $uri = "https://vsrm.dev.azure.com/$(devopsAccount)/$(projectName)/_apis/release/releases?api-version=5.1"

        # Invoke the REST call
        $result = Invoke-RestMethod -Uri $uri -Method Get -ContentType "application/json" -Headers @{Authorization=("Basic {0}" -f $base64AuthInfo)}

        # Output releases in JSON
        Write-Host $result.value
  env:
    MY_MAPPED_TOKEN: $(token) # Maps the secret variable $(token) from my-var-group

Information om hur du anger hemliga variabler med hjälp av Azure DevOps CLI finns i Skapa en variabel eller Uppdatera en variabel.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

Använda utdata i en annan fas

Om du vill använda utdata från en annan fas är stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']formatet för att referera till variabler . På fasnivå, men inte jobbnivå, kan du använda dessa variabler under förhållanden.

Utdatavariabler är endast tillgängliga i nästa nedströmssteg. Om flera steg använder samma utdatavariabel använder du villkoret dependsOn .

stages:
- stage: One
  jobs:
  - job: A
    steps:
    - task: MyTask@1  # this step generates the output variable
      name: ProduceVar  # because we're going to depend on it, we need to name the step

- stage: Two
  dependsOn:
  - One
  jobs:
  - job: B
    variables:
      # map the output variable from A into this job
      varFromA: $[ stageDependencies.One.A.outputs['ProduceVar.MyVar'] ]
    steps:
    - script: echo $(varFromA) # this step uses the mapped-in variable

- stage: Three
  dependsOn:
  - One
  - Two
  jobs:
  - job: C
    variables:
      # map the output variable from A into this job
      varFromA: $[ stageDependencies.One.A.outputs['ProduceVar.MyVar'] ]
    steps:
    - script: echo $(varFromA) # this step uses the mapped-in variable

Du kan också skicka variabler mellan faser med en filinmatning. För att göra det måste du definiera variabler i det andra steget på jobbnivå och sedan skicka variablerna som env: indata.

## script-a.sh
echo "##vso[task.setvariable variable=sauce;isOutput=true]crushed tomatoes"

## script-b.sh
echo 'Hello file version'
echo $skipMe
echo $StageSauce

## azure-pipelines.yml
stages:

- stage: one
  jobs:
  - job: A
    steps:
    - task: Bash@3
      inputs:
          filePath: 'script-a.sh'
      name: setvar
    - bash: |
       echo "##vso[task.setvariable variable=skipsubsequent;isOutput=true]true"
      name: skipstep

- stage: two
  jobs:
  - job: B
    variables:
      - name: StageSauce
        value: $[ stageDependencies.one.A.outputs['setvar.sauce'] ]
      - name: skipMe
        value: $[ stageDependencies.one.A.outputs['skipstep.skipsubsequent'] ]
    steps:
    - task: Bash@3
      inputs:
        filePath: 'script-b.sh'
      name: fileversion
      env:
        StageSauce: $(StageSauce) # predefined in variables section
        skipMe: $(skipMe) # predefined in variables section
    - task: Bash@3
      inputs:
        targetType: 'inline'
        script: |
          echo 'Hello inline version'
          echo $(skipMe) 
          echo $(StageSauce) 

Utdata från faser i föregående pipeline ser ut så här:

Hello inline version
true
crushed tomatoes

Det finns inget az pipelines-kommando som gäller för att använda utdatavariabler från aktiviteter.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

Ange en variabel med jobbomfattning från ett skript

Om du vill ange en variabel från ett skript använder du loggningskommandot task.setvariable . Detta uppdaterar miljövariablerna för efterföljande jobb. Efterföljande jobb har åtkomst till den nya variabeln med makrosyntax och i aktiviteter som miljövariabler.

När issecret är sant sparas värdet för variabeln som hemlighet och maskeras från loggen. Mer information om hemliga variabler finns i loggningskommandon.

steps:
# Create a variable
- bash: |
    echo "##vso[task.setvariable variable=sauce]crushed tomatoes" # remember to use double quotes

# Use the variable
# "$(sauce)" is replaced by the contents of the `sauce` variable by Azure Pipelines
# before handing the body of the script to the shell.
- bash: |
    echo my pipeline variable is $(sauce)

Efterföljande steg kommer också att lägga till pipelinevariabeln i deras miljö. Du kan inte använda variabeln i steget som den har definierats.

steps:
# Create a variable
# Note that this does not update the environment of the current script.
- bash: |
    echo "##vso[task.setvariable variable=sauce]crushed tomatoes"

# An environment variable called `SAUCE` has been added to all downstream steps
- bash: |
    echo "my environment variable is $SAUCE"
- pwsh: |
    Write-Host "my environment variable is $env:SAUCE"

Utdata från föregående pipeline.

my environment variable is crushed tomatoes
my environment variable is crushed tomatoes

Ange en utdatavariabel för flera jobb

Om du vill göra en variabel tillgänglig för framtida jobb måste du markera den som en utdatavariabel med hjälp isOutput=trueav . Sedan kan du mappa den till framtida jobb med hjälp av syntaxen $[] och inkludera det stegnamn som anger variabeln. Utdatavariabler för flera jobb fungerar bara för jobb i samma fas.

Om du vill skicka variabler till jobb i olika steg använder du syntaxen för fasberoenden .

När du skapar en utdatavariabel för flera jobb bör du tilldela uttrycket till en variabel. I denna YAML $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] tilldelas till variabeln $(myVarFromJobA).

jobs:
# Set an output variable from job A
- job: A
  pool:
    vmImage: 'windows-latest'
  steps:
  - powershell: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the value"
    name: setvarStep
  - script: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable into job B
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromJobA: $[ dependencies.A.outputs['setvarStep.myOutputVar'] ]  # map in the variable
                                                                          # remember, expressions require single quotes
  steps:
  - script: echo $(myVarFromJobA)
    name: echovar

Utdata från föregående pipeline.

this is the value
this is the value

Om du ställer in en variabel från en fas till en annan använder du stageDependencies.

stages:
- stage: A
  jobs:
  - job: A1
    steps:
     - bash: echo "##vso[task.setvariable variable=myStageOutputVar;isOutput=true]this is a stage output var"
       name: printvar

- stage: B
  dependsOn: A
  variables:
    myVarfromStageA: $[ stageDependencies.A.A1.outputs['printvar.myStageOutputVar'] ]
  jobs:
  - job: B1
    steps:
    - script: echo $(myVarfromStageA)

Om du ställer in en variabel från en matris eller ett segment måste du inkludera följande för att referera till variabeln när du kommer åt den från ett nedströmsjobb:

• Namnet på jobbet.
• Steget.

jobs:

# Set an output variable from a job with a matrix
- job: A
  pool:
    vmImage: 'ubuntu-latest'
  strategy:
    maxParallel: 2
    matrix:
      debugJob:
        configuration: debug
        platform: x64
      releaseJob:
        configuration: release
        platform: x64
  steps:
  - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the $(configuration) value"
    name: setvarStep
  - bash: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable from the debug job
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromJobADebug: $[ dependencies.A.outputs['debugJob.setvarStep.myOutputVar'] ]
  steps:
  - script: echo $(myVarFromJobADebug)
    name: echovar

jobs:

# Set an output variable from a job with slicing
- job: A
  pool:
    vmImage: 'ubuntu-latest'
    parallel: 2 # Two slices
  steps:
  - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the slice $(system.jobPositionInPhase) value"
    name: setvarStep
  - script: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable from the job for the first slice
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromJobsA1: $[ dependencies.A.outputs['job1.setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromJobsA1)"
    name: echovar

Se till att prefixet jobbnamnet till utdatavariablerna för ett distributionsjobb . I det här fallet är Ajobbnamnet :

jobs:

# Set an output variable from a deployment
- deployment: A
  pool:
    vmImage: 'ubuntu-latest'
  environment: staging
  strategy:
    runOnce:
      deploy:
        steps:
        - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the deployment variable value"
          name: setvarStep
        - bash: echo $(setvarStep.myOutputVar)
          name: echovar

# Map the variable from the job for the first slice
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromDeploymentJob: $[ dependencies.A.outputs['A.setvarStep.myOutputVar'] ]
  steps:
  - bash: "echo $(myVarFromDeploymentJob)"
    name: echovar

Det finns inget az pipelines-kommando som gäller för att ange variabler i skript.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

Du kan ange en variabel med hjälp av ett uttryck. Vi har redan stött på ett fall av detta för att ange en variabel till utdata från ett annat från ett tidigare jobb.

- job: B
  dependsOn: A
  variables:
    myVarFromJobsA1: $[ dependencies.A.outputs['job1.setvarStep.myOutputVar'] ] # remember to use single quotes

Du kan använda något av de uttryck som stöds för att ange en variabel. Här är ett exempel på hur du ställer in en variabel som ska fungera som en räknare som börjar vid 100, ökas med 1 för varje körning och återställs till 100 varje dag.

jobs:
- job:
  variables:
    a: $[counter(format('{0:yyyyMMdd}', pipeline.startTime), 100)]
  steps:
  - bash: echo $(a)

Mer information om räknare, beroenden och andra uttryck finns i uttryck.

Det finns inget az pipelines-kommando som gäller för att ange variabler med hjälp av uttryck.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

Om en variabel visas i blocket för variables en YAML-fil är dess värde fast och kan inte åsidosättas vid kötid. Bästa praxis är att definiera dina variabler i en YAML-fil, men det finns tillfällen då detta inte är meningsfullt. Du kanske till exempel vill definiera en hemlig variabel och inte ha variabeln exponerad i YAML. Eller så kan du behöva ange ett variabelvärde manuellt under pipelinekörningen.

Du har två alternativ för att definiera kötidsvärden. Du kan definiera en variabel i användargränssnittet och välja alternativet Låt användare åsidosätta det här värdet när de kör den här pipelinen , eller så kan du använda körningsparametrar i stället. Om din variabel inte är en hemlighet är det bästa sättet att använda körningsparametrar.

Om du vill ange en variabel i kö lägger du till en ny variabel i pipelinen och väljer alternativet åsidosättning.

Om du vill tillåta att en variabel anges vid kötid kontrollerar du att variabeln inte också visas i blocket för variables en pipeline eller ett jobb. Om du definierar en variabel i både variabelblocket för en YAML och i användargränssnittet har värdet i YAML prioritet.

Om du vill välja vilka variabler som ska kunna ställas in vid kötid med hjälp av Azure DevOps CLI läser du Skapa en variabel eller Uppdatera en variabel.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.

När du anger en variabel med samma namn i flera definitionsområden gäller följande prioritet (högsta prioritet först).

1. Variabel på jobbnivå som anges i YAML-filen
2. Variabel på fasnivå som anges i YAML-filen
3. Variabel på pipelinenivå som anges i YAML-filen
4. Variabel som anges vid kötid
5. Pipelinevariabel som anges i användargränssnittet för pipelineinställningar

I följande exempel anges samma variabel a på pipelinenivå och jobbnivå i YAML-filen. Den anges också i en variabelgrupp Goch som en variabel i användargränssnittet för pipelineinställningar.

variables:
  a: 'pipeline yaml'

stages:
- stage: one
  displayName: one
  variables:
  - name: a
    value: 'stage yaml'

  jobs:
  - job: A
    variables:
    - name: a
      value: 'job yaml'
    steps:
    - bash: echo $(a)        # This will be 'job yaml'

När du anger en variabel med samma namn i samma omfång har det sista angivna värdet företräde.

stages:
- stage: one
  displayName: Stage One
  variables: 
    - name: a
      value: alpha
    - name: a
      value: beta
  jobs: 
  - job: I
    displayName: Job I
    variables:
      - name: b
        value: uno
      - name: b
        value: dos
    steps: 
    - script: echo $(a) #outputs beta
    - script: echo $(b) #outputs dos

Variabler expanderas en gång när körningen startas och igen i början av varje steg. Till exempel:

jobs:
- job: A
  variables:
    a: 10
  steps:
  - bash: |
      echo $(a)            # This will be 10
      echo '##vso[task.setvariable variable=a]20'
      echo $(a)            # This will also be 10, since the expansion of $(a) happens before the step
  - bash: echo $(a)        # This will be 20, since the variables are expanded just before the step

Det finns två steg i föregående exempel. Expansionen av $(a) sker en gång i början av jobbet och en gång i början av vart och ett av de två stegen.

Eftersom variabler expanderas i början av ett jobb kan du inte använda dem i en strategi. I följande exempel kan du inte använda variabeln a för att expandera jobbmatrisen, eftersom variabeln endast är tillgänglig i början av varje expanderat jobb.

jobs:
- job: A
  variables:
    a: 10
  strategy:
    matrix:
      x:
        some_variable: $(a)    # This does not work

Om variabeln a är en utdatavariabel från ett tidigare jobb kan du använda den i ett framtida jobb.

- job: A
  steps:
  - powershell: echo "##vso[task.setvariable variable=a;isOutput=true]10"
    name: a_step

# Map the variable into job B
- job: B
  dependsOn: A
  variables:
    some_variable: $[ dependencies.A.outputs['a_step.a'] ]

Rekursiv expansion

På agenten expanderas variabler som refereras med syntax $( ) rekursivt. Till exempel:

variables:
  myInner: someValue
  myOuter: $(myInner)

steps:
- script: echo $(myOuter)  # prints "someValue"
  displayName: Variable is $(myOuter)  # display name is "Variable is someValue"

Det finns inget az pipelines-kommando som gäller för expansionen av variabler.

Azure DevOps CLI-kommandon stöds inte för Azure DevOps Server.