Pide tu presupuesto ya!

Articulo BLOG

Creación de un informe de inventario de computadoras

La creación de herramientas PowerShell es una parte esencial para aprender a pasar de un programador de copiar y pegar a alguien que pueda crear scripts reales y reutilizables. Como ejemplo de una metodología de creación de herramientas, creemos una herramienta sencilla de informe de inventario informático que le guiará a través del proceso de creación de una herramienta sencilla pero eficaz utilizando PowerShell.

Comenzaremos leyendo datos de un archivo CSV, luego consultaremos los detalles de la computadora usando CIM y finalmente generaremos los resultados en un formato estructurado. ¡Empecemos!

Paso 1: leer y procesar un archivo CSV

Primero, necesitamos configurar nuestro entorno. Crearemos un archivo CSV de muestra que contiene el nombre de una computadora y el departamento en el que puede estar esa computadora. También crearé un script en blanco llamado Start-ComputerInventoryReport.ps1.

# Sample CSV content
@'
ComputerName,Department
PC1,HR
PC2,Finance
'@ | Set-Content -Path C:computers.csv

Set-Content -Path C:Start-ComputerInventoryReport.ps1 -Value ''

A continuación, abra C:Start-ComputerInventoryReport.ps1 en su editor favorito y ¡comencemos con las secuencias de comandos!

Primero, lea las computadoras en un archivo CSV. Deberías ver cada fila CSV.

$computers = Import-Csv -Path C:computers.csv
$computers

Esto importará nuestro archivo CSV y almacenará los datos en el $computers variable.

Paso 2: agregar una verificación de conexión

Siempre recomiendo empezar poco a poco; Comience con un solo objeto y luego construya sobre eso. Así que comience a trabajar con una sola computadora y obtenga todo el código.

Dado que nuestro script consultará computadoras remotas, es una buena práctica verificar si la computadora está en línea antes de continuar:

Test-Connection -ComputerName $computers[0].ComputerName -Count 1 -Quiet

Este comando regresará True si la máquina está en línea y False de lo contrario.

Paso 3: procesar cada computadora

Para manejar varias computadoras, usaremos un foreach bucle:

foreach ($computer in $computers) {
    Write-Host "Processing the [$($computer.ComputerName)] computer."
}

Por ahora, centrémonos en una sola computadora ajustando temporalmente nuestro bucle:

foreach ($computer in $computers[0]) {
    Write-Host "Processing the [$($computer.ComputerName)] computer."
}

Paso 4: crear el objeto de salida

queremos reunir la ComputerName, Departmenty IsOnline propiedades. Creemos una tabla hash y convirtámosla en un objeto personalizado:

foreach ($computer in $computers[0]) {
    $output = @{
        ComputerName = $computer.ComputerName
        Department   = $computer.Department
        IsOnline     = $null
    }
    [pscustomobject]$output
}

Ahora, llene el IsOnline propiedad utilizando el Test-Connection dominio:

foreach ($computer in $computers[0]) {
    $output = @{
        ComputerName = $computer.ComputerName
        Department   = $computer.Department
        IsOnline     = $null
    }

    $isOnline = Test-Connection -ComputerName $computer.ComputerName -Count 1 -Quiet
    $output.IsOnline = $isOnline
    [pscustomobject]$output
}

Paso 5: procesar todas las computadoras

Finalmente, elimine el foco temporal de computadora única y procese todas las computadoras:

foreach ($computer in $computers) {
    $output = @{
        ComputerName = $computer.ComputerName
        Department   = $computer.Department
        IsOnline     = $null
    }

    $isOnline = Test-Connection -ComputerName $computer.ComputerName -Count 1 -Quiet
    $output.IsOnline = $isOnline
    [pscustomobject]$output
}

Paso 6: Agregar consulta CIM

Ampliemos nuestra herramienta para recopilar información adicional, como el fabricante, el modelo, el número de CPU y la RAM total de cada computadora que utiliza la clase CIM. Win32_ComputerSystem:

foreach ($computer in $computers) {
    $output = @{
        ComputerName = $computer.ComputerName
        Department   = $computer.Department
        IsOnline     = $null
        Manufacturer = $null
        Model        = $null
        CPUCount     = $null
        TotalRAM     = $null
    }

    $isOnline = Test-Connection -ComputerName $computer.ComputerName -Count 1 -Quiet
    $output.IsOnline = $isOnline

    if ($isOnline) {
        $systemInfo = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $computer.ComputerName
        $output.Manufacturer = $systemInfo.Manufacturer
        $output.Model        = $systemInfo.Model
        $output.CPUCount     = $systemInfo.NumberOfProcessors
        $output.TotalRAM     = $systemInfo.TotalPhysicalMemory
    }

    [pscustomobject]$output
}

Paso 7: Refactorización utilizando Pipeline

Para hacer que nuestra herramienta sea más flexible, refactoricémosla para aceptar entradas del proceso. Esto nos permite utilizar varias fuentes de datos, no solo archivos CSV:

[CmdletBinding()]
param(
    [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
    [string]$ComputerName
)

process {
    $output = @{
        ComputerName = $ComputerName
        IsOnline     = $null
        Manufacturer = $null
        Model        = $null
        CPUCount     = $null
        TotalRAM     = $null
    }

    $isOnline = Test-Connection -ComputerName $ComputerName -Count 1 -Quiet
    $output.IsOnline = $isOnline

    if ($isOnline) {
        $systemInfo = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $ComputerName
        $output.Manufacturer = $systemInfo.Manufacturer
        $output.Model        = $systemInfo.Model
        $output.CPUCount     = $systemInfo.NumberOfProcessors
        $output.TotalRAM     = $systemInfo.TotalPhysicalMemory
    }

    [pscustomobject]$output
}

Ahora puede canalizar datos desde varias fuentes:

Get-ADComputer -Filter * -SearchBase "OU=IT, DC=contoso, DC=com" |
Select-Object -Property *,@{n='ComputerName';e={$_.Name}} -ExcludeProperty Name |
C:Start-ComputerInventoryReportv4.ps1

Paso 8: guardar la salida en CSV

Agreguemos funcionalidad para guardar el resultado en un archivo CSV:

[CmdletBinding()]
param(
    [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
    [string]$ComputerName,

    [Parameter()]
    [string]$OutputFilePath
)

process {
    $output = @{
        ComputerName = $ComputerName
        IsOnline     = $null
        Manufacturer = $null
        Model        = $null
        CPUCount     = $null
        TotalRAM     = $null
    }

    $isOnline = Test-Connection -ComputerName $ComputerName -Count 1 -Quiet
    $output.IsOnline = $isOnline

    if ($isOnline) {
        $systemInfo = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $ComputerName
        $output.Manufacturer = $systemInfo.Manufacturer
        $output.Model        = $systemInfo.Model
        $output.CPUCount     = $systemInfo.NumberOfProcessors
        $output.TotalRAM     = $systemInfo.TotalPhysicalMemory
    }

    $out = [pscustomobject]$output
    if ($PSBoundParameters.ContainsKey('OutputFilePath')) {
        $out | Export-Csv -Path $OutputFilePath -Append
    }
    $out
}

Paso 9: Agregar manejo de errores

Finalmente, agreguemos manejo de errores para que nuestro script sea más sólido:

[CmdletBinding()]
param(
    [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
    [string]$ComputerName,

    [Parameter()]
    [string]$OutputFilePath
)

begin {
    $ErrorActionPreference = 'Stop'
}

process {
    try {
        $output = @{
            ComputerName = $ComputerName
            IsOnline     = $null
            Manufacturer = $null
            Model        = $null
            CPUCount     = $null
            TotalRAM     = $null
            Error        = $null
        }

        $isOnline = Test-Connection -ComputerName $ComputerName -Count 1 -Quiet
        $output.IsOnline = $isOnline

        if ($isOnline) {
            $systemInfo = Get-CimInstance -ClassName Win32_ComputerSystem -ComputerName $ComputerName
            $output.Manufacturer = $systemInfo.Manufacturer
            $output.Model        = $systemInfo.Model
            $output.CPUCount     = $systemInfo.NumberOfProcessors
            $output.TotalRAM     = $systemInfo.TotalPhysicalMemory
        }

        $out = [pscustomobject]$output
    }
    catch {
        $output.Error = $_.Exception.Message
        $out = [pscustomobject]$output
    }
    finally {
        if ($PSBoundParameters.ContainsKey('OutputFilePath')) {
            $out | Export-Csv -Path $OutputFilePath -Append
        }
        $out
    }
}

Si sigue estos pasos, habrá creado una herramienta integral para generar un informe de inventario de computadoras mediante PowerShell. Esta herramienta puede leer de varias fuentes, consultar información del sistema, manejar errores y exportar los resultados a un archivo CSV. ¡Feliz guión!

Written by

Leave a comment