Microsoft Azure — Service Bus & Queue Storage

# Queue Storage: simple, cheap, high throughput
az storage queue create --name orders-queue --account-name mystorage

# Service Bus: advanced features, higher cost
az servicebus queue create --resource-group rg --namespace-name sbns \
  --name orders-queue --enable-partitioning true --max-size 1024

resource "azurerm_servicebus_namespace" "sb" {
  name                = "sb-orders-${var.environment}"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  sku                 = "Premium"
  capacity            = 1
}

resource "azurerm_servicebus_queue" "orders" {
  name         = "orders-queue"
  namespace_id = azurerm_servicebus_namespace.sb.id

  enable_partitioning          = true
  max_size_in_megabytes        = 1024
  default_message_ttl          = "PT1H"
  lock_duration                = "PT30S"
  max_delivery_count           = 10
  dead_lettering_on_message_expiration = true
}

using Azure.Messaging.ServiceBus;

public class OrderPublisher
{
    private readonly ServiceBusSender _sender;

    public OrderPublisher(string connectionString, string queueName)
    {
        var client = new ServiceBusClient(connectionString);
        _sender = client.CreateSender(queueName);
    }

    public async Task PublishOrderAsync(Order order)
    {
        var message = new ServiceBusMessage(BinaryData.FromObjectAsJson(order))
        {
            MessageId = order.OrderId,
            SessionId = order.CustomerId,
            ApplicationProperties =
            {
                { "OrderType", order.Type },
                { "Priority", order.Priority }
            }
        };

        await _sender.SendMessageAsync(message);
    }

    public async ValueTask DisposeAsync()
    {
        await _sender.DisposeAsync();
    }
}

using Azure.Messaging.ServiceBus;

public class OrderProcessor
{
    public async Task StartProcessingAsync(string connectionString, string queueName)
    {
        var client = new ServiceBusClient(connectionString);
        var processor = client.CreateSessionProcessor(queueName, new ServiceBusSessionProcessorOptions
        {
            MaxConcurrentSessions = 10,
            MaxConcurrentCallsPerSession = 1,
            AutoCompleteMessages = false
        });

        processor.ProcessMessageAsync += async args =>
        {
            var order = args.Message.Body.ToObjectFromJson<Order>();
            try
            {
                await ProcessOrderAsync(order);
                await args.CompleteMessageAsync(args.Message);
            }
            catch (Exception ex)
            {
                await args.AbandonMessageAsync(args.Message);
                // After max delivery count, message moves to dead-letter
            }
        };

        processor.ProcessErrorAsync += args =>
        {
            Console.WriteLine($"Error: {args.Exception.Message}");
            return Task.CompletedTask;
        };

        await processor.StartProcessingAsync();
        Console.WriteLine("Processor started. Press any key to stop.");
        Console.ReadKey();
        await processor.StopProcessingAsync();
    }
}

using Azure.Messaging.ServiceBus;

public class DeadLetterReprocessor
{
    public async Task ReprocessDeadLettersAsync(string connectionString, string queueName)
    {
        var client = new ServiceBusClient(connectionString);
        var receiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions
        {
            SubQueue = SubQueue.DeadLetter
        });

        var sender = client.CreateSender(queueName);

        while (true)
        {
            var message = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5));
            if (message == null) break;

            Console.WriteLine($"DLQ: {message.MessageId} - Reason: {message.DeadLetterReason}");

            // Attempt to fix and resend
            var fixedMessage = new ServiceBusMessage(message);
            await sender.SendMessageAsync(fixedMessage);
            await receiver.CompleteMessageAsync(message);
        }

        await receiver.DisposeAsync();
        await sender.DisposeAsync();
    }
}

using Azure.Storage.Queues;

public class QueueStorageService
{
    private readonly QueueClient _queue;

    public QueueStorageService(string connectionString, string queueName)
    {
        _queue = new QueueClient(connectionString, queueName);
        _queue.CreateIfNotExists();
    }

    public async Task SendMessageAsync(string messageText)
    {
        await _queue.SendMessageAsync(messageText);
    }

    public async Task<string?> ReceiveMessageAsync()
    {
        var response = await _queue.ReceiveMessageAsync(TimeSpan.FromSeconds(30));
        if (response.Value == null) return null;

        var messageText = response.Value.MessageText;
        await _queue.DeleteMessageAsync(response.Value.MessageId, response.Value.PopReceipt);
        return messageText;
    }
}

{
  "name": "High Dead-Letter Queue",
  "condition": {
    "metricName": "DeadletteredMessages",
    "operator": "GreaterThan",
    "threshold": 100,
    "aggregation": "Total",
    "windowSize": "PT5M"
  },
  "actions": [
    {
      "actionGroupId": "/subscriptions/.../actionGroups/ops-team"
    }
  ]
}

// Service Bus sender batching
var batch = new List<ServiceBusMessage>();
for (int i = 0; i < 100; i++)
{
    batch.Add(new ServiceBusMessage($"Message {i}"));
}
await sender.SendMessagesAsync(batch);

// Service Bus processor with prefetch
var processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions
{
    PrefetchCount = 50,
    MaxConcurrentCalls = 20,
    AutoCompleteMessages = false
});

// Queue Storage receive batch
var messages = await queue.ReceiveMessagesAsync(maxMessages: 32);
foreach (var msg in messages.Value)
{
    await queue.DeleteMessageAsync(msg.MessageId, msg.PopReceipt);
}

# Assign managed identity to Service Bus
az role assignment create --assignee <managed-identity-id> \
  --role "Azure Service Bus Data Sender" \
  --scope /subscriptions/.../resourceGroups/rg/providers/Microsoft.ServiceBus/namespaces/sbns

# Create private endpoint
az network private-endpoint create --name sb-pe \
  --resource-group rg --vnet-name vnet --subnet subnet \
  --private-connection-resource-id /subscriptions/.../namespaces/sbns \
  --group-id namespace

resource "azurerm_servicebus_namespace" "primary" {
  name                = "sb-primary"
  location            = "eastus"
  sku                 = "Premium"
  capacity            = 1
}

resource "azurerm_servicebus_namespace" "secondary" {
  name                = "sb-secondary"
  location            = "westus"
  sku                 = "Premium"
  capacity            = 1
}

resource "azurerm_servicebus_namespace_disaster_recovery_config" "dr" {
  name                 = "dr-config"
  primary_namespace_id = azurerm_servicebus_namespace.primary.id
  partner_namespace_id = azurerm_servicebus_namespace.secondary.id
}

# Purchase reserved capacity for Service Bus Premium
az reservations create \
  --reserved-resource-type "ServiceBus" \
  --sku Premium \
  --quantity 1 \
  --term P1Y \
  --billing-scope Single \
  --display-name "SB Premium 1yr"

# Download Service Bus Explorer (Windows)
# https://github.com/paolosalvatori/ServiceBusExplorer/releases

# Or use Azure CLI to peek messages
az servicebus queue show --name orders-queue --namespace-name sbns \
  --resource-group rg --query "countDetails.activeMessageCount"

# Peek messages with CLI (preview)
az servicebus queue message peek --queue-name orders-queue \
  --namespace-name sbns --resource-group rg --count 5