¿Estás luchando por encontrar el módulo PowerShell perfecto para tu escenario único? Con miles de módulos disponibles, puede parecer que debe conformarse con lo que está ahí fuera. Bueno, eso podría dejar su solución incompleta o ineficiente. ¿Por qué no comenzar a crear módulos en su lugar?

Esta guía lo guiará a través de la creación de módulos para construir soluciones robustas y reutilizables adaptadas a sus necesidades.

¡Convierta sus guiones en poderosos bloques de construcción que puede reutilizar en diferentes proyectos!

Construyendo un módulo de inventario de computadora

En esta guía, crearemos un módulo PowerShell para recopilar información de hardware de la computadora. Este módulo ayudará a los administradores del sistema a recopilar e informar sobre la memoria, el almacenamiento y los detalles del procesador en múltiples sistemas.

Nuestro módulo presentará:

• Funciones para recopilar información de hardware específica
• Soporte de sistema remoto utilizando sesiones de PowerShell
• Formato de salida estandarizado para informes consistentes

Este ejemplo práctico demuestra conceptos esenciales de desarrollo de módulos al tiempo que crea una herramienta útil para la administración del sistema.

Configuración del módulo PowerShell

Administrar sus scripts en múltiples sistemas puede volverse caótico rápidamente. Pero cuando tus flujos de trabajo se convierten en una batalla cuesta arriba, los módulos de PowerShell son útiles. Un módulo es una forma estructurada de agrupar y reutilizar scripts para ahorrar tiempo y reducir los errores.

Combinemos conceptos clave para construir un módulo PowerShell.

Comience creando el directorio del módulo y definiendo el módulo en sí para organizar su trabajo.

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

El Set-Content El comando crea un módulo llamado ComputerInventory En el camino de todos los usuarios. Esta ubicación se elige porque hace que el módulo sea accesible para cualquier persona que inicie sesión en la máquina, lo cual es crucial en entornos empresariales donde múltiples usuarios necesitan acceso a la misma funcionalidad de PowerShell. A diferencia de las ubicaciones específicas del usuario, esta ruta centralizada garantiza una disponibilidad consistente del módulo y una gestión más fácil en todo el sistema.

Verifique la disponibilidad del módulo:

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

Aunque actualmente es un shell, esto confirma que se cargará adecuadamente más tarde.

Funciones de andamio

Un módulo bien estructurado es crítico, pero lo que está dentro lo hace realmente útil. Evite perder el tiempo descubrir qué hace cada parte en lugar de ser productivo creando andamios para las funciones de su módulo.

Abra el módulo en un editor de texto como VS Código, luego las funciones de andamio.

Comience creando funciones de marcador de posición con nombres descriptivos.

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

}

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

}

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

}

Los nombres de funciones siguen una convención consistente de nombres de sustantivos verbales.

Los nombres de funciones en PowerShell siguen una convención de nombres de sustantivos verbales, que es un patrón de nombres estandarizado. En este caso, las funciones se nombran:

• Get-MemoryInfo
• Get-storageInfo
• Get-processorinfo

Cada nombre de la función comienza con el verbo “Get” (indicando que recupera información) seguido de un sustantivo que describe qué información recupera (memoria, almacenamiento o procesador).

Esta convención de nombres es importante en PowerShell porque hace que las funciones sean predecibles y más fáciles de entender: los usuarios pueden comprender rápidamente lo que hace una función simplemente mirando su nombre.

Verifique su existencia ejecutando lo siguiente:

Get-Command -Module ComputerInventory

Cuando ejecutas el comando Get-Command -Module ComputerInventoryverías una salida similar 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 enumera todas las funciones disponibles en el módulo ComputerInventory, que incluye las tres funciones que creamos: Get-MemoryInfo, Get-StorageInfo y Get-ProcessorInfo.

En esta etapa, el módulo incluye capas de funciones. Mejoremos estas funciones definiendo la salida consistente utilizando objetos personalizados.

Salida estandarizada con objetos personalizados

Los resultados inconsistentes en los scripts pueden convertir una tarea simple en una pesadilla de análisis de datos y solución de problemas. En el desarrollo profesional de PowerShell, garantizar resultados consistentes es una piedra angular de secuencias de comandos efectivas.

Estandarizar la salida con objetos personalizados ayuda a mantener la consistencia entre las funciones.

En el siguiente script:

• Los objetos personalizados incluyen ComputerName, HardwareCategoryy Info propiedades.
• El HardwareCategory grupos de propiedades tipos de hardware similares, y ComputerName está diseñado para escalabilidad múltiple.

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
}

Primero, volvamos a importar el módulo para asegurarnos de que tengamos la última versión:

Import-Module ComputerInventory -Force

Ahora puede ejecutar las funciones para ver su salida:

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 función devuelve un hashtable con las propiedades de información e información vacía, pero con sus respectivas categorías de hardware definidas.

Agregar un parámetro de sesión para soporte remoto

Imagine la necesidad de ejecutar sus scripts en docenas o incluso cientos de computadoras. Si cada función requería especificar manualmente el nombre de una computadora, sería engorroso y propenso a errores. Afortunadamente, PowerShell Remoting proporciona una solución.

En lugar de un ComputerName parámetro, use un Session Parámetro para aprovechar el control remoto de PowerShell:

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
}

Este parámetro garantiza la flexibilidad al escalar a múltiples sistemas.

El parámetro de sesión está diseñado para usar PowerShell Remoting para ejecutar comandos en computadoras remotas. Esto es lo que lo hace poderoso:

• Se define como un parámetro obligatorio que acepta un objeto PSSession (específicamente de tipo System.Management.Automation.RunSpaces.PsSession)
• El parámetro de la sesión proporciona automáticamente el nombre de la computadora a través de $ session.computername, que se pobla en el objeto de salida

Este enfoque ofrece varias ventajas:

• Permite una escala eficiente cuando se trabaja con múltiples sistemas.
• En lugar de crear nuevas conexiones para cada comando, puede reutilizar la misma sesión para múltiples operaciones, que es más eficiente que establecer conexiones individuales para cada llamada de función
• Puede probar las funciones creando un solo pssession y usándolo en todas las funciones de inventario, como se muestra en el ejemplo donde se crea una sesión de prueba con: $ testSession = new -PSSession -Comutername SRV2

Guarde y vuelva a importar el módulo:

ipmo ComputerInventory -Force

Prueba de las funciones

¿Cómo se asegura de que un módulo funcione después de construirlo? Las pruebas son esenciales para confirmar que las funciones de su módulo funcionan como se esperaba y devuelve datos precisos. Saltar este paso podría conducir a sorpresas en entornos de producción.

Establecer una sesión remota y probar el módulo:

$testSession = New-PSSession -ComputerName SRV2

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

Cada función debe devolver un objeto con las propiedades esperadas y el nombre correcto de la computadora. Estas funciones forman la base de una herramienta de inventario robusta.

Según el código que se muestra, cuando prueba estas funciones con una sesión remota, la salida se vería así:

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 función devuelve un hashtable que contiene el nombre de la computadora (de la sesión), la categoría de hardware específica y un campo de información (actualmente nulo pero diseñado para contener la información de hardware real).

Conclusión

En este artículo, ha aprendido por qué crear sus propios módulos de PowerShell es esencial para abordar desafíos únicos que ningún módulo estándar puede abordar. Exploramos cómo los módulos personalizados pueden ser un cambio de juego para configuraciones o procesos especializados dentro de su entorno.

Este es solo el comienzo de nuestro viaje con el módulo ComputerInventory. En las próximas publicaciones de blog, ampliaremos esta base agregando capacidades reales de recopilación de información de hardware, manejo de errores y funciones avanzadas de administración remota.

¡Estén atentos mientras transformamos este marco básico en una herramienta poderosa para los administradores del sistema!