This source did not publish a separate summary. Review SKILL.md before using the skill.
SKILL.md
Azure Service Bus library for Rust
When to Use
Use this skill when you need azure Service Bus library for Rust. Send and receive messages using queues, topics, and subscriptions. Triggers: "service bus rust", "ServiceBusClient rust", "send message servicebus rust", "receive message servicebus rust", "queue rust messaging", "topic subscription rust".
Client library for Azure Service Bus — enterprise message broker with queues and publish-subscribe topics.
⚠️ WARNING: This crate is in early development and SHOULD NOT be used in production. APIs may change without notice.
Use this skill when:
An app needs to send or receive messages via Azure Service Bus from Rust
You need queue-based messaging with competing consumers
You need publish-subscribe messaging with topics and subscriptions
You need reliable message delivery with completion semantics
IMPORTANT: Only use the official azure_messaging_servicebus crate published by the azure-sdk crates.io user. Do NOT use unofficial or community crates. Official crates use underscores in names and none have version 0.21.0.
Installation
cargo add azure_messaging_servicebus azure_identity tokio
If your code uses azure_core types directly, add azure_core to Cargo.toml. If you only use azure_messaging_servicebus re-exports, direct azure_core dependency is optional.
Publish-subscribe messaging — one sender, many subscribers
Subscription
Receives messages from a topic
Message
Package of data and metadata, with completion/abandon semantics
Authentication
use azure_identity::DeveloperToolsCredential;
use azure_messaging_servicebus::ServiceBusClient;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.
let credential = DeveloperToolsCredential::new(None)?;
let client = ServiceBusClient::builder()
.open("your_namespace.servicebus.windows.net", credential.clone())
.await?;
Ok(())
}
Core Workflow
Send a Message to a Queue
use azure_identity::DeveloperToolsCredential;
use azure_messaging_servicebus::{ServiceBusClient, Message};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let credential = DeveloperToolsCredential::new(None)?;
let client = ServiceBusClient::builder()
.open("your_namespace.servicebus.windows.net", credential.clone())
.await?;
let sender = client.create_sender("my_queue", None).await?;
let message = Message::from("Hello, Service Bus!");
sender.send_message(message, None).await?;
Ok(())
}
Receive Messages from a Queue
use azure_identity::DeveloperToolsCredential;
use azure_messaging_servicebus::ServiceBusClient;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let credential = DeveloperToolsCredential::new(None)?;
let client = ServiceBusClient::builder()
.open("your_namespace.servicebus.windows.net", credential.clone())
.await?;
let receiver = client.create_receiver("my_queue", None).await?;
let messages = receiver.receive_messages(5, None).await?;
for message in messages {
println!("Received: {}", message.body_as_string()?);
receiver.complete_message(&message, None).await?;
}
Ok(())
}
Send a Message to a Topic
let sender = client.create_sender("my_topic", None).await?;
let message = Message::from("Hello, Topic subscribers!");
sender.send_message(message, None).await?;
Receive Messages from a Subscription
let receiver = client
.create_receiver_for_subscription("my_topic", "my_subscription", None)
.await?;
let messages = receiver.receive_messages(5, None).await?;
for message in messages {
println!("Received: {}", message.body_as_string()?);
receiver.complete_message(&message, None).await?;
}
Message Settlement
Action
Purpose
complete
Remove message from queue — processing succeeded
abandon
Release lock — message becomes available for retry
Always complete messages after successful processing to prevent redelivery.
RBAC Roles
For Entra ID auth, assign one of these roles:
Role
Access
Azure Service Bus Data Sender
Send messages
Azure Service Bus Data Receiver
Receive messages
Azure Service Bus Data Owner
Full access
Best Practices
Use cargo add to manage dependencies, never edit Cargo.toml directly. Add and remove Rust SDK dependencies with cargo commands instead of manual manifest edits.
Add azure_core only when importing azure_core types directly. If your code imports azure_core::http::Url, azure_core::http::RequestContent, or azure_core::error::ErrorKind, include azure_core; otherwise a direct dependency is optional.
Use DeveloperToolsCredential for local dev, ManagedIdentityCredential for production — Rust does not provide a single DefaultAzureCredential type
Never hardcode credentials — use environment variables or managed identity
Assign RBAC roles — ensure the identity has appropriate Service Bus data roles
Always complete messages — call complete_message after processing to remove from queue
Use topics for fan-out — when multiple consumers need the same messages, use topics with subscriptions
This crate is pre-production — APIs may change; pin your dependency version with cargo commands in your dependency workflow
