Hey, Scripting Guy! Sichern der Ereignisprotokolle mit einem Windows PowerShell-Skript

The Microsoft Scripting Guys

Hot! Sweltering, Kurznotizen, Atem Notizen humid Wärme wurde als Erstes Jason, und bemerkt wir am Flughafen in Kuala Lumpur, Malaysia Bezugskosten. Bevor wir den Bordstein erreicht hatte, musste ein angezeigter CAB-Treiber unsere Tüten in den Stamm und die Tür öffnen für uns. Die Reise war brisk über Palm Tree–lined Straßen, die zu Kuala Lumpur Ort Center (KLCC) geführt. Sobald wir der Autobahn ein eingegeben haben, konnte wir oben glistening Patronus Towers angezeigt, die KLCC von Meilen sofort in jede Richtung zu kennzeichnen. Wir waren Stadt zu eine Klasse Microsoft Operations Framework (MOF) an einer Gruppe von Microsoft-Mitarbeitern zu vermitteln.

Die Hervorhebung der MOF-Klasse wurde eine Flughafen Simulation, die absolut niemand jemals direkt auf dem ersten Versuch haben. Aber, die Teil der Punkt der Klasse war – Verbesserung zu verarbeiten. Wir mussten die Klasse mehr als zwanzig Mal behandelt, und niemand jemals auf den ersten Tag erfolgreich. Einige Klassen vorgenommen kaum über die Simulation auf den letzten Tag der Klasse. Bis jetzt.

Am Ende den ersten Tag war es Zeit für die Runde der Simulation. Jason und ausgetauscht da Sie wissen, dass Glances wie wir Anweisungen gegeben haben. Die Kursteilnehmer mit rapt Aufmerksamkeit sat, und dann als die Uhr Ticking statt der üblichen laut ausgeführt um in verschlüsselten Verwirrung gestartet die Kursteilnehmer im stillen Modus haben zusammen in einem kleinen Huddle. Sie erläutert einen Kursteilnehmer Öffnen von seinem Laptop und begann, machen Notizen schnell für ca. fünf Minuten. Dann Sie calmly um aktiviert und das Spiel in der ersten Runde zu gewinnen fortgesetzt.

Wie? Sie es Einfach geleitet Sie all Ihre Aufmerksamkeit auf die wichtigsten Elemente des Szenarios. Sie ignoriert alle nicht benötigte Informationen und erstellt einen neuen Prozess, der das Problem gelöst. Da Sie auf das zentrale Problem konzentriert, Sie frei von komplizierten Arbeit Regeln wurden und Sie konnten Ihre Energie auf die Aufgabe zu konzentrieren.

Übermäßig komplexe Arbeit Regeln können die Produktivität beeinträchtigen. Heutige Skript wurde außerhalb eines Situation eines Kunden konfrontiert in dem Sie, mehrere Stunden täglich sichern Ereignisprotokolle von verschiedenen Netzwerkserver und kopieren Sie an einem zentralen Speicherort Ausgaben wurden, wo Sie später waren, auf Band gesichert. Nachdem wir über Ihre Regeln komplexe Arbeit haben, konnten wir zum Erstellen eines benutzerdefinierten Skripts, das genau, was Sie benötigt haben. Dieses Skript, dass Kunden 10 Stunden pro Woche und 500 Stunden pro Jahr in mussten Sie zuvor Verwalten von Ereignisprotokollen aufgewendete Arbeitszeit gespeichert.

Wenn wir Timeout von komplizierten Arbeit Regeln verwenden, können wir konzentrieren, mehr Aufmerksamkeit und Energie für den Vorgang zur hand, IT-Dienste bereitstellen. Betrachten wir nun ein Skript, mit sichern, Archivieren und Löschen von Ereignisprotokollen über das Netzwerk. Das gesamte BackUpAndClearEventLogs.ps1 Skript ist in Abbildung 1 dargestellt.

Abbildung 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

Zunächst müssen wir in der BackUpAndClearEventLogs.ps1 das Skript ist die Parameter-Anweisung zur einige Befehlszeilenparameter für das Skript Erstellung verwenden wie folgt:

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

Wir verwenden verschiedene Parameter, um das Skript viel Flexibilität bieten. -LogsArchive, die den Speicherort der Archiv-Ereignisprotokoll definieren Parameter verwendet wird. Wir Festlegen dieses in eine Standard-Speicherort auf dem Laufwerk C:\, aber mithilfe von-LogsArchive, können Sie einen beliebigen Speicherort, der für die Computerumgebung sinnvoll ist.

Liste der - Parameter können Sie eine Liste von Computern, um das Skript über eine Textdatei angeben. Dieser Parameter erwartet den vollständigen Pfad zu einer Textdatei mit die Computernamen. Die Syntax für die Textdatei ist einfach, die Sie gerade Ort des Namen jedes Computers mit in einer eigenen einzelne Zeile arbeiten möchten.

-Computer, die Parameter können Sie eine Liste der Computer von der Befehlszeile aus bereitstellen, wenn Sie das Skript ausführen. Zum diesen Parameter verwenden, platzieren Sie in einer Gruppe von Anführungszeichen Computernamen durch Kommas getrennt. Idealerweise würden Sie diesen Parameter verwenden, wenn Sie nur eine kleine Anzahl von Computern überprüfen möchten.

Als Nächstes kommen Sie vier switched Parameter. Eines der coolsten ist ein switched-Parameter aufgerufen, –AD, dem Sie die Active Directory für eine Liste von Computern Abfragen können. Es sinnvoll, diese Option verwenden, wenn Sie beabsichtigen, eine große Anzahl von Ereignisprotokollen auf allen Computern im Netzwerk überprüfen. In einem großen Netzwerk dauern dies natürlich sehr lange. Wenn das Skript für den lokalen Computer ausgeführt werden soll, verwenden Sie den - Localhost-Schalter, die das Skript für den lokalen Computer ausgeführt. Neben sichern das Ereignis protokolliert und Archivieren der an einen zentralen Speicherort Sie können gewechselt auch leere den Inhalt der Ereignisprotokolle mithilfe der - löschen-Parameter. Hilfeinformationen abzurufen, die mithilfe von Skripts ausgeführt - Hilfe. Wir sind jetzt an die erste Funktion in unser Skript. Die Get-ADComputers-Funktion ist eine Abfrage verwendet, um eine Auflistung aller Computerkonten in Active Directory abzurufen. Diese Funktion ist keine Eingabeparameter erforderlich. Beim Aufruf der Funktion verwendet es das New-Object-Cmdlet, um eine Instanz der DirectoryServices.DirectorySearcher-Klasse aus dem Microsoft .NET Framework zu erstellen. Wir übergeben keine Informationen an das New-Object-Cmdlet, sodass die DirectoryServices.DirectorySearcher-Klasse mithilfe des Standardkonstruktors erstellt wird. Die neue DirectorySearcher-Klasse wird in die Variable $ ds gespeichert, wie hier gezeigt:

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

Nachdem wir eine Instanz des DirectorySearcher-Klasse haben, können wir die Filter-Eigenschaft, Sie Erstellen eines Suchfilters, um die Anzahl der Elemente zu reduzieren, die abgerufen werden. LDAP-Suchfilter sind in dokumentiert" Search Filter Syntax." Wir das Attribut wird ObjectCategory aufgerufen, und wir suchen nach einem Wert von "Computer". Nachdem wir unsere Filter erstellt haben, verwenden wir die FindAll-Methode aus dem DirectorySearcher-Objekt:

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

Die Ergebnisse von FindAll-Methode werden an das ForEach-Object-Cmdlet pipelined dient zum Durchlaufen der Auflistung der DirectoryEntry-Objekte, die von FindAll zurückgegeben werden. Innerhalb des Skriptblocks abgegrenzt durch die geschweiften Klammern verwenden wir die Variable $ _ automatische, um auf das aktuelle Element auf die Pipeline zu verweisen. Wir greifen auf die Eigenschaften des DirectoryEntry-Objekts und der Dnshostname zurückzugeben:

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

Nun erstellen wir die Funktion Test ComputerConnection, um sicherzustellen, dass der Computer im Netzwerk und Ausführung ist. Dies Timeout Probleme und das Skript effizienter gestalten. Wir beginnen, indem Sie das Function-Schlüsselwort dann den Namen der Funktion angeben, und öffnen Sie den Skriptblock:

Function Test-ComputerConnection
{

Als Nächstes müssen wir durchlaufen die Auflistung von Computern in der $ Computer-Variablen, was wir müssen gespeichert verwenden die ForEach-Anweisung mit die Variable $ Computer als den Enumerator. Wir öffnen dann den Skriptblock eine linke geschweifte Klammer verwenden:

 ForEach($Computer in $Computers)
{

Wir müssen die WMI-Klasse Win32_PingStatus verwenden, um den Remotecomputer ping. Zu diesem Zweck verwenden Sie das Get-WmiObject-Cmdlet wir und geben Sie die Klasse Win32_PingStatus und Erstellen eines Filters, das die Adresse-Eigenschaft, ob es in die Variable $ Computer gespeicherten Wert entspricht. Wir speichern die Ergebnisse dieser WMI-Abfrage in einer benannten Variable $ Ergebnis, wie hier gezeigt:

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

Nun bewerten wir aus der WMI-Abfrage zurückgegebenen Statuscode. Wenn der Statuscode gleich Null ist, keine Fehler aufgetreten und der Computer betriebsbereit ist:

  If($Result.Statuscode -eq 0)
   {

Aus irgendeinem merkwürdigen Grund auf meinem Computer die Abfrage gibt einen phantom Computer, den Sie ausgewertet als vorhanden, jedoch einen Namen nicht über. Phantom Computer zu entfernen, hinzugefügt habe ich eine Codezeile, um sicherzustellen, dass die Computername mindestens ein Zeichen lange wurde:

     if($computer.length -ge 1) 
        { 

Als Nächstes bereitstellen wir etwas Feedback für Benutzer durch Anzeigen einer Status angezeigt, die besagt, dass wir den Computer verarbeitet werden. Wir verwenden das Cmdlet „ Write-Host, um dieses Feedback:

         Write-Host "+t Processing $Computer"

Jetzt rufen wir Sie die Funktion BackupFolder abrufen, um den Ordner für die Sicherung verwendet werden zu suchen:

         Get-BackUpFolder 
        }
   } #end if

Wenn der Computer nicht verfügbar ist, besteht keine Punkt in dem Versuch, das Ereignisprotokoll sichern, da wir erreicht werden können. Wir zeigen einen Status Message, dass wir überspringen den Computer und die Funktion beenden:

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

Nach der Auswertung des Zugriff auf den Computer, ist es Zeit, die Get-BackupFolder-Funktion zu erstellen:

Function Get-BackupFolder
{

Die nächste Codezeile ist etwas odd-looking und daher ein wenig verwirrend:

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

Wir verwenden den Format-Operator (-f), einige Wertersetzung innerhalb der Zeichenfolge auszuführen, die wir für den Ordnernamen verwenden. Die Zeichenfolge enthält die Zahl 1 in einem Paar von geschweiften Klammern, das Wort Protokolle umgeben von Striche und ein weiteres Paar von geschweiften Klammern einschließen die Zahl 0 eine Reihe von Buchstaben gefolgt.

Werfen Sie diesem eine Schritt zu einem Zeitpunkt. Der f-Operator führt eine Ersetzung der Werte in der Zeichenfolge enthalten. Genau wie bei einem Array, beginnt das erste Element bei 0, der zweite bei 1. Die Elemente auf der rechten Seite des Operators f sind die Ersatz-Werte, die in die entsprechenden Felder auf der linken Seite platziert werden.

Bevor wieder an das Hauptfenster Skript abrufen, wir nehmen Sie sich einen Moment Zeit, um ein Beispiel zur Verdeutlichung Vorgehensweise Ersetzung im Skript. Beachten Sie, wie wir das Wort eins für die Komponente {0} und dem Wort zwei für den {1} Teil im folgenden Code ersetzen:

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

Wir sollten wahrscheinlich unser Code angeordnet haben, dass das erste Element in der ersten Position war. Stattdessen haben wir es geschrieben, das zweite Element in der ersten Position ist, und das erste Element in der zweiten Position ist. Wenn wir verschoben hatte würde Elemente ein wenig die Codezeile etwa wie folgt sah haben:

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} im obigen Befehl wird verwendet, um das aktuelle Datum und die Uhrzeit zu dienen. Wir möchten nicht die normale Anzeige des DateTime-Objekt, die hier angezeigt wird, da Sie zu lang ist und enthält Zeichen, die für einen Ordnernamen nicht zulässig sind. Die Standardanzeige für das DateTime-Objekt ist Dienstag, April 07, 2009 6:45:37 PM.

Brief-Muster, die Folgen der Doppelpunkt in unserem Skript werden zum Steuern, wie die DateTime-Werte angezeigt werden. In unserem Fall wird der Monat der Tag, Jahr und die Minute gefolgt. Diese DateTime-Formatzeichenfolgen sind am dokumentiert. Benutzerdefinierte DateTime-Formatzeichenfolgen. Aber wurden auch in einem letzten Artikel im Microsoft Script Center behandelt" Wie kann ich die Größe der Ereignisprotokoll überprüfen und dann sichern und archivieren Sie Sie mehr als halb voll ist?"

Als Nächstes erstellen wir den Ereignisprotokoll Archiv-Ordner. Um den Ordner zu erstellen, wir verwenden das Cmdlet „ New Item und geben Sie als Verzeichnis. Wir verwenden die Variable $ LogsArchive und das Muster, das wir in die Variable $ Ordner den Pfad für das Archiv erstellen gespeichert. Wir verwenden den - Force-Parameter um erstellen den vollständigen Pfad zu aktivieren, wenn dies erforderlich ist. Da wir nicht die Rückmeldung dieses Befehls interessiert sind, pipeline wir die Ergebnisse der Out-Null weiter hier-Cmdlet:

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

Wir müssen auch bestimmen, ob der Protokollordner auf dem Computer vorhanden ist. Dazu verwenden wir das Cmdlet „ Test-Path wie folgt:

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

Das Cmdlet „ Test-PATH Gibt eine $ True oder false booleschen Wert $. Es ist, fragt "Protokollordner vorhanden ist?" Platzieren den nicht-Operator (!) vor der das Cmdlet „ Test-Path bedeutet Wir interessieren nur wenn der Ordner nicht vorhanden ist.

Wenn der als Protokollordner nicht auf dem Remotecomputer vorhanden ist, verwenden wir das Cmdlet „ New-Item, um ihn zu erstellen. Wir haben hart codierte Wert ein LogFolder, aber Sie können dies ändern. Als in der vorherigen Artikel neu-Cmdlet verwenden wir-Force-Parameter für den gesamten Pfad erstellen und pipeline die Ergebnisse der Out-Null weiter Cmdlet:

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

Wir möchten nun die Funktion Sicherung Ereignisprotokolle aufrufen, die führt die eigentliche Sicherung der Ereignisprotokolle. Wir übergeben den Pfad in der Variablen $ Ordner gespeichert werden, wenn wir die-Funktion aufrufen:

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

Als Nächstes erstellen Sie die Backup-Ereignisprotokolle-Funktion:

Function Backup-EventLogs
{

Wir verwenden die Win32_NTEventLogFile WMI-Klasse, um die eigentliche Sicherung durchführen. Dazu wir Aufrufen des Get-WmiObject-Cmdlet und benennen Sie die Klasse Win32_NTEventLogFile sowie die Computername in der Variable $ Computer enthalten. Wir haben das resultierende WMI-Objekt in die Variable $ Ereignisprotokolle speichern:

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

Eine generische, ungefilterte WMI-Abfrage ausführen, geben wir Ereignisprotokoll-Objekten, die jedes Ereignisprotokoll auf dem Computer darstellen zurück. Dies sind die klassische Ereignisprotokolle in Abbildung 2 dargestellt.

Um mit dieser Ereignisprotokolle arbeiten, müssen wir die ForEach-Anweisung verwenden, durchlaufen die Auflistung von WMI-Objekten. Wir verwenden das Variable $ Protokoll als unsere Enumerator, um unsere Position zu schützen, wie wir die Auflistung durchlaufen:

fig02.gif

Abbildung 2 Classic Ereignisprotokolle durch Win32_NTEventLogFile abgerufen

 ForEach($log in $EventLogs)
        {

Wir müssen nun den Pfad zu erstellen. Wiederum verwenden wir den Format-Operator, um einige Muster Ersetzung durchzuführen. {0} Ist ein Platzhalter für die Computername im Pfad, die für die Event logs verwendet wird. {1} Ist ein Platzhalter, mit der Name der Protokolldatei enthalten, die beim Sichern des Ereignisprotokolls verwendet wird:

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

Jetzt rufen wir die BackupEventLog-Methode aus der Win32_NTEventLogFile-WMI-Klasse. Wir übergeben Sie den Pfad an die BackupEventLog-Methode und den Rückgabewert aus der Aufruf der Methode abrufen. Speichern den Rückgabewert in die Variable $ ErrBackup wie hier gezeigt:

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

Wenn das Skript mit der –clear-Option ausgeführt wurden, die Variable $ löschen würden vorhanden sein, und wir würden in diesem Fall deaktivieren Sie die Ereignisprotokolle müssen. Daher verwenden wir die, wenn Anweisung, um festzustellen, ob die deaktivieren Variable $ vorhanden ist:

            if($clear)
               {

Bevor wir die Ereignisprotokolle leer ist, möchten wir sicherstellen, dass das Ereignisprotokoll erfolgreich gesichert wurde. Dazu überprüfen wir in die Variable $ ErrBackup gespeicherten Wert. Wenn Sie gleich Null ist, wissen wir traten keine Fehler während des Sicherungsvorgangs und sicher mit der Ereignisprotokolle leeren fortsetzen ist:

                if($ErrBackup -eq 0)
                  {

Wir rufen Sie die ClearEventLog-Methode aus der Win32_NTEventLogFile-WMI-Klasse und der Rückgabewert aus der Aufruf der Methode abrufen. Wir speichern den Rückgabewert in die Variable $ ErrClear wie hier gezeigt:

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

Wenn der Wert der Variablen $ ErrBackup nicht gleich 0 ist, wir nicht deaktivieren die Ereignisprotokolle out. Stattdessen zeigen wir eine Statusmeldung wir konnten das Ereignisprotokoll löschen, da der Sicherungsvorgang fehlgeschlagen ist. Bereitstellen anzeigen Weitere Problembehandlungsinformationen, wir den Statuscode, der aus der Sicherungsvorgang abgerufen wurde:

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

Kopieren Sie wir Nächstes die Ereignisprotokolle, zu dem Speicherort archivieren. Dazu, indem wir die Copy-EventLogsToArchive-Funktion aufrufen und ihm den Pfad zu der Ereignisprotokolle und die Ordner für das Ziel:

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

Kopie EventLogsToArchive verwendet das Cmdlet „ Copy-Item, um die Ereignisprotokolle zu dem Archivspeicherort zu kopieren. Erneut verwenden wir den - Force-Parameter Erstellen des Ordners ist nicht vorhanden:

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

Jetzt müssen wir einige Hilfetext für das Skript zu erstellen. Zu diesem Zweck, erstellen wir eine Get-HelpText-Funktion, der die Informationen in eine einzelne Variable speichert: $ HelpText. Der Hilfetext wird als hier-Zeichenfolge geschrieben, die uns den Text wie wir auf dem Bildschirm angezeigt werden, ohne uns mit Anführungszeichen ein Escapezeichen bezüglich soll formatieren können. Dies erleichtert viel für uns eine große Zeichenfolge wie in Abbildung 3 geben.

Abbildung 3 Get HelpText-Funktion

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

Rufen wir die Variable nach Namen auf, um den Hilfetext anzuzeigen:

  $helpText
}

Danach analysieren wir die Befehlszeileneingabe hier:

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 }

Wenn die $ AD Variable vorhanden ist, wurde der Skriptausführung mit-AD wechseln wir daher auffüllen und die Variable $ Computer mit den Informationen aus der Get-ADComputers-Funktion abgerufen. Wir rufen Sie dann die Test-ComputerConnection-Funktion auf, das bestimmt wird, wenn der Computer online ist und wieder die Ereignisprotokolle wird. Dann beenden Sie das Skript. Wenn die Variable $ Liste vorhanden ist, verwenden wir das Cmdlet „ Get-Content, um eine Textdatei lesen und füllen die Variable $ Computer. Wir rufen Sie dann die Test-ComputerConnection-Funktion und das Skript zu beenden. Wenn die Variable $ LocalHost vorhanden ist, füllen wir die Variable $ Computer, indem Sie den Wert direkt aus der ComputerName-Umgebungsvariable zu lesen. Wir rufen Sie dann die Test-ComputerConnection-Funktion und das Skript zu beenden.

Wenn die Variable $ Computer vorhanden ist, bedeutet dies, dass das Skript ausgeführt wurde und, dass die Computernamen in der Befehlszeile angegeben wurden. Wir müssen diese Computernamen in ein Array aufzuteilen. Dazu verwenden wir die Teilung-Methode der String-Objekt:

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

Wenn das Skript mit der - Hilfe-Option ausgeführt wurde, wir rufen die Get-HelpText-Funktion, Anzeigen der Hilfe, und beenden das Skript:

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

Wenn keine Parameter vorhanden sind, zeigen wir eine Meldung Zustände wir sind fehlende Parameter und rufen dann die Hilfe, Funktion zu testen:

"Missing parameters" ; Get-HelpText

Das Skript BackupAndClearEventLogs.ps1 kann problemlos angepasst für Ihre Anforderungen in Ihrem Netzwerk sein. Sie konnte z. B. die Active Directory-Abfrage ändern, sodass es gibt nur Server aus einer bestimmten Organisationseinheit zurück, oder Sie konnte hinzufügen, zusätzliche Abfrage aus WMI, um weitere Computer herausfiltern, die verarbeitet werden. Wir hoffen, dass das Skript genießen und verwendet werden kann, in dem Sie arbeiten. Besuchen Sie uns und der Skriptprogrammierung-Community auf der SkriptcenterBei Sie hier auch können catch unsere tägliche Hey, Scripting Guy! Artikel.

Ed Wilson , bekannte scripting-Experte ist Autor von acht Büchern, einschließlich Windows PowerShell Scripting Guide Microsoft Press (2008) und Microsoft Windows PowerShell Step by Step Microsoft Press (2007). Ed enthält mehr als 20 Branchenzertifizierungen, einschließlich Microsoft Certified Systems Engineer (MCSE) und Certified Information Systems Security Professional (CISSP). In seiner Freizeit bietet er Sporttauchen, Woodworking und Unterwasser Fotografie. Und Tee.

Er Liebendorfer ist eine Wordsmith und langjähriger Microsoft-Editor. Er kann nicht weiterhin glauben es gibt ein Auftrag, die ihm arbeiten täglich mit Wörtern zahlt, zurück. Eines seinen bevorzugten Dinge irreverent Humor ist, damit er passen sollten in hier nach rechts. Er zieht seinen größte Leistung im Leben, seine wunderbare Tochter.