CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-google-cloud-dataproc-metastore

Google Cloud Dataproc Metastore API client library for managing fully managed, highly available metastore services

—

Pending
Overview
Eval results
Files

backup-restore.mddocs/

Backup and Restore Operations

Complete backup and restore functionality for metastore services including scheduled backups, point-in-time recovery, and cross-region backup management for disaster recovery scenarios. Supports automated backup policies and granular restore options.

Capabilities

List Backups

Retrieve all backups for a metastore service with filtering and pagination support.

def list_backups(
    self,
    request: Optional[ListBackupsRequest] = None,
    *,
    parent: Optional[str] = None,
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
    metadata: Sequence[Tuple[str, str]] = ()
) -> pagers.ListBackupsPager:
    """
    Lists backups in a service.

    Args:
        request: The request object containing list parameters
        parent: Required. The relative resource name of the service
                Format: projects/{project_id}/locations/{location_id}/services/{service_id}
        retry: Retry configuration for the request
        timeout: Request timeout in seconds
        metadata: Additional metadata for the request

    Returns:
        ListBackupsPager: Pageable list of backups

    Raises:
        google.api_core.exceptions.GoogleAPICallError: If the request fails
    """

Usage example:

from google.cloud import metastore

client = metastore.DataprocMetastoreClient()
parent = "projects/my-project/locations/us-central1/services/my-metastore"

# List all backups
for backup in client.list_backups(parent=parent):
    print(f"Backup: {backup.name}")
    print(f"State: {backup.state.name}")
    print(f"Created: {backup.create_time}")
    print(f"Service revision: {backup.service_revision}")

# With filtering
request = metastore.ListBackupsRequest(
    parent=parent,
    filter="state=ACTIVE",
    order_by="create_time desc"
)

Get Backup

Retrieve detailed information about a specific backup including metadata and restore capabilities.

def get_backup(
    self,
    request: Optional[GetBackupRequest] = None,
    *,
    name: Optional[str] = None,
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
    metadata: Sequence[Tuple[str, str]] = ()
) -> Backup:
    """
    Gets details of a single backup.

    Args:
        request: The request object
        name: Required. The relative resource name of the backup
              Format: projects/{project_id}/locations/{location_id}/services/{service_id}/backups/{backup_id}
        retry: Retry configuration
        timeout: Request timeout in seconds
        metadata: Additional metadata

    Returns:
        Backup: The backup resource

    Raises:
        google.api_core.exceptions.NotFound: If the backup doesn't exist
    """

Create Backup

Create a new backup of a metastore service with optional description and metadata.

def create_backup(
    self,
    request: Optional[CreateBackupRequest] = None,
    *,
    parent: Optional[str] = None,
    backup: Optional[Backup] = None,
    backup_id: Optional[str] = None,
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
    metadata: Sequence[Tuple[str, str]] = ()
) -> operation.Operation:
    """
    Creates a metastore service backup.

    Args:
        request: The request object
        parent: Required. The relative resource name of the service
        backup: Required. The backup configuration
        backup_id: Required. The ID to use for the backup
        retry: Retry configuration
        timeout: Request timeout in seconds
        metadata: Additional metadata

    Returns:
        Operation: Long-running operation for backup creation

    Raises:
        google.api_core.exceptions.AlreadyExists: If backup_id already exists
        google.api_core.exceptions.FailedPrecondition: If service cannot be backed up
    """

Usage example:

from google.cloud import metastore

client = metastore.DataprocMetastoreClient()

# Create a backup
backup_config = metastore.Backup(
    description="Weekly automated backup for disaster recovery"
)

operation = client.create_backup(
    parent="projects/my-project/locations/us-central1/services/my-metastore",
    backup_id="weekly-backup-2024-01-15",
    backup=backup_config
)

# Wait for completion (typically 5-15 minutes)
backup = operation.result(timeout=900)
print(f"Backup created: {backup.name}")
print(f"Service revision: {backup.service_revision}")

Delete Backup

Delete a backup permanently. This operation cannot be undone.

def delete_backup(
    self,
    request: Optional[DeleteBackupRequest] = None,
    *,
    name: Optional[str] = None,
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
    metadata: Sequence[Tuple[str, str]] = ()
) -> operation.Operation:
    """
    Deletes a single backup.

    Args:
        request: The request object
        name: Required. The relative resource name of the backup to delete
        retry: Retry configuration
        timeout: Request timeout in seconds
        metadata: Additional metadata

    Returns:
        Operation: Long-running operation for backup deletion

    Raises:
        google.api_core.exceptions.NotFound: If the backup doesn't exist
        google.api_core.exceptions.FailedPrecondition: If backup cannot be deleted
    """

Restore Service

Restore a metastore service from a backup with options for full or metadata-only restoration.

def restore_service(
    self,
    request: Optional[RestoreServiceRequest] = None,
    *,
    service: Optional[str] = None,
    backup: Optional[str] = None,
    retry: OptionalRetry = gapic_v1.method.DEFAULT,
    timeout: Union[float, object] = gapic_v1.method.DEFAULT,
    metadata: Sequence[Tuple[str, str]] = ()
) -> operation.Operation:
    """
    Restores a service from a backup.

    Args:
        request: The request object
        service: Required. The relative resource name of the service to restore
        backup: Required. The relative resource name of the backup to restore from
        retry: Retry configuration
        timeout: Request timeout in seconds
        metadata: Additional metadata

    Returns:
        Operation: Long-running operation for service restoration

    Raises:
        google.api_core.exceptions.NotFound: If service or backup doesn't exist
        google.api_core.exceptions.FailedPrecondition: If restore cannot be performed
    """

Usage example:

from google.cloud import metastore

client = metastore.DataprocMetastoreClient()

# Restore from backup
restore_request = metastore.RestoreServiceRequest(
    service="projects/my-project/locations/us-central1/services/my-metastore",
    backup="projects/my-project/locations/us-central1/services/my-metastore/backups/backup-id",
    restore_type=metastore.Restore.RestoreType.FULL
)

operation = client.restore_service(request=restore_request)

# Monitor restoration progress
print("Starting restoration...")
result = operation.result(timeout=3600)  # Can take up to 1 hour
print(f"Service restored successfully")

Core Types

Backup Resource

class Backup:
    name: str
    create_time: timestamp_pb2.Timestamp
    end_time: timestamp_pb2.Timestamp
    state: State
    service_revision: Service
    description: str
    restoring_services: List[str]

    class State(enum.Enum):
        STATE_UNSPECIFIED = 0
        CREATING = 1
        DELETING = 2
        ACTIVE = 3
        FAILED = 4
        RESTORING = 5

Restore Configuration

class Restore:
    start_time: timestamp_pb2.Timestamp
    end_time: timestamp_pb2.Timestamp
    state: State
    backup: str
    type: RestoreType
    details: str

    class State(enum.Enum):
        STATE_UNSPECIFIED = 0
        RUNNING = 1
        SUCCEEDED = 2
        FAILED = 3
        CANCELLED = 4

    class RestoreType(enum.Enum):
        RESTORE_TYPE_UNSPECIFIED = 0
        FULL = 1
        METADATA_ONLY = 2

Request/Response Types

class ListBackupsRequest:
    parent: str
    page_size: int
    page_token: str
    filter: str
    order_by: str

class ListBackupsResponse:
    backups: List[Backup]
    next_page_token: str
    unreachable: List[str]

class GetBackupRequest:
    name: str

class CreateBackupRequest:
    parent: str
    backup_id: str
    backup: Backup
    request_id: str

class DeleteBackupRequest:
    name: str
    request_id: str

class RestoreServiceRequest:
    service: str
    backup: str
    restore_type: Restore.RestoreType
    request_id: str

Usage Patterns

Automated Backup Strategy

import schedule
import time
from datetime import datetime
from google.cloud import metastore

def create_daily_backup():
    client = metastore.DataprocMetastoreClient()
    
    # Generate timestamp-based backup ID
    backup_id = f"daily-backup-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
    
    backup_config = metastore.Backup(
        description=f"Automated daily backup created at {datetime.now()}"
    )
    
    operation = client.create_backup(
        parent="projects/my-project/locations/us-central1/services/my-metastore",
        backup_id=backup_id,
        backup=backup_config
    )
    
    # Don't wait for completion in automated scenarios
    print(f"Backup operation started: {operation.name}")

# Schedule daily backups at 2 AM
schedule.every().day.at("02:00").do(create_daily_backup)

Disaster Recovery Workflow

from google.cloud import metastore
import logging

def disaster_recovery_restore(backup_name: str, target_service: str):
    """
    Perform disaster recovery restoration from backup.
    """
    client = metastore.DataprocMetastoreClient()
    
    try:
        # Verify backup exists and is in ACTIVE state
        backup = client.get_backup(name=backup_name)
        if backup.state != metastore.Backup.State.ACTIVE:
            raise ValueError(f"Backup {backup_name} is not in ACTIVE state")
        
        # Start restoration
        restore_request = metastore.RestoreServiceRequest(
            service=target_service,
            backup=backup_name,
            restore_type=metastore.Restore.RestoreType.FULL
        )
        
        operation = client.restore_service(request=restore_request)
        logging.info(f"Restoration started: {operation.name}")
        
        # Wait for completion with progress logging
        while not operation.done():
            time.sleep(30)
            logging.info("Restoration in progress...")
        
        result = operation.result()
        logging.info(f"Disaster recovery completed successfully")
        return result
        
    except Exception as e:
        logging.error(f"Disaster recovery failed: {e}")
        raise

Install with Tessl CLI

npx tessl i tessl/pypi-google-cloud-dataproc-metastore

docs

async-operations.md

backup-restore.md

federation-management.md

index.md

metadata-import-export.md

metadata-query.md

service-management.md

tile.json