Değişkenleri tanımlama

Not

Microsoft Team Foundation Server (TFS) 2018 ve önceki sürümlerde derleme ve yayın işlem hatları tanımlar, çalıştırmalar derlemeler, hizmet bağlantıları hizmet noktaları,aşamalar ortamlar ve işler olarak adlandırılan aşamalar olarak adlandırılanlardır.

Değişkenler, önemli veri parçalarını işlem hattının çeşitli bölümlerine almak için kullanışlı bir yol sağlar. Değişkenlerin en yaygın kullanımı, işlem hattında kullanabileceğiniz bir değer tanımlamaktır. Tüm değişkenler dize olarak depolanır ve değişken olabilir. Bir değişkenin değeri çalıştırmadan çalıştırmaya veya işten işlem hattınıza kadar değişebilir.

Aynı değişkeni aynı adla birden çok yerde tanımladığınız zaman, yerel olarak kapsamı en fazla olan değişken kazanır. Bu nedenle iş düzeyinde tanımlanan bir değişken, aşama düzeyinde ayarlanmış bir değişkeni geçersiz k olabilir. Aşama düzeyinde tanımlanan bir değişken, işlem hattı kök düzeyinde ayarlanmış bir değişkeni geçersiz kılar. İşlem hattı kök düzeyinde ayarlanmış bir değişken, İşlem hattı ayarları kullanıcı arabiriminde ayarlanmış bir değişkeni geçersiz kılar.

Değerleri koşullu olarak atamak ve işlem hatlarını daha fazla özelleştirmek için değişkenleri ifadelerle birlikte kullanabilirsiniz.

Değişkenler, şablon ayrıştırma sırasında yazarakkullanılabilen çalışma zamanı parametrelerinden farklıdır.

Kullanıcı tanımlı değişkenler

Bir değişken tanımlarken, farklı söz dizimleri (makro, şablon ifadesi veya çalışma zamanı) kullanabilirsiniz ve hangi söz dizimini kullanırsanız, değişkeninizin işlem hattında nerede işley olduğunu belirler.

YAML işlem hatlarında kök, aşama ve iş düzeyinde değişkenler belirtebilirsiniz. Değişkenleri kullanıcı arabiriminde YAML işlem hattının dışında da belirtebilirsiniz. Kullanıcı arabiriminde bir değişken ayarlıyorsa bu değişken şifrelenir ve gizli dizi olarak ayarlanabilir.

Kullanıcı tanımlı değişkenler salt okunur olarak ayarlanmalıdır. Değişkenler için adlandırma kısıtlamaları vardır (örneğin, bir değişken adının başında bunu kullanasınız).

Değişkenleri birden çok işlem hattında kullanılabilir hale yapmak için bir değişken grubu kullanabilirsiniz.

Bir dosyada birden çok işlem hattında kullanılan değişkenleri tanımlamak için şablonları kullanabilirsiniz.

Sistem değişkenleri

Kullanıcı tanımlı değişkenlere ek olarak, Azure Pipelines değerleri olan sistem değişkenleri vardır. YAML veya klasik derleme işlem hatları kullanıyorsanız kapsamlı bir sistem değişkeni listesi için önceden tanımlanmış değişkenlere bakın. Klasik yayın işlem hatları kullanıyorsanız bkz. yayın değişkenleri.

İşlem hattını çalıştırarak sistem değişkenleri geçerli değerleriyle ayarlanır. Bazı değişkenler otomatik olarak ayarlanır. İşlem hattı yazarı veya son kullanıcı olarak, işlem hattı çalıştırılmadan önce sistem değişkeninin değerini değiştirirsiniz.

Sistem değişkenleri salt okunur.

Ortam değişkenleri

Ortam değişkenleri, kullanmakta olduğu işletim sistemine özeldir. Platforma özgü yollarla bir işlem hattına bu işlem hattına eklemeler. Biçim, ortam değişkenlerinin belirli bir betik platformu için nasıl biçimlendirildiklerini gösterir.

Bu UNIX (macOS ve Linux) ortam değişkenleri $NAME biçimindedir. Bu Windows biçimi batch %NAME% ve $env:NAME PowerShell'dedir.

Sistem ve kullanıcı tanımlı değişkenler de platform için ortam değişkenleri olarak dahil edilir. Değişkenler ortam değişkenlerine dönüştür olduğunda, değişken adları büyük harfe, nokta ise alt çizgiye döner. Örneğin, değişken adı any.variable değişken adı $ANY_VARIABLE olur.

Değişken adlandırma kısıtlamaları

Kullanıcı tanımlı değişkenler harf, sayı ve . karakterlerden _ oluşur. Sistem tarafından ayrılmış değişken ön eklerini kullanma. Bunlar: endpoint , inputsecret , ve securefile . Bu dizelerden biri ile başlayan herhangi bir değişken (büyük harf kullanımına bakılmaksızın) görevleriniz ve betikleriniz tarafından kullanılamaz.

Değişken söz dizimlerini anlama

Azure Pipelines değişkenlere başvuru yapmak için üç farklı yolu destekler: makro, şablon ifadesi ve çalışma zamanı ifadesi. Her söz dizimi farklı bir amaç için kullanılabilir ve bazı sınırlamaları vardır.

Bir işlem hattında, şablon ifadesi değişkenleri ( ${{ variables.var }} ) çalışma zamanı başlamadan önce derleme zamanında işlenir. Makro söz dizimi değişkenleri ( $(var) ) bir görev çalışmadan önce çalışma zamanı sırasında işlenir. Çalışma zamanı ifadeleri ( $[variables.var] ) çalışma zamanı sırasında da işlenir, ancak koşullar ve $[variables.var] üzere tasarlanmıştır. Bir çalışma zamanı ifadesi kullanırken, bir tanımın sağ tarafının tamamını alması gerekir.

Bu örnekte, değişken güncelleştirildikten sonra şablon ifadesinin değişkenin ilk değerine hala sahip olduğunu görüyorsunuz. Makro söz dizimi değişkeninin değeri uzer. Tüm şablon ifadesi değişkenleri, görevler çalışmadan önce derleme zamanında işlendiğinden şablon ifadesi değeri değişmez. Buna karşılık, makro söz dizimi değişkenleri her görev çalışmadan önce değerlendirilir.

variables:
- name: one
  value: initialValue 

steps:
  - script: |
      echo ${{ variables.one }} # outputs initialValue
      echo $(one)
    displayName: First variable pass
  - bash: echo "##vso[task.setvariable variable=one]secondValue"
    displayName: Set new variable value
  - script: |
      echo ${{ variables.one }} # outputs initialValue
      echo $(one) # outputs secondValue
    displayName: Second variable pass

Makro söz dizimi değişkenleri

Çoğu belge örneğinde makro söz dizimi ( ) $(var) kullanılır. Makro söz dizimi, değişken değerlerini görev girişlerine ve diğer değişkenlere ilişkilendirmek için tasarlanmıştır.

Bir görev çalışma zamanı sırasında yürütülmeden önce makro söz dizimi olan değişkenler işlenir. Çalışma zamanı şablon genişletmesi sonrasında gerçekleşir. Sistem bir makro ifadesiyle karşılaştığında, ifadeyi değişkenin içeriğiyle değiştirir. Bu adla bir değişken yoksa makro ifadesi değiştirilmeden kalır. Örneğin, $(var) değiştirilenene kadar hiçbir $(var) şey ile değiştirilemez.

Gibi boş bir değer, çalıştırmakta olduğu görev için bir şey ifade eder ve aracı bu değerin değiştirilmesini istediğiniz varsaymay olabileceği için makro söz dizimi değişkenleri hiçbir $() değerle değişmeden kalır. Örneğin, bir Bash görevdeki değişkene başvuru yapmak için kullanırsanız, girişte görevdeki tüm ifadelerin değiştirilmesi $(foo)foo Bash $() betiklerinizi bozabilirsiniz.

Makro değişkenleri yalnızca bir değer için kullanılırken genişletilir, anahtar sözcük olarak değil. Değerler, bir işlem hattı tanımının sağ tarafında görünür. Aşağıdakiler geçerlidir: key: $(value) . Aşağıdakiler geçerli değildir: $(key): value . Makro değişkenleri, satır içi bir iş adı görüntülemek için kullanılırken genişletilir. Bunun yerine özelliğini displayName kullanabilirsiniz.

Not

Makro söz dizimi değişkenleri yalnızca stages , ve jobs için steps genişletilir. Örneğin, bir veya içinde makro söz dizimi resourcetrigger kullanamazsiniz.

Bu örnekte makro söz dizimi Bash, PowerShell ve bir betik görevi ile birlikte kullanılır. Makro söz dizimi ile bir değişkeni çağırma söz dizimi üçü için de aynıdır.

variables:
 - name: projectName
   value: contoso

steps: 
- bash: echo $(projectName)
- powershell: echo $(projectName)
- script: echo $(projectName)

Şablon ifadesi söz dizimi

Şablon parametrelerini ve değişkenlerini () genişletmek için şablon ifadesi söz dizimi kullanabilirsiniz. Şablon değişkenleri derleme zamanında işlenir ve çalışma zamanı başlamadan önce değiştirilir. Şablon ifadeleri YAML'nin parçalarını şablon olarak yeniden kullanmak için tasarlanmıştır.

Şablon değişkenleri, değiştirme değeri bulunamadıklarında boş dizelerle sessizce biriktir. Şablon ifadeleri, makro ve çalışma zamanı ifadelerden farklı olarak anahtarlar (sol taraf) veya değerler (sağ taraf) olarak görünebilir. Aşağıdakiler geçerlidir: ${{ variables.key }} : ${{ variables.value }} .

Çalışma zamanı ifadesi söz dizimi

Çalışma zamanında genişletilen değişkenler için çalışma zamanı ifadesi söz dizimi kullanabilirsiniz ( $[variables.var] ). Çalışma zamanı ifadesi değişkenleri, değiştirme değeri bulunamadıklarında boş dizelerle sessizce biriker. Çalışma zamanı ifadeleri, işlerin koşullu yürütülmesini veya tüm aşamaları desteklemek için işlerin koşullarında kullanılacak şekilde tasarlanmıştır.

Çalışma zamanı ifadesi değişkenleri yalnızca bir değer için kullanılırken genişletilir, anahtar sözcük olarak değil. Değerler, bir işlem hattı tanımının sağ tarafında görünür. Aşağıdakiler geçerlidir: key: $[variables.value] . Aşağıdakiler geçerli değildir: $[variables.key]: value . Çalışma zamanı ifadesi bir anahtar-değer çiftinin sağ tarafının tamamını al olmalıdır. Örneğin, key: $[variables.value] geçerlidir ancak key: $[variables.value] foo geçerli değildir.

Syntax Örnek Ne zaman işlenir? İşlem hattı tanımında nerede genişler? Bulunamasa nasıl işler?
Makro $(var) bir görev yürütülmeden önce çalışma zamanı değer (sağ taraf) Baskı $(var)
şablon ifadesi ${{ variables.var }} derleme zamanı anahtar veya değer (sol veya sağ taraf) boş dize
çalışma zamanı ifadesi $[variables.var] çalışma zamanı değer (sağ taraf) boş dize

Hangi söz dizimi kullan gerekir?

Bir görev için giriş sağlıyorsanız makro söz dizimi kullanın.

Koşullar ve ifadelerle çalışıyorsanız bir çalışma zamanıifadesi seçin. Bunun istisnası, boş değişkeninizin yazdırılırken soruna neden olacak bir işlem hattınız varsa geçerli olur. Örneğin, belirli bir değere sahip olan veya değer belirten bir değişkene dayanan koşullu mantığın olması. Bu durumda, bir çalışma zamanı ifadesi kullan gerekir.

Bir şablonda değişken tanım kullanıyorsanız şablon ifadesi kullanın.

İşlem hattında değişkenleri ayarlama

En yaygın durumda, değişkenleri ayarlar ve YAML dosyasında kullanırsanız. Bu, sürüm denetimi sisteminiz içinde değişkende yapılan değişiklikleri izlemenizi sağlar. Ayrıca işlem hattı ayarları kullanıcı arabiriminde değişkenleri tanımlayabilir (Klasik sekmesine bakın) ve YAML'nize başvurabilirsiniz.

Ve olmak üzere iki değişkeni ayarlamayı ve bunları daha sonra adımlarda kullanmayı configuration gösteren bir örnek burada ve ve ve platform 2. YAML deyiminde bir değişken kullanmak için içinde $() sarman. Değişkenler YAML deyiminde tanımlamak repository 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 ayarlayın:

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

YAML'nin en üstünde bir değişken tanımlandığı zaman, işlem hattında tüm işler ve aşamalar tarafından 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üzeydeki 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ş de şu şekilde olur:

# job1
value 
value1
value1

# job2
value
value2
value

Değişkenleri belirtme

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

Değişken şablonları veya değişken grupları kullanmak istediğinizde yararlı olan başka bir sözdizimi vardır. Bu söz dizimi bir işlem hattının kök düzeyinde kullanılmalıdır.

Bu alternatif söz variables dizimsinde anahtar sözcüğü, değişken belirleyicilerinin listesini alır. Değişken belirleyicileri name normal bir değişkene, group bir değişken grubuna ve bir değişken template şablonuna dahildir. Aşağıdaki örnek üçünü de gösteriyor.

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şkeni yeniden kullanma hakkında daha fazla bilgi.

Ortam üzerinden değişkenlere erişme

Değişkenlerin ortam değişkenleri aracılığıyla betikler için de kullanılabilir olduğunu fark edersiniz. Bu ortam değişkenlerini kullanma söz dizimi, betik diline bağlıdır.

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

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

Önemli

Dosya yolları içeren önceden tanımlanmış değişkenler, aracı konak türüne ve kabuk türüne göre uygun stile (Windows stili C:\foo\ ve Unix stili /foo/) çevrilir. Windows üzerinde bash betik görevleri çalıştırdısanız, doğru dosya yolu stiline sahip olduğundan emin olmak için işlem hattı değişken yöntemi yerine bu değişkenlere erişmek için ortam değişkeni yöntemini kullanmalıdır.

TFS'de YAML desteklenmiyor.

Gizli dizi değişkenlerini ayarlama

YAML dosyanıza gizli değişkenler ayarlanmayabilirsiniz. İşletim sistemleri genellikle çalıştırıldıları işlemler için komutlar günlüğe kaydedilir ve günlüğün giriş olarak geçirilen gizli bilgileri içermesini istemeyebilirsiniz. Komut dosyasının ortamını kullanın veya blok içindeki değişkeni variables eşler ve gizli dizileri işlem hattınıza iletir.

İşlem hattınız için işlem hattı ayarları kullanıcı arabiriminde gizli dizi değişkenlerini ayarlamanız gerekir. Bu değişkenlerin kapsamı, bunları ayarlandırarak işlem hattına göre ayarlanır. Gizli dizi değişkenlerini değişken gruplarında da ayarleyebilirsiniz.

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

  1. Pipelines 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şkenler'i bulun.
  3. Değişkeni ekleyin veya güncelleştirin.
  4. Değişkeni şifrelenmiş bir şekilde depolamak için Gizli kilit simgesini seçin.
  5. İşlem hattını kaydedin.

Gizli değişkenler 2048 bit RSA anahtarıyla istirahatta şifrelenir. Gizli diziler, görevler ve betikler için aracıda kullanılabilir. İşlem hattınızı değiştirme erişimi olan kişi hakkında dikkatli olun.

Önemli

Gizli dizilerin çıkışta görünmesini Azure Pipelines ama yine de önlemler alacağız. Hiçbir zaman çıkış olarak gizli dizileri yankılayın. Bazı işletim sistemleri komut satırı bağımsız değişkenlerini günlüğe kopyalar. Gizli dizileri komut satırına hiçbir zaman geçme. Bunun yerine, gizli dizilerinizi ortam değişkenlerine eşlemenizi öneririz.

Gizli dizilerin alt dizelerini hiçbir zaman maskelemeziz. Örneğin, "abc123" gizli dizi olarak ayarlanırsa günlüklerden "abc" maskelemez. Bu, gizli dizileri bir düzeyde çok ayrıntılı olarak maskelemenin önüne geçerek günlükleri okunamaz hale etmektir. Bu nedenle gizli diziler yapılandırılmış veriler içermez. Örneğin, "{ "foo": "bar" }" gizli dizi olarak ayarlanırsa, "çubuk" günlüklerden maskelemez.

Normal bir değişkenden farklı olarak, betikler için ortam değişkenlerinin şifresi otomatik olarak çözülz. Gizli değişkenleri açıkça eşlemelisiniz.

Aşağıdaki örnekte, PowerShell ve Bash betikleri içinde adlı mySecret bir gizli dizi değişkeninin nasıl kullanıldığı gösterir. Normal bir işlem hattı değişkenden farklı olarak adlı bir ortam değişkeni MYSECRET yoktur.

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 betikte yer alan her iki görevden de çıktı şöyle olur:

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 değişkenleri betiklerin dışında da kullanabilirsiniz. Örneğin, tanımını kullanarak gizli değişkenleri görevlerle variables eşleyebilirsiniz. Bu örnekte, gizli değişkenlerin ve $(vmsUser) bir Azure dosya kopyalama $(vmsAdminPass) görevinin nasıl kullanımına sahip olduğu gösterir.

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 değişkenlere başvuru

Bu örnekte YAML dosyanız içindeki bir değişken grubuna nasıl başvurabilirsiniz ve ayrıca YAML içinde değişkenler ekleyebilirsiniz. Değişken grubundan kullanılan iki değişken vardır: user ve token . değişkeni token gizlidir ve YAML'de başvurulacak şekilde ortam $env:MY_MAPPED_TOKEN değişkeniyle eşlenmiş.

Bu YAML, sürüm listesini almak için bir REST çağrısı yapar ve sonucun çıkışını oluşturur.

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

Önemli

Varsayılan olarak GitHub depolarda, işlem hattınız ile ilişkili gizli değişkenler, çekme isteği derlemeleri için kullanılamaz. Daha fazla bilgi için bkz. Forks'tan katkılar.

TFS'de YAML desteklenmiyor.

İşlem hatları arasında değişkenleri paylaşma

Projenizin birden çok işlem hattında değişkenleri paylaşmak için web arabirimini kullanın. Kitaplık altındadeğişken gruplarını kullanın.

Görevlerden çıkış değişkenlerini kullanma

Bazı görevler, aşağı akış adımlarında, işlerde ve aşamalarda tüketebilirsiniz çıkış değişkenlerini tanımlar. YAML'de bağımlılıkları kullanarak işler ve aşamalar arasındaki değişkenlere erişebilirsiniz.

Bazı görevler, aşağı akış adımlarında ve işlerinde aynı aşamada tüketebilirsiniz çıkış değişkenlerini tanımlar. YAML'de bağımlılıkları kullanarak işler arasında değişkenlere erişebilirsiniz.

Bazı görevler, aynı iş içindeki aşağı akış adımlarında tüketebilirsiniz çıkış değişkenlerini tanımlar.

Not

Varsayılan olarak, bir işlem hattında yer alan her aşama YAML dosyasından hemen önceki aşamaya bağlıdır. Geçerli aşamadan hemen önce olmayan bir aşamaya başvurursanız, aşamaya bir bölüm ekleyerek bu otomatik dependsOn varsayılanı geçersiz kılabilirsiniz.

Not

Aşağıdaki örneklerde standart işlem hattı söz dizimi kullanılır. Dağıtım işlem hatlarını kullanıyorsanız hem değişken hem de koşullu değişken söz dizimi farklılık gösterir. Belirli bir söz dizimi hakkında daha fazla bilgi için bkz. Dağıtım işleri.

Bu örnekler için adlı bir çıkış değişkeni ayaran MyTask adlı bir görev olduğunu varsayalım. MyVar İfadeler - Bağımlılıklar içinde söz dizimi hakkında daha fazla bilgi edinmek için bkz..

Aynı işteki çıkışları kullanma

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
- script: echo $(ProduceVar.MyVar) # this step uses the output variable

Çıkışları farklı bir işte kullanma

jobs:
- job: A
  steps:
  # assume that MyTask generates an output variable called "MyVar"
  # (you would learn that from the task's documentation)
  - task: MyTask@1
    name: ProduceVar  # because we're going to depend on it, we need to name the step
- job: B
  dependsOn: A
  variables:
    # map the output variable from A into this job
    varFromA: $[ dependencies.A.outputs['ProduceVar.MyVar'] ]
  steps:
  - script: echo $(varFromA) # this step uses the mapped-in variable

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

İş düzeyinde farklı bir aşamadaki çıkışı kullanmak için söz dizimi stageDependencies kullanılır.

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

Ayrıca, bir dosya girişi ile aşamalar arasında değişkenler de geçebilirsiniz. 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çmenizi 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ında aşamaların çıktısı aşağıdaki gibi olur:

Hello inline version
true
crushed tomatoes

Değişkenleri listele

az pipelines variable list komutuyla işlem hattınıza tüm değişkenleri listeleyebilirsiniz. Çalışmaya başlama için bkz. Kullanmaya başlayın CLI ile Azure DevOps.

az pipelines variable list [--org]
                           [--pipeline-id]
                           [--pipeline-name]
                           [--project]

Parametreler

  • org:Azure DevOps URL'si. Varsayılan kuruluşu kullanarak az devops configure -d organization=ORG_URL yapılandırarak. Varsayılan olarak yapılandırılmamışsa veya kullanılarak toplanmazsa git config gereklidir. Örnek: --org https://dev.azure.com/MyOrganizationName/.
  • pipeline-id:İşlem hattı-adı sağlanmadı ise gereklidir. İşlem hattının kimliği.
  • işlem hattı-adı:pipeline-id sağlanmadı ise gereklidir, ancak pipeline-id sağlanırsa yoksayılır. İşlem hattının adı.
  • project: Projenin adı veya kimliği. Varsayılan projeyi kullanarak az devops configure -d project=NAME_OR_ID yapılandırarak. Varsayılan olarak yapılandırılmamışsa veya kullanılarak toplanmazsa git config gereklidir.

Örnek

Aşağıdaki komut, işlem hattındaki tüm değişkenleri KIMLIĞI 12 ile listeler ve sonucu tablo biçiminde gösterir.

az pipelines variable list --pipeline-id 12 --output table

Name           Allow Override    Is Secret    Value
-------------  ----------------  -----------  ------------
MyVariable     False             False        platform
NextVariable   False             True         platform
Configuration  False             False        config.debug

Betiklerdeki değişkenleri ayarlama

İşlem hattınızdaki bir betik, ardışık düzendeki sonraki adımlardan biri tarafından tüketilebilmesi için bir değişken tanımlayabilir. Bu yöntem tarafından ayarlanan tüm değişkenler dizeler olarak değerlendirilir. Bir betikten bir değişken ayarlamak için bir komut söz dizimini kullanır ve STDOUT ' a yazdırabilirsiniz.

Bir betikten iş kapsamındaki değişken ayarlama

Bir betikten bir değişken ayarlamak için, task.setvariabletask.setvariablekullanın. Bu, sonraki işlerin ortam değişkenlerini güncelleştirir. Sonraki işlerin, makro söz dizimi ve görevlerde ortam değişkenleri olarak yeni değişkene erişimi olur.

issecretTrue olarak ayarlandığında, değişkenin değeri gizli olarak kaydedilir ve günlüğünden maskelenir. Gizli değişkenler hakkında daha fazla bilgi için bkz. Logging 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 ortamlarına de 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ının çıktısı.

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

Çoklu iş çıkış değişkeni ayarlama

Bir değişkeni gelecekteki işleri için kullanılabilir hale getirmek istiyorsanız, öğesini kullanarak bir çıktı değişkeni olarak işaretlemeniz gerekir isOutput=true . Ardından, $[] sözdizimini kullanarak ve değişkeni ayarlanan adım adı dahil olmak üzere bunu gelecekteki işlerle eşleyebilirsiniz. Çoklu iş çıktısı 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özdizimini kullanın.

Not

Varsayılan olarak, bir işlem hattındaki her aşama, YAML dosyasında hemen öncesine göre değişir. Bu nedenle, her aşama önceki aşamada çıkış değişkenlerini kullanabilir. Daha fazla aşamaya erişmek için, bağımlılık grafiğini değiştirmeniz gerekir, örneğin, 2. Aşama 1. aşama için bir değişken gerektiriyorsa, 1. aşama üzerinde açık bir bağımlılık bildirmeniz gerekir.

Çoklu iş çıkış değişkeni oluşturduğunuzda, ifadeyi bir değişkene atamanız gerekir. Bu YAML 'de $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] değişkenine atanır $(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-18.04'
  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ının çıktısı.

this is the value
this is the value

Bir aşamayı bir aşamadan diğerine ayarlarsanı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)

Bir matris veya dilimdenbir değişken ayarlıyorsanız, bir aşağı akış işinden eriştiğinizde değişkene başvurmak için şunu dahil etmeniz gerekir:

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

# Set an output variable from a job with a matrix
- job: A
  pool:
    vmImage: 'ubuntu-18.04'
  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-18.04'
  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-18.04'
    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-18.04'
  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 önek olarak belirttiğinizden emin olun. Bu durumda, iş adı şu şekilde olur A :

jobs:

# Set an output variable from a deployment
- deployment: A
  pool:
    vmImage: 'ubuntu-18.04'
  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-18.04'
  variables:
    myVarFromDeploymentJob: $[ dependencies.A.outputs['A.setvarStep.myOutputVar'] ]
  steps:
  - bash: "echo $(myVarFromDeploymentJob)"
    name: echovar

YAML, TFS 'de desteklenmez.

İfadeleri kullanarak değişkenleri ayarlama

Bir ifade kullanarak bir değişken ayarlayabilirsiniz. Bir değişkeni önceki bir işten başka bir şekilde ayarlamak için bu bir durum ile zaten karşılaştık.

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

Bir değişken ayarlamak için desteklenen ifadelerden herhangi birini kullanabilirsiniz. İşte, 100 ' de başlayan bir sayaç görevi gören bir değişken ayarlamaya yönelik bir örnek, her çalıştırma için 1 ' den arttırılır ve her gün 100 ' e sıfırlanır.

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.

YAML, TFS 'de desteklenmez.

Adımlar için ayarlanabilir değişkenleri yapılandırın

settableVariablesBir adım içinde tanımlayabilir veya hiçbir değişkenin ayarlanbileceğine ilişkin bir değişken belirtebilirsiniz.

Bu örnekte, betik bir değişken ayarlayamazsınız.

steps:
- script: echo This is a step
  target:
    settableVariables: none

Bu örnekte, komut dosyası değişkene izin verir, sauce ancak değişkenine izin vermez secretSauce . İşlem hattı çalıştırma sayfasında bir uyarı görürsünüz.

SecretSauce ayarlayaamadığına dikkat edin.

steps:
  - bash: |
      echo "##vso[task.setvariable variable=Sauce;]crushed tomatoes"
      echo "##vso[task.setvariable variable=secretSauce;]crushed tomatoes with garlic"
    target:
     settableVariables:
      - sauce
    name: SetVars
  - bash: 
      echo "Sauce is $(sauce)"
      echo "secretSauce is $(secretSauce)"
    name: OutputVars

Kuyruk zamanında izin ver

Bir variables YAML dosyasının bloğunda bir değişken görünürse, değeri sabittir ve kuyruk sırasında geçersiz kılınamaz. En iyi yöntem, değişkenlerinizi bir YAML dosyasında tanımlamaktır ancak bazen bunun anlamlı olmadığını fark edersiniz. Örneğin, bir gizli değişken tanımlamak istiyor ve değişkeni YAML'nize açık istemiyor olabilir. Veya işlem hattı çalıştırması sırasında el ile bir değişken değeri 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ırarak bu değeri geçersiz k kullanmasına izin ver seçeneğini belirtebilirsiniz veya bunun yerine çalışma zamanı parametrelerini kullanabilirsiniz. Değişkeniniz gizli bir gizli değişkense en iyi yöntem çalışma zamanı parametrelerini kullanmaktır.

Kuyruk zamanında 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.

Kuyruk zamanında bir değişken ayarlayın.

Bir değişkenin kuyruk zamanında ayarlanmalarına izin vermek için değişkenin işlem hattı veya iş variables bloğunda da görünmey olduğundan emin olun. Hem YAML'nin hem de kullanıcı arabiriminin değişken bloğunda bir değişken tanımlarsanız YAML'nin değeri önceliklidir.

TFS'de YAML desteklenmiyor.

Değişkenlerin genişletilmesi

Birden çok kapsamda aynı adla bir değişken ayar her zaman aşağıdaki öncelik uygulanır (önce en yüksek öncelik).

  1. YAML dosyasında ayarlanmış iş düzeyi değişkeni
  2. YAML dosyasında ayarlanmış aşama düzeyi değişken
  3. YAML dosyasında ayarlanmış işlem hattı düzeyi değişken
  4. Kuyruk zamanında ayarlanmış değişken
  5. İşlem hattı ayarları kullanıcı arabiriminde ayarlanmış 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 ayarlanır. Ayrıca, bir değişken grubunda ve İşlem hattı G ayarları kullanıcı arabiriminde bir 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ı adla bir değişken ayar farklı olduğunda, son ayar değeri ö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

Not

YAML dosyasında bir değişken ayarladığınız zaman, bunu web düzenleyicisinde kuyruk zamanında ayarlanabilir olarak tanımlamayın. Şu anda YAML dosyasında kuyruk sırasında ayarlanmış değişkenleri değiştiremezsiniz. Bir değişkenin kuyruk sırasında ayarlanabilir olması gerekirse YAML dosyasında ayarlanamayan bir değişkene ihtiyacınız vardır.

Değişkenler, çalıştırma başlatıldıktan sonra ve her adımın başında tekrar 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

Yukarıdaki örnekte iki adım yer alan bir adımdır. genişletmesi, işin başında bir kez ve iki $(a) adımın her biri başında gerçekleşir.

Değişkenler işin başında genişletildiklerine göre, bunları bir stratejide kullanamazsiniz. Aşağıdaki örnekte, değişkeni yalnızca her genişletilmiş işin başında kullanılabilir olduğundan, iş matrisini genişletmek için a değişkenini kullanasınız.

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

Değişken, a önceki bir işin çıktı değişkeni ise, 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'] ]

Recursive genişletme

Aracıda söz dizimi kullanılarak $( ) başvurulan değişkenler, tekrar tekrar 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"

TFS'de YAML desteklenmiyor.