Megosztás a következőn keresztül:

Változók meghatározása

  • Cikk

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

A változók kényelmes módszert nyújtanak ahhoz, hogy fontos adatokat beillesszen a folyamat különböző részeibe. A változók használatának leggyakoribb módja egy olyan érték meghatározása, amelyet azután a folyamatban használhat. Minden változó sztring, és mindegyik módosítható. A változók értéke a folyamatban futtatásról futtatásra vagy feladatról feladatra módosítható.

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.

A változók kifejezésekkel való használatával feltételesen hozzárendelhet értékeket, és további folyamatokat szabhat testre.

A változók nem azonosak a futtatási paraméterekkel. 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 különböző szintaxisokat (makró, sablonkifejezés vagy futtatókörnyezet) használhat, és a használt szintaxis határozza meg, hogy a változó hol jelenik meg a folyamatban.

A YAML-folyamatokban a változókat a gyökér, a fázis és a feladat szintjén állíthatja be. 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, az titkosítható és titkosként állítható 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).

Egy változócsoport használatával több folyamaton keresztül is elérhetővé teheti a változókat.

Sablonokkal definiálhat változókat egy fájlban, amelyet több folyamat is használ.

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

Az 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.

Az Azure DevOps nem módosítja a felhasználó által definiált változóértékeket. A változóértékeket helyesen kell formázni, mielőtt többsoros változóként adjuk á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. Ennek 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.

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

Rendszerváltozók

A felhasználó által definiált változók mellett az 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- vagy klasszikus buildfolyamatokat használ, a rendszerváltozók átfogó listájának előre definiált változóit tekintheti meg.

Ha klasszikus kiadási folyamatokat használ, tekintse meg a kiadási változókat.

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

A rendszerváltozók írásvédettek.

Környezeti változók

A környezeti változók a használt operációs rendszerre vonatkoznak. Platformspecifikus módon injektálják őket egy folyamatba. 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 %NAME% kötegelt és $env:NAME PowerShell-alapú.

A rendszer- és felhasználó által definiált változók 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_VARIABLElesz.

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ók elnevezési 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 a következők: endpoint, input, secret, pathés securefile. Az ilyen sztringekkel kezdődő változók (a nagybetűsítéstől függetlenül) nem lesznek elérhetők a tevékenységek és szkriptek számára.

Változószintaxis ismertetése

Az Azure Pipelines három különböző módszert támogat a változók hivatkozására: a makrókat, a sablonkifejezéseket és a futtatókörnyezeti kifejezéseket. 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ó teljes jobb oldalát ennek kell kitennie.

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 az összes sablonkifejezés-változó feldolgozásra kerül fordításkor 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. A makrószintaxis célja, hogy a változóértékeket a tevékenységbemenetekbe és más változókba interpolálja.

A makrószintaxissal rendelkező változók feldolgozása a feladat futásideje során történő végrehajtása előtt történik. A futtatókörnyezet a sablonbővítés után történik. Amikor a rendszer makrókifejezéssel találkozik, lecseréli a kifejezést a változó tartalmára. Ha nincs ilyen nevű változó, akkor a makrókifejezés nem változik. Ha például $(var) nem lehet lecserélni, $(var) akkor a rendszer nem cseréli le semmit.

A makrószintaxis változói érték nélkül változatlanok maradnak, mert egy üres érték, például $() jelenthet valamit a futtatott feladat számára, és az ügynök nem feltételezheti, hogy ezt az értéket szeretné lecserélni. Ha például egy Bash-feladat változójára foo hivatkozik$(foo), a feladat bemenetében lévő összes $() kifejezés cseréje megszakíthatja a Bash-szkripteket.

A makróváltozók csak akkor lesznek kibontva, 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 lesznek kibontva, ha egy feladatnév beágyazott megjelenítésére szolgálnak. Ehelyett a tulajdonságot displayName kell használnia.

Feljegyzés

A makrószintaxis változói csak a , jobsés stepsa stages. Például nem használhat makrószintaxist egy resource vagy trigger.

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

variables:
 - name: projectName
   value: contoso

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

Sablonkifejezés szintaxisa

A sablonkifejezés szintaxisa a sablonparaméterek és a változók (${{ variables.var }}) kibontására is használható. A sablonváltozók fordítási időben dolgoznak fel, és a futtatókörnyezet megkezdése előtt lecserélik. A sablonkifejezések a YAML egyes részeinek sablonként való újrafelhasználására lettek kialakítva.

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

A futtatókörnyezeti kifejezés szintaxisa a futtatókörnyezetben ($[variables.var]) kibontott változókhoz használható. A futtatókörnyezeti kifejezés változói csendesen üres sztringekké hatnak, ha nem található helyettesítő érték. Futásidejű kifejezések használata feladatfeltételekben a feladatok feltételes végrehajtásának támogatására vagy teljes szakaszokban.

A futtatókörnyezeti kifejezés változói csak akkor lesznek kibontva, 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.

Syntax Példa Mikor történik a feldolgozás? Hol bontja ki a folyamatdefiníciót? Hogyan jelenik meg, ha nem található?
makró $(var) futtatókörnyezet 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 sztring
futtatókörnyezeti kifejezés $[variables.var] Runtime érték (jobb oldal) üres sztring

Milyen szintaxist használjak?

Makrószintaxis használata, ha biztonságos sztringet vagy előre definiált változó bemenetet biztosít egy tevékenységhez.

Ha feltételekkel és kifejezésekkel dolgozik, válasszon futtatókörnyezeti kifejezést. 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. Ebben az esetben makrókifejezést kell használnia.

Általában a sablonváltozó a szokásos. A sablonváltozók használatával a folyamat teljes mértékben injektálja a változó értékét a folyamatba a folyamat fordítása során. Ez akkor hasznos, ha folyamatokat próbál hibakeresésre használni. Letöltheti a naplófájlokat, és kiértékelheti a lecserélt teljes kibontott értéket. Mivel a változó be van helyettesítve, nem szabad sablonszintaxisokat használni a bizalmas értékekhez.

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

A leggyakoribb esetben beállítja a változókat, és a YAML-fájlban használja őket. Ez lehetővé teszi a változó módosítá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.

Íme egy példa, amely 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.$() A változók nem definiálhatók repository YAML-utasításban.

# 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 különböző hatókörökben állíthat be változókat:

  • A gyökérszinten, hogy elérhetővé tegye a folyamat összes feladatának.
  • 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.

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

Sablonokkal a változók definiálhatók egy YAML-fájlban, és egy másik YAML-fájlban is megtalálhatók.

A változócsoportok olyan változók, amelyeket több folyamaton keresztül is használhat. Lehetővé teszik olyan változók kezelését és rendszerezését, amelyek egy helyen gyakoriak a különböző szakaszokban.

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ó a változók sablonokkal való újrafelhasználásáról.

Változók elérése 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űs, a helyére pedig a . _. 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 lefordí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 képezheti le a blokkon belüli változót, variables hogy titkos kulcsokat adjon át a folyamatnak.

Feljegyzés

Az Azure Pipelines arra törekszik, hogy titkos kulcsokat rejtsen el, amikor adatokat bocsát ki a folyamatnaplókba, így további változókat és adatokat láthat 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 Folyamatok 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 a folyamatot.

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 kinek van hozzáférése a folyamat módosításához.

Fontos

Igyekszünk elfedni a titkos kulcsokat az Azure Pipelines kimenetében való megjelenéstől, de óvintézkedéseket kell tennie. Soha ne visszhangozza a titkos kulcsokat kimenetként. Néhány operációs rendszer naplójának parancssori argumentumai. Soha ne adjon át titkos kulcsokat a parancssorban. Ehelyett azt javasoljuk, hogy a titkos kulcsokat környezeti változókra képezheti 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 maszkolódik a naplókból. 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" }" titkos kódként van beállítva, a "bar" nem lesz maszkolva a naplókból.

A normál változókkal ellentétben a rendszer nem fejti vissza automatikusan a szkriptek környezeti változóira. Explicit módon le kell képeznie 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örnyezeti változóként próbálja elérni a titkos változót, ami nem működik, mert a titkos változók nem lesznek automatikusan leképezve a környezeti változókra.
  • $env:GLOBAL_MYSECRET: Ez egy globális változón keresztül próbálja elérni a titkos változót, amely 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 tevékenységének kimenete így nézne 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 feladatokra a variables definíció használatával. Ez a példa bemutatja, hogyan használhat titkos változókat $(vmsUser) és $(vmsAdminPass) azure-fájlmásolási feladatokat.

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)

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 változócsoport két változót használ: user és token. A token változó titkos, és a környezeti változóra $env:MY_MAPPED_TOKEN van leképezve, hogy hivatkozni lehessen 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

A GitHub-adattárakban alapértelmezés szerint a folyamathoz társított titkos változók nem érhetők el az elágaztatások lekérési kéréseinek összeállításához. További információt az elágazásokból származó hozzájárulások című témakörben talál.

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

Ha több folyamat változóit szeretné megosztani 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 az alsóbb rétegbeli lépésekben, feladatokban és szakaszokban használhat fel. A YAML-ben a különböző feladatok és szakaszok változóit függőségek használatával érheti el.

Ha mátrixfeladatokra hivatkozik az alsóbb rétegbeli tevékenységekben, más szintaxist kell használnia. 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.

Egyes tevékenységek kimeneti változókat határoznak meg, amelyeket az alsóbb rétegbeli lépésekben és feladatokban használhat fel ugyanabban a fázisban. A YAML-ben a különböző feladatok változóit függőségek használatával érheti el.

  • 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 lévő előtt lévőtő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 üzembehelyezési folyamatokat használ, a változó és a feltételes változó 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 feladatunk MyTask, amely egy úgynevezett kimeneti változót MyVarállít be. További információ a Kifejezések – Függőségek szintaxisáról.

Kimenetek használata ugyanabban a feladatban

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

Kimenetek használata más fázisban

Ha egy másik fázis kimenetét szeretné használni, a hivatkozó változók formátuma a következő stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']: . A fázis szintjén, de a feladat szintjén ezeket a változókat feltételek között használhatja.

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 a feladat szintjén, majd bemenetként env: kell átadnia a változókat.

## 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át az az pipelines változólista paranccsal listázhatja. Első lépésként tekintse meg az Azure DevOps parancssori felület használatának első lépéseit.

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

Paraméterek

  • org: Azure DevOps-szervezet URL-címe. Az alapértelmezett szervezetet konfigurálhatja a következővel az devops configure -d organization=ORG_URL: . Kötelező, ha nincs alapértelmezettként konfigurálva, vagy ha a rendszer felvette a következőt git config: . 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. A folyamat 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. A folyamat neve.
  • projekt: A projekt neve vagy azonosítója. Az alapértelmezett projektet konfigurálhatja a következővel az devops configure -d project=NAME_OR_ID: . Kötelező, ha nincs alapértelmezettként konfigurálva, vagy ha a használatával git configveszi fel a 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 később a folyamat későbbi lépései során használnak fel. A metódus által beállított összes változó sztringként lesz kezelve. Ha egy változót egy szkriptből szeretne beállítani, használja a parancs szintaxisát, é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.setvariable parancsot. Ez frissíti a környezeti változókat a későbbi feladatokhoz. A későbbi feladatok hozzáférhetnek az új változóhoz makrószintaxissal és a tevékenységekben környezeti változóként.

Ha issecret igaz, 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ó is hozzá lesz adva a környezethez. 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 szintaxissal és a $[] változót beállítva a lépés nevével leképítheti 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 lévő előtt lévőtől függ. Ezért minden fázis használhatja az előző fázis kimeneti változóit. A további szakaszok eléréséhez módosítania kell a függőségi gráfot, például ha a 3. fázishoz egy változóra van szükség az 1. fázisból, 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 mátrixból vagy szeletből állít be változót, akkor ha egy alsóbb rétegbeli feladatból éri el a változót, a következőket 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:
    myVarFromJobsA1: $[ dependencies.A.outputs['job1.setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromJobsA1)"
    name: echovar

Ügyeljen arra, hogy a feladat nevét az üzembehelyezési feladat kimeneti változóira előtagként adja meg. 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. Már találkoztunk ilyen esettel, amikor egy változót egy másik kimenetére állítottunk be egy korábbi feladatból.

- 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

Ebben a példában a szkript engedélyezi a változót sauce , de a változót secretSaucenem. A folyamatfuttatási lapon figyelmeztetés jelenik meg.

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 nem bírálható felül az üzenetsor idején. Az ajánlott eljárás a változók YAML-fájlban való definiálása, de vannak olyan esetek, amikor ennek nincs értelme. Előfordulhat például, hogy titkos változót szeretne definiálni, és nem szeretné, hogy a változó elérhető legyen 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.

Ha várólistán szeretne beállítani egy változót, vegyen fel egy új változót a folyamatba, és válassza a felülbírálási lehetőséget.

Állítson be egy változót az üzenetsor idejé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.

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

Ha egy változót több hatókörben is ugyanazzal a névvel állít be, a következő prioritási sorrend érvényesül (első helyen a legmagasabb prioritás).

  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 definiálja azt a webes szerkesztőben az üzenetsor idején beállított beállításként. 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 indításakor, majd az egyes lépések elején egyszer lesznek kibontva. 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 a ké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ökben a szintaxissal $( ) hivatkozott változók rekurzívan ki vannak bontva. Példa:

variables:
  myInner: someValue
  myOuter: $(myInner)

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