0
# Resource Management
1

2
Core Azure resource lifecycle management including deployments, resource groups, providers, and resource operations. The ResourceManagementClient is the primary client for most Azure resource management tasks, providing comprehensive CRUD operations and deployment capabilities.
3

4
## Capabilities
5

6
### Resource Groups
7

8
Manage Azure resource groups - logical containers that hold related resources for an Azure solution.
9

10
```python { .api }
11
from typing import Union, Optional, List, Dict, Any
12
from typing_extensions import Literal
13
from azure.core.polling import LROPoller
14
from azure.core.paging import ItemPaged
15
from io import IOBase
16

17
class ResourceGroupsOperations:
18
    def create_or_update(
19
        self, 
20
        resource_group_name: str, 
21
        parameters: Union[ResourceGroup, IO[bytes]],
22
        **kwargs
23
    ) -> ResourceGroup:
24
        """
25
        Create or update a resource group.
26
        
27
        Args:
28
            resource_group_name (str): The name of the resource group
29
            parameters (ResourceGroup): Resource group properties
30
            
31
        Returns:
32
            ResourceGroup: The created or updated resource group
33
        """
34

35
    def get(self, resource_group_name: str, **kwargs) -> ResourceGroup:  
36
        """
37
        Get a resource group.
38
        
39
        Args:
40
            resource_group_name (str): The name of the resource group
41
            
42
        Returns:
43
            ResourceGroup: The resource group details
44
        """
45

46
    def begin_delete(
47
        self, 
48
        resource_group_name: str, 
49
        force_deletion_types: Optional[str] = None,
50
        **kwargs
51
    ) -> LROPoller[None]:
52
        """
53
        Delete a resource group.
54
        
55
        Args:
56
            resource_group_name (str): The name of the resource group to delete
57
            force_deletion_types (str, optional): Comma-separated resource types to force delete
58
            
59
        Returns:
60
            LROPoller[None]: Long-running operation poller
61
        """
62

63
    def list(
64
        self, 
65
        filter: Optional[str] = None,
66
        top: Optional[int] = None,
67
        **kwargs
68
    ) -> ItemPaged[ResourceGroup]:
69
        """
70
        List all resource groups in a subscription.
71
        
72
        Args:
73
            filter (str, optional): OData filter expression
74
            top (int, optional): Maximum number of results to return
75
        
76
        Returns:
77
            ItemPaged[ResourceGroup]: Paginated list of resource groups
78
        """
79

80
    def update(
81
        self, 
82
        resource_group_name: str, 
83
        parameters: Union[ResourceGroupPatchable, IO[bytes]],
84
        **kwargs
85
    ) -> ResourceGroup:
86
        """
87
        Update a resource group (tags only).
88
        
89
        Args:
90
            resource_group_name (str): The name of the resource group
91
            parameters (ResourceGroupPatchable): Updated properties
92
            
93
        Returns:
94
            ResourceGroup: The updated resource group
95
        """
96

97
    def check_existence(self, resource_group_name: str, **kwargs) -> bool:
98
        """
99
        Check if a resource group exists.
100
        
101
        Args:
102
            resource_group_name (str): The name of the resource group
103
            
104
        Returns:
105
            bool: True if resource group exists, False otherwise
106
        """
107
```
108

109
**Usage Example:**
110

111
```python
112
from azure.mgmt.resource.resources.models import ResourceGroup
113

114
# Create a resource group
115
rg_params = ResourceGroup(
116
    location="East US",
117
    tags={"environment": "dev", "project": "myapp"}
118
)
119

120
resource_group = client.resource_groups.create_or_update(
121
    resource_group_name="my-resource-group",
122
    parameters=rg_params
123
)
124

125
# List all resource groups
126
for rg in client.resource_groups.list():
127
    print(f"{rg.name}: {rg.location}")
128
```
129

130
### Resources
131

132
Manage individual Azure resources across all resource types and providers.
133

134
```python { .api }
135
class ResourcesOperations:
136
    def begin_create_or_update(
137
        self,
138
        resource_group_name: str,
139
        resource_provider_namespace: str, 
140
        parent_resource_path: str,
141
        resource_type: str,
142
        resource_name: str,
143
        api_version: str,
144
        parameters: Union[GenericResource, IO[bytes]],
145
        **kwargs
146
    ) -> LROPoller[GenericResource]:
147
        """
148
        Create or update a resource.
149
        
150
        Args:
151
            resource_group_name (str): Resource group name
152
            resource_provider_namespace (str): Resource provider namespace
153
            parent_resource_path (str): Parent resource path
154
            resource_type (str): Resource type
155
            resource_name (str): Resource name
156
            api_version (str): API version to use for the resource provider
157
            parameters (GenericResource): Resource properties
158
            
159
        Returns:
160
            LROPoller[GenericResource]: Long-running operation poller
161
        """
162

163
    def get(
164
        self,
165
        resource_group_name: str,
166
        resource_provider_namespace: str,
167
        parent_resource_path: str, 
168
        resource_type: str,
169
        resource_name: str,
170
        api_version: str,
171
        **kwargs
172
    ) -> GenericResource:
173
        """
174
        Get a resource.
175
        
176
        Args:
177
            resource_group_name (str): Resource group name
178
            resource_provider_namespace (str): Resource provider namespace
179
            parent_resource_path (str): Parent resource path
180
            resource_type (str): Resource type
181
            resource_name (str): Resource name
182
            api_version (str): API version to use for the resource provider
183
        
184
        Returns:
185
            GenericResource: The resource details
186
        """
187

188
    def begin_delete(
189
        self,
190
        resource_group_name: str,
191
        resource_provider_namespace: str,
192
        parent_resource_path: str,
193
        resource_type: str, 
194
        resource_name: str,
195
        api_version: str,
196
        **kwargs
197
    ) -> LROPoller[None]:
198
        """
199
        Delete a resource.
200
        
201
        Args:
202
            resource_group_name (str): Resource group name
203
            resource_provider_namespace (str): Resource provider namespace
204
            parent_resource_path (str): Parent resource path
205
            resource_type (str): Resource type
206
            resource_name (str): Resource name
207
            api_version (str): API version to use for the resource provider
208
            
209
        Returns:
210
            LROPoller[None]: Long-running operation poller
211
        """
212

213
    def list(self, **kwargs) -> Iterable[GenericResource]:
214
        """
215
        List all resources in a subscription.
216
        
217
        Returns:
218
            Iterable[GenericResource]: Iterator of resources
219
        """
220

221
    def list_by_resource_group(
222
        self, 
223
        resource_group_name: str, 
224
        filter: Optional[str] = None,
225
        expand: Optional[str] = None,
226
        top: Optional[int] = None,
227
        **kwargs
228
    ) -> ItemPaged[GenericResourceExpanded]:
229
        """
230
        List resources in a resource group.
231
        
232
        Args:
233
            resource_group_name (str): Resource group name
234
            filter (str, optional): OData filter expression
235
            expand (str, optional): Comma-separated list of additional properties
236
            top (int, optional): Maximum number of results to return
237
            
238
        Returns:
239
            ItemPaged[GenericResourceExpanded]: Paginated list of resources
240
        """
241
```
242

243
### Deployments
244

245
Manage Azure Resource Manager (ARM) template deployments for infrastructure as code.
246

247
```python { .api }
248
class DeploymentsOperations:
249
    def begin_create_or_update(
250
        self,
251
        resource_group_name: str,
252
        deployment_name: str,
253
        parameters: Deployment,
254
        **kwargs
255
    ) -> LROPoller[DeploymentExtended]:
256
        """
257
        Deploy ARM template to resource group.
258
        
259
        Args:
260
            resource_group_name (str): Resource group name
261
            deployment_name (str): Deployment name
262
            parameters (Deployment): Deployment parameters
263
            
264
        Returns:
265
            LROPoller[DeploymentExtended]: Long-running operation poller
266
        """
267

268
    def get(
269
        self,
270
        resource_group_name: str, 
271
        deployment_name: str,
272
        **kwargs
273
    ) -> DeploymentExtended:
274
        """
275
        Get deployment details.
276
        
277
        Returns:
278
            DeploymentExtended: Deployment information
279
        """
280

281
    def begin_delete(
282
        self,
283
        resource_group_name: str,
284
        deployment_name: str, 
285
        **kwargs
286
    ) -> LROPoller[None]:
287
        """Delete a deployment."""
288

289
    def list_by_resource_group(
290
        self,
291
        resource_group_name: str,
292
        **kwargs  
293
    ) -> Iterable[DeploymentExtended]:
294
        """
295
        List deployments in a resource group.
296
        
297
        Returns:
298
            Iterable[DeploymentExtended]: Iterator of deployments
299
        """
300

301
    def begin_validate(
302
        self,
303
        resource_group_name: str,
304
        deployment_name: str,
305
        parameters: Union[Deployment, IO[bytes]],
306
        **kwargs
307
    ) -> LROPoller[DeploymentValidateResult]:
308
        """
309
        Validate deployment template and parameters.
310
        
311
        Args:
312
            resource_group_name (str): Resource group name
313
            deployment_name (str): Deployment name
314
            parameters (Deployment): Deployment parameters to validate
315
        
316
        Returns:
317
            LROPoller[DeploymentValidateResult]: Long-running validation operation
318
        """
319

320
    def begin_what_if(
321
        self,
322
        resource_group_name: str,
323
        deployment_name: str, 
324
        parameters: DeploymentWhatIf,
325
        **kwargs
326
    ) -> LROPoller[WhatIfOperationResult]:
327
        """
328
        Preview changes that would be made by deployment.
329
        
330
        Returns:
331
            LROPoller[WhatIfOperationResult]: What-if operation results
332
        """
333
```
334

335
### Resource Providers
336

337
Discover and manage Azure resource providers and their capabilities.
338

339
```python { .api }
340
class ProvidersOperations:
341
    def get(self, resource_provider_namespace: str, **kwargs) -> Provider:
342
        """
343
        Get resource provider information.
344
        
345
        Args:
346
            resource_provider_namespace (str): Provider namespace
347
            
348
        Returns:
349
            Provider: Provider details
350
        """
351

352
    def list(self, **kwargs) -> Iterable[Provider]:
353
        """
354
        List all resource providers.
355
        
356
        Returns:
357
            Iterable[Provider]: Iterator of providers
358
        """
359

360
    def register(self, resource_provider_namespace: str, **kwargs) -> Provider:
361
        """
362
        Register a resource provider.
363
        
364
        Args:
365
            resource_provider_namespace (str): Provider namespace
366
            
367
        Returns:
368
            Provider: Registered provider details
369
        """
370

371
    def unregister(self, resource_provider_namespace: str, **kwargs) -> Provider:
372
        """Unregister a resource provider."""
373
```
374

375
### Tags
376

377
Manage resource tags for organization and cost management.
378

379
```python { .api }
380
class TagsOperations:
381
    def create_or_update(self, tag_name: str, **kwargs) -> TagDetails:
382
        """
383
        Create or update a tag.
384
        
385
        Args:
386
            tag_name (str): Tag name
387
            
388
        Returns:
389
            TagDetails: Tag information
390
        """
391

392
    def delete(self, tag_name: str, **kwargs) -> None:
393
        """Delete a tag."""
394

395
    def list(self, **kwargs) -> Iterable[TagDetails]:
396
        """
397
        List all tags.
398
        
399
        Returns:
400
            Iterable[TagDetails]: Iterator of tags
401
        """
402

403
    def create_or_update_value(
404
        self, 
405
        tag_name: str, 
406
        tag_value: str, 
407
        **kwargs
408
    ) -> TagValue:
409
        """
410
        Create or update a tag value.
411
        
412
        Returns:
413
            TagValue: Tag value information
414
        """
415

416
    def create_or_update_at_scope(
417
        self,
418
        scope: str,
419
        parameters: TagsResource,
420
        **kwargs
421
    ) -> TagsResource:
422
        """
423
        Create or update tags at a specific scope.
424
        
425
        Args:
426
            scope (str): Resource scope
427
            parameters (TagsResource): Tag parameters
428
            
429
        Returns:
430
            TagsResource: Updated tags
431
        """
432
```
433

434
## Model Classes
435

436
```python { .api }
437
class ResourceGroup:
438
    """Resource group model."""
439
    id: str
440
    name: str
441
    type: str
442
    location: str
443
    properties: ResourceGroupProperties
444
    tags: Dict[str, str]
445
    managed_by: str
446

447
class GenericResource:
448
    """Generic resource model."""
449
    id: str
450
    name: str
451
    type: str
452
    location: str
453
    tags: Dict[str, str]
454
    plan: Plan
455
    properties: Any
456
    kind: str
457
    managed_by: str
458
    sku: Sku
459
    identity: Identity
460

461
class Deployment:
462
    """Deployment model."""
463
    properties: DeploymentProperties
464

465
class DeploymentProperties:
466
    """Deployment properties."""
467
    template: Any
468
    template_link: TemplateLink
469
    parameters: Any
470
    parameters_link: ParametersLink
471
    mode: DeploymentMode
472
    debug_setting: DebugSetting
473

474
class DeploymentExtended:
475
    """Extended deployment information."""
476
    id: str
477
    name: str
478
    type: str
479
    location: str
480
    properties: DeploymentPropertiesExtended
481

482
class Provider:
483
    """Resource provider model."""
484
    id: str
485
    namespace: str  
486
    registration_state: str
487
    resource_types: List[ProviderResourceType]
488

489
class TagDetails:
490
    """Tag details model."""
491
    id: str
492
    tag_name: str
493
    values: List[TagValue]
494
    count: TagCount
495

496
class GenericResourceExpanded(GenericResource):
497
    """Extended generic resource with additional properties."""
498
    created_time: str
499
    changed_time: str
500

501
class ResourceGroupProperties:
502
    """Resource group properties."""
503
    provisioning_state: str
504

505
class ResourceGroupPatchable:
506
    """Resource group patchable properties."""
507
    name: str
508
    tags: Dict[str, str]
509
    managed_by: str
510

511
class Plan:
512
    """Resource plan."""
513
    name: str
514
    publisher: str
515
    product: str
516
    promotion_code: str
517
    version: str
518

519
class Sku:
520
    """Resource SKU."""
521
    name: str
522
    tier: str
523
    size: str
524
    family: str
525
    capacity: int
526

527
class Identity:
528
    """Resource identity."""
529
    principal_id: str
530
    tenant_id: str
531
    type: str
532
    user_assigned_identities: Dict[str, Any]
533

534
class DeploymentPropertiesExtended:
535
    """Extended deployment properties."""
536
    provisioning_state: ProvisioningState
537
    correlation_id: str
538
    timestamp: str
539
    duration: str
540
    outputs: Any
541
    providers: List[Provider]
542
    dependencies: List[Dependency]
543

544
class DeploymentValidateResult:
545
    """Deployment validation result."""
546
    error: ErrorResponse
547
    properties: DeploymentPropertiesExtended
548

549
class WhatIfOperationResult:
550
    """What-if operation result."""
551
    status: str
552
    error: ErrorResponse
553
    properties: WhatIfOperationProperties
554

555
class DeploymentWhatIf:
556
    """Deployment what-if parameters."""
557
    location: str
558
    properties: DeploymentWhatIfProperties
559

560
class TemplateLink:
561
    """Template link."""
562
    uri: str
563
    content_version: str
564

565
class ParametersLink:
566
    """Parameters link."""
567
    uri: str
568
    content_version: str
569

570
class DebugSetting:
571
    """Debug setting."""
572
    detail_level: str
573

574
class ProviderResourceType:
575
    """Provider resource type."""
576
    resource_type: str
577
    locations: List[str]
578
    api_versions: List[str]
579
    capabilities: str
580

581
class TagValue:
582
    """Tag value."""
583
    id: str
584
    tag_value: str
585
    count: TagCount
586

587
class TagCount:
588
    """Tag count."""
589
    type: str
590
    value: int
591

592
class TagsResource:
593
    """Tags resource."""
594
    properties: TagsResourceProperties
595

596
class TagsResourceProperties:
597
    """Tags resource properties."""
598
    tags: Dict[str, str]
599

600
class ErrorResponse:
601
    """Error response."""
602
    code: str
603
    message: str
604
    target: str
605
    details: List[ErrorDetail]
606

607
class ErrorDetail:
608
    """Error detail."""
609
    code: str
610
    message: str
611
    target: str
612

613
class Dependency:
614
    """Deployment dependency."""
615
    depends_on: List[BasicDependency]
616
    id: str
617
    resource_type: str
618
    resource_name: str
619

620
class BasicDependency:
621
    """Basic dependency."""
622
    id: str
623
    resource_type: str
624
    resource_name: str
625

626
class WhatIfOperationProperties:
627
    """What-if operation properties."""
628
    changes: List[WhatIfChange]
629

630
class WhatIfChange:
631
    """What-if change."""
632
    resource_id: str
633
    change_type: str
634
    before: Any
635
    after: Any
636

637
class DeploymentWhatIfProperties:
638
    """Deployment what-if properties."""
639
    template: Any
640
    template_link: TemplateLink
641
    parameters: Any
642
    parameters_link: ParametersLink
643
    mode: DeploymentMode
644
```
645

646
## Enums
647

648
```python { .api }
649
class DeploymentMode(str, Enum):
650
    """Deployment modes."""
651
    INCREMENTAL = "Incremental"
652
    COMPLETE = "Complete"
653

654
class ProvisioningState(str, Enum):
655
    """Resource provisioning states."""
656
    SUCCEEDED = "Succeeded"
657
    FAILED = "Failed"
658
    CANCELED = "Canceled"
659
    ACCEPTED = "Accepted"
660
    CREATING = "Creating"
661
    CREATED = "Created"
662
    UPDATING = "Updating"
663
    UPDATED = "Updated"
664
    DELETING = "Deleting"
665
    DELETED = "Deleted"
666
    RUNNING = "Running"
667
```