Değişkenleri tanımlama

En yaygın durumda, değişkenleri ayarlar ve YAML dosyasında kullanırsınız. Bu, sürüm denetim sisteminizdeki değişkende yapılan değişiklikleri izlemenize olanak tanır. Ayrıca işlem hattı ayarları kullanıcı arabiriminde değişkenler tanımlayabilir (Klasik sekmesine bakın) ve YAML'nizde bunlara başvurabilirsiniz.

aşağıda, ve olmak üzere iki değişkenin configuration nasıl ayarlanacağı ve platformadımlarda daha sonra bunların nasıl kullanılacağı gösterilmektedir. YAML deyiminde değişken kullanmak için içinde sarmalayın $(). Değişkenler YAML deyiminde bir repository tanımlamak için kullanılamaz.

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

Değişken kapsamları

YAML dosyasında, çeşitli kapsamlarda bir değişken ayarlayabilirsiniz:

• kök düzeyinde, işlem hattındaki tüm işler için kullanılabilir hale getirmek için.
• Aşama düzeyinde, yalnızca belirli bir aşamada kullanılabilir hale getirmek için.
• yalnızca belirli bir iş için kullanılabilir hale getirmek için iş düzeyinde.

YAML'nin en üstünde bir değişken tanımladığınızda, değişken işlem hattındaki tüm işler ve aşamalar için kullanılabilir ve genel bir değişkendir. YAML'de tanımlanan genel değişkenler işlem hattı ayarları kullanıcı arabiriminde görünmez.

İş düzeyindeki değişkenler, kök ve aşama düzeyinde değişkenleri geçersiz kılar. Aşama düzeyindeki değişkenler, kök düzeyindeki değişkenleri geçersiz kılar.

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

Her iki işin çıktısı şöyle görünür:

# job1
value 
value1
value1

# job2
value
value2
value

Değişkenleri belirtme

Yukarıdaki örneklerde anahtar sözcüğün variables ardından anahtar-değer çiftlerinin listesi yer alır. Anahtarlar değişken adları ve değerler değişken değerleridir.

Değişkenler veya değişken grupları için şablonları kullanmak istediğinizde yararlı olan başka bir söz dizimi daha vardır.

Şablonlarla değişkenler bir YAML'de tanımlanabilir ve başka bir YAML dosyasına eklenebilir.

Değişken grupları, birden çok işlem hattında kullanabileceğiniz bir dizi değişkendir. Çeşitli aşamalarda ortak olan değişkenleri tek bir yerde yönetmenize ve düzenlemenize olanak sağlar.

İşlem hattının kök düzeyindeki değişken şablonları ve değişken grupları için bu söz dizimini kullanın.

Bu alternatif söz diziminde variables anahtar sözcük, değişken tanımlayıcılarının listesini alır. Değişken tanımlayıcıları name , group bir değişken grubu için normal bir değişkene ve template değişken şablonu eklemeye yöneliktir. Aşağıdaki örnekte üçü de gösterilmiştir.

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

Şablonlarla değişken yeniden kullanımı hakkında daha fazla bilgi edinin.

Ortam üzerinden değişkenlere erişme

Değişkenlerin ortam değişkenleri aracılığıyla betikler için de kullanılabilir hale getirildiğini unutmayın. Bu ortam değişkenlerini kullanmaya yönelik söz dizimi betik diline bağlıdır.

Ad büyük harfle ve . ile değiştirilir _. Bu işlem ortamına otomatik olarak eklenir. Burada bazı örnekler verilmiştir:

• Batch betiği: %VARIABLE_NAME%
• PowerShell betiği: $env:VARIABLE_NAME
• Bash betiği: $VARIABLE_NAME

Azure DevOps CLI'yı kullanarak projenizdeki işlem hattı çalıştırmaları için değişkenler oluşturabilir ve güncelleştirebilirsiniz. Artık ihtiyacınız yoksa değişkenleri de silebilirsiniz.

Değişken oluşturma Değişken | güncelleştirme Değişkeni | silme

Önkoşullar

• Azure DevOps CLI'yi kullanmaya başlama bölümünde açıklandığı gibi Azure DevOps CLI uzantısını yüklediniz.
• kullanarak az loginAzure DevOps'ta oturum açın.
• Bu makaledeki örnekler için kullanarak az devops configure --defaults organization=YourOrganizationURLvarsayılan kuruluşu ayarlayın.

Değişken oluşturma

az pipelines variable create komutuyla işlem hattınızda değişkenler oluşturabilirsiniz . Başlamak için bkz . Azure DevOps CLI ile çalışmaya başlama.

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

Parametreler

• name: Gerekli. Değişkenin adı.
• allow-override: İsteğe bağlı. Değerin kuyruk zamanında ayarlanıp ayarlanamayacağını gösterir. Kabul edilen değerler false ve true değerleridir.
• kuruluş: Azure DevOps kuruluş URL'si. kullanarak az devops configure -d organization=ORG_URLvarsayılan kuruluşu yapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir. Örnek: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: İşlem hattı adı sağlanmazsa gereklidir. İşlem hattının kimliği.
• pipeline-name: pipeline-id sağlanmazsa gereklidir, ancak pipeline-id sağlandığında yoksayılır. İşlem hattının adı.
• project: Projenin adı veya kimliği. kullanarak varsayılan projeyi az devops configure -d project=NAME_OR_IDyapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir.
• gizli dizi: İsteğe bağlı. Değişkenin değerinin gizli dizi olup olmadığını gösterir. Kabul edilen değerler false ve true değerleridir.
• değer: Gizli dizi olmayan değişken için gereklidir. Değişkenin değeri. Gizli dizi değişkenleri için, değer parametresi sağlanmazsa, ön ekli AZURE_DEVOPS_EXT_PIPELINE_VAR_ ortam değişkeninden seçilir veya kullanıcıdan standart giriş yoluyla girmesi istenir. Örneğin, MySecret adlı bir değişken ortam değişkeni AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecretkullanılarak giriş yapılabilir.

Örnek

Aşağıdaki komut, MyFirstProject içinde configuration adlı ve işlem hattında 12 kimliğine sahip değer platformu olan bir değişken oluşturur. Sonucu tablo biçiminde gösterir.

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

Değişken güncelleştirme

az pipelines variable update komutuyla işlem hattınızdaki değişkenleri güncelleştirebilirsiniz . Başlamak için bkz . Azure DevOps CLI ile çalışmaya başlama.

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]

Parametreler

• name: Gerekli. Değişkenin özgün adı.
• allow-override: İsteğe bağlı. Değerin kuyruk zamanında ayarlanıp ayarlanamayacağını gösterir. Kabul edilen değerler false ve true değerleridir.
• new-name: İsteğe bağlı. Değişkenin adını değiştirmek için belirtin.
• kuruluş: Azure DevOps kuruluş URL'si. kullanarak az devops configure -d organization=ORG_URLvarsayılan kuruluşu yapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir. Örnek: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: İşlem hattı adı sağlanmazsa gereklidir. İşlem hattının kimliği.
• pipeline-name: pipeline-id sağlanmazsa gereklidir, ancak pipeline-id sağlandığında yoksayılır. İşlem hattının adı.
• project: Projenin adı veya kimliği. kullanarak varsayılan projeyi az devops configure -d project=NAME_OR_IDyapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir.
• prompt-value: Ortam değişkenini veya standart giriş aracılığıyla istem kullanarak gizli dizi değişkeninin değerini güncelleştirmek için true olarak ayarlayın. Kabul edilen değerler false ve true değerleridir.
• secret: Değişkenin değerinin gizli dizi olup olmadığını gösterir. Kabul edilen değerler false ve true değerleridir.
• value: Değişkenin değerini güncelleştirir. Gizli dizi değişkenleri için, standart giriş aracılığıyla girmeniz istenecek prompt-value parametresini kullanın. Etkileşimli olmayan konsollar için, ön ekli AZURE_DEVOPS_EXT_PIPELINE_VAR_ortam değişkeninden seçilebilir. Örneğin, MySecret adlı bir değişken ortam değişkeni AZURE_DEVOPS_EXT_PIPELINE_VAR_MySecretkullanılarak giriş yapılabilir.

Örnek

Aşağıdaki komut Configuration değişkenini 12 kimliğine sahip işlem hattındaki yeni config.debug değeriyle güncelleştirir. Değişkenin gizli dizi olmadığını belirtir ve sonucu tablo biçiminde gösterir.

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

Değişken silme

az pipelines variable delete komutuyla işlem hattınızdaki değişkenleri silebilirsiniz . Başlamak için bkz . Azure DevOps CLI ile çalışmaya başlama.

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

Parametreler

• name: Gerekli. Silmek istediğiniz değişkenin adı.
• kuruluş: Azure DevOps kuruluş URL'si. kullanarak az devops configure -d organization=ORG_URLvarsayılan kuruluşu yapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir. Örnek: --org https://dev.azure.com/MyOrganizationName/.
• pipeline-id: İşlem hattı adı sağlanmazsa gereklidir. İşlem hattının kimliği.
• pipeline-name: pipeline-id sağlanmazsa gereklidir, ancak pipeline-id sağlandığında yoksayılır. İşlem hattının adı.
• project: Projenin adı veya kimliği. kullanarak varsayılan projeyi az devops configure -d project=NAME_OR_IDyapılandırabilirsiniz. Varsayılan olarak yapılandırılmadıysa veya kullanılarak git configalınmadıysa gereklidir.
• Evet: İsteğe bağlı. Onay istemez.

Örnek

Aşağıdaki komut, Yapılandırma değişkenini 12 kimliğine sahip işlem hattından siler ve onay istemez.

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

Deleted variable 'Configuration' successfully.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

YAML dosyanızda gizli dizi değişkenleri ayarlamayın. İşletim sistemleri genellikle çalıştırdıkları işlemler için komutları günlüğe kaydeder ve günlüğün giriş olarak iletmiş olduğunuz bir gizli dizi içermesini istemezsiniz. Gizli dizileri işlem hattınıza geçirmek için betiğin ortamını kullanın veya bloğun variables içindeki değişkeni eşleyin.

İşlem hattınızın işlem hattı ayarları kullanıcı arabiriminde gizli dizi değişkenleri ayarlamanız gerekir. Bu değişkenlerin kapsamı, ayarlandıkları işlem hattına göre belirlenmiştir. Değişken gruplarında gizli dizi değişkenleri de ayarlayabilirsiniz.

Web arabiriminde gizli dizileri ayarlamak için şu adımları izleyin:

1. İşlem Hatları sayfasına gidin, uygun işlem hattını seçin ve ardından Düzenle'yi seçin.
2. Bu işlem hattı için Değişkenleri bulun.
3. Değişkeni ekleyin veya güncelleştirin.
4. Değişkeni şifrelenmiş bir şekilde depolamak için Bu değeri gizli tut seçeneğini belirleyin.
5. İşlem hattını kaydedin.

Gizli dizi değişkenleri bekleyen bir 2048 bit RSA anahtarıyla şifrelenir. Gizli diziler, kullanılacak görevler ve betikler için aracıda kullanılabilir. İşlem hattınızı değiştirme erişimi olan kişilere dikkat edin.

Normal bir değişkenin aksine, betikler için ortam değişkenlerine otomatik olarak şifresi çözülmez. Gizli dizi değişkenlerini açıkça eşlemeniz gerekir.

Aşağıdaki örnekte, PowerShell ve Bash betiklerinde adlı gizli dizi değişkeninin nasıl eşlenip mySecret kullanılacağı gösterilmektedir. İki genel değişken tanımlanır. GLOBAL_MYSECRET , bir gizli dizi değişkeninin mySecretdeğerine atanır ve GLOBAL_MY_MAPPED_ENV_VAR gizli dizi olmayan bir değişkenin nonSecretVariabledeğerine atanır. Normal işlem hattı değişkenlerinin aksine adlı MYSECRETbir ortam değişkeni yoktur.

PowerShell görevi, değişkenleri yazdırmak için bir betik çalıştırır.

• $(mySecret): Bu, gizli dizi değişkenine doğrudan başvurudur ve çalışır.
• $env:MYSECRET: Bu, gizli dizi değişkenine ortam değişkeni olarak erişmeye çalışır ve gizli dizi değişkenleri ortam değişkenlerine otomatik olarak eşlenmediğinden çalışmaz.
• $env:GLOBAL_MYSECRET: Bu, gizli dizi değişkenine genel bir değişken aracılığıyla erişmeye çalışır ve gizli dizi değişkenleri bu şekilde eşlenemediğinden de çalışmaz.
• $env:GLOBAL_MY_MAPPED_ENV_VAR: Bu, gizli olmayan değişkene çalışan bir genel değişken aracılığıyla erişir.
• $env:MY_MAPPED_ENV_VAR: Bu, gizli dizi değişkenlerini ortam değişkenlerine eşlemenin önerilen yolu olan göreve özgü ortam değişkeni aracılığıyla gizli dizi değişkenine erişir.

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

Önceki betikteki her iki görevden alınan çıkış şu şekilde görünü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: ***

Gizli dizi değişkenlerini betiklerin dışında da kullanabilirsiniz. Örneğin, tanımı kullanarak gizli dizi değişkenlerini görevlere variables eşleyebilirsiniz. Bu örnekte gizli dizi değişkenlerinin $(vmsUser) ve $(vmsAdminPass) Azure dosya kopyalama görevinin nasıl kullanılacağı gösterilmektedir.

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)

Değişken gruplarında gizli dizi değişkenlerine başvurma

Bu örnekte YAML dosyanızdaki bir değişken grubuna başvurma ve YAML içinde değişken ekleme işlemleri gösterilmektedir. Değişken grubundan kullanılan iki değişken vardır: user ve token. token değişken gizli dizidir ve YAML'de başvurulabilmesi için ortam değişkenine $env:MY_MAPPED_TOKEN eşlenir.

Bu YAML, yayınların listesini almak için bir REST çağrısı yapar ve sonucu verir.

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

Azure DevOps CLI kullanarak gizli dizi değişkenleri ayarlamak için bkz. Değişken oluşturma veya Değişken güncelleştirme.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

Çıkışları farklı bir aşamada kullanma

Farklı bir aşamadan çıkışı kullanmak için, değişkenlere başvurma biçimi şeklindedir stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']. Aşama düzeyinde, ancak iş düzeyinde değil, bu değişkenleri koşullarda kullanabilirsiniz.

Çıkış değişkenleri yalnızca sonraki aşağı akış aşamasında kullanılabilir. Birden çok aşama aynı çıkış değişkenini kullanıyorsa koşulunu dependsOn kullanın.

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

Ayrıca, bir dosya girişiyle aşamalar arasında değişken geçirebilirsiniz. Bunu yapmak için ikinci aşamada iş düzeyinde değişkenleri tanımlamanız ve ardından değişkenleri giriş olarak env: geçirmeniz gerekir.

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

Önceki işlem hattındaki aşamaların çıkışı şöyle görünür:

Hello inline version
true
crushed tomatoes

Görevlerden çıkış değişkenlerini kullanmak için geçerli olan az pipelines komutu yoktur.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

Betikten iş kapsamlı değişken ayarlama

Bir betikten değişken ayarlamak için günlüğe task.setvariable kaydetme komutunu kullanırsınız. Bu, izleyen işler için ortam değişkenlerini güncelleştirir. Sonraki işler, makro söz dizimi ile yeni değişkene ve görevlerde ortam değişkenleri olarak erişime sahiptir.

True olduğunda issecret değişkenin değeri gizli dizi olarak kaydedilir ve günlükten maskelenir. Gizli dizi değişkenleri hakkında daha fazla bilgi için bkz . günlük komutları.

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)

Sonraki adımlarda işlem hattı değişkeni de ortamlarına eklenir. Değişkeni tanımlandığı adımda kullanamazsınız.

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"

Önceki işlem hattından çıktı.

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

Çok işli çıkış değişkeni ayarlama

Bir değişkeni gelecekteki işler için kullanılabilir hale getirmek istiyorsanız, kullanarak isOutput=truebir çıkış değişkeni olarak işaretlemeniz gerekir. Ardından söz dizimini $[] kullanarak ve değişkeni ayarlayan adım adını ekleyerek bunu gelecekteki işlere eşleyebilirsiniz. Çok işli çıkış değişkenleri yalnızca aynı aşamadaki işler için çalışır.

Değişkenleri farklı aşamalardaki işlere geçirmek için aşama bağımlılıkları söz dizimini kullanın.

Çok işli bir çıkış değişkeni oluşturduğunuzda, ifadeyi bir değişkene atamanız gerekir. Bu YAML'de değişkenine $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] $(myVarFromJobA)atanır.

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

Önceki işlem hattından çıktı.

this is the value
this is the value

Bir değişkeni bir aşamadan diğerine ayarlıysanız kullanın 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)

Matristen veya dilimden bir değişken ayarıyorsanız, aşağı akış işinden erişirken değişkene başvurmak için şunları eklemeniz gerekir:

• İşin adı.
• Adım.

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

İş adını bir dağıtım işinin çıkış değişkenlerine ön ek olarak eklemeyi unutmayın. Bu durumda, iş adı şeklindedir 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

Betiklerdeki değişkenleri ayarlamak için geçerli olan az pipelines komutu yoktur.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

İfade kullanarak değişken ayarlayabilirsiniz. Önceki bir işten başka bir değişkenin çıkışına değişken ayarlamak için zaten bir durumla karşılaştık.

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

Değişken ayarlamak için desteklenen ifadelerden herhangi birini kullanabilirsiniz. Aşağıda, 100'de başlayan, her çalıştırma için 1 artırılan ve her gün 100'e sıfırlanan bir sayaç olarak davranacak bir değişken ayarlama örneği verilmişti.

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

Sayaçlar, bağımlılıklar ve diğer ifadeler hakkında daha fazla bilgi için bkz . ifadeler.

İfadeleri kullanarak değişkenleri ayarlamak için geçerli olan az pipelines komutu yoktur.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

Bir değişken YAML dosyasının variables bloğunda görünürse değeri sabittir ve kuyruk zamanında geçersiz kılınamaz. En iyi yöntem, değişkenlerinizi bir YAML dosyasında tanımlamaktır, ancak bunun anlamlı olmadığı zamanlar vardır. Örneğin, bir gizli dizi değişkeni tanımlamak ve değişkenin YAML'nizde gösterilmemesini isteyebilirsiniz. Öte yandan işlem hattı çalıştırması sırasında bir değişken değerini el ile ayarlamanız gerekebilir.

Kuyruk zamanı değerlerini tanımlamak için iki seçeneğiniz vardır. Kullanıcı arabiriminde bir değişken tanımlayabilir ve Kullanıcıların bu işlem hattını çalıştırırken bu değeri geçersiz kılmasına izin ver seçeneğini belirleyebilir veya bunun yerine çalışma zamanı parametrelerini kullanabilirsiniz. Değişkeniniz gizli dizi değilse, en iyi yöntem çalışma zamanı parametrelerini kullanmaktır.

Kuyruk zamanında bir değişken ayarlamak için işlem hattınıza yeni bir değişken ekleyin ve geçersiz kılma seçeneğini belirleyin.

Bir değişkenin kuyruk zamanında ayarlanmasına izin vermek için değişkenin bir işlem hattı veya işin bloğunda variables da görünmediğinden emin olun. YaML'nin değişken bloğunda ve kullanıcı arabiriminde bir değişken tanımlarsanız YAML'deki değerin önceliği vardır.

Azure DevOps CLI kullanılarak kuyruk zamanında hangi değişkenlerin ayarlanmasına izin verileceğini seçmek için bkz. Değişken oluşturma veya Değişken güncelleştirme.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.

Birden çok kapsamda aynı ada sahip bir değişken ayarladığınızda aşağıdaki öncelik geçerlidir (önce en yüksek öncelik).

1. YAML dosyasında ayarlanan iş düzeyi değişkeni
2. YAML dosyasında ayarlanan aşama düzeyi değişkeni
3. YAML dosyasında ayarlanan işlem hattı düzeyi değişkeni
4. Kuyruk zamanında ayarlanan değişken
5. İşlem hattı ayarları kullanıcı arabiriminde ayarlanan işlem hattı değişkeni

Aşağıdaki örnekte aynı değişken a YAML dosyasında işlem hattı düzeyinde ve iş düzeyinde ayarlanmıştır. Ayrıca değişken grubunda Gve İşlem hattı ayarları kullanıcı arabiriminde değişken olarak ayarlanır.

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'

Aynı kapsamda aynı ada sahip bir değişken ayarladığınızda, son ayarlanan değer öncelikli olur.

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

Çalıştırma başlatıldığında değişkenler bir kez ve her adımın başında yeniden genişletilir. Örneğin:

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

Önceki örnekte iki adım vardır. genişletme işlemi $(a) , işin başlangıcında bir kez ve iki adımın her birinin başında bir kez gerçekleşir.

Değişkenler işin başında genişletildiğinden, bunları bir stratejide kullanamazsınız. Aşağıdaki örnekte değişkeni iş matrisini a genişletmek için kullanamazsınız, çünkü değişken yalnızca genişletilmiş her işin başında kullanılabilir.

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

Değişken a önceki bir işten bir çıkış değişkeniyse, bunu gelecekteki bir işte kullanabilirsiniz.

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

Özyinelemeli genişletme

Aracıda, söz dizimi kullanılarak $( ) başvuruda bulunan değişkenler özyinelemeli olarak genişletilir. Örneğin:

variables:
  myInner: someValue
  myOuter: $(myInner)

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

Değişkenlerin genişletilmesi için geçerli olan az pipelines komutu yoktur.

Azure DevOps CLI komutları Azure DevOps Server için desteklenmez.