Index of every page on this site: llms.txt
All skills
microsoft avatar

/azure-storage-queue-rust

@0d60658
by microsoftmicrosoft/skills3.2k stars
373
Run it yourself

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".

Use this Skill: https://skilld.dev/gh/microsoft/skills/azure-storage-queue-rust

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈61 tokens for metadata: the name and description. ≈1.8k when used: this file.

Description uses 3.1% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈245 characters, or 3.1%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

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

Client Purpose Access
QueueServiceClient Account-level operations, list queues QueueServiceClient::new()
QueueClient Queue operations, send/receive/delete service_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:

Role Access
Storage Queue Data Reader Read and peek messages
Storage Queue Data Contributor Read/write messages
Storage Queue Data Message Sender Send messages only
Storage Queue Data Message Processor Receive 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

Resource Link
API Reference https://docs.rs/crate/azure_storage_queue/latest
crates.io https://crates.io/crates/azure_storage_queue
Source Code https://github.com/Azure/azure-sdk-for-rust/tree/main/sdk/storage/azure_storage_queue

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning3mo3 checks · Risk SAFE
  • Gen Agent Trust Hub3mo

    This skill follows secure coding practices for Azure Queue Storage in Rust, emphasizing official libraries, environment-based configuration, and proper identity management.

  • Socket3mo

    No alerts

  • Snyk3mo

    Risk: MEDIUM · 1 issue

Signed by skilld at 0d60658. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 4 months ago
metadata
{
  "author": "Microsoft",
  "package": "azure_storage_queue"
}

README badge

README badge for microsoft/skills/azure-storage-queue-rust