Változók meghatározása

  • Cikk
  • 35 perc alatt elolvasható

Azure DevOps Services | Azure DevOps Server 2020-| 2019 Azure DevOps Server | TFS 2018

Megjegyzés

A Microsoft Team Foundation Server (TFS) 2018-ban és a korábbi verziókban a buildelési és kiadási folyamatokat definícióknak, a futtatásokatbuildeknek, a szolgáltatáskapcsolatokatszolgáltatásvégpontoknak, a fázisokatkörnyezeteknek, a feladatokatpedig fázisoknak nevezzük.

A változók segítségével kényelmesen lekérheti a kulcsbiteket a folyamat különböző részeibe. A változók leggyakoribb használata egy érték definiálása, amelyet aztán felhasználhat a folyamatban. Minden változó sztringként van tárolva, és módosítható. A változó értéke futtatásról futtatásra vagy feladatról folyamatfeladatra változhat.

Ha ugyanazt a változót több helyen, azonos néven definiálja, akkor a helyi hatókörű változó nyer. Így a feladatszinten definiált változók felülbírálhatják a fázisszinten beállított változót. A fázisszinten definiált változó felülbírál egy, a folyamat gyökérszintjén beállított változót. A folyamat gyökérszintjéhez tartozó változók felülbírálják a Folyamatbeállítások felhasználói felületén beállított változót.

A változók kifejezésekkel együtt használhatók az értékek feltételes hozzárendeléséhez és a folyamatok további testreszabásához.

A változók eltérnek a futtatókörnyezeti paraméterektől, amelyek a sablon elemzése során vannak begépelve és elérhetők.

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, a változó titkosítható, és titkosként állítható be.

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

Egy változócsoport használatával több folyamat változóit is elérhetővé teheti.

Sablonokkal definiálhatja azokat a változókat, amelyeket egy fájl több folyamatában használnak.

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. YAML- vagy klasszikus buildfolyamatok használata esetén a rendszerváltozók átfogó listájáért tekintse meg az előre definiált változókat . 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 vannak beállítva. Egyes változók automatikusan be vannak állítva. Folyamat szerzőjeké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 jellemzőek. Platformspecifikus módon kerülnek be egy folyamatba. A formátum megfelel annak, hogy a környezeti változók hogyan lesznek formázva az adott szkriptelési platformhoz.

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álva lesznek a platformhoz. Amikor a változókat környezeti változókká alakítják, a változók neve nagybetűssé válik, a pontok 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ókra változóelnevezési korlátozások vonatkoznak (például nem használható secret a változónevek elején).

Változóelnevezési korlátozások

A felhasználó által definiált és a környezeti változók betűkből, számokból .és _ karakterekből állhatnak. Ne használjon a rendszer által lefoglalt változóelőtagokat. Ezek a következők: endpoint, input, secret, , pathés securefile. Az ezen sztringek egyikével kezdődő változók (a nagybetűktől függetlenül) nem lesznek elérhetők a tevékenységek és szkriptek számára.

A változószintaxis ismertetése

Az 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. Minden szintaxis más célra használható, és bizonyos korlátozásokkal rendelkezik.

A folyamatokban a sablonkifejezés változói (${{ variables.var }}) a fordítási időpontban, a futtatókörnyezet indítása előtt lesznek feldolgozva. A makrószintaxis változói ($(var)) a futásidőben lesznek feldolgozva, mielőtt egy feladat lefutna. A futtatókörnyezeti kifejezések ($[variables.var]) a futásidőben is feldolgozásra kerülnek, de feltételekkel és kifejezésekkel való használatra lettek kialakítva. Futtatókörnyezeti kifejezés használatakor a definíció teljes jobb oldalát fel kell vennie.

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 minden sablonkifejezés-változó feldolgozásra kerül fordításkor a feladatok futtatása előtt. Ezzel szemben a makrószintaxis változóinak kiértékelése az egyes tevékenységek futtatása előtt történik.

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 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 ezen a néven nincs változó, akkor a makrókifejezés változatlan marad. Ha például $(var) nem lehet lecserélni, $(var) akkor semmi sem lesz lecserélve.

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 feladatnak, é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.

Megjegyzés

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

Ebben a példában a makrószintaxis a Bash, a PowerShell és egy szkriptfeladat esetén használatos. A makrószintaxissal rendelkező változók meghívásának szintaxisa mind a három esetében 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 feldolgozása a fordítási időpontban történik, és a futtatókörnyezet kezdete előtt lecserélődik. A sablonkifejezések a YAML egyes részeinek sablonként való újrafelhasználására szolgálnak.

A sablonváltozók csendesen üres sztringekké olvadnak, ha nem található helyettesítő érték. A sablonkifejezések a makró- és futásidejű kifejezésektől eltérően 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 futásidejű 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. A futtatókörnyezeti kifejezések úgy vannak kialakítva, hogy a feladatok feltételeiben, a feladatok feltételes végrehajtásának támogatására vagy teljes szakaszokban használhatók legyenek.

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 fel kell vennie egy kulcs-érték pár teljes jobb oldalát. 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 folyamat definíciójá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 bemenetet ad egy tevékenységhez.

Válasszon futtatókörnyezeti kifejezést, ha feltételekkel és kifejezésekkel dolgozik. Ez alól kivételt képeznek azok a folyamatok, amelyeknél az üres változó nyomtatása problémát okoz. Ha például olyan feltételes logikával rendelkezik, amely egy adott értékkel rendelkező vagy érték nélküli változóra támaszkodik. Ebben az esetben makrókifejezést kell használnia.

Ha változót definiál egy sablonban, használjon sablonkifejezést.

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

A leggyakoribb esetben be kell állítani a változókat, és a YAML-fájlban kell használni őket. Ez lehetővé teszi a változó változásainak nyomon követését a verziókövetési rendszerben. A változókat a folyamatbeállítások felhasználói felületén is definiálhatja (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ésekben. Ha változót szeretne használni egy YAML-utasításban, burkolja be.$() A változók nem használhatók YAML-utasítások definiálására repository .

# 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ő.
  • A feladat szintjén csak egy adott feladat számára tegye elérhetővé.

Ha egy változó egy YAML tetején van definiálva, az a folyamat összes feladata és szakasza számára elérhető lesz, é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 feladat szintjén lévő változók felülbírálják a változókat a gyökér- és a szakaszszinten. A fázisszintű változók felülbírálják a gyökérszintű változókat.

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 a következőképpen 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ósablonokat vagy változócsoportokat szeretne használni. Ezt a szintaxist a folyamat gyökérszintjén kell használni.

Ebben az alternatív szintaxisban a variables kulcsszó a változókijelölők listáját veszi fel. A változókijelölők name egy normál változóhoz, group egy változócsoporthoz és template egy változósablonhoz tartoznak. 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 parancsfájlnyelvtől függ.

A név nagybetűs, a helyére pedig . a _. Ezt a rendszer automatikusan beszúrja 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 lesznek lefordítva (Windows-stílus: C:\foo\ és Unix /foo/). Ha Bash-szkriptfeladatokat futtat Windows rendszeren, a környezeti változó metódust kell használnia a változók eléréséhez a folyamatváltozó metódusa helyett, hogy biztosan a megfelelő fájlelérési út legyen megadva.

A YAML nem támogatott a TFS-ben.

Titkos vá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 kódokat adjon át a folyamatnak.

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állítja őket. 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. Válassza a Titkos kulcs ikont a változó titkosított tárolásához.
  5. Mentse a folyamatot.

A titkos változók inaktív állapotban vannak titkosítva egy 2048 bites RSA-kulccsal. A titkos kódok az ügynökön érhetők el a használandó feladatokhoz és szkriptekhez. Legyen óvatos azzal kapcsolatban, hogy kinek van hozzáférése a folyamat módosításához.

Fontos

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

Soha nem rejtjük el 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 lesz elrejtve a naplókból. Ennek célja, hogy elkerülje a titkos kódok túl részletes maszkolását, így a naplók olvashatatlanok lesznek. Ezért a titkos kulcsok 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 őket 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 használhat egy PowerShell- és Bash-szkriptekben meghívott mySecret titkos változót. A normál folyamatváltozótól eltérően nincs úgynevezett MYSECRETkörnyezeti változó.

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 így 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 definíció használatával például leképezheti a titkos változókat a variables tevékenységekre. Ez a példa bemutatja, hogyan használhat titkos változókat $(vmsUser) egy $(vmsAdminPass) Azure-fájlmásolási feladatban.

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)

A 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-fájlban. A változócsoport két változót használ: user és token. A token változó titkos, és le van képezve a környezeti változóra $env:MY_MAPPED_TOKEN , 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 lesznek elérhetők az elágazások lekéréses kérelmeihez. További információ: Elágazásokból származó hozzájárulások.

A YAML nem támogatott a TFS-ben.

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

Ha változókat szeretne megosztani a projekt több folyamatában, használja a webes felületet. A Könyvtár területen 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 felhasználhat alsóbb rétegbeli lépésekben, feladatokban és szakaszokban. A YAML-ben függőségek használatával érheti el a különböző feladatok és szakaszok változóit.

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.

Egyes tevékenységek kimeneti változókat határoznak meg, amelyeket ugyanazon feladat alsóbb rétegbeli lépéseiben használhat fel.

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

Megjegyzés

Alapértelmezés szerint a folyamat minden szakasza a YAML-fájlban előtte 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 dependsOn szakaszt a szakaszhoz.

Megjegyzés

Az alábbi példák szabványos folyamatszintaxist használnak. Üzembehelyezési folyamatok használata esetén a változók és a feltételes változók szintaxisa is eltérő lesz. A használandó szintaxissal kapcsolatos információkért lásd az üzembehelyezési feladatokat.

Ezekben a példákban tegyük fel, hogy van egy nevesított MyTaskfeladat, amely beállít egy úgynevezett MyVarkimeneti változót. 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ásik fázisban

Ha a feladat szintjén egy másik fázis kimenetét szeretné használni, használja a következő szintaxist stageDependencies :

  • A fázis szintjén a változók másik fázisból való hivatkozásának formátuma a következő: dependencies.STAGE.outputs['JOB.TASK.VARIABLE']
  • A feladat szintjén a változók másik fázisból való hivatkozásának formátuma a következő: stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE']
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
  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

A fázisok között fájlbemenettel is átadhat változókat. Ehhez a második szakaszban definiálnia kell 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 listázhatja az az pipelines variable list paranccsal. Első lépésekért tekintse meg az Azure DevOps CLI 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 a következővel az devops configure -d organization=ORG_URLkonfigurálhatja: . Kötelező, ha nem alapértelmezettként van konfigurálva, vagy a rendszer a használatával git configveszi át. Példa: --org https://dev.azure.com/MyOrganizationName/.
  • folyamatazonosító: Kötelező, ha a folyamat neve nincs megadva. A folyamat azonosítója.
  • folyamat neve: Akkor szükséges, ha a folyamatazonosító nincs megadva, de a rendszer figyelmen kívül hagyja, ha a folyamatazonosító meg van adva. A folyamat neve.
  • projekt: A projekt neve vagy azonosítója. Az alapértelmezett projektet a következővel az devops configure -d project=NAME_OR_IDkonfigurálhatja: . Kötelező, ha nincs alapértelmezettként konfigurálva, vagy ha a használatával git configfelvette.

Példa

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

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 folyamat egy szkriptje definiálhat egy változót, hogy a folyamat következő lépéseinek egyikével felhasználhassa azt. A metódus által beállított összes változó sztringként lesz kezelve. Ha egy szkriptből szeretne változót 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 egy szkriptből szeretne beállítani, használja a naplózási task.setvariableparancsot. Ez frissíti a környezeti változókat a későbbi feladatokhoz. Az ezt követő feladatok hozzáférhetnek az új változóhoz makrószintaxissal és tevékenységekben környezeti változóként.

Ha issecret igaz értékre van állítva, a változó értéke titkosként lesz mentve, és el lesz rejtve 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, akkor a használatával isOutput=truekimeneti változóként kell megjelölnie. Ezután leképítheti a jövőbeli feladatokra a $[] szintaxis használatával, valamint a változót beállítva a lépés nevével. A többfeladatos kimeneti változók csak az ugyanabban a fázisban 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 fázisfüggőségek szintaxisát.

Megjegyzés

Alapértelmezés szerint a folyamat minden fázisa a YAML-fájlban előtte 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-18.04'
  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 mátrixból vagy szeletből állít be változót, akkor a változóra való hivatkozáshoz, amikor egy alárendelt feladatból éri el, 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-18.04'
  strategy:
    maxParallel: 2
    matrix:
      debugJob:
        configuration: debug
        platform: x64
      releaseJob:
        configuration: release
        platform: x64
  steps:
  - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the $(configuration) value"
    name: setvarStep
  - bash: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable from the debug job
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-18.04'
  variables:
    myVarFromJobADebug: $[ dependencies.A.outputs['debugJob.setvarStep.myOutputVar'] ]
  steps:
  - script: echo $(myVarFromJobADebug)
    name: echovar

jobs:

# Set an output variable from a job with slicing
- job: A
  pool:
    vmImage: 'ubuntu-18.04'
    parallel: 2 # Two slices
  steps:
  - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the slice $(system.jobPositionInPhase) value"
    name: setvarStep
  - script: echo $(setvarStep.myOutputVar)
    name: echovar

# Map the variable from the job for the first slice
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-18.04'
  variables:
    myVarFromJobsA1: $[ dependencies.A.outputs['job1.setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromJobsA1)"
    name: echovar

Ügyeljen arra, hogy a feladat nevét az üzembehelyezési feladat kimeneti változóihoz adja meg. Ebben az esetben a feladat neve A:

jobs:

# Set an output variable from a deployment
- deployment: A
  pool:
    vmImage: 'ubuntu-18.04'
  environment: staging
  strategy:
    runOnce:
      deploy:
        steps:
        - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the deployment variable value"
          name: setvarStep
        - bash: echo $(setvarStep.myOutputVar)
          name: echovar

# Map the variable from the job for the first slice
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-18.04'
  variables:
    myVarFromDeploymentJob: $[ dependencies.A.outputs['A.setvarStep.myOutputVar'] ]
  steps:
  - bash: "echo $(myVarFromDeploymentJob)"
    name: echovar

A YAML nem támogatott a TFS-ben.

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ók beállításához a támogatott kifejezések bármelyikét használhatja. Íme egy példa egy változó számlálóként való beállítására, amely 100-nál kezdődik, minden futtatásnál 1-zel növekszik, és minden nap alaphelyzetbe áll 100-ra.

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.

A YAML nem támogatott a TFS-ben.

Beállítható 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 oldalon megjelenik egy figyelmeztetés.

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 sorban

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 a várólistá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ővé legyen téve 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ége van. 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 futásidejű paramétereket . Ha a változó nem titkos, az ajánlott eljárás a futtatókörnyezeti paraméterek használata.

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

Állítson be egy változót az üzenetsor idején.

Ha azt szeretné, hogy egy változót az üzenetsor idején állítson be, győződjön meg arról, hogy a változó nem jelenik meg a 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 fog rendelkezni.

A YAML nem támogatott a TFS-ben.

Változók kibontása

Ha egy azonos nevű változót több hatókörben állít be, a következő prioritás érvényesül (először a legmagasabb prioritás).

  1. Feladatszintű változókészlet a YAML-fájlban
  2. Szakaszszintű változókészlet a YAML-fájlban
  3. Folyamatszintű változókészlet a YAML-fájlban
  4. A várólista idején beállított változó
  5. Folyamatváltozó-készlet a Folyamatbeállítások felhasználói felületén

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 Gis be van állítva, valamint változóként a Folyamatbeállítások felhasználói felületén.

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 élvez elsőbbséget.

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

Megjegyzés

Amikor beállít egy változót a YAML-fájlban, ne a várakozási sorban beállított módon definiálja azt a webszerkesztőben. Jelenleg nem módosíthatja a YAML-fájlban az üzenetsor idején beállított változókat. Ha egy változót a várólistá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éldául:

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égiaként. Az alábbi példában a változó a nem használható 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ökön a szintaxissal $( ) hivatkozott változók rekurzívan ki vannak bontva. Például:

variables:
  myInner: someValue
  myOuter: $(myInner)

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

A YAML nem támogatott a TFS-ben.