El Blog de Gualtrysoft

Windows 2000/2003/2008, Active Directory, VBScript, Hyper-V, PowerShell y todo aquello interesante a la hora de usar, configurar y administrar Windows Server. También tenemos longanizas…

PowerShell: Cmdlet para inventariar los procesadores de un equipo

Posted by urpiano en Jueves 9 \09\UTC diciembre \09\UTC 2010

Este Cmdlet permite obtener información sobre los procesadores de la máquina recibida como parámetro o de la máquina local si se omite este parámetro. La información es obtenida procesando la clase WMI Win32_Processor del espacio de nombres root/CIMv2. La función permite especificar las credenciales con las que se conectará a WMI, credenciales que serán ignoradas en el caso del equipo local, pues no se puede acceder a WMI con credenciales alternativas desde el equipo local.

Este Cmdlet requiere otra serie de Cmdlets auxiliares, que lo que hacen es cambiar el valor numérico de determinadas numeraciones por su valor conceptual. Además de ésto, usa el Cmdlet Invoke-WmiExpression, que publiqué anteriormente; el presente Cmdlet es un ejemplo de la utilidad de Get-WmiExpression.

El Cmdlet incluye ayuda, pego a continuación la ayuda con modificador -Detailed (esta ayuda se basa en la prestación de ayuda basada en comentarios de PowerShell 2.0 ¿Qué todavía tienes la versión 1.0 y no la 2.0? ¿A qué esperas para instalarla si es mucho mejor?):

NOMBRE
    Get-Processor
    
SINOPSIS
    Devuelve información sobre los procesadores de un equipo.
    
SINTAXIS
    Get-Processor [[-ComputerName] <String>] [[-Credential] <Object>] [<CommonParameters>]
    
DESCRIPCIÓN
    Este Cmdlet permite obtener información sobre los procesadores de la
    máquina recibida como parámetro o de la máquina local si se omite este
    parámetro. La información es obtenida procesando la clase WMI
    Win32_Processor del espacio de nombres root/CIMv2. La función permite
    especificar las credenciales con las que se conectará a WMI, credenciales
    que serán ignoradas en el caso del equipo local, pues no se puede acceder a
    WMI con credenciales alternativas desde el equipo local.
    
    La función permite canalización, admitiendo como entrada nombres o IPs de
    equipos
    
PARÁMETROS
    -ComputerName <String>
        Nombre o IP del equipo al que se consultará. Tiene también los alias
        "Equipo","Sistema","E","C" y "S".
        
    -Credential <Object>
        Nombre de usuario o credenciales completas del usuario con el que se
        conectara a WMI. En caso de pasarse sólo el nombre de usuario, se pedirá
        entrar la contraseña del mismo. Si se pasan credenciales y se consulta el
        equipo local, las credenciales serán ignoradas, pues no se puede conectar
        a WMI del equipo local con credenciales alternativas. Tiene también los
        alias "Usuario","U","Credenciales" y "Cred".
        
    <CommonParameters>
        Este cmdlet admite los parámetros comunes Verbose, Debug,
        ErrorAction, ErrorVariable, WarningAction, WarningVariable,
        OutBuffer y OutVariable. Para obtener más información, escriba:
        "get-help about_commonparameters".
    
    -------------------------- EJEMPLO 1 --------------------------
    
    PS >Get-Processor
    
    Muestra por pantalla los procesadores del equipo local.
    
    -------------------------- EJEMPLO 2 --------------------------
    
    PS >Get-Processor -ComputerName Mortadelo-PC
    
    Muestra por pantalla los procesadores del equipo de nombre Mortadelo-PC.
    
    -------------------------- EJEMPLO 3 --------------------------
    
    PS >Get-Processor -C Mortadelo-PC -Credential TIA\Bacterio
    
    Muestra por pantalla los procesadores del equipo de nombre Mortadelo-PC,
    conectando a WMI con el usuario TIA\Bacterio; se solicitará la contraseña
    de dicho usuario.
    
    -------------------------- EJEMPLO 4 --------------------------
    
    PS >"Mortadelo-PC","Filemon-PC" | Get-Processor -Cred TIA\Bacterio
    
    Muestra por pantalla los procesadores de los equipos de nombre Mortadelo-PC
    y Filemon-PC, conectando a WMI con el usuario TIA\Bacterio; se solicitará la
    contraseña de dicho usuario.
    
    -------------------------- EJEMPLO 5 --------------------------
    
    PS >$Usuario = Get-Credential  
    PS >"Mortadelo-PC","Filemon-PC" | Get-Processor -Usuario $Usuario

    Muestra por pantalla los procesadores de los equipos de nombre Mortadelo-PC
    y Filemon-PC, conectando a WMI con el usuario establecido previamente con
    Get-Credential en la variable $Usuario.
    
    -------------------------- EJEMPLO 6 --------------------------
    
    PS >$Usr = Get-Credential    
    PS >Get-Content c:\Equipos.txt | Get-Processor -U $Usr | Export-CSV c:\Proc.csv

    Este ejemplo muestra una manera muy útil de usar esta función. Guarda, en el
    fichero de valores separados por coma c:\Proc.csv, un listado con los
    procesadores de los equipos contenidos en el fichero de texto
    c:\Equipos.txt, que contiene un nombre de equipo por línea, conectando a WMI
    con el usuario, establecido previamente con Get-Credential, en la variable
    $Usr.

Este es el código del Cmdlet:

Function Get-ProcessorArchitecture([Int16]$Architecture)
{
    Switch($Architecture)
    {
        0{"x86"}
        1{"MIPS"}
        2{"Alpha"}
        3{"PowerPC"}
        6{"Intel Itanium Processor Family (IPF)"}
        9{"x64"}
    }
}
Function Get-ProcessorFamily([Int16]$Family)
{
    Switch($Family)
    {
        1{"Other"}
        2{"Unknown"}
        3{"8086"}
        4{"80286"}
        5{"Intel386™ Processor"}
        6{"Intel486™ Processor"}
        7{"8087"}
        8{"80287"}
        9{"80387"}
        10{"80487"}
        11{"Pentium Brand"}
        12{"Pentium Pro"}
        13{"Pentium II"}
        14{"Pentium Processor with MMX™ Technology"}
        15{"Celeron™"}
        16{"Pentium II Xeon™"}
        17{"Pentium III"}
        18{"M1 Family"}
        19{"M2 Family"}
        24{"AMD Duron™ Processor Family"}
        25{"K5 Family"}
        26{"K6 Family"}
        27{"K6-2"}
        28{"K6-3"}
        29{"AMD Athlon™ Processor Family"}
        30{"AMD2900 Family"}
        31{"K6-2+"}
        32{"Power PC Family"}
        33{"Power PC 601"}
        34{"Power PC 603"}
        35{"Power PC 603+"}
        36{"Power PC 604"}
        37{"Power PC 620"}
        38{"Power PC X704"}
        39{"Power PC 750"}
        48{"Alpha Family"}
        49{"Alpha 21064"}
        50{"Alpha 21066"}
        51{"Alpha 21164"}
        52{"Alpha 21164PC"}
        53{"Alpha 21164a"}
        54{"Alpha 21264"}
        55{"Alpha 21364"}
        64{"MIPS Family"}
        65{"MIPS R4000"}
        66{"MIPS R4200"}
        67{"MIPS R4400"}
        68{"MIPS R4600"}
        69{"MIPS R10000"}
        80{"SPARC Family"}
        81{"SuperSPARC"}
        82{"microSPARC II"}
        83{"microSPARC IIep"}
        84{"UltraSPARC"}
        85{"UltraSPARC II"}
        86{"UltraSPARC IIi"}
        87{"UltraSPARC III"}
        88{"UltraSPARC IIIi"}
        96{"68040"}
        97{"68xxx Family"}
        98{"68000"}
        99{"68010"}
        100{"68020"}
        101{"68030"}
        112{"Hobbit Family"}
        120{"Crusoe™ TM5000 Family"}
        121{"Crusoe™ TM3000 Family"}
        122{"Efficeon™ TM8000 Family"}
        128{"Weitek"}
        130{"Itanium™ Processor"}
        131{"AMD Athlon™ 64 Processor Famiily"}
        132{"AMD Opteron™ Processor Family"}
        144{"PA-RISC Family"}
        145{"PA-RISC 8500"}
        146{"PA-RISC 8000"}
        147{"PA-RISC 7300LC"}
        148{"PA-RISC 7200"}
        149{"PA-RISC 7100LC"}
        150{"PA-RISC 7100"}
        160{"V30 Family"}
        176{"Pentium III Xeon™ Processor"}
        177{"Pentium III Processor with Intel SpeedStep™ Technology"}
        178{"Pentium 4"}
        179{"Intel Xeon™"}
        180{"AS400 Family"}
        181{"Intel Xeon™ Processor MP"}
        182{"AMD Athlon™ XP Family"}
        183{"AMD Athlon™ MP Family"}
        184{"Intel Itanium 2"}
        185{"Intel Pentium M Processor"}
        190{"K7"}
        200{"IBM390 Family"}
        201{"G4"}
        202{"G5"}
        203{"G6"}
        204{"z/Architecture Base"}
        250{"i860"}
        251{"i960"}
        260{"SH-3"}
        261{"SH-4"}
        280{"ARM"}
        281{"StrongARM"}
        300{"6x86"}
        301{"MediaGX"}
        302{"MII"}
        320{"WinChip"}
        350{"DSP"}
        500{"Video Processor"}
    }
}
Function Get-ProcessorType([int16]$ProcessorType)
{
    Switch($ProcessorType)
    {
        1{"Other"}
        2{"Unknown"}
        3{"Central Processor"}
        4{"Math Processor"}
        5{"DSP Processor"}
        6{"Video Processor"}
    }
}
Function Get-ProcessorUpgradeMethod([int16]$UpgradeMethod)
{
    Switch($UpgradeMethod)
    {
        1{"Other"}
        2{"Unknown"}
        3{"Daughter Board"}
        4{"ZIF Socket"}
        5{"Replacement or Piggy Back"}
        6{"None"}
        7{"LIF Socket"}
        8{"Slot 1"}
        9{"Slot 2"}
        10{"370 Pin Socket"}
        11{"Slot A"}
        12{"Slot M"}
        13{"Socket 423"}
        14{"Socket A (Socket 462)"}
        15{"Socket 478"}
        16{"Socket 754"}
        17{"Socket 940"}
        18{"Socket 939"}
    }
}
Function Get-CpuStatus([int16]$CpuStatus)
{
    Switch($CpuStatus)
    {
        0{"Unknown"}
        1{"CPU Enabled"}
        2{"CPU Disabled by User via BIOS Setup"}
        3{"CPU Disabled by BIOS (POST Error)"}
        4{"CPU Is Idle"}
        5{"Reserved"}
        6{"Reserved"}
        7{"Other"}
    }
}
Function Get-ProcessorVoltageCaps([Int32]$VoltageCaps)
{
    $Devolucion = ""
    If(($VoltageCaps -band 1) -eq 1){$Devolucion = "5;"}
    If(($VoltageCaps -band 2) -eq 2){$Devolucion = "$Devolucion`3.3;"}
    If(($VoltageCaps -band 4) -eq 4){$Devolucion = "$Devolucion`2.9;"}
    If($Devolucion.Length -gt 0)
    {
        $Devolucion = $Devolucion.Substring(0,$Devolucion.Length -1)
    }
    $Devolucion
}

Function Invoke-WmiExpression([string]$Expression,$Credential)
{
    # Si se ha recibido credenciales, las añadimos al comando
    If($Credential -ne $null -and `
      ($Credential.GetType()).Name -eq "PsCredential")
    {
        # Guadamos el comando sin credenciales
        $ExpressionNoCredential = $Expression
        # Agregamos las credenciales al comando
        $Expression = "$Expression -Credential `$Credential"
    }
    # Limpiamos la variable de errores
    $Error.Clear()
    # Nos guardamos la configuración existente ante los errores que no
    # interrumpen
    $AccionError = $ErrorActionPreference
    # Establecemos que los errores que no interrumpen sí lo hagan, así
    # podremos capturarlos con Try/Catch
    $ErrorActionPreference = "Stop"
    Try
    {
        # Obtenemos los módulos de memoria del equipo
        $Devolucion = Invoke-Expression $Expression
    }
    Catch
    {
        # Si el error producido es provocado porque se ha intentado
        # pasar credenciales al equipo local...
        If($Error[0].Exception.ErrorCode -eq "LocalCredentials")
        {
            # Restituimos el comando para que sea sin pedir credenciales
            $Expression = $ExpressionNoCredential
            # Volvemos a invocar el comando para obtener los volúmenes
            $Devolucion = Invoke-Expression $Expression
        }
        Else
        {
            $Devolucion = $null
        }
    }
    # Restituimos la acción que estaba configurada para los errores que
    # no interrumpen
    $ErrorActionPreference = $AccionError
    $Devolucion
#.SYNOPSIS
#   Devuelve el resultado de una llamada que se hace a Get-WmiObject con la
#   cadena que se recibe como parámetro y que es pasada a Execute-Expression,
#   realizando control de errores.
#.DESCRIPTION
#   La princpal tarea de esta función es evitar la redundancia de código que
#   se produce al controlar el error que se genera si se realiza una llamada
#   a Get-WmiObject con credenciales alternativas al equipo local. En toda
#   función que realice este tipo de llamadas y que se quiera controlar este 
#   error, cuando usamos Try/Catch, el bloque de la función se coloca en la
#   parte Try y en el Catch hay que controlar si el error es por las
#   credenciales alternativas y en caso afirmativo volver a invocar
#   Get-WmiObject sin pasarlas, para a continuación volver a poner el bloque de
#   código, lo que lo duplica. En el código de la función que usa ésta, sólo se
#   tendrá que poner el bloque principal una vez, pues se convierte en
#   transparente si es el equipo local o no.
#.PARAMETER Expression
#   Cadena que es una llamada a Get-WmiObject.
#.PARAMETER Credential
#   Nombre de usuario o credenciales completas del usuario con el que se
#   conectara a WMI. En caso de pasarse sólo el nombre de usuario, se pedirá
#   entrar la contraseña del mismo. Si se pasan credenciales y se consulta el
#   equipo local, las credenciales serán ignoradas, pues no se puede conectar
#   a WMI del equipo local con credenciales alternativas. Tiene también los
#   alias "Usuario","U","Credenciales" y "Cred".
#.NOTES
#   Desarrollado por Fernando Reyes López
#   Noviembre de 2010
#.LINK
#   http://freyes.svetlian.com -> Artículos de Fernando reyes
#.LINK
#   https://urpiano.wordpress.com -> El Blog de GualtrySoft
#.EXAMPLE
#     PS >Invoke-WmiExpression "Get-WmiObject Win32_Process -ComputerName mortadelo-pc" -Credential (Get-Credential TIA\Bacterio)
#   Muestra por pantalla los procesos del equipo mortadelo-pc, pasando las
#   credenciales de un prestigioso científico y no importando si se trata del
#   equipo local o no; se pedirá al insigne profesor que entre su contraseña.
#.EXAMPLE
#     PS >$Usr = Get-Credential
#     PS >Invoke-WmiExpression "Get-WmiObject Win32_Process -ComputerName mortadelo-pc" -Credential (Get-Credential TIA\Bacterio)
#   Muestra por pantalla los procesos del equipo mortadelo-pc, pasando las
#   credenciales contenidas en $Usr y que fueron obtenidas invocando
#   Get-Credential.
}

Function Get-Processor([parameter(position=0,
                               ValueFromPipeLine=$True,
                               HelpMessage="Nombre de equipo.")]
                        [Alias("Equipo","Sistema","E","C","S")]
                        [String]$ComputerName = "$($env:ComputerName)",
                    [parameter(Position=1,
                             Mandatory=$false,
                             HelpMessage="Credenciales de usuario de conexión")]
                        [Alias("Usuario","U","Credenciales","Cred")]
                        $Credential)
{
    Begin
    {
        # Iniciamos la devolución
        $Devolucion = @()
        # Si no se han pasado unas credenciales completas, si no sólo un nombre
        # de usuario, hay que llamar a Get-Credential para obtenerlas completas
        If($Credential -ne $null -and `
          ($Credential.GetType()).Name -ne "PsCredential")
        {
                $Credential = Get-Credential $Credential
        }
    }
    Process
    {
        # Si se recibió como nombre de equipo un punto, esto implica el equipo
        # local; sustituimos el punto por el nombre de equipo
        If($ComputerName -eq "."){$ComputerName = "$($env:ComputerName)"}
        # Iniciamos el comando que obtendrá los procesadores del equipo
        # consultando a WMI, en concreto la clase Win32_Processor del espacio de
        # nombres CIMv2
        $Comando = "Get-WmiObject Win32_Processor"
        $Comando = "$Comando -Namespace root/CIMv2"
        # Agregamos el nombre de equipo
        $Comando = "$Comando -ComputerName $ComputerName"
        # Obtenemos los procesadores del equipo
        $Procesadores = Invoke-WmiExpression -Expression $Comando `
                                             -Credential $Credential
        # Si la devoloución no es nula, significa que no ha habido problemas
        If($Procesadores -ne $null)
        {
            # Iniciamos el Hash del recuento, en el que las claves serán los
            # diferentes modelos de procesador, y el valor será el objeto
            # de la clase Win32_Processor primero que se obtenga 
            $Recuento = @{}
            $Resultado = @()
            $Indice = 0
            # Recorremos los procesadores
            ForEach($Procesador In $Procesadores)
            {
                # Si ya está como clave el nombre del procesador actual,
                # sumamos uno al recuento de número de procesadores del modelo
                If($Recuento.Keys -contains $Procesador.Name)
                {
                    # Cargamos un objeto 
                    $objProcesador = $Recuento.($Procesador.Name).Count++
#                    $objProcesador.Count++
#                    $Recuento.($Procesador.Name) = $objProcesador
                }
                # Como no existe esa clave, la agregamos poniendo como valor el
                # objeto Win32_Processor, al que retocaremos para sustituir
                # las enumeraciones Architecture, Family, ProcessorType,
                # UpgradeMethod y VoltageCaps por sus valores, realizando
                # llamadas a las funciones correspondientes. A parte de esto,
                # agregaremos la propiedad Count, que indica el número de
                # procesadores del modelo actual, y la propiedad Error, que al
                # no haberse producido ninguna tendrá valor $null
                Else
                {
                    # Agregamos las propiedades del procesador, excepto las de
                    # las enumeraciones antes indicadas, a un objeto creado a
                    # partir del objeto Win32_Processor
                    $objProcesador = `
                            $Procesador | `
                                Select-Object `
                                    -Property Availability, `
                                              AddressWidth, `
                                              Caption, `
                                              CurrentClockSpeed, `
                                              CurrentVoltage, `
                                              DataWidth, `
                                              Description, `
                                              ExtClock, `
                                              L2CacheSize, `
                                              L2CacheSpeed, `
                                              L3CacheSize, `
                                              L3CacheSpeed, `
                                              Level, `
                                              Manufacturer, `
                                              MaxClockSpeed, `
                                              Name, `
                                              NumberOfCores, `
                                              NumberOfLogicalProcessors, `
                                              OtherFamilyDescription, `
                                              PNPDeviceID, `
                                              PowerManagementCapabilities, `
                                              PowerManagementSupported, `
                                              Revision, `
                                              Role, `
                                              SocketDesignation, `
                                              Stepping, `
                                              SystemCreationClassName, `
                                              SystemName, `
                                              Version
                    # Agregamos la arquitectura
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name Architecture `
                               -Value (Get-ProcessorArchitecture `
                                                   $Procesador.Architecture)
                    # Agregamos la familia
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name Family `
                               -Value (Get-ProcessorFamily `
                                                         $Procesador.Family)
                    # Agregamos el tipo de procesador
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name ProcessorType `
                               -Value (Get-ProcessorType `
                                                  $Procesador.ProcessorType)
                    # Agregamos el método de upgrade
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name UpgradeMethod `
                               -Value (Get-ProcessorUpgradeMethod `
                                                  $Procesador.UpgradeMethod)
                    # Agregamos los voltages de trabajo
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name VoltageCaps `
                               -Value (Get-ProcessorVoltageCaps `
                                                    $Procesador.VoltageCaps)
                    # Agregamos el número de procesadores del tipo
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name Count `
                               -Value 1
                    # Agregamos el error (no se produjo, por tanto $null)
                    Add-Member -InputObject $objProcesador `
                               -MemberType NoteProperty `
                               -Name Error `
                               -Value $null
                    # Agregamos el procesador al hash de modelos de procesadores
                    $Recuento += @{$Procesador.Name = $objProcesador}
                }
            }
            # Una vez recorridos todos los procesadores, montaremos la
            # devolución de la función agregando todos los modelos obtenidos,
            # añadiendo a cada,modelo el cálculo de total de cores y de
            # procesadores lógicos
            ForEach($Valor In $Recuento.Values)
            {
                # Agregamos el número total de cores
                Add-Member -InputObject $Valor `
                           -MemberType NoteProperty `
                           -Name TotalCores `
                           -Value ($Valor.Count * $Valor.NumberOfCores)
                # Agregamos el número total de procesadores lógicos
                Add-Member -InputObject $Valor `
                           -MemberType NoteProperty `
                           -Name TotalLogicalProcessors `
                           -Value ($Valor.Count * `
                                               $Valor.NumberOfLogicalProcessors)
                # Agregamos el modelo a la devolución
                $Devolucion += $Valor
            }
        }
        Else
        {
            # Mostramos el error que se ha producido
            Write-Host "$ComputerName`: $($Error[0].Exception.Message)" `
                       -ForegroundColor Red
            # Como se produce error generaremos un resultado en el que
            # todo tendrá valor nulo excepto el nombre del equipo y el
            # error que se ha producido. Por tanto, creamos un objeto
            # para el resultado
            $Resultado = [WmiClass] "Win32_Processor"
            $Resultado = `
                $Resultado | `
                    Select-Object `
                        -Property Availability, `
                                  AddressWidth, `
                                  Caption, `
                                  CurrentClockSpeed, `
                                  CurrentVoltage, `
                                  DataWidth, `
                                  Description, `
                                  ExtClock, `
                                  L2CacheSize, `
                                  L2CacheSpeed, `
                                  L3CacheSize, `
                                  L3CacheSpeed, `
                                  Level, `
                                  Manufacturer, `
                                  MaxClockSpeed, `
                                  Name, `
                                  NumberOfCores, `
                                  NumberOfLogicalProcessors, `
                                  OtherFamilyDescription, `
                                  PNPDeviceID, `
                                  PowerManagementCapabilities, `
                                  PowerManagementSupported, `
                                  Revision, `
                                  Role, `
                                  SocketDesignation, `
                                  Stepping, `
                                  SystemCreationClassName, `
                                  SystemName, `
                                  Version
            # Agregamos la arquitectura
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name Architecture `
                       -Value $null
            # Agregamos la familia
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name Family `
                       -Value $null
            # Agregamos el tipo de procesador
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name ProcessorType `
                       -Value $null
            # Agregamos el método de upgrade
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name UpgradeMethod `
                       -Value $null
            # Agregamos los voltages de trabajo
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name VoltageCaps `
                       -Value $null
            # Agregamos el número de procesadores del tipo
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name Count `
                       -Value 0
            # Agregamos el total de cores
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name TotalCores `
                       -Value $null
            # Agregamos el total de procesadores lógicos
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name TotalLogicalProcessors `
                       -Value $null
            # Agregamos el error que se produjo
            Add-Member -InputObject $Resultado `
                       -MemberType NoteProperty `
                       -Name Error `
                       -Value $Error[0].Exception.Message
            # Ponemos el nombre del equipo
            $Resultado.SystemName = $ComputerName
            # Agregamos el objeto a la devolución
            $Devolucion += $Resultado
        }
    }
    End
    {
        # Realizamos la devolución
        $Devolucion
    }
#.SYNOPSIS
#   Devuelve información sobre los procesadores de un equipo.
#.DESCRIPTION
#   Este Cmdlet permite obtener información sobre los procesadores de la
#   máquina recibida como parámetro o de la máquina local si se omite este
#   parámetro. La información es obtenida procesando la clase WMI
#   Win32_Processor del espacio de nombres root/CIMv2. La función permite
#   especificar las credenciales con las que se conectará a WMI, credenciales
#   que serán ignoradas en el caso del equipo local, pues no se puede acceder a
#   WMI con credenciales alternativas desde el equipo local.
#   
#   La función permite canalización, admitiendo como entrada nombres o IPs de
#   equipos
#.PARAMETER ComputerName
#   Nombre o IP del equipo al que se consultará. Tiene también los alias
#   "Equipo","Sistema","E","C" y "S".
#.PARAMETER Credential
#   Nombre de usuario o credenciales completas del usuario con el que se
#   conectara a WMI. En caso de pasarse sólo el nombre de usuario, se pedirá
#   entrar la contraseña del mismo. Si se pasan credenciales y se consulta el
#   equipo local, las credenciales serán ignoradas, pues no se puede conectar
#   a WMI del equipo local con credenciales alternativas. Tiene también los
#   alias "Usuario","U","Credenciales" y "Cred".
#.NOTES
#   Desarrollado por Fernando Reyes López
#   Noviembre de 2010
#.LINK
#   http://freyes.svetlian.com -> Artículos de Fernando reyes
#.LINK
#   https://urpiano.wordpress.com -> El Blog de GualtrySoft
#.EXAMPLE
#     PS >Get-Processor
#   Muestra por pantalla los procesadores del equipo local.
#.EXAMPLE
#     PS >Get-Processor -ComputerName Mortadelo-PC
#   Muestra por pantalla los procesadores del equipo de nombre Mortadelo-PC.
#.EXAMPLE
#     PS >Get-Processor -C Mortadelo-PC -Credential TIA\Bacterio
#   Muestra por pantalla los procesadores del equipo de nombre Mortadelo-PC,
#   conectando a WMI con el usuario TIA\Bacterio; se solicitará la contraseña
#   de dicho usuario.
#.EXAMPLE
#     PS >"Mortadelo-PC","Filemon-PC" | Get-Processor -Cred TIA\Bacterio
#   Muestra por pantalla los procesadores de los equipos de nombre Mortadelo-PC
#   y Filemon-PC, conectando a WMI con el usuario TIA\Bacterio; se solicitará la
#   contraseña de dicho usuario.
#.EXAMPLE
#     PS >$Usuario = Get-Credential
#     PS >"Mortadelo-PC","Filemon-PC" | Get-Processor -Usuario $Usuario
#   Muestra por pantalla los procesadores de los equipos de nombre Mortadelo-PC
#   y Filemon-PC, conectando a WMI con el usuario establecido previamente con
#   Get-Credential en la variable $Usuario.
#.EXAMPLE
#     PS >$Usr = Get-Credential
#     PS >Get-Content c:\Equipos.txt | Get-Processor -U $Usr | Export-CSV c:\Proc.csv
#   Este ejemplo muestra una manera muy útil de usar esta función. Guarda, en el
#   fichero de valores separados por coma c:\Proc.csv, un listado con los
#   procesadores de los equipos contenidos en el fichero de texto
#   c:\Equipos.txt, que contiene un nombre de equipo por línea, conectando a WMI
#   con el usuario, establecido previamente con Get-Credential, en la variable
#   $Usr.
}

Una respuesta to “PowerShell: Cmdlet para inventariar los procesadores de un equipo”

  1. […] PowerShell: Cmdlet para inventariar los procesadores de uno o más equipos […]

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: