0
# DNS Resource References
1

2
Lookup functionality for DNS records by Azure resource IDs, enabling discovery of DNS records that reference specific Azure resources. This capability is useful for finding which DNS records point to particular Azure services like App Services, CDN endpoints, or Traffic Manager profiles.
3

4
## Resource Reference Operations
5

6
### Get DNS Records by Target Resources
7

8
Retrieves DNS records that reference specific Azure resources through their resource IDs.
9

10
```python { .api }
11
def get_by_target_resources(
12
    self,
13
    parameters: Union[DnsResourceReferenceRequest, IO[bytes]],
14
    **kwargs: Any
15
) -> DnsResourceReferenceResult:
16
    """
17
    Get DNS records that reference specific Azure target resources.
18
    
19
    This operation allows you to find DNS records (across all zones in a subscription)
20
    that point to specific Azure resources like App Services, CDN endpoints, etc.
21
    
22
    Args:
23
        parameters: Request containing list of target resource IDs to search for
24
        
25
    Returns:
26
        DnsResourceReferenceResult: DNS records that reference the target resources
27
        
28
    Raises:
29
        HttpResponseError: If the operation fails or access is denied
30
    """
31
```
32

33
**Usage Example:**
34

35
```python
36
from azure.mgmt.dns.models import DnsResourceReferenceRequest, SubResource
37

38
# Define target resources to search for
39
target_resources = [
40
    SubResource(id="/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Web/sites/myapp"),
41
    SubResource(id="/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.Cdn/profiles/{profile}/endpoints/{endpoint}")
42
]
43

44
# Create the request
45
request = DnsResourceReferenceRequest(target_resources=target_resources)
46

47
# Find DNS records referencing these resources
48
result = dns_client.dns_resource_reference.get_by_target_resources(
49
    parameters=request
50
)
51

52
# Process results
53
for dns_ref in result.dns_resource_references:
54
    print(f"Target Resource: {dns_ref.target_resource.id}")
55
    for dns_resource in dns_ref.dns_resources:
56
        print(f"  DNS Record: {dns_resource.id}")
57
```
58

59
## Data Models
60

61
### DnsResourceReferenceRequest
62

63
```python { .api }
64
class DnsResourceReferenceRequest:
65
    """
66
    Request for finding DNS records that reference specific Azure resources.
67
    """
68
    target_resources: List[SubResource]  # List of Azure resource IDs to search for
69
```
70

71
### DnsResourceReferenceResult
72

73
```python { .api }
74
class DnsResourceReferenceResult:
75
    """
76
    Response containing DNS records that reference the requested target resources.
77
    """
78
    dns_resource_references: List[DnsResourceReference]  # List of DNS resource references found
79
```
80

81
### DnsResourceReference
82

83
```python { .api }
84
class DnsResourceReference:
85
    """
86
    Associates a target Azure resource with DNS records that reference it.
87
    """
88
    dns_resources: List[SubResource]  # DNS records that reference the target resource
89
    target_resource: SubResource      # The Azure resource being referenced
90
```
91

92
### SubResource
93

94
```python { .api }
95
class SubResource:
96
    """
97
    Reference to an Azure resource by its ID.
98
    """
99
    id: str  # Full Azure resource ID
100
```
101

102
## Use Cases
103

104
### Finding DNS Records for App Services
105

106
Discover which DNS records point to your Azure App Service:
107

108
```python
109
from azure.mgmt.dns.models import DnsResourceReferenceRequest, SubResource
110

111
# App Service resource ID
112
app_service_id = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/myapp-rg/providers/Microsoft.Web/sites/mywebapp"
113

114
request = DnsResourceReferenceRequest(
115
    target_resources=[SubResource(id=app_service_id)]
116
)
117

118
result = dns_client.dns_resource_reference.get_by_target_resources(request)
119

120
print(f"DNS records pointing to App Service '{app_service_id}':")
121
for dns_ref in result.dns_resource_references:
122
    if dns_ref.target_resource.id == app_service_id:
123
        for dns_resource in dns_ref.dns_resources:
124
            # Extract zone and record info from DNS resource ID
125
            resource_parts = dns_resource.id.split('/')
126
            zone_name = resource_parts[8]  # Zone name is at index 8
127
            record_name = resource_parts[10] if len(resource_parts) > 10 else "@"
128
            record_type = resource_parts[9] if len(resource_parts) > 9 else "Unknown"
129
            
130
            print(f"  Zone: {zone_name}")
131
            print(f"  Record: {record_name} ({record_type})")
132
```
133

134
### Bulk Resource Lookup
135

136
Find DNS records for multiple Azure resources in a single request:
137

138
```python
139
# Multiple resource types
140
target_resources = [
141
    # CDN endpoint
142
    SubResource(id="/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Cdn/profiles/mycdnprofile/endpoints/myendpoint"),
143
    
144
    # Traffic Manager profile
145
    SubResource(id="/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/trafficmanagerprofiles/mytmprofile"),
146
    
147
    # App Service
148
    SubResource(id="/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/sites/mywebapp"),
149
    
150
    # Public IP address
151
    SubResource(id="/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Network/publicIPAddresses/mypublicip")
152
]
153

154
request = DnsResourceReferenceRequest(target_resources=target_resources)
155
result = dns_client.dns_resource_reference.get_by_target_resources(request)
156

157
# Group DNS records by target resource
158
for dns_ref in result.dns_resource_references:
159
    target_id = dns_ref.target_resource.id
160
    resource_name = target_id.split('/')[-1]  # Extract resource name
161
    resource_type = target_id.split('/')[-3]  # Extract resource type
162
    
163
    print(f"\n{resource_type}: {resource_name}")
164
    print(f"Resource ID: {target_id}")
165
    print("DNS Records:")
166
    
167
    for dns_resource in dns_ref.dns_resources:
168
        print(f"  - {dns_resource.id}")
169
```
170

171
### Integration with Other Operations
172

173
Combine resource reference lookup with record set operations:
174

175
```python
176
from azure.mgmt.dns.models import DnsResourceReferenceRequest, SubResource
177

178
# Find existing DNS records for a resource
179
app_service_id = "/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.Web/sites/myapp"
180
request = DnsResourceReferenceRequest(target_resources=[SubResource(id=app_service_id)])
181
result = dns_client.dns_resource_reference.get_by_target_resources(request)
182

183
# Update TTL for all found DNS records
184
for dns_ref in result.dns_resource_references:
185
    for dns_resource in dns_ref.dns_resources:
186
        # Parse DNS resource ID to get zone and record details
187
        resource_parts = dns_resource.id.split('/')
188
        resource_group = resource_parts[4]
189
        zone_name = resource_parts[8]
190
        record_type = resource_parts[9]
191
        record_name = resource_parts[10] if len(resource_parts) > 10 else "@"
192
        
193
        # Get current record set
194
        try:
195
            record_set = dns_client.record_sets.get(
196
                resource_group_name=resource_group,
197
                zone_name=zone_name,
198
                relative_record_set_name=record_name,
199
                record_type=record_type
200
            )
201
            
202
            # Update TTL to 1 hour
203
            record_set.ttl = 3600
204
            
205
            # Save changes
206
            dns_client.record_sets.create_or_update(
207
                resource_group_name=resource_group,
208
                zone_name=zone_name,
209
                relative_record_set_name=record_name,
210
                record_type=record_type,
211
                parameters=record_set
212
            )
213
            
214
            print(f"Updated TTL for {record_name}.{zone_name} ({record_type})")
215
            
216
        except Exception as e:
217
            print(f"Failed to update {record_name}.{zone_name}: {e}")
218
```
219

220
## Resource ID Patterns
221

222
Different Azure services have different resource ID patterns:
223

224
### App Services
225
```
226
/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Web/sites/{site-name}
227
```
228

229
### CDN Endpoints
230
```
231
/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Cdn/profiles/{profile-name}/endpoints/{endpoint-name}
232
```
233

234
### Traffic Manager Profiles
235
```
236
/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/trafficmanagerprofiles/{profile-name}
237
```
238

239
### Public IP Addresses
240
```
241
/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/publicIPAddresses/{ip-name}
242
```
243

244
### Load Balancers
245
```
246
/subscriptions/{subscription-id}/resourceGroups/{resource-group}/providers/Microsoft.Network/loadBalancers/{lb-name}
247
```
248

249
## Limitations and Considerations
250

251
### Scope
252
- Searches DNS records across **all zones** in the subscription
253
- Only finds records that use Azure resource references (alias records or target_resource properties)
254
- Does not find traditional DNS records that contain IP addresses or hostnames pointing to Azure resources
255

256
### Performance
257
- Results may be cached for performance
258
- Large subscriptions with many DNS zones may experience longer response times
259
- Consider limiting the number of target resources in a single request
260

261
### Permissions
262
- Requires DNS zone read permissions across the subscription
263
- May return incomplete results if access is restricted to specific resource groups
264

265
## Error Handling
266

267
```python
268
from azure.core.exceptions import HttpResponseError
269

270
try:
271
    request = DnsResourceReferenceRequest(
272
        target_resources=[SubResource(id="invalid-resource-id")]
273
    )
274
    result = dns_client.dns_resource_reference.get_by_target_resources(request)
275
except HttpResponseError as e:
276
    if e.status_code == 400:
277
        print("Bad request: Invalid resource ID format")
278
    elif e.status_code == 403:
279
        print("Access denied: Insufficient permissions to access DNS zones")
280
    elif e.status_code == 404:
281
        print("Not found: One or more target resources don't exist")
282
    else:
283
        print(f"Unexpected error: {e.status_code} - {e.message}")
284
```
285

286
Common error scenarios:
287
- **400 Bad Request**: Malformed resource IDs in the request
288
- **403 Forbidden**: Insufficient permissions to read DNS zones
289
- **404 Not Found**: Target resources don't exist or are not accessible