Azure DevOps Pipelines Skill

Build CI/CD pipelines with Azure DevOps YAML pipelines for automated builds, tests, and deployments.

Triggers

Use this skill when you see:

• azure devops, ado, azure pipelines
• yaml pipeline, ci/cd, build pipeline
• release pipeline, deployment, artifacts
• pipeline template, variable group

Instructions

Basic Pipeline Structure

# azure-pipelines.yml
trigger:
  branches:
    include:
      - main
      - release/*
  paths:
    exclude:
      - docs/*
      - README.md

pr:
  branches:
    include:
      - main

pool:
  vmImage: 'ubuntu-latest'

variables:
  - name: buildConfiguration
    value: 'Release'
  - group: my-variable-group

stages:
  - stage: Build
    displayName: 'Build Stage'
    jobs:
      - job: BuildJob
        displayName: 'Build'
        steps:
          - task: UseDotNet@2
            inputs:
              version: '8.x'

          - script: dotnet build --configuration $(buildConfiguration)
            displayName: 'Build'

          - script: dotnet test --configuration $(buildConfiguration)
            displayName: 'Test'

          - task: PublishBuildArtifacts@1
            inputs:
              pathtoPublish: '$(Build.ArtifactStagingDirectory)'
              artifactName: 'drop'

Multi-Stage Pipeline

trigger:
  - main

stages:
  - stage: Build
    jobs:
      - job: Build
        pool:
          vmImage: 'ubuntu-latest'
        steps:
          - script: npm ci
          - script: npm run build
          - script: npm test
          - publish: $(System.DefaultWorkingDirectory)/dist
            artifact: webapp

  - stage: DeployDev
    displayName: 'Deploy to Development'
    dependsOn: Build
    condition: succeeded()
    jobs:
      - deployment: DeployDev
        environment: development
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: webapp
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: 'my-subscription'
                    appName: 'myapp-dev'
                    package: '$(Pipeline.Workspace)/webapp'

  - stage: DeployProd
    displayName: 'Deploy to Production'
    dependsOn: DeployDev
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: DeployProd
        environment: production
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: webapp
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: 'my-subscription'
                    appName: 'myapp-prod'
                    package: '$(Pipeline.Workspace)/webapp'

Templates

Job Template

# templates/build-job.yml
parameters:
  - name: buildConfiguration
    type: string
    default: 'Release'
  - name: dotnetVersion
    type: string
    default: '8.x'

jobs:
  - job: Build
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - task: UseDotNet@2
        inputs:
          version: ${{ parameters.dotnetVersion }}

      - script: dotnet restore
        displayName: 'Restore'

      - script: dotnet build --configuration ${{ parameters.buildConfiguration }}
        displayName: 'Build'

      - script: dotnet test --configuration ${{ parameters.buildConfiguration }}
        displayName: 'Test'

# Main pipeline using template
stages:
  - stage: Build
    jobs:
      - template: templates/build-job.yml
        parameters:
          buildConfiguration: 'Release'
          dotnetVersion: '8.x'

Stage Template

# templates/deploy-stage.yml
parameters:
  - name: environment
    type: string
  - name: azureSubscription
    type: string
  - name: appName
    type: string

stages:
  - stage: Deploy_${{ parameters.environment }}
    displayName: 'Deploy to ${{ parameters.environment }}'
    jobs:
      - deployment: Deploy
        environment: ${{ parameters.environment }}
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: webapp
                - task: AzureWebApp@1
                  inputs:
                    azureSubscription: ${{ parameters.azureSubscription }}
                    appName: ${{ parameters.appName }}
                    package: '$(Pipeline.Workspace)/webapp'

Variables and Variable Groups

variables:
  # Inline variables
  - name: solution
    value: '**/*.sln'
  - name: buildPlatform
    value: 'Any CPU'

  # Variable group from library
  - group: my-secrets

  # Template expression
  - name: environment
    ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}:
      value: 'production'
    ${{ else }}:
      value: 'development'

  # Conditional variable
  - ${{ if eq(variables['Build.Reason'], 'PullRequest') }}:
    - name: isPR
      value: true

Conditions and Dependencies

stages:
  - stage: Build
    jobs:
      - job: BuildJob
        steps:
          - script: echo "Building"

  - stage: Test
    dependsOn: Build
    condition: succeeded()
    jobs:
      - job: UnitTests
        steps:
          - script: echo "Unit Tests"

      - job: IntegrationTests
        dependsOn: UnitTests
        condition: succeeded()
        steps:
          - script: echo "Integration Tests"

  - stage: Deploy
    dependsOn: Test
    condition: |
      and(
        succeeded(),
        eq(variables['Build.SourceBranch'], 'refs/heads/main')
      )

Container Jobs

jobs:
  - job: BuildInContainer
    pool:
      vmImage: 'ubuntu-latest'
    container:
      image: node:20
      options: --user 0:0
    steps:
      - script: npm ci
      - script: npm run build
      - script: npm test

  # Multiple containers (services)
  - job: IntegrationTests
    pool:
      vmImage: 'ubuntu-latest'
    container: node:20
    services:
      postgres:
        image: postgres:15
        ports:
          - 5432:5432
        env:
          POSTGRES_PASSWORD: password
      redis:
        image: redis:alpine
        ports:
          - 6379:6379
    steps:
      - script: npm run test:integration
        env:
          DATABASE_URL: postgres://postgres:password@postgres:5432/test
          REDIS_URL: redis://redis:6379

Matrix Strategy

jobs:
  - job: Build
    strategy:
      matrix:
        linux:
          vmImage: 'ubuntu-latest'
          platform: 'linux'
        windows:
          vmImage: 'windows-latest'
          platform: 'windows'
        mac:
          vmImage: 'macos-latest'
          platform: 'mac'
      maxParallel: 3
    pool:
      vmImage: $(vmImage)
    steps:
      - script: echo "Building on $(platform)"

Deployment Strategies

jobs:
  # Rolling deployment
  - deployment: RollingDeploy
    environment: production
    strategy:
      rolling:
        maxParallel: 2
        preDeploy:
          steps:
            - script: echo "Pre-deploy"
        deploy:
          steps:
            - script: echo "Deploy"
        routeTraffic:
          steps:
            - script: echo "Route traffic"
        postRouteTraffic:
          steps:
            - script: echo "Health check"
        on:
          failure:
            steps:
              - script: echo "Rollback"
          success:
            steps:
              - script: echo "Cleanup"

  # Canary deployment
  - deployment: CanaryDeploy
    environment: production
    strategy:
      canary:
        increments: [10, 20, 50]
        preDeploy:
          steps:
            - script: echo "Pre-deploy"
        deploy:
          steps:
            - script: echo "Deploy"
        routeTraffic:
          steps:
            - script: echo "Route $(strategy.increment)% traffic"
        postRouteTraffic:
          steps:
            - script: echo "Monitor"

Approvals and Checks

# Configure in Azure DevOps UI:
# Project Settings > Environments > [environment] > Approvals and checks

stages:
  - stage: DeployProd
    jobs:
      - deployment: DeployProd
        environment: production  # Has approval configured
        strategy:
          runOnce:
            deploy:
              steps:
                - script: echo "Deploying to production"

Common Tasks

# Azure CLI
- task: AzureCLI@2
  inputs:
    azureSubscription: 'my-subscription'
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az webapp list --output table

# Docker
- task: Docker@2
  inputs:
    containerRegistry: 'my-acr'
    repository: 'myapp'
    command: 'buildAndPush'
    Dockerfile: '**/Dockerfile'
    tags: |
      $(Build.BuildId)
      latest

# Kubernetes
- task: KubernetesManifest@0
  inputs:
    action: 'deploy'
    kubernetesServiceConnection: 'my-aks'
    namespace: 'production'
    manifests: |
      $(Pipeline.Workspace)/manifests/*.yml

Best Practices

1. Templates: Use templates for reusable pipeline components
2. Variable Groups: Store secrets in variable groups linked to Key Vault
3. Environments: Use environments with approvals for production
4. Caching: Cache dependencies to speed up builds
5. Artifacts: Publish and reuse artifacts between stages

Common Workflows

CI/CD Pipeline

1. Define trigger branches and paths
2. Create build stage with tests
3. Publish artifacts
4. Create deployment stages per environment
5. Configure approvals for production

Multi-Environment Deployment

1. Create environments in Azure DevOps
2. Configure approval gates
3. Use stage templates for consistency
4. Deploy with appropriate strategies
5. Monitor deployment health