Mastering Azure Service Bus with Python REST API (No SDK Guide)

Why Bypass the Azure SDK for Service Bus?

Azure Service Bus is a robust messaging platform that supports reliable communication between applications and services. While the official Python SDK simplifies interaction with Service Bus, there are compelling reasons to bypass it and directly interact with the REST API instead:

• Minimal Dependencies: The SDK introduces additional dependencies, which can be problematic for lightweight environments or projects with strict dependency management policies.
• Full HTTP Control: Direct API access allows you to customize headers, configure retries, and handle raw responses, giving you complete control over the HTTP lifecycle.
• Compatibility with Unique Environments: Non-standard environments, such as some serverless functions or niche container setups, may not support the Azure SDK. The REST API ensures compatibility.
• Deeper Insights: By working directly with the REST API, you gain a better understanding of how Azure Service Bus operates, which can be invaluable for debugging and advanced configurations.

While the SDK is a convenient abstraction, bypassing it offers granular control and greater flexibility. This guide will walk you through sending and receiving messages from Azure Service Bus using Python’s requests library, without relying on the Azure SDK. Along the way, you’ll learn to authenticate using Shared Access Signature (SAS) tokens, troubleshoot common issues, and explore advanced use cases for the Service Bus REST API.

Prerequisites: Setting Up for Success

Before diving into implementation, ensure you have the following:

• Azure Subscription: Access to the Azure portal with an active subscription is required to provision and manage Service Bus resources.
• Service Bus Namespace: Create a Service Bus namespace in Azure. This namespace serves as a container for your queues, topics, and subscriptions.
• Queue Configuration: Set up a queue within your namespace. You will use this queue to send and receive messages.
• Authentication Credentials: Obtain the SAS key and key name for your namespace. These credentials will be used to generate authentication tokens for accessing the Service Bus.
• Python Environment: Install Python 3.6+ and the requests library. You can install the library via pip using pip install requests.
• Basic HTTP Knowledge: Familiarity with HTTP methods (GET, POST, DELETE) and JSON formatting will make the process easier to understand.

Once you have these prerequisites in place, you’re ready to start building your Service Bus integration using the REST API.

Step 1: Generating a Shared Access Signature (SAS) Token

Authentication is a critical step when working with Azure Service Bus. To interact with the Service Bus REST API, you need to generate a Shared Access Signature (SAS) token. This token provides time-limited access to specific Service Bus resources. Below is a Python function to generate SAS tokens:

import time
import urllib.parse
import hmac
import hashlib
import base64

def generate_sas_token(namespace, queue, key_name, key_value):
    """
    Generate a SAS token for Azure Service Bus.
    """
    resource_uri = f"https://{namespace}.servicebus.windows.net/{queue}"
    encoded_uri = urllib.parse.quote_plus(resource_uri)
    expiry = str(int(time.time()) + 3600)  # Token valid for 1 hour
    string_to_sign = f"{encoded_uri}\n{expiry}"
    key = key_value.encode("utf-8")
    signature = hmac.new(key, string_to_sign.encode("utf-8"), hashlib.sha256).digest()
    encoded_signature = base64.b64encode(signature).decode()

    sas_token = f"SharedAccessSignature sr={encoded_uri}&sig={encoded_signature}&se={expiry}&skn={key_name}"
    return {"uri": resource_uri, "token": sas_token}

Replace namespace, queue, key_name, and key_value with your actual Azure Service Bus details. The function returns a dictionary containing the resource URI and the SAS token.

Step 2: Sending Messages to the Queue

Once you have a SAS token, sending messages to the queue is straightforward. Use an HTTP POST request to send the message. Below is an example implementation: