Partilhar via


Retenção da Execução do Pipeline

Serviços do Azure DevOps | Azure DevOps Server 2022 | Azure DevOps Server 2020

Manter uma execução de pipeline por mais tempo do que as definições de projeto configuradas é processada pela criação de concessões de retenção. As concessões de retenção temporária são muitas vezes criadas por processos automáticos e concessões mais permanentes ao manipular a IU ou quando a Gestão de Versões retém artefactos, mas também podem ser manipuladas através da API REST. Eis alguns exemplos de tarefas que pode adicionar ao seu pipeline yaml para retenção.

Pré-requisitos

Por predefinição, os membros dos grupos Contribuidores, Administradores da Compilação, Administradores de Projeto e Administradores da Versão podem gerir políticas de retenção.

Exemplo: Substituir uma pequena janela de retenção ao nível do projeto

Neste exemplo, o projeto está configurado para eliminar execuções de pipelines após apenas 30 dias.

Exemplo 1: políticas de retenção de definições de projeto

Se um pipeline neste projeto for importante e as execuções deverão ser mantidas durante mais de 30 dias, esta tarefa garante que a execução é válida durante dois anos ao adicionar uma nova concessão de retenção.

- task: PowerShell@2
  condition: and(succeeded(), not(canceled()))
  name: RetainOnSuccess
  displayName: Retain on Success
  inputs:
    failOnStderr: true
    targetType: 'inline'
    script: |
      $contentType = "application/json";
      $headers = @{ Authorization = 'Bearer $(System.AccessToken)' };
      $rawRequest = @{ daysValid = 365 * 2; definitionId = $(System.DefinitionId); ownerId = 'User:$(Build.RequestedForId)'; protectPipeline = $false; runId = $(Build.BuildId) };
      $request = ConvertTo-Json @($rawRequest);
      $uri = "$(System.CollectionUri)$(System.TeamProject)/_apis/build/retention/leases?api-version=6.0-preview.1";
      Invoke-RestMethod -uri $uri -method POST -Headers $headers -ContentType $contentType -Body $request;

Pergunta: um pipeline pode ser retido por menos do que os valores de projeto configurados?

Não, as concessões não funcionam ao contrário. Se um projeto estiver configurado para reter durante dois anos, o pipeline executa o sistema não removerá execuções durante dois anos. Para eliminar estas execuções anteriormente, elimine-as manualmente ou utilize a API REST equivalente.

Exemplo: apenas as execuções em ramos com o nome releases/* devem ser mantidas durante muito tempo

Isto é semelhante ao acima, apenas a condição tem de ser alterada:

- task: PowerShell@2
  condition: and(succeeded(), not(canceled()), startsWith(variables['Build.SourceBranch'], 'releases/'))
  name: RetainReleaseBuildOnSuccess
  displayName: Retain Release Build on Success
  inputs:
    failOnStderr: true
    targetType: 'inline'
    script: |
      $contentType = "application/json";
      $headers = @{ Authorization = 'Bearer $(System.AccessToken)' };
      $rawRequest = @{ daysValid = 365 * 2; definitionId = $(System.DefinitionId); ownerId = 'User:$(Build.RequestedForId)'; protectPipeline = $false; runId = $(Build.BuildId) };
      $request = ConvertTo-Json @($rawRequest);
      $uri = "$(System.CollectionUri)$(System.TeamProject)/_apis/build/retention/leases?api-version=6.0-preview.1";
      Invoke-RestMethod -uri $uri -method POST -Headers $headers -ContentType $contentType -Body $request;

Exemplo: Atualizar a janela de retenção para um pipeline de várias fases com base no êxito da fase

Considere um pipeline de duas fases que executa primeiro uma compilação e, em seguida, uma versão. Quando for bem-sucedida, a Build fase mantém a execução durante três dias, mas o administrador do projeto quer uma fase de sucesso Release para prolongar a concessão para um ano.

A Build fase pode manter o pipeline como nos exemplos acima, mas com uma adição: ao guardar a nova concessão numa variável de Id saída, a concessão pode ser atualizada mais tarde quando a fase de lançamento for executada.

- task: PowerShell@2
  condition: and(succeeded(), not(canceled()))
  name: RetainOnSuccess
  displayName: Retain on Success
  inputs:
    failOnStderr: true
    targetType: 'inline'
    script: |
      $contentType = "application/json";
      $headers = @{ Authorization = 'Bearer $(System.AccessToken)' };
      $rawRequest = @{ daysValid = 365; definitionId = $(System.DefinitionId); ownerId = 'User:$(Build.RequestedForId)'; protectPipeline = $false; runId = $(Build.BuildId) };
      $request = ConvertTo-Json @($rawRequest);
      $uri = "$(System.CollectionUri)$(System.TeamProject)/_apis/build/retention/leases?api-version=6.0-preview.1";
      $newLease = Invoke-RestMethod -uri $uri -method POST -Headers $headers -ContentType $contentType -Body $request;
      $newLeaseId = $newLease.Value[0].LeaseId
      echo "##vso[task.setvariable variable=newLeaseId;isOutput=true]$newLeaseId";

Para atualizar uma concessão de retenção , é necessária uma chamada à API REST diferente.

- stage: Release
  dependsOn: Build
  jobs:
  - job: default
    variables:
    - name: NewLeaseId
      value: $[ stageDependencies.Build.default.outputs['RetainOnSuccess.newLeaseId']]
    steps:
    - task: PowerShell@2
      condition: and(succeeded(), not(canceled()))
      name: RetainOnSuccess
      displayName: Retain on Success
      inputs:
        failOnStderr: true
        targetType: 'inline'
        script: |
          $contentType = "application/json";
          $headers = @{ Authorization = 'Bearer $(System.AccessToken)' };
          $rawRequest = @{ daysValid = 365 };
          $request = ConvertTo-Json $rawRequest;
          $uri = "$(System.CollectionUri)$(System.TeamProject)/_apis/build/retention/leases/$(newLeaseId)?api-version=7.1-preview.2";
          Invoke-RestMethod -uri $uri -method PATCH -Headers $headers -ContentType $contentType -Body $request;

Passos seguintes

Com estes exemplos, aprendeu a utilizar tarefas de pipeline personalizadas para gerir a retenção de execução.

Aprendeu a:

  • Substituir uma janela de retenção curta
  • Substituir a retenção de execuções em ramos específicos
  • Atualizar uma concessão de retenção quando uma execução deve ser mantida ainda mais tempo