0
# MySQL Flexible Servers Management
1

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

4
## Capabilities
5

6
### Management Client
7

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

10
```python { .api }
11
class MySQLManagementClient:
12
    """
13
    MySQL 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
    - backups: Backup management and restore operations
27
    - replicas: Read replica operations
28
    - location_based_capabilities: Regional capability queries
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
### Enhanced Server Operations
44

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

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

175
### Backup and Restore Operations
176

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

179
```python { .api }
180
class BackupsOperations:
181
    """Backup management and restore operations for flexible servers."""
182
    
183
    def get(self, resource_group_name: str, server_name: str, backup_name: str, **kwargs):
184
        """
185
        Gets backup information for a flexible server.
186
        
187
        Parameters:
188
        - resource_group_name: str, resource group name
189
        - server_name: str, server name
190
        - backup_name: str, backup name
191
        
192
        Returns:
193
        ServerBackup object with backup details
194
        """
195
    
196
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
197
        """
198
        Lists all backups for a MySQL flexible server.
199
        
200
        Parameters:
201
        - resource_group_name: str, resource group name
202
        - server_name: str, server name
203
        
204
        Returns:
205
        Paged collection of ServerBackup objects
206
        """
207
```
208

209
### Database Operations
210

211
Enhanced database management within MySQL flexible servers.
212

213
```python { .api }
214
class DatabasesOperations:
215
    """Database management operations within MySQL flexible servers."""
216
    
217
    def create_or_update(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
218
        """
219
        Creates or updates a database in a flexible server.
220
        
221
        Parameters:
222
        - resource_group_name: str, resource group name
223
        - server_name: str, server name
224
        - database_name: str, database name
225
        - parameters: Database parameters (charset, collation)
226
        
227
        Returns:
228
        LROPoller for database operation
229
        """
230
    
231
    def delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
232
        """
233
        Deletes a database from a flexible server.
234
        
235
        Parameters:
236
        - resource_group_name: str, resource group name
237
        - server_name: str, server name
238
        - database_name: str, database name
239
        
240
        Returns:
241
        LROPoller for deletion operation
242
        """
243
    
244
    def get(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
245
        """
246
        Gets database properties from a flexible server.
247
        
248
        Parameters:
249
        - resource_group_name: str, resource group name
250
        - server_name: str, server name
251
        - database_name: str, database name
252
        
253
        Returns:
254
        Database object with properties
255
        """
256
    
257
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
258
        """
259
        Lists databases in a MySQL flexible server.
260
        
261
        Parameters:
262
        - resource_group_name: str, resource group name
263
        - server_name: str, server name
264
        
265
        Returns:
266
        Paged collection of Database objects
267
        """
268
```
269

270
### Firewall Rules Operations
271

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

274
```python { .api }
275
class FirewallRulesOperations:
276
    """Enhanced firewall rule management for MySQL flexible servers."""
277
    
278
    def create_or_update(self, resource_group_name: str, server_name: str, firewall_rule_name: str, parameters, **kwargs):
279
        """
280
        Creates or updates a firewall rule for a flexible server.
281
        
282
        Parameters:
283
        - resource_group_name: str, resource group name
284
        - server_name: str, server name
285
        - firewall_rule_name: str, firewall rule name
286
        - parameters: Enhanced firewall rule parameters
287
        
288
        Returns:
289
        LROPoller for firewall rule operation
290
        """
291
    
292
    def delete(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
293
        """
294
        Deletes a firewall rule from a flexible server.
295
        
296
        Parameters:
297
        - resource_group_name: str, resource group name
298
        - server_name: str, server name
299
        - firewall_rule_name: str, firewall rule name
300
        
301
        Returns:
302
        LROPoller for deletion operation
303
        """
304
    
305
    def get(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
306
        """
307
        Gets a firewall rule from a flexible server.
308
        
309
        Parameters:
310
        - resource_group_name: str, resource group name
311
        - server_name: str, server name
312
        - firewall_rule_name: str, firewall rule name
313
        
314
        Returns:
315
        FirewallRule object
316
        """
317
    
318
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
319
        """
320
        Lists firewall rules for a MySQL flexible server.
321
        
322
        Parameters:
323
        - resource_group_name: str, resource group name
324
        - server_name: str, server name
325
        
326
        Returns:
327
        Paged collection of FirewallRule objects
328
        """
329
```
330

331
### Configuration Operations
332

333
Enhanced server parameter and configuration management for MySQL flexible servers.
334

335
```python { .api }
336
class ConfigurationsOperations:
337
    """Enhanced MySQL flexible server configuration and parameter management."""
338
    
339
    def create_or_update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
340
        """
341
        Updates a configuration parameter for a flexible server.
342
        
343
        Parameters:
344
        - resource_group_name: str, resource group name
345
        - server_name: str, server name
346
        - configuration_name: str, parameter name
347
        - parameters: Enhanced configuration value and properties
348
        
349
        Returns:
350
        LROPoller for configuration update
351
        """
352
    
353
    def batch_update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
354
        """
355
        Updates multiple configuration parameters in a single operation.
356
        
357
        Parameters:
358
        - resource_group_name: str, resource group name
359
        - server_name: str, server name
360
        - parameters: Batch configuration parameters
361
        
362
        Returns:
363
        LROPoller for batch configuration update
364
        """
365
    
366
    def get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
367
        """
368
        Gets a configuration parameter value from a flexible server.
369
        
370
        Parameters:
371
        - resource_group_name: str, resource group name
372
        - server_name: str, server name
373
        - configuration_name: str, parameter name
374
        
375
        Returns:
376
        Configuration object with current value
377
        """
378
    
379
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
380
        """
381
        Lists all configuration parameters for a flexible server.
382
        
383
        Parameters:
384
        - resource_group_name: str, resource group name
385
        - server_name: str, server name
386
        
387
        Returns:
388
        Paged collection of Configuration objects
389
        """
390
```
391

392
### Location-Based Capabilities Operations
393

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

396
```python { .api }
397
class LocationBasedCapabilitiesOperations:
398
    """Regional capability queries for MySQL flexible servers."""
399
    
400
    def list(self, location_name: str, **kwargs):
401
        """
402
        Lists capabilities available in a specific region for flexible servers.
403
        
404
        Parameters:
405
        - location_name: str, Azure region name
406
        
407
        Returns:
408
        Paged collection of capability objects including:
409
        - Available server versions
410
        - Supported SKUs and compute tiers
411
        - Storage options and limits
412
        - High availability support
413
        - Backup retention limits
414
        """
415
```
416

417
## Enhanced Models for Flexible Servers
418

419
```python { .api }
420
class Server:
421
    """Enhanced MySQL flexible server resource representation."""
422
    id: str
423
    name: str
424
    type: str
425
    location: str
426
    tags: Dict[str, str]
427
    system_data: SystemData
428
    administrator_login: str
429
    version: str  # MySQL version (5.7, 8.0)
430
    state: str  # Ready, Starting, Stopping, Stopped, Updating, etc.
431
    fully_qualified_domain_name: str
432
    storage: Storage
433
    backup: Backup
434
    high_availability: HighAvailability
435
    network: Network
436
    maintenance_window: MaintenanceWindow
437
    source_server_resource_id: str
438
    restore_point_in_time: datetime
439
    availability_zone: str
440
    standby_availability_zone: str
441
    data_encryption: DataEncryption
442

443
class Storage:
444
    """Enhanced storage configuration for flexible servers."""
445
    storage_size_gb: int
446
    iops: int
447
    auto_grow: str  # Enabled, Disabled
448
    storage_sku: str  # Premium_LRS, Standard_LRS
449
    auto_io_scaling: str  # Enabled, Disabled
450

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

457
class Backup:
458
    """Backup configuration and policies for flexible servers."""
459
    backup_retention_days: int
460
    geo_redundant_backup: str  # Enabled, Disabled
461
    earliest_restore_date: datetime
462

463
class Network:
464
    """Network configuration for flexible servers."""
465
    public_network_access: str  # Enabled, Disabled
466
    delegated_subnet_resource_id: str
467
    private_dns_zone_resource_id: str
468

469
class MaintenanceWindow:
470
    """Maintenance scheduling configuration."""
471
    custom_window: str  # Enabled, Disabled
472
    start_hour: int
473
    start_minute: int
474
    day_of_week: int
475

476
class DataEncryption:
477
    """Data encryption settings for flexible servers."""
478
    type: str  # AzureKeyVault, SystemManaged
479
    geo_backup_key_uri: str
480
    geo_backup_user_assigned_identity_id: str
481
    primary_key_uri: str
482
    primary_user_assigned_identity_id: str
483

484
class Database:
485
    """Database within MySQL flexible server."""
486
    id: str
487
    name: str
488
    type: str
489
    charset: str
490
    collation: str
491
    system_data: SystemData
492

493
class FirewallRule:
494
    """Enhanced firewall rule for MySQL flexible server."""
495
    id: str
496
    name: str
497
    type: str
498
    start_ip_address: str
499
    end_ip_address: str
500
    system_data: SystemData
501

502
class Configuration:
503
    """Enhanced MySQL flexible server configuration parameter."""
504
    id: str
505
    name: str
506
    type: str
507
    value: str
508
    current_value: str
509
    description: str
510
    default_value: str
511
    data_type: str
512
    allowed_values: str
513
    source: str
514
    is_dynamic: bool
515
    is_read_only: bool
516
    is_config_pending_restart: bool
517
    system_data: SystemData
518

519
class ServerBackup:
520
    """Backup resource representation for flexible servers."""
521
    id: str
522
    name: str
523
    type: str
524
    backup_type: str  # Full, Incremental
525
    completed_time: datetime
526
    source: str
527
    system_data: SystemData
528
```
529

530
## Usage Examples
531

532
### Creating a MySQL Flexible Server with High Availability
533

534
```python
535
from azure.identity import DefaultAzureCredential
536
from azure.mgmt.rdbms.mysql_flexibleservers import MySQLManagementClient
537
from azure.mgmt.rdbms.mysql_flexibleservers.models import (
538
    Server, ServerForCreate, Storage, HighAvailability, Backup, 
539
    Network, MaintenanceWindow, DataEncryption
540
)
541

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

545
# Define enhanced server parameters
546
server_creation_parameters = ServerForCreate(
547
    location="East US",
548
    tags={"environment": "production"},
549
    properties=Server(
550
        administrator_login="myadmin",
551
        administrator_login_password="SecurePassword123!",
552
        version="8.0",
553
        availability_zone="1",
554
        storage=Storage(
555
            storage_size_gb=100,
556
            iops=400,
557
            auto_grow="Enabled",
558
            storage_sku="Premium_LRS"
559
        ),
560
        high_availability=HighAvailability(
561
            mode="ZoneRedundant",
562
            standby_availability_zone="2"
563
        ),
564
        backup=Backup(
565
            backup_retention_days=14,
566
            geo_redundant_backup="Enabled"
567
        ),
568
        network=Network(
569
            public_network_access="Disabled",
570
            delegated_subnet_resource_id="/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet"
571
        ),
572
        maintenance_window=MaintenanceWindow(
573
            custom_window="Enabled",
574
            start_hour=2,
575
            start_minute=0,
576
            day_of_week=0  # Sunday
577
        )
578
    )
579
)
580

581
# Create flexible server (async operation)
582
server_operation = client.servers.begin_create(
583
    "my-resource-group",
584
    "my-mysql-flexible-server",
585
    server_creation_parameters
586
)
587
server = server_operation.result()  # Wait for completion
588
print(f"Flexible server created: {server.name}")
589
print(f"High availability mode: {server.high_availability.mode}")
590
```
591

592
### Managing Backups and Restore Operations
593

594
```python
595
# List available backups
596
backups = client.backups.list_by_server(
597
    "my-resource-group",
598
    "my-mysql-flexible-server"
599
)
600

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

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

607
restore_time = datetime.utcnow() - timedelta(hours=2)
608
restore_parameters = ServerForCreate(
609
    location="East US",
610
    properties=Server(
611
        source_server_resource_id=server.id,
612
        restore_point_in_time=restore_time,
613
        create_mode="PointInTimeRestore"
614
    )
615
)
616

617
restore_operation = client.servers.begin_create(
618
    "my-resource-group",
619
    "my-mysql-restored-server",
620
    restore_parameters
621
)
622
restored_server = restore_operation.result()
623
print(f"Server restored from backup: {restored_server.name}")
624
```
625

626
### Managing High Availability and Failover
627

628
```python
629
# Enable high availability on existing server
630
ha_config = {"high_availability": {"mode": "SameZone"}}
631
ha_operation = client.servers.begin_update(
632
    "my-resource-group",
633
    "my-mysql-flexible-server",
634
    ha_config
635
)
636
updated_server = ha_operation.result()
637

638
# Trigger manual failover
639
failover_operation = client.servers.begin_failover(
640
    "my-resource-group",
641
    "my-mysql-flexible-server"
642
)
643
failover_operation.result()
644
print("Manual failover completed")
645

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

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