Bye Bye Prof

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 :

Composants clés :

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 :

  1. Racine (.) : Sommet de la hiérarchie, géré par 13 serveurs racines mondiaux
  2. Domaines de premier niveau (TLD) : .com, .org, .fr, .net, etc.
  3. Domaines de second niveau : exemple.com, microsoft.com
  4. Sous-domaines : mail.exemple.com, www.exemple.com

Types de serveurs DNS :

2. Installation du rôle Serveur DNS

Prérequis

Installation via Server Manager

Ouvrir Server Manager

Assistant d'installation

Configuration post-installation

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 :

  1. Ouvrir la console DNS (dnsmgmt.msc)
  2. Clic droit sur "Forward Lookup Zones" → "New Zone"
  3. Sélectionner "Secondary zone"
  4. Entrer le nom de la zone (ex: contoso.com)
  5. Spécifier l'adresse IP du serveur DNS principal
  6. 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 :

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 :

  1. Console DNS → Clic droit sur "Forward Lookup Zones"
  2. "New Zone" → "Primary zone"
  3. Cocher "Store the zone in Active Directory" (si contrôleur de domaine)
  4. Choisir la réplication (tous les DC du domaine recommandé)
  5. Entrer le nom de la zone
  6. 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 :

Via l'interface graphique :

  1. Console DNS → Clic droit sur "Reverse Lookup Zones"
  2. "New Zone" → Suivre l'assistant
  3. Choisir IPv4 ou IPv6
  4. Entrer l'ID réseau (ex: 192.168.1)
  5. 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 :

4. Gestion du serveur DNS

4.1 Supprimer des enregistrements

Via l'interface graphique :

  1. Naviguer vers la zone concernée
  2. Clic droit sur l'enregistrement → "Delete"
  3. 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 :

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 :

  1. Redirecteurs standard : Redirige toutes les requêtes non résolues localement
  2. Redirecteurs conditionnels : Redirige selon le domaine demandé
  3. 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 :

# 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

  1. Redondance : Toujours déployer au moins deux serveurs DNS
  2. Sécurité : Implémenter DNSSEC et limiter les transferts de zone
  3. Surveillance : Mettre en place un monitoring continu
  4. Documentation : Maintenir une documentation à jour de toutes les zones et enregistrements
  5. Sauvegarde : Effectuer des sauvegardes régulières et tester les restaurations
  6. Maintenance : Planifier des opérations de maintenance régulières
  7. Formation : Former l'équipe aux procédures d'urgence