DNS sous Windows
Cours complet : Implémentation d'un serveur DNS sur Windows Server 2022
1. Présentation du service DNS
1.1 Introduction
Le DNS (Domain Name System) est un service fondamental dans toute infrastructure réseau. Il agit comme un annuaire téléphonique d'Internet et des réseaux privés, traduisant les noms de domaine compréhensibles par l'homme (comme www.exemple.com) en adresses IP (comme 192.168.1.10) que les ordinateurs utilisent pour communiquer.
Rôles principaux du DNS :
- Résolution de noms : Conversion des noms d'hôtes en adresses IP (résolution directe)
- Résolution inverse : Conversion des adresses IP en noms d'hôtes
- Localisation de services : Identification des serveurs offrant des services spécifiques (mail, web, etc.)
- Distribution de charge : Répartition du trafic entre plusieurs serveurs
Composants clés :
- Serveur DNS : Machine hébergeant le service DNS
- Zone DNS : Portion de l'espace de noms DNS gérée par un serveur
- Enregistrements DNS : Entrées dans la base de données DNS (A, AAAA, CNAME, MX, etc.)
- Client DNS (Resolver) : Composant qui interroge les serveurs DNS
1.2 Système hiérarchique
Le DNS fonctionne selon une structure hiérarchique arborescente, similaire au système de fichiers Windows.
Structure hiérarchique :
. (racine)
|
+---------------+---------------+
| | |
.com .org .fr
| | |
exemple.com organisation.org entreprise.fr
|
+---+---+
| |
www mail
Niveaux de la hiérarchie :
- Racine (.) : Sommet de la hiérarchie, géré par 13 serveurs racines mondiaux
- Domaines de premier niveau (TLD) : .com, .org, .fr, .net, etc.
- Domaines de second niveau : exemple.com, microsoft.com
- Sous-domaines : mail.exemple.com, www.exemple.com
Types de serveurs DNS :
- Serveur racine : Point de départ pour toute résolution DNS
- Serveur autoritaire : Détient les informations officielles pour une zone
- Serveur récursif : Effectue les requêtes pour le compte des clients
- Serveur de transfert (Forwarder) : Relais les requêtes vers d'autres serveurs DNS
2. Installation du rôle Serveur DNS
Prérequis
- Windows Server 2022 installé et configuré
- Adresse IP statique configurée
- Accès administrateur au serveur
- Planification de l'espace de noms DNS
Installation via Server Manager
Ouvrir Server Manager
- Cliquer sur "Manage" → "Add Roles and Features"
Assistant d'installation
- Type d'installation : "Role-based or feature-based installation"
- Sélectionner le serveur local
- Dans la liste des rôles, cocher "DNS Server"
- Accepter l'ajout des fonctionnalités requises
- Cliquer sur "Next" puis "Install"
Configuration post-installation
- Ouvrir la console DNS (dnsmgmt.msc)
- Configurer les redirecteurs si nécessaire
- Créer les zones requises
Installation via PowerShell
# Installation du rôle DNS
Install-WindowsFeature -Name DNS -IncludeManagementTools
# Vérification de l'installation
Get-WindowsFeature -Name DNS
# Démarrage du service DNS
Start-Service -Name DNS
# Configuration du service pour démarrage automatique
Set-Service -Name DNS -StartupType Automatic
Configuration initiale recommandée
# Configuration des redirecteurs DNS
Add-DnsServerForwarder -IPAddress 8.8.8.8, 8.8.4.4
# Activation de la récursion
Set-DnsServerRecursion -Enable $true
# Configuration de la mise en cache
Set-DnsServerCache -MaxTTL 86400
3. Gestion des zones DNS
3.1 Création d'une zone de recherche directe secondaire
Une zone secondaire est une copie en lecture seule d'une zone principale, utilisée pour la redondance et la répartition de charge.
Via l'interface graphique :
- Ouvrir la console DNS (dnsmgmt.msc)
- Clic droit sur "Forward Lookup Zones" → "New Zone"
- Sélectionner "Secondary zone"
- Entrer le nom de la zone (ex: contoso.com)
- Spécifier l'adresse IP du serveur DNS principal
- Finaliser l'assistant
Via PowerShell :
# Création d'une zone secondaire
Add-DnsServerSecondaryZone -Name "contoso.com" `
-ZoneFile "contoso.com.dns" `
-MasterServers 192.168.1.10
# Configuration du transfert de zone
Set-DnsServerSecondaryZone -Name "contoso.com" `
-MasterServers 192.168.1.10, 192.168.1.11
# Forcer le transfert de zone
Start-DnsServerZoneTransfer -Name "contoso.com"
Points importants :
- Le serveur principal doit autoriser les transferts de zone
- Configurer les notifications de changements
- Planifier les intervalles de rafraîchissement
3.2 Création d'une zone de recherche directe principale
Une zone principale contient la copie maître modifiable des enregistrements DNS.
Via l'interface graphique :
- Console DNS → Clic droit sur "Forward Lookup Zones"
- "New Zone" → "Primary zone"
- Cocher "Store the zone in Active Directory" (si contrôleur de domaine)
- Choisir la réplication (tous les DC du domaine recommandé)
- Entrer le nom de la zone
- Configurer les mises à jour dynamiques
Via PowerShell :
# Zone principale intégrée à AD
Add-DnsServerPrimaryZone -Name "entreprise.local" `
-ReplicationScope "Domain" `
-DynamicUpdate "Secure"
# Zone principale basée sur fichier
Add-DnsServerPrimaryZone -Name "exemple.com" `
-ZoneFile "exemple.com.dns" `
-DynamicUpdate "NonsecureAndSecure"
# Ajout d'enregistrements de base
Add-DnsServerResourceRecordA -Name "www" `
-ZoneName "entreprise.local" `
-IPv4Address "192.168.1.100"
Add-DnsServerResourceRecordCName -Name "ftp" `
-ZoneName "entreprise.local" `
-HostNameAlias "www.entreprise.local"
Configuration des transferts de zone :
# Autoriser les transferts vers des serveurs spécifiques
Set-DnsServerPrimaryZone -Name "entreprise.local" `
-SecondaryServers "192.168.1.20", "192.168.1.21" `
-SecureSecondaries "TransferToSecureServers"
# Configurer les notifications
Set-DnsServerPrimaryZone -Name "entreprise.local" `
-Notify "NotifyServers" `
-NotifyServers "192.168.1.20", "192.168.1.21"
3.3 Création d'une zone de recherche inversée
Les zones inversées permettent la résolution d'adresses IP en noms d'hôtes.
Format des zones inversées :
- IPv4 : x.y.z.in-addr.arpa (ex: 1.168.192.in-addr.arpa pour 192.168.1.0/24)
- IPv6 : utilise ip6.arpa
Via l'interface graphique :
- Console DNS → Clic droit sur "Reverse Lookup Zones"
- "New Zone" → Suivre l'assistant
- Choisir IPv4 ou IPv6
- Entrer l'ID réseau (ex: 192.168.1)
- Configurer les options (AD integration, dynamic updates)
Via PowerShell :
# Création zone inversée pour 192.168.1.0/24
Add-DnsServerPrimaryZone -NetworkID "192.168.1.0/24" `
-ReplicationScope "Domain" `
-DynamicUpdate "Secure"
# Ajout d'un enregistrement PTR
Add-DnsServerResourceRecordPtr -Name "100" `
-ZoneName "1.168.192.in-addr.arpa" `
-PtrDomainName "serveur.entreprise.local"
# Configuration automatique des PTR avec les enregistrements A
$zone = "entreprise.local"
$reverseZone = "1.168.192.in-addr.arpa"
Get-DnsServerResourceRecord -ZoneName $zone -RRType A | ForEach-Object {
$ip = $_.RecordData.IPv4Address.ToString()
$octets = $ip.Split('.')
$ptrName = $octets[3]
$hostName = $_.HostName + "." + $zone
Add-DnsServerResourceRecordPtr -Name $ptrName `
-ZoneName $reverseZone `
-PtrDomainName $hostName
}
3.4 Création d'une zone GlobalNames
La zone GlobalNames (GNZ) permet la résolution de noms uniques sans suffixe DNS, remplaçant WINS.
Activation et configuration :
# Activer le support GlobalNames sur le serveur
Set-DnsServerGlobalNameZone -Enable $true `
-AlwaysQueryServer $true
# Créer la zone GlobalNames
Add-DnsServerPrimaryZone -Name "GlobalNames" `
-ReplicationScope "Forest" `
-DynamicUpdate "Off"
# Ajouter des enregistrements CNAME
Add-DnsServerResourceRecordCName -Name "Intranet" `
-ZoneName "GlobalNames" `
-HostNameAlias "intranet.entreprise.local"
Add-DnsServerResourceRecordCName -Name "Mail" `
-ZoneName "GlobalNames" `
-HostNameAlias "exchange.entreprise.local"
Bonnes pratiques GlobalNames :
- Utiliser uniquement pour les noms courts critiques
- Pas de mises à jour dynamiques
- Répliquer sur tous les serveurs DNS de la forêt
- Documenter tous les enregistrements
4. Gestion du serveur DNS
4.1 Supprimer des enregistrements
Via l'interface graphique :
- Naviguer vers la zone concernée
- Clic droit sur l'enregistrement → "Delete"
- Confirmer la suppression
Via PowerShell :
# Supprimer un enregistrement A spécifique
Remove-DnsServerResourceRecord -Name "ancien-serveur" `
-ZoneName "entreprise.local" `
-RRType "A" `
-Force
# Supprimer tous les enregistrements d'un type
Get-DnsServerResourceRecord -ZoneName "entreprise.local" `
-RRType "CNAME" |
Where-Object {$_.HostName -like "test*"} |
Remove-DnsServerResourceRecord -ZoneName "entreprise.local" `
-Force
# Script de nettoyage avec confirmation
$records = Get-DnsServerResourceRecord -ZoneName "entreprise.local" `
-RRType "A" |
Where-Object {$_.TimeStamp -lt (Get-Date).AddDays(-90)}
foreach ($record in $records) {
Write-Host "Suppression de : $($record.HostName)"
Remove-DnsServerResourceRecord -InputObject $record `
-ZoneName "entreprise.local" `
-Force
}
4.2 Définir le vieillissement pour les zones
Le vieillissement permet de supprimer automatiquement les enregistrements obsolètes.
Configuration du vieillissement :
# Activer le vieillissement sur une zone
Set-DnsServerZoneAging -Name "entreprise.local" `
-Aging $true `
-NoRefreshInterval 7.00:00:00 `
-RefreshInterval 7.00:00:00
# Configurer pour toutes les zones
Get-DnsServerZone | Where-Object {$_.IsDsIntegrated -eq $true} |
ForEach-Object {
Set-DnsServerZoneAging -Name $_.ZoneName `
-Aging $true `
-NoRefreshInterval 7.00:00:00 `
-RefreshInterval 7.00:00:00
}
# Vérifier la configuration
Get-DnsServerZone -Name "entreprise.local" |
Select-Object ZoneName, AgingEnabled, NoRefreshInterval, RefreshInterval
Paramètres importants :
- No-refresh interval : Période pendant laquelle l'horodatage ne peut pas être actualisé
- Refresh interval : Période après laquelle l'enregistrement peut être actualisé
- Scavenging period : Fréquence du nettoyage automatique
4.3 Activer le nettoyage automatique
Le nettoyage (scavenging) supprime automatiquement les enregistrements expirés.
# Activer le nettoyage sur le serveur
Set-DnsServerScavenging -ScavengingState $true `
-ScavengingInterval 7.00:00:00 `
-RefreshInterval 7.00:00:00 `
-NoRefreshInterval 7.00:00:00
# Configurer le nettoyage avancé
Set-DnsServerScavenging -ScavengingState $true `
-ScavengingInterval 3.00:00:00 `
-RefreshInterval 3.00:00:00 `
-NoRefreshInterval 3.00:00:00 `
-ApplyOnAllZones
# Vérifier l'état du nettoyage
Get-DnsServerScavenging
4.4 Effectuer un nettoyage manuel
# Démarrer le nettoyage immédiatement
Start-DnsServerScavenging -Force
# Script de nettoyage manuel avec rapport
$obsoleteRecords = @()
$zones = Get-DnsServerZone | Where-Object {$_.ZoneType -eq "Primary"}
foreach ($zone in $zones) {
$records = Get-DnsServerResourceRecord -ZoneName $zone.ZoneName |
Where-Object {
$_.TimeStamp -ne $null -and
$_.TimeStamp -lt (Get-Date).AddDays(-30)
}
$obsoleteRecords += $records | Select-Object @{
Name="Zone";Expression={$zone.ZoneName}
}, HostName, RecordType, TimeStamp
}
# Exporter le rapport
$obsoleteRecords | Export-Csv -Path "C:\DNS_Obsolete_Records.csv" -NoTypeInformation
# Supprimer les enregistrements obsolètes
foreach ($record in $obsoleteRecords) {
Remove-DnsServerResourceRecord -Name $record.HostName `
-ZoneName $record.Zone `
-RRType $record.RecordType `
-Force
}
4.5 Les différents types de redirecteurs
Les redirecteurs (forwarders) permettent de diriger les requêtes DNS vers d'autres serveurs.
Types de redirecteurs :
- Redirecteurs standard : Redirige toutes les requêtes non résolues localement
- Redirecteurs conditionnels : Redirige selon le domaine demandé
- Redirecteurs exclusifs : Désactive la récursion si le redirecteur ne répond pas
Configuration des redirecteurs :
# Redirecteurs standard
Add-DnsServerForwarder -IPAddress 8.8.8.8, 8.8.4.4
Set-DnsServerForwarder -IPAddress 1.1.1.1, 1.0.0.1 -UseRootHint $false
# Redirecteurs conditionnels
Add-DnsServerConditionalForwarderZone -Name "partenaire.com" `
-MasterServers 192.168.100.10, 192.168.100.11 `
-ReplicationScope "Forest"
# Gestion avancée
# Lister les redirecteurs
Get-DnsServerForwarder
# Supprimer un redirecteur
Remove-DnsServerForwarder -IPAddress 8.8.8.8 -Force
# Configurer le timeout
Set-DnsServerForwarder -EnableReordering $true `
-Timeout 3 `
-UseRootHint $true
4.6 Utilisation des statistiques au niveau du service DNS
Windows Server 2022 offre des statistiques détaillées pour surveiller les performances DNS.
# Obtenir les statistiques globales
Get-DnsServerStatistics
# Statistiques détaillées
$stats = Get-DnsServerStatistics
$stats.Query2Statistics
$stats.CacheStatistics
$stats.TimeStatistics
# Statistiques par zone
Get-DnsServerZone | ForEach-Object {
$zoneStats = Get-DnsServerStatistics -ZoneName $_.ZoneName
[PSCustomObject]@{
Zone = $_.ZoneName
QueryCount = $zoneStats.Query2Statistics.TotalQueries
CacheHits = $zoneStats.CacheStatistics.CacheHitCount
}
}
# Surveillance en temps réel
while ($true) {
Clear-Host
$stats = Get-DnsServerStatistics
Write-Host "=== Statistiques DNS ===" -ForegroundColor Cyan
Write-Host "Requêtes totales: $($stats.Query2Statistics.TotalQueries)"
Write-Host "Requêtes/sec: $($stats.Query2Statistics.QueriesPerSecond)"
Write-Host "Cache Hits: $($stats.CacheStatistics.CacheHitCount)"
Write-Host "Échecs: $($stats.ErrorStatistics.ServFail)"
Start-Sleep -Seconds 5
}
# Exporter les statistiques
Get-DnsServerStatistics | ConvertTo-Json |
Out-File "C:\DNS_Stats_$(Get-Date -Format 'yyyyMMdd').json"
Création de rapports automatisés :
# Script de rapport quotidien
$reportPath = "C:\DNSReports"
$date = Get-Date -Format "yyyyMMdd"
# Créer le dossier si nécessaire
if (!(Test-Path $reportPath)) {
New-Item -ItemType Directory -Path $reportPath
}
# Collecter les statistiques
$globalStats = Get-DnsServerStatistics
$zoneStats = Get-DnsServerZone | ForEach-Object {
Get-DnsServerStatistics -ZoneName $_.ZoneName
}
# Générer le rapport HTML
$html = @"
<!DOCTYPE html>
<html>
<head>
<title>Rapport DNS - $date</title>
<style>
body { font-family: Arial; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
th { background-color: #4CAF50; color: white; }
</style>
</head>
<body>
<h1>Rapport DNS du $date</h1>
<h2>Statistiques Globales</h2>
<table>
<tr><th>Métrique</th><th>Valeur</th></tr>
<tr><td>Requêtes totales</td><td>$($globalStats.Query2Statistics.TotalQueries)</td></tr>
<tr><td>Requêtes réussies</td><td>$($globalStats.Query2Statistics.StandardQueries)</td></tr>
<tr><td>Cache Hits</td><td>$($globalStats.CacheStatistics.CacheHitCount)</td></tr>
</table>
</body>
</html>
"@
$html | Out-File "$reportPath\DNSReport_$date.html"
4.7 Création de politique DNS
Les politiques DNS permettent un contrôle granulaire du comportement du serveur DNS.
Types de politiques :
- Politiques de requête
- Politiques de transfert de zone
- Politiques de récursion
- Géolocalisation
# Politique basée sur l'interface réseau
Add-DnsServerQueryResolutionPolicy -Name "InternalOnly" `
-Action "ALLOW" `
-ServerInterface "eq,192.168.1.10" `
-PassThru
# Politique basée sur le sous-réseau client
Add-DnsServerClientSubnet -Name "SubnetParis" `
-IPv4Subnet "192.168.10.0/24"
Add-DnsServerClientSubnet -Name "SubnetLyon" `
-IPv4Subnet "192.168.20.0/24"
# Créer des zones scope
Add-DnsServerZoneScope -ZoneName "entreprise.local" `
-Name "ParisScope"
Add-DnsServerZoneScope -ZoneName "entreprise.local" `
-Name "LyonScope"
# Ajouter des enregistrements spécifiques aux scopes
Add-DnsServerResourceRecord -ZoneName "entreprise.local" `
-ZoneScope "ParisScope" `
-A -Name "www" `
-IPv4Address "192.168.10.100"
Add-DnsServerResourceRecord -ZoneName "entreprise.local" `
-ZoneScope "LyonScope" `
-A -Name "www" `
-IPv4Address "192.168.20.100"
# Créer les politiques de résolution
Add-DnsServerQueryResolutionPolicy -Name "ParisSitePolicy" `
-Action ALLOW `
-ClientSubnet "eq,SubnetParis" `
-ZoneScope "ParisScope,1" `
-ZoneName "entreprise.local"
Add-DnsServerQueryResolutionPolicy -Name "LyonSitePolicy" `
-Action ALLOW `
-ClientSubnet "eq,SubnetLyon" `
-ZoneScope "LyonScope,1" `
-ZoneName "entreprise.local"
# Politique de limitation de taux
Add-DnsServerResponseRateLimiting `
-Mode Enable `
-ErrorsPerSec 5 `
-ResponsesPerSec 20 `
-IPv4PrefixLength 24 `
-LeakRate 3 `
-TruncateRate 2
Politiques de sécurité avancées :
# Bloquer des domaines malveillants
$maliciousDomains = @("badsite.com", "phishing.org")
foreach ($domain in $maliciousDomains) {
Add-DnsServerPrimaryZone -Name $domain `
-ReplicationScope "Domain" `
-DynamicUpdate "None"
Add-DnsServerQueryResolutionPolicy -Name "Block_$domain" `
-Action DENY `
-QType "EQ,ANY" `
-FQDN "EQ,*.$domain"
}
# Politique de récursion sélective
Add-DnsServerRecursionScope -Name "InternalRecursion" `
-EnableRecursion $true
Add-DnsServerRecursionScope -Name "ExternalRecursion" `
-EnableRecursion $false
Set-DnsServerRecursionScope -Name "." `
-EnableRecursion $false
4.8 Gestion du DNS à l'aide de PowerShell
PowerShell offre une gestion complète et automatisée du DNS.
Scripts d'administration courants :
# === Script de sauvegarde DNS ===
function Backup-DNSConfiguration {
param(
[string]$BackupPath = "C:\DNSBackup"
)
$date = Get-Date -Format "yyyyMMdd_HHmmss"
$backupFolder = "$BackupPath\$date"
New-Item -ItemType Directory -Path $backupFolder -Force
# Exporter les zones
Get-DnsServerZone | ForEach-Object {
Export-DnsServerZone -Name $_.ZoneName `
-FileName "$backupFolder\$($_.ZoneName).txt"
}
# Exporter la configuration
Get-DnsServer | ConvertTo-Json -Depth 10 |
Out-File "$backupFolder\ServerConfig.json"
Write-Host "Sauvegarde terminée dans $backupFolder" -ForegroundColor Green
}
# === Script de monitoring ===
function Test-DNSHealth {
$tests = @()
# Test du service
$dnsService = Get-Service -Name DNS
$tests += [PSCustomObject]@{
Test = "Service DNS"
Status = $dnsService.Status
Result = if($dnsService.Status -eq "Running") {"OK"} else {"ERREUR"}
}
# Test de résolution
try {
$resolution = Resolve-DnsName -Name "google.com" -ErrorAction Stop
$tests += [PSCustomObject]@{
Test = "Résolution externe"
Status = "Succès"
Result = "OK"
}
} catch {
$tests += [PSCustomObject]@{
Test = "Résolution externe"
Status = "Échec"
Result = "ERREUR"
}
}
# Test des zones
Get-DnsServerZone | ForEach-Object {
$soa = Get-DnsServerResourceRecord -ZoneName $_.ZoneName `
-RRType SOA -ErrorAction SilentlyContinue
$tests += [PSCustomObject]@{
Test = "Zone $($_.ZoneName)"
Status = if($soa) {"Actif"} else {"Problème"}
Result = if($soa) {"OK"} else {"ATTENTION"}
}
}
return $tests
}
# === Script de création en masse ===
function New-BulkDNSRecords {
param(
[string]$CSVPath,
[string]$ZoneName
)
$records = Import-Csv $CSVPath
foreach ($record in $records) {
switch ($record.Type) {
"A" {
Add-DnsServerResourceRecordA -Name $record.Name `
-ZoneName $ZoneName `
-IPv4Address $record.Value `
-CreatePtr $true
}
"CNAME" {
Add-DnsServerResourceRecordCName -Name $record.Name `
-ZoneName $ZoneName `
-HostNameAlias $record.Value
}
"MX" {
Add-DnsServerResourceRecordMX -Name $record.Name `
-ZoneName $ZoneName `
-MailExchange $record.Value `
-Preference $record.Priority
}
}
Write-Host "Créé: $($record.Name) ($($record.Type))" -ForegroundColor Green
}
}
# === Fonction de migration DNS ===
function Migrate-DNSZone {
param(
[string]$SourceServer,
[string]$DestinationServer,
[string]$ZoneName
)
# Exporter depuis la source
$tempFile = "$env:TEMP\$ZoneName.dns"
Invoke-Command -ComputerName $SourceServer -ScriptBlock {
param($zone, $file)
Export-DnsServerZone -Name $zone -FileName $file
} -ArgumentList $ZoneName, $tempFile
# Copier le fichier
Copy-Item "\\$SourceServer\C$\Windows\System32\dns\$ZoneName.dns" `
-Destination "\\$DestinationServer\C$\Windows\System32\dns\"
# Importer sur la destination
Invoke-Command -ComputerName $DestinationServer -ScriptBlock {
param($zone, $file)
Add-DnsServerPrimaryZone -Name $zone `
-ZoneFile "$zone.dns" `
-DynamicUpdate "Secure"
} -ArgumentList $ZoneName
Write-Host "Migration de $ZoneName terminée" -ForegroundColor Green
}
Module PowerShell personnalisé pour DNS :
# DNSTools.psm1
function Get-DNSDashboard {
Clear-Host
Write-Host "=== Tableau de bord DNS ===" -ForegroundColor Cyan
Write-Host ""
# État du service
$service = Get-Service DNS
Write-Host "Service DNS: " -NoNewline
if ($service.Status -eq "Running") {
Write-Host $service.Status -ForegroundColor Green
} else {
Write-Host $service.Status -ForegroundColor Red
}
# Zones
$zones = Get-DnsServerZone
Write-Host "`nNombre de zones: $($zones.Count)"
Write-Host "Zones primaires: $(($zones | Where-Object {$_.ZoneType -eq 'Primary'}).Count)"
Write-Host "Zones secondaires: $(($zones | Where-Object {$_.ZoneType -eq 'Secondary'}).Count)"
# Statistiques
$stats = Get-DnsServerStatistics
Write-Host "`n=== Statistiques ===" -ForegroundColor Cyan
Write-Host "Requêtes totales: $($stats.Query2Statistics.TotalQueries)"
Write-Host "Cache Hits: $($stats.CacheStatistics.CacheHitCount)"
# Redirecteurs
$forwarders = Get-DnsServerForwarder
Write-Host "`n=== Redirecteurs ===" -ForegroundColor Cyan
$forwarders.IPAddress | ForEach-Object {
Write-Host " - $_"
}
}
Export-ModuleMember -Function Get-DNSDashboard
5. Gestion des enregistrements
Types d'enregistrements DNS
Enregistrements principaux :
| Type | Description | Exemple |
|---|---|---|
| A | Adresse IPv4 | www → 192.168.1.100 |
| AAAA | Adresse IPv6 | www → 2001:db8::1 |
| CNAME | Alias canonique | ftp → www.exemple.com |
| MX | Serveur de messagerie | @ → mail.exemple.com (priorité 10) |
| NS | Serveur de noms | @ → ns1.exemple.com |
| PTR | Pointeur (résolution inverse) | 192.168.1.100 → www.exemple.com |
| SOA | Start of Authority | Informations sur la zone |
| SRV | Service | _ldap._tcp → dc1.exemple.com:389 |
| TXT | Texte | Vérification SPF, DKIM |
Gestion avancée des enregistrements
# === Création d'enregistrements complexes ===
# Enregistrement SRV pour Active Directory
Add-DnsServerResourceRecord -ZoneName "entreprise.local" `
-Name "_ldap._tcp" `
-SRV -Priority 0 `
-Weight 100 `
-Port 389 `
-DomainName "dc1.entreprise.local"
# Enregistrement TXT pour SPF
Add-DnsServerResourceRecord -ZoneName "entreprise.local" `
-Name "@" `
-TXT -DescriptiveText "v=spf1 mx a ip4:192.168.1.0/24 ~all"
# Enregistrement MX avec priorités multiples
Add-DnsServerResourceRecordMX -Name "@" `
-ZoneName "entreprise.local" `
-MailExchange "mail1.entreprise.local" `
-Preference 10
Add-DnsServerResourceRecordMX -Name "@" `
-ZoneName "entreprise.local" `
-MailExchange "mail2.entreprise.local" `
-Preference 20
# === Script de validation des enregistrements ===
function Test-DNSRecords {
param(
[string]$ZoneName
)
$results = @()
$records = Get-DnsServerResourceRecord -ZoneName $ZoneName
foreach ($record in $records) {
$testResult = $null
switch ($record.RecordType) {
"A" {
$ip = $record.RecordData.IPv4Address.ToString()
$ping = Test-Connection -ComputerName $ip -Count 1 -Quiet
$testResult = [PSCustomObject]@{
Name = $record.HostName
Type = "A"
Value = $ip
Status = if($ping) {"Accessible"} else {"Inaccessible"}
}
}
"CNAME" {
$target = $record.RecordData.HostNameAlias
try {
$resolved = Resolve-DnsName -Name $target -ErrorAction Stop
$testResult = [PSCustomObject]@{
Name = $record.HostName
Type = "CNAME"
Value = $target
Status = "Résolu"
}
} catch {
$testResult = [PSCustomObject]@{
Name = $record.HostName
Type = "CNAME"
Value = $target
Status = "Erreur de résolution"
}
}
}
}
if ($testResult) {
$results += $testResult
}
}
return $results
}
# === Gestion des TTL ===
function Set-BulkTTL {
param(
[string]$ZoneName,
[string]$RecordType,
[timespan]$TTL
)
$records = Get-DnsServerResourceRecord -ZoneName $ZoneName `
-RRType $RecordType
foreach ($record in $records) {
$oldRecord = $record.Clone()
$record.TimeToLive = $TTL
Set-DnsServerResourceRecord -ZoneName $ZoneName `
-OldInputObject $oldRecord `
-NewInputObject $record
}
Write-Host "TTL mis à jour pour $($records.Count) enregistrements $RecordType" `
-ForegroundColor Green
}
# Utilisation
Set-BulkTTL -ZoneName "entreprise.local" -RecordType "A" -TTL ([timespan]::FromHours(1))
Maintenance et optimisation
# === Script de maintenance hebdomadaire ===
function Start-DNSMaintenance {
Write-Host "Démarrage de la maintenance DNS..." -ForegroundColor Yellow
# 1. Sauvegarde
Write-Host "1. Sauvegarde des zones..." -ForegroundColor Cyan
Backup-DNSConfiguration
# 2. Nettoyage
Write-Host "2. Nettoyage des enregistrements obsolètes..." -ForegroundColor Cyan
Start-DnsServerScavenging -Force
# 3. Vérification de l'intégrité
Write-Host "3. Vérification de l'intégrité des zones..." -ForegroundColor Cyan
Get-DnsServerZone | ForEach-Object {
$result = Test-DnsServerZone -ZoneName $_.ZoneName
if ($result) {
Write-Host " ✓ $($_.ZoneName)" -ForegroundColor Green
} else {
Write-Host " ✗ $($_.ZoneName)" -ForegroundColor Red
}
}
# 4. Optimisation du cache
Write-Host "4. Optimisation du cache..." -ForegroundColor Cyan
Clear-DnsServerCache -Force
# 5. Mise à jour des statistiques
Write-Host "5. Génération du rapport..." -ForegroundColor Cyan
$stats = Get-DnsServerStatistics
$stats | ConvertTo-Html | Out-File "C:\DNSReports\Maintenance_$(Get-Date -Format 'yyyyMMdd').html"
Write-Host "Maintenance terminée!" -ForegroundColor Green
}
# === Surveillance continue ===
function Start-DNSMonitoring {
param(
[int]$IntervalSeconds = 300,
[string]$LogPath = "C:\DNSLogs"
)
while ($true) {
$timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
$stats = Get-DnsServerStatistics
# Vérifier les seuils
if ($stats.ErrorStatistics.ServFail -gt 100) {
Write-Warning "[$timestamp] Nombre élevé d'échecs ServFail détecté"
# Envoyer une alerte (exemple avec event log)
Write-EventLog -LogName Application `
-Source "DNS Server" `
-EventId 9999 `
-EntryType Warning `
-Message "Nombre élevé d'échecs DNS détecté: $($stats.ErrorStatistics.ServFail)"
}
# Logger les statistiques
$logEntry = [PSCustomObject]@{
Timestamp = $timestamp
TotalQueries = $stats.Query2Statistics.TotalQueries
CacheHits = $stats.CacheStatistics.CacheHitCount
ServFails = $stats.ErrorStatistics.ServFail
}
$logEntry | Export-Csv -Path "$LogPath\DNSStats.csv" -Append -NoTypeInformation
Start-Sleep -Seconds $IntervalSeconds
}
}
Conclusion et bonnes pratiques
Recommandations essentielles
- Redondance : Toujours déployer au moins deux serveurs DNS
- Sécurité : Implémenter DNSSEC et limiter les transferts de zone
- Surveillance : Mettre en place un monitoring continu
- Documentation : Maintenir une documentation à jour de toutes les zones et enregistrements
- Sauvegarde : Effectuer des sauvegardes régulières et tester les restaurations
- Maintenance : Planifier des opérations de maintenance régulières
- Formation : Former l'équipe aux procédures d'urgence