0
# PostgreSQL Flexible Servers Management
1

2
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.
3

4
## Capabilities
5

6
### Management Client
7

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

10
```python { .api }
11
class PostgreSQLManagementClient:
12
    """
13
    PostgreSQL management client for flexible server deployments.
14
    
15
    Parameters:
16
    - credential: TokenCredential for Azure authentication
17
    - subscription_id: str, Azure subscription ID
18
    - base_url: str, management endpoint (default: https://management.azure.com)
19
    - polling_interval: int, LRO polling interval in seconds
20
    
21
    Attributes:
22
    - servers: Enhanced server lifecycle operations
23
    - databases: Database management operations
24
    - firewall_rules: Firewall configuration operations
25
    - configurations: Server parameter operations
26
    - location_based_capabilities: Regional capability queries
27
    """
28
    def __init__(
29
        self,
30
        credential,
31
        subscription_id: str,
32
        base_url: str = "https://management.azure.com",
33
        **kwargs
34
    ): ...
35
    
36
    def close(self): ...
37
    def __enter__(self): ...
38
    def __exit__(self, *exc_details): ...
39
```
40

41
### Enhanced Server Operations
42

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

45
```python { .api }
46
class ServersOperations:
47
    """Enhanced server lifecycle and management operations for PostgreSQL flexible servers."""
48
    
49
    def create(self, resource_group_name: str, server_name: str, parameters, **kwargs):
50
        """
51
        Creates a new PostgreSQL flexible server with enhanced capabilities.
52
        
53
        Parameters:
54
        - resource_group_name: str, resource group name
55
        - server_name: str, server name (must be globally unique)
56
        - parameters: Enhanced server creation parameters including:
57
          - high_availability: HighAvailability configuration
58
          - backup: Backup configuration and policies
59
          - network: Network configuration including private access
60
          - maintenance_window: Maintenance scheduling
61
          - data_encryption: Data encryption settings
62
          - storage: Storage configuration with auto-scaling
63
        
64
        Returns:
65
        LROPoller for server creation operation
66
        """
67
    
68
    def update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
69
        """
70
        Updates an existing PostgreSQL flexible server.
71
        
72
        Parameters:
73
        - resource_group_name: str, resource group name
74
        - server_name: str, server name
75
        - parameters: Server update parameters with flexible server properties
76
        
77
        Returns:
78
        LROPoller for server update operation
79
        """
80
    
81
    def delete(self, resource_group_name: str, server_name: str, **kwargs):
82
        """
83
        Deletes a PostgreSQL flexible server.
84
        
85
        Parameters:
86
        - resource_group_name: str, resource group name
87
        - server_name: str, server name
88
        
89
        Returns:
90
        LROPoller for server deletion operation
91
        """
92
    
93
    def get(self, resource_group_name: str, server_name: str, **kwargs):
94
        """
95
        Gets details of a PostgreSQL flexible server.
96
        
97
        Parameters:
98
        - resource_group_name: str, resource group name
99
        - server_name: str, server name
100
        
101
        Returns:
102
        Server object with enhanced flexible server properties
103
        """
104
    
105
    def list(self, **kwargs):
106
        """
107
        Lists all PostgreSQL flexible servers in the subscription.
108
        
109
        Returns:
110
        Paged collection of Server objects
111
        """
112
    
113
    def list_by_resource_group(self, resource_group_name: str, **kwargs):
114
        """
115
        Lists PostgreSQL flexible servers in a resource group.
116
        
117
        Parameters:
118
        - resource_group_name: str, resource group name
119
        
120
        Returns:
121
        Paged collection of Server objects
122
        """
123
    
124
    def restart(self, resource_group_name: str, server_name: str, restart_parameters, **kwargs):
125
        """
126
        Restarts a PostgreSQL flexible server with optional parameters.
127
        
128
        Parameters:
129
        - resource_group_name: str, resource group name
130
        - server_name: str, server name
131
        - restart_parameters: Restart configuration options
132
        
133
        Returns:
134
        LROPoller for restart operation
135
        """
136
    
137
    def start(self, resource_group_name: str, server_name: str, **kwargs):
138
        """
139
        Starts a stopped PostgreSQL flexible server.
140
        
141
        Parameters:
142
        - resource_group_name: str, resource group name
143
        - server_name: str, server name
144
        
145
        Returns:
146
        LROPoller for start operation
147
        """
148
    
149
    def stop(self, resource_group_name: str, server_name: str, **kwargs):
150
        """
151
        Stops a running PostgreSQL flexible server.
152
        
153
        Parameters:
154
        - resource_group_name: str, resource group name
155
        - server_name: str, server name
156
        
157
        Returns:
158
        LROPoller for stop operation
159
        """
160
```
161

162
### Database Operations
163

164
Enhanced database management within PostgreSQL flexible servers.
165

166
```python { .api }
167
class DatabasesOperations:
168
    """Database management operations within PostgreSQL flexible servers."""
169
    
170
    def create(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
171
        """
172
        Creates a database in a PostgreSQL flexible server.
173
        
174
        Parameters:
175
        - resource_group_name: str, resource group name
176
        - server_name: str, server name
177
        - database_name: str, database name
178
        - parameters: Database parameters (charset, collation)
179
        
180
        Returns:
181
        LROPoller for database creation operation
182
        """
183
    
184
    def delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
185
        """
186
        Deletes a database from a PostgreSQL flexible server.
187
        
188
        Parameters:
189
        - resource_group_name: str, resource group name
190
        - server_name: str, server name
191
        - database_name: str, database name
192
        
193
        Returns:
194
        LROPoller for deletion operation
195
        """
196
    
197
    def get(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
198
        """
199
        Gets database properties from a PostgreSQL flexible server.
200
        
201
        Parameters:
202
        - resource_group_name: str, resource group name
203
        - server_name: str, server name
204
        - database_name: str, database name
205
        
206
        Returns:
207
        Database object with properties
208
        """
209
    
210
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
211
        """
212
        Lists databases in a PostgreSQL flexible server.
213
        
214
        Parameters:
215
        - resource_group_name: str, resource group name
216
        - server_name: str, server name
217
        
218
        Returns:
219
        Paged collection of Database objects
220
        """
221
```
222

223
### Firewall Rules Operations
224

225
Enhanced firewall management for PostgreSQL flexible servers with improved security features.
226

227
```python { .api }
228
class FirewallRulesOperations:
229
    """Enhanced firewall rule management for PostgreSQL flexible servers."""
230
    
231
    def create_or_update(self, resource_group_name: str, server_name: str, firewall_rule_name: str, parameters, **kwargs):
232
        """
233
        Creates or updates a firewall rule for a PostgreSQL flexible server.
234
        
235
        Parameters:
236
        - resource_group_name: str, resource group name
237
        - server_name: str, server name
238
        - firewall_rule_name: str, firewall rule name
239
        - parameters: Enhanced firewall rule parameters
240
        
241
        Returns:
242
        LROPoller for firewall rule operation
243
        """
244
    
245
    def delete(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
246
        """
247
        Deletes a firewall rule from a PostgreSQL flexible server.
248
        
249
        Parameters:
250
        - resource_group_name: str, resource group name
251
        - server_name: str, server name
252
        - firewall_rule_name: str, firewall rule name
253
        
254
        Returns:
255
        LROPoller for deletion operation
256
        """
257
    
258
    def get(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
259
        """
260
        Gets a firewall rule from a PostgreSQL flexible server.
261
        
262
        Parameters:
263
        - resource_group_name: str, resource group name
264
        - server_name: str, server name
265
        - firewall_rule_name: str, firewall rule name
266
        
267
        Returns:
268
        FirewallRule object
269
        """
270
    
271
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
272
        """
273
        Lists firewall rules for a PostgreSQL flexible server.
274
        
275
        Parameters:
276
        - resource_group_name: str, resource group name
277
        - server_name: str, server name
278
        
279
        Returns:
280
        Paged collection of FirewallRule objects
281
        """
282
```
283

284
### Configuration Operations
285

286
Enhanced server parameter and configuration management for PostgreSQL flexible servers.
287

288
```python { .api }
289
class ConfigurationsOperations:
290
    """Enhanced PostgreSQL flexible server configuration and parameter management."""
291
    
292
    def update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
293
        """
294
        Updates a configuration parameter for a PostgreSQL flexible server.
295
        
296
        Parameters:
297
        - resource_group_name: str, resource group name
298
        - server_name: str, server name
299
        - configuration_name: str, parameter name
300
        - parameters: Enhanced configuration value and properties
301
        
302
        Returns:
303
        LROPoller for configuration update
304
        """
305
    
306
    def get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
307
        """
308
        Gets a configuration parameter value from a PostgreSQL flexible server.
309
        
310
        Parameters:
311
        - resource_group_name: str, resource group name
312
        - server_name: str, server name
313
        - configuration_name: str, parameter name
314
        
315
        Returns:
316
        Configuration object with current value
317
        """
318
    
319
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
320
        """
321
        Lists all configuration parameters for a PostgreSQL flexible server.
322
        
323
        Parameters:
324
        - resource_group_name: str, resource group name
325
        - server_name: str, server name
326
        
327
        Returns:
328
        Paged collection of Configuration objects
329
        """
330
```
331

332
### Location-Based Capabilities Operations
333

334
Regional capability queries for PostgreSQL flexible servers to understand available features and SKUs.
335

336
```python { .api }
337
class LocationBasedCapabilitiesOperations:
338
    """Regional capability queries for PostgreSQL flexible servers."""
339
    
340
    def execute(self, location_name: str, parameters, **kwargs):
341
        """
342
        Executes capability queries for a specific region for PostgreSQL flexible servers.
343
        
344
        Parameters:
345
        - location_name: str, Azure region name
346
        - parameters: Capability query parameters
347
        
348
        Returns:
349
        Capability results including:
350
        - Available server versions (11, 12, 13, 14, 15)
351
        - Supported SKUs and compute tiers
352
        - Storage options and limits
353
        - High availability support
354
        - Backup retention limits
355
        - Zone availability
356
        """
357
```
358

359
## Enhanced Models for PostgreSQL Flexible Servers
360

361
```python { .api }
362
class Server:
363
    """Enhanced PostgreSQL flexible server resource representation."""
364
    id: str
365
    name: str
366
    type: str
367
    location: str
368
    tags: Dict[str, str]
369
    system_data: SystemData
370
    administrator_login: str
371
    administrator_login_password: str
372
    version: str  # PostgreSQL version (11, 12, 13, 14, 15)
373
    state: str  # Ready, Starting, Stopping, Stopped, Updating, etc.
374
    fully_qualified_domain_name: str
375
    storage: Storage
376
    backup: Backup
377
    high_availability: HighAvailability
378
    network: Network
379
    maintenance_window: MaintenanceWindow
380
    source_server_resource_id: str
381
    point_in_time_utc: datetime
382
    availability_zone: str
383
    standby_availability_zone: str
384
    create_mode: str  # Default, Create, Update, PointInTimeRestore, GeoRestore, Replica
385
    auth_config: AuthConfig
386
    data_encryption: DataEncryption
387
    replica: Replica
388

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

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

401
class Backup:
402
    """Backup configuration and policies for PostgreSQL flexible servers."""
403
    backup_retention_days: int
404
    geo_redundant_backup: str  # Enabled, Disabled
405
    earliest_restore_date: datetime
406

407
class Network:
408
    """Network configuration for PostgreSQL flexible servers."""
409
    public_network_access: str  # Enabled, Disabled
410
    delegated_subnet_resource_id: str
411
    private_dns_zone_resource_id: str
412

413
class MaintenanceWindow:
414
    """Maintenance scheduling configuration for PostgreSQL flexible servers."""
415
    custom_window: str  # Enabled, Disabled
416
    start_hour: int
417
    start_minute: int
418
    day_of_week: int
419

420
class AuthConfig:
421
    """Authentication configuration for PostgreSQL flexible servers."""
422
    active_directory_auth: str  # Enabled, Disabled
423
    password_auth: str  # Enabled, Disabled
424
    tenant_id: str
425

426
class DataEncryption:
427
    """Data encryption settings for PostgreSQL flexible servers."""
428
    type: str  # AzureKeyVault, SystemManaged
429
    primary_key_uri: str
430
    primary_user_assigned_identity_id: str
431
    geo_backup_key_uri: str
432
    geo_backup_user_assigned_identity_id: str
433

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

440
class Database:
441
    """Database within PostgreSQL flexible server."""
442
    id: str
443
    name: str
444
    type: str
445
    charset: str
446
    collation: str
447
    system_data: SystemData
448

449
class FirewallRule:
450
    """Enhanced firewall rule for PostgreSQL flexible server."""
451
    id: str
452
    name: str
453
    type: str
454
    start_ip_address: str
455
    end_ip_address: str
456
    system_data: SystemData
457

458
class Configuration:
459
    """Enhanced PostgreSQL flexible server configuration parameter."""
460
    id: str
461
    name: str
462
    type: str
463
    value: str
464
    description: str
465
    default_value: str
466
    data_type: str
467
    allowed_values: str
468
    source: str
469
    is_dynamic: bool
470
    is_read_only: bool
471
    is_config_pending_restart: bool
472
    unit: str
473
    system_data: SystemData
474
```
475

476
## Usage Examples
477

478
### Creating a PostgreSQL Flexible Server with High Availability
479

480
```python
481
from azure.identity import DefaultAzureCredential
482
from azure.mgmt.rdbms.postgresql_flexibleservers import PostgreSQLManagementClient
483
from azure.mgmt.rdbms.postgresql_flexibleservers.models import (
484
    Server, ServerForCreate, Storage, HighAvailability, Backup, 
485
    Network, MaintenanceWindow, AuthConfig, DataEncryption
486
)
487

488
credential = DefaultAzureCredential()
489
client = PostgreSQLManagementClient(credential, "subscription-id")
490

491
# Define enhanced server parameters
492
server_creation_parameters = ServerForCreate(
493
    location="East US",
494
    tags={"environment": "production"},
495
    properties=Server(
496
        administrator_login="myadmin",
497
        administrator_login_password="SecurePassword123!",
498
        version="14",
499
        availability_zone="1",
500
        create_mode="Default",
501
        storage=Storage(
502
            storage_size_gb=128,
503
            auto_grow="Enabled",
504
            tier="P10"
505
        ),
506
        high_availability=HighAvailability(
507
            mode="ZoneRedundant",
508
            standby_availability_zone="2"
509
        ),
510
        backup=Backup(
511
            backup_retention_days=14,
512
            geo_redundant_backup="Enabled"
513
        ),
514
        network=Network(
515
            public_network_access="Disabled",
516
            delegated_subnet_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet",
517
            private_dns_zone_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/privateDnsZones/privatelink.postgres.database.azure.com"
518
        ),
519
        maintenance_window=MaintenanceWindow(
520
            custom_window="Enabled",
521
            start_hour=2,
522
            start_minute=0,
523
            day_of_week=0  # Sunday
524
        ),
525
        auth_config=AuthConfig(
526
            active_directory_auth="Enabled",
527
            password_auth="Enabled",
528
            tenant_id="11111111-1111-1111-1111-111111111111"
529
        )
530
    )
531
)
532

533
# Create flexible server (async operation)
534
server_operation = client.servers.begin_create(
535
    "my-resource-group",
536
    "my-postgresql-flexible-server",
537
    server_creation_parameters
538
)
539
server = server_operation.result()  # Wait for completion
540
print(f"PostgreSQL flexible server created: {server.name}")
541
print(f"High availability mode: {server.high_availability.mode}")
542
print(f"Authentication config: {server.auth_config.active_directory_auth}")
543
```
544

545
### Point-in-Time Restore and Geo-Restore
546

547
```python
548
from datetime import datetime, timedelta
549

550
# Point-in-time restore (create new server from backup)
551
restore_time = datetime.utcnow() - timedelta(hours=2)
552
pitr_parameters = ServerForCreate(
553
    location="East US",
554
    properties=Server(
555
        source_server_resource_id=server.id,
556
        point_in_time_utc=restore_time,
557
        create_mode="PointInTimeRestore"
558
    )
559
)
560

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

569
# Geo-restore (restore to different region)
570
geo_restore_parameters = ServerForCreate(
571
    location="West US 2",  # Different region
572
    properties=Server(
573
        source_server_resource_id=server.id,
574
        create_mode="GeoRestore"
575
    )
576
)
577

578
geo_operation = client.servers.begin_create(
579
    "my-resource-group-west",
580
    "my-postgresql-geo-server",
581
    geo_restore_parameters
582
)
583
geo_server = geo_operation.result()
584
print(f"Server geo-restored: {geo_server.name}")
585
```
586

587
### Managing Private Networking and DNS
588

589
```python
590
# Check VNet subnet usage before creating server
591
from azure.mgmt.rdbms.postgresql_flexibleservers.models import VirtualNetworkSubnetUsageParameter
592

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

597
subnet_usage = client.check_virtual_network_subnet_usage.execute(
598
    "East US",
599
    subnet_usage_params
600
)
601
print(f"Subnet delegated: {subnet_usage.subnet_usage.delegated_subnets}")
602

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

607
# Update server network configuration
608
network_update = {
609
    "network": {
610
        "public_network_access": "Disabled"
611
    }
612
}
613

614
network_operation = client.servers.begin_update(
615
    "my-resource-group",
616
    "my-postgresql-flexible-server",
617
    network_update
618
)
619
updated_server = network_operation.result()
620
print(f"Network access updated: {updated_server.network.public_network_access}")
621
```
622

623
### Advanced Configuration and Monitoring
624

625
```python
626
# Configure PostgreSQL parameters
627
config_params = {"value": "on"}
628
config_operation = client.configurations.begin_update(
629
    "my-resource-group",
630
    "my-postgresql-flexible-server",
631
    "log_statement",
632
    config_params
633
)
634
config_operation.result()
635

636
# List all server configurations
637
configurations = client.configurations.list_by_server(
638
    "my-resource-group",
639
    "my-postgresql-flexible-server"
640
)
641

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

646
# Stop and start server for maintenance
647
stop_operation = client.servers.begin_stop(
648
    "my-resource-group",
649
    "my-postgresql-flexible-server"
650
)
651
stop_operation.result()
652
print("PostgreSQL server stopped for maintenance")
653

654
start_operation = client.servers.begin_start(
655
    "my-resource-group",
656
    "my-postgresql-flexible-server"
657
)
658
start_operation.result()
659
print("PostgreSQL server started after maintenance")
660
```