Azure Storage Queue Rust

Azure Queue Storage library for Rust

Client library for Azure Queue Storage — send, receive, and manage queue messages.

Use this skill when:

• An app needs to send or receive messages from Azure Queue Storage in Rust
• You need to create or manage queues
• You need to peek, receive, or delete queue messages
• You need RBAC-based auth for queue operations

IMPORTANT: Only use the official azure_storage_queue 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_storage_queue azure_identity azure_core tokio

If your code uses azure_core types directly, add azure_core to Cargo.toml. If you only use azure_storage_queue re-exports, direct azure_core dependency is optional.

Environment Variables

AZURE_STORAGE_QUEUE_ENDPOINT=https://<account>.queue.core.windows.net/ # Required for all operations

Authentication

Rust Azure SDK code must not use DefaultAzureCredential. The Rust identity crate does not provide that type.

use azure_core::http::Url;use azure_identity::DeveloperToolsCredential;use azure_storage_queue::QueueServiceClient;
#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    // Local dev: DeveloperToolsCredential. Production: use ManagedIdentityCredential.    let credential = DeveloperToolsCredential::new(None)?;    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;
    // Derive a queue client by name.    let queue_client = service_client.queue_client("<queue_name>")?;    Ok(())}

Do not infer public SDK types from generated internal model names. Prefer the crate README/examples when checking queue client method signatures and message/result shapes.

Client Types

Core Workflow

Send a Message

use azure_core::http::Url;use azure_identity::DeveloperToolsCredential;use azure_storage_queue::{models::QueueMessage, QueueServiceClient};
#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let credential = DeveloperToolsCredential::new(None)?;    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;    let queue_client = service_client.queue_client("<queue_name>")?;
    #[allow(clippy::needless_update)]    let message = QueueMessage {        message_text: Some("hello world".to_string()),        ..Default::default()    };    queue_client.send_message(message.try_into()?, None).await?;    Ok(())}

Receive Messages

use azure_core::http::Url;use azure_identity::DeveloperToolsCredential;use azure_storage_queue::QueueServiceClient;
#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let credential = DeveloperToolsCredential::new(None)?;    let service_url = Url::parse("https://<storage_account_name>.queue.core.windows.net/")?;    let service_client = QueueServiceClient::new(service_url, Some(credential), None)?;    let queue_client = service_client.queue_client("<queue_name>")?;
    let response = queue_client.receive_messages(None).await?;    let messages = response.into_model()?;    for msg in messages.items.unwrap_or_default() {        println!("{}", msg.message_text.as_deref().unwrap_or("<empty>"));    }    Ok(())}

Delete a Message

After receiving a message, delete it using the message ID and pop receipt:

let response = queue_client.receive_messages(None).await?;let messages = response.into_model()?;for msg in messages.items.unwrap_or_default() {    if let (Some(id), Some(pop_receipt)) = (&msg.message_id, &msg.pop_receipt) {        queue_client.delete_message(id, pop_receipt, None).await?;    }}

Peek Messages

Peek at messages without removing them from the queue:

let response = queue_client.peek_messages(None).await?;let messages = response.into_model()?;for msg in messages.items.unwrap_or_default() {    println!("Peeked: {}", msg.message_text.as_deref().unwrap_or("<empty>"));}

RBAC Roles

For Entra ID auth, assign one of these roles to the identity:

Best Practices

1. 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.
2. 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.
3. Use DeveloperToolsCredential for local dev, ManagedIdentityCredential for production — Rust does not provide a single DefaultAzureCredential type
4. Never hardcode credentials — use environment variables or managed identity
5. Assign RBAC roles — ensure appropriate queue data roles for the identity
6. Use QueueServiceClient as the entry point and derive QueueClient from it via queue_client()
7. Delete messages after processing — use the message ID and pop receipt from receive_messages
8. Reuse clients — clients are thread-safe; create once, share across tasks
9. Run cargo clippy -- -D warnings when the prompt, eval, or CI expects lint-clean output
10. Future-proof #[non_exhaustive] SDK models — end model-struct initializers (e.g. QueueMessage) with ..Default::default() (add #[allow(clippy::needless_update)]) and use a _ wildcard arm when matching SDK enums, so new service-added fields/variants don't break your build

Reference Links