Azure service bus queue with .net core and python

dotnet new webapi --use-controllers -o AzureServiceBus

dotnet add package Azure.Messaging.ServiceBus

namespace AzureServiceBus;
public class EmployeeModel
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Designation { get; set; }
    public string Department { get; set; }
    public string Note { get; set; }

}

using Microsoft.AspNetCore.Mvc;
using Azure.Messaging.ServiceBus;
using Newtonsoft.Json;
namespace AzureServiceBus.Controllers;
[ApiController]
[Route("[controller]")]
public class ServiceBusController: ControllerBase
{
    public ServiceBusController(){
    }
    [HttpPost]
    public async Task<IActionResult> SendMessageAsync([FromBody] EmployeeModel employee)
    {
        string connectionString = "your_connection_string";
        string queueName = "your_queue_name";
        var client = new ServiceBusClient(connectionString);
        var sender = client.CreateSender(queueName);
        string body = JsonConvert.SerializeObject(employee);
        var message = new ServiceBusMessage(body);
        await sender.SendMessageAsync(message);       
        return Ok("Message sent to the service bus queue");
        
    }

}

dotnet new console -n AzureServiceBusReceiver

This creates a console application named AzureServiceBusReceiver.

Now open the solution in VSCode and install the below NugetPackage using the terminal itself.

dotnet add package Azure.Messaging.ServiceBus

Once, this is done, add the below code to the Program. cs.

using Azure.Messaging.ServiceBus;
string connectionString = "your_connection_string";
string queueName = "your_queue_name";
var client = new ServiceBusClient(connectionString);
var processor = client.CreateProcessor(queueName);
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
await processor.StartProcessingAsync();
Console.ReadKey();
async Task MessageHandler(ProcessMessageEventArgs args)
{
    string body = args.Message.Body.ToString();
    Console.WriteLine($"Received: {body}");
    await args.CompleteMessageAsync(args.Message);
}
async Task ErrorHandler(ProcessErrorEventArgs args)
{
    Console.WriteLine(args.Exception.ToString());
}

Once you run this console application, it will read any existing messages in the queue. If you run both the above solutions together, you can send messages from web API solution and it will be received by the console application

Python

Now, let's try to achieve the same using Python.

Create a folder for Python files and install the below package. This package is used to write and read messages to the Azure service bus queue.

pip install azure-servicebus

Create a file for pushing messages to the service bus queue and use the code below.

import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
connection_string = 'your_connection_string'
queue = 'your_queue_name'
async def publish_message():
    async with ServiceBusClient.from_connection_string(connection_string) as client:
        async with client.get_queue_sender(queue) as sender:
            message = ServiceBusMessage("Hi, this is from python code")
            await sender.send_messages(message)
            print("Message sent successfully.")
asyncio.run(publish_message())

This code is quite straightforward. It creates a client using a connection string and then creates an object od the queue and then pushes the message to the queue. Asyncio is used to run the method asynchronously.

Now, create another file to read the messages from the queue.

import asyncio
from azure.servicebus.aio import ServiceBusClient
from azure.servicebus import ServiceBusMessage
connection_string = 'your_connection_string'
queue = 'your_queue_name'
async def read_message():
    async with ServiceBusClient.from_connection_string(connection_string) as client:
        async with client.get_queue_receiver(queue) as receiver:
            received_message = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
            for message in received_message:
                print(message)
                await receiver.complete_message(message)
asyncio.run(read_message())

This method is similar to the previous one, the only difference is that we are reading the message in this one. This is also making sure to delete the message from the queue by marking it as deleted.

Now, let's run both files together using the below code.

python AzureServiceBusPub.py; python AzureServiceBusReceiver.py

We get the below result.

As you can see, the message is sent by the publisher and then read by the receiver.

Hope this article helps you in setting up basic Azure service queue integration with .netcore and Python.