Azure Storage Queue Py

1---
2name: azure-storage-queue-py
3description: |
4  Azure Queue Storage SDK for Python. Use for reliable message queuing, task distribution, and asynchronous processing.
5  Triggers: "queue storage", "QueueServiceClient", "QueueClient", "message queue", "dequeue".
6package: azure-storage-queue
7---
8 
9# Azure Queue Storage SDK for Python
10 
11Simple, cost-effective message queuing for asynchronous communication.
12 
13## Installation
14 
15```bash
16pip install azure-storage-queue azure-identity
17```
18 
19## Environment Variables
20 
21```bash
22AZURE_STORAGE_ACCOUNT_URL=https://<account>.queue.core.windows.net
23```
24 
25## Authentication
26 
27```python
28from azure.identity import DefaultAzureCredential
29from azure.storage.queue import QueueServiceClient, QueueClient
30 
31credential = DefaultAzureCredential()
32account_url = "https://<account>.queue.core.windows.net"
33 
34# Service client
35service_client = QueueServiceClient(account_url=account_url, credential=credential)
36 
37# Queue client
38queue_client = QueueClient(account_url=account_url, queue_name="myqueue", credential=credential)
39```
40 
41## Queue Operations
42 
43```python
44# Create queue
45service_client.create_queue("myqueue")
46 
47# Get queue client
48queue_client = service_client.get_queue_client("myqueue")
49 
50# Delete queue
51service_client.delete_queue("myqueue")
52 
53# List queues
54for queue in service_client.list_queues():
55    print(queue.name)
56```
57 
58## Send Messages
59 
60```python
61# Send message (string)
62queue_client.send_message("Hello, Queue!")
63 
64# Send with options
65queue_client.send_message(
66    content="Delayed message",
67    visibility_timeout=60,  # Hidden for 60 seconds
68    time_to_live=3600       # Expires in 1 hour
69)
70 
71# Send JSON
72import json
73data = {"task": "process", "id": 123}
74queue_client.send_message(json.dumps(data))
75```
76 
77## Receive Messages
78 
79```python
80# Receive messages (makes them invisible temporarily)
81messages = queue_client.receive_messages(
82    messages_per_page=10,
83    visibility_timeout=30  # 30 seconds to process
84)
85 
86for message in messages:
87    print(f"ID: {message.id}")
88    print(f"Content: {message.content}")
89    print(f"Dequeue count: {message.dequeue_count}")
90    
91    # Process message...
92    
93    # Delete after processing
94    queue_client.delete_message(message)
95```
96 
97## Peek Messages
98 
99```python
100# Peek without hiding (doesn't affect visibility)
101messages = queue_client.peek_messages(max_messages=5)
102 
103for message in messages:
104    print(message.content)
105```
106 
107## Update Message
108 
109```python
110# Extend visibility or update content
111messages = queue_client.receive_messages()
112for message in messages:
113    # Extend timeout (need more time)
114    queue_client.update_message(
115        message,
116        visibility_timeout=60
117    )
118    
119    # Update content and timeout
120    queue_client.update_message(
121        message,
122        content="Updated content",
123        visibility_timeout=60
124    )
125```
126 
127## Delete Message
128 
129```python
130# Delete after successful processing
131messages = queue_client.receive_messages()
132for message in messages:
133    try:
134        # Process...
135        queue_client.delete_message(message)
136    except Exception:
137        # Message becomes visible again after timeout
138        pass
139```
140 
141## Clear Queue
142 
143```python
144# Delete all messages
145queue_client.clear_messages()
146```
147 
148## Queue Properties
149 
150```python
151# Get queue properties
152properties = queue_client.get_queue_properties()
153print(f"Approximate message count: {properties.approximate_message_count}")
154 
155# Set/get metadata
156queue_client.set_queue_metadata(metadata={"environment": "production"})
157properties = queue_client.get_queue_properties()
158print(properties.metadata)
159```
160 
161## Async Client
162 
163```python
164from azure.storage.queue.aio import QueueServiceClient, QueueClient
165from azure.identity.aio import DefaultAzureCredential
166 
167async def queue_operations():
168    credential = DefaultAzureCredential()
169    
170    async with QueueClient(
171        account_url="https://<account>.queue.core.windows.net",
172        queue_name="myqueue",
173        credential=credential
174    ) as client:
175        # Send
176        await client.send_message("Async message")
177        
178        # Receive
179        async for message in client.receive_messages():
180            print(message.content)
181            await client.delete_message(message)
182 
183import asyncio
184asyncio.run(queue_operations())
185```
186 
187## Base64 Encoding
188 
189```python
190from azure.storage.queue import QueueClient, BinaryBase64EncodePolicy, BinaryBase64DecodePolicy
191 
192# For binary data
193queue_client = QueueClient(
194    account_url=account_url,
195    queue_name="myqueue",
196    credential=credential,
197    message_encode_policy=BinaryBase64EncodePolicy(),
198    message_decode_policy=BinaryBase64DecodePolicy()
199)
200 
201# Send bytes
202queue_client.send_message(b"Binary content")
203```
204 
205## Best Practices
206 
2071. **Delete messages after processing** to prevent reprocessing
2082. **Set appropriate visibility timeout** based on processing time
2093. **Handle `dequeue_count`** for poison message detection
2104. **Use async client** for high-throughput scenarios
2115. **Use `peek_messages`** for monitoring without affecting queue
2126. **Set `time_to_live`** to prevent stale messages
2137. **Consider Service Bus** for advanced features (sessions, topics)
214