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

Vault Configuration

Management of Recovery Services vault settings including storage configuration, encryption settings, and vault-level policies. Provides comprehensive vault administration capabilities for backup infrastructure management, security configuration, and operational settings.

Capabilities

Vault Configuration Management

Core operations for managing Recovery Services vault configurations and settings.

class BackupResourceVaultConfigsOperations:
    def get(self, resource_group_name: str, vault_name: str, **kwargs) -> BackupResourceVaultConfigResource:
        """
        Get Recovery Services vault configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Additional options

        Returns:
        BackupResourceVaultConfigResource with vault configuration
        """

    def update(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceVaultConfigResource,
        **kwargs
    ) -> BackupResourceVaultConfigResource:
        """
        Update Recovery Services vault configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - parameters: Updated vault configuration
        - kwargs: Additional options

        Returns:
        Updated BackupResourceVaultConfigResource
        """

Usage example:

# Get current vault configuration
vault_config = client.backup_resource_vault_configs.get("my-rg", "my-vault")
print(f"Storage Type: {vault_config.properties.storage_model_type}")
print(f"Soft Delete Enabled: {vault_config.properties.soft_delete_feature_state}")

# Update vault configuration
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupResourceVaultConfigResource,
    BackupResourceVaultConfig
)

updated_config = BackupResourceVaultConfigResource(
    properties=BackupResourceVaultConfig(
        storage_model_type="GeoRedundant",
        cross_region_restore_flag=True,
        soft_delete_feature_state="Enabled",
        soft_delete_retention_period_in_days=14,
        resource_guard_operation_requests=[],
        is_soft_delete_feature_state_enabled=True
    )
)

result = client.backup_resource_vault_configs.update("my-rg", "my-vault", updated_config)
print("Vault configuration updated successfully")

Storage Configuration Management

Operations for managing vault storage settings including redundancy and cross-region restore capabilities.

class BackupResourceStorageConfigsOperations:
    def get(self, resource_group_name: str, vault_name: str, **kwargs) -> BackupResourceStorageConfigResource:
        """
        Get vault storage configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Additional options

        Returns:
        BackupResourceStorageConfigResource with storage configuration
        """

    def update(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceStorageConfigResource,
        **kwargs
    ) -> None:
        """
        Update vault storage configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - parameters: Updated storage configuration
        - kwargs: Additional options
        """

    def patch(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceStorageConfigResource,
        **kwargs
    ) -> None:
        """
        Partially update vault storage configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - parameters: Storage configuration updates
        - kwargs: Additional options
        """

class BackupResourceStorageConfigsNonCRROperations:
    def get(self, resource_group_name: str, vault_name: str, **kwargs) -> BackupResourceStorageConfigResource:
        """Get storage configuration for non-CRR scenarios."""

    def update(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceStorageConfigResource,
        **kwargs
    ) -> None:
        """Update storage configuration for non-CRR scenarios."""

    def patch(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceStorageConfigResource,
        **kwargs
    ) -> None:
        """Partially update storage configuration for non-CRR scenarios."""

Usage example:

# Get storage configuration
storage_config = client.backup_resource_storage_configs.get("my-rg", "my-vault")
print(f"Storage Type: {storage_config.properties.storage_type}")
print(f"Cross Region Restore: {storage_config.properties.cross_region_restore_flag}")

# Update to Geo-Redundant storage with CRR
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupResourceStorageConfigResource,
    BackupResourceStorageConfig
)

new_storage_config = BackupResourceStorageConfigResource(
    properties=BackupResourceStorageConfig(
        storage_type="GeoRedundant",
        cross_region_restore_flag=True,
        storage_type_state="Locked"
    )
)

client.backup_resource_storage_configs.update("my-rg", "my-vault", new_storage_config)
print("Storage configuration updated")

Encryption Configuration

Management of backup data encryption settings and configurations.

class BackupResourceEncryptionConfigsOperations:
    def get(self, resource_group_name: str, vault_name: str, **kwargs) -> BackupResourceEncryptionConfigResource:
        """
        Get backup encryption configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - kwargs: Additional options

        Returns:
        BackupResourceEncryptionConfigResource with encryption configuration
        """

    def update(
        self,
        resource_group_name: str,
        vault_name: str,
        parameters: BackupResourceEncryptionConfigResource,
        **kwargs
    ) -> BackupResourceEncryptionConfigResource:
        """
        Update backup encryption configuration.

        Parameters:
        - resource_group_name: Resource group containing the vault
        - vault_name: Recovery Services vault name
        - parameters: Updated encryption configuration
        - kwargs: Additional options

        Returns:
        Updated BackupResourceEncryptionConfigResource
        """

Usage example:

# Get encryption configuration
encryption_config = client.backup_resource_encryption_configs.get("my-rg", "my-vault")
print(f"Encryption State: {encryption_config.properties.encryption_at_rest_type}")
print(f"Key URI: {encryption_config.properties.key_uri}")

# Enable customer-managed key encryption
from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupResourceEncryptionConfigResource,
    BackupResourceEncryptionConfig
)

new_encryption_config = BackupResourceEncryptionConfigResource(
    properties=BackupResourceEncryptionConfig(
        encryption_at_rest_type="CustomerManaged",
        key_uri="https://myvault.vault.azure.net/keys/mykey",
        subscription_id=subscription_id,
        last_update_status="Succeeded",
        infrastructure_encryption="Enabled"
    )
)

result = client.backup_resource_encryption_configs.update("my-rg", "my-vault", new_encryption_config)
print("Encryption configuration updated")

Configuration Types

Backup Resource Vault Config

Core vault configuration settings including soft delete, cross-region restore, and security features.

class BackupResourceVaultConfig:
    def __init__(
        self,
        storage_model_type: Optional[str] = None,
        cross_region_restore_flag: Optional[bool] = None,
        storage_type: Optional[str] = None,
        storage_type_state: Optional[str] = None,
        enhanced_security_state: Optional[str] = None,
        soft_delete_feature_state: Optional[str] = None,
        soft_delete_retention_period_in_days: Optional[int] = None,
        resource_guard_operation_requests: Optional[List[str]] = None,
        is_soft_delete_feature_state_enabled: Optional[bool] = None,
        **kwargs
    ):
        """
        Backup resource vault configuration.

        Parameters:
        - storage_model_type: "GeoRedundant", "LocallyRedundant", "ReadAccessGeoRedundant", "ZoneRedundant"
        - cross_region_restore_flag: Enable cross-region restore capability
        - storage_type: Storage redundancy type
        - storage_type_state: "Locked", "Unlocked"
        - enhanced_security_state: "Enabled", "Disabled", "Invalid"
        - soft_delete_feature_state: "Enabled", "Disabled", "Invalid"
        - soft_delete_retention_period_in_days: Retention period (1-180 days)
        - resource_guard_operation_requests: Resource guard operation identifiers
        - is_soft_delete_feature_state_enabled: Whether soft delete is enabled
        """

    storage_model_type: Optional[str]
    cross_region_restore_flag: Optional[bool]
    storage_type: Optional[str]
    storage_type_state: Optional[str]
    enhanced_security_state: Optional[str]
    soft_delete_feature_state: Optional[str]
    soft_delete_retention_period_in_days: Optional[int]
    resource_guard_operation_requests: Optional[List[str]]
    is_soft_delete_feature_state_enabled: Optional[bool]

Backup Resource Storage Config

Storage-specific configuration settings for the Recovery Services vault.

class BackupResourceStorageConfig:
    def __init__(
        self,
        storage_type: Optional[str] = None,
        storage_type_state: Optional[str] = None,
        cross_region_restore_flag: Optional[bool] = None,
        dedup_state: Optional[str] = None,
        xcool_state: Optional[str] = None,
        **kwargs
    ):
        """
        Backup resource storage configuration.

        Parameters:
        - storage_type: "GeoRedundant", "LocallyRedundant", "ReadAccessGeoRedundant", "ZoneRedundant"
        - storage_type_state: "Locked", "Unlocked"
        - cross_region_restore_flag: Enable cross-region restore
        - dedup_state: Deduplication state
        - xcool_state: Cross-cool tier state
        """

    storage_type: Optional[str]
    storage_type_state: Optional[str]
    cross_region_restore_flag: Optional[bool]
    dedup_state: Optional[str]
    xcool_state: Optional[str]

Backup Resource Encryption Config

Encryption configuration for backup data at rest.

class BackupResourceEncryptionConfig:
    def __init__(
        self,
        encryption_at_rest_type: Optional[str] = None,
        key_uri: Optional[str] = None,
        subscription_id: Optional[str] = None,
        last_update_status: Optional[str] = None,
        infrastructure_encryption: Optional[str] = None,
        user_assigned_identity: Optional[str] = None,
        use_system_assigned_identity: Optional[bool] = None,
        **kwargs
    ):
        """
        Backup resource encryption configuration.

        Parameters:
        - encryption_at_rest_type: "MicrosoftManaged", "CustomerManaged", "Invalid"
        - key_uri: URI of the customer-managed key
        - subscription_id: Subscription ID for the key vault
        - last_update_status: Status of the last update
        - infrastructure_encryption: "Enabled", "Disabled"
        - user_assigned_identity: User-assigned managed identity for key access
        - use_system_assigned_identity: Whether to use system-assigned identity
        """

    encryption_at_rest_type: Optional[str]
    key_uri: Optional[str]
    subscription_id: Optional[str]
    last_update_status: Optional[str]
    infrastructure_encryption: Optional[str]
    user_assigned_identity: Optional[str]
    use_system_assigned_identity: Optional[bool]

Usage Examples

Configure Vault for Cross-Region Restore

from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupResourceVaultConfigResource,
    BackupResourceVaultConfig,
    BackupResourceStorageConfigResource,
    BackupResourceStorageConfig
)

# Step 1: Configure storage for cross-region restore
storage_config = BackupResourceStorageConfigResource(
    properties=BackupResourceStorageConfig(
        storage_type="GeoRedundant",
        cross_region_restore_flag=True,
        storage_type_state="Unlocked"
    )
)

client.backup_resource_storage_configs.update("my-rg", "my-vault", storage_config)

# Step 2: Configure vault settings
vault_config = BackupResourceVaultConfigResource(
    properties=BackupResourceVaultConfig(
        storage_model_type="GeoRedundant",
        cross_region_restore_flag=True,
        soft_delete_feature_state="Enabled",
        soft_delete_retention_period_in_days=14,
        enhanced_security_state="Enabled"
    )
)

client.backup_resource_vault_configs.update("my-rg", "my-vault", vault_config)
print("Vault configured for cross-region restore")

Enable Customer-Managed Key Encryption

from azure.mgmt.recoveryservicesbackup.activestamp.models import (
    BackupResourceEncryptionConfigResource,
    BackupResourceEncryptionConfig
)

# Configure customer-managed key encryption
encryption_config = BackupResourceEncryptionConfigResource(
    properties=BackupResourceEncryptionConfig(
        encryption_at_rest_type="CustomerManaged",
        key_uri="https://myvault.vault.azure.net/keys/backupkey/version",
        subscription_id=subscription_id,
        infrastructure_encryption="Enabled",
        use_system_assigned_identity=False,
        user_assigned_identity="/subscriptions/sub-id/resourceGroups/my-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/backup-identity"
    )
)

result = client.backup_resource_encryption_configs.update("my-rg", "my-vault", encryption_config)
print(f"Encryption configured: {result.properties.last_update_status}")

Configure Soft Delete Settings

# Enable soft delete with custom retention period
vault_config = BackupResourceVaultConfigResource(
    properties=BackupResourceVaultConfig(
        soft_delete_feature_state="Enabled",
        soft_delete_retention_period_in_days=30,  # 30 days retention
        is_soft_delete_feature_state_enabled=True
    )
)

result = client.backup_resource_vault_configs.update("my-rg", "my-vault", vault_config)
print("Soft delete configured with 30-day retention")

Monitor Vault Configuration

# Get comprehensive vault configuration
vault_config = client.backup_resource_vault_configs.get("my-rg", "my-vault")
storage_config = client.backup_resource_storage_configs.get("my-rg", "my-vault")
encryption_config = client.backup_resource_encryption_configs.get("my-rg", "my-vault")

print("=== Vault Configuration ===")
print(f"Storage Type: {vault_config.properties.storage_model_type}")
print(f"Cross-Region Restore: {vault_config.properties.cross_region_restore_flag}")
print(f"Soft Delete: {vault_config.properties.soft_delete_feature_state}")
print(f"Soft Delete Retention: {vault_config.properties.soft_delete_retention_period_in_days} days")
print(f"Enhanced Security: {vault_config.properties.enhanced_security_state}")

print("\n=== Storage Configuration ===")
print(f"Storage Type: {storage_config.properties.storage_type}")
print(f"Storage State: {storage_config.properties.storage_type_state}")
print(f"Cross-Region Restore: {storage_config.properties.cross_region_restore_flag}")

print("\n=== Encryption Configuration ===")
print(f"Encryption Type: {encryption_config.properties.encryption_at_rest_type}")
if encryption_config.properties.key_uri:
    print(f"Key URI: {encryption_config.properties.key_uri}")
print(f"Infrastructure Encryption: {encryption_config.properties.infrastructure_encryption}")

Update Storage Redundancy

# Change storage redundancy type (only when unlocked)
current_config = client.backup_resource_storage_configs.get("my-rg", "my-vault")

if current_config.properties.storage_type_state == "Unlocked":
    new_config = BackupResourceStorageConfigResource(
        properties=BackupResourceStorageConfig(
            storage_type="ZoneRedundant",  # Change to zone-redundant
            cross_region_restore_flag=False,  # Disable CRR for ZRS
            storage_type_state="Locked"  # Lock after change
        )
    )
    
    client.backup_resource_storage_configs.update("my-rg", "my-vault", new_config)
    print("Storage changed to Zone-Redundant and locked")
else:
    print("Storage type is locked and cannot be changed")

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