0
# Queue Operations
1
2
Queue lifecycle management, configuration, and authorization rule management for point-to-point messaging scenarios. Service Bus queues provide reliable message delivery with features like dead lettering, message sessions, duplicate detection, and automatic forwarding.
3
4
## Capabilities
5
6
### Queue Lifecycle Management
7
8
Create, retrieve, update, delete, and list Service Bus queues within a namespace.
9
10
```python { .api }
11
def list_by_namespace(
12
self,
13
resource_group_name: str,
14
namespace_name: str,
15
skip: Optional[int] = None,
16
top: Optional[int] = None
17
) -> ItemPaged[SBQueue]:
18
"""List queues in a namespace.
19
20
Args:
21
resource_group_name (str): Name of the resource group.
22
namespace_name (str): Name of the namespace.
23
skip (int, optional): Number of queues to skip.
24
top (int, optional): Maximum number of queues to return.
25
26
Returns:
27
ItemPaged[SBQueue]: Iterable of queue resources.
28
"""
29
30
def create_or_update(
31
self,
32
resource_group_name: str,
33
namespace_name: str,
34
queue_name: str,
35
parameters: SBQueue
36
) -> SBQueue:
37
"""Create or update a Service Bus queue.
38
39
Args:
40
resource_group_name (str): Name of the resource group.
41
namespace_name (str): Name of the namespace.
42
queue_name (str): Name of the queue.
43
parameters (SBQueue): Queue configuration parameters.
44
45
Returns:
46
SBQueue: The created or updated queue.
47
"""
48
49
def get(
50
self,
51
resource_group_name: str,
52
namespace_name: str,
53
queue_name: str
54
) -> SBQueue:
55
"""Get details of a specific queue.
56
57
Args:
58
resource_group_name (str): Name of the resource group.
59
namespace_name (str): Name of the namespace.
60
queue_name (str): Name of the queue.
61
62
Returns:
63
SBQueue: The queue resource.
64
"""
65
66
def delete(
67
self,
68
resource_group_name: str,
69
namespace_name: str,
70
queue_name: str
71
) -> None:
72
"""Delete a queue.
73
74
Args:
75
resource_group_name (str): Name of the resource group.
76
namespace_name (str): Name of the namespace.
77
queue_name (str): Name of the queue.
78
"""
79
```
80
81
### Queue Authorization Rules
82
83
Manage authorization rules for queue-level access control with specific rights (Send, Listen, Manage).
84
85
```python { .api }
86
def list_authorization_rules(
87
self,
88
resource_group_name: str,
89
namespace_name: str,
90
queue_name: str
91
) -> ItemPaged[SBAuthorizationRule]:
92
"""List authorization rules for a queue.
93
94
Args:
95
resource_group_name (str): Name of the resource group.
96
namespace_name (str): Name of the namespace.
97
queue_name (str): Name of the queue.
98
99
Returns:
100
ItemPaged[SBAuthorizationRule]: Iterable of authorization rules.
101
"""
102
103
def create_or_update_authorization_rule(
104
self,
105
resource_group_name: str,
106
namespace_name: str,
107
queue_name: str,
108
authorization_rule_name: str,
109
parameters: SBAuthorizationRule
110
) -> SBAuthorizationRule:
111
"""Create or update an authorization rule for a queue.
112
113
Args:
114
resource_group_name (str): Name of the resource group.
115
namespace_name (str): Name of the namespace.
116
queue_name (str): Name of the queue.
117
authorization_rule_name (str): Name of the authorization rule.
118
parameters (SBAuthorizationRule): Authorization rule parameters.
119
120
Returns:
121
SBAuthorizationRule: The created or updated authorization rule.
122
"""
123
124
def get_authorization_rule(
125
self,
126
resource_group_name: str,
127
namespace_name: str,
128
queue_name: str,
129
authorization_rule_name: str
130
) -> SBAuthorizationRule:
131
"""Get an authorization rule for a queue.
132
133
Args:
134
resource_group_name (str): Name of the resource group.
135
namespace_name (str): Name of the namespace.
136
queue_name (str): Name of the queue.
137
authorization_rule_name (str): Name of the authorization rule.
138
139
Returns:
140
SBAuthorizationRule: The authorization rule.
141
"""
142
143
def delete_authorization_rule(
144
self,
145
resource_group_name: str,
146
namespace_name: str,
147
queue_name: str,
148
authorization_rule_name: str
149
) -> None:
150
"""Delete an authorization rule for a queue.
151
152
Args:
153
resource_group_name (str): Name of the resource group.
154
namespace_name (str): Name of the namespace.
155
queue_name (str): Name of the queue.
156
authorization_rule_name (str): Name of the authorization rule.
157
"""
158
```
159
160
### Queue Access Key Management
161
162
Generate and manage access keys for queue-specific authentication.
163
164
```python { .api }
165
def list_keys(
166
self,
167
resource_group_name: str,
168
namespace_name: str,
169
queue_name: str,
170
authorization_rule_name: str
171
) -> AccessKeys:
172
"""Get access keys for a queue authorization rule.
173
174
Args:
175
resource_group_name (str): Name of the resource group.
176
namespace_name (str): Name of the namespace.
177
queue_name (str): Name of the queue.
178
authorization_rule_name (str): Name of the authorization rule.
179
180
Returns:
181
AccessKeys: Primary and secondary keys with connection strings.
182
"""
183
184
def regenerate_keys(
185
self,
186
resource_group_name: str,
187
namespace_name: str,
188
queue_name: str,
189
authorization_rule_name: str,
190
parameters: RegenerateAccessKeyParameters
191
) -> AccessKeys:
192
"""Regenerate access keys for a queue authorization rule.
193
194
Args:
195
resource_group_name (str): Name of the resource group.
196
namespace_name (str): Name of the namespace.
197
queue_name (str): Name of the queue.
198
authorization_rule_name (str): Name of the authorization rule.
199
parameters (RegenerateAccessKeyParameters): Regeneration parameters.
200
201
Returns:
202
AccessKeys: New keys with connection strings.
203
"""
204
```
205
206
## Usage Examples
207
208
### Creating a Basic Queue
209
210
```python
211
from azure.mgmt.servicebus import ServiceBusManagementClient
212
from azure.mgmt.servicebus.models import SBQueue
213
from azure.identity import DefaultAzureCredential
214
from datetime import timedelta
215
216
client = ServiceBusManagementClient(DefaultAzureCredential(), subscription_id)
217
218
# Create a basic queue with default settings
219
queue_params = SBQueue(
220
max_size_in_megabytes=1024, # 1GB
221
default_message_time_to_live=timedelta(days=14) # 14 days TTL
222
)
223
224
queue = client.queues.create_or_update(
225
resource_group_name="my-resource-group",
226
namespace_name="my-servicebus-namespace",
227
queue_name="orders-queue",
228
parameters=queue_params
229
)
230
231
print(f"Queue created: {queue.name}")
232
print(f"Max size: {queue.max_size_in_megabytes} MB")
233
```
234
235
### Creating a Queue with Advanced Features
236
237
```python
238
from azure.mgmt.servicebus.models import EntityStatus
239
240
# Create a queue with advanced messaging features
241
advanced_queue_params = SBQueue(
242
max_size_in_megabytes=5120, # 5GB
243
lock_duration=timedelta(minutes=5), # Lock duration for message processing
244
max_delivery_count=10, # Max delivery attempts before dead lettering
245
requires_duplicate_detection=True, # Enable duplicate detection
246
duplicate_detection_history_time_window=timedelta(minutes=10),
247
dead_lettering_on_message_expiration=True, # Dead letter expired messages
248
enable_batched_operations=True, # Enable server-side batching
249
requires_session=True, # Enable message sessions for ordering
250
default_message_time_to_live=timedelta(days=7),
251
auto_delete_on_idle=timedelta(days=30), # Auto-delete if idle for 30 days
252
enable_partitioning=True, # Enable partitioning for higher throughput
253
status=EntityStatus.ACTIVE
254
)
255
256
advanced_queue = client.queues.create_or_update(
257
resource_group_name="my-resource-group",
258
namespace_name="my-servicebus-namespace",
259
queue_name="high-throughput-queue",
260
parameters=advanced_queue_params
261
)
262
```
263
264
### Creating a Queue with Message Forwarding
265
266
```python
267
# Create a queue that forwards messages to another queue
268
forwarding_queue_params = SBQueue(
269
max_size_in_megabytes=2048,
270
forward_to="processed-orders-queue", # Forward all messages here
271
forward_dead_lettered_messages_to="dead-letter-queue", # Forward dead letters
272
max_delivery_count=3,
273
dead_lettering_on_message_expiration=True
274
)
275
276
forwarding_queue = client.queues.create_or_update(
277
resource_group_name="my-resource-group",
278
namespace_name="my-servicebus-namespace",
279
queue_name="input-queue",
280
parameters=forwarding_queue_params
281
)
282
```
283
284
### Managing Queue Authorization Rules
285
286
```python
287
from azure.mgmt.servicebus.models import SBAuthorizationRule, AccessRights
288
289
# Create a listen-only authorization rule for consumers
290
listen_rule = SBAuthorizationRule(
291
rights=[AccessRights.LISTEN]
292
)
293
294
consumer_auth = client.queues.create_or_update_authorization_rule(
295
resource_group_name="my-resource-group",
296
namespace_name="my-servicebus-namespace",
297
queue_name="orders-queue",
298
authorization_rule_name="ConsumerPolicy",
299
parameters=listen_rule
300
)
301
302
# Create a send-only authorization rule for producers
303
send_rule = SBAuthorizationRule(
304
rights=[AccessRights.SEND]
305
)
306
307
producer_auth = client.queues.create_or_update_authorization_rule(
308
resource_group_name="my-resource-group",
309
namespace_name="my-servicebus-namespace",
310
queue_name="orders-queue",
311
authorization_rule_name="ProducerPolicy",
312
parameters=send_rule
313
)
314
315
# Get connection strings for each role
316
consumer_keys = client.queues.list_keys(
317
resource_group_name="my-resource-group",
318
namespace_name="my-servicebus-namespace",
319
queue_name="orders-queue",
320
authorization_rule_name="ConsumerPolicy"
321
)
322
323
producer_keys = client.queues.list_keys(
324
resource_group_name="my-resource-group",
325
namespace_name="my-servicebus-namespace",
326
queue_name="orders-queue",
327
authorization_rule_name="ProducerPolicy"
328
)
329
330
print(f"Consumer connection: {consumer_keys.primary_connection_string}")
331
print(f"Producer connection: {producer_keys.primary_connection_string}")
332
```
333
334
### Queue Monitoring and Statistics
335
336
```python
337
# Get queue details with message statistics
338
queue_info = client.queues.get(
339
resource_group_name="my-resource-group",
340
namespace_name="my-servicebus-namespace",
341
queue_name="orders-queue"
342
)
343
344
print(f"Queue: {queue_info.name}")
345
print(f"Status: {queue_info.status}")
346
print(f"Message count: {queue_info.message_count}")
347
print(f"Size in bytes: {queue_info.size_in_bytes}")
348
print(f"Created: {queue_info.created_at}")
349
print(f"Updated: {queue_info.updated_at}")
350
351
if queue_info.count_details:
352
details = queue_info.count_details
353
print(f"Active messages: {details.active_message_count}")
354
print(f"Dead letter messages: {details.dead_letter_message_count}")
355
print(f"Scheduled messages: {details.scheduled_message_count}")
356
```
357
358
## Types
359
360
```python { .api }
361
class SBQueue:
362
def __init__(self, **kwargs): ...
363
364
# Queue statistics (read-only)
365
count_details: Optional[MessageCountDetails]
366
created_at: Optional[datetime]
367
updated_at: Optional[datetime]
368
accessed_at: Optional[datetime]
369
size_in_bytes: Optional[int]
370
message_count: Optional[int]
371
372
# Queue configuration
373
lock_duration: Optional[timedelta] # Default: 1 minute, Max: 5 minutes
374
max_size_in_megabytes: Optional[int] # Default: 1024 MB
375
max_message_size_in_kilobytes: Optional[int] # Premium only, default: 1024 KB
376
requires_duplicate_detection: Optional[bool] # Default: False
377
requires_session: Optional[bool] # Default: False
378
default_message_time_to_live: Optional[timedelta] # Default: TimeSpan.Max
379
dead_lettering_on_message_expiration: Optional[bool] # Default: False
380
duplicate_detection_history_time_window: Optional[timedelta] # Default: 10 minutes
381
max_delivery_count: Optional[int] # Default: 10
382
status: Optional[Union[str, EntityStatus]] # Default: Active
383
enable_batched_operations: Optional[bool] # Default: True
384
auto_delete_on_idle: Optional[timedelta] # Minimum: 5 minutes
385
enable_partitioning: Optional[bool] # Default: False
386
enable_express: Optional[bool] # Default: False
387
forward_to: Optional[str] # Queue/topic name for message forwarding
388
forward_dead_lettered_messages_to: Optional[str] # Dead letter forwarding destination
389
390
class MessageCountDetails:
391
def __init__(self, **kwargs): ...
392
393
active_message_count: Optional[int]
394
dead_letter_message_count: Optional[int]
395
scheduled_message_count: Optional[int]
396
transfer_message_count: Optional[int]
397
transfer_dead_letter_message_count: Optional[int]
398
399
class SBAuthorizationRule:
400
def __init__(self, **kwargs): ...
401
402
rights: List[Union[str, AccessRights]]
403
404
class AccessKeys:
405
def __init__(self, **kwargs): ...
406
407
primary_connection_string: Optional[str]
408
secondary_connection_string: Optional[str]
409
alias_primary_connection_string: Optional[str] # For GEO DR scenarios
410
alias_secondary_connection_string: Optional[str] # For GEO DR scenarios
411
primary_key: Optional[str]
412
secondary_key: Optional[str]
413
key_name: Optional[str]
414
```