0
# PostgreSQL Single Server Management
1
2
Complete management capabilities for PostgreSQL single server deployments on Azure. This service provides server lifecycle management, database operations, security configuration, and administrative features for PostgreSQL instances.
3
4
## Capabilities
5
6
### Management Client
7
8
Main client for PostgreSQL single server operations with comprehensive resource management capabilities.
9
10
```python { .api }
11
class PostgreSQLManagementClient:
12
"""
13
PostgreSQL management client for single 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: Server lifecycle operations
23
- databases: Database management operations
24
- firewall_rules: Firewall configuration operations
25
- configurations: Server parameter operations
26
- replicas: Read replica operations
27
- server_administrators: Azure AD administrator management
28
- server_keys: Customer-managed encryption keys
29
"""
30
def __init__(
31
self,
32
credential,
33
subscription_id: str,
34
base_url: str = "https://management.azure.com",
35
**kwargs
36
): ...
37
38
def close(self): ...
39
def __enter__(self): ...
40
def __exit__(self, *exc_details): ...
41
```
42
43
### Server Operations
44
45
Core server lifecycle management including creation, updates, deletion, restart, and upgrade operations.
46
47
```python { .api }
48
class ServersOperations:
49
"""Server lifecycle and management operations."""
50
51
def create(self, resource_group_name: str, server_name: str, parameters, **kwargs):
52
"""
53
Creates a new PostgreSQL server.
54
55
Parameters:
56
- resource_group_name: str, resource group name
57
- server_name: str, server name (must be globally unique)
58
- parameters: Server creation parameters
59
60
Returns:
61
LROPoller for server creation operation
62
"""
63
64
def update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
65
"""
66
Updates an existing PostgreSQL server.
67
68
Parameters:
69
- resource_group_name: str, resource group name
70
- server_name: str, server name
71
- parameters: Server update parameters
72
73
Returns:
74
LROPoller for server update operation
75
"""
76
77
def delete(self, resource_group_name: str, server_name: str, **kwargs):
78
"""
79
Deletes a PostgreSQL server.
80
81
Parameters:
82
- resource_group_name: str, resource group name
83
- server_name: str, server name
84
85
Returns:
86
LROPoller for server deletion operation
87
"""
88
89
def get(self, resource_group_name: str, server_name: str, **kwargs):
90
"""
91
Gets details of a PostgreSQL server.
92
93
Parameters:
94
- resource_group_name: str, resource group name
95
- server_name: str, server name
96
97
Returns:
98
Server object with current properties
99
"""
100
101
def list(self, **kwargs):
102
"""
103
Lists all PostgreSQL servers in the subscription.
104
105
Returns:
106
Paged collection of Server objects
107
"""
108
109
def list_by_resource_group(self, resource_group_name: str, **kwargs):
110
"""
111
Lists PostgreSQL servers in a resource group.
112
113
Parameters:
114
- resource_group_name: str, resource group name
115
116
Returns:
117
Paged collection of Server objects
118
"""
119
120
def restart(self, resource_group_name: str, server_name: str, **kwargs):
121
"""
122
Restarts a PostgreSQL server.
123
124
Parameters:
125
- resource_group_name: str, resource group name
126
- server_name: str, server name
127
128
Returns:
129
LROPoller for restart operation
130
"""
131
```
132
133
### Database Operations
134
135
Database management within PostgreSQL servers including creation, deletion, and property queries.
136
137
```python { .api }
138
class DatabasesOperations:
139
"""Database management operations within PostgreSQL servers."""
140
141
def create_or_update(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
142
"""
143
Creates or updates a database.
144
145
Parameters:
146
- resource_group_name: str, resource group name
147
- server_name: str, server name
148
- database_name: str, database name
149
- parameters: Database parameters (charset, collation)
150
151
Returns:
152
LROPoller for database operation
153
"""
154
155
def delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
156
"""
157
Deletes a database.
158
159
Parameters:
160
- resource_group_name: str, resource group name
161
- server_name: str, server name
162
- database_name: str, database name
163
164
Returns:
165
LROPoller for deletion operation
166
"""
167
168
def get(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
169
"""
170
Gets database properties.
171
172
Parameters:
173
- resource_group_name: str, resource group name
174
- server_name: str, server name
175
- database_name: str, database name
176
177
Returns:
178
Database object with properties
179
"""
180
181
def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
182
"""
183
Lists databases in a PostgreSQL server.
184
185
Parameters:
186
- resource_group_name: str, resource group name
187
- server_name: str, server name
188
189
Returns:
190
Paged collection of Database objects
191
"""
192
```
193
194
### Firewall Rules Operations
195
196
IP-based access control configuration for PostgreSQL servers.
197
198
```python { .api }
199
class FirewallRulesOperations:
200
"""Firewall rule management for PostgreSQL servers."""
201
202
def create_or_update(self, resource_group_name: str, server_name: str, firewall_rule_name: str, parameters, **kwargs):
203
"""
204
Creates or updates a firewall rule.
205
206
Parameters:
207
- resource_group_name: str, resource group name
208
- server_name: str, server name
209
- firewall_rule_name: str, firewall rule name
210
- parameters: Firewall rule parameters (start_ip_address, end_ip_address)
211
212
Returns:
213
LROPoller for firewall rule operation
214
"""
215
216
def delete(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
217
"""
218
Deletes a firewall rule.
219
220
Parameters:
221
- resource_group_name: str, resource group name
222
- server_name: str, server name
223
- firewall_rule_name: str, firewall rule name
224
225
Returns:
226
LROPoller for deletion operation
227
"""
228
229
def get(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
230
"""
231
Gets a firewall rule.
232
233
Parameters:
234
- resource_group_name: str, resource group name
235
- server_name: str, server name
236
- firewall_rule_name: str, firewall rule name
237
238
Returns:
239
FirewallRule object
240
"""
241
242
def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
243
"""
244
Lists firewall rules for a PostgreSQL server.
245
246
Parameters:
247
- resource_group_name: str, resource group name
248
- server_name: str, server name
249
250
Returns:
251
Paged collection of FirewallRule objects
252
"""
253
```
254
255
### Configuration Operations
256
257
Server parameter and configuration management for PostgreSQL instances.
258
259
```python { .api }
260
class ConfigurationsOperations:
261
"""PostgreSQL server configuration and parameter management."""
262
263
def create_or_update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
264
"""
265
Updates a configuration parameter.
266
267
Parameters:
268
- resource_group_name: str, resource group name
269
- server_name: str, server name
270
- configuration_name: str, parameter name
271
- parameters: Configuration value and properties
272
273
Returns:
274
LROPoller for configuration update
275
"""
276
277
def get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
278
"""
279
Gets a configuration parameter value.
280
281
Parameters:
282
- resource_group_name: str, resource group name
283
- server_name: str, server name
284
- configuration_name: str, parameter name
285
286
Returns:
287
Configuration object with current value
288
"""
289
290
def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
291
"""
292
Lists all configuration parameters for a server.
293
294
Parameters:
295
- resource_group_name: str, resource group name
296
- server_name: str, server name
297
298
Returns:
299
Paged collection of Configuration objects
300
"""
301
```
302
303
### Security and Administration Operations
304
305
Advanced security and administrative features for PostgreSQL servers.
306
307
```python { .api }
308
class ServerAdministratorsOperations:
309
"""Azure Active Directory administrator management."""
310
311
def create_or_update(self, resource_group_name: str, server_name: str, properties, **kwargs):
312
"""
313
Creates or updates an Azure AD administrator.
314
315
Parameters:
316
- resource_group_name: str, resource group name
317
- server_name: str, server name
318
- properties: Administrator properties (login, sid, tenant_id)
319
320
Returns:
321
LROPoller for administrator operation
322
"""
323
324
def delete(self, resource_group_name: str, server_name: str, **kwargs):
325
"""
326
Removes the Azure AD administrator.
327
328
Parameters:
329
- resource_group_name: str, resource group name
330
- server_name: str, server name
331
332
Returns:
333
LROPoller for deletion operation
334
"""
335
336
def get(self, resource_group_name: str, server_name: str, **kwargs):
337
"""
338
Gets the Azure AD administrator.
339
340
Parameters:
341
- resource_group_name: str, resource group name
342
- server_name: str, server name
343
344
Returns:
345
ServerAdministratorResource object
346
"""
347
348
def list(self, resource_group_name: str, server_name: str, **kwargs):
349
"""
350
Lists Azure AD administrators for a server.
351
352
Parameters:
353
- resource_group_name: str, resource group name
354
- server_name: str, server name
355
356
Returns:
357
Paged collection of ServerAdministratorResource objects
358
"""
359
360
class ServerKeysOperations:
361
"""Customer-managed encryption key operations."""
362
363
def create_or_update(self, resource_group_name: str, server_name: str, key_name: str, parameters, **kwargs):
364
"""
365
Creates or updates a server key for data encryption.
366
367
Parameters:
368
- resource_group_name: str, resource group name
369
- server_name: str, server name
370
- key_name: str, key name
371
- parameters: Key parameters (server_key_type, uri)
372
373
Returns:
374
LROPoller for key operation
375
"""
376
377
def delete(self, resource_group_name: str, server_name: str, key_name: str, **kwargs):
378
"""
379
Deletes a server key.
380
381
Parameters:
382
- resource_group_name: str, resource group name
383
- server_name: str, server name
384
- key_name: str, key name
385
386
Returns:
387
LROPoller for deletion operation
388
"""
389
390
def get(self, resource_group_name: str, server_name: str, key_name: str, **kwargs):
391
"""
392
Gets a server key.
393
394
Parameters:
395
- resource_group_name: str, resource group name
396
- server_name: str, server name
397
- key_name: str, key name
398
399
Returns:
400
ServerKey object
401
"""
402
403
def list(self, resource_group_name: str, server_name: str, **kwargs):
404
"""
405
Lists server keys for a PostgreSQL server.
406
407
Parameters:
408
- resource_group_name: str, resource group name
409
- server_name: str, server name
410
411
Returns:
412
Paged collection of ServerKey objects
413
"""
414
```
415
416
## Key Models
417
418
```python { .api }
419
class Server:
420
"""PostgreSQL server resource representation."""
421
id: str
422
name: str
423
type: str
424
location: str
425
tags: Dict[str, str]
426
administrator_login: str
427
version: str # PostgreSQL version (9.5, 9.6, 10, 11, 12, 13, 14)
428
ssl_enforcement: str # Enabled, Disabled
429
minimal_tls_version: str # TLS1_0, TLS1_1, TLS1_2
430
user_visible_state: str # Ready, Dropping, Disabled, etc.
431
fully_qualified_domain_name: str
432
earliest_restore_date: datetime
433
storage_profile: StorageProfile
434
replication_role: str # None, Master, Replica
435
master_server_id: str
436
replica_capacity: int
437
public_network_access: str # Enabled, Disabled
438
infrastructure_encryption: str # Enabled, Disabled
439
440
class Database:
441
"""Database within PostgreSQL server."""
442
id: str
443
name: str
444
type: str
445
charset: str
446
collation: str
447
448
class FirewallRule:
449
"""IP-based access rule for PostgreSQL server."""
450
id: str
451
name: str
452
type: str
453
start_ip_address: str
454
end_ip_address: str
455
456
class Configuration:
457
"""PostgreSQL server configuration parameter."""
458
id: str
459
name: str
460
type: str
461
value: str
462
description: str
463
default_value: str
464
data_type: str
465
allowed_values: str
466
source: str
467
468
class StorageProfile:
469
"""Storage configuration for PostgreSQL server."""
470
backup_retention_days: int
471
geo_redundant_backup: str # Enabled, Disabled
472
storage_mb: int
473
storage_autogrow: str # Enabled, Disabled
474
475
class ServerAdministratorResource:
476
"""Azure AD administrator for PostgreSQL server."""
477
id: str
478
name: str
479
type: str
480
administrator_type: str # ActiveDirectory
481
login: str
482
sid: str
483
tenant_id: str
484
485
class ServerKey:
486
"""Customer-managed encryption key for PostgreSQL server."""
487
id: str
488
name: str
489
type: str
490
kind: str
491
server_key_type: str # AzureKeyVault
492
uri: str
493
creation_date: datetime
494
```
495
496
## Usage Examples
497
498
### Creating a PostgreSQL Server
499
500
```python
501
from azure.identity import DefaultAzureCredential
502
from azure.mgmt.rdbms.postgresql import PostgreSQLManagementClient
503
from azure.mgmt.rdbms.postgresql.models import ServerForCreate, ServerPropertiesForDefaultCreate, StorageProfile
504
505
credential = DefaultAzureCredential()
506
client = PostgreSQLManagementClient(credential, "subscription-id")
507
508
# Define server parameters
509
server_creation_parameters = ServerForCreate(
510
properties=ServerPropertiesForDefaultCreate(
511
administrator_login="myadmin",
512
administrator_login_password="SecurePassword123!",
513
version="13",
514
ssl_enforcement="Enabled",
515
minimal_tls_version="TLS1_2",
516
storage_profile=StorageProfile(
517
backup_retention_days=7,
518
geo_redundant_backup="Disabled",
519
storage_mb=5120,
520
storage_autogrow="Enabled"
521
)
522
),
523
location="East US",
524
tags={"environment": "production"}
525
)
526
527
# Create server (async operation)
528
server_operation = client.servers.begin_create(
529
"my-resource-group",
530
"my-postgresql-server",
531
server_creation_parameters
532
)
533
server = server_operation.result() # Wait for completion
534
print(f"Server created: {server.name}")
535
```
536
537
### Managing Databases and Security
538
539
```python
540
# Create a database
541
database_params = {"charset": "UTF8", "collation": "en_US.utf8"}
542
db_operation = client.databases.begin_create_or_update(
543
"my-resource-group",
544
"my-postgresql-server",
545
"my-application-db",
546
database_params
547
)
548
database = db_operation.result()
549
550
# Add firewall rule for application servers
551
firewall_params = {
552
"start_ip_address": "203.0.113.0",
553
"end_ip_address": "203.0.113.255"
554
}
555
fw_operation = client.firewall_rules.begin_create_or_update(
556
"my-resource-group",
557
"my-postgresql-server",
558
"app-servers",
559
firewall_params
560
)
561
firewall_rule = fw_operation.result()
562
563
# Configure Azure AD administrator
564
admin_params = {
565
"administrator_type": "ActiveDirectory",
566
"login": "admin@company.com",
567
"sid": "00000000-0000-0000-0000-000000000000",
568
"tenant_id": "11111111-1111-1111-1111-111111111111"
569
}
570
admin_operation = client.server_administrators.begin_create_or_update(
571
"my-resource-group",
572
"my-postgresql-server",
573
admin_params
574
)
575
administrator = admin_operation.result()
576
577
# Configure server parameter
578
config_params = {"value": "on"}
579
config_operation = client.configurations.begin_create_or_update(
580
"my-resource-group",
581
"my-postgresql-server",
582
"log_connections",
583
config_params
584
)
585
configuration = config_operation.result()
586
```