PowerShell-Skript für eine effektive SQL Server-Zustandsüberwachung

Die wichtigsten Erkenntnisse

• PowerShell-Skripte rationalisieren die Überwachung vom SQL Server-Zustand und verbessern Genauigkeit und betriebliche Effizienz.
• Anpassbare Parameter im Skript ermöglichen eine personalisierte Überwachung von Datenbankdiensten, Speicherplatz und Latenz.
• Durch die automatische Überwachung wird das Risiko von Serverausfallzeiten und Leistungsproblemen verringert.
• Das Skript prüft, ob Sie über Administratorrechte verfügen, die für den Zugriff auf Systeminformationen und die Durchführung bestimmter Vorgänge erforderlich sind.
• Die Echtzeit-Überwachungsfunktionen des Skripts sind entscheidend für die Aufrechterhaltung des Zustands der Datenbank und die Vermeidung von Datenverlusten.
• Das Skript ist anpassbar an verschiedene SQL Server-Versionen, was es zu einem vielseitigen Tool für unterschiedliche IT-Umgebungen macht.
• Die Integration dieses Skripts in umfassende IT-Management-Plattformen wie NinjaOne bietet eine robuste Überwachungslösung.
• Um die Effektivität des Skripts zu maximieren, werden regelmäßige Updates und Mitarbeiterschulungen in PowerShell empfohlen.
• Die proaktive Überwachung und Wartung von SQL-Servern ist für die Gewährleistung einer hohen Verfügbarkeit und Datenintegrität in modernen Geschäftsumgebungen unerlässlich.

Kontext

Die Sicherstellung des Zustands und der Leistung von SQL Server-Datenbanken ist für Unternehmen essenziell, um Kontinuität und Effizienz aufrechtzuerhalten. Angesichts der zunehmenden Abhängigkeit von datengesteuerten Entscheidungen wird IT-Expert:innen häufig die wichtige Aufgabe übertragen, diese Systeme zu überwachen und zu verwalten. Der Einsatz von PowerShell-Skripten zu diesem Zweck optimiert den Prozess und erhöht sowohl die Genauigkeit als auch die Effizienz.

Das mitgelieferte PowerShell-Skript ist ein wertvolles Tool für IT-Administrator:innen und Managed Service Provider (MSPs). Es konzentriert sich auf die Überwachung von drei Schlüsselaspekten des SQL Server-Status: Status der Datenbankdienste, Verfügbarkeit von Festplattenplatz und Festplattenlatenz. Eine solche Überwachung ist unerlässlich, da sie dazu beiträgt, Datenverluste zu verhindern, eine hohe Verfügbarkeit zu gewährleisten und die optimale Leistung des SQL Servers aufrechtzuerhalten.

Das Skript zur Überwachung vom SQL Server-Zustand

#Requires -Version 5.1

<#
.SYNOPSIS
    Monitors the database services, database's drive free space, and database's disk latency.
.DESCRIPTION
    Monitors the database services, database's drive free space, and database's disk latency.

    Exit code of 1 means there is a problem.

    Will not detect LocalDB uses of SQL Express

.EXAMPLE
    (No Parameters)
    ## EXAMPLE OUTPUT WITHOUT PARAMS ##
    SQL Server's services are running.
    SQL Server's disk latency is below threshold.
    SQL Server's disk free space is above threshold.

PARAMETER: -RequireAgentService
    Checks if the SQL Agent service is running or not.
.EXAMPLE
    -RequireAgentService
    ## EXAMPLE OUTPUT WITH RequireAgentService ##
    SQL Server's services are running.
    SQL Server's disk latency is below threshold.
    SQL Server's disk free space is above threshold.


PARAMETER: -DiskSpaceThreshold 50
    The percentage of free space where the database is stored must have free. 0-100
.EXAMPLE
    -DiskSpaceThreshold 50
    ## EXAMPLE OUTPUT WITH DiskSpeedThreshold ##
    [MSSQLSERVER] C: is under the threshold(50%) at 20%

PARAMETER: -DiskSpeedThreshold 40
    A brief explanation of the parameter.
.EXAMPLE
    -DiskSpeedThreshold 40
    ## EXAMPLE OUTPUT WITH DiskSpeedThreshold ##
    [MSSQLSERVER] Disk Read/Write latency is over 0 ms.
    Path                                           InstanceName          CookedValue
    ----                                           ------------          -----------
    \\test01\logicaldisk(c:)\disk reads/sec      c:               42.89807648928576
    \\test01\logicaldisk(c:)\disk writes/sec     c:                49.484308202068
.OUTPUTS
    None
.NOTES
    Minimum OS Architecture Supported: Windows 10, Windows Server 2016
    Release Notes: Renamed script and added Script Variable support
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 (
    [Parameter()]
    # Expects number in percentage with out the %
    # Default is 10 %
    [int]$DiskSpaceThreshold = 10,
    [Parameter()]
    # Expects number in milliseconds(ms)
    # Default is 50 ms
    [int]$DiskSpeedThreshold = 50,
    [switch]$RequireAgentService = [System.Convert]::ToBoolean($env:requireAgentService)
)

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 ($env:DiskSpaceThreshold) {
        $DiskSpaceThreshold = $env:DiskSpaceThreshold
    }
    if ($env:DiskSpeedThreshold) {
        $DiskSpeedThreshold = $env:DiskSpeedThreshold
    }

    Function Get-DefaultDBLocation {
        Param ([string] $vInstance)
        # Get the registry key associated with the Instance Name
        $vRegInst = (Get-ItemProperty -Path HKLM:"SOFTWARE\Microsoft\Microsoft SQL Server\Instance Names\SQL" -ErrorAction SilentlyContinue).$vInstance
        $vRegPath = "SOFTWARE\Microsoft\Microsoft SQL Server\" + $vRegInst + "\MSSQLServer"
        # Get the Data and Log file paths if available
        $vDataPath = (Get-ItemProperty -Path HKLM:$vRegPath -ErrorAction SilentlyContinue).DefaultData
        $vLogPath = (Get-ItemProperty -Path HKLM:$vRegPath -ErrorAction SilentlyContinue).DefaultLog
        # Report the entries found
        $Locations = [PSCustomObject]@{
            Data = ""
            Log  = ""
        }
        if ($vDataPath.Length -lt 1) {
            $vRegPath = "SOFTWARE\Microsoft\Microsoft SQL Server\" + $vRegInst + "\Setup"
            $vDataPath = (Get-ItemProperty -Path HKLM:$vRegPath -ErrorAction SilentlyContinue).SQLDataRoot + "\Data\"
            $Locations.Data = $vDataPath
        }
        else {
            $Locations.Data = $vDataPath
        }
        if ($vLogPath.Length -lt 1) {
            $vRegPath = "SOFTWARE\Microsoft\Microsoft SQL Server\" + $vRegInst + "\Setup"
            $vDataPath = (Get-ItemProperty -Path HKLM:$vRegPath -ErrorAction SilentlyContinue).SQLDataRoot + "\Data\"
            $Locations.Log = $vDataPath
        }
        else {
            $Locations.Log = $vDataPath
        }
        $Locations
    }
    function Get-DiskCounters {
        param ($Drive)
        $Counters = @(
            "\LogicalDisk($Drive*)\Avg. Disk sec/Read"
            "\LogicalDisk($Drive*)\Avg. Disk sec/Write"
            "\LogicalDisk($Drive*)\Disk Reads/sec"
            "\LogicalDisk($Drive*)\Disk Writes/sec"
        )
        $CounterData = Get-Counter -Counter $Counters -MaxSamples 1 -SampleInterval 10 | Select-Object -ExpandProperty CounterSamples

        $CounterData | Where-Object { $_.CookedValue -gt $DiskSpeedThreshold } | Write-Output
    }
    function Get-DiskFreePercentage {
        param ($Drive)
        $TotalSize = Get-Partition | Where-Object { $_.DriveLetter -like $Drive } | Select-Object -ExpandProperty Size
        $Free = Get-PSDrive -Name $Drive | Select-Object -ExpandProperty Free
        try {
            $Free / $TotalSize * 100
        }
        catch {
            0
        }
    }
    $script:HasErrors = $false
}
process {
    Write-Host
    if (-not (Test-IsElevated)) {
        Write-Error -Message "Access Denied. Please run with Administrator privileges."
        exit 1
    }
    $Services = Get-Service | Where-Object { $_.DisplayName -like "SQL Server*" }
    $SqlDbServices = $Services | Where-Object { $_.DisplayName -like "SQL Server (*" } | Select-Object -ExpandProperty DisplayName
    $SqlDbNames = $SqlDbServices | ForEach-Object {
        "$_" -split '\(' -replace '\)' | Select-Object -Last 1
    }

    # Get all MS SQL Databases
    $Databases = $SqlDbNames | ForEach-Object {
        $DbName = $_
        $DbLocations = Get-DefaultDBLocation -vInstance $DbName
        [PSCustomObject]@{
            Name            = $DbName
            DatabaseService = $Services | Where-Object { $_.DisplayName -like "SQL Server ($DbName)" }
            AgentService    = $Services | Where-Object { $_.DisplayName -like "*Agent *$DbName*" }
            DataPath        = $DbLocations.Data
            LogPath         = $DbLocations.Log
        }
    }

    $Databases | ForEach-Object {
        $Database = $_
        $DatabaseService = $Database.DatabaseService
        $AgentService = $Database.AgentService
        $DatabaseName = $Database.Name
        $Drive = $Database.DataPath -split ':\\' | Select-Object -First 1

        # Check service status
        if ($DatabaseService.Status -notlike "Running") {
            Write-Host "[$DatabaseName] Database Service is not running."
            $script:HasErrors = $true
        }
        if ($AgentService.Status -notlike "Running") {
            Write-Host "[$DatabaseName] Database Agent Service is not running."
            if ($RequireAgentService) {
                $script:HasErrors = $true
            }
        }

        # Get disk free space percentage
        $FreePercent = Get-DiskFreePercentage -Drive $Drive
        if ($FreePercent -lt $DiskSpaceThreshold) {
            Write-Host "[$DatabaseName] $($Drive): is under the threshold($DiskSpaceThreshold%) at $([System.Math]::Round($FreePercent,0))%"
            $script:HasErrors = $true
        }

        # Get disk latency
        $HighCounters = Get-DiskCounters -Drive $Drive
        if ($HighCounters) {
            $HighCounters | ForEach-Object {
                Write-Host "[$DatabaseName] Disk Read/Write latency is over $DiskSpeedThreshold ms at $([System.Math]::Round($_.CookedValue,2)) for $($_.InstanceName)."
            }
            $HighCounters | Out-String | Write-Host
            $script:HasErrors = $true
        }
    }

    if ($script:HasErrors) {
        exit 1
    }
    else {
        Write-Host "SQL Server's services are running."
        Write-Host "SQL Server's disk latency is below threshold."
        Write-Host "SQL Server's disk free space is above threshold."
        exit 0
    }
    
}
end {
    
    
    
}

 

Detaillierte Aufschlüsselung

Das Skript beginnt mit einer Reihe von Parametern, die eine Anpassung an spezifische Überwachungsbedürfnisse ermöglichen, zum Beispiel Schwellenwerte für Speicherplatz und Geschwindigkeit. Es umfasst mehrere Funktionen:

• Test-IsElevated: Überprüft, ob das Skript mit Administratorrechten ausgeführt wird, die für den Zugriff auf bestimmte Systeminformationen unerlässlich sind.
• Get-DefaultDBLocation: Legt die Standardspeicherorte für Daten und Protokolldateien für SQL Server-Instanzen fest.
• Get-DiskCounters: Ruft Metriken zur Festplattenleistung ab.
• Get-DiskFreePercentage: Berechnet den Prozentsatz des freien Speicherplatzes.

In seinem Hauptprozess bewertet das Skript den Status der SQL Server-Dienste, der Agentendienste, den Speicherplatz und die Festplattenlatenz. Wenn ein Parameter unter die festgelegten Schwellenwerte fällt oder ein Dienst nicht läuft, wird ein Fehler gemeldet.

Mögliche Anwendungsfälle

Stellen Sie sich einen MSP vor, der für die Wartung der SQL Server-Umgebung eines Kunden verantwortlich ist. Er kann dieses Skript so planen, dass es in regelmäßigen Abständen ausgeführt wird, um sicherzustellen, dass potenzielle Probleme mit Datenbankdiensten, Speicherplatz oder Latenzzeiten schnell erkannt und behoben werden, wodurch das Risiko von Serverausfällen oder Leistungseinbußen verringert wird.

Vergleiche

Herkömmliche Methoden zur Überwachung vom SQL Server-Zustand bestehen oft in manuellen Kontrollen oder Tools von Drittanbietern. Dieses Skript bietet jedoch einen stärker integrierten und automatisierten Ansatz, der Echtzeitwarnmeldungen ermöglicht und menschliches Versagen minimiert.

FAQs

Q1: Wie oft sollte das Skript ausgeführt werden? 
A1: Dies hängt von der Kritikalität der SQL Server-Umgebung ab. Für Datenbanken mit hohem Datenverkehr kann ein täglicher oder sogar stündlicher Zeitplan angemessen sein.

Q2: Kann das Skript für verschiedene SQL Server-Versionen angepasst werden? 
A2: Ja, es kann für verschiedene Versionen angepasst werden, wobei je nach den spezifischen Funktionen und Konfigurationen der Version einige Anpassungen erforderlich sein können.

Q3: Sind für die Verwendung dieses Skripts PowerShell-Kenntnisse erforderlich? 
A3: Grundlegende PowerShell-Kenntnisse sind von Vorteil, aber das Skript ist benutzerfreundlich gestaltet und enthält klare Parameteranweisungen.

Folgen

Eine ineffiziente Überwachung kann zu Serverausfällen, langsamen Abfrageantworten und sogar zu Datenverlusten führen. Dieses Skript minimiert solche Risiken und trägt zu einer sichereren und zuverlässigeren IT-Umgebung bei.

Empfehlungen

• Aktualisieren Sie das Skript regelmäßig, um es an neue SQL Server-Versionen oder organisatorische Änderungen anzupassen.
• Kombinieren Sie dieses Skript mit anderen Überwachungs-Tools, um einen umfassenden Überblick über die IT-Infrastruktur zu erhalten.
• Schulung der IT-Mitarbeiter:innen in PowerShell, um den Nutzen des Skripts zu maximieren.

Abschließende Überlegungen

In der Welt der Datenbankverwaltung und IT-Infrastrukturüberwachung bieten Tools wie NinjaOne robuste Lösungen, die PowerShell-Skripte ergänzen. NinjaOne kann die Fähigkeiten solcher Skripte verbessern, indem es eine einheitliche Plattform für die Überwachung, Benachrichtigung und Automatisierung von Reaktionen auf SQL Server-Leistungsprobleme bietet. Durch die Integration von Skripten mit solchen Tools können Unternehmen eine proaktivere und effizientere IT-Verwaltungsstrategie erreichen und sicherstellen, dass ihre SQL-Server stabil, reaktionsschnell und zuverlässig bleiben.