Aracılığıyla paylaş

Değişkenleri tanımlama

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

Değişkenler, işlem hattının çeşitli bölümlerine anahtar verileri eklemek için kullanışlı bir yol sağlar. Değişkenlerin en yaygın kullanımı, işlem hattınızda kullanabileceğiniz bir değer tanımlamaktır. Tüm değişkenler dizedir ve değiştirilebilir. Bir değişkenin değeri çalıştırmadan çalıştırmaya veya işlem hattınızdaki işten işe değişebilir.

Aynı değişkeni aynı ada sahip birden çok yerde tanımladığınızda, en yerel olarak kapsamlı değişken önceliklidir. Bu nedenle, iş düzeyinde tanımlanan bir değişken, aşama düzeyinde ayarlanan bir değişkeni geçersiz kılabilir. Aşama düzeyinde tanımlanan bir değişken, işlem hattı kök düzeyinde bir değişken kümesini geçersiz kılar. İşlem hattı kök düzeyinde ayarlanan bir değişken, İşlem hattı ayarları kullanıcı arabirimindeki bir değişken kümesini geçersiz kılar. İş, aşama ve kök düzeyinde tanımlanan değişkenlerle çalışma hakkında daha fazla bilgi edinmek için bkz. Değişken kapsamı.

Değerleri koşullu olarak atamak ve pipelines daha fazla özelleştirmek için değişkenleri expressions ile kullanabilirsiniz.

Değişkenler çalışma zamanı parametrelerinden farklıdır. Çalışma zamanı parametreleri yazılır ve şablon ayrıştırması sırasında kullanılabilir.

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

Bir değişken tanımlarken , farklı söz dizimleri (makro, şablon ifadesi veya çalışma zamanı) kullanın. Seçtiğiniz söz dizimi, değişkeninizin işlem hattında nerede işleneceğini belirler.

YAML pipeline'larda, değişkenleri kök, aşama ve iş seviyelerinde ayarlar. Kullanıcı arabiriminde YAML işlem hattının dışındaki değişkenleri de belirtebilirsiniz. Kullanıcı arabiriminde bir değişken ayarladığınızda, değişkeni şifreleyebilir ve gizli dizi olarak ayarlayabilirsiniz.

Kullanıcı tanımlı değişkenler salt okunabilir olarak ayarlanabilir. Değişkenler için adlandırma kısıtlamaları vardır (örnek: değişken adının başında kullanamazsınızsecret).

Bir değişken grubunu kullanarak değişkenleri birden fazla ardışık düzende kullanılabilir hale getirebilirsiniz.

Birden çok pipelines kullanmak üzere bir dosyada değişkenleri tanımlamak için templates kullanın.

Kullanıcı tanımlı çok satırlı değişkenler

Azure DevOps çok satırlı değişkenleri destekler, ancak birkaç sınırlama vardır.

İşlem hattı görevleri gibi aşağı akış bileşenleri değişken değerlerini doğru işleyemeyebilir.

Azure DevOps, kullanıcı tanımlı değişken değerlerini değiştirmez. Değişken değerlerini çok satırlı değişkenler olarak geçirmeden önce doğru şekilde biçimlendirmeniz gerekir. Değişkeninizi biçimlendirirken özel karakterlerden kaçının, kısıtlı adlar kullanmayın ve aracınızın işletim sistemi için uygun bir satır bitiş biçimi kullandığınızdan emin olun.

Çok satırlı değişkenler, işletim sistemine bağlı olarak farklı davranır. Bu sorunu önlemek için, hedef işletim sistemi için çok satırlı değişkenleri doğru biçimlendirdiğinizden emin olun.

Azure DevOps, desteklenmeyen biçimlendirme sağlasanız bile değişken değerlerini hiçbir zaman değiştirmez.

Sistem değişkenleri

Kullanıcı tanımlı değişkenlere ek olarak, Azure Pipelines önceden tanımlanmış değerlere sahip sistem değişkenleri vardır. Örneğin, önceden tanımlanmış Build.BuildId değişkeni her derlemenin kimliğini verir ve farklı işlem hattı çalıştırmalarını tanımlamak için kullanılabilir. Değişkeni, benzersiz bir değere ihtiyacınız olduğunda betiklerde veya görevlerde kullanabilirsiniz Build.BuildId .

YAML veya klasik derleme boru hatlarını kullanıyorsanız, sistem değişkenlerinin kapsamlı listesi için bakınız önceden tanımlanmış değişkenler.

Klasik sürüm pipelines kullanıyorsanız bkz. release variables.

İşlem hattını çalıştırdığınızda sistem değişkenleri geçerli değerlerini ayarlar. Bazı değişkenler otomatik olarak ayarlanır. İşlem hattı yazarı veya son kullanıcı olarak, işlem hattı çalışmadan önce sistem değişkeninin değerini değiştirebilirsiniz.

Sistem değişkenleri salt okunur.

Ortam değişkenleri

Ortam değişkenleri, kullandığınız işletim sistemine özeldir. Bunları platforma özgü yollarla bir işlem hattına eklersiniz. Ortam değişkenlerinin, belirli betik platformunuz için nasıl biçimlendirileceğine karşılık gelir.

UNIX sistemlerinde (macOS ve Linux) ortam değişkenleri biçimindedir $NAME. Windows'da, toplu işlem dosyası için biçim %NAME%, PowerShell'de ise $env:NAME şeklindedir.

Sistem ve kullanıcı tanımlı değişkenler (gizli dizi değişkenleri hariç) platformunuz için ortam değişkenleri olarak da eklenmiştir. Değişkenler ortam değişkenlerine dönüştüğünde, değişken adları büyük harflerle yazılır ve noktalar alt çizgiye dönüşür. Örneğin, değişken adı any.variable değişken adı $ANY_VARIABLEolur.

Ortam değişkenleri için değişken adlandırma kısıtlamaları vardır (örnek: değişken adının başında kullanamazsınızsecret).

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

Kullanıcı tanımlı ve ortam değişkenleri harf, sayı .ve _ karakterlerden oluşabilir. Sistem tarafından ayrılmış değişken ön eklerini kullanmayın. Bu ön ekler şunlardır: endpoint, input, secret, pathve securefile. Bu dizelerden biriyle başlayan herhangi bir değişken (büyük harfe çevirmeden) görevleriniz ve betikleriniz tarafından kullanılamaz. Değişkenlerde boşluk kullanmayın. Ek kısıtlamalar için bkz. Azure Pipelines adlandırma kısıtlamaları.

Değişken söz dizimlerini anlama

Azure Pipelines, değişkenlere başvurmak için üç farklı yolu destekler: makro, şablon ifadesi ve çalışma zamanı ifadesi. Her söz dizimlerini farklı bir amaç için kullanabilirsiniz ve her birinin bazı sınırlamaları vardır.

İş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)) çalışma zamanı sırasında bir görev çalıştırılmadan önce işlenir. Çalışma zamanı ifadeleri ($[variables.var]) çalışma zamanı sırasında da işlenir, ancak koşullar ve ifadelerle kullanılması amaçlanır. Bir çalışma zamanı ifadesi kullandığınızda tanımın sağ tarafının tamamını kaplaması gerekir.

Bu örnekte, değişken güncelleştirildikten sonra şablon ifadesinin değişkenin başlangıç değerine sahip olduğunu görebilirsiniz. Makro söz dizimi değişkeninin değeri güncelleştirilir. İşlem hattı tüm şablon ifadesi değişkenlerini görevler çalışmadan önce derleme zamanında işlediğ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

Belge örneklerinin çoğunda makro söz dizimi ($(var) kullanılır). Değişken değerlerini görev girişlerine ve diğer değişkenlere ilişkilendirmek için makro söz dizimlerini kullanın.

Sistem, çalışma zamanı sırasında bir görev yürütülmeden önce değişkenleri makro söz dizimi ile işler. Çalışma zamanı, şablon genişletildikten sonra gerçekleşir. Sistem bir makro ifadesiyle karşılaştığında, ifadeyi değişkeninin içeriğiyle değiştirir. Belirtilen isimde bir değişken yoksa, makro ifadesi değişmez. Örneğin, değiştirilemiyorsa $(var) olarak $(var)kalır.

Makro söz dizimi değişkenleri, değer olmadığında değişmeden kalır çünkü örneğin $() , çalıştırdığınız göreve bir şey ifade edebilir ve aracı bu değerin değiştirilmesini istediğinizi varsaymamalıdır. Örneğin, Bash görevinde $(foo) kullanarak foo değişkenine başvurursanız, göreve girişteki tüm $() ifadeleri değiştirmeniz Bash betiklerinizi bozabilir.

Makro değişkenleri yalnızca bir değer için kullanıldığında genişler, anahtar sözcük olarak değil. Değerler, 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ğil: $(key): value. Makro değişkenler iş adını satır içinde görüntülemek için kullanıldığında genişletilmez. Bunun yerine özelliğini kullanmanız displayName gerekir.

Not

Sistem yalnızca , ve stagesiçindeki jobsgörev girişleri için makro söz dizimi steps genişletir. Derleme zamanında çözümlenen işlem hattı anahtar sözcüklerinde, örneğin adımların resources, trigger, veya checkout depo başvuru değeri (checkout: git://MyProject/MyRepo@$(var) örneğin, çalışmaz) gibi olanlarda bunları genişletmez. Bu değerleri parametreleştirmek için bunun yerine şablon ifadelerini (${{ }}) veya çalışma zamanı parametrelerini kullanın.

Bu örnekte Bash, PowerShell ve bir betik göreviyle makro söz dizimi kullanılır. Makro söz dizimi kullanarak 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 ifade söz dizimi

Hem şablon parametrelerini hem de değişkenlerini (${{ variables.var }} ) genişletmek için şablon ifadesi söz dizimlerini kullanın. Sistem, derleme zamanında şablon değişkenlerini işler ve çalışma zamanı başlamadan önce bunları değiştirir. YAML'nin bölümlerini şablon olarak yeniden kullanmak için şablon ifadelerini kullanın.

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

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

Çalışma zamanında ($[variables.var]) genişleyen değişkenler için çalışma zamanı ifadesi söz dizimlerini kullanın. Çalışma zamanı ifade değişkenleri, değiştirme değeri bulunamadığında sessizce boş dizelerle birleşti. İşlerin veya tüm aşamaların koşullu yürütülmesini desteklemek için iş koşullarında çalışma zamanı ifadelerini kullanın.

Çalışma zamanı ifade değişkenleri, anahtar sözcük olarak değil, yalnızca bir değer için kullanıldığında genişler. Değerler, 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ğil: $[variables.key]: value. Çalışma zamanı ifadesi bir anahtar-değer çiftinin sağ tarafının tamamını kaplamalıdır. Örneğin, key: $[variables.value] geçerli ancak key: $[variables.value] foo geçerli değil.

Sözdizimi Örnek Ne zaman işlenir? İşlem hattı tanımında nerede genişletiliyor? Bulunamadığında nasıl görünür?
Makro $(var) görev yürütülmeden önce çalışma zamanı değer (sağ taraf) Yazdırır $(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 dizimlerini kullanmalıyım?

Görev için güvenli bir dize veya önceden tanımlanmış değişken girişi sağlıyorsanız makro söz dizimi kullanın.

Koşullar ve [ifadeler](expressions.md] ile çalışıyorsanız bir çalışma zamanı ifadesi seçin. Ancak boş değişkeninizin yazdırılmasını istemiyorsanız çalışma zamanı ifadesi kullanmayın (örnek: $[variables.var]). Örneğin, belirli bir değere sahip olan veya değer içermeyen bir değişkeni kullanan koşullu mantığınız varsa, makro ifadesi kullanın.

Genellikle şablon değişkeni, kullanılacak standart değişkendir. şablon değişkenlerinden yararlanarak işlem hattınız işlem hattı derlemesinde değişken değerini işlem hattınıza tam olarak ekler. Bu enjeksiyon, işlem hatlarında hata ayıklamaya çalışırken yararlıdır. Günlük dosyalarını indirebilir ve yerine geçirilen tamamen genişletilmiş değeri değerlendirebilirsiniz. Değişken yerine yerleştirildiği için, hassas değerler için şablon söz dizimini kullanmayın.

Değişken söz dizimi sorunlarını belirlemek için yapay zeka kullanma

Copilot Sohbeti için bu örnek istem, bir işlem hattında hangi tür değişkenlerin kullanıldığını ve değişkenlerin ne zaman çözüleceğini tanımlar. YAML kodunuzu vurgulayın ve aşağıdaki Copilot Sohbet istemini girin.

What types of Azure DevOps variables are used in this YAML pipeline? Give specific examples.
When does each variable process in the pipeline? 
How will each variable render when not found? 
What stages and jobs will the variables be available for?

Gerekirse ayrıntıları eklemek için isteminizi özelleştirin.

Copilot yapay zeka ile desteklendiğinden sürprizler ve hatalar mümkündür. Daha fazla bilgi için Sıkça Sorulan Sorular bölümüne bakın.

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

En yaygın durumda, değişkenleri ayarlayın ve YAML dosyasında kullanın. Bu yaklaşım, 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ğıdaki örnek, iki değişken olan configuration ve platform nasıl ayarlanacağını ve adımlarda daha sonra nasıl kullanılacaklarını göstermektedir. YAML ifadesinde bir değişken kullanmak için onu $() içinde sarın. YAML deyiminde bir repository tanımlamak için değişkenleri kullanamazsınız.

# 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ü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.
  • Belirli bir iş için yalnızca iş düzeyinde kullanılabilir hale getirmek.

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 başka bir söz dizimi yararlıdır.

Şablonları kullanarak bir YAML dosyasında değişkenler tanımlayabilir ve bunları başka bir YAML dosyasına ekleyebilirsiniz.

Değişken grupları, birden çok boru hattında kullanabileceğiniz bir grup değişkendir. Değişken gruplarını kullanarak, çeşitli aşamalarda ortak olan değişkenleri tek bir yerde yönetebilir ve düzenleyebilirsiniz.

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

Daha fazla bilgi edinmek için bkz. Şablonlarla değişken yeniden kullanımı.

Değişkenlere ortam aracılığıyla eriş

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.

İsim büyük harfle yazılır 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

Önemli

Dosya yolları içeren tanımlı değişkenler, ajan ana bilgisayar türüne ve komut kabuğu türüne göre uygun stile (Windows stili C:\foo\ ile Unix stili /foo/) dönüştürülür. Windows üzerinde bash betik görevleri çalıştırıyorsanız, doğru dosya yolu stiline sahip olduğunuzdan emin olmak için işlem hattı değişkeni yöntemi yerine bu değişkenlere erişmek için ortam değişkeni yöntemini kullanmanız gerekir.

Gizli dizi değişkenlerini ayarlama

İpucu

Gizli dizi değişkenleri ortam değişkenleri olarak otomatik olarak dışarı aktarılamaz. Betiklerinizde gizli dizi değişkenlerini kullanmak için bunları ortam değişkenlerine açıkça eşleyin. Daha fazla bilgi için bkz. Gizli dizi değişkenlerini ayarlama.

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 bilgi içermesini istemezsiniz. Betiğin ortam değişkenini kullanın veya variables bloğundaki değişkene haritalayarak gizli bilgileri işlem hattınıza iletin.

Not

Azure Pipelines işlem hattı günlüklerine veri gönderirken gizli dizileri maskelemeye çaba gösterir, bu nedenle çıkışta ve günlüklerde gizli dizi olarak ayarlanmamış ek değişkenleri ve verileri maskelenmiş olarak görebilirsiniz.

İş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 ayarları ayarlamak için şu adımları izleyin:

  1. Pipelines sayfasına gidin, uygun işlem hattını seçin ve ardından Edit öğesini 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 değişkenler, depolama sırasında 2048 bitlik RSA anahtarıyla şifrelenir. Gizli bilgiler, görevlerde ve betiklerde kullanılmak üzere ajan üzerinde mevcuttur. İşlem hattınızı değiştirmek için kimin erişimi olduğu konusunda dikkatli olun.

Önemli

Gizli bilgilerin Azure Pipelines çıktısında görünmesini engellemeye çalışıyoruz, ancak yine de önlem almanız gerekir. Gizli bilgileri hiçbir zaman çıkış olarak yazdırmayın. Bazı işletim sistemleri komut satırı bağımsız değişkenlerini günlüğe kaydeder. Komut satırında gizli bilgileri hiçbir zaman geçirmeyin. Bunun yerine, gizli bilgilerinizi ortam değişkenlerine eşlemenizi öneririz.

Gizli dizilerin alt dizelerini asla maskelemeyiz. Örneğin, "abc123" bir gizli anahtar olarak ayarlandıysa, "abc" günlüklerde maskelenmez. Bu, gizlilikleri fazla ayrıntılı bir şekilde maskeleyerek günlükleri okunamaz hale getirmeyi önlemektir. Bu nedenle gizli diziler yapılandırılmış veriler içermemelidir. Örneğin, "{ "foo": "bar" }" gizli olarak ayarlanırsa, "bar" günlüklerden gizlenmez.

Normal bir değişkenin aksine, betikler için otomatik olarak ortam değişkenlerine şifre çö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 komut dosyası çalıştırır.

  • $(mySecret): Bu, gizli değişkene doğrudan başvurudur ve çalışır.
  • $env:MYSECRET: Bu, gizli değişkenleri ortam değişkeni olarak erişmeye çalışır, ancak gizli değişkenler otomatik olarak ortam değişkenleriyle eşlenmez, bu nedenle işe yaramaz.
  • $env:GLOBAL_MYSECRET: Bu, gizli değişkene genel bir değişken aracılığıyla erişmeye çalışır, ancak gizli değişkenler bu şekilde eşlenemediğinden bu da çalışmaz.
  • $env:GLOBAL_MY_MAPPED_ENV_VAR: Bu, gizli olmayan değişkene bir genel değişken aracılığıyla erişim sağlar.
  • $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 betikte yer alan her iki görevin çıktısı şu şekildedir:

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, variables tanımını kullanarak gizli değişkenleri görevlere eşleyebilirsiniz. Bu örnekte, Azure dosya kopyalama görevinde $(vmsUser) ve $(vmsAdminPass) gizli değişkenlerinin nasıl kullanılacağı gösterilmektedir.

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

Değişken gruplarında gizli değişkenlere 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. Örnekte değişken grubundan iki değişken kullanılır: user ve token. Değişken token gizli dizidir ve YAML'de başvurabilmeniz 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

Önemli

Varsayılan olarak, GitHub depolarında, çatalların çekme isteği oluşturma işlemleri işlem hattınızla ilişkili gizli dizi değişkenlerine erişemez. Daha fazla bilgi için bkz. Çatallardan yapılan katkılar.

Hatlar arasında değişkenlerin paylaşılması

Projedeki birden çok iş akışı arasında değişkenleri paylaşmak için web arabirimini kullanın. Kitaplık altında değişken gruplarını kullanın.

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

Bazı görevler çıkış değişkenlerini tanımlar. Bu değişkenleri aşağı akış adımlarında, işlerde ve aşamalarda kullanabilirsiniz. YAML'de dependencies kullanarak işler ve aşamalardaki değişkenlere erişebilirsiniz.

Aşağı akış görevlerinde matris işlerine başvururken farklı bir söz dizimi kullanın. Bkz Çok işli çıkış değişkeni ayarlama. Ayrıca dağıtım işlerindeki değişkenler için farklı bir söz dizimi kullanmanız gerekir. Bkz: Dağıtım işlerinde çıkış değişkenleri desteği.

  • Aynı iş içindeki farklı bir görevden bir değişkene başvurmak için kullanın TASK.VARIABLE.
  • Farklı bir işteki bir görevden bir değişkene başvurmak için kullanın dependencies.JOB.outputs['TASK.VARIABLE'].

Not

Varsayılan olarak, bir işlem hattındaki 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şvurmanız gerekiyorsa, aşamaya bir dependsOn bölüm ekleyerek bu otomatik varsayılanı geçersiz kılabilirsiniz.

Not

Aşağıdaki örneklerde standart işlem hattı söz dizimi kullanılır. Dağıtım ardışık düzenlerini kullanıyorsanız, hem değişken hem de koşullu değişken söz dizimi farklılık gösterecektir. Kullanılacak söz dizimi hakkında bilgi için Dağıtım işleri bölümüne bakınız.

Bu örneklerde, MyVar adlı bir çıkış değişkenini ayarlayan MyTask adlı bir göreviniz olduğunu varsayalım. İfadeler - Bağımlılıklar'da söz dizimi hakkında daha fazla bilgi edinin.

Aynı işte çıkışları kullan

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

Çıktıları farklı bir işte kullanın

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

Farklı bir aşamadan gelen çıktıyı kullanmak için, değişkenlere başvurmak üzere stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE'] biçimini kullanın. 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şi kullanarak aşamalar arasında değişken geçirebilirsiniz. Bunu yapmak için, görev seviyesinde ikinci aşamada değişkenleri tanımlamanız ve sonra değişkenleri env: giriş olarak geçirmeniz gerekiyor.

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

Değişkenleri listeleme

az pipelines variable list komutunu kullanarak işlem hattınızdaki tüm değişkenleri listeleyin. Başlamak için Azure DevOps CLI ile çalışmaya başlama konusuna bakınız.

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

Parametreler

  • org: Azure DevOps kuruluş URL'si. Varsayılan kuruluşu az devops configure -d organization=ORG_URL kullanarak yapılandırın. Varsayılan olarak yapılandırılmadıysa veya git config kullanılarak elde edilmediyse gereklidir. Örnek: --org https://dev.azure.com/MyOrganizationName/.
  • pipeline-id: Pipeline-name sağlanmadığında gereklidir. İşlem hattının kimliği.
  • pipeline-name: eğer pipeline-id sağlanmazsa gereklidir, fakat pipeline-id sağlandığında göz ardı edilir. İşlem hattının adı.
  • project: project adı veya kimliği. az devops configure -d project=NAME_OR_ID kullanarak varsayılan project yapılandırın. Varsayılan olarak yapılandırılmadıysa veya git config kullanılarak elde edilmediyse gereklidir.

Örnek

Aşağıdaki komut, işlem hattındaki 12 kimliğine sahip tüm değişkenleri 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

Betiklerde değişkenleri ayarlama

Betikler, işlem hattındaki sonraki adımların tükettiği değişkenleri tanımlayabilir. Bu yöntem tarafından ayarlanan tüm değişkenler dize olarak değerlendirilir. Bir betikten değişken ayarlamak için bir komut söz dizimi kullanın ve stdout'a yazdırın.

Komut dosyasından görev kapsamlı bir değişken ayarlama

Bir betikten bir değişken ayarlamak için task.setvariablegünlük komutunu kullanın. Bu komut, izleyen işler için ortam değişkenlerini güncelleştirir. Sonraki işler, macro söz dizimini ve görevlerde ortam değişkeni olarak kullanarak yeni değişkene erişebilir.

issecret’yi true olarak ayarladığınızda, değişkenin değeri gizli olarak kaydedilir ve günlükten gizlenir. 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 gelen çıktı.

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

Birden fazla iş için çıkış değişkeni ayarla

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.

Not

Varsayılan olarak, bir işlem hattındaki her aşama YAML dosyasından hemen önceki aşamaya bağlıdır. Bu nedenle, her aşama önceki aşamadan çıkış değişkenlerini kullanabilir. Diğer aşamaları access için bağımlılık grafiğini değiştirmeniz gerekir. Örneğin, 3. aşama 1. aşamadan bir değişken gerektiriyorsa, 1. aşamada açık bir bağımlılık bildirmeniz gerekir.

Çok işli bir çı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 $(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 gelen çı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)

matrix veya slice ile bir değişken ayarlıyorsanız, bu değişkene aşağı akış işinden erişmek için şunları eklemeniz gerekir:

  • İşin adı.
  • Bu 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

İfadeleri kullanarak değişkenleri ayarlama

İfade kullanarak değişken ayarlayabilirsiniz. Önceki bir işten başka bir değişkenin çıkışına bir değişken ayarladığınızda bu yaklaşımın bir örneğiyle zaten karşılaştınız.

- 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 davranan bir değişken ayarlama örneği verilmiştir.

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.

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

Bir adım içinde settableVariables tanımlayabilir veya değişkenlerin ayarlanamayacağını belirtebilirsiniz.

Bu örnekte, script bir değişken tanımlayamıyor.

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

Aşağıdaki örnekte betik değişkenini sauce ayarlayabilir ancak değişkenini secretSauceayarlayamaz. İşlem hattı çalıştırma sayfasında bir uyarı mesajı görürsünüz.

SecretSauce ayarlayamazsınız uyarısı. 

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

YaML dosyasının variables bloğunda bir değişken görünüyorsa, değeri sabittir ve kullanıcılar kuyruk zamanında bu değişkeni geçersiz kılamaz. Değişkenlerinizi bir YAML dosyasında tanımlayın, ancak bu yaklaşımın anlamlı olmadığı zamanlar vardır. Örneğin, bir gizli dizi değişkeni tanımlamak ve YAML'nizde kullanıma sunmamak 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 değilse, en iyi uygulama ç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. Yalnızca Sıra derleme yapılandırmayı düzenle iznine sahip kullanıcılar bir değişkenin değerini değiştirebilir.

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

Bir değişkenin kuyruklanma zamanında ayarlanmasına izin vermek için değişkenin bir iş hattı veya görev bloğu içerisinde 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.

Ek güvenlik için, kuyruk zamanı değişkenlerinde ayarlanabilir ve boolean ve tamsayılar gibi güvenli türler için önceden tanımlanmış bir değer kümesi kullanın. Dizeler için önceden tanımlanmış bir değer kümesi kullanın.

Değişkenlerin genişletilmesi

Birden çok kapsamda aynı ada sahip bir değişken ayarladığınızda, aşağıdaki öncelik uygulanır (ö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 belirlenen boru hattı düzeyi değişkeni
  4. Kuyruk zamanında ayarlanan değişken
  5. "İşlem hattı ayarları arayüzünde ayarlanan değişken"

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 değişken grubunda G ve Boruhattı 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

Not

YAML dosyasında bir değişken ayarladığınızda, bunu web düzenleyicisinde kuyruk zamanında ayarlanabilir olarak tanımlamayın. Şu anda kuyruk zamanında YAML dosyasında ayarlanan değişkenleri değiştiremezsiniz. Kuyruk sırasında bir değişkenin ayarlanması gerekiyorsa, değişkeni YAML dosyasında ayarlamayın.

Ç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şvurulan değişkenler ardışık 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"
  • Last updated on