Azure ServiceBus (Quotas and limits) with Azure functions

Azure Service Bus is a fully managed enterprise integration message broker. It provides a reliable and secure platform for asynchronous transfer of data and state across services and devices. Service Bus allows you to send and receive messages between services and applications, even when they are offline.

Service Bus has several features that enable you to scale and manage the flow of messages through your application. These include:

• Queues: A Service Bus queue is a FIFO (first-in, first-out) data structure that stores and retrieves messages. A queue can be used to store and transmit any type of data, and it can support a virtually unlimited number of concurrent readers and writers.
• Topics and subscriptions: Service Bus topics and subscriptions provide a one-to-many form of communication over the same queue. You can use topics to broadcast messages to multiple subscribers, and each subscriber can receive a copy of the message using a subscription.
• Dead-lettering: Service Bus has a dead-letter queue for messages that cannot be delivered or processed. This feature can be used to store and analyze messages that have failed delivery or processing, so you can troubleshoot and resolve any issues.
• Quotas and limits: Service Bus has limits on the number of entities (queues, topics, subscriptions, etc.) that can be created in a namespace, as well as limits on the rate of message transfer and the size of messages. These limits are in place to ensure the stability and performance of the Service Bus service.
• Premium Services: Service Bus Premium offers additional features and higher scale and performance compared to the standard offering. Premium features include increased throughput, active-active geo-disaster recovery, and more.

Updating ServiceBus Queue size using Azure CLI

When creating some resources in Azure, mostly we use default settings – If you need to increase the size of the Azure Servicebus queue size use the below CLI command

az servicebus queue update --resource-group myresourcegroup --namespace-name mynamespace --name myqueuename --max-size 2048


az servicebus queue create --name
                           --namespace-name
                           --resource-group
                           [--auto-delete-on-idle]
                           [--default-message-time-to-live]
                           [--duplicate-detection-history-time-window]
                           [--enable-batched-operations {false, true}]
                           [--enable-dead-lettering-on-message-expiration {false, true}]
                           [--enable-duplicate-detection {false, true}]
                           [--enable-express {false, true}]
                           [--enable-partitioning {false, true}]
                           [--enable-session {false, true}]
                           [--forward-dead-lettered-messages-to]
                           [--forward-to]
                           [--lock-duration]
                           [--max-delivery-count]
                           [--max-message-size]
                           [--max-size {1024, 10240, 2048, 20480, 3072, 4096, 40960, 5120, 81920}]
                           [--status {Active, Disabled, ReceiveDisabled, SendDisabled}]

Azure Functions with ServiceBus

Azure Functions is a serverless compute service that enables you to run code on-demand without having to explicitly provision or manage infrastructure. You can use Azure Functions to run a script or piece of code in response to a specific trigger, such as an HTTP request, a timer, or the arrival of a message in a Service Bus queue.

Here is a Python Azure Functions code that demonstrates how to send and receive messages from a Service Bus queue:

# Send message to Service Bus queue
import azure.functions as func
import azure.servicebus as servicebus

def main(req: func.HttpRequest) -> func.HttpResponse:
    queue_name = "myqueue"
    servicebus_connection_string = "your_connection_string"

    queue_client = servicebus.QueueClient.from_connection_string(
        servicebus_connection_string, queue_name)
    
    message = servicebus.Message("Hello, World!")
    queue_client.send(message)
    
    return func.HttpResponse(f"Sent message to queue: {message.body}")
    
    
# Receive message from Service Bus queue
import azure.functions as func
import azure.servicebus as servicebus

def main(msg: servicebus.ServiceBusMessage) -> None:
    print(f"Received message: {msg.body}")

You can use Service Bus to build various types of messaging scenarios, such as:

• One-way messaging: A sender sends a message to a receiver, but does not require a response.
• Request/response: A sender sends a message to a receiver and waits for a response.
• Publish/subscribe: A sender broadcasts a message to multiple receivers.

Service Bus supports a variety of messaging patterns, including point-to-point, publish/subscribe, and request/response. It also provides a range of reliable messaging options, such as transactions, message deferral, and message sessions.

Service Bus is commonly used to enable communication and coordination between microservices, distributed systems, and serverless applications. It can also be used to connect on-premises applications to cloud-based systems, or to enable hybrid scenarios where some components are in the cloud and others are on-premises.

Service Bus is available in two tiers: standard and premium. Standard Service Bus is suitable for most common scenarios, and premium Service Bus offers additional features and higher scale and performance.