0
# Azure DNS Management Client
1

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

4
## Package Information
5

6
- **Package Name**: azure-mgmt-dns
7
- **Language**: Python
8
- **Installation**: `pip install azure-mgmt-dns`
9
- **Dependencies**: `azure-common>=1.1`, `azure-mgmt-core>=1.5.0`, `isodate>=0.6.1`, `typing-extensions>=4.6.0`
10
- **Python Version**: 3.9+
11

12
## Core Imports
13

14
```python
15
from azure.mgmt.dns import DnsManagementClient
16
from azure.mgmt.dns.models import Zone, RecordSet, RecordType, ZoneType
17
```
18

19
For specific DNS record types:
20

21
```python
22
from azure.mgmt.dns.models import (
23
    ARecord, AaaaRecord, CaaRecord, CnameRecord, MxRecord, 
24
    NsRecord, PtrRecord, SoaRecord, SrvRecord, TxtRecord
25
)
26
```
27

28
For resource reference operations:
29

30
```python
31
from azure.mgmt.dns.models import (
32
    DnsResourceReferenceRequest, DnsResourceReferenceResult, 
33
    DnsResourceReference, SubResource
34
)
35
```
36

37
For error handling and pagination:
38

39
```python
40
from azure.mgmt.dns.models import (
41
    CloudErrorBody, Resource, 
42
    ZoneListResult, RecordSetListResult,
43
    ZoneUpdate
44
)
45
from azure.core.paging import ItemPaged
46
from azure.core.polling import LROPoller
47
```
48

49
For async operations:
50

51
```python
52
from azure.mgmt.dns.aio import DnsManagementClient
53
from azure.identity.aio import DefaultAzureCredential  # Async credential
54
```
55

56
## Basic Usage
57

58
```python
59
from azure.core.credentials import DefaultAzureCredential
60
from azure.mgmt.dns import DnsManagementClient
61
from azure.mgmt.dns.models import Zone, RecordSet, ARecord, RecordType
62

63
# Initialize the client
64
credential = DefaultAzureCredential()
65
subscription_id = "your-subscription-id"
66
dns_client = DnsManagementClient(credential, subscription_id)
67

68
# Create a DNS zone
69
zone_params = Zone(location="global")
70
zone = dns_client.zones.create_or_update(
71
    resource_group_name="myResourceGroup",
72
    zone_name="example.com",
73
    parameters=zone_params
74
)
75

76
# Create an A record
77
record_set = RecordSet(
78
    ttl=300,
79
    a_records=[ARecord(ipv4_address="1.2.3.4")]
80
)
81
dns_client.record_sets.create_or_update(
82
    resource_group_name="myResourceGroup",
83
    zone_name="example.com",
84
    relative_record_set_name="www",
85
    record_type=RecordType.A,
86
    parameters=record_set
87
)
88

89
# List all zones in a resource group
90
zones = dns_client.zones.list_by_resource_group("myResourceGroup")
91
for zone in zones:
92
    print(f"Zone: {zone.name}")
93
```
94

95
## Architecture
96

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

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

104
## Capabilities
105

106
### DNS Zone Management
107

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

110
```python { .api }
111
class ZonesOperations:
112
    def create_or_update(
113
        self,
114
        resource_group_name: str,
115
        zone_name: str,
116
        parameters: Union[Zone, IO[bytes]],
117
        if_match: Optional[str] = None,
118
        if_none_match: Optional[str] = None,
119
        **kwargs: Any
120
    ) -> Zone: ...
121

122
    def begin_delete(
123
        self,
124
        resource_group_name: str,
125
        zone_name: str,
126
        if_match: Optional[str] = None,
127
        **kwargs: Any
128
    ) -> LROPoller[None]: ...
129

130
    def get(
131
        self,
132
        resource_group_name: str,
133
        zone_name: str,
134
        **kwargs: Any
135
    ) -> Zone: ...
136

137
    def list_by_resource_group(
138
        self,
139
        resource_group_name: str,
140
        top: Optional[int] = None,
141
        **kwargs: Any
142
    ) -> ItemPaged[Zone]: ...
143
```
144

145
[DNS Zone Management](./dns-zones.md)
146

147
### DNS Record Set Management
148

149
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.
150

151
```python { .api }
152
class RecordSetsOperations:
153
    def create_or_update(
154
        self,
155
        resource_group_name: str,
156
        zone_name: str,
157
        relative_record_set_name: str,
158
        record_type: Union[str, RecordType],
159
        parameters: Union[RecordSet, IO[bytes]],
160
        if_match: Optional[str] = None,
161
        if_none_match: Optional[str] = None,
162
        **kwargs: Any
163
    ) -> RecordSet: ...
164

165
    def update(
166
        self,
167
        resource_group_name: str,
168
        zone_name: str,
169
        relative_record_set_name: str,
170
        record_type: Union[str, RecordType],
171
        parameters: Union[RecordSet, IO[bytes]],
172
        if_match: Optional[str] = None,
173
        **kwargs: Any
174
    ) -> RecordSet: ...
175

176
    def delete(
177
        self,
178
        resource_group_name: str,
179
        zone_name: str,
180
        relative_record_set_name: str,
181
        record_type: Union[str, RecordType],
182
        if_match: Optional[str] = None,
183
        **kwargs: Any
184
    ) -> None: ...
185

186
    def get(
187
        self,
188
        resource_group_name: str,
189
        zone_name: str,
190
        relative_record_set_name: str,
191
        record_type: Union[str, RecordType],
192
        **kwargs: Any
193
    ) -> RecordSet: ...
194

195
    def list_by_dns_zone(
196
        self,
197
        resource_group_name: str,
198
        zone_name: str,
199
        top: Optional[int] = None,
200
        recordsetnamesuffix: Optional[str] = None,
201
        **kwargs: Any
202
    ) -> ItemPaged[RecordSet]: ...
203

204
    def list_by_type(
205
        self,
206
        resource_group_name: str,
207
        zone_name: str,
208
        record_type: Union[str, RecordType],
209
        top: Optional[int] = None,
210
        recordsetnamesuffix: Optional[str] = None,
211
        **kwargs: Any
212
    ) -> ItemPaged[RecordSet]: ...
213

214
    def list_all_by_dns_zone(
215
        self,
216
        resource_group_name: str,
217
        zone_name: str,
218
        top: Optional[int] = None,
219
        record_set_name_suffix: Optional[str] = None,
220
        **kwargs: Any
221
    ) -> ItemPaged[RecordSet]: ...
222
```
223

224
[DNS Record Set Management](./dns-record-sets.md)
225

226
### DNS Resource References
227

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

230
```python { .api }
231
class DnsResourceReferenceOperations:
232
    def get_by_target_resources(
233
        self,
234
        parameters: Union[DnsResourceReferenceRequest, IO[bytes]],
235
        **kwargs: Any
236
    ) -> DnsResourceReferenceResult: ...
237
```
238

239
[DNS Resource References](./dns-resource-references.md)
240

241
## Common Types
242

243
### Core DNS Models
244

245
```python { .api }
246
class Zone:
247
    """Represents a DNS zone resource."""
248
    id: str                                    # Resource ID (read-only)
249
    name: str                                  # Resource name (read-only)
250
    type: str                                  # Resource type (read-only)
251
    location: str                              # Resource location (required)
252
    tags: Dict[str, str]                       # Resource tags
253
    etag: str                                  # ETag for concurrency control
254
    max_number_of_record_sets: int             # Maximum record sets allowed (read-only)
255
    number_of_record_sets: int                 # Current number of record sets (read-only)
256
    name_servers: List[str]                    # Name servers for the zone (read-only)
257
    zone_type: ZoneType                        # Public or Private zone type
258
    registration_virtual_networks: List[SubResource]  # VNets for hostname registration
259
    resolution_virtual_networks: List[SubResource]    # VNets for record resolution
260

261
class RecordSet:
262
    """Represents a DNS record set within a zone."""
263
    id: str                       # Record set ID (read-only)
264
    name: str                     # Record set name (read-only)
265
    type: str                     # Record set type (read-only)
266
    etag: str                     # ETag for concurrency control
267
    metadata: Dict[str, str]      # Metadata key-value pairs
268
    ttl: int                      # Time-to-live in seconds
269
    fqdn: str                     # Fully qualified domain name (read-only)
270
    target_resource: SubResource  # Reference to Azure resource
271
    # Record type specific arrays:
272
    a_records: List[ARecord]
273
    aaaa_records: List[AaaaRecord]
274
    caa_records: List[CaaRecord]
275
    cname_record: CnameRecord
276
    mx_records: List[MxRecord]
277
    ns_records: List[NsRecord]
278
    ptr_records: List[PtrRecord]
279
    soa_record: SoaRecord
280
    srv_records: List[SrvRecord]
281
    txt_records: List[TxtRecord]
282

283
class RecordType(str, Enum):
284
    """Supported DNS record types."""
285
    A = "A"
286
    AAAA = "AAAA"
287
    CAA = "CAA"
288
    CNAME = "CNAME"
289
    MX = "MX"
290
    NS = "NS"
291
    PTR = "PTR"
292
    SOA = "SOA"
293
    SRV = "SRV"
294
    TXT = "TXT"
295

296
class ZoneType(str, Enum):
297
    """DNS zone types."""
298
    PUBLIC = "Public"
299
    PRIVATE = "Private"
300
```
301

302
### Authentication and Configuration
303

304
The client requires Azure Active Directory authentication and subscription configuration:
305

306
```python { .api }
307
class DnsManagementClient:
308
    """Main client for Azure DNS management operations."""
309
    def __init__(
310
        self,
311
        credential: TokenCredential,
312
        subscription_id: str,
313
        base_url: Optional[str] = None,
314
        **kwargs: Any
315
    ) -> None: ...
316

317
    # Operation properties
318
    record_sets: RecordSetsOperations
319
    zones: ZonesOperations  
320
    dns_resource_reference: DnsResourceReferenceOperations
321

322
    def close(self) -> None: ...
323
    def __enter__(self) -> Self: ...
324
    def __exit__(self, *exc_details: Any) -> None: ...
325
```
326

327
### Supporting Models
328

329
```python { .api }
330
class Resource:
331
    """Base Azure resource model."""
332
    id: str                       # Azure resource ID (read-only)
333
    name: str                     # Resource name (read-only)
334
    type: str                     # Resource type (read-only)
335
    location: str                 # Resource location
336
    tags: Dict[str, str]          # Resource tags
337

338
class SubResource:
339
    """Reference to another Azure resource."""
340
    id: str                       # Full Azure resource ID
341

342
class CloudErrorBody:
343
    """Azure REST API error response structure."""
344
    code: str                     # Error code
345
    message: str                  # Error message
346
    target: Optional[str]         # Error target
347
    details: List[CloudErrorBody] # Nested error details
348
    additional_info: List[Dict]   # Additional error information
349

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

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

360
class ZoneUpdate:
361
    """Parameters for updating DNS zone properties."""
362
    tags: Dict[str, str]          # Updated resource tags
363
```
364

365
## Async Support
366

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

369
```python { .api }
370
from azure.mgmt.dns.aio import DnsManagementClient
371

372
class DnsManagementClient:
373
    """Async version of the DNS management client."""
374
    def __init__(
375
        self,
376
        credential: AsyncTokenCredential,
377
        subscription_id: str,
378
        base_url: Optional[str] = None,
379
        **kwargs: Any
380
    ) -> None: ...
381

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

387
    async def close(self) -> None: ...
388
    async def __aenter__(self) -> Self: ...
389
    async def __aexit__(self, *exc_details: Any) -> None: ...
390
```
391

392
**Async Usage Example:**
393

394
```python
395
import asyncio
396
from azure.identity.aio import DefaultAzureCredential
397
from azure.mgmt.dns.aio import DnsManagementClient
398
from azure.mgmt.dns.models import Zone
399

400
async def manage_dns_async():
401
    credential = DefaultAzureCredential()
402
    async with DnsManagementClient(credential, "subscription-id") as dns_client:
403
        # Create zone asynchronously
404
        zone_params = Zone(location="global")
405
        zone = await dns_client.zones.create_or_update(
406
            resource_group_name="my-rg",
407
            zone_name="example.com",
408
            parameters=zone_params
409
        )
410
        
411
        # List zones asynchronously
412
        zones = dns_client.zones.list_by_resource_group("my-rg")
413
        async for zone in zones:
414
            print(f"Zone: {zone.name}")
415

416
# Run async function
417
asyncio.run(manage_dns_async())
418
```