def _ensure_ase_private_dns_zone(cli_ctx, resource_group_name, name,
inbound_vnet_id, inbound_ip_address):
# Private DNS Zone
private_dns_client = _get_private_dns_client_factory(cli_ctx)
zone_name = '{}.appserviceenvironment.net'.format(name)
zone = PrivateZone(location='global', tags=None)
poller = private_dns_client.private_zones.begin_create_or_update(
resource_group_name, zone_name, zone)
LongRunningOperation(cli_ctx)(poller)
link_name = '{}_link'.format(name)
link = VirtualNetworkLink(location='global', tags=None)
link.virtual_network = SubResource(id=inbound_vnet_id)
link.registration_enabled = False
private_dns_client.virtual_network_links.begin_create_or_update(
resource_group_name, zone_name, link_name, link, if_none_match='*')
ase_record = ARecord(ipv4_address=inbound_ip_address)
record_set = RecordSet(ttl=3600)
record_set.a_records = [ase_record]
private_dns_client.record_sets.create_or_update(resource_group_name,
zone_name, 'a', '*',
record_set)
private_dns_client.record_sets.create_or_update(resource_group_name,
zone_name, 'a', '@',
record_set)
private_dns_client.record_sets.create_or_update(resource_group_name,
zone_name, 'a', '*.scm',
record_set)
def private_dns_create_a_record(self,
name: str,
ip: str,
zone: str,
rsg: str = None) -> None:
"""Create a Private DNS A record
Args:
name (str): name of the A record
ip (str): IP address
zone (str, optional): Zone of the A record. Defaults to None.
"""
self.logger.info(f"Creating Private DNS record {name}.{zone} for {ip}")
if isinstance(ip, str):
ips = [ARecord(ipv4_address=ip)]
else:
ips = [ARecord(ipv4_address=i) for i in ip]
self.client(PrivateDnsManagementClient).record_sets.create_or_update(
self.rsg if not rsg else rsg,
zone,
"A",
name,
RecordSet(ttl=3600, a_records=ips),
)
self.logger.info("DNS Record created.")
def _privatedns_add_save_record(client, record, record_type, relative_record_set_name, resource_group_name, private_zone_name, is_list=True):
from azure.mgmt.privatedns.models import RecordSet
try:
record_set = client.get(
resource_group_name, private_zone_name, record_type, relative_record_set_name)
except HttpResponseError:
record_set = RecordSet(ttl=3600)
_privatedns_add_record(record_set, record, record_type, is_list)
return client.create_or_update(resource_group_name, private_zone_name, record_type, relative_record_set_name, record_set)
def create_privatedns_record_set(cmd,
resource_group_name,
private_zone_name,
relative_record_set_name,
record_type,
metadata=None,
ttl=3600):
from azure.mgmt.privatedns import PrivateDnsManagementClient
from azure.mgmt.privatedns.models import RecordSet
client = get_mgmt_service_client(cmd.cli_ctx,
PrivateDnsManagementClient).record_sets
record_set = RecordSet(ttl=ttl, metadata=metadata)
return client.create_or_update(resource_group_name,
private_zone_name,
record_type,
relative_record_set_name,
record_set,
if_none_match='*')
def import_zone(cmd, resource_group_name, private_zone_name, file_name):
from azure.cli.core.util import read_file_content
import sys
from azure.mgmt.privatedns.models import RecordSet
file_text = read_file_content(file_name)
zone_obj = parse_zone_file(file_text, private_zone_name)
origin = private_zone_name
record_sets = {}
for record_set_name in zone_obj:
for record_set_type in zone_obj[record_set_name]:
record_set_obj = zone_obj[record_set_name][record_set_type]
if record_set_type == 'soa':
origin = record_set_name.rstrip('.')
if not isinstance(record_set_obj, list):
record_set_obj = [record_set_obj]
for entry in record_set_obj:
record_set_ttl = entry['ttl']
record_set_key = '{}{}'.format(record_set_name.lower(),
record_set_type)
record = _build_record(cmd, entry)
if not record:
logger.warning(
'Cannot import %s. RecordType is not found. Skipping...',
entry['delim'].lower())
continue
record_set = record_sets.get(record_set_key, None)
if not record_set:
# Workaround for issue #2824
relative_record_set_name = record_set_name.rstrip('.')
if not relative_record_set_name.endswith(origin):
logger.warning(
'Cannot import %s. Only records relative to origin may be '
'imported at this time. Skipping...',
relative_record_set_name)
continue
record_set = RecordSet(ttl=record_set_ttl)
record_sets[record_set_key] = record_set
_privatedns_add_record(record_set,
record,
record_set_type,
is_list=record_set_type.lower()
not in ['soa', 'cname'])
total_records = 0
for key, rs in record_sets.items():
rs_name, rs_type = key.lower().rsplit('.', 1)
rs_name = rs_name[:-(len(origin) + 1)] if rs_name != origin else '@'
try:
record_count = len(
getattr(rs, _privatedns_type_to_property_name(rs_type)))
except TypeError:
record_count = 1
total_records += record_count
cum_records = 0
from azure.mgmt.privatedns import PrivateDnsManagementClient
from azure.mgmt.privatedns.models import PrivateZone
client = get_mgmt_service_client(cmd.cli_ctx, PrivateDnsManagementClient)
print('== BEGINNING ZONE IMPORT: {} ==\n'.format(private_zone_name),
file=sys.stderr)
if private_zone_name.endswith(".local"):
logger.warning((
"Please be aware that DNS names ending with .local are reserved for use with multicast DNS "
"and may not work as expected with some operating systems. For details refer to your operating systems documentation."
))
zone = PrivateZone(location='global')
result = LongRunningOperation(cmd.cli_ctx)(
client.private_zones.create_or_update(resource_group_name,
private_zone_name, zone))
if result.provisioning_state != 'Succeeded':
raise CLIError(
'Error occured while creating or updating private dns zone.')
for key, rs in record_sets.items():
rs_name, rs_type = key.lower().rsplit('.', 1)
rs_name = '@' if rs_name == origin else rs_name
if rs_name.endswith(origin):
rs_name = rs_name[:-(len(origin) + 1)]
try:
record_count = len(
getattr(rs, _privatedns_type_to_property_name(rs_type)))
except TypeError:
record_count = 1
if rs_name == '@' and rs_type == 'soa':
root_soa = client.record_sets.get(resource_group_name,
private_zone_name, 'soa', '@')
rs.soa_record.host = root_soa.soa_record.host
rs_name = '@'
try:
client.record_sets.create_or_update(resource_group_name,
private_zone_name, rs_type,
rs_name, rs)
cum_records += record_count
print("({}/{}) Imported {} records of type '{}' and name '{}'".
format(cum_records, total_records, record_count, rs_type,
rs_name),
file=sys.stderr)
except CloudError as ex:
logger.error(ex)
print("\n== {}/{} RECORDS IMPORTED SUCCESSFULLY: '{}' ==".format(
cum_records, total_records, private_zone_name),
file=sys.stderr)