0
# MySQL Single Server Management
1

2
Complete management capabilities for MySQL single server deployments on Azure. This service provides server lifecycle management, database operations, security configuration, performance monitoring, and advisory recommendations.
3

4
## Capabilities
5

6
### Management Client
7

8
Main client for MySQL single server operations with comprehensive resource management capabilities.
9

10
```python { .api }
11
class MySQLManagementClient:
12
    """
13
    MySQL 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
    - virtual_network_rules: Virtual network rule operations
26
    - configurations: Server parameter operations
27
    - server_parameters: Server parameter operations (legacy)
28
    - log_files: Log file access operations
29
    - server_administrators: Azure AD administrator operations
30
    - recoverable_servers: Disaster recovery operations
31
    - replicas: Read replica operations
32
    - server_based_performance_tier: Performance tier operations (server-specific)
33
    - location_based_performance_tier: Performance tier operations (location-based)
34
    - check_name_availability: Name availability validation
35
    - operations: Available API operations listing
36
    - server_security_alert_policies: Threat detection policies
37
    - query_texts: Performance query text operations
38
    - top_query_statistics: Query performance statistics
39
    - wait_statistics: Wait event statistics
40
    - advisors: Performance advisory operations
41
    - recommended_actions: Performance recommendations
42
    - location_based_recommended_action_sessions_operation_status: Recommendation session status
43
    - location_based_recommended_action_sessions_result: Recommendation session results
44
    - private_endpoint_connections: Private endpoint connections
45
    - private_link_resources: Private link resource operations
46
    - server_keys: Customer-managed encryption keys
47
    """
48
    def __init__(
49
        self,
50
        credential,
51
        subscription_id: str,
52
        base_url: str = "https://management.azure.com",
53
        **kwargs
54
    ): ...
55
    
56
    def close(self): ...
57
    def __enter__(self): ...
58
    def __exit__(self, *exc_details): ...
59
```
60

61
### Server Operations
62

63
Core server lifecycle management including creation, updates, deletion, restart, and upgrade operations.
64

65
```python { .api }
66
class ServersOperations:
67
    """Server lifecycle and management operations."""
68
    
69
    def begin_create(self, resource_group_name: str, server_name: str, parameters, **kwargs):
70
        """
71
        Creates a new MySQL server or updates an existing server.
72
        
73
        Parameters:
74
        - resource_group_name: str, resource group name
75
        - server_name: str, server name (must be globally unique)
76
        - parameters: ServerForCreate, server creation parameters
77
        
78
        Returns:
79
        LROPoller[Server] for server creation operation
80
        """
81
    
82
    def begin_update(self, resource_group_name: str, server_name: str, parameters, **kwargs):
83
        """
84
        Updates an existing MySQL server configuration.
85
        
86
        Parameters:
87
        - resource_group_name: str, resource group name
88
        - server_name: str, server name
89
        - parameters: ServerUpdateParameters, server update parameters
90
        
91
        Returns:
92
        LROPoller[Server] for server update operation
93
        """
94
    
95
    def begin_delete(self, resource_group_name: str, server_name: str, **kwargs):
96
        """
97
        Deletes a MySQL server and all its resources.
98
        
99
        Parameters:
100
        - resource_group_name: str, resource group name
101
        - server_name: str, server name
102
        
103
        Returns:
104
        LROPoller[None] for server deletion operation
105
        """
106
    
107
    def begin_restart(self, resource_group_name: str, server_name: str, **kwargs):
108
        """
109
        Restarts a MySQL server.
110
        
111
        Parameters:
112
        - resource_group_name: str, resource group name
113
        - server_name: str, server name
114
        
115
        Returns:
116
        LROPoller[None] for server restart operation
117
        """
118
    
119
    def begin_start(self, resource_group_name: str, server_name: str, **kwargs):
120
        """
121
        Starts a stopped MySQL server.
122
        
123
        Parameters:
124
        - resource_group_name: str, resource group name
125
        - server_name: str, server name
126
        
127
        Returns:
128
        LROPoller[None] for server start operation
129
        """
130
    
131
    def begin_stop(self, resource_group_name: str, server_name: str, **kwargs):
132
        """
133
        Stops a running MySQL server.
134
        
135
        Parameters:
136
        - resource_group_name: str, resource group name
137
        - server_name: str, server name
138
        
139
        Returns:
140
        LROPoller[None] for server stop operation
141
        """
142
    
143
    def begin_upgrade(self, resource_group_name: str, server_name: str, parameters, **kwargs):
144
        """
145
        Upgrades a MySQL server version.
146
        
147
        Parameters:
148
        - resource_group_name: str, resource group name
149
        - server_name: str, server name
150
        - parameters: ServerUpgradeParameters, upgrade parameters
151
        
152
        Returns:
153
        LROPoller[None] for server upgrade operation
154
        """
155
    
156
    def get(self, resource_group_name: str, server_name: str, **kwargs):
157
        """
158
        Gets details of a MySQL server.
159
        
160
        Parameters:
161
        - resource_group_name: str, resource group name
162
        - server_name: str, server name
163
        
164
        Returns:
165
        Server object with current properties
166
        """
167
    
168
    def list(self, **kwargs):
169
        """
170
        Lists all MySQL servers in the subscription.
171
        
172
        Returns:
173
        Paged collection of Server objects
174
        """
175
    
176
    def list_by_resource_group(self, resource_group_name: str, **kwargs):
177
        """
178
        Lists MySQL servers in a resource group.
179
        
180
        Parameters:
181
        - resource_group_name: str, resource group name
182
        
183
        Returns:
184
        Paged collection of Server objects
185
        """
186
    
187
```
188

189
### Database Operations
190

191
Database management within MySQL servers including creation, deletion, and property queries.
192

193
```python { .api }
194
class DatabasesOperations:
195
    """Database management operations within MySQL servers."""
196
    
197
    def begin_create_or_update(self, resource_group_name: str, server_name: str, database_name: str, parameters, **kwargs):
198
        """
199
        Creates or updates a database within a MySQL 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
        - parameters: Database, database parameters (charset, collation)
206
        
207
        Returns:
208
        LROPoller[Database] for database operation
209
        """
210
    
211
    def begin_delete(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
212
        """
213
        Deletes a database from a MySQL server.
214
        
215
        Parameters:
216
        - resource_group_name: str, resource group name
217
        - server_name: str, server name
218
        - database_name: str, database name
219
        
220
        Returns:
221
        LROPoller[None] for deletion operation
222
        """
223
    
224
    def get(self, resource_group_name: str, server_name: str, database_name: str, **kwargs):
225
        """
226
        Gets database properties.
227
        
228
        Parameters:
229
        - resource_group_name: str, resource group name
230
        - server_name: str, server name
231
        - database_name: str, database name
232
        
233
        Returns:
234
        Database object with properties
235
        """
236
    
237
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
238
        """
239
        Lists databases in a MySQL server.
240
        
241
        Parameters:
242
        - resource_group_name: str, resource group name
243
        - server_name: str, server name
244
        
245
        Returns:
246
        Paged collection of Database objects
247
        """
248
```
249

250
### Firewall Rules Operations
251

252
IP-based access control configuration for MySQL servers.
253

254
```python { .api }
255
class FirewallRulesOperations:
256
    """Firewall rule management for MySQL servers."""
257
    
258
    def create_or_update(self, resource_group_name: str, server_name: str, firewall_rule_name: str, parameters, **kwargs):
259
        """
260
        Creates or updates a firewall rule.
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
        - parameters: Firewall rule parameters (start_ip_address, end_ip_address)
267
        
268
        Returns:
269
        LROPoller for firewall rule operation
270
        """
271
    
272
    def delete(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
273
        """
274
        Deletes a firewall rule.
275
        
276
        Parameters:
277
        - resource_group_name: str, resource group name
278
        - server_name: str, server name
279
        - firewall_rule_name: str, firewall rule name
280
        
281
        Returns:
282
        LROPoller for deletion operation
283
        """
284
    
285
    def get(self, resource_group_name: str, server_name: str, firewall_rule_name: str, **kwargs):
286
        """
287
        Gets a firewall rule.
288
        
289
        Parameters:
290
        - resource_group_name: str, resource group name
291
        - server_name: str, server name
292
        - firewall_rule_name: str, firewall rule name
293
        
294
        Returns:
295
        FirewallRule object
296
        """
297
    
298
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
299
        """
300
        Lists firewall rules for a MySQL server.
301
        
302
        Parameters:
303
        - resource_group_name: str, resource group name
304
        - server_name: str, server name
305
        
306
        Returns:
307
        Paged collection of FirewallRule objects
308
        """
309
```
310

311
### Virtual Network Rules Operations
312

313
VNet-based access control configuration for MySQL servers.
314

315
```python { .api }
316
class VirtualNetworkRulesOperations:
317
    """Virtual network rule management for MySQL servers."""
318
    
319
    def create_or_update(self, resource_group_name: str, server_name: str, virtual_network_rule_name: str, parameters, **kwargs):
320
        """
321
        Creates or updates a virtual network rule.
322
        
323
        Parameters:
324
        - resource_group_name: str, resource group name
325
        - server_name: str, server name
326
        - virtual_network_rule_name: str, virtual network rule name
327
        - parameters: VNet rule parameters (virtual_network_subnet_id, ignore_missing_vnet_service_endpoint)
328
        
329
        Returns:
330
        LROPoller for virtual network rule operation
331
        """
332
    
333
    def delete(self, resource_group_name: str, server_name: str, virtual_network_rule_name: str, **kwargs):
334
        """
335
        Deletes a virtual network rule.
336
        
337
        Parameters:
338
        - resource_group_name: str, resource group name
339
        - server_name: str, server name
340
        - virtual_network_rule_name: str, virtual network rule name
341
        
342
        Returns:
343
        LROPoller for deletion operation
344
        """
345
    
346
    def get(self, resource_group_name: str, server_name: str, virtual_network_rule_name: str, **kwargs):
347
        """
348
        Gets a virtual network rule.
349
        
350
        Parameters:
351
        - resource_group_name: str, resource group name
352
        - server_name: str, server name
353
        - virtual_network_rule_name: str, virtual network rule name
354
        
355
        Returns:
356
        VirtualNetworkRule object
357
        """
358
    
359
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
360
        """
361
        Lists virtual network rules for a MySQL server.
362
        
363
        Parameters:
364
        - resource_group_name: str, resource group name
365
        - server_name: str, server name
366
        
367
        Returns:
368
        Paged collection of VirtualNetworkRule objects
369
        """
370
```
371

372
### Configuration Operations
373

374
Server parameter and configuration management for MySQL instances.
375

376
```python { .api }
377
class ConfigurationsOperations:
378
    """MySQL server configuration and parameter management."""
379
    
380
    def create_or_update(self, resource_group_name: str, server_name: str, configuration_name: str, parameters, **kwargs):
381
        """
382
        Updates a configuration parameter.
383
        
384
        Parameters:
385
        - resource_group_name: str, resource group name
386
        - server_name: str, server name
387
        - configuration_name: str, parameter name
388
        - parameters: Configuration value and properties
389
        
390
        Returns:
391
        LROPoller for configuration update
392
        """
393
    
394
    def get(self, resource_group_name: str, server_name: str, configuration_name: str, **kwargs):
395
        """
396
        Gets a configuration parameter value.
397
        
398
        Parameters:
399
        - resource_group_name: str, resource group name
400
        - server_name: str, server name
401
        - configuration_name: str, parameter name
402
        
403
        Returns:
404
        Configuration object with current value
405
        """
406
    
407
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
408
        """
409
        Lists all configuration parameters for a server.
410
        
411
        Parameters:
412
        - resource_group_name: str, resource group name
413
        - server_name: str, server name
414
        
415
        Returns:
416
        Paged collection of Configuration objects
417
        """
418
```
419

420
### Performance Monitoring Operations
421

422
MySQL-specific performance insight capabilities including query analysis and performance recommendations.
423

424
```python { .api }
425
class QueryTextsOperations:
426
    """Query text retrieval for performance analysis."""
427
    
428
    def get(self, resource_group_name: str, server_name: str, query_id: str, **kwargs):
429
        """
430
        Gets query text by query ID.
431
        
432
        Parameters:
433
        - resource_group_name: str, resource group name
434
        - server_name: str, server name
435
        - query_id: str, query identifier
436
        
437
        Returns:
438
        QueryText object with query details
439
        """
440
    
441
    def list_by_server(self, resource_group_name: str, server_name: str, query_ids: List[str], **kwargs):
442
        """
443
        Lists query texts for specified query IDs.
444
        
445
        Parameters:
446
        - resource_group_name: str, resource group name
447
        - server_name: str, server name
448
        - query_ids: List[str], query identifiers
449
        
450
        Returns:
451
        Paged collection of QueryText objects
452
        """
453

454
class TopQueryStatisticsOperations:
455
    """Top query performance statistics operations."""
456
    
457
    def get(self, resource_group_name: str, server_name: str, query_statistic_id: str, **kwargs):
458
        """
459
        Gets query performance statistics.
460
        
461
        Parameters:
462
        - resource_group_name: str, resource group name
463
        - server_name: str, server name
464
        - query_statistic_id: str, statistic identifier
465
        
466
        Returns:
467
        QueryStatistic object with performance metrics
468
        """
469
    
470
    def list_by_server(self, resource_group_name: str, server_name: str, parameters, **kwargs):
471
        """
472
        Lists top query statistics for a server.
473
        
474
        Parameters:
475
        - resource_group_name: str, resource group name
476
        - server_name: str, server name
477
        - parameters: Query parameters (aggregation window, observed metrics)
478
        
479
        Returns:
480
        Paged collection of QueryStatistic objects
481
        """
482

483
class AdvisorsOperations:
484
    """Performance advisor operations for MySQL servers."""
485
    
486
    def get(self, resource_group_name: str, server_name: str, advisor_name: str, **kwargs):
487
        """
488
        Gets performance advisor details.
489
        
490
        Parameters:
491
        - resource_group_name: str, resource group name
492
        - server_name: str, server name
493
        - advisor_name: str, advisor name
494
        
495
        Returns:
496
        Advisor object with recommendations
497
        """
498
    
499
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
500
        """
501
        Lists performance advisors for a server.
502
        
503
        Parameters:
504
        - resource_group_name: str, resource group name
505
        - server_name: str, server name
506
        
507
        Returns:
508
        Paged collection of Advisor objects
509
        """
510

511
class RecommendedActionsOperations:
512
    """Recommended action operations for MySQL servers."""
513
    
514
    def get(self, resource_group_name: str, server_name: str, advisor_name: str, recommended_action_name: str, **kwargs):
515
        """
516
        Gets a recommended action for performance improvement.
517
        
518
        Parameters:
519
        - resource_group_name: str, resource group name
520
        - server_name: str, server name
521
        - advisor_name: str, advisor name
522
        - recommended_action_name: str, recommended action name
523
        
524
        Returns:
525
        RecommendedAction object with implementation details
526
        """
527
    
528
    def list_by_server(self, resource_group_name: str, server_name: str, advisor_name: str, **kwargs):
529
        """
530
        Lists recommended actions for a specific advisor.
531
        
532
        Parameters:
533
        - resource_group_name: str, resource group name
534
        - server_name: str, server name
535
        - advisor_name: str, advisor name
536
        
537
        Returns:
538
        Paged collection of RecommendedAction objects
539
        """
540

541
class PrivateEndpointConnectionsOperations:
542
    """Private endpoint connection operations for MySQL servers."""
543
    
544
    def get(self, resource_group_name: str, server_name: str, private_endpoint_connection_name: str, **kwargs):
545
        """
546
        Gets a private endpoint connection.
547
        
548
        Parameters:
549
        - resource_group_name: str, resource group name
550
        - server_name: str, server name
551
        - private_endpoint_connection_name: str, connection name
552
        
553
        Returns:
554
        PrivateEndpointConnection object
555
        """
556
    
557
    def create_or_update(self, resource_group_name: str, server_name: str, private_endpoint_connection_name: str, parameters, **kwargs):
558
        """
559
        Creates or updates a private endpoint connection.
560
        
561
        Parameters:
562
        - resource_group_name: str, resource group name
563
        - server_name: str, server name
564
        - private_endpoint_connection_name: str, connection name
565
        - parameters: Connection parameters including private link service connection state
566
        
567
        Returns:
568
        LROPoller for private endpoint connection operation
569
        """
570
    
571
    def delete(self, resource_group_name: str, server_name: str, private_endpoint_connection_name: str, **kwargs):
572
        """
573
        Deletes a private endpoint connection.
574
        
575
        Parameters:
576
        - resource_group_name: str, resource group name
577
        - server_name: str, server name
578
        - private_endpoint_connection_name: str, connection name
579
        
580
        Returns:
581
        LROPoller for deletion operation
582
        """
583
    
584
    def list_by_server(self, resource_group_name: str, server_name: str, **kwargs):
585
        """
586
        Lists private endpoint connections for a server.
587
        
588
        Parameters:
589
        - resource_group_name: str, resource group name
590
        - server_name: str, server name
591
        
592
        Returns:
593
        Paged collection of PrivateEndpointConnection objects
594
        """
595

596
class ServerKeysOperations:
597
    """Customer-managed encryption key operations for MySQL servers."""
598
    
599
    def get(self, resource_group_name: str, server_name: str, key_name: str, **kwargs):
600
        """
601
        Gets a server key used for encryption.
602
        
603
        Parameters:
604
        - resource_group_name: str, resource group name
605
        - server_name: str, server name
606
        - key_name: str, key name
607
        
608
        Returns:
609
        ServerKey object with key details
610
        """
611
    
612
    def create_or_update(self, resource_group_name: str, server_name: str, key_name: str, parameters, **kwargs):
613
        """
614
        Creates or updates a server key for encryption.
615
        
616
        Parameters:
617
        - resource_group_name: str, resource group name
618
        - server_name: str, server name
619
        - key_name: str, key name
620
        - parameters: Key parameters including server key type and URI
621
        
622
        Returns:
623
        LROPoller for server key operation
624
        """
625
    
626
    def delete(self, resource_group_name: str, server_name: str, key_name: str, **kwargs):
627
        """
628
        Deletes a server key.
629
        
630
        Parameters:
631
        - resource_group_name: str, resource group name
632
        - server_name: str, server name
633
        - key_name: str, key name
634
        
635
        Returns:
636
        LROPoller for deletion operation
637
        """
638
    
639
    def list(self, resource_group_name: str, server_name: str, **kwargs):
640
        """
641
        Lists server keys for a MySQL server.
642
        
643
        Parameters:
644
        - resource_group_name: str, resource group name
645
        - server_name: str, server name
646
        
647
        Returns:
648
        Paged collection of ServerKey objects
649
        """
650
```
651

652
## Key Models
653

654
```python { .api }
655
class Server:
656
    """MySQL server resource representation."""
657
    id: str
658
    name: str
659
    type: str
660
    location: str
661
    tags: Dict[str, str]
662
    administrator_login: str
663
    version: str  # MySQL version (5.6, 5.7, 8.0)
664
    ssl_enforcement: str  # Enabled, Disabled
665
    user_visible_state: str  # Ready, Dropping, Disabled, etc.
666
    fully_qualified_domain_name: str
667
    earliest_restore_date: datetime
668
    storage_profile: StorageProfile
669
    replication_role: str  # None, Master, Replica
670
    master_server_id: str
671
    replica_capacity: int
672

673
class Database:
674
    """Database within MySQL server."""
675
    id: str
676
    name: str
677
    type: str
678
    charset: str
679
    collation: str
680

681
class FirewallRule:
682
    """IP-based access rule for MySQL server."""
683
    id: str
684
    name: str
685
    type: str
686
    start_ip_address: str
687
    end_ip_address: str
688

689
class Configuration:
690
    """MySQL server configuration parameter."""
691
    id: str
692
    name: str
693
    type: str
694
    value: str
695
    description: str
696
    default_value: str
697
    data_type: str
698
    allowed_values: str
699
    source: str
700

701
class StorageProfile:
702
    """Storage configuration for MySQL server."""
703
    backup_retention_days: int
704
    geo_redundant_backup: str  # Enabled, Disabled
705
    storage_mb: int
706
    storage_autogrow: str  # Enabled, Disabled
707

708
class VirtualNetworkRule:
709
    """VNet-based access rule for MySQL server."""
710
    id: str
711
    name: str
712
    type: str
713
    virtual_network_subnet_id: str
714
    ignore_missing_vnet_service_endpoint: bool
715
    state: str  # Ready, Deleting, Unknown, etc.
716

717
class PrivateEndpointConnection:
718
    """Private endpoint connection for MySQL server."""
719
    id: str
720
    name: str
721
    type: str
722
    private_endpoint: PrivateEndpointProperty
723
    private_link_service_connection_state: PrivateLinkServiceConnectionStateProperty
724
    provisioning_state: str
725

726
class ServerKey:
727
    """Customer-managed encryption key for MySQL server."""
728
    id: str
729
    name: str
730
    type: str
731
    kind: str
732
    server_key_type: str  # AzureKeyVault
733
    uri: str
734
    creation_date: datetime
735

736
class QueryText:
737
    """Query text for performance analysis."""
738
    id: str
739
    name: str
740
    type: str
741
    query_id: str
742
    query_text: str
743

744
class QueryStatistic:
745
    """Query performance statistics."""
746
    id: str
747
    name: str
748
    type: str
749
    query_id: str
750
    start_time: datetime
751
    end_time: datetime
752
    aggregation_function: str
753
    database_names: List[str]
754
    query_execution_count: int
755
    metric_name: str
756
    metric_display_name: str
757
    metric_value: float
758
    metric_value_unit: str
759

760
class Advisor:
761
    """Performance advisor for MySQL server."""
762
    id: str
763
    name: str
764
    type: str
765
    properties: Dict[str, Any]
766

767
class RecommendedAction:
768
    """Performance recommendation for MySQL server."""
769
    id: str
770
    name: str
771
    type: str
772
    advisor_name: str
773
    session_id: str
774
    action_id: int
775
    created_time: datetime
776
    expiration_time: datetime
777
    reason: str
778
    recommendation_type: str
779
    details: Dict[str, Any]
780
```
781

782
## Usage Examples
783

784
### Creating a MySQL Server
785

786
```python
787
from azure.identity import DefaultAzureCredential
788
from azure.mgmt.rdbms.mysql import MySQLManagementClient
789
from azure.mgmt.rdbms.mysql.models import ServerForCreate, ServerPropertiesForDefaultCreate, StorageProfile
790

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

794
# Define server parameters
795
server_creation_parameters = ServerForCreate(
796
    properties=ServerPropertiesForDefaultCreate(
797
        administrator_login="myadmin",
798
        administrator_login_password="SecurePassword123!",
799
        version="8.0",
800
        ssl_enforcement="Enabled",
801
        storage_profile=StorageProfile(
802
            backup_retention_days=7,
803
            geo_redundant_backup="Disabled",
804
            storage_mb=5120,
805
            storage_autogrow="Enabled"
806
        )
807
    ),
808
    location="East US",
809
    tags={"environment": "production"}
810
)
811

812
# Create server (async operation)
813
server_operation = client.servers.begin_create(
814
    "my-resource-group",
815
    "my-mysql-server",
816
    server_creation_parameters
817
)
818
server = server_operation.result()  # Wait for completion
819
print(f"Server created: {server.name}")
820
```
821

822
### Managing Databases and Firewall Rules
823

824
```python
825
# Create a database
826
database_params = {"charset": "utf8mb4", "collation": "utf8mb4_general_ci"}
827
db_operation = client.databases.begin_create_or_update(
828
    "my-resource-group",
829
    "my-mysql-server", 
830
    "my-application-db",
831
    database_params
832
)
833
database = db_operation.result()
834

835
# Add firewall rule for office network
836
firewall_params = {
837
    "start_ip_address": "203.0.113.0",
838
    "end_ip_address": "203.0.113.255"
839
}
840
fw_operation = client.firewall_rules.begin_create_or_update(
841
    "my-resource-group",
842
    "my-mysql-server",
843
    "office-network",
844
    firewall_params
845
)
846
firewall_rule = fw_operation.result()
847

848
# Configure server parameter
849
config_params = {"value": "3600"}
850
config_operation = client.configurations.begin_create_or_update(
851
    "my-resource-group",
852
    "my-mysql-server",
853
    "wait_timeout",
854
    config_params
855
)
856
configuration = config_operation.result()
857
```