0
# Cross-Region Restore
1
2
Specialized operations for Cross-Region Restore (CRR) scenarios using the PassiveStamp API. Enables backup and restore operations across Azure regions for disaster recovery and compliance requirements, providing comprehensive cross-region backup management and recovery capabilities.
3
4
## Capabilities
5
6
### Cross-Region Restore Operations
7
8
Primary operations for executing cross-region restore using the PassiveStamp client.
9
10
```python { .api }
11
class CrossRegionRestoreOperations:
12
def trigger(
13
self,
14
azure_region: str,
15
parameters: CrossRegionRestoreRequestResource,
16
**kwargs
17
) -> None:
18
"""
19
Trigger a cross-region restore operation.
20
21
Parameters:
22
- azure_region: Target Azure region for the restore
23
- parameters: Cross-region restore request configuration
24
- kwargs: Additional options
25
26
Returns:
27
None (operation is asynchronous - monitor via CRR job operations)
28
"""
29
30
def get_operation_status(
31
self,
32
azure_region: str,
33
operation_id: str,
34
**kwargs
35
) -> OperationStatus:
36
"""
37
Get the status of a cross-region restore operation.
38
39
Parameters:
40
- azure_region: Azure region where the operation is running
41
- operation_id: ID of the CRR operation
42
- kwargs: Additional options
43
44
Returns:
45
OperationStatus with current operation status
46
"""
47
```
48
49
Usage example:
50
51
```python
52
from azure.identity import DefaultAzureCredential
53
from azure.mgmt.recoveryservicesbackup.passivestamp import RecoveryServicesBackupPassiveClient
54
from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
55
CrossRegionRestoreRequestResource,
56
CrossRegionRestoreRequest
57
)
58
59
# Create PassiveStamp client for CRR operations
60
credential = DefaultAzureCredential()
61
crr_client = RecoveryServicesBackupPassiveClient(
62
credential=credential,
63
subscription_id=subscription_id
64
)
65
66
# Trigger cross-region restore
67
crr_request = CrossRegionRestoreRequestResource(
68
properties=CrossRegionRestoreRequest(
69
source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
70
source_region="eastus",
71
cross_region_restore_access_details={
72
"access_token": "crr-access-token",
73
"object_type": "CrrAccessToken"
74
},
75
restore_request={
76
"object_type": "IaasVMRestoreRequest",
77
"recovery_point_id": "recovery-point-id-12345",
78
"recovery_type": "AlternateLocation",
79
"target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg",
80
"storage_account_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Storage/storageAccounts/targetstorage"
81
}
82
)
83
)
84
85
crr_client.cross_region_restore.trigger("westus2", crr_request)
86
print("Cross-region restore operation triggered")
87
```
88
89
### CRR Job Management
90
91
Operations for monitoring and managing cross-region restore jobs.
92
93
```python { .api }
94
class BackupCrrJobsOperations:
95
def list(
96
self,
97
azure_region: str,
98
resource_group_name: str,
99
vault_name: str,
100
**kwargs
101
) -> Iterable[JobResource]:
102
"""
103
List cross-region restore jobs.
104
105
Parameters:
106
- azure_region: Azure region containing the jobs
107
- resource_group_name: Resource group containing the vault
108
- vault_name: Recovery Services vault name
109
- kwargs: Filter options (status, operation, start_time, end_time, etc.)
110
111
Returns:
112
Iterable of JobResource objects for CRR jobs
113
"""
114
115
class BackupCrrJobDetailsOperations:
116
def get(
117
self,
118
azure_region: str,
119
resource_group_name: str,
120
vault_name: str,
121
job_name: str,
122
**kwargs
123
) -> JobResource:
124
"""
125
Get detailed information about a specific CRR job.
126
127
Parameters:
128
- azure_region: Azure region containing the job
129
- resource_group_name: Resource group containing the vault
130
- vault_name: Recovery Services vault name
131
- job_name: Name/ID of the CRR job
132
- kwargs: Additional options
133
134
Returns:
135
JobResource with detailed CRR job information
136
"""
137
138
class BackupCrrOperationResultsOperations:
139
def get(
140
self,
141
azure_region: str,
142
operation_id: str,
143
**kwargs
144
) -> OperationResultInfoBaseResource:
145
"""
146
Get result of a CRR operation.
147
148
Parameters:
149
- azure_region: Azure region where the operation ran
150
- operation_id: ID of the CRR operation
151
- kwargs: Additional options
152
153
Returns:
154
OperationResultInfoBaseResource with operation results
155
"""
156
157
class CrrOperationStatusOperations:
158
def get(
159
self,
160
azure_region: str,
161
operation_id: str,
162
**kwargs
163
) -> OperationStatus:
164
"""
165
Get status of a CRR operation.
166
167
Parameters:
168
- azure_region: Azure region where the operation is running
169
- operation_id: ID of the CRR operation
170
- kwargs: Additional options
171
172
Returns:
173
OperationStatus with current operation status
174
"""
175
```
176
177
Usage example:
178
179
```python
180
# List CRR jobs in the target region
181
crr_jobs = crr_client.backup_crr_jobs.list(
182
azure_region="westus2",
183
resource_group_name="target-rg",
184
vault_name="target-vault"
185
)
186
187
for job in crr_jobs:
188
print(f"CRR Job: {job.name}, Status: {job.properties.status}")
189
190
# Get detailed job information
191
job_details = crr_client.backup_crr_job_details.get(
192
azure_region="westus2",
193
resource_group_name="target-rg",
194
vault_name="target-vault",
195
job_name="crr-job-id-12345"
196
)
197
198
print(f"Job Status: {job_details.properties.status}")
199
print(f"Start Time: {job_details.properties.start_time}")
200
print(f"End Time: {job_details.properties.end_time}")
201
```
202
203
### CRR Recovery Points
204
205
Operations for accessing recovery points available for cross-region restore.
206
207
```python { .api }
208
class RecoveryPointsOperations:
209
def list(
210
self,
211
azure_region: str,
212
resource_group_name: str,
213
vault_name: str,
214
fabric_name: str,
215
container_name: str,
216
protected_item_name: str,
217
**kwargs
218
) -> Iterable[RecoveryPointResource]:
219
"""
220
List recovery points available for CRR.
221
222
Parameters:
223
- azure_region: Source Azure region
224
- resource_group_name: Resource group containing the source vault
225
- vault_name: Source Recovery Services vault name
226
- fabric_name: Fabric name (usually "Azure")
227
- container_name: Container hosting the protected item
228
- protected_item_name: Name of the protected item
229
- kwargs: Filter options
230
231
Returns:
232
Iterable of RecoveryPointResource objects available for CRR
233
"""
234
235
class RecoveryPointsGetOperations:
236
def get(
237
self,
238
azure_region: str,
239
resource_group_name: str,
240
vault_name: str,
241
fabric_name: str,
242
container_name: str,
243
protected_item_name: str,
244
recovery_point_id: str,
245
**kwargs
246
) -> RecoveryPointResource:
247
"""
248
Get specific recovery point details for CRR.
249
250
Parameters:
251
- azure_region: Source Azure region
252
- resource_group_name: Resource group containing the source vault
253
- vault_name: Source Recovery Services vault name
254
- fabric_name: Fabric name (usually "Azure")
255
- container_name: Container hosting the protected item
256
- protected_item_name: Name of the protected item
257
- recovery_point_id: ID of the recovery point
258
- kwargs: Additional options
259
260
Returns:
261
RecoveryPointResource with CRR-specific recovery point information
262
"""
263
264
class RecoveryPointsCrrOperations:
265
def list(
266
self,
267
azure_region: str,
268
resource_group_name: str,
269
vault_name: str,
270
fabric_name: str,
271
container_name: str,
272
protected_item_name: str,
273
**kwargs
274
) -> Iterable[RecoveryPointResource]:
275
"""
276
List recovery points specifically for cross-region restore scenarios.
277
278
Parameters:
279
- azure_region: Source Azure region
280
- resource_group_name: Resource group containing the source vault
281
- vault_name: Source Recovery Services vault name
282
- fabric_name: Fabric name (usually "Azure")
283
- container_name: Container hosting the protected item
284
- protected_item_name: Name of the protected item
285
- kwargs: Filter and pagination options
286
287
Returns:
288
Iterable of RecoveryPointResource objects for CRR
289
"""
290
```
291
292
### CRR Validation
293
294
Operations for validating cross-region restore requests before execution.
295
296
```python { .api }
297
class ValidateOperationsOperations:
298
def trigger(
299
self,
300
azure_region: str,
301
parameters: ValidateOperationRequest,
302
**kwargs
303
) -> ValidateOperationResponse:
304
"""
305
Validate a cross-region restore operation request.
306
307
Parameters:
308
- azure_region: Target Azure region for validation
309
- parameters: Validation request configuration
310
- kwargs: Additional options
311
312
Returns:
313
ValidateOperationResponse with validation results
314
"""
315
```
316
317
## Cross-Region Restore Request Types
318
319
### Cross-Region Restore Request
320
321
Primary request type for cross-region restore operations.
322
323
```python { .api }
324
class CrossRegionRestoreRequest:
325
def __init__(
326
self,
327
source_backup_vault_id: Optional[str] = None,
328
source_region: Optional[str] = None,
329
cross_region_restore_access_details: Optional[CrrAccessToken] = None,
330
restore_request: Optional[RestoreRequest] = None,
331
**kwargs
332
):
333
"""
334
Cross-region restore request.
335
336
Parameters:
337
- source_backup_vault_id: Resource ID of the source backup vault
338
- source_region: Source Azure region containing the backup
339
- cross_region_restore_access_details: Access token for CRR operation
340
- restore_request: Underlying restore request details
341
"""
342
343
source_backup_vault_id: Optional[str]
344
source_region: Optional[str]
345
cross_region_restore_access_details: Optional[CrrAccessToken]
346
restore_request: Optional[RestoreRequest]
347
```
348
349
### CRR Access Token
350
351
Access token required for cross-region restore operations.
352
353
```python { .api }
354
class CrrAccessToken:
355
def __init__(
356
self,
357
access_token: Optional[str] = None,
358
location: Optional[str] = None,
359
properties: Optional[CrrAccessTokenProperties] = None,
360
**kwargs
361
):
362
"""
363
Cross-region restore access token.
364
365
Parameters:
366
- access_token: The access token string
367
- location: Azure region for the token
368
- properties: Additional token properties
369
"""
370
371
access_token: Optional[str]
372
location: Optional[str]
373
properties: Optional[CrrAccessTokenProperties]
374
```
375
376
## Usage Examples
377
378
### Complete Cross-Region Restore Workflow
379
380
```python
381
from azure.identity import DefaultAzureCredential
382
from azure.mgmt.recoveryservicesbackup.passivestamp import RecoveryServicesBackupPassiveClient
383
from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
384
CrossRegionRestoreRequestResource,
385
CrossRegionRestoreRequest,
386
CrrAccessToken
387
)
388
389
# Initialize CRR client
390
credential = DefaultAzureCredential()
391
crr_client = RecoveryServicesBackupPassiveClient(
392
credential=credential,
393
subscription_id=subscription_id
394
)
395
396
# Step 1: List available recovery points for CRR
397
source_region = "eastus"
398
target_region = "westus2"
399
400
recovery_points = crr_client.recovery_points_crr.list(
401
azure_region=source_region,
402
resource_group_name="source-rg",
403
vault_name="source-vault",
404
fabric_name="Azure",
405
container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
406
protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm"
407
)
408
409
latest_rp = next(recovery_points)
410
print(f"Using recovery point: {latest_rp.name}")
411
412
# Step 2: Get CRR access token (this would typically come from Azure portal or API)
413
crr_access_token = CrrAccessToken(
414
access_token="your-crr-access-token",
415
location=target_region
416
)
417
418
# Step 3: Create cross-region restore request
419
crr_request = CrossRegionRestoreRequestResource(
420
properties=CrossRegionRestoreRequest(
421
source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
422
source_region=source_region,
423
cross_region_restore_access_details=crr_access_token,
424
restore_request={
425
"object_type": "IaasVMRestoreRequest",
426
"recovery_point_id": latest_rp.name,
427
"recovery_type": "AlternateLocation",
428
"source_resource_id": "/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
429
"target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg",
430
"storage_account_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Storage/storageAccounts/targetstorage",
431
"virtual_network_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Network/virtualNetworks/target-vnet",
432
"subnet_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Network/virtualNetworks/target-vnet/subnets/default",
433
"region": target_region,
434
"restore_with_managed_disks": True
435
}
436
)
437
)
438
439
# Step 4: Trigger cross-region restore
440
crr_client.cross_region_restore.trigger(target_region, crr_request)
441
print(f"Cross-region restore triggered from {source_region} to {target_region}")
442
443
# Step 5: Monitor the CRR job
444
import time
445
446
while True:
447
crr_jobs = crr_client.backup_crr_jobs.list(
448
azure_region=target_region,
449
resource_group_name="target-rg",
450
vault_name="target-vault"
451
)
452
453
for job in crr_jobs:
454
if job.properties.operation == "CrossRegionRestore":
455
print(f"CRR Job Status: {job.properties.status}")
456
if job.properties.status in ["Completed", "Failed", "Cancelled"]:
457
print(f"CRR Job finished with status: {job.properties.status}")
458
exit()
459
break
460
461
print("Waiting for CRR job to complete...")
462
time.sleep(30)
463
```
464
465
### Validate CRR Operation
466
467
```python
468
from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
469
ValidateOperationRequest,
470
CrossRegionRestoreRequest
471
)
472
473
# Validate CRR request before execution
474
validate_request = ValidateOperationRequest(
475
properties=CrossRegionRestoreRequest(
476
source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
477
source_region="eastus",
478
restore_request={
479
"object_type": "IaasVMRestoreRequest",
480
"recovery_point_id": "recovery-point-id-12345",
481
"recovery_type": "AlternateLocation",
482
"target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg"
483
}
484
)
485
)
486
487
validation_result = crr_client.validate_operations.trigger("westus2", validate_request)
488
489
if validation_result.validation_results:
490
for result in validation_result.validation_results:
491
print(f"Validation: {result.code} - {result.message}")
492
else:
493
print("CRR request validation passed")
494
```
495
496
### Monitor CRR Operation Status
497
498
```python
499
# Get detailed status of a CRR operation
500
operation_id = "crr-operation-id-12345"
501
502
operation_status = crr_client.crr_operation_status.get("westus2", operation_id)
503
print(f"Operation Status: {operation_status.status}")
504
print(f"Start Time: {operation_status.start_time}")
505
506
if operation_status.error:
507
print(f"Error: {operation_status.error.message}")
508
509
# Get operation results
510
if operation_status.status == "Succeeded":
511
operation_result = crr_client.backup_crr_operation_results.get("westus2", operation_id)
512
print(f"Operation completed successfully")
513
```