Apprendre PowerShell Part 1.2 : Plongez dans l'automatisation

Bienvenue dans la deuxième partie de notre série sur Apprendre PowerShell ! Dans la première partie, nous avons couvert les bases essentielles pour commencer avec PowerShell. Maintenant que vous avez acquis ces connaissances fondamentales, nous allons plonger plus profondément dans les fonctionnalités avancées qui vous permettront de nager en autonomie dans la piscine PowerShell.

Table des matières

Introduction

Après avoir assimilé le contenu de ces deux parties, vous serez en mesure de créer des scripts PowerShell plus sophistiqués et d‘automatiser des tâches plus complexes. Dans les parties 3 et 4 à venir, nous explorerons des cas pratiques plus avancés, tels que la gestion des fichiers, l’Active Directory, les journaux d’événements, et bien plus encore. Mais pour l’instant, concentrons-nous sur les concepts avancés qui vous permettront de mieux apprendre PowerShell.

1. Variables d’environnement

Les variables d’environnement sont des variables globales du système d’exploitation qui peuvent être utilisées dans PowerShell. Voici comment les utiliser et quelques exemples :

Pour obtenir toutes les variables d’environnement :

Get-ChildItem Env:

Voici 7 exemples de variables d’environnement couramment utilisées avec leurs cas d’utilisation :

# 1. Chemin d'accès de l'utilisateur
$Env:USERPROFILE
# Cas d'utilisation : Accéder au dossier personnel de l'utilisateur

# 2. Chemin système
$Env:PATH
# Cas d'utilisation : Vérifier ou modifier les chemins d'accès aux exécutables

# 3. Nom de l'ordinateur
$Env:COMPUTERNAME
# Cas d'utilisation : Identifier la machine sur laquelle le script s'exécute

# 4. Nom d'utilisateur
$Env:USERNAME
# Cas d'utilisation : Personnaliser les scripts en fonction de l'utilisateur

# 5. Système d'exploitation
$Env:OS
# Cas d'utilisation : Adapter le comportement du script selon le système d'exploitation

# 6. Processeur
$Env:PROCESSOR_ARCHITECTURE
# Cas d'utilisation : Vérifier l'architecture du processeur pour la compatibilité des logiciels

# 7. Dossier temporaire
$Env:TEMP
# Cas d'utilisation : Stocker des fichiers temporaires pendant l'exécution du script

2. Variables automatiques

Certainement. Je vais vous expliquer en détail ce que fait chaque ligne de ce bloc de code PowerShell :

# 1. $_ ou $PSItem : L'objet courant dans le pipeline
1..5 | ForEach-Object { $_ * 2 }

Cette ligne crée une séquence de nombres de 1 à 5, puis utilise ForEach-Object pour multiplier chaque nombre par 2. $_ représente chaque élément dans le pipeline. Le résultat sera 2, 4, 6, 8, 10.

# 2. $$ : L'ID du processus PowerShell actuel
$$

Cette commande affiche l’ID du processus PowerShell en cours d’exécution.

# 3. $? : État de la dernière opération (True si réussie, False sinon)
Get-Process | Out-Null
$?

Ce code exécute la commande Get-Process (qui liste tous les processus) et redirige la sortie vers Out-Null (qui la supprime). Ensuite, $? affiche si cette opération a réussi (True) ou échoué (False).

# 4. $^ : Premier token de la dernière ligne exécutée
Get-Process
$^

Ici, Get-Process est exécuté, puis $^ affiche le premier « token » (mot) de cette commande, qui sera « Get-Process ».

# 5. $Error : Tableau contenant les erreurs récentes
$Error[0]

Cette ligne affiche la dernière erreur survenue dans la session PowerShell actuelle.

# 6. $PSVersionTable : Informations sur la version de PowerShell
$PSVersionTable

Cette commande affiche un tableau contenant des informations détaillées sur la version de PowerShell en cours d’utilisation.

# 7. $Host : Informations sur l'hôte PowerShell actuel
$Host.Version

Cette ligne affiche la version de l’hôte PowerShell actuel. L’hôte est l’application qui exécute PowerShell (comme la console PowerShell ou l’ISE).

Chacune de ces commandes démontre l’utilisation d’une variable automatique différente en PowerShell, fournissant des informations sur l’état actuel de l’environnement PowerShell ou sur le résultat des opérations précédentes.

3. Variables de préférence

Les variables de préférence contrôlent le comportement de PowerShell. Voici 7 exemples avec leurs cas d’utilisation :

# 1. $ErrorActionPreference : Contrôle la réponse aux erreurs non-terminales
$ErrorActionPreference = "SilentlyContinue"
# Cas d'utilisation : Ignorer les erreurs non-critiques dans un script

# 2. $ConfirmPreference : Contrôle les invites de confirmation
$ConfirmPreference = "High"
# Cas d'utilisation : Demander confirmation pour les actions potentiellement dangereuses

# 3. $DebugPreference : Contrôle l'affichage des messages de débogage
$DebugPreference = "Continue"
# Cas d'utilisation : Afficher des informations de débogage lors de l'exécution du script

# 4. $VerbosePreference : Contrôle l'affichage des messages détaillés
$VerbosePreference = "Continue"
# Cas d'utilisation : Afficher des informations détaillées sur l'exécution du script

# 5. $WarningPreference : Contrôle l'affichage des avertissements
$WarningPreference = "Inquire"
# Cas d'utilisation : Demander à l'utilisateur comment gérer les avertissements

# 6. $ProgressPreference : Contrôle l'affichage de la barre de progression
$ProgressPreference = "SilentlyContinue"
# Cas d'utilisation : Masquer les barres de progression pour accélérer l'exécution

# 7. $InformationPreference : Contrôle l'affichage des messages d'information
$InformationPreference = "Continue"
# Cas d'utilisation : Afficher des messages informatifs pendant l'exécution du script

Exemple de Gestion avancée des erreurs

La gestion avancée des erreurs en PowerShell est un aspect crucial pour créer des scripts robustes et fiables. Voici une explication détaillée des différents aspects de la gestion des erreurs :

Types d’erreurs

Erreurs non terminales (Non-terminating errors):

Ne stoppent pas l’exécution du script.
Sont écrites dans le flux d’erreurs.
Exemple : Get-ChildItem sur un dossier inexistant.

Erreurs terminales (Terminating errors):

Arrêtent l’exécution du script ou de la fonction.
Déclenchent une exception.
Exemple : Erreur de syntaxe dans un script.

ErrorRecord

Un ErrorRecord est un objet qui encapsule les détails d’une erreur. Voici 7 propriétés importantes :

CategoryInfo : Catégorie de l’erreur (ex: SyntaxError, ResourceUnavailable).
ErrorDetails : Détails supplémentaires sur l’erreur.
FullyQualifiedErrorId : Identifiant unique de l’erreur.
Exception : L’objet Exception .NET sous-jacent.
TargetObject : L’objet en cours de traitement lors de l’erreur.
InvocationInfo : Informations sur l’endroit où l’erreur s’est produite.
ScriptStackTrace : Trace de la pile d’appels au moment de l’erreur.

Variables et paramètres de gestion d’erreurs

$Error : Contient la dernière erreur survenue.
-ErrorAction : Paramètre commun pour contrôler le comportement en cas d’erreur non terminale.
$ErrorActionPreference : Variable globale définissant le comportement par défaut.

Options pour -ErrorAction et $ErrorActionPreference :

Continue (défaut) : Affiche l’erreur et continue l’exécution.
SilentlyContinue : Ignore l’erreur et continue.
Stop : Convertit une erreur non terminale en erreur terminale.
Inquire : Demande à l’utilisateur comment procéder.
Ignore : Supprime l’erreur (PowerShell 3.0+).

Exemple avec trap

Le mot-clé trap permet de définir un gestionnaire d’erreurs global. Voici un exemple :

#Recommander d'utiliser que dans des fonctions sinon utiliser Try{}catch{}

function Get-error-trap {


trap [System.Management.Automation.RuntimeException] {
    Write-Host "La commande Get-MxmsDecl n'existe pas." -ForegroundColor Green
    continue
} 

1/0
}
Get-error-trap

Dans cet exemple :

Le trap capture spécifiquement les erreurs de type CommandNotFoundException.
Si Get-MxmsDecl n’existe pas, un message d’erreur personnalisé est affiché.
Le continue dans le trap permet à l’exécution de se poursuivre après l’erreur.
Le bloc try/catch offre une gestion d’erreur plus localisée.

Points de vue sur la gestion des erreurs

Gestion proactive : Anticiper les erreurs possibles et les gérer avant qu’elles ne se produisent.
Gestion réactive : Utiliser try/catch pour gérer les erreurs lorsqu’elles surviennent.
Gestion globale : Utiliser $ErrorActionPreference pour définir un comportement par défaut.
Gestion spécifique : Utiliser -ErrorAction pour contrôler le comportement d’erreur pour des commandes spécifiques.

Apprendre Powershell sur La gestion avancée des erreurs offre une grande flexibilité, permettant de créer des scripts robustes capables de gérer efficacement les situations imprévues.

4. Fonctions natives et cmdlets

PowerShell offre de nombreuses fonctions natives et cmdlets. Voici quelques exemples :

# Manipulation de chaînes
"hello world".ToUpper()
"hello world".Replace("world", "PowerShell")
"hello world".StartsWith("hello")
"hello,world".Split(",")

# Gestion des erreurs avec try/catch/finally

try {
    # Code qui pourrait générer une erreur
    Get-Noexist
}
catch [System.Management.Automation.CommandNotFoundException],[System.Management.Automation.ItemNotFoundException]{
    Write-Warning "Une erreur de gestion s'est produite sur l'exeption : $_"
}
catch {
    Write-Error "Une erreur inattendue s'est produite de façon générique : $_"
}
finally {
    Write-Host "Le bloc 'finally' s'exécute toujours, qu'il y ait une erreur ou non."
}

5. Classes et objets

Les classes et les objets sont utiles pour créer des structures de données complexes et réutilisables. Voici comment les utiliser :

# Définition d'une classe
class Personne {
    [string]$Nom
    [int]$Age

    Personne([string]$nom, [int]$age) {
        $this.Nom = $nom
        $this.Age = $age
    }

    [string] SePresenter() {
        return "Je m'appelle $($this.Nom) et j'ai $($this.Age) ans."
    }
}

# Instanciation d'un objet
$personne = [Personne]::new("Alice", 30)

# Utilisation de l'objet
$personne.SePresenter()

# Obtenir les membres d'un objet
$personne | Get-Member

# Ajouter un membre à un objet existant
$personne | Add-Member -MemberType NoteProperty -Name "Ville" -Value "Paris"
$personne.Ville

6. Modules

Les modules permettent d’organiser et de partager du code PowerShell. Voici comment les utiliser :

# Lister les modules disponibles
Get-Module -ListAvailable

# Importer un module
Import-Module ActiveDirectory

# Créer un module simple
New-ModuleManifest -Path "C:\MonModule\MonModule.psd1" -RootModule "MonModule.psm1" -Author "Votre Nom"

# Contenu de MonModule.psm1
function Dire-Bonjour {
    param([string]$Nom)
    Write-Host "Bonjour, $Nom !"
}

Export-ModuleMember -Function Dire-Bonjour

# Utiliser le module
Import-Module C:\MonModule\MonModule.psd1
Dire-Bonjour -Nom "Alice"

7. Les blocs de script

Les blocs de script sont encore largement utilisés en PowerShell, en particulier pour les administrateurs systèmes. Ils offrent une grande flexibilité et sont essentiels pour de nombreuses tâches d’automatisation. Voici un exemple concret qui pourrait être utile pour un administrateur système :

$serverList = @("Server1", "Server2", "Server3")

$scriptBlock = {
    param($serverName)

    $diskInfo = Get-WmiObject Win32_LogicalDisk -ComputerName $serverName -Filter "DriveType=3" |
        Select-Object DeviceID, 
            @{Name="Size(GB)";Expression={[math]::Round($_.Size/1GB, 2)}},
            @{Name="FreeSpace(GB)";Expression={[math]::Round($_.FreeSpace/1GB, 2)}},
            @{Name="FreePercent";Expression={[math]::Round(($_.FreeSpace/$_.Size)*100, 2)}}

    foreach ($disk in $diskInfo) {
        if ($disk.FreePercent -lt 20) {
            Write-Output "ALERTE : $serverName - Le disque $($disk.DeviceID) n'a plus que $($disk.FreePercent)% d'espace libre"
        }
    }
}

foreach ($server in $serverList) {
    Invoke-Command -ScriptBlock $scriptBlock -ArgumentList $server
}

Expliquons ce script :

Nous définissons une liste de serveurs à vérifier.
Le bloc de script $scriptBlock contient la logique principale :

Il accepte un paramètre $serverName.
Il récupère les informations sur les disques du serveur spécifié.
Il calcule la taille, l’espace libre et le pourcentage d’espace libre pour chaque disque.
Il vérifie si l’espace libre est inférieur à 20% et génère une alerte si c’est le cas.

Nous utilisons une boucle foreach pour exécuter le bloc de script sur chaque serveur de la liste, en utilisant Invoke-Command.

Ce script est particulièrement utile pour un administrateur système car :

Il automatise la vérification de l’espace disque sur plusieurs serveurs.
Il peut être facilement modifié pour inclure d’autres vérifications ou actions.
Il utilise des techniques PowerShell avancées comme les blocs de script paramétrés et le calcul d’attributs personnalisés.

L’utilisation de blocs de script de cette manière permet aux administrateurs de créer des outils de surveillance et de maintenance puissants et flexibles, essentiels pour gérer efficacement une infrastructure informatique moderne.

Avec ces connaissances approfondies sur les variables d’environnement, les variables automatiques, les variables de préférence, les fonctions natives, les classes et les modules, vous êtes maintenant capable de créer des scripts PowerShell plus sophistiqués et d’automatiser des tâches plus complexes.

Dans les prochaines parties de cette série, nous plongerons dans le grand bassin avec des études de cas pratiques sur la gestion des fichiers, l’Active Directory, les journaux d’événements et bien d’autres sujets avancés. Restez à l’écoute pour continuer à développer vos compétences pour apprendre PowerShell !
Si vous souhaitez allez plus loin je vous recommande la documentation officielle de Microsoft.
#Apprendre Powershell

Apprendre PowerShell Part II : Plongez plus profondément dans l’automatisation – Résumé

Introduction

1. Variables d’environnement

2. Variables automatiques

3. Variables de préférence

Exemple de Gestion avancée des erreurs

Types d’erreurs

ErrorRecord

Variables et paramètres de gestion d’erreurs

Exemple avec trap

Points de vue sur la gestion des erreurs

4. Fonctions natives et cmdlets

5. Classes et objets

6. Modules

7. Les blocs de script

Jeter un coup d'œil

Comments

Laisser un commentaire Annuler la réponse

Introduction

1. Variables d’environnement

2. Variables automatiques

3. Variables de préférence

Exemple de Gestion avancée des erreurs

Types d’erreurs

ErrorRecord

Variables et paramètres de gestion d’erreurs

Exemple avec trap

Points de vue sur la gestion des erreurs

4. Fonctions natives et cmdlets

5. Classes et objets

6. Modules

7. Les blocs de script

Jeter un coup d'œil

Comments

Laisser un commentaire Annuler la réponse

En savoir plus sur Next Workplace