© Ilyes Hamdane - CC BY-NC-ND 4.

Documentation - Création en masse d’utilisateurs Active

Directory (PowerShell)

Introduction

4.0
Dans le cadre de la gestion d’un environnement Active Directory, il est fréquent de devoir

ND
créer un grand nombre de comptes utilisateurs (nouveaux collaborateurs, comptes de test,
travaux pratiques, environnements de pré-production, etc.).​

C-
Réaliser ces opérations manuellement via les consoles graphiques peut être chronophage,
source d’erreurs et difficile à reproduire de manière cohérente.

-N
BY
Afin de répondre à ce besoin, ce script PowerShell a été conçu pour automatiser la
création en masse d’utilisateurs Active Directory, à partir d’une simple liste de noms.​

C
Il permet de standardiser :

-C
●​ la nomenclature des identifiants (sAMAccountName et UPN),
●​ le placement des comptes dans une OU spécifique,

NE
●​ l’application d’un mot de passe initial commun,
DA
●​ ainsi que l’obligation de changement de mot de passe à la première connexion.
M
SCHÉMA LOGIQUE
HA
ES
LY
-I
GÉ
TÉ
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Script :
Import-Module ActiveDirectory

# ================== PARAMÈTRES ==================

$TargetOU = "OU=production,OU=Utilisateurs,DC=test,DC=local"

4.0
$DefaultPassword = "T3ST123456!"
$UPNSuffix = "[Link]"

ND
$ChangePwdAtLogon = $true
# ===============================================

C-
# Mot de passe sécurisé

-N
$SecurePassword = ConvertTo-SecureString $DefaultPassword -AsPlainText

BY
-Force

C
# Liste des utilisateurs

-C
$Users = @"

NE
Itachi Uchiwa
Ichigo Kurosaki
DA
Sousuke Aizen
Roronoa Zoro
M

Eren Yeager
HA

"@ -split "`n"

ES

foreach ($User in $Users) {

LY
-I

if ($[Link]() -eq "") { continue }

GÉ

# Séparation NOM / Prénom

TÉ

$Parts = $[Link]() -split "\s+", 2

$LastNameRaw = $Parts[0]
RO

$FirstNameRaw = $Parts[1]
TP

# Login : première lettre du prénom + nom (minuscule)

EN

$FirstName = $[Link]()
$LastName = $[Link]()
M

$SamBase = $[Link](0,1) + $LastName

CU

# Gestion des doublons

DO

$Sam = $SamBase
$i = 2
while (Get-ADUser -Filter "SamAccountName -eq '$Sam'" -ErrorAction
SilentlyContinue) {

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

$Sam = "$SamBase$i"
$i++
}

$UPN = "$Sam@$UPNSuffix"
$DisplayName = "$FirstNameRaw $LastNameRaw"

4.0
try {

ND
New-ADUser `
-Name $DisplayName `

C-
-GivenName $FirstNameRaw `

-N
-Surname $LastNameRaw `

BY
-DisplayName $DisplayName `
-SamAccountName $Sam `

C
-UserPrincipalName $UPN `

-C
-Path $TargetOU `
-AccountPassword $SecurePassword `

NE
-Enabled $true ` DA
-ChangePasswordAtLogon $ChangePwdAtLogon
M
Write-Host "Créé : $DisplayName → $Sam" -ForegroundColor Green
HA

}
catch {
ES

Write-Host "Erreur pour $DisplayName : $($_.[Link])"

-ForegroundColor Red
LY

}
-I

}
GÉ

Paramètres du script (à adapter) :

TÉ

$TargetOU = "OU=production,OU=Utilisateurs,DC=test,DC=local"
RO

$DefaultPassword = "T3ST123456!"
$UPNSuffix = "[Link]"
TP

$ChangePwdAtLogon = $true
EN

$TargetOU : DN complet de l’OU où les comptes seront créés.

M

$DefaultPassword : mot de passe initial appliqué à tous les comptes.

CU

$UPNSuffix : suffixe UPN (souvent le domaine, ex: [Link]).

$ChangePwdAtLogon : si $true, l’utilisateur devra changer son mot de passe au premier
DO

login.
​

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Format attendu pour la liste d’utilisateurs

La variable $Users doit contenir 1 utilisateur par ligne, sous la forme :

NOM Prénom
NOM PrénomComposé

4.0
NOM-DOUBLE Prénom

ND
Exemple :

C-
$Users = @"
Sousuke Aizen

-N
Roronoa Zoro

BY
Eren Yeager
"@ -split "`n"

C
-C
Important : le script considère que le 1er mot = NOM et le reste = Prénom (grâce au -split
... , 2).

NE
DA
Fonctionnement global (logique)
M
Pour chaque ligne utilisateur :
HA

1.​ Ignore les lignes vides.

2.​ Sépare NOM et Prénom.​
ES
LY

3.​ Génère un login : première lettre du prénom + nom en minuscule​

Exemple : Sousuke Aizen → asousuke​
-I
GÉ

4.​ Vérifie si ce login existe déjà :

○​ si oui, ajoutez un compteur : asousuke2, asousuke3, etc.​
TÉ

5.​ Crée l’utilisateur dans l’OU cible (New-ADUser).

RO

6.​ Affiche un retour console “échec ou réussite”.

TP

Explication du code (bloc par bloc)

EN

1) Chargement du module AD
M

Import-Module ActiveDirectory
CU
DO

Charge les cmdlets* AD (Get-ADUser, New-ADUser, etc.). Sans ça, le script ne peut pas
interagir avec Active Directory.

cmdlets* : voir p.14

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

2) Définition des paramètres

$TargetOU = "OU=production,OU=Utilisateurs,DC=test,DC=local"
$DefaultPassword = "T3ST123456!"
$UPNSuffix = "[Link]"
$ChangePwdAtLogon = $true

4.0
Centralise les variables de configuration, pour éviter de modifier le script partout.

ND
3) Conversion du mot de passe en SecureString

C-
$SecurePassword = ConvertTo-SecureString $DefaultPassword -AsPlainText

-N
-Force

BY
“New-ADUser” “-AccountPassword” exige un SecureString*. Ici, on convertit une chaîne

C
“en clair” en SecureString.

-C
4) Déclaration de la liste d’utilisateurs​

$Users = @"
NE
DA
M
"@ -split "`n"
HA

Ce bloc permet d’écrire plusieurs utilisateurs directement dans le script, chacun sur
une ligne, de façon lisible et pratique.
ES
LY

@"
.
-I

"@
GÉ

Cela sert simplement à dire à PowerShell : « Tout ce qu’il y a entre ces deux marques est du
TÉ

texte, même s’il est écrit sur plusieurs lignes. »

RO

Chaque ligne = un utilisateur comme expliqué plus précédemment.

TP

-split "`n"
EN

Cette partie dit à PowerShell : « Coupe ce texte à chaque retour à la ligne. »

M

Résultat :
CU

●​ PowerShell transforme le bloc de texte en une liste

DO

●​ Chaque ligne devient un élément que le script va traiter un par un

SecureString* : voir p.14

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

C’est ce qui permet ensuite d’utiliser :

5) Boucle de traitement

foreach ($User in $Users)

4.0
Parcourt chaque entrée.

Ignore les lignes vides

ND
if ($[Link]() -eq "") { continue }

C-
-N
“Trim()” enlève les espaces ; si la ligne est vide, on passe à la suivante.

BY
6) Découpage NOM / Prénom

C
$Parts = $[Link]() -split "\s+", 2

-C
Cette ligne sert à séparer le NOM et le Prénom à partir d’une ligne de texte.

Exemple de ligne :
NE
DA
DUPONT Marie Claire
M
HA

"\s+"
ES

Cela veut dire : « Coupe le texte dès que tu rencontres un ou plusieurs espaces »
LY
-I

Que ce soit :
GÉ

●​ un espace
●​ deux espaces
TÉ

●​ ou plus
RO

2
TP

Cela veut dire : « Ne coupe qu’une seule fois »​

Donc :
EN
M

●​ la première partie = le NOM

●​ tout le reste = le Prénom
CU

Résultat, si on a : DUPONT Marie Claire

DO

PowerShell comprend :

●​ Nom → DUPONT
●​ Prénom → Marie Claire
Version : v1.0 — Date : [30/12/2025]
Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

À quoi servent ces deux lignes ?

$LastNameRaw = $Parts[0]
$FirstNameRaw = $Parts[1]

Elles servent à ranger correctement le nom et le prénom dans des variables séparées,

4.0
pour pouvoir les réutiliser facilement ensuite.

$LastNameRaw = $Parts[0] : Stocke le nom de famille dans une variable claire.

ND
$FirstNameRaw = $Parts[1] : Stocke le prénom (simple ou composé) dans une autre

C-
variable.

-N
7) Construction du login (SamAccountName)

BY
$FirstName = $[Link]()

C
$LastName = $[Link]()

-C
$SamBase = $[Link](0,1) + $LastName

NE
Mise en minuscule.
Substring(0,1) prend la première lettre du prénom.
DA
Concatène : a + sousuke = asousuke
M

8) Gestion des doublons

HA

$Sam = $SamBase
ES

$i = 2
while (Get-ADUser -Filter "SamAccountName -eq '$Sam'" -ErrorAction
LY

SilentlyContinue) {
-I

$Sam = "$SamBase$i"
GÉ

$i++
}
TÉ
RO

Tant qu’un utilisateur existe déjà avec ce SamAccountName, tu incrémentes.

Exemple :
TP

●​ asousuke existe → devient asousuke2

EN

●​ si asousuke 2 existe → asousuke3, etc.

M

9) Construction UPN + DisplayName

CU

$UPN = "$Sam@$UPNSuffix"
$DisplayName = "$FirstNameRaw $LastNameRaw"
DO

●​ UPN : asousuke@[Link]
●​ DisplayName : Sousuke Aizen (tel que fourni)​

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

10) Création AD + retour console

try {
New-ADUser `
-Name $DisplayName `
-GivenName $FirstNameRaw `

4.0
-Surname $LastNameRaw `
-DisplayName $DisplayName `

ND
-SamAccountName $Sam `
-UserPrincipalName $UPN `

C-
-Path $TargetOU `

-N
-AccountPassword $SecurePassword `
-Enabled $true `

BY
-ChangePasswordAtLogon $ChangePwdAtLogon

C
-C
Write-Host "Créé : $DisplayName → $Sam" -ForegroundColor Green
}

NE
catch {
Write-Host "Erreur pour $DisplayName : $($_.[Link])"
DA
-ForegroundColor Red
M
}
HA

-Name $DisplayName​
Nom “complet” de l’objet AD.​
ES

Exemple : Sousuke Aizen

LY

-GivenName $FirstNameRaw​
-I

Le prénom (champ “Given name” dans AD).​

Exemple : Aizen
GÉ

-Surname $LastNameRaw​
TÉ

Le nom de famille (champ “Surname” dans AD).​

RO

Exemple : Sousuke
TP

-DisplayName $DisplayName​
Le nom affiché dans l’annuaire (colonne “Display name”).
EN

-SamAccountName $Sam​
M

Le login Windows classique (format court), utilisé pour ouvrir session :​

CU

Exemple : asousuke, asousuke2, etc.​

Il doit être unique dans le domaine.
DO

-UserPrincipalName $UPN​
Le login au format “email-like” :​
Exemple : asousuke@[Link].

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

-Path $TargetOU​
L’endroit où est créé l’utilisateur (l’OU).​
Exemple : OU=production,OU=Utilisateurs,DC=test,DC=local

-AccountPassword $SecurePassword​
Le mot de passe initial du compte (au format SecureString).

4.0
-Enabled $true​
Active le compte immédiatement.

ND
-ChangePasswordAtLogon $ChangePwdAtLogon​

C-
Si $true, l’utilisateur devra changer son mot de passe à la première connexion.

-N
Les messages de sortie (vert / rouge)

BY
Si tout se passe bien (dans try)

C
Write-Host "Créé : $DisplayName → $Sam" -ForegroundColor Green

-C
Ça affiche un message en vert pour confirmer la création et montrer le login généré.

NE
DA
Si ça échoue (dans catch)
M
Write-Host "Erreur pour $DisplayName : $($_.[Link])"
HA

-ForegroundColor Red
ES

$($_.[Link]) = “le message d’erreur exact”

Ça aide à comprendre pourquoi ça a échoué (OU inexistante, droits insuffisants, mot de
LY

passe non conforme, etc.) et le script continue ensuite sur les autres utilisateurs au lieu de
-I

s’arrêter.
GÉ
TÉ
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Test de fonctionnement :
Étape 1 - Préparer l’environnement

Sur votre machine Windows Server faisant office de contrôleur de domaine Active
Directory (ou un poste avec les outils RSAT installés) :

4.0
1.​ Ouvrez un éditeur de texte (Bloc-notes, VS Code ou PowerShell ISE).​

ND
2.​ Copiez l’intégralité du script de création des utilisateurs.​

C-
3.​ Enregistrez le fichier sous le nom par exemple :

-N
Create-AD-Users.ps1

BY
Étape 2 - Renseigner la liste des utilisateurs

C
Dans le script, repérez la partie suivante :

-C
$Users = @"

NE
DA
"@ -split "`n"
M

Remplacez-la par votre liste d’utilisateurs, une personne par ligne, sous le format :
HA

NOM Prénom
ES

Exemple :
LY
-I

$Users = @"
DUPONT Marie
GÉ

MARTIN Jean
TÉ

BENALI Ahmed
"@ -split "`n"
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Étape 3 – Vérifier l’OU cible

Avant l’exécution, assurez-vous que l’OU indiquée dans la variable $TargetOU existe bien
dans Active Directory.

4.0
ND
C-
-N
BY
C
-C
NE
DA
M
HA
ES
LY

Adaptez le chemin en fonction de votre arborescence AD

-I
GÉ

Étape 4 – Ouvrir PowerShell

TÉ

1.​ Ouvrez PowerShell.

RO

2.​ Lancez PowerShell en tant qu’administrateur.

3.​ Placez-vous dans le dossier où se trouve le script :
TP

a.​ exemple cd C:\Scripts

EN

Étape 7 – Exécuter le script

M

Lancez le script avec la commande :

CU

.\Create-AD-Users.ps1
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Après avoir lancé le script, même si aucun message d’erreur n’est affiché, il est possible
que les utilisateurs n’apparaissent pas immédiatement dans la console graphique.

Pour y remédier ouvrez le gestionnaire de serveur > Outils > Utilisateurs et ordinateurs
Active Directory.

4.0
ND
C-
-N
BY
C
-C
NE
DA
M

Naviguez jusqu’à l’OU cible (exemple : Utilisateurs > production) > Faites un clic droit
HA

dans l’OU > Cliquez sur Actualiser

ES
LY
-I
GÉ
TÉ
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

4.0
ND
C-
-N
BY
C
-C
Les utilisateurs créés par le script devraient alors apparaître immédiatement.

NE
DA
M
HA
ES
LY
-I
GÉ
TÉ
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.
 © Ilyes Hamdane - CC BY-NC-ND 4.0

Définitions :

Qu’est-ce qu’une cmdlet Active Directory ?

Une cmdlet AD est une commande PowerShell spécialisée fournie par Microsoft pour
administrer Active Directory (utilisateurs, groupes, ordinateurs, OU, GPO, etc.).

4.0
-​ Le mot cmdlet vient de Command-let (petite commande).

ND
Ces cmdlets font partie du module PowerShell ActiveDirectory (RSAT).

C-
-N
SecureString : à quoi ça sert vraiment ?

BY
Un SecureString sert à protéger un secret en mémoire, pas à le hacher.

C
Ce que SecureString FAIT

-C
●​ Évite que le mot de passe reste en texte clair en mémoire

NE
●​ Chiffre la valeur en RAM
●​ Limite l’exposition du secret lors de l’exécution du script
DA
●​ Est requis par certaines cmdlets (comme New-ADUser -AccountPassword)
M

Ce que SecureString NE FAIT PAS

HA

●​ Ne calcule aucun hash

ES

●​ Ne remplace pas un mécanisme de stockage sécurisé

●​ Ne protège pas si le mot de passe est écrit en clair dans le script
LY
-I
GÉ
TÉ
RO
TP
EN
M
CU
DO

Version : v1.0 — Date : [30/12/2025]

Diffusion autorisée uniquement via LinkedIn (post original).
Toute autre utilisation est strictement interdite.