How do I limit Concurrency of a Durable Azure Function with a Servicebus Queue Trigger?

Question

How do I limit Concurrency of a Durable Azure Function with a Servicebus Queue Trigger?

Benedikt Schmitt 140

Hello,

I have an Azure Function in python that is sending requests to an API. This API has limits on concurrent requests so I want to limit the number of concurrent calls from my Azure Function to four.

I am currently using the following settings:

host.json:
"extensions": {
"serviceBus": {
"maxMessageBatchSize": 1,
"prefetchCount": 0,
"maxConcurrentCalls": 4
}
},
local.settings.json:
"WEBSITE_MAX_DYNAMIC_APPLICATION_SCALE_OUT": 1,
"FUNCTIONS_WORKER_PROCESS_COUNT": 1

However every time I load messages into my Service Bus the Function App pulls more than 4 messages and also creates API calls for every message it pulls.

My preferred behaviour would be that the Function App only ever has four instances running and does not pull more messages until one of these four instances stops running.

How would I achieve this?

RithwikBojja 3,055 Reputation points Microsoft External Staff Moderator

2025-04-01T07:24:56.3366667+00:00
To set the concurrency for Durable functions you can use:

{ "extensions": { "durableTask": { "maxConcurrentActivityFunctions": 4, "maxConcurrentOrchestratorFunctions": 4 } } }
Benedikt Schmitt 140 Reputation points

2025-04-03T06:14:12.9366667+00:00

I have tried this but it doesn't work correctly. If you have an Orchestrator with several activities it can break things and an orchestrator does not count as running every time it is waiting for an activity to finish.

So even if you set maxConcurrentOrchestratorFunctions to 1 you can still have several processes running because all the orchestrators are waiting for an activity.
RithwikBojja 3,055 Reputation points Microsoft External Staff Moderator

2025-04-03T09:51:16.3+00:00

Yes, you are right @Benedikt, you can just set it to 1

1 answer

Your answer

RithwikBojja 3,055 Reputation points Microsoft External Staff Moderator

2025-04-01T07:24:56.3366667+00:00

To set the concurrency for Durable functions you can use:

{ "extensions": { "durableTask": { "maxConcurrentActivityFunctions": 4, "maxConcurrentOrchestratorFunctions": 4 } } }
Benedikt Schmitt 140 Reputation points

2025-04-03T06:14:12.9366667+00:00

I have tried this but it doesn't work correctly. If you have an Orchestrator with several activities it can break things and an orchestrator does not count as running every time it is waiting for an activity to finish.

So even if you set maxConcurrentOrchestratorFunctions to 1 you can still have several processes running because all the orchestrators are waiting for an activity.
RithwikBojja 3,055 Reputation points Microsoft External Staff Moderator

2025-04-03T09:51:16.3+00:00

Yes, you are right @Benedikt, you can just set it to 1

Answer 1

Sai Prabhu Naveen Parimi 2,265 Microsoft External Staff Moderator

@Benedikt Schmitt

Based on your current setup, it looks like your Azure Durable Function is processing more than four concurrent messages despite setting maxConcurrentCalls to 4. To ensure strict concurrency control, here are a few key adjustments:

Limit Function Scaling to a Single Instance

You have already set WEBSITE_MAX_DYNAMIC_APPLICATION_SCALE_OUT = 1, which is correct. However, also check your Azure Portal → Function App → Scale Out settings and set Maximum Burst Limit = 1 to fully enforce single-instance scaling. More details on Azure Function scaling.

Adjust Host Configuration for Concurrency Control

Modify your host.json file to enforce concurrency limits:

{
  "version": "2.0",
  "extensions": {
    "serviceBus": {
      "maxMessageBatchSize": 1,
      "prefetchCount": 0,
      "maxConcurrentCalls": 4,
      "autoCompleteMessages": false
    },
    "durableTask": {
      "maxConcurrentActivityFunctions": 4,
      "maxConcurrentOrchestratorFunctions": 1
    }
  },
  "functionTimeout": "00:10:00"
}

maxConcurrentCalls: 4 ensures only four messages are processed at a time. Service Bus trigger settings.

maxConcurrentActivityFunctions: 4 restricts Durable Function activities to four concurrent executions.

maxConcurrentOrchestratorFunctions: 1 prevents multiple orchestrator instances from running in parallel.

autoCompleteMessages: false ensures messages are only marked complete after processing.

Limit API Calls to 4 Concurrent Requests

To enforce this at the function level, use a semaphore inside your activity function:

import asyncio
import requests

semaphore = asyncio.Semaphore(4)  # Limit concurrent API calls to 4

async def call_api(payload):
    async with semaphore:
        response = requests.post("https://example.com/api", json=payload)
        return response.status_code

This ensures that even if multiple messages are received, only four API calls are made at any given time. Concurrency in Azure Functions.

Handling Additional Messages

Any messages beyond the four currently being processed will remain in the Service Bus queue and be picked up only when one of the ongoing executions completes. This ensures a controlled and sequential processing flow without exceeding the API’s concurrency limit.

Let me know if you need any further clarification.

Benedikt Schmitt 140 Reputation points

2025-03-26T10:06:09.7633333+00:00

Hello @Sai Prabhu Naveen Parimi ,

I have tried your suggestions and it almost works.

The function App only starts four API calls at a time. But the messages exceeding these four do not remain in the Service Bus. They get pulled and stored in the Function App and are then worked on when one of the four active runs is finished.

I also have an additional question that came up in the last few days:

If I theoretically have a durable function with a Service Bus Topic Trigger and several Orchestrator functions that each call one activity, is it possible to have individual concurrency limit per Orchestrator-function?

Say I have my limited Orchestrator that can only have four activities running at once but a second Orchestrator that starts activities that start API calls against an API with a limit of six calls. Can I implement a limit of four to one orchestrator and a limit of six to another?
Sai Prabhu Naveen Parimi 2,265 Reputation points Microsoft External Staff Moderator

2025-03-27T01:46:02.83+00:00
Benedikt Schmitt

Thanks for the update! It’s great to hear that the function is correctly limiting API calls to four at a time. However, regarding the remaining messages not staying in Service Bus but instead being preloaded into the Function App—this is expected behavior due to the internal message prefetching mechanism in Azure Functions

Setting Individual Concurrency Limits for Orchestrators

Yes, you can enforce different concurrency limits per Orchestrator function. Modify your host.json as follows:

{ "version": "2.0", "extensions": { "durableTask": { "maxConcurrentActivityFunctions": 10, "maxConcurrentOrchestratorFunctions": 10, "orchestrationService": { "instanceConcurrency": { "LimitedOrchestrator": 4, "HighThroughputOrchestrator": 6 } } } } }

LimitedOrchestrator → Maximum 4 concurrent activities.

HighThroughputOrchestrator → Maximum 6 concurrent activities.

This ensures each orchestrator has its own concurrency limit while running in the same Function App.

Please do not forget to click "Accept the answer” and Yes wherever the information provided helps you, this can be beneficial to other community members.
Benedikt Schmitt 140 Reputation points

2025-03-27T09:03:36.77+00:00

When I try doing it like you suggested it tells me that the property "orchestrationService" is not allowed. So this is not a setting that I can write into my host.json
Sai Prabhu Naveen Parimi 2,265 Reputation points Microsoft External Staff Moderator

2025-03-27T09:35:39.5533333+00:00
Benedikt Schmitt

Regarding your question about setting different concurrency limits for different orchestrators, here are two possible approaches:

Option 1: Use Separate Service Bus Queues

If you can route messages to different queues, you can set different concurrency limits at the queue level. This ensures that each orchestrator processes messages at its respective limit without interference.

Configuration in host.json

{ "extensions": { "serviceBus": { "queues": { "limited-orchestrator-queue": { "maxConcurrentCalls": 4 }, "high-throughput-orchestrator-queue": { "maxConcurrentCalls": 6 } } } } }

Messages for LimitedOrchestrator will be processed with a max concurrency of 4.

Messages for HighThroughputOrchestrator will be processed with a max concurrency of 6.

This approach ensures a clear separation of workloads, making it the most scalable solution.

Option 2: Use Semaphores to Control Concurrency in Code

If using separate queues isn’t possible, you can enforce concurrency limits inside the activity functions using semaphores.

Python Example

import asyncio import requests # Define separate semaphores for different orchestrators limited_orchestrator_semaphore = asyncio.Semaphore(4) # Limit to 4 concurrent executions high_throughput_orchestrator_semaphore = asyncio.Semaphore(6) # Limit to 6 concurrent executions async def limited_orchestrator_activity(payload): async with limited_orchestrator_semaphore: response = requests.post("https://example.com/api", json=payload) return response.status_code async def high_throughput_orchestrator_activity(payload): async with high_throughput_orchestrator_semaphore: response = requests.post("https://example.com/api", json=payload) return response.status_code

LimitedOrchestrator activities will not exceed 4 concurrent executions.

HighThroughputOrchestrator activities will not exceed 6 concurrent executions.

This approach allows you to enforce concurrency limits while using a single queue.

If multiple queues are an option, Option 1 is the recommended approach for better separation.

If a single queue must be used, Option 2 will help manage concurrency at the function level.
Benedikt Schmitt 140 Reputation points

2025-03-27T14:21:25.1133333+00:00

Again, the host.json does not have the property "queues" in the serviceBus options.

I will try your second suggestions and get back to you once I have done so.
Benedikt Schmitt 140 Reputation points

2025-03-31T13:24:31.1266667+00:00
I have tried the solution with Semaphore but I encountered a problem. There are edge cases where several calls wait for the completion of one API call and when one slot frees up, several of them get started.

Also with the settings you wrote first:

{ "version": "2.0", "extensions": { "serviceBus": { "maxMessageBatchSize": 1, "prefetchCount": 0, "maxConcurrentCalls": 4, "autoCompleteMessages": false }, "durableTask": { "maxConcurrentActivityFunctions": 4, "maxConcurrentOrchestratorFunctions": 1 } }, "functionTimeout": "00:10:00" }

There are cases when more than 4 jobs get started. If my function App starts and I sent 6 messages to my service bus input in a loop, all 6 of them get started.

Why is there no simple way of limiting this?

Share via

How do I limit Concurrency of a Durable Azure Function with a Servicebus Queue Trigger?

1 answer

Your answer