How To Make An Azure DevOps Pipeline Wait For An External Process To Complete?

Introduction

Azure DevOps Pipelines provide a powerful way to automate the build, test, and deployment of software projects. However, sometimes you may need to wait for an external process to complete before proceeding with the pipeline. This can be a challenge, especially when working with proprietary deployment tools that don't provide a straightforward way to integrate with Azure DevOps.

In this article, we'll explore how to make an Azure DevOps pipeline wait for an external process to complete. We'll use a C# solution as an example, but the principles can be applied to other languages and deployment tools.

Prerequisites

Before we dive into the solution, make sure you have the following:

• Azure DevOps Server deployed on-premises
• A C# solution that you want to build, package, and deploy
• A proprietary deployment tool that you want to integrate with Azure DevOps
• Azure DevOps Pipelines installed and configured on your server

Step 1: Pull, Build, and Package the C# Solution

First, let's create a pipeline that pulls, builds, and packages the C# solution. We'll use the Azure Pipelines YAML file format to define the pipeline.

trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
buildConfiguration: 'Release'
stages:

build
package

build:
stage: build
jobs:

job: build
displayName: 'Build'
steps:

task: DotNetCoreCLI@2
displayName: 'Restore NuGet Packages'
inputs:
command: 'restore'
projects: '**/*.csproj'
task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'
task: DotNetCoreCLI@2
displayName: 'Pack'
inputs:
command: 'pack'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'



package:
stage: package
jobs:

job: package
displayName: 'Package'
steps:

task: CopyFiles@2
displayName: 'Copy Files'
inputs:
contents: '**/*.nupkg'
targetFolder: '$(System.ArtifactsDirectory)'

This pipeline has two stages: build and package. The build stage restores NuGet packages, builds the solution, and packs the resulting artifacts. The package stage copies the packaged artifacts to the artifacts directory.

Step 2: Call Out to the Proprietary Deployment Tool

Next, let's add a step to the pipeline that calls out to the proprietary deployment tool. We'll use a PowerShell script to make the API call.

deploy:
  stage: deploy
  jobs:
  - job: deploy
    displayName: 'Deploy'
    steps:
    - task: PowerShell@2
      displayName: 'Deploy'
      inputs:
        targetType: 'filePath'
        filePath: 'deploy.ps1'
        arguments: '-ArtifactPath $(System.ArtifactsDirectory)'

This step uses the PowerShell task to a PowerShell script called deploy.ps1. The script takes the artifact path as an argument and makes the API call to the proprietary deployment tool.

Step 3: Wait for the External Process to Complete

Now, let's add a step to the pipeline that waits for the external process to complete. We'll use a PowerShell script to poll the API endpoint until the deployment is complete.

wait:
  stage: wait
  jobs:
  - job: wait
    displayName: 'Wait'
    steps:
    - task: PowerShell@2
      displayName: 'Wait'
      inputs:
        targetType: 'filePath'
        filePath: 'wait.ps1'
        arguments: '-ApiEndpoint $(ApiEndpoint) -DeploymentId $(DeploymentId)'

This step uses the PowerShell task to execute a PowerShell script called wait.ps1. The script takes the API endpoint and deployment ID as arguments and polls the API endpoint until the deployment is complete.

Step 4: Continue with the Pipeline

Finally, let's add a step to the pipeline that continues with the pipeline once the external process is complete.

continue:
  stage: continue
  jobs:
  - job: continue
    displayName: 'Continue'
    steps:
    - task: PowerShell@2
      displayName: 'Continue'
      inputs:
        targetType: 'filePath'
        filePath: 'continue.ps1'
        arguments: '-ArtifactPath $(System.ArtifactsDirectory)'

This step uses the PowerShell task to execute a PowerShell script called continue.ps1. The script takes the artifact path as an argument and continues with the pipeline.

Putting it All Together

Here's the complete pipeline YAML file:

trigger:
- main
pool:
vmImage: 'ubuntu-latest'
variables:
buildConfiguration: 'Release'
stages:

build
package
deploy
wait
continue

build:
stage: build
jobs:

job: build
displayName: 'Build'
steps:

task: DotNetCoreCLI@2
displayName: 'Restore NuGet Packages'
inputs:
command: 'restore'
projects: '**/*.csproj'
task: DotNetCoreCLI@2
displayName: 'Build'
inputs:
command: 'build'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'
task: DotNetCoreCLI@2
displayName: 'Pack'
inputs:
command: 'pack'
projects: '**/*.csproj'
arguments: '--configuration $(buildConfiguration)'



package:
stage: package
jobs:

job: package
displayName: 'Package'
steps:

task: CopyFiles@2
displayName: 'Copy Files'
inputs:
contents: '**/*.nupkg'
targetFolder: '$(System.ArtifactsDirectory)'



deploy:
stage: deploy
jobs:

job: deploy
displayName: 'Deploy'
steps:

task: PowerShell@2
displayName: 'Deploy'
inputs:
targetType: 'filePath'
filePath: 'deploy.ps1'
arguments: '-ArtifactPath $(System.ArtifactsDirectory)'



wait:
stage: wait
jobs:
-: wait
displayName: 'Wait'
steps:
- task: PowerShell@2
displayName: 'Wait'
inputs:
targetType: 'filePath'
filePath: 'wait.ps1'
arguments: '-ApiEndpoint $(ApiEndpoint) -DeploymentId $(DeploymentId)'
continue:
stage: continue
jobs:

job: continue
displayName: 'Continue'
steps:

task: PowerShell@2
displayName: 'Continue'
inputs:
targetType: 'filePath'
filePath: 'continue.ps1'
arguments: '-ArtifactPath $(System.ArtifactsDirectory)'

This pipeline has five stages: build, package, deploy, wait, and continue. The build stage restores NuGet packages, builds the solution, and packs the resulting artifacts. The package stage copies the packaged artifacts to the artifacts directory. The deploy stage calls out to the proprietary deployment tool. The wait stage waits for the external process to complete. The continue stage continues with the pipeline once the external process is complete.

Conclusion

Q: What is the purpose of waiting for an external process to complete in an Azure DevOps pipeline?

A: The purpose of waiting for an external process to complete in an Azure DevOps pipeline is to ensure that the pipeline waits for the external process to finish before proceeding with the next steps. This is particularly useful when working with proprietary deployment tools that don't provide a straightforward way to integrate with Azure DevOps.

Q: How do I wait for an external process to complete in an Azure DevOps pipeline?

A: To wait for an external process to complete in an Azure DevOps pipeline, you can use a PowerShell script to poll the API endpoint until the deployment is complete. You can use the wait.ps1 script provided in the example pipeline YAML file.

Q: What is the wait.ps1 script and how does it work?

A: The wait.ps1 script is a PowerShell script that takes the API endpoint and deployment ID as arguments and polls the API endpoint until the deployment is complete. The script uses the Invoke-RestMethod cmdlet to make a GET request to the API endpoint and checks the response to determine if the deployment is complete.

Q: How do I integrate the wait.ps1 script with my Azure DevOps pipeline?

A: To integrate the wait.ps1 script with your Azure DevOps pipeline, you can add a step to the pipeline that runs the wait.ps1 script. You can use the PowerShell@2 task to run the script and pass the API endpoint and deployment ID as arguments.

Q: What are the benefits of using the wait.ps1 script in an Azure DevOps pipeline?

A: The benefits of using the wait.ps1 script in an Azure DevOps pipeline include:

• Ensuring that the pipeline waits for the external process to complete before proceeding with the next steps
• Providing a flexible and reliable way to integrate with proprietary deployment tools
• Allowing for easy customization of the polling interval and API endpoint

Q: Can I use the wait.ps1 script with other languages and deployment tools?

A: Yes, you can use the wait.ps1 script with other languages and deployment tools. The script is written in PowerShell and can be easily modified to work with other languages and deployment tools.

Q: How do I troubleshoot issues with the wait.ps1 script?

A: To troubleshoot issues with the wait.ps1 script, you can use the following steps:

• Check the API endpoint and deployment ID to ensure that they are correct
• Verify that the wait.ps1 script is running correctly and making the GET request to the API endpoint
• Check the response from the API endpoint to determine if the deployment is complete

Q: Can I use the wait.ps1 script in a multi-stage pipeline?

A: Yes, you can use the wait.ps1 script in a multi-stage pipeline. The script can be run in a separate stage as part of a larger pipeline.

Q: How do I update the wait.ps1 script to work with a new API endpoint or deployment tool?

A: To update the wait.ps1 script to work with a new API endpoint or deployment tool, you can modify the script to use the new API endpoint or deployment tool. You can also add new parameters to the script to allow for easy customization.

Q: Can I use the wait.ps1 script with Azure DevOps Server on-premises?

A: Yes, you can use the wait.ps1 script with Azure DevOps Server on-premises. The script can be run on the on-premises server and can be used to integrate with proprietary deployment tools.

Q: How do I secure the wait.ps1 script and prevent unauthorized access?

A: To secure the wait.ps1 script and prevent unauthorized access, you can use the following steps:

• Use a secure API endpoint and deployment tool
• Use authentication and authorization to restrict access to the script
• Use encryption to protect sensitive data
• Use a secure storage mechanism to store sensitive data

Q: Can I use the wait.ps1 script with other Azure DevOps services?

A: Yes, you can use the wait.ps1 script with other Azure DevOps services, such as Azure Pipelines, Azure Repos, and Azure Test Plans. The script can be run in a separate stage or as part of a larger pipeline.