Back Up Your Event Logs with a Windows PowerShell Script

Artigo
08/19/2016

Ei, equipe de scripts! Fazer backup de seus logs de eventos com um script do Windows PowerShell

The Microsoft Scripting Guys

Interessantes! Calor humid sweltering, auto-adesiva, colocando respiração foi a primeira coisa que Jason e percebido quando nós trouxe no aeroporto no Kuala Lumpur, Malásia. Antes de nós tinha alcançado a rua, um driver de cab amigável tinha nossos pacotes no tronco e abrir a porta para nós. A viagem era brisk por meio de palm tree–lined estradas que levou a Central de cidade Kuala Lumpur (KLCC). Assim que inserimos a estrada, poderia vemos glistening parte superior das torres de Patronus marcar KLCC de quilômetros fora em cada direção. Estamos na cidade para ministrar uma classe de MOF (Microsoft Operations Framework) para um grupo de funcionários da Microsoft.

O realce da classe MOF foi uma simulação de aeroporto absolutamente ninguém nunca tem direito na primeira tentativa. Mas que fazia parte do ponto da classe — aprimoramento de processo. Nós tinha ensinado a classe mais de vinte horas, e ninguém nunca teve êxito no primeiro dia. Algumas classes mal-feita por meio a simulação no último dia da classe. Até agora.

No final do primeiro dia, fosse tempo para um redondo da simulação. Jason e trocadas glances saber como que demos as instruções. Os alunos sal com atenção rapt e, em seguida, como o relógio iniciado ticking, em vez do usual alto executar ao redor no embaralhado confusão, os alunos silenciosamente tem juntos em uma pequena huddle. Eles falamos rapidamente para cerca de cinco minutos como um aluno aberto até seu laptop e começou a fazer anotações. Em seguida, eles calmamente ativado ao redor e prosseguiu para vencer o jogo na primeira rodada.

Como eles fazê-lo? Eles simplesmente direcionado todos os seu atenção para os elementos essenciais do cenário. Eles ignorado todas as informações não essenciais e criou um novo processo que resolveu o problema. Porque eles enfoca o problema principal, eles estavam sem quaisquer regras de trabalho complicado, e eles foram capazes de concentrar sua energia a tarefa à mão.

Regras de trabalho excessivamente complexos podem comprometer a produtividade. Script de hoje cresceu fora de um situação um cliente enfrentado no qual eles foram gastos várias horas um dia fazendo backup de logs de eventos de vários servidores de rede e copiá-los para um local de armazenamento central onde eles foram mais recente feito backup em fita. Depois que obtivemos anteriores suas regras de trabalho complexos, conseguimos criar um script personalizado que foi exatamente o que eles necessário. Esse script salva esse cliente 10 horas por semana e 500 horas por ano em mão-de-obra que eles tinham anteriormente gasto gerenciando logs de eventos.

Quando pegamos o tempo limite do trabalho complicado regras, pode se concentrar mais atenção e energia na tarefa à mão, que fornecem serviços de TI. Vamos dar uma olhada em um script que pode ser usado para fazer backup, arquivar e limpar os logs de eventos através da rede. Todo o script BackUpAndClearEventLogs.ps1 é mostrado na Figura 1 .

A Figura 1 BackUpAndClearEventLogs.ps1

Param(
       $LogsArchive = "c:\logarchive", 
       $List,
       $computers,
       [switch]$AD, 
       [switch]$Localhost,
       [switch]$clear,
       [switch]$Help
     )
Function Get-ADComputers
{
 $ds = New-Object DirectoryServices.DirectorySearcher
 $ds.Filter = "ObjectCategory=Computer"
 $ds.FindAll() | 
     ForEach-Object { $_.Properties['dnshostname']}
} #end Get-AdComputers

Function Test-ComputerConnection
{
 ForEach($Computer in $Computers)
 {
  $Result = Get-WmiObject -Class win32_pingstatus -Filter "address='$computer'"
  If($Result.Statuscode -eq 0)
   {
     if($computer.length -ge 1) 
        { 
         Write-Host "+ Processing $Computer"
         Get-BackUpFolder 
        }
   } #end if
   else { "Skipping $computer .. not accessible" }
 } #end Foreach
} #end Test-ComputerConnection



Function Get-BackUpFolder
{
 $Folder = "{1}-Logs-{0:MMddyymm}" -f [DateTime]::now,$computer
  New-Item "$LogsArchive\$folder" -type Directory -force  | out-Null
  If(!(Test-Path "\\$computer\c$\LogFolder\$folder"))
    {
      New-Item "\\$computer\c$\LogFolder\$folder" -type Directory -force | out-Null
    } #end if
 Backup-EventLogs($Folder)
} #end Get-BackUpFolder

Function Backup-EventLogs
{
 $Eventlogs = Get-WmiObject -Class Win32_NTEventLogFile -ComputerName $computer
 Foreach($log in $EventLogs)
        {
            $path = "\\{0}\c$\LogFolder\$folder\{1}.evt" -f $Computer,$log.LogFileName
            $ErrBackup = ($log.BackupEventLog($path)).ReturnValue
            if($clear)
               {
                if($ErrBackup -eq 0)
                  {
                   $errClear = ($log.ClearEventLog()).ReturnValue
                  } #end if
                else
                  { 
                    "Unable to clear event log because backup failed" 
                    "Backup Error was " + $ErrBackup
                  } #end else
               } #end if clear
            Copy-EventLogsToArchive -path $path -Folder $Folder
        } #end foreach log
} #end Backup-EventLogs

Function Copy-EventLogsToArchive($path, $folder)
{
 Copy-Item -path $path -dest "$LogsArchive\$folder" -force
} # end Copy-EventLogsToArchive

Function Get-HelpText
{
 $helpText= `
@"
 DESCRIPTION:
 NAME: BackUpAndClearEventLogs.ps1
 This script will backup, archive, and clear the event logs on 
 both local and remote computers. It will accept a computer name,
 query AD, or read a text file for the list of computers. 

 PARAMETERS: 
 -LogsArchive local or remote collection of all computers event logs
 -List path to a list of computer names to process
 -Computers one or more computer names typed in
 -AD switch that causes script to query AD for all computer accounts
 -Localhost switch that runs script against local computer only
 -Clear switch that causes script to empty the event log if the back succeeds
 -Help displays this help topic

 SYNTAX:
 BackUpAndClearEventLogs.ps1 -LocalHost 

 Backs up all event logs on local computer. Archives them to C:\logarchive.

 BackUpAndClearEventLogs.ps1 -AD -Clear

 Searches AD for all computers. Connects to these computers, and backs up all event 
 logs. Archives all event logs to C:\logarchive. It then clears all event logs 
 if the backup operation was successful. 

 BackUpAndClearEventLogs.ps1 -List C:\fso\ListOfComputers.txt

 Reads the ListOfComputers.txt file to obtain a list of computer. Connects to these 
 computers, and backs up all event logs. Archives all event logs to C:\logarchive. 

 BackUpAndClearEventLogs.ps1 -Computers "Berlin,Vista" -LogsArchive "\\berlin\C$\fso\Logs"

 Connects to a remote computers named Berlin and Vista, and backs up    all event 
 logs. Archives all event logs from all computers to the path c:\fso\Logs directory on 
   a remote computer named Berlin. 

BackUpAndClearEventLogs.ps1 -help

Prints the help topic for the script
"@ #end helpText
  $helpText
}

# *** Entry Point To Script ***

If($AD) { $Computers = Get-ADComputers; Test-ComputerConnection; exit }
If($List) { $Computers = Get-Content -path $list; Test-ComputerConnection; exit }
If($LocalHost) { $computers = $env:computerName; Test-ComputerConnection; exit }
If($Computers) 
  { 
   if($Computers.Contains(",")) {$Computers = $Computers.Split(",")} 
   Test-ComputerConnection; exit 
  }
If($help) { Get-HelpText; exit }
"Missing parameters" ; Get-HelpText

A primeira coisa que nós em BackUpAndClearEventLogs.ps1 script é usar a instrução de parâmetros para criar alguns parâmetros de linha de comando para o script, da seguinte forma:

Param(
       $LogsArchive = "c:\logarchive", 
       $List,
       $Computers,
       [switch]$AD, 
       [switch]$Localhost,
       [switch]$Clear,
       [switch]$Help
     )

Usamos vários parâmetros para fornecer a script muita flexibilidade. -LogsArchive parâmetro é usado para definir o local do arquivo de log de eventos. Definimos isso como um local padrão na unidade C:\ mas usando - LogsArchive, você pode escolher qualquer local que faz sentido para seu ambiente de computação.

-Lista de parâmetro permite que você fornecer uma lista de computadores para o script por meio de um arquivo de texto. Este parâmetro espera o caminho completo para um arquivo de texto contendo os nomes de computador. A sintaxe para o arquivo de texto é simples; você apenas coloca o nome de cada computador que você deseja trabalhar com sua própria linha individual.

-Computadores parâmetro permite que você forneça uma lista de computadores a partir da linha de comando quando você executar o script. Para usar este parâmetro, você colocar em um conjunto de aspas nomes de computador separados por vírgulas. O ideal é que você usaria esse parâmetro se você quiser verificar apenas um pequeno número de computadores.

Em seguida vêm quatro parâmetros comutados. Um dos mais interessantes é a é um parâmetro comutado chamado –AD, que lhe permite consultar o Active Directory para obter uma lista de computadores. Faz sentido usar essa opção se você for para verificar um grande número de logs de eventos em todos os computadores na rede. Claro, em uma rede grande isso pode levar bastante tempo. Se você desejar executar o script em seu computador local, use a opção-opção Localhost, que instrui o script para executar contra o computador local. Além de registra o evento de backup e arquivamento-los para um local central, você pode também vazia o conteúdo de logs de eventos usando o - limpar alternado parâmetro. Para obter informações de Ajuda, execute o script usando - Ajuda. Nós agora venha para a primeira função no nosso script. A função ADComputers Get é uma consulta usada para recuperar uma lista de todas as contas de computador no Active Directory. Esta função não requer quaisquer parâmetros de entrada. Quando a função é chamada, ele usa o cmdlet New-Object para criar uma instância de uma classe DirectoryServices.DirectorySearcher do Microsoft .NET Framework. Nós não transmita informações para o cmdlet New-Object, então a classe DirectoryServices.DirectorySearcher é criada usando o construtor padrão. A nova classe DirectorySearcher é armazenada na variável $ ds, conforme mostrado aqui:

Function Get-ADComputers
{
$ds = New-Object DirectoryServices.DirectorySearcher

Após obtermos uma instância da classe DirectorySearcher, podemos usar a propriedade filtro para criar um filtro de pesquisa para reduzir o número de itens que são recuperados. Filtros de pesquisa LDAP estão documentados em" Sintaxe do filtro de pesquisa." O atributo que desejamos é chamado ObjectCategory e estamos procurando um valor de "Computador". Depois de criarmos nosso filtro, use o método FindAll do objeto DirectorySearcher:

 $ds.Filter = "ObjectCategory=Computer"
$ds.FindAll() |

Os resultados do método FindAll são pipelined para o cmdlet ForEach-Object, que é usado para iterar na coleção de objetos DirectoryEntry que são retornados pelo FindAll. Dentro do bloco script, delineado por chaves, usamos a variável $ _ automática para referir-se o item atual no pipeline. Podemos acessar as propriedades do objeto DirectoryEntry e retornar o dnshostname:

     ForEach-Object {$_.Properties['dnshostname']}
} #end Get-ADComputers

Agora vamos criar a função ComputerConnection de teste para garantir que o computador está na rede e em execução. Isso irá evitar problemas de tempo limite e tornar mais eficiente o script. Nós começar usando a palavra-chave Function, em seguida, especifique o nome da função e abrir o bloco de script:

Function Test-ComputerConnection
{

Em seguida, precisamos percorrer a coleção de computadores armazenado na variável $ computadores, que faremos com a instrução ForEach a variável de computador $ como o enumerador. Em seguida, abrimos o bloco de script usando uma chave esquerda:

 ForEach($Computer in $Computers)
{

Precisamos usar a classe WMI Win32_PingStatus para fazer ping no computador remoto. Para fazer isso, use o cmdlet Get-WmiObject e especificar a classe Win32_PingStatus e criar um filtro que examina a propriedade de endereço para ver se ele corresponde ao valor armazenado na variável $ Computer. Armazenamos os resultados dessa consulta WMI em um resultado de $ nomeado variável, conforme mostrado aqui:

  $Result = Get-WmiObject -Class Win32_PingStatus -Filter "address='$computer'"

Agora é avaliar o código de status retornado da consulta WMI. Se o código de status for igual a zero, não tenha havido erros e o computador está em execução:

  If($Result.Statuscode -eq 0)
   {

Por algum motivo estranho, no meu computador a consulta retorna com que um computador fantasma que ele será avaliado como presente, mas que não tinha um nome. Para se livrar do computador fantasma, adicionei uma linha de código para garantir que o nome do computador foi pelo menos um caractere longo:

     if($computer.length -ge 1) 
        {

Em seguida fornecemos um pouco de comentários para o usuário, exibindo uma mensagem de status indicando que nós está processando o computador. Usamos o cmdlet write-host para fornecer esse comentário:

         Write-Host "+t Processing $Computer"

Agora, chamamos a função de BackupFolder Get para localizar a pasta a ser usado para o backup:

         Get-BackUpFolder 
        }
   } #end if

Se o computador não estiver acessível, não há nenhum ponto na tentativa de fazer backup de log de eventos porque nós não ser capazes de acessá-lo. Exibimos uma mensagem de status indicando que irá ignorar o computador e a função de sair:

   else { "Skipping $computer .. not accessible" }
 } #end Foreach
} #end Test-ComputerConnection

Depois de avaliar a acessibilidade do computador, é hora de criar a função de Get-BackupFolder:

Function Get-BackupFolder
{

A próxima linha de código é um pouco odd-looking e, portanto, um pouco confuso:

$Folder = "{1}-Logs-{0:MMddyymm}" -f [DateTime]::now,$computer

Estamos usando o operador de formato (-f) para executar alguns substituição de valor dentro da seqüência que utilizaremos para o nome da pasta. A seqüência contém o número de 1 em um par de chaves, os logs de palavra circundados por traços e outro par de chaves, colocando o número 0 seguido por uma série de letras.

Vamos esta um etapa por vez. O operador – f executa uma substituição de valores contidos na seqüência de caracteres. Como com uma matriz, o primeiro elemento começa o segundo em 1 em 0. Os itens à direita do operador – f são os valores de substituição que são colocados em slots de apropriado no lado esquerdo.

Antes de obter de volta para o script principal, reservemos um momento considerar um exemplo para esclarecer como substituição é feita no script. Observe como nós substituir a palavra um para a parte {0} e a palavra dois para a parte {1} no código a seguir:

PS C:\Users\edwilson> $test = "{0}-first-{1}-second" -f "one","two"
PS C:\Users\edwilson> $test
one-first-two-second

Nós provavelmente deve ter reorganizadas nosso código para que o primeiro elemento estava na primeira posição. Em vez disso, ter escrevemos-lo, que é o segundo elemento na primeira posição e o primeiro elemento é a segunda posição. Se nós tinha movido coisas ao redor de um pouco, a linha de código seriam procurou algo assim:

PS C:\Users\edwilson> $computer = "localhost"
PS C:\Users\edwilson> $Folder = "{0}-Logs-{1:MMddyymm}" -f $computer, [DateTime]::now
PS C:\Users\edwilson> $Folder
localhost-Logs-04070938

{1:MMddyymm} no comando acima é usado para fornecer a data e hora atuais. Não queremos que a exibição normal do objeto DateTime que é mostrado aqui porque ele é muito longo e tem caracteres que não são permitidas para um nome de pasta. A exibição padrão para o objeto DateTime é terça-feira, 07 de abril de 2009 6:45:37 PM.

Os padrões de letras que seguem o caractere de dois-pontos em nosso script são usados para controlar a maneira como os valores de DateTime serão exibidos. Em nosso caso, o mês é seguido por dia, o ano e o minuto. Essas seqüências de formato DateTime estão documentadas no Seqüências de formato DateTime personalizadas. Eles também foram discutidos em um artigo recente no Centro de scripts da Microsoft " Como pode verificar o tamanho do meu log de eventos do backup e e arquivar IT se é mais que half total?"

Em seguida, criamos a pasta de arquivamento log de eventos. Para criar a pasta, use o cmdlet New-Item e especifique o tipo como Directory. Usamos a variável LogsArchive $ e o padrão são armazenados na variável $ pasta para criar o caminho para o arquivo morto. Usamos o parâmetro - force para habilitar a criação todo o caminho se for necessário. Como não estamos interessados em comentários deste comando, nós pipeline os resultados para o Out-Null cmdlet, mostrado aqui:

New-Item "$LogsArchive\$folder" -type Directory -force | Out-Null

Também precisamos determinar se a pasta de log existe no computador. Para fazer isso, usamos o cmdlet Test-Path, assim:

  If(!(Test-Path "\\$computer\c$\LogFolder\$folder"))
    {

O cmdlet Test-Path retorna um $ true ou valor booleano false $. Perguntando "É a pasta de log existe?" Colocando o não operador (!) na frente do cmdlet Test-Path indica que estão interessados apenas se a pasta não existir.

Se a pasta de log não existir no computador remoto, usamos o cmdlet New-Item para criá-lo. Temos um valor embutido de LogFolder, mas você pode alterar isso. Como no cmdlet New-Item anterior, usamos o parâmetro - force para criar o caminho inteiro e pipeline os resultados para o cmdlet Out-Null:

      New-Item "\\$computer\c$\LogFolder\$folder" -type Directory -force | out-Null
    } #end if

Agora, queremos chamar a função EventLogs de backup, que executa o backup real dos logs de eventos. Passamos o caminho armazenado na variável $ pasta quando chamamos a função:

 Backup-EventLogs($folder)
} #end Get-BackUpFolder

Em seguida, criamos a função EventLogs Backup:

Function Backup-EventLogs
{

Usamos a classe WMI Win32_NTEventLogFile para executar o backup real. Para fazer isso, podemos chamar o cmdlet Get-WmiObject e dê a ele o nome da classe de Win32_NTEventLogFile, bem como o nome de computador contida na variável $ computador. É armazenar o objeto WMI resultante na variável $ Eventlogs:

$Eventlogs = Get-WmiObject -Class Win32_NTEventLogFile -ComputerName $computer

Ao executar uma consulta WMI genérica, não filtrada, retornamos objetos de log de eventos que representam cada log de eventos no computador. Esses são os logs de eventos clássicos mostrados na Figura 2 .

Para trabalhar com esses logs de eventos, precisamos usar a instrução ForEach para percorrer a coleção de objetos do WMI. Usamos o log de $ variável como nosso enumerador para ajudar a manter nosso lugar conforme percorremos a coleção:

Figura 2 logs de eventos clássico recuperados pelo Win32_NTEventLogFile

 ForEach($log in $EventLogs)
        {

Agora precisamos criar o caminho. Uma vez, usamos o operador de formato para fazer algumas substituição padrão. {0} É um espaço reservado para o nome do computador no caminho que será usado para os logs de eventos. {1} É um espaço reservado que é usado para armazenar o nome de arquivo de log que será usado ao fazer backup de log de eventos do:

            $path = "\\{0}\c$\LogFolder\$folder\{1}.evt" -f $Computer,$log.LogFileName

Agora, chamamos o método BackupEventLog da classe WMI de Win32_NTEventLogFile. Nós passar o caminho para o método BackupEventLog e recuperar o valor de retorno de chamada do método. Armazenamos o valor de retorno em variável de ErrBackup $ como visto aqui:

            $ErrBackup = ($log.BackupEventLog($path)).ReturnValue

Se o script foi executado com a opção –clear, a variável de limpar $ seria presente e, nesse caso, seria necessário limpar os logs de eventos. Portanto, usamos o se instrução para determinar se o $ desmarque variável está presente:

            if($clear)
               {

Antes de nós vazio os logs de eventos, gostaríamos de garantir que o log de eventos foi feito com êxito. Para fazer isso, vamos inspecionar o valor armazenado na variável $ ErrBackup. Se for igual a zero, sabemos que não tenha havido erros durante a operação de backup e que é seguro prosseguir com esvaziando os logs de eventos:

                if($ErrBackup -eq 0)
                  {

Chamamos o método ClearEventLog da classe WMI Win32_NTEventLogFile e recuperar o ReturnValue de chamada do método. Armazenamos o ReturnValue em variável de errClear $ conforme mostrado aqui:

                   $errClear = ($log.ClearEventLog()).ReturnValue
                  } #end if

Se o valor da variável $ ErrBackup não for igual a 0, podemos não desmarque saída os logs de eventos. Em vez disso, podemos exibir uma mensagem status informando que não foi possível limpar o log de eventos porque a operação de backup falhou. Para fornecer adicionais de solução de problemas informações, mostramos o código de status foi recuperado da operação de backup:

                else
                  { 
                    "Unable to clear event log because backup failed" 
                    "Backup Error was " + $ErrBackup
                  } #end else
               } #end if clear

Em seguida, vamos copiar os logs de eventos para o local arquivo morto. Para fazer isso, podemos chamar a função Copiar EventLogsToArchive e atribuir a ela o caminho para os logs de eventos e a pasta para o destino:

            Copy-EventLogsToArchive -path $path -Folder $Folder
        } #end foreach log
} #end Backup-EventLogs

Cópia EventLogsToArchive utiliza o cmdlet copy-item para copiar os logs de eventos para o local de arquivamento. Usamos novamente o parâmetro - force para criar a pasta se não existir:

Function Copy-EventLogsToArchive($path, $folder)
{
 Copy-Item -path $path -dest "$LogsArchive\$folder" -force
} # end Copy-EventLogsToArchive

Agora, precisamos criar alguns textos de Ajuda para o script. Para fazer isso, criamos uma função de Get-HelpText que armazena as informações da Ajuda em uma única variável: $ helpText. O texto de Ajuda é gravado como uma aqui-seqüência, que permite formatar o texto como queremos que ela aparecer na tela sem que precisem nos preocupar com saída entre aspas. Isso torna muito mais fácil para nós digitar uma seqüência de caracteres grande, como a mostrada na Figura 3 .

Figura 3 Get-HelpText função

Function Get-HelpText
{ 
 $helpText= `
@"
 DESCRIPTION:
 NAME: BackUpAndClearEventLogs.ps1
 This script will backup, archive, and clear the event logs on 
 both local and remote computers. It will accept a computer name,
 query AD, or read a text file for the list of computers. 
 PARAMETERS: 
 -LogsArchive local or remote collection of all computers event logs
 -List path to a list of computer names to process
 -Computers one or more computer names typed in
 -AD switch that causes script to query AD for all computer accounts
 -Localhost switch that runs script against local computer only
 -Clear switch that causes script to empty the event log if the back succeeds
 -Help displays this help topic
 SYNTAX:
 BackUpAndClearEventLogs.ps1 -LocalHost 
Backs up all event logs on local computer. Archives them to C:\logarchive.
 BackUpAndClearEventLogs.ps1 -AD -Clear
 Searches AD for all computers. Connects to these computers, and backs up all event 
 logs. Archives all event logs to C:\logarchive. It then clears all event logs if the
 backup operation was successful. 
 BackUpAndClearEventLogs.ps1 -List C:\fso\ListOfComputers.txt
 Reads the ListOfComputers.txt file to obtain a list of computer. Connects to these 
 computers, and backs up all event logs. Archives all event logs to C:\logarchive. 
 BackUpAndClearEventLogs.ps1 -Computers "Berlin,Vista" -LogsArchive "\\berlin\C$\fso\Logs"
 Connects to a remote computers named Berlin and Vista, and backs up all event 
 logs. Archives all event logs from all computers to the path c:\fso\Logs directory on 
 a remote computer named Berlin. 
 BackUpAndClearEventLogs.ps1 -help
 Prints the help topic for the script
 "@ #end helpText

Para exibir o texto da Ajuda, chamamos a variável pelo nome:

  $helpText
}

Em seguida, vamos analisar a entrada de linha de comando mostrada aqui:

If($AD) { $Computers = Get-ADComputers; Test-ComputerConnection; exit }
If($List) { $Computers = Get-Content -path $list; Test-ComputerConnection; exit }
If($LocalHost) { $computers = $env:computerName; Test-ComputerConnection; exit }

Se o $ variável AD está presente, o script foi executado com o opção-AD opção e, portanto, preencher a variável de computadores $ com as informações obtidas da função ADComputers Get. Em seguida, chamamos a função ComputerConnection de teste, que irá determinar se o computador é on-line e volta até os logs de eventos. Em seguida, encerramos o script. Se a variável de lista $ estiver presente, usamos o cmdlet Get-Content para ler um arquivo de texto e preencher a variável de computadores $. Em seguida, chamamos a função de teste ComputerConnection e sair do script. Se a variável de LocalHost $ estiver presente, nós preencher a variável de computadores $ lendo o valor diretamente da variável de ambiente computerName. Em seguida, chamamos a função de teste ComputerConnection e sair do script.

Se a variável de computadores $ estiver presente, significa que o script foi executado e que os nomes dos computadores fornecidos a partir da linha de comando. É necessário dividir esses nomes de computador em uma matriz. Para fazer isso, usamos o método divisão do objeto de cadeia de caracteres:

If($Computers) 
  { 
   if($Computers.Contains(",")) {$Computers = $Computers.Split(",")} 
   Test-ComputerConnection; exit 
  }

Se o script foi executado com a Ajuda opção-, podemos chamar a função de Get-HelpText, exibir a Ajuda e sair do script:

If($help) { Get-HelpText; exit }

Se nenhum parâmetro estiverem presente, podemos exibir uma mensagem estados que está faltando parâmetros e, em seguida, chamar Get-Help testar função:

"Missing parameters" ; Get-HelpText

O script BackupAndClearEventLogs.ps1 pode ser facilmente adaptado para atender suas necessidades em sua rede. Por exemplo, você poderia modificar a consulta ao Active Directory para que ela retorna somente os servidores de uma determinada unidade organizacional, ou você pode adicionar uma consulta WMI adicional para filtrar ainda mais as máquinas que são processadas. Esperamos que você aproveite o script e usá-lo onde você trabalha. Visite nós e a comunidade de criadores de scripts no Script Centerem onde você também pode captura nosso diária Ei, equipe de scripts! artigos.

Ed Wilson , um especialista script conhecido, é autor de oito livros, incluindo Windows PowerShell Scripting Guide Microsoft Press (2008) e Microsoft Windows PowerShell Step by Step Microsoft Press (2007). Ed tem mais de 20 certificações do setor, incluindo Microsoft Certified Systems Engineer (MCSE) e Professional de Security Systems (CISSP) de informações Certified. Em seu tempo livre, ele gosta de woodworking, fotografia submarinas e scuba diving. E chá.

Craig Liebendorfer é um wordsmith e longtime editor da Microsoft. Craig ainda não é possível achar há um trabalho que pague a ele para trabalhar com palavras diariamente. Uma das suas coisas favoritas é o humor irreverente, portanto, ele deve ajustar à direita em aqui. Ele considera sua maior realização na vida seja sua linda filha.

Recursos adicionais