Templates & Reuse

Scale Azure DevOps YAML by extracting repeated logic into step, job, stage, and variable templates so many teams can share one delivery standard without copying the same pipeline everywhere.

🧒 Simple Explanation (ELI5)

If every team writes its own copy of the same recipe, eventually one copy says bake for 10 minutes, another says 12, another forgets salt, and nobody knows which one is correct. Templates solve that problem. You keep one trusted recipe and let teams fill in only the parts that change.

🔧 Technical Explanation

Why Templates Matter

• Reduce copy-paste across repositories.
• Standardize testing, security scanning, and deployment behavior.
• Make platform improvements available to many teams from one place.
• Support safer governance because shared patterns are easier to audit.

Parameterized Job Template

# templates/jobs/docker-build.yml
parameters:
- name: imageRepository
  type: string
- name: dockerfile
  type: string
  default: Dockerfile

jobs:
- job: BuildImage
  pool:
    vmImage: ubuntu-latest
  steps:
  - task: Docker@2
    inputs:
      command: buildAndPush
      repository: ${{ parameters.imageRepository }}
      dockerfile: ${{ parameters.dockerfile }}
      containerRegistry: 'sc-acr-shared'
      tags: '$(Build.BuildId)'

Using the Template

stages:
- stage: Build
  jobs:
  - template: templates/jobs/docker-build.yml
    parameters:
      imageRepository: 'payments-api'
      dockerfile: 'src/Payments/Dockerfile'

Reusable AKS Deploy Stage

# templates/stages/aks-deploy.yml
parameters:
- name: environmentName
  type: string
- name: namespace
  type: string

stages:
- stage: Deploy_${{ parameters.environmentName }}
  jobs:
  - deployment: Deploy_${{ parameters.environmentName }}
    environment: ${{ parameters.environmentName }}
    strategy:
      runOnce:
        deploy:
          steps:
          - script: |
              helm upgrade --install webapp ./charts/webapp \
                --namespace ${{ parameters.namespace }} \
                --set image.tag=$(Build.BuildId)

This pattern keeps AKS promotion consistent without repeating the same deployment logic across every repository.

🛠️ Hands-on

Refactor Copy-Pasted Pipeline Logic

1. Find repeated jobs like test, Docker build, Helm deploy, or security scan.
2. Extract them into templates with a small parameter surface.
3. Keep behavior opinionated. Do not create templates with 40 switches.
4. Version and review template changes carefully because many pipelines may depend on them.

Variable Template Example

# templates/vars/common.yml
variables:
  chartPath: 'charts/webapp'
  acrLoginServer: 'contosoregistry.azurecr.io'
  kubernetesNamespace: 'default'

# usage
variables:
- template: templates/vars/common.yml

🐛 Debugging Scenarios

Scenario 1: Template Not Found

• Check relative path from the calling pipeline file.
• Validate repository resource alias if templates live in another repo.
• Confirm the branch or ref for the template repository is correct.

Scenario 2: Parameter Is Empty Unexpectedly

• Verify compile-time vs runtime syntax. Template parameters use ${{ }}.
• Check the parameter name exactly matches the template definition.
• Confirm a default value exists where appropriate.

Scenario 3: Template Change Breaks Many Pipelines

• Version templates or test changes in a lower-risk branch first.
• Use a consumer test pipeline to validate shared templates before broad rollout.
• Avoid backward-incompatible parameter changes without a migration plan.

📋 Interview Questions

🌍 Real-World Usage

Large Azure DevOps estates depend on templates to keep hundreds of pipelines aligned. Shared build, security, and AKS deployment patterns give teams a paved road while still allowing application-specific inputs where needed.

🧾 Summary

Templates are how Azure Pipelines scale. They turn YAML from repository-local automation into an organization-wide delivery framework with reusable, reviewable standards.