How to Create Shared Steps in Azure DevOps- OpsNexa!

How to Create Shared Steps in Azure DevOps

In Azure DevOps, shared steps (also known as shared templates or templates in pipelines) are a way to organize and reuse pipeline code across multiple pipelines or stages. This reduces redundancy, makes maintenance easier, and helps maintain consistency across your DevOps workflows.

Azure DevOps allows you to create shared steps that can be used in multiple pipelines through YAML templates or Classic Pipeline tasks. These templates can be used for common tasks like deploying applications, running tests, or setting up environments.

In this guide, we’ll walk through the process of creating and using shared steps (templates) in Azure DevOps.

Why Create Shared Steps?

Creating shared steps or templates in Azure DevOps has several benefits:

Reusability: You can reuse common tasks across multiple pipelines, which makes your code more maintainable.
Consistency: Shared steps ensure consistency in your workflows, as the same tasks are executed in the same way across all pipelines.
Simplification: Instead of duplicating pipeline code in every pipeline, you can centralize it and reference the template wherever necessary.
Maintenance: If you need to update a shared step, you only need to change it in the template file, and it will automatically apply to all pipelines using it.

Steps to Create Shared Steps in Azure DevOps

1. Create a Shared Template (YAML)

Azure DevOps pipelines allow you to define reusable YAML templates for shared steps. Here’s how you can create and use them:

Step 1: Define the Template File

In your Azure DevOps repository, create a folder for your pipeline templates (e.g., azure-pipelines/templates/).

Inside this folder, create a new YAML file for your shared step. For example, let’s create a shared template for deploying a web app.

# azure-pipelines/templates/deploy.yml

parameters:
  - name: environment
    type: string

jobs:
  - job: DeployJob
    displayName: 'Deploy to $(environment)'
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - task: AzureWebApp@1
        inputs:
          appName: '$(webAppName)'
          package: $(Pipeline.Workspace)/drop/*.zip
          deployToSlotOrASE: true
          resourceGroupName: $(resourceGroup)
          slotName: $(environment)

In this template, we are defining a deploy job that can be used for any environment (e.g., dev, staging, production) by passing in the environment parameter.

Step 2: Reference the Template in Your Main Pipeline

After creating the template, you can reference it in any pipeline by using the template keyword. For example, in the main pipeline YAML file, you can reference the shared deploy step:

# azure-pipelines/azure-pipeline.yml

trigger:
  branches:
    include:
      - main

jobs:
  - job: Build
    steps:
      - task: NodeTool@0
        inputs:
          versionSpec: '14.x'
          addToPath: true

  - job: DeployDev
    steps:
      - template: azure-pipelines/templates/deploy.yml
        parameters:
          environment: 'dev'
  
  - job: DeployProd
    steps:
      - template: azure-pipelines/templates/deploy.yml
        parameters:
          environment: 'production'

In this example, the pipeline uses the deploy.yml template for both the DeployDev and DeployProd jobs, passing different parameters for the deployment environment.

Step 3: Commit the Files

Commit the template file and the pipeline YAML file to your repository.

2. Using Shared Steps in Classic Pipelines

If you’re using Classic Pipelines instead of YAML pipelines, you can create shared steps using task groups.

Step 1: Create a Task Group

In the Azure DevOps portal, go to Pipelines > Task groups.
Click on New Task Group and give it a name (e.g., DeployToWebApp).
Add the tasks you want to reuse in this task group (e.g., Azure Web App deployment, copying files, etc.).
Save the task group.

Step 2: Use the Task Group in Pipelines

In any Classic pipeline, click on the + button to add a new task.
Select Task Groups and choose the task group you created.
This will insert the shared steps into your pipeline, and you can use it in multiple pipelines across your organization.

Best Practices for Shared Steps in Azure DevOps

Version Control: Always version your shared YAML templates to avoid breaking changes across pipelines.
Parameterization: Use parameters in your templates to make them flexible and reusable in different contexts.
Documentation: Clearly document what each shared step does and how to use it to ensure that team members can easily understand and adopt it.
Testing: Test your shared templates thoroughly before using them in production pipelines.

Conclusion: Creating Shared Steps in Azure DevOps

Creating shared steps in Azure DevOps helps streamline your DevOps processes, reduce redundancy, and improve the maintainability of your pipelines. Whether you’re using YAML pipelines or Classic pipelines, you can easily create reusable templates or task groups to standardize your CI/CD processes.

By following the steps above, you can effectively use shared steps to automate and manage your pipeline tasks across multiple projects in Azure DevOps.