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


Feladatok meghatározása a folyamatban

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

A folyamatot feladatokba rendezheti. Minden folyamathoz tartozik legalább egy feladat. A feladatok olyan lépések sorozatai, amelyek egymás után futnak egységként. Más szóval a feladat az ütemezhető legkisebb munkaegység.

A folyamatokat alkotó fő fogalmakkal és összetevőkkel kapcsolatos információkért tekintse meg az új Azure Pipelines-felhasználók legfontosabb fogalmait.

Az Azure Pipelines nem támogatja a YAML-folyamatok feladatprioritását. A feladatok futásának szabályozásához feltételeket és függőségeket adhat meg.

Egyetlen feladat definiálása

A legegyszerűbb esetben egy folyamat egyetlen feladatból áll. Ebben az esetben csak akkor kell explicit módon használnia a job kulcsszót, ha sablont használ. Közvetlenül megadhatja a YAML-fájl lépéseit.

Ez a YAML-fájl egy Microsoft által üzemeltetett ügynökön és kimeneteken futó feladatokkal rendelkezikHello world.

pool:
  vmImage: 'ubuntu-latest'
steps:
- bash: echo "Hello world"

Előfordulhat, hogy további tulajdonságokat szeretne megadni a feladathoz. Ebben az esetben használhatja a kulcsszót job .

jobs:
- job: myJob
  timeoutInMinutes: 10
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - bash: echo "Hello world"

A folyamat több feladatból is állhat. Ebben az esetben használja a kulcsszót jobs .

jobs:
- job: A
  steps:
  - bash: echo "A"

- job: B
  steps:
  - bash: echo "B"

A folyamat több fázisból állhat, amelyek mindegyike több feladattal rendelkezik. Ebben az esetben használja a kulcsszót stages .

stages:
- stage: A
  jobs:
  - job: A1
  - job: A2

- stage: B
  jobs:
  - job: B1
  - job: B2

A feladat megadásához a teljes szintaxis a következő:

- job: string  # name of the job, A-Z, a-z, 0-9, and underscore
  displayName: string  # friendly name to display in the UI
  dependsOn: string | [ string ]
  condition: string
  strategy:
    parallel: # parallel strategy
    matrix: # matrix strategy
    maxParallel: number # maximum number simultaneous matrix legs to run
    # note: `parallel` and `matrix` are mutually exclusive
    # you may specify one or the other; including both is an error
    # `maxParallel` is only valid with `matrix`
  continueOnError: boolean  # 'true' if future jobs should run even if this job fails; defaults to 'false'
  pool: pool # agent pool
  workspace:
    clean: outputs | resources | all # what to clean up before the job runs
  container: containerReference # container to run this job inside
  timeoutInMinutes: number # how long to run the job before automatically cancelling
  cancelTimeoutInMinutes: number # how much time to give 'run always even if cancelled tasks' before killing them
  variables: { string: string } | [ variable | variableReference ] 
  steps: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
  services: { string: string | container } # container resources to run as a service container

A feladat megadásához a teljes szintaxis a következő:

- job: string  # name of the job, A-Z, a-z, 0-9, and underscore
  displayName: string  # friendly name to display in the UI
  dependsOn: string | [ string ]
  condition: string
  strategy:
    parallel: # parallel strategy
    matrix: # matrix strategy
    maxParallel: number # maximum number simultaneous matrix legs to run
    # note: `parallel` and `matrix` are mutually exclusive
    # you may specify one or the other; including both is an error
    # `maxParallel` is only valid with `matrix`
  continueOnError: boolean  # 'true' if future jobs should run even if this job fails; defaults to 'false'
  pool: pool # agent pool
  workspace:
    clean: outputs | resources | all # what to clean up before the job runs
  container: containerReference # container to run this job inside
  timeoutInMinutes: number # how long to run the job before automatically cancelling
  cancelTimeoutInMinutes: number # how much time to give 'run always even if cancelled tasks' before killing them
  variables: { string: string } | [ variable | variableReference ] 
  steps: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
  services: { string: string | container } # container resources to run as a service container
  uses: # Any resources (repos or pools) required by this job that are not already referenced
    repositories: [ string ] # Repository references to Azure Git repositories
    pools: [ string ] # Pool names, typically when using a matrix strategy for the job

Ha a feladat elsődleges célja az alkalmazás üzembe helyezése (az alkalmazás létrehozása vagy tesztelése helyett), akkor használhat egy speciális típusú, úgynevezett üzembe helyezési feladatot.

Az üzembehelyezési feladat szintaxisa a következő:

- deployment: string        # instead of job keyword, use deployment keyword
  pool:
    name: string
    demands: string | [ string ]
  environment: string
  strategy:
    runOnce:
      deploy:
        steps:
        - script: echo Hi!

Bár az üzembehelyezési feladatokhoz is hozzáadhat lépéseket, jobjavasoljuk, hogy inkább egy üzembe helyezési feladatot használjon. Az üzembe helyezési feladatoknak van néhány előnye. Üzembe helyezhet például egy környezetben, amely olyan előnyöket is tartalmaz, mint például az üzembe helyezett adatok előzményeinek megtekintése.

Feladatok típusai

A feladatok különböző típusúak lehetnek, attól függően, hogy hol futnak.

  • Az ügynökkészlet-feladatok egy ügynökkészletben található ügynökön futnak.
  • A kiszolgálófeladatok az Azure DevOps Serveren futnak.
  • A tárolófeladatok egy ügynökkészletben található ügynökhöz tartozó tárolóban futnak. A tárolók kiválasztásáról további információt a Tárolófeladatok definiálása című témakörben talál.
  • Az ügynökkészlet-feladatok egy ügynökkészletben található ügynökön futnak.
  • A kiszolgálófeladatok az Azure DevOps Serveren futnak.

Ügynökkészlet-feladatok

Ezek a leggyakoribb típusú feladatok, és egy ügynökkészlet ügynökén futnak.

  • A Microsoft által üzemeltetett ügynökök használatakor a folyamat minden feladata új ügynököt kap.
  • A saját üzemeltetésű ügynökökkel kapcsolatos igényeket használva megadhatja, hogy az ügynök milyen képességeket használjon a feladat futtatásához. Ugyanazt az ügynököt szerezheti be az egymást követő feladatokhoz, attól függően, hogy egynél több ügynök van-e az ügynökkészletben, amely megfelel a folyamat igényeinek. Ha a készletben csak egy ügynök található, amely megfelel a folyamat igényeinek, a folyamat megvárja, amíg ez az ügynök elérhetővé válik.

Feljegyzés

Az igényeket és képességeket saját üzemeltetésű ügynökökkel való használatra tervezték, hogy a feladatok megfelelhessenek a feladat követelményeinek megfelelő ügynöknek. A Microsoft által üzemeltetett ügynökök használatakor kiválaszt egy olyan képet az ügynökhöz, amely megfelel a feladat követelményeinek, így bár lehetőség van képességek hozzáadására a Microsoft által üzemeltetett ügynökökhöz, nem kell a Microsoft által üzemeltetett ügynökökkel használnia a képességeket.

pool:
  name: myPrivateAgents    # your job runs on an agent in this pool
  demands: agent.os -equals Windows_NT    # the agent must have this capability to run the job
steps:
- script: echo hello world

Vagy több igény:

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse
steps:
- script: echo hello world

További információ az ügynök képességeiről.

Kiszolgálói feladatok

A kiszolgálói feladatok feladatait a kiszolgálón (Azure Pipelines vagy TFS) vezénylik és hajtják végre. A kiszolgálói feladatokhoz nincs szükség ügynökre vagy célszámítógépre. Most már csak néhány feladat támogatott egy kiszolgálói feladatban. A kiszolgálói feladatok maximális időtartama 30 nap.

Ügynök nélküli feladatok által támogatott feladatok

Ügynök nélküli feladatok esetében jelenleg csak a következő feladatok támogatottak:

Mivel a tevékenységek bővíthetőek, bővítmények használatával több ügynök nélküli tevékenységet is hozzáadhat. Az ügynök nélküli feladatok alapértelmezett időtúllépése 60 perc.

A kiszolgálói feladat megadásának teljes szintaxisa a következő:

jobs:
- job: string
  timeoutInMinutes: number
  cancelTimeoutInMinutes: number
  strategy:
    maxParallel: number
    matrix: { string: { string: string } }

  pool: server # note: the value 'server' is a reserved keyword which indicates this is an agentless job

Az egyszerűsített szintaxist is használhatja:

jobs:
- job: string
  pool: server # note: the value 'server' is a reserved keyword which indicates this is an agentless job

Függőségek

Ha több feladatot határoz meg egyetlen szakaszban, megadhatja a közöttük lévő függőségeket. A folyamatoknak legalább egy, függőségek nélküli feladatot kell tartalmazniuk. Alapértelmezés szerint az Azure DevOps YAML-folyamatfeladatok párhuzamosan futnak, kivéve, ha az dependsOn érték be van állítva.

Feljegyzés

Minden ügynök egyszerre csak egy feladatot futtathat. Több feladat párhuzamos futtatásához több ügynököt kell konfigurálni. Elegendő párhuzamos feladatra is szüksége van.

Több feladat és függőségük meghatározásának szintaxisa a következő:

jobs:
- job: string
  dependsOn: string
  condition: string

Példafeladatok, amelyek egymás után jönnek létre:

jobs:
- job: Debug
  steps:
  - script: echo hello from the Debug build
- job: Release
  dependsOn: Debug
  steps:
  - script: echo hello from the Release build

Párhuzamos buildelési példafeladatok (függőségek nélkül):

jobs:
- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - script: echo hello from Windows
- job: macOS
  pool:
    vmImage: 'macOS-latest'
  steps:
  - script: echo hello from macOS
- job: Linux
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: echo hello from Linux

Példa a kifúvatott ventilátorra:

jobs:
- job: InitialJob
  steps:
  - script: echo hello from initial job
- job: SubsequentA
  dependsOn: InitialJob
  steps:
  - script: echo hello from subsequent A
- job: SubsequentB
  dependsOn: InitialJob
  steps:
  - script: echo hello from subsequent B

Példa a beillő ventilátorra:

jobs:
- job: InitialA
  steps:
  - script: echo hello from initial A
- job: InitialB
  steps:
  - script: echo hello from initial B
- job: Subsequent
  dependsOn:
  - InitialA
  - InitialB
  steps:
  - script: echo hello from subsequent

Feltételek

Megadhatja az egyes feladatok futtatásának feltételeit. Alapértelmezés szerint egy feladat akkor fut, ha az nem függ más feladatoktól, vagy ha az összes feladat, amelytől függ, befejeződött és sikeres volt. Ezt a viselkedést úgy szabhatja testre, hogy egy feladat futtatására kényszeríti a feladatot, még akkor is, ha egy korábbi feladat meghiúsul, vagy egyéni feltételt ad meg.

Példa egy feladat futtatására az előző feladat futtatásának állapota alapján:

jobs:
- job: A
  steps:
  - script: exit 1

- job: B
  dependsOn: A
  condition: failed()
  steps:
  - script: echo this will run when A fails

- job: C
  dependsOn:
  - A
  - B
  condition: succeeded('B')
  steps:
  - script: echo this will run when B runs and succeeds

Példa egyéni feltétel használatára:

jobs:
- job: A
  steps:
  - script: echo hello

- job: B
  dependsOn: A
  condition: and(succeeded(), eq(variables['build.sourceBranch'], 'refs/heads/main'))
  steps:
  - script: echo this only runs for master

Megadhatja, hogy egy feladat egy korábbi feladatban beállított kimeneti változó értéke alapján fusson. Ebben az esetben csak a közvetlenül függő feladatokban beállított változókat használhatja:

jobs:
- job: A
  steps:
  - script: "echo '##vso[task.setvariable variable=skipsubsequent;isOutput=true]false'"
    name: printvar

- job: B
  condition: and(succeeded(), ne(dependencies.A.outputs['printvar.skipsubsequent'], 'true'))
  dependsOn: A
  steps:
  - script: echo hello from B

Időtúllépések

Ha el szeretné kerülni az erőforrás-felhasználást, ha a feladat nem válaszol vagy túl sokáig várakozik, érdemes korlátozni, hogy mennyi ideig futhasson a feladat. A feladat időtúllépési beállításával megadhatja a feladat futtatására vonatkozó korlátot percekben. Az érték nullára állítása azt jelenti, hogy a feladat futtatható:

  • Örökre a saját üzemeltetésű ügynökökön
  • 360 percig (6 óra) a Microsoft által üzemeltetett ügynökökön nyilvános projekttel és nyilvános adattárral
  • 60 percig a Microsoft által üzemeltetett ügynökök magánprojekttel vagy privát adattárral (kivéve, ha további kapacitást fizetnek)

Az időtúllépési időszak a feladat futásának kezdetekor kezdődik. Nem tartalmazza azt az időt, amikor a feladat várólistára kerül, vagy egy ügynökre vár.

Ez timeoutInMinutes lehetővé teszi a feladat végrehajtásának időtartamára vonatkozó korlát beállítását. Ha nincs megadva, az alapértelmezett érték 60 perc. Ha 0 meg van adva, a maximális korlátot használja a rendszer (a fent leírtak szerint).

Ez cancelTimeoutInMinutes lehetővé teszi a feladat megszakítási idejének korlátozását, ha az üzembe helyezési feladat úgy van beállítva, hogy továbbra is fusson, ha egy korábbi feladat sikertelen volt. Ha nincs megadva, az alapértelmezett érték 5 perc. Az értéknek 1 és 35790 perc közötti tartományban kell lennie.

jobs:
- job: Test
  timeoutInMinutes: 10 # how long to run the job before automatically cancelling
  cancelTimeoutInMinutes: 2 # how much time to give 'run always even if cancelled tasks' before stopping them

Az időtúllépések a következő szintű elsőbbséget élvezik.

  1. A Microsoft által üzemeltetett ügynökök esetében a feladatok korlátozottak abban az esetben, ha a projekt típusa alapján futtathatók, és hogy fizetős párhuzamos feladattal futnak-e. Amikor a Microsoft által üzemeltetett feladat időtúllépési időköze el nem telik, a feladat leáll. A Microsoft által üzemeltetett ügynökök esetében a feladatok nem futhatnak tovább ennél az intervallumnál, függetlenül a feladatban megadott feladatszintű időtúllépéstől.
  2. A feladat szintjén konfigurált időtúllépés határozza meg a feladat futtatásának maximális időtartamát. Amikor a feladatszint időtúllépési időköze eltelik, a feladat leáll. Ha a feladatot Egy Microsoft által üzemeltetett ügynökön futtatják, a feladatszint időtúllépésének beállítása a Microsoft által üzemeltetett feladatok beépített időkorlátjánál nagyobb időközre nincs hatással, és a Rendszer a Microsoft által üzemeltetett feladatok időtúllépését használja.
  3. Az időtúllépést külön-külön is beállíthatja – lásd a tevékenységvezérlési beállításokat. Ha a feladatszint időtúllépési időköze a tevékenység befejezése előtt eltelik, a futó feladat leáll, még akkor is, ha a tevékenység hosszabb időtúllépési intervallummal van konfigurálva.

Többfeladatos konfiguráció

Egyetlen ön által létrehozott feladatból egyszerre több feladatot is futtathat több ügynökön. Néhány példa:

  • Többkonfigurációs buildek: Több konfigurációt is létrehozhat párhuzamosan. Létrehozhat például egy Visual C++ alkalmazást mindkettőhöz debug és release konfigurációhoz mindkét x86 x64 platformon. További információ: Visual Studio Build – több konfiguráció több platformhoz.

  • Többkonfigurációs üzemelő példányok: Több üzembe helyezést is futtathat párhuzamosan, például különböző földrajzi régiókba.

  • Többkonfigurációs tesztelés: Egyszerre több konfigurációt is futtathat.

  • A többkonfiguráció mindig létrehoz legalább egy feladatot, még akkor is, ha egy többkonfigurációs változó üres.

A matrix stratégia lehetővé teszi, hogy egy feladat több alkalommal, különböző változókészletekkel legyen elküldve. A maxParallel címke korlátozza a párhuzamosság mértékét. A rendszer háromszor küldi el a következő feladatot a hely és a böngésző megadott értékeivel. Egyszerre azonban csak két feladat fut.

jobs:
- job: Test
  strategy:
    maxParallel: 2
    matrix: 
      US_IE:
        Location: US
        Browser: IE
      US_Chrome:
        Location: US
        Browser: Chrome
      Europe_Chrome:
        Location: Europe
        Browser: Chrome

Feljegyzés

A mátrix konfigurációs neveinek (a fentihez hasonlóan US_IE ) csak egyszerű latin betűs betűket (A-Z, a-z), számokat és aláhúzásjeleket (_) kell tartalmazniuk. Az oszlopok nevének betűvel kell kezdődnie. Emellett legalább 100 karakter hosszúságúnak kell lenniük.

Kimeneti változók használatával is létrehozhat egy mátrixot. Ez hasznos lehet, ha szkripttel kell létrehoznia a mátrixot.

matrix sztringezett JSON-objektumot tartalmazó futtatókörnyezeti kifejezést fogad el. A kibontott JSON-objektumnak meg kell egyeznie a mátrixozási szintaxissal. Az alábbi példában keményen kódoltuk a JSON-sztringet, de szkriptnyelv vagy parancssori program is létrehozhatja.

jobs:
- job: generator
  steps:
  - bash: echo "##vso[task.setVariable variable=legs;isOutput=true]{'a':{'myvar':'A'}, 'b':{'myvar':'B'}}"
    name: mtrx
  # This expands to the matrix
  #   a:
  #     myvar: A
  #   b:
  #     myvar: B
- job: runner
  dependsOn: generator
  strategy:
    matrix: $[ dependencies.generator.outputs['mtrx.legs'] ]
  steps:
  - script: echo $(myvar) # echos A or B depending on which leg is running

Szeletelés

Az ügynökfeladatokkal párhuzamosan futtathat tesztcsomagokat. Futtathat például egy nagy, 1000 tesztből álló csomagot egyetlen ügynökön. Vagy használhat két ügynököt, és 500 tesztet futtathat mindegyiken párhuzamosan.

A szeletelés alkalmazásához a feladat tevékenységeinek elég intelligensnek kell lenniük ahhoz, hogy megértsék a szeletet, amelyhez tartoznak.

A Visual Studio tesztfeladat egy olyan feladat, amely támogatja a tesztelési szeletelést. Ha több ügynököt telepített, megadhatja, hogyan fut párhuzamosan a Visual Studio tesztfeladat ezeken az ügynökökön.

A parallel stratégia lehetővé teszi a feladatok többszöri duplikálását. Változók System.JobPositionInPhase , és System.TotalJobsInPhase az egyes feladatokhoz lesznek hozzáadva. A változók ezután a szkripteken belül használhatók a feladatok közötti munka megosztására. Lásd: Párhuzamos és többszörös végrehajtás ügynökfeladatokkal.

A következő feladatot ötször küldi el a rendszer a megfelelő értékekkel System.JobPositionInPhase és System.TotalJobsInPhase beállítással.

jobs:
- job: Test
  strategy:
    parallel: 5

Feladatváltozók

HA YAML-t használ, a feladathoz változók is megadhatóak. A változók átadhatók a tevékenységbemeneteknek a $(variableName) makrószintaxis használatával, vagy a szakaszváltozó használatával érhetők el egy szkripten belül.

Az alábbi példa egy feladat változóinak definiálását és a tevékenységeken belüli használatát szemlélteti.

variables:
  mySimpleVar: simple var value
  "my.dotted.var": dotted var value
  "my var with spaces": var with spaces value

steps:
- script: echo Input macro = $(mySimpleVar). Env var = %MYSIMPLEVAR%
  condition: eq(variables['agent.os'], 'Windows_NT')
- script: echo Input macro = $(mySimpleVar). Env var = $MYSIMPLEVAR
  condition: in(variables['agent.os'], 'Darwin', 'Linux')
- bash: echo Input macro = $(my.dotted.var). Env var = $MY_DOTTED_VAR
- powershell: Write-Host "Input macro = $(my var with spaces). Env var = $env:MY_VAR_WITH_SPACES"

A feltétel használatáról további információt a Feltételek megadása című témakörben talál.

Munkaterület

Amikor egy ügynökkészlet-feladatot futtat, az létrehoz egy munkaterületet az ügynökön. A munkaterület egy könyvtár, amelyben letölti a forrást, futtatja a lépéseket, és kimeneteket hoz létre. A munkaterület könyvtárára változóval Pipeline.Workspace hivatkozhat a feladatban. Ebben a szakaszban különböző alkönyvtárak jönnek létre:

  • Build.SourcesDirectory itt töltik le a feladatok az alkalmazás forráskódját.
  • Build.ArtifactStagingDirectory Itt töltik le a tevékenységek a folyamathoz szükséges összetevőket, vagy feltöltik az összetevőket a közzétételük előtt.
  • Build.BinariesDirectory ahol a tevékenységek megírják a kimenetüket.
  • Common.TestResultsDirectory itt töltik fel a feladatok a teszteredményeket.

Az $(Build.ArtifactStagingDirectory) és $(Common.TestResultsDirectory) mindig minden build előtt törlődnek és újra létrejönnek.

Ha egy saját üzemeltetésű ügynökön futtat egy folyamatot, alapértelmezés szerint egyik alkönyvtárat $(Build.ArtifactStagingDirectory) $(Common.TestResultsDirectory) sem távolítja el két egymást követő futtatás között. Ennek eredményeképpen növekményes buildeket és üzembe helyezéseket hajthat végre, feltéve, hogy a tevékenységek implementálva vannak a használatukhoz. Ezt a viselkedést felülbírálhatja a workspace feladat beállításával.

Fontos

A munkaterület tiszta beállításai csak a saját üzemeltetésű ügynökökre vonatkoznak. A feladatok mindig egy új ügynökön futnak a Microsoft által üzemeltetett ügynökökkel.

- job: myJob
  workspace:
    clean: outputs | resources | all # what to clean up before the job runs

Az egyik beállítás megadásakor a rendszer a clean következőképpen értelmezi őket:

  • outputs: Törlés Build.BinariesDirectory új feladat futtatása előtt.
  • resources: Törlés Build.SourcesDirectory új feladat futtatása előtt.
  • all: Új feladat futtatása előtt törölje a teljes Pipeline.Workspace könyvtárat.
  jobs:
  - deployment: MyDeploy
    pool:
      vmImage: 'ubuntu-latest'
    workspace:
      clean: all
    environment: staging

Feljegyzés

Az ügynök képességeitől és a folyamatigénytől függően minden feladat átirányítható egy másik ügynökhöz a saját üzemeltetésű készletben. Ennek eredményeképpen új ügynököt kaphat a következő folyamatfuttatásokhoz (vagy ugyanabban a folyamatban lévő szakaszokhoz vagy feladatokhoz), így a tisztítás nem garantálja, hogy a későbbi futtatások, feladatok vagy szakaszok hozzáférhetnek a korábbi futtatások, feladatok vagy szakaszok kimeneteihez. Az ügynöki képességek és a folyamatigények konfigurálhatók úgy, hogy megadják, mely ügynököket használják a folyamatfeladatok futtatásához, de ha csak egyetlen ügynök van a készletben, amely megfelel az igényeknek, nincs garancia arra, hogy a későbbi feladatok ugyanazt az ügynököt használják, mint a korábbi feladatok. További információ: Igény megadása.

A munkaterület megtisztítása mellett a tisztítást is konfigurálhatja a folyamatbeállítások felhasználói felületén a Tiszta beállítás konfigurálásával. Ha a Tiszta beállítás igaz, amely egyben az alapértelmezett értéke is, az egyenértékű a folyamat minden kivételi lépésének megadásávalclean: true. Ha megadja clean: true, a git beolvasása előtt futtatja git clean -ffdx a elemet git reset --hard HEAD . A Tiszta beállítás konfigurálása:

  1. Szerkessze a folyamatot, válassza a ..., majd az Eseményindítók lehetőséget.

    Eseményindítók szerkesztése.

  2. Válassza ki a YAML-t, kérje le a forrásokat, és konfigurálja a kívánt Tiszta beállítást. Az alapértelmezett érték igaz.

    Tiszta beállítás.

Összetevő letöltése

Ez a példa YAML-fájl közzéteszi az összetevőt WebSite , majd letölti az összetevőt a fájlba $(Pipeline.Workspace). Az üzembe helyezési feladat csak akkor fut, ha a buildelési feladat sikeres.

# test and upload my code as an artifact named WebSite
jobs:
- job: Build
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: npm test
  - task: PublishBuildArtifacts@1
    inputs:
      pathtoPublish: '$(System.DefaultWorkingDirectory)'
      artifactName: WebSite

# download the artifact and deploy it only if the build job succeeded
- job: Deploy
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - checkout: none #skip checking out the default repository resource
  - task: DownloadBuildArtifacts@0
    displayName: 'Download Build Artifacts'
    inputs:
      artifactName: WebSite
      downloadPath: $(Pipeline.Workspace)

  dependsOn: Build
  condition: succeeded()

A dependsOn és a feltétel használatáról további információt a feltételek megadása című témakörben talál.

Hozzáférés az OAuth-jogkivonathoz

Engedélyezheti, hogy a feladatban futó szkriptek hozzáférjenek az aktuális Azure Pipelines- vagy TFS OAuth-biztonsági jogkivonathoz. A jogkivonat használható az Azure Pipelines REST API-val való hitelesítéshez.

Az OAuth-jogkivonat mindig elérhető a YAML-folyamatok számára. Explicit módon le kell képezni a feladatba vagy a lépésbe a használatával env. Példa:

steps:
- powershell: |
    $url = "$($env:SYSTEM_TEAMFOUNDATIONCOLLECTIONURI)$env:SYSTEM_TEAMPROJECTID/_apis/build/definitions/$($env:SYSTEM_DEFINITIONID)?api-version=4.1-preview"
    Write-Host "URL: $url"
    $pipeline = Invoke-RestMethod -Uri $url -Headers @{
      Authorization = "Bearer $env:SYSTEM_ACCESSTOKEN"
    }
    Write-Host "Pipeline = $($pipeline | ConvertTo-Json -Depth 100)"
  env:
    SYSTEM_ACCESSTOKEN: $(system.accesstoken)

A következő lépések