I am have 2 build agents and 8 pipelines in azure devops. If a run starts for pipeline A, and another run is triggered for the same pipeline Azure Devops will start a second run on the other agent without waiting for the first to finish.
How do I make Azure Devops wait until the first run is finished before starting the second one?
Edit: using yaml pipelines rather than old build/release pipelines.
Looks like you can do this by using the trigger options in the yaml file:
trigger:
batch: true
Do note that this value is false by default (so when left empty), but it might only be when a trigger has been defined?
Preventing concurrent runs may be done by setting up an environment with an Exclusive Lock check. That allows working with Microsoft-hosted agents, not just self-hosted agents. It also does not require pipelines to be assigned to specific agents the way Demands do.
In Pipelines/Environments define an environment, say "my_environment".
To the environment add a check of type "Exclusive Lock".
In your YAML, reference environment "my_environment" using this form:
lockBehavior: sequential
stages:
- stage: Stage
jobs:
- deployment: Job
environment: my_environment
strategy:
runOnce:
deploy:
steps:
...
This will force multiple queues of the same pipeline to run sequentially in queue order. Different pipelines must use different environments, otherwise they will block each other.
More information here: https://learn.microsoft.com/en-us/azure/devops/release-notes/2021/sprint-190-update#azure-pipelines-1
I think you can use adding demands to the pool on the agent job of pipelines, so that it will run with one same agent because of the same specified condition.
First, add one Capability in the agent.
And then, in your YAML, add demands to the pool.
pool:
name: {agent pool name}
demands: Limit -equals DisAbleParallel
The format of it is demands:{CapabilityName} -equals {CapabilityValue}.
While you specified the agent demands, the pipeline will just run with this agent. While A is running, the second one will not run at same time because the previous is running, the agent is being using. So that, the second one will run until previous ends.
I was able to do this (prevent a stage from being executed by multiple builds at the same time) by doing the following:
build_concurrency_lock. You can add it via Pipelines -> Library -> Variable Groups. Be sure to add an "Exclusive Lock" to the resource.
azure-pipelines.yml.stages:
# Code Pipeline
- stage: BuildStage
displayName: "Build"
# These next three lines make builds run in serial. We need to do this since we use a shared "builds" environment in azure - see https://stackoverflow.com/a/73694320/1072030, https://learn.microsoft.com/en-us/azure/devops/pipelines/library/variable-groups?view=azure-devops&tabs=yaml, and https://learn.microsoft.com/en-us/azure/devops/release-notes/2021/sprint-190-update#support-for-sequential-deployments-rather-than-latest-only-when-using-exclusive-lock-checks
lockBehavior: sequential
variables:
- group: build_concurrency_lock # relies on a "build_concurrency_lock" Library variable group existing and having an "Exclusive Lock" "Approvals and checks" setup.
The linked-to PowerShell Task works well. I personally set the sleep polling to 60 seconds but other than that this works with one main exception. It won't work if they're queued simultaneously or within a similar starting time. If more than one build is queued before this task completes when no jobs are actually building yet, it will just get stuck until cancelled or times out.
That means if you can wait for a minute or two before building, this will work.
