Voltar ao Blog

CI/CD no Azure DevOps

Como estruturar uma pipeline de entrega contínua em Azure DevOps com build, testes, gate de qualidade e deploy multi-ambiente.

2 min read
Azure DevOpsCI/CDDevOps

Uma pipeline de CI/CD bem desenhada é a diferença entre deployar com medo e deployar com confiança. Neste post mostro a estrutura que uso em projetos .NET.

Estrutura básica

A pipeline é dividida em stages: build, test, quality gate e deploy. Cada stage roda apenas se o anterior passar.

trigger:
  branches:
    include:
      - main
      - develop
 
pool:
  vmImage: ubuntu-latest
 
variables:
  buildConfiguration: Release
  projectPath: src/MyApp/MyApp.csproj
 
stages:
  - stage: Build
    jobs:
      - job: BuildJob
        steps:
          - task: UseDotNet@2
            inputs:
              version: 8.x
          - task: DotNetCoreCLI@2
            displayName: Restore
            inputs:
              command: restore
              projects: $(projectPath)
          - task: DotNetCoreCLI@2
            displayName: Build
            inputs:
              command: build
              projects: $(projectPath)
              arguments: --configuration $(buildConfiguration)
          - task: DotNetCoreCLI@2
            displayName: Publish
            inputs:
              command: publish
              projects: $(projectPath)
              publishWebProjects: true
              arguments: --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)
          - task: PublishBuildArtifacts@1
            inputs:
              pathtoPublish: $(Build.ArtifactStagingDirectory)
              artifactName: drop

Testes e qualidade

Depois do build, rodo testes com cobertura e.publico o resultado:

  - stage: Test
    dependsOn: Build
    jobs:
      - job: TestJob
        steps:
          - task: DotNetCoreCLI@2
            displayName: Test
            inputs:
              command: test
              arguments: --configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura
          - task: PublishCodeCoverageResults@2
            inputs:
              summaryFileLocation: $(Agent.TempDirectory)/**/coverage.cobertura.xml

Deploy multi-ambiente

Para cada ambiente (dev, staging, prod) uso um stage separado com approvals:

  - stage: DeployProd
    dependsOn: Test
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: DeployProd
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: my-service-connection
                    appName: myapp-prod
                    package: $(Pipeline.Workspace)/drop

O environment: production habilita approvals manuais no Azure DevOps — fundamental para qualquer deploy que toca produção.

Conclusão

O segredo de uma boa pipeline é pequena, rápida e confiável. Cada segundo economizado no build é um segundo multiplicado por todos os devs do time. Cada gate bem posicionado é um incidente evitado.