Tout d'abord, assurez-vous que le module Active Directory PowerShell est installé sur votre contrôleur de domaine. Ce module fournit les cmdlets nécessaires pour la surveillance de la santé d'AD.

Add-WindowsCapability -Online -Name Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0

Si vous exécutez cela sur une machine cliente Windows 10/11 au lieu d'un serveur, utilisez cette commande alternative :

Get-WindowsCapability -Name RSAT* -Online | Add-WindowsCapability -Online

Vérifiez que le module est installé et disponible :

Get-Module -Name ActiveDirectory -ListAvailable

Téléchargez le script complet Get-ADHealth.ps1 depuis le dépôt d'ALI TAJRAN. Ce script effectue des tests DCDiag, des vérifications de ping, une validation DNS et une surveillance des services.

# Créer le répertoire des scripts
New-Item -Path "C:\scripts" -ItemType Directory -Force

# Télécharger le script (remplacer par la méthode de téléchargement réelle)
Invoke-WebRequest -Uri "https://www.alitajran.com/active-directory-health-check-powershell-script/" -OutFile "C:\scripts\Get-ADHealth.ps1"

Débloquez le script téléchargé pour éviter les problèmes de politique d'exécution :

Unblock-File -Path "C:\scripts\Get-ADHealth.ps1"

Définissez la politique d'exécution pour autoriser l'exécution des scripts :

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Vérifiez que le script est prêt à être exécuté :

Get-Content "C:\scripts\Get-ADHealth.ps1" | Select-Object -First 10

Exécutez votre premier contrôle de santé pour tester la fonctionnalité du script et générer un rapport de référence. Cela vérifiera tous les contrôleurs de domaine dans votre forêt.

# Naviguer vers le répertoire des scripts
Set-Location "C:\scripts"

# Exécuter un contrôle de santé de base avec un rapport HTML
.\Get-ADHealth.ps1 -ReportFile

Pour un domaine spécifique uniquement :

.\Get-ADHealth.ps1 -DomainName "yourdomain.com" -ReportFile

Le script génère un rapport HTML avec un horodatage. Vérifiez la sortie :

# Lister les rapports générés
Get-ChildItem -Path "C:\scripts" -Filter "dc_health_report_*.html" | Sort-Object LastWriteTime -Descending

Ouvrez le dernier rapport pour examiner les résultats :

# Ouvrir le rapport le plus récent
$latestReport = Get-ChildItem -Path "C:\scripts" -Filter "dc_health_report_*.html" | Sort-Object LastWriteTime -Descending | Select-Object -First 1
Invoke-Item $latestReport.FullName

Modifiez le script pour envoyer des rapports par email automatisés. Ouvrez le fichier Get-ADHealth.ps1 et localisez la section des paramètres SMTP, puis personnalisez-la pour votre environnement.

# Modifiez le script pour configurer les paramètres SMTP
$smtpsettings = @{
    To = 'admin@yourdomain.com'
    From = 'adhealth@yourdomain.com'
    Subject = "Rapport de santé AD - $(Get-Date -Format 'yyyy-MM-dd HH:mm')"
    SmtpServer = "mail.yourdomain.com"
    Port = "25"
    # Credential = (Get-Credential)  # Décommentez pour l'authentification
    # UseSsl = $true                 # Décommentez pour SSL
}

Testez la fonctionnalité d'envoi d'email avant de planifier :

# Testez l'envoi d'email
Send-MailMessage -To "admin@yourdomain.com" -From "adhealth@yourdomain.com" -Subject "Test de santé AD" -Body "Email de test de la surveillance de la santé AD" -SmtpServer "mail.yourdomain.com"

Exécutez le script avec notification par email :

.\Get-ADHealth.ps1 -DomainName "yourdomain.com" -SendEmail

Vérifiez que l'email a été envoyé en consultant votre boîte de réception et la sortie PowerShell pour tout message d'erreur.

Améliorez la surveillance en ajoutant des fonctions personnalisées pour des composants AD spécifiques. Créez un script supplémentaire pour des vérifications supplémentaires.

# Créer des fonctions de santé AD personnalisées
function Test-ADReplication {
    param([string]$DomainController)
    
    $replStatus = repadmin /replsummary $DomainController
    $errors = $replStatus | Where-Object { $_ -match "error" }
    
    return @{
        DC = $DomainController
        HasErrors = ($errors.Count -gt 0)
        ErrorCount = $errors.Count
        Details = $replStatus
    }
}

function Test-SysvolReplication {
    $sysvolPath = "\\$env:COMPUTERNAME\SYSVOL"
    $accessible = Test-Path $sysvolPath
    
    return @{
        Path = $sysvolPath
        Accessible = $accessible
        LastWrite = if ($accessible) { (Get-Item $sysvolPath).LastWriteTime } else { "N/A" }
    }
}

function Test-ADServices {
    $services = @("ADWS", "DNS", "DFS Replication", "Intersite Messaging", "Kerberos Key Distribution Center", "NetLogon", "Active Directory Domain Services")
    $results = @()
    
    foreach ($service in $services) {
        $svc = Get-Service -DisplayName "*$service*" -ErrorAction SilentlyContinue
        if ($svc) {
            $results += @{
                ServiceName = $svc.DisplayName
                Status = $svc.Status
                StartType = $svc.StartType
            }
        }
    }
    return $results
}

Enregistrez ces fonctions dans un fichier séparé et testez-les :

# Enregistrer les fonctions dans un fichier
$functions | Out-File "C:\scripts\AD-CustomFunctions.ps1"

# Charger et tester les fonctions
. "C:\scripts\AD-CustomFunctions.ps1"

# Tester la réplication
Test-ADReplication -DomainController $env:COMPUTERNAME

# Tester SYSVOL
Test-SysvolReplication

# Tester les services
Test-ADServices

Configurez le Planificateur de tâches Windows pour exécuter automatiquement des vérifications de santé. Cela garantit une surveillance cohérente sans intervention manuelle.

# Créer une tâche planifiée pour les vérifications de santé quotidiennes
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -ExecutionPolicy Bypass -File 'C:\scripts\Get-ADHealth.ps1' -ReportFile -DomainName 'yourdomain.com'"

$trigger = New-ScheduledTaskTrigger -Daily -At "02:00AM"

$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable

$principal = New-ScheduledTaskPrincipal -UserId "SYSTEM" -LogonType ServiceAccount -RunLevel Highest

Enregistrez la tâche planifiée :

Register-ScheduledTask -TaskName "AD-HealthCheck-Daily" -Action $action -Trigger $trigger -Settings $settings -Principal $principal -Description "Surveillance quotidienne de la santé Active Directory"

Créez une vérification hebdomadaire complète avec email :

# Vérification hebdomadaire complète avec email
$weeklyAction = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -ExecutionPolicy Bypass -File 'C:\scripts\Get-ADHealth.ps1' -SendEmail -DomainName 'yourdomain.com'"

$weeklyTrigger = New-ScheduledTaskTrigger -Weekly -WeeksInterval 1 -DaysOfWeek Monday -At "06:00AM"

Register-ScheduledTask -TaskName "AD-HealthCheck-Weekly-Email" -Action $weeklyAction -Trigger $weeklyTrigger -Settings $settings -Principal $principal -Description "Vérification hebdomadaire de la santé AD avec notification par email"

Vérifiez que les tâches planifiées sont créées :

Get-ScheduledTask -TaskName "AD-HealthCheck*" | Format-Table TaskName, State, NextRunTime

Créer un système de journalisation centralisé pour suivre les résultats des vérifications de santé au fil du temps et mettre en œuvre des alertes pour les problèmes critiques.

# Créer une fonction de journalisation centralisée
function Write-ADHealthLog {
    param(
        [string]$Message,
        [string]$Level = "INFO",
        [string]$LogPath = "C:\logs\ADHealth.log"
    )
    
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "[$timestamp] [$Level] $Message"
    
    # S'assurer que le répertoire de journalisation existe
    $logDir = Split-Path $LogPath -Parent
    if (!(Test-Path $logDir)) {
        New-Item -Path $logDir -ItemType Directory -Force
    }
    
    # Écrire dans le fichier de journal
    Add-Content -Path $LogPath -Value $logEntry
    
    # Écrire également dans le journal des événements pour les problèmes critiques
    if ($Level -eq "ERROR" -or $Level -eq "CRITICAL") {
        Write-EventLog -LogName "Application" -Source "AD Health Monitor" -EventId 1001 -EntryType Error -Message $Message
    }
}

Créer une fonction d'alerte pour les problèmes critiques :

function Send-ADHealthAlert {
    param(
        [string]$AlertMessage,
        [string]$Severity = "High",
        [array]$Recipients = @("admin@yourdomain.com")
    )
    
    $subject = "[AD ALERT - $Severity] Problème de santé Active Directory"
    $body = @"
Alerte de santé Active Directory

Gravité : $Severity
Horodatage : $(Get-Date)
Contrôleur de domaine : $env:COMPUTERNAME

Détails du problème :
$AlertMessage

Veuillez enquêter immédiatement.
"@
    
    try {
        Send-MailMessage -To $Recipients -From "adalert@yourdomain.com" -Subject $subject -Body $body -SmtpServer "mail.yourdomain.com"
        Write-ADHealthLog "Alerte envoyée avec succès : $AlertMessage" "INFO"
    }
    catch {
        Write-ADHealthLog "Échec de l'envoi de l'alerte : $($_.Exception.Message)" "ERROR"
    }
}

Intégrer la journalisation dans vos vérifications de santé :

# Exemple d'intégration avec les résultats de DCDiag
$dcdiagResults = dcdiag /test:DNS /test:FSMOCheck /v

if ($dcdiagResults -match "failed") {
    $failedTests = $dcdiagResults | Where-Object { $_ -match "failed" }
    $alertMessage = "Les tests DCDiag ont échoué:`n" + ($failedTests -join "`n")
    
    Write-ADHealthLog $alertMessage "ERROR"
    Send-ADHealthAlert -AlertMessage $alertMessage -Severity "High"
}
else {
    Write-ADHealthLog "Tous les tests DCDiag ont réussi" "INFO"
}

Tester le système de journalisation et d'alerte :

# Tester la journalisation
Write-ADHealthLog "Entrée de journal de test" "INFO"

# Tester l'alerte
Send-ADHealthAlert -AlertMessage "Message d'alerte de test" -Severity "Low"

# Vérifier le fichier de journal
Get-Content "C:\logs\ADHealth.log" -Tail 5

Construisez un tableau de bord HTML simple qui affiche l'état de santé actuel d'AD et les tendances historiques. Cela fournit un aperçu visuel rapide de votre infrastructure AD.

# Créer une fonction de génération de tableau de bord
function New-ADHealthDashboard {
    param(
        [string]$OutputPath = "C:\scripts\dashboard.html",
        [int]$DaysHistory = 7
    )
    
    # Obtenir les contrôleurs de domaine actuels
    $domainControllers = Get-ADDomainController -Filter * | Select-Object Name, IPv4Address, OperatingSystem, IsGlobalCatalog
    
    # Obtenir les résultats récents des vérifications de santé
    $recentReports = Get-ChildItem "C:\scripts" -Filter "dc_health_report_*.html" | 
        Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-$DaysHistory) } |
        Sort-Object LastWriteTime -Descending
    
    # Générer le tableau de bord HTML
    $html = @"



    
    


    

        
Tableau de bord de santé Active Directory
        
Dernière mise à jour : $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')
    
    
    
Aperçu des contrôleurs de domaine
    
"@
    
    foreach ($dc in $domainControllers) {
        $pingResult = Test-Connection -ComputerName $dc.Name -Count 1 -Quiet
        $status = if ($pingResult) { "En ligne" } else { "Hors ligne" }
        
        $html += ""
    }
    
    $html += @"
        

        

            
Nom
Adresse IP
Système d'exploitation
Catalogue global
Statut
        
        
$($dc.Name)
$($dc.IPv4Address)
$($dc.OperatingSystem)
$($dc.IsGlobalCatalog)
$status
    
    
    
Rapports de santé récents
    

"@
    
    foreach ($report in $recentReports) {
        $html += "
$($report.Name) - $(($report.LastWriteTime).ToString('yyyy-MM-dd HH:mm'))
"
    }
    
    $html += @"
    
    
    

        
Métriques rapides
        
Total des DC : $($domainControllers.Count)
        
Catalogues globaux : $(($domainControllers | Where-Object IsGlobalCatalog).Count)
        
Rapports récents : $($recentReports.Count)
    


"@
    
    $html | Out-File -FilePath $OutputPath -Encoding UTF8
    Write-Host "Tableau de bord créé : $OutputPath"
}

Générez et visualisez le tableau de bord :

# Créer le tableau de bord
New-ADHealthDashboard

# Ouvrir le tableau de bord dans le navigateur
Invoke-Item "C:\scripts\dashboard.html"

Planifiez les mises à jour du tableau de bord :

# Ajouter la génération de tableau de bord à la tâche planifiée
$dashboardAction = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-NoProfile -ExecutionPolicy Bypass -Command 'New-ADHealthDashboard'"

$dashboardTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(5) -RepetitionInterval (New-TimeSpan -Hours 1)

Register-ScheduledTask -TaskName "AD-Dashboard-Update" -Action $dashboardAction -Trigger $dashboardTrigger -Settings $settings -Principal $principal