Değişkenleri tanımlama
Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019
Değişkenler size işlem hattının çeşitli bölümlerine anahtar bitlerini almak için kullanışlı bir yol sağlar. Değişkenlerin en yaygın kullanımı, daha sonra işlem hattında kullanabileceğiniz bir değer tanımlamaktır. Tüm değişkenler dizedir ve değiştirilebilir. Değişkenin değeri işlem hattınızın her çalıştırmasında veya işinde değişebilir.
Aynı değişkeni aynı ada sahip birden çok yerde tanımladığınızda, en yerel kapsamlı değişken kazanır. 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 işlem hatlarını daha fazla özelleştirmek için ifadelerle değişkenleri 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ı) kullanabilirsiniz ve kullandığınız söz dizimi değişkeninizin işlem hattında nerede işleneceğini belirler.
YAML işlem hatlarında değişkenleri kök, aşama ve iş düzeyinde ayarlayabilirsiniz. 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, bu değişken şifrelenebilir ve gizli dizi olarak ayarlanabilir.
Kullanıcı tanımlı değişkenler salt okunur 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).
Değişkenleri birden çok işlem hattında kullanılabilir hale getirmek için bir değişken grubu kullanabilirsiniz.
Birden çok işlem hattında kullanılan tek bir dosyada değişkenleri tanımlamak için şablonları 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ğerlerinin çok satırlı değişkenler olarak geçirilmeden önce doğru biçimlendirilmesi 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. Bunu ö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
Azure Pipelines, kullanıcı tanımlı değişkenlere ek olarak önceden tanımlanmış değerlere sahip sistem değişkenlerine sahiptir. Ö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 işlem hatları kullanıyorsanız, sistem değişkenlerinin kapsamlı bir listesi için önceden tanımlanmış değişkenlere bakın.
Klasik yayın işlem hatlarını kullanıyorsanız bkz . yayın değişkenleri.
sistem değişkenleri, işlem hattını çalıştırdığınızda 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ışmadan önce sistem değişkeninin değerini değiştirirsiniz.
Sistem değişkenleri salt okunur.
Ortam değişkenleri
Ortam değişkenleri, kullandığınız işletim sistemine özeldir. Platforma özgü yollarla bir işlem hattına eklenmişlerdir. Biçim, ortam değişkenlerinin belirli betik platformunuz için nasıl biçimlendirilme biçimine karşılık gelir.
UNIX sistemlerinde (macOS ve Linux) ortam değişkenleri biçimindedir $NAME. Windows'da biçim %NAME% toplu iş ve $env:NAME PowerShell içindir.
Sistem ve kullanıcı tanımlı değişkenler de platformunuz için ortam değişkenleri olarak eklenmiştir. Değişkenler ortam değişkenlerine dönüştüğünde, değişken adları büyük harfe dönüşür ve nokta 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. Bunlar: 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ş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. 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
Belge örneklerinin çoğunda 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.
Makro söz dizimine sahip değişkenler, çalışma zamanı sırasında bir görev yürütülmeden önce işlenir. Ç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. Bu ada göre bir değişken yoksa, makro ifadesi değişmez. Örneğin, değiştirilemiyorsa $(var) hiçbir $(var) şeyle değiştirilmez.
Makro söz dizimi değişkenleri değer olmadan kalır çünkü gibi $() boş bir değer çalıştırdığınız görev için bir anlam ifade edebilir ve aracı bu değerin değiştirilmesini istediğinizi varsaymamalıdır. Örneğin, bash görevinde değişkene foo başvurmak için kullanırsanız$(foo), göreve girişteki tüm $() ifadelerin değiştirilmesi Bash betiklerinizi bozabilir.
Makro değişkenleri yalnızca bir değer için kullanıldığında genişletilir, 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. Satır içinde iş adı görüntülemek için kullanılan makro değişkenleri genişletilmeyen. Bunun yerine özelliğini kullanmanız displayName gerekir.
Not
Makro söz dizimi değişkenleri yalnızca , jobsve stepsiçin stagesgenişletilir.
Örneğin, veya resourcetriggeriçinde makro söz dizimi kullanamazsınız.
Bu örnekte Bash, PowerShell ve bir betik göreviyle makro söz dizimi kullanılır. Bir değişkeni makro söz dizimi ile ç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
Hem şablon parametrelerini hem de değişkenlerini (${{ variables.var }} ) genişletmek için şablon ifadesi söz dizimlerini kullanabilirsiniz. Şablon değişkenleri derleme zamanında işlenir ve çalışma zamanı başlamadan önce değiştirilir. Şablon ifadeleri, YAML'nin bölümlerini şablon olarak yeniden kullanma amacıyla tasarlanmıştır.
Ş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ı ifadesi söz dizimi
Çalışma zamanında ($[variables.var]) genişletilmiş değişkenler için çalışma zamanı ifadesi söz dizimlerini kullanabilirsiniz. Çalışma zamanı ifade değişkenleri, değiştirme değeri bulunamadığında sessizce boş dizelerle birleşti. İşlerin koşullu yürütülmesini veya aşamaların tamamını 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şletilir. 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 işlenir? |
|---|---|---|---|---|
| Makro | $(var) |
görev yürütülmeden önce çalışma zamanı | value (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ı | value (sağ taraf) | boş dize |
Hangi söz dizimlerini kullanmalıyım?
Görev için giriş sağlıyorsanız makro söz dizimlerini kullanın.
Koşullar ve ifadelerle ç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. Bu durumda, bir makro ifadesi kullanmanız gerekir.
Şablonda değişken tanımlı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ı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
Ö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\ ile Unix stili /foo/) çevrilir. 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
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.
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 dizileri ayarlamak için şu adımları izleyin:
- İşlem Hatları sayfasına gidin, uygun işlem hattını seçin ve ardından Düzenle'yi seçin.
- Bu işlem hattı için Değişkenleri bulun.
- Değişkeni ekleyin veya güncelleştirin.
- Değişkeni şifrelenmiş bir şekilde depolamak için Bu değeri gizli tut seçeneğini belirleyin.
- İş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.
Önemli
Gizli dizilerin Azure Pipelines çıkışında görünmesini maskeleme çabası gösteririz, ancak yine de önlem almanız gerekir. Gizli dizileri hiçbir zaman çıkış olarak yankılamayın. Bazı işletim sistemleri komut satırı bağımsız değişkenlerini günlüğe kaydeder. Komut satırında gizli dizileri hiçbir zaman geçirmeyin. Bunun yerine gizli dizilerinizi ortam değişkenlerine eşlemenizi öneririz.
Gizli dizilerin alt dizelerini asla maskelemeyiz. Örneğin, "abc123" gizli dizi olarak ayarlandıysa, "abc" günlüklerden maskelenmez. Bu, gizli dizileri çok ayrıntılı bir düzeyde maskeleyerek günlükleri okunamaz hale getirmekten kaçınmaktır. Bu nedenle gizli diziler yapılandırılmış veriler içermemelidir. Örneğin, "{ "foo": "bar" }" gizli dizi olarak ayarlanırsa, "çubuk" günlüklerden maskelenmez.
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
Önemli
GitHub depolarında varsayılan olarak, işlem hattınızla ilişkili gizli dizi değişkenleri çatalların çekme isteği derlemeleri için kullanılamaz. Daha fazla bilgi için bkz . Çatallardan gelen katkılar.
İşlem hatları arasında değişkenleri paylaşma
Projenizdeki birden çok işlem hattında değişkenleri paylaşmak için web arabirimini kullanın. Kitaplık'ın altında değişken grupları 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, bağımlılıkları kullanarak işler ve aşamalar arasında değişkenlere erişebilirsiniz.
Aşağı akış görevlerinde matris işlerine başvururken farklı bir söz dizimi kullanmanız gerekir. Bkz . Çok işli çıkış değişkeni ayarlama.
Bazı görevler çıkış değişkenlerini tanımlar ve bu değişkenleri aynı aşamadaki aşağı akış adımlarında ve işlerde kullanabilirsiniz. YAML'de bağımlılıkları kullanarak işler arasında değişkenlere erişebilirsiniz.
- 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 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. Kullanılacak söz dizimi hakkında bilgi için bkz . Dağıtım işleri.
Bu örnekler için adlı bir çıkış değişkeni MyVarayarlayan adlı MyTaskbir görev olduğunu varsayalım.
İfadeler - Bağımlılıklar'da söz dizimi hakkında daha fazla bilgi edinin.
Aynı işte çı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
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
Değişkenleri listeleme
az pipelines variable list komutuyla işlem hattınızdaki tüm değişkenleri listeleyebilirsiniz . Başlamak için bkz . Azure DevOps CLI ile çalışmaya başlama.
az pipelines variable list [--org]
[--pipeline-id]
[--pipeline-name]
[--project]
Parametreler
- 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ılarakgit 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ılarakgit configalınmadıysa 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ımlarda daha sonra kullanılan 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ır ve stdout'a yazdırırsınız.
Betikten iş kapsamlı değişken ayarlama
Bir betikten değişken ayarlamak için günlüğe task.setvariablekaydetme 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.
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. Daha fazla aşamaya erişmek 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 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
İfadeleri kullanarak değişkenleri ayarlama
İ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.
Adımlar için ayarlanabilir değişkenleri yapılandırma
Bir adım içinde tanımlayabilir settableVariables veya hiçbir değişkenin ayarlanabileceğini belirtebilirsiniz.
Bu örnekte betik bir değişken ayarlayamaz.
steps:
- script: echo This is a step
target:
settableVariables: none
Bu örnekte betik değişkenine sauce izin verir ancak değişkenine secretSauceizin vermez. İşlem hattı çalıştırma sayfasında bir uyarı görürsünüz.
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 verme
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.
Değişkenlerin genişletilmesi
Birden çok kapsamda aynı ada sahip bir değişken ayarladığınızda aşağıdaki öncelik geçerlidir (önce en yüksek öncelik).
- YAML dosyasında ayarlanan iş düzeyi değişkeni
- YAML dosyasında ayarlanan aşama düzeyi değişkeni
- YAML dosyasında ayarlanan işlem hattı düzeyi değişkeni
- Kuyruk zamanında ayarlanan değişken
- İş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
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ş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"
İlgili makaleler
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin