Comment importer en masse des utilisateurs Active Directory à partir d'un CSV en utilisant PowerShell

Tout d'abord, assurez-vous d'avoir installé le module PowerShell Active Directory. Sur Windows Server, il est préinstallé. Sur les machines clientes, vous avez besoin de RSAT (Remote Server Administration Tools).

Pour Windows 10/11, installez RSAT via Paramètres :

# Ouvrez Paramètres > Applications > Fonctionnalités facultatives > Ajouter une fonctionnalité
# Recherchez "RSAT: Active Directory Domain Services and Lightweight Directory Services Tools"
# Ou installez via PowerShell (exécutez en tant qu'administrateur) :
Get-WindowsCapability -Name RSAT* -Online | Add-WindowsCapability -Online

Une fois installé, ouvrez PowerShell en tant qu'administrateur et importez le module :

Import-Module ActiveDirectory

Vérifiez que le module a été chargé avec succès :

Get-Module ActiveDirectory

Vous devriez voir le module ActiveDirectory listé avec les informations de version. Si vous obtenez une erreur, redémarrez PowerShell et réessayez.

Créez un fichier CSV correctement formaté avec tous les attributs utilisateur requis. Les en-têtes de colonne doivent correspondre exactement à ce que votre script PowerShell attend.

Créez un fichier appelé users.csv avec cette structure :

FirstName,LastName,SamAccountName,Password,OU,Email,Description,Department,Title
John,Doe,jdoe,TempPass123!,"OU=Users,DC=contoso,DC=com",jdoe@contoso.com,Marketing Manager,Marketing,Manager
Jane,Smith,jsmith,TempPass456!,"OU=Users,DC=contoso,DC=com",jsmith@contoso.com,IT Specialist,IT,Specialist
Mike,Johnson,mjohnson,TempPass789!,"OU=IT,OU=Users,DC=contoso,DC=com",mjohnson@contoso.com,System Administrator,IT,Administrator

Enregistrez le fichier avec l'encodage UTF-8 pour éviter les problèmes de caractères. Dans Notepad, utilisez Enregistrer sous et sélectionnez "UTF-8" dans le menu déroulant d'encodage.

Vérifiez la structure de votre CSV :

Import-Csv -Path "C:\users.csv" | Format-Table

Testez que vos chemins OU existent :

Get-ADOrganizationalUnit -Filter "Name -eq 'Users'"

Avant d'exécuter l'importation en masse, vérifiez que votre environnement est correctement configuré et que vous disposez des autorisations nécessaires.

Testez la connectivité de votre domaine :

# Test de la connectivité du contrôleur de domaine
Test-ComputerSecureChannel -Verbose

# Vérifiez que vous pouvez interroger Active Directory
Get-ADDomain

Vérifiez les autorisations de votre utilisateur actuel :

# Obtenez votre contexte utilisateur actuel
whoami

# Testez si vous pouvez créer des utilisateurs (essayez de créer un utilisateur de test)
$TestPassword = ConvertTo-SecureString "TempTest123!" -AsPlainText -Force
New-ADUser -Name "TestUser" -SamAccountName "testuser" -AccountPassword $TestPassword -WhatIf

Le paramètre -WhatIf montre ce qui se passerait sans réellement créer l'utilisateur. Si vous ne voyez pas d'erreurs, vous avez les autorisations requises.

Vérifiez que vos UO cibles existent et sont accessibles :

# Listez toutes les UO pour vérifier les chemins
Get-ADOrganizationalUnit -Filter * | Select-Object Name, DistinguishedName | Sort-Object Name

Créez un script PowerShell complet qui gère les erreurs, vérifie les doublons et fournit une journalisation détaillée. Enregistrez ceci sous Import-ADUsers.ps1 :

# Import-ADUsers.ps1
# Importation en masse des utilisateurs Active Directory à partir de CSV

param(
    [Parameter(Mandatory=$true)]
    [string]$CSVPath,
    [string]$LogPath = "C:\ADImport.log"
)

# Importer le module requis
Import-Module ActiveDirectory -ErrorAction Stop

# Initialiser les compteurs
$SuccessCount = 0
$FailureCount = 0
$SkippedCount = 0

# Commencer la journalisation
Start-Transcript -Path $LogPath -Append
Write-Host "Début de l'importation des utilisateurs AD depuis : $CSVPath" -ForegroundColor Green
Write-Host "Fichier journal : $LogPath" -ForegroundColor Yellow

try {
    # Importer le fichier CSV
    $ADUsers = Import-Csv -Path $CSVPath -ErrorAction Stop
    Write-Host "Trouvé $($ADUsers.Count) utilisateurs dans le fichier CSV" -ForegroundColor Cyan
    
    # Traiter chaque utilisateur
    foreach ($User in $ADUsers) {
        $Username = $User.SamAccountName
        
        try {
            # Vérifier si l'utilisateur existe déjà
            $ExistingUser = Get-ADUser -Filter {SamAccountName -eq $Username} -ErrorAction SilentlyContinue
            
            if ($ExistingUser) {
                Write-Warning "L'utilisateur $Username existe déjà. Passage..."
                $SkippedCount++
                continue
            }
            
            # Préparer les attributs de l'utilisateur
            $UserParams = @{
                SamAccountName = $Username
                UserPrincipalName = "$Username@$((Get-ADDomain).DNSRoot)"
                Name = "$($User.FirstName) $($User.LastName)"
                GivenName = $User.FirstName
                Surname = $User.LastName
                EmailAddress = $User.Email
                Path = $User.OU
                AccountPassword = (ConvertTo-SecureString $User.Password -AsPlainText -Force)
                Enabled = $true
                ChangePasswordAtLogon = $true
                Description = $User.Description
                Department = $User.Department
                Title = $User.Title
            }
            
            # Créer l'utilisateur
            New-ADUser @UserParams -ErrorAction Stop
            Write-Host "✓ Utilisateur créé avec succès : $Username" -ForegroundColor Green
            $SuccessCount++
            
        } catch {
            Write-Error "✗ Échec de la création de l'utilisateur $Username`: $($_.Exception.Message)"
            $FailureCount++
        }
    }
    
} catch {
    Write-Error "Erreur critique : $($_.Exception.Message)"
    exit 1
}

# Afficher le résumé
Write-Host "`n=== RÉSUMÉ DE L'IMPORTATION ===" -ForegroundColor Magenta
Write-Host "Réussi : $SuccessCount" -ForegroundColor Green
Write-Host "Échoué : $FailureCount" -ForegroundColor Red
Write-Host "Passé : $SkippedCount" -ForegroundColor Yellow
Write-Host "Total traité : $($SuccessCount + $FailureCount + $SkippedCount)" -ForegroundColor Cyan

Stop-Transcript

Rendez le script exécutable et testez-le :

# Tester le script avec WhatIf (exécution à sec)
.\Import-ADUsers.ps1 -CSVPath "C:\users.csv" -WhatIf

Exécutez le script d'importation avec une gestion des erreurs et une surveillance appropriées. Commencez toujours par un petit lot de test avant d'importer des centaines d'utilisateurs.

Tout d'abord, créez un CSV de test avec seulement 2-3 utilisateurs :

# Créer un sous-ensemble de test
$TestUsers = Import-Csv -Path "C:\users.csv" | Select-Object -First 3
$TestUsers | Export-Csv -Path "C:\users-test.csv" -NoTypeInformation

Exécutez l'importation de test :

# Exécuter le script d'importation
.\Import-ADUsers.ps1 -CSVPath "C:\users-test.csv" -LogPath "C:\ADImport-test.log"

Surveillez attentivement la sortie. Vous devriez voir un retour d'information en temps réel pour chaque tentative de création d'utilisateur. Vérifiez le fichier journal pour des informations détaillées :

# Examiner le fichier journal
Get-Content "C:\ADImport-test.log" | Select-Object -Last 20

Si l'importation de test réussit, procédez à l'importation complète :

# Importation complète
.\Import-ADUsers.ps1 -CSVPath "C:\users.csv" -LogPath "C:\ADImport-full.log"

Pour les importations très importantes, procédez par lots :

# Traiter par lots de 100
$AllUsers = Import-Csv -Path "C:\users.csv"
$BatchSize = 100

for ($i = 0; $i -lt $AllUsers.Count; $i += $BatchSize) {
    $Batch = $AllUsers | Select-Object -Skip $i -First $BatchSize
    $BatchFile = "C:\users-batch-$($i/$BatchSize + 1).csv"
    $Batch | Export-Csv -Path $BatchFile -NoTypeInformation
    
    Write-Host "Traitement du lot $($i/$BatchSize + 1)..."
    .\Import-ADUsers.ps1 -CSVPath $BatchFile
    
    Start-Sleep -Seconds 10  # Pause brève entre les lots
}

Après l'importation, vérifiez soigneusement que tous les utilisateurs ont été créés correctement avec les attributs et paramètres appropriés.

Vérifiez le nombre total d'utilisateurs créés :

# Compter les utilisateurs dans votre OU cible
$TargetOU = "OU=Users,DC=contoso,DC=com"
$ImportedUsers = Get-ADUser -Filter * -SearchBase $TargetOU
Write-Host "Total des utilisateurs dans l'OU : $($ImportedUsers.Count)" -ForegroundColor Cyan

Vérifiez que les attributs spécifiques des utilisateurs correspondent à vos données CSV :

# Vérification détaillée des utilisateurs importés
$CSVData = Import-Csv -Path "C:\users.csv"

foreach ($CSVUser in $CSVData) {
    $ADUser = Get-ADUser -Identity $CSVUser.SamAccountName -Properties EmailAddress, Department, Title, Description -ErrorAction SilentlyContinue
    
    if ($ADUser) {
        Write-Host "✓ Utilisateur : $($ADUser.SamAccountName)" -ForegroundColor Green
        Write-Host "  Email : $($ADUser.EmailAddress)" -ForegroundColor Gray
        Write-Host "  Département : $($ADUser.Department)" -ForegroundColor Gray
        Write-Host "  Titre : $($ADUser.Title)" -ForegroundColor Gray
        Write-Host "  Activé : $($ADUser.Enabled)" -ForegroundColor Gray
    } else {
        Write-Host "✗ Utilisateur non trouvé : $($CSVUser.SamAccountName)" -ForegroundColor Red
    }
}

Testez l'authentification des utilisateurs (optionnel, mais recommandé pour quelques comptes de test) :

# Tester l'authentification pour un utilisateur spécifique
$TestUser = "jdoe"
$TestPassword = "TempPass123!"

try {
    $SecurePassword = ConvertTo-SecureString $TestPassword -AsPlainText -Force
    $Credential = New-Object System.Management.Automation.PSCredential($TestUser, $SecurePassword)
    
    # Cela réussira si l'utilisateur peut s'authentifier
    Get-ADUser -Identity $TestUser -Credential $Credential -ErrorAction Stop
    Write-Host "✓ Test d'authentification réussi pour $TestUser" -ForegroundColor Green
} catch {
    Write-Host "✗ Test d'authentification échoué pour $TestUser`: $($_.Exception.Message)" -ForegroundColor Red
}

Générez un rapport de synthèse :

# Créer un rapport de vérification
$ReportPath = "C:\ADImport-Report.csv"
$ImportedUsers | Select-Object Name, SamAccountName, EmailAddress, Department, Title, Enabled, Created | 
    Export-Csv -Path $ReportPath -NoTypeInformation

Write-Host "Rapport de vérification enregistré à : $ReportPath" -ForegroundColor Yellow

Après la création réussie d'un utilisateur, vous devrez peut-être configurer des paramètres supplémentaires tels que les appartenances à des groupes, les répertoires personnels ou les chemins de profil. Cette étape gère la configuration post-création.

Ajoutez des utilisateurs à des groupes de sécurité en fonction de leur département ou rôle :

# Ajouter des utilisateurs à des groupes basés sur des données CSV
$CSVData = Import-Csv -Path "C:\users.csv"

foreach ($User in $CSVData) {
    $Username = $User.SamAccountName
    $Department = $User.Department
    
    try {
        # Ajouter au groupe spécifique au département
        $GroupName = "$Department-Users"
        
        # Vérifier si le groupe existe
        $Group = Get-ADGroup -Filter "Name -eq '$GroupName'" -ErrorAction SilentlyContinue
        
        if ($Group) {
            Add-ADGroupMember -Identity $GroupName -Members $Username -ErrorAction Stop
            Write-Host "✓ Ajouté $Username au groupe $GroupName" -ForegroundColor Green
        } else {
            Write-Warning "Le groupe $GroupName n'existe pas. Ignorer l'attribution de groupe pour $Username"
        }
        
        # Ajouter tous les utilisateurs à un groupe commun
        Add-ADGroupMember -Identity "All-Users" -Members $Username -ErrorAction SilentlyContinue
        
    } catch {
        Write-Error "Échec de l'ajout de $Username aux groupes : $($_.Exception.Message)"
    }
}

Configurer les répertoires personnels (si nécessaire) :

# Définir les répertoires personnels
$HomeDirectoryBase = "\\fileserver\home$"

foreach ($User in $CSVData) {
    $Username = $User.SamAccountName
    $HomeDirectory = "$HomeDirectoryBase\$Username"
    
    try {
        # Définir le chemin du répertoire personnel
        Set-ADUser -Identity $Username -HomeDirectory $HomeDirectory -HomeDrive "H:"
        Write-Host "✓ Définir le répertoire personnel pour $Username`: $HomeDirectory" -ForegroundColor Green
        
        # Créer le répertoire (nécessite des autorisations appropriées)
        if (!(Test-Path $HomeDirectory)) {
            New-Item -Path $HomeDirectory -ItemType Directory -Force
            # Définir les autorisations (exemple - ajuster pour votre environnement)
            icacls $HomeDirectory /grant "$Username:(OI)(CI)F" /T
        }
        
    } catch {
        Write-Error "Échec de la configuration du répertoire personnel pour $Username`: $($_.Exception.Message)"
    }
}

Définir les politiques de mot de passe et l'expiration du compte si nécessaire :

# Configurer les politiques de compte
foreach ($User in $CSVData) {
    $Username = $User.SamAccountName
    
    try {
        # Définir l'expiration du compte dans 90 jours (exemple)
        $ExpirationDate = (Get-Date).AddDays(90)
        Set-ADUser -Identity $Username -AccountExpirationDate $ExpirationDate
        
        # Exiger le changement de mot de passe à la prochaine connexion
        Set-ADUser -Identity $Username -ChangePasswordAtLogon $true
        
        Write-Host "✓ Configuré les politiques de compte pour $Username" -ForegroundColor Green
        
    } catch {
        Write-Error "Échec de la définition des politiques de compte pour $Username`: $($_.Exception.Message)"
    }
}

Vérification finale de toutes les configurations :

# Vérification complète
$VerificationResults = @()

foreach ($User in $CSVData) {
    $Username = $User.SamAccountName
    $ADUser = Get-ADUser -Identity $Username -Properties MemberOf, HomeDirectory, AccountExpirationDate -ErrorAction SilentlyContinue
    
    $Result = [PSCustomObject]@{
        Username = $Username
        Exists = ($ADUser -ne $null)
        GroupCount = ($ADUser.MemberOf | Measure-Object).Count
        HomeDirectory = $ADUser.HomeDirectory
        ExpirationDate = $ADUser.AccountExpirationDate
        Enabled = $ADUser.Enabled
    }
    
    $VerificationResults += $Result
}

# Afficher les résultats
$VerificationResults | Format-Table -AutoSize

# Exporter le rapport final
$VerificationResults | Export-Csv -Path "C:\ADImport-Final-Report.csv" -NoTypeInformation