Sdílet prostřednictvím

Úlohy nasazení

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

Důležité

  • Názvy úloh a fází nesmí být v konfliktu s rezervovanými klíčovými slovy (například deployment pro typ úlohy).
  • Každá úloha ve fázi musí mít jedinečný název.

V kanálech YAML doporučujeme umístit kroky nasazení do speciálního typu úlohy označované jako úloha nasazení. Úloha nasazení je soubor kroků, které se v prostředí spouštějí postupně. Úloha nasazení a tradiční úloha mohou existovat ve stejné fázi. Azure DevOps podporuje runOnce, rolling a kanárské strategie.

Úlohy nasazení poskytují následující výhody:

  • Historie nasazení: Získáte historii nasazení napříč kanály, až po konkrétní prostředky a stav nasazení pro účely auditování.
  • Použít strategii nasazení: Definujete, jak má být vaše aplikace zaváděna.

Úloha nasazení nenaklonuje automaticky zdrojové úložiště. Zdrojové úložiště si můžete prohlédnout v rámci své úlohy pomocí checkout: self.

Poznámka:

Tento článek se zaměřuje na nasazení s úlohami nasazení. Pokud se chcete naučit, jak nasazovat do Azure pomocí pipelines, podívejte se na přehled nasazení do Azure.

Schéma

Přejděte do schématu YAML a prohlédněte si definice jobs.deployment a jobs.deployment.environment .

Pro virtuální počítače nemusíte definovat fond. Jakékoli kroky, které definujete v nasazovací úloze s prostředkem virtuálního počítače, běží na tomto virtuálním počítači, nikoli na agentu ve fondu. U jiných typů prostředků, jako je Kubernetes, je potřeba definovat fond, aby se na tomto počítači mohly spouštět úlohy.

Strategie nasazení

Při nasazování aktualizací aplikací je důležité, aby technika, kterou používáte k doručení aktualizace,:

  • Povolte inicializaci.
  • Nasaďte aktualizaci.
  • Směrujte provoz na aktualizovanou verzi.
  • Po směrování provozu otestujte aktualizovanou verzi.
  • V případě selhání spusťte kroky pro obnovení na poslední známou dobrou verzi.

Toho dosáhneme pomocí háků životního cyklu, které mohou spouštět kroky v průběhu nasazení. Každý z háků životního cyklu se v závislosti na atributu transformuje na úlohu agenta nebo úlohu serveru (v budoucnu na úlohu kontejneru nebo ověřovací úlohu). Ve výchozím nastavení háky životního cyklu dědí pool zadané úlohou deployment .

Úlohy nasazení využívají proměnnou systému $(Pipeline.Workspace).

Popisy háků životního cyklu

preDeploy: Slouží ke spuštění kroků, které inicializují prostředky před spuštěním nasazení aplikace.

deploy: Slouží ke spuštění kroků, které nasazují vaši aplikaci. Automatizované vložení úlohy stažení artefaktu probíhá pouze v háku deploy pro nasazovací úlohy. Chcete-li zastavit stahování artefaktů, použijte - download: none nebo zvolte konkrétní artefakty ke stažení zvolením úkolu Stažení artefaktu z kanálu.

routeTraffic: Slouží ke spuštění kroků, které směřují provoz na aktualizovanou verzi.

postRouteTraffic: Používá se ke spuštění kroků po směrování provozu. Tyto úlohy obvykle monitorují stav aktualizované verze pro definovaný interval.

on: failure nebo on: success: Slouží ke spuštění kroků pro akce vrácení změn nebo čištění.

Strategie nasazení RunOnce

runOnce je nejjednodušší strategie nasazení, ve které se všechny háky životního cyklu, konkrétně preDeploydeploy, routeTraffic a postRouteTraffic, spustí jednou. Buď se provede on:success, nebo se spustí on:failure.

strategy: 
    runOnce:
      preDeploy:        
        pool: [ server | pool ] # See pool schema.        
        steps:
        - script: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
      deploy:          
        pool: [ server | pool ] # See pool schema.        
        steps:
        ...
      routeTraffic:         
        pool: [ server | pool ]         
        steps:
        ...        
      postRouteTraffic:          
        pool: [ server | pool ]        
        steps:
        ...
      on:
        failure:         
          pool: [ server | pool ]           
          steps:
          ...
        success:          
          pool: [ server | pool ]           
          steps:
          ...

Pokud používáte agenty v místním prostředí, můžete pracovní prostor vyčistit pomocí možností vyčištění pracovního prostoru.

  jobs:
  - deployment: MyDeploy
    pool:
      vmImage: 'ubuntu-latest'
    workspace:
      clean: all
    environment: staging

Strategie postupného nasazení

Postupné nasazení nahrazuje instance předchozí verze aplikace instancemi nové verze aplikace na pevné sadě virtuálních počítačů (rolling set) v každé iteraci.

V současné době podporujeme pouze strategii zajištění provozu pro prostředky virtuálních počítačů.

Například postupné nasazení obvykle čeká na dokončení nasazení na každé sadě virtuálních počítačů, než pokračuje k další sadě. Po každé iteraci můžete provést kontrolu stavu a pokud dojde k významnému problému, je možné postupné nasazení zastavit.

Postupná nasazení lze nakonfigurovat zadáním klíčového slova rolling: pod uzlem strategy:. Proměnná strategy.name je k dispozici v tomto bloku strategie, která přebírá název strategie. V tomto případě se točí.

strategy:
  rolling:
    maxParallel: [ number or percentage as x% ]
    preDeploy:        
      steps:
      - script: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
    deploy:          
      steps:
      ...
    routeTraffic:         
      steps:
      ...        
    postRouteTraffic:          
      steps:
      ...
    on:
      failure:         
        steps:
        ...
      success:          
        steps:
        ...

Jsou podporovány všechny háčky životního cyklu a úlohy pro jednotlivé háčky životního cyklu jsou vytvářeny tak, aby běžely na každém virtuálním počítači.

preDeploy, deploy, routeTraffic a postRouteTraffic jsou prováděny jednou na velikost dávky definovanou maxParallel. Pak se buď on: success provede, nebo on: failure spustí.

Pomocí maxParallel: <# or % of VMs>funkce můžete řídit počet/procent cílů virtuálních počítačů, které se mají nasadit paralelně. Tím se zajistí, že aplikace běží na těchto počítačích a dokáže zpracovávat požadavky, zatímco se nasazení provádí na zbývajících počítačích, což snižuje celkový výpadek.

Poznámka:

Tato funkce obsahuje několik známých mezer. Například při opakováním úlohy znovu spustíte nasazení na všech virtuálních počítačích, nejen na těch, které selhaly.

Strategie kanářího nasazení

Canary deployment strategy je pokročilá strategie nasazení, která pomáhá zmírnit riziko spojené s zaváděním nových verzí aplikací. Pomocí této strategie můžete nejprve zavést změny malé podmnožině serverů. Jakmile budete mít větší jistotu v nové verzi, můžete ji uvolnit na více serverů ve vaší infrastruktuře a směrovat do ní větší provoz.

strategy: 
    canary:
      increments: [ number ]
      preDeploy:        
        pool: [ server | pool ] # See pool schema.        
        steps:
        - script: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
      deploy:          
        pool: [ server | pool ] # See pool schema.        
        steps:
        ...
      routeTraffic:         
        pool: [ server | pool ]         
        steps:
        ...        
      postRouteTraffic:          
        pool: [ server | pool ]        
        steps:
        ...
      on:
        failure:         
          pool: [ server | pool ]           
          steps:
          ...
        success:          
          pool: [ server | pool ]           
          steps:
          ...

Strategie nasazení Canary podporuje životní cyklus hooku preDeploy (proveden jednou) a iteruje s hooky životního cyklu deploy, routeTraffic a postRouteTraffic. Poté se ukončí buď s hákem success nebo failure hákem.

V této strategii jsou k dispozici následující proměnné:

strategy.name: Název strategie. Například kanár.
strategy.action: Akce, která se má provést v clusteru Kubernetes. Například nasadit, povýšit nebo odmítnout.
strategy.increment: Hodnota přírůstku použitá v aktuální interakci. Tato proměnná je k dispozici pouze v deploy, routeTraffic, a postRouteTraffic hácích životního cyklu.

Příklady

Strategie nasazení RunOnce

Následující příklad fragment kódu YAML předvádí jednoduché použití úlohy nasazení pomocí runOnce strategie nasazení. Příklad obsahuje krok pokladny.

jobs:
  # Track deployments on the environment.
  - deployment: DeployWeb
    displayName: deploy Web App
    pool:
      vmImage: 'ubuntu-latest'
    # Creates an environment if it doesn't exist.
    environment: 'smarthotel-dev'
    strategy:
      # Default deployment strategy, more coming...
      runOnce:
        deploy:
          steps:
            - checkout: self
            - script: echo my first deployment

Při každém spuštění této úlohy se historie nasazení zaznamená pro smarthotel-dev prostředí.

Poznámka:

  • Je také možné vytvořit prostředí s prázdnými prostředky a použít ho jako abstraktní prostředí k zaznamenání historie nasazení, jak je znázorněno v předchozím příkladu.

Další příklad ukazuje, jak může kanál odkazovat na prostředí a prostředek, které se mají použít jako cíl úlohy nasazení.

jobs:
  - deployment: DeployWeb
    displayName: deploy Web App
    pool:
      vmImage: 'ubuntu-latest'
    # Records deployment against bookings resource - Kubernetes namespace.
    environment: 'smarthotel-dev.bookings'
    strategy: 
      runOnce:
        deploy:
          steps:
            # No need to explicitly pass the connection details.
            - task: KubernetesManifest@1
              displayName: Deploy to Kubernetes cluster
              inputs:
                action: deploy
                namespace: $(k8sNamespace)
                manifests: |
                  $(System.ArtifactsDirectory)/manifests/*
                imagePullSecrets: |
                  $(imagePullSecret)
                containers: |
                  $(containerRegistry)/$(imageRepository):$(tag)

Tento přístup má následujících výhody:

  • Zaznamenává historii nasazení pro konkrétní prostředek v rámci prostředí, a ne zaznamenává historii všech prostředků v rámci prostředí.
  • Kroky v rámci úlohy nasazení automaticky dědí podrobnosti o připojení prostředku (v tomto případě oboru názvů Kubernetes), protože úloha nasazení je propojená s prostředím. To je užitečné v případech, kdy je stejný detail připojení nastavený pro více kroků úlohy.

Poznámka:

Pokud používáte privátní cluster AKS, ujistěte se, že jste připojení k virtuální síti clusteru, protože koncový bod serveru rozhraní API není přístupný prostřednictvím veřejné IP adresy.

Azure Pipelines doporučuje nastavit vlastního hostovaného agenta v rámci virtuální sítě (VNET), která má přístup k virtuální síti clusteru. Podrobnosti najdete v tématu Možnosti připojení k privátnímu clusteru .

Strategie postupného nasazení

Strategie postupných aktualizací virtuálních počítačů aktualizuje v každé iteraci až pět cílů. maxParallel určuje počet cílů, na které lze paralelně nasadit. Výběr zahrnuje absolutní počet nebo procento cílů, které musí být kdykoli dostupné, s výjimkou cílů, na které se právě nasazuje. Používá se také k určení podmínek úspěchu a selhání během nasazování.

jobs:
  - deployment: VMDeploy
    displayName: web
    environment:
      name: smarthotel-dev
      resourceType: VirtualMachine
    strategy:
      rolling:
        maxParallel: 5  # for percentages, mention as x%
        preDeploy:
          steps:
            - download: current
              artifact: drop
            - script: echo initialize, cleanup, backup, install certs
        deploy:
          steps:
            - task: IISWebAppDeploymentOnMachineGroup@0
              displayName: 'Deploy application to Website'
              inputs:
                WebSiteName: 'Default Web Site'
                Package: '$(Pipeline.Workspace)/drop/**/*.zip'
        routeTraffic:
          steps:
            - script: echo routing traffic
        postRouteTraffic:
          steps:
            - script: echo health check post-route traffic
        on:
          failure:
            steps:
              - script: echo Restore from backup! This is on failure
          success:
            steps:
              - script: echo Notify! This is on success

Strategie kanářího nasazení

V dalším příkladu kanárová strategie pro AKS nejprve nasadí změny s 10procentním podem, po kterém následuje 20 procent a během sledování postRouteTrafficstavu . Pokud všechno půjde dobře, dosáhne na 100 procent.

jobs:
  - deployment: 
      environment: smarthotel-dev.bookings
      pool: 
        name: smarthotel-devPool
      strategy:                  
        canary:      
          increments: [10, 20]  
          preDeploy:                                     
            steps:           
              - script: initialize, cleanup....
          deploy:             
            steps: 
              - script: echo deploy updates...
              - task: KubernetesManifest@1
                inputs:
                  action: $(strategy.action)
                  namespace: 'default'
                  strategy: $(strategy.name)
                  percentage: $(strategy.increment)
                  manifests: 'manifest.yml'
          postRouteTraffic: 
            pool: server 
            steps:           
              - script: echo monitor application health...
          on: 
            failure: 
              steps: 
                - script: echo clean-up, rollback...
            success: 
              steps: 
                - script: echo checks passed, notify...

Automatické vkládání kroků pomocí dekorátorů kanálu

Dekorátory kanálů lze použít v úlohách nasazení k automatickému vložení libovolného vlastního kroku (například skeneru zranitelnosti) do každého spuštění každého háku životního cyklu úlohy nasazení. Vzhledem k tomu, že dekorátory kanálu je možné použít u všech kanálů v organizaci, je možné je použít jako součást vynucování postupů bezpečného nasazení.

Kromě toho je možné úlohy nasazení spustit jako úloha kontejneru společně s vedlejšími službami, pokud jsou definované.

Podpora výstupních proměnných

Definujte výstupní proměnné v hookech životního cyklu úlohy nasazení a používejte je v dalších následujících krocích a úlohách ve stejné fázi.

Pokud chcete sdílet proměnné mezi fázemi, vypište artefakt v jedné fázi a pak ho spotřebujte v další fázi nebo použijte stageDependencies syntaxi popsanou v proměnných.

Při provádění strategií nasazení můžete přistupovat k výstupním proměnným napříč úlohami pomocí následující syntaxe.

  • Pro strategii runOnce : $[dependencies.<job-name>.outputs['<job-name>.<step-name>.<variable-name>']] (například $[dependencies.JobA.outputs['JobA.StepA.VariableA']])
  • Pro strategii runOnce plus typ zdroje: $[dependencies.<job-name>.outputs['Deploy_<resource-name>.<step-name>.<variable-name>']]. (například $[dependencies.JobA.outputs['Deploy_VM1.StepA.VariableA']])
  • Pro kanárovou strategii: $[dependencies.<job-name>.outputs['<lifecycle-hookname>_<increment-value>.<step-name>.<variable-name>']]
  • Pro strategii postupného zavádění : $[dependencies.<job-name>.outputs['<lifecycle-hookname>_<resource-name>.<step-name>.<variable-name>']]
# Set an output variable in a lifecycle hook of a deployment job executing canary strategy.
- deployment: A
  pool:
    vmImage: 'ubuntu-latest'
  environment: staging
  strategy:                  
    canary:      
      increments: [10,20]  # Creates multiple jobs, one for each increment. Output variable can be referenced with this.
      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.
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromDeploymentJob: $[ dependencies.A.outputs['deploy_10.setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromDeploymentJob)"
    name: echovar

Pro úlohu runOnce zadejte název úlohy místo háku životního cyklu:

# Set an output variable in a lifecycle hook of a deployment job executing runOnce strategy.
- 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.
- job: B
  dependsOn: A
  pool:
    vmImage: 'ubuntu-latest'
  variables:
    myVarFromDeploymentJob: $[ dependencies.A.outputs['A.setvarStep.myOutputVar'] ]
  steps:
  - script: "echo $(myVarFromDeploymentJob)"
    name: echovar

Při definování prostředí v úloze nasazení se syntaxe výstupní proměnné liší v závislosti na tom, jak se prostředí definuje. V tomto příkladu env1 používá zkrácený zápis a env2 zahrnuje úplnou syntaxi s definovaným typem prostředku.

stages:
- stage: StageA
  jobs:
  - deployment: A1
    pool:
      vmImage: 'ubuntu-latest'
    environment: env1
    strategy:                  
      runOnce:
        deploy:
          steps:
          - bash: echo "##vso[task.setvariable variable=myOutputVar;isOutput=true]this is the deployment variable value"
            name: setvarStep
          - bash: echo $(System.JobName)
  - deployment: A2
    pool:
      vmImage: 'ubuntu-latest'
    environment: 
      name: env2
      resourceName: vmsfortesting
      resourceType: virtualmachine
    strategy:                  
      runOnce:
        deploy:
          steps:
          - script: echo "##vso[task.setvariable variable=myOutputVarTwo;isOutput=true]this is the second deployment variable value"
            name: setvarStepTwo
  
  - job: B1
    dependsOn: A1
    pool:
      vmImage: 'ubuntu-latest'
    variables:
      myVarFromDeploymentJob: $[ dependencies.A1.outputs['A1.setvarStep.myOutputVar'] ]
      
    steps:
    - script: "echo $(myVarFromDeploymentJob)"
      name: echovar
 
  - job: B2
    dependsOn: A2
    pool:
      vmImage: 'ubuntu-latest'
    variables:
      myVarFromDeploymentJob: $[ dependencies.A2.outputs['A2.setvarStepTwo.myOutputVarTwo'] ]
      myOutputVarTwo: $[ dependencies.A2.outputs['Deploy_vmsfortesting.setvarStepTwo.myOutputVarTwo'] ]
    
    steps:
    - script: "echo $(myOutputVarTwo)"
      name: echovartwo

Když vypíšete proměnnou z úlohy ve fázi 1, odkazování na ni z úlohy nasazení v další fázi použije jinou syntaxi v závislosti na tom, jestli chcete nastavit proměnnou nebo ji použít jako podmínku pro fázi.

stages:
- stage: StageA
  jobs:
  - job: A1
    steps:
      - pwsh: echo "##vso[task.setvariable variable=RunStageB;isOutput=true]true"
        name: setvarStep
      - bash: echo $(System.JobName)

- stage: StageB
  dependsOn: 
    - StageA
 
  # when referring to another stage, stage name is included in variable path
  condition: eq(dependencies.StageA.outputs['A1.setvarStep.RunStageB'], 'true')
  
  # Variables reference syntax differs slightly from inter-stage condition syntax
  variables:
    myOutputVar: $[stageDependencies.StageA.A1.outputs['setvarStep.RunStageB']]
  jobs:
  - deployment: B1
    pool:
      vmImage: 'ubuntu-latest'
    environment: envB
    strategy:                  
      runOnce:
        deploy:
          steps:
          - bash: echo $(myOutputVar)

Při výstupu proměnné z úlohy nasazení použijte syntaxi stageDependencies k odkazování z další fáze (například $[stageDependencies.<stage-name>.<job-name>.outputs[Deploy_<resource-name>.<step-name>.<variable-name>]]).

stages:
- stage: StageA
  jobs:
    - deployment: A1
      environment: 
        name:  env1
        resourceName: DevEnvironmentV
        resourceType: virtualMachine
      strategy:
        runOnce:
          deploy:
            steps:
              - script: echo "##vso[task.setvariable variable=myVar;isOutput=true]true"
                name: setvarStep
              - script: |
                  echo "Value of myVar in the same Job : $(setVarStep.myVar)"
                displayName: 'Verify variable in StageA'
- stage: StageB
  dependsOn: StageA

  # Full Variables syntax for inter-stage jobs
  variables:
    myOutputVar: $[stageDependencies.StageA.A1.outputs['Deploy_DevEnvironmentV.setvarStep.myVar']]
  jobs:
  - deployment: B1
    pool:
      vmImage: 'ubuntu-latest'
    environment: envB
    strategy:                  
      runOnce:
        deploy:
          steps:
          - bash: echo $(myOutputVar)

Další informace o tom, jak nastavit výstupní proměnnou s více úlohami

časté otázky

Kanál je zablokovaný se zprávou "Úloha čeká na vyřízení...". Jak to můžu opravit?

K tomu může dojít, když dojde ke konfliktu názvů mezi dvěma úlohami. Ověřte, že všechny úlohy nasazení ve stejné fázi mají jedinečný název a že názvy úloh a fází neobsahují klíčová slova. Pokud přejmenování problém nevyřeší, projděte si odstraňování potíží se spuštěním kanálu.

Jsou dekorátory podporovány ve skupinách nasazení?

Ne. Ve skupinách nasazení nemůžete používat dekorátory.

  • Last updated on