Vous avez écrit un joli script avec Windows Forms (ou pas) et vous vous agacez de voir une fenêtre powershell s'ouvrir en même temps que vos fenêtres Windows Forms lors de l'exécution ?
Rien de plus facile ! PS2EXE !
Convertissez votre script en .exe !

1) Installer PS2EXE :
- Ouvrez PowerShell en mode Administrateur, puis tappez :

Install-Module ps2exe

- Acceptez pour tout ce qui vous sera demandé (de toute façon, vous n'avez pas le choix !)

2) A présent, vous pouvez ouvrir Win-PS2EXE

Win-PS2EXE

3) Choisissez votre script powershell (.ps1) à convertir, et choisissez un nom pour l'export en .exe
Enfin, si vous avez utilisé Windows Forms pour votre script, je vous conseille de cocher les mêmes cases que moi, autrement, vous allez avoir quelques surprises...

J'attire tout de même votre attention sur un point crucial : le code powershell d'un programme est très facilement lisible dans un .exe ..
(à méditer... avant de switcher vers une formation dev !)

Voilà un outil ultra basique que j'utilise en permanence : transformer mes scripts pour avoir un affichage graphique un peu plus sympa !

Les 2 exemples sont des extraits de mon script de réplication de labos Hyper-V :

Exemple 1 :
1) Je veux poser une question simple à l'utilisateur.
2) S'il répond non, le script lui affiche une nouvelle fenêtre et lui propose de remédier à la situation avant de recommencer puis quitte

- D'abord, on indique la ligne suivant en haut de chaque script qui contiendra de l'affichage Windows Forms :

Add-Type -AssemblyName System.Windows.Forms

- Le code des fenêtres :

# (1) Avez-vous placé les VM non compressées dans C:\LABOVM ?
$response1 = [System.Windows.Forms.MessageBox]::Show('Avez-vous placé les VM non compressées dans C:\LABOVM ?', 'Vérification des pré-requis', [System.Windows.Forms.MessageBoxButtons]::YesNo)
if ($response1 -eq 'No') {
    # (4) Veuillez procéder à l'action demandée puis ré-exécuter ce script
    [System.Windows.Forms.MessageBox]::Show('Veuillez procéder à l`action demandée puis ré-exécuter ce script')
    exit
}

Voici le résultat lors de l'exécution :

Et si je clique sur Oui (ou tappe ENTRER) :

Exemple 2 :
1) je veux créer un formulaire qui demande à l'utilisateur d'entrer le nom d'un labo
(là, le code est déjà bien plus dégueulasse...)

Voici le code :

# Veuillez nommer le LABO (exemple : TP06)
$form8 = New-Object System.Windows.Forms.Form
$form8.Text = 'Nom du LABO'
$form8.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen  # Cette ligne centre la fenêtre
$form8.AutoSize = $true
$form8.AutoSizeMode = [System.Windows.Forms.AutoSizeMode]::GrowAndShrink
$textBox8 = New-Object System.Windows.Forms.TextBox
$textBox8.Location = New-Object System.Drawing.Point(10, 10)
$textBox8.Size = New-Object System.Drawing.Size(200, 20)
$form8.Controls.Add($textBox8)
$buttonOk = New-Object System.Windows.Forms.Button
$buttonOk.Text = 'OK'
$buttonOk.Location = New-Object System.Drawing.Point(220, 10)
$buttonOk.Size = New-Object System.Drawing.Size(50, 20)
$buttonOk.DialogResult = [System.Windows.Forms.DialogResult]::OK
$form8.Controls.Add($buttonOk)
$form8.AcceptButton = $buttonOk
$form8.ShowDialog()
$LABNAME = $textBox8.Text

Voici le résultat lors de l'exécution :

Pour aller plus loin, regardez le mini-article pour convertir votre joli script graphique en .exe !

Dans un script, lorsque ce dernier demande à l'utilisateur de choisir et d'entrer une lettre pour déclencher une action, il peut parfois être très utile de rendre la réponse de l'utilisateur insensible à la casse (majuscules/minuscules).

Exemple, l'utilisateur doit rentrer la lettre "O" (pour oui).. S'il entre "o", ça ne fonctionne pas, puisque les systèmes Unix sont sensibles à la casse.

La commande "shopt" est très utile pour régler le problème :

shopt -s nocasematch # Activer la correspondance sans tenir compte de la casse

read -p "Voulez-vous continuer ? (O/N) : " reponse

case $reponse in
    O) 
        echo "Vous avez choisi Oui."
        ;;
    N)
        echo "Vous avez choisi Non."
        ;;
    *)
        echo "Choix invalide."
        ;;
esac

shopt -u nocasematch # Désactiver la correspondance sans tenir compte de la casse

Voici un petit script amusant pour obtenir la taille de tous les éléments se trouvant dans le même répertoire que le script.
Il suffit de placer le script dans un dossier dont on veut avoir la taille précise de chaque élément s'y trouvant, on l'exécute, un fichier de bilan apparaît dans ce dossier, avec le noms des éléments et leur taille en Ko, Mo, Go, du plus lourd au plus léger.

clear
Write-Output "####################################################################################" > $PSScriptRoot\bilan-tailles.txt
Write-Output "#      Taille de chaque élément présent dans le dossier où se situe le script      #" >> $PSScriptRoot\bilan-tailles.txt
Write-Output "####################################################################################" >> $PSScriptRoot\bilan-tailles.txt
Write-Output " "

Get-ChildItem $PSScriptRoot | Sort-Object Length -Descending | Select-Object FullName, @{name='Size';expression={ switch ($_.length) { { $_ -gt 1gb } { '{0:N2}GB' -f ($_ / 1gb); break } { $_ -gt 1mb } { '{0:N2}MB' -f ($_ / 1mb); break } { $_ -gt 1kb } { '{0:N2}KB' -f ($_ / 1Kb); break } default { '{0}B ' -f $_ } } }} >> $PSScriptRoot\bilan-tailles.txt

Voici ce que donne le fichier bilan-tailles.txt généré par l'exécution du script :

####################################################################################
#      Taille de chaque élément présent dans le dossier où se situe le script      #
####################################################################################

FullName                                                                         Size    
--------                                                                         ----    
C:\Users\Administrateur\Desktop\Taille\global-DEB4.sh                            282,74KB
C:\Users\Administrateur\Desktop\Taille\taille-de-tous-elements-dun-dossier.ps1   796B    
C:\Users\Administrateur\Desktop\Taille\bilan-tailles.txt                         518B    
C:\Users\Administrateur\Desktop\Taille\setup-02954-Le_Livre_de_Lulu-PCDOSBox.exe 0B      
C:\Users\Administrateur\Desktop\Taille\COMMANDES                                 1B      
C:\Users\Administrateur\Desktop\Taille\CV                                        1B      

Le script s'appelle "taille-de-tous-elements-dun-dossier.ps1"

Après les scripts de création des utilisateurs, voici celui qui s'occupe de tout (création des unités d'organisation (OU) ET des utilisateurs)

Bien entendu, il s'agît d'un mini-script basique (qui ne vérifie rien du tout !)
A vous de l'améliorer ! Et il ne manquera plus que les GG et les DL !

On part d'un fichier CSV de type :

PRENOM;NOM;DEPARTEMENT
Henri;dubas;DIRECTION
pierre;abernaty;RH
josé;lemoine;R&D
andréa;claire;MARKETING
marion;games;ACCUEIL
Julie;lecointre;R&D
Anthony;dilly;SAV
Amaury;De villenave;RH
Julie;mathieu;MARKETING
mathieu;saintclair;MARKETING

Voici le script :

# Comme toujours, on commence par importer le fichier csv
$contenu_csv = Import-Csv -Path "C:\Users\Administrateur\Desktop\liste-collaborateurs.csv" -Delimiter ";"

# Puis, on récupère les informations de chaque ligne du fichier .csv et on traîte !
foreach ($ligne in $contenu_csv)
{
    # Récupération du nom, prénom et département de chaque utilisateur 
    $nom=$ligne.NOM    
    $prenom=$ligne.PRENOM
    $OU=$ligne.DEPARTEMENT

    # Créer l'OU correspondante à l'utilisateur avant de créer l'utilisateur.
    # Vous noterez la présence de -ErrorAction SilentlyContinue, qui sans cela, arrêterait l'exécution du script dès qu'il tombe sur une OU déjà existante
    New-ADOrganizationalUnit -Name $OU -Path "OU=ENTREPRISE,DC=COMPUSET,DC=LOCAL" -ProtectedFromAccidentalDeletion $false -ErrorAction SilentlyContinue

    # La création de l'utilisateur :
    New-ADUser -Name "$($prenom) $($nom)" -Surname "$($nom)" -GivenName "$($prenom)" -SamAccountName "$($prenom[0]).$($nom)" -UserPrincipalName "$($prenom).$($nom)@COMPUSET.LOCAL" -path "OU=$($OU),OU=ENTREPRISE,DC=COMPUSET,DC=LOCAL" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true
}

Vous noterez que je place toutes les OU qui seront créées à l'intérieur d'une OU nommée "ENTREPRISE", pour plus de lisibilité sous le domaine. Cette OU "ENTREPRISE" peut évidemment être créée automatiquement...
Libre à vous de l'ajouter au script ou de le faire manuellement avant !

En PowerShell, l'opération est "simple", puisqu'une commande existe (Import-Csv)
En Bash, ce n'est pas plus compliqué ! Voici comment faire !

Pour ce script ultra basique, nous allons créer tous les utilisateurs linux à partir d'un fichier CSV (nommé fichier.csv pour l'exemple) comme ci-dessous :

sheldon,AbzGhjeZl,/home/sheldon
artigue,gefok33gPl,/home/artigue
pirate,Eerinpin34,/home/pirate
antoine,Zbpinr254g,/home/drog22
radjish,BQINDzpinfbin3,/home/radd

A gauche, nous avons le prénom de l'utilisateur à créer, au milieu son mot de passe, à droite le chemin de son répertoire personnel..
Notez que j'ai volontairement changé le nom du répertoire personnel pour les 2 derniers (bah oui, on peut !)

Comme il s'agît d'un fichier .csv, j'ai laissé la virgule en tant que délimiteur par défaut, mais rien ne vous empêche de mettre le caractère de votre choix dans le fichier csv !
Vous veillerez simplement à changer le caractère indiqué dans la variable IFS du script qui suit

Vous remarquez qu'à la différence de PowerShell, la première ligne n'est pas réservée au nommage des colonnes (que vous pouvez directement récupérer ensuite grâce aux fonctions).
En Bash, on entre directement les données !

Voici comment se composera donc ce script !

#!/bin/bash

clear

while IFS="," read -r username passwd homepath
do
	useradd -d "$homepath" -m -p "$passwd" "$username"

done < <(cat /chemin/fichier.csv)

Nous faisons une simple boucle, en prenant soin d'indiquer dans la variable IFS le caractère délimiteur de chaque colonne.
Puis nous faisons une lecture récursive de toutes les données, ligne par ligne, en déclarant les variables (username passwd et homepath) qui contiendront la valeur de chaque donnée de chaque colonne.

Enfin, à chaque fin de ligne, les 3 variables étant remplies des informations nécessaires pour créer l'utilisateur, nous créons l'utilisateur avec la commande useradd !

Attention, l'espace entre les 2 < à la fin est volontaire !!

Pas bien compliqué hein ?

La commande "sort" est très utile pour réorganiser un fichier texte.

Pour réorganiser un fichier par ordre alphabétique :

sort fichier

La commande va afficher le contenu du fichier, réorganisé de A à Z
Pour inverser cet ordre :

sort -r fichier

Pour réorganiser un fichier rempli de valeurs numériques (genre des listes d'IP), la commande précédente va réorganiser en fonction du premier caractère. Nous aurons 21.xxx et 213.xxx qui se suivront...
Pour réorganiser de façon propre lorsqu'il s'agît de nombres :

sort -g fichier

Admettons enfin que votre fichier texte comporte un nombre, un espace et une chaîne de caractère.
(exemple :)

213 john Davis
643 pierre Mark
790 antoine Plumel
112 marcel Duchamps

Pour demander un rangement dans l'ordre alphabétique selon les prénoms :

sort -k 2 fichier

l'option "k" étant le séparateur (l'espace), le nombre 2 le numéro du champs - celui des prénoms donc !).
Pour demander un rangement dans l'ordre alphabétique selon les noms cette fois :

sort -k 3 fichier

Enfin, pour vérifier si un fichier est correctement réorganisé :

check -c fichier

Enfin, pour enregistrer le fruit de votre réorganisation, n'oubliez pas de rediriger la sortie vers un second fichier :

sort -k 2 fichier > fichier2

sur XFCE :

xfce4-terminal --command="vi /tmp/exemple.txt"

Le résultat est l'affichage d'un terminal avec le contenu du fichier exemple.txt

Le sujet de sed est très vaste !!
En plus de cela, la syntaxe est assez différente entre BASH et SH...
Ici, on parle SH !
Je ne fais d'ailleurs pas d'article pour sed en BASH, il y a de nombreuses bibles sur le net !

Je vais rappeler les cas de figure qui me semblent les plus basiques et les plus importants quand on commence à faire du script en SH !!
En effet, je me suis décidé à écrire ce mini-article car la syntaxe correcte de sed en SH est particulièrement difficile à trouver sur internet.
Vous vous rendrez vite compte que les 3/4 des trucs du net concernent la commande sed en BASH, et que bien souvent, même en BASH, ça ne fonctionne pas/plus !!

Remplacer une chaîne de caractères spécifique dans un fichier.
Vous cherchez "perdu" et vous voulez le remplacer par "trouvé" (c'est un exemple bien sûr !!) dans un fichier texte /tmp/exemple.txt

sed -i "" "s/perdu/trouvé/" /tmp/exemple.txt

Attention, la commande va remplacer automatiquement CHAQUE ITERATION de "perdu" par "trouvé" !
Autrement dit, si le mot "perdu" se trouve à plusieurs endroits dans le fichier, la commande va remplacer "perdu" par "trouvé" à chaque fois !
A manier avec précaution donc !

Notez qu'en BASH, -i n'est pas suivi des double-guillemets ""... en SH si !

Que faire si ce que vous souhaitez remplacer comporte des caractères spéciaux ?
genre "/" (il y en a plein d'autres ! à vous de les découvrir !!)
Vous devez utiliser l'anti-slash devant chacun de ces caractères.
Exemple, je veux remplacer l'URL : http://perdu.com par http://jaitrouve.fr du fichier /tmp/exemple.txt

sed -i "" "s/http:\/\/perdu.com/http:\/\/jaitrouve.fr/" /tmp/exemple.txt

Tout de suite, ça commence à devenir plus chiant hein ?
Si vous commencez, dîtes-vous que vous n'êtes qu'au début... lorsqu'il y aura des wildcards, ce sera beaucoup plus marrant !

Remplacer la ligne numéro 23 du fichier exemple.txt par une chaîne de caractères (par autre chose donc !).
Là, c'est clairement une syntaxe précise de SH ! Attention !

sed -i "" '23 s/^.*$/nimporte nawak/' /tmp/exemple.txt

Ajouter plusieurs lignes de chaînes de caractères à un emplacement précis d'un fichier (/tmp/exemple.txt).
Comment aller à la ligne donc ? ... tout simplement en ajoutant \n lorsque vous voulez aller à la ligne !
Pour procéder :
- soit, repérer la ligne à partir de laquelle vous souhaitez ou remplacer/inscrire vos lignes (genre la ligne 42. Attention, s'il y a du texte sur la ligne en question, ça va tout remplacer !).

(je veux obtenir ceci à partir de la ligne 42 :)
un
mot
par
ligne

sed -i "" '42 s/^.*$/un\nmot\npar\nligne/' /tmp/exemple.txt

- soit, repérer la chaîne de caractères précise que vous souhaitez remplacer par vos lignes.
(Genre, remplacer la chaîne "boutafoulirumatismal" par ceci :)
je pas
avoir
compris

sed -i "" 's/boutafoulirumatismal/je pas\navoir\ncompris/' /tmp/exemple.txt

Supprimer la ligne 23 du fichier /tmp/exemple.txt

sed -i "" '23d' /tmp/exemple.txt

Supprimer de la ligne 23 à la ligne 30 inclue du fichier /tmp/exemple.txt

sed -i "" '23,30d' /tmp/exemple.txt

Voilà, c'est un article minimaliste, mais vous l'aurez compris, on peut déjà quasiemment tout faire avec ça !

Vous disposez du chemin absolu vers un fichier : /usr/home/USER/truc/bidule/muche/fichier.txt
Comment extraire de ce chemin le nom "fichier.txt" et le chemin du répertoire parent ?

Entrez le chemin absolu vers le fichier dans une variable :

filepath="/usr/home/USER/truc/bidule/muche/fichier.txt"

Nom du fichier, isolé :

filename=$(basenme "$filepath")

si vous faîtes un echo $filename, il vous renvoie seulement le nom "fichier.txt"

Chemin absolu vers le dossier parent du fichier :

path=${filepath%/*}

si vous faîtes un echo $path, il vous renvoie seulement /usr/home/USER/truc/bidule/muche

Pour trouver l'adresse de la bibliothèque :

which bash

/bin/bash

Ecrire un mini-script, avec plusieurs exemples
 

nano script.sh
#!/bin/bash

# je veux que le script affiche "ça marche" lors de son exécution.
echo "ça marche"

# je veux que le script affiche le contenu d'une variable que je vais définir (roger, ici) lors de son exécution
# D'abord, je définis la variable roger
roger="marcel"
# je demande ensuite à afficher le contenu de la variable grâce au $
echo $roger

# je veux que le script me demande d'entrer du texte, je veux ensuite que le script me l'affiche
# D'abord, je demande au script de me demander d'écrire !
read x
# je demande ensuite que le script m'affiche ce que j'ai entré, au milieu d'une petite phrase
echo "l'utilisateur a écrit : $x"

# je veux que le script affiche la date. Pour cela, je veux utiliser la commande date qui existe.
# .. Attention aux paranthèses, date est une commande !
echo "Nous sommes le $(date)"

Lancer le script

./script.sh
ça marche
marcel
JE RENTRE UNE PHRASE #le script me demande d'entrer une phrase
l'utilisateur a écrit : JE RENTRE UNE PHRASE #il me l'affiche
Nous sommes le Mon Mar 21 14:21:19 CET 2022

1er Script :

$nom = read-host "Entrez l'identifiant de l'utilisateur à supprimer"
##### Rechercher un utilisateur dans l'AD
$listeDesUsers = Get-ADUser -Filter "name -like '*$nom*'"
$compteur=0
foreach ($user in $listeDesUsers)
{
     if($compteur -ne 0)
          {
               write-host "L'utilisateur $($user.Surname) a comme identifiant $($user.UserPrincipalName)"
          }
     $compteur++
}

$id = read-host "Entrez l'identifiant que vous souhaitez supprimer"
Remove-ADUser -Identity $listeDesUsers[$id]

2nd Script :

$nom = read-host "Entrez l'identifiant de l'utilisatuer à supprimer"

#####Rechercher un utilisateur dans l'AD
$collection=Get-ADUser -Filter "name -like '*$nom*'"
$compteur=1

foreach ($item in $collection)
{
     $item.numero_d_utilisateur_dans_la_liste=$compteur
     $compteur++
}
$collection | Format-Table numero_d_utilisateur_dans_la_liste,name,UserPrincipalName,DistinguishedName -AutoSize
$choix=read-host "Quel est votre choix ?"
Remove-ADUser -Identity $collection[$choix-1].UserPrincipalName

Je suis sur le poste A, je veux pouvoir exécuter un script présent sur le poste B

Je n'oublie pas de générer une clef SSH sur A et de partager la clef publique à B, sans passphrase, dans le cas où je voudrais automatiser la tâche.

Sur A :

ssh USER-B@IP-B '(/CHEMIN-DU-SCRIPT-SUR-B.sh)'

Le fait de mettre une commande - ou un script - entre simple guillements (apostrophe), dans une commande ssh, permet d'exécuter une commande à distance.

Attention, si vous souhaitez exécuter une commande avec une variable, les guillemets simples doivent être remplacés par des doubles (") !

ssh USER-B@IP-B "ls $cheminBACKUP"

1er Script simple, sans gestion des doublons :

Voici le script pour créer automatiquement les utilisateurs dans l'AD en fonction des informations contenues dans le fichier tartempion.csv

Pour ce 1er script, tartempion.csv contient :

Nom;Prenom;OU
Versaire;Annie;GESTION
Peuplu;Jean;GESTION

Le domaine est TSSR.INFO

Le script :

# On crée une première variable qui va contenir le fichier .csv

$contenu_csv=Import-Csv -path "C:\Users\Administrateur\Desktop\tartenpion.txt" -Delimiter ";"
#
foreach ($ligne in $contenu_csv)
{
# On va ensuite envoyer chaque information dans une variable spécifique
$nom=$ligne.Nom    
# Pour la ligne suivante, voici un autre exemple pour sélectionner la colonne Prenom.. 
# la colonne prénom est en 2nde position dans l'index.. [0] : 1ère position, [1] : 2e position
$prenom=$ligne.Prenom
$OU=$ligne.OU
#
# La commande pour créer :
New-ADUser -Name "$($prenom) $($nom)" -Surname "$($nom)" -GivenName "$($prenom)" -SamAccountName "$($prenom[0]).$($nom)" -UserPrincipalName "$($prenom).$($nom)@TSSR.INFO" -path "OU=$($OU),OU=ENTREPRISE,DC=TSSR,DC=INFO" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true
}
 

2nd Script, Exemple avec un fichier .csv de plusieurs milliers d'utilisateurs !
Plusieurs problèmes avec de gros fichiers csv : 
- les noms complets trop longs (le -SamAccountName fait 20 caractères au max)
Idée pour résoudre : couper les noms et prénoms et n'inscrire que les 5 premiers caractères de chaque.
- les homonymes (certaines personnes ont les mêmes noms et prénoms).
Idée pour résoudre : ajouter le chiffre 2 au nom de l'utilisateur, lors de la rencontre de l'erreur pour compte déjà existant


# On crée une première variable qui va contenir le fichier .csv
$contenu_csv=Import-Csv -path "C:\Users\Administrateur\Desktop\Utilisateurs.csv" -Delimiter ","
#
foreach ($ligne in $contenu_csv)
{
# On va ensuite envoyer chaque information dans une variable spécifique
$nom=$($ligne.Nom)    
# Pour la ligne suivante, voici un autre exemple pour sélectionner la colonne Prenom.. 
# la colonne prénom est en 2nde position dans l'index.. [0] : 1ère position, [1] : 2e position
$prenom=$($ligne.Prenom)
$OU=$($ligne.Service)
#
# La commande pour créer :
try{
    
New-ADUser -Name "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4]).$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])" -Surname "$($nom)" -GivenName "$($prenom)" -SamAccountName "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4]).$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])" -UserPrincipalName "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4]).$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])@TSSR.INFO" -path "OU=$($OU),OU=ENTREPRISE,DC=TSSR,DC=INFO" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true
}

catch { 
New-ADUser -Name "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4])2.$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])" -Surname "$($nom)" -GivenName "$($prenom)" -SamAccountName "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4])2.$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])" -UserPrincipalName "$($prenom[0])$($prenom[1])$($prenom[2])$($prenom[3])$($prenom[4])2.$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])@TSSR.INFO" -path "OU=$($OU),OU=ENTREPRISE,DC=TSSR,DC=INFO" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true
}
}

(Le second script est le plus simple !)

Script No.1 :
On souhaite créer un utilisateur.
Le script doit demander le nom complet de l'utilisateur (Prénom Nom)
- demander le nom seul
- demander le prénom seul
- créer un SamAccountName de la forme        première lettre du prénom.nom
- créer un UserPrincipalName de la forme       prenom.nom
- demander le chemin où sera placé l'utilisateur (exemple : OU=GESTION,OU=ENTREPRISE,DC=TSSR,DC=INFO).
Attention, les OU doivent avoir été créé précédemment
- activer le compte automatiquement
- faire changer le mot de passe temporaire lors de la première connexion de l'utilisateur

$nomcomplet=Read-Host "Entrez le nom complet de l'utilisateur"
$nom=Read-Host "Entrez le nom de l'utilisateur"
$prenom=Read-Host "Entrez le prénom de l'utilisateur"
$ADUser=Read-Host "Entrez l'ADUser, OU=...,OU=...,DC=...,DC=...?"
New-ADUser -Name $nomcomplet -Surname $nom -GivenName $prenom -SamAccountName "$($prenom[0]).$($nom)" -UserPrincipalName "$($prenom).$($nom)" -path "$ADUser" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true

Script No.2 :

On souhaite créer un utilisateur.
Le script doit demander le nom complet de l'utilisateur (Prénom Nom)
- demander le prénom seul
- demander le nom seul
- demander dans quel service sera l'utilisatueur 
Attention, les OU doivent avoir été créé précédemment
- Vérifier si l'utilisateur n'existe pas déjà
- activer le compte automatiquement
- faire changer le mot de passe temporaire lors de la première connexion de l'utilisateur

$prenom=Read-Host "Entrez le prénom de l'utilisateur"
$nom=Read-Host "Entre le nom de l'utilisateur"
$name="$($prenom[0])$($nom[0])$($nom[1])$($nom[2])$($nom[3])$($nom[4])"
$service=Read-Host "Entrez le service dont dépend l'utilisateur"
$PATH="OU=$($service),OU=ENTREPRISE,DC=JURABOIS,DC=LAN"

$Utilisateur=$(try {Get-ADUser $name} catch {$null})
if($Utilisateur -ne $Null)
    {
        "L'utilisateur existe déjà dans l'AD"
    }
else
    {
        New-ADUser -Name "$($name)" -Surname "$($nom)" -GivenName "$($prenom)" -SamAccountName "$($name)" -UserPrincipalName "$($name)" -path "$($PATH)" -AccountPassword(ConvertTo-SecureString "P@ssw0rd" -AsPlainText -Force) -Enabled $true -ChangePasswordAtLogon $true
        Add-ADGroupMember -Identity "CN=GG-$($service),OU=$($service),OU=ENTREPRISE,DC=JURABOIS,DC=LAN" -Members "$($name)"
    }

Installer le rôle AD DS :
Add-WindowsFeature AD-Domain-Services

Créer une nouvelle forêt (TSSR.INFO pour l'exemple)
Install-ADDSForest -DomainName TSSR.INFO -InstallDNS

Créer une OU (Unité d'Organisation) COMPTA :
New-ADOrganizationalUnit -name "COMPTA"

Créer un utilisateur avec les caractéristiques suivantes :
Nom Complet : Micheline Micheu
Prénom : Micheline
Nom : Micheu
Nom du compte : Micheline.Micheu
Nom principal de l'utilisateur(@domaine) : Micheline.Micheu
Le domaine dont il dépend : TSSR.INFO
L'OU dont l'utilisateur dépend : "OU=COMPTA,DC=TSSR,DC=INFO"
L'utilisateur a un mot de passe, et il devra le changer à sa première connexion
Le compte utilisateur est actif

New-ADUser -Name "Micheline Micheu" -GivenName "Micheline" -Surname "Micheu" -SamAccountName "Micheline.Micheu" -UserPrincipalName "Micheline.Micheu@TSSR.INFO" -Path "OU=COMPTA,DC=TSSR,DC=INFO" -AccountPassword(ConvertTo-SecureString "mot-de-passe-de-micheline" -AsPlainText -Force) -ChangePasswordAtLogon $true -Enabled $true


Supprimer un utilisateur (au cas où)
Remove-ADUser -Identity "CN=Micheline Micheu,OU=COMPTA,DC=TSSR,DC=INFO"

Vérifier si les scripts ont le droit d'être exécutés
se positionner dans le répertoire, puis :
Get-ExecutionPolicy
 -> si le résultat est "Restricted", cela signifie que le script ne peut s'exécuter que dans un domaine de confiance
...

Modifier les droits d'exécution des scripts (pour tout autoriser - non restreint)
(Lancer Powershell ISE en mode administrateur)
Set-ExecutionPolicy unrestricted

A ne pas Faire, cela s'entend !!

Modifier les droits d'exécution des scripts (autoriser les locaux ET domaines de confiance)
(Lancer Powershell ISE en mode administrateur)
Set-ExecutionPolicy remotesigned

Changer de dossier (se déplacer dans D: par exemple)
Set-Location D:
ou
cd D:

Si le dossier contient des espaces :
Set-Location "D:\nom du fichier avec des espaces"

Savoir où on se trouve (pwd)
pwd
ou
Get-Location

Créer un dossier (Bidon Bidon)
New-Item -ItemType Directory -name "Bidon Bidon" -path "C:\endroit où créer le dossier\"

Supprimer un fichier/dossier (Bidon Bidon)
Remove-Item "Bidon Bidon"
Attention, ça supprime TOUT CE QUI S'APPELLE "Bidon Bidon" dans le répertoire.
Donc s'il y a un dossier ET un fichier qui portent ce nom, ça supprimera les 2 !!

Créer un fichier texte du nom "essai.rtf" contenant la ligne de texte "Bonjour tout le monde !"
New-Item -itemType file -name essai.rtf -Value "Bonjour tout le monde !"

Ajouter du texte dans le fichier essai.rtf, sans supprimer le contenu (ajouter à la suite):
echo "j'ajoute du texte" >> ./essai.rtf
ou
Write-Output "j'ajoute du texte" >> ./essai.rtf

Déplacer un fichier : 
Move-Item .\essai.rtf "C:\chemin où déplacer

Trouver/Obtenir les commandes ayant un lien avec l'ordinateur (computer) :
Get-Command *-computer

Obtenir de l'aide sur une commande (Restore-Computer par exemple) :
Get-Help Restore-Computer

Obtenir une aide détaillée sur une commande (Restore-Computer, par exemple) :
Get-Help Restore-Computer -full
ou
Get-Help -full Restore-Computer

Compter les résultats d'une commande (exemple, le nombre de sous-dossiers d'un dossier)
$nbre_dossiers = (Get-ChildItem -Path "C:\DOSSIER" -Filter * -Recurse -Directory).count

Télécharger un fichier sur internet (via une URL) :
Invoke-WebRequest -Uri URL -OutFile C:\CHEMIN-OU-TELECHARGER\NOM-DU-FICHIER.EXTENSION
ou
Invoke-RestMethod -Uri URL -OutFile C:\CHEMIN-OU-TELECHARGER\NOM-DU-FICHIER.EXTENSION

Quelles sont toutes les manipulations possibles sur une variable.
$MaVariable="Coucou tout le monde"
$MaVariable | Get-Member

Afficher la liste des fonctions disponibles d'une variable
$MaVariable="Coucou tout le monde"
$MaVariable.

Demander à l'utilisateur d'entrer quelque chose :
$entree=Read-Host "bonjour, entrez ce que vous voulez"

Vérifier si les scripts ont le droit d'être exécutés
se positionner dans le répertoire, puis :
Get-ExecutionPolicy
 -> si le résultat est "Restricted", cela signifie que le script ne peut s'exécuter que dans un domaine de confiance
...

Modifier les droits d'exécution des scripts (pour tout autoriser - unrestricted)
(Lancer Powershell ISE en mode administrateur)
Set-ExecutionPolicy unrestricted

Modifier les droits d'exécution des scripts (autoriser les locaux ET domaines de confiance)
(Lancer Powershell ISE en mode administrateur)
Set-ExecutionPolicy remotesigned