Comment supprimer des groupes orphelins dans Azure AD à l'aide de Microsoft Graph PowerShell

Tout d'abord, nous devons installer le SDK Microsoft Graph PowerShell, qui a remplacé le module Azure AD PowerShell obsolète en 2024. Ouvrez PowerShell en tant qu'administrateur et installez les modules requis.

# Vérifier la version de PowerShell (doit être 7.2 ou supérieure)
$PSVersionTable.PSVersion

# Installer le SDK Microsoft Graph PowerShell
Install-Module Microsoft.Graph -Scope CurrentUser -Force

# Installer des modules spécifiques pour la gestion des groupes
Install-Module Microsoft.Graph.Groups -Scope CurrentUser -Force
Install-Module Microsoft.Graph.DirectoryObjects -Scope CurrentUser -Force

L'installation peut prendre plusieurs minutes car elle télécharge plusieurs sous-modules. Vous verrez des indicateurs de progression pour chaque composant en cours d'installation.

Vérifiez l'installation en vérifiant la version du module :

Get-Module Microsoft.Graph -ListAvailable | Select-Object Name, Version

Connectez-vous à Microsoft Graph en utilisant les autorisations appropriées pour la gestion des groupes. Cela remplace la commande Connect-AzureAD de l'ancien module.

# Connectez-vous à Microsoft Graph avec des autorisations de gestion des groupes
Connect-MgGraph -Scopes "Group.ReadWrite.All", "Directory.ReadWrite.All", "GroupMember.ReadWrite.All"

# Vérifiez la connexion et consultez le contexte actuel
Get-MgContext | Select-Object Account, Scopes, TenantId

Une fenêtre de navigateur s'ouvrira pour l'authentification. Connectez-vous avec votre compte d'administrateur global ou d'administrateur de groupes. Après une authentification réussie, vous verrez une confirmation dans la console PowerShell.

Confirmez que vous êtes connecté au bon locataire :

# Affichez les informations du locataire
Get-MgOrganization | Select-Object DisplayName, Id, VerifiedDomains

Nous allons maintenant identifier les groupes orphelins qui restent généralement après la suppression d'Azure AD Connect ou d'autres outils de synchronisation. Ces groupes ont souvent des caractéristiques spécifiques qui les rendent identifiables.

# Obtenez tous les groupes et filtrez pour les groupes potentiellement orphelins
$allGroups = Get-MgGroup -All -Property Id, DisplayName, Description, GroupTypes, SecurityEnabled, MailEnabled, OnPremisesSyncEnabled, CreatedDateTime

# Filtrez pour les groupes qui sont probablement orphelins (synchronisés sur site mais plus actifs)
$orphanedGroups = $allGroups | Where-Object {
    $_.OnPremisesSyncEnabled -eq $true -and
    $_.Description -like "*orphaned*" -or
    $_.DisplayName -like "*_*" -or
    $_.DisplayName -match "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
}

# Affichez les groupes potentiellement orphelins
$orphanedGroups | Select-Object DisplayName, Id, Description, CreatedDateTime | Format-Table -AutoSize

Cette commande identifie les groupes avec des caractéristiques communes aux orphelins : synchronisation sur site activée, noms de type GUID ou descriptions contenant "orphaned".

Pour une recherche plus complète, vérifiez les groupes sans membres :

# Vérifiez les groupes vides qui pourraient être orphelins
$emptyGroups = @()
foreach ($group in $allGroups) {
    $memberCount = (Get-MgGroupMember -GroupId $group.Id -All).Count
    if ($memberCount -eq 0) {
        $emptyGroups += $group
    }
}

$emptyGroups | Select-Object DisplayName, Id, CreatedDateTime | Format-Table -AutoSize

Avant de supprimer des groupes, créez une sauvegarde complète de leurs informations. Cela est crucial pour la récupération si vous supprimez accidentellement les mauvais groupes.

# Créer un répertoire de sauvegarde
$backupPath = "C:\AzureAD_GroupBackup_$(Get-Date -Format 'yyyyMMdd_HHmmss')"
New-Item -ItemType Directory -Path $backupPath -Force

# Exporter toutes les informations de groupe vers un fichier CSV
$allGroups | Export-Csv -Path "$backupPath\AllGroups_Backup.csv" -NoTypeInformation

# Exporter des informations détaillées pour chaque groupe orphelin
foreach ($group in $orphanedGroups) {
    $groupDetails = @{
        'GroupId' = $group.Id
        'DisplayName' = $group.DisplayName
        'Description' = $group.Description
        'GroupTypes' = $group.GroupTypes -join ','
        'SecurityEnabled' = $group.SecurityEnabled
        'MailEnabled' = $group.MailEnabled
        'CreatedDateTime' = $group.CreatedDateTime
        'OnPremisesSyncEnabled' = $group.OnPremisesSyncEnabled
    }
    
    # Obtenir les membres du groupe
    $members = Get-MgGroupMember -GroupId $group.Id -All
    $groupDetails['MemberCount'] = $members.Count
    $groupDetails['Members'] = ($members | ForEach-Object { $_.AdditionalProperties.displayName }) -join ';'
    
    # Exporter vers un fichier JSON individuel
    $groupDetails | ConvertTo-Json | Out-File -FilePath "$backupPath\Group_$($group.DisplayName -replace '[^a-zA-Z0-9]', '_').json"
}

Write-Host "Sauvegarde terminée à : $backupPath" -ForegroundColor Green

Cela crée un répertoire de sauvegarde horodaté avec des informations complètes sur les groupes, y compris les membres, les propriétés et les métadonnées.

Vérifiez que la sauvegarde a été créée avec succès :

Get-ChildItem $backupPath | Select-Object Name, Length, LastWriteTime

Effectuez une validation finale pour vous assurer que vous ne supprimez que des groupes véritablement orphelins. Cette étape empêche la suppression accidentelle de groupes actifs.

# Créer un rapport de validation
$validationReport = @()

foreach ($group in $orphanedGroups) {
    $validation = @{
        'GroupName' = $group.DisplayName
        'GroupId' = $group.Id
        'MemberCount' = (Get-MgGroupMember -GroupId $group.Id -All).Count
        'HasOwners' = (Get-MgGroupOwner -GroupId $group.Id -All).Count -gt 0
        'LastActivity' = 'Unknown' # Microsoft Graph ne fournit pas directement la dernière activité
        'IsMailEnabled' = $group.MailEnabled
        'IsSecurityGroup' = $group.SecurityEnabled
        'OnPremisesSync' = $group.OnPremisesSyncEnabled
        'RecommendDelete' = $false
    }
    
    # Déterminer si le groupe doit être supprimé en fonction des critères
    if ($validation.MemberCount -eq 0 -and 
        -not $validation.HasOwners -and 
        $validation.OnPremisesSync -eq $true) {
        $validation.RecommendDelete = $true
    }
    
    $validationReport += New-Object PSObject -Property $validation
}

# Afficher le rapport de validation
$validationReport | Format-Table GroupName, MemberCount, HasOwners, IsMailEnabled, RecommendDelete -AutoSize

# Afficher uniquement les groupes recommandés pour la suppression
$groupsToDelete = $validationReport | Where-Object { $_.RecommendDelete -eq $true }
Write-Host "Groupes recommandés pour la suppression : $($groupsToDelete.Count)" -ForegroundColor Yellow

Examinez attentivement le rapport de validation. Les groupes marqués avec RecommendDelete = $true répondent aux critères pour une suppression sécurisée.

Vérifiez manuellement des groupes spécifiques :

# Inspecter manuellement un groupe spécifique
$groupId = "your-group-id-here"
Get-MgGroup -GroupId $groupId | Select-Object DisplayName, Description, CreatedDateTime, OnPremisesSyncEnabled
Get-MgGroupMember -GroupId $groupId -All | Select-Object AdditionalProperties

Nous allons maintenant supprimer les groupes orphelins validés en utilisant le SDK Microsoft Graph PowerShell. Cela remplace le cmdlet Remove-AzureADGroup obsolète.

# Supprimer les groupes orphelins avec confirmation
$deletionLog = @()

foreach ($group in $groupsToDelete) {
    try {
        Write-Host "Tentative de suppression du groupe : $($group.GroupName)" -ForegroundColor Yellow
        
        # Supprimer le groupe
        Remove-MgGroup -GroupId $group.GroupId -Confirm:$false
        
        $logEntry = @{
            'GroupName' = $group.GroupName
            'GroupId' = $group.GroupId
            'DeletionTime' = Get-Date
            'Status' = 'Success'
            'Error' = $null
        }
        
        Write-Host "Supprimé avec succès : $($group.GroupName)" -ForegroundColor Green
        
    } catch {
        $logEntry = @{
            'GroupName' = $group.GroupName
            'GroupId' = $group.GroupId
            'DeletionTime' = Get-Date
            'Status' = 'Failed'
            'Error' = $_.Exception.Message
        }
        
        Write-Host "Échec de la suppression de $($group.GroupName) : $($_.Exception.Message)" -ForegroundColor Red
    }
    
    $deletionLog += New-Object PSObject -Property $logEntry
    Start-Sleep -Seconds 2  # Éviter la limitation de l'API
}

# Exporter le journal de suppression
$deletionLog | Export-Csv -Path "$backupPath\DeletionLog.csv" -NoTypeInformation

# Afficher le résumé
$successCount = ($deletionLog | Where-Object { $_.Status -eq 'Success' }).Count
$failedCount = ($deletionLog | Where-Object { $_.Status -eq 'Failed' }).Count

Write-Host "\nRésumé de la suppression :" -ForegroundColor Cyan
Write-Host "Supprimé avec succès : $successCount groupes" -ForegroundColor Green
Write-Host "Échecs de suppression : $failedCount groupes" -ForegroundColor Red

Pour une suppression plus sûre avec confirmation individuelle :

# Alternative : Supprimer avec confirmation individuelle
foreach ($group in $groupsToDelete) {
    $confirmation = Read-Host "Supprimer le groupe '$($group.GroupName)' ? (y/N)"
    if ($confirmation -eq 'y' -or $confirmation -eq 'Y') {
        Remove-MgGroup -GroupId $group.GroupId
        Write-Host "Supprimé : $($group.GroupName)" -ForegroundColor Green
    }
}

Vérifiez que les groupes orphelins ont été supprimés avec succès et effectuez les tâches de nettoyage.

# Vérifier que les groupes sont supprimés
Write-Host "Vérification des suppressions de groupes..." -ForegroundColor Cyan

$verificationResults = @()
foreach ($deletedGroup in ($deletionLog | Where-Object { $_.Status -eq 'Success' })) {
    try {
        $group = Get-MgGroup -GroupId $deletedGroup.GroupId -ErrorAction Stop
        $verificationResults += @{
            'GroupName' = $deletedGroup.GroupName
            'Status' = 'Still Exists'
            'Note' = 'Le groupe n'a pas été supprimé avec succès'
        }
    } catch {
        $verificationResults += @{
            'GroupName' = $deletedGroup.GroupName
            'Status' = 'Deleted Successfully'
            'Note' = 'Le groupe n'existe plus dans Azure AD'
        }
    }
}

# Afficher les résultats de la vérification
$verificationResults | ForEach-Object { New-Object PSObject -Property $_ } | Format-Table -AutoSize

# Vérifier s'il reste des groupes orphelins
Write-Host "\nVérification des groupes orphelins restants..." -ForegroundColor Cyan
$remainingGroups = Get-MgGroup -All -Property Id, DisplayName, OnPremisesSyncEnabled | Where-Object {
    $_.OnPremisesSyncEnabled -eq $true -and
    $_.DisplayName -like "*_*"
}

if ($remainingGroups.Count -gt 0) {
    Write-Host "Trouvé $($remainingGroups.Count) groupes potentiellement orphelins restants :" -ForegroundColor Yellow
    $remainingGroups | Select-Object DisplayName, Id | Format-Table -AutoSize
} else {
    Write-Host "Aucun groupe orphelin supplémentaire trouvé." -ForegroundColor Green
}

# Générer le rapport final
$finalReport = @{
    'TotalGroupsProcessed' = $orphanedGroups.Count
    'SuccessfulDeletions' = $successCount
    'FailedDeletions' = $failedCount
    'BackupLocation' = $backupPath
    'ProcessingDate' = Get-Date
}

$finalReport | ConvertTo-Json | Out-File -FilePath "$backupPath\FinalReport.json"

Write-Host "\nNettoyage terminé. Rapport final enregistré à : $backupPath\FinalReport.json" -ForegroundColor Green

Déconnectez-vous de Microsoft Graph une fois terminé :

# Déconnecter de Microsoft Graph
Disconnect-MgGraph
Write-Host "Déconnecté de Microsoft Graph" -ForegroundColor Green