Effizientes Erhöhen der Größe der Ereignisprotokolldatei mit PowerShell

Ereignisprotokolle in Windows-Plattformen bieten einen unschätzbaren Einblick in den Systembetrieb und mögliche Probleme. IT-Fachleute benötigen daher eine Möglichkeit, die Größe dieser Protokolle an die unterschiedlichen Anforderungen anzupassen. Dieser Artikel befasst sich mit einem PowerShell-Skript, das speziell für diejenigen entwickelt wurde, die sich fragen, wie sie die Größe der Ereignisprotokolldatei erhöhen können, um sicherzustellen, dass die Systeme immer ordnungsgemäß überwacht werden.

Hintergrund

PowerShell, das Aufgabenautomatisierungs-Framework von Microsoft, hat sich zu einem unverzichtbaren Tool für IT-Experten weltweit entwickelt. Zu seinen zahlreichen Funktionen gehört die Möglichkeit, Systemkonfigurationen zu ändern, einschließlich der Größe von Ereignisprotokollen. Da Systeme im Laufe der Zeit große Mengen an Protokollen erzeugen, ist die Möglichkeit, die Speicherkapazität dieser Protokolle anzupassen, für Managed Service Provider (MSPs ) und IT-Administratoren von entscheidender Bedeutung.

Das Skript

#Requires -Version 5.1

<#
.SYNOPSIS
    Changes the max size for the specified Event Logs.
.DESCRIPTION
    Changes the max size for the specified Event Logs.
    Common log names used: Security, Application, System
    To get a list of Event Log names from your system you can run:
        Get-WinEvent -ListLog * | Select-Object LogName
.EXAMPLE
     -LogName Security -MaxSize 50MB
    Changes the max log size for Security to 50MB
.EXAMPLE
     -LogName Security, Application, System -MaxSize 50MB
    Changes the max log size for Security, Application, and System to 50MB
.OUTPUTS
    None
.NOTES
    Windows 10 defaults to 20MB / 20480KB

    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes:
    Initial Release
By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#>

[CmdletBinding(SupportsShouldProcess)]
param (
    # Event Log name
    # https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.management/limit-eventlog?view=powershell-5.1#-logname
    [Parameter(Mandatory = $true)]
    [ValidateScript(
        {
            if ( -not $($_ | Where-Object { $_ -in $(Get-WinEvent -ListLog * | Select-Object LogName).LogName }) ) {
                throw "$_ is not a valid Event Log Name."
            }
            else {
                $true
            }
        }
    )]
    [String[]]
    $LogName,
    # The max size of the event log storage in KB.
    # Use KB, MB, or GB after your number like 111MB for example.
    [Parameter(Mandatory = $true)]
    [Int64]
    [ValidateRange(64KB, 4GB)]
    $MaxSize
)

begin {
    function Test-IsElevated {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        $p = New-Object System.Security.Principal.WindowsPrincipal($id)
        $p.IsInRole([System.Security.Principal.WindowsBuiltInRole]::Administrator)
    }

    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }

    "Used Parameters:"
    $(
        $PSBoundParameters.Keys | ForEach-Object {
            $Key = $_
            $Value = $PSBoundParameters["$_"] -join ', '
            "-$Key $Value"
        }
    ) -join ' '

    # Look for Event log names that don't exist
    if ($($LogName | ForEach-Object { $_ -notin $(Get-WinEvent -ListLog * | Select-Object LogName).LogName })) {
        $InvalidLogNames = $LogName | Where-Object { $_ -notin $(Get-WinEvent -ListLog * | Select-Object LogName).LogName }
        Write-Error "Invalid Log Names Found."
        Write-Host "Invalid Log Names: $($InvalidLogNames -join ', ')"
        exit 1
    }

    "Current Log Sizes:"
    Get-WinEvent -ListLog $LogName | Select-Object LogName, MaximumSizeInBytes | ForEach-Object {
        "$($_.LogName): $($_.MaximumSizeInBytes / 1024)KB"
    }
}
process {
    if ($PSCmdlet.ShouldProcess($($LogName -join ','), "Limit-EventLog")) {
        Limit-EventLog -LogName $LogName -MaximumSize $MaxSize -ErrorAction Stop
        # -ErrorAction Stop will exit and return an exit code of 1
        "Changed Log Sizes to:"
        Get-WinEvent -ListLog $LogName | Select-Object LogName, MaximumSizeInBytes | ForEach-Object {
            "$($_.LogName): $($_.MaximumSizeInBytes / 1024)KB"
        }
    }
    else {
        # If -WhatIf was used then print out what the changes would have been.
        "Would have changed the max log size(s) of: $($LogName -join ',') to $($MaxSize / 1024)KB"
    }
}
end {}

 

Detailansicht

Das Skript beginnt mit der Validierung seiner Umgebungsanforderungen. Dann tut es Folgendes:

• Parameter-Definitionen: Es werden Parameter für die Angabe der Protokollnamen($LogName) und der gewünschten maximalen Größe($MaxSize) festgelegt.
• Elevation Check: Mit der Funktion Test-IsElevated wird sichergestellt, dass das Skript mit administrativen Rechten ausgeführt wird, was für die Änderung von Ereignisprotokolleigenschaften erforderlich ist.
• Validierung des Protokollnamens: Das Skript überprüft mit dem Cmdlet Get-WinEvent, ob die angegebenen Protokollnamen auf dem System vorhanden sind.
• Aktuelle Größen anzeigen: Bevor Sie Änderungen vornehmen, zeigt das Skript die aktuellen Größen der angegebenen Protokolle an.
• Größenanpassung: Wenn die Überprüfung erfolgreich ist und die Genehmigung des Benutzers vorliegt (mit der Prüfung $PSCmdlet.ShouldProcess ), passt das Cmdlet ” Limit-EventLog” die Protokollgrößen an den gewünschten Wert an.

Potenzielle Anwendungsfälle

Fallstudie: Stellen Sie sich einen IT-Administrator in einem großen Unternehmen vor, in dem kritische Anwendungen täglich eine Fülle von Protokollen erzeugen. In regelmäßigen Abständen füllt sich das Anwendungsprotokoll, wodurch neuere Ereignisse ältere überschreiben können. Mit diesem Skript kann der Administrator die Größe des Anwendungsprotokolls problemlos erhöhen, um sicherzustellen, dass keine wichtigen Daten verloren gehen.

Vergleiche

Um die Größe eines Ereignisprotokolls zu erhöhen, musste man bisher durch die grafische Benutzeroberfläche der Ereignisanzeige navigieren, mit der rechten Maustaste auf das gewünschte Protokoll klicken, “Eigenschaften” auswählen und dann die Größe anpassen. Das Skript bietet eine automatisierte, effiziente und fehlerreduzierende Alternative. Es ermöglicht auch die Anpassung von Stapeln, was mit manuellen Methoden nicht so einfach möglich ist.

FAQs

• Kann ich dieses Skript verwenden, um die Protokollgröße zu reduzieren?
  Ja, geben Sie eine kleinere Größe als die aktuelle an.
• Was passiert, wenn ich einen ungültigen Protokollnamen angebe?
  Das Skript führt eine Validierung durch, gibt eine Fehlermeldung aus und bricht dann ab.
• Was ist, wenn ich sehen möchte, was das Skript macht, ohne Änderungen vorzunehmen?
  Verwenden Sie bei der Ausführung den Schalter -WhatIf, dann zeigt das Skript die Aktionen an, ohne sie auszuführen.

Auswirkungen

Eine Vergrößerung des Protokolls kann zwar die Speicherung wichtiger Daten gewährleisten, hat aber auch Auswirkungen auf den Speicherplatz. Wenn die Systemlaufwerke fast ausgelastet sind und die Protokolle erheblich erweitert werden, kann dies zu Problemen mit dem Speicherplatz führen. Außerdem können größere Protokolldateien die Geschwindigkeit bestimmter Protokollabfragen leicht beeinträchtigen.

Empfehlungen

• Überwachen Sie regelmäßig Ihren Speicherplatz, nachdem Sie die Protokollgröße erhöht haben.
• Passe die Protokollgrößen nur an, wenn es notwendig ist, und habe ein klares Verständnis dafür, warum.
• Überwachen Sie die Protokolle, insbesondere das Sicherheitsprotokoll, stets, um potenzielle Sicherheitsbedrohungen zu erkennen.

Abschließende Überlegungen

Für MSPs und IT-Profis können Tools wie NinjaOne bei der Verwaltung von Protokollen und verwandten Aufgaben entscheidend sein. NinjaOne, wenn es mit Skripten wie dem besprochenen integriert wird, kann die Systemverwaltung weiter verbessern und es einfacher machen, die Gesundheit und Sicherheit des Systems sicherzustellen.