Bagikan melalui

Tentukan variabel

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

Variabel memberi Anda cara yang mudah untuk mendapatkan data penting ke bagian-bagian yang berbeda dalam alur kerja. 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 satu eksekusi ke eksekusi lain atau dari satu pekerjaan ke pekerjaan lain pada alur Anda.

Ketika Anda menentukan variabel yang sama di beberapa tempat dengan nama yang sama, variabel yang paling terlingkup secara lokal lebih diutamakan. Jadi, variabel yang ditentukan pada tingkat pekerjaan dapat menggantikan variabel yang diatur pada tingkat tahap. Variabel yang ditentukan pada tingkat tahap menggantikan variabel yang diatur pada tingkat akar pipeline. Variabel yang ditetapkan di tingkat akar pipeline menggantikan variabel yang ditetapkan dalam antarmuka pengguna pengaturan pipeline. Untuk mempelajari lebih lanjut tentang cara bekerja dengan variabel yang ditentukan pada tingkat pekerjaan, tahap, dan akar, 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 Anda menentukan variabel, Anda dapat menggunakan gaya sintaks yang berbeda (makro, ekspresi templat, atau runtime) dan gaya sintaks yang Anda gunakan akan menentukan di mana variabel Anda dirender dalam alur.

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 pipeline rilis klasik, lihat variabel rilis.

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 hanya dapat dibaca.

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 sistem dan yang ditentukan pengguna (kecuali variabel rahasia) 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 variabel any.variable menjadi nama variabel $ANY_VARIABLE.

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

Pembatasan penamaan variabel

Variabel yang ditentukan pengguna dan lingkungan dapat terdiri dari huruf, angka, ., dan _ karakter. Jangan gunakan awalan variabel yang dicadangkan oleh sistem. Ini adalah: endpoint, , inputsecret, 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, ekspresi tersebut harus menempati seluruh sisi kanan definisi.

Dalam contoh ini, Anda dapat melihat bahwa ekspresi templat masih memiliki nilai awal variabel setelah variabel diperbarui. Variabel sintaks makro diperbarui nilainya. 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

Sintaks variabel 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 tugas sebaris. Sebagai gantinya, Anda harus menggunakan properti displayName.

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 }}). Variabel templat diproses 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 waktu proses

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 waktu aktif dalam kondisi tugas, untuk mendukung eksekusi tugas bersyarat, atau tahapan keseluruhan.

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 tampilannya ketika tidak ditemukan?
makro $(var) waktu eksekusi sebelum tugas dilakukan 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 string aman atau input variabel yang telah ditentukan sebelumnya 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.

Biasanya variabel templat adalah standar untuk digunakan. Dengan memanfaatkan variabel templat, alur Anda akan sepenuhnya menyuntikkan nilai variabel ke dalam alur Anda pada kompilasi alur. Ini berguna saat mencoba men-debug alur. Anda dapat mengunduh file log dan mengevaluasi nilai yang sepenuhnya diperluas yang sedang digantikan. Karena variabel diganti, Anda tidak boleh memanfaatkan sintaks templat untuk nilai sensitif.

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 root, untuk membuatnya tersedia untuk semua tugas dalam alur kerja.
  • Pada tingkat tahap, untuk membuatnya hanya tersedia untuk tahap tertentu.
  • Pada tingkat pekerjaan, agar hanya tersedia untuk pekerjaan spesifik.

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 menggunakan kata kunci sebagai daftar spesifikator 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 ditulis dengan huruf kapital, 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

Petunjuk

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 mereka jalankan, dan Anda tidak ingin log menyertakan rahasia yang Anda masukkan sebagai input. Gunakan lingkungan skrip atau petakan variabel dalam blok variables untuk meneruskan rahasia ke pipeline Anda.

Catatan

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

Anda perlu mengatur variabel rahasia di antarmuka pengguna pengaturan alur untuk alur Anda. Variabel-variabel ini dibatasi pada pipeline tempat mereka 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 pipelinenya.

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 menampilkan rahasia sebagai output. Beberapa sistem operasi mencatat argumen baris perintah. Jangan pernah meneruskan rahasia pada baris perintah. Sebagai gantinya, kami sarankan Anda memetakan rahasia Anda ke dalam variabel lingkungan.

Kami tidak pernah mengaburkan bagian dari rahasia. Jika, misalnya, "abc123" ditetapkan sebagai rahasia, "abc" tidak disembunyikan dari log. Ini untuk menghindari menyembunyikan rahasia pada tingkat yang terlalu terperinci, sehingga log menjadi tidak dapat dibaca. Untuk alasan ini, rahasia tidak boleh berisi data terstruktur. Jika, misalnya, "{ "foo": "bar" }" diatur sebagai rahasia, "bar" tidak disembunyikan dalam 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 dengan baik.
  • $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@6
  inputs:
    SourcePath: 'my/path' # Specify the source path
    azureSubscription: 'my-subscription' # Azure subscription name
    Destination: 'AzureVMs' # Destination type
    storage: 'my-storage' # Azure storage account name
    resourceGroup: 'my-resource-group' # Resource group name
    vmsAdminUserName: $(VMS_USER) # Admin username for the VM
    vmsAdminPassword: $(VMS_PASS) # Admin password for the VM
    CleanTargetBeforeCopy: false # Do not clean the target before copying

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 build pull request dari fork. Untuk informasi selengkapnya, lihat Kontribusi dari fork.

Berbagi variabel di seluruh pipeline

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 bagaimana mengatur variabel output multi-pekerjaan. Anda juga perlu menggunakan sintaksis variabel yang berbeda untuk tugas penyebaran. Lihat Dukungan untuk variabel output dalam pekerjaan penempatan.

  • 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 langsung sebelum tahap saat ini, Anda dapat mengubah 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 Tugas 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.

Gunakan output pada 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 sebuah 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 keluaran di tahap yang berbeda

Untuk menggunakan output dari tahap yang berbeda, format untuk mereferensikan variabel adalah stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']. Pada level tahap, tetapi bukan level pekerjaan, Anda bisa 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 pada level pekerjaan, lalu meneruskan variabel sebagai masukan env:.

## 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 pada alur proses 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 jalur 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 variabel ini digunakan 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"

Keluaran dari jalur sebelumnya.

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

Tetapkan variabel output banyak 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 mendatang dengan menggunakan $[] sintaks dan menyertakan nama langkah yang menetapkan variabel. Variabel output multi-tugas hanya berfungsi untuk tugas dalam langkah yang sama.

Untuk meneruskan variabel ke pekerjaan pada 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 sebaiknya menetapkan ekspresi tersebut ke sebuah 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

Hasil dari jalur proses 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.
  • Langkah.
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 mendahului nama pekerjaan pada 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 pipeline.

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 saat waktu mengantre

Jika sebuah variabel muncul di dalam blok variables pada file YAML, nilainya tetap dan tidak dapat diubah saat 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 pipeline.

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 waktu jalan.

Untuk mengatur variabel pada waktu antrean, tambahkan variabel baru dalam alur Anda dan pilih opsi 'override'. Hanya pengguna dengan izin konfigurasi build antrean Edit yang dapat mengubah nilai variabel.

Atur variabel pada waktu antrean.

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

Untuk keamanan tambahan, gunakan sekumpulan nilai yang telah ditentukan sebelumnya untuk dapat diatur pada variabel waktu antrean dan jenis yang aman seperti boolean dan bilangan bulat. Untuk string, gunakan sekumpulan nilai yang telah ditentukan sebelumnya.

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 pipa ditentukan dalam file YAML
  4. Variabel ditetapkan saat antrean
  5. Variabel pipeline ditetapkan dalam pengaturan antarmuka pengguna Pipeline

Dalam contoh berikut, variabel a yang sama diatur pada tingkat alur dan tingkat pekerjaan dalam file YAML. Ini juga diatur dalam grup variabel G, dan sebagai variabel di UI pengaturan Pipeline.

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 menetapkan variabel dalam file YAML, jangan tentukan di editor web agar tidak dapat diatur saat 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 tugas, dan sekali di awal masing-masing dari dua tahap.

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"