0
# Queue Storage Management
1

2
Azure Queue service configuration and individual queue management operations. Azure Queue storage provides reliable messaging between application components with support for large numbers of messages.
3

4
## Capabilities
5

6
### Queue Service Configuration
7

8
Configure queue service properties including CORS rules, logging, and metrics settings.
9

10
```python { .api }
11
class QueueServicesOperations:
12
    def get_service_properties(
13
        self,
14
        resource_group_name: str,
15
        account_name: str
16
    ) -> QueueServiceProperties:
17
        """
18
        Gets the properties of a storage account's Queue service.
19
        
20
        Parameters:
21
        - resource_group_name: Name of the resource group
22
        - account_name: Name of the storage account
23
        
24
        Returns:
25
        QueueServiceProperties with current configuration
26
        """
27
    
28
    def set_service_properties(
29
        self,
30
        resource_group_name: str,
31
        account_name: str,
32
        parameters: QueueServiceProperties
33
    ) -> QueueServiceProperties:
34
        """
35
        Sets the properties of a storage account's Queue service.
36
        
37
        Parameters:
38
        - resource_group_name: Name of the resource group
39
        - account_name: Name of the storage account
40
        - parameters: Queue service properties to configure
41
        
42
        Returns:
43
        Updated QueueServiceProperties
44
        """
45
    
46
    def list(
47
        self,
48
        resource_group_name: str,
49
        account_name: str
50
    ) -> ListQueueServices:
51
        """
52
        Lists all queue services for a storage account.
53
        
54
        Parameters:
55
        - resource_group_name: Name of the resource group
56
        - account_name: Name of the storage account
57
        
58
        Returns:
59
        ListQueueServices containing queue services
60
        """
61
```
62

63
Usage example:
64

65
```python
66
from azure.mgmt.storage.models import (
67
    QueueServiceProperties, CorsRules, CorsRule
68
)
69

70
# Configure queue service with CORS rules
71
cors_rule = CorsRule(
72
    allowed_origins=["https://myapp.com", "https://*.myapp.com"],
73
    allowed_methods=["GET", "POST", "PUT", "DELETE"],
74
    allowed_headers=["*"],
75
    exposed_headers=["x-ms-request-id", "x-ms-version"],
76
    max_age_in_seconds=3600
77
)
78

79
queue_properties = QueueServiceProperties(
80
    properties=QueueServicePropertiesProperties(
81
        cors=CorsRules(cors_rules=[cors_rule])
82
    )
83
)
84

85
updated_service = client.queue_services.set_service_properties(
86
    resource_group_name="my-resource-group",
87
    account_name="mystorageaccount123",
88
    parameters=queue_properties
89
)
90

91
# Get current queue service properties
92
current_properties = client.queue_services.get_service_properties(
93
    resource_group_name="my-resource-group",
94
    account_name="mystorageaccount123"
95
)
96

97
print(f"Queue service configured with {len(current_properties.cors.cors_rules)} CORS rules")
98
```
99

100
### Queue Management
101

102
Create, configure, and manage individual queues with metadata and access policies.
103

104
```python { .api }
105
class QueueOperations:
106
    def create(
107
        self,
108
        resource_group_name: str,
109
        account_name: str,
110
        queue_name: str,
111
        queue: StorageQueue
112
    ) -> StorageQueue:
113
        """
114
        Creates a new queue with the specified name.
115
        
116
        Parameters:
117
        - resource_group_name: Name of the resource group
118
        - account_name: Name of the storage account
119
        - queue_name: Name of the queue (3-63 chars, lowercase letters/numbers/hyphens)
120
        - queue: Queue properties and metadata
121
        
122
        Returns:
123
        Created StorageQueue
124
        """
125
    
126
    def update(
127
        self,
128
        resource_group_name: str,
129
        account_name: str,
130
        queue_name: str,
131
        queue: StorageQueue
132
    ) -> StorageQueue:
133
        """
134
        Updates queue properties or metadata.
135
        
136
        Parameters:
137
        - resource_group_name: Name of the resource group
138
        - account_name: Name of the storage account
139
        - queue_name: Name of the queue
140
        - queue: Updated queue properties
141
        
142
        Returns:
143
        Updated StorageQueue
144
        """
145
    
146
    def get(
147
        self,
148
        resource_group_name: str,
149
        account_name: str,
150
        queue_name: str
151
    ) -> StorageQueue:
152
        """
153
        Gets the queue with the specified name.
154
        
155
        Parameters:
156
        - resource_group_name: Name of the resource group
157
        - account_name: Name of the storage account
158
        - queue_name: Name of the queue
159
        
160
        Returns:
161
        StorageQueue with properties
162
        """
163
    
164
    def delete(
165
        self,
166
        resource_group_name: str,
167
        account_name: str,
168
        queue_name: str
169
    ) -> None:
170
        """
171
        Deletes the queue with the specified name.
172
        
173
        Parameters:
174
        - resource_group_name: Name of the resource group
175
        - account_name: Name of the storage account
176
        - queue_name: Name of the queue to delete
177
        """
178
    
179
    def list(
180
        self,
181
        resource_group_name: str,
182
        account_name: str,
183
        maxpagesize: Optional[str] = None,
184
        filter: Optional[str] = None
185
    ) -> ItemPaged[ListQueueResource]:
186
        """
187
        Lists all queues in a storage account.
188
        
189
        Parameters:
190
        - resource_group_name: Name of the resource group
191
        - account_name: Name of the storage account
192
        - maxpagesize: Maximum number of results per page
193
        - filter: OData filter expression
194
        
195
        Returns:
196
        Paginated list of ListQueueResource objects
197
        """
198
```
199

200
Usage example:
201

202
```python
203
from azure.mgmt.storage.models import StorageQueue
204

205
# Create a queue with metadata
206
queue_metadata = {
207
    "purpose": "order-processing",
208
    "environment": "production",
209
    "team": "backend"
210
}
211

212
new_queue = StorageQueue(
213
    properties=StorageQueueProperties(
214
        metadata=queue_metadata
215
    )
216
)
217

218
created_queue = client.queue.create(
219
    resource_group_name="my-resource-group",
220
    account_name="mystorageaccount123",
221
    queue_name="order-processing-queue",
222
    queue=new_queue
223
)
224

225
print(f"Created queue: {created_queue.name}")
226

227
# Create multiple queues for different purposes
228
queue_configs = [
229
    {"name": "high-priority-tasks", "metadata": {"priority": "high", "retention": "short"}},
230
    {"name": "low-priority-tasks", "metadata": {"priority": "low", "retention": "long"}},
231
    {"name": "notification-queue", "metadata": {"type": "notifications", "max-size": "small"}},
232
    {"name": "audit-log-queue", "metadata": {"type": "audit", "retention": "extended"}}
233
]
234

235
for config in queue_configs:
236
    queue = StorageQueue(
237
        properties=StorageQueueProperties(
238
            metadata=config["metadata"]
239
        )
240
    )
241
    
242
    client.queue.create(
243
        resource_group_name="my-resource-group",
244
        account_name="mystorageaccount123",
245
        queue_name=config["name"],
246
        queue=queue
247
    )
248

249
# List all queues
250
queues = list(client.queue.list(
251
    resource_group_name="my-resource-group",
252
    account_name="mystorageaccount123"
253
))
254

255
print(f"Total queues: {len(queues)}")
256
for queue in queues:
257
    print(f"Queue: {queue.name}")
258
    if hasattr(queue, 'metadata') and queue.metadata:
259
        print(f"  Metadata: {queue.metadata}")
260

261
# Update queue metadata
262
updated_metadata = {
263
    "purpose": "order-processing",
264
    "environment": "production", 
265
    "team": "backend",
266
    "last-updated": "2024-01-15",
267
    "max-messages": "1000"
268
}
269

270
updated_queue = StorageQueue(
271
    properties=StorageQueueProperties(
272
        metadata=updated_metadata
273
    )
274
)
275

276
client.queue.update(
277
    resource_group_name="my-resource-group",
278
    account_name="mystorageaccount123",
279
    queue_name="order-processing-queue",
280
    queue=updated_queue
281
)
282

283
# Get specific queue details
284
queue_details = client.queue.get(
285
    resource_group_name="my-resource-group",
286
    account_name="mystorageaccount123",
287
    queue_name="order-processing-queue"
288
)
289

290
print(f"Queue details for {queue_details.name}:")
291
print(f"  ID: {queue_details.id}")
292
print(f"  Type: {queue_details.type_}")
293
if hasattr(queue_details, 'properties') and queue_details.properties.metadata:
294
    print(f"  Metadata: {queue_details.properties.metadata}")
295
```
296

297
### Queue Access Control
298

299
Configure access policies and permissions for queue operations.
300

301
```python
302
# Example of using queues with access policies through SAS tokens
303
from azure.mgmt.storage.models import ServiceSasParameters, Services, SignedResourceTypes
304

305
# Generate SAS token for queue access
306
sas_params = ServiceSasParameters(
307
    canonical_name=f"/queue/mystorageaccount123/order-processing-queue",
308
    resource=SignedResource.Q,  # Queue
309
    permissions=Permissions.RAU,  # Read, Add, Update
310
    services=Services.Q,  # Queue service
311
    resource_types=SignedResourceTypes.O,  # Object
312
    shared_access_expiry_time=datetime.utcnow() + timedelta(hours=24)
313
)
314

315
sas_response = client.storage_accounts.list_service_sas(
316
    resource_group_name="my-resource-group",
317
    account_name="mystorageaccount123",
318
    parameters=sas_params
319
)
320

321
print(f"SAS token for queue access: {sas_response.service_sas_token}")
322
```
323

324
## Types
325

326
```python { .api }
327
class QueueServiceProperties:
328
    """Queue service properties configuration."""
329
    id: str
330
    name: str
331
    type_: str
332
    properties: QueueServicePropertiesProperties
333

334
class QueueServicePropertiesProperties:
335
    """Properties of queue service."""
336
    cors: CorsRules
337

338
class StorageQueue:
339
    """Storage queue resource."""
340
    id: str
341
    name: str
342
    type_: str
343
    properties: StorageQueueProperties
344

345
class StorageQueueProperties:
346
    """Properties of a storage queue."""
347
    metadata: Dict[str, str]
348
    approximate_message_count: int
349

350
class ListQueueResource:
351
    """Queue resource in list results."""
352
    name: str
353
    properties: StorageQueueProperties
354

355
class ListQueueServices:
356
    """List of queue services."""
357
    value: List[QueueServiceProperties]
358

359
class ListQueue:
360
    """List of queues."""
361
    value: List[ListQueueResource]
362
```