Criando um Módulo do PowerShell do Mundo Real: Funções de Escoramento – techsyncer

Está a ter dificuldades em encontrar o módulo PowerShell perfeito para o seu cenário único? Com milhares de módulos disponíveis, pode parecer que deve simplesmente conformar-se com o que está disponível. Bem, isso poderia deixar a sua solução incompleta ou ineficiente. Por que não começar a criar módulos em vez disso?

Este guia irá ajudá-lo a criar módulos para construir soluções robustas e reutilizáveis adaptadas às suas necessidades.

Transforme os seus scripts em blocos de construção poderosos que pode reutilizar em diferentes projetos!

Criando um Módulo de Inventário de Computadores

Neste guia, iremos criar um módulo PowerShell para recolher informações sobre hardware de computadores. Este módulo irá ajudar os administradores de sistema a recolher e relatar informações sobre memória, armazenamento e detalhes do processador em vários sistemas.

O nosso módulo irá incluir:

Funções para recolher informações específicas de hardware
Suporte a sistemas remotos usando sessões PowerShell
Formato de saída padronizado para relatórios consistentes

Este exemplo prático demonstra conceitos essenciais de desenvolvimento de módulos ao criar uma ferramenta útil para administração de sistemas.

Configurando o Módulo PowerShell

Gerir os seus scripts em vários sistemas pode rapidamente tornar-se caótico. Mas quando os seus fluxos de trabalho se tornam uma batalha difícil, os módulos PowerShell são úteis. Um módulo é uma maneira estruturada de agrupar e reutilizar scripts para poupar tempo e reduzir erros.

Vamos combinar conceitos chave para construir um módulo PowerShell.

Comece por criar o diretório do módulo e definir o próprio módulo para organizar o seu trabalho.

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

O comando Set-Content cria um módulo chamado ComputerInventory no caminho de todos os usuários. Essa localização é escolhida porque torna o módulo acessível a qualquer pessoa que fizer login na máquina, o que é crucial em ambientes corporativos onde vários usuários precisam ter acesso à mesma funcionalidade do PowerShell. Ao contrário de locais específicos do usuário, este caminho centralizado garante a disponibilidade consistente do módulo e facilita a gestão em todo o sistema.

Verifique a disponibilidade do módulo:

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

Embora atualmente seja uma casca, isso confirma que ele será carregado adequadamente posteriormente.

Funções de Estruturação

Um módulo bem estruturado é crítico, mas o que está dentro dele é que o torna verdadeiramente útil. Evite perder tempo descobrindo o que cada parte faz em vez de ser produtivo, criando estrutura para as funções do seu módulo.

Abra o módulo em um editor de texto como o VS Code e, em seguida, estruture as funções.

Comece criando funções de espaço reservado com nomes descritivos.

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

}

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

}

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

}

Os nomes das funções seguem uma convenção de nomenclatura consistente de verbo-substantivo.

Os nomes das funções no PowerShell seguem uma convenção de nomenclatura de verbo-substantivo, que é um padrão de nomenclatura padronizado. Neste caso, as funções são nomeadas:

Get-MemoryInfo
Get-StorageInfo
Get-ProcessorInfo

Cada nome de função começa com o verbo “Get” (indicando que ela recupera informações), seguido por um substantivo que descreve que informações ele recupera (Memória, Armazenamento ou Processador).

Esta convenção de nomenclatura é importante no PowerShell porque torna as funções previsíveis e mais fáceis de entender – os usuários podem rapidamente compreender o que uma função faz apenas olhando para o seu nome.

Verifique a existência deles executando o seguinte:

Get-Command -Module ComputerInventory

Ao executar o comando Get-Command -Module ComputerInventory, você verá uma saída semelhante a esta:

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

Este comando lista todas as funções disponíveis no módulo ComputerInventory, que inclui as três funções que criamos: Get-MemoryInfo, Get-StorageInfo e Get-ProcessorInfo.

Nesta etapa, o módulo inclui cascas de funções. Vamos aprimorar essas funções definindo uma saída consistente usando objetos personalizados.

Saída Padronizada com Objetos Personalizados

As saídas inconsistentes em scripts podem transformar uma tarefa simples em um pesadelo de análise de dados e solução de problemas. No desenvolvimento profissional do PowerShell, garantir saídas consistentes é uma pedra angular da elaboração de scripts eficazes.

Padronizar a saída com objetos personalizados ajuda a manter a consistência entre as funções.

No script a seguir:

Os objetos personalizados incluem as propriedades ComputerName, HardwareCategory e Info.
A propriedade HardwareCategory agrupa tipos de hardware similares, e ComputerName é projetado para escalabilidade em vários computadores.

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
}

Primeiro, vamos reimportar o módulo para garantir que tenhamos a versão mais recente:

Import-Module ComputerInventory -Force

Agora você pode executar as funções para ver a saída delas:

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

Cada função retorna um hashtable com ComputerName vazio e propriedades Info, mas com suas respectivas categorias de hardware definidas.

Adicionando um Parâmetro de Sessão para Suporte Remoto

Imagine precisar executar seus scripts em dezenas ou até centenas de computadores. Se cada função exigisse a especificação manual de um nome de computador, seria complicado e propenso a erros. Felizmente, o PowerShell Remoting oferece uma solução.

Em vez de um parâmetro ComputerName, use um parâmetro Session para aproveitar o 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
}

Esse parâmetro garante flexibilidade ao escalar para vários sistemas.

O parâmetro de Sessão é projetado para usar o PowerShell Remoting para executar comandos em computadores remotos. Veja o que o torna poderoso:

É definido como um parâmetro obrigatório que aceita um objeto PSSession (especificamente do tipo System.Management.Automation.Runspaces.PSSession)
O parâmetro Session fornece automaticamente o nome do computador por meio de $Session.ComputerName, que é preenchido no objeto de saída

Essa abordagem oferece várias vantagens:

Permite dimensionamento eficiente ao trabalhar com vários sistemas
Em vez de criar novas conexões para cada comando, você pode reutilizar a mesma sessão para operações múltiplas, o que é mais eficiente do que estabelecer conexões individuais para cada chamada de função
Você pode testar as funções criando uma única PSSession e usando-a em todas as funções de inventário, como mostrado no exemplo em que uma sessão de teste é criada com: $testSession = New-PSSession -ComputerName SRV2

Salve e importe novamente o módulo:

ipmo ComputerInventory -Force

Testando as Funções

Como garantir que um módulo funcione após construí-lo? Testar é essencial para confirmar que as funções do seu módulo se comportam conforme esperado e retornam dados precisos. Pular esta etapa pode resultar em surpresas em ambientes de produção.

Estabeleça uma sessão remota e teste o módulo:

$testSession = New-PSSession -ComputerName SRV2

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

Cada função deve retornar um objeto com as propriedades esperadas e o nome correto do computador. Essas funções formam a base de uma ferramenta de inventário robusta.

Com base no código mostrado, ao testar essas funções com uma sessão remota, a saída seria algo semelhante a isso:

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

Cada função retorna um hashtable contendo o nome do computador (da sessão), a categoria específica de hardware e um campo Info (atualmente nulo, mas projetado para conter as informações reais de hardware).

Conclusão

Neste artigo, você aprendeu por que criar seus próprios módulos do PowerShell é essencial para lidar com desafios únicos que nenhum módulo pronto pode resolver. Exploramos como módulos personalizados podem ser um diferencial para configurações ou processos especializados dentro do seu ambiente.

Este é apenas o começo da nossa jornada com o módulo ComputerInventory. Nos próximos posts do blog, vamos expandir esta base adicionando capacidades reais de coleta de informações de hardware, tratamento de erros e recursos avançados de gerenciamento remoto.

Fique ligado enquanto transformamos este framework básico em uma ferramenta poderosa para administradores de sistemas!