Het maken van een PowerShell-module voor de echte wereld: het opzetten van functies – techsyncer

Ben je aan het worstelen om de perfecte PowerShell-module te vinden voor jouw unieke scenario? Met duizenden modules beschikbaar, kan het voelen alsof je genoegen moet nemen met wat er al is. Nou, dat kan ervoor zorgen dat jouw oplossing onvolledig of inefficiënt is. Waarom begin je niet met het maken van modules in plaats daarvan?

Deze gids loodst je door het proces van het maken van modules om robuuste, herbruikbare oplossingen op maat van jouw behoeften te bouwen.

Verander jouw scripts in krachtige bouwstenen die je opnieuw kunt gebruiken in verschillende projecten!

Het bouwen van een Computerinventarisatiemodule

In deze gids zullen we een PowerShell-module maken voor het verzamelen van informatie over computerhardware. Deze module zal systeembeheerders helpen bij het verzamelen en rapporteren over geheugen, opslag en processorinformatie over meerdere systemen.

Onze module zal het volgende bevatten:

Functies om specifieke hardware-informatie te verzamelen
Ondersteuning voor externe systemen met behulp van PowerShell-sessies
Gestandaardiseerd uitvoerformaat voor consistente rapportage

Deze praktische voorbeeld demonstreert essentiële concepten voor module-ontwikkeling terwijl het een nuttige tool voor systeembeheer creëert.

Het opzetten van de PowerShell-module

Je scripts beheren over meerdere systemen kan snel chaotisch worden. Maar wanneer jouw workflows een strijd worden, komen PowerShell-modules goed van pas. Een module is een gestructureerde manier om scripts te groeperen en te hergebruiken om tijd te besparen en fouten te verminderen.

Laten we belangrijke concepten combineren om een PowerShell-module te bouwen.

Begin met het maken van de modulemap en het definiëren van de module zelf om jouw werk te organiseren.

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

De opdracht Set-Content maakt een module genaamd ComputerInventory aan in het pad voor alle gebruikers. Deze locatie is gekozen omdat het de module toegankelijk maakt voor iedereen die zich aanmeldt op de machine, wat cruciaal is in bedrijfsomgevingen waar meerdere gebruikers toegang nodig hebben tot dezelfde PowerShell-functionaliteit. In tegenstelling tot gebruikersspecifieke locaties, zorgt dit gecentraliseerde pad voor consistente modulebeschikbaarheid en eenvoudiger beheer over het systeem.

Controleer de beschikbaarheid van de module:

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

Hoewel momenteel een huls, bevestigt dit dat het later adequaat zal laden.

Opzetten van Functies

Een goed gestructureerde module is van cruciaal belang, maar wat erin zit maakt het echt nuttig. Verspil geen tijd met het uitzoeken van wat elk deel doet in plaats van productief te zijn door een skelet te maken voor uw modulefuncties.

Open de module in een teksteditor zoals VS Code, en zet functies op.

Begin met het maken van tijdelijke functies met beschrijvende namen.

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

}

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

}

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

}

De functienamen volgen een consistente werkwoord-zelfstandignaamgeving.

De functienamen in PowerShell volgen een werkwoord-zelfstandignaamgeving, wat een gestandaardiseerd naamgevingspatroon is. In dit geval hebben de functies de namen:

Get-MemoryInfo
Get-StorageInfo
Get-ProcessorInfo

Elke functienaam begint met het werkwoord “Get” (wat aangeeft dat het informatie ophaalt) gevolgd door een zelfstandignaam die beschrijft welke informatie het ophaalt (Memory, Storage of Processor).

Deze naamgevingsconventie is belangrijk in PowerShell omdat het functies voorspelbaar maakt en gemakkelijker te begrijpen – gebruikers kunnen snel begrijpen wat een functie doet door alleen naar de naam te kijken.

Controleer hun bestaan door het volgende uit te voeren:

Get-Command -Module ComputerInventory

Wanneer u het commando Get-Command -Module ComputerInventory uitvoert, ziet u een uitvoer die hierop lijkt:

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

Dit commando lijst alle functies op die beschikbaar zijn in de ComputerInventory-module, waaronder de drie functies die we hebben gemaakt: Get-MemoryInfo, Get-StorageInfo en Get-ProcessorInfo.

Op dit moment bevat de module functieschalen. Laten we deze functies verbeteren door consistente uitvoer te definiëren met behulp van aangepaste objecten.

Gestandaardiseerde uitvoer met aangepaste objecten

Inconsistente uitvoer in scripts kan een eenvoudige taak veranderen in een nachtmerrie van gegevensverwerking en probleemoplossing. In professionele PowerShell-ontwikkeling is het waarborgen van consistente uitvoer een hoeksteen van effectief scripten.

Het standaardiseren van de uitvoer met aangepaste objecten helpt bij het handhaven van consistentie over functies.

In het volgende script:

De aangepaste objecten bevatten de eigenschappen ComputerName, HardwareCategory en Info.
De eigenschap HardwareCategory groepeert vergelijkbare hardwaretypen, en ComputerName is ontworpen voor schaalbaarheid naar meerdere computers.

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
}

Laten we eerst de module opnieuw importeren om ervoor te zorgen dat we de nieuwste versie hebben:

Import-Module ComputerInventory -Force

Nu kunt u de functies uitvoeren om hun uitvoer te zien:

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

Elke functie retourneert een hashtable met lege ComputerName en Info eigenschappen, maar met hun respectievelijke hardwarecategorieën gedefinieerd.

Het toevoegen van een Sessieparameter voor externe ondersteuning

Stel je voor dat je je scripts op tientallen of zelfs honderden computers moet uitvoeren. Als elke functie handmatig een computernaam vereiste, zou dit omslachtig en foutgevoelig zijn. Gelukkig biedt PowerShell Remoting een oplossing.

In plaats van een ComputerName parameter, gebruik een Session parameter om PowerShell Remoting te benutten:

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
}

Deze parameter zorgt voor flexibiliteit bij het schalen naar meerdere systemen.

De Session parameter is ontworpen om PowerShell Remoting te gebruiken voor het uitvoeren van commando’s op externe computers. Dit maakt het krachtig:

Het is gedefinieerd als een verplichte parameter die een PSSession-object accepteert (specifiek van het type System.Management.Automation.Runspaces.PSSession)
De Session parameter biedt automatisch de computernaam via $Session.ComputerName, die wordt ingevuld in het uitvoerobject

Deze aanpak biedt verschillende voordelen:

Het maakt efficiënt schalen mogelijk bij het werken met meerdere systemen
In plaats van nieuwe verbindingen te maken voor elk commando, kunt u dezelfde sessie hergebruiken voor meerdere bewerkingen, wat efficiënter is dan individuele verbindingen tot stand te brengen voor elke functieoproep
U kunt de functies testen door een enkele PSSession te maken en deze te gebruiken bij alle inventarisfuncties, zoals getoond in het voorbeeld waar een testsessie wordt gemaakt met: $testSession = New-PSSession -ComputerName SRV2

Sla op en importeer de module opnieuw:

ipmo ComputerInventory -Force

Het testen van de Functies

Hoe zorgt u ervoor dat een module werkt nadat u deze heeft gebouwd? Testen is essentieel om te bevestigen dat de functies van uw module werken zoals verwacht en nauwkeurige gegevens retourneren. Het overslaan van deze stap kan leiden tot verrassingen in productieomgevingen.

Maak een externe sessie aan en test de module:

$testSession = New-PSSession -ComputerName SRV2

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

Elke functie zou een object moeten retourneren met de verwachte eigenschappen en de juiste computernaam. Deze functies vormen de basis van een robuuste inventarisatietool.

Op basis van de getoonde code, wanneer u deze functies test met een externe sessie, zou de output er ongeveer zo uitzien:

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

Elke functie retourneert een hashtable met daarin de computernaam (van de sessie), de specifieke hardwarecategorie, en een Info-veld (momenteel leeg maar ontworpen om de daadwerkelijke hardware-informatie te bevatten).

Conclusie

In dit artikel heeft u geleerd waarom het maken van uw eigen PowerShell-modules essentieel is om unieke uitdagingen aan te pakken die geen kant-en-klare module kan oplossen. We hebben verkend hoe aangepaste modules een gamechanger kunnen zijn voor gespecialiseerde configuraties of processen binnen uw omgeving.

Dit is nog maar het begin van onze reis met de ComputerInventory module. In toekomstige blogposts zullen we dit fundament uitbreiden door echte hardware-informatieverzamelingsmogelijkheden, foutafhandeling en geavanceerde externe beheerfuncties toe te voegen.

Blijf op de hoogte terwijl we dit eenvoudige framework transformeren tot een krachtig hulpmiddel voor systeembeheerders!