Trabajo con salidas de comandos

 

Se aplica a: Exchange Server 2007 SP3, Exchange Server 2007 SP2, Exchange Server 2007 SP1, Exchange Server 2007

Última modificación del tema: 2006-08-21

El Shell de administración de Exchange ofrece varios métodos que puede utilizar para dar formato a la salida de comandos. En este tema se explican los siguientes asuntos:

  • Cómo dar formato a datos   Controlar el formato de los datos que se ven mediante los cmdlets Format-List, Format-Table y Format-Wide.

  • Cómo mostrar datos   Determina si la salida de los datos se realiza en la ventana de la consola del Shell de administración de Exchange o en un archivo mediante los cmdlets Out-Host y Out-File. En este tema se incluye un script de ejemplo para enviar datos a Microsoft Internet Explorer.

  • Cómo filtrar datos   Filtrar datos mediante uno de los siguientes métodos de filtrado:

    • Filtrado del servidor, disponible en determinados cmdlets

    • Filtrado del cliente, disponible en todos los cmdlets canalizando los resultados de un comando al cmdlet Where-Object

Para utilizar la funcionalidad descrita en este tema, debe estar familiarizado con los siguientes conceptos:

Cómo dar formato a datos

Si llama a cmdlets de formato al final del canal, puede invalidar el formato predeterminado para controlar qué datos se muestran y cómo aparecen dichos datos. Los cmdlets de formato son Format-List, Format-Table y Format-Wide. Cada uno de ellos tiene su propio estilo de salida particular que difiere de los restantes cmdlets de formato.

Format-List

El cmdlet Format-List toma una entrada del canal y muestra como resultado una lista en columna vertical de todas las propiedades especificadas de cada objeto. Puede especificar qué propiedades desea mostrar mediante el parámetro Property. Si se llama al cmdlet Format-List sin especificar ningún parámetro, se muestran todas las propiedades. El cmdlet Format-List ajusta las líneas en lugar de truncarlas. Uno de los mejores usos del cmdlet Format-List es invalidar la salida predeterminada de un cmdlet de forma que se pueda recuperar información adicional o más centrada.

Por ejemplo, cuando se llama al cmdlet Get-Mailbox, sólo se ve una cantidad de información limitada en un formato de tabla. Si canaliza la salida del cmdlet Get-Mailbox al cmdlet Format-List y agrega parámetros para la información adicional o más centrada que desea visualizar, puede recuperar el resultado que desee.

También puede especificar un carácter comodín "*" con un nombre de propiedad parcial. Si incluye un carácter comodín, puede hacer coincidir varias propiedades sin tener que escribir el nombre de cada propiedad individualmente. Por ejemplo, Get-Mailbox | Format-List -Property Email* devuelve todas las propiedades que empiezan por Email.

Los ejemplos siguientes muestran las distintas formas que tiene de poder ver los mismos datos devueltos por el cmdlet Get-Mailbox.

Get-MailBox TestUser1

Name                      Alias                Server           StorageQuota
----                      -----                ------           ------------
TestUser1                  TestUser1             e12           unlimited

En este primer ejemplo, se llama al cmdlet Get-Mailbox sin formato específico, de modo que el resultado predeterminado es en formato de tabla y contiene un conjunto predeterminado de propiedades.

Get-Mailbox TestUser1 | Format-List -Property Name,Alias,EmailAddresses

Name           : TestUser1
Alias          : TestUser1
EmailAddresses : {SMTP:TestUser1@contoso.com, X400:c=US;a= ;p=Contoso;o=Exchange;s=TestUser1;}
Get-Mailbox TestUser1 | Format-List -Property Name, Alias, Email*

En el segundo ejemplo, el resultado del cmdlet Get-Mailbox se canaliza al cmdlet Format-List, junto con propiedades específicas. Como puede ver, el formato y el contenido del resultado son notablemente distintos.

Name                      : Test User
Alias                     : TestUser1
EmailAddresses            : {SMTP:TestUser1@contoso.com, X400:c=US;a= ;p=First
                            Organization;o=Exchange;s=User;g=Test;}
EmailAddressPolicyEnabled : True

En el último ejemplo, el resultado del cmdlet Get-Mailbox se canaliza al cmdlet Format-List como en el segundo ejemplo. No obstante, en el último ejemplo, se utiliza un carácter comodín para hacer coincidir todas las propiedades que empiezan por Email.

Si se pasa más de un objeto al cmdlet Format-List, todas las propiedades especificadas para un objeto se muestran y se agrupan por objeto. El orden para mostrar depende del parámetro predeterminado del cmdlet. Con frecuencia es el parámetro Name o el parámetro Identity. Por ejemplo, cuando se llama al cmdlet Get-Childitem, el orden para mostrar predeterminado es el de nombres de archivo en orden alfabético. Para cambiar este comportamiento, debe llamar al cmdlet Format-List, conjuntamente con el parámetro GroupBy, y el nombre de un valor de propiedad por el que desee agrupar el resultado. Por ejemplo, el comando siguiente enumera todos los archivos de un directorio y agrupa dichos archivos por extensión.

Get-Childitem | Format-List Name,Length -GroupBy Extension

    Extension: .xml

Name   : Config_01.xml
Length : 5627

Name   : Config_02.xml
Length : 3901


    Extension: .bmp

Name   : Image_01.bmp
Length : 746550

Name   : Image_02.bmp
Length : 746550


    Extension: .txt

Name   : Text_01.txt
Length : 16822

Name   : Text_02.txt
Length : 9835

En este ejemplo, el cmdlet Format-List ha agrupado los elementos por la propiedad Extension especificada por el parámetro GroupBy. Puede utilizar el parámetro GroupBy con cualquier propiedad válida para los objetos en la secuencia de canalización.

Format-Table

El cmdlet Format-Table le permite mostrar elementos en un formato de tabla con encabezados de etiqueta y columnas de datos de propiedad. De forma predeterminada, muchos cmdlets, por ejemplo, los cmdlets Get-Process y Get-Service, utilizan el formato de tabla para el resultado. Entre los parámetros para el cmdlet Format-Table se incluyen Properties y GroupBy. Éstos funcionan exactamente igual que lo harían con el cmdlet Format-List.

El cmdlet Format-Table utiliza además el parámetro Wrap. Ello permite mostrar completamente líneas de información de propiedad largas en lugar de truncarlas al final de una línea. Para ver cómo se utiliza el parámetro Wrap para mostrar información devuelta, compare el resultado del comando Get-Command en los dos ejemplos siguientes.

En el primer ejemplo, cuando el cmdlet Get-Command se utiliza para mostrar información de comando acerca del cmdlet Get-Process, se trunca la información de la propiedad Definition.

Get-Command Get-Process | Format-Table Name,Definition

Name                                    Definition
----                                    ----------
get-process                             get-process [[-ProcessName] String[]...

En el segundo ejemplo, se agrega el parámetro Wrap al comando para obligar a mostrar el contenido completo de la propiedad Definition.

Get-Command Get-Process | Format-Table Name,Definition -Wrap

Name                                    Definition
----                                    ----------
get-process                             get-process [[-ProcessName] String[]] [
                                        -Verbose] [-Debug] [-ErrorAction Action
                                        Preference] [-ErrorVariable String] [-O
                                        utVariable String] [-OutBuffer Int32]
                                        get-process -Id Int32[] [-Verbose] [-De
                                        bug] [-ErrorAction ActionPreference] [-
                                        ErrorVariable String] [-OutVariable Str
                                        ing] [-OutBuffer Int32]
                                        get-process -Input Process[] [-Verbose]
                                         [-Debug] [-ErrorAction ActionPreferenc
                                        e] [-ErrorVariable String] [-OutVariabl
                                        e String] [-OutBuffer Int32] 

Al igual que en el caso del cmdlet Format-List, también puede especificar un carácter comodín "*" con un nombre de propiedad parcial. Al incluir un carácter comodín, puede hacer coincidir varias propiedades sin tener que escribir cada nombre de propiedad individualmente.

Format-Wide

El cmdlet Format-Wide permite un control de resultado mucho más simple que otros cmdlets de formato. De forma predeterminada, el cmdlet Format-Wide intenta mostrar tantas columnas de valores de propiedad como sea posible en una línea de resultado. Puede controlar el número de columnas y cómo se utiliza el espacio del resultado agregando parámetros.

Mediante el uso más básico, al llamar al cmdlet Format-Wide sin ningún parámetro, se organiza el resultado en tantas columnas como se ajusten a la página. Por ejemplo, si ejecuta el cmdlet Get-Childitem y canaliza su resultado al cmdlet Format-Wide, verá mostrada la siguiente información:

Get-ChildItem | Format-Wide

    Directory: FileSystem::C:\WorkingFolder

Config_01.xml                           Config_02.xml
Config_03.xml                           Config_04.xml
Config_05.xml                           Config_06.xml
Config_07.xml                           Config_08.xml
Config_09.xml                           Image_01.bmp
Image_02.bmp                            Image_03.bmp
Image_04.bmp                            Image_05.bmp
Image_06.bmp                            Text_01.txt
Text_02.txt                             Text_03.txt
Text_04.txt                             Text_05.txt
Text_06.txt                             Text_07.txt
Text_08.txt                             Text_09.txt
Text_10.txt                             Text_11.txt
Text_12.txt

Generalmente, al llamar al cmdlet Get-Childitem sin ningún parámetro, se muestran los nombres de todos los archivos en el directorio en una tabla de propiedades. En este ejemplo, canalizando el resultado del cmdlet Get-Childitem al cmdlet Format-Wide, el resultado se mostró en dos columnas de nombres. Observe que sólo se puede mostrar un tipo de propiedad a la vez, especificado por el nombre de propiedad que sigue al cmdlet Format-Wide. Si agrega el parámetro Autosize, el resultado cambia de dos columnas a tantas como se ajuste al ancho de la pantalla.

Get-ChildItem | Format-Wide -AutoSize

    Directory: FileSystem::C:\WorkingFolder

Config_01.xml   Config_02.xml   Config_03.xml   Config_04.xml   Config_05.xml
Config_06.xml   Config_07.xml   Config_08.xml   Config_09.xml   Image_01.bmp
Image_02.bmp    Image_03.bmp    Image_04.bmp    Image_05.bmp    Image_06.bmp
Text_01.txt     Text_02.txt     Text_03.txt     Text_04.txt     Text_05.txt
Text_06.txt     Text_07.txt     Text_08.txt     Text_09.txt     Text_10.txt
Text_11.txt     Text_12.txt

En este ejemplo, la tabla se organiza en cinco columnas, en lugar de dos columnas. El parámetro Column permite un mayor control, permitiendo especificar el número máximo de columnas para mostrar información del siguiente modo:

Get-ChildItem | Format-Wide -Columns 4

    Directory: FileSystem::C:\WorkingFolder

Config_01.xml       Config_02.xml       Config_03.xml       Config_04.xml
Config_05.xml       Config_06.xml       Config_07.xml       Config_08.xml
Config_09.xml       Image_01.bmp        Image_02.bmp        Image_03.bmp
Image_04.bmp        Image_05.bmp        Image_06.bmp        Text_01.txt
Text_02.txt         Text_03.txt         Text_04.txt         Text_05.txt
Text_06.txt         Text_07.txt         Text_08.txt         Text_09.txt
Text_10.txt         Text_11.txt         Text_12.txt

En este ejemplo, se obliga a que el número de columnas sea de cuatro mediante el parámetro Column.

Cómo dar salida a los datos

Out-Host y Out-File

El cmdlet Out-Host es un cmdlet predeterminado no visto al final del canal. Después de aplicar todo el formato, el cmdlet Out-Host envía el resultado final a la ventana de consola para visualización. No tiene que llamar explícitamente al cmdlet Out-Host, dado que es el resultado predeterminado. Puede invalidar el envío del resultado a la ventana de consola llamando al cmdlet Out-Host como último cmdlet del comando. El cmdlet Out-File escribe a continuación el resultado en el archivo que especifica en el comando, como se muestra en el ejemplo siguiente:

Get-ChildItem | Format-Wide -Columns 4 | Out-File c:\OutputFile.txt

En este ejemplo, el cmdlet Out-Host escribe la información que se muestra en el comando Get-ChildItem | Format-Wide -Columns 4 en un archivo denominado OutputFile.txt. También puede redirigir el resultado del canal a un archivo mediante el operador de redirección, que es el corchete angular de cierre ( > ). Para anexar el resultado del canal de un comando a un archivo existente sin reemplazar el archivo original, utilice el corchete angular de cierre doble ( >> ), como en el ejemplo siguiente:

Get-ChildItem | Format-Wide -Columns 4 >> C:\OutputFile.txt

En este ejemplo, el resultado del cmdlet Get-Childitem se canaliza al cmdlet Format-Wide para dar formato y, después, se escribe al final del archivo OutputFile.txt. Tenga en cuenta que si el archivo OutputFile.txt no existe, éste se crearía al usar los corchetes angulares de cierre dobles ( >> ).

Para obtener más información acerca de los canales, vea Canalización (en inglés).

Para obtener más información acerca de la sintaxis utilizada en los ejemplos anteriores, vea Sintaxis (en inglés).

Visualización de datos en Internet Explorer

Dada la flexibilidad y la facilidad de creación de scripting en el Shell de administración de Exchange, puede extraer los datos devueltos por los comandos y darles formato y salida de forma casi ilimitada.

El ejemplo siguiente muestra cómo se puede utilizar un script simple para enviar los datos devueltos por un comando y mostrarlos en Internet Explorer. Este script extrae los objetos que pasan por el canal, abre una ventana de Internet Explorer y ,a continuación, muestra los datos en Internet Explorer:

$Ie = New-Object -Com InternetExplorer.Application
$Ie.Navigate("about:blank")
While ($Ie.Busy) { Sleep 1 }
$Ie.Visible = $True
$Ie.Document.Write("$Input")
# If the previous line doesn't work on your system, uncomment the line below.
# $Ie.Document.IHtmlDocument2_Write(\"$Input\")
$Ie

Para utilizar este script, guárdelo en el directorio C:\Program Files\Microsoft\Exchange Server\Scripts del equipo donde se ejecutará. Nombre al archivo Out-Ie.ps1. Después de guardar el archivo, puede utilizar el script como un cmdlet normal.

La secuencia de comandos Out-Ie supone que los datos que recibe son código HTML válido. Para convertir los datos que desea ver en código HTML, debe canalizar los resultados del comando al cmdlet ConvertTo-Html. A continuación, puede canalizar los resultados de dicho comando a la secuencia de comandos Out-Ie. El siguiente ejemplo muestra cómo visualizar un listado de directorios en una ventana de Internet Explorer:

Get-ChildItem | Select Name,Length | ConvertTo-Html | Out-Ie

Cómo filtrar datos

El Shell de administración de Exchange ofrece acceso a una gran cantidad de información acerca de servidores, buzones, servicio de directorios de Active Directory y otros objetos de su organización. Aunque el acceso a esta información ayuda a comprender mejor el entorno, esta gran cantidad de información puede saturarlo con facilidad. El Shell de administración de Exchange le permite controlar esta información y sólo devuelve los datos que desea ver por medio del filtrado. Se dispone de los dos tipos de filtrado siguientes:

  • Filtrado del servidor   El filtrado del servidor toma el filtro que especifique en la línea de comandos y lo envía al servidor de Exchange en el que realice la consulta. Dicho servidor procesa la consulta y devuelve sólo los datos que coincidan con el filtro especificado.

    El filtrado del servidor sólo se lleva a cabo en objetos en los que se pueden devolver decenas o centenas de miles de resultados. Por tanto, sólo los cmdlets de administración de destinatarios como, por ejemplo, el cmdlet Get-Mailbox, y los cmdlets de administración de colas como, por ejemplo, el cmdlet Get-Queue, son compatibles con el filtrado del servidor. Estos cmdlets son compatibles con el parámetro Filter, que toma la expresión del filtro que se especifica y la envía al servidor para que sea procesada.

  • Filtrado del cliente   El filtrado del cliente se lleva a cabo en los objetos de la ventana de consola local en la que se está trabajando actualmente. Cuando se utiliza el filtrado del cliente, el cmdlet recupera todos los objetos que coinciden con la tarea que se está realizando en la ventana de consola local. El Shell de administración de Exchange toma entonces todos los resultados devueltos, aplica el filtro del cliente a dichos resultados y devuelve sólo los resultados que coincidan con su filtro. Todos los cmdlets son compatibles con el filtrado del cliente. Éste se llama canalizando los resultados de un comando al cmdlet Where-Object.

Filtrado del servidor

La implementación del filtrado del servidor es específica del cmdlet en el que está admitido. El filtrado del servidor sólo se habilita sobre propiedades específicas en los objetos devueltos.

Para obtener más información acerca de cómo administrar destinatarios mediante el filtrado del servidor, vea Crear filtros en los comandos de destinatario (en inglés).

Para obtener más información acerca de cómo administrar colas mediante el filtrado del servidor, vea Filtrado de colas (en inglés).

Filtrado del cliente

El filtrado del cliente se puede utilizar con cualquier cmdlet. Esto incluye a aquéllos que son compatibles con el filtrado del servidor. Como se ha descrito anteriormente en este tema, el filtrado del cliente acepta todos los datos devueltos por un comando anterior en el canal y, a cambio, devuelve sólo los resultados que coinciden con el filtro que se especifica. El cmdlet Where-Object realiza este filtrado. Se puede abreviar a Where.

Conforme los datos pasan por el canal, el cmdlet Where recibe los datos del objeto anterior y, a continuación, filtra los datos antes de pasarlos al siguiente objeto. El filtrado se basa en un bloque de scripts de comandos definido en el comando Where. El bloque de scripts de comandos filtra los datos basados en las propiedades y los valores del objeto.

El cmdlet Clear-Host se utiliza para borrar la ventana de consola. En este ejemplo, puede encontrar todos los alias definidos para el cmdlet Clear-Host si ejecuta el siguiente comando:

Get-Alias | Where {$_.Definition -eq "Clear-Host"}

CommandType     Name                            Definition
-----------     ----                            ----------
Alias           clear                           clear-host
Alias           cls                             clear-host

El cmdlet Get-Alias y el comando Where trabajan conjuntamente para devolver la lista de alias que se han definido para el cmdlet Clear-Host y ningún otro cmdlet. La Tabla 1 describe todos los elementos del comando Where que se utilizan en el ejemplo.

Tabla 1   Elementos del comando Where

Elemento Descripción

{ }

Las llaves encierran el bloque de scripts que define el filtro.

$_

Esta variable especial se inicia automáticamente y enlaza con los objetos del canal.

Definición

La propiedad Definition es la propiedad de los objetos del canal actual que almacena el nombre de la definición de alias. Cuando se utiliza Definition con la variable $_, hay un punto delante del nombre de propiedad.

-eq

Este operador de comparación para “igual que” se utiliza para especificar que el resultado debe coincidir exactamente con el valor de la propiedad que se suministra en la expresión.

“Clear-Host”

En este ejemplo, “Clear-Host” es el valor para el que está analizando el comando.

En el ejemplo, los objetos devueltos por el cmdlet Get-Alias representan todos los alias definidos en el sistema. Incluso aunque no los vea desde la línea de comandos, los alias se recopilan y pasan al cmdlet Where a través del canal. El cmdlet Where utiliza la información en el bloque de scripts de comandos para aplicar un filtro a los objetos del alias.

La variable especial $_representa los objetos que se están pasando. La variable $_ se inicia automáticamente por el Shell y se enlaza con el objeto de canal actual. Para obtener más información acerca de esta variable especial, vea Variables de shell (en inglés).

Utilizando la notación con "punto" estándar (objeto.propiedad), se agrega la propiedad Definition para definir la propiedad exacta del objeto a evaluar. El operador de comparación -eq compara entonces el valor de esta propiedad con "Clear-Host". Sólo los objetos que tienen la propiedad Definition que coincide con este criterio se pasan a la ventana de consola para salida. Para obtener más información acerca de los operadores de comparación, vea Operadores comparativos (en inglés).