0
# Protected Items
1

2
Management of items under backup protection including virtual machines, databases, file shares, and workloads. Provides comprehensive operations for enabling protection, modifying protection settings, monitoring backup status, and removing protection across all supported Azure Backup workload types.
3

4
## Capabilities
5

6
### Protected Item Management
7

8
Core operations for managing items that are currently protected by backup policies.
9

10
```python { .api }
11
class BackupProtectedItemsOperations:
12
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[BackupProtectedItemResource]:
13
        """
14
        List all protected items in a Recovery Services vault.
15

16
        Parameters:
17
        - resource_group_name: Resource group containing the vault
18
        - vault_name: Recovery Services vault name
19
        - kwargs: Filter options (backup_management_type, workload_type, etc.)
20

21
        Returns:
22
        Iterable of BackupProtectedItemResource objects
23
        """
24

25
class ProtectedItemsOperations:
26
    def get(
27
        self, 
28
        resource_group_name: str, 
29
        vault_name: str, 
30
        fabric_name: str, 
31
        container_name: str, 
32
        protected_item_name: str, 
33
        **kwargs
34
    ) -> BackupProtectedItemResource:
35
        """
36
        Get details of a specific protected item.
37

38
        Parameters:
39
        - resource_group_name: Resource group containing the vault
40
        - vault_name: Recovery Services vault name
41
        - fabric_name: Fabric name (usually "Azure")
42
        - container_name: Container name hosting the item
43
        - protected_item_name: Name of the protected item
44
        - kwargs: Additional options (expand, filter)
45

46
        Returns:
47
        BackupProtectedItemResource with detailed information
48
        """
49

50
    def create_or_update(
51
        self,
52
        resource_group_name: str,
53
        vault_name: str, 
54
        fabric_name: str,
55
        container_name: str,
56
        protected_item_name: str,
57
        parameters: BackupProtectedItemResource,
58
        **kwargs
59
    ) -> BackupProtectedItemResource:
60
        """
61
        Enable protection or update protection settings for an item.
62

63
        Parameters:
64
        - resource_group_name: Resource group containing the vault
65
        - vault_name: Recovery Services vault name
66
        - fabric_name: Fabric name (usually "Azure")
67
        - container_name: Container name hosting the item
68
        - protected_item_name: Name of the item to protect
69
        - parameters: Protection configuration details
70
        - kwargs: Additional options
71

72
        Returns:
73
        Updated BackupProtectedItemResource
74
        """
75

76
    def delete(
77
        self,
78
        resource_group_name: str,
79
        vault_name: str,
80
        fabric_name: str, 
81
        container_name: str,
82
        protected_item_name: str,
83
        **kwargs
84
    ) -> None:
85
        """
86
        Stop protection and optionally delete backup data for an item.
87

88
        Parameters:
89
        - resource_group_name: Resource group containing the vault
90
        - vault_name: Recovery Services vault name
91
        - fabric_name: Fabric name (usually "Azure")
92
        - container_name: Container name hosting the item
93
        - protected_item_name: Name of the protected item
94
        - kwargs: Options including delete_backup_data flag
95
        """
96
```
97

98
Usage example:
99

100
```python
101
# List all protected items
102
protected_items = client.backup_protected_items.list("my-rg", "my-vault")
103
for item in protected_items:
104
    print(f"Item: {item.name}, Type: {item.properties.workload_type}")
105

106
# Get specific protected VM
107
vm_item = client.protected_items.get(
108
    "my-rg", "my-vault", "Azure", "iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm", "vm;iaasvmcontainerv2;vm-rg;my-vm"
109
)
110
print(f"Protection status: {vm_item.properties.protection_status}")
111

112
# Enable protection for a VM
113
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
114
    BackupProtectedItemResource,
115
    AzureIaaSVMProtectedItem
116
)
117

118
protection_request = BackupProtectedItemResource(
119
    properties=AzureIaaSVMProtectedItem(
120
        backup_management_type="AzureIaasVM",
121
        workload_type="VM",
122
        policy_id="/subscriptions/sub-id/resourceGroups/my-rg/providers/Microsoft.RecoveryServices/vaults/my-vault/backupPolicies/DefaultPolicy",
123
        source_resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm"
124
    )
125
)
126

127
protected_item = client.protected_items.create_or_update(
128
    "my-rg", "my-vault", "Azure", "iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm", 
129
    "vm;iaasvmcontainerv2;vm-rg;my-vm", protection_request
130
)
131
```
132

133
### Protected Item Operations
134

135
Advanced operations for protected items including operation tracking and status monitoring.
136

137
```python { .api }
138
class ProtectedItemsOperations:
139
    def list(self, resource_group_name: str, vault_name: str, **kwargs) -> Iterable[ProtectedItemResource]:
140
        """List protected items with advanced filtering."""
141

142
    def get(
143
        self,
144
        resource_group_name: str,
145
        vault_name: str,
146
        fabric_name: str,
147
        container_name: str,
148
        protected_item_name: str,
149
        **kwargs
150
    ) -> ProtectedItemResource:
151
        """Get protected item with detailed properties."""
152

153
    def create_or_update(
154
        self,
155
        resource_group_name: str,
156
        vault_name: str,
157
        fabric_name: str,
158
        container_name: str, 
159
        protected_item_name: str,
160
        parameters: ProtectedItemResource,
161
        **kwargs
162
    ) -> ProtectedItemResource:
163
        """Create or update protected item configuration."""
164

165
    def delete(
166
        self,
167
        resource_group_name: str,
168
        vault_name: str,
169
        fabric_name: str,
170
        container_name: str,
171
        protected_item_name: str,
172
        **kwargs
173
    ) -> None:
174
        """Remove protection from item."""
175

176
class ProtectedItemOperationResultsOperations:
177
    def get(
178
        self,
179
        resource_group_name: str,
180
        vault_name: str,
181
        fabric_name: str,
182
        container_name: str,
183
        protected_item_name: str,
184
        operation_id: str,
185
        **kwargs
186
    ) -> ProtectedItemResource:
187
        """Get result of protected item operation."""
188

189
class ProtectedItemOperationStatusesOperations:
190
    def get(
191
        self,
192
        resource_group_name: str,
193
        vault_name: str,
194
        fabric_name: str,
195
        container_name: str,
196
        protected_item_name: str,
197
        operation_id: str,
198
        **kwargs
199
    ) -> OperationStatus:
200
        """Get status of protected item operation."""
201
```
202

203
## Protected Item Types
204

205
### Azure IaaS VM Protected Items
206

207
Protected items representing Azure virtual machines with comprehensive backup and restore capabilities.
208

209
```python { .api }
210
class AzureIaaSVMProtectedItem:
211
    def __init__(
212
        self,
213
        backup_management_type: str = "AzureIaasVM",
214
        workload_type: str = "VM",
215
        container_name: Optional[str] = None,
216
        source_resource_id: Optional[str] = None,
217
        policy_id: Optional[str] = None,
218
        last_recovery_point: Optional[datetime] = None,
219
        backup_set_name: Optional[str] = None,
220
        create_mode: Optional[str] = None,
221
        deferred_delete_time_in_utc: Optional[datetime] = None,
222
        is_deferred_delete_schedule_upcoming: Optional[bool] = None,
223
        is_rehydrate: Optional[bool] = None,
224
        resource_guard_operation_requests: Optional[List[str]] = None,
225
        is_archive_enabled: Optional[bool] = None,
226
        policy_name: Optional[str] = None,
227
        soft_delete_retention_period: Optional[int] = None,
228
        **kwargs
229
    ):
230
        """
231
        Azure IaaS VM protected item.
232

233
        Parameters:
234
        - backup_management_type: Always "AzureIaasVM"
235
        - workload_type: Always "VM"
236
        - container_name: Container hosting the VM
237
        - source_resource_id: Azure resource ID of the VM
238
        - policy_id: ID of the backup policy applied to the VM
239
        - last_recovery_point: Date/time of last successful backup
240
        - backup_set_name: Backup set identifier
241
        - create_mode: Protection creation mode
242
        - deferred_delete_time_in_utc: Soft delete expiration time
243
        - is_deferred_delete_schedule_upcoming: Whether soft delete is scheduled
244
        - is_rehydrate: Whether item is being rehydrated from archive
245
        - resource_guard_operation_requests: Resource guard operation identifiers
246
        - is_archive_enabled: Whether archive tier is enabled
247
        - policy_name: Name of the applied backup policy
248
        - soft_delete_retention_period: Soft delete retention period in days
249
        """
250

251
    backup_management_type: str
252
    workload_type: str
253
    container_name: Optional[str]
254
    source_resource_id: Optional[str]
255
    policy_id: Optional[str]
256
    last_recovery_point: Optional[datetime]
257
    backup_set_name: Optional[str]
258
    create_mode: Optional[str]
259
    deferred_delete_time_in_utc: Optional[datetime]
260
    is_deferred_delete_schedule_upcoming: Optional[bool]
261
    is_rehydrate: Optional[bool]
262
    resource_guard_operation_requests: Optional[List[str]]
263
    is_archive_enabled: Optional[bool]
264
    policy_name: Optional[str]
265
    soft_delete_retention_period: Optional[int]
266
    friendly_name: Optional[str]
267
    virtual_machine_id: Optional[str]
268
    protection_status: Optional[str]
269
    protection_state: Optional[str]
270
    health_status: Optional[str]
271
    health_details: Optional[List[AzureIaaSVMHealthDetails]]
272
    kpis_healths: Optional[Dict[str, AzureIaaSVMProtectedItemHealthStatus]]
273
    last_backup_status: Optional[str]
274
    last_backup_time: Optional[datetime]
275
    protected_item_data_id: Optional[str]
276
    protected_item_health_status: Optional[str]
277
    extended_info: Optional[AzureIaaSVMProtectedItemExtendedInfo]
278
```
279

280
### Azure File Share Protected Items
281

282
Protected items for Azure file shares with snapshot-based backup protection.
283

284
```python { .api }
285
class AzureFileshareProtectedItem:
286
    def __init__(
287
        self,
288
        backup_management_type: str = "AzureStorage",
289
        workload_type: str = "AzureFileShare",
290
        container_name: Optional[str] = None,
291
        source_resource_id: Optional[str] = None, 
292
        policy_id: Optional[str] = None,
293
        last_recovery_point: Optional[datetime] = None,
294
        friendly_name: Optional[str] = None,
295
        protection_status: Optional[str] = None,
296
        protection_state: Optional[str] = None,
297
        last_backup_status: Optional[str] = None,
298
        last_backup_time: Optional[datetime] = None,
299
        kpis_healths: Optional[Dict[str, str]] = None,
300
        extended_info: Optional[AzureFileshareProtectedItemExtendedInfo] = None,
301
        **kwargs
302
    ):
303
        """
304
        Azure file share protected item.
305

306
        Parameters:
307
        - backup_management_type: Always "AzureStorage"
308
        - workload_type: Always "AzureFileShare"
309
        - container_name: Storage account container name
310
        - source_resource_id: Azure resource ID of the file share
311
        - policy_id: ID of the backup policy
312
        - last_recovery_point: Date/time of last successful backup
313
        - friendly_name: Display name for the file share
314
        - protection_status: Current protection status
315
        - protection_state: Current protection state
316
        - last_backup_status: Status of the last backup operation
317
        - last_backup_time: Date/time of last backup attempt
318
        - kpis_healths: Key performance indicator health statuses
319
        - extended_info: Additional file share information
320
        """
321

322
    backup_management_type: str
323
    workload_type: str
324
    container_name: Optional[str]
325
    source_resource_id: Optional[str]
326
    policy_id: Optional[str]
327
    last_recovery_point: Optional[datetime]
328
    friendly_name: Optional[str]
329
    protection_status: Optional[str]
330
    protection_state: Optional[str]
331
    last_backup_status: Optional[str]
332
    last_backup_time: Optional[datetime]
333
    kpis_healths: Optional[Dict[str, str]]
334
    extended_info: Optional[AzureFileshareProtectedItemExtendedInfo]
335
```
336

337
### Azure SQL Protected Items
338

339
Protected items for SQL databases with transaction log backup support.
340

341
```python { .api }
342
class AzureSqlProtectedItem:
343
    def __init__(
344
        self,
345
        backup_management_type: str = "AzureSql",
346
        workload_type: str = "SQLDB",
347
        container_name: Optional[str] = None,
348
        source_resource_id: Optional[str] = None,
349
        policy_id: Optional[str] = None,
350
        last_recovery_point: Optional[datetime] = None,
351
        protection_status: Optional[str] = None,
352
        protection_state: Optional[str] = None,
353
        extended_info: Optional[AzureSqlProtectedItemExtendedInfo] = None,
354
        **kwargs
355
    ):
356
        """
357
        Azure SQL database protected item.
358

359
        Parameters:
360
        - backup_management_type: Always "AzureSql"
361
        - workload_type: Always "SQLDB"
362
        - container_name: SQL server container name
363
        - source_resource_id: Azure resource ID of the SQL database
364
        - policy_id: ID of the backup policy
365
        - last_recovery_point: Date/time of last successful backup
366
        - protection_status: Current protection status
367
        - protection_state: Current protection state
368
        - extended_info: Additional SQL database information
369
        """
370

371
    backup_management_type: str
372
    workload_type: str
373
    container_name: Optional[str]
374
    source_resource_id: Optional[str]
375
    policy_id: Optional[str]
376
    last_recovery_point: Optional[datetime]
377
    protection_status: Optional[str]
378
    protection_state: Optional[str]
379
    extended_info: Optional[AzureSqlProtectedItemExtendedInfo]
380
```
381

382
### Azure VM Workload Protected Items
383

384
Protected items for workloads running inside Azure VMs (SQL Server, SAP HANA, etc.).
385

386
```python { .api }
387
class AzureVmWorkloadProtectedItem:
388
    def __init__(
389
        self,
390
        backup_management_type: str = "AzureWorkload",
391
        workload_type: Optional[str] = None,
392
        container_name: Optional[str] = None,
393
        source_resource_id: Optional[str] = None,
394
        policy_id: Optional[str] = None,
395
        last_recovery_point: Optional[datetime] = None,
396
        friendly_name: Optional[str] = None,
397
        server_name: Optional[str] = None,
398
        parent_name: Optional[str] = None,
399
        parent_type: Optional[str] = None,
400
        protection_status: Optional[str] = None,
401
        protection_state: Optional[str] = None,
402
        last_backup_status: Optional[str] = None,
403
        last_backup_time: Optional[datetime] = None,
404
        last_backup_error_detail: Optional[ErrorDetail] = None,
405
        protected_item_data_source_id: Optional[str] = None,
406
        protected_item_health_status: Optional[str] = None,
407
        extended_info: Optional[AzureVmWorkloadProtectedItemExtendedInfo] = None,
408
        kpis_healths: Optional[Dict[str, str]] = None,
409
        **kwargs
410
    ):
411
        """
412
        Azure VM workload protected item.
413

414
        Parameters:
415
        - backup_management_type: Always "AzureWorkload"
416
        - workload_type: Type of workload ("SQLDataBase", "SAPHanaDatabase", etc.)
417
        - container_name: VM container name
418
        - source_resource_id: Azure resource ID of the workload
419
        - policy_id: ID of the backup policy
420
        - last_recovery_point: Date/time of last successful backup
421
        - friendly_name: Display name for the workload
422
        - server_name: Name of the server hosting the workload
423
        - parent_name: Name of the parent component
424
        - parent_type: Type of the parent component
425
        - protection_status: Current protection status
426
        - protection_state: Current protection state
427
        - last_backup_status: Status of the last backup operation
428
        - last_backup_time: Date/time of last backup attempt
429
        - last_backup_error_detail: Details of the last backup error
430
        - protected_item_data_source_id: Data source identifier
431
        - protected_item_health_status: Health status of the protected item
432
        - extended_info: Additional workload information
433
        - kpis_healths: Key performance indicator health statuses
434
        """
435

436
    backup_management_type: str
437
    workload_type: Optional[str]
438
    container_name: Optional[str]
439
    source_resource_id: Optional[str]
440
    policy_id: Optional[str]
441
    last_recovery_point: Optional[datetime]
442
    friendly_name: Optional[str]
443
    server_name: Optional[str]
444
    parent_name: Optional[str]
445
    parent_type: Optional[str]
446
    protection_status: Optional[str]
447
    protection_state: Optional[str]
448
    last_backup_status: Optional[str]
449
    last_backup_time: Optional[datetime]
450
    last_backup_error_detail: Optional[ErrorDetail]
451
    protected_item_data_source_id: Optional[str]
452
    protected_item_health_status: Optional[str]
453
    extended_info: Optional[AzureVmWorkloadProtectedItemExtendedInfo]
454
    kpis_healths: Optional[Dict[str, str]]
455
```
456

457
## Usage Examples
458

459
### Enable VM Protection
460

461
```python
462
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
463
    BackupProtectedItemResource,
464
    AzureIaaSVMProtectedItem
465
)
466

467
# Enable backup protection for an Azure VM
468
vm_protection = BackupProtectedItemResource(
469
    properties=AzureIaaSVMProtectedItem(
470
        backup_management_type="AzureIaasVM",
471
        workload_type="VM",
472
        policy_id="/subscriptions/sub-id/resourceGroups/my-rg/providers/Microsoft.RecoveryServices/vaults/my-vault/backupPolicies/DefaultPolicy",
473
        source_resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm"
474
    )
475
)
476

477
protected_vm = client.protected_items.create_or_update(
478
    resource_group_name="my-rg",
479
    vault_name="my-vault",
480
    fabric_name="Azure",
481
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
482
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
483
    parameters=vm_protection
484
)
485

486
print(f"VM protection enabled: {protected_vm.properties.protection_status}")
487
```
488

489
### Stop Protection and Delete Data
490

491
```python
492
# Stop protection and delete backup data
493
client.protected_items.delete(
494
    resource_group_name="my-rg",
495
    vault_name="my-vault", 
496
    fabric_name="Azure",
497
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
498
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
499
    delete_backup_data=True
500
)
501
```
502

503
### Monitor Protection Status
504

505
```python
506
# Get detailed protection information
507
protected_item = client.protected_items.get(
508
    "my-rg", "my-vault", "Azure", 
509
    "iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
510
    "vm;iaasvmcontainerv2;vm-rg;my-vm"
511
)
512

513
print(f"Protection Status: {protected_item.properties.protection_status}")
514
print(f"Last Backup: {protected_item.properties.last_backup_time}")
515
print(f"Last Recovery Point: {protected_item.properties.last_recovery_point}")
516
print(f"Health Status: {protected_item.properties.health_status}")
517

518
if hasattr(protected_item.properties, 'health_details'):
519
    for detail in protected_item.properties.health_details:
520
        print(f"Health Detail: {detail.message}")
521
```