AutoGineer
Generated banner for Azure Storage Queue Rust
Generated logo for Azure Storage Queue Rust

Azure Storage Queue Rust

MicrosoftOfficialCreated by Microsoft

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found
Download ZIP

From the author

Azure Queue Storage library for Rust. Send, receive, and manage queue messages. Triggers: "queue storage rust", "QueueClient rust", "send message rust", "receive messages rust", "QueueServiceClient rust", "queue rust".
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides instructions for integrating the official Azure Queue Storage SDK into Rust applications. It covers client initialization, authentication using Entra ID, and core queue operations such as sending, receiving, peeking, and deleting messages. The guide emphasizes best practices for dependency management, security, and handling SDK models in Rust.

What it does

  • Initializes QueueServiceClient and QueueClient for Azure storage operations
  • Demonstrates how to send messages to an Azure storage queue
  • Provides patterns for receiving and processing queue messages
  • Explains how to delete messages using message IDs and pop receipts
  • Outlines required RBAC roles for secure access to queue data
  • Offers guidance on local development versus production authentication

When to use it

  • When building Rust applications that require asynchronous messaging via Azure Queue Storage
  • When you need to perform account-level or queue-specific operations in Azure
  • When implementing secure, identity-based access to storage queues
  • When you need to manage the lifecycle of queue messages within a Rust service

Advantages

  • Uses the official, supported Azure SDK for Rust
  • Provides thread-safe client patterns for efficient resource usage
  • Includes clear guidance on handling non-exhaustive SDK models
  • Aligns with security best practices by recommending RBAC over hardcoded credentials

Usage examples

“How do I send a message to an Azure queue using Rust?”
The agent provides a code snippet using QueueClient.send_message, including the necessary struct initialization and error handling.
“Show me how to receive and delete a message from an Azure queue in Rust.”
The agent demonstrates the receive_messages call followed by the delete_message operation using the required message ID and pop receipt.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/azure-storage-queue-rust/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip azure-storage-queue-rust.zip -d .agents/skills

Documentation by Microsoft

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

ClientPurposeAccess
QueueServiceClientAccount-level operations, list queuesQueueServiceClient::new()
QueueClientQueue operations, send/receive/deleteservice_client.queue_client("<name>")?

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:

RoleAccess
Storage Queue Data ReaderRead and peek messages
Storage Queue Data ContributorRead/write messages
Storage Queue Data Message SenderSend messages only
Storage Queue Data Message ProcessorReceive and delete

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

ResourceLink
API Referencehttps://docs.rs/crate/azure_storage_queue/latest
crates.iohttps://crates.io/crates/azure_storage_queue
Source Codehttps://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/storage/azure_storage_queue

Files

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/skills · .github/plugins/azure-sdk-rust/skills/azure-storage-queue-rust · commit 0696600
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download azure-storage-queue-rust.zip