or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

dns-record-sets.mddns-resource-references.mddns-zones.mdindex.md
tile.json

tessl/pypi-azure-mgmt-dns

Microsoft Azure DNS Management Client Library for Python

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
pypipkg:pypi/azure-mgmt-dns@9.0.x

To install, run

npx @tessl/cli install tessl/pypi-azure-mgmt-dns@9.0.0

index.mddocs/

Azure DNS Management Client

A comprehensive Python client library for managing Azure DNS resources through the Azure Resource Manager API. Enables programmatic creation, configuration, and management of DNS zones, record sets, and various DNS record types within Azure's cloud DNS service.

Package Information

  • Package Name: azure-mgmt-dns
  • Language: Python
  • Installation: pip install azure-mgmt-dns
  • Dependencies: azure-common>=1.1, azure-mgmt-core>=1.5.0, isodate>=0.6.1, typing-extensions>=4.6.0
  • Python Version: 3.9+

Core Imports

from azure.mgmt.dns import DnsManagementClient
from azure.mgmt.dns.models import Zone, RecordSet, RecordType, ZoneType

For specific DNS record types:

from azure.mgmt.dns.models import (
    ARecord, AaaaRecord, CaaRecord, CnameRecord, MxRecord, 
    NsRecord, PtrRecord, SoaRecord, SrvRecord, TxtRecord
)

For resource reference operations:

from azure.mgmt.dns.models import (
    DnsResourceReferenceRequest, DnsResourceReferenceResult, 
    DnsResourceReference, SubResource
)

For error handling and pagination:

from azure.mgmt.dns.models import (
    CloudErrorBody, Resource, 
    ZoneListResult, RecordSetListResult,
    ZoneUpdate
)
from azure.core.paging import ItemPaged
from azure.core.polling import LROPoller

For async operations:

from azure.mgmt.dns.aio import DnsManagementClient
from azure.identity.aio import DefaultAzureCredential  # Async credential

Basic Usage

from azure.core.credentials import DefaultAzureCredential
from azure.mgmt.dns import DnsManagementClient
from azure.mgmt.dns.models import Zone, RecordSet, ARecord, RecordType

# Initialize the client
credential = DefaultAzureCredential()
subscription_id = "your-subscription-id"
dns_client = DnsManagementClient(credential, subscription_id)

# Create a DNS zone
zone_params = Zone(location="global")
zone = dns_client.zones.create_or_update(
    resource_group_name="myResourceGroup",
    zone_name="example.com",
    parameters=zone_params
)

# Create an A record
record_set = RecordSet(
    ttl=300,
    a_records=[ARecord(ipv4_address="1.2.3.4")]
)
dns_client.record_sets.create_or_update(
    resource_group_name="myResourceGroup",
    zone_name="example.com",
    relative_record_set_name="www",
    record_type=RecordType.A,
    parameters=record_set
)

# List all zones in a resource group
zones = dns_client.zones.list_by_resource_group("myResourceGroup")
for zone in zones:
    print(f"Zone: {zone.name}")

Architecture

The Azure DNS Management Client follows the Azure SDK design patterns:

  • DnsManagementClient: Main client providing access to all DNS operations
  • Operations Classes: Specialized classes for different resource types (zones, record sets, references)
  • Model Classes: Data structures representing DNS resources and configuration
  • Azure Core Integration: Built on Azure Core for authentication, error handling, and HTTP pipeline management

Capabilities

DNS Zone Management

Comprehensive management of DNS zones including creation, deletion, updating, and listing operations. Supports both public and private zones with virtual network associations.

class ZonesOperations:
    def create_or_update(
        self,
        resource_group_name: str,
        zone_name: str,
        parameters: Union[Zone, IO[bytes]],
        if_match: Optional[str] = None,
        if_none_match: Optional[str] = None,
        **kwargs: Any
    ) -> Zone: ...

    def begin_delete(
        self,
        resource_group_name: str,
        zone_name: str,
        if_match: Optional[str] = None,
        **kwargs: Any
    ) -> LROPoller[None]: ...

    def get(
        self,
        resource_group_name: str,
        zone_name: str,
        **kwargs: Any
    ) -> Zone: ...

    def list_by_resource_group(
        self,
        resource_group_name: str,
        top: Optional[int] = None,
        **kwargs: Any
    ) -> ItemPaged[Zone]: ...

DNS Zone Management

DNS Record Set Management

Complete CRUD operations for DNS record sets supporting all major DNS record types (A, AAAA, CAA, CNAME, MX, NS, PTR, SOA, SRV, TXT) with conditional updates and batch operations.

class RecordSetsOperations:
    def create_or_update(
        self,
        resource_group_name: str,
        zone_name: str,
        relative_record_set_name: str,
        record_type: Union[str, RecordType],
        parameters: Union[RecordSet, IO[bytes]],
        if_match: Optional[str] = None,
        if_none_match: Optional[str] = None,
        **kwargs: Any
    ) -> RecordSet: ...

    def update(
        self,
        resource_group_name: str,
        zone_name: str,
        relative_record_set_name: str,
        record_type: Union[str, RecordType],
        parameters: Union[RecordSet, IO[bytes]],
        if_match: Optional[str] = None,
        **kwargs: Any
    ) -> RecordSet: ...

    def delete(
        self,
        resource_group_name: str,
        zone_name: str,
        relative_record_set_name: str,
        record_type: Union[str, RecordType],
        if_match: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...

    def get(
        self,
        resource_group_name: str,
        zone_name: str,
        relative_record_set_name: str,
        record_type: Union[str, RecordType],
        **kwargs: Any
    ) -> RecordSet: ...

    def list_by_dns_zone(
        self,
        resource_group_name: str,
        zone_name: str,
        top: Optional[int] = None,
        recordsetnamesuffix: Optional[str] = None,
        **kwargs: Any
    ) -> ItemPaged[RecordSet]: ...

    def list_by_type(
        self,
        resource_group_name: str,
        zone_name: str,
        record_type: Union[str, RecordType],
        top: Optional[int] = None,
        recordsetnamesuffix: Optional[str] = None,
        **kwargs: Any
    ) -> ItemPaged[RecordSet]: ...

    def list_all_by_dns_zone(
        self,
        resource_group_name: str,
        zone_name: str,
        top: Optional[int] = None,
        record_set_name_suffix: Optional[str] = None,
        **kwargs: Any
    ) -> ItemPaged[RecordSet]: ...

DNS Record Set Management

DNS Resource References

Lookup functionality for DNS records by Azure resource IDs, enabling discovery of DNS records that reference specific Azure resources.

class DnsResourceReferenceOperations:
    def get_by_target_resources(
        self,
        parameters: Union[DnsResourceReferenceRequest, IO[bytes]],
        **kwargs: Any
    ) -> DnsResourceReferenceResult: ...

DNS Resource References

Common Types

Core DNS Models

class Zone:
    """Represents a DNS zone resource."""
    id: str                                    # Resource ID (read-only)
    name: str                                  # Resource name (read-only)
    type: str                                  # Resource type (read-only)
    location: str                              # Resource location (required)
    tags: Dict[str, str]                       # Resource tags
    etag: str                                  # ETag for concurrency control
    max_number_of_record_sets: int             # Maximum record sets allowed (read-only)
    number_of_record_sets: int                 # Current number of record sets (read-only)
    name_servers: List[str]                    # Name servers for the zone (read-only)
    zone_type: ZoneType                        # Public or Private zone type
    registration_virtual_networks: List[SubResource]  # VNets for hostname registration
    resolution_virtual_networks: List[SubResource]    # VNets for record resolution

class RecordSet:
    """Represents a DNS record set within a zone."""
    id: str                       # Record set ID (read-only)
    name: str                     # Record set name (read-only)
    type: str                     # Record set type (read-only)
    etag: str                     # ETag for concurrency control
    metadata: Dict[str, str]      # Metadata key-value pairs
    ttl: int                      # Time-to-live in seconds
    fqdn: str                     # Fully qualified domain name (read-only)
    target_resource: SubResource  # Reference to Azure resource
    # Record type specific arrays:
    a_records: List[ARecord]
    aaaa_records: List[AaaaRecord]
    caa_records: List[CaaRecord]
    cname_record: CnameRecord
    mx_records: List[MxRecord]
    ns_records: List[NsRecord]
    ptr_records: List[PtrRecord]
    soa_record: SoaRecord
    srv_records: List[SrvRecord]
    txt_records: List[TxtRecord]

class RecordType(str, Enum):
    """Supported DNS record types."""
    A = "A"
    AAAA = "AAAA"
    CAA = "CAA"
    CNAME = "CNAME"
    MX = "MX"
    NS = "NS"
    PTR = "PTR"
    SOA = "SOA"
    SRV = "SRV"
    TXT = "TXT"

class ZoneType(str, Enum):
    """DNS zone types."""
    PUBLIC = "Public"
    PRIVATE = "Private"

Authentication and Configuration

The client requires Azure Active Directory authentication and subscription configuration:

class DnsManagementClient:
    """Main client for Azure DNS management operations."""
    def __init__(
        self,
        credential: TokenCredential,
        subscription_id: str,
        base_url: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...

    # Operation properties
    record_sets: RecordSetsOperations
    zones: ZonesOperations  
    dns_resource_reference: DnsResourceReferenceOperations

    def close(self) -> None: ...
    def __enter__(self) -> Self: ...
    def __exit__(self, *exc_details: Any) -> None: ...

Supporting Models

class Resource:
    """Base Azure resource model."""
    id: str                       # Azure resource ID (read-only)
    name: str                     # Resource name (read-only)
    type: str                     # Resource type (read-only)
    location: str                 # Resource location
    tags: Dict[str, str]          # Resource tags

class SubResource:
    """Reference to another Azure resource."""
    id: str                       # Full Azure resource ID

class CloudErrorBody:
    """Azure REST API error response structure."""
    code: str                     # Error code
    message: str                  # Error message
    target: Optional[str]         # Error target
    details: List[CloudErrorBody] # Nested error details
    additional_info: List[Dict]   # Additional error information

class ZoneListResult:
    """Paginated result for zone list operations."""
    value: List[Zone]             # List of zones in current page
    next_link: Optional[str]      # URL for next page of results

class RecordSetListResult:
    """Paginated result for record set list operations."""
    value: List[RecordSet]        # List of record sets in current page
    next_link: Optional[str]      # URL for next page of results

class ZoneUpdate:
    """Parameters for updating DNS zone properties."""
    tags: Dict[str, str]          # Updated resource tags

Async Support

The Azure DNS Management Client provides full async support through the azure.mgmt.dns.aio module:

from azure.mgmt.dns.aio import DnsManagementClient

class DnsManagementClient:
    """Async version of the DNS management client."""
    def __init__(
        self,
        credential: AsyncTokenCredential,
        subscription_id: str,
        base_url: Optional[str] = None,
        **kwargs: Any
    ) -> None: ...

    # Async operation properties (same methods as sync, but async)
    record_sets: RecordSetsOperations
    zones: ZonesOperations  
    dns_resource_reference: DnsResourceReferenceOperations

    async def close(self) -> None: ...
    async def __aenter__(self) -> Self: ...
    async def __aexit__(self, *exc_details: Any) -> None: ...

Async Usage Example:

import asyncio
from azure.identity.aio import DefaultAzureCredential
from azure.mgmt.dns.aio import DnsManagementClient
from azure.mgmt.dns.models import Zone

async def manage_dns_async():
    credential = DefaultAzureCredential()
    async with DnsManagementClient(credential, "subscription-id") as dns_client:
        # Create zone asynchronously
        zone_params = Zone(location="global")
        zone = await dns_client.zones.create_or_update(
            resource_group_name="my-rg",
            zone_name="example.com",
            parameters=zone_params
        )
        
        # List zones asynchronously
        zones = dns_client.zones.list_by_resource_group("my-rg")
        async for zone in zones:
            print(f"Zone: {zone.name}")

# Run async function
asyncio.run(manage_dns_async())