0
# Restore Operations
1

2
Comprehensive restore capabilities including full restore, file-level restore, and recovery point management. Supports various restore targets and scenarios with detailed restore job tracking, flexible recovery point selection, and advanced restore configurations across all Azure Backup workload types.
3

4
## Capabilities
5

6
### Restore Execution
7

8
Core operations for triggering and managing restore operations across all supported workload types.
9

10
```python { .api }
11
class RestoresOperations:
12
    def trigger(
13
        self,
14
        resource_group_name: str,
15
        vault_name: str,
16
        fabric_name: str,
17
        container_name: str,
18
        protected_item_name: str,
19
        recovery_point_id: str,
20
        parameters: RestoreRequestResource,
21
        **kwargs
22
    ) -> None:
23
        """
24
        Trigger a restore operation for a protected item.
25

26
        Parameters:
27
        - resource_group_name: Resource group containing the vault
28
        - vault_name: Recovery Services vault name
29
        - fabric_name: Fabric name (usually "Azure")
30
        - container_name: Container hosting the protected item
31
        - protected_item_name: Name of the protected item
32
        - recovery_point_id: ID of the recovery point to restore from
33
        - parameters: Restore request configuration
34
        - kwargs: Additional options
35

36
        Returns:
37
        None (operation is asynchronous - monitor via job operations)
38
        """
39
```
40

41
Usage example:
42

43
```python
44
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
45
    RestoreRequestResource,
46
    IaasVMRestoreRequest
47
)
48

49
# Restore VM to original location
50
restore_request = RestoreRequestResource(
51
    properties=IaasVMRestoreRequest(
52
        recovery_point_id="recovery-point-id-12345",
53
        recovery_type="OriginalLocation",
54
        create_new_cloud_service=False,
55
        original_storage_account_option=False,
56
        encryption_details={
57
            "encryption_enabled": False
58
        }
59
    )
60
)
61

62
client.restores.trigger(
63
    resource_group_name="my-rg",
64
    vault_name="my-vault",
65
    fabric_name="Azure",
66
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
67
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
68
    recovery_point_id="recovery-point-id-12345",
69
    parameters=restore_request
70
)
71

72
print("Restore operation triggered successfully")
73
```
74

75
### Recovery Point Management
76

77
Operations for discovering, listing, and managing recovery points available for restore.
78

79
```python { .api }
80
class RecoveryPointsOperations:
81
    def list(
82
        self,
83
        resource_group_name: str,
84
        vault_name: str,
85
        fabric_name: str,
86
        container_name: str,
87
        protected_item_name: str,
88
        **kwargs
89
    ) -> Iterable[RecoveryPointResource]:
90
        """
91
        List recovery points for a protected item.
92

93
        Parameters:
94
        - resource_group_name: Resource group containing the vault
95
        - vault_name: Recovery Services vault name
96
        - fabric_name: Fabric name (usually "Azure")
97
        - container_name: Container hosting the protected item
98
        - protected_item_name: Name of the protected item
99
        - kwargs: Filter options (start_date, end_date, etc.)
100

101
        Returns:
102
        Iterable of RecoveryPointResource objects
103
        """
104

105
    def get(
106
        self,
107
        resource_group_name: str,
108
        vault_name: str,
109
        fabric_name: str,
110
        container_name: str,
111
        protected_item_name: str,
112
        recovery_point_id: str,
113
        **kwargs
114
    ) -> RecoveryPointResource:
115
        """
116
        Get details of a specific recovery point.
117

118
        Parameters:
119
        - resource_group_name: Resource group containing the vault
120
        - vault_name: Recovery Services vault name
121
        - fabric_name: Fabric name (usually "Azure")
122
        - container_name: Container hosting the protected item
123
        - protected_item_name: Name of the protected item
124
        - recovery_point_id: ID of the recovery point
125
        - kwargs: Additional options
126

127
        Returns:
128
        RecoveryPointResource with detailed recovery point information
129
        """
130
```
131

132
Usage example:
133

134
```python
135
# List recovery points for a VM
136
recovery_points = client.recovery_points.list(
137
    "my-rg", "my-vault", "Azure",
138
    "iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
139
    "vm;iaasvmcontainerv2;vm-rg;my-vm"
140
)
141

142
for rp in recovery_points:
143
    print(f"Recovery Point: {rp.name}, Time: {rp.properties.recovery_point_time}")
144

145
# Get specific recovery point details
146
latest_rp = client.recovery_points.get(
147
    "my-rg", "my-vault", "Azure",
148
    "iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm", 
149
    "vm;iaasvmcontainerv2;vm-rg;my-vm",
150
    "recovery-point-id-12345"
151
)
152

153
print(f"Recovery Point Type: {latest_rp.properties.recovery_point_type}")
154
print(f"Consistency Type: {latest_rp.properties.recovery_point_additional_info}")
155
```
156

157
## Restore Request Types
158

159
### IaaS VM Restore Request
160

161
Restore request for Azure virtual machines with various restore scenarios.
162

163
```python { .api }
164
class IaasVMRestoreRequest:
165
    def __init__(
166
        self,
167
        recovery_point_id: Optional[str] = None,
168
        recovery_type: Optional[str] = None,
169
        source_resource_id: Optional[str] = None,
170
        target_virtual_machine_id: Optional[str] = None,
171
        target_resource_group_id: Optional[str] = None,
172
        storage_account_id: Optional[str] = None,
173
        virtual_network_id: Optional[str] = None,
174
        subnet_id: Optional[str] = None,
175
        target_domain_name_id: Optional[str] = None,
176
        region: Optional[str] = None,
177
        affinity_group: Optional[str] = None,
178
        create_new_cloud_service: Optional[bool] = None,
179
        original_storage_account_option: Optional[bool] = None,
180
        encryption_details: Optional[EncryptionDetails] = None,
181
        restore_disk_lun_list: Optional[List[int]] = None,
182
        restore_with_managed_disks: Optional[bool] = None,
183
        disk_encryption_set_id: Optional[str] = None,
184
        zones: Optional[List[str]] = None,
185
        identity_info: Optional[IdentityInfo] = None,
186
        identity_based_restore_details: Optional[IdentityBasedRestoreDetails] = None,
187
        **kwargs
188
    ):
189
        """
190
        IaaS VM restore request.
191

192
        Parameters:
193
        - recovery_point_id: ID of the recovery point to restore from
194
        - recovery_type: "OriginalLocation", "AlternateLocation", "RestoreDisks"
195
        - source_resource_id: Resource ID of the source VM
196
        - target_virtual_machine_id: Target VM resource ID (for alternate location)
197
        - target_resource_group_id: Target resource group ID
198
        - storage_account_id: Storage account for restore operation
199
        - virtual_network_id: Target virtual network ID
200
        - subnet_id: Target subnet ID
201
        - target_domain_name_id: Target domain name ID
202
        - region: Target Azure region
203
        - affinity_group: Affinity group for the restore
204
        - create_new_cloud_service: Whether to create a new cloud service
205
        - original_storage_account_option: Use original storage account
206
        - encryption_details: Encryption configuration for restored VM
207
        - restore_disk_lun_list: List of disk LUNs to restore
208
        - restore_with_managed_disks: Whether to restore as managed disks
209
        - disk_encryption_set_id: Disk encryption set ID
210
        - zones: Availability zones for the restored VM
211
        - identity_info: Managed identity information
212
        - identity_based_restore_details: Identity-based restore configuration
213
        """
214

215
    recovery_point_id: Optional[str]
216
    recovery_type: Optional[str]
217
    source_resource_id: Optional[str]
218
    target_virtual_machine_id: Optional[str]
219
    target_resource_group_id: Optional[str]
220
    storage_account_id: Optional[str]
221
    virtual_network_id: Optional[str]
222
    subnet_id: Optional[str]
223
    target_domain_name_id: Optional[str]
224
    region: Optional[str]
225
    affinity_group: Optional[str]
226
    create_new_cloud_service: Optional[bool]
227
    original_storage_account_option: Optional[bool]
228
    encryption_details: Optional[EncryptionDetails]
229
    restore_disk_lun_list: Optional[List[int]]
230
    restore_with_managed_disks: Optional[bool]
231
    disk_encryption_set_id: Optional[str]
232
    zones: Optional[List[str]]
233
    identity_info: Optional[IdentityInfo]
234
    identity_based_restore_details: Optional[IdentityBasedRestoreDetails]
235
```
236

237
### Azure File Share Restore Request
238

239
Restore request for Azure file shares with file-level and share-level restore options.
240

241
```python { .api }
242
class AzureFileShareRestoreRequest:
243
    def __init__(
244
        self,
245
        recovery_type: Optional[str] = None,
246
        source_resource_id: Optional[str] = None,
247
        copy_options: Optional[str] = None,
248
        restore_request_type: Optional[str] = None,
249
        restore_file_specs: Optional[List[RestoreFileSpecs]] = None,
250
        target_details: Optional[TargetAFSRestoreInfo] = None,
251
        **kwargs
252
    ):
253
        """
254
        Azure file share restore request.
255

256
        Parameters:
257
        - recovery_type: "OriginalLocation", "AlternateLocation"
258
        - source_resource_id: Resource ID of the source file share
259
        - copy_options: "CreateCopy", "Skip", "Overwrite", "FailOnConflict"
260
        - restore_request_type: "FullShareRestore", "ItemLevelRestore"
261
        - restore_file_specs: List of files/folders to restore (for item-level)
262
        - target_details: Target file share details (for alternate location)
263
        """
264

265
    recovery_type: Optional[str]
266
    source_resource_id: Optional[str]
267
    copy_options: Optional[str]
268
    restore_request_type: Optional[str]
269
    restore_file_specs: Optional[List[RestoreFileSpecs]]
270
    target_details: Optional[TargetAFSRestoreInfo]
271
```
272

273
### Azure Workload Restore Request
274

275
Restore request for workloads running inside Azure VMs (SQL Server, SAP HANA, etc.).
276

277
```python { .api }
278
class AzureWorkloadRestoreRequest:
279
    def __init__(
280
        self,
281
        recovery_type: Optional[str] = None,
282
        source_resource_id: Optional[str] = None,
283
        property_bag: Optional[Dict[str, str]] = None,
284
        target_info: Optional[TargetRestoreInfo] = None,
285
        recovery_mode: Optional[str] = None,
286
        target_virtual_machine_id: Optional[str] = None,
287
        **kwargs
288
    ):
289
        """
290
        Azure workload restore request.
291

292
        Parameters:
293
        - recovery_type: "OriginalLocation", "AlternateLocation"
294
        - source_resource_id: Resource ID of the source workload
295
        - property_bag: Additional properties for the restore
296
        - target_info: Target workload details
297
        - recovery_mode: "FileRecovery", "WorkloadRecovery"
298
        - target_virtual_machine_id: Target VM resource ID
299
        """
300

301
    recovery_type: Optional[str]
302
    source_resource_id: Optional[str]
303
    property_bag: Optional[Dict[str, str]]
304
    target_info: Optional[TargetRestoreInfo]
305
    recovery_mode: Optional[str]
306
    target_virtual_machine_id: Optional[str]
307
```
308

309
### Azure Workload SQL Point In Time Restore Request
310

311
Specialized restore request for SQL databases with point-in-time recovery.
312

313
```python { .api }
314
class AzureWorkloadSQLPointInTimeRestoreRequest:
315
    def __init__(
316
        self,
317
        recovery_type: Optional[str] = None,
318
        source_resource_id: Optional[str] = None,
319
        property_bag: Optional[Dict[str, str]] = None,
320
        target_info: Optional[TargetRestoreInfo] = None,
321
        recovery_mode: Optional[str] = None,
322
        target_virtual_machine_id: Optional[str] = None,
323
        point_in_time: Optional[datetime] = None,
324
        **kwargs
325
    ):
326
        """
327
        Azure workload SQL point-in-time restore request.
328

329
        Parameters:
330
        - recovery_type: "OriginalLocation", "AlternateLocation"
331
        - source_resource_id: Resource ID of the source SQL database
332
        - property_bag: Additional properties for the restore
333
        - target_info: Target database details
334
        - recovery_mode: "FileRecovery", "WorkloadRecovery"
335
        - target_virtual_machine_id: Target VM resource ID
336
        - point_in_time: Point in time to restore to
337
        """
338

339
    recovery_type: Optional[str]
340
    source_resource_id: Optional[str]
341
    property_bag: Optional[Dict[str, str]]
342
    target_info: Optional[TargetRestoreInfo]
343
    recovery_mode: Optional[str]
344
    target_virtual_machine_id: Optional[str]
345
    point_in_time: Optional[datetime]
346
```
347

348
## Recovery Point Types
349

350
### IaaS VM Recovery Point
351

352
Recovery point information for Azure virtual machines.
353

354
```python { .api }
355
class IaasVMRecoveryPoint:
356
    def __init__(
357
        self,
358
        recovery_point_type: Optional[str] = None,
359
        recovery_point_time: Optional[datetime] = None,
360
        recovery_point_additional_info: Optional[str] = None,
361
        source_vm_storage_type: Optional[str] = None,
362
        is_source_vm_encrypted: Optional[bool] = None,
363
        key_and_secret: Optional[KeyAndSecretDetails] = None,
364
        is_instant_ilr_session_active: Optional[bool] = None,
365
        recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]] = None,
366
        is_managed_virtual_machine: Optional[bool] = None,
367
        virtual_machine_size: Optional[str] = None,
368
        original_storage_account_option: Optional[bool] = None,
369
        os_type: Optional[str] = None,
370
        recovery_point_disk_configuration: Optional[RecoveryPointDiskConfiguration] = None,
371
        zones: Optional[List[str]] = None,
372
        **kwargs
373
    ):
374
        """
375
        IaaS VM recovery point.
376

377
        Parameters:
378
        - recovery_point_type: "AppConsistent", "CrashConsistent", "FileSystemConsistent"
379
        - recovery_point_time: Time when the recovery point was created
380
        - recovery_point_additional_info: Additional recovery point information
381
        - source_vm_storage_type: Storage type of the source VM
382
        - is_source_vm_encrypted: Whether the source VM is encrypted
383
        - key_and_secret: Encryption key and secret details
384
        - is_instant_ilr_session_active: Whether instant ILR session is active
385
        - recovery_point_tier_details: Tier information for the recovery point
386
        - is_managed_virtual_machine: Whether VM uses managed disks
387
        - virtual_machine_size: Size of the virtual machine
388
        - original_storage_account_option: Original storage account option
389
        - os_type: Operating system type
390
        - recovery_point_disk_configuration: Disk configuration details
391
        - zones: Availability zones
392
        """
393

394
    recovery_point_type: Optional[str]
395
    recovery_point_time: Optional[datetime]
396
    recovery_point_additional_info: Optional[str]
397
    source_vm_storage_type: Optional[str]
398
    is_source_vm_encrypted: Optional[bool]
399
    key_and_secret: Optional[KeyAndSecretDetails]
400
    is_instant_ilr_session_active: Optional[bool]
401
    recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]]
402
    is_managed_virtual_machine: Optional[bool]
403
    virtual_machine_size: Optional[str]
404
    original_storage_account_option: Optional[bool]
405
    os_type: Optional[str]
406
    recovery_point_disk_configuration: Optional[RecoveryPointDiskConfiguration]
407
    zones: Optional[List[str]]
408
```
409

410
### Azure File Share Recovery Point
411

412
Recovery point information for Azure file shares.
413

414
```python { .api }
415
class AzureFileShareRecoveryPoint:
416
    def __init__(
417
        self,
418
        recovery_point_type: Optional[str] = None,
419
        recovery_point_time: Optional[datetime] = None,
420
        file_share_snapshot_uri: Optional[str] = None,
421
        recovery_point_size_in_gb: Optional[int] = None,
422
        recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]] = None,
423
        **kwargs
424
    ):
425
        """
426
        Azure file share recovery point.
427

428
        Parameters:
429
        - recovery_point_type: Type of recovery point
430
        - recovery_point_time: Time when the recovery point was created
431
        - file_share_snapshot_uri: URI of the file share snapshot
432
        - recovery_point_size_in_gb: Size of the recovery point in GB
433
        - recovery_point_tier_details: Tier information for the recovery point
434
        """
435

436
    recovery_point_type: Optional[str]
437
    recovery_point_time: Optional[datetime]
438
    file_share_snapshot_uri: Optional[str]
439
    recovery_point_size_in_gb: Optional[int]
440
    recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]]
441
```
442

443
### Azure Workload Recovery Point
444

445
Recovery point information for workloads running inside Azure VMs.
446

447
```python { .api }
448
class AzureWorkloadRecoveryPoint:
449
    def __init__(
450
        self,
451
        recovery_point_time_in_utc: Optional[datetime] = None,
452
        type: Optional[str] = None,
453
        recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]] = None,
454
        recovery_point_move_readiness_info: Optional[Dict[str, RecoveryPointMoveReadinessInfo]] = None,
455
        **kwargs
456
    ):
457
        """
458
        Azure workload recovery point.
459

460
        Parameters:
461
        - recovery_point_time_in_utc: UTC time when recovery point was created
462
        - type: Type of recovery point ("Full", "Log", "Differential")
463
        - recovery_point_tier_details: Tier information for the recovery point
464
        - recovery_point_move_readiness_info: Move readiness information
465
        """
466

467
    recovery_point_time_in_utc: Optional[datetime]
468
    type: Optional[str]
469
    recovery_point_tier_details: Optional[List[RecoveryPointTierInformation]]
470
    recovery_point_move_readiness_info: Optional[Dict[str, RecoveryPointMoveReadinessInfo]]
471
```
472

473
## Usage Examples
474

475
### Restore VM to Original Location
476

477
```python
478
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
479
    RestoreRequestResource,
480
    IaasVMRestoreRequest
481
)
482

483
# Restore VM to its original location
484
restore_request = RestoreRequestResource(
485
    properties=IaasVMRestoreRequest(
486
        recovery_point_id="recovery-point-id-12345",
487
        recovery_type="OriginalLocation",
488
        source_resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
489
        create_new_cloud_service=False,
490
        original_storage_account_option=True,
491
        encryption_details={"encryption_enabled": False}
492
    )
493
)
494

495
client.restores.trigger(
496
    resource_group_name="my-rg",
497
    vault_name="my-vault",
498
    fabric_name="Azure",
499
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
500
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
501
    recovery_point_id="recovery-point-id-12345",
502
    parameters=restore_request
503
)
504
```
505

506
### Restore VM to Alternate Location
507

508
```python
509
# Restore VM to different resource group/location
510
alternate_restore = RestoreRequestResource(
511
    properties=IaasVMRestoreRequest(
512
        recovery_point_id="recovery-point-id-12345",
513
        recovery_type="AlternateLocation",
514
        source_resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
515
        target_resource_group_id="/subscriptions/sub-id/resourceGroups/restored-vms",
516
        storage_account_id="/subscriptions/sub-id/resourceGroups/storage-rg/providers/Microsoft.Storage/storageAccounts/restorestorage",
517
        virtual_network_id="/subscriptions/sub-id/resourceGroups/network-rg/providers/Microsoft.Network/virtualNetworks/restore-vnet",
518
        subnet_id="/subscriptions/sub-id/resourceGroups/network-rg/providers/Microsoft.Network/virtualNetworks/restore-vnet/subnets/default",
519
        region="eastus2",
520
        restore_with_managed_disks=True
521
    )
522
)
523

524
client.restores.trigger(
525
    resource_group_name="my-rg",
526
    vault_name="my-vault",
527
    fabric_name="Azure",
528
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
529
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm",
530
    recovery_point_id="recovery-point-id-12345",
531
    parameters=alternate_restore
532
)
533
```
534

535
### Restore Specific Files from File Share
536

537
```python
538
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
539
    RestoreRequestResource,
540
    AzureFileShareRestoreRequest,
541
    RestoreFileSpecs
542
)
543

544
# Restore specific files from Azure file share
545
file_restore = RestoreRequestResource(
546
    properties=AzureFileShareRestoreRequest(
547
        recovery_type="OriginalLocation",
548
        source_resource_id="/subscriptions/sub-id/resourceGroups/storage-rg/providers/Microsoft.Storage/storageAccounts/mystorageaccount/fileServices/default/fileshares/myfileshare",
549
        copy_options="Overwrite",
550
        restore_request_type="ItemLevelRestore",
551
        restore_file_specs=[
552
            RestoreFileSpecs(
553
                path="documents/important.docx",
554
                file_spec_type="File",
555
                target_folder_path="restored/"
556
            ),
557
            RestoreFileSpecs(
558
                path="data/",
559
                file_spec_type="Folder", 
560
                target_folder_path="restored/"
561
            )
562
        ]
563
    )
564
)
565

566
client.restores.trigger(
567
    resource_group_name="my-rg",
568
    vault_name="my-vault",
569
    fabric_name="Azure",
570
    container_name="storagecontainer;storage;storage-rg;mystorageaccount",
571
    protected_item_name="azurefileshare;myfileshare",
572
    recovery_point_id="recovery-point-id-12345",
573
    parameters=file_restore
574
)
575
```
576

577
### SQL Database Point-in-Time Restore
578

579
```python
580
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
581
    RestoreRequestResource,
582
    AzureWorkloadSQLPointInTimeRestoreRequest
583
)
584
from datetime import datetime
585

586
# Restore SQL database to specific point in time
587
sql_restore = RestoreRequestResource(
588
    properties=AzureWorkloadSQLPointInTimeRestoreRequest(
589
        recovery_type="AlternateLocation",
590
        source_resource_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/sql-vm",
591
        target_virtual_machine_id="/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/sql-vm",
592
        point_in_time=datetime(2024, 1, 15, 14, 30, 0),
593
        recovery_mode="WorkloadRecovery",
594
        target_info={
595
            "overwrite_option": "AlternateDatabase",
596
            "database_name": "RestoredDatabase",
597
            "container_id": "vmappcontainer;compute;vm-rg;sql-vm"
598
        }
599
    )
600
)
601

602
client.restores.trigger(
603
    resource_group_name="my-rg", 
604
    vault_name="my-vault",
605
    fabric_name="Azure",
606
    container_name="vmappcontainer;compute;vm-rg;sql-vm",
607
    protected_item_name="sqldatabase;mssqlserver;originaldb",
608
    recovery_point_id="point-in-time-recovery",
609
    parameters=sql_restore
610
)
611
```