Inzicht in een Windows PowerShell-module

  • Artikel

Een module is een set gerelateerde Windows PowerShell functies, gegroepeerd als een handige eenheid (meestal opgeslagen in één map). Door een set gerelateerde scriptbestanden, -assemblies en gerelateerde resources als module te definiëren, kunt u uw code veel eenvoudiger verwijzen, laden, persistent maken en delen dan anders.

Het belangrijkste doel van een module is het toestaan van de modularisering (dat wil weten, hergebruik en abstractie) van Windows PowerShell code. De meest eenvoudige manier om een module te maken is bijvoorbeeld door een eenvoudig script Windows PowerShell op te slaan als een PSM1-bestand. Zo kunt u de functies en variabelen in het script bepalen (openbaar of privé maken). Door het script op te slaan als een PSM1-bestand kunt u ook het bereik van bepaalde variabelen bepalen. Ten slotte kunt u ook cmdlets zoals Install-Module gebruiken om uw script te organiseren, te installeren en te gebruiken als bouwstenen voor grotere oplossingen.

Moduleonderdelen en -typen

Een module bestaat uit vier basisonderdelen:

  1. Een soort codebestand: meestal een PowerShell-script of een beheerde cmdlet-assembly.

  2. Iets anders dat het bovenstaande codebestand mogelijk nodig heeft, zoals aanvullende assemblies, helpbestanden of scripts.

  3. Een manifestbestand met een beschrijving van de bovenstaande bestanden, evenals metagegevens zoals auteurs- en versie-informatie.

  4. Een map die alle bovenstaande inhoud bevat en zich bevindt waar PowerShell deze redelijk kan vinden.

    Notitie

    Geen van deze onderdelen op zichzelf zijn daadwerkelijk nodig. Een module kan technisch bijvoorbeeld alleen een script zijn dat is opgeslagen in een PSM1-bestand. U kunt ook een module hebben die niets meer is dan een manifestbestand, dat hoofdzakelijk wordt gebruikt voor organisatorische doeleinden. U kunt ook een script schrijven dat dynamisch een module maakt en als zodanig niet daadwerkelijk een map nodig heeft om iets in op te slaan. In de volgende secties worden de typen modules beschreven die u kunt krijgen door de verschillende mogelijke onderdelen van een module te combineren en te koppelen.

Scriptmodules

Zoals de naam al aangeeft, is een scriptmodule een bestand ( ) dat geldige .psm1 Windows PowerShell bevat. Scriptontwikkelaars en beheerders kunnen dit type module gebruiken om modules te maken waarvan de leden functies, variabelen en meer bevatten. In het hart is een scriptmodule gewoon een Windows PowerShell-script met een andere extensie, waarmee beheerders import-, export- en beheerfuncties kunnen gebruiken.

Daarnaast kunt u een manifestbestand gebruiken om andere resources in uw module op te nemen, zoals gegevensbestanden, andere afhankelijke modules of runtimescripts. Manifestbestanden zijn ook handig voor het bijhouden van metagegevens, zoals ontwerp- en versie-informatie.

Ten slotte moet een scriptmodule, net als elke andere module die niet dynamisch is gemaakt, worden opgeslagen in een map die met PowerShell redelijk goed kan worden ontdekt. Meestal is dit het pad van de PowerShell-module; maar indien nodig kunt u expliciet beschrijven waar uw module is geïnstalleerd. Zie How to Write a PowerShell Script Module (Een PowerShell-scriptmodule schrijven) voor meer informatie.

Binaire modules

Een binaire module is een .NET Framework assembly ( ) die .dll gecompileerde code bevat, zoals C#. Cmdlet-ontwikkelaars kunnen dit type module gebruiken om cmdlets, providers en meer te delen. (Bestaande modules kunnen ook worden gebruikt als binaire modules.) Vergeleken met een scriptmodule kunt u met een binaire module cmdlets maken die sneller zijn of functies (zoals multithreading) gebruiken die niet zo eenvoudig te codeeren zijn in Windows PowerShell scripts.

Net als bij scriptmodules kunt u een manifestbestand opnemen om aanvullende resources te beschrijven die uw module gebruikt, en om metagegevens over uw module bij te houden. Op dezelfde manier moet u waarschijnlijk uw binaire module installeren in een map ergens langs het pad van de PowerShell-module. Zie How to Write a PowerShell Binary Module (Een binaire PowerShell-module schrijven) voor meer informatie.

Manifestmodules

Een manifestmodule is een module die gebruikmaakt van een manifestbestand om alle onderdelen ervan te beschrijven, maar geen kernassemblage of -script heeft. (Formeel laat een manifestmodule het ModuleToProcess element of van het manifest RootModule leeg.) U kunt echter nog steeds de andere functies van een module gebruiken, zoals de mogelijkheid om afhankelijke assemblies te laden of automatisch bepaalde voorverwerkingsscripts uit te voeren. U kunt ook een manifestmodule gebruiken als een handige manier om resources te verpakken die door andere modules worden gebruikt, zoals geneste modules, assemblies, typen of indelingen. Zie How to Write a PowerShell Module Manifest (Een PowerShell-modulemanifest schrijven) voor meer informatie.

Dynamische modules

Een dynamische module is een module die niet wordt geladen vanuit of wordt opgeslagen in een bestand. In plaats daarvan worden ze dynamisch gemaakt door een script met behulp van de cmdlet New-Module. Met dit type module kan een script op aanvraag een module maken die niet hoeft te worden geladen of opgeslagen in permanente opslag. Een dynamische module is van nature bedoeld om kort te zijn en kan daarom niet worden gebruikt door de Get-Module cmdlet . Op dezelfde manier hebben ze doorgaans geen modulemanifests nodig en hebben ze waarschijnlijk geen permanente mappen nodig om hun gerelateerde assemblies op te slaan.

Modulemanifests

Een modulemanifest is .psd1 een bestand dat een hashtabel bevat. De sleutels en waarden in de hashtabel doen het volgende:

  • De inhoud en kenmerken van de module beschrijven.

  • Definieer de vereisten.

  • Bepaal hoe de onderdelen worden verwerkt.

    Manifesten zijn niet vereist voor een module. Modules kunnen verwijzen naar scriptbestanden ( ), scriptmodulebestanden ( ), manifestbestanden ( ), opmaak- en typebestanden ( ), cmdlet- en providerassemblage's .ps1 .psm1 ( ), .psd1 .ps1xml .dll resourcebestanden, Help-bestanden, lokalisatiebestanden of een ander type bestand of resource dat is gebundeld als onderdeel van de module. Voor een geinterpolaliseerd script bevat de modulemap ook een set berichtencatalogusbestanden. Als u een manifestbestand aan de modulemap toevoegt, kunt u verwijzen naar de meerdere bestanden als één eenheid door te verwijzen naar het manifest.

    In het manifest zelf worden de volgende categorieën informatie beschreven:

  • Metagegevens over de module, zoals het versienummer van de module, de auteur en de beschrijving.

  • Vereisten die nodig zijn om de module te importeren, zoals de Windows PowerShell-versie, de CLR-versie (Common Language Runtime) en de vereiste modules.

  • Verwerkingsrichtlijnen, zoals de scripts, indelingen en typen die moeten worden verwerkt.

  • Beperkingen voor de leden van de module die moeten worden geëxporteerd, zoals de aliassen, functies, variabelen en cmdlets die moeten worden geëxporteerd.

    Zie How to Write a PowerShell Module Manifest (Een PowerShell-modulemanifest schrijven) voor meer informatie.

Een module opslaan en installeren

Zodra u een script-, binaire of manifestmodule hebt gemaakt, kunt u uw werk opslaan op een locatie waar anderen er toegang toe hebben. Uw module kan bijvoorbeeld worden opgeslagen in de systeemmap Windows PowerShell is geïnstalleerd, of in een gebruikersmap.

Over het algemeen kunt u bepalen waar u de module moet installeren met behulp van een van de paden die zijn opgeslagen in de $ENV:PSModulePath variabele . Het gebruik van een van deze paden betekent dat PowerShell uw module automatisch kan vinden en laden wanneer een gebruiker deze in de code aanroept. Als u uw module ergens anders opgeslagen, kunt u PowerShell dit expliciet laten weten door de locatie van uw module door te geven als parameter wanneer u Install-Module aanroept.

Ongeacht, het pad van de map wordt aangeduid als de basis van de module (ModuleBase) en de naam van het script, het binaire bestand of het manifestmodulebestand moet hetzelfde zijn als de naam van de modulemap, met de volgende uitzonderingen:

Module-cmdlets en variabelen

De volgende cmdlets en variabelen worden geleverd door Windows PowerShell voor het maken en beheren van modules.

Cmdlet New-Module Met deze cmdlet maakt u een nieuwe dynamische module die alleen in het geheugen bestaat. De module wordt gemaakt vanuit een scriptblok en de geëxporteerde leden, zoals de functies en variabelen, zijn onmiddellijk beschikbaar in de sessie en blijven beschikbaar totdat de sessie wordt gesloten.

Cmdlet New-ModuleManifest Met deze cmdlet maakt u een nieuw modulemanifestbestand (.psd1), vult u de waarden in en slaat u het manifestbestand op in het opgegeven pad. Deze cmdlet kan ook worden gebruikt om een modulemanifestsjabloon te maken die handmatig kan worden ingevuld.

Cmdlet Import-Module Met deze cmdlet voegt u een of meer modules toe aan de huidige sessie.

Cmdlet Get-Module Met deze cmdlet wordt informatie opgehaald over de modules die zijn of kunnen worden geïmporteerd in de huidige sessie.

Cmdlet Export-ModuleMember Met deze cmdlet geeft u de moduleleden (zoals cmdlets, functies, variabelen en aliassen) op die worden geëxporteerd uit een scriptmodulebestand (.psm1) of uit een dynamische module die is gemaakt met behulp van de New-Module cmdlet .

Cmdlet Remove-Module Met deze cmdlet worden modules uit de huidige sessie verwijderd.

Test-ModuleManifest-cmdlet Met deze cmdlet wordt gecontroleerd of een modulemanifest de onderdelen van een module nauwkeurig beschrijft door te controleren of de bestanden die worden vermeld in het modulemanifestbestand (.psd1) daadwerkelijk bestaan in de opgegeven paden.

$PSScriptRoot deze variabele bevat de map van waaruit de scriptmodule wordt uitgevoerd. Hiermee kunnen scripts het modulepad gebruiken om toegang te krijgen tot andere resources.

$env:PSModulePath Deze omgevingsvariabele bevat een lijst met de Windows PowerShell modules worden opgeslagen. Windows PowerShell gebruikt de waarde van deze variabele bij het automatisch importeren van modules en het bijwerken van Help-onderwerpen voor modules.

Zie ook

Een Windows PowerShell-module schrijven