What does this skill do, and when should you use it?
This skill is for Rust applications that use Azure Service Bus for enterprise messaging. It covers installation, identity-based authentication, queue and topic workflows, subscription receivers, and message settlement. It recommends the official azure_messaging_servicebus crate and explains the relevant Entra ID roles. The crate is in early development and should not be used in production because its APIs may change.
Shows how to install azure_messaging_servicebus, azure_identity, and tokio with cargo add; configure SERVICEBUS_NAMESPACE; create a ServiceBusClient with DeveloperToolsCredential or ManagedIdentityCredential; create senders and receivers for queues, topics, and subscriptions; send messages; receive batches; inspect message bodies; complete successfully processed messages; abandon messages for retry; and assign Service Bus Data Sender, Data Receiver, or Data Owner roles.
- A Rust application needs to send work items to an Azure Service Bus queue and uses a sender to publish Message values.
- A Rust worker needs to receive several queue messages, process them, and complete them to prevent redelivery.
- Several consumers need the same published messages, so the application uses a topic with subscriptions for fan-out delivery.
- A developer needs local Azure authentication with DeveloperToolsCredential, while a production design would use ManagedIdentityCredential instead.
How do you install this skill?
- The crate is explicitly in early development and should not be used directly in production; verify and pin the actual version and API before adoption.
- Sending, completing, and abandoning messages change external state; add confirmation boundaries, idempotency, retries, lock renewal, dead-letter, audit, and recovery policies before deployment.
- Do not log message bodies or credentials, and verify Azure Service Bus reachability in the target network environment.
- Shell / CLI
- Network access
Rust and Cargoazure_messaging_servicebusazure_identitytokio
Run npx skills add microsoft/skills and select this skill in the installation wizard for the target agent. Alternatively, clone the collection and copy .github/plugins/azure-sdk-rust/skills/azure-servicebus-rust/ into the target agent skills directory. Add project dependencies with: cargo add azure_messaging_servicebus azure_identity tokio. Add azure_core only if the project directly imports azure_core types.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/microsoft/skills.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/.github/plugins/azure-sdk-rust/skills/azure-servicebus-rust" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- service bus rust
- send message servicebus rust
- receive message servicebus rust
- queue rust messaging
Use a trigger such as "service bus rust", "ServiceBusClient rust", "send message servicebus rust", "receive message servicebus rust", "queue rust messaging", or "topic subscription rust". Provide the Service Bus namespace and the relevant queue, topic, or subscription, then request a send, receive, or subscription workflow. Set SERVICEBUS_NAMESPACE=<namespace>.servicebus.windows.net and ensure the identity has the required Azure Service Bus data role.
What are this skill's strengths and limitations?
- Covers queues, topics, subscriptions, sending, receiving, and settlement semantics.
- Uses the official crate and documents authentication, RBAC, and credential-handling practices.
- Includes copyable asynchronous Rust examples.
- Distinguishes local development credentials from production managed identity.
- The azure_messaging_servicebus crate is explicitly early-development software and should not be used in production.
- APIs may change, and the source provides no stability guarantee or compatibility matrix.
- The source does not show a dedicated test suite or platform-coverage evidence for this skill.
- Azure resources, network access, and appropriate permissions are required; pricing is not documented.
How does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Azure Service Bus for Rust this page ✓ Microsoft · Official | 47 · Use with care | ★ 2.7k | 3mo ago | MIT |
| Azure Service Bus for TypeScript ✓ Microsoft · Official | 50 · Use with care | ★ 2.7k | 3mo ago | MIT |
| Azure Service Bus for Python ✓ Microsoft · Official | 45 · Not recommended | ★ 2.7k | 3mo ago | MIT |
| Azure Service Bus for .NET ✓ Microsoft · Official | 47 · Use with care | ★ 2.7k | 3mo ago | MIT |
| Azure Queue Storage for Rust ✓ Microsoft · Official | 54 · Use with care | ★ 2.7k | 3mo ago | MIT |
How did FollowSkills review this skill?
The document requires the official crate, discourages hardcoded credentials, and provides DeveloperToolsCredential/ManagedIdentityCredential guidance plus scoped RBAC roles. However, sending, receiving, and completing messages create external state changes without explicit user confirmation, and it omits data-flow disclosure, sensitive-data handling, idempotency, rollback, and recovery guidance, so points are deducted.
Installation, authentication, queue/topic/subscription, and settlement flows are internally consistent, and examples propagate errors with Result. However, the crate is explicitly early-stage, with no guidance for retries, lock expiry, dead-lettering, connection failures, or abnormal inputs, and no skill-specific test evidence is supplied; the static score is therefore limited.
Triggers, Rust audience, and queue/topic/subscription scenarios are reasonably clear. Non-fit ranges, API/version boundaries, input/output contracts, and environment requirements are not defined, and Chinese-language support is absent. The core function depends on network access to Azure Service Bus, whose mainland-China reachability is not established by the supplied material, so points are deducted.
The document has clear sections for installation, environment variables, authentication, workflows, RBAC, practices, references, MIT licensing, and author metadata. It lacks concrete version-pinning examples, changelog, maintenance ownership and update path, troubleshooting, and fuller limitations; the scope of the instruction not to edit Cargo.toml is also unexplained.
The material covers the core send, receive, topic, and subscription tasks and offers directly useful starting snippets. However, the crate is explicitly unsuitable for production, while the examples omit complete configuration, lifecycle management, retries, and production reliability handling. Static evidence does not establish compilation or complete outcomes, so the score remains within the static ceiling.
The skill supplies docs.rs, crates.io, and Azure SDK source references, with repository-level CI/test material providing limited corroboration. The supplied evidence does not show skill-specific tests, build results, or independent reproduction, and nothing was executed in this review, so a higher score is not justified.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →