Definieren von Variablen

Legen Sie in den häufigsten Fällen die Variablen fest, und verwenden Sie sie in der YAML-Datei. Mit diesem Ansatz können Sie Änderungen an der Variablen im Versionssteuerungssystem nachverfolgen. Sie können Variablen auch auf der Benutzeroberfläche für die Pipelineeinstellungen definieren (siehe Registerkarte „Klassisch“) und in Ihrem YAML-Code darauf verweisen.

Das folgende Beispiel zeigt, wie zwei Variablen configuration festgelegt und platform später in Schritten verwendet werden. Umschließen Sie eine Variable mit $(), um sie in einer YAML-Anweisung zu verwenden. Sie können variablen nicht verwenden, um eine repository in einer YAML-Anweisung zu definieren.

# 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)

Variablenbereiche

Legen Sie in der YAML-Datei eine Variable in verschiedenen Bereichen fest:

• Auf Stammebene, um sie für alle Aufträge in der Pipeline verfügbar zu machen
• Auf Phasenebene, um sie nur für eine bestimmte Phase verfügbar zu machen
• Auf Auftragsebene, um es nur für einen bestimmten Auftrag verfügbar zu machen.

Wenn Sie eine Variable am Anfang einer YAML-Datei definieren, ist die Variable für alle Aufträge und Phasen in der Pipeline verfügbar und eine globale Variable. Globale Variablen, die in einer YAML-Datei definiert sind, sind auf der Benutzeroberfläche für die Pipelineeinstellungen nicht sichtbar.

Variablen auf Auftragsebene setzen Variablen auf Stamm- und Phasenebene außer Kraft. Variablen auf Phasenebene setzen Variablen auf Stammebene außer Kraft.

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

Die Ausgabe beider Aufträge sieht wie folgt aus:

# job1
value 
value1
value1

# job2
value
value2
value

Angeben von Variablen

In den vorherigen Beispielen folgt auf das variables-Schlüsselwort eine Liste mit Schlüssel-Wert-Paaren. Die Schlüssel sind die Variablennamen, die Werte sind die Variablenwerte.

Eine weitere Syntax ist nützlich, wenn Sie Vorlagen für Variablen oder Variablengruppen verwenden möchten.

Mithilfe von Vorlagen können Sie Variablen in einer YAML-Datei definieren und in eine andere YAML-Datei einschließen.

Variable Gruppen sind eine Reihe von Variablen, die Sie über mehrere pipelines hinweg verwenden können. Mithilfe von Variablengruppen können Sie Variablen verwalten und organisieren, die für verschiedene Phasen an einem zentralen Ort gemeinsam sind.

Verwenden Sie diese Syntax für Variablenvorlagen und Variablengruppen auf der Stammebene einer Pipeline.

In dieser alternativen Syntax akzeptiert das variables-Schlüsselwort eine Liste von Variablenbezeichnern. Die Variablenbezeichner sind name für eine reguläre Variable, group für eine Variablengruppe und template zum Einschließen einer Variablenvorlage. Im folgenden Beispiel werden alle drei veranschaulicht:

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

Weitere Informationen finden Sie unter Wiederverwendung von Variablen mit Vorlagen.

Zugriff auf Variablen über die Umgebungsvariablen

Beachten Sie, dass Variablen auch über Umgebungsvariablen für Skripts verfügbar gemacht werden. Die Syntax für die Verwendung dieser Umgebungsvariablen hängt von der Skriptsprache ab.

Der Name ist groß geschrieben, und der Punkt (.) wird durch einen Unterstrich (_) ersetzt. Dies wird automatisch in die Prozessumgebung eingefügt. Im Folgenden finden Sie einige Beispiele:

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

Mithilfe der Azure DevOps CLI können Sie Variablen für die Pipeline erstellen und aktualisieren, die in Ihrem project ausgeführt werden. Außerdem können Sie die Variablen löschen, wenn Sie sie nicht mehr benötigen.

Erstellen einer Variablen | Aktualisieren einer Variablen | Löschen einer Variablen

Voraussetzungen

• Installieren Sie die Azure DevOps CLI-Erweiterung wie in Get started mit Azure DevOps CLI beschrieben.
• Melden Sie sich mit az login bei Azure DevOps an.
• Legen Sie die Standardorganisation für die Beispiele in diesem Artikel mithilfe von az devops configure --defaults organization=YourOrganizationURL.

Erstellen einer Variablen

Erstellen Sie Variablen in Ihrer Pipeline mithilfe des Befehls az pipelines Variable create. Informationen zum Einstieg finden Sie unter Erste Schritte mit Azure DevOps CLI.

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

Parameter

• Name: Erforderlich. Name der Variable.
• allow-override: Optional. Legen Sie den Wert auf "true" fest, wenn Sie zulassen möchten, dass der Wert zur Warteschlangenzeit festgelegt wird; andernfalls auf "false" festgelegt.
• org: Azure DevOps-Organisations-URL. Konfigurieren Sie die Standardorganisation mithilfe von az devops configure -d organization=ORG_URL. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird. Beispiel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Erforderlich, wenn pipeline-name nicht angegeben wird. Die ID der Pipeline.
• pipeline-name: Erforderlich, wenn pipeline-id nicht angegeben wird. Wird allerdings ignoriert, wenn pipeline-id angegeben wird. Name der Pipeline.
• project: Name oder ID des project. Konfigurieren Sie das Standardprojekt mithilfe von az devops configure -d project=NAME_OR_ID. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird.
• geheim: Optional. Wenn der Wert der Variablen ein Geheimnis ist, setzen Sie ihn auf true; andernfalls setzen Sie ihn auf false.
• value: Bei nicht geheimen Variablen erforderlich. Der Wert der Variablen. Wenn Sie für geheime Variablen nicht den Wertparameter angeben, wird der Wert aus einer Umgebungsvariable ausgewählt, die AZURE_DEVOPS_EXT_PIPELINE_VAR_ dem Präfix vorangestellt ist, oder Sie werden aufgefordert, ihn über die Standardeingabe einzugeben. Eine Variable mit dem Namen MySecret kann z. B. mithilfe der Umgebungsvariablen AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecreteingegeben werden.

Beispiel

Der folgende Befehl erstellt eine Variable in MyFirstProject mit dem Namen Configuration und mit dem Wert value platform in der Pipeline mit der ID 12. Das Ergebnis wird im Tabellenformat angezeigt:

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

Aktualisieren einer Variablen

Verwenden Sie den Befehl az pipelines Variablenaktualisierung, um Variablen in Ihrer Pipeline zu aktualisieren. Informationen zum Einstieg finden Sie unter Erste Schritte mit 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]

Parameter

• Name: Erforderlich. Der ursprüngliche Name der Variablen.
• allow-override: Optional. Legen Sie den Wert auf "true" fest, wenn Sie zulassen möchten, dass der Wert zur Warteschlangenzeit festgelegt wird; andernfalls auf "false" festgelegt.
• neuer Name: Optional. Kann angegeben werden, um den Namen der Variablen zu ändern.
• org: Azure DevOps-Organisations-URL. Konfigurieren Sie die Standardorganisation mithilfe von az devops configure -d organization=ORG_URL. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird. Beispiel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Erforderlich, wenn pipeline-name nicht angegeben wird. Die ID der Pipeline.
• pipeline-name: Erforderlich, wenn pipeline-id nicht angegeben wird. Wird allerdings ignoriert, wenn pipeline-id angegeben wird. Name der Pipeline.
• project: Name oder ID des project. Konfigurieren Sie das Standardprojekt mithilfe von az devops configure -d project=NAME_OR_ID. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird.
• prompt-value: Legen Sie diesen Wert auf true fest, um den Wert einer geheimen Variablen mithilfe einer Umgebungsvariablen oder nach Aufforderung über die Standardeingabe zu aktualisieren. Zulässige Werte sind false und true.
• secret: Gibt an, ob der Wert der Variablen ein Geheimnis ist. Zulässige Werte sind false und true.
• value: Aktualisiert den Wert der Variablen. Verwenden Sie bei geheimen Variablen den Parameter prompt-value, um zur Eingabe über die Standardeingabe aufgefordert zu werden. Bei nicht interaktiven Konsolen kann dies aus der Umgebungsvariablen mit dem Präfix AZURE_DEVOPS_EXT_PIPELINE_VAR_ übernommen werden. Beispielsweise kann eine Variable mit dem Namen MySecret mithilfe der Umgebungsvariablen AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecret eingegeben werden.

Beispiel

Der folgende Befehl aktualisiert die Variable Configuration mit dem neuen Wert config.debug in der Pipeline mit der ID 12. Dabei wird angegeben, dass die Variable kein Geheimnis ist, und das Ergebnis wird im Tabellenformat angezeigt.

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

Löschen einer Variable

Sie können Variablen in Ihrer Pipeline mit dem Befehl az pipelines Variablen löschen löschen. Informationen zum Einstieg finden Sie unter Erste Schritte mit Azure DevOps CLI.

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

Parameter

• Name: Erforderlich. Der Name der zu löschenden Variablen.
• org: Azure DevOps-Organisations-URL. Konfigurieren Sie die Standardorganisation mithilfe von az devops configure -d organization=ORG_URL. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird. Beispiel: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: Erforderlich, wenn pipeline-name nicht angegeben wird. Die ID der Pipeline.
• pipeline-name: Erforderlich, wenn pipeline-id nicht angegeben wird. Wird allerdings ignoriert, wenn pipeline-id angegeben wird. Name der Pipeline.
• project: Name oder ID des project. Konfigurieren Sie das Standardprojekt mithilfe von az devops configure -d project=NAME_OR_ID. Erforderlich, wenn nicht als Standard konfiguriert oder mithilfe git configvon verwendet wird.
• ja: Optional. Fordert nicht zur Bestätigung auf.

Beispiel

Der folgende Befehl löscht die Variable Configuration aus der Pipeline mit der ID 12 und fordert nicht zur Bestätigung auf.

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

Deleted variable 'Configuration' successfully.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Legen Sie geheime Variablen nicht in Ihrer YAML-Datei fest. Betriebssysteme protokollieren häufig Befehle für die ausgeführten Prozesse, und Sie möchten natürlich nicht, dass das Protokoll ein Geheimnis enthält, das Sie als Eingabe übergeben haben. Verwenden Sie die Umgebung des Skripts, oder ordnen Sie die Variable innerhalb des variables-Blocks zu, um Geheimnisse an Ihre Pipeline zu übergeben.

Geheime Variablen müssen für Ihre Pipeline über die Benutzeroberfläche für die Pipelineeinstellungen festgelegt werden. Diese Variablen sind auf die Pipeline beschränkt, in der sie festgelegt sind. Sie können auch geheime Variablen in Variablengruppen festlegen.

Führen Sie die folgenden Schritte aus, um Geheimnisse über die Weboberfläche festzulegen:

1. Wechseln Sie zur Seite Pipelines, wählen Sie die entsprechende Pipeline aus, und wählen Sie dann Edit aus.
2. Suchen Sie die Variablen für diese Pipeline.
3. Fügen Sie die Variable hinzu oder aktualisieren Sie sie.
4. Wählen Sie die Option Diesen Wert geheim halten, um die Variable verschlüsselt zu speichern.
5. Speichern Sie die Pipeline.

Geheimnisvariablen werden im Ruhezustand mit einem 2048-Bit-RSA-Schlüssel verschlüsselt. Geheimnisse sind auf dem Agent für verwendbare Aufgaben und Skripts verfügbar. Achten Sie darauf, wer Zugriff hat, um Ihre Pipeline zu verändern.

Im Gegensatz zu einer normalen Variablen werden sie nicht automatisch zu Umgebungsvariablen für Skripts entschlüsselt. Geheime Variablen müssen explizit zugeordnet werden.

Im folgenden Beispiel wird gezeigt, wie eine geheime Variable mit dem Namen mySecret in PowerShell- und Bash-Skripts zugeordnet und verwendet wird. Es werden zwei globale Variablen definiert. GLOBAL_MYSECRET wird dem Wert einer geheimen Variablen mySecret und GLOBAL_MY_MAPPED_ENV_VAR wird dem Wert einer nicht geheimen Variablen nonSecretVariable zugewiesen. Anders als bei einer normalen Pipelinevariablen gibt es keine Umgebungsvariable namens MYSECRET.

Die PowerShell-Aufgabe führt ein Skript aus, um die Variablen auszugeben.

• $(mySecret): Dies ist ein direkter Verweis auf die geheime Variable, der funktioniert.
• $env:MYSECRET: Dadurch wird versucht, die geheime Variable als Umgebungsvariable zu access, was nicht funktioniert, da geheime Variablen nicht automatisch Umgebungsvariablen zugeordnet werden.
• $env:GLOBAL_MYSECRET: Dadurch wird versucht, die geheime Variable über eine globale Variable zu access, die auch nicht funktioniert, da geheime Variablen nicht auf diese Weise zugeordnet werden können.
• $env:GLOBAL_MY_MAPPED_ENV_VAR: Dadurch wird über eine funktionierende globale Variable auf die nicht geheime Variable zugegriffen.
• $env:MY_MAPPED_ENV_VAR: Dadurch wird über eine aufgabenspezifische Umgebungsvariable auf die geheime Variable zugegriffen. Dies ist die Methode, die zum Zuordnen geheimer Variablen zu Umgebungsvariablen empfohlen wird.

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

Die Ausgabe aus beiden Aufgaben im vorherigen Skript sieht wie folgt aus:

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: ***

Geheime Variablen können auch außerhalb von Skripts verwendet werden. Sie können z. B. geheime Variablen Vorgängen mithilfe der variables Definition zuordnen. In diesem Beispiel wird gezeigt, wie geheime Variablen $(vmsUser) und $(vmsAdminPass) in einer Azure Dateikopie-Aufgabe verwendet werden.

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

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: AzureFileCopy@6
  inputs:
    SourcePath: 'my/path' # Specify the source path
    azureSubscription: 'my-subscription' # Azure subscription name
    Destination: 'AzureVMs' # Destination type
    storage: 'my-storage' # Azure storage account name
    resourceGroup: 'my-resource-group' # Resource group name
    vmsAdminUserName: $(VMS_USER) # Admin username for the VM
    vmsAdminPassword: $(VMS_PASS) # Admin password for the VM
    CleanTargetBeforeCopy: false # Do not clean the target before copying

Verweisen auf geheime Variablen in Variablengruppen

In diesem Beispiel wird gezeigt, wie Sie in Ihrer YAML-Datei auf eine Variablengruppe verweisen und wie Sie Variablen innerhalb der YAML-Datei hinzufügen. Im Beispiel werden zwei Variablen aus der Variablengruppe verwendet: user und token. Die token Variable ist geheim und der Umgebungsvariablen $env:MY_MAPPED_TOKEN zugeordnet, sodass Sie im YAML darauf verweisen können.

Der folgende YAML-Code führt einen REST-Aufruf aus, um eine Liste von Releases abzurufen, und gibt das Ergebnis aus:

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

Informationen zum Festlegen geheimer Variablen mithilfe der Azure DevOps CLI finden Sie unter Create a variable or Update a variable.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Verwenden von Ausgaben in einer anderen Phase

Um die Ausgabe aus einer anderen Phase zu verwenden, verwenden Sie das Format stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE'] , um auf Variablen zu verweisen. Auf Stufenebene, aber nicht auf Auftragsebene, können Sie diese Variablen in Bedingungen verwenden.

Ausgabevariablen sind nur in der nächsten Downstream-Stufe verfügbar. Wenn mehrere Phasen die gleiche Ausgabevariable nutzen, verwenden Sie die dependsOn-Bedingung.

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

Sie können Variablen auch mithilfe einer Dateieingabe zwischen Phasen übergeben. Um dies zu tun, müssen Sie Variablen in der zweiten Phase auf Auftragsebene definieren und dann die Variablen als Eingaben env: weitergeben.

## 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) 

Die Ausgabe aus Phasen in der vorherigen Pipeline sieht wie folgt aus:

Hello inline version
true
crushed tomatoes

Es gibt keinen Befehl az pipelines, der für die Verwendung von Ausgabevariablen aus Aufgaben gilt.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Festlegen einer auftragsbezogenen Variablen über ein Skript

Verwenden Sie den task.setvariableProtokollierungsbefehl, um eine Variable aus einem Skript festzulegen. Mit diesem Befehl werden die Umgebungsvariablen für nachfolgende Aufträge aktualisiert. Nachfolgende Aufträge können mithilfe der Makrosyntax und in Aufgaben als Umgebungsvariablen auf die neue Variable zugreifen.

Wenn Sie auf "true" festlegen issecret , wird der Wert der Variablen als geheimer Schlüssel gespeichert und aus dem Protokoll maskiert. Weitere Informationen zu geheimen Variablen finden Sie unter Protokollierungsbefehle.

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)

In den nachfolgenden Schritten wird auch die Pipelinevariable zu ihrer Umgebung hinzugefügt. Sie können die Variable nicht in dem Schritt verwenden, in dem sie definiert wird.

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"

Die Ausgabe der vorherigen Pipeline:

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

Festlegen einer Ausgabevariablen für mehrere Aufträge

Wenn Sie eine Variable für zukünftige Aufträge verfügbar machen möchten, müssen Sie sie mithilfe von isOutput=true als Ausgabevariable markieren. Anschließend können Sie sie zukünftigen Aufträgen zuordnen, indem Sie die Syntax $[] verwenden und den Namen des Schritts einschließen, in dem die Variable festgelegt wurde. Ausgabevariablen für mehrere Aufträge funktionieren nur für Aufträge in der gleichen Phase.

Verwenden Sie die Syntax für Phasenabhängigkeiten, um Variablen an Aufträge in verschiedenen Phasen zu übergeben.

Wenn Sie eine Ausgabevariable für mehrere Aufträge erstellen, sollten Sie den Ausdruck einer Variablen zuweisen. Im folgenden YAML-Code wird $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] der Variablen $(myVarFromJobA)zugewiesen:

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

Die Ausgabe der vorherigen Pipeline:

this is the value
this is the value

Wenn Sie eine Variable von einer Phase auf eine andere festlegen, verwenden Sie 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)

Wenn Sie eine Variable aus einer matrix oder slice festlegen, müssen Sie folgendes einschließen, um auf die Variable zu verweisen, wenn Sie sie aus einem nachgelagerten Auftrag abrufen:

• Der Name des Auftrags.
• Der Schritt.

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

Achten Sie darauf, den Ausgabevariablen eines Bereitstellungsauftrags den Auftragsnamen als Präfix voranzustellen. In diesem Fall lautet der Auftragsname A:

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

Es gibt keinen Befehl az pipelines, der für das Festlegen von Variablen in Skripts gilt.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Sie können eine Variable mithilfe eines Ausdrucks festlegen. Sie haben bereits einen Fall dieses Ansatzes erlebt, indem Sie eine Variable auf die Ausgabe einer anderen Variablen aus einem vorherigen Auftrag setzen.

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

Sie können einen der unterstützten Ausdrücke zum Festlegen einer Variablen verwenden. Im folgenden Beispiel wird eine Variable festgelegt, die als Zähler fungiert, der bei 100 beginnt, bei jeder Ausführung um 1 erhöht wird und jeden Tag auf 100 zurückgesetzt wird.

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

Weitere Informationen zu Zählern, Abhängigkeiten und anderen Ausdrücken finden Sie unter Ausdrücke.

Es gibt keinen Befehl az pipelines, der für das Festlegen von Variablen mit Ausdrücken gilt.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Wenn eine Variable im variables Block einer YAML-Datei erscheint, ist der Wert festgelegt, und Benutzer können ihn zum Zeitpunkt der Warteschlange nicht außer Kraft setzen. Definieren Sie Ihre Variablen in einer YAML-Datei, aber es gibt Zeiten, in denen dieser Ansatz nicht sinnvoll ist. Sie können z. B. eine geheime Variable definieren und nicht in Ihrem YAML verfügbar machen. Es kann auch notwendig sein, einen Variablenwert manuell während der Pipeline-Ausführung festzulegen.

Wenn Sie Werte zur Warteschlangenzeit definieren möchten, haben Sie zwei Möglichkeiten: Sie können eine Variable über die Benutzeroberfläche definieren und die Option Benutzern erlauben, diesen Wert beim Ausführen dieser Pipeline zu überschreiben aktivieren oder stattdessen Laufzeitparameter verwenden. Wenn Ihre Variable kein Geheimnis ist, empfiehlt es sich, Laufzeitparameter zu verwenden.

Um eine Variable zur Warteschlangenzeit festzulegen, fügen Sie in Ihrer Pipeline eine neue Variable hinzu, und aktivieren Sie die Überschreibungsoption. Nur Benutzer*innen mit der Berechtigung zum Bearbeiten der Warteschlangen-Buildkonfiguration können den Wert einer Variablen ändern.

Damit eine Variable zur Warteschlangenzeit festgelegt werden kann, achten Sie darauf, dass sie nicht auch im variables-Block einer Pipeline oder eines Auftrags enthalten ist. Wenn Sie eine Variable sowohl im Variablenblock einer YAML-Datei als auch über die Benutzeroberfläche definieren, hat der Wert in der YAML-Datei Priorität.

Verwenden Sie zur zusätzlichen Sicherheit einen vordefinierten Satz von Werten zur Festlegung von Variablen zur Warteschlangenzeit und sichere Typen wie Boolesche Werte und ganze Zahlen. Verwenden Sie für Zeichenfolgen einen vordefinierten Wertesatz.

Informationen zum Auswählen, welche Variablen zur Warteschlangenzeit mithilfe der Azure devOps CLI festgelegt werden dürfen, finden Sie unter Create a variable or Update a variable.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.

Wenn Sie eine Variable mit demselben Namen in mehreren Bereichen festlegen, gilt die folgende Rangfolge (oberste Rangfolge zuerst):

1. In der YAML-Datei festgelegte Variable für die Auftragsebene
2. In der YAML-Datei festgelegte Variable auf Phasenebene
3. In der YAML-Datei festgelegte Variable auf Pipelineebene
4. Variable, die zur Zeit der Warteschlange festgelegt wurde
5. Über die Benutzeroberfläche für die Pipelineeinstellungen festgelegte Variable

Im folgenden Beispiel wird dieselbe Variable a auf Pipelineebene und Auftragsebene in der YAML-Datei festgelegt. Außerdem wird sie in einer Variablengruppe G, sowie als Variable auf der Benutzeroberfläche für die Pipelineeinstellungen festgelegt.

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'

Wenn Sie eine Variable mit dem gleichen Namen im gleichen Bereich festlegen, hat der letzte Wert Vorrang.

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

Variablen werden einmal erweitert, wenn die Ausführung gestartet wird, und wieder am Anfang jedes Schritts. Beispiel:

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

Im vorherigen Beispiel gibt es zwei Schritte. Die Erweiterung von $(a) erfolgt einmal zu Beginn des Auftrags und jeweils am Anfang jedes der beiden Schritte.

Da Variablen am Anfang eines Auftrags erweitert werden, können Sie sie nicht in einer Strategie verwenden. Im folgenden Beispiel können Sie die Variable a nicht verwenden, um die Auftragsmatrix zu erweitern, da die Variable nur am Anfang jedes erweiterten Auftrags verfügbar ist.

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

Wenn es sich bei der Variablen a um eine Ausgabevariable eines vorherigen Auftrags handelt, können Sie sie in einem zukünftigen Auftrag verwenden.

- 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'] ]

Rekursive Erweiterung

Im Agent werden Variablen, auf die mithilfe der Syntax $( ) verwiesen wird, rekursiv erweitert. Beispiel:

variables:
  myInner: someValue
  myOuter: $(myInner)

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

Es gibt keinen Befehl az pipelines, der für die Erweiterung von Variablen gilt.

Azure DevOps CLI-Befehle werden für Azure DevOps Server nicht unterstützt.