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 :
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 :
Types de serveurs DNS :
Ouvrir Server Manager
Assistant d'installation
Configuration post-installation
# 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 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
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 :
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 :
Une zone principale contient la copie maître modifiable des enregistrements DNS.
Via l'interface graphique :
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"
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 :
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
}
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 :
Via l'interface graphique :
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
}
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 :
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
# 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
}
Les redirecteurs (forwarders) permettent de diriger les requêtes DNS vers d'autres serveurs.
Types de redirecteurs :
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
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"
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
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
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 |
# === 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))
# === 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
}
}