Création d’un module PowerShell réel : Fonctions de structure – techsyncer

Êtes-vous en train de chercher le module PowerShell parfait pour votre scénario unique ? Avec des milliers de modules disponibles, il peut sembler que vous devriez simplement vous contenter de ce qui est disponible. Eh bien, cela pourrait laisser votre solution incomplète ou inefficace. Pourquoi ne pas commencer à créer des modules à la place ?

Ce guide vous guidera dans la création de modules pour construire des solutions robustes et réutilisables adaptées à vos besoins.

Transformez vos scripts en blocs de construction puissants que vous pouvez réutiliser dans différents projets !

Création d’un module d’inventaire informatique

Dans ce guide, nous allons créer un module PowerShell pour collecter des informations sur le matériel informatique des ordinateurs. Ce module aidera les administrateurs système à collecter et à rapporter des détails sur la mémoire, le stockage et le processeur à travers plusieurs systèmes.

Notre module comprendra :

Fonctions pour collecter des informations matérielles spécifiques
Prise en charge des systèmes distants en utilisant des sessions PowerShell
Format de sortie standardisé pour des rapports cohérents

Cet exemple pratique démontre des concepts essentiels de développement de modules tout en créant un outil utile pour l’administration système.

Mise en place du module PowerShell

Gérer vos scripts à travers plusieurs systèmes peut rapidement devenir chaotique. Mais lorsque vos flux de travail deviennent une bataille difficile, les modules PowerShell sont utiles. Un module est un moyen structuré de regrouper et de réutiliser des scripts pour gagner du temps et réduire les erreurs.

Combinons les concepts clés pour construire un module PowerShell.

Commencez par créer le répertoire du module et définir le module lui-même pour organiser votre travail.

## Create the module directory in the all-user location
mkdir 'C:\Program Files\PowerShell\Modules\ComputerInventory'

## Create the module to hold the module functions
Set-Content -Path 'C:\Program Files\PowerShell\Modules\ComputerInventory\ComputerInventory.psm1' -Value ''

La commande Set-Content crée un module nommé ComputerInventory dans le chemin de tous les utilisateurs. Cet emplacement est choisi car il rend le module accessible à toute personne se connectant à la machine, ce qui est crucial dans les environnements d’entreprise où plusieurs utilisateurs ont besoin d’accéder à la même fonctionnalité PowerShell. Contrairement aux emplacements spécifiques à l’utilisateur, ce chemin centralisé garantit une disponibilité cohérente du module et une gestion plus facile à travers le système.

Vérifiez la disponibilité du module :

## The module is already showing up as available
Get-Module ComputerInventory -ListAvailable

Bien que ce soit actuellement une coquille, cela confirme qu’il se chargera correctement plus tard.

Création de fonctions d’échafaudage

Un module bien structuré est essentiel, mais ce qu’il contient le rend vraiment utile. Évitez de perdre du temps à comprendre ce que fait chaque partie au lieu d’être productif en créant un échafaudage pour les fonctions de votre module.

Ouvrez le module dans un éditeur de texte comme VS Code, puis créez des fonctions d’échafaudage.

Commencez par créer des fonctions d’espacement réservé avec des noms descriptifs.

function Get-MemoryInfo {
    [CmdletBinding()]
    param()

}

function Get-StorageInfo {
    [CmdletBinding()]
    param()

}

function Get-ProcessorInfo {
    [CmdletBinding()]
    param()

}

Les noms de fonctions suivent une convention de nommage verbe-nom cohérente.

Les noms de fonctions en PowerShell suivent une convention de nommage verbe-nom, qui est un motif de nommage standardisé. Dans ce cas, les fonctions sont nommées :

Get-MemoryInfo
Get-StorageInfo
Get-ProcessorInfo

Chaque nom de fonction commence par le verbe « Get » (indiquant qu’il récupère des informations) suivi d’un nom qui décrit les informations qu’il récupère (Mémoire, Stockage ou Processeur).

Cette convention de nommage est importante en PowerShell car elle rend les fonctions prévisibles et plus faciles à comprendre – les utilisateurs peuvent rapidement saisir ce qu’une fonction fait rien qu’en regardant son nom.

Vérifiez leur existence en exécutant la commande suivante :

Get-Command -Module ComputerInventory

Lorsque vous exécutez la commande Get-Command -Module ComputerInventory, vous verriez une sortie similaire à ceci :

CommandType     Name                                               Version    Source
-----------     ----                                               -------    ------
Function        Get-MemoryInfo                                     1.0.0      ComputerInventory
Function        Get-ProcessorInfo                                  1.0.0      ComputerInventory
Function        Get-StorageInfo                                    1.0.0      ComputerInventory

Cette commande répertorie toutes les fonctions disponibles dans le module ComputerInventory, qui inclut les trois fonctions que nous avons créées : Get-MemoryInfo, Get-StorageInfo et Get-ProcessorInfo.

À ce stade, le module comprend des coquilles de fonctions. Améliorons ces fonctions en définissant une sortie cohérente en utilisant des objets personnalisés.

Sortie standardisée avec des objets personnalisés

Des sorties incohérentes à travers les scripts peuvent transformer une tâche simple en un cauchemar d’analyse de données et de dépannage. Dans le développement professionnel en PowerShell, garantir des sorties cohérentes est un pilier du scripting efficace.

Standardiser la sortie avec des objets personnalisés aide à maintenir la cohérence à travers les fonctions.

Dans le script suivant :

Les objets personnalisés incluent les propriétés ComputerName, HardwareCategory et Info.
La propriété HardwareCategory regroupe des types de matériels similaires, et ComputerName est conçu pour une évolutivité multi-ordinateurs.

function Get-MemoryInfo {
    [CmdletBinding()]
    param()

    $outObject = @{
        'ComputerName'      = ''
        'HardwareCategory'  = 'Memory'
        'Info'              = $null
    }

    $outObject
}

function Get-StorageInfo {
    [CmdletBinding()]
    param()

    $outObject = @{
        'ComputerName'      = ''
        'HardwareCategory'  = 'Storage'
        'Info'              = $null
    }

    $outObject
}

function Get-ProcessorInfo {
    [CmdletBinding()]
    param()

    $outObject = @{
        'ComputerName'      = ''
        'HardwareCategory'  = 'Processor'
        'Info'              = $null
    }

    $outObject
}

Tout d’abord, réimportons le module pour nous assurer d’avoir la dernière version :

Import-Module ComputerInventory -Force

Maintenant, vous pouvez exécuter les fonctions pour voir leur sortie :

PS> Get-MemoryInfo
Name                           Value
----                           -----
Info                           
HardwareCategory              Memory
ComputerName                  

PS> Get-StorageInfo
Name                           Value
----                           -----
Info                           
HardwareCategory              Storage
ComputerName                  

PS> Get-ProcessorInfo
Name                           Value
----                           -----
Info                           
HardwareCategory              Processor
ComputerName

Chaque fonction renvoie une table de hachage avec les propriétés ComputerName et Info vides, mais avec leurs catégories matérielles respectives définies.

Ajout d’un paramètre de session pour le support à distance

Imaginez devoir exécuter vos scripts sur des dizaines, voire des centaines d’ordinateurs. Si chaque fonction nécessitait de spécifier manuellement un nom d’ordinateur, cela serait fastidieux et sujet aux erreurs. Heureusement, PowerShell Remoting fournit une solution.

Au lieu d’un paramètre ComputerName, utilisez un paramètre Session pour exploiter le PowerShell Remoting:

function Get-MemoryInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [System.Management.Automation.Runspaces.PSSession]$Session
    )

    $outObject = @{
        'ComputerName'      = $Session.ComputerName
        'HardwareCategory'  = 'Memory'
        'Info'              = $null
    }

    $outObject
}

function Get-StorageInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [System.Management.Automation.Runspaces.PSSession]$Session
    )

    $outObject = @{
        'ComputerName'      = $Session.ComputerName
        'HardwareCategory'  = 'Storage'
        'Info'              = $null
    }

    $outObject
}

function Get-ProcessorInfo {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)]
        [System.Management.Automation.Runspaces.PSSession]$Session
    )

    $outObject = @{
        'ComputerName'      = $Session.ComputerName
        'HardwareCategory'  = 'Processor'
        'Info'              = $null
    }

    $outObject
}

Ce paramètre garantit la flexibilité lors de l’extension vers plusieurs systèmes.

Le paramètre Session est conçu pour utiliser le PowerShell Remoting afin d’exécuter des commandes sur des ordinateurs distants. Voici ce qui le rend puissant:

Il est défini comme un paramètre obligatoire qui accepte un objet PSSession (spécifiquement du type System.Management.Automation.Runspaces.PSSession)
Le paramètre Session fournit automatiquement le nom de l’ordinateur via $Session.ComputerName, qui se remplit dans l’objet de sortie

Cette approche offre plusieurs avantages:

Elle permet de mettre à l’échelle efficacement lors du travail avec plusieurs systèmes
Au lieu de créer de nouvelles connexions pour chaque commande, vous pouvez réutiliser la même session pour plusieurs opérations, ce qui est plus efficace que d’établir des connexions individuelles pour chaque appel de fonction
Vous pouvez tester les fonctions en créant une seule PSSession et en l’utilisant pour toutes les fonctions d’inventaire, comme indiqué dans l’exemple où une session de test est créée avec : $testSession = New-PSSession -ComputerName SRV2

Enregistrez et ré-importez le module:

ipmo ComputerInventory -Force

Tester les fonctions

Comment vous assurez-vous qu’un module fonctionne après l’avoir construit ? Tester est essentiel pour confirmer que les fonctions de votre module se comportent comme prévu et renvoient des données précises. Sauter cette étape pourrait entraîner des surprises dans les environnements de production.

Établissez une session à distance et testez le module :

$testSession = New-PSSession -ComputerName SRV2

Get-MemoryInfo -Session $testSession
Get-StorageInfo -Session $testSession
Get-ProcessorInfo -Session $testSession

Chaque fonction devrait renvoyer un objet avec les propriétés attendues et le nom d’ordinateur correct. Ces fonctions forment la base d’un outil d’inventaire robuste.

Sur la base du code présenté, lorsque vous testez ces fonctions avec une session à distance, la sortie ressemblerait à ceci :

PS> $testSession = New-PSSession -ComputerName SRV2
PS> Get-MemoryInfo -Session $testSession
Name                           Value
----                           -----
Info                           
HardwareCategory              Memory
ComputerName                  SRV2

PS> Get-StorageInfo -Session $testSession
Name                           Value
----                           -----
Info                           
HardwareCategory              Storage
ComputerName                  SRV2

PS> Get-ProcessorInfo -Session $testSession
Name                           Value
----                           -----
Info                           
HardwareCategory              Processor
ComputerName                  SRV2

Chaque fonction renvoie une table de hachage contenant le nom de l’ordinateur (de la session), la catégorie matérielle spécifique, et un champ Info (actuellement nul mais conçu pour contenir les informations matérielles réelles).

Conclusion

Dans cet article, vous avez appris pourquoi la création de vos propres modules PowerShell est essentielle pour relever des défis uniques auxquels aucun module prêt à l’emploi ne peut répondre. Nous avons exploré comment les modules personnalisés peuvent être un atout majeur pour des configurations ou des processus spécialisés au sein de votre environnement.

Ceci n’est que le début de notre voyage avec le module ComputerInventory. Dans les prochains articles de blog, nous élargirons cette base en ajoutant des capacités de collecte d’informations matérielles réelles, la gestion des erreurs et des fonctionnalités avancées de gestion à distance.

Restez à l’écoute pendant que nous transformons ce cadre de base en un outil puissant pour les administrateurs système!