tessl/pypi-azure-mgmt-rdbms

Microsoft Azure RDBMS Management Client Library for Python providing management capabilities for MySQL, MariaDB, and PostgreSQL databases

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

MySQL Flexible Servers Management

Name: tessl/pypi-azure-mgmt-rdbms
Author: tessl

Advanced management capabilities for MySQL flexible server deployments on Azure. This service provides enhanced server lifecycle management, high availability configuration, backup and restore operations, private networking, and advanced monitoring capabilities for MySQL instances.

Capabilities

Management Client

Main client for MySQL flexible server operations with enhanced features and comprehensive resource management capabilities.

class MySQLManagementClient:
    """
    MySQL management client for flexible server deployments.
    
    Parameters:
    - credential: TokenCredential for Azure authentication
    - subscription_id: str, Azure subscription ID
    - base_url: str, management endpoint (default: https://management.azure.com)
    - polling_interval: int, LRO polling interval in seconds
    
    Attributes:
    - servers: Enhanced server lifecycle operations
    - databases: Database management operations
    - firewall_rules: Firewall configuration operations
    - configurations: Server parameter operations
    - backups: Backup management and restore operations
    - replicas: Read replica operations
    - location_based_capabilities: Regional capability queries
    """
    def __init__(
        self,
        credential,
        subscription_id: str,
        base_url: str = "https://management.azure.com",
        **kwargs
    ): ...
    
    def close(self): ...
    def __enter__(self): ...
    def __exit__(self, *exc_details): ...

Enhanced Server Operations

Comprehensive server lifecycle management with flexible server features including high availability, backup configuration, and maintenance windows.

class ServersOperations:
    """Enhanced server lifecycle and management operations for flexible servers."""
    
    def create(self, resource_group_name: str, server_name: str, parameters, **kwargs):
        """
        Creates a new MySQL flexible server with enhanced capabilities.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name (must be globally unique)
        - parameters: Enhanced server creation parameters including:
          - high_availability: HighAvailability configuration
          - backup: Backup configuration and policies
          - network: Network configuration including private access
          - maintenance_window: Maintenance scheduling
          - data_encryption: Data encryption settings
        
        Returns:
        LROPoller for server creation operation
        """
    
    def update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
        """
        Updates an existing MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - parameters: Server update parameters with flexible server properties
        
        Returns:
        LROPoller for server update operation
        """
    
    def delete(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Deletes a MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        LROPoller for server deletion operation
        """
    
    def get(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Gets details of a MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        Server object with enhanced flexible server properties
        """
    
    def list(self, **kwargs):
        """
        Lists all MySQL flexible servers in the subscription.
        
        Returns:
        Paged collection of Server objects
        """
    
    def list_by_resource_group(self, resource_group_name: str, **kwargs):
        """
        Lists MySQL flexible servers in a resource group.
        
        Parameters:
        - resource_group_name: str, resource group name
        
        Returns:
        Paged collection of Server objects
        """
    
    def restart(self, resource_group_name: str, server_name: str, restart_parameters, **kwargs):
        """
        Restarts a MySQL flexible server with optional parameters.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - restart_parameters: Restart configuration options
        
        Returns:
        LROPoller for restart operation
        """
    
    def start(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Starts a stopped MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        LROPoller for start operation
        """
    
    def stop(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Stops a running MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        LROPoller for stop operation
        """
    
    def failover(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Triggers a failover for high availability enabled server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        LROPoller for failover operation
        """

Backup and Restore Operations

Advanced backup management and point-in-time restore capabilities for MySQL flexible servers.

class BackupsOperations:
    """Backup management and restore operations for flexible servers."""
    
    def get(self, resource_group_name: str, server_name: str, backup_name: str, **kwargs):
        """
        Gets backup information for a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - backup_name: str, backup name
        
        Returns:
        ServerBackup object with backup details
        """
    
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Lists all backups for a MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        Paged collection of ServerBackup objects
        """

Database Operations

Enhanced database management within MySQL flexible servers.

class DatabasesOperations:
    """Database management operations within MySQL flexible servers."""
    
    def create_or_update(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
        """
        Creates or updates a database in a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - database_name: str, database name
        - parameters: Database parameters (charset, collation)
        
        Returns:
        LROPoller for database operation
        """
    
    def delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
        """
        Deletes a database from a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - database_name: str, database name
        
        Returns:
        LROPoller for deletion operation
        """
    
    def get(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
        """
        Gets database properties from a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - database_name: str, database name
        
        Returns:
        Database object with properties
        """
    
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Lists databases in a MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        Paged collection of Database objects
        """

Firewall Rules Operations

Enhanced firewall management for MySQL flexible servers with improved security features.

class FirewallRulesOperations:
    """Enhanced firewall rule management for MySQL flexible servers."""
    
    def create_or_update(self, resource_group_name: str, server_name: str, firewall_rule_name: str, parameters, **kwargs):
        """
        Creates or updates a firewall rule for a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - firewall_rule_name: str, firewall rule name
        - parameters: Enhanced firewall rule parameters
        
        Returns:
        LROPoller for firewall rule operation
        """
    
    def delete(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
        """
        Deletes a firewall rule from a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - firewall_rule_name: str, firewall rule name
        
        Returns:
        LROPoller for deletion operation
        """
    
    def get(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
        """
        Gets a firewall rule from a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - firewall_rule_name: str, firewall rule name
        
        Returns:
        FirewallRule object
        """
    
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Lists firewall rules for a MySQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        Paged collection of FirewallRule objects
        """

Configuration Operations

Enhanced server parameter and configuration management for MySQL flexible servers.

class ConfigurationsOperations:
    """Enhanced MySQL flexible server configuration and parameter management."""
    
    def create_or_update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
        """
        Updates a configuration parameter for a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - configuration_name: str, parameter name
        - parameters: Enhanced configuration value and properties
        
        Returns:
        LROPoller for configuration update
        """
    
    def batch_update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
        """
        Updates multiple configuration parameters in a single operation.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - parameters: Batch configuration parameters
        
        Returns:
        LROPoller for batch configuration update
        """
    
    def get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
        """
        Gets a configuration parameter value from a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        - configuration_name: str, parameter name
        
        Returns:
        Configuration object with current value
        """
    
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
        """
        Lists all configuration parameters for a flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        Paged collection of Configuration objects
        """

Location-Based Capabilities Operations

Regional capability queries for MySQL flexible servers to understand available features and SKUs.

class LocationBasedCapabilitiesOperations:
    """Regional capability queries for MySQL flexible servers."""
    
    def list(self, location_name: str, **kwargs):
        """
        Lists capabilities available in a specific region for flexible servers.
        
        Parameters:
        - location_name: str, Azure region name
        
        Returns:
        Paged collection of capability objects including:
        - Available server versions
        - Supported SKUs and compute tiers
        - Storage options and limits
        - High availability support
        - Backup retention limits
        """

Enhanced Models for Flexible Servers

class Server:
    """Enhanced MySQL flexible server resource representation."""
    id: str
    name: str
    type: str
    location: str
    tags: Dict[str, str]
    system_data: SystemData
    administrator_login: str
    version: str  # MySQL version (5.7, 8.0)
    state: str  # Ready, Starting, Stopping, Stopped, Updating, etc.
    fully_qualified_domain_name: str
    storage: Storage
    backup: Backup
    high_availability: HighAvailability
    network: Network
    maintenance_window: MaintenanceWindow
    source_server_resource_id: str
    restore_point_in_time: datetime
    availability_zone: str
    standby_availability_zone: str
    data_encryption: DataEncryption

class Storage:
    """Enhanced storage configuration for flexible servers."""
    storage_size_gb: int
    iops: int
    auto_grow: str  # Enabled, Disabled
    storage_sku: str  # Premium_LRS, Standard_LRS
    auto_io_scaling: str  # Enabled, Disabled

class HighAvailability:
    """High availability configuration for flexible servers."""
    mode: str  # Disabled, ZoneRedundant, SameZone
    state: str  # NotEnabled, CreatingStandby, Healthy, FailingOver
    standby_availability_zone: str

class Backup:
    """Backup configuration and policies for flexible servers."""
    backup_retention_days: int
    geo_redundant_backup: str  # Enabled, Disabled
    earliest_restore_date: datetime

class Network:
    """Network configuration for flexible servers."""
    public_network_access: str  # Enabled, Disabled
    delegated_subnet_resource_id: str
    private_dns_zone_resource_id: str

class MaintenanceWindow:
    """Maintenance scheduling configuration."""
    custom_window: str  # Enabled, Disabled
    start_hour: int
    start_minute: int
    day_of_week: int

class DataEncryption:
    """Data encryption settings for flexible servers."""
    type: str  # AzureKeyVault, SystemManaged
    geo_backup_key_uri: str
    geo_backup_user_assigned_identity_id: str
    primary_key_uri: str
    primary_user_assigned_identity_id: str

class Database:
    """Database within MySQL flexible server."""
    id: str
    name: str
    type: str
    charset: str
    collation: str
    system_data: SystemData

class FirewallRule:
    """Enhanced firewall rule for MySQL flexible server."""
    id: str
    name: str
    type: str
    start_ip_address: str
    end_ip_address: str
    system_data: SystemData

class Configuration:
    """Enhanced MySQL flexible server configuration parameter."""
    id: str
    name: str
    type: str
    value: str
    current_value: str
    description: str
    default_value: str
    data_type: str
    allowed_values: str
    source: str
    is_dynamic: bool
    is_read_only: bool
    is_config_pending_restart: bool
    system_data: SystemData

class ServerBackup:
    """Backup resource representation for flexible servers."""
    id: str
    name: str
    type: str
    backup_type: str  # Full, Incremental
    completed_time: datetime
    source: str
    system_data: SystemData

Usage Examples

Creating a MySQL Flexible Server with High Availability

from azure.identity import DefaultAzureCredential
from azure.mgmt.rdbms.mysql_flexibleservers import MySQLManagementClient
from azure.mgmt.rdbms.mysql_flexibleservers.models import (
    Server, ServerForCreate, Storage, HighAvailability, Backup, 
    Network, MaintenanceWindow, DataEncryption
)

credential = DefaultAzureCredential()
client = MySQLManagementClient(credential, "subscription-id")

# Define enhanced server parameters
server_creation_parameters = ServerForCreate(
    location="East US",
    tags={"environment": "production"},
    properties=Server(
        administrator_login="myadmin",
        administrator_login_password="SecurePassword123!",
        version="8.0",
        availability_zone="1",
        storage=Storage(
            storage_size_gb=100,
            iops=400,
            auto_grow="Enabled",
            storage_sku="Premium_LRS"
        ),
        high_availability=HighAvailability(
            mode="ZoneRedundant",
            standby_availability_zone="2"
        ),
        backup=Backup(
            backup_retention_days=14,
            geo_redundant_backup="Enabled"
        ),
        network=Network(
            public_network_access="Disabled",
            delegated_subnet_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet"
        ),
        maintenance_window=MaintenanceWindow(
            custom_window="Enabled",
            start_hour=2,
            start_minute=0,
            day_of_week=0  # Sunday
        )
    )
)

# Create flexible server (async operation)
server_operation = client.servers.begin_create(
    "my-resource-group",
    "my-mysql-flexible-server",
    server_creation_parameters
)
server = server_operation.result()  # Wait for completion
print(f"Flexible server created: {server.name}")
print(f"High availability mode: {server.high_availability.mode}")

Managing Backups and Restore Operations

# List available backups
backups = client.backups.list_by_server(
    "my-resource-group",
    "my-mysql-flexible-server"
)

for backup in backups:
    print(f"Backup: {backup.name}, Type: {backup.backup_type}, Completed: {backup.completed_time}")

# Restore to a point in time (create new server from backup)
from datetime import datetime, timedelta

restore_time = datetime.utcnow() - timedelta(hours=2)
restore_parameters = ServerForCreate(
    location="East US",
    properties=Server(
        source_server_resource_id=server.id,
        restore_point_in_time=restore_time,
        create_mode="PointInTimeRestore"
    )
)

restore_operation = client.servers.begin_create(
    "my-resource-group",
    "my-mysql-restored-server",
    restore_parameters
)
restored_server = restore_operation.result()
print(f"Server restored from backup: {restored_server.name}")

Managing High Availability and Failover

# Enable high availability on existing server
ha_config = {"high_availability": {"mode": "SameZone"}}
ha_operation = client.servers.begin_update(
    "my-resource-group",
    "my-mysql-flexible-server",
    ha_config
)
updated_server = ha_operation.result()

# Trigger manual failover
failover_operation = client.servers.begin_failover(
    "my-resource-group",
    "my-mysql-flexible-server"
)
failover_operation.result()
print("Manual failover completed")

# Stop and start server operations
stop_operation = client.servers.begin_stop(
    "my-resource-group",
    "my-mysql-flexible-server"
)
stop_operation.result()
print("Server stopped")

start_operation = client.servers.begin_start(
    "my-resource-group",
    "my-mysql-flexible-server"
)
start_operation.result()
print("Server started")

Install with Tessl CLI