Wie man die letzte BIOS-Zeit für optimale Systemleistung mit PowerShell überwacht

Der vorliegende Blogbeitrag befasst sich damit, wie man die letzte BIOS-Zeit abrufen kann. In der heutigen schnelllebigen IT-Umgebung ist es von größter Bedeutung, dass IT-Systeme effizient laufen. Ein kritischer Aspekt dieser Effizienz ist die System-Startzeit, die oft als ‘letzte BIOS-Zeit’ bezeichnet wird.

Die Überwachung und Verwaltung dieser Zeit kann IT-Expert:innen dabei helfen, die Systemleistung zu optimieren und Probleme effektiver zu beheben. In diesem Blogbeitrag wird ein PowerShell-Skript vorgestellt, das die letzte BIOS-Zeit aus dem Startabschnitt des Task-Managers abruft und Benutzer:innen benachrichtigt, wenn die Zeit einen bestimmten Schwellenwert überschreitet.

Kontext

Die letzte BIOS-Zeit ist eine Metrik, die im Startabschnitt des Task-Managers von Windows verfügbar ist und angibt, wie lange es dauert, bis das BIOS des Systems während des Startvorgangs initialisiert wird. Eine längere BIOS-Zeit kann auf mögliche Probleme wie Hardware-Probleme oder Fehlkonfigurationen hinweisen. Für IT-Expert:innen und Managed Service Provider (MSPs) kann es entscheidend sein, diese Kennzahl im Auge zu behalten, um den Systemzustand aufrechtzuerhalten und schnelle Startzeiten zu gewährleisten.

Das Skript zur Überwachung der BIOS-Zeit

#Requires -Version 5.1

<#
.SYNOPSIS
    Gets the Last BIOS time from the startup section of task manager and alerts if it exceeds a threshold you specify.
.DESCRIPTION
    Gets the Last BIOS time from the startup section of task manager and alerts if it exceeds a threshold you specify.
    Can save the result to a custom field.

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    Last BIOS Time: 14.6s

PARAMETER: -BootCustomField "BootTime"
    Saves the boot time to this Text Custom Field.
.EXAMPLE
    -BootCustomField "BootTime"
    ## EXAMPLE OUTPUT WITH BootCustomField ##
    Last BIOS Time: 14.6s

PARAMETER: -Seconds 20
    Sets the threshold for when the boot time is greater than this number.
    In this case the boot time is over the threshold.
.EXAMPLE
    -Seconds 20
    ## EXAMPLE OUTPUT WITH Seconds ##
    Last BIOS Time: 14.6s
    [Error] Boot time exceeded threshold of 20s by 5.41s. Boot time: 14.6s

PARAMETER: -Seconds 10
    Sets the threshold for when the boot time is greater than this number.
    In this case the boot time is under the threshold.
.EXAMPLE
    -Seconds 10
    ## EXAMPLE OUTPUT WITH Seconds ##
    Last BIOS Time: 14.6s
    [Info] Boot time under threshold of 10s by 4.59s. Boot time: 14.6s

.OUTPUTS
    String
.NOTES
    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()]
param (
    $Seconds,
    [String]$BootCustomField
)

begin {
    if ($env:bootCustomField -and $env:bootCustomField -notlike "null") {
        $BootCustomField = $env:bootCustomField
    }
    if ($env:bootTimeThreshold -and $env:bootTimeThreshold -notlike "null") {
        # Remove any non digits
        [double]$Seconds = $env:bootTimeThreshold -replace '[^0-9.]+'
    }
    function Set-NinjaProperty {
        [CmdletBinding()]
        Param(
            [Parameter(Mandatory = $True)]
            [String]$Name,
            [Parameter()]
            [String]$Type,
            [Parameter(Mandatory = $True, ValueFromPipeline = $True)]
            $Value,
            [Parameter()]
            [String]$DocumentName
        )
    
        $Characters = $Value | Measure-Object -Character | Select-Object -ExpandProperty Characters
        if ($Characters -ge 10000) {
            throw [System.ArgumentOutOfRangeException]::New("Character limit exceeded, value is greater than 10,000 characters.")
        }
        
        # If we're requested to set the field value for a Ninja document we'll specify it here.
        $DocumentationParams = @{}
        if ($DocumentName) { $DocumentationParams["DocumentName"] = $DocumentName }
        
        # This is a list of valid fields that can be set. If no type is given, it will be assumed that the input doesn't need to be changed.
        $ValidFields = "Attachment", "Checkbox", "Date", "Date or Date Time", "Decimal", "Dropdown", "Email", "Integer", "IP Address", "MultiLine", "MultiSelect", "Phone", "Secure", "Text", "Time", "URL", "WYSIWYG"
        if ($Type -and $ValidFields -notcontains $Type) { Write-Warning "$Type is an invalid type! Please check here for valid types. https://ninjarmm.zendesk.com/hc/en-us/articles/16973443979789-Command-Line-Interface-CLI-Supported-Fields-and-Functionality" }
        
        # The field below requires additional information to be set
        $NeedsOptions = "Dropdown"
        if ($DocumentName) {
            if ($NeedsOptions -contains $Type) {
                # We'll redirect the error output to the success stream to make it easier to error out if nothing was found or something else went wrong.
                $NinjaPropertyOptions = Ninja-Property-Docs-Options -AttributeName $Name @DocumentationParams 2>&1
            }
        }
        else {
            if ($NeedsOptions -contains $Type) {
                $NinjaPropertyOptions = Ninja-Property-Options -Name $Name 2>&1
            }
        }
        
        # If an error is received it will have an exception property, the function will exit with that error information.
        if ($NinjaPropertyOptions.Exception) { throw $NinjaPropertyOptions }
        
        # The below type's require values not typically given in order to be set. The below code will convert whatever we're given into a format ninjarmm-cli supports.
        switch ($Type) {
            "Checkbox" {
                # While it's highly likely we were given a value like "True" or a boolean datatype it's better to be safe than sorry.
                $NinjaValue = [System.Convert]::ToBoolean($Value)
            }
            "Date or Date Time" {
                # Ninjarmm-cli expects the GUID of the option to be selected. Therefore, the given value will be matched with a GUID.
                $Date = (Get-Date $Value).ToUniversalTime()
                $TimeSpan = New-TimeSpan (Get-Date "1970-01-01 00:00:00") $Date
                $NinjaValue = $TimeSpan.TotalSeconds
            }
            "Dropdown" {
                # Ninjarmm-cli is expecting the guid of the option we're trying to select. So we'll match up the value we were given with a guid.
                $Options = $NinjaPropertyOptions -replace '=', ',' | ConvertFrom-Csv -Header "GUID", "Name"
                $Selection = $Options | Where-Object { $_.Name -eq $Value } | Select-Object -ExpandProperty GUID
        
                if (-not $Selection) {
                    throw [System.ArgumentOutOfRangeException]::New("Value is not present in dropdown")
                }
        
                $NinjaValue = $Selection
            }
            default {
                # All the other types shouldn't require additional work on the input.
                $NinjaValue = $Value
            }
        }
        
        # We'll need to set the field differently depending on if its a field in a Ninja Document or not.
        if ($DocumentName) {
            $CustomField = Ninja-Property-Docs-Set -AttributeName $Name -AttributeValue $NinjaValue @DocumentationParams 2>&1
        }
        else {
            $CustomField = Ninja-Property-Set -Name $Name -Value $NinjaValue 2>&1
        }
        
        if ($CustomField.Exception) {
            throw $CustomField
        }
    }
}
process {
    $Ticks = try {
        # Get boot time from performance event logs
        $PerfTicks = Get-WinEvent -FilterHashtable @{LogName = "Microsoft-Windows-Diagnostics-Performance/Operational"; Id = 100 } -MaxEvents 1 -ErrorAction SilentlyContinue | ForEach-Object {
            # Convert the event to XML and grab the Event node
            $eventXml = ([xml]$_.ToXml()).Event
            # Output boot time in ms
            [int64]($eventXml.EventData.Data | Where-Object { $_.Name -eq 'BootTime' }).InnerXml
        }
        # Get the boot POST time from the firmware, when available
        $FirmwareTicks = Get-ItemPropertyValue -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager\Power" -Name "FwPOSTTime" -ErrorAction SilentlyContinue
        # Get the boot POST time from Windows, used as fall back
        $OsTicks = Get-ItemPropertyValue -Path "HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager\Power" -Name "POSTTime" -ErrorAction SilentlyContinue
        # Use most likely to be accurate to least accurate
        if ($FirmwareTicks -gt 0) {
            $FirmwareTicks
        }
        elseif ($OsTicks -gt 0) {
            $OsTicks
        }
        elseif ($PerfTicks -and $PerfTicks -gt 0) {
            $PerfTicks
        }
        else {
            # Fall back to reading System event logs
            $StartOfBoot = Get-WinEvent -FilterHashtable @{LogName = 'System'; Id = 12 } -MaxEvents 1 | Select-Object -ExpandProperty TimeCreated
            $LastUpTime = Get-WmiObject Win32_OperatingSystem -ErrorAction Stop | Select-Object @{Label = 'LastBootUpTime'; Expression = { $_.ConvertToDateTime($_.LastBootUpTime) } } | Select-Object -ExpandProperty LastBootUpTime
            New-TimeSpan -Start $LastUpTime -End $StartOfBoot -ErrorAction Stop | Select-Object -ExpandProperty TotalMilliseconds
        }
    }
    catch {
        Write-Host "[Error] Failed to get Last BIOS Time from registry."
        exit 2
    }

    $TimeSpan = [TimeSpan]::FromMilliseconds($Ticks)

    $BootTime = if ($TimeSpan.Days -gt 0) {
        "$($TimeSpan.Days)d, $($TimeSpan.Hours)h, $($TimeSpan.Minutes)m, $($TimeSpan.Seconds + [Math]::Round($TimeSpan.Milliseconds / 1000, 1))s"
    }
    elseif ($TimeSpan.Hours -gt 0) {
        "$($TimeSpan.Hours)h, $($TimeSpan.Minutes)m, $($TimeSpan.Seconds + [Math]::Round($TimeSpan.Milliseconds / 1000, 1))s"
    }
    elseif ($TimeSpan.Minutes -gt 0) {
        "$($TimeSpan.Minutes)m, $($TimeSpan.Seconds + [Math]::Round($TimeSpan.Milliseconds / 1000, 1))s"
    }
    elseif ($TimeSpan.Seconds -gt 0) {
        "$($TimeSpan.Seconds + [Math]::Round($TimeSpan.Milliseconds / 1000, 1))s"
    }
    else {
        # Fail safe output
        "$($TimeSpan.Days)d, $($TimeSpan.Hours)h, $($TimeSpan.Minutes)m, $($TimeSpan.Seconds + [Math]::Round($TimeSpan.Milliseconds / 1000, 1))s"
    }

    Write-Host "Last BIOS Time: $BootTime"

    if ($BootCustomField) {
        Set-NinjaProperty -Name $BootCustomField -Type Text -Value $BootTime
    }

    if ($Seconds -gt 0) {
        if ($TimeSpan.TotalSeconds -gt $Seconds) {
            Write-Host "[Error] Boot time exceeded threshold of $($Seconds)s by $($TimeSpan.TotalSeconds - $Seconds)s. Boot time: $BootTime"
            exit 1
        }
        Write-Host "[Info] Boot time under threshold of $($Seconds)s by $($Seconds - $TimeSpan.TotalSeconds)s. Boot time: $BootTime"
    }
    exit 0
}
end {
    
    
    
}

 

Detailansicht

Das bereitgestellte PowerShell-Skript dient dazu, die letzte BIOS-Zeit von einem Windows-System abzurufen und Benutzer:innen zu benachrichtigen, wenn sie einen bestimmten Schwellenwert überschreitet. Außerdem kann das Ergebnis zu Dokumentationszwecken in einem benutzerdefinierten Feld gespeichert werden. Im Folgenden wird Schritt für Schritt erklärt, wie das Skript funktioniert.

Schritt-für-Schritt-Erläuterung

1. Definition der Parameter:

• Das Skript beginnt mit der Definition von zwei Parametern: $Seconds und $BootCustomField.

• $Seconds gibt den Schwellenwert für die Bootzeit an.

• $BootCustomField ist ein benutzerdefiniertes Feld, in dem die Bootzeit gespeichert werden kann.

2. Prüfung der Umgebungsvariablen:

• Das Skript prüft die Umgebungsvariablen ‘bootCustomField’ und ‘bootTimeThreshold’.

• Wenn diese festgelegt sind, haben sie Vorrang vor den Skriptparametern.

3. Set-NinjaProperty:

• Diese Funktion wird verwendet, um den Wert für die Bootzeit auf ein bestimmtes benutzerdefiniertes Feld zu setzen.

• Es beinhaltet eine Validierung, um sicherzustellen, dass der Wert die Zeichengrenzen nicht überschreitet und verschiedene Datentypen angemessen behandelt werden.

4. Prozess-Block:

• Das Skript ruft die letzte BIOS-Zeit mit mehreren Methoden ab, wobei die Genauigkeit im Vordergrund steht:

• Ereignisprotokolle zur Leistung.

• Registrierungswerte für die Firmware-POST-Zeit.

• System-Ereignisprotokolle als Ausweichmöglichkeit.

• Die abgerufene Zeit wird in ein für Menschen lesbares Format umgewandelt.

5. Ausgaben und Warnmeldungen:

• Das Skript gibt die letzte BIOS-Zeit aus.

• Falls ein benutzerdefiniertes Feld angegeben ist, wird dieser Wert mit der Funktion ‘Set-NinjaProperty’ festgelegt.

• Bei einem definierten Schwellenwert vergleicht es die Boot-Zeit mit diesem Schwellenwert und löst Warnmeldungen aus, wenn er überschritten wird.

Potenzielle Anwendungsfälle

Stellen Sie sich einen IT-Experten namens Alex vor, der zahlreiche Unternehmens-Laptops verwaltet. Eines Tages stellt Alex fest, dass mehrere Benutzer:innen ungewöhnlich lange Startzeiten melden. Durch die Bereitstellung dieses PowerShell-Skripts im Netzwerk kann Alex automatisch die letzte BIOS-Zeit für jedes System abrufen und überwachen.

Wenn ein System den vordefinierten Schwellenwert überschreitet, wird Alex sofort benachrichtigt und kann weitere Untersuchungen durchführen, um möglicherweise Hardware-Probleme oder Fehlkonfigurationen zu identifizieren, die behoben werden müssen.

Vergleiche

Andere Methoden zur Erzielung ähnlicher Ergebnisse sind die Verwendung integrierter Windows-Tools oder Software von Drittanbietern. Diesen Ansätzen fehlen jedoch oft die Anpassungs- und Automatisierungs-Möglichkeiten eines PowerShell-Skripts. Zum Beispiel:

• Eingebaute Tools: Tools wie der Task-Manager können die letzte BIOS-Zeit anzeigen, lösen aber keine Warnmeldungen aus und stellen keine Automatisierungsfunktionen zur Verfügung.

• Software von Drittanbietern: Diese können zwar eine umfassende Überwachung bieten, sind aber unter Umständen teurer und erfordern eine zusätzliche Konfiguration.

FAQs

F: Was ist, wenn das Skript die letzte BIOS-Zeit nicht abrufen kann?

A: Das Skript enthält mehrere Ausweichmöglichkeiten, um sicherzustellen, dass die letzte BIOS-Zeit genau abgerufen wird. Wenn alle Methoden fehlschlagen, wird eine Fehlermeldung ausgegeben.

F: Kann ich den Schwellenwert nach der Bereitstellung des Skripts ändern?

A: Ja, Sie können den Schwellenwert mit dem Parameter -Secondsparameter oder durch Setzen der Umgebungsvariablen ‘bootTimeThreshold’ festlegen.

F: Wie kann ich die letzte BIOS-Zeit in einem benutzerdefinierten Feld speichern?

A: Verwenden Sie den Parameter -BootCustomField, um das benutzerdefinierte Feld anzugeben, in dem die Startzeit gespeichert werden soll.

Folgen

Die Überwachung der letzten BIOS-Zeit kann die IT-Sicherheit und -Leistung erheblich beeinflussen. Eine verlängerte BIOS-Zeit kann auf zugrunde liegende Probleme hinweisen, die die allgemeine Systemstabilität und die Benutzerproduktivität möglicherweise beeinträchtigen. Durch proaktive Überwachung und Behebung dieser Probleme sind IT-Expert:innen in der Lage, eine optimale Systemleistung aufrechtzuerhalten und Ausfallzeiten zu reduzieren.

Empfehlungen

• Überwachen Sie mit diesem Skript regelmäßig die letzte BIOS-Zeit, um mögliche Probleme frühzeitig zu erkennen.

• Legen Sie realistische Schwellenwerte auf der Grundlage der typischen Leistung Ihrer Systeme fest.

• Dokumentieren Sie alle Anomalien und untersuchen Sie diese umgehend, um langfristige Probleme zu vermeiden.

Abschließende Überlegungen

Zusammenfassend lässt sich sagen, dass dieses PowerShell-Skript eine robuste Lösung für die Überwachung der letzten BIOS-Zeit bietet, die wichtige Erkenntnisse über die Systemleistung liefert. Wenn Sie dieses Skript in Ihre IT-Verwaltungspraktiken integrieren, können Sie sicherstellen, dass die Systeme reibungslos und effizient laufen. NinjaOne bietet eine Reihe von Tools, die Ihren IT-Betrieb weiter verbessern können. Mithilfe von den leistungsstarken Überwachungs- und Automatisierungsfunktionen ist es möglich, Ihre Systeme in bestem Zustand zu halten.