Coroutines in Azure Functions - EventHub processing - parallel processing of messages

Hi @Wentzler, Charlotte ,

Thanks for reaching out to Microsoft Q&A.

By design, each partition hands you one batch at a time and won’t fetch the next batch until your function completes and checkpoints the current one. There isn’t a setting you can flip in the trigger to overlap batches on the same partition.

Here are some approaches you can consider:

1. In your host.json (for v1 you can still set these under the eventHub section), adjust maxBatchSize and prefetchCount so you pull smaller (or larger) batches in memory, avoiding long‐running single invocations.

{
  "version": "2.0",
  "extensions": {
    "eventHubs": {
      "maxBatchSize": 100,
      "prefetchCount": 300,
      "batchCheckpointFrequency": 1
    }
  }
}

2. The only way to truly parallelize at the trigger level is more partitions. With more partitions, Azure Functions can spin up more hosts and distribute partitions across them. If you can’t change the Event Hub’s partition count, you could add consumer groups plus separate function instances (though you’ll have to handle de‐duplication or idempotency).
3. Python v1 doesn't support dynamic concurrency or the more advanced host.json tuning that later versions do. Migrating to v2 on a Premium plan gives you dynamic concurrency, which can automatically pull multiple batches per partition as your app scales.
4. If you need full control over parallelism, drop the built‐in trigger and write your own async receiver with the azure-eventhub library. Then you can spin up coroutines over messages or batches however you like.

Hope this helps!

If the resolution was helpful, kindly take a moment to click on and click on Yes for was this answer helpful. And, if you have any further query do let us know.

Event Hubs–triggered Functions process events per partition with a defined concurrency model. To increase parallelism and avoid effectively “one batch at a time” behavior, adjust concurrency and batching rather than relying only on coroutines inside a single invocation.

Key options to increase throughput:

1. Enable and tune batching

• Ensure the Event Hubs trigger is configured for batch processing (cardinality = many in function.json for Python) so each invocation receives multiple events.
• In host.json, increase:
  • maxEventBatchSize: maximum events delivered per invocation.
  • prefetchCount: should be ≥ maxEventBatchSize and often a multiple of it so the client caches more messages and can feed invocations faster.
• Batching reduces per-invocation overhead and is recommended for performance.

2. Increase per-instance concurrency

• Azure Functions supports multiple concurrent executions per function app instance. For Event Hubs triggers, concurrency is controlled via host-level settings in host.json (fixed concurrency) or by enabling dynamic concurrency.
• Increasing concurrency allows multiple batches to be processed in parallel on the same instance instead of strictly one after another.

3. Use async code correctly

• For I/O-bound workloads, use fully asynchronous code and avoid blocking calls. Mixing sync and async or blocking on async (sync over async) can cause thread-pool starvation and make the app appear to process only one batch at a time.
• Ensure the function and all downstream I/O (HTTP calls, storage, etc.) are async end-to-end.

4. Scale out and partition-level parallelism

• Maximum parallelism is achieved when there is a one-to-one relationship between Event Hubs partitions and function instances (partition-level parallelism). With only a connection string and fixed partition count, this cannot be changed from the function side, but the Functions platform will still scale out instances (in Consumption/Premium plans) up to the number of partitions.
• If throughput requirements exceed what the current Event Hubs tier/partitions can support, the upstream Event Hubs configuration (tier, partitions) must be adjusted by whoever owns that resource.

5. Python-specific throughput tuning

• For Python (single-threaded runtime), increase FUNCTIONS_WORKER_PROCESS_COUNT (up to 10) to run multiple worker processes per host instance.
• For I/O-bound workloads, tune PYTHON_THREADPOOL_THREAD_COUNT to increase threads per worker, starting from (number of cores + 4) and adjusting based on observed throughput.

These changes allow multiple batches to be processed concurrently across workers, threads, and instances, rather than waiting for one batch to complete before the next is handled.

References:

• Improve throughput performance of Python apps in Azure Functions
• Performance and scale guidance for Event Hubs and Azure Functions
• Improve the performance and reliability of Azure Functions
• Concurrency in Azure Functions
• Reliable event processing with Azure Functions and Event Hubs
• Balance partition load across multiple instances of your application