Stages, Jobs & Tasks

Azure DevOps Release Pipelines are structured into **Stages, Jobs, and Tasks** to ensure controlled, automated deployments. Understanding these components helps teams manage and execute deployment workflows efficiently.

Understanding Stages, Jobs & Tasks

Release Pipelines in Azure DevOps consist of three key components:

Stages: High-level phases in a pipeline representing different deployment environments (e.g., Development, Testing, Staging, Production). Each stage contains jobs that execute tasks.
Jobs: A job is a logical grouping of **tasks** that run sequentially within a stage. Jobs can be executed in **parallel or sequentially** within the same stage.
Tasks: These are **individual steps** executed within a job, such as building code, deploying artifacts, running scripts, or sending notifications.

Structure of Stages, Jobs, and Tasks in Azure DevOps

Key Concepts

Each **stage** can contain multiple **jobs**, representing different phases of deployment.
Each **job** consists of multiple **tasks** that define the execution steps.
Stages can be executed **sequentially or in parallel** based on deployment needs.
Approval gates can be configured **before moving to the next stage** to ensure controlled deployments.
Jobs can be run on different **agents** or **self-hosted environments** based on configuration.

Defining Stages, Jobs & Tasks in YAML

Below is an example YAML pipeline demonstrating how to define **stages, jobs, and tasks**:

stages:
- stage: Build
  displayName: 'Build Stage'
  jobs:
  - job: BuildJob
    displayName: 'Build and Compile'
    steps:
    - task: DotNetCoreCLI@2
      inputs:
        command: 'build'
        projects: '**/*.csproj'

- stage: Test
  displayName: 'Testing Stage'
  jobs:
  - job: UnitTests
    displayName: 'Run Unit Tests'
    steps:
    - task: VSTest@2
      inputs:
        testSelector: 'testAssemblies'
        testAssemblyVer2: '**/*.Tests.dll'

- stage: Deploy
  displayName: 'Deployment Stage'
  jobs:
  - deployment: DeployJob
    displayName: 'Deploy to Production'
    environment: 'Production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              azureSubscription: 'AzureServiceConnection'
              appName: 'my-web-app'
              package: '$(Pipeline.Workspace)/drop/*.zip'

This example demonstrates a **multi-stage pipeline** where:

Code is built in the **Build Stage**.
Tests are executed in the **Testing Stage**.
The application is deployed to **Production** in the final **Deployment Stage**.

Best Practices for Stages, Jobs & Tasks

Use **separate stages** for different deployment environments (Development, Testing, Production).
Define **pre-deployment and post-deployment approvals** to prevent unauthorized releases.
Enable **conditional execution** to handle rollback and different deployment scenarios.
Use **parallel jobs** to speed up execution time and optimize resource usage.
Implement **artifact versioning** to ensure rollback to stable builds.
Monitor deployments with **Azure DevOps logs, alerts, and dashboards** to track performance and failures.
Use **environment variables** to avoid hardcoding sensitive configurations.

Conclusion

Stages, Jobs, and Tasks in Azure DevOps Pipelines allow teams to create structured, repeatable, and automated deployments. By organizing workflows effectively, teams can improve **deployment efficiency, minimize risks, and ensure smooth rollouts**.

The next step is to explore **Deploying to Azure App Services** and how applications can be hosted and managed in the cloud effectively.

← Previous: Introduction to Release Pipelines Next: Deploying to Azure App Services →