Exploring multi-configuration and multi-agent in Azure DevOps

Exploring multi-configuration and multi-agent in Azure DevOps

In Azure DevOps, multi-configuration and multi-agent pipelines are useful techniques to run jobs across different configurations (like operating systems, environments, tool versions, etc.) and agents concurrently. This helps you ensure that your code works across a variety of platforms or conditions without requiring manual intervention.

Let's explore these two concepts in detail.

1. Multi-Configuration Pipelines

Multi-configuration pipelines allow you to run the same set of tests or builds across different configurations, like operating systems, software versions, or environments. This is useful when you need to verify that your application works in multiple setups (e.g., testing an app on both Linux and Windows, or ensuring compatibility with multiple versions of a runtime).

Use Case for Multi-Configuration Pipelines:

• Cross-platform Testing: Ensure your application runs on multiple platforms, like Windows, macOS, and Linux.

• Version Testing: Verify your software with multiple versions of a runtime, such as Node.js, Python, .NET, or Java.

• Multiple Environments: Test your app with different database versions or in different configurations (e.g., staging, production).

Multi-Configuration in YAML Pipelines:

In Azure DevOps, you can set up a matrix strategy in your YAML pipeline to define multiple configurations. This allows jobs to run in parallel with different sets of parameters, such as operating systems, tool versions, and other environment settings.

Example of a multi-configuration matrix:

xxxxxxxxxx
29
1
trigger:
2
  branches:
3
    include:
4
     - main
5
jobs:
6
- job: BuildAndTest
7
  displayName: 'Build and Test in Multiple Configurations'
8
  strategy:
9
    matrix:
10
      windows:
11
        os: 'windows-latest'
12
        nodeVersion: '16.x'
13
      linux:
14
        os: 'ubuntu-latest'
15
        nodeVersion: '16.x'
16
      macos:
17
        os: 'macos-latest'
18
        nodeVersion: '16.x'
19
  pool:
20
    vmImage: $(os)
21
  steps:
22
   - task: UseNode@2
23
    inputs:
24
      versionSpec: $(nodeVersion)
25
      addToPath: true
26
   - script: |
27
      npm install
28
      npm test
29
    displayName: 'Install dependencies and run tests'

Explanation of the YAML

• The strategy section defines a matrix with three different configurations (windows, linux, and macos).

• Each configuration has a different OS (windows-latest, ubuntu-latest, macos-latest) and nodeVersion.

• The pool uses vmImage: $(os) to select the appropriate virtual machine image based on the matrix value (os).

• The steps are shared across all matrix configurations (installing Node.js, running tests).

Key points:

• Azure DevOps will run each configuration in parallel, resulting in faster feedback and multi-platform validation.

• You can scale the matrix to test against more configurations or environments.

2. Multi-Agent Pipelines

A multi-agent pipeline allows you to run jobs or tasks across multiple agents concurrently. This is especially useful when your workload is large and you need parallel execution to optimize performance and reduce pipeline execution time.

Azure DevOps uses agent pools to manage agents, and jobs can be distributed across multiple agents in the pool. A multi-agent pipeline can be configured to run jobs simultaneously on different agents, improving throughput.

Use Case for Multi-Agent Pipelines:

• Parallel builds: Run multiple builds or tests in parallel across different agents, especially for large projects with multiple components.

• Optimizing build time: Split your pipeline tasks across multiple agents to reduce overall pipeline time.

• Isolate jobs to specific agents: Certain tasks might require specific agents with unique configurations (e.g., Windows for .NET builds, Linux for Node.js, etc.).

Multi-Agent in YAML Pipelines:

In YAML, you can explicitly define jobs to run on different agents or in parallel. You can specify a job pool and distribute jobs across agents.

Example of a multi-agent pipeline with multiple jobs:

xxxxxxxxxx
26
1
trigger:
2
  branches:
3
    include:
4
     - main
5
jobs:
6
- job: BuildOnWindows
7
  displayName: 'Build on Windows Agent'
8
  pool:
9
    name: 'Windows Agent Pool'
10
  steps:
11
   - script: echo "Building on Windows"
12
    displayName: 'Build on Windows'
13
- job: BuildOnLinux
14
  displayName: 'Build on Linux Agent'
15
  pool:
16
    name: 'Linux Agent Pool'
17
  steps:
18
   - script: echo "Building on Linux"
19
    displayName: 'Build on Linux'
20
- job: BuildOnMac
21
  displayName: 'Build on Mac Agent'
22
  pool:
23
    name: 'Mac Agent Pool'
24
  steps:
25
   - script: echo "Building on Mac"
26
    displayName: 'Build on Mac'

Explanation of the YAML:

• Jobs: This pipeline defines three jobs — one for each platform (Windows, Linux, and Mac).

• Pool: Each job specifies an agent pool using the pool keyword. Each job runs on an agent from its respective pool (Windows Agent Pool, Linux Agent Pool, Mac Agent Pool).

• Parallel execution: The jobs will run in parallel across the different agent pools.

Key points:

• Each job runs on a different agent or a pool of agents, and the jobs run in parallel.

• You can have as many jobs as you need, distributed across different agents or agent pools.

• Parallel execution can significantly speed up the pipeline, especially for large or multi-platform projects.

3. Combining Multi-Configuration and Multi-Agent

You can combine multi-configuration and multi-agent strategies to create powerful pipelines that run across multiple platforms and agents in parallel. This combination is especially useful for complex build and test scenarios where you want to validate your code across different environments, tool versions, and agent configurations.

Example: Multi-Configuration + Multi-Agent

xxxxxxxxxx
47
1
trigger:
2
  branches:
3
    include:
4
     - main
5
jobs:
6
- job: BuildAndTest
7
  displayName: 'Build and Test Across Configurations and Agents'
8
  strategy:
9
    matrix:
10
      windows:
11
        os: 'windows-latest'
12
        nodeVersion: '16.x'
13
      linux:
14
        os: 'ubuntu-latest'
15
        nodeVersion: '16.x'
16
      macos:
17
        os: 'macos-latest'
18
        nodeVersion: '16.x'
19
  pool:
20
    vmImage: $(os)
21
  steps:
22
   - task: UseNode@2
23
    inputs:
24
      versionSpec: $(nodeVersion)
25
      addToPath: true
26
   - script: |
27
      npm install
28
      npm test
29
    displayName: 'Install dependencies and run tests'
30
- job: DeployOnDifferentAgents
31
  displayName: 'Deploy to Different Environments'
32
  dependsOn: BuildAndTest
33
  condition: succeeded()
34
  strategy:
35
    parallel: 3
36
  pool:
37
    name: 'DeployAgentPool'
38
  steps:
39
   - script: |
40
      echo "Deploying to environment 1"
41
    displayName: 'Deploy to Environment 1'
42
   - script: |
43
      echo "Deploying to environment 2"
44
    displayName: 'Deploy to Environment 2'
45
   - script: |
46
      echo "Deploying to environment 3"
47
    displayName: 'Deploy to Environment 3'

Explanation:

• The first job (BuildAndTest) runs across three configurations (Windows, Linux, and macOS) using a matrix strategy.

• The second job (DeployOnDifferentAgents) runs in parallel with three deployment steps, each running on a different agent (specified by the DeployAgentPool).

• This combination tests the application on multiple platforms and performs deployments in parallel on multiple agents.

Best Practices

1. Limit Matrix Combinations:

Having too many configurations in a matrix can significantly increase the time and resources required for your pipeline. Try to balance the number of configurations with pipeline performance.

2. Use Agent Pools Efficiently:

Organize your agents into pools based on similar configurations (e.g., Windows, Linux, macOS) to ensure that jobs run on appropriate agents and avoid unnecessary overhead.

3. Monitor Agent Capacity:

Ensure your agent pools are sufficiently scaled to handle parallel jobs. Azure DevOps has limits on the number of parallel jobs based on your licensing tier, so you may need to adjust your pipeline or scaling accordingly.

4. Conditional Execution:

Use conditions (dependsOn, condition: succeeded()) to control the flow of jobs based on previous job outcomes, which ensures that unnecessary jobs aren’t run if earlier ones fail.

Summary:

Multi-configuration and multi-agent pipelines in Azure DevOps are powerful tools for improving the efficiency and scalability of your CI/CD workflows. By running tests across multiple configurations or distributing jobs across multiple agents, you can significantly reduce build and test times, while ensuring that your code works in different environments and platforms.

Combining these strategies can lead to highly optimized and flexible pipelines.