Bagikan melalui

Tentukan variabel

  • Artikel

Layanan Azure DevOps | Azure DevOps Server 2022 - Azure DevOps Server 2019

Variabel memberi Anda cara yang mudah untuk mendapatkan bit kunci data ke berbagai bagian alur. Penggunaan variabel yang paling umum adalah menentukan nilai yang nantinya dapat digunakan dalam alur Anda. Semua variabel adalah string dan dapat diubah. Nilai variabel dapat berubah dari eksekusi ke eksekusi atau pekerjaan ke pekerjaan pada alur Anda.

Ketika Anda menentukan variabel yang sama di beberapa tempat dengan nama yang sama, variabel yang paling terlingkup secara lokal akan menang. Jadi, variabel yang ditentukan pada tingkat pekerjaan dapat mengambil alih set variabel pada tingkat tahap. Variabel yang ditentukan pada tingkat tahap mengambil alih set variabel di tingkat akar alur. Variabel yang diatur dalam tingkat akar alur mengambil alih variabel yang ditetapkan dalam antarmuka pengguna pengaturan Alur. Untuk mempelajari selengkapnya cara bekerja dengan variabel yang ditentukan pada tingkat pekerjaan, tahap, dan root, lihat Cakupan variabel.

Anda dapat menggunakan variabel dengan ekspresi untuk menetapkan nilai secara kondisional dan menyesuaikan alur lebih lanjut.

Variabel berbeda dengan parameter runtime. Parameter runtime diketik dan tersedia selama penguraian template.

Variabel yang ditentukan pengguna

Saat menentukan variabel, Anda dapat menggunakan sintaks yang berbeda (makro, ekspresi templat, atau runtime) dan sintaks apa yang Anda gunakan menentukan di mana dalam alur yang dirender variabel Anda.

Dalam alur YAML, Anda dapat mengatur variabel di tingkat akar, tahap, dan pekerjaan. Anda juga dapat menentukan variabel di luar alur YAML di UI. Saat Anda mengatur variabel di UI, variabel tersebut dapat dienkripsi dan diatur sebagai rahasia.

Variabel yang ditentukan pengguna dapat diatur sebagai baca-saja. Ada pembatasan penamaan untuk variabel (misalnya: Anda tidak dapat menggunakan secret di awal nama variabel).

Anda dapat menggunakan grup variabel untuk membuat variabel tersedia di beberapa alur.

Gunakan templat untuk menentukan variabel dalam satu file yang digunakan dalam beberapa alur.

Variabel multibaris yang ditentukan pengguna

Azure DevOps mendukung variabel multibaris tetapi ada beberapa batasan.

Komponen hilir seperti tugas alur mungkin tidak menangani nilai variabel dengan benar.

Azure DevOps tidak akan mengubah nilai variabel yang ditentukan pengguna. Nilai variabel perlu diformat dengan benar sebelum diteruskan sebagai variabel multibaris. Saat memformat variabel Anda, hindari karakter khusus, jangan gunakan nama terbatas, dan pastikan Anda menggunakan format akhir baris yang berfungsi untuk sistem operasi agen Anda.

Variabel multibaris berperilaku berbeda tergantung pada sistem operasi. Untuk menghindari hal ini, pastikan Anda memformat variabel multibaris dengan benar untuk sistem operasi target.

Azure DevOps tidak pernah mengubah nilai variabel, bahkan jika Anda menyediakan pemformatan yang tidak didukung.

Variabel sistem

Selain variabel yang ditentukan pengguna, Azure Pipelines memiliki variabel sistem dengan nilai yang telah ditentukan sebelumnya. Misalnya, variabel build.BuildId yang telah ditentukan sebelumnya memberikan ID dari setiap build dan dapat digunakan untuk mengidentifikasi eksekusi alur yang berbeda. Anda dapat menggunakan Build.BuildId variabel dalam skrip atau tugas saat Anda memerlukan nilai unik.

Jika Anda menggunakan YAML atau alur build klasik, lihat variabel yang telah ditentukan sebelumnya untuk daftar variabel sistem yang komprehensif.

Jika Anda menggunakan alur rilis klasik, lihat merilis variabel.

Variabel sistem diatur dengan nilainya saat ini saat Anda menjalankan alur. Beberapa variabel diatur secara otomatis. Sebagai penulis alur atau pengguna akhir, Anda mengubah nilai variabel sistem sebelum alur berjalan.

Variabel sistem bersifat baca-saja.

Variabel lingkungan

Variabel lingkungan khusus untuk sistem operasi yang Anda gunakan. Mereka disuntikkan ke dalam alur dengan cara khusus platform. Format ini sesuai dengan bagaimana variabel lingkungan diformat untuk platform pembuatan skrip spesifik Anda.

Pada sistem UNIX (macOS dan Linux), variabel lingkungan memiliki format $NAME. Di Windows, formatnya adalah %NAME% untuk batch dan $env:NAME di PowerShell.

Variabel yang ditentukan sistem dan pengguna juga disuntikkan sebagai variabel lingkungan untuk platform Anda. Ketika variabel diubah menjadi variabel lingkungan, nama variabel menjadi huruf besar, dan titik berubah menjadi garis bawah. Misalnya, nama any.variable variabel menjadi nama $ANY_VARIABLEvariabel .

Ada pembatasan penamaan variabel untuk variabel lingkungan (misalnya: Anda tidak dapat menggunakan secret di awal nama variabel).

Pembatasan penamaan sumber daya

Variabel yang ditentukan pengguna dan lingkungan dapat terdiri dari huruf, angka, ., dan _ karakter. Jangan gunakan awalan variabel yang dicadangkan oleh sistem. Ini adalah: endpoint, , secretinput, path, dan securefile. Variabel apa pun yang dimulai dengan salah satu string ini (terlepas dari kapitalisasi) tidak akan tersedia untuk tugas dan skrip Anda.

Memahami sintaks variabel

Azure Pipelines mendukung tiga cara berbeda untuk mereferensikan variabel: makro, ekspresi templat, dan ekspresi runtime. Anda dapat menggunakan setiap sintaks untuk tujuan yang berbeda dan masing-masing memiliki beberapa batasan.

Dalam alur, variabel ekspresi templat (${{ variables.var }}) diproses pada waktu kompilasi, sebelum runtime dimulai. Variabel sintaks makro ($(var)) diproses selama runtime sebelum tugas berjalan. Ekspresi runtime ($[variables.var]) juga diproses selama runtime tetapi dimaksudkan untuk digunakan dengan kondisi dan ekspresi. Saat Anda menggunakan ekspresi runtime, proses ini harus menggunakan seluruh sisi kanan definisi.

Dalam contoh ini, Anda dapat melihat bahwa ekspresi templat masih memiliki nilai awal variabel setelah variabel diperbarui. Nilai pembaruan variabel sintaks makro. Nilai ekspresi templat tidak berubah karena semua variabel ekspresi templat diproses pada waktu kompilasi sebelum tugas berjalan. Sebaliknya, variabel sintaks makro mengevaluasi sebelum setiap tugas berjalan.

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

Variabel sintaks makro

Sebagian besar contoh dokumentasi menggunakan sintaks makro ($(var)). Sintaks makro dirancang untuk menginterpolasi nilai variabel ke dalam input tugas dan ke variabel lain.

Variabel dengan sintaks makro diproses sebelum tugas dijalankan selama runtime. Runtime terjadi setelah ekspansi templat. Ketika sistem menemukan ekspresi makro, sistem mengganti ekspresi dengan konten variabel. Jika tidak ada variabel dengan nama tersebut, maka ekspresi makro tidak berubah. Misalnya, jika $(var) tidak dapat diganti, $(var) tidak akan digantikan oleh apa pun.

Variabel sintaks makro tetap tidak berubah tanpa nilai karena nilai kosong seperti $() mungkin berarti sesuatu untuk tugas yang Anda jalankan dan agen seharusnya tidak menganggap Anda ingin nilai tersebut diganti. Misalnya, jika Anda menggunakan $(foo) untuk mereferensikan variabel foo dalam tugas Bash, mengganti semua $() ekspresi dalam input ke tugas dapat merusak skrip Bash Anda.

Variabel makro hanya diperluas saat digunakan untuk nilai, bukan sebagai kata kunci. Nilai muncul di sisi kanan definisi alur. Berikut ini valid: key: $(value). Berikut ini tidak valid: $(key): value. Variabel makro tidak diperluas saat digunakan untuk menampilkan nama pekerjaan sebaris. Sebagai gantinya displayName , Anda harus menggunakan properti .

Catatan

Variabel sintaks makro hanya diperluas untuk stages, , jobsdan steps. Anda tidak dapat, misalnya, menggunakan sintaks makro di dalam resource atau trigger.

Contoh ini menggunakan sintaks makro dengan Bash, PowerShell, dan tugas skrip. Sintaks untuk memanggil variabel dengan sintaks makro sama untuk ketiganya.

variables:
 - name: projectName
   value: contoso

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

Sintaks ekspresi templat

Anda dapat menggunakan sintaks ekspresi templat untuk memperluas parameter templat dan variabel (${{ variables.var }}). Proses variabel templat pada waktu kompilasi, dan diganti sebelum runtime dimulai. Ekspresi templat dirancang untuk menggunakan kembali bagian YAML sebagai templat.

Variabel templat secara diam-diam bersatu ke string kosong saat nilai penggantian tidak ditemukan. Ekspresi templat, tidak seperti ekspresi makro dan runtime, dapat muncul sebagai kunci (sisi kiri) atau nilai (sisi kanan). Berikut ini valid: ${{ variables.key }} : ${{ variables.value }}.

Sintaks ekspresi runtime

Anda dapat menggunakan sintaks ekspresi runtime untuk variabel yang diperluas saat runtime ($[variables.var]). Variabel ekspresi runtime secara diam-diam bersatu ke string kosong saat nilai pengganti tidak ditemukan. Gunakan ekspresi runtime dalam kondisi pekerjaan, untuk mendukung eksekusi pekerjaan bersyariah, atau seluruh tahapan.

Variabel ekspresi runtime hanya diperluas saat digunakan untuk nilai, bukan sebagai kata kunci. Nilai muncul di sisi kanan definisi alur. Berikut ini valid: key: $[variables.value]. Berikut ini tidak valid: $[variables.key]: value. Ekspresi runtime harus mengambil seluruh sisi kanan pasangan kunci-nilai. Misalnya, key: $[variables.value] valid tetapi key: $[variables.value] foo tidak.

Sintaks Contoh Kapan diproses? Di mana perluasannya dalam definisi alur? Bagaimana render ketika tidak ditemukan?
makro $(var) runtime sebelum tugas dijalankan nilai (sisi kanan) Cetakan $(var)
ekspresi templat ${{ variables.var }} waktu kompilasi kunci atau nilai (sisi kiri atau kanan) string kosong
ekspresi runtime $[variables.var] runtime nilai (sisi kanan) string kosong

Sintaks apa yang harus saya gunakan?

Gunakan sintaks makro jika Anda menyediakan input untuk tugas.

Pilih ekspresi runtime jika Anda bekerja dengan kondisi dan ekspresi. Namun, jangan gunakan ekspresi runtime jika Anda tidak ingin variabel kosong Anda dicetak (misalnya: $[variables.var]). Misalnya, jika Anda memiliki logika kondisional yang bergantung pada variabel yang memiliki nilai tertentu atau tanpa nilai. Dalam hal ini, Anda harus menggunakan ekspresi makro.

Jika Anda menentukan variabel dalam templat, gunakan ekspresi templat.

Mengatur variabel dalam alur

Dalam kasus yang paling umum, Anda mengatur variabel dan menggunakannya dalam file YAML. Ini memungkinkan Anda melacak perubahan pada variabel dalam sistem kontrol versi Anda. Anda juga dapat menentukan variabel di antarmuka pengguna pengaturan alur (lihat tab Klasik) dan mereferensikannya di YAML Anda.

Berikut adalah contoh yang menunjukkan cara mengatur dua variabel, configuration dan platform, dan menggunakannya nanti dalam langkah-langkah. Untuk menggunakan variabel dalam pernyataan YAML, bungkus dalam $(). Variabel tidak dapat digunakan untuk menentukan repository dalam pernyataan YAML.

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

Cakupan variabel

Dalam file YAML, Anda dapat mengatur variabel di berbagai cakupan:

  • Pada tingkat akar, untuk membuatnya tersedia untuk semua pekerjaan dalam alur.
  • Pada tingkat panggung, untuk membuatnya hanya tersedia untuk tahap tertentu.
  • Pada tingkat pekerjaan, untuk membuatnya hanya tersedia untuk pekerjaan tertentu.

Ketika Anda menentukan variabel di bagian atas YAML, variabel tersedia untuk semua pekerjaan dan tahapan dalam alur dan merupakan variabel global. Variabel global yang ditentukan dalam YAML tidak terlihat di antarmuka pengguna pengaturan alur.

Variabel pada tingkat pekerjaan mengambil alih variabel pada tingkat akar dan tahap. Variabel pada tingkat tahap mengambil alih variabel di tingkat akar.

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

Output dari kedua pekerjaan terlihat seperti ini:

# job1
value 
value1
value1

# job2
value
value2
value

Tentukan variabel

Dalam contoh sebelumnya, variables kata kunci diikuti oleh daftar pasangan kunci-nilai. Kuncinya adalah nama variabel dan nilainya adalah nilai variabel.

Ada sintaks lain, berguna saat Anda ingin menggunakan templat untuk variabel atau grup variabel.

Dengan templat, variabel dapat didefinisikan dalam satu YAML dan disertakan dalam file YAML lain.

Grup variabel adalah sekumpulan variabel yang dapat Anda gunakan di beberapa alur. Mereka memungkinkan Anda untuk mengelola dan mengatur variabel yang umum untuk berbagai tahap di satu tempat.

Gunakan sintaks ini untuk templat variabel dan grup variabel di tingkat akar alur.

Dalam sintaks alternatif ini, variables kata kunci mengambil daftar penentu variabel. Penentu variabel adalah name untuk variabel reguler, group untuk grup variabel, dan template untuk menyertakan templat variabel. Contoh berikut menunjukkan ketiganya.

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

Pelajari selengkapnya tentang penggunaan kembali variabel dengan templat.

Mengakses variabel melalui lingkungan

Perhatikan bahwa variabel juga tersedia untuk skrip melalui variabel lingkungan. Sintaks untuk menggunakan variabel lingkungan ini tergantung pada bahasa pembuatan skrip.

Nama ini huruf besar, dan . diganti dengan _. Ini secara otomatis dimasukkan ke dalam lingkungan proses. Berikut adalah beberapa contoh:

  • Skrip batch: %VARIABLE_NAME%
  • Skrip PowerShell: $env:VARIABLE_NAME
  • Skrip Bash: $VARIABLE_NAME

Penting

Variabel yang telah ditentukan sebelumnya yang berisi jalur file diterjemahkan ke gaya yang sesuai (gaya Windows C:\foo\ versus gaya Unix /foo/) berdasarkan jenis host agen dan jenis shell. Jika Anda menjalankan tugas skrip bash di Windows, Anda harus menggunakan metode variabel lingkungan untuk mengakses variabel ini daripada metode variabel alur untuk memastikan Anda memiliki gaya jalur file yang benar.

Atur variabel rahasia

Tip

Variabel rahasia tidak diekspor secara otomatis sebagai variabel lingkungan. Untuk menggunakan variabel rahasia dalam skrip Anda, petakan secara eksplisit ke variabel lingkungan. Untuk informasi selengkapnya, lihat Mengatur variabel rahasia.

Jangan atur variabel rahasia dalam file YAML Anda. Sistem operasi sering mencatat perintah untuk proses yang dijalankannya, dan Anda tidak ingin log menyertakan rahasia yang Anda lewati sebagai input. Gunakan lingkungan skrip atau petakan variabel dalam variables blok untuk meneruskan rahasia ke alur Anda.

Catatan

Azure Pipelines berupaya menutupi rahasia saat memancarkan data ke log alur, sehingga Anda mungkin melihat variabel dan data tambahan yang diselubungi dalam output dan log yang tidak ditetapkan sebagai rahasia.

Anda perlu mengatur variabel rahasia di antarmuka pengguna pengaturan alur untuk alur Anda. Variabel ini dicakup ke alur tempat variabel diatur. Anda juga dapat mengatur variabel rahasia dalam grup variabel.

Untuk mengatur rahasia di antarmuka web, ikuti langkah-langkah berikut:

  1. Masuk ke halaman Alur, pilih alur yang sesuai, lalu pilih Edit.
  2. Temukan Variabel untuk alur ini.
  3. Tambahkan atau perbarui variabel.
  4. Pilih opsi untuk Menyimpan rahasia nilai ini untuk menyimpan variabel dengan cara terenkripsi.
  5. Simpan alurnya.

Variabel rahasia dienkripsi saat tidak aktif dengan kunci RSA 2048-bit. Rahasia tersedia di agen untuk tugas dan skrip yang akan digunakan. Berhati-hatilah tentang siapa yang memiliki akses untuk mengubah alur Anda.

Penting

Kami berupaya menutupi rahasia agar tidak muncul di output Azure Pipelines, tetapi Anda masih perlu mengambil tindakan pencegahan. Jangan pernah menggaungkan rahasia sebagai output. Beberapa argumen baris perintah log sistem operasi. Jangan pernah meneruskan rahasia pada baris perintah. Sebagai gantinya, kami sarankan Anda memetakan rahasia Anda ke dalam variabel lingkungan.

Kami tidak pernah menutupi substring rahasia. Jika, misalnya, "abc123" diatur sebagai rahasia, "abc" tidak ditutupi dari log. Ini untuk menghindari menutupi rahasia terlalu terperinci dari tingkat, membuat log tidak dapat dibaca. Untuk alasan ini, rahasia tidak boleh berisi data terstruktur. Jika, misalnya, "{ "foo": "bar" }" diatur sebagai rahasia, "bar" tidak ditutupi dari log.

Tidak seperti variabel normal, variabel tersebut tidak secara otomatis didekripsi ke dalam variabel lingkungan untuk skrip. Anda perlu secara eksplisit memetakan variabel rahasia.

Contoh berikut menunjukkan cara memetakan dan menggunakan variabel rahasia yang disebut mySecret dalam skrip PowerShell dan Bash. Dua variabel global didefinisikan. GLOBAL_MYSECRET diberi nilai variabel mySecretrahasia , dan GLOBAL_MY_MAPPED_ENV_VAR diberi nilai variabel nonSecretVariablenon-rahasia . Tidak seperti variabel alur normal, tidak ada variabel lingkungan yang disebut MYSECRET.

Tugas PowerShell menjalankan skrip untuk mencetak variabel.

  • $(mySecret): Ini adalah referensi langsung ke variabel rahasia dan berfungsi.
  • $env:MYSECRET: Upaya ini untuk mengakses variabel rahasia sebagai variabel lingkungan, yang tidak berfungsi karena variabel rahasia tidak secara otomatis dipetakan ke variabel lingkungan.
  • $env:GLOBAL_MYSECRET: Upaya ini untuk mengakses variabel rahasia melalui variabel global, yang juga tidak berfungsi karena variabel rahasia tidak dapat dipetakan dengan cara ini.
  • $env:GLOBAL_MY_MAPPED_ENV_VAR: Ini mengakses variabel non-rahasia melalui variabel global, yang berfungsi.
  • $env:MY_MAPPED_ENV_VAR: Ini mengakses variabel rahasia melalui variabel lingkungan khusus tugas, yang merupakan cara yang direkomendasikan untuk memetakan variabel rahasia ke variabel lingkungan.
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

Output dari kedua tugas dalam skrip sebelumnya akan terlihat seperti ini:

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

Anda juga dapat menggunakan variabel rahasia di luar skrip. Misalnya, Anda dapat memetakan variabel rahasia ke tugas menggunakan variables definisi . Contoh ini menunjukkan cara menggunakan variabel $(vmsUser) rahasia dan $(vmsAdminPass) dalam tugas penyalinan file Azure.

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)

Mereferensikan variabel rahasia dalam grup variabel

Contoh ini menunjukkan cara mereferensikan grup variabel dalam file YAML Anda, dan juga cara menambahkan variabel dalam YAML. Ada dua variabel yang digunakan dari grup variabel: user dan token. Variabel token ini rahasia, dan dipetakan ke variabel $env:MY_MAPPED_TOKEN lingkungan sehingga dapat direferensikan dalam YAML.

YAML ini melakukan panggilan REST untuk mengambil daftar rilis, dan menghasilkan hasilnya.

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

Penting

Secara default dengan repositori GitHub, variabel rahasia yang terkait dengan alur Anda tidak tersedia untuk menarik build permintaan fork. Untuk informasi selengkapnya, lihat Kontribusi dari fork.

Berbagi variabel di seluruh alur

Untuk berbagi variabel di beberapa alur dalam proyek Anda, gunakan antarmuka web. Di bawah Pustaka, gunakan grup variabel.

Menggunakan variabel output dari tugas

Beberapa tugas menentukan variabel output, yang dapat Anda gunakan dalam langkah hilir, pekerjaan, dan tahapan. Di YAML, Anda dapat mengakses variabel di seluruh pekerjaan dan tahapan dengan menggunakan dependensi.

Saat mereferensikan pekerjaan matriks dalam tugas hilir, Anda harus menggunakan sintaks yang berbeda. Lihat Mengatur variabel output multi-pekerjaan. Anda juga perlu menggunakan sintaks yang berbeda untuk variabel dalam pekerjaan penyebaran. Lihat Dukungan untuk variabel output dalam pekerjaan penyebaran.

Beberapa tugas menentukan variabel output, yang dapat Anda gunakan dalam langkah-langkah hilir dan pekerjaan dalam tahap yang sama. Di YAML, Anda dapat mengakses variabel di seluruh pekerjaan dengan menggunakan dependensi.

  • Untuk mereferensikan variabel dari tugas yang berbeda dalam pekerjaan yang sama, gunakan TASK.VARIABLE.
  • Untuk mereferensikan variabel dari tugas dari pekerjaan lain, gunakan dependencies.JOB.outputs['TASK.VARIABLE'].

Catatan

Secara default, setiap tahapan dalam alur bergantung pada satu tahapan tepat sebelum tahapan tersebut di file YAML. Jika Anda perlu merujuk ke tahap yang tidak segera sebelum tahap saat ini, Anda dapat mengambil alih default otomatis ini dengan menambahkan dependsOn bagian ke tahap.

Catatan

Contoh berikut menggunakan sintaks alur standar. Jika Anda menggunakan alur penyebaran, sintaks variabel dan variabel bersyarat akan berbeda. Untuk informasi tentang sintaksis tertentu yang akan digunakan, lihat Pekerjaan penyebaran.

Untuk contoh ini, asumsikan kita memiliki tugas yang disebut MyTask, yang menetapkan variabel output yang disebut MyVar. Pelajari selengkapnya tentang sintaks dalam Ekspresi - Dependensi.

Menggunakan output dalam pekerjaan yang sama

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

Menggunakan output dalam pekerjaan yang berbeda

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

Menggunakan output dalam tahap yang berbeda

Untuk menggunakan output dari tahap yang berbeda, format untuk mereferensikan variabel adalah stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']. Pada tingkat tahap, tetapi bukan tingkat pekerjaan, Anda dapat menggunakan variabel ini dalam kondisi.

Variabel output hanya tersedia di tahap hilir berikutnya. Jika beberapa tahap menggunakan variabel output yang sama, gunakan kondisi tersebut dependsOn .

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

Anda juga dapat meneruskan variabel antar tahap dengan input file. Untuk melakukannya, Anda harus menentukan variabel pada tahap kedua di tingkat pekerjaan, lalu meneruskan variabel sebagai env: input.

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

Output dari tahapan dalam alur sebelumnya terlihat seperti ini:

Hello inline version
true
crushed tomatoes

Mencantumkan variabel

Anda dapat mencantumkan semua variabel dalam alur Anda dengan perintah az pipelines variable list . Untuk memulai, lihat Mulai menggunakan Azure DevOps CLI.

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

Parameter

  • org: URL organisasi Azure DevOps. Anda dapat mengonfigurasi organisasi default menggunakan az devops configure -d organization=ORG_URL. Diperlukan jika tidak dikonfigurasi sebagai default atau diambil menggunakan git config. Contoh: --org https://dev.azure.com/MyOrganizationName/.
  • pipeline-id: Diperlukan jika nama alur tidak disediakan. ID alur.
  • pipeline-name: Diperlukan jika pipeline-id tidak disediakan, tetapi diabaikan jika pipeline-id disediakan. Nama alur.
  • project: Nama atau ID proyek. Anda dapat mengonfigurasi proyek default menggunakan az devops configure -d project=NAME_OR_ID. Diperlukan jika tidak dikonfigurasi sebagai default atau diambil dengan menggunakan git config.

Contoh

Perintah berikut mencantumkan semua variabel dalam alur dengan ID 12 dan memperlihatkan hasilnya dalam format tabel.

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

Menetapkan variabel dalam skrip

Skrip dapat menentukan variabel yang nantinya digunakan dalam langkah-langkah berikutnya dalam alur. Semua variabel yang ditetapkan oleh metode ini diperlakukan sebagai string. Untuk mengatur variabel dari skrip, Anda menggunakan sintaks perintah dan mencetak ke stdout.

Mengatur variabel cakupan pekerjaan dari skrip

Untuk mengatur variabel dari skrip, Anda menggunakan perintah pengelogan task.setvariable . Ini memperbarui variabel lingkungan untuk pekerjaan berikutnya. Pekerjaan berikutnya memiliki akses ke variabel baru dengan sintaks makro dan dalam tugas sebagai variabel lingkungan.

Ketika issecret benar, nilai variabel akan disimpan sebagai rahasia dan ditutupi dari log. Untuk informasi selengkapnya tentang variabel rahasia, lihat perintah pengelogan.

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)

Langkah berikutnya juga akan memiliki variabel alur yang ditambahkan ke lingkungan mereka. Anda tidak dapat menggunakan variabel dalam langkah yang ditentukan.

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"

Output dari alur sebelumnya.

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

Mengatur variabel output multi-pekerjaan

Jika Anda ingin membuat variabel tersedia untuk pekerjaan di masa mendatang, Anda harus menandainya sebagai variabel output dengan menggunakan isOutput=true. Kemudian Anda dapat memetakannya ke dalam pekerjaan di masa mendatang dengan menggunakan $[] sintaks dan menyertakan nama langkah yang mengatur variabel. Variabel output multi-pekerjaan hanya berfungsi untuk pekerjaan dalam tahap yang sama.

Untuk meneruskan variabel ke pekerjaan dalam tahap yang berbeda, gunakan sintaksis dependensi tahap.

Catatan

Secara default, setiap tahapan dalam alur bergantung pada satu tahapan tepat sebelum tahapan tersebut di file YAML. Oleh karenanya, setiap tahap dapat menggunakan variabel output dari tahap sebelumnya. Untuk mengakses tahap lebih lanjut, Anda harus mengubah grafik dependensi, misalnya, jika tahap 3 memerlukan variabel dari tahap 1, Anda harus menyatakan dependensi eksplisit pada tahap 1.

Saat membuat variabel output multi-pekerjaan, Anda harus menetapkan ekspresi ke variabel. Dalam YAML ini, $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] ditetapkan ke variabel $(myVarFromJobA).

jobs:
# Set an output variable from job A
- job: A
  pool:
    vmImage: 'windows-latest'
  steps:
  - powershell: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the value"
    name: setvarStep
  - script: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable into job B
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromJobA: $[ dependencies.A.outputs['setvarStep.myOutputVar'] ]  # map in the variable
                                                                          # remember, expressions require single quotes
  steps:
  - script: echo $(myVarFromJobA)
    name: echovar

Output dari alur sebelumnya.

this is the value
this is the value

Jika Anda mengatur variabel dari satu tahap ke tahap lainnya, gunakan 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)

Jika Anda mengatur variabel dari matriks atau potongan, maka untuk mereferensikan variabel saat Anda mengaksesnya dari pekerjaan hilir, Anda harus menyertakan:

  • Nama pekerjaan.
  • Langkahnya.
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

Pastikan untuk mengawali nama pekerjaan ke variabel output dari pekerjaan penyebaran . Dalam hal ini, nama pekerjaan adalah 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

Mengatur variabel dengan menggunakan ekspresi

Anda dapat mengatur variabel dengan menggunakan ekspresi. Kami sudah menemukan satu kasus ini untuk mengatur variabel ke output yang lain dari pekerjaan sebelumnya.

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

Anda dapat menggunakan salah satu ekspresi yang didukung untuk mengatur variabel. Berikut adalah contoh pengaturan variabel untuk bertindak sebagai penghitung yang dimulai dari 100, bertambah 1 untuk setiap eksekusi, dan direset ke 100 setiap hari.

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

Untuk informasi selengkapnya tentang penghitung, dependensi, dan ekspresi lainnya, lihat ekspresi.

Mengonfigurasi variabel yang dapat diatur untuk langkah-langkah

Anda dapat menentukan settableVariables dalam langkah atau menentukan bahwa tidak ada variabel yang dapat diatur.

Dalam contoh ini, skrip tidak dapat mengatur variabel.

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

Dalam contoh ini, skrip memungkinkan variabel sauce tetapi bukan variabel secretSauce. Anda akan melihat peringatan di halaman eksekusi alur.

Peringatan bahwa Anda tidak dapat mengatur secretSauce. 

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

Izinkan pada waktu antrean

Jika variabel muncul di variables blok file YAML, nilainya diperbaiki dan tidak dapat ditimpa pada waktu antrean. Praktik terbaik adalah menentukan variabel Anda dalam file YAML tetapi ada kalanya ini tidak masuk akal. Misalnya, Anda mungkin ingin menentukan variabel rahasia dan tidak memiliki variabel yang diekspos di YAML Anda. Atau, Anda mungkin perlu mengatur nilai variabel secara manual selama eksekusi alur.

Anda memiliki dua opsi untuk menentukan nilai waktu antrean. Anda dapat menentukan variabel di UI dan memilih opsi untuk Memungkinkan pengguna mengambil alih nilai ini saat menjalankan alur ini atau Anda dapat menggunakan parameter runtime sebagai gantinya. Jika variabel Anda bukan rahasia, praktik terbaiknya adalah menggunakan parameter runtime.

Untuk mengatur variabel pada waktu antrean, tambahkan variabel baru dalam alur Anda dan pilih opsi ambil alih.

Atur variabel pada waktu antrean.

Untuk mengizinkan variabel diatur pada waktu antrean, pastikan variabel juga tidak muncul di variables blok alur atau pekerjaan. Jika Anda menentukan variabel di blok variabel YAML dan di UI, nilai dalam YAML memiliki prioritas.

Perluasan variabel

Saat Anda menetapkan variabel dengan nama yang sama dalam beberapa cakupan, prioritas berikut berlaku (prioritas paling tinggi terlebih dahulu).

  1. Variabel tingkat pekerjaan ditetapkan dalam file YAML
  2. Variabel tingkat tahap ditetapkan dalam file YAML
  3. Variabel tingkat alur ditetapkan dalam file YAML
  4. Variabel ditetapkan pada waktu antrean
  5. Variabel alur ditetapkan dalam antarmuka pengguna pengaturan Alur

Dalam contoh berikut, variabel a yang sama diatur pada tingkat alur dan tingkat pekerjaan dalam file YAML. Ini juga diatur dalam grup Gvariabel , dan sebagai variabel di antarmuka pengguna pengaturan Alur.

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'

Saat Anda mengatur variabel dengan nama yang sama dalam cakupan yang sama, nilai set terakhir lebih diutamakan.

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

Catatan

Saat Anda mengatur variabel dalam file YAML, jangan tentukan di editor web sebagai dapat diatur pada waktu antrean. Saat ini Anda tidak dapat mengubah variabel yang diatur dalam file YAML pada waktu antrean. Jika Anda memerlukan variabel untuk diatur pada waktu antrean, jangan atur dalam file YAML.

Variabel diperluas sekali ketika eksekusi dimulai, dan sekali lagi di awal setiap langkah. Contohnya:

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

Ada dua langkah dalam contoh sebelumnya. Perluasan $(a) terjadi sekali di awal pekerjaan, dan sekali di awal masing-masing dari dua langkah.

Karena variabel diperluas di awal pekerjaan, Anda tidak dapat menggunakannya dalam strategi. Dalam contoh berikut, Anda tidak dapat menggunakan variabel a untuk memperluas matriks pekerjaan, karena variabel hanya tersedia di awal setiap pekerjaan yang diperluas.

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

Jika variabel a adalah variabel output dari pekerjaan sebelumnya, maka Anda dapat menggunakannya dalam pekerjaan di masa mendatang.

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

Ekspansi rekursif

Pada agen, variabel yang direferensikan menggunakan $( ) sintaksis diperluas secara rekursif. Contohnya:

variables:
  myInner: someValue
  myOuter: $(myInner)

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