This article provides step-by-step instructions for a simple scenario of sending messages to a Service Bus queue and receiving them. You can find prebuilt JavaScript and TypeScript samples for Azure Service Bus in the Azure SDK for Python repository on GitHub.
In this quickstart, you:
Create a Service Bus namespace, using the Azure portal.
Create a Service Bus queue, using the Azure portal.
Write Python code to use the azure-servicebus package to:
If you're new to the service, see Service Bus overview before you begin.
PrerequisitesAn Azure subscription. To complete this quickstart, you need an Azure account. You can activate your Monthly Azure credits for Visual Studio subscribers or sign-up for a free account.
Python 3.8 or higher.
To use this quickstart with your own Azure account:
az login.Note the following values, which you use in the code:
This quickstart works with samples that you can copy and run using Python. For instructions on how to create a Python application, see Quickstart: Deploy a Python web app to Azure App Service. For more information about installing packages used in this quickstart, see How to install Azure library packages for Python.
Create a namespace in the Azure portalTo begin using Service Bus messaging entities in Azure, create a namespace with a name that is unique across Azure. A namespace provides a scoping container for Service Bus resources, such as queues and topics, in your application.
To create a namespace:
Sign in to the Azure portal.
Select the flyout menu from the top left and navigate to the All services page.
On the left navigation bar, select Integration.
Scroll down to Messaging services > Service Bus and select Create.
In the Basics tab of the Create namespace page, follow these steps:
For Subscription, choose an Azure subscription in which to create the namespace.
For Resource group, choose an existing resource group, or create a new one.
Enter a Namespace name that meets the following naming conventions:
-.-sb or -mgmt.For Location, choose the region to host your namespace.
For Pricing tier, select the pricing tier (Basic, Standard, or Premium) for the namespace. For this quickstart, select Standard.
If you select Premium tier, you can enable geo-replication for the namespace. The geo-replication feature ensures that the metadata and data of a namespace are continuously replicated from a primary region to one or more secondary regions.
Important
If you want to use topics and subscriptions, choose either Standard or Premium. Topics and subscriptions aren't supported in the Basic pricing tier.
If you selected the Premium pricing tier, specify the number of messaging units. The premium tier provides resource isolation at the CPU and memory level so that each workload runs in isolation. This resource container is called a messaging unit. A premium namespace has at least one messaging unit. You can select 1, 2, 4, 8 or 16 messaging units for each Service Bus Premium namespace. For more information, see Service Bus premium messaging tier.
Select Review + create at the bottom of the page.
On the Review + create page, review settings, and select Create.
After the deployment of the resource is successful, select Go to resource on the deployment page.
You see the home page for your service bus namespace.
On the Service Bus Namespace page, expand Entities on the navigational menu to the left, and select Queues.
On the Queues page, on the toolbar, select + Queue.
Enter a name for the queue. Leave the other values with their defaults.
Select Create.
This article shows you two ways of connecting to Azure Service Bus: passwordless and connection string.
The first option shows you how to use your security principal in Microsoft Entra ID and role-based access control (RBAC) to connect to a Service Bus namespace. You don't need to worry about having a hard-coded connection string in your code, in a configuration file, or in a secure storage like Azure Key Vault.
The second option shows you how to use a connection string to connect to a Service Bus namespace. If you're new to Azure, you might find the connection string option easier to follow. We recommend using the passwordless option in real-world applications and production environments. For more information, see Service Bus authentication and authorization. To read more about passwordless authentication, see Authenticate .NET apps.
Assign roles to your Microsoft Entra userWhen you develop locally, make sure that the user account that connects to Azure Service Bus has the correct permissions. You need the Azure Service Bus Data Owner role in order to send and receive messages. To assign yourself this role, you need the User Access Administrator role, or another role that includes the Microsoft.Authorization/roleAssignments/write action.
You can assign Azure RBAC roles to a user using the Azure portal, Azure CLI, or Azure PowerShell. To learn more the available scopes for role assignments, see Understand scope for Azure RBAC.
The following example assigns the Azure Service Bus Data Owner role to your user account, which provides full access to Azure Service Bus resources. In a real scenario, follow the principle of least privilege to give users only the minimum permissions needed for a more secure production environment.
For Azure Service Bus, the management of namespaces and all related resources through the Azure portal and the Azure resource management API is already protected using the Azure RBAC model. Azure provides the following Azure built-in roles for authorizing access to a Service Bus namespace:
send access to Service Bus namespace and its entities.receive access to Service Bus namespace and its entities.If you want to create a custom role, see Rights required for Service Bus operations.
Add Microsoft Entra user to Azure Service Bus Owner roleAdd your Microsoft Entra user name to the Azure Service Bus Data Owner role at the Service Bus namespace level. This configuration allows an app that runs in the context of your user account to send messages to a queue or a topic. It can receive messages from a queue or a topic's subscription.
Important
In most cases, it takes a minute or two for the role assignment to propagate in Azure. In rare cases, it might take up to eight minutes. If you receive authentication errors when you first run your code, wait a few moments and try again.
If you don't have the Service Bus Namespace page open in the Azure portal, locate your Service Bus namespace using the main search bar or left navigation.
On the Overview page, select Access control (IAM) from the left-hand menu.
On the Access control (IAM) page, select the Role assignments tab.
Select + Add from the top menu and then Add role assignment.
Use the search box to filter the results to the desired role. For this example, search for Azure Service Bus Data Owner and select the matching result. Then choose Next.
Under Assign access to, select User, group, or service principal, and then choose + Select members.
In the dialog, search for your Microsoft Entra username (usually your user@domain email address) and then choose Select at the bottom of the dialog.
Select Review + assign to go to the final page, and then Review + assign again to complete the process.
Creating a new namespace automatically generates an initial Shared Access Signature (SAS) policy with primary and secondary keys. It creates primary and secondary connection strings that each grant full control over all aspects of the namespace. For more information about how to create rules with more constrained rights for regular senders and receivers, see Service Bus authentication and authorization.
A client can use the connection string to connect to the Service Bus namespace. To copy the primary connection string for your namespace, follow these steps:
On the Service Bus Namespace page, in the left menu, expand Settings, then select Shared access policies.
On the Shared access policies page, select RootManageSharedAccessKey.
In the Policy: RootManageSharedAccessKey window, select the copy button next to Primary Connection String, to copy the connection string to your clipboard for later use. Paste this value into Notepad or some other temporary location.
You can use this page to copy primary key, secondary key, primary connection string, and secondary connection string.
To install the required Python packages for this Service Bus quickstart, open a Command Prompt window that has Python in its path.
Change the directory to the folder where you want to have your samples.
Install the following packages:
pip install azure-servicebus
pip install azure-identity
pip install aiohttp
To install the required Python packages for this Service Bus quickstart, open a Command Prompt window that has Python in its path.
Change the directory to the folder where you want to have your samples.
Install the following package:
pip install azure-servicebus
The following sample code shows you how to send a message to a queue. Open a text editor, such as Visual Studio Code, create a file send.py, and add the following code into it.
Add import statements.
import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
from azure.identity.aio import DefaultAzureCredential
Add constants and define a credential.
FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
QUEUE_NAME = "QUEUE_NAME"
credential = DefaultAzureCredential()
Important
FULLY_QUALIFIED_NAMESPACE with the fully qualified namespace for your Service Bus namespace.QUEUE_NAME with the name of the queue.Add a method to send a single message.
async def send_single_message(sender):
# Create a Service Bus message and send it to the queue
message = ServiceBusMessage("Single Message")
await sender.send_messages(message)
print("Sent a single message")
The sender is an object that acts as a client for the queue you created. You create it later and send as an argument to this function.
Add a method to send a list of messages.
async def send_a_list_of_messages(sender):
# Create a list of messages and send it to the queue
messages = [ServiceBusMessage("Message in list") for _ in range(5)]
await sender.send_messages(messages)
print("Sent a list of 5 messages")
Add a method to send a batch of messages.
async def send_batch_message(sender):
# Create a batch of messages
async with sender:
batch_message = await sender.create_message_batch()
for _ in range(10):
try:
# Add a message to the batch
batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
except ValueError:
# ServiceBusMessageBatch object reaches max_size.
# New ServiceBusMessageBatch object can be created here to send more data.
break
# Send the batch of messages to the queue
await sender.send_messages(batch_message)
print("Sent a batch of 10 messages")
Create a Service Bus client and then a queue sender object to send messages.
async def run():
# create a Service Bus client using the credential
async with ServiceBusClient(
fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
credential=credential,
logging_enable=True) as servicebus_client:
# get a Queue Sender object to send messages to the queue
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
async with sender:
# send one message
await send_single_message(sender)
# send a list of messages
await send_a_list_of_messages(sender)
# send a batch of messages
await send_batch_message(sender)
# Close credential when no longer needed.
await credential.close()
Call the run method and print a message.
asyncio.run(run())
print("Done sending messages")
print("-----------------------")
Add import statements.
import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
Add constants.
NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STR"
QUEUE_NAME = "QUEUE_NAME"
Important
NAMESPACE_CONNECTION_STR with the connection string for your Service Bus namespace.QUEUE_NAME with the name of the queue.Add a method to send a single message.
async def send_single_message(sender):
# Create a Service Bus message and send it to the queue
message = ServiceBusMessage("Single Message")
await sender.send_messages(message)
print("Sent a single message")
The sender is an object that acts as a client for the queue you created. You create it later and send as an argument to this function.
Add a method to send a list of messages.
async def send_a_list_of_messages(sender):
# Create a list of messages and send it to the queue
messages = [ServiceBusMessage("Message in list") for _ in range(5)]
await sender.send_messages(messages)
print("Sent a list of 5 messages")
Add a method to send a batch of messages.
async def send_batch_message(sender):
# Create a batch of messages
async with sender:
batch_message = await sender.create_message_batch()
for _ in range(10):
try:
# Add a message to the batch
batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
except ValueError:
# ServiceBusMessageBatch object reaches max_size.
# New ServiceBusMessageBatch object can be created here to send more data.
break
# Send the batch of messages to the queue
await sender.send_messages(batch_message)
print("Sent a batch of 10 messages")
Create a Service Bus client and then a queue sender object to send messages.
async def run():
# create a Service Bus client using the connection string
async with ServiceBusClient.from_connection_string(
conn_str=NAMESPACE_CONNECTION_STR,
logging_enable=True) as servicebus_client:
# Get a Queue Sender object to send messages to the queue
sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
async with sender:
# Send one message
await send_single_message(sender)
# Send a list of messages
await send_a_list_of_messages(sender)
# Send a batch of messages
await send_batch_message(sender)
Call the run method and print a message.
asyncio.run(run())
print("Done sending messages")
print("-----------------------")
The following sample code shows you how to receive messages from a queue. The code shown receives new messages until it doesn't receive any new messages for 5 (max_wait_time) seconds.
Open a text editor, such as Visual Studio Code, create a file recv.py, and add the following code to it.
Similar to the send.py sample, add import statements. Replace the constants with your own values and define a credential.
import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.identity.aio import DefaultAzureCredential
FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
QUEUE_NAME = "QUEUE_NAME"
credential = DefaultAzureCredential()
Create a Service Bus client and then a queue receiver object to receive messages.
async def run():
# create a Service Bus client using the connection string
async with ServiceBusClient(
fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
credential=credential,
logging_enable=True) as servicebus_client:
async with servicebus_client:
# get the Queue Receiver object for the queue
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
for msg in received_msgs:
print("Received: " + str(msg))
# complete the message so that the message is removed from the queue
await receiver.complete_message(msg)
# Close credential when no longer needed.
await credential.close()
Call the run method.
asyncio.run(run())
Similar to the send.py sample, add import statements and define constants that use your own values.
import asyncio
from azure.servicebus.aio import ServiceBusClient
NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STR"
QUEUE_NAME = "QUEUE_NAME"
Create a Service Bus client and then a queue receiver object to receive messages.
async def run():
# create a Service Bus client using the connection string
async with ServiceBusClient.from_connection_string(
conn_str=NAMESPACE_CONNECTION_STR,
logging_enable=True) as servicebus_client:
async with servicebus_client:
# get the Queue Receiver object for the queue
receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
async with receiver:
received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
for msg in received_msgs:
print("Received: " + str(msg))
# complete the message so that the message is removed from the queue
await receiver.complete_message(msg)
Call the run method.
asyncio.run(run())
Open a command prompt that has Python in its path, and then run the code to send and receive messages from the queue.
python send.py; python recv.py
You should see the following output:
Sent a single message
Sent a list of 5 messages
Sent a batch of 10 messages
Done sending messages
-----------------------
Received: Single Message
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
In the Azure portal, navigate to your Service Bus namespace. On the Overview page, verify that the incoming and outgoing message counts are 16. If you don't see the counts, wait few minutes, then refresh the page.
Select the queue on this Overview page to navigate to the Service Bus Queue page. You can also see the incoming and outgoing message count on this page. You also see other information such as the current size of the queue and active message count.
See the following documentation and samples:
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4