0
# Queue Service Management
1
2
Account-level operations for managing multiple queues, service configuration, and authentication within an Azure Storage account. The QueueServiceClient provides comprehensive queue service management capabilities.
3
4
## Capabilities
5
6
### QueueServiceClient Creation
7
8
Create service clients using various authentication methods including connection strings, account keys, and SAS tokens.
9
10
```python { .api }
11
class QueueServiceClient:
12
def __init__(
13
self,
14
account_url: str,
15
credential=None,
16
*,
17
api_version: Optional[str] = None,
18
secondary_hostname: Optional[str] = None,
19
audience: Optional[str] = None,
20
**kwargs
21
):
22
"""
23
Create a QueueServiceClient from account URL and credential.
24
25
Parameters:
26
- account_url: Queue service endpoint URL
27
- credential: Authentication credential (key, SAS token, or Azure credential)
28
- api_version: Storage service API version
29
- secondary_hostname: Secondary hostname for read access
30
- audience: Token audience for Azure AD authentication
31
"""
32
33
@classmethod
34
def from_connection_string(
35
cls,
36
conn_str: str,
37
credential=None,
38
**kwargs
39
) -> 'QueueServiceClient':
40
"""
41
Create client from storage account connection string.
42
43
Parameters:
44
- conn_str: Storage account connection string
45
- credential: Optional additional credential
46
47
Returns:
48
QueueServiceClient instance
49
"""
50
```
51
52
### Queue Listing
53
54
List all queues in the storage account with optional filtering and metadata inclusion.
55
56
```python { .api }
57
def list_queues(
58
self,
59
name_starts_with: Optional[str] = None,
60
include_metadata: bool = False,
61
*,
62
results_per_page: Optional[int] = None,
63
timeout: Optional[int] = None,
64
**kwargs
65
) -> ItemPaged[QueueProperties]:
66
"""
67
List queues in the storage account.
68
69
Parameters:
70
- name_starts_with: Filter queues by name prefix
71
- include_metadata: Include queue metadata in results
72
- results_per_page: Number of results per page
73
- timeout: Request timeout in seconds
74
75
Returns:
76
Paginated list of QueueProperties
77
"""
78
```
79
80
### Queue Creation and Deletion
81
82
Create and delete queues at the service level with optional metadata.
83
84
```python { .api }
85
def create_queue(
86
self,
87
name: str,
88
metadata: Optional[Dict[str, str]] = None,
89
*,
90
timeout: Optional[int] = None,
91
**kwargs
92
) -> QueueClient:
93
"""
94
Create a new queue in the storage account.
95
96
Parameters:
97
- name: Queue name (3-63 characters, lowercase letters, numbers, hyphens)
98
- metadata: User-defined metadata key-value pairs
99
- timeout: Request timeout in seconds
100
101
Returns:
102
QueueClient for the created queue
103
104
Raises:
105
ResourceExistsError: If queue already exists
106
"""
107
108
def delete_queue(
109
self,
110
queue: Union[str, QueueProperties],
111
*,
112
timeout: Optional[int] = None,
113
**kwargs
114
) -> None:
115
"""
116
Delete a queue from the storage account.
117
118
Parameters:
119
- queue: Queue name or QueueProperties object
120
- timeout: Request timeout in seconds
121
122
Raises:
123
ResourceNotFoundError: If queue does not exist
124
"""
125
```
126
127
### Service Properties Management
128
129
Get and set service-wide properties including analytics, CORS rules, and retention policies.
130
131
```python { .api }
132
def get_service_properties(
133
self,
134
*,
135
timeout: Optional[int] = None,
136
**kwargs
137
) -> Dict[str, Any]:
138
"""
139
Get storage service properties including analytics and CORS.
140
141
Parameters:
142
- timeout: Request timeout in seconds
143
144
Returns:
145
Dictionary containing service properties:
146
- analytics_logging: QueueAnalyticsLogging settings
147
- hour_metrics: Metrics configuration
148
- minute_metrics: Metrics configuration
149
- cors: List of CorsRule objects
150
"""
151
152
def set_service_properties(
153
self,
154
analytics_logging: Optional[QueueAnalyticsLogging] = None,
155
hour_metrics: Optional[Metrics] = None,
156
minute_metrics: Optional[Metrics] = None,
157
cors: Optional[List[CorsRule]] = None,
158
*,
159
timeout: Optional[int] = None,
160
**kwargs
161
) -> None:
162
"""
163
Set storage service properties.
164
165
Parameters:
166
- analytics_logging: Logging configuration
167
- hour_metrics: Hourly metrics configuration
168
- minute_metrics: Per-minute metrics configuration
169
- cors: Cross-origin resource sharing rules
170
- timeout: Request timeout in seconds
171
"""
172
```
173
174
### Service Statistics
175
176
Retrieve service statistics for geo-replicated storage accounts.
177
178
```python { .api }
179
def get_service_stats(
180
self,
181
*,
182
timeout: Optional[int] = None,
183
**kwargs
184
) -> Dict[str, Any]:
185
"""
186
Get service statistics for geo-replicated accounts.
187
188
Parameters:
189
- timeout: Request timeout in seconds
190
191
Returns:
192
Dictionary containing replication statistics:
193
- geo_replication: Replication status and timestamps
194
195
Note:
196
Only available for read-access geo-redundant replication (RA-GRS)
197
"""
198
```
199
200
### Queue Client Creation
201
202
Get QueueClient instances for specific queues without making service calls.
203
204
```python { .api }
205
def get_queue_client(
206
self,
207
queue: Union[str, QueueProperties],
208
**kwargs
209
) -> QueueClient:
210
"""
211
Create a QueueClient for a specific queue.
212
213
Parameters:
214
- queue: Queue name or QueueProperties object
215
216
Returns:
217
QueueClient instance for the specified queue
218
219
Note:
220
Does not verify queue existence
221
"""
222
```
223
224
## Usage Examples
225
226
### Basic Service Client Usage
227
228
```python
229
from azure.storage.queue import QueueServiceClient
230
231
# Create service client from connection string
232
service_client = QueueServiceClient.from_connection_string(
233
"DefaultEndpointsProtocol=https;AccountName=myaccount;AccountKey=mykey"
234
)
235
236
# List all queues
237
queues = service_client.list_queues(include_metadata=True)
238
for queue in queues:
239
print(f"Queue: {queue.name}, Messages: {queue.approximate_message_count}")
240
241
# Create a new queue
242
queue_client = service_client.create_queue("myqueue", metadata={"purpose": "testing"})
243
244
# Delete a queue
245
service_client.delete_queue("myqueue")
246
```
247
248
### Service Properties Configuration
249
250
```python
251
from azure.storage.queue import QueueAnalyticsLogging, Metrics, RetentionPolicy
252
253
# Configure service properties
254
logging_config = QueueAnalyticsLogging(
255
version="1.0",
256
delete=True,
257
read=True,
258
write=True,
259
retention_policy=RetentionPolicy(enabled=True, days=7)
260
)
261
262
metrics_config = Metrics(
263
version="1.0",
264
enabled=True,
265
include_apis=True,
266
retention_policy=RetentionPolicy(enabled=True, days=7)
267
)
268
269
service_client.set_service_properties(
270
analytics_logging=logging_config,
271
hour_metrics=metrics_config,
272
minute_metrics=metrics_config
273
)
274
```
275
276
## Types
277
278
### Service Configuration Types
279
280
```python { .api }
281
class QueueAnalyticsLogging:
282
version: str
283
delete: bool
284
read: bool
285
write: bool
286
retention_policy: RetentionPolicy
287
288
class Metrics:
289
version: str
290
enabled: bool
291
include_apis: Optional[bool]
292
retention_policy: RetentionPolicy
293
294
class RetentionPolicy:
295
enabled: bool
296
days: Optional[int]
297
298
class CorsRule:
299
allowed_origins: str
300
allowed_methods: str
301
max_age_in_seconds: int
302
exposed_headers: str
303
allowed_headers: str
304
```