Blog Docs Log in Get started

tessl/pypi-azure-mgmt-recoveryservicesbackup

Microsoft Azure Recovery Services Backup Management Client Library for Python

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Cross-Region Restore

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.

Capabilities

Cross-Region Restore Operations

Primary operations for executing cross-region restore using the PassiveStamp client.

class CrossRegionRestoreOperations:
    def trigger(
        self,
        azure_region: str,
        parameters: CrossRegionRestoreRequestResource,
        **kwargs
    ) -> None:
        """
        Trigger a cross-region restore operation.

        Parameters:
        - azure_region: Target Azure region for the restore
        - parameters: Cross-region restore request configuration
        - kwargs: Additional options

        Returns:
        None (operation is asynchronous - monitor via CRR job operations)
        """

    def get_operation_status(
        self,
        azure_region: str,
        operation_id: str,
        **kwargs
    ) -> OperationStatus:
        """
        Get the status of a cross-region restore operation.

        Parameters:
        - azure_region: Azure region where the operation is running
        - operation_id: ID of the CRR operation
        - kwargs: Additional options

        Returns:
        OperationStatus with current operation status
        """

Usage example:

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservicesbackup.passivestamp import RecoveryServicesBackupPassiveClient
from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
    CrossRegionRestoreRequestResource,
    CrossRegionRestoreRequest
)

# Create PassiveStamp client for CRR operations
credential = DefaultAzureCredential()
crr_client = RecoveryServicesBackupPassiveClient(
    credential=credential,
    subscription_id=subscription_id
)

# Trigger cross-region restore
crr_request = CrossRegionRestoreRequestResource(
    properties=CrossRegionRestoreRequest(
        source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
        source_region="eastus",
        cross_region_restore_access_details={
            "access_token": "crr-access-token",
            "object_type": "CrrAccessToken"
        },
        restore_request={
            "object_type": "IaasVMRestoreRequest",
            "recovery_point_id": "recovery-point-id-12345",
            "recovery_type": "AlternateLocation",
            "target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg",
            "storage_account_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Storage/storageAccounts/targetstorage"
        }
    )
)

crr_client.cross_region_restore.trigger("westus2", crr_request)
print("Cross-region restore operation triggered")

CRR Job Management

Operations for monitoring and managing cross-region restore jobs.

class BackupCrrJobsOperations:
    def list(
        self,
        azure_region: str,
        resource_group_name: str,
        vault_name: str,
        **kwargs
    ) -> Iterable[JobResource]:
        """
        List cross-region restore jobs.

        Parameters:
        - azure_region: Azure region containing the jobs
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Filter options (status, operation, start_time, end_time, etc.)

        Returns:
        Iterable of JobResource objects for CRR jobs
        """

class BackupCrrJobDetailsOperations:
    def get(
        self,
        azure_region: str,
        resource_group_name: str,
        vault_name: str,
        job_name: str,
        **kwargs
    ) -> JobResource:
        """
        Get detailed information about a specific CRR job.

        Parameters:
        - azure_region: Azure region containing the job
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - job_name: Name/ID of the CRR job
        - kwargs: Additional options

        Returns:
        JobResource with detailed CRR job information
        """

class BackupCrrOperationResultsOperations:
    def get(
        self,
        azure_region: str,
        operation_id: str,
        **kwargs
    ) -> OperationResultInfoBaseResource:
        """
        Get result of a CRR operation.

        Parameters:
        - azure_region: Azure region where the operation ran
        - operation_id: ID of the CRR operation
        - kwargs: Additional options

        Returns:
        OperationResultInfoBaseResource with operation results
        """

class CrrOperationStatusOperations:
    def get(
        self,
        azure_region: str,
        operation_id: str,
        **kwargs
    ) -> OperationStatus:
        """
        Get status of a CRR operation.

        Parameters:
        - azure_region: Azure region where the operation is running
        - operation_id: ID of the CRR operation
        - kwargs: Additional options

        Returns:
        OperationStatus with current operation status
        """

Usage example:

# List CRR jobs in the target region
crr_jobs = crr_client.backup_crr_jobs.list(
    azure_region="westus2",
    resource_group_name="target-rg",
    vault_name="target-vault"
)

for job in crr_jobs:
    print(f"CRR Job: {job.name}, Status: {job.properties.status}")

# Get detailed job information
job_details = crr_client.backup_crr_job_details.get(
    azure_region="westus2",
    resource_group_name="target-rg", 
    vault_name="target-vault",
    job_name="crr-job-id-12345"
)

print(f"Job Status: {job_details.properties.status}")
print(f"Start Time: {job_details.properties.start_time}")
print(f"End Time: {job_details.properties.end_time}")

CRR Recovery Points

Operations for accessing recovery points available for cross-region restore.

class RecoveryPointsOperations:
    def list(
        self,
        azure_region: str,
        resource_group_name: str,
        vault_name: str,
        fabric_name: str,
        container_name: str,
        protected_item_name: str,
        **kwargs
    ) -> Iterable[RecoveryPointResource]:
        """
        List recovery points available for CRR.

        Parameters:
        - azure_region: Source Azure region
        - resource_group_name: Resource group containing the source vault
        - vault_name: Source Recovery Services vault name
        - fabric_name: Fabric name (usually "Azure")
        - container_name: Container hosting the protected item
        - protected_item_name: Name of the protected item
        - kwargs: Filter options

        Returns:
        Iterable of RecoveryPointResource objects available for CRR
        """

class RecoveryPointsGetOperations:
    def get(
        self,
        azure_region: str,
        resource_group_name: str,
        vault_name: str,
        fabric_name: str,
        container_name: str,
        protected_item_name: str,
        recovery_point_id: str,
        **kwargs
    ) -> RecoveryPointResource:
        """
        Get specific recovery point details for CRR.

        Parameters:
        - azure_region: Source Azure region
        - resource_group_name: Resource group containing the source vault
        - vault_name: Source Recovery Services vault name
        - fabric_name: Fabric name (usually "Azure")
        - container_name: Container hosting the protected item
        - protected_item_name: Name of the protected item
        - recovery_point_id: ID of the recovery point
        - kwargs: Additional options

        Returns:
        RecoveryPointResource with CRR-specific recovery point information
        """

class RecoveryPointsCrrOperations:
    def list(
        self,
        azure_region: str,
        resource_group_name: str,
        vault_name: str,
        fabric_name: str,
        container_name: str,
        protected_item_name: str,
        **kwargs
    ) -> Iterable[RecoveryPointResource]:
        """
        List recovery points specifically for cross-region restore scenarios.

        Parameters:
        - azure_region: Source Azure region
        - resource_group_name: Resource group containing the source vault
        - vault_name: Source Recovery Services vault name
        - fabric_name: Fabric name (usually "Azure")
        - container_name: Container hosting the protected item
        - protected_item_name: Name of the protected item
        - kwargs: Filter and pagination options

        Returns:
        Iterable of RecoveryPointResource objects for CRR
        """

CRR Validation

Operations for validating cross-region restore requests before execution.

class ValidateOperationsOperations:
    def trigger(
        self,
        azure_region: str,
        parameters: ValidateOperationRequest,
        **kwargs
    ) -> ValidateOperationResponse:
        """
        Validate a cross-region restore operation request.

        Parameters:
        - azure_region: Target Azure region for validation
        - parameters: Validation request configuration
        - kwargs: Additional options

        Returns:
        ValidateOperationResponse with validation results
        """

Cross-Region Restore Request Types

Cross-Region Restore Request

Primary request type for cross-region restore operations.

class CrossRegionRestoreRequest:
    def __init__(
        self,
        source_backup_vault_id: Optional[str] = None,
        source_region: Optional[str] = None,
        cross_region_restore_access_details: Optional[CrrAccessToken] = None,
        restore_request: Optional[RestoreRequest] = None,
        **kwargs
    ):
        """
        Cross-region restore request.

        Parameters:
        - source_backup_vault_id: Resource ID of the source backup vault
        - source_region: Source Azure region containing the backup
        - cross_region_restore_access_details: Access token for CRR operation
        - restore_request: Underlying restore request details
        """

    source_backup_vault_id: Optional[str]
    source_region: Optional[str]
    cross_region_restore_access_details: Optional[CrrAccessToken]
    restore_request: Optional[RestoreRequest]

CRR Access Token

Access token required for cross-region restore operations.

class CrrAccessToken:
    def __init__(
        self,
        access_token: Optional[str] = None,
        location: Optional[str] = None,
        properties: Optional[CrrAccessTokenProperties] = None,
        **kwargs
    ):
        """
        Cross-region restore access token.

        Parameters:
        - access_token: The access token string
        - location: Azure region for the token
        - properties: Additional token properties
        """

    access_token: Optional[str]
    location: Optional[str]
    properties: Optional[CrrAccessTokenProperties]

Usage Examples

Complete Cross-Region Restore Workflow

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservicesbackup.passivestamp import RecoveryServicesBackupPassiveClient
from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
    CrossRegionRestoreRequestResource,
    CrossRegionRestoreRequest,
    CrrAccessToken
)

# Initialize CRR client
credential = DefaultAzureCredential()
crr_client = RecoveryServicesBackupPassiveClient(
    credential=credential,
    subscription_id=subscription_id
)

# Step 1: List available recovery points for CRR
source_region = "eastus"
target_region = "westus2"

recovery_points = crr_client.recovery_points_crr.list(
    azure_region=source_region,
    resource_group_name="source-rg",
    vault_name="source-vault",
    fabric_name="Azure",
    container_name="iaasvmcontainer;iaasvmcontainerv2;vm-rg;my-vm",
    protected_item_name="vm;iaasvmcontainerv2;vm-rg;my-vm"
)

latest_rp = next(recovery_points)
print(f"Using recovery point: {latest_rp.name}")

# Step 2: Get CRR access token (this would typically come from Azure portal or API)
crr_access_token = CrrAccessToken(
    access_token="your-crr-access-token",
    location=target_region
)

# Step 3: Create cross-region restore request
crr_request = CrossRegionRestoreRequestResource(
    properties=CrossRegionRestoreRequest(
        source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
        source_region=source_region,
        cross_region_restore_access_details=crr_access_token,
        restore_request={
            "object_type": "IaasVMRestoreRequest",
            "recovery_point_id": latest_rp.name,
            "recovery_type": "AlternateLocation",
            "source_resource_id": "/subscriptions/sub-id/resourceGroups/vm-rg/providers/Microsoft.Compute/virtualMachines/my-vm",
            "target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg",
            "storage_account_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Storage/storageAccounts/targetstorage",
            "virtual_network_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Network/virtualNetworks/target-vnet",
            "subnet_id": "/subscriptions/sub-id/resourceGroups/target-rg/providers/Microsoft.Network/virtualNetworks/target-vnet/subnets/default",
            "region": target_region,
            "restore_with_managed_disks": True
        }
    )
)

# Step 4: Trigger cross-region restore
crr_client.cross_region_restore.trigger(target_region, crr_request)
print(f"Cross-region restore triggered from {source_region} to {target_region}")

# Step 5: Monitor the CRR job
import time

while True:
    crr_jobs = crr_client.backup_crr_jobs.list(
        azure_region=target_region,
        resource_group_name="target-rg",
        vault_name="target-vault"
    )
    
    for job in crr_jobs:
        if job.properties.operation == "CrossRegionRestore":
            print(f"CRR Job Status: {job.properties.status}")
            if job.properties.status in ["Completed", "Failed", "Cancelled"]:
                print(f"CRR Job finished with status: {job.properties.status}")
                exit()
            break
    
    print("Waiting for CRR job to complete...")
    time.sleep(30)

Validate CRR Operation

from azure.mgmt.recoveryservicesbackup.passivestamp.models import (
    ValidateOperationRequest,
    CrossRegionRestoreRequest
)

# Validate CRR request before execution
validate_request = ValidateOperationRequest(
    properties=CrossRegionRestoreRequest(
        source_backup_vault_id="/subscriptions/sub-id/resourceGroups/source-rg/providers/Microsoft.RecoveryServices/vaults/source-vault",
        source_region="eastus",
        restore_request={
            "object_type": "IaasVMRestoreRequest",
            "recovery_point_id": "recovery-point-id-12345",
            "recovery_type": "AlternateLocation",
            "target_resource_group_id": "/subscriptions/sub-id/resourceGroups/target-rg"
        }
    )
)

validation_result = crr_client.validate_operations.trigger("westus2", validate_request)

if validation_result.validation_results:
    for result in validation_result.validation_results:
        print(f"Validation: {result.code} - {result.message}")
else:
    print("CRR request validation passed")

Monitor CRR Operation Status

# Get detailed status of a CRR operation
operation_id = "crr-operation-id-12345"

operation_status = crr_client.crr_operation_status.get("westus2", operation_id)
print(f"Operation Status: {operation_status.status}")
print(f"Start Time: {operation_status.start_time}")

if operation_status.error:
    print(f"Error: {operation_status.error.message}")

# Get operation results
if operation_status.status == "Succeeded":
    operation_result = crr_client.backup_crr_operation_results.get("westus2", operation_id)
    print(f"Operation completed successfully")

Install with Tessl CLI

npx tessl i tessl/pypi-azure-mgmt-recoveryservicesbackup

docs

backup-operations.md

backup-policies.md

client-management.md

cross-region-restore.md

job-management.md

protected-items.md

restore-operations.md

vault-configuration.md