Benutzerdefinierte Windows-Dienste erstellen und verwalten

PowerShell:

• New-Service: Legt einen neuen Dienst an.
• Remove-Service: Löscht einen existierenden Dienst.
• Set-Service: Ändert Parameter eines Dienstes wie Starttyp oder Anmeldekonto.

sc.exe (Service Controller):

• Ein Kommandozeilentool, das schon sehr lange unter Windows existiert und manuell oder in Batch-Skripten genutzt werden kann.
• Beispiel: sc create MeinDienst binPath= "C:\path\to\programm.exe" start= auto

NSSM (Non-Sucking Service Manager):

• Ein beliebter Community-Weg, um selbst geschriebene Skripte (PowerShell, Python, Java etc.) als Dienst einzurichten.
• Vereinfacht das Handling und bietet u. a. eine übersichtliche GUI für die Konfiguration.

.NET und Visual Studio:

• Wer eine eigene Anwendung (z. B. in C#) schreibt, kann direkt auf die ServiceBase-Klasse zurückgreifen und so professionelle Windows-Dienste entwickeln.

Beispiel 1: Einfache CPU-Überwachung

Szenario
Ein Dienst, der in regelmäßigen Abständen die CPU-Auslastung misst und einen Warnhinweis ins Ereignisprotokoll schreibt, wenn sie über 80 % liegt. Nützlich in Situationen, in denen man eine gewisse Last nicht dauerhaft überschreiten möchte oder Engpässe frühzeitig bemerken will.

Skript (C:\Scripts\CPUWatchdog.ps1):

# CPUWatchdog.ps1
# Überwacht die CPU-Auslastung und schreibt einen Log-Eintrag,
# wenn der Wert über 80% liegt.

$LogName  = "Application"
$EventID  = 3001
$EventSrc = "CPUWatchdog"

# Dienst-Schleife
while ($true) {
    # CPU ermitteln
    $cpu = Get-Counter -Counter "\Processor(_Total)\% Processor Time" -SampleInterval 1 -MaxSamples 1
    $cpuValue = [int]$cpu.CounterSamples.CookedValue

    if ($cpuValue -gt 80) {
        # Ereignis ins Event Log schreiben
        Write-EventLog -LogName $LogName -Source $EventSrc -EventId $EventID -EntryType Warning -Message "CPU-Auslastung über 80%: $cpuValue%"
    }

    Start-Sleep -Seconds 5
}

Dienst erstellen:

New-Service -Name "CPUWatchdog" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\CPUWatchdog.ps1" `
    -DisplayName "CPU Watchdog Dienst" `
    -Description "Überwacht kontinuierlich die CPU-Auslastung und warnt bei Überschreitung." `
    -StartupType Automatic

Beispiel 2: Automatische SQL-Datenbank-Backups

Szenario
Tägliche Sicherung einer oder mehrerer Datenbanken auf einem Netzlaufwerk. Unternehmen profitieren, da sie Backups nicht mehr manuell anstoßen müssen. Das Skript läuft im Hintergrund als Dienst und kümmert sich um die Datensicherung.

Skript (C:\Scripts\DatabaseBackup.ps1):

# DatabaseBackup.ps1
# Führt ein tägliches Backup einer SQL-Datenbank durch und legt das Ergebnis
# in einem gewünschten Verzeichnis ab.

$SqlServer = "SQL01\INSTANCE"
$Database  = "WichtigeDB"
$BackupDir = "\\Fileserver\Backups\Databases"
$LogName   = "Application"
$Source    = "DBBackupService"

function Do-DatabaseBackup {
    param (
        [string]$ServerInstance,
        [string]$DbName,
        [string]$BackupPath
    )

    $backupFile = Join-Path $BackupPath ("$($DbName)_$(Get-Date -Format yyyyMMdd_HHmmss).bak")
    $sql = "BACKUP DATABASE [$DbName] TO DISK = N'$backupFile' WITH NOFORMAT, NOINIT, NAME = N'$($DbName) Full Backup', SKIP, NOREWIND, NOUNLOAD, STATS = 10;"

    try {
        Invoke-Sqlcmd -ServerInstance $ServerInstance -Query $sql
        Write-EventLog -LogName $LogName -Source $Source -EventId 4001 -EntryType Information -Message "Backup für $DbName erfolgreich abgeschlossen. Datei: $backupFile"
    }
    catch {
        Write-EventLog -LogName $LogName -Source $Source -EventId 4002 -EntryType Error -Message "Fehler beim Backup von $DbName: $_"
    }
}

while ($true) {
    $currentTime = Get-Date -Format "HH:mm"
    if ($currentTime -eq "01:00") {
        Do-DatabaseBackup -ServerInstance $SqlServer -DbName $Database -BackupPath $BackupDir
        Start-Sleep -Seconds 86400
    } else {
        Start-Sleep -Seconds 300
    }
}

Dienst erstellen:

New-Service -Name "DBBackupService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\DatabaseBackup.ps1" `
    -DisplayName "Datenbank-Backup-Dienst" `
    -Description "Sichert jede Nacht die SQL-Datenbank und legt die Sicherung auf dem Netzlaufwerk ab." `
    -StartupType Automatic

Beispiel 3: Log-Archivierung mit Kompression

Szenario
Stetig wachsende Logdateien in einem bestimmten Verzeichnis belasten die Übersicht oder den Speicherplatz. Dieses Skript sucht nach älteren Logs (z. B. älter als eine Woche), komprimiert sie und verschiebt sie ins Archiv.

Skript (C:\Scripts\LogArchiver.ps1):

# LogArchiver.ps1
# Durchsucht ein Verzeichnis nach alten Logdateien (älter als 7 Tage), komprimiert sie
# und verschiebt die Archiv-ZIP-Dateien in ein spezielles Archivverzeichnis.

$SourcePath   = "C:\Logs"
$ArchivePath  = "C:\Logs\Archiv"
$LogName      = "Application"
$EventSource  = "LogArchiver"
$ZipModule    = "C:\Scripts\ModulesZipZip.psm1"  # Beispiel für externes Modul

Import-Module $ZipModule -ErrorAction SilentlyContinue

function Compress-LogFile {
    param (
        [string]$FilePath
    )
    $fileName  = Split-Path $FilePath -Leaf
    $zipName   = $fileName.Replace(".log", ".zip")
    $zipTarget = Join-Path $ArchivePath $zipName

    # Beispielhafter Aufruf einer externen ZIP-Funktion:
    # Compress-7Zip -Source $FilePath -Destination $zipTarget 

    # Demonstration: nur Kopieren und alte Datei löschen
    [System.IO.File]::Copy($FilePath, $zipTarget)
    Remove-Item $FilePath -Force
}

while ($true) {
    try {
        $oldFiles = Get-ChildItem $SourcePath -Filter *.log -File | Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-7) }
        foreach ($file in $oldFiles) {
            Compress-LogFile -FilePath $file.FullName
        }
        Write-EventLog -LogName $LogName -Source $EventSource -EventId 5001 -EntryType Information -Message "Logarchivierung erfolgreich abgeschlossen."
    }
    catch {
        Write-EventLog -LogName $LogName -Source $EventSource -EventId 5002 -EntryType Error -Message "Fehler bei der Logarchivierung: $_"
    }

    Start-Sleep -Seconds 86400
}

Dienst erstellen:

New-Service -Name "LogArchiverService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\LogArchiver.ps1" `
    -DisplayName "Log-Archivierungsdienst" `
    -Description "Komprimiert alte Logdateien und verschiebt sie ins Archiv." `
    -StartupType Automatic

Beispiel 4: Netzwerkfreigabe-Überwachung (Ping-Monitor)

Szenario
Ein wichtiges Netzwerkshare wird sporadisch unerreichbar. Dieser PowerShell-Dienst pingt den Fileserver, um Ausfälle zu registrieren. Bei wiederholten Fehlschlägen wird ein Eintrag im Eventlog erzeugt und ggf. ein Dienstneustart (z. B. LanmanServer) ausgelöst.

Skript (C:\Scripts\ShareMonitor.ps1):

# ShareMonitor.ps1
# Überwacht in festen Abständen eine Netzwerkfreigabe per Ping und meldet Ausfälle.

$Server         = "FILESERVER01"
$LogName        = "System"
$EventSource    = "ShareMonitor"
$PingInterval   = 60   # in Sekunden
$FailureCount   = 0
$FailureLimit   = 3    # Ab wie vielen aufeinanderfolgenden Fehlern eine Aktion ausgelöst wird

while ($true) {
    $pingResult = Test-Connection -ComputerName $Server -Count 1 -Quiet
    if ($pingResult -eq $false) {
        $FailureCount++
        if ($FailureCount -ge $FailureLimit) {
            Write-EventLog -LogName $LogName -Source $EventSource -EventId 6001 -EntryType Error -Message "$Server nicht erreichbar. $FailureCount Pings fehlgeschlagen."
            # Beispielhafter Neustart eines Dienstes
            # Restart-Service -Name "LanmanServer" -ErrorAction SilentlyContinue
        }
    } else {
        $FailureCount = 0
    }
    Start-Sleep -Seconds $PingInterval
}

Dienst erstellen:

New-Service -Name "ShareMonitorService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\ShareMonitor.ps1" `
    -DisplayName "Netzwerkfreigabe-Überwachung" `
    -Description "Ping-Überwachung einer wichtigen Netzwerkfreigabe." `
    -StartupType Automatic

Beispiel 5: Automatische Firewallregel-Aktualisierung

Szenario
Bestimmte IP-Ranges ändern sich regelmäßig, sollen aber immer Zugriff auf Port 80/443 haben. Das Skript liest eine Konfigurationsdatei ein und passt eine Firewallregel an. Ideal, wenn sich externe Partner-Netzwerke öfter ändern.

Skript (C:\Scripts\FirewallUpdateService.ps1):

# FirewallUpdateService.ps1
# Liest eine Datei mit neuen IP-Bereichen und passt die Windows-Firewallregeln an.

$configFile    = "C:\Scripts\allowedIPs.txt"
$ruleName      = "AllowCustomIPs"
$LogName       = "Application"
$EventSource   = "FirewallUpdateService"

function Update-FirewallRule {
    param(
        [string]$RuleName,
        [string[]]$IPList
    )
    # Bestehende Regel löschen, falls vorhanden
    netsh advfirewall firewall delete rule name="$RuleName" dir=in
    # Neue Regel anlegen
    netsh advfirewall firewall add rule name="$RuleName" dir=in action=allow protocol=TCP localport=80,443 remoteip=($IPList -join ",")
}

while ($true) {
    try {
        if (Test-Path $configFile) {
            $ipList = Get-Content $configFile | Where-Object { $_ -match '^\d{1,3}\.' }
            if ($ipList) {
                Update-FirewallRule -RuleName $ruleName -IPList $ipList
                Write-EventLog -LogName $LogName -Source $EventSource -EventId 7001 -EntryType Information -Message "Firewallregel erfolgreich aktualisiert."
            }
        }
    }
    catch {
        Write-EventLog -LogName $LogName -Source $EventSource -EventId 7002 -EntryType Error -Message "Fehler bei Firewall-Aktualisierung: $_"
    }

    Start-Sleep -Seconds 14400
}

Dienst erstellen:

New-Service -Name "FirewallUpdateService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\FirewallUpdateService.ps1" `
    -DisplayName "Firewall Update Dienst" `
    -Description "Aktualisiert regelmäßig eine Windows-Firewallregel basierend auf externer Konfiguration." `
    -StartupType Automatic

Beispiel 6: Automatischer Shutdown bei Inaktivität

Szenario
Ein Dienst, der prüft, ob der Computer in einem bestimmten Zeitfenster (z. B. 22–06 Uhr) nicht genutzt wird. Ist keine Session aktiv, erfolgt ein Herunterfahren, um Energie zu sparen. Typisch für Bürorechner oder Terminalserver, die nachts nicht laufen müssen.

Skript (C:\Scripts\AutoShutdown.ps1):

# AutoShutdown.ps1
# Wenn das System in einem festgelegten Zeitfenster ohne aktive User ist,
# soll es heruntergefahren werden.

$startTime = [TimeSpan]"22:00"
$endTime   = [TimeSpan]"06:00"
$LogSource = "AutoShutdownService"

while ($true) {
    $nowTimeSpan = (Get-Date).TimeOfDay
    if (($nowTimeSpan -ge $startTime) -or ($nowTimeSpan -le $endTime)) {
        # Prüfen, ob ein Benutzer angemeldet ist
        $sessions = quser 2>$null | Select-Object -Skip 1
        if (-not $sessions) {
            Write-EventLog -LogName "System" -Source $LogSource -EventId 8001 -EntryType Information -Message "Leerlauf erkannt, initiiere Shutdown."
            Stop-Computer -Force
        }
    }
    Start-Sleep -Seconds 300
}

Dienst erstellen:

New-Service -Name "AutoShutdownService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\AutoShutdown.ps1" `
    -DisplayName "Automatischer Shutdown" `
    -Description "Fährt das System in definierten Zeitfenstern automatisch herunter, wenn keine Benutzer angemeldet sind." `
    -StartupType Automatic

Beispiel 7: E-Mail-Warnung bei wenig Festplattenspeicher

Szenario
Wird auf Laufwerk C: der freie Speicher zu knapp, soll eine Warn-E-Mail ans Administratorenteam gesendet werden. So vermeidet man Systemstillstände wegen volllaufender Partitionen.

Skript (C:\Scripts\DiskSpaceMonitor.ps1):

# DiskSpaceMonitorSSL_Plaintext.ps1
# ---------------------------------
# Überwacht den freien Speicherplatz auf Laufwerk C und verschickt eine Warn-E-Mail
# über SSL/TLS, sobald ein definierter Schwellwert (z. B. 5 GB) unterschritten wird.
# Die SMTP-Zugangsdaten liegen hier bewusst im Klartext vor. In echten Produktivumgebungen
# ist dies aus Sicherheitsgründen NICHT empfohlen.

# ---------------------------
# KONFIGURATION
# ---------------------------
$Drive         = "C:"
$ThresholdGB   = 5

# SMTP-Einstellungen
$SmtpServer    = "mail.example.com"
$SmtpPort      = 587      # 587 (TLS) oder 465 (SSL)
$UseSsl        = $true    # True für SSL/TLS-Verschlüsselung

# Klartext-Zugangsdaten
$SmtpUsername  = "monitor@example.com"
$SmtpPassword  = "P@ssw0rd123"  # Beispielpasswort (im Klartext!)

# Absender und Empfänger
$EmailFrom     = "monitor@example.com"
$EmailTo       = "admin@example.com"
$MailSubject   = "WARNUNG: Freier Speicherplatz knapp"

# Windows-Eventlog-Einstellungen
$LogName       = "Application"
$EventSource   = "DiskSpaceMonitorSSLPlaintext"

# ---------------------------
# PSCredential für Send-MailMessage erstellen
# (Trotz Klartext-Passwort erzeugen wir ein SecureString-Objekt,
#  damit Send-MailMessage ein Credential-Objekt nutzen kann.)
# ---------------------------
$SecurePassword = ConvertTo-SecureString $SmtpPassword -AsPlainText -Force
$SmtpCredential = New-Object System.Management.Automation.PSCredential($SmtpUsername, $SecurePassword)

# ---------------------------
# FUNKTION: SendWarningMail
# ---------------------------
function SendWarningMail {
    param (
        [string]$Subject,
        [string]$Body
    )
    Send-MailMessage `
        -SmtpServer  $SmtpServer `
        -Port        $SmtpPort `
        -UseSsl      $UseSsl `
        -Credential  $SmtpCredential `
        -From        $EmailFrom `
        -To          $EmailTo `
        -Subject     $Subject `
        -Body        $Body
}

# ---------------------------
# HAUPTSCHLEIFE
# ---------------------------
while ($true) {
    try {
        # Freien Speicherplatz ermitteln
        $FreeGB = [math]::Round((Get-PSDrive $Drive).Free / 1GB, 2)
        
        # Prüfen, ob der Schwellwert unterschritten ist
        if ($FreeGB -lt $ThresholdGB) {
            $Subject = "$MailSubject ($FreeGB GB)"
            $Body    = "ACHTUNG: Das Laufwerk $Drive hat nur noch $FreeGB GB freien Speicherplatz."
            
            # Warn-E-Mail versenden
            SendWarningMail -Subject $Subject -Body $Body
            
            # Ereignis ins Windows-Eventlog schreiben
            Write-EventLog -LogName $LogName `
                           -Source $EventSource `
                           -EventId 9001 `
                           -EntryType Warning `
                           -Message $Subject
        }
    }
    catch {
        # Bei Fehlern Eintrag ins Eventlog
        Write-EventLog -LogName $LogName `
                       -Source $EventSource `
                       -EventId 9002 `
                       -EntryType Error `
                       -Message "Fehler beim DiskSpace-Monitoring (SSL): $_"
    }

    # 30 Minuten warten, dann erneut prüfen
    Start-Sleep -Seconds 1800
}

Dienst erstellen:

NeNew-Service -Name "DiskSpaceMonitorSSLPlaintextService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\DiskSpaceMonitorSSL_Plaintext.ps1" `
    -DisplayName "Festplattenspeicher-Überwachung SSL (Plaintext Credentials)" `
    -Description "Versendet Warnmails bei knappem Speicher. SMTP-Credentials im Klartext." `
    -StartupType Automatic

Beispiel 8: Zentrales Eventlog-Forwarding (Syslog)

Szenario
Manche Organisationen leiten Windows-Ereignisse in Echtzeit an einen zentralen Syslog-Server weiter. Das folgende Skript beobachtet das „Application“-Log und leitet neu auftretende Events an einen Syslog-Endpunkt (beispielhaft) weiter.

Skript (C:\Scripts\EventLogCollector.ps1):

# EventLogCollector.ps1
# Liest neu auftretende Ereignisse aus der Windows-Ereignisanzeige (Application) und sendet sie an einen Syslog-Server.

$syslogServer  = "192.168.0.50"
$logname       = "Application"
$EventSource   = "EventLogCollector"

$lastCheck = Get-Date

function Send-Syslog {
    param(
        [string]$Message
    )
    # Beispiel: Syslog-Send via UDP oder externes Modul
    Write-Host "Sende an Syslog: $Message"
}

while ($true) {
    try {
        $newEvents = Get-EventLog -LogName $logname -After $lastCheck
        if ($newEvents) {
            foreach ($evt in $newEvents) {
                $msg = "EventID: $($evt.EventID), Source: $($evt.Source), Message: $($evt.Message)"
                Send-Syslog -Message $msg
            }
            $lastCheck = Get-Date
        }
    }
    catch {
        Write-EventLog -LogName $logname -Source $EventSource -EventId 10001 -EntryType Error -Message "Fehler beim Abfragen von EventLogs: $_"
    }
    Start-Sleep -Seconds 15
}

Dienst erstellen:

New-Service -Name "EventLogCollectorService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\EventLogCollector.ps1" `
    -DisplayName "Eventlog nach Syslog-Weiterleitung" `
    -Description "Sammelt Ereignisse aus der Windows-Ereignisanzeige und sendet sie an einen Syslog-Server." `
    -StartupType Automatic

Beispiel 9: Registry-Bereinigung

Szenario
In manchen Umgebungen entstehen nach dem Systemstart oder nach Software-Updates irrelevante Registry-Einträge, die regelmäßig entfernt werden sollen. Das Skript löscht diese Einträge periodisch.

Skript (C:\Scripts\RegistryCleaner.ps1):

# RegistryCleaner.ps1
# Beispielhaftes Skript, das bestimmte Registrypfade bereinigt.

$pathsToClean = @(
    "HKCU:\Software\SomeOldApp",
    "HKLM:\SOFTWARE\AnotherKey"
)
$LogName     = "System"
$EventSource = "RegistryCleaner"

while ($true) {
    try {
        foreach ($path in $pathsToClean) {
            if (Test-Path $path) {
                Remove-Item $path -Recurse -Force
                Write-EventLog -LogName $LogName -Source $EventSource -EventId 11001 -EntryType Information -Message "Registry-Schlüssel entfernt: $path"
            }
        }
    }
    catch {
        Write-EventLog -LogName $LogName -Source $EventSource -EventId 11002 -EntryType Error -Message "Fehler bei der Registry-Bereinigung: $_"
    }

    Start-Sleep -Seconds 43200
}

Dienst erstellen:

New-Service -Name "RegistryCleanerService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\RegistryCleaner.ps1" `
    -DisplayName "Registry-Bereinigungsdienst" `
    -Description "Entfernt ungenutzte Registry-Einträge in festen Intervallen." `
    -StartupType Automatic

Beispiel 10: Datenkollektion für ein Custom-Dashboard

Szenario
In vielen IT-Teams entsteht das Bedürfnis, ein eigenes Dashboard zu bauen, das System-Kennzahlen in Echtzeit anzeigt. Dieses Skript sammelt CPU-Last, Speicherauslastung und Prozessanzahl und schreibt sie alle paar Minuten in eine CSV-Datei, die man mit Power BI, Excel oder anderen Tools visualisieren kann.

Skript (C:\Scripts\DashboardCollector.ps1):

# DashboardCollector.ps1
# Sammelt diverse Kennzahlen und schreibt sie in eine CSV-Datei.

$outputFile = "C:\Scripts\DashboardData.csv"

if (-not (Test-Path $outputFile)) {
    "Timestamp,CPU_Usage,Memory_MB,Processes_Count" | Out-File $outputFile
}

while ($true) {
    $timestamp   = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $cpuCounter  = Get-Counter "\Processor(_Total)\% Processor Time" -SampleInterval 1 -MaxSamples 1
    $cpuUsage    = [int]$cpuCounter.CounterSamples.CookedValue
    $memUsedMB   = (Get-WmiObject Win32_OperatingSystem).TotalVisibleMemorySize - (Get-WmiObject Win32_OperatingSystem).FreePhysicalMemory
    $procCount   = (Get-Process | Measure-Object).Count

    $line = "$timestamp,$cpuUsage,$memUsedMB,$procCount"
    Add-Content -Path $outputFile -Value $line

    Start-Sleep -Seconds 60
}

Dienst erstellen:

New-Service -Name "DashboardCollectorService" `
    -BinaryPathName "powershell.exe -ExecutionPolicy Bypass -File C:\Scripts\DashboardCollector.ps1" `
    -DisplayName "Dashboard-Datenkollektor" `
    -Description "Erfasst Systemkennzahlen und schreibt sie in eine CSV-Datei." `
    -StartupType Automatic