Erstellen eines PowerShell-Moduls in der realen Welt: Funktionen erstellen

Tutorials
PowerShell

Haben Sie Schwierigkeiten, das perfekte PowerShell-Modul für Ihr einzigartiges Szenario zu finden? Bei Tausenden von verfügbaren Modulen könnte es sich so anfühlen, als ob Sie sich einfach mit dem zufrieden geben sollten, was verfügbar ist. Nun, das könnte Ihre Lösung unvollständig oder ineffizient lassen. Warum nicht stattdessen damit beginnen, Module zu erstellen?

Dieser Leitfaden führt Sie durch die Erstellung von Modulen, um robuste, wiederverwendbare Lösungen maßgeschneidert auf Ihre Bedürfnisse zu erstellen.

Verwandeln Sie Ihre Skripte in leistungsstarke Bausteine, die Sie in verschiedenen Projekten wiederverwenden können!

Erstellen eines Computer-Inventar-Moduls

In diesem Leitfaden erstellen wir ein PowerShell-Modul zur Erfassung von Informationen über Computerhardware. Dieses Modul hilft Systemadministratoren dabei, Speicher-, Speicher- und Prozessordetails über mehrere Systeme zu sammeln und zu berichten.

Unser Modul wird folgende Funktionen umfassen:

  • Funktionen zum Erfassen spezifischer Hardwareinformationen
  • Unterstützung für Remote-Systeme mit PowerShell-Sitzungen
  • Standardisiertes Ausgabeformat für konsistente Berichterstattung

Dieses praktische Beispiel demonstriert wesentliche Konzepte der Modulentwicklung bei der Erstellung eines nützlichen Werkzeugs für die Systemverwaltung.

Einrichten des PowerShell-Moduls

Das Verwalten Ihrer Skripte über mehrere Systeme hinweg kann schnell chaotisch werden. Aber wenn Ihre Workflows zu einem mühsamen Kampf werden, sind PowerShell-Module praktisch. Ein Modul ist eine strukturierte Möglichkeit, Skripte zu gruppieren und wiederzuverwenden, um Zeit zu sparen und Fehler zu reduzieren.

Lassen Sie uns Schlüsselkonzepte kombinieren, um ein PowerShell-Modul zu erstellen.

Beginnen Sie damit, das Modulverzeichnis zu erstellen und das Modul selbst zu definieren, um Ihre Arbeit zu organisieren.

## 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 ''

Der Befehl Set-Content erstellt ein Modul namens ComputerInventory im All-User-Pfad. Dieser Speicherort wurde gewählt, da er das Modul für alle Benutzer, die sich auf dem Computer anmelden, zugänglich macht, was in Unternehmensumgebungen entscheidend ist, in denen mehrere Benutzer Zugriff auf dieselbe PowerShell-Funktionalität benötigen. Im Gegensatz zu benutzerspezifischen Speicherorten gewährleistet dieser zentrale Pfad eine konsistente Modulverfügbarkeit und vereinfachtes Management im gesamten System.

Überprüfen Sie die Verfügbarkeit des Moduls:

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

Obwohl es derzeit eine Shell ist, bestätigt dies, dass es später ordnungsgemäß geladen wird.

Erstellung von Grundgerüstfunktionen

Ein gut strukturiertes Modul ist entscheidend, aber sein Inneres macht es wirklich nützlich. Vermeiden Sie es, Zeit damit zu verschwenden, herauszufinden, was jeder Teil macht, anstatt produktiv zu sein, indem Sie Grundgerüste für Ihre Modulfunktionen erstellen.

Öffnen Sie das Modul in einem Texteditor wie VS Code und erstellen Sie Gerüstfunktionen.

Beginnen Sie mit der Erstellung von Platzhalterfunktionen mit beschreibenden Namen.

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

}

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

}

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

}

Die Funktionsnamen folgen einer konsistenten Verb-Nomen-Namenskonvention.

Die Funktionsnamen in PowerShell folgen einer Verb-Nomen-Namenskonvention, die ein standardisiertes Namensmuster ist. In diesem Fall lauten die Funktionen:

  • Get-MemoryInfo
  • Get-StorageInfo
  • Get-ProcessorInfo

Jeder Funktionsname beginnt mit dem Verb „Get“ (was darauf hinweist, dass Informationen abgerufen werden) gefolgt von einem Nomen, das beschreibt, welche Informationen abgerufen werden (Speicher, Speicherplatz oder Prozessor).

Diese Benennungskonvention ist in PowerShell wichtig, da sie Funktionen vorhersehbar und leicht verständlich macht – Benutzer können schnell erfassen, was eine Funktion tut, indem sie sich einfach ihren Namen ansehen.

Überprüfen Sie ihre Existenz, indem Sie das Folgende ausführen:

Get-Command -Module ComputerInventory

Wenn Sie den Befehl Get-Command -Module ComputerInventory ausführen, sehen Sie eine ähnliche Ausgabe wie diese:

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

Dieser Befehl listet alle verfügbaren Funktionen im ComputerInventory-Modul auf, zu denen die drei von uns erstellten Funktionen gehören: Get-MemoryInfo, Get-StorageInfo und Get-ProcessorInfo.

Zu diesem Zeitpunkt enthält das Modul Funktionsschalen. Verbessern wir diese Funktionen, indem wir eine konsistente Ausgabe mit benutzerdefinierten Objekten definieren.

Standardisierte Ausgabe mit benutzerdefinierten Objekten

Inkonsistente Ausgaben in Skripten können eine einfache Aufgabe in ein Albtraum des Datenauslesens und der Fehlerbehebung verwandeln. In der professionellen PowerShell-Entwicklung ist die Sicherstellung konsistenter Ausgaben ein Eckpfeiler effektiven Skriptings.

Das Standardisieren der Ausgabe mit benutzerdefinierten Objekten hilft dabei, die Konsistenz über Funktionen hinweg zu erhalten.

In dem folgenden Skript:

  • Die benutzerdefinierten Objekte enthalten die Eigenschaften ComputerName, HardwareCategory und Info.
  • Die Eigenschaft HardwareCategory gruppiert ähnliche Hardwaretypen, und ComputerName ist für eine Skalierbarkeit auf mehreren Computern konzipiert.
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
}

Zuerst importieren wir das Modul erneut, um sicherzustellen, dass wir die neueste Version haben:

Import-Module ComputerInventory -Force

Jetzt können Sie die Funktionen ausführen, um ihre Ausgabe zu sehen:

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

Jede Funktion gibt eine Hashtable mit leeren ComputerName- und Info-Eigenschaften zurück, jedoch mit ihren jeweiligen Hardwarekategorien definiert.

Hinzufügen eines Sitzungsparameters für Remote-Support

Stellen Sie sich vor, Sie müssten Ihre Skripte auf Dutzenden oder sogar Hunderten von Computern ausführen. Wenn für jede Funktion manuell ein Computernamen angegeben werden müsste, wäre dies umständlich und fehleranfällig. Glücklicherweise bietet PowerShell Remoting eine Lösung.

Verwenden Sie anstelle eines ComputerName-Parameters einen Sitzung-Parameter, um PowerShell Remoting zu nutzen:

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
}

Dieser Parameter gewährleistet die Flexibilität beim Skalieren auf mehrere Systeme.

Der Sitzungsparameter ist darauf ausgelegt, PowerShell Remoting für die Ausführung von Befehlen auf entfernten Computern zu verwenden. Hier ist, was ihn leistungsfähig macht:

  • Er ist als obligatorischer Parameter definiert, der ein PSSession-Objekt akzeptiert (speziell vom Typ System.Management.Automation.Runspaces.PSSession)
  • Der Sitzungsparameter stellt automatisch den Computernamen über $Session.ComputerName bereit, der im Ausgabeobjekt ausgefüllt wird

Dieser Ansatz bietet mehrere Vorteile:

  • Er ermöglicht eine effiziente Skalierung bei der Arbeit mit mehreren Systemen
  • Anstatt für jeden Befehl neue Verbindungen herzustellen, können Sie dieselbe Sitzung für mehrere Operationen wiederverwenden, was effizienter ist als individuelle Verbindungen für jeden Funktionsaufruf herzustellen
  • Sie können die Funktionen testen, indem Sie eine einzelne PSSession erstellen und diese in allen Inventarfunktionen verwenden, wie im Beispiel gezeigt, wo eine Testsitzung mit: $testSession = New-PSSession -ComputerName SRV2

gespeichert und das Modul erneut importiert wird:

ipmo ComputerInventory -Force

Die Funktionen testen

Wie stellen Sie sicher, dass ein Modul nach dem Erstellen funktioniert? Testing ist entscheidend, um zu bestätigen, dass die Funktionen Ihres Moduls wie erwartet arbeiten und genaue Daten zurückgeben. Das Überspringen dieses Schrittes könnte zu Überraschungen in Produktionsumgebungen führen.

Stellen Sie eine remote Sitzung her und testen Sie das Modul:

$testSession = New-PSSession -ComputerName SRV2

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

Jede Funktion sollte ein Objekt mit den erwarteten Eigenschaften und dem korrekten Computernamen zurückgeben. Diese Funktionen bilden die Grundlage eines robusten Inventarwerkzeugs.

Basierend auf dem gezeigten Code würde die Ausgabe beim Testen dieser Funktionen mit einer remote Sitzung ungefähr so aussehen:

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

Jede Funktion gibt eine Hashtable zurück, die den Computernamen (aus der Sitzung), die spezifische Hardwarekategorie und ein Info-Feld (derzeit null, aber dafür vorgesehen, die tatsächlichen Hardwareinformationen zu halten) enthält.

Fazit

In diesem Artikel haben Sie gelernt, warum es wichtig ist, Ihre eigenen PowerShell-Module zu erstellen, um einzigartige Herausforderungen zu bewältigen, die kein handelsübliches Modul ansprechen kann. Wir haben untersucht, wie benutzerdefinierte Module ein Wendepunkt für spezialisierte Konfigurationen oder Prozesse in Ihrer Umgebung sein können.

Dies ist erst der Anfang unserer Reise mit dem ComputerInventory-Modul. In bevorstehenden Blog-Beiträgen werden wir dieses Fundament erweitern, indem wir echte Hardware-Informationsbeschaffungsfunktionen, Fehlerbehandlung und erweiterte Remote-Verwaltungsfunktionen hinzufügen.

Bleiben Sie dran, während wir dieses Grundgerüst in ein leistungsstarkes Werkzeug für Systemadministratoren verwandeln!

Source:
https://adamtheautomator.com/powershell-module-functions/