Creazione di un modulo PowerShell del mondo reale: Funzioni di impalcatura – techsyncer

Stai lottando per trovare il modulo PowerShell perfetto per il tuo scenario unico? Con migliaia di moduli disponibili, potresti sentirti tentato di accontentarti di ciò che c’è. Beh, questo potrebbe lasciare la tua soluzione incompleta o inefficiente. Perché non iniziare a creare moduli invece?

Questa guida ti accompagnerà nella creazione di moduli per costruire soluzioni robuste e riutilizzabili personalizzate alle tue esigenze.

Trasforma i tuoi script in potenti blocchi di costruzione riutilizzabili su diversi progetti!

Creazione di un Modulo di Inventario dei Computer

In questa guida, creeremo un modulo PowerShell per raccogliere informazioni sull’hardware del computer. Questo modulo aiuterà gli amministratori di sistema a raccogliere e segnalare informazioni sulla memoria, lo storage e i dettagli del processore su più sistemi.

Il nostro modulo includerà:

Funzioni per raccogliere informazioni specifiche sull’hardware
Supporto per sistemi remoti utilizzando sessioni PowerShell
Formato di output standardizzato per segnalazioni coerenti

Questo esempio pratico dimostra concetti essenziali dello sviluppo di moduli mentre si crea uno strumento utile per l’amministrazione di sistema.

Configurazione del Modulo PowerShell

Gestire i tuoi script su più sistemi può rapidamente diventare caotico. Ma quando i tuoi flussi di lavoro diventano una battaglia in salita, i moduli PowerShell sono utili. Un modulo è un modo strutturato per raggruppare e riutilizzare script per risparmiare tempo e ridurre gli errori.

Uniamo i concetti chiave per costruire un modulo PowerShell.

Inizia creando la directory del modulo e definendo il modulo stesso per organizzare il tuo lavoro.

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

Il comando Set-Content crea un modulo chiamato ComputerInventory nel percorso per tutti gli utenti. Questa posizione è stata scelta perché rende il modulo accessibile a chiunque acceda alla macchina, il che è cruciale negli ambienti aziendali in cui più utenti hanno bisogno di accedere alla stessa funzionalità di PowerShell. A differenza delle posizioni specifiche degli utenti, questo percorso centralizzato garantisce una disponibilità costante del modulo e una gestione più semplice dell’intero sistema.

Verificare la disponibilità del modulo:

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

Sebbene attualmente sia solo una shell, ciò conferma che verrà caricato correttamente in seguito.

Funzioni di Impalcatura

Un modulo ben strutturato è fondamentale, ma ciò che contiene lo rende veramente utile. Evita di perdere tempo a capire cosa fa ogni parte anziché essere produttivo creando l’impalcatura per le funzioni del tuo modulo.

Apri il modulo in un editor di testo come VS Code, quindi crea le funzioni di impalcatura.

Inizia creando funzioni segnaposto con nomi descrittivi.

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

}

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

}

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

}

I nomi delle funzioni seguono una convenzione di denominazione costante verbo-sostantivo.

I nomi delle funzioni in PowerShell seguono una convenzione di denominazione verbo-sostantivo, che è un modello di denominazione standardizzato. In questo caso, le funzioni sono chiamate:

Get-MemoryInfo
Get-StorageInfo
Get-ProcessorInfo

Ogni nome di funzione inizia con il verbo “Get” (indicando che recupera informazioni) seguito da un sostantivo che descrive le informazioni che recupera (Memory, Storage o Processor).

Questa convenzione di denominazione è importante in PowerShell perché rende le funzioni prevedibili e più facili da capire: gli utenti possono rapidamente comprendere cosa fa una funzione solo guardando il suo nome.

Verifica la loro esistenza eseguendo quanto segue:

Get-Command -Module ComputerInventory

Quando esegui il comando Get-Command -Module ComputerInventory, vedrai un output simile a questo:

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

Questo comando elenca tutte le funzioni disponibili nel modulo ComputerInventory, che include le tre funzioni che abbiamo creato: Get-MemoryInfo, Get-StorageInfo e Get-ProcessorInfo.

A questo punto, il modulo include le strutture delle funzioni. Miglioriamo queste funzioni definendo un output coerente utilizzando oggetti personalizzati.

Output standardizzato con oggetti personalizzati

Gli output non coerenti tra script possono trasformare un compito semplice in un incubo di analisi dati e risoluzione dei problemi. Nello sviluppo professionale di PowerShell, garantire output coerenti è un pilastro dello scripting efficace.

Standardizzare l’output con oggetti personalizzati aiuta a mantenere la coerenza tra le funzioni.

Nello script seguente:

Gli oggetti personalizzati includono le proprietà ComputerName, HardwareCategory e Info.
La proprietà HardwareCategory raggruppa tipi di hardware simili e ComputerName è progettata per la scalabilità multi-computer.

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
}

Per prima cosa, re-importiamo il modulo per assicurarci di avere l’ultima versione:

Import-Module ComputerInventory -Force

Ora puoi eseguire le funzioni per vedere il loro output:

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

Ogni funzione restituisce una tabella hash con ComputerName e proprietà Info vuote, ma con le rispettive categorie hardware definite.

Aggiunta di un parametro Session per il supporto remoto

Immagina di dover eseguire i tuoi script su decine o addirittura centinaia di computer. Se ogni funzione richiedesse di specificare manualmente un nome computer, sarebbe scomodo e soggetto a errori. Fortunatamente, il PowerShell Remoting fornisce una soluzione.

Utilizza un parametro Session anziché un parametro ComputerName per sfruttare il 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
}

Questo parametro garantisce flessibilità quando si passa a più sistemi.

Il parametro Session è progettato per utilizzare il PowerShell Remoting per eseguire comandi su computer remoti. Ecco cosa lo rende potente:

È definito come un parametro obbligatorio che accetta un oggetto PSSession (specificamente di tipo System.Management.Automation.Runspaces.PSSession)
Il parametro Session fornisce automaticamente il nome del computer tramite $Session.ComputerName, che viene popolato nell’oggetto di output

Questo approccio offre diversi vantaggi:

Consente di scalare efficientemente quando si lavora con più sistemi
Piuttosto che creare nuove connessioni per ciascun comando, è possibile riutilizzare la stessa sessione per operazioni multiple, il che è più efficiente rispetto all’istituzione di connessioni individuali per ciascuna chiamata di funzione
Puoi testare le funzioni creando un’unica PSSession e utilizzandola per tutte le funzioni di inventario, come mostrato nell’esempio in cui viene creata una sessione di test con: $testSession = New-PSSession -ComputerName SRV2

Salva e riesporta il modulo:

ipmo ComputerInventory -Force

Testare le Funzioni

Come puoi assicurarti che un modulo funzioni dopo averlo costruito? Il testing è essenziale per confermare che le funzioni del tuo modulo si comportino come previsto e restituiscano dati accurati. Saltare questo passaggio potrebbe portare a sorprese negli ambienti di produzione.

Stabilisci una sessione remota e testa il modulo:

$testSession = New-PSSession -ComputerName SRV2

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

Ogni funzione dovrebbe restituire un oggetto con le proprietà attese e il nome del computer corretto. Queste funzioni formano la base di uno strumento di inventario robusto.

Sulla base del codice mostrato, quando testi queste funzioni con una sessione remota, l’output apparirebbe simile a questo:

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

Ogni funzione restituisce una hashtable contenente il nome del computer (dalla sessione), la categoria hardware specifica e un campo Info (attualmente nullo ma progettato per contenere le informazioni hardware effettive).

Conclusione

In questo articolo, hai appreso perché creare i tuoi moduli PowerShell è essenziale per affrontare sfide uniche che nessun modulo preconfezionato può risolvere. Abbiamo esplorato come i moduli personalizzati possano essere un cambiamento decisivo per configurazioni o processi specializzati all’interno del tuo ambiente.

Questo è solo l’inizio del nostro viaggio con il modulo ComputerInventory. Nei prossimi post del blog, amplieremo questa base aggiungendo capacità di raccolta di informazioni hardware reali, gestione degli errori e funzionalità avanzate di gestione remota.

Rimanete sintonizzati mentre trasformiamo questo framework di base in uno strumento potente per gli amministratori di sistema!