Sdílet prostřednictvím

Definování proměnných

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

Proměnné poskytují pohodlný způsob, jak zahrnout klíčová data do různých částí pracovního postupu. Nejběžnějším použitím proměnných je definovat hodnotu, kterou můžete použít v celém kanálu. Všechny proměnné jsou měnitelné řetězce. Hodnota proměnné se může změnit ze spuštění na spuštění nebo z úlohy na úlohu v rámci toku úkolů.

Když definujete stejnou proměnnou na více místech se stejným názvem, má přednost nejvíce místně vymezená proměnná. Proměnná definovaná na úrovni úlohy tedy může přepsat proměnnou nastavenou na úrovni fáze. Proměnná definovaná na úrovni fáze přepíše proměnnou nastavenou na úrovni kořenového kanálu. Proměnná nastavená v kořenové úrovni kanálu přepíše proměnnou nastavenou v uživatelském rozhraní nastavení kanálu. Další informace o tom, jak pracovat s proměnnými definovanými na úrovni úlohy, fáze a kořenové úrovně, najdete v tématu Rozsah proměnných.

Pomocí proměnných s výrazy můžete podmíněně přiřadit hodnoty a dále přizpůsobit pipelines.

Proměnné se liší od parametrů modulu runtime. Parametry modulu runtime jsou typované a dostupné během parsování šablony.

Uživatelem definované proměnné

Při definování proměnné použijte různé syntaxe (makro, výraz šablony nebo modul runtime). Zvolená syntaxe určuje, kde se proměnná v pipeline vykreslí.

V YAML pipelines nastavte proměnné na úrovni root, fáze a úlohy. V uživatelském rozhraní můžete také zadat proměnné mimo kanál YAML. Když nastavíte proměnnou v uživatelském rozhraní, můžete proměnnou zašifrovat a nastavit jako tajný kód.

Uživatelem definované proměnné lze nastavit jen pro čtení. Pro proměnné existují omezení pojmenování (příklad: Nemůžete použít secret na začátku názvu proměnné).

Můžete použít skupinu proměnných a zpřístupnit proměnné napříč několika pipelines.

Pokud chcete definovat proměnné v jednom souboru pro použití ve více pipelines, použijte templates.

Uživatelem definované víceřádkové proměnné

Azure DevOps podporuje víceřádkové proměnné, ale existuje několik omezení.

Dílčí komponenty, jako jsou úlohy v potrubí, nemusí správně zpracovávat hodnoty proměnných.

Azure DevOps nemění uživatelem definované hodnoty proměnných. Před předáním proměnných jako víceřádkových proměnných je potřeba správně formátovat hodnoty proměnných. Při formátování proměnné nepoužívejte speciální znaky, nepoužívejte omezené názvy a ujistěte se, že používáte formát konce řádku, který funguje pro operační systém vašeho agenta.

Víceřádkové proměnné se chovají odlišně v závislosti na operačním systému. Chcete-li se tomuto problému vyhnout, ujistěte se, že pro cílový operační systém správně naformátujete víceřádkové proměnné.

Azure DevOps nikdy nemění hodnoty proměnných, i když poskytujete nepodporované formátování.

Systémové proměnné

Kromě uživatelem definovaných proměnných má Azure Pipelines systémové proměnné s předdefinovanými hodnotami. Například předdefinovaná proměnná Build.BuildId poskytuje ID každého sestavení a můžete použít k identifikaci různých spuštění pipelinu. Proměnnou Build.BuildId můžete použít ve skriptech nebo úkolech, když potřebujete jedinečnou hodnotu.

Pokud používáte YAML nebo klasické kanály sestavení, podívejte se na předem definované proměnné pro komplexní seznam.

Pokud používáte klasické verze pipeline, přečtěte si téma proměnné verze.

Když spustíte pipeline, systémové proměnné nastaví svou aktuální hodnotu. Některé proměnné se nastaví automaticky. Jako autor kanálu nebo koncový uživatel můžete změnit hodnotu systémové proměnné před spuštěním kanálu.

Systémové proměnné jsou jen pro čtení.

Proměnné prostředí

Proměnné prostředí jsou specifické pro operační systém, který používáte. Vložíte je do kanálu způsobem specifickým pro jednotlivé platformy. Formát odpovídá způsobu formátování proměnných prostředí pro vaši konkrétní skriptovací platformu.

V systémech UNIX (macOS a Linux) mají proměnné prostředí formát $NAME. Ve Windows je formát %NAME% pro dávkový soubor a $env:NAME v PowerShellu.

Systémové a uživatelem definované proměnné (kromě tajných proměnných) se také vloží jako proměnné prostředí pro vaši platformu. Když se proměnné změní na proměnné prostředí, názvy proměnných se převedou na velká písmena a tečky se nahradí podtržítky. Například se název proměnné any.variable změní na název proměnné $ANY_VARIABLE.

Existují omezení pojmenovávání proměnných pro proměnné prostředí (příklad: Nemůžete použít secret na začátku názvu proměnné).

Omezení názvů proměnných

Uživatelsky definované proměnné a proměnné prostředí mohou obsahovat písmena, číslice . a znaky _. Nepoužívejte předpony proměnných rezervované systémem. Tyto předpony jsou: endpoint, input, secret, patha securefile. Každá proměnná, která začíná jedním z těchto řetězců (bez ohledu na velká písmena), nebude k dispozici pro vaše úkoly a skripty. Nepoužívejte mezery v proměnných. Pro další omezení se podívejte na omezení pojmenování v Azure Pipelines.

Principy syntaxe proměnných

Azure Pipelines podporuje tři různé způsoby, jak odkazovat na proměnné: makro, výraz šablony a výraz modulu runtime. Každou syntaxi můžete použít pro jiný účel a každá má určitá omezení.

V rámci kanálu se proměnné výrazů šablony (${{ variables.var }}) zpracovávají v době kompilace, ještě před zahájením běhu programu. Proměnné syntaxe maker ($(var)) se zpracovávají během běhu před spuštěním úlohy. Výrazy runtime ($[variables.var]) se zpracovávají při běhu a jsou určeny k použití s podmínkami a výrazy. Pokud používáte běhový výraz, musí zabírat celou pravou stranu definice.

V tomto příkladu můžete vidět, že výraz šablony má stále počáteční hodnotu proměnné i po její aktualizaci. Hodnota proměnné syntaxe makra se aktualizuje. Hodnota výrazu šablony se nemění, protože kanál zpracovává všechny proměnné výrazů šablony v době kompilace před spuštěním úloh. Proměnné makrosyntaxe se naproti tomu vyhodnocují před spuštěním každé úlohy.

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

Proměnné syntaxe maker

Příklady v dokumentaci většinou používají syntaxi maker ($(var)). Syntaxe makra slouží k interpolaci hodnot proměnných do vstupů úkolů a do jiných proměnných.

Systém zpracovává proměnné se syntaxí maker před spuštěním úlohy během běhu. K běhu dochází po rozšíření šablony. Když systém narazí na výraz makra, nahradí výraz obsahem proměnné. Pokud tento název neobsahuje žádnou proměnnou, výraz makra se nezmění. $(var) Pokud například nelze nahradit, zůstane jako $(var).

Proměnné syntaxe maker zůstávají beze změny, pokud nemají žádnou hodnotu, protože prázdná hodnota $() může znamenat něco pro spuštěnou úlohu a agent by neměl předpokládat, že chcete tuto hodnotu nahradit. Pokud například použijete $(foo) k odkazu na proměnnou foo v úloze Bash, může nahrazení všech $() výrazů ve vstupu do úlohy narušit vaše skripty Bash.

Proměnné maker expandují se pouze když se používají pro hodnotu, ne jako klíčové slovo. Hodnoty se zobrazí na pravé straně definice kanálu. Toto je platné: key: $(value). Toto není platné: $(key): value. Proměnné maker nejsou rozbalené, pokud se používají k zobrazení názvu úlohy v textu. Místo toho musíte použít displayName vlastnost.

Poznámka:

Systém rozšiřuje pouze proměnné syntaxe maker pro vstupy úkolů v rámci stages, jobsa steps. Nerozšiřuje je v klíčových slovech pipeline, která jsou vyřešena v době kompilace, například resources, trigger nebo ve kroku checkout v hodnotě referenčního úložiště (například checkout: git://MyProject/MyRepo@$(var) nebude fungovat). K parametrizaci těchto hodnot použijte výrazy šablony nebo parametry modulu runtime místo toho.

V tomto příkladu se používá syntaxe maker s Bashem, PowerShellem a skriptovou úlohou. Syntaxe volání proměnné pomocí syntaxe makra je stejná pro všechny tři.

variables:
 - name: projectName
   value: contoso

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

Syntaxe výrazu šablony

Pomocí syntaxe výrazu šablony rozbalte parametry šablony i proměnné (${{ variables.var }}). Systém zpracovává proměnné šablony v době kompilace a nahrazuje je před spuštěním modulu runtime. K opakovanému použití částí YAML jako šablon použijte výrazy šablon.

Proměnné šablony se neslyšně slijí do prázdných řetězců, pokud se nenajde náhradní hodnota. Výrazy šablony, na rozdíl od výrazů makra a modulu runtime, se můžou zobrazit jako klíče (levá strana) nebo hodnoty (pravá strana). Toto je platné: ${{ variables.key }} : ${{ variables.value }}.

Syntaxe výrazů modulu runtime

Použijte syntaxi výrazu runtime pro proměnné, které se rozbalí za běhu ($[variables.var]). Proměnné výrazů modulu runtime se tiše spojí s prázdnými řetězci, pokud není nalezena žádná náhradní hodnota. Použití výrazů modulu runtime v podmínkách úlohy k podpoře podmíněného spouštění úloh nebo celých fází.

Proměnné výrazů runtime se rozšiřují pouze tehdy, když se používají pro hodnotu, nikoli jako klíčové slovo. Hodnoty se zobrazí na pravé straně definice kanálu. Toto je platné: key: $[variables.value]. Toto není platné: $[variables.key]: value. Výraz runtime musí obsáhnout celou pravou stranu páru klíč-hodnota. Například key: $[variables.value] je platný, ale key: $[variables.value] foo není.

Syntaxe Příklad Kdy se zpracovává? Kde se rozšiřuje v definici pipeline? Jak se vykresluje, když není nalezeno?
makro $(var) runtime před spuštěním úlohy hodnota (pravá strana) tiskne $(var)
výraz šablony ${{ variables.var }} za kompilace klíč nebo hodnota (vlevo nebo vpravo) prázdný řetězec
výraz runtime $[variables.var] modul runtime hodnota (pravá strana) prázdný řetězec

Jakou syntaxi mám použít?

Syntaxi makra použijte, pokud poskytujete zabezpečený řetězec nebo definovanou proměnnou vstup pro úlohu.

Zvolte výraz modulu runtime, pokud pracujete s podmínkami a [expressions](expressions.md]. Výraz runtime však nepoužívejte, pokud nechcete, aby se prázdná proměnná vytiskla (příklad: $[variables.var]). Pokud máte například podmíněnou logiku, která spoléhá na proměnnou, která má konkrétní hodnotu nebo žádnou hodnotu, použijte výraz makra.

Obvykle je proměnná šablony standardem, který se má použít. Díky využití proměnných šablon váš kanál plně vloží hodnotu proměnné do kanálu při kompilaci kanálu. Tato injekce je užitečná při pokusu o ladění potrubí. Můžete stáhnout soubory protokolu a vyhodnotit plně rozšířenou hodnotu, která je nahrazována. Vzhledem k tomu, že je proměnná nahrazena, nevyužívejte syntaxi šablony pro citlivé hodnoty.

Identifikace problémů se syntaxí proměnných pomocí AI

Tento příklad výzvy pro Copilot Chat identifikuje, jaké typy proměnných se používají v potrubí a kdy se proměnné vyřeší. Zvýrazněte kód YAML a zadejte následující příkazový řádek Copilot Chatu.

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?

Podle potřeby si přizpůsobte výzvu, abyste mohli přidat konkrétní údaje.

Copilot využívá AI, takže překvapení a chyby jsou možné. Další informace najdete v tématu Copilot nejčastější dotazy.

Nastavení proměnných v potrubí

V nejběžnějším případě nastavte proměnné a použijte je v souboru YAML. Tento přístup umožňuje sledovat změny proměnné v systému správy verzí. Můžete také definovat proměnné v uživatelském rozhraní nastavení kanálu (viz karta Classic) a odkazovat na ně v YAML.

Následující příklad ukazuje, jak nastavit dvě proměnné configuration a platforma použít je později v krocích. Chcete-li použít proměnnou v příkazu YAML, zabalte ji do $(). Proměnné nemůžete použít k definování repository v příkazu YAML.

# Set variables once
variables:
  configuration: debug
  platform: x64

steps:

# Use them once
- task: MSBuild@1
  inputs:
    solution: solution1.sln
    configuration: $(configuration) # Use the variable
    platform: $(platform)

# Use them again
- task: MSBuild@1
  inputs:
    solution: solution2.sln
    configuration: $(configuration) # Use the variable
    platform: $(platform)

Proměnné rozsahu

V souboru YAML nastavte proměnnou v různých oborech:

  • Na úrovni kořene ho zpřístupníte pro všechny úlohy v pipeline.
  • Na úrovni fáze ji zpřístupněte pouze pro konkrétní fázi.
  • Na úrovni úlohy ji zpřístupníte tak, aby byla dostupná pouze pro konkrétní úlohu.

Když definujete proměnnou v horní části YAML, je tato proměnná dostupná pro všechny úlohy a fáze v kanálu a je globální proměnnou. Globální proměnné definované v YAML nejsou viditelné v uživatelském rozhraní nastavení kanálu.

Proměnné na úrovni úlohy přepisují proměnné na úrovni kořene a fáze. Proměnné na úrovni fáze přepisují proměnné na kořenové úrovni.

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

Výstup obou úloh vypadá takto:

# job1
value 
value1
value1

# job2
value
value2
value

Zadání proměnných

V předchozích příkladech následuje za klíčovým slovem variables seznam dvojic klíč-hodnota. Klíče jsou názvy proměnných a jejich hodnoty.

Další syntaxe je užitečná, když chcete použít šablony pro proměnné nebo skupiny proměnných.

Pomocí šablon můžete definovat proměnné v jednom souboru YAML a zahrnout je do jiného souboru YAML.

Skupiny proměnných jsou sada proměnných, které můžete použít v několika pipelines. Pomocí skupin proměnných můžete spravovat a organizovat proměnné, které jsou společné pro různé fáze na jednom místě.

Tuto syntaxi použijte pro šablony proměnných a skupiny proměnných na kořenové úrovni pipeliny.

V této alternativní syntaxi klíčové slovo variables přebírá seznam specifikátorů proměnných. Specifikátory proměnných jsou name určené pro běžnou proměnnou, group pro skupinu proměnných a template pro zahrnutí šablony proměnné. Následující příklad ukazuje všechny tři.

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

Další informace najdete v tématu Opětovné použití proměnných pomocí šablon.

Přístup k proměnným prostřednictvím prostředí

Všimněte si, že proměnné jsou také zpřístupněny skriptům prostřednictvím proměnných prostředí. Syntaxe pro použití těchto proměnných prostředí závisí na skriptovacím jazyce.

Název je velkými písmeny a . je nahrazen znakem _. Ten se automaticky vloží do procesního prostředí. Několik příkladů:

  • Dávkový skript: %VARIABLE_NAME%
  • Skript PowerShellu: $env:VARIABLE_NAME
  • Bash skript: $VARIABLE_NAME

Důležité

Předdefinované proměnné, které obsahují cesty k souborům, se překládají na odpovídající styl (styl Windows C:\foo\ versus Unix style /foo/) na základě typu hostitele agenta a typu prostředí. Pokud spouštíte úlohy skriptu Bash ve Windows, měli byste pro přístup k těmto proměnným použít metodu proměnných prostředí namísto metody potrubních proměnných, abyste zajistili správný formát cesty k souboru.

Nastavení tajných proměnných

Doporučení

Tajné proměnné se automaticky neexportují jako proměnné prostředí. Pokud chcete ve skriptech použít tajné proměnné, explicitně je namapujte na proměnné prostředí. Další informace naleznete v tématu Nastavení tajných proměnných.

Nenastavujte v souboru YAML tajné proměnné. Operační systémy často protokolují příkazy pro procesy, které spouští, a nechcete, aby protokol obsahoval tajný kód, který jste předali jako vstup. Pomocí prostředí skriptu nebo mapujte proměnnou v rámci bloku variables k předání citlivých údajů do vaší pipeliny.

Poznámka:

Azure Pipelines se snaží maskovat tajemství při výpisu dat do protokolů kanálu, takže můžete vidět další proměnné a data maskovaná ve výstupu a protokolech, které nejsou nastavené jako tajemství.

V uživatelském rozhraní nastavení potrubí musíte nastavit tajné proměnné. Tyto proměnné jsou omezeny na potrubí, ve kterém jsou nastaveny. Tajné proměnné můžete také nastavit ve skupinách proměnných.

Pokud chcete nastavit tajné kódy ve webovém rozhraní, postupujte takto:

  1. Přejděte na stránku Pipelines, vyberte příslušný kanál a pak vyberte Edit.
  2. Vyhledejte proměnné pro tento kanál.
  3. Přidejte nebo aktualizujte proměnnou.
  4. Vyberte možnost Udržet tuto hodnotu v tajnosti, aby se proměnná ukládala šifrovaně.
  5. Uložte potrubí.

Tajné proměnné se šifrují v klidovém stavu pomocí 2048bitového klíče RSA. Tajné kódy jsou k dispozici v agentu pro úlohy a skripty, které se mají použít. Buďte opatrní, kdo má přístup k úpravám vašeho zásobníku.

Důležité

Děláme maximum pro to, aby se důvěrné informace nezobrazovaly ve výstupu Azure Pipelines, ale přesto musíte podniknout opatření. Nikdy nevypisujte tajnosti jako výstup. Některé operační systémy zaznamenávají argumenty příkazového řádku. Nikdy nepředávejte tajné kódy na příkazovém řádku. Místo toho doporučujeme namapovat vaše tajemství na proměnné prostředí.

Nikdy nezamaskujeme podřetěžky tajných kódů. Pokud je například "abc123" nastaven jako tajný kód, "abc" není maskován z protokolů. Tím se vyhnete maskování tajných kódů na příliš podrobné úrovni, aby protokoly byly nečitelné. Z tohoto důvodu by tajné kódy neměly obsahovat strukturovaná data. Pokud je například "{ "foo": "bar" }" nastaven jako tajný kód, "bar" není maskován z protokolů.

Na rozdíl od normální proměnné nejsou automaticky dešifrovány do proměnných prostředí pro skripty. Musíte explicitně mapovat tajné proměnné.

Následující příklad ukazuje, jak mapovat a používat tajnou proměnnou volanou mySecret ve skriptech PowerShellu a Bash. Jsou definovány dvě globální proměnné. GLOBAL_MYSECRET je přiřazena hodnota tajné proměnné mySecret, a GLOBAL_MY_MAPPED_ENV_VAR je přiřazena hodnota netajné proměnné nonSecretVariable. Na rozdíl od běžné proměnné kanálu neexistuje žádná proměnná prostředí nazývaná MYSECRET.

Úloha PowerShellu spustí skript pro tisk proměnných.

  • $(mySecret): Toto je přímý odkaz na tajnou proměnnou a funguje.
  • $env:MYSECRET: Pokouší se přistupovat k tajné proměnné jako k proměnné prostředí, což nefunguje, protože tajné proměnné se automaticky nemapují na proměnné prostředí.
  • $env:GLOBAL_MYSECRET: Pokouší se získat přístup k tajné proměnné prostřednictvím globální proměnné, což také nefunguje, protože tajné proměnné nelze tímto způsobem mapovat.
  • $env:GLOBAL_MY_MAPPED_ENV_VAR: Tímto se přistupuje k neveřejné proměnné prostřednictvím globální proměnné, což funguje.
  • $env:MY_MAPPED_ENV_VAR: Tato metoda přistupuje k tajné proměnné prostřednictvím proměnné prostředí specifické pro úlohu, což je doporučený způsob mapování tajných proměnných na proměnné prostředí.
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

Výstup z obou úloh v předchozím skriptu vypadá takto:

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

Můžete také použít tajné proměnné mimo skripty. Například můžete pomocí definice variables mapovat tajné proměnné na úkoly. Tento příklad ukazuje, jak používat tajné proměnné $(vmsUser) a $(vmsAdminPass) v úloze kopírování souboru Azure.

variables:
  VMS_USER: $(vmsUser)
  VMS_PASS: $(vmsAdminPass)

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: AzureFileCopy@6
  inputs:
    SourcePath: 'my/path' # Specify the source path
    azureSubscription: 'my-subscription' # Azure subscription name
    Destination: 'AzureVMs' # Destination type
    storage: 'my-storage' # Azure storage account name
    resourceGroup: 'my-resource-group' # Resource group name
    vmsAdminUserName: $(VMS_USER) # Admin username for the VM
    vmsAdminPassword: $(VMS_PASS) # Admin password for the VM
    CleanTargetBeforeCopy: false # Do not clean the target before copying

Odkazy na tajné proměnné ve skupinách proměnných

Tento příklad ukazuje, jak odkazovat na skupinu proměnných v souboru YAML a také jak přidat proměnné v rámci YAML. Příklad používá dvě proměnné ze skupiny proměnných: user a token. Proměnná token je tajná a mapuje se na proměnnou $env:MY_MAPPED_TOKEN prostředí, abyste na ni mohli odkazovat v YAML.

Tento YAML provede volání REST k načtení seznamu vydaných verzí a výstupu výsledku.

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

Důležité

Ve výchozím nastavení nemají sestavení pull requestů u forkovaných repozitářů na GitHubu přístup k tajným proměnným přidruženým k vašemu kanálu. Další informace najdete v tématu Příspěvky forků.

Sdílení proměnných napříč pipelines

Pokud chcete sdílet proměnné napříč více pipeline v projektu, použijte webové rozhraní. V části Knihovna použijte skupiny proměnných.

Použití výstupních proměnných z úkolů

Některé úkoly definují výstupní proměnné, které můžete použít v podřízených krocích, úlohách a fázích. V YAML můžete přistupovat k proměnným napříč úlohami a fázemi pomocí dependencies.

Při odkazování na maticové úlohy v podřízených úkolech použijte jinou syntaxi. Viz Nastavení výstupní proměnné s více úlohami. Musíte také použít jinou syntaxi pro proměnné v úlohách nasazení. Viz Podpora výstupních proměnných v úlohách nasazení.

  • Pokud chcete odkazovat na proměnnou z jiného úkolu ve stejné úloze, použijte TASK.VARIABLE.
  • Pokud chcete odkazovat na proměnnou z úkolu z jiné úlohy, použijte dependencies.JOB.outputs['TASK.VARIABLE'].

Poznámka:

Ve výchozím nastavení každá fáze v potrubí závisí na fázi bezprostředně předcházející v souboru YAML. Pokud potřebujete odkazovat na fázi, která není bezprostředně před aktuální fází, můžete tuto automatickou výchozí hodnotu přepsat přidáním dependsOn oddílu do fáze.

Poznámka:

Následující příklady používají standardní syntaxi pipeline. Pokud používáte nasazovací pipelines, bude se lišit syntaxe proměnných a podmíněných. Informace o konkrétní syntaxi, která se má použít, najdete v tématu Úlohy nasazení.

Pro tyto příklady předpokládejme, že máte úkol s názvem MyTask, který nastaví výstupní proměnnou s názvem MyVar. Přečtěte si další informace o syntaxi výrazů – závislosti.

Použití výstupů ve stejné úloze

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

Použití výstupů v jiné úloze

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

Použití výstupů v jiné fázi

Pokud chcete použít výstup z jiné fáze, použijte formát stageDependencies.STAGE.JOB.outputs['TASK.VARIABLE'] pro odkaz na proměnné. Na úrovni fáze, ale ne na úrovni úlohy, můžete tyto proměnné použít v podmínkách.

Výstupní proměnné jsou k dispozici pouze v další podřízené fázi. Pokud více fází spotřebovává stejnou výstupní proměnnou, použijte podmínku 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

Proměnné mezi fázemi můžete předávat také pomocí vstupu souboru. Aby se to povedlo, je potřeba definovat proměnné ve druhé fázi na úrovni úlohy a předat je jako vstupy env:.

## script-a.sh
echo "##vso[task.setvariable variable=sauce;isOutput=true]crushed tomatoes"

## script-b.sh
echo 'Hello file version'
echo $skipMe
echo $StageSauce

## azure-pipelines.yml
stages:

- stage: one
  jobs:
  - job: A
    steps:
    - task: Bash@3
      inputs:
          filePath: 'script-a.sh'
      name: setvar
    - bash: |
       echo "##vso[task.setvariable variable=skipsubsequent;isOutput=true]true"
      name: skipstep

- stage: two
  jobs:
  - job: B
    variables:
      - name: StageSauce
        value: $[ stageDependencies.one.A.outputs['setvar.sauce'] ]
      - name: skipMe
        value: $[ stageDependencies.one.A.outputs['skipstep.skipsubsequent'] ]
    steps:
    - task: Bash@3
      inputs:
        filePath: 'script-b.sh'
      name: fileversion
      env:
        StageSauce: $(StageSauce) # predefined in variables section
        skipMe: $(skipMe) # predefined in variables section
    - task: Bash@3
      inputs:
        targetType: 'inline'
        script: |
          echo 'Hello inline version'
          echo $(skipMe) 
          echo $(StageSauce)

Výstup z fází v předchozím zpracování vypadá takto:

Hello inline version
true
crushed tomatoes

Výpis proměnných

Seznam všech proměnných v pipelině pomocí příkazu az pipelines variable list. Pokud chcete začít, přečtěte si Začínáme s Azure DevOps CLI.

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

Parametry

  • org: URL organizace Azure DevOps. Nakonfigurujte výchozí organizaci pomocí .az devops configure -d organization=ORG_URL Vyžaduje se, pokud není nakonfigurováno jako výchozí nebo získáno pomocí git config. Příklad: --org https://dev.azure.com/MyOrganizationName/.
  • ID kanálu: Vyžaduje se, pokud není zadaný název kanálu. ID potrubí.
  • název kanálu: Vyžaduje se, pokud není zadáno ID kanálu, ale ignoruje se, pokud je zadáno ID kanálu. Název kanálu.
  • project: Název nebo ID project. Nakonfigurujte výchozí project pomocí az devops configure -d project=NAME_OR_ID. Vyžaduje se, pokud není nakonfigurováno jako výchozí nebo získáno pomocí git config.

Příklad

Následující příkaz zobrazí seznam všech proměnných v kanálu s ID 12 a zobrazí výsledek ve formátu tabulky.

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

Nastavení proměnných ve skriptech

Skripty mohou definovat proměnné, které později kroky v pipeline využívají. Všechny proměnné nastavené touto metodou jsou považovány za řetězce. Pokud chcete nastavit proměnnou ze skriptu, použijte syntaxi příkazu a vytiskněte ji na stdout.

Nastavit proměnnou v rámci úlohy ze skriptu

Pokud chcete nastavit proměnnou ze skriptu, použijte task.setvariablepříkaz protokolování. Tento příkaz aktualizuje proměnné prostředí pro následné úlohy. Následné úlohy mohou k nové proměnné přistupovat pomocí syntaxe makra a v úkolech ji používat jako proměnné prostředí.

Když nastavíte issecret hodnotu true, hodnota proměnné se uloží jako tajný kód a maskuje se z protokolu. Další informace o tajných proměnných najdete v tématu příkazy protokolování.

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)

Následující kroky mají ve svém prostředí také přidanou proměnnou pipeline. Proměnnou v kroku, který je definovaný, nemůžete použí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"

Výstup z předchozího potrubí.

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

Nastavit výstupní proměnnou pro více úloh

Pokud chcete zpřístupnit proměnnou pro budoucí úlohy, musíte ji označit jako výstupní proměnnou pomocí isOutput=true. Pak ho můžete namapovat do budoucích úloh pomocí $[] syntaxe a zahrnutím názvu kroku, který proměnnou nastavil. Výstupní proměnné s více úlohami fungují jenom pro úlohy ve stejné fázi.

Pokud chcete předat proměnné úlohám v různých fázích, použijte syntaxi závislostí fází.

Poznámka:

Ve výchozím nastavení každá fáze v potrubí závisí na fázi bezprostředně předcházející v souboru YAML. Každá fáze proto může používat výstupní proměnné z předchozí fáze. Pokud chcete access další fáze, budete muset změnit graf závislostí, například pokud fáze 3 vyžaduje proměnnou z fáze 1, budete muset deklarovat explicitní závislost na fázi 1.

Při vytváření výstupní proměnné pro více úloh byste měli přiřadit výraz k proměnné. V tomto YAML $[ dependencies.A.outputs['setvarStep.myOutputVar'] ] je přiřazen k proměnné $(myVarFromJobA).

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

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

Výstup z předchozího potrubí.

this is the value
this is the value

Pokud nastavujete proměnnou z jedné fáze na jinou, použijte 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)

Pokud nastavujete proměnnou z matrix nebo slice a pak na proměnnou odkazujete při přístupu z následné úlohy, musíte zahrnout:

  • Název úlohy.
  • Ten krok.
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

Nezapomeňte přidat název úlohy jako předponu k výstupním proměnným úlohy nasazení. V tomto případě je Anázev úlohy:

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

Nastavení proměnných pomocí výrazů

Proměnnou můžete nastavit pomocí výrazu. Už jste narazili na jeden případ tohoto přístupu, když nastavíte proměnnou na výstup jiné proměnné z předchozí úlohy.

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

Pro nastavení proměnné můžete použít libovolný z podporovaných výrazů. Tady je příklad nastavení proměnné tak, aby fungovala jako čítač, který začíná na 100, se pro každé spuštění zvýší o 1 a každý den se resetuje na 100.

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

Další informace o čítačích, závislostech a dalších výrazech najdete v tématu výrazy.

Konfigurace nastavených proměnných pro kroky

Můžete definovat settableVariables v rámci kroku nebo určit, že nelze nastavit žádné proměnné.

V tomto příkladu nemůže skript nastavit proměnnou.

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

V následujícím příkladu může skript nastavit proměnnou sauce , ale nemůže nastavit proměnnou secretSauce. Na stránce spuštění kanálu se zobrazí upozornění.

Upozornění, že nemůžete nastavit secretSauce 

steps:
  - bash: |
      echo "##vso[task.setvariable variable=Sauce;]crushed tomatoes"
      echo "##vso[task.setvariable variable=secretSauce;]crushed tomatoes with garlic"
    target:
     settableVariables:
      - sauce
    name: SetVars
  - bash: 
      echo "Sauce is $(sauce)"
      echo "secretSauce is $(secretSauce)"
    name: OutputVars

Povolit při čekání ve frontě

Pokud se proměnná zobrazí v variables bloku souboru YAML, její hodnota je pevná a uživatelé ji nemůžou přepsat v době fronty. Definujte proměnné v souboru YAML, ale tento přístup nedává smysl. Můžete například chtít definovat tajnou proměnnou a nezpřístupněte ji v YAML. Nebo může být potřeba ručně nastavit hodnotu proměnné během spuštění kanálu.

Pro definování hodnoty doby fronty máte dvě možnosti. Můžete definovat proměnnou v uživatelském rozhraní a vybrat možnost Umožnit uživatelům přepsat tuto hodnotu při spuštění tohoto pipeline nebo místo toho můžete použít parametry za běhu. Pokud vaše proměnná není tajemstvím, osvědčeným postupem je použít parametry za běhu.

Pokud chcete nastavit proměnnou v době fronty, přidejte do kanálu novou proměnnou a vyberte možnost přepsání. Hodnotu proměnné mohou změnit pouze uživatelé, kteří mají oprávnění ke konfiguraci sestavení fronty úprav .

Nastavte proměnnou při zpracování fronty.

Pokud chcete povolit nastavení proměnné v době fronty, ujistěte se, že se proměnná také nezobrazuje v variables bloku kanálu nebo úlohy. Pokud definujete proměnnou v bloku proměnných YAML i v uživatelském rozhraní, má hodnota v YAML prioritu.

Pro zvýšení zabezpečení použijte předem definovanou sadu hodnot pro proměnné nastavitelné při zpracování fronty a bezpečné typy, jako jsou logické (boolean) hodnoty a celá čísla. Pro řetězce použijte předdefinovanou sadu hodnot.

Rozšíření proměnných

Když nastavíte proměnnou se stejným názvem ve více oborech, platí následující priorita (první nejvyšší priorita):

  1. Proměnná na úrovni úlohy nastavená v souboru YAML
  2. Proměnná na úrovni fáze nastavená v souboru YAML
  3. Proměnná na úrovni kanálu nastavená v souboru YAML
  4. Proměnná nastavená při čekání ve frontě
  5. Proměnná kanálu nastavená v uživatelském rozhraní nastavení kanálu

V následujícím příkladu je stejná proměnná a nastavená na úrovni kanálu a na úrovni úlohy v souboru YAML. Je také nastavena ve skupině proměnných G a jako proměnná v nastavení kanálu v uživatelském rozhraní.

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'

Když nastavíte proměnnou se stejným názvem ve stejném oboru, bude mít přednost hodnota poslední sady.

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

Poznámka:

Když nastavíte proměnnou v souboru YAML, nedefinujte ji ve webovém editoru jako nastavitelnou během času ve frontě. V současné době nemůžete měnit proměnné, které jsou nastavené v souboru YAML při zařazení do fronty. Pokud potřebujete nastavit proměnnou v době fronty, nenastavujte ji v souboru YAML.

Proměnné se po spuštění rozbalí jednou a znovu na začátku každého jednotlivého kroku. Příklad:

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

V předchozím příkladu jsou dva kroky. Rozšíření $(a) se provede jednou na začátku úlohy a jednou na začátku každého ze dvou kroků.

Vzhledem k tomu, že se proměnné rozšiřují na začátku úlohy, nemůžete je použít ve strategii. V následujícím příkladu nemůžete proměnnou a použít k rozbalení matice úlohy, protože proměnná je k dispozici pouze na začátku každé rozšířené úlohy.

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

Pokud je proměnná a výstupní proměnnou z předchozí úlohy, můžete ji použít v budoucí úloze.

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

Rekurzivní rozšíření

V rámci agenta se proměnné odkazované syntaxí $( ) rekurzivně expandují. Příklad:

variables:
  myInner: someValue
  myOuter: $(myInner)

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