Değişkenleri tanımlama

Not

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

Değişkenler, işlem hattının çeşitli bölümlerine anahtar bitleri almanın kolay bir yolunu sunar. Değişkenlerin en yaygın kullanımı, daha sonra işlem hattınızda kullanabileceğiniz bir değer tanımlamaktır. Tüm değişkenler dizeler olarak depolanır ve değişebilir. Bir değişkenin değeri, işlem hattınızda çalıştırılacak veya iş arasında değişebilir.

Aynı değişkeni aynı ada sahip birden fazla yerde tanımladığınızda, en yerel olarak kapsamlı değişken kazanır. Bu nedenle, iş düzeyinde tanımlanan bir değişken, aşama düzeyinde bir değişken kümesini geçersiz kılabilir. Aşama düzeyinde tanımlanan bir değişken, işlem hattı kök düzeyindeki bir değişken kümesini geçersiz kılacaktır. Ardışık düzen kök düzeyindeki bir değişken kümesi, işlem hattı ayarları Kullanıcı arabirimindeki bir değişken kümesini geçersiz kılar.

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, şablon ayrıştırma sırasında yazılan ve kullanılabilen çalışma zamanı parametrelerindenfarklıdır.

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

Bir değişken tanımladığınızda, farklı sözdizimleri (makro, şablon ifadesi veya çalışma zamanı) kullanabilirsiniz ve kullandığınız söz dizimi, değişkeninizin hangi işlem hattının işleneceğini belirler.

YAML işlem hatları içinde, değişkenleri kök, aşama ve iş düzeyinde ayarlayabilirsiniz. Ayrıca, Kullanıcı arabirimindeki bir YAML işlem hattı dışında değişkenler de belirtebilirsiniz. Kullanıcı arabiriminde bir değişken belirlediğinizde, bu değişken şifrelenebilir ve gizli olarak ayarlanabilir. Gizli değişkenler YAML işlem hatlarında otomatik olarak çözülür ve YAML dosyanıza env: veya kök düzeyinde bir değişkenle geçirilmesi gerekir.

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

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

Tek bir dosyada birden çok işlem hattı içinde 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 önceden tanımlanmış değerlerle sistem değişkenleri vardır. YAML veya klasik derleme işlem hatları kullanıyorsanız, sistem değişkenlerinin kapsamlı bir listesi için önceden tanımlanmış değişkenler bölümüne bakın. Klasik yayın işlem hatları kullanıyorsanız bkz. yayın değişkenleri.

İşlem hattını çalıştırdığınızda sistem değişkenleri geçerli değerleri ile 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 bir sistem değişkeninin değerini değiştirirsiniz.

Sistem değişkenleri salt okunurdur.

Ortam değişkenleri

Ortam değişkenleri, kullanmakta olduğunuz işletim sistemine özgüdür. Bunlara platforma özgü yollarla bir işlem hattına eklenir. Biçim, ortam değişkenlerinin belirli komut dosyası platformunuz için nasıl formatlandığından karşılık gelir.

UNIX sistemlerde (macos ve Linux), ortam değişkenlerinin biçimi vardır $NAME . Windows, biçim %NAME% batch ve $env:NAME PowerShell içinde bulunur.

Sistem ve Kullanıcı tanımlı değişkenler, platformunuz için ortam değişkenleri olarak da eklenebilir. Değişkenler ortam değişkenlerine açıldığında, değişken adları büyük harfle gelir ve dönemler alt çizgi içine alınır. Örneğin, değişken adı any.variable değişken adı olur $ANY_VARIABLE .

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

Kullanıcı tanımlı değişkenler harf, sayı, . ve _ karakterden oluşabilir. Sistem tarafından ayrılan değişken öneklerini kullanmayın. Bunlar: endpoint ,, input secret , ve securefile . Bu dizelerden biriyle başlayan herhangi bir değişken (büyük harften bağımsız olarak), görevleriniz ve betikleriniz için kullanılamaz.

Değişken sözdizimini anlama

Azure Pipelines, değişkenlere başvurmak için üç farklı yöntemi destekler: makro, şablon ifadesi ve çalışma zamanı ifadesi. Her sözdizimi farklı amaçlarla kullanılabilir ve bazı sınırlamalar vardır.

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

Bu örnekte, şablon ifadesinin değişken güncelleştirildikten sonra değişkenin ilk değerini hala içerdiğinden emin olabilirsiniz. Makro sözdizimi değişkeninin değeri güncellenir. Tüm şablon ifadesi değişkenleri, görevler çalıştırılmadan önce derleme zamanında işlendiği için şablon ifadesi değeri değişmez. Buna karşılık, makro sözdizimi değişkenleri her bir görev çalıştırılmadan ö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özdizimi değişkenleri

Çoğu belge örneği makro sözdizimini ( $(var) ) kullanır. Makro sözdizimi, değişken değerlerini görev girdilerine ve diğer değişkenlere bağlamak için tasarlanmıştır.

Makro sözdizimi olan değişkenler, bir görev çalışma zamanı sırasında yürütülmeden önce işlenir. Çalışma zamanı, şablon genişletmesinden sonragerçekleşir. Sistem bir makro ifadesi ile karşılaştığında, ifadenin içeriğini değişkenin içeriğiyle değiştirir. Bu ada sahip bir değişken yoksa, makro ifadesi değiştirilmeden bırakılır. Örneğin, $(var) değiştirilmediyse $(var) hiçbir şeyle değiştirilmez.

Makro sözdizimi değişkenleri hiçbir değer olmadan değişmeden kalır çünkü benzer bir değer $() , çalıştırdığınız göreve bir şeyi ve aracının bu değerin değiştirilmesini varsaymamalıdır. Örneğin, $(foo) foo bir bash görevinde değişkene başvurmak için kullanırsanız, $() girişte bulunan tüm ifadeleri görev olarak değiştirmek Bash betiklerinizi bozabilir.

Makro değişkenleri yalnızca bir değer için kullanıldıkları zaman, anahtar sözcük olarak değil, genişletilir. Değerler, işlem hattı tanımının sağ tarafında görünür. Şunlar geçerlidir: key: $(value) . Aşağıdakiler geçerli değil: $(key): value . Makro değişkenleri bir iş adını satır içi olarak göstermek için kullanıldığında genişletilmez. Bunun yerine, özelliğini kullanmanız gerekir displayName .

Not

Makro sözdizimi değişkenleri yalnızca stages , ve için genişletilir jobs steps . Örneğin, bir veya içinde makro söz dizimini kullanamazsınız resource trigger .

Bu örnekte, makro sözdizimi Bash, PowerShell ve bir betik göreviyle birlikte kullanılır. Bir değişkeni makro söz dizimi ile çağırmak için sözdizimi, her üç 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 ifadesi sözdizimini, hem şablon parametrelerini hem de değişkenlerini () genişletmek için kullanabilirsiniz ${{ variables.var }} . Şablon değişkenleri derleme zamanında işlenir ve çalışma zamanı başlamadan önce değişir. Şablon ifadeleri, YAML 'nin parçalarını şablon olarak yeniden kullanmak için tasarlanmıştır.

Şablon değişkenleri, bir değiştirme değeri bulunamadığında boş dizelere sessizce bir şekilde birleşim yapılır. Makro ve çalışma zamanı ifadelerinin aksine şablon ifadeleri, anahtar (sol tarafta) veya değerler (sağ taraf) olarak görünebilir. Şunlar geçerlidir: ${{ variables.key }} : ${{ variables.value }} .

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

Çalışma zamanı ifadesi sözdizimini, çalışma zamanında () genişletilmiş değişkenler için kullanabilirsiniz $[variables.var] . Çalışma zamanı ifade değişkenleri, bir değiştirme değeri bulunamadığında boş dizelere sessizce bir şekilde birleşim yapılır. Çalışma zamanı ifadeleri iş koşullarında, işlerin koşullu olarak yürütülmesini desteklemek için veya Tüm aşamaların kullanılmak üzere tasarlanmıştır.

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

Syntax Örnek Ne zaman işlendiğinde? Ardışık düzen tanımında nerede genişletilir? Bulunamadığında nasıl işlenir?
makroya $(var) bir görevi yürütmeden önce çalışma zamanı değer (sağ taraf) denetleyin $(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özdizimini kullanmalıyım?

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

Koşullar ve ifadelerleçalışıyorsanız bir çalışma zamanı ifadesi seçin. Bunun özel durumu, boş değişkeninizin yazdırılması için bir soruna neden olacağı bir işlem hattınızla karşılaşırsanız olur. Örneğin, belirli bir değere sahip veya değeri olmayan bir değişkene dayalı koşullu mantığınızın olması durumunda. Bu durumda, bir çalışma zamanı ifadesi kullanmanız gerekir.

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

İşlem hatdüzeninde değişkenleri ayarlama

En yaygın durumda, değişkenleri ayarlar ve YAML dosyası içinde kullanırsınız. Bu, sürüm denetim sisteminizdeki değişkende yapılan değişiklikleri izlemenize olanak sağlar. Ayrıca, işlem hattı ayarları Kullanıcı arabiriminde değişkenler tanımlayabilir (klasik sekmeye bakın) ve YAML 'nize başvurabilirsiniz.

Aşağıda, iki değişkenin nasıl ayarlanacağını ve configuration platform daha sonra adımlarda nasıl kullanılacağı gösterilmektedir. Bir YAML deyimindeki bir değişkeni kullanmak için, içine sarın $() . Değişkenler bir repository YAML ifadesinde 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ının tüm işleri için kullanılabilir hale getirin.
  • Yalnızca belirli bir aşamada kullanılabilir hale getirmek için, aşama düzeyinde.
  • İş düzeyinde yalnızca belirli bir iş için kullanılabilir hale getirin.

Bir değişken bir YAML 'nin üstünde tanımlandığında, işlem hattındaki tüm işler ve aşamalar tarafından kullanılabilir ve genel bir değişkendir. Bir YAML 'de tanımlanan genel değişkenler, işlem hattı ayarları Kullanıcı arabiriminde görünür değildir.

İş düzeyindeki değişkenler, kök ve aşama düzeyindeki 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şin çıkışı şöyle görünür:

# job1
value 
value1
value1

# job2
value
value2
value

Değişkenleri belirtin

Önceki örneklerde anahtar variables kelimesinin ardından anahtar-değer çiftleri listesi gelir. Anahtarlar değişken adlarıdır ve değerler değişken değerlerdir.

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

Bu alternatif sözdiziminde, variables anahtar sözcüğü değişken Belirticilerinin bir listesini alır. Değişken belirticileri, değişken name Grup için normal bir değişken group ve template bir değişken şablonu içerir. Aşağıdaki örnekte üçü gösterilmektedir.

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ımhakkında daha fazla bilgi edinin.

Değişkenlere ortam üzerinden erişin

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 ortamına otomatik olarak 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 Windows, doğru dosya yolu stiline sahip olduğundan 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 kullanmalıdır.

YAML, TFS 'de desteklenmez.

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. Şunu seçerek: Gizli dizi değişkeni şifrelenmiş bir şekilde depolamak için kilit simgesi.
  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 çaba gösteriyoruz, ancak 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 $env:MY_MAPPED_TOKEN şekilde ortam 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ında değ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, aynı aşamadaki aşağı akış adımlarında ve işlerinde 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 konusunda 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ı şöyle 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, id 12 ile işlem hattında 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

İşlem hattınız içinde bir betik, işlem hattında sonraki adımlardan biri tarafından tüketilmesi için bir değişken tanımlayabilir. Bu yöntem tarafından ayarlanmış olan tüm değişkenler dize olarak kabul edilir. Bir betikten değişken ayarlamak için bir komut söz dizimi kullanır ve stdout'a yazdırabilirsiniz.

Betikten iş kapsamlı değişken ayarlama

Bir betikten değişken ayarlamak için günlük komutunu task.setvariable kullanırnız. Bu, sonraki işler için ortam değişkenlerini güncelleştirecek. Sonraki işler makro söz dizimi ile yeni değişkene ve görevlerde ortam değişkenleri olarak erişime sahip olur.

true issecret olarak ayarlanırsa değişkenin değeri gizli dizi olarak kaydedilir ve günlükten maskelenmiş olur. Gizli değişkenler 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, ortamlarına işlem hattı değişkeni de eklenir. Değişken tanımlandığı adımda kullanılamaz.

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

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

Bir değişkeni gelecekteki işlerin kullanımına almak için kullanarak bir çıkış değişkeni olarak isOutput=true işaretlemelisiniz. Daha sonra söz dizimi kullanarak ve değişkeni ayaran adım $[] adını kullanarak gelecekteki işlere eşlersiniz. Çok işli çıkış değişkenleri yalnızca aynı aşamadaki işler için çalışır.

Değişkenleri farklı aşamalarda işlere geçmek için aşama bağımlılıkları söz dizimlerini kullanın.

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. Bu nedenle, her aşama önceki aşamadaki çıkış değişkenlerini kullanabilir. Daha fazla aşamaya erişmek için bağımlılık grafiğini değiştirmelisiniz; örneğin, 3. aşama 1. aşamadan bir değişken gerektiriyorsa, 1. aşamada açık bir bağımlılık tanımlaması gerekir.

Çok işli bir çıkış değişkeni oluştururken, ifadeyi bir değişkene atamalısiniz. Bu YAML içinde $[ 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-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şamadan diğerine değişken ayar ediyorsanız stageDependencies kullanın.

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 matristen veya dilimden bir değişken ayarıyorsanız, aşağı akış işlerinden erişilirken değişkene başvuracak şekilde şunları dahil etmek gerekir:

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

bir dağıtım işinin çıkış değişkenlerine iş adına ön ek olarak eklerken emin olun. Bu durumda, iş A adı:

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

TFS'de YAML desteklenmiyor.

İfadeleri kullanarak değişkenleri ayarlama

Bir ifade kullanarak bir değişken ayarlanabilir. Bir değişkeni önceki işlerden birinin çıkışına ayarlamak için bunun bir durumuyla zaten karşılaştık.

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

Değişken ayarlama için desteklenen ifadelerden herhangi birini kullanabilirsiniz. Burada bir değişkenin 100 ile başlayan, her çalıştırma için 1 artıran ve her gün 100'e sıfırlanacak bir sayaç olarak davranması için bir örnek veserde yer alı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 ifadelerine bakın.

TFS'de YAML desteklenmiyor.

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

Bir adım settableVariables içinde tanımlayabilir veya hiçbir değişkenin ayarı olmadığını belirtebilirsiniz.

Bu örnekte, betik bir değişken ayaramaz.

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

Bu örnekte betik değişkenine izin verir sauce ancak değişkenine izin secretSauce verir. İşlem hattı çalıştırma sayfasında bir uyarı görüntülenir.

secretSauce'yi ayarlayamazken uyarı.

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 bloğunda bir değişken görünürse, değeri sabittir ve kuyruk variables zamanında geçersiz kılınamıyor. 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şken YAML'nize açık değil. 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. Örnek:

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 aladı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. Örnek:

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.