Változók meghatározása

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

A változók kényelmes módot biztosítanak a kulcsadatok a folyamat különböző részeibe való belefoglalására. A változók leggyakoribb használata egy olyan érték meghatározása, amelyet a folyamat során használhat. Minden változó sztring, és mindegyik módosítható. A változó értéke futtatásról futtatásra vagy feladatról feladatra változhat a csővezetékben.

Ha ugyanazt a változót több helyen, azonos nevű helyen definiálja, a helyi hatókörű változó elsőbbséget élvez. A feladatszinten definiált változók tehát felülbírálhatnak egy változókészletet a fázis szintjén. A fázisszinten definiált változó felülbírál egy változókészletet a folyamat gyökérszintjén. A folyamat gyökérszintjének változókészlete felülbírál egy változókészletet a Folyamatbeállítások felhasználói felületén. A feladat, a fázis és a gyökérszinten definiált változók használatáról további információt a Változó hatóköre című témakörben talál.

Használhat változókat, amelyeket kifejezésekkel feltételesen értékekhez rendelhet hozzá, és tovább testre szabhatja a folyamatokat.

A változók eltérnek a futtatókörnyezet paramétereitől. A futtatási paramétereket be kell írni, és a sablon elemzése során érhetők el.

Felhasználó által definiált változók

Változó definiálásakor használjon különböző szintaxisokat (makró, sablonkifejezés vagy futtatókörnyezet). A választott szintaxis határozza meg, hogy a változó hol jelenik meg a folyamatban.

A YAML pipeline-ben állítsd be a változókat a gyökér, a szakasz és a feladatok szintjén. A felhasználói felületen a YAML-folyamaton kívül is megadhat változókat. Amikor beállít egy változót a felhasználói felületen, titkosíthatja a változót, és titkosként állíthatja be.

A felhasználó által definiált változók írásvédettként állíthatók be. A változók elnevezési korlátozásai vannak (például a változónév elején nem használhatósecret).

Változócsoportot használhat, hogy a változók több folyamat számára is elérhetőek legyenek.

Ha több pipelines használható változót szeretne definiálni egy fájlban, használja a templates.

Felhasználó által definiált többsoros változók

Azure DevOps támogatja a többsoros változókat, de van néhány korlátozás.

Előfordulhat, hogy az alsóbb rétegbeli összetevők, például a folyamatfeladatok nem kezelik megfelelően a változóértékeket.

Azure DevOps nem módosítja a felhasználó által definiált változóértékeket. A változóértékeket helyesen kell formáznia, mielőtt többsoros változóként adja át őket. A változó formázásakor kerülje a speciális karaktereket, ne használjon korlátozott neveket, és győződjön meg arról, hogy az ügynök operációs rendszerének megfelelő sorvégző formátumot használ.

A többsoros változók az operációs rendszertől függően eltérően viselkednek. A probléma elkerülése érdekében győződjön meg arról, hogy helyesen formázza a többsoros változókat a cél operációs rendszer számára.

Azure DevOps soha nem módosítja a változóértékeket, még akkor sem, ha nem támogatott formázást ad meg.

Rendszerváltozók

A felhasználó által definiált változók mellett Azure Pipelines előre definiált értékekkel rendelkező rendszerváltozókkal is rendelkezik. Az előre definiált Build.BuildId változó például megadja az egyes buildek azonosítóját, és különböző folyamatfuttatások azonosítására használható. A változót Build.BuildId szkriptekben vagy feladatokban is használhatja, ha egyedi értékre van szüksége.

Ha YAML-t vagy klasszikus build folyamatokat használ, a rendszerváltozók átfogó listájáért tekintse meg az előre definiált változókat.

Ha klasszikus kiadási csővezetékeket használ, lásd a kiadási változókat.

A folyamat futtatásakor a rendszerváltozók beállítják az aktuális értéküket. Egyes változók automatikusan be vannak állítva. Folyamatkészítőként vagy végfelhasználóként módosíthatja egy rendszerváltozó értékét a folyamat futtatása előtt.

A rendszerváltozók csak olvashatók.

Környezeti változók

A környezeti változók a használt operációs rendszerre vonatkoznak. A csővezetékbe platformspecifikusan injektálhatja őket. A formátum megfelel az adott szkriptelési platform környezeti változóinak formázásának.

UNIX rendszereken (macOS és Linux) a környezeti változók formátuma $NAME. Windows rendszeren a formátum a kötegelt feldolgozásnál %NAME% és a PowerShell-ben $env:NAME.

A rendszer- és felhasználó által definiált változók (a titkos változók kivételével) környezeti változókként is injektálhatók a platformhoz. Amikor a változók környezeti változókká alakulnak, a változók neve nagybetűssé válik, az időszakok pedig aláhúzásjelekké alakulnak. A változó neve any.variable például a változó neve $ANY_VARIABLE lesz.

A környezeti változókhoz változóelnevezési korlátozások vonatkoznak (például egy változónév elején nem használhatósecret).

Változónevek korlátozásai

A felhasználó által definiált és környezeti változók betűkből, számokból .és _ karakterekből állhatnak. Ne használjon a rendszer által fenntartott változó előtagokat. Ezek az előtagok a következők: endpoint, input, secret, pathés securefile. Azok a változók, amelyek ezekkel a sztringekkel kezdődnek (függetlenül a nagybetűsítéstől), nem lesznek elérhetők a feladatok és szkriptek számára. Ne használjon szóközöket változókban. További korlátozások: Azure Pipelines elnevezési korlátozások.

Változószintaxis ismertetése

Azure Pipelines három különböző módszert támogat a változókra való hivatkozáshoz: makró, sablonkifejezés és futtatókörnyezeti kifejezés. Az egyes szintaxisokat más célra használhatja, és mindegyiknek vannak korlátai.

A folyamatokban a sablonkifejezés változói (${{ variables.var }}) fordításkor, a futtatókörnyezet indítása előtt lesznek feldolgozva. A makrószintaxis változói ($(var)) futásidőben lesznek feldolgozva, mielőtt egy feladat lefutna. A futtatókörnyezeti kifejezések ($[variables.var]) futásidőben is feldolgozhatók, de feltételekkel és kifejezésekkel használhatók. Futtatókörnyezeti kifejezés használatakor a definíció jobb oldalának egésze ezt kell tartalmazza.

Ebben a példában láthatja, hogy a sablonkifejezés a változó frissítése után is a változó kezdeti értékével rendelkezik. A makrószintaxis változó értéke frissül. A sablonkifejezés értéke nem változik, mert a folyamat az összes sablonkifejezés-változót fordításkor dolgozza fel a feladatok futtatása előtt. Ezzel szemben a makrószintaxis változói az egyes tevékenységek futtatása előtt kiértékelnek.

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

Makrószintaxis változói

A legtöbb dokumentációs példa makrószintaxist ($(var)) használ. Makrószintaxis használatával interpolálhatja a változóértékeket feladatbemenetekbe és más változókba.

A rendszer makrószintaxissal dolgozza fel a változókat, mielőtt egy feladat futásidőben végrehajtanák. A futási idő a sablonbővítés után következik be. Amikor a rendszer makrókifejezéssel találkozik, lecseréli a kifejezést a változó tartalmára. Ha ezen a néven nincs változó, a makrókifejezés nem változik. Ha például $(var) nem lehet lecserélni, az a következő marad $(var): .

A makrószintaxis változói változatlanok maradnak, ha nincs értékük, mert egy üres érték, például $() jelenthet valamit a futó feladat számára, és az ügynök nem feltételezheti, hogy ezt az értéket szeretné lecserélni. Ha például a $(foo)-ot egy változóként használja a Bash-feladatban, a feladat bemeneti adataiban lévő összes foo kifejezés cseréje megszakíthatja a bash szkripteket.

A makróváltozók csak akkor bontanak ki, ha egy értékhez használják őket, nem kulcsszóként. Az értékek a folyamatdefiníció jobb oldalán jelennek meg. A következő érvényes: key: $(value). A következő érvénytelen: $(key): value. A makróváltozók nem kerülnek kibontásra, ha egy feladatnév beágyazott megjelenítésére használják őket. Ehelyett a tulajdonságot displayName kell használnia.

Feljegyzés

A rendszer csak a feladatbemenetek makrószintaxis változóit bontja ki a stages, jobs, és steps-ban. Nem bontja ki őket olyan folyamat kulcsszavakban, amelyek fordításkor feloldódnak, például resources, triggervagy a checkout lépés adattárának referenciaértéke (például checkout: git://MyProject/MyRepo@$(var) nem működik). Az értékek paraméterezéséhez használjon sablonkifejezéseket (${{ }}) vagy futtatókörnyezeti paramétereket .

Ez a példa a Bash, a PowerShell és egy szkriptfeladat makrószintaxisát használja. A változók makrószintaxissal történő meghívásának szintaxisa mind a háromhoz azonos.

variables:
 - name: projectName
   value: contoso

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

Sablonkifejezés szintaxisa

Sablonkifejezés-szintaxis használata a sablonparaméterek és a változók (${{ variables.var }}) kibontásához. A rendszer fordításkor feldolgozza a sablonváltozókat, és lecseréli őket a futtatókörnyezet megkezdése előtt. Sablonkifejezések használata a YAML egyes részeinek sablonként való újrafelhasználására.

A sablonváltozók csendesen üres sztringekké süllyesznek, ha nem található helyettesítő érték. A sablonkifejezések a makró- és futtatókörnyezeti kifejezésekkel ellentétben kulcsként (bal oldalon) vagy értékekként (jobb oldalon) jelenhetnek meg. A következő érvényes: ${{ variables.key }} : ${{ variables.value }}.

Futtatókörnyezeti kifejezés szintaxisa

Futásidejű kifejezés szintaxisa olyan változókhoz használható, amelyek futásidőben ($[variables.var]) bontanak ki. A futtatókörnyezeti kifejezés változói csendesen üres karaktersorozatokként alakulnak át, ha nem található helyettesítő érték. A feladatok vagy egész szakaszok feltételes végrehajtásának támogatásához használjon futtatókörnyezeti kifejezéseket a feladatfeltételekben.

A futtatókörnyezeti kifejezés változói csak akkor bontanak ki, ha egy értékhez használják őket, nem kulcsszóként. Az értékek a folyamatdefiníció jobb oldalán jelennek meg. A következő érvényes: key: $[variables.value]. A következő érvénytelen: $[variables.key]: value. A futtatókörnyezeti kifejezésnek egy kulcs-érték pár teljes jobb oldalát fel kell vennie. Például érvényes, key: $[variables.value] de key: $[variables.value] foo nem.

Szintaxis Példa Mikor történik a feldolgozás? Hol bővül ki egy csővezeték definíciója? Hogyan jelenik meg, ha nem található?
makró $(var) futásidő a feladat végrehajtása előtt érték (jobb oldal) Nyomatok $(var)
sablonkifejezés ${{ variables.var }} fordítási idő kulcs vagy érték (bal vagy jobb oldal) üres karaktersorozat
futtatókörnyezeti kifejezés $[variables.var] Futtatási idő érték (jobb oldal) üres karaktersorozat

Milyen szintaxist használjak?

Makrószintaxis használata, ha biztonságos sztringet vagy predefinált változót bemenetet ad meg egy tevékenységhez.

Válasszon futtatókörnyezeti kifejezést, ha feltételekkel és kifejezésekkel dolgozik. Ne használjon futtatókörnyezeti kifejezést, ha nem szeretné kinyomtatni az üres változót (például: $[variables.var]). Ha például olyan feltételes logikával rendelkezik, amely egy adott értékkel vagy értékkel nem rendelkező változóra támaszkodik, használjon makrókifejezést.

Általában egy sablonváltozó használata a szokásos. A sablonváltozók kihasználásával a pipeline teljes mértékben beilleszti a változó értékét a pipeline-ba a pipeline összeállítása során. Ez az injektálás hasznos, ha valaki folyamatok hibakeresését próbálja elvégezni. Letöltheti a naplófájlokat, és kiértékelheti a teljesen kibontott értéket, amelyet beillesztenek. Mivel a változó be van helyettesítve, ne használja a sablon szintaxisát a bizalmas értékekhez.

Változószintaxissal kapcsolatos problémák azonosítása AI használatával

Ez a példa a Copilot Chatben meghatározza, milyen típusú változókat használnak egy folyamatsorban, és mikor oldódnak meg a változók. Jelölje ki a YAML-kódot, majd írja be a következő Copilot-csevegési üzenetet.

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

Igény szerint testre szabhatja a kérést, hogy konkrétumokat adjon hozzá.

A Copilot mesterséges intelligenciával működik, így meglepetések és hibák lehetségesek. További információkért lásd a Copilot gyakori kérdéseket.

Változók beállítása a folyamatban

A leggyakoribb esetben állítsa be a változókat, és használja őket a YAML-fájlban. Ez a módszer lehetővé teszi a változó változásainak nyomon követését a verziókövetési rendszerben. A folyamatbeállítások felhasználói felületén változókat is definiálhat (lásd a Klasszikus lapot), és hivatkozhat rájuk a YAML-ben.

Az alábbi példa bemutatja, hogyan állíthat be két változót, configuration és platformhogyan használhatja őket később a lépések során. Ha egy változót egy YAML-utasításban szeretne használni, csomagolja be.$() YaML-utasításban nem definiálhat repository változókat.

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

Változó hatókörök

A YAML-fájlban állítson be egy változót különböző hatókörökben:

  • A gyökérszinten, hogy elérhetővé váljon a teljes folyamat minden feladata számára.
  • A fázis szintjén, hogy csak egy adott szakasz számára legyen elérhető.
  • Feladatszinten, hogy csak egy adott feladat számára legyen elérhető.

Amikor meghatároz egy változót egy YAML tetején, a változó a folyamat összes feladata és fázisa számára elérhető, és globális változó. A YAML-ben definiált globális változók nem láthatók a folyamatbeállítások felhasználói felületén.

A feladatszintű változók felülbírálják a változókat a gyökér- és a fázisszinten. A fázisszintű változók felülbírálják a változókat a gyökérszinten.

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

Mindkét feladat kimenete így néz ki:

# job1
value 
value1
value1

# job2
value
value2
value

Változók megadása

Az előző példákban a variables kulcsszót a kulcs-érték párok listája követi. A kulcsok a változók nevei, az értékek pedig a változóértékek.

Egy másik szintaxis akkor hasznos, ha változókhoz vagy változócsoportokhoz szeretne sablonokat használni.

Sablonok használatával változókat definiálhat egy YAML-fájlban, és felveheti őket egy másik YAML-fájlba.

A változócsoportok olyan változók, amelyeket több folyamatba is be lehet illeszteni. A változócsoportok használatával egy helyen kezelheti és rendszerezheti a különböző szakaszokban gyakori változókat.

Használja ezt a szintaxist a folyamat gyökérszintjén lévő változósablonokhoz és változócsoportokhoz.

Ebben a másodlagos szintaxisban a variables kulcsszó a változók megadóinak listáját tartalmazza. A változójelölők name egy normál változóhoz, group egy változócsoporthoz tartoznak, és template egy változósablont is tartalmaznak. Az alábbi példa mindháromat szemlélteti.

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

További információkért tekintse meg a változók sablonokkal való újrafelhasználását.

Hozzáférés a változókhoz a környezeten keresztül

Figyelje meg, hogy a változók környezeti változókon keresztül is elérhetők a szkriptek számára. A környezeti változók használatának szintaxisa a szkriptnyelvtől függ.

A név nagybetűvel van írva, és a . le lesz cserélve a _-re. Ez automatikusan be lesz szúrva a folyamatkörnyezetbe. Íme néhány példa:

  • Batch-szkript: %VARIABLE_NAME%
  • PowerShell-szkript: $env:VARIABLE_NAME
  • Bash-szkript: $VARIABLE_NAME

Fontos

A fájlelérési utakat tartalmazó előre definiált változók az ügynök gazdagéptípusa és a rendszerhéj típusa alapján a megfelelő stílusra (Windows-stílus: C:\foo\ és Unix-stílus: /foo/) lesznek átalakítva. Ha Bash-szkriptfeladatokat futtat Windows rendszeren, a környezeti változó metódus használatával érheti el ezeket a változókat a folyamatváltozó metódus helyett, hogy a megfelelő fájlelérési útvonal-stílussal rendelkezzen.

Titkos változók beállítása

Tipp.

A titkos változók nem lesznek automatikusan exportálva környezeti változókként. Ha titkos változókat szeretne használni a szkriptekben, explicit módon képezheti le őket környezeti változókra. További információ: Titkos kódváltozók beállítása.

Ne állítson be titkos változókat a YAML-fájlban. Az operációs rendszerek gyakran naplózzák az általuk futtatott folyamatok parancsait, és nem szeretné, hogy a napló tartalmazzon bemenetként átadott titkos kódot. Használja a szkript környezetét, vagy adja hozzá a változót a variables blokkon belül, hogy titkokat adjon át a csővezetékbe.

Feljegyzés

Azure Pipelines az adatok folyamatnaplókba való kibocsátásakor igyekszik elfedni a titkos kulcsokat, így további változók és adatok is megjelenhetnek a kimenetben és a naplókban, amelyek nincsenek titkos kulcsként beállítva.

Titkos változókat kell beállítania a folyamat folyamatbeállítási felhasználói felületén. Ezek a változók hatóköre arra a folyamatra terjed ki, amelyben be vannak állítva. A titkos változókat változócsoportokban is beállíthatja.

Ha titkos kulcsokat szeretne beállítani a webes felületen, kövesse az alábbi lépéseket:

  1. Lépjen a Pipelines lapra, válassza ki a megfelelő folyamatot, majd válassza a Szerkesztés lehetőséget.
  2. Keresse meg a folyamat változóit .
  3. Adja hozzá vagy frissítse a változót.
  4. A változó titkosított tárolásához válassza az érték titokban tartásának lehetőségét.
  5. Mentse el a csővezetéket.

A titkos változók inaktív állapotban, 2048 bites RSA-kulccsal vannak titkosítva. A titkos kódok az ügynökön érhetők el a használni kívánt feladatokhoz és szkriptekhez. Ügyeljen arra, hogy ki fér hozzá a csővezeték módosításához.

Fontos

Igyekszünk elfedni a titkos kódokat a Azure Pipelines kimenetben való megjelenéstől, de továbbra is óvintézkedéseket kell tennie. Soha ne visszhangozza a titkos kulcsokat kimenetként. Néhány operációs rendszer naplózza a parancssori argumentumokat. Soha ne adjon át titkos kulcsokat a parancssorban. Ehelyett azt javasoljuk, hogy a titkokat környezeti változókra képezze le.

Soha nem maszkoljuk a titkos kódok részszúrásait. Ha például az "abc123" titkos kódként van beállítva, az "abc" nem kerül maszkolásra a naplókban. Ennek az az oka, hogy a titkos kulcsok túl részletes elfedésének elkerülése érdekében a naplók olvashatatlanok lesznek. Ezért a titkos kódok nem tartalmazhatnak strukturált adatokat. Ha például a "{ "foo": "bar" }" titkosnak van beállítva, a "bar" nincs elrejtve a naplókból.

A normál változókkal ellentétben, ezek nem kerülnek automatikusan visszafejtésre és nem alakulnak át a szkriptek környezeti változóivá. Egyértelműen meg kell adnia a titkos változókat.

Az alábbi példa bemutatja, hogyan képezheti le és használhatja a PowerShell- és Bash-szkriptekben hívott mySecret titkos változókat. Két globális változó van definiálva. GLOBAL_MYSECRET egy titkos változó mySecretértékét rendeli hozzá, és GLOBAL_MY_MAPPED_ENV_VAR egy nem titkos változó nonSecretVariableértékét rendeli hozzá. A normál folyamatváltozótól eltérően nincs neve környezeti változónak MYSECRET.

A PowerShell-feladat egy szkriptet futtat a változók nyomtatásához.

  • $(mySecret): Ez közvetlen hivatkozás a titkos változóra, és működik.
  • $env:MYSECRET: Ez kísérletet tesz arra, hogy a titkos változót környezeti változóként elérje, ami nem működik, mert a titkos változók nem térképeződnek le automatikusan a környezeti változókra.
  • $env:GLOBAL_MYSECRET: Ez megpróbálja elérni a titkos változót egy globális változón keresztül, ami szintén nem működik, mert a titkos változók nem képezhetők le így.
  • $env:GLOBAL_MY_MAPPED_ENV_VAR: Ez egy globális változón keresztül éri el a nem titkos változót, amely működik.
  • $env:MY_MAPPED_ENV_VAR: Ez egy feladatspecifikus környezeti változón keresztül éri el a titkos változót, amely a titkos változók környezeti változókhoz való leképezésének ajánlott módja.
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

Az előző szkript mindkét feladatának kimenete a következőképpen néz ki:

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

A szkripteken kívül titkos változókat is használhat. A titkos változókat például leképezheti a feladatokhoz a variables definíció használatával. Ez a példa bemutatja, hogyan használható titkos változók $(vmsUser) és $(vmsAdminPass) egy Azure fájlmásolási feladatban.

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

Titkos kód változóinak hivatkozása változócsoportokban

Ez a példa bemutatja, hogyan hivatkozhat egy változócsoportra a YAML-fájlban, és hogyan adhat hozzá változókat a YAML-ben. A példa két változót használ a változócsoportból: user és token. A token változó titkos, és a környezeti változóra $env:MY_MAPPED_TOKEN van leképezve, így hivatkozhat rá a YAML-ben.

Ez a YAML REST-hívást indít a kiadások listájának lekéréséhez, és megjeleníti az eredményt.

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

Fontos

Alapértelmezés szerint a GitHub adattárakban a forkok lekéréses kérelmei nem férhetnek hozzá a folyamathoz társított titkos változókhoz. További információ: Hozzájárulások forkokból.

Változók megosztása folyamatok között

Több pipeline változóinak megosztásához a projektben használja a webes felületet. A Kódtár csoportban használjon változócsoportokat.

Kimeneti változók használata tevékenységekből

Egyes tevékenységek kimeneti változókat határoznak meg, amelyeket alsóbb rétegbeli lépésekben, feladatokban és szakaszokban használhat. YAML-ben különböző feladatok és szakaszok változóihoz férhet hozzá dependencies használatával.

Ha mátrixfeladatokra hivatkozik az alsóbb rétegbeli tevékenységekben, használjon másik szintaxist. Lásd: Többfeladatos kimeneti változó beállítása. Az üzembehelyezési feladatok változóihoz másik szintaxist is használnia kell. Lásd: A kimeneti változók támogatása az üzembe helyezési feladatokban.

  • Ha egy másik feladatból származó változóra szeretne hivatkozni ugyanazon a feladaton belül, használja a következőt TASK.VARIABLE: .
  • Ha egy másik feladatból származó tevékenység változóira szeretne hivatkozni, használja a következőt dependencies.JOB.outputs['TASK.VARIABLE']: .

Feljegyzés

Alapértelmezés szerint a folyamat minden szakasza a YAML fájlban az előtte lévő közvetlen szakasztól függ. Ha olyan szakaszra kell hivatkoznia, amely nem közvetlenül az aktuális előtt van, felülbírálhatja ezt az automatikus alapértelmezett beállítást úgy, hogy hozzáad egy szakaszt dependsOn a szakaszhoz.

Feljegyzés

Az alábbi példák szabványos folyamatszintaxist használnak. Ha üzembe helyezési folyamatokat használ, a változók és a feltételes változók szintaxisa is eltérő lesz. A használni kívánt szintaxissal kapcsolatos információkért lásd az üzembe helyezési feladatokat.

Ezekben a példákban tegyük fel, hogy van egy nevesített MyTaskfeladat, amely beállít egy kimeneti változót.MyVar További információ a Kifejezések – Függőségek szintaxisáról.

Az eredmények felhasználása ugyanabban a munkában

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

Kimenetek használata másik feladatban

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

Más szakaszban történő kimenetek használata

Ha egy másik fázis kimenetét szeretné használni, használja a formátumot stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE'] a változókra való hivatkozáshoz. A fázis szintjén, de nem a feladat szintjén használhatja ezeket a változókat feltételekben.

A kimeneti változók csak a következő alsó szakaszban érhetők el. Ha több fázis is ugyanazt a kimeneti változót használja, használja a feltételt 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

A fázisok közötti változókat fájlbemenettel is átadhatja. Ehhez a második szakaszban meg kell határoznia a változókat munka szintjén, majd a változókat env: bemenetként kell továbbítania.

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

Az előző folyamat szakaszainak kimenete a következőképpen néz ki:

Hello inline version
true
crushed tomatoes

Változók listázása

A folyamat összes változójának listázása a az pipelines változólista paranccsal. A kezdéshez lásd: Get started with Azure DevOps CLI.

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

Paraméterek

  • org: Azure DevOps-szervezet URL-címe. Konfigurálja az alapértelmezett szervezetet a következő használatával az devops configure -d organization=ORG_URL: . Kötelező, ha nincs alapértelmezettként konfigurálva, vagy ha a git config használatával veszi fel az elemet. Példa: --org https://dev.azure.com/MyOrganizationName/.
  • folyamatazonosító: Szükség van rá, ha a folyamat neve nem szerepel a megadott adatok között. Az adatfolyam azonosítója.
  • pipeline-name: Kötelező, ha a folyamatazonosító nincs megadva, de figyelmen kívül hagyva, ha a folyamatazonosító meg van adva. Az adatfolyam neve.
  • project: A project neve vagy azonosítója. Konfigurálja az alapértelmezett projektet a az devops configure -d project=NAME_OR_ID használatával. Kötelező, ha nincs alapértelmezettként konfigurálva, vagy ha a git config használatával veszi fel az elemet.

Példa

Az alábbi parancs felsorolja a folyamat összes változóját 12-s azonosítóval, és táblaformátumban jeleníti meg az eredményt.

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

Változók beállítása szkriptekben

A szkriptek meghatározhatnak olyan változókat, amelyeket a folyamat későbbi lépései használnak. A metódus által beállított összes változó sztringként lesz kezelve. Ha egy változót szkriptből szeretne beállítani, használjon parancsszintaxist, és nyomtassa ki az stdout parancsot.

Feladat hatókörű változó beállítása szkriptből

Ha egy változót parancsfájlból szeretne beállítani, használja a naplózási task.setvariableparancsot. Ez a parancs frissíti a környezeti változókat a későbbi feladatokhoz. A következő feladatok a makrószintaxis használatával, illetve környezeti változóként férhetnek hozzá az új változóhoz.

Ha igaz értékre van állítva issecret , a változó értéke titkosként lesz mentve, és maszkolva lesz a naplóból. A titkos változókkal kapcsolatos további információkért lásd a naplózási parancsokat.

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)

A következő lépésekben a folyamatváltozót is hozzáadják a környezetükhöz. A definiált lépésben nem használhatja a változót.

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"

Az előző folyamat kimenete.

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

Többfeladatos kimeneti változó beállítása

Ha elérhetővé szeretne tenni egy változót a jövőbeli feladatok számára, a következővel isOutput=truekimeneti változóként kell megjelölnie. Ezután a $[] szintaxis használatával és a változót beállító lépés nevének megadásával leképezheti a jövőbeli feladatokba. A többfeladatos kimeneti változók csak ugyanabban a szakaszban lévő feladatokhoz működnek.

Ha változókat szeretne átadni a különböző fázisokban lévő feladatoknak, használja a szakaszfüggőségek szintaxisát .

Feljegyzés

Alapértelmezés szerint a folyamat minden szakasza a YAML fájlban az előtte lévő közvetlen szakasztól függ. Ezért minden fázis használhatja az előző fázis kimeneti változóit. A további szakaszok access módosítania kell a függőségi gráfot, például ha a 3. fázishoz az 1. fázis változója szükséges, akkor explicit függőséget kell deklarálnia az 1. fázisban.

Többfeladatos kimeneti változó létrehozásakor a kifejezést hozzá kell rendelnie egy változóhoz. Ebben a YAML-ben $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] a változóhoz $(myVarFromJobA)van rendelve.

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

Az előző folyamat kimenete.

this is the value
this is the value

Ha változót állít be egyik fázisból a másikba, használja a következőt 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)

Ha egy változót egy mátrix vagy darab értékről állít be, akkor, ha egy következő feladatból szeretne hivatkozni erre a változóra, az alábbiakat kell tartalmaznia:

  • A feladat neve.
  • A lépés.
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:
    myVarFromJobsA: $[ dependencies.A.outputs['setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromJobsA)"
    name: echovar

Ügyeljen arra, hogy a feladat nevét előtagként adja hozzá az üzembehelyezési feladat kimeneti változóihoz. Ebben az esetben a feladat neve: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

Változók beállítása kifejezések használatával

A változók kifejezéssel állíthatók be. A módszer egyik esete már előfordult, amikor egy változót egy korábbi feladatból származó másik változó kimenetére állított be.

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

A változó beállításához a támogatott kifejezések bármelyikét használhatja. Íme egy példa egy olyan változó beállítására, amely számlálóként működik, amely 100-nál kezdődik, minden futtatásnál 1-zel növekszik, és naponta 100-ra lesz visszaállítva.

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

A számlálókkal, függőségekkel és más kifejezésekkel kapcsolatos további információkért lásd a kifejezéseket.

Beállítási változók konfigurálása lépésekhez

Definiálhat settableVariables egy lépésen belül, vagy megadhatja, hogy nem állíthatók be változók.

Ebben a példában a szkript nem tud változót beállítani.

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

Az alábbi példában a szkript beállíthatja a változót sauce , de nem tudja beállítani a változót secretSauce. Figyelmeztetés jelenik meg a folyamatfuttatási lapon.

Figyelmeztetés, hogy a secretSauce nem állítható be. 

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

Engedélyezés várakozási idő alatt

Ha egy változó megjelenik egy variables YAML-fájl blokkjában, az értéke rögzített, és a felhasználók nem módosíthatják ütemezéskor. Definiálja a változókat egy YAML-fájlban, de vannak olyan esetek, amikor ennek a megközelítésnek nincs értelme. Előfordulhat például, hogy titkos változót szeretne definiálni, és nem teszi elérhetővé a YAML-ben. Vagy előfordulhat, hogy manuálisan kell beállítania egy változóértéket a folyamat futtatása során.

Az üzenetsor-idő értékek meghatározására két lehetőség áll rendelkezésre. Definiálhat egy változót a felhasználói felületen, és kiválaszthatja azt a lehetőséget, hogy a felhasználók felülbírálják ezt az értéket a folyamat futtatásakor, vagy használhat helyette futtatókörnyezeti paramétereket. Ha a változó nem titkos, akkor ajánlott futtatókörnyezeti paramétereket használni.

Ahhoz, hogy egy változót a várólista idején állítson be, adjon hozzá egy új változót a folyamathoz, és válassza a felülírási lehetőséget. Csak azok a felhasználók módosíthatják egy változó értékét, akik rendelkeznek a szerkesztési várólista-konfiguráció engedéllyel.

Állítson be egy változót várakozási idő esetén.

Annak érdekében, hogy egy változót várakozási időben lehessen beállítani, győződjön meg arról, hogy a változó nem jelenik meg egy variables folyamat vagy feladat blokkjában sem. Ha egy változót a YAML változóblokkjában és a felhasználói felületen is meghatároz, a YAML-ben lévő érték prioritással rendelkezik.

A biztonság növelése érdekében használjon előre meghatározott értékeket az üzenetsor-időben beállítható változókhoz, és válasszon biztonságos típusokat, mint például logikai értékeket és egész számokat. Sztringek esetén használjon előre definiált értékkészletet.

Változók bővítése

Ha egy azonos nevű változót több hatókörben állít be, a következő elsőbbséget kell alkalmaznia (előbb a legmagasabb prioritást):

  1. A YAML-fájlban beállított feladatszintű változó
  2. A YAML-fájlban beállított fázisszszintű változó
  3. A YAML-fájlban beállított folyamatszintű változó
  4. Várakozás során beállított változó
  5. Folyamatbeállítások felhasználói felületén beállított folyamatváltozó

Az alábbi példában ugyanez a változó a a YAML-fájl folyamat- és feladatszintjén van beállítva. Emellett egy változócsoportban G, valamint a Folyamatbeállítások felhasználói felületén lévő változóként is be van állítva.

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'

Ha egy azonos nevű változót állít be ugyanabban a hatókörben, az utolsó beállítás értéke elsőbbséget élvez.

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

Feljegyzés

Amikor beállít egy változót a YAML-fájlban, ne tegye beállíthatóvá a webes szerkesztőben a feladat sorba állításakor. Jelenleg nem módosíthatja a YAML-fájlban az üzenetsor idején beállított változókat. Ha egy változót várólista idején kell beállítania, ne állítsa be a YAML-fájlban.

A változók a futtatás kezdetekor kibontásra kerülnek, majd ismét az egyes lépések elején. Példa:

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

Az előző példában két lépés szerepel. A bővítés $(a) egyszer történik a feladat elején, és egyszer mindkét lépés elején.

Mivel a változók a feladat elején vannak kibontva, nem használhatja őket stratégiában. Az alábbi példában nem használhatja a változót a a feladatmátrix kibontására, mert a változó csak az egyes kibontott feladatok elején érhető el.

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

Ha a változó a egy korábbi feladat kimeneti változója, akkor egy későbbi feladatban is használhatja.

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

Rekurzív bővítés

Az ügynöknél a $( ) szintaxissal hivatkozott változókat rekurzívan bontják ki. Példa:

variables:
  myInner: someValue
  myOuter: $(myInner)

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