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

PostgreSQL Flexible Servers Management

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

Advanced management capabilities for PostgreSQL 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 PostgreSQL instances.

Capabilities

Management Client

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

class PostgreSQLManagementClient:
    """
    PostgreSQL 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
    - 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 PostgreSQL flexible servers."""
    
    def create(self, resource_group_name: str, server_name: str, parameters, **kwargs):
        """
        Creates a new PostgreSQL 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
          - storage: Storage configuration with auto-scaling
        
        Returns:
        LROPoller for server creation operation
        """
    
    def update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
        """
        Updates an existing PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL flexible servers in the subscription.
        
        Returns:
        Paged collection of Server objects
        """
    
    def list_by_resource_group(self, resource_group_name: str, **kwargs):
        """
        Lists PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL flexible server.
        
        Parameters:
        - resource_group_name: str, resource group name
        - server_name: str, server name
        
        Returns:
        LROPoller for stop operation
        """

Database Operations

Enhanced database management within PostgreSQL flexible servers.

class DatabasesOperations:
    """Database management operations within PostgreSQL flexible servers."""
    
    def create(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
        """
        Creates a database in a PostgreSQL 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 creation operation
        """
    
    def delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
        """
        Deletes a database from a PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL flexible servers with improved security features.

class FirewallRulesOperations:
    """Enhanced firewall rule management for PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL 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 PostgreSQL flexible servers.

class ConfigurationsOperations:
    """Enhanced PostgreSQL flexible server configuration and parameter management."""
    
    def update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
        """
        Updates a configuration parameter for a PostgreSQL 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 get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
        """
        Gets a configuration parameter value from a PostgreSQL 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 PostgreSQL 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 PostgreSQL flexible servers to understand available features and SKUs.

class LocationBasedCapabilitiesOperations:
    """Regional capability queries for PostgreSQL flexible servers."""
    
    def execute(self, location_name: str, parameters, **kwargs):
        """
        Executes capability queries for a specific region for PostgreSQL flexible servers.
        
        Parameters:
        - location_name: str, Azure region name
        - parameters: Capability query parameters
        
        Returns:
        Capability results including:
        - Available server versions (11, 12, 13, 14, 15)
        - Supported SKUs and compute tiers
        - Storage options and limits
        - High availability support
        - Backup retention limits
        - Zone availability
        """

Enhanced Models for PostgreSQL Flexible Servers

class Server:
    """Enhanced PostgreSQL flexible server resource representation."""
    id: str
    name: str
    type: str
    location: str
    tags: Dict[str, str]
    system_data: SystemData
    administrator_login: str
    administrator_login_password: str
    version: str  # PostgreSQL version (11, 12, 13, 14, 15)
    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
    point_in_time_utc: datetime
    availability_zone: str
    standby_availability_zone: str
    create_mode: str  # Default, Create, Update, PointInTimeRestore, GeoRestore, Replica
    auth_config: AuthConfig
    data_encryption: DataEncryption
    replica: Replica

class Storage:
    """Enhanced storage configuration for PostgreSQL flexible servers."""
    storage_size_gb: int
    auto_grow: str  # Enabled, Disabled
    tier: str  # P4, P6, P10, P15, P20, P30, P40, P50, P60, P70, P80

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

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

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

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

class AuthConfig:
    """Authentication configuration for PostgreSQL flexible servers."""
    active_directory_auth: str  # Enabled, Disabled
    password_auth: str  # Enabled, Disabled
    tenant_id: str

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

class Replica:
    """Read replica configuration for PostgreSQL flexible servers."""
    role: str  # Primary, AsyncReplica, GeoAsyncReplica
    capacity: int
    replication_state: str  # Active, Catchup, Provisioning, Updating, Broken, Reconfiguring

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

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

class Configuration:
    """Enhanced PostgreSQL flexible server configuration parameter."""
    id: str
    name: str
    type: str
    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
    unit: str
    system_data: SystemData

Usage Examples

Creating a PostgreSQL Flexible Server with High Availability

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

credential = DefaultAzureCredential()
client = PostgreSQLManagementClient(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="14",
        availability_zone="1",
        create_mode="Default",
        storage=Storage(
            storage_size_gb=128,
            auto_grow="Enabled",
            tier="P10"
        ),
        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",
            private_dns_zone_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/privateDnsZones/privatelink.postgres.database.azure.com"
        ),
        maintenance_window=MaintenanceWindow(
            custom_window="Enabled",
            start_hour=2,
            start_minute=0,
            day_of_week=0  # Sunday
        ),
        auth_config=AuthConfig(
            active_directory_auth="Enabled",
            password_auth="Enabled",
            tenant_id="11111111-1111-1111-1111-111111111111"
        )
    )
)

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

Point-in-Time Restore and Geo-Restore

from datetime import datetime, timedelta

# Point-in-time restore (create new server from backup)
restore_time = datetime.utcnow() - timedelta(hours=2)
pitr_parameters = ServerForCreate(
    location="East US",
    properties=Server(
        source_server_resource_id=server.id,
        point_in_time_utc=restore_time,
        create_mode="PointInTimeRestore"
    )
)

pitr_operation = client.servers.begin_create(
    "my-resource-group",
    "my-postgresql-pitr-server",
    pitr_parameters
)
pitr_server = pitr_operation.result()
print(f"Server restored from point-in-time: {pitr_server.name}")

# Geo-restore (restore to different region)
geo_restore_parameters = ServerForCreate(
    location="West US 2",  # Different region
    properties=Server(
        source_server_resource_id=server.id,
        create_mode="GeoRestore"
    )
)

geo_operation = client.servers.begin_create(
    "my-resource-group-west",
    "my-postgresql-geo-server",
    geo_restore_parameters
)
geo_server = geo_operation.result()
print(f"Server geo-restored: {geo_server.name}")

Managing Private Networking and DNS

# Check VNet subnet usage before creating server
from azure.mgmt.rdbms.postgresql_flexibleservers.models import VirtualNetworkSubnetUsageParameter

subnet_usage_params = VirtualNetworkSubnetUsageParameter(
    virtual_network_arm_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet"
)

subnet_usage = client.check_virtual_network_subnet_usage.execute(
    "East US",
    subnet_usage_params
)
print(f"Subnet delegated: {subnet_usage.subnet_usage.delegated_subnets}")

# Get private DNS zone suffix for region
dns_suffix = client.get_private_dns_zone_suffix.execute("East US")
print(f"Private DNS suffix: {dns_suffix.private_dns_zone_suffix}")

# Update server network configuration
network_update = {
    "network": {
        "public_network_access": "Disabled"
    }
}

network_operation = client.servers.begin_update(
    "my-resource-group",
    "my-postgresql-flexible-server",
    network_update
)
updated_server = network_operation.result()
print(f"Network access updated: {updated_server.network.public_network_access}")

Advanced Configuration and Monitoring

# Configure PostgreSQL parameters
config_params = {"value": "on"}
config_operation = client.configurations.begin_update(
    "my-resource-group",
    "my-postgresql-flexible-server",
    "log_statement",
    config_params
)
config_operation.result()

# List all server configurations
configurations = client.configurations.list_by_server(
    "my-resource-group",
    "my-postgresql-flexible-server"
)

for config in configurations:
    if config.source != "system-default":
        print(f"Custom config: {config.name} = {config.value}")

# Stop and start server for maintenance
stop_operation = client.servers.begin_stop(
    "my-resource-group",
    "my-postgresql-flexible-server"
)
stop_operation.result()
print("PostgreSQL server stopped for maintenance")

start_operation = client.servers.begin_start(
    "my-resource-group",
    "my-postgresql-flexible-server"
)
start_operation.result()
print("PostgreSQL server started after maintenance")

Install with Tessl CLI