[RDBMS] Add Private DNS zone for every database server created with private network access

src/azure-cli/azure/cli/command_modules/rdbms/_client_factory.py

@@ -355,9 +355,24 @@ def cf_postgres_flexible_db(cli_ctx, _):
     return get_postgresql_flexible_management_client(cli_ctx).databases
 
 
+def cf_postgres_flexible_private_dns_zone_suffix_operations(cli_ctx, _):
+    return get_postgresql_flexible_management_client(cli_ctx).get_private_dns_zone_suffix
+
+
 def resource_client_factory(cli_ctx, subscription_id=None):
     return get_mgmt_service_client(cli_ctx, ResourceType.MGMT_RESOURCE_RESOURCES, subscription_id=subscription_id)
 
 
 def network_client_factory(cli_ctx, subscription_id=None):
     return get_mgmt_service_client(cli_ctx, ResourceType.MGMT_NETWORK, subscription_id=subscription_id)
+
+
+def private_dns_client_factory(cli_ctx, subscription_id=None):
+    from azure.mgmt.privatedns import PrivateDnsManagementClient
+    return get_mgmt_service_client(cli_ctx, PrivateDnsManagementClient, subscription_id=subscription_id).private_zones
+
+
+def private_dns_link_client_factory(cli_ctx, subscription_id=None):
+    from azure.mgmt.privatedns import PrivateDnsManagementClient
+    return get_mgmt_service_client(cli_ctx, PrivateDnsManagementClient,
+                                   subscription_id=subscription_id).virtual_network_links

src/azure-cli/azure/cli/command_modules/rdbms/_flexible_server_util.py

@@ -302,10 +302,10 @@ def get_id_components(rid):
     parsed_rid = parse_resource_id(rid)
     subscription = parsed_rid['subscription']
     resource_group = parsed_rid['resource_group']
-    vnet_name = parsed_rid['name']
-    subnet_name = parsed_rid['child_name_1'] if 'child_name_1' in parsed_rid else None
+    name = parsed_rid['name']
+    child_name = parsed_rid['child_name_1'] if 'child_name_1' in parsed_rid else None
 
-    return subscription, resource_group, vnet_name, subnet_name
+    return subscription, resource_group, name, child_name
 
 
 def check_existence(resource_client, value, resource_group, provider_namespace, resource_type,

src/azure-cli/azure/cli/command_modules/rdbms/_helptext_pg.py

@@ -49,7 +49,13 @@
       az postgres flexible-server create --subnet /subscriptions/{SubID}/resourceGroups/{ResourceGroup}/providers/Microsoft.Network/virtualNetworks/{VNetName}/subnets/{SubnetName}
   - name: Create a PostgreSQL flexible server using new virtual network, subnet with non-default address prefix.
     text: |
-      az postgres flexible-server create --vnet myVnet --address-prefixes 10.0.0.0/24 --subnet mySubnet --subnet-prefixes 10.0.0.0/24
+      az postgres flexible-server create --vnet myVnet --address-prefixes 15.0.0.0/24 --subnet mySubnet --subnet-prefixes 15.0.0.0/24
+  - name: Create a PostgreSQL flexible server using new virtual network, subnet, and new private dns zone address
+    text: |
+      az postgres flexible-server create --vnet myVnet --subnet mySubnet --private-dns-zone myDnsZone.private.postgres.database.azure.com
+  - name: Create a PostgreSQL flexible server using existing subnet and private dns zone address in different resource group
+    text: |
+      az postgres flexible-server create --subnet /subscriptions/{SubID}/resourceGroups/{ResourceGroup}/providers/Microsoft.Network/virtualNetworks/{VNetName}/subnets/{SubnetName} --private-dns-zone /subscriptions/{SubID}/resourceGroups/{ResourceGroup}/providers/Microsoft.Network/privateDnsZones/myDnsZone.private.postgres.database.azure.com
   - name: Create a PostgreSQL flexible server with  parameters set.
     text: |
         az postgres flexible-server create --location northeurope --resource-group testGroup \\

src/azure-cli/azure/cli/command_modules/rdbms/_params.py

@@ -269,7 +269,7 @@ def _flexible_server_params(command_group):
                            help='Compute tier of the server. Accepted values: Burstable, GeneralPurpose, Memory Optimized ')
                 c.argument('sku_name', default='Standard_B1ms', options_list=['--sku-name'],
                            help='The name of the compute SKU. Follows the convention Standard_{VM name}. Examples: Standard_B1ms, Standard_E16ds_v4 ')
-                c.argument('storage_mb', default='10', options_list=['--storage-size'], type=int,
+                c.argument('storage_mb', default='32', options_list=['--storage-size'], type=int,
                            help='The storage capacity of the server. Minimum is 5 GiB and increases in 1 GiB increments. Max is 16 TiB.')
                 c.argument('backup_retention', default=7, type=int, options_list=['--backup-retention'],
                            help='The number of days a backup is retained. Range of 7 to 35 days. Default is 7 days.')
@@ -282,11 +282,11 @@ def _flexible_server_params(command_group):
                                 'on compute and storage provisioned. The default value for IOPS is free IOPS. '
                                 'To learn more about IOPS based on compute and storage, refer to IOPS in Azure Database for MySQL Flexible Server')
 
-            c.argument('vnet_resource_id', options_list=['--vnet'], help='Name of an existing virtual network or name of a new one to create. The name must be between 2 to 64 characters. The name must begin with a letter or number, end with a letter, number or underscore, and may contain only letters, numbers, underscores, periods, or hyphens.')
+            c.argument('vnet_resource_id', options_list=['--vnet'], help='Name or ID of a new or existing virtual network. If you want to use a vnet from different resource group or subscription, please provide a resource ID. The name must be between 2 to 64 characters. The name must begin with a letter or number, end with a letter, number or underscore, and may contain only letters, numbers, underscores, periods, or hyphens.')
             c.argument('vnet_address_prefix', options_list=['--address-prefixes'], help='The IP address prefix to use when creating a new virtual network in CIDR format. Default value is 10.0.0.0/16.')
             c.argument('subnet_address_prefix', options_list=['--subnet-prefixes'], help='The subnet IP address prefix to use when creating a new VNet in CIDR format. Default value is 10.0.0.0/24.')
             c.argument('subnet_arm_resource_id', options_list=['--subnet'],
-                       help='Resource ID of an existing subnet. Please note that the subnet will be delegated to Microsoft.DBforPostgreSQL/flexibleServers/Microsoft.DBforMySQL/flexibleServers.After delegation, this subnet cannot be used for any other type of Azure resources.')
+                       help='Name or resource ID of a new or existing subnet. If you want to use a subnet from different resource group or subscription, please provide resource ID instead of name. Please note that the subnet will be delegated to Microsoft.DBforPostgreSQL/flexibleServers/Microsoft.DBforMySQL/flexibleServers. After delegation, this subnet cannot be used for any other type of Azure resources.')
             c.argument('server_name', options_list=['--name', '-n'], arg_type=server_name_setter_arg_type)
             c.argument('location', arg_type=get_location_type(self.cli_ctx))
             c.argument('administrator_login', default=generate_username(), options_list=['--admin-user', '-u'], arg_group='Authentication', arg_type=administrator_login_setter_arg_type,
@@ -301,7 +301,8 @@ def _flexible_server_params(command_group):
             c.argument('high_availability', default="Disabled", options_list=['--high-availability'], help='Enable or disable high availability feature.  Default value is Disabled.')
             c.argument('assign_identity', options_list=['--assign-identity'],
                        help='Generate and assign an Azure Active Directory Identity for this server for use with key management services like Azure KeyVault. No need to enter extra argument.')
-            c.ignore('database_name')
+            c.argument('private_dns_zone_arguments', options_list=['--private-dns-zone'], help='The name or id of new or existing private dns zone. You can use the private dns zone from same resource group, different resource group, or different subscription. If you want to use a zone from different resource group or subscription, please provide resource Id. CLI creates a new private dns zone within the same resource group if not provided by users.')
+            c.argument('database_name', id_part=None, arg_type=database_name_setter_arg_type, options_list=['--database-name', '-d'], help='The name of the database to be created when provisioning the database server')
 
         with self.argument_context('{} flexible-server delete'.format(command_group)) as c:
             c.argument('resource_group_name', required=True)

src/azure-cli/azure/cli/command_modules/rdbms/flexible_server_custom_mysql.py

@@ -14,13 +14,13 @@
 from azure.cli.core.local_context import ALL
 from azure.mgmt.rdbms import mysql_flexibleservers
 from ._client_factory import get_mysql_flexible_management_client, cf_mysql_flexible_firewall_rules, \
-    cf_mysql_flexible_db
+    cf_mysql_flexible_db, cf_mysql_check_resource_availability
 from ._flexible_server_util import resolve_poller, generate_missing_parameters, create_firewall_rule, \
     parse_public_access_input, generate_password, parse_maintenance_window, get_mysql_list_skus_info, \
     DEFAULT_LOCATION_MySQL
 from .flexible_server_custom_common import user_confirmation
 from .flexible_server_virtual_network import prepare_private_network
-from .validators import mysql_arguments_validator
+from .validators import mysql_arguments_validator, validate_server_name
 
 logger = get_logger(__name__)
 DEFAULT_DB_NAME = 'flexibleserverdb'
@@ -56,6 +56,7 @@ def flexible_server_create(cmd, client, resource_group_name=None, server_name=No
     location, resource_group_name, server_name = generate_missing_parameters(cmd, location, resource_group_name,
                                                                              server_name, 'mysql')
     server_name = server_name.lower()
+    validate_server_name(cf_mysql_check_resource_availability(cmd.cli_ctx, '_'), server_name, 'Microsoft.DBforMySQL/flexibleServers')
 
     # Handle Vnet scenario
     if public_access is None:
@@ -121,6 +122,7 @@ def flexible_server_create(cmd, client, resource_group_name=None, server_name=No
 
 def flexible_server_restore(cmd, client, resource_group_name, server_name, source_server, restore_point_in_time, location=None, no_wait=False):
     provider = 'Microsoft.DBforMySQL'
+    validate_server_name(cf_mysql_check_resource_availability(cmd.cli_ctx, '_'), server_name, 'Microsoft.DBforMySQL/flexibleServers')
 
     if not is_valid_resource_id(source_server):
         if len(source_server.split('/')) == 1:
@@ -373,6 +375,7 @@ def flexible_parameter_update(client, server_name, configuration_name, resource_
 # Custom functions for server replica, will add PostgreSQL part after backend ready in future
 def flexible_replica_create(cmd, client, resource_group_name, replica_name, server_name, no_wait=False, location=None, sku_name=None, tier=None, **kwargs):
     provider = 'Microsoft.DBforMySQL'
+    validate_server_name(cf_mysql_check_resource_availability(cmd.cli_ctx, '_'), replica_name, 'Microsoft.DBforMySQL/flexibleServers')
 
     # set source server id
     if not is_valid_resource_id(server_name):

src/azure-cli/azure/cli/command_modules/rdbms/flexible_server_custom_postgres.py

@@ -13,13 +13,13 @@
 from azure.core.exceptions import ResourceNotFoundError
 from azure.cli.core.azclierror import RequiredArgumentMissingError
 from azure.mgmt.rdbms import postgresql_flexibleservers
-from ._client_factory import cf_postgres_flexible_firewall_rules, get_postgresql_flexible_management_client, cf_postgres_flexible_db
+from ._client_factory import cf_postgres_flexible_firewall_rules, get_postgresql_flexible_management_client, cf_postgres_flexible_db, cf_postgres_check_resource_availability
 from .flexible_server_custom_common import user_confirmation
 from ._flexible_server_util import generate_missing_parameters, resolve_poller, create_firewall_rule, \
     parse_public_access_input, generate_password, parse_maintenance_window, get_postgres_list_skus_info, \
     DEFAULT_LOCATION_PG
-from .flexible_server_virtual_network import prepare_private_network
-from .validators import pg_arguments_validator
+from .flexible_server_virtual_network import prepare_private_network, prepare_private_dns_zone
+from .validators import pg_arguments_validator, validate_server_name
 
 
 logger = get_logger(__name__)
@@ -39,7 +39,8 @@ def flexible_server_create(cmd, client,
                            tags=None, public_access=None, database_name=None,
                            assign_identity=False, subnet_arm_resource_id=None,
                            high_availability=None, zone=None, vnet_resource_id=None,
-                           vnet_address_prefix=None, subnet_address_prefix=None):
+                           vnet_address_prefix=None, subnet_address_prefix=None,
+                           private_dns_zone_arguments=None):
     # validator
     if location is None:
         location = DEFAULT_LOCATION_PG
@@ -62,6 +63,7 @@ def flexible_server_create(cmd, client,
     location, resource_group_name, server_name = generate_missing_parameters(cmd, location, resource_group_name,
                                                                              server_name, 'postgres')
     server_name = server_name.lower()
+    validate_server_name(cf_postgres_check_resource_availability(cmd.cli_ctx, '_'), server_name, 'Microsoft.DBforPostgreSQL/flexibleServers')
 
     # Handle Vnet scenario
     if public_access is None:
@@ -75,8 +77,17 @@ def flexible_server_create(cmd, client,
                                             vnet_address_pref=vnet_address_prefix,
                                             subnet_address_pref=subnet_address_prefix)
         delegated_subnet_arguments = postgresql_flexibleservers.models.ServerPropertiesDelegatedSubnetArguments(subnet_arm_resource_id=subnet_id)
+        private_dns_zone_id = prepare_private_dns_zone(cmd,
+                                                       'PostgreSQL',
+                                                       resource_group_name,
+                                                       server_name,
+                                                       private_dns_zone=private_dns_zone_arguments,
+                                                       subnet_id=subnet_id,
+                                                       location=location)
+        private_dns_zone_arguments = postgresql_flexibleservers.models.ServerPropertiesPrivateDnsZoneArguments(private_dns_zone_arm_resource_id=private_dns_zone_id)
     else:
         delegated_subnet_arguments = None
+        private_dns_zone_arguments = None
 
     administrator_login_password = generate_password(administrator_login_password)
     if server_result is None:
@@ -87,7 +98,7 @@ def flexible_server_create(cmd, client,
                                        sku_name, tier, storage_mb, administrator_login,
                                        administrator_login_password,
                                        version, tags, subnet_id, assign_identity, delegated_subnet_arguments,
-                                       high_availability, zone)
+                                       high_availability, zone, private_dns_zone_arguments)
 
         # Adding firewall rule
         if public_access is not None and str(public_access).lower() != 'none':
@@ -125,6 +136,7 @@ def flexible_server_restore(cmd, client,
                             resource_group_name, server_name,
                             source_server, restore_point_in_time=None, location=None, zone=None, no_wait=False):
     provider = 'Microsoft.DBforPostgreSQL'
+    validate_server_name(cf_postgres_check_resource_availability(cmd.cli_ctx, '_'), server_name, 'Microsoft.DBforPostgreSQL/flexibleServers')
 
     if not is_valid_resource_id(source_server):
         if len(source_server.split('/')) == 1:
@@ -153,6 +165,7 @@ def flexible_server_restore(cmd, client,
     try:
         source_server_object = client.get(id_parts['resource_group'], id_parts['name'])
         parameters.location = source_server_object.location
+        parameters.private_dns_zone_arguments = source_server_object.private_dns_zone_arguments
     except Exception as e:
         raise ResourceNotFoundError(e)
 
@@ -292,7 +305,7 @@ def flexible_list_skus(cmd, client, location):
 
 def _create_server(db_context, cmd, resource_group_name, server_name, location, backup_retention, sku_name, tier,
                    storage_mb, administrator_login, administrator_login_password, version, tags, public_network_access,
-                   assign_identity, delegated_subnet_arguments, ha_enabled, availability_zone):
+                   assign_identity, delegated_subnet_arguments, ha_enabled, availability_zone, private_dns_zone_arguments):
     logging_name, server_client = db_context.logging_name, db_context.server_client
     logger.warning('Creating %s Server \'%s\' in group \'%s\'...', logging_name, server_name, resource_group_name)
 
@@ -315,7 +328,8 @@ def _create_server(db_context, cmd, resource_group_name, server_name, location,
         availability_zone=availability_zone,
         location=location,
         create_mode="Default",  # can also be create
-        tags=tags)
+        tags=tags,
+        private_dns_zone_arguments=private_dns_zone_arguments)
 
     if assign_identity:
         parameters.identity = postgresql_flexibleservers.models.Identity()