Compare commits

...
18 Commits
Author SHA1 Message Date
Madzone 193fa40e3c update 2026-10-15 14:46:41 +02:00
Madzone 1b3e50cd32 function Get-VeeamConfig {
<#
        .SYNOPSIS
            Lädt zentrale Veeam Konfiguration aus JSON.
    #>

    param(

        [string]$Path = (Join-Path ( Split-Path $PSScriptRoot -Parent )"Config\VeeamConfig.json")

    )

    if(!(Test-Path $Path))
    {

        throw `

            "Konfigurationsdatei nicht gefunden: $Path"

    }

    $Content =

        Get-Content `

            -Path $Path `

            -Raw

    $Configuration =

        $Content |

        ConvertFrom-Json

    return $Configuration

}
2026-10-15 13:11:00 +02:00
Madzone 242c7c1253 Update 2026-10-15 13:00:30 +02:00
Madzone dd8d44da1e Update 2026-10-15 12:21:26 +02:00
Madzone c286614cfd Update 2026-10-13 15:13:34 +02:00
Madzone 3bc149a3e6 Update 2026-10-09 15:08:41 +02:00
Madzone ae8f403715 Update 2026-10-09 14:55:47 +02:00
Madzone 2500b1f354 Update 2026-10-09 14:50:28 +02:00
Madzone afbad0cb50 EJBCA Update 2026-09-25 21:14:21 +02:00
Madzone 3555432cd7 Update 2026-09-24 16:39:49 +02:00
Madzone 9da9ec58cc EJBCA 2026-09-24 16:31:15 +02:00
Madzone dc08e3ec4f feat(stagging): add OVSIntPort settings to PVE network workbook 2026-09-10 21:52:57 +02:00
Madzone e848c66626 feat(stagging): plan vCenter and PVE networks before VM deployment 2026-09-10 21:43:08 +02:00
Madzone b0ad63185f OLDAP 2026-09-10 14:24:39 +02:00
Madzone ce5e389abd New 2026-09-10 09:14:19 +02:00
Madzone efba066b51 New Version 2026-09-09 14:13:44 +02:00
Madzone 23312854fc New Version 2026-09-09 13:31:53 +02:00
Madzone 0206070493 feat(stagging): rename hypervisor sheet and add VM specifications 2026-09-09 11:18:49 +02:00
88 changed files with 7514 additions and 136 deletions
@@ -0,0 +1,2 @@
reports/
*.local.json
@@ -0,0 +1,22 @@
# Zuordnung verbindlicher Anforderungen – Entwurf
Nur in einer zugelassenen Umgebung mit freigegebenen Angaben ergänzen.
Für jede Sicherheitsdomäne einen eigenen geprüften Vorlagenstand führen.
NATO-/EU-Zuordnungen sind offen und werden nicht aus SCG-/STIG-Werten abgeleitet.
| Bereich | Umsetzung im Paket | Verbindliche Vorgabe / Stand | Nachweis / Ausnahme |
|---|---|---|---|
| Kontosperre und Entsperrzeit | AccountLockFailures=5, AccountUnlockTime=900 | Offen | JSON-Bericht |
| Passworthistorie | PasswordHistory=5 | Offen | JSON-Bericht |
| Passwortqualität | PasswordQualityControl laut baseline.json | Offen | JSON-Bericht; lokale Konten |
| SSH und ESXi Shell | Startmodus off, beendet | Offen | JSON-Bericht; Wartungsprozess ergänzen |
| Rollen, MFA, Notfallzugriff, Lockdown | Nicht automatisiert | Offen | Separater Prüfpunkt |
| Netz-/Sicherheitsdomänentrennung | Nicht automatisiert | Offen | Architekturprüfung |
| Zeitquelle, Remote-Logs, Aufbewahrung | Nicht automatisiert | Offen | Funktions-/Transportprüfung |
| Secure Boot, TPM, Verschlüsselung | Nicht automatisiert | Offen | Plattformprüfung |
| Zertifikate, Patch-/Buildstand | Build wird protokolliert | Offen | Separater Prüfpunkt |
| vCenter, VMs, vSAN, Backups | Nicht automatisiert | Offen | Separate Baselines |
Freigabeverantwortliche Stelle: offen
Freigegebener Vorlagenstand und Geltungsbereich: offen
Ausnahmen, Begründung, Ablaufdatum: offen
@@ -0,0 +1,108 @@
#Requires -Version 7.0
[CmdletBinding(SupportsShouldProcess, ConfirmImpact = 'High')]
param(
[Parameter(Mandatory)][string]$VCenter,
[Parameter(Mandatory)][string[]]$VMHostName,
[string]$BaselinePath = (Join-Path $PSScriptRoot 'baseline.json'),
[ValidateSet('Audit', 'Apply')][string]$Mode = 'Audit',
[string]$ReportDirectory = (Join-Path $PSScriptRoot 'reports')
)
Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'
$config = Get-Content -LiteralPath $BaselinePath -Raw | ConvertFrom-Json
if ($config.TargetVersion -ne '8.0.3') { throw 'Diese Version des Werkzeugs unterstützt ESXi 8.0.3.' }
if (@($config.AdvancedSettings).Count + @($config.Services).Count -eq 0) { throw 'Leere Baseline.' }
foreach ($entry in $config.AdvancedSettings) {
if ([string]::IsNullOrWhiteSpace($entry.Name) -or $null -eq $entry.Value) { throw 'Ungültiger Einstellungswert.' }
}
foreach ($entry in $config.Services) {
if ($entry.Policy -notin @('on', 'off', 'automatic') -or $entry.Running -isnot [bool]) { throw 'Ungültige Dienstkonfiguration.' }
}
foreach ($name in $VMHostName) {
if ([string]::IsNullOrWhiteSpace($name) -or $name -match '[*?\[\]]') { throw 'Nur explizite Hostnamen, keine Suchmuster angeben.' }
}
Import-Module VMware.VimAutomation.Core -ErrorAction Stop
# Existing authenticated session only; no embedded credentials or certificate bypass.
$sessions = @(foreach ($variableName in @('DefaultVIServers', 'DefaultVIServer')) {
$variable = Get-Variable -Name $variableName -Scope Global -ErrorAction SilentlyContinue
if ($null -ne $variable) { $variable.Value }
})
$servers = @($sessions | Where-Object { $_.Name -eq $VCenter -and $_.IsConnected } | Sort-Object -Property Name -Unique)
if ($servers.Count -ne 1) { throw 'Zuerst mit Connect-VIServer genau eine Sitzung zum angegebenen vCenter herstellen.' }
$server = $servers[0]
if ([version]$server.Version -lt [version]'8.0' -or [version]$server.Version -ge [version]'9.0') { throw 'vCenter 8 erforderlich.' }
# Resolve and validate every target before making any change.
$targets = @(foreach ($name in ($VMHostName | Select-Object -Unique)) {
$found = @(Get-VMHost -Server $server -Name $name | Where-Object { $_.Name -eq $name })
if ($found.Count -ne 1) { throw "Host nicht eindeutig gefunden: $name" }
if ($found[0].Version -ne $config.TargetVersion) { throw "Nicht unterstützte ESXi-Version auf $name" }
if ([string]$found[0].ConnectionState -notin @('Connected', 'Maintenance')) { throw "Host nicht erreichbar: $name" }
$found[0]
})
$runId = '{0}-{1}' -f (Get-Date -Format 'yyyyMMdd-HHmmss'), ([guid]::NewGuid().ToString('N').Substring(0,8))
# Reports are intentionally also written in Audit and -WhatIf modes.
$null = [IO.Directory]::CreateDirectory($ReportDirectory)
$reportPath = Join-Path $ReportDirectory "$runId.json"
$rows = [Collections.Generic.List[object]]::new()
$report = [ordered]@{
StartedUtc = [DateTime]::UtcNow.ToString('o'); VCenter = $VCenter; Mode = $Mode
Baseline = $config; BaselineSha256 = (Get-FileHash -LiteralPath $BaselinePath -Algorithm SHA256).Hash
Results = $rows
}
function Save-Report { $report | ConvertTo-Json -Depth 15 | Set-Content -LiteralPath $reportPath -Encoding utf8 -WhatIf:$false }
Save-Report
foreach ($target in $targets) {
$controls = @(
foreach ($entry in $config.AdvancedSettings) { [pscustomobject]@{ Kind = 'Advanced'; Entry = $entry } }
foreach ($entry in $config.Services) { [pscustomobject]@{ Kind = 'Service'; Entry = $entry } }
)
foreach ($control in $controls) {
$entry = $control.Entry
$key = if ($control.Kind -eq 'Advanced') { $entry.Name } else { $entry.Key }
$desired = if ($control.Kind -eq 'Advanced') { [string]$entry.Value } else { "$($entry.Policy)/$($entry.Running)" }
$row = [pscustomobject]@{
Host = $target.Name; Build = $target.Build; Kind = $control.Kind; Setting = $key
Control = $entry.Control; Before = $null; Desired = $desired; After = $null
Status = 'Pending'; Error = $null
}
$rows.Add($row)
try {
if ($control.Kind -eq 'Advanced') {
$items = @(Get-AdvancedSetting -Entity $target -Name $key | Where-Object Name -EQ $key)
if ($items.Count -ne 1) { throw 'Einstellung fehlt oder ist nicht eindeutig; wird nicht neu angelegt.' }
$item = $items[0]
$row.Before = [string]$item.Value
} else {
$items = @(Get-VMHostService -VMHost $target | Where-Object Key -EQ $key)
if ($items.Count -ne 1) { throw 'Dienst fehlt oder ist nicht eindeutig.' }
$item = $items[0]
$row.Before = "$($item.Policy)/$($item.Running)"
}
$row.After = $row.Before
$row.Status = if ($row.Before -ceq $desired) { 'Match' } else { 'Drift' }
if ($row.Status -eq 'Drift' -and $Mode -eq 'Apply') {
if ($PSCmdlet.ShouldProcess("$($target.Name): $key", "$($row.Before) -> $desired")) {
$row.Status = 'Applying'
Save-Report # Persist original value before any remote mutation.
if ($control.Kind -eq 'Advanced') {
$null = Set-AdvancedSetting -AdvancedSetting $item -Value $entry.Value -Confirm:$false
$row.After = [string](Get-AdvancedSetting -Entity $target -Name $key).Value
} else {
if ($item.Policy -ne $entry.Policy) { $null = Set-VMHostService -HostService $item -Policy $entry.Policy -Confirm:$false }
if ($item.Running -ne $entry.Running) {
if ($entry.Running) { $null = Start-VMHostService -HostService $item -Confirm:$false }
else { $null = Stop-VMHostService -HostService $item -Confirm:$false }
}
$fresh = Get-VMHostService -VMHost $target | Where-Object Key -EQ $key
$row.After = "$($fresh.Policy)/$($fresh.Running)"
}
$row.Status = if ($row.After -ceq $desired) { 'AppliedVerified' } else { 'VerificationFailed' }
} else { $row.Status = 'Skipped' }
}
} catch { $row.Status = 'Error'; $row.Error = $_.Exception.Message; $row.After = $null }
Save-Report
}
}
$rows | Format-Table Host, Setting, Before, Desired, After, Status -AutoSize | Out-Host
Write-Host "Bericht: $reportPath"
if (@($rows | Where-Object Status -In @('Error','VerificationFailed')).Count) { throw 'Prüfung/Anwendung unvollständig. Bericht beachten; Teiländerungen sind möglich.' }
+111
View File
@@ -0,0 +1,111 @@
# Wiederverwendbare ESXi-Sicherheitsvorlage
Entwurf für ESXi **8.0.3** und vCenter **8**. Enthält sechs automatisierte
Kontrollen als erweiterbare Startbasis, keine vollständige VMware-Härtung und
keine NATO-/EU-Freigabe. Die vier Advanced Settings stammen aus dem öffentlichen
VMware Security Configuration Guide für 8.0.3; SSH und ESXi Shell werden als
lokale Entwurfsentscheidung deaktiviert. Diese Werte sind keine behaupteten
NATO-/EU-Vorgaben. Es werden keine vCenter-Einstellungen geändert.
## Verwendung
PowerShell 7 und das Modul VMware.VimAutomation.Core werden vorausgesetzt.
In einer zugelassenen Administrationsumgebung ausführen. Zugangsdaten bleiben
in der interaktiven PowerCLI-Anmeldung; Zertifikatsprüfung nicht deaktivieren.
1. `baseline.json` pro freigegebenem Einsatzzweck kopieren und versionieren.
Anforderungen und Ausnahmen in `Anforderungsmatrix.md` ergänzen.
2. Mit vCenter verbinden und zunächst einen expliziten Testhost prüfen.
3. Änderungen simulieren, dann auf dem Testhost anwenden und erneut prüfen.
4. Erst danach denselben Vorlagenstand auf weitere passende Hosts anwenden.
```powershell
Connect-VIServer -Server 'vcenter.example.internal'
# Standard: ausschließlich prüfen
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal'
# Änderungen anzeigen, ohne sie auf dem Host auszuführen
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal' -Mode Apply -WhatIf
# Anwenden: PowerShell fragt pro abweichender Einstellung nach
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal' -Mode Apply
# Eigene, bereits geprüfte Vorlage und mehrere explizite Hosts
./Invoke-EsxiBaseline.ps1 -VCenter 'vcenter.example.internal' `
-VMHostName 'esxi01.example.internal','esxi02.example.internal' `
-BaselinePath './standort-baseline.json'
```
`-Confirm:$false` ermöglicht später einen bewusst unbeaufsichtigten Apply-Lauf.
Die Standardaktion bleibt Audit. Audit und WhatIf schreiben lokale Berichte.
Berichte unter `reports/` enthalten Baseline, Hash, Build, Vorher-/Nachherwerte
und Einzelstatus. `Match` bedeutet nur Übereinstimmung mit dieser Vorlage,
keine Gesamt-Konformität. `Drift` ist eine Abweichung, `Skipped` wurde nicht
angewendet. Fehler und fehlgeschlagene Nachprüfungen führen am Ende zu einem
terminierenden Fehler. Abweichungen im Audit sind normale Berichtsergebnisse.
Bei Fehlern können Teiländerungen vorliegen; es gibt keinen automatischen Rollback.
Vorherwerte werden vor jeder Änderung gespeichert. Eine Rücknahme erfolgt
gezielt mit diesen Werten und anschließender erneuter Prüfung.
Passwortregeln können Integrationen beeinträchtigen; Kontosperren können auch
berechtigte Zugriffe blockieren. SSH-/Shell-Abschaltung beeinflusst Wartungswege.
Vor Apply einen funktionierenden administrativen Wiederherstellungsweg prüfen.
Berichte und standortspezifische Vorlagen nur in der dafür zugelassenen Umgebung
speichern; nicht in öffentliche Repositories übernehmen.
## Daraus ein natives Hostprofil erstellen
Nach erfolgreicher Einrichtung und Prüfung des ersten Hosts kann vCenter das
native Profil extrahieren. Host-Profile-Funktion und Lizenzberechtigung müssen
vorhanden sein. Beispiel in derselben PowerCLI-Sitzung:
```powershell
$vc = $global:DefaultVIServers | Where-Object Name -EQ 'vcenter.example.internal'
$reference = Get-VMHost -Server $vc -Name 'esxi01.example.internal'
New-VMHostProfile -Server $vc -Name 'ESXi803-Freigegebene-Basis-v1' `
-ReferenceHost $reference
```
Das extrahierte Profil umfasst auch andere Einstellungen des Referenzhosts.
Vor Zuordnung zu weiteren Hosts im vSphere Client den Profilumfang bearbeiten,
hostabhängige Netzwerk-/Storage-Werte prüfen und Hostanpassungen festlegen.
Dieses Paket verteilt oder remediert native Hostprofile nicht automatisch.
## Offene Bereiche
Netztrennung, Lockdown und Notfallzugang, Rollen/MFA, NTP, zentrale Protokollierung
mit geschütztem Transport, Zertifikate, Secure Boot/TPM, Patchstand, VM-/vSAN-
Härtung, Sicherung/Wiederherstellung und vCenter-Härtung müssen separat bewertet
werden. Insbesondere ist die Versionsnummer 8.0.3 kein Nachweis eines aktuellen
Patchstands. Anforderungen für NATO und EU sowie unterschiedliche Einstufungen
lokal zuordnen; keine erfundenen SECRET-/RESTRICTED-Parameter verwenden.
## Quellen
Abgeglichen am 05.10.2026; die Online-Baseline kann sich ändern.
- [Offizieller VMware SCG 8 mit Kontrollen und PowerCLI-Beispielen](https://github.com/vmware/vcf-security-and-compliance-guidelines/tree/main/security-configuration-hardening-guide/vsphere/8.0)
- [New-VMHostProfile](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.core/commands/new-vmhostprofile/)
- [Set-VMHostService](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.core/commands/set-vmhostservice)
## Prüfung dieses Pakets
PowerShell-Syntax und simulierte Audit-/Apply-/WhatIf-/Fehlerpfade lokal prüfen.
Ein Integrationstest gegen echtes vCenter/ESXi ist vor produktivem Einsatz nötig.
Offline-Test in einem separaten PowerShell-Prozess starten (verwendet simulierte
PowerCLI-Befehle und schreibt Testberichte ins temporäre Verzeichnis):
```powershell
pwsh -NoProfile -File ./Tests/Test-Offline.ps1
```
Geprüft: Audit ohne Änderungen, WhatIf ohne Änderungen, Apply mit Nachprüfung,
wiederholtes Apply ohne erneute Änderungen, Ablehnung falscher ESXi-Versionen
und Fehlerbericht bei fehlenden Einstellungen. Diese Tests ersetzen keinen
Integrationstest auf einem ESXi-Testhost.
@@ -0,0 +1,62 @@
# Offline behavioral tests; no VMware module, credentials or remote connection.
$ErrorActionPreference = 'Stop'
$scriptPath = Join-Path $PSScriptRoot '../Invoke-EsxiBaseline.ps1'
$baselinePath = Join-Path $PSScriptRoot '../baseline.json'
$testRoot = Join-Path ([IO.Path]::GetTempPath()) ('esxi-baseline-test-' + [guid]::NewGuid())
function Import-Module { param($Name, $ErrorAction) }
$global:DefaultVIServers = @([pscustomobject]@{Name='test-vc'; IsConnected=$true; Version='8.0.3'})
$global:DefaultVIServer = $global:DefaultVIServers[0]
function Get-VMHost { param($Server,$Name)
[pscustomobject]@{Name=$Name; Version=$global:baselineTestVersion; Build='mock'; ConnectionState='Connected'}
}
function Get-AdvancedSetting { param($Entity,$Name)
if ($global:baselineTestMissing -eq $Name) { return }
[pscustomobject]@{Name=$Name;Value=$global:baselineTestValues[$Name]}
}
function Set-AdvancedSetting { param($AdvancedSetting,$Value,[switch]$Confirm)
$global:baselineTestWrites++; $global:baselineTestValues[$AdvancedSetting.Name]=$Value
}
function Get-VMHostService { param($VMHost) $global:baselineTestServices }
function Set-VMHostService { param($HostService,$Policy,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Policy=$Policy }
function Stop-VMHostService { param($HostService,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Running=$false }
function Start-VMHostService { param($HostService,[switch]$Confirm) $global:baselineTestWrites++; $HostService.Running=$true }
function Reset-State {
$global:baselineTestWrites=0; $global:baselineTestVersion='8.0.3'; $global:baselineTestMissing=''
$global:baselineTestValues=@{}
(Get-Content $baselinePath -Raw | ConvertFrom-Json).AdvancedSettings | ForEach-Object { $global:baselineTestValues[$_.Name]='different' }
$global:baselineTestServices=@('TSM','TSM-SSH') | ForEach-Object { [pscustomobject]@{Key=$_; Policy='on'; Running=$true} }
}
function Assert($condition,$message) { if (-not $condition) { throw $message } }
function Run-Case($name,$mode,[switch]$Simulation) {
$parameters=@{VCenter='test-vc';VMHostName=@('test-esxi');Mode=$mode;ReportDirectory=(Join-Path $testRoot $name);Confirm=$false}
if ($Simulation) { $parameters.WhatIf=$true }
& $scriptPath @parameters
Get-Content (Get-ChildItem $parameters.ReportDirectory -Filter '*.json')[0].FullName -Raw | ConvertFrom-Json
}
Reset-State
$r=Run-Case 'audit' 'Audit'
Assert ($global:baselineTestWrites -eq 0) 'Audit mutated host'
Assert (@($r.Results | Where-Object Status -EQ Drift).Count -eq 6) 'Audit missed drift'
$r=Run-Case 'whatif' 'Apply' -Simulation
Assert ($global:baselineTestWrites -eq 0) 'WhatIf mutated host'
Assert (@($r.Results | Where-Object Status -EQ Skipped).Count -eq 6) 'WhatIf results incorrect'
$r=Run-Case 'apply' 'Apply'
Assert ($global:baselineTestWrites -eq 8) 'Unexpected mutation count'
Assert (@($r.Results | Where-Object Status -EQ AppliedVerified).Count -eq 6) 'Apply not verified'
$previousWrites=$global:baselineTestWrites
$r=Run-Case 'repeat' 'Apply'
Assert ($global:baselineTestWrites -eq $previousWrites) 'Repeated apply not idempotent'
Assert (@($r.Results | Where-Object Status -EQ Match).Count -eq 6) 'Repeat did not match'
Reset-State
$global:baselineTestVersion='7.0.3'
$failed=$false
try { $null=Run-Case 'version' 'Apply' } catch { $failed=$true }
Assert ($failed -and $global:baselineTestWrites -eq 0) 'Version gate failed'
Reset-State
$global:baselineTestMissing='Security.PasswordHistory'
$failed=$false
try { $null=Run-Case 'missing' 'Audit' } catch { $failed=$true }
Assert ($failed -and $global:baselineTestWrites -eq 0) 'Missing setting did not fail safely'
$r=Get-Content (Get-ChildItem (Join-Path $testRoot 'missing') -Filter '*.json')[0].FullName -Raw | ConvertFrom-Json
Assert (@($r.Results | Where-Object Status -EQ Error).Count -eq 1) 'Missing setting not reported'
Write-Host 'PASS: Audit, WhatIf, Apply, repeat, version gate, missing-setting report.'
@@ -0,0 +1,17 @@
{
"Name": "ESXi-8.0.3-Startbaseline",
"Revision": "0.1-draft",
"TargetVersion": "8.0.3",
"ClassificationMapping": "Offen: freigegebene NATO-/EU-Vorgaben lokal zuordnen",
"Source": "https://github.com/vmware/vcf-security-and-compliance-guidelines/tree/main/security-configuration-hardening-guide/vsphere/8.0",
"AdvancedSettings": [
{ "Name": "Security.AccountUnlockTime", "Value": 900, "Control": "esxi-8.account-auto-unlock-time" },
{ "Name": "Security.AccountLockFailures", "Value": 5, "Control": "esxi-8.account-lockout" },
{ "Name": "Security.PasswordHistory", "Value": 5, "Control": "esxi-8.account-password-history" },
{ "Name": "Security.PasswordQualityControl", "Value": "similar=deny retry=3 min=disabled,disabled,disabled,disabled,15 max=64", "Control": "esxi-8.account-password-policies" }
],
"Services": [
{ "Key": "TSM-SSH", "Policy": "off", "Running": false, "Control": "LOCAL-disable-ssh" },
{ "Key": "TSM", "Policy": "off", "Running": false, "Control": "LOCAL-disable-shell" }
]
}
+172
View File
@@ -0,0 +1,172 @@
# EJBCA Issuing: automatisierte Migration von H2 nach PostgreSQL
## Start
Die Datei `migrate_ejbca_issuing.py` auf den Docker-Host nach
`/root/migrate_ejbca_issuing.py` hochladen. Nicht den Quelltext aus einem Chat
in das Terminal kopieren. Auf dem Docker-Host als root ausführen:
```bash
python3 /root/migrate_ejbca_issuing.py
```
Die Issuing-CA wird nach den Vorprüfungen gestoppt und bleibt bis zum anschließenden
Portainer-Update außer Betrieb. Die Root-CA wird weder gestoppt noch verändert.
Der Lauf kann mehrere Minuten dauern. Keine zweite Instanz des Skripts starten.
## Voraussetzungen und festgelegter Umfang
- Linux-Docker-Host mit Python ab 3.9; keine zusätzlichen Python-Pakete nötig.
- Quelle: Container `ejbca_issuing`, ein Volume `ejbca_issuing_data` unter
`/mnt/persistent`, Netzwerk `cert-net`, keine veröffentlichten Host-Ports.
- Das bereits geprüfte EJBCA-Image wird über seinen Digest festgelegt:
`keyfactor/ejbca-ce@sha256:183b86af44b9b13e7cc8912c868f635aeb8dba6bf056ccbd4683b17626964d0a`.
- Die konfigurierte H2-Datei muss direkt unter `/mnt/persistent` liegen.
- Der H2-Treiber muss dem bereits geprüften H2 2.2.224 entsprechen.
- Das Skript ist für die gezeigte Konfiguration mit Software-CryptoTokens gebaut.
Bei inaktiven Tokens, HSMs, unbekannten Datentypen, anderen Mounts oder
nicht unterstützten Containeroptionen bricht es ab.
- Es benötigt ausreichend freien Speicher für die Volumesicherung, zwei
Anwendungskopien, H2-Arbeitskopien und zwei PostgreSQL-Volumes.
- PostgreSQL 17 und Java 17 werden bei Bedarf vor der Ausfallzeit heruntergeladen.
## Bereits vorhandene Issuing-Sicherung
Vor dem Stoppen prüft das Skript die im Chat bestätigten Sicherungen:
- `/root/ejbca-backup/ejbca_issuing.tar.gz`
- `/mnt/HEIMLAN/001-Zertifikate/EJBCA-Backup/2026-09-24/ejbca_issuing.tar.gz`
Mindestens eine Kopie muss erreichbar sein. Jede vorhandene Kopie wird anhand
der damaligen SHA-256-Prüfsummen des Archivs und der enthaltenen H2-Datei
geprüft. Bei einer Abweichung bricht das Skript vor dem Stoppen ab. Die Archive
werden ausschließlich gelesen, niemals überschrieben oder entpackt.
Zusätzlich wird nach dem Stoppen ein aktueller Stand gesichert und für die
Migration verwendet. Issuing lief seit der alten Sicherung weiter; deshalb
wird kein älterer Datenstand zurückgespielt. Ein Unterschied der H2-Dateien
wird protokolliert und ist kein Fehler. Er beweist allein keine fachliche
Datenänderung. `existing-backups.json` und `backup-comparison.json` dokumentieren
die Prüfung im neuen Arbeitsverzeichnis.
## Ablauf
1. Containerkonfiguration und Image prüfen, JDBC-Treiber und SQL-Skripte aus dem
vorhandenen Issuing-Container extrahieren, Java-Helfer kompilieren.
2. Issuing stoppen, vollständiges Originalvolume als TAR sichern, H2-Datei
separat kopieren und beide Kopien über SHA-256 vergleichen.
3. H2 Recover ausschließlich auf einer Arbeitskopie ausführen. Alle im Dump
gefundenen binären Hilfsspalten von VARCHAR auf VARBINARY korrigieren.
Der ursprüngliche Dump bleibt erhalten. Ein neues temporäres H2-Passwort
wird ausschließlich für die Rekonstruktion verwendet.
4. Neue H2-Datenbank erzeugen. Alle nichtleeren Tabellenzahlen mit den
Recover-INSERTs und alle Binärwerte einschließlich ihrer Längen und
SHA-256-Werte mit den Hexliteralen im ursprünglichen Dump vergleichen.
5. Neue Testdatenbank in einem internen Netzwerk erstellen. Den aus dem
Root-Verfahren abgeleiteten JDBC-Helper ausführen. Tabellen-/Zeilenzahlen
werden aus der Issuing-Quelle ermittelt. Spaltenzuordnung, Datentypen,
Fremdschlüssel, Leerheit, vollständige Werte und Rowcounts werden geprüft.
Inserts erfolgen in einer Transaktion. Der Helper kennt ausschließlich
`ejbca_issuing_migration_test_db`.
6. Alle 44 PostgreSQL-Indizes vor dem ersten EJBCA-Teststart anlegen. Die vier
DELETE-Befehle im Originalskript werden durch eine Abbruchprüfung ersetzt.
7. Testanwendung mit kopiertem Volume, erhaltenen Verschlüsselungs-/CLI-Einstellungen,
ohne veröffentlichte Ports und in einem internen Netzwerk starten.
Bereitschaft, Fehlerlogs, CA-Liste, Tokenstatus und alle erkannten
Software-Schlüsselpaare prüfen. Danach Testanwendung stoppen.
8. Ausschließlich das vom Skript neu angelegte Testschema erneut aufbauen und
die ursprünglichen Issuing-Daten plus Indizes importieren. Somit werden keine
beim Teststart erzeugten Zertifikate oder anderen Änderungen übernommen.
9. Sauberen Dump erstellen. Neue endgültige Datenbank `ejbca_issuing_db` in
`ejbca-issuing-db-net` erstellen, Dump transaktional wiederherstellen und
Tabellenzahlen, vollständige Zeilen-Digests sowie Indizes vergleichen.
10. Eigenes dauerhaftes App-Volume aus dem gestoppten Original kopieren und die
fertige Compose-Datei für den bestehenden Portainer-Stack erzeugen.
Das Skript exportiert keine privaten Schlüssel als separate Dateien und stellt
keine Zertifikate per CLI aus. Der EJBCA-Teststart selbst kann ein Serverzertifikat
in seiner isolierten Testdatenbank anlegen. Sicherungen und Datenbank-Dumps
enthalten selbstverständlich vertrauliche CA-Daten.
## Ergebnis
Am Ende zeigt das Skript das neu generierte Passwort für **Issuing-PostgreSQL**
und die vollständige Compose-Konfiguration direkt im lokalen Terminal an.
Dieses Passwort ist nicht das alte H2-Passwort, kein Root-CA-Passwort und kein
CryptoToken-PIN. Vorhandene Schlüssel-/Verschlüsselungspasswörter werden nicht
geändert. Die Compose-Datei enthält das neue DB-Passwort bereits; keine zusätzliche
Portainer-Variable ist erforderlich.
Alle Dateien liegen in einem neuen, nur für root zugänglichen Verzeichnis:
```text
/root/ejbca-issuing-migration/run-DATUM-UHRZEIT-ZUFALL/
```
Wichtige Dateien:
- `docker-compose.issuing.yml`: fertige Konfiguration für den vorhandenen
Portainer-Stack `ejbca-issuing`.
- `credentials.private.json`: erzeugte H2-, Test- und endgültige DB-Zugangsdaten.
- `original.inspect.json`, `original-volume.tar`, `original.mv.db` und
`original.sha256`: Originalkonfiguration und geprüfte Sicherungen.
- `recover/ejbcadb.h2.sql`: ursprünglicher Recover-Dump.
- `restored/`: binärsicher rekonstruierte H2-Quelle; SQL enthält ein temporäres Passwort.
- `source-inventory.tsv`, `migration.log`, `key-tests.log`, `report.json`:
Prüfresultate ohne vollständige Nutzdaten.
- `issuing-clean.dump` und `.sha256`: sauberer Export vor Anwendungsstart.
- `verify-after-deploy.sh`: Bereitschafts- und Schlüsseltests nach dem Deployment.
- `docker-compose.database-reference.yml`: Dokumentation des bereits vom Skript
gestarteten DB-Containers. Nicht als zusätzlichen Stack deployen, solange dieser
Container existiert.
Das Skript ersetzt/deployt den bestehenden Issuing-Container **nicht automatisch**.
Die endgültige PostgreSQL-Datenbank läuft bereits mit einem benannten Volume und
Restart-Policy `unless-stopped`. Die Testanwendung ist gestoppt.
## Portainer-Update und Abschluss
1. Nach erfolgreichem Skriptende in Portainer den bestehenden Stack
`ejbca-issuing` öffnen.
2. Den Editorinhalt durch `docker-compose.issuing.yml` ersetzen.
3. Stack aktualisieren. Das festgelegte Image bleibt die getestete Version.
4. Nach etwa 90 Sekunden den erzeugten Prüfblock ausführen:
```bash
sh /root/ejbca-issuing-migration/run-DATUM-UHRZEIT-ZUFALL/verify-after-deploy.sh
```
5. In der gewohnten Adminoberfläche Issuing-CA und Profile kontrollieren.
6. Nach erfolgreichem Abschluss einen aktuellen PostgreSQL-Dump sichern und
regelmäßige Datenbankbackups vorsehen. Alte H2-Sicherungen vorerst behalten.
Bestehende TLS-/Adminzugangseinstellungen werden übernommen. Insbesondere wird
`TLS_SETUP_ENABLED=simple`, falls vorhanden, durch dieses Migrationsskript nicht
auf Clientzertifikatsanmeldung umgestellt.
## Bei einem Fehler
Das Skript bricht ab und stoppt seine eigene Testanwendung, soweit sie bereits
angelegt wurde. Es löscht keine vorhandenen Container/Volumes automatisch.
Nach begonnenen Arbeiten nicht blind erneut ausführen: vorhandene Zielnamen
führen absichtlich zum Abbruch.
Die ursprüngliche Issuing-Compose-Konfiguration und das ursprüngliche H2-Volume
bleiben unverändert. Die ursprüngliche Anwendung kann bereits gestoppt sein.
Solange noch kein Portainer-Update erfolgt ist und niemand die Originalkonfiguration
geändert hat, kann sie bei Bedarf mit `docker start ejbca_issuing` wieder auf dem
alten H2-Stand laufen. Danach ist eine frühere Migrationskopie möglicherweise
veraltet und darf nicht ohne neuen Abgleich eingesetzt werden.
Zur Diagnose zunächst nur die Abbruchmeldung und `progress.log` weitergeben.
`private-errors.log`, `test-start.private.log`, JSON-Konfigurationen, SQL-Dumps und
Compose-Dateien können Geheimnisse enthalten; nicht ungeschwärzt posten.
## Prüfstatus dieses Lieferstands
Python-Syntax und lokale Tests für SQL-Lexer, Binärkorrektur, Abbruchfälle,
Indexkonvertierung und Compose-Werte wurden geprüft. Der JDBC-Migrationscode
ist aus dem auf deinem Host ausgeführten Root-Helper abgeleitet; das Original
bleibt unverändert. Ein vollständiger Docker-/EJBCA-Durchlauf wurde in dieser
Arbeitsumgebung nicht ausgeführt. Die Java-Helfer werden auf dem Docker-Host
vor dem Stoppen der Issuing-Anwendung kompiliert.
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
"""Finish only the verified Issuing migration run; never deploy the app."""
import importlib.util
import json
import os
from pathlib import Path
import subprocess
import sys
RUN = Path('/root/ejbca-issuing-migration/run-20260924-163240-49d64d')
DUMP_HASH = '23e989f0c39ee7abc1491833cb37b61827029091e8b5f8aaa8148251f74f83be'
def main():
if os.geteuid() != 0:
raise RuntimeError('Als root auf dem Docker-Host ausfuehren.')
os.umask(0o077)
spec = importlib.util.spec_from_file_location('migration', '/root/migrate_ejbca_issuing.py')
m = importlib.util.module_from_spec(spec)
spec.loader.exec_module(m)
m.WORK = RUN
m.check(m.APP == 'ejbca_issuing' and m.FINAL_DB == 'ejbca_issuing_db', 'Unerwartete Zielnamen.')
for app in (m.APP, m.TEST_APP):
m.check(m.inspect(app)['State']['Status'] == 'exited', app + ' muss gestoppt sein.')
original = json.loads((RUN / 'original.inspect.json').read_text())
current = m.inspect(m.APP)
for key in ('Id', 'Image', 'Config', 'Mounts', 'HostConfig'):
m.check(current[key] == original[key], 'Originalkonfiguration hat sich geaendert: ' + key)
m.check(current['Image'] == m.EXPECTED_IMAGE, 'Unerwartetes EJBCA-Image.')
image = json.loads(m.docker('image', 'inspect', m.EXPECTED_IMAGE))[0]
m.check(m.EJBCA_IMAGE in image.get('RepoDigests', []), 'EJBCA-Digest fehlt.')
dump = RUN / 'issuing-clean.dump'
m.check(m.digest(dump) == DUMP_HASH, 'Pruefsumme des sauberen Exports stimmt nicht.')
expected = {t: tuple(v) for t, v in json.loads((RUN / 'clean-counts-and-digests.json').read_text()).items()}
m.check(len(expected) == 37 and sum(v[0] for v in expected.values()) == 129,
'Erwartetes Inventar stimmt nicht.')
m.check(expected['userdatasourcedata'][0] == 0, 'userdatasourcedata muss leer sein.')
m.check(m.snapshot(m.TEST_DB) == expected, 'Saubere Testdatenbank wurde zwischenzeitlich veraendert.')
for line in (RUN / 'original.sha256').read_text().splitlines():
checksum, name = line.split()
m.check(name in ('original.mv.db', 'original-volume.tar'), 'Unerwarteter Sicherungspfad.')
m.check(m.digest(RUN / name) == checksum, 'Originalsicherung stimmt nicht: ' + name)
url = m.envmap(current['Config'])['DATABASE_JDBC_URL']
m.check(url.startswith('jdbc:h2:/mnt/persistent/'), 'Quelle ist nicht mehr H2.')
dbfile = url.split(';')[0].removeprefix('jdbc:h2:') + '.mv.db'
checkfile = RUN / 'original-current-check.mv.db'
m.docker('cp', m.APP + ':' + dbfile, str(checkfile))
checkfile.chmod(0o600)
m.check(m.digest(checkfile) == m.digest(RUN / 'original.mv.db'), 'Original-H2 wurde seit der Sicherung veraendert.')
credentials = json.loads((RUN / 'credentials.private.json').read_text())
m.FINAL_PASSWORD = credentials['issuing_pg']
m.check(bool(m.FINAL_PASSWORD), 'Zielpasswort fehlt.')
# Reuse exactly the PostgreSQL image used by the verified test database.
pgimage = json.loads(m.docker('image', 'inspect', m.inspect(m.TEST_DB)['Image']))[0]
m.PG_PIN = next((d for d in pgimage.get('RepoDigests', []) if d.startswith('postgres@')), None)
m.check(m.PG_PIN, 'PostgreSQL-Image-Digest fehlt.')
m.absent('container', [m.FINAL_DB])
m.absent('network', [m.FINAL_NETWORK])
m.absent('volume', [m.FINAL_DB_VOLUME, m.FINAL_APP_VOLUME])
for name in ('docker-compose.issuing.yml', 'docker-compose.database-reference.yml'):
m.check(not (RUN / name).exists(), 'Compose-Datei existiert bereits: ' + name)
print('Vorpruefungen erfolgreich. Neues Issuing-PostgreSQL-Ziel wird erstellt.', flush=True)
m.docker('network', 'create', '--internal', m.FINAL_NETWORK)
m.create_pg(m.FINAL_DB, m.FINAL_DB_VOLUME, m.FINAL_NETWORK, m.FINAL_PASSWORD)
m.docker('exec', '-i', m.FINAL_DB, 'pg_restore', '-U', 'ejbca', '-d', 'ejbcadb',
'--exit-on-error', '--single-transaction', data=dump.read_bytes(), timeout=3600)
m.check(m.snapshot(m.FINAL_DB) == expected, 'Endgueltiges Ziel weicht vom sauberen Stand ab.')
m.check(m.inspect(m.APP)['State']['Status'] == 'exited', 'Original-App wurde gestartet.')
m.copy_volume(m.FINAL_APP_VOLUME)
m.write_compose(original, m.envmap(image['Config']))
if subprocess.run(['docker', 'compose', 'version'], stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL).returncode == 0:
m.docker('compose', '-f', str(RUN / 'docker-compose.issuing.yml'), 'config', '--quiet')
(RUN / 'finish-report.json').write_text(json.dumps({
'dump_sha256': DUMP_HASH, 'rows': 129, 'tables': 37, 'valid_additional_indexes': 44,
'app_deployed': False, 'offline_token': 'ImportedCryptoToken264870329',
'offline_token_key_tested': False,
'active_token_key_tests': '5 successful tests reported by operator in chat'
}, indent=2))
print('OK: Ziel wiederhergestellt und vollstaendig mit dem sauberen Stand verglichen.')
print('Die Issuing-App bleibt gestoppt. Deployment erfolgt anschliessend in Portainer.')
print('\nISSUING-POSTGRESQL-PASSWORT (vertraulich):\n' + m.FINAL_PASSWORD)
print('\nCOMPOSE FUER DEN BESTEHENDEN STACK ejbca-issuing:\n')
print((RUN / 'docker-compose.issuing.yml').read_text())
print('Die database-reference-Datei NICHT als weiteren Stack deployen.')
print('Passwort und Compose nicht in den Chat posten. Ergebnisverzeichnis: ' + str(RUN))
if __name__ == '__main__':
try:
main()
except (Exception, KeyboardInterrupt) as exc:
# Avoid displaying command outputs or configuration containing secrets.
print('ABBRUCH: ' + (str(exc) if type(exc).__name__ in ('MigrationError', 'RuntimeError')
else type(exc).__name__), file=sys.stderr)
print('Vorhandene Ressourcen bleiben erhalten. Nicht blind erneut starten.', file=sys.stderr)
sys.exit(1)
File diff suppressed because one or more lines are too long
+1
View File
@@ -0,0 +1 @@
2c69fc5001d7fe09e8251bf379cb4121594387c6617ec011c97345a8f8af7443 migrate_ejbca_issuing.py
+4
View File
@@ -0,0 +1,4 @@
__pycache__/
*.pyc
token
.env
+53
View File
@@ -0,0 +1,53 @@
# HOMELAB
Lokale Webseite für eine Synology DS1817+ mit DSM 7.3.2 als Zielplattform.
Hauptseite `/`, DSM-Unterseite `/dsm`. Keine externen Dienste, Schriftarten oder Bibliotheken.
## Umfang
- CPU und RAM, aktuelle Übertragungsraten und Verlauf der letzten 60 Messungen.
- Physische Netzwerkschnittstellen mit Verbindungsstatus. Das ist NAS-Traffic, kein Router-/Internet-Monitoring. Bond- und Bridge-Interfaces werden nicht zusätzlich summiert.
- SMART-Gesamtzustand, Temperatur und Warnung bei SMART-Fehlerbits. Unlesbare oder schlafende Laufwerke bleiben „Unbekannt“. Keine Tests oder Änderungen an Laufwerken.
- LVM-Poolkapazitäten (zugewiesen/frei), Volume-Kapazitäten (belegt/frei), Linux-RAID-Zustand und Synchronisierungsaktion. DSM-Poolnamen und SHR-Zuordnung sind noch nicht auf dem Gerät validiert. LVM- und RAID-Zeilen sind keine garantierte Eins-zu-eins-Zuordnung zu DSM-Speicherpools.
- DNS-Paketneustart mit Dialog, Authentifizierung und 60 Sekunden Sperre zwischen Versuchen.
## Lokale Vorschau
Python 3 wird benötigt, keine zusätzlichen Pakete:
```sh
python3 server.py --demo
```
Danach `http://127.0.0.1:8787` öffnen. Alle Werte sind ausdrücklich Beispieldaten; Neustart ist gesperrt.
## Auf dem NAS starten
Die Einrichtung auf dem NAS wurde noch nicht ausgeführt. Python 3 muss dort vorhanden sein. Den gesamten Ordner beispielsweise nach `/volume1/homelab` kopieren und den tatsächlichen Python-Pfad verwenden. Programmdateien und Schlüsseldatei dürfen bei Ausführung als root nur für Administratoren schreibbar sein.
Einmal einen zufälligen Schlüssel erzeugen und in einer nur für root lesbaren Datei speichern, zum Beispiel `/volume1/homelab/token`. Erzeugung mit Python: `python3 -c 'import secrets; print(secrets.token_urlsafe(32))'`. Datei nicht in Git speichern. Den Schlüssel später im Dashboard eingeben; er wird nicht im Browser gespeichert.
Startskript für einen DSM-Aufgabenplaner-Task „Beim Hochfahren“, Benutzer root (Pfade anpassen):
```sh
#!/bin/sh
export HOMELAB_TOKEN="$(cat /volume1/homelab/token)"
# Erst nach Prüfung, dass das Synology-Paket DNSServer installiert ist:
# export HOMELAB_ALLOW_DNS_RESTART=1
exec /usr/local/bin/python3 /volume1/homelab/server.py --host 127.0.0.1 --port 8787
```
Der Dienst bindet standardmäßig nur an Loopback. In DSM einen HTTPS-Reverse-Proxy auf `http://127.0.0.1:8787` einrichten und über den lokalen Hostnamen öffnen. Den gesamten Pfad `/` weiterleiten. Kein öffentliches Portforwarding erforderlich. Für einen direkten LAN-Test kann `--host NAS-LAN-IP` verwendet werden; den Zugriffsschlüssel nur über HTTPS oder einen verschlüsselten Tunnel übertragen.
Das Backend benötigt erhöhte Leserechte für SMART/LVM; der optionale Paketneustart benötigt Verwaltungsrechte. Es führt ausschließlich den festen Befehl `/usr/syno/bin/synopkg restart DNSServer` aus. Keine frei übergebenen Shell-Befehle und keine DSM-Kennwörter im Frontend. Vor Aktivierung auf dem NAS die Existenz dieses Programms und des Pakets prüfen. Neustartbefehl und PID-Pfad sind auf DSM 7.3.2 noch nicht verifiziert. Ein erfolgreicher Befehl ist kein Nachweis einer erfolgreichen DNS-Anfrage.
## Grenzen und Prüfung auf dem NAS
- Noch keine Verbindung zu einer echten DS1817+; die Kompatibilität muss dort geprüft werden.
- SMART wird höchstens alle 60 Sekunden gelesen (`smartctl -n standby -a`). Fehlende Programme oder Berechtigungen ergeben unbekannte Werte.
- Die erste CPU-/Netzwerkmessung benötigt eine zweite Abfrage. Keine dauerhafte Messwertspeicherung.
- DNS-Status über `/var/packages/DNSServer/target/var/named.pid`; falls dieser Pfad abweicht, „Unbekannt“. Keine geratenen Erfolgszustände.
- Falls LVM auf dem Gerät nicht verfügbar ist, bleiben Poolkapazitäten offen; Volume-Werte werden unabhängig davon angezeigt.
- Python-Standard-HTTP-Server für ein privates Netz hinter dem DSM-Reverse-Proxy; nicht direkt ins Internet stellen.
Tests: `python3 -m unittest discover -s tests -v`
+405
View File
@@ -0,0 +1,405 @@
# DNS-Neustart aus Home Assistant Container
Ziel: `Madzone@192.168.1.230`, SSH-Port 22. Neustart ausschließlich des Synology-Pakets `DNSServer`. Docker-Container: **`HomeAssistant`** (Groß-/Kleinschreibung beachten).
## Geräte und Orte
| Ort | Erkennbarer Prompt | Verwendung |
| --- | --- | --- |
| Docker-Host | `root@Docker:~#` | Container finden, öffnen und neu starten |
| HA-Container `HomeAssistant` | `/config #` | SSH-Schlüssel, bekannte Server und HA-Konfiguration |
| Synology DS1817+, DSM 7.3.2 | `Madzone@NEW-SYNO:~$` | Gateway, sudo-Regel und öffentlicher Schlüssel |
Die Prompt-Zeichen und die bei mehrzeiligen Eingaben angezeigten `>` nicht mitkopieren. Ein alleinstehendes `EOF` beendet den jeweiligen Dateiblock. `exit` verlässt die Container-Shell und führt zum Docker-Host zurück.
## Bereits bestätigter Stand
- Gateway-Skript auf DSM installiert, Syntax geprüft; `/usr/local/sbin` und Skript haben Rechte `755`, Eigentümer root.
- DSM bindet `/etc/sudoers.d` ein; `visudo` ist nicht vorhanden. Die separate Regel wurde eingerichtet.
- Server-Fingerprints auf DSM und im HA-Container stimmen überein.
- `check-dns` aus dem HA-Container war erfolgreich, ohne DNS neu zu starten.
- HA-Konfigurationsprüfung zeigte nur `Testing configuration at /config`, keine Fehlermeldung.
- Ein tatsächlicher DNS-Neustart über den HA-Button wurde im Gespräch noch nicht bestätigt.
Für die laufende Einrichtung bei **Schritt 6** fortfahren. Die vorigen Schritte dokumentieren die vollständige Einrichtung und müssen nicht wiederholt werden. Eine erfolgreiche HA-Konfigurationsprüfung allein bestätigt noch nicht, dass das Package geladen wurde.
## 1. Schlüssel im Home-Assistant-Container erstellen
Auf dem Docker-Host wurde zuerst der tatsächliche Containername ermittelt:
```sh
sudo docker ps --format 'table {{.Names}}\t{{.Image}}'
```
Relevante Ausgabe:
```text
NAMES IMAGE
HomeAssistant homeassistant/home-assistant:latest
```
Auf deinem Docker-Host (`root@Docker`) den vorhandenen Container öffnen:
```sh
docker exec -it HomeAssistant sh
```
Ab jetzt im Container:
```sh
command -v ssh
command -v ssh-keygen
command -v ssh-keyscan
mkdir -p /config/ssh
chmod 700 /config/ssh
```
Bestätigte Programmpfade: `/usr/bin/ssh`, `/usr/bin/ssh-keygen` und `/usr/bin/ssh-keyscan`.
Falls eines der Programme fehlt, hier stoppen; dann muss das Container-Image passend erweitert werden. Keine nur vorübergehende Installation im laufenden Container.
Einen neuen, ausschließlich dafür verwendeten Schlüssel erzeugen. Vorhandene Datei nicht überschreiben:
```sh
if [ -e /config/ssh/synology_dns_ed25519 ]; then
echo 'Schlüssel existiert bereits – wird beibehalten.'
else
ssh-keygen -t ed25519 -N '' -f /config/ssh/synology_dns_ed25519 -C ha-dns-only
fi
chmod 600 /config/ssh/synology_dns_ed25519
cat /config/ssh/synology_dns_ed25519.pub
```
Bei dir wurde **„Schlüssel existiert bereits – wird beibehalten.“** ausgegeben. Es wurde kein neuer Schlüssel erzeugt. Dein öffentlicher Schlüssel lautet:
```text
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE ha-dns-only
```
Nur die ausgegebene öffentliche Zeile wird auf DSM benötigt. Der private Schlüssel bleibt in `/config/ssh`; dieser Ordner muss im persistenten HA-Konfigurationsvolume liegen.
## 2. Auf DSM Paket und Rechte vorbereiten
Separat als `Madzone` auf DSM anmelden:
```sh
ssh Madzone@192.168.1.230
id
ls -l /usr/syno/bin/synopkg
ls -ld /var/packages/DNSServer
```
`Madzone` muss Administratorrechte besitzen. Wenn Paket oder Programm nicht vorhanden sind, nicht fortfahren.
Das Gateway direkt auf DSM erstellen; eine lokale Datei auf deinem Computer liegt nicht automatisch im NAS-Home-Verzeichnis:
```sh
cat > "$HOME/ha-dns-gateway.sh" <<'EOF'
#!/bin/sh
# Install on DSM as root-owned /usr/local/sbin/ha-dns-gateway.sh.
# Only used as the forced command of the dedicated Home Assistant SSH key.
set -eu
case "${SSH_ORIGINAL_COMMAND:-}" in
check-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
sudo -n -l /usr/syno/bin/synopkg restart DNSServer >/dev/null
printf '%s\n' 'DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.'
;;
restart-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
exec sudo -n /usr/syno/bin/synopkg restart DNSServer
;;
*)
printf '%s\n' 'Nur check-dns oder restart-dns ist erlaubt.' >&2
exit 64
;;
esac
EOF
sudo mkdir -p /usr/local/sbin
sudo cp "$HOME/ha-dns-gateway.sh" /usr/local/sbin/ha-dns-gateway.sh
sudo chown root:root /usr/local/sbin/ha-dns-gateway.sh
sudo chmod 755 /usr/local/sbin/ha-dns-gateway.sh
sudo sh -n /usr/local/sbin/ha-dns-gateway.sh
sudo ls -ld /usr /usr/local /usr/local/sbin
```
Auf deinem NAS wurde `/usr/local/sbin` mit `700` angelegt. Deshalb konnte Madzone das Skript trotz dessen `755`-Rechten nicht erreichen. Für dieses neu angelegte Verzeichnis wurde korrigiert:
```sh
sudo chmod 755 /usr/local/sbin
ls -l /usr/local/sbin/ha-dns-gateway.sh
```
Nicht rekursiv Rechte ändern. Das Verzeichnis und Skript bleiben nur für root schreibbar.
### Separate sudo-Regel ohne visudo
Auf deiner DSM ist `visudo` nicht vorhanden. Die Einbindung wurde geprüft:
```sh
sudo grep -nE '^[[:space:]]*([#@]include)' /etc/sudoers
sudo ls -ld /etc/sudoers.d
```
Bestätigte Ausgabe: `19:#includedir /etc/sudoers.d`. Das `#includedir` ist eine aktive sudo-Direktive, kein gewöhnlicher Kommentar.
Folgender Block legt nur die zusätzliche Regel an und überschreibt keine vorhandene Datei. `/etc/sudoers` bleibt unverändert:
```sh
sudo sh -c '
set -eu
target=/etc/sudoers.d/ha-dns
if [ -e "$target" ]; then
echo "Datei existiert bereits – nichts geändert."
exit 1
fi
umask 077
printf "%s\n" \
"Madzone ALL=(root) NOPASSWD: /usr/syno/bin/synopkg restart DNSServer" \
> "$target"
chown root:root "$target"
chmod 440 "$target"
'
```
Bei bereits vorhandener Datei den Inhalt mit `sudo cat /etc/sudoers.d/ha-dns` prüfen, nicht erneut anhängen. Anschließend als Madzone testen:
```sh
SSH_ORIGINAL_COMMAND=check-dns /usr/local/sbin/ha-dns-gateway.sh
```
Erwartet: `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` Dieser Check prüft die sudo-Regel, führt aber den privilegierten Neustart nicht aus. Er ersetzt keine vollständige Prüfung aller sudo-Regeln durch `visudo`.
## 3. Öffentlichen Schlüssel auf einen festen Befehl beschränken
Weiterhin in der DSM-Sitzung von Madzone:
```sh
mkdir -p "$HOME/.ssh"
chmod 700 "$HOME/.ssh"
touch "$HOME/.ssh/authorized_keys"
chmod 600 "$HOME/.ssh/authorized_keys"
```
Für deinen vorhandenen Schlüssel wurde folgender Eintrag vorbereitet. Auf DSM als Madzone ausführen, wenn dieser Schlüssel noch nicht eingetragen ist. Bei einem Treffer wird nichts angehängt; den vorhandenen Eintrag auf dieselben Einschränkungen prüfen:
```sh
if grep -qF 'AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE' "$HOME/.ssh/authorized_keys"; then
echo "Schlüssel bereits vorhanden – Eintrag vor Änderungen prüfen."
else
printf '\n%s\n' 'command="/usr/local/sbin/ha-dns-gateway.sh",no-port-forwarding,no-agent-forwarding,no-X11-forwarding,no-pty,no-user-rc ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDK2Cxy/jmphN3gOaLssWnnhh9hUtCnwblGrUxDwS5ZE ha-dns-only' >> "$HOME/.ssh/authorized_keys"
echo "Eingeschränkter Schlüssel eingetragen."
fi
```
Bei einem neu erzeugten Schlüssel muss die öffentliche Zeile und der Suchwert entsprechend ersetzt werden. Die Ausgabe dieses Eintragsschritts wurde nicht im Chat gezeigt; der spätere SSH-Test war erfolgreich.
Der Schlüssel darf damit nur `check-dns` und `restart-dns` ausführen, keine interaktive Shell oder Weiterleitungen. Der separate sudo-Eintrag erlaubt Madzone nur den angegebenen Paketneustart ohne Passwort; seine sonstigen bestehenden Administratorrechte bleiben bestehen. Bei Problemen mit dem Home-Verzeichnis den DSM-Benutzer-Home-Dienst und Dateieigentümer prüfen, nicht die SSH-Rechte lockern.
## 4. NAS-Identität prüfen und Verbindung ohne Neustart testen
In der bereits vertrauenswürdigen DSM-Sitzung den Fingerprint ablesen:
```sh
sudo ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
```
Im HA-Container:
```sh
ssh-keyscan -t ed25519 -p 22 192.168.1.230 > /config/ssh/synology_dns_known_hosts.pending
ssh-keygen -lf /config/ssh/synology_dns_known_hosts.pending
```
Bei deiner Einrichtung stimmten beide Fingerprints überein:
```text
SHA256:tIb+4+U9Ojztyqrj6fh2hqEIbNvshkR4hc7NRnO/zdI
```
Bei einer erneuten Einrichtung die aktuell ausgegebenen Fingerprints wieder miteinander vergleichen; nach einer Neuinstallation kann sich der Server-Schlüssel ändern. Beide SHA256-Fingerprints müssen übereinstimmen. Erst danach die geprüfte Datei übernehmen:
```sh
mv /config/ssh/synology_dns_known_hosts.pending /config/ssh/synology_dns_known_hosts
chmod 600 /config/ssh/synology_dns_known_hosts
ssh -F /dev/null -T -p 22 -i /config/ssh/synology_dns_ed25519 -o BatchMode=yes -o IdentitiesOnly=yes -o StrictHostKeyChecking=yes -o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts -o ConnectTimeout=10 Madzone@192.168.1.230 check-dns
```
Erwartet: `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` Dieser Test prüft SSH, Programmpfad, Paketverzeichnis und sudo-Freigabe. Er startet DNS nicht neu und bestätigt noch nicht, dass ein späterer Neustart erfolgreich sein wird.
Beim erfolgreichen Test erschien zusätzlich die Warnung `connection is not using a post-quantum key exchange algorithm`. Sie verhinderte die Anmeldung und den Test nicht. Die Host-Key-Prüfung bleibt aktiviert; die Warnung wird nicht durch Abschalten von SSH-Schutzoptionen umgangen.
## 5. HA-Konfiguration installieren
Im HA-Container bei Bedarf `mkdir -p /config/packages` ausführen. Die mitgelieferte Datei [synology-dns.yaml](synology-dns.yaml) als `/config/packages/synology_dns.yaml` in das HA-Konfigurationsvolume kopieren. Der Quelldateiname enthält einen Bindestrich, der hier gewählte Zieldateiname einen Unterstrich. Nur eine Kopie des Packages installieren.
Damit die Anleitung auch ohne separates Kopieren der Datei vollständig ist, hier der komplette Inhalt für `/config/packages/synology_dns.yaml`. Einen eventuell vorhandenen Stand vorher sichern und nicht zusätzlich eine zweite Package-Datei mit denselben Schlüsseln anlegen:
```yaml
# Nach /config/packages/synology_dns.yaml kopieren.
shell_command:
synology_dns_restart: >-
ssh -F /dev/null -T -p 22
-i /config/ssh/synology_dns_ed25519
-o BatchMode=yes -o IdentitiesOnly=yes
-o StrictHostKeyChecking=yes
-o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts
-o ConnectTimeout=10 -o ServerAliveInterval=5 -o ServerAliveCountMax=2
Madzone@192.168.1.230 restart-dns
script:
synology_dns_restart:
alias: Synology · DNS Server neu starten
icon: mdi:dns
mode: single
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: Neustartbefehl wird gesendet …
- variables:
dns_result:
returncode: -1
- action: shell_command.synology_dns_restart
response_variable: dns_result
continue_on_error: true
- choose:
- conditions: "{{ dns_result is defined and dns_result is mapping and dns_result.get('returncode', -1) == 0 }}"
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: >-
Der DNS-Neustartbefehl wurde erfolgreich ausgeführt.
Das NAS wurde nicht neu gestartet. Die DNS-Auflösung wurde nicht separat geprüft.
default:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS · Neustart nicht bestätigt
message: >-
SSH oder der Neustartbefehl ist fehlgeschlagen, oder das Zeitlimit wurde erreicht.
Prüfe den DNS-Paketstatus in DSM und das Home-Assistant-Protokoll,
bevor du einen weiteren Neustart auslöst.
- delay: '00:01:00'
```
In `/config/configuration.yaml` Packages einbinden. Falls bereits ein `homeassistant:`-Abschnitt existiert, dort ergänzen; keinen zweiten gleichnamigen Abschnitt anlegen. Vorhandene Packages-Konfiguration nicht ersetzen:
```yaml
homeassistant:
packages: !include_dir_named packages
```
Konfiguration auf dem Docker-Host prüfen:
```sh
docker exec HomeAssistant python -m homeassistant --script check_config --config /config
```
Alternativ direkt in der bereits geöffneten Container-Sitzung:
```sh
python -m homeassistant --script check_config --config /config
```
Deine tatsächliche Ausgabe:
```text
/config # python -m homeassistant --script check_config --config /config
Testing configuration at /config
/config #
```
Die Ausgabe enthielt keine Fehlermeldung. Bei Fehlern erst die Konfiguration korrigieren.
## 6. Home Assistant neu starten
Wenn du noch am Prompt `/config #` bist, mit `exit` zum Docker-Host zurückkehren. Dort:
```sh
docker restart HomeAssistant
```
Das startet nur Home Assistant neu, nicht die Synology oder deren DNS-Paket. Warten, bis HA wieder erreichbar ist. Unter Entwicklerwerkzeuge → Zustände nach `script.synology_dns_restart` suchen. Fehlt es, Package-Pfad, Include-Einbindung und HA-Protokoll prüfen.
## 7. Dashboard aktualisieren und DNS neu starten
Den aktualisierten Inhalt von `dashboard.yaml` im Rohkonfigurationseditor deines HOMELAB-Dashboards übernehmen. Auf DSM → **DNS Server neu starten** klicken und die Sicherheitsabfrage bestätigen. Jetzt wird erstmals der tatsächliche DNS-Neustart ausgeführt.
Falls du nur die vorhandene DNS-Karte bearbeiten möchtest, lautet deren YAML:
```yaml
type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
```
Dieser Block ist eine einzelne Karte; die vollständige `dashboard.yaml` gehört dagegen in den Dashboard-Rohkonfigurationseditor. Die bestehende HOMELAB-Startseite mit separater DSM-Unterseite und Graphen bleibt erhalten.
Der Button ruft das HA-Skript auf. Es zeigt das Ergebnis als persistente HA-Benachrichtigung an und sperrt weitere Skriptaufrufe während der Ausführung plus 60 Sekunden danach. Ein Erfolg bedeutet, dass der Paketbefehl Exitcode 0 zurückgegeben hat; eine DNS-Abfrage wurde damit nicht geprüft.
Bei Fehler oder Zeitüberschreitung zuerst Paketstatus in DSM und HA-Protokoll prüfen. HA beendet Shell-Befehle nach 60 Sekunden; der entfernte Vorgang könnte trotzdem weiterlaufen. Nicht sofort wiederholt starten.
Nach DSM-Updates gegebenenfalls sudo-Regel, Gateway-Datei und SSH-Zugang prüfen. Zum Entfernen: HA-Package und Button entfernen, genau den `ha-dns-only`-Schlüsseleintrag aus `authorized_keys` löschen, die ausschließlich hierfür angelegte Datei `/etc/sudoers.d/ha-dns` entfernen (zuvor Inhalt prüfen) und die nur hierfür angelegten Schlüssel-/Gateway-Dateien entfernen.
## Ablaufprotokoll der tatsächlich gezeigten Einrichtung
Die folgende Reihenfolge entspricht den Terminalausgaben im Gespräch. Die obige Anleitung ist für eine erneute Einrichtung nach Aufgaben geordnet.
| Schritt | Beobachtung / Ergebnis | Lösung oder Folgeschritt |
| --- | --- | --- |
| Gateway kopieren | `cp: cannot stat '/var/services/homes/Madzone/ha-dns-gateway.sh': No such file or directory` | Skript direkt mit `cat … <<'EOF'` in Madzones Home erstellt. |
| Gateway installieren | `mkdir`, `cp`, `chown root:root`, `chmod 755` liefen ohne Fehler. | Datei lag unter `/usr/local/sbin/ha-dns-gateway.sh`. |
| Datei als Madzone ansehen | `Permission denied` trotz ausführbarer Datei. | Verzeichnisse mit `sudo ls -ld /usr /usr/local /usr/local/sbin` geprüft. |
| Rechte und Syntax prüfen | `/usr/local/sbin` hatte `drwx------`; Datei `-rwxr-xr-x root root`; `sudo sh -n` blieb ohne Ausgabe. | `sudo chmod 755 /usr/local/sbin`; danach konnte Madzone die Datei auflisten. |
| sudo-Regel bearbeiten | `sudo: visudo: command not found` | Bekannte Programmpfade geprüft; kein `visudo` gefunden. |
| Include-Verzeichnis prüfen | `19:#includedir /etc/sudoers.d`, Verzeichnis vorhanden. | Separate Datei `/etc/sudoers.d/ha-dns` mit der festen Regel vorgesehen. |
| Lokaler Gateway-Test | `DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.` | Programmpfad, Paketverzeichnis und sudo-Regel erfolgreich geprüft. |
| Container ermitteln | `HomeAssistant`, Image `homeassistant/home-assistant:latest`. | `docker exec -it HomeAssistant sh`. |
| SSH-Werkzeuge prüfen | Alle drei Programme unter `/usr/bin/` vorhanden. | `/config/ssh` mit `700` angelegt. |
| Client-Schlüssel | Schlüssel bereits vorhanden; beibehalten, privater Schlüssel auf `600` gesetzt. | Öffentlichen Schlüssel aus `.pub` abgelesen. |
| Schlüssel auf DSM | Eingeschränkter `authorized_keys`-Eintrag bereitgestellt; keine separate Eintragsausgabe gezeigt. | Erfolgreicher nachfolgender SSH-Test bestätigt den Zugang. |
| Server-Identität | Beide Fingerprints identisch: `SHA256:tIb+4+U9Ojztyqrj6fh2hqEIbNvshkR4hc7NRnO/zdI`. | Geprüfte `.pending`-Datei nach `synology_dns_known_hosts` verschoben, Rechte `600`. |
| SSH-Test aus HA | Post-Quantum-Warnung, danach erfolgreiche `check-dns`-Meldung. | Kein DNS-Neustart durchgeführt. |
| HA-Package | Package und Include-Anleitung bereitgestellt; Dateiinhalt auf HA nicht separat ausgegeben. | Anschließend HA-Konfiguration geprüft. |
| HA-Konfigurationsprüfung | Nur `Testing configuration at /config`, keine Fehler. | HA-Neustart empfohlen. |
| HA-Neustart und DNS-Button | Befehle/Bedienung beschrieben, noch keine Erfolgsausgabe vom Benutzer vorgelegt. | Noch nicht als ausgeführt oder erfolgreich dokumentiert. |
### Befehle zur damaligen Fehlerdiagnose
Diese Prüfungen sind hier der Vollständigkeit halber aufgeführt; die Fehler sind bereits behoben:
```sh
sudo ls -ld /usr /usr/local /usr/local/sbin
sudo ls -l /usr/local/sbin/ha-dns-gateway.sh
sudo sh -n /usr/local/sbin/ha-dns-gateway.sh
sudo sh -c '
for p in /usr/sbin/visudo /usr/bin/visudo /sbin/visudo /bin/visudo /usr/local/sbin/visudo; do
[ ! -x "$p" ] || printf "%s\n" "$p"
done
grep -nE "^[[:space:]]*([#@]include)" /etc/sudoers
ls -ld /etc/sudoers.d
'
```
Offizielle HA-Dokumentation:
- https://www.home-assistant.io/integrations/shell_command/
- https://www.home-assistant.io/docs/configuration/packages/
- https://www.home-assistant.io/dashboards/actions/
+81
View File
@@ -0,0 +1,81 @@
# HOMELAB in Home Assistant
Diese Konfiguration ersetzt für diesen Anwendungsfall die separate Python-Webseite im übergeordneten Ordner. Python-Dienst und Demo werden nicht benötigt.
## Einfügen
1. Einstellungen → Dashboards → Dashboard hinzufügen. Ein neues, leeres, selbst verwaltetes Dashboard erstellen.
2. Titel **HOMELAB**, Icon `mdi:home-network`, URL **dashboard-homelab** festlegen. In der Seitenleiste anzeigen.
3. Neues Dashboard öffnen → Bearbeiten → Drei-Punkte-Menü → Rohkonfigurationseditor.
4. Den gesamten Inhalt von `dashboard.yaml` einfügen und speichern. Nur die Konfiguration des neuen Dashboards ersetzen.
5. Auf der HOMELAB-Startseite die große DSM-Kachel öffnen. Die DSM-Unterseite enthält alle Detailanzeigen und einen Zurück-Pfeil zur Startseite.
Die Datei ist eine vollständige Dashboard-Konfiguration, keine einzelne Karte und kein Eintrag für `configuration.yaml`.
Es werden ausschließlich integrierte Karten verwendet; HACS, Mushroom und zusätzliche Frontend-Ressourcen sind nicht notwendig. Das Layout passt sich der Bildschirmbreite an. Die Graphen benötigen Messwertverlauf im Home-Assistant-Recorder.
## Bereits verbunden
Die 64 Messwert- und Status-Entitäten stammen aus der gelieferten Liste; zusätzlich verwendet der DNS-Button das separat eingerichtete `script.synology_dns_restart`: CPU, RAM, NAS-Temperatur, Sicherheitsstatus, Netzwerkdurchsatz, Volume 1, acht interne Laufwerke und zwei USB-Laufwerke. Die Anzeige übernimmt Einheiten direkt aus Home Assistant.
RAM-Auslastung kommt direkt aus dem Prozent-Sensor. Sie wird nicht aus Gesamt-RAM minus verfügbarem RAM berechnet, da die gelieferten Werte unterschiedliche Speicherkategorien abbilden können.
## Noch offen
- **Netzwerk-Linkstatus:** Es wurde kein eigener Link-/Erreichbarkeitssensor geliefert. Empfangene CPU-Daten zeigen die Messwertverfügbarkeit; daraus wird kein angeblich aktueller Ethernet-Linkstatus abgeleitet.
- **SMART und Volume-Kapazität ergänzt:** Die neue Liste enthält SMART-Status für alle acht Laufwerke, Volume-Gesamtgröße und maximale Laufwerkstemperatur. Diese sind jetzt eingebaut; außerdem ein SMART-Verlauf über 24 Stunden. Freier Volume-Speicher wird als Gesamtgröße minus belegtem Speicher berechnet und bei fehlenden oder widersprüchlichen Werten nicht angezeigt.
- **Speicherpool:** Echte Pool-Sensoren fehlen weiterhin. Volume-Größe und -Zustand werden ausdrücklich als Volume-Werte angezeigt, nicht als Pool-Werte.
- **DNS-Neustart:** Button und HA-Package sind für `Madzone@192.168.1.230:22` vorbereitet. Die einmalige SSH-Einrichtung und Installation stehen in [DNS-SETUP.md](DNS-SETUP.md). Gateway und sudo-Regel sind auf DSM eingerichtet; der SSH-Prüfbefehl aus dem Container **HomeAssistant** war erfolgreich. Die HA-Konfigurationsprüfung zeigte keine Fehler. Der tatsächliche DNS-Neustart per Button ist noch nicht bestätigt.
Die Aktualisierungsrate wird von der Integration bestimmt, nicht vom Dashboard. Die offizielle Dokumentation nennt standardmäßig 15 Minuten und beschreibt eine individuelle Polling-Konfiguration. Es wird hier keine aggressive Abfrageautomatik hinzugefügt.
## Prüfung
YAML wurde geparst; Messwert- und Status-Entitäten wurden mit der gelieferten Liste abgeglichen. Die vom Benutzer gelieferten HA-Screenshots zeigen Messwerte und Graphen auf beiden Seiten. DNS-Verbindung und Berechtigungsprüfung sind durch die Terminalausgaben bestätigt; der Neustart über den Button bleibt noch zu prüfen.
Referenzen:
- https://www.home-assistant.io/integrations/synology_dsm/
- https://www.home-assistant.io/dashboards/views/
- https://www.home-assistant.io/dashboards/actions/
## Grafische Ansicht
Die ursprüngliche Anordnung ist wiederhergestellt: HOMELAB-Startseite mit DSM-Kachel, vier Verlaufskacheln und Volume-Anzeige; separate DSM-Unterseite mit allen bisherigen Karten und der ergänzten SMART-Verlaufskarte einschließlich Graphen und DNS-Button. Weitere Systeme können später ergänzt werden.
Bei einem anderen Dashboard-URL-Pfad `navigation_path` und `back_path` entsprechend anpassen.
Die Graphen zeigen nur tatsächlich gespeicherte Messwerte. Neue oder vom Recorder ausgeschlossene Sensoren haben noch keinen Verlauf.
YAML, Kartenanzahl und DNS-Aktion wurden geprüft. Keine direkte Änderung in der laufenden Home-Assistant-Instanz.
## Letzte übermittelte Werte
Alle acht SMART-Sensoren meldeten `normal`. Volume 1: 26,810903851008 TB gesamt, 12,022071693312 TB belegt, daraus 14,788832157696 TB frei. Laufwerkstemperaturen 32–35 °C. Diese Werte sind eine Momentaufnahme aus der übermittelten Liste; das Dashboard liest die Entitäten dynamisch. Neu aktivierte SMART-Sensoren benötigen erst Verlaufshistorie.
## Geordnete DSM-Ansicht
Die DSM-Unterseite verwendet jetzt das native Sections-Layout mit maximal drei Spalten:
| Erste Reihe | | |
| --- | --- | --- |
| System | Netzwerk & DNS | Speicher · Volume 1 |
| Laufwerke 1–4 | Laufwerke 5–8 | SMART & USB-Speicher |
Die automatische Lückenfüllung ist deaktiviert, damit die Reihenfolge der Bereiche erhalten bleibt. Auf schmaleren Bildschirmen reduziert Home Assistant die Spaltenzahl. Alle bisherigen Messwerte, Graphen und DNS-Aktionen bleiben erhalten; die HOMELAB-Startseite ist unverändert.
Die bisherige Konfiguration ist als `dashboard-vor-sortierung.yaml` gesichert. Die neue Anordnung ist noch nicht in deiner laufenden HA-Oberfläche visuell geprüft.
## OPNsense · ALG
Die HOMELAB-Startseite enthält zusätzlich eine OPNsense-Kachel. Die neue Unterseite `/dashboard-homelab/opnsense` verwendet dieselbe Struktur mit maximal drei Spalten wie DSM. Die vorhandene DSM-Unterseite wurde unverändert übernommen.
- Erste Reihe: System (CPU, RAM, Temperaturzonen, Last und Dateisystem), WAN mit Durchsatz und Gateway-Verlauf, Status und Hinweise.
- Weitere Bereiche: LAN, DMZ, PROXY, TRANSFER jeweils mit Status und Eingangs-/Ausgangsgraphen; Loopback separat.
- Alle 32 Entitäten sind mit der gelieferten OPNsense-Liste abgeglichen. Es sind keine zusätzlichen HA-Templates, HACS-Karten oder Konfigurations-Packages erforderlich.
- LAN meldete in der gelieferten Momentaufnahme `no carrier`. Ein bedingter Hinweis erscheint nur bei diesem Zustand. Dies ist kein Beweis, dass die gesamte Firewall offline ist.
- WAN in/out wird aus Sicht der Firewall beschriftet. Interne Schnittstellen werden nicht als Internet-Download/-Upload bezeichnet oder zu einem Gesamtdurchsatz addiert.
- Temperaturzonen bleiben Zone 0 und Zone 1, da ihre genaue Hardware-Zuordnung nicht geliefert wurde.
- Die DHCP-Abfrage meldete 0 Leases; daraus wird keine Anzahl verbundener Geräte abgeleitet.
- Firmware-Update wird als Textstatus dargestellt, ohne Update-Aktion. Firewall-/Regeländerungen oder Neustartaktionen sind nicht Bestandteil dieser Ansicht.
Zum Übernehmen den vollständigen Inhalt von `dashboard.yaml` im Rohkonfigurationseditor des bestehenden HOMELAB-Dashboards ersetzen. Falls du inzwischen eigene Änderungen vorgenommen hast, vorher deine aktuelle Konfiguration sichern. Die neue OPNsense-Seite wurde auf YAML und Entitäten geprüft, aber noch nicht in deiner HA-Oberfläche gerendert.
@@ -0,0 +1,432 @@
# HOMELAB: Dashboard-URL dashboard-homelab
---
title: HOMELAB
views:
- title: HOMELAB
path: home
icon: mdi:home-network
cards:
- type: markdown
content: |
# HOMELAB
Deine Infrastruktur auf einen Blick.
- type: button
name: DSM · Synology DS1817+
icon: mdi:nas
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/dsm"
hold_action:
action: none
- type: grid
columns: 2
square: false
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- title: DSM
path: dsm
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:nas
cards:
- type: markdown
content: |
# DSM · DS1817+
**Zielsystem: DSM 7.3.2** · Werte aus deiner Synology-Integration.
{% set cpu = states.sensor.datennutzung_new_syno_cpu_auslastung_gesamt %}
{% if cpu.state in ['unknown', 'unavailable'] %}
⚠️ **Messwerte nicht verfügbar.** Integration und NAS-Verbindung prüfen.
{% else %}
**CPU-Messwert empfangen:** {{ as_local(cpu.last_reported).strftime('%d.%m.%Y %H:%M:%S') }}
{% endif %}
Netzwerkraten gelten für das NAS. Die Aktualisierung erfolgt durch die Integration.
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
- entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
- type: sensor
entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
- type: entities
title: System
show_header_toggle: false
entities:
- entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur
- entity: sensor.datennutzung_new_syno_speicher_gesamt_real
name: RAM gesamt
- entity: sensor.datennutzung_new_syno_speicher_verfugbar_real
name: RAM verfügbar · DSM-Messwert
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_5_min
name: CPU-Last · 5 Minuten
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_15_min
name: CPU-Last · 15 Minuten
- entity: binary_sensor.datennutzung_new_syno_sicherheitsstatus
name: Sicherheitswarnung
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
graph: line
detail: 2
hours_to_show: 6
- type: history-graph
title: Netzwerk · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
- entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- type: sensor
entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Volume 1 · Belegter Speicher · 7 Tage
graph: line
detail: 2
hours_to_show: 168
- type: entities
title: Volume 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_volume_1_status
name: Zustand
- entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Belegter Speicher
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Belegung
- entity: sensor.new_syno_volume_1_durchschnittliche_festplattentemperatur
name: Mittlere Laufwerkstemperatur
- entity: sensor.new_syno_volume_1_gesamtgrosse
name: Gesamtkapazität
- entity: sensor.new_syno_volume_1_maximale_festplattentemperatur
name: Höchste Laufwerkstemperatur
- type: markdown
title: Volume 1 · Kapazität
content: |
{% set total = states('sensor.new_syno_volume_1_gesamtgrosse') %}
{% set used = states('sensor.new_syno_volume_1_belegter_speicherplatz') %}
{% if is_number(total) and is_number(used) and total | float >= used | float and used | float >= 0 %}
| Gesamt | Belegt | Frei (berechnet) |
| :--- | :--- | :--- |
| {{ total | float | round(2) }} TB | {{ used | float | round(2) }} TB | {{ ((total | float) - (used | float)) | round(2) }} TB |
{% else %}
**Kapazitätsdaten fehlen oder sind widersprüchlich.** Freier Speicher kann nicht berechnet werden.
{% endif %}
Angaben für **Volume 1**. Echte Speicherpool-Kapazitäten und Pool-Zustand werden von den vorhandenen Entitäten nicht bereitgestellt.
- type: history-graph
title: SMART-Status · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_status_smart
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_status_smart
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_status_smart
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_status_smart
name: Laufwerk 4
- entity: sensor.new_syno_drive_5_status_smart
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_status_smart
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_status_smart
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_status_smart
name: Laufwerk 8
- type: vertical-stack
cards:
- type: markdown
content: "## Laufwerke · Einschübe 1–4"
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_temperatur
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_temperatur
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_temperatur
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_temperatur
name: Laufwerk 4
- type: entities
title: Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_1_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_1_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_1_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_1_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_1_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_2_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_2_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_2_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_2_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_2_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 3
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_3_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_3_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_3_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_3_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_3_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 4
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_4_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_4_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_4_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_4_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_4_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: vertical-stack
cards:
- type: markdown
content: "## Laufwerke · Einschübe 5–8"
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_5_temperatur
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_temperatur
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_temperatur
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_temperatur
name: Laufwerk 8
- type: entities
title: Laufwerk 5
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_5_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_5_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_5_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_5_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_5_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 6
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_6_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_6_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_6_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_6_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_6_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 7
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_7_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_7_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_7_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_7_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_7_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: entities
title: Laufwerk 8
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_8_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_8_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_8_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_8_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_8_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
- type: history-graph
title: Speicherbelegung · 7 Tage
hours_to_show: 168
entities:
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: USB 1
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: USB 2
- type: entities
title: USB-Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_1_status
name: Zustand
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_1_partition_1_partitionsgrosse
name: Gesamtkapazität
- type: entities
title: USB-Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_2_status
name: Zustand
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_2_partition_1_partitionsgrosse
name: Gesamtkapazität
- type: vertical-stack
cards:
- type: markdown
content: |
## DNS Server
Neustart des DNS-Pakets auf **192.168.1.230**.
SSH-Einrichtung gemäß DNS-SETUP.md erforderlich. Das Ergebnis erscheint als HA-Benachrichtigung.
- type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann
kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
+965
View File
@@ -0,0 +1,965 @@
# HOMELAB: Dashboard-URL dashboard-homelab
# Unterseiten: DSM und OPNsense
---
title: HOMELAB
views:
- title: HOMELAB
path: home
icon: mdi:home-network
cards:
- type: markdown
content: |
# HOMELAB
Deine Infrastruktur auf einen Blick.
- type: button
name: DSM · Synology DS1817+
icon: mdi:nas
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/dsm"
hold_action:
action: none
- type: button
name: OPNsense · ALG
icon: mdi:shield-lock
show_state: false
tap_action:
action: navigate
navigation_path: "/dashboard-homelab/opnsense"
hold_action:
action: none
- type: grid
columns: 2
square: false
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
limits:
min: 0
max: 100
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload · 6 Stunden
graph: line
detail: 2
hours_to_show: 6
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
- title: DSM
path: dsm
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:nas
type: sections
max_columns: 3
dense_section_placement: false
header:
card:
type: markdown
content: |
# DSM · DS1817+
**Zielsystem: DSM 7.3.2** · Werte aus deiner Synology-Integration.
{% set cpu = states.sensor.datennutzung_new_syno_cpu_auslastung_gesamt %}
{% if cpu.state in ['unknown', 'unavailable'] %}
⚠️ **Messwerte nicht verfügbar.** Integration und NAS-Verbindung prüfen.
{% else %}
**CPU-Messwert empfangen:** {{ as_local(cpu.last_reported).strftime('%d.%m.%Y %H:%M:%S') }}
{% endif %}
Netzwerkraten gelten für das NAS. Die Aktualisierung erfolgt durch die Integration.
layout: start
sections:
- type: grid
cards:
- type: heading
heading: System
heading_style: title
icon: mdi:chip
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_cpu_auslastung_gesamt
name: CPU
- entity: sensor.datennutzung_new_syno_speichernutzung_real
name: RAM
grid_options:
columns: 12
rows: auto
- type: sensor
entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur · 24 Stunden
graph: line
detail: 2
hours_to_show: 24
grid_options:
columns: 12
rows: auto
- type: entities
title: System
show_header_toggle: false
entities:
- entity: sensor.datennutzung_new_syno_temperatur
name: Systemtemperatur
- entity: sensor.datennutzung_new_syno_speicher_gesamt_real
name: RAM gesamt
- entity: sensor.datennutzung_new_syno_speicher_verfugbar_real
name: RAM verfügbar · DSM-Messwert
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_5_min
name: CPU-Last · 5 Minuten
- entity: sensor.datennutzung_new_syno_durchschnittliche_cpu_last_15_min
name: CPU-Last · 15 Minuten
- entity: binary_sensor.datennutzung_new_syno_sicherheitsstatus
name: Sicherheitswarnung
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Netzwerk & DNS
heading_style: title
icon: mdi:network
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Netzwerk · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.datennutzung_new_syno_download_durchsatz
name: Download
- entity: sensor.datennutzung_new_syno_upload_durchsatz
name: Upload
grid_options:
columns: 12
rows: auto
- type: vertical-stack
cards:
- type: markdown
content: |
## DNS Server
Neustart des DNS-Pakets auf **192.168.1.230**.
SSH-Einrichtung gemäß DNS-SETUP.md erforderlich. Das Ergebnis erscheint als HA-Benachrichtigung.
- type: button
entity: script.synology_dns_restart
name: DNS Server neu starten
icon: mdi:dns
show_state: true
tap_action:
action: perform-action
perform_action: script.synology_dns_restart
confirmation:
text: DNS Server auf 192.168.1.230 neu starten? Die Namensauflösung kann
kurz ausfallen.
hold_action:
action: none
double_tap_action:
action: none
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Speicher · Volume 1
heading_style: title
icon: mdi:database
- type: gauge
entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1 · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: markdown
title: Volume 1 · Kapazität
content: |
{% set total = states('sensor.new_syno_volume_1_gesamtgrosse') %}
{% set used = states('sensor.new_syno_volume_1_belegter_speicherplatz') %}
{% if is_number(total) and is_number(used) and total | float >= used | float and used | float >= 0 %}
| Gesamt | Belegt | Frei (berechnet) |
| :--- | :--- | :--- |
| {{ total | float | round(2) }} TB | {{ used | float | round(2) }} TB | {{ ((total | float) - (used | float)) | round(2) }} TB |
{% else %}
**Kapazitätsdaten fehlen oder sind widersprüchlich.** Freier Speicher kann nicht berechnet werden.
{% endif %}
Angaben für **Volume 1**. Echte Speicherpool-Kapazitäten und Pool-Zustand werden von den vorhandenen Entitäten nicht bereitgestellt.
grid_options:
columns: 12
rows: auto
- type: sensor
entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Volume 1 · Belegter Speicher · 7 Tage
graph: line
detail: 2
hours_to_show: 168
grid_options:
columns: 12
rows: auto
- type: entities
title: Volume 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_volume_1_status
name: Zustand
- entity: sensor.new_syno_volume_1_belegter_speicherplatz
name: Belegter Speicher
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Belegung
- entity: sensor.new_syno_volume_1_durchschnittliche_festplattentemperatur
name: Mittlere Laufwerkstemperatur
- entity: sensor.new_syno_volume_1_gesamtgrosse
name: Gesamtkapazität
- entity: sensor.new_syno_volume_1_maximale_festplattentemperatur
name: Höchste Laufwerkstemperatur
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Laufwerke 1–4
heading_style: title
icon: mdi:harddisk
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_temperatur
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_temperatur
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_temperatur
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_temperatur
name: Laufwerk 4
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_1_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_1_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_1_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_1_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_1_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_2_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_2_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_2_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_2_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_2_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 3
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_3_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_3_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_3_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_3_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_3_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 4
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_4_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_4_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_4_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_4_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_4_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Laufwerke 5–8
heading_style: title
icon: mdi:harddisk
- type: history-graph
title: Laufwerkstemperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_5_temperatur
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_temperatur
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_temperatur
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_temperatur
name: Laufwerk 8
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 5
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_5_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_5_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_5_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_5_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_5_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 6
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_6_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_6_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_6_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_6_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_6_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 7
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_7_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_7_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_7_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_7_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_7_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: entities
title: Laufwerk 8
show_header_toggle: false
entities:
- entity: sensor.new_syno_drive_8_status
name: DSM-Zustand
- entity: sensor.new_syno_drive_8_status_smart
name: SMART-Status
icon: mdi:harddisk-check
- entity: sensor.new_syno_drive_8_temperatur
name: Temperatur
- entity: binary_sensor.new_syno_drive_8_max_fehlerhafte_sektoren_uberschritten
name: Sektorgrenzwert überschritten
- entity: binary_sensor.new_syno_drive_8_unterhalb_der_mindestrestlebensdauer
name: Restlebensdauer kritisch
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: SMART & USB-Speicher
heading_style: title
icon: mdi:harddisk-check
- type: history-graph
title: SMART-Status · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.new_syno_drive_1_status_smart
name: Laufwerk 1
- entity: sensor.new_syno_drive_2_status_smart
name: Laufwerk 2
- entity: sensor.new_syno_drive_3_status_smart
name: Laufwerk 3
- entity: sensor.new_syno_drive_4_status_smart
name: Laufwerk 4
- entity: sensor.new_syno_drive_5_status_smart
name: Laufwerk 5
- entity: sensor.new_syno_drive_6_status_smart
name: Laufwerk 6
- entity: sensor.new_syno_drive_7_status_smart
name: Laufwerk 7
- entity: sensor.new_syno_drive_8_status_smart
name: Laufwerk 8
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Speicherbelegung · 7 Tage
hours_to_show: 168
entities:
- entity: sensor.new_syno_volume_1_volume_nutzung
name: Volume 1
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: USB 1
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: USB 2
grid_options:
columns: 12
rows: auto
- type: entities
title: USB-Laufwerk 1
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_1_status
name: Zustand
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_1_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_1_partition_1_partitionsgrosse
name: Gesamtkapazität
grid_options:
columns: 12
rows: auto
- type: entities
title: USB-Laufwerk 2
show_header_toggle: false
entities:
- entity: sensor.new_syno_usb_disk_2_status
name: Zustand
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzte_partition
name: Belegung
- entity: sensor.new_syno_usb_disk_2_partition_1_genutzter_partitionsplatz
name: Belegter Speicher
- entity: sensor.new_syno_usb_disk_2_partition_1_partitionsgrosse
name: Gesamtkapazität
grid_options:
columns: 12
rows: auto
- title: OPNsense
path: opnsense
subview: true
back_path: "/dashboard-homelab/home"
icon: mdi:shield-lock
type: sections
max_columns: 3
dense_section_placement: false
header:
layout: start
card:
type: markdown
content: |-
# OPNsense · ALG
Firewall **192.168.1.250:8443** · Konfigurierte Version **26.7.7**
Messwerte aus der OPNsense-Integration. Netzwerkwerte in Mbit/s, Temperaturen ohne angenommene Hardware-Zuordnung.
sections:
- type: grid
cards:
- type: heading
heading: System
heading_style: title
icon: mdi:chip
- type: horizontal-stack
cards:
- type: gauge
entity: sensor.alg_cpu_usage
name: CPU
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 70
red: 90
- type: gauge
entity: sensor.alg_memory_used_percentage
name: RAM
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: history-graph
title: CPU & RAM · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_cpu_usage
name: CPU
- entity: sensor.alg_memory_used_percentage
name: RAM
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Temperaturen · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.alg_temp_zone_0
name: Zone 0
- entity: sensor.alg_temp_zone_1
name: Zone 1
grid_options:
columns: 12
rows: auto
- type: entities
title: Systemdetails
show_header_toggle: false
entities:
- entity: sensor.alg_system_boottime
name: Letzter Systemstart
- entity: sensor.alg_system_load_average_one_minute
name: Last · 1 Minute
- entity: sensor.alg_system_load_average_five_minute
name: Last · 5 Minuten
- entity: sensor.alg_system_load_average_fifteen_minute
name: Last · 15 Minuten
grid_options:
columns: 12
rows: auto
- type: gauge
entity: sensor.alg_filesystem_used_percentage_root
name: Systemspeicher · Belegung
min: 0
max: 100
needle: true
severity:
green: 0
yellow: 75
red: 90
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: WAN · Internet
heading_style: title
icon: mdi:web
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_wan_traffic_in_rate
name: WAN eingehend
graph: line
detail: 2
hours_to_show: 6
icon: mdi:download-network
- type: sensor
entity: sensor.alg_interface_wan_traffic_out_rate
name: WAN ausgehend
graph: line
detail: 2
hours_to_show: 6
icon: mdi:upload-network
grid_options:
columns: 12
rows: auto
- type: history-graph
title: WAN-Durchsatz · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_wan_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_wan_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: entities
title: WAN & Gateways
show_header_toggle: false
entities:
- entity: sensor.alg_interface_wan_status
name: WAN-Verbindung
- entity: sensor.alg_gateway_wan_gw_status
name: WAN_GW
- entity: sensor.alg_gateway_alg_status
name: ALG
grid_options:
columns: 12
rows: auto
- type: history-graph
title: Gateway-Erreichbarkeit · 24 Stunden
hours_to_show: 24
entities:
- entity: sensor.alg_gateway_wan_gw_status
name: WAN_GW
- entity: sensor.alg_gateway_alg_status
name: ALG
grid_options:
columns: 12
rows: auto
- type: markdown
content: WAN eingehend entspricht der Download-Richtung, ausgehend der Upload-Richtung
aus Sicht der Firewall. Schnittstellenverkehr enthält auch Verkehr der Firewall
selbst.
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Status & Hinweise
heading_style: title
icon: mdi:shield-check
- type: conditional
conditions:
- condition: state
entity: sensor.alg_interface_lan_status
state: no carrier
card:
type: markdown
content: |-
### LAN · Kein Link
Die LAN-Schnittstelle meldet **no carrier**. Falls sie verwendet werden soll, Kabel, Gegenstelle und Port-Zuordnung prüfen. Bei einem ungenutzten Port kann dies erwartet sein.
grid_options:
columns: 12
rows: auto
- type: entities
title: Schnittstellen
show_header_toggle: false
entities:
- entity: sensor.alg_interface_wan_status
name: WAN
- entity: sensor.alg_interface_lan_status
name: LAN
- entity: sensor.alg_interface_dmz_status
name: DMZ
- entity: sensor.alg_interface_proxy_status
name: PROXY
- entity: sensor.alg_interface_transfer_status
name: TRANSFER
- entity: sensor.alg_interface_loopback_status
name: LOOPBACK
grid_options:
columns: 12
rows: auto
- type: entities
title: Meldungen & DHCP
show_header_toggle: false
entities:
- entity: binary_sensor.alg_pending_notices_present
name: Offene Systemmeldungen
- entity: sensor.alg_dhcp_leases_all
name: Gemeldete DHCP-Leases
grid_options:
columns: 12
rows: auto
- type: markdown
content: |-
**Firmware:** {% if is_state('update.alg_firmware_updates_available', 'on') %}Update verfügbar{% elif is_state('update.alg_firmware_updates_available', 'off') %}Kein Update gemeldet{% else %}Status unbekannt{% endif %}
DHCP-Wert 0 allein bestätigt nicht, dass keine Clients verbunden sind; die Anzeige hängt von der aktivierten DHCP-Abfrage ab.
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: LAN
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_lan_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_lan_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_lan_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: LAN · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_lan_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_lan_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: DMZ
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_dmz_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_dmz_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_dmz_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: DMZ · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_dmz_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_dmz_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: PROXY
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_proxy_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_proxy_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_proxy_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: PROXY · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_proxy_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_proxy_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: TRANSFER
heading_style: title
icon: mdi:ethernet
- type: entities
title: Verbindung
show_header_toggle: false
entities:
- entity: sensor.alg_interface_transfer_status
name: Linkstatus
grid_options:
columns: 12
rows: auto
- type: horizontal-stack
cards:
- type: sensor
entity: sensor.alg_interface_transfer_traffic_in_rate
name: Eingehend
graph: line
detail: 2
hours_to_show: 6
- type: sensor
entity: sensor.alg_interface_transfer_traffic_out_rate
name: Ausgehend
graph: line
detail: 2
hours_to_show: 6
grid_options:
columns: 12
rows: auto
- type: history-graph
title: TRANSFER · 6 Stunden
hours_to_show: 6
entities:
- entity: sensor.alg_interface_transfer_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_transfer_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
- type: grid
cards:
- type: heading
heading: Loopback
heading_style: title
icon: mdi:swap-horizontal
- type: entities
title: Interne Schnittstelle
show_header_toggle: false
entities:
- entity: sensor.alg_interface_loopback_status
name: Status
- entity: sensor.alg_interface_loopback_traffic_in_rate
name: Eingehend
- entity: sensor.alg_interface_loopback_traffic_out_rate
name: Ausgehend
grid_options:
columns: 12
rows: auto
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# Install on DSM as root-owned /usr/local/sbin/ha-dns-gateway.sh.
# Only used as the forced command of the dedicated Home Assistant SSH key.
set -eu
case "${SSH_ORIGINAL_COMMAND:-}" in
check-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
sudo -n -l /usr/syno/bin/synopkg restart DNSServer >/dev/null
printf '%s\n' 'DNS-Paket und sudo-Regel vorhanden. Kein Neustart ausgeführt.'
;;
restart-dns)
test -x /usr/syno/bin/synopkg
test -d /var/packages/DNSServer
exec sudo -n /usr/syno/bin/synopkg restart DNSServer
;;
*)
printf '%s\n' 'Nur check-dns oder restart-dns ist erlaubt.' >&2
exit 64
;;
esac
@@ -0,0 +1,3 @@
# DSM: confirmed includedir /etc/sudoers.d; visudo unavailable.
# See DNS-SETUP.md: create /etc/sudoers.d/ha-dns without overwriting (root:root, 0440).
Madzone ALL=(root) NOPASSWD: /usr/syno/bin/synopkg restart DNSServer
+48
View File
@@ -0,0 +1,48 @@
# Nach /config/packages/synology_dns.yaml kopieren.
shell_command:
synology_dns_restart: >-
ssh -F /dev/null -T -p 22
-i /config/ssh/synology_dns_ed25519
-o BatchMode=yes -o IdentitiesOnly=yes
-o StrictHostKeyChecking=yes
-o UserKnownHostsFile=/config/ssh/synology_dns_known_hosts
-o ConnectTimeout=10 -o ServerAliveInterval=5 -o ServerAliveCountMax=2
Madzone@192.168.1.230 restart-dns
script:
synology_dns_restart:
alias: Synology · DNS Server neu starten
icon: mdi:dns
mode: single
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: Neustartbefehl wird gesendet …
- variables:
dns_result:
returncode: -1
- action: shell_command.synology_dns_restart
response_variable: dns_result
continue_on_error: true
- choose:
- conditions: "{{ dns_result is defined and dns_result is mapping and dns_result.get('returncode', -1) == 0 }}"
sequence:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS Server
message: >-
Der DNS-Neustartbefehl wurde erfolgreich ausgeführt.
Das NAS wurde nicht neu gestartet. Die DNS-Auflösung wurde nicht separat geprüft.
default:
- action: persistent_notification.create
data:
notification_id: synology_dns_restart
title: Synology DNS · Neustart nicht bestätigt
message: >-
SSH oder der Neustartbefehl ist fehlgeschlagen, oder das Zeitlimit wurde erreicht.
Prüfe den DNS-Paketstatus in DSM und das Home-Assistant-Protokoll,
bevor du einen weiteren Neustart auslöst.
- delay: '00:01:00'
+199
View File
@@ -0,0 +1,199 @@
#!/usr/bin/env python3
"""Local DSM collector and authenticated HOMELAB API. Python 3 standard library."""
import argparse
import glob
import hmac
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
STATIC = Path(__file__).parent / 'static'
def read(path):
try:
return Path(path).read_text().strip()
except OSError:
return ''
def run(args):
try:
p = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
universal_newlines=True, timeout=25, env=dict(os.environ, LC_ALL='C'))
return p.returncode, p.stdout
except (OSError, subprocess.TimeoutExpired):
return -1, ''
def executable(name, paths):
return next((p for p in paths if os.access(p, os.X_OK)), shutil.which(name))
def smart(text, code):
match = re.search(r'(?:overall-health self-assessment test result|Health Status):\s*(.+)', text)
status = 'Unbekannt'
if match and code >= 0 and not code & 7:
status = 'OK' if match[1].strip() in ('PASSED', 'OK') else 'Warnung'
if code & 248:
status = 'Warnung'
temp = re.search(r'^\s*194\s+\S+\s+(?:\S+\s+){7}(\d+)', text, re.M)
if not temp:
temp = re.search(r'(?:Temperature|Current Drive Temperature):\s*(\d+)', text)
return {'status': status, 'temperature': int(temp[1]) if temp else None}
class Collector:
def __init__(self):
self.lock = threading.Lock()
self.previous = None
self.storage = {}
self.storage_time = 0
def disks_and_pools(self):
disks = []
binary = executable('smartctl', ['/usr/syno/bin/smartctl', '/usr/sbin/smartctl'])
for path in sorted(glob.glob('/sys/block/*')):
name = Path(path).name
if not re.fullmatch(r'(sd[a-z]+|sata\d+|nvme\d+n\d+)', name):
continue
code, output = run([binary, '-n', 'standby', '-a', '/dev/' + name]) if binary else (-1, '')
disks.append(dict(name=name, model=read(path + '/device/model') or name, **smart(output, code)))
raids = []
for path in sorted(glob.glob('/sys/block/md*/md')):
name = Path(path).parent.name
if name in ('md0', 'md1'):
continue
degraded = read(path + '/degraded')
raids.append({'name': name, 'level': read(path + '/level'),
'status': ('Warnung' if int(degraded) else 'OK') if degraded.isdigit() else 'Unbekannt',
'action': read(path + '/sync_action') or 'Unbekannt'})
pools = []
vgs = executable('vgs', ['/sbin/vgs', '/usr/sbin/vgs'])
if vgs:
code, output = run([vgs, '--noheadings', '--units', 'b', '--nosuffix', '--separator', '|', '-o', 'vg_name,vg_size,vg_free'])
if code == 0:
for line in output.splitlines():
fields = line.strip().split('|')
try:
pools.append({'name': fields[0].strip(), 'total': float(fields[1]), 'free': float(fields[2])})
except (ValueError, IndexError):
pass
volumes = []
for path in sorted(glob.glob('/volume[0-9]*')):
if not re.fullmatch(r'/volume\d+', path) or not os.path.ismount(path):
continue
usage = shutil.disk_usage(path)
volumes.append(dict(name=path, total=usage.total, free=usage.free))
return dict(disks=disks, raids=raids, pools=pools, volumes=volumes)
def sample(self):
with self.lock:
now = time.monotonic()
cpu_line = read('/proc/stat').splitlines()
cpu = [int(x) for x in cpu_line[0].split()[1:9]] if cpu_line else []
net = {}
for path in sorted(glob.glob('/sys/class/net/*')):
name = Path(path).name
# Physical links only: avoids counting bonds/bridges and members twice.
if not os.path.exists(path + '/device'):
continue
rx, tx = read(path + '/statistics/rx_bytes'), read(path + '/statistics/tx_bytes')
if rx.isdigit() and tx.isdigit():
net[name] = (int(rx), int(tx), read(path + '/operstate'))
load, interfaces = None, []
if self.previous:
before, old_cpu, old_net = self.previous
if cpu and old_cpu:
total = sum(cpu) - sum(old_cpu)
idle = sum(cpu[3:5]) - sum(old_cpu[3:5])
load = round(max(0, min(100, 100 * (1 - idle / total))), 1) if total > 0 else None
for name, (rx, tx, state) in net.items():
old = old_net.get(name)
interfaces.append(dict(name=name, status=state,
down=max(0, rx-old[0]) / (now-before) if old else None,
up=max(0, tx-old[1]) / (now-before) if old else None))
else:
interfaces = [dict(name=n, status=v[2], down=None, up=None) for n,v in net.items()]
self.previous = now, cpu, net
mem = dict((k, int(v)*1024) for k,v in re.findall(r'^(\w+):\s+(\d+)', read('/proc/meminfo'), re.M))
ram = dict(total=mem.get('MemTotal'), free=mem.get('MemAvailable'))
if now-self.storage_time > 60 or not self.storage:
self.storage = self.disks_and_pools()
self.storage_time = now
dns_pid = read('/var/packages/DNSServer/target/var/named.pid')
dns = 'Läuft' if dns_pid.isdigit() and Path('/proc/' + dns_pid).exists() else 'Unbekannt'
return dict(cpu=load, ram=ram, interfaces=interfaces, dns=dns,
timestamp=time.time(), storage_age=round(now-self.storage_time), **self.storage)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--host', default='127.0.0.1')
parser.add_argument('--port', type=int, default=8787)
parser.add_argument('--demo', action='store_true')
args = parser.parse_args()
token = os.environ.get('HOMELAB_TOKEN', '')
if not args.demo and len(token) < 24:
parser.error('HOMELAB_TOKEN muss mindestens 24 Zeichen enthalten.')
collector = Collector()
restart_lock = threading.Lock()
last_restart = [0]
class Handler(BaseHTTPRequestHandler):
def reply(self, status, data, kind='application/json'):
body = json.dumps(data).encode() if kind == 'application/json' else data
self.send_response(status)
self.send_header('Content-Type', kind + '; charset=utf-8')
self.send_header('Content-Length', str(len(body)))
self.send_header('Cache-Control', 'no-store')
self.send_header('X-Content-Type-Options', 'nosniff')
self.send_header('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; frame-ancestors 'none'; base-uri 'none'")
self.end_headers()
self.wfile.write(body)
def authorized(self):
return hmac.compare_digest(self.headers.get('Authorization', ''), 'Bearer ' + token) and bool(token)
def do_GET(self):
if self.path == '/api/status':
if args.demo:
return self.reply(200, {'demo': True})
if not self.authorized():
return self.reply(401, {'error': 'Zugriffsschlüssel erforderlich.'})
try:
data = collector.sample()
data['can_restart'] = os.environ.get('HOMELAB_ALLOW_DNS_RESTART') == '1'
return self.reply(200, data)
except Exception:
return self.reply(503, {'error': 'Messwerte konnten nicht gelesen werden.'})
files = {'/': ('index.html','text/html'), '/dsm': ('index.html','text/html'),
'/app.js': ('app.js','text/javascript'), '/style.css': ('style.css','text/css')}
if self.path not in files:
return self.reply(404, {'error': 'Nicht gefunden'})
name, kind = files[self.path]
self.reply(200, (STATIC/name).read_bytes(), kind)
def do_POST(self):
if self.path != '/api/dns/restart':
return self.reply(404, {'error': 'Nicht gefunden'})
if args.demo or not self.authorized():
return self.reply(403, {'error': 'Neustart nicht freigegeben.'})
if os.environ.get('HOMELAB_ALLOW_DNS_RESTART') != '1':
return self.reply(403, {'error': 'DNS-Neustart muss auf dem NAS aktiviert werden.'})
if not restart_lock.acquire(blocking=False):
return self.reply(409, {'error': 'Neustart läuft bereits.'})
try:
if time.monotonic()-last_restart[0] < 60:
return self.reply(429, {'error': 'Bitte 60 Sekunden zwischen Neustarts warten.'})
last_restart[0] = time.monotonic()
code, _ = run(['/usr/syno/bin/synopkg', 'restart', 'DNSServer'])
self.reply(200 if code == 0 else 503, {'message': 'Neustartbefehl erfolgreich ausgeführt. Dienststatus in DSM prüfen.'} if code == 0 else {'error': 'Neustart fehlgeschlagen oder Zeitlimit erreicht. Dienststatus in DSM prüfen.'})
finally:
restart_lock.release()
httpd = ThreadingHTTPServer((args.host, args.port), Handler)
print('HOMELAB: http://%s:%s%s' % (args.host, args.port, ' (DEMO)' if args.demo else ''), flush=True)
httpd.serve_forever()
if __name__ == '__main__':
main()
+30
View File
@@ -0,0 +1,30 @@
'use strict';
const $ = id => document.getElementById(id);
const isDSM = location.pathname === '/dsm';
$('home').hidden = isDSM; $('dsm').hidden = !isDSM;
$(isDSM ? 'dsm-nav' : 'home-nav').classList.add('active');
$('breadcrumb').textContent = isDSM ? 'DSM' : 'Übersicht';
let token = '', demo = false, busy = false, restarting = false, canRestart = false;
const history = {down: [], up: []};
const number = n => n.toLocaleString('de-DE', {maximumFractionDigits: 1});
const bytes = n => {if(n == null) return '—'; const unit = n >= 2**40 ? [2**40,'TiB'] : n >= 2**30 ? [2**30,'GiB'] : n >= 2**20 ? [2**20,'MiB'] : [1024,'KiB']; return `${number(n/unit[0])} ${unit[1]}`;};
const escape = s => String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
function fixture(){return {cpu:18.4,ram:{total:8*2**30,free:5.2*2**30},interfaces:[{name:'eth0',status:'up',down:24.8*2**20,up:6.3*2**20},{name:'eth1',status:'down',down:0,up:0}],pools:[{name:'vg1000',total:32*2**40,free:4*2**40}],volumes:[{name:'/volume1',total:28*2**40,free:12.6*2**40}],raids:[{name:'md2',level:'raid6',status:'OK',action:'idle'}],disks:Array.from({length:8},(_,i)=>({name:`sata${i+1}`,model:'Beispiellaufwerk · 8 TB',status:'OK',temperature:32+i%4})),dns:'Demo · Läuft',timestamp:Date.now()/1000,storage_age:0};}
function chart(key, color){const c=$(key+'-chart'),ctx=c.getContext('2d'),arr=history[key];ctx.clearRect(0,0,c.width,c.height); if(arr.length<2)return;const max=Math.max(...arr,1);ctx.beginPath();arr.forEach((v,i)=>{const x=i*300/59,y=44-v/max*38;i?ctx.lineTo(x,y):ctx.moveTo(x,y);});ctx.strokeStyle=color;ctx.lineWidth=2;ctx.stroke();}
function render(d){
$('cpu').textContent=d.cpu==null?'—':number(d.cpu)+' %';$('cpu-bar').value=d.cpu||0;
const ram=d.ram.total&&d.ram.free!=null?100*(1-d.ram.free/d.ram.total):null;
$('ram').textContent=ram==null?'—':number(ram)+' %';$('ram-bar').value=ram||0;
$('ram-detail').textContent=ram==null?'Nicht verfügbar':`${bytes(d.ram.total-d.ram.free)} von ${bytes(d.ram.total)}`;
for(const [key,id,color] of [['down','download','#65dfb3'],['up','upload','#80b6ff']]){const measured=d.interfaces.filter(n=>n[key]!=null);const sum=measured.length?measured.reduce((a,n)=>a+n[key],0):null;$(id).textContent=sum==null?'—':bytes(sum)+'/s';if(sum!=null){history[key].push(sum);if(history[key].length>60)history[key].shift();}chart(key,color);}
$('network').innerHTML=d.interfaces.map(n=>`<div class="network-row"><div>${escape(n.name)}<small class="${n.status==='up'?'ok':'warn'}">${escape(n.status==='up'?'Verbunden':n.status==='down'?'Getrennt':n.status)}</small></div><div>↓ ${bytes(n.down)}/s<small>↑ ${bytes(n.up)}/s</small></div></div>`).join('')||'<p class="quiet">Keine physischen Schnittstellen verfügbar.</p>';
$('storage').innerHTML=[...d.pools.map(p=>({...p,label:'Pool / LVM'})),...d.volumes.map(p=>({...p,label:'Volume'}))].map(p=>`<div class="storage-row"><div class="row"><span>${escape(p.name)}</span><small>${p.label}</small></div><progress max="100" value="${p.total?100*(1-p.free/p.total):0}"></progress><div class="row"><small>${bytes(p.total-p.free)} von ${bytes(p.total)}</small><small>${bytes(p.free)} frei</small></div></div>`).join('')+(d.pools.length?'':'<p class="quiet">Pool-Kapazität nicht verfügbar.</p>')+d.raids.map(r=>`<p class="quiet">${escape(r.name)} · ${escape(r.level)} · <span class="${r.status==='OK'?'ok':'warn'}">${escape(r.status)}</span> · ${escape(r.action)}</p>`).join('');
$('disks').innerHTML=d.disks.map(x=>`<tr><td>${escape(x.name)}</td><td>${escape(x.model)}</td><td class="${x.status==='OK'?'ok':'warn'}">${escape(x.status)}</td><td>${x.temperature==null?'—':escape(x.temperature)+' °C'}</td></tr>`).join('')||'<tr><td colspan="4">Keine Laufwerksdaten verfügbar.</td></tr>';
$('dns-status').textContent=d.dns;$('updated').textContent=new Date(d.timestamp*1000).toLocaleTimeString('de-DE');
canRestart=!!d.can_restart; $('restart').disabled=demo||restarting||!canRestart;
}
async function refresh(){if(busy)return;busy=true;try{const response=await fetch('/api/status',{headers:{Authorization:'Bearer '+token},signal:AbortSignal.timeout(90000)});if(response.status===401){$('login').hidden=false;throw Error('Verbinde dein NAS mit dem Zugriffsschlüssel.');}if(!response.ok)throw Error('Messwerte konnten nicht geladen werden.');let data=await response.json();demo=!!data.demo;if(demo)data=fixture();$('connection').textContent=demo?'DEMO · Beispieldaten':'LIVE · Verbunden';$('notice').textContent=demo?'VORSCHAU · Alle Werte sind Beispieldaten. Es besteht keine Verbindung zu deinem NAS. DNS-Neustart ist deaktiviert.':'';$('login').hidden=true;render(data);}catch(e){$('connection').textContent='Nicht verbunden';$('notice').textContent=e.message+' Angezeigte Werte sind gegebenenfalls veraltet.';$('restart').disabled=true;}finally{busy=false;}}
$('login-form').addEventListener('submit',e=>{e.preventDefault();token=$('token').value;$('token').value='';refresh();});
$('restart').onclick=()=>$('confirm').showModal();$('cancel').onclick=()=>$('confirm').close();
$('confirm-restart').onclick=async()=>{$('confirm').close();restarting=true;$('restart').disabled=true;$('dns-status').textContent='Neustart läuft …';try{const r=await fetch('/api/dns/restart',{method:'POST',headers:{Authorization:'Bearer '+token},signal:AbortSignal.timeout(30000)});const data=await r.json();$('action-result').textContent=data.message||data.error;}catch(e){$('action-result').textContent='Keine Bestätigung erhalten. DNS-Status in DSM prüfen, bevor du erneut startest.';}finally{restarting=false;$('restart').disabled=demo||!canRestart;}};
refresh();setInterval(refresh,5000);
+10
View File
@@ -0,0 +1,10 @@
<!doctype html>
<html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>HOMELAB · DSM</title><link rel="stylesheet" href="/style.css"><script src="/app.js" defer></script></head>
<body><aside><a class="brand" href="/">▦ <span>HOMELAB<small>DEIN NETZWERK. EIN BLICK.</small></span></a><div class="nav-label">WORKSPACE</div><nav><a href="/" id="home-nav">⌂ &nbsp; Übersicht</a><a href="/dsm" id="dsm-nav">▤ &nbsp; DSM <span class="dot"></span></a></nav><div class="side-bottom"><span class="dot"></span> Lokales Dashboard<br><small>Synology DS1817+ · DSM 7.3.2<br>Konfigurierte Zielplattform</small></div></aside>
<main><header><span>Workspace <b>/</b> <span id="breadcrumb">Übersicht</span></span><span id="connection" class="badge">Verbinde …</span></header><div id="notice" role="status"></div><section id="login" hidden><form id="login-form"><label for="token">Zugriffsschlüssel für dein NAS</label><div class="login-row"><input id="token" type="password" autocomplete="off" required placeholder="HOMELAB-Zugriffsschlüssel"><button>Verbinden</button></div><small>Der Schlüssel bleibt nur für diese geöffnete Seite im Arbeitsspeicher.</small></form></section>
<section id="home"><div class="eyebrow">DEINE INFRASTRUKTUR</div><h1>Alles an einem Ort.</h1><p class="subtitle">Dein Homelab. Klar im Blick.</p><a class="service" href="/dsm"><div class="service-icon">▤</div><div><div class="eyebrow">STORAGE & SERVICES</div><h2>Synology DSM</h2><p>DS1817+ <span>·</span> DSM 7.3.2</p><div class="tags"><span>Netzwerk</span><span>Speicher</span><span>System</span></div></div><span class="arrow">↗</span></a><p class="quiet">Öffne DSM für Live-Messwerte, Laufwerkszustand und DNS-Verwaltung.</p></section>
<section id="dsm" hidden><div class="title-row"><div><div class="eyebrow">SYNOLOGY · DS1817+</div><h1>DiskStation</h1><p class="subtitle">System, Speicher und Netzwerk im Überblick.</p></div><div class="updated">Aktualisiert alle 5 Sekunden<br><span id="updated">Noch keine Daten</span></div></div><div class="metrics"><article><div class="card-label">CPU-AUSLASTUNG <span>◉</span></div><div class="value" id="cpu">—</div><progress id="cpu-bar" max="100" value="0"></progress><small>Aktuelle Prozessorauslastung</small></article><article><div class="card-label">ARBEITSSPEICHER <span>▥</span></div><div class="value" id="ram">—</div><progress id="ram-bar" max="100" value="0"></progress><small id="ram-detail">Noch keine Daten</small></article><article><div class="card-label">DOWNLOAD <span class="mint">↓</span></div><div class="value mint" id="download">—</div><canvas id="down-chart" width="300" height="48" aria-label="Download-Verlauf"></canvas><small>Summe physischer Netzwerkschnittstellen</small></article><article><div class="card-label">UPLOAD <span class="blue">↑</span></div><div class="value blue" id="upload">—</div><canvas id="up-chart" width="300" height="48" aria-label="Upload-Verlauf"></canvas><small>Summe physischer Netzwerkschnittstellen</small></article></div>
<div class="columns"><article><div class="section-head"><h2>Speicher</h2><span class="badge">Pools & Volumes</span></div><div id="storage"></div><p class="quiet">Pool: zugewiesener Speicher · Volume: belegter Speicher</p></article><article><div class="section-head"><h2>Netzwerk</h2><span class="badge">Schnittstellen</span></div><div id="network"></div></article></div>
<article class="disk-panel"><div class="section-head"><h2>Festplatten</h2><span class="badge">SMART</span></div><div class="table-wrap"><table><thead><tr><th>Laufwerk</th><th>Modell</th><th>SMART-Zustand</th><th>Temperatur</th></tr></thead><tbody id="disks"></tbody></table></div><p class="quiet" id="smart-age">SMART wird alle 60 Sekunden gelesen; schlafende Laufwerke werden nicht geweckt.</p></article>
<article class="dns"><div class="dns-icon">⌘</div><div><h2>DNS Server</h2><p id="dns-status">Status unbekannt</p></div><button id="restart" disabled>↻ &nbsp; DNS Server neu starten</button></article><p id="action-result" role="status"></p><p class="quiet">Netzwerkwerte zeigen den Datenverkehr des NAS, nicht den gesamten Internetanschluss.</p></section><footer>HOMELAB <span>Privat. Lokal. Unter deiner Kontrolle.</span></footer></main>
<dialog id="confirm"><h2>DNS Server neu starten?</h2><p>Die Namensauflösung kann dabei kurzzeitig ausfallen.</p><div class="dialog-buttons"><button id="cancel">Abbrechen</button><button id="confirm-restart">Jetzt neu starten</button></div></dialog></body></html>
File diff suppressed because one or more lines are too long
+27
View File
@@ -0,0 +1,27 @@
import importlib.util
from pathlib import Path
import unittest
spec = importlib.util.spec_from_file_location('server', Path(__file__).resolve().parents[1] / 'server.py')
server = importlib.util.module_from_spec(spec)
spec.loader.exec_module(server)
class SmartTests(unittest.TestCase):
def test_passed(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 0)['status'], 'OK')
def test_failed_command_is_not_healthy(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 2)['status'], 'Unbekannt')
def test_historical_errors_warn(self):
self.assertEqual(server.smart('SMART overall-health self-assessment test result: PASSED', 64)['status'], 'Warnung')
def test_sleeping_drive_unknown(self):
self.assertEqual(server.smart('Device is in STANDBY mode', 2)['status'], 'Unbekannt')
def test_temperature(self):
result = server.smart('194 Temperature_Celsius 0x0022 020 020 000 Old_age Always - 32 (Min/Max 19/42)', 0)
self.assertEqual(result['temperature'], 32)
if __name__ == '__main__':
unittest.main()
+170
View File
@@ -0,0 +1,170 @@
# Korrigierte Kopie: alle acht Optionen
Datei: `NDTrack-Geprueft.ps1`, Version **1.0.3** (2026-10-15). Das Original und die vorherige Fassung bleiben unverändert.
## Vor dem Einsatz
Auf dem Mac bearbeiten, auf einem Windows-Verwaltungsrechner mit Windows PowerShell 5.1 oder geeigneter Windows-PowerShell-Umgebung ausführen. AD-Zugriff und WinRM-Berechtigungen werden benötigt. Linux benötigt SSH und SCP im Suchpfad. Die bisherige RDS-Option ist nicht mehr im Menü; die alten Hilfsfunktionen bleiben unaufgerufen erhalten. Das Skript ändert keine Ausführungsrichtlinien oder Serverkonfigurationen.
Ablage auf dem ausführenden Windows-Verwaltungsrechner:
```text
C:\SCAN\SCRIPT\PreScript.ps1
C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
C:\SCAN\SCRIPT\Logs\
C:\SCAN\NDTRACK\RunNdTrackWindows_Local.cmd
C:\SCAN\NDTRACK\RunNdTrackLinuxUnix_Local.sh
C:\SCAN\RESULTS\
```
Das Skript vom Mac nach `C:\SCAN\SCRIPT` kopieren. Die vollständigen NDTrack-Pakete liegen unter `C:\SCAN\NDTRACK`; für Linux wird die SH-Datei nur bei Verwendung der Linux-Optionen benötigt. Bei gleichnamigen, unterschiedlichen Paketdateien separate Quellunterordner verwenden und die beiden Quellpfade entsprechend anpassen. Beim empfohlenen Start über das PreScript müssen SCRIPT-, NDTRACK-, RESULTS- und Logordner bereits vorhanden sein: Das PreScript prüft nur und legt nichts an. Das Hauptskript besitzt zusätzlich eine eigene Ordnerprüfung, die bei direktem Start fehlende Ordner anlegen kann. Existiert unter einem dieser Pfade eine Datei statt eines Ordners, wird abgebrochen. Anschließend muss NDTRACK mindestens eine Datei enthalten (Unterordner werden mit durchsucht); andernfalls endet das Skript vor dem Menü mit einem Hinweis zum Ablegen des Pakets. Vor der Windows- oder Linux-Verteilung wird zusätzlich geprüft, ob die jeweils benötigte CMD-/SH-Startdatei vorhanden und nicht leer ist. Die Prüfung bewertet nicht die Vollständigkeit oder Funktionsfähigkeit aller Paketdateien. Der ausführende Benutzer braucht dort Schreibrechte. Die Pfade sind jetzt bewusst unabhängig vom Benutzerprofil.
In `Initialize-Configuration` konfiguriert:
- `SourcePath`: `C:\SCAN\NDTRACK` mit dem vollständigen Windows-NDTrack-Paket.
- `LinuxSourcePath`: `C:\SCAN\NDTRACK` mit dem vollständigen Linux-Paket. Die Startdatei muss eine gültige Shebang und Unix-Zeilenenden besitzen. Benötigte Binärdateien müssen für das Zielsystem passen und ausführbar sein.
- `TestServers`: zunächst eigene Windows-Testserver eintragen. Leer verwendet die Windows-Option die Serverauswahl aus dem AD. Linux-Ziele kommen separat aus einer Textdatei mit einem DNS-Namen oder einer IPv4-Adresse pro Zeile; Leerzeilen und Zeilen mit führendem # werden ignoriert.
- `DestinationPath`: standardmäßig leer; Systemlaufwerk automatisch per WMI/DCOM. `ServerDestinationPaths` ist nur für optionale Ausnahmen. Option 1 kopiert wie im Original über administrative Freigaben. Option 2 verwendet Task-Scheduler-RPC und schtasks.exe; Optionen 3 und 7 verwenden weiterhin WinRM. Die Löschfunktion akzeptiert nur einen dedizierten Ordner mit dem Namen ndtrack.
- Die alten RDS-Hilfsfunktionen werden von keinem Menüpunkt aufgerufen. Option 8 ist ausschließlich das Aufräumen auf Linux.
Die CMD-/SH-Startdateien wurden nicht mitgeliefert. Sie müssen synchron bis zum Scan-Ende laufen, einen sinnvollen Exitcode zurückgeben und ihre Inventare unter dem jeweiligen ndtrack/inventory ablegen. Eine Startdatei, die einen Prozess nur im Hintergrund startet oder Fehler verschluckt, kann das übergeordnete Skript nicht zuverlässig bewerten.
## Ausführen
Empfohlener Start in Windows PowerShell über die Vorprüfung:
```powershell
Set-Location 'C:\SCAN\SCRIPT'
.\PreScript.ps1 -Platform Windows
```
1. Windows: NDTrack-Dateien auf die AD-Server kopieren. Startet keinen Scan.
2. Windows: Task NDTRACK mit dem eingegebenen Benutzerkonto über den ursprünglichen schtasks.exe-Aufruf erstellen. Einmaliger Start nach fünf Minuten, kein sofortiger /Run-Aufruf. CMD muss aus Option 1 vorhanden sein. Kein XML, kein SYSTEM, kein WinRM. Wie im Original überschreibt /F einen vorhandenen Task; nur bei nicht laufendem Scan verwenden.
3. Windows: vorhandene Scan-Dateien nach C:\SCAN\RESULTS holen. Aktive bzw. fehlerhafte Tasks verhindern das Einsammeln.
4. Linux: NDTrack-Dateien über SCP kopieren. Startet keinen Scan.
5. Linux: zuvor bereitgestellten Scan per SSH starten und auf Abschluss warten. Verwendet keinen Windows-Scheduled-Task.
6. Linux: vorhandene Scan-Dateien nach C:\SCAN\RESULTS holen.
7. Windows: Task NDTRACK stoppen/entfernen, danach den NDTrack-Ordner löschen. Bei Fehlern beim Entfernen des Tasks keine Dateilöschung.
8. Linux: NDTrack-Ordner entfernen, sofern keine Scan-Sperre oder erkannter laufender ndtrack-Prozess besteht.
0. Beenden.
Ergebnisse liegen unter `C:\SCAN\RESULTS`, Protokolle unter `C:\SCAN\SCRIPT\Logs` auf dem ausführenden Rechner. Das Task-Konto ist davon unabhängig. Auf den entfernten Windows-Servern wird standardmäßig `<Systemlaufwerk>\ndtrack` automatisch per WMI/DCOM ermittelt. Jede Sammlung erzeugt einen separaten Ordner und überschreibt keine vorherigen Sammlungen. Das Alter der gesammelten Inventardateien wird ausdrücklich nicht bewertet.
Eine `.ndtrack-running`-Sperre wird für direkte Scans angelegt und normalerweise entfernt. Nach einem Verbindungs-/Systemabbruch kann sie zurückbleiben. Erst den tatsächlichen Prozesszustand prüfen und dann eine verwaiste Sperre manuell entfernen. Extern gestartete Scans oder gleichzeitig gestartete Skriptinstanzen können nicht vollständig ausgeschlossen werden; das Skript bietet keine transaktionale Sperre über Verteilung, Task und Sammlung hinweg.
## Einsatz in unterschiedlichen AD-Domänen
Das Hauptskript enthält keine fest vorgegebene Kundendomäne. Bei leeren Werten für `TargetDomain` und `DomainController` verwendet es `USERDNSDOMAIN`, also die DNS-Domäne des ausführenden Windows-Benutzers. Die Suchbasis wird aus dem AD selbst ermittelt. Es werden aktivierte Windows-Server der ausgewählten Domäne über ihre vollständigen DNS-Hostnamen angesprochen. Es erfolgt keine automatische Suche über alle Domänen einer Gesamtstruktur.
Für eine andere Domäne in `Initialize-Configuration` setzen, zum Beispiel:
```powershell
$script:TargetDomain = 'firma.example'
$script:DomainController = ''
```
Optional einen bestimmten DC angeben:
```powershell
$script:TargetDomain = 'firma.example'
$script:DomainController = 'dc01.firma.example'
```
Die Namen sind Beispiele und müssen durch die tatsächlichen DNS-Namen ersetzt werden. Bei beiden Angaben prüft das Skript, ob der DC zur angegebenen Domäne gehört. Ohne automatisch erkennbare Benutzerdomäne und ohne explizite Konfiguration bricht die AD-Auswahl mit einem Hinweis ab. Eine explizite `TestServers`-Liste umgeht die AD-Suche.
AD-Abfrage und WinRM verwenden das aktuelle Windows-Konto. Option 2 fragt das Ausführungskonto für den Task ab; Remote-Verwaltung erfolgt weiterhin mit dem aktuell angemeldeten Windows-Konto. DNS, Netzwerkzugriff und Berechtigungen müssen in der Zieldomäne vorhanden sein. Bei nicht vertrauenswürdigen Domänen reicht die Angabe des Domänennamens allein nicht; das Skript richtet keine Vertrauensstellung oder alternative WinRM-Anmeldung ein. Es kann auf einem passend berechtigten Verwaltungsrechner der jeweiligen Domäne verwendet werden. Linux-Ziele bleiben unabhängig davon in der Textdatei definiert.
Sieben isolierte Tests der Domänenauswahl bestanden; echte domänenübergreifende AD-/WinRM-Verbindungen wurden nicht getestet. Test: `pwsh -NoProfile -File ./NDTrack/tests/Test-DomainSelection.ps1`.
## Dynamischer Zielpfad ohne WinRM beim Kopieren
`$script:DestinationPath = ''` ist die Standardeinstellung. Das Systemlaufwerk wird pro Windows-Zielserver aus `Win32_OperatingSystem.SystemDrive` über eine ausdrücklich auf DCOM eingestellte CIM-Verbindung ermittelt. Option 1 verwendet anschließend SMB für die Dateiübertragung:
| Systemlaufwerk des Servers | Lokaler Zielordner | Kopierfreigabe |
|---|---|---|
| C: | `C:\ndtrack` | `\\SERVER\C$\ndtrack` |
| D: | `D:\ndtrack` | `\\SERVER\D$\ndtrack` |
| E: | `E:\ndtrack` | `\\SERVER\E$\ndtrack` |
Für einen SQL-Server ohne C: mit Windows auf D: wird damit automatisch D:\ndtrack verwendet. Maßgeblich ist das Windows-Systemlaufwerk, nicht das SQL-Datenlaufwerk. Es muss keine Serverliste mit Laufwerkszuordnungen gepflegt werden. `ServerDestinationPaths` bleibt standardmäßig leer und dient ausschließlich optionalen Ausnahmen; ein expliziter DestinationPath überschreibt die automatische Ermittlung.
Voraussetzungen für Option 1: WMI/DCOM-Zugriff zur Laufwerksermittlung sowie Zugriff auf die administrative Freigabe mit dem aktuellen Windows-Konto. WinRM wird von Option 1 nicht verwendet. Ist die WMI-Abfrage oder die Freigabe nicht erreichbar, wird der Server mit einer Warnung übersprungen; das Skript rät kein Ersatzlaufwerk. Firewall-, DCOM- und Berechtigungseinstellungen werden nicht automatisch verändert.
Der Zielordner wird über die Freigabe angelegt. Eine vorhandene Scan-Sperre verhindert das Kopieren; der Task-Zustand wird hier nicht per WinRM geprüft. Option 1 nur ausführen, wenn kein Scan läuft. Option 2 verwendet ebenfalls kein WinRM mehr: ursprünglicher schtasks.exe /Create-Aufruf mit Benutzerkonto und einmaligem Start nach fünf Minuten. Optionen 3 und 7 verwenden weiterhin WinRM. Alle verwenden denselben ermittelten Zielpfad.
Die CMD-Datei muss ohne fest eingebautes C:\ndtrack funktionieren. Ihre internen Pfade wurden nicht geprüft. Die festen C:\SCAN-Pfade gelten ausschließlich für den Verwaltungsrechner. Alte Installationen werden nicht automatisch migriert.
Die simulierten Tests decken unterschiedliche Laufwerke, fehlende Freigaben, WMI-Fehler und das Schließen der CIM-Verbindungen ab. Ein echter Zielservertest steht aus; der zuvor gemeldete Anmeldefehler ist damit noch nicht nachweislich behoben.
## Prüfung und Grenzen
- PowerShell-Syntax geprüft.
- Alle acht Menüabläufe isoliert getestet.
- Geprüft: getrennte Menüaktionen für Kopieren, Starten und Einsammeln; Task-Entfernung vor Dateilöschung; native Exitcodes; Task-Aufruf ohne Kontoabfrage; Standardzielpfad und explizite Zielpfade pro Server; Ablehnung ungültiger Hostnamen/Pfadsegmente.
- Fehlerpfade mit simulierten Remote-/SSH-Fehlern geprüft: Warnung statt falscher Erfolgsmeldung.
- Aktuelle Menü-/Fehlerprüfungen: 41 bestanden. Zusätzlich 4 simulierte Task-Start-Szenarien für schtasks.exe bestanden. Ordner-/Datei- und PreScript-Tests liegen separat vor.
- Keine echten AD-, Windows-, RDS- oder Linux-Zielsysteme getestet. Die Tests ersetzen keinen Abnahmelauf mit den tatsächlichen NDTrack-Dateien.
Tests auf Mac oder Windows mit PowerShell:
```powershell
pwsh -NoProfile -File ./NDTrack/tests/Test-NDTrack.ps1
pwsh -NoProfile -File ./NDTrack/tests/Test-SourceFolders.ps1
```
Der Befehl gilt aus dem Repository-Hauptordner. Die Tests führen ausschließlich lokale PowerShell-Kindprozesse und Simulationen aus; keine Zielserverzugriffe.
## Git im bestehenden Repository
```bash
cd '/Users/michaeltroebs/Documents/GIT/syno-scripts'
git status --short
git add NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
git diff --cached -- NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
git commit -m "NDTrack: alle acht Ablaeufe und Fehlerbehandlung korrigieren" -- NDTrack/NDTrack-Geprueft.ps1 NDTrack/ANLEITUNG-Geprueft.md NDTrack/tests/Test-NDTrack.ps1 NDTrack/tests/Test-SourceFolders.ps1
```
Es wurde von Codex nichts vorgemerkt, committed oder hochgeladen.
## Separates PreScript
`PreScript.ps1` prüft ausschließlich vorhandene Ordner und Dateien. Es legt keine Ordner an und kopiert keine Dateien. Vorab bereitstellen:
- `C:\SCAN\SCRIPT` mit PreScript.ps1 und NDTrack-Geprueft.ps1
- `C:\SCAN\SCRIPT\Logs`
- `C:\SCAN\NDTRACK` mit dem vollständigen NDTrack-Paket
- `C:\SCAN\RESULTS`
```powershell
Set-Location 'C:\SCAN\SCRIPT'
.\PreScript.ps1 -Platform Windows
```
Für beide Pakete `-Platform Both`, für Linux `-Platform Linux`. Bei erfolgreicher Prüfung startet das PreScript automatisch das Hauptskript und damit dessen Menü. Eine Scan-Option wird nicht automatisch ausgewählt. Bei fehlenden Ordnern, fehlenden Dateien, leeren Startdateien oder Syntaxfehlern im Hauptskript wird abgebrochen; das Hauptskript startet nicht.
Die Prüfung bestätigt nicht die vollständige Paketintegrität oder die Erreichbarkeit der Zielserver. Das gestartete Hauptskript besitzt weiterhin seine eigenen Prüfungen und führt erst nach der Menüauswahl die entsprechende Aktion aus.
`-BasePath` dient isolierten Tests und ändert nicht die Konfiguration des Hauptskripts. Sechs Szenarien wurden mit temporären Dateien und einem harmlosen Test-Hauptskript erfolgreich geprüft, einschließlich automatischem Start und Verzicht auf Ordneranlage:
```powershell
pwsh -NoProfile -File ./NDTrack/tests/Test-PreScript.ps1
```
Zusätzliche Dateien für Git: `NDTrack/PreScript.ps1` und `NDTrack/tests/Test-PreScript.ps1`.
Nach Umstieg wird ausschließlich der Task NDTRACK verwendet. Ein alter Task NDTrackTask aus einer früheren Version wird nicht automatisch migriert oder entfernt.
Task-Start-Test: `pwsh -NoProfile -File ./NDTrack/tests/Test-TaskStart.ps1`. Auch diese Tests verwenden keine echten Server.
SMB-Kopiertest: `pwsh -NoProfile -File ./NDTrack/tests/Test-SmbCopy.ps1` (simulierte Freigaben, keine Serverzugriffe).
## Version 1.0.3: ursprüngliche Task-Erstellung wiederhergestellt
Option 2 verwendet wieder /Create /S /TN /TR /SC Once /ST /RU /RP /RL HIGHEST /F wie das Original. Taskname NDTRACK, dynamischer Zielpfad und Exitcode-Prüfung bleiben erhalten. Benutzerkonto und Kennwort werden wieder abgefragt. Der Start erfolgt nach fünf Minuten; es gibt keinen zusätzlichen Sofortstart. Die Zeit wird auf dem Verwaltungsrechner berechnet und auf dem Zielserver als lokale Uhrzeit verwendet; gleiche Zeitzone und synchronisierte Uhren werden vorausgesetzt. Bei Überschreiten der Tagesgrenze wird vor Erstellung abgebrochen; nach Mitternacht erneut ausführen.
Kein XML und kein SYSTEM-Konto. Wie im Original wird kein Arbeitsverzeichnis in der Taskdefinition gesetzt. Die CMD muss selbst in ihren Ordner wechseln oder absolute Pfade verwenden. Ein vorhandener Task wird mit /F überschrieben; eine zusätzliche Remote-Zustandsabfrage ist nicht mehr vorgeschaltet. Option 2 daher nicht während eines laufenden Scans erneut ausführen.
Die CMD wird vorab über SMB auf Vorhandensein geprüft. Das Kennwort wird wie im Original als /RP-Argument übergeben. RPC-Taskverwaltung und das verwendete Task-Konto benötigen weiterhin die passenden Rechte. Die Rückkehr zum Originalaufruf ist keine bestätigte Behebung des Anmeldesitzungsfehlers; hierfür ist der Test auf deinen Windows-Servern erforderlich.
41 Ablauf-/Fehlerprüfungen und vier Task-Szenarien bestanden. Option 1 und PreScript unverändert.
+178
View File
@@ -0,0 +1,178 @@
--- Original/NDTrack.ps1
+++ Angepasst/NDTrack.ps1
@@ -1,14 +1,17 @@
# =========================
# Konfigurationsparameter
# =========================
-$global:SourcePath = "$env:USERPROFILE\Documents\Windows" # Pfad zur Quelldatei die verteilt werden soll
+$DocumentsPath = [Environment]::GetFolderPath('MyDocuments')
+$global:SourcePath = Join-Path $DocumentsPath 'Windows'
$global:DestinationPath = "C:\ndtrack" # Zielpfad auf den Remote Servern
$global:DestinationPath_RDS = "\RDSFIXV001\workfolders$\$env:USERPROFILE\Documents\windows"
$global:TaskName = "NDTrackTask"
#$global:TestServers = "GARRDSV003","GARRDSV002"
-$global:Dest_folder = "\\$f_server\c$\ndtrack"
-$global:logfile= "$env:USERPROFILES\Documents\"
-$global:Ergebnisordner= "$env:USERPROFILES\Documents\Ergebnisse"
+$global:logfile = Join-Path $DocumentsPath 'NDTrack-Logs'
+$global:Ergebnisordner = Join-Path $DocumentsPath 'Ergebnisse'
+
+New-Item -Path $logfile, $Ergebnisordner -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
Import-Module RemoteDesktop
@@ -31,7 +34,8 @@
Write-Host "Option 7: NDTRACK von Systemen entfernen. (Linux|Textdatei)"
Write-Host "Option 8: RDS Server mittels NDTRACK scannen"
Write-Host "==============================================================================="
- $f_Choice = Read-Host -Prompt "Auswahl Variante (1-8)"
+ Write-Host "Option 0: Beenden"
+ $f_Choice = Read-Host -Prompt "Auswahl Variante (0-8)"
Write-Host
return $f_Choice
@@ -81,22 +85,22 @@
try{
# Zielordner prüfen
- Invoke-Command -ComputerName $f_Server -ScriptBlock {
- param($Dest_folder) # Anpassung an wirklichen Ordner
-
- #$a = !(Test-Path "\\$f_Server\c$") # TRUE, ohne ! immer false $f_Server anstatt $DestinationPath, asonsten keine valide Abfrage
- #write-host $a # Ausgabe zur kontrolle
-
- if ((Test-Path "\\$f_Server\c$")){
- New-Item -Path $DestinationPath -ItemType Directory #-Force #unbedingtes Schreiben ausgeschaltet
- }
- } -ArgumentList $DestinationPath
-
- #Datei auf Remote Server kopieren
- Copy-Item -Path "$SourcePath\*" -Destination "\\$f_Server\c$\ndtrack" -Recurse -Force # Schleife für das Abfange der Meldungen
+ $RemoteFolder = "\\$f_Server\c$\ndtrack"
+
+ if (-not (Test-Path -LiteralPath "$SourcePath\RunNdTrackWindows_Local.cmd" `
+ -PathType Leaf -ErrorAction Stop)) {
+ throw "Startdatei fehlt in $SourcePath."
+ }
+
+ New-Item -Path $RemoteFolder -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
+
+ Copy-Item -Path "$SourcePath\*" -Destination $RemoteFolder `
+ -Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
+ Write-Output $f_Server
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red
write-host $Error}
@@ -112,7 +116,34 @@
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
- schtasks.exe /Create /S $f_Server /TN $TaskName /TR "$DestinationPath\RunNdTrackWindows_Local.cmd" /SC "Once" /ST (Get-Date).AddMinutes(5).ToShortTimeString() /RU $User /RP $Password /RL "HIGHEST" /F
+ Invoke-Command -ComputerName $f_Server -ScriptBlock {
+ param($DestinationPath, $TaskName, [pscredential]$Credential)
+
+ $ErrorActionPreference = 'Stop'
+ $CmdPath = Join-Path $DestinationPath 'RunNdTrackWindows_Local.cmd'
+
+ if (-not (Test-Path -LiteralPath $CmdPath -PathType Leaf)) {
+ throw "Startdatei fehlt: $CmdPath"
+ }
+
+ $Action = New-ScheduledTaskAction `
+ -Execute "$env:SystemRoot\System32\cmd.exe" `
+ -Argument ('/d /s /c ""{0}""' -f $CmdPath) `
+ -WorkingDirectory $DestinationPath
+
+ $Trigger = New-ScheduledTaskTrigger `
+ -Once -At (Get-Date).AddMinutes(5)
+
+ $Settings = New-ScheduledTaskSettingsSet -StartWhenAvailable
+
+ Register-ScheduledTask -TaskName $TaskName `
+ -Action $Action -Trigger $Trigger -Settings $Settings `
+ -User $Credential.UserName `
+ -Password $Credential.GetNetworkCredential().Password `
+ -RunLevel Highest -Force | Out-Null
+
+ } -ArgumentList $DestinationPath, $TaskName, $ServiceAccount `
+ -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
@@ -213,18 +244,28 @@
try{
# Zielordner prüfen
- Invoke-Command -ComputerName $f_Server -ScriptBlock {
- param($Dest_folder) #Dest_folder=\\$f_server\c$\ndtrack
-
- if (Test-Path $Dest_folder) {
- Write-Host "Es wurde kein Inventory Ordner gefunden." -ForegroundColor Red
-
- }
- } -ArgumentList $Dest_folder
-
- # Datei vom Remote Server kopieren
- #Copy-Item -Path "\\$f_Server\c$\ndtrack\inventory\*" -Destination "$SourcePath\Result" -Recurse -Force
- Copy-Item -Path "\\$f_Server\c$\ndtrack\inventory\*" -Destination "c:\\users\qsadmin03\Documents\Ergebnisse" -Recurse -Force -PassThru #| Out-File -FilePath "$Source_Path\Result.txt" -Append
+ $InventoryPath = "\\$f_Server\c$\ndtrack\inventory"
+ $TargetPath = Join-Path $Ergebnisordner $f_Server
+
+ if (-not (Test-Path -LiteralPath $InventoryPath `
+ -PathType Container -ErrorAction Stop)) {
+ Write-Warning "${f_Server}: Kein Inventory-Ordner gefunden."
+ continue
+ }
+
+ $Files = @(Get-ChildItem -LiteralPath $InventoryPath `
+ -File -Recurse -ErrorAction Stop)
+
+ if ($Files.Count -eq 0) {
+ Write-Warning "${f_Server}: Keine Inventardateien vorhanden."
+ continue
+ }
+
+ New-Item -Path $TargetPath -ItemType Directory `
+ -Force -ErrorAction Stop | Out-Null
+
+ Copy-Item -Path "$InventoryPath\*" -Destination $TargetPath `
+ -Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server Ergebnis geholt." -ForegroundColor Green
@@ -404,13 +445,14 @@
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
$ServiceAccount = Get-Credential -Message "User für Scheduled Task eingeben"
- $User = $ServiceAccount.UserName
- $Password = $ServiceAccount.GetNetworkCredential().Password
$AllServers = GetADServer
#$AllServers = $TestServers
- CopyFile $AllServers
- CreateScheduledTask $AllServers
+ $CopiedServers = @(CopyFile $AllServers)
+
+ if ($CopiedServers.Count -gt 0) {
+ CreateScheduledTask $CopiedServers
+ }
Stop-Transcript
} # Windows|AD Scheduled Task
@@ -470,9 +512,11 @@
Stop-Transcript
} # RDS|Textdatei löschen
+ 0 { }
+
default {
Write-Host "Das war wohl nix... Bitte versuche es erneut!" -ForegroundColor Red
Start-Sleep 2
}
}
-} while ($Choice -notin (1,2,3,4,5,6,7))+} while ($Choice -ne '0')
+464
View File
@@ -0,0 +1,464 @@
#Requires -Version 5.1
# Skriptversion: 1.0.3
# Versionsstand: 2026-10-15
<#
Korrigierte Kopie auf Basis des Originalskripts, mit denselben acht Optionen.
Windows-Verwaltungsrechner erforderlich. Die CMD-/SH-Dateien werden separat geliefert.
-LibraryOnly laedt nur Funktionen fuer isolierte Tests; fuehrt keine Aktionen aus.
#>
[CmdletBinding()]
param([switch]$LibraryOnly)
function Initialize-Configuration {
# Ablage auf dem ausfuehrenden Windows-Verwaltungsrechner:
# C:\SCAN\SCRIPT\NDTrack-Geprueft.ps1
$script:ScriptFolder = 'C:\SCAN\SCRIPT'
$script:SourcePath = 'C:\SCAN\NDTRACK'
$script:LinuxSourcePath = 'C:\SCAN\NDTRACK'
$script:DestinationPath = '' # Leer = Systemlaufwerk automatisch per WMI/DCOM ermitteln
$script:ServerDestinationPaths = @{} # Optional: @{ 'sql01.firma.example' = 'D:\ndtrack' }
$script:TaskName = 'NDTRACK'
$script:WindowsLauncher = 'RunNdTrackWindows_Local.cmd'
$script:LinuxLauncher = 'RunNdTrackLinuxUnix_Local.sh'
$script:Ergebnisordner = 'C:\SCAN\RESULTS'
$script:LogFolder = 'C:\SCAN\SCRIPT\Logs'
$script:TargetDomain = '' # Leer = DNS-Domaene des angemeldeten Benutzers
$script:DomainController = '' # Optional: FQDN eines DCs der Zieldomaene
$script:TestServers = @() # Zum Test z.B. @('GARRDSV003'); leer = AD/RDS
$script:RDSConnectionBroker = '' # Leer: wird bei Option 8 abgefragt
# Option 8 verwendet einen VOLLSTAENDIGEN, auf den RDS-Servern erreichbaren CMD-Pfad.
# Bei UNC-Pfaden muss der Remote-Ausfuehrungskontext Zugriff auf die Freigabe haben.
$script:RDSLauncherPath = '' # Kein Freigabepfad wird geraten.
}
function ShowMenu {
Write-Host @'
NDTRACK - Version 1.0.3 (Stand: 2026-10-15)
1: Windows - NDTrack-Dateien auf Server kopieren
2: Windows - Task NDTRACK mit Benutzerkonto erstellen (Start in 5 Minuten)
3: Windows - Scan-Dateien von Servern holen
4: Linux - NDTrack-Dateien auf Server kopieren
5: Linux - Scan per SSH starten
6: Linux - Scan-Dateien von Servern holen
7: Windows - aufraeumen (Task und NDTrack entfernen)
8: Linux - aufraeumen (NDTrack entfernen)
0: Beenden
'@
Read-Host 'Auswahl (0-8)'
}
function Assert-ServerName {
param([string]$Name)
if ($Name -notmatch '^[A-Za-z0-9][A-Za-z0-9.-]*$') {
throw "Ungueltiger Servername: $Name (DNS-Name oder IPv4 verwenden)."
}
}
function Get-DirectoryEndpoint {
# Keine kundenspezifischen Domain-DNs oder Servernamen.
if ($script:DomainController) {
Assert-ServerName $script:DomainController
return $script:DomainController
}
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
return $script:TargetDomain
}
if ($env:USERDNSDOMAIN) {
Assert-ServerName $env:USERDNSDOMAIN
return $env:USERDNSDOMAIN
}
throw 'Keine Benutzerdomaene ermittelbar. TargetDomain oder DomainController konfigurieren oder TestServers mit expliziten Zielservern fuellen.'
}
function GetADServer {
if ($script:TestServers.Count) {
foreach ($server in $script:TestServers) { Assert-ServerName $server }
return $script:TestServers | Sort-Object -Unique
}
$endpoint = Get-DirectoryEndpoint
$root = $null; $entry = $null; $searcher = $null; $results = $null
try {
$root = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$endpoint/RootDSE")
$namingContext = [string]$root.Properties['defaultNamingContext'].Value
$dc = [string]$root.Properties['dnsHostName'].Value
if (-not $namingContext -or -not $dc) { throw 'RootDSE liefert keine AD-Domaene bzw. keinen DC.' }
Assert-ServerName $dc
# Optionalen DC auf Zugehoerigkeit zur expliziten Zieldomaene pruefen.
if ($script:TargetDomain) {
Assert-ServerName $script:TargetDomain
$expected = ($script:TargetDomain.TrimEnd('.').Split('.') | ForEach-Object { 'DC=' + $_ }) -join ','
if ($namingContext -ine $expected) { throw "DC gehoert zu $namingContext, erwartet wurde $expected." }
}
Write-Host "AD-AUSWAHL: $namingContext ueber $dc (aktuelles Windows-Konto)."
$entry = New-Object System.DirectoryServices.DirectoryEntry("LDAP://$dc/$namingContext")
$searcher = New-Object System.DirectoryServices.DirectorySearcher($entry)
$searcher.Filter = '(&(objectCategory=computer)(operatingSystem=*Server*)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))'
$searcher.PageSize = 1000
[void]$searcher.PropertiesToLoad.Add('dnshostname')
[void]$searcher.PropertiesToLoad.Add('name')
$results = $searcher.FindAll()
$servers = @($results | ForEach-Object {
if ($_.Properties['dnshostname'].Count) {
$name = [string]$_.Properties['dnshostname'][0]
Assert-ServerName $name
$name
} else {
Write-Warning "AD-Computer $($_.Properties['name'][0]) ohne DNS-Hostnamen wird uebersprungen."
}
} | Sort-Object -Unique)
if (-not $servers.Count) { throw 'Keine aktivierten Windows-Server mit DNS-Hostnamen gefunden.' }
$servers
}
catch { throw "AD-Abfrage fuer '$endpoint' fehlgeschlagen: $($_.Exception.Message)" }
finally {
if ($null -ne $results) { $results.Dispose() }
if ($null -ne $searcher) { $searcher.Dispose() }
if ($null -ne $entry) { $entry.Dispose() }
if ($null -ne $root) { $root.Dispose() }
}
}
function GetRDSServer {
if ($script:TestServers.Count) { return $script:TestServers }
Import-Module RemoteDesktop -ErrorAction Stop
if (-not $script:RDSConnectionBroker) { $script:RDSConnectionBroker = Read-Host 'RDS Connection Broker (FQDN)' }
Assert-ServerName $script:RDSConnectionBroker
Get-RDServer -ConnectionBroker $script:RDSConnectionBroker -Role 'RDS-RD-SERVER' -ErrorAction Stop |
Select-Object -ExpandProperty Server -Unique
}
function GetLinuxServer {
$path = Read-Host 'Vollstaendiger Pfad zur Linux-Serverliste'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "Serverliste nicht gefunden: $path" }
$names = @(Get-Content -LiteralPath $path -ErrorAction Stop | ForEach-Object { $_.Trim() } |
Where-Object { $_ -and -not $_.StartsWith('#') } | Sort-Object -Unique)
foreach ($name in $names) { Assert-ServerName $name }
$names
}
function Resolve-WindowsFolder {
param([string]$Server)
Assert-ServerName $Server
$folder = $script:DestinationPath
$overrides = Get-Variable -Name ServerDestinationPaths -Scope Script -ErrorAction SilentlyContinue
if ($overrides -and $overrides.Value.ContainsKey($Server)) { $folder = $overrides.Value[$Server] }
if (-not $folder) {
$cimSession = $null
try {
$options = New-CimSessionOption -Protocol Dcom -ErrorAction Stop
$cimSession = New-CimSession -ComputerName $Server -SessionOption $options -ErrorAction Stop
$os = Get-CimInstance -CimSession $cimSession -ClassName Win32_OperatingSystem -Property SystemDrive -ErrorAction Stop
$drive = [string]$os.SystemDrive
if ($drive -notmatch '^[A-Za-z]:$') { throw 'Kein gueltiges Systemlaufwerk vom Zielserver erhalten.' }
$folder = $drive + '\ndtrack'
} catch {
throw "Systemlaufwerk von '$Server' konnte per WMI/DCOM nicht ermittelt werden: $($_.Exception.Message)"
} finally {
if ($null -ne $cimSession) { Remove-CimSession -CimSession $cimSession -ErrorAction SilentlyContinue }
}
}
if ($folder -notmatch '^[A-Za-z]:\\[^"\r\n]+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)') { throw 'Ungueltiger lokaler NDTrack-Zielpfad.' }
$folder.TrimEnd('\')
}
function Get-WindowsSharePath {
param([string]$Server)
$folder = Resolve-WindowsFolder $Server
'\\{0}\{1}$\{2}' -f $Server,$folder.Substring(0,1),$folder.Substring(3)
}
function CheckDirectory {
$paths = @($script:ScriptFolder,$script:SourcePath,$script:LinuxSourcePath,
$script:Ergebnisordner,$script:LogFolder) | Select-Object -Unique
foreach ($path in $paths) {
if (Test-Path -LiteralPath $path -ErrorAction Stop) {
if (-not (Test-Path -LiteralPath $path -PathType Container -ErrorAction Stop)) {
throw "Pfad ist eine Datei statt eines Ordners: $path"
}
Write-Host "ORDNER VORHANDEN: $path"
} else {
New-Item -Path $path -ItemType Directory -Force -ErrorAction Stop | Out-Null
Write-Host "ORDNER ANGELEGT: $path"
}
}
}
function Test-SourceFiles {
param([string]$Path,[string]$Launcher)
if (-not (Test-Path -LiteralPath $Path -PathType Container -ErrorAction Stop)) {
throw "Quellordner fehlt: $Path"
}
$files = @(Get-ChildItem -LiteralPath $Path -File -Recurse -Force -ErrorAction Stop)
if ($files.Count -eq 0) {
throw "Keine Dateien in $Path gefunden. Bitte das vollstaendige NDTrack-Paket dort ablegen und das Skript erneut starten. Leere Unterordner reichen nicht aus."
}
if ($Launcher) {
$launcherPath = Join-Path $Path $Launcher
if (-not (Test-Path -LiteralPath $launcherPath -PathType Leaf -ErrorAction Stop)) {
throw "Benoetigte Startdatei fehlt: $launcherPath"
}
if ((Get-Item -LiteralPath $launcherPath -ErrorAction Stop).Length -eq 0) {
throw "Startdatei ist leer: $launcherPath"
}
}
Write-Host "QUELLE GEPRUEFT: $Path - $($files.Count) Datei(en) vorhanden."
}
function CopyFile {
param([string[]]$Servers)
Test-SourceFiles -Path $script:SourcePath -Launcher $script:WindowsLauncher
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
$remote = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$share = '\\{0}\{1}$' -f $server,$folder.Substring(0,1)
if (-not (Test-Path -LiteralPath $share -PathType Container -ErrorAction Stop)) {
throw "Freigabe nicht erreichbar: $share. Laufwerk, Freigabe und Berechtigungen pruefen."
}
if (Test-Path -LiteralPath ($remote + '\.ndtrack-running') -ErrorAction Stop) {
throw 'Scan-Sperre vorhanden; laufenden Scan bzw. verwaiste Sperre pruefen.'
}
New-Item -Path $remote -ItemType Directory -Force -ErrorAction Stop | Out-Null
Get-ChildItem -LiteralPath $script:SourcePath -Force -ErrorAction Stop |
Where-Object { $_.Name -notin @('inventory','Result','Ergebnisse','.ndtrack-running') } |
Copy-Item -Destination $remote -Recurse -Force -ErrorAction Stop
Write-Host "KOPIERT: $server -> $remote"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function CreateScheduledTask {
param([string[]]$Servers,[pscredential]$Credential)
if ($null -eq $Credential) { throw 'Kein Task-Konto angegeben.' }
foreach ($server in $Servers) {
$stage = 'Zielpfad ermitteln'
try {
$folder = Resolve-WindowsFolder $server
$share = '\\{0}\{1}$\{2}' -f $server,$folder.Substring(0,1),$folder.Substring(3)
$stage = 'CMD ueber SMB pruefen'
if (-not (Test-Path -LiteralPath ($share + '\' + $script:WindowsLauncher) -PathType Leaf -ErrorAction Stop)) { throw 'CMD fehlt; zuerst Option 1 ausfuehren.' }
$stage = 'Startzeit berechnen'
$now = Get-Date
$start = $now.AddMinutes(5)
if ($start.Date -ne $now.Date) { throw 'Startzeit liegt am Folgetag. Option 2 nach Mitternacht erneut ausfuehren.' }
$stage = 'Task mit urspruenglichem schtasks-Aufruf erstellen'
# Originalablauf: Benutzerkonto, einmaliger Start nach fuenf Minuten.
# Kein XML, kein SYSTEM, kein WinRM und kein zusaetzlicher /Run-Aufruf.
Invoke-NativeChecked 'schtasks.exe' @(
'/Create','/S',$server,'/TN',$script:TaskName,
'/TR',($folder + '\' + $script:WindowsLauncher),
'/SC','Once','/ST',$start.ToString('HH:mm'),
'/RU',$Credential.UserName,'/RP',$Credential.GetNetworkCredential().Password,
'/RL','HIGHEST','/F'
)
Write-Host "GEPLANT: $server - Task $script:TaskName fuer $($start.ToString('HH:mm')) erstellt. Scan-Abschluss noch nicht bestaetigt."
} catch { Write-Warning "${server}: $stage fehlgeschlagen: $($_.Exception.Message)" }
}
}
function Invoke-WindowsScan {
param([string[]]$Servers,[string]$LauncherPath)
foreach ($server in $Servers) {
try {
Assert-ServerName $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($path)
$ErrorActionPreference = 'Stop'
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) { throw "CMD nicht erreichbar: $path" }
$folder = Split-Path -Parent $path
$lock = Join-Path $folder '.ndtrack-running'
New-Item -Path $lock -ItemType Directory -ErrorAction Stop | Out-Null
try {
$process = Start-Process -FilePath "$env:SystemRoot\System32\cmd.exe" -ArgumentList ('/d /s /c ""{0}""' -f $path) -WorkingDirectory $folder -Wait -PassThru -NoNewWindow -ErrorAction Stop
if ($process.ExitCode -ne 0) { throw "CMD-Exitcode: $($process.ExitCode)" }
} finally { Remove-Item -LiteralPath $lock -Force -ErrorAction Stop }
} -ArgumentList $LauncherPath
Write-Host "BEENDET: $server - CMD-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotely {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-WindowsScan @($server) ($folder + '\' + $script:WindowsLauncher)
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Scan_RDS_SINA {
param([string[]]$Servers)
if (-not $script:RDSLauncherPath) { $script:RDSLauncherPath = Read-Host 'Vollstaendiger CMD-Pfad auf den RDS-Servern (lokal oder UNC)' }
if ($script:RDSLauncherPath -notmatch '^(?:[A-Za-z]:\\|\\\\).+\.cmd$' -or $script:RDSLauncherPath.Contains('"')) { throw 'Gueltigen absoluten RDS-CMD-Pfad konfigurieren.' }
Invoke-WindowsScan $Servers $script:RDSLauncherPath
}
function GetInventoryFiles {
param([string[]]$Servers)
$batch = Join-Path $script:Ergebnisordner ('Windows-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
$session = $null
try {
$remote = Resolve-WindowsFolder $server
$session = New-PSSession -ComputerName $server -ErrorAction Stop
Invoke-Command -Session $session -ErrorAction Stop -ScriptBlock {
param($folder,$name)
$ErrorActionPreference = 'Stop'
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Scan laeuft oder Sperre ist verwaist.' }
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
$info = Get-ScheduledTaskInfo -TaskName $name -TaskPath '\'
if ($task.State -in @('Running','Queued') -or $info.LastTaskResult -ne 0 -or $info.NextRunTime -gt (Get-Date)) { throw 'Task noch ausstehend/aktiv oder letzter Lauf fehlerhaft.' }
}
$inventory = Join-Path $folder 'inventory'
$files = @(Get-ChildItem -LiteralPath $inventory -File -Recurse)
if (-not $files.Count) { throw 'Keine Inventardateien vorhanden.' }
} -ArgumentList $remote,$script:TaskName
$inventory = $remote + '\inventory'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$inventory\*" -FromSession $session -Destination $target -Recurse -Force -ErrorAction Stop
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
finally { if ($null -ne $session) { Remove-PSSession -Session $session } }
}
}
function DeleteScheduledTask {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($name)
$ErrorActionPreference = 'Stop'
$task = Get-ScheduledTask | Where-Object { $_.TaskName -eq $name -and $_.TaskPath -eq '\' }
if ($task) {
Disable-ScheduledTask -TaskName $name -TaskPath '\' | Out-Null
Stop-ScheduledTask -TaskName $name -TaskPath '\'
$deadline = (Get-Date).AddSeconds(30)
do {
$state = (Get-ScheduledTask -TaskName $name -TaskPath '\').State
if ($state -notin @('Running','Queued')) { break }
Start-Sleep -Milliseconds 500
} while ((Get-Date) -lt $deadline)
if ($state -in @('Running','Queued')) { throw 'Task konnte nicht gestoppt werden.' }
Unregister-ScheduledTask -TaskName $name -TaskPath '\' -Confirm:$false
}
} -ArgumentList $script:TaskName
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFile {
param([string[]]$Servers)
foreach ($server in $Servers) {
try {
$folder = Resolve-WindowsFolder $server
Invoke-Command -ComputerName $server -ErrorAction Stop -ScriptBlock {
param($folder)
$ErrorActionPreference = 'Stop'
# Nur den dedizierten NDTrack-Ordner entfernen.
if ($folder.TrimEnd('\') -notmatch '^[A-Za-z]:\\.+$' -or $folder -match '(?:^|\\)\.\.?(?:\\|$)' -or (Split-Path $folder.TrimEnd('\') -Leaf) -ne 'ndtrack') { throw 'Loeschen nur fuer einen dedizierten ndtrack-Ordner erlaubt.' }
if (Test-Path -LiteralPath (Join-Path $folder '.ndtrack-running')) { throw 'Direkter Scan aktiv oder Sperre verwaist.' }
$processes = @(Get-CimInstance Win32_Process -Filter "Name = 'ndtrack.exe'")
foreach ($process in $processes) {
if (-not $process.ExecutablePath -or $process.ExecutablePath.StartsWith($folder.TrimEnd('\')+'\',[StringComparison]::OrdinalIgnoreCase)) { throw 'NDTrack-Prozess noch aktiv; keine Dateien geloescht.' }
}
if (Test-Path -LiteralPath $folder) { Remove-Item -LiteralPath $folder -Recurse -Force }
} -ArgumentList $folder
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
# Native Programme: Exitcode immer direkt pruefen.
function Invoke-NativeChecked {
param([string]$Program,[string[]]$Arguments)
& $Program @Arguments | Out-Host
if ($LASTEXITCODE -ne 0) { throw "$Program fehlgeschlagen (Exitcode $LASTEXITCODE)." }
}
function Get-LinuxUser {
$userName = Read-Host 'Linux-SSH-Benutzer (z.B. scanuser; kein Windows-Domaenenformat)'
if ($userName -notmatch '^[a-zA-Z_][a-zA-Z0-9_.-]*[$]?$') { throw 'Ungueltiger Linux-Benutzername.' }
$userName
}
function Invoke-LinuxCommand {
param([string]$Server,[string]$User,[string]$Command)
Assert-ServerName $Server
Invoke-NativeChecked 'ssh' @('-o','ConnectTimeout=15','-l',$User,$Server,$Command)
}
function CopyFileLinux {
param([string[]]$Servers,[string]$User)
Test-SourceFiles -Path $script:LinuxSourcePath -Launcher $script:LinuxLauncher
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && mkdir -p "$HOME/ndtrack"'
$items = @(Get-ChildItem -LiteralPath $script:LinuxSourcePath -Force -ErrorAction Stop | Where-Object { $_.Name -notin @('inventory','.ndtrack-running') })
foreach ($item in $items) { Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',$item.FullName,"${User}@${server}:ndtrack/") }
Write-Host "KOPIERT: $server"
$server
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function RunNDTRACKRemotelyLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Interpreter aus der Shebang verwenden; Startdatei muss synchron laufen.
$command = 'cd "$HOME/ndtrack" && mkdir .ndtrack-running && { trap ''rmdir "$HOME/ndtrack/.ndtrack-running"'' EXIT; chmod u+x ./RunNdTrackLinuxUnix_Local.sh && ./RunNdTrackLinuxUnix_Local.sh; }'
Invoke-LinuxCommand $server $User $command
Write-Host "BEENDET: $server - SH-Exitcode 0."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function GetInventoryFilesLinux {
param([string[]]$Servers,[string]$User)
$batch = Join-Path $script:Ergebnisordner ('Linux-' + [guid]::NewGuid().ToString('N'))
foreach ($server in $Servers) {
try {
Invoke-LinuxCommand $server $User 'test ! -d "$HOME/ndtrack/.ndtrack-running" && test -d "$HOME/ndtrack/inventory" && test -n "$(find "$HOME/ndtrack/inventory" -type f -print -quit)"'
$target = Join-Path $batch $server
New-Item -Path $target -ItemType Directory -Force -ErrorAction Stop | Out-Null
Invoke-NativeChecked 'scp' @('-r','-o','ConnectTimeout=15',"${User}@${server}:ndtrack/inventory",$target)
Write-Host "EINGESAMMELT: $server -> $target (vorhandene Dateien, Alter nicht bewertet)."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function DeleteFileLinux {
param([string[]]$Servers,[string]$User)
foreach ($server in $Servers) {
try {
# Bei fehlendem pgrep ebenfalls abbrechen statt einen laufenden Scan zu riskieren.
$command = 'test -n "$HOME" && test "$HOME" != / && test ! -d "$HOME/ndtrack/.ndtrack-running" && command -v pgrep >/dev/null && { pgrep -x ndtrack >/dev/null; rc=$?; test "$rc" -eq 1; } && rm -rf -- "$HOME/ndtrack"'
Invoke-LinuxCommand $server $User $command
Write-Host "ENTFERNT: $server - NDTrack-Ordner."
} catch { Write-Warning "${server}: $($_.Exception.Message)" }
}
}
function Invoke-MenuOption {
param([string]$Choice)
switch ($Choice) {
'1' { CopyFile @(GetADServer) | Out-Null }
'2' {
$credential = Get-Credential -Message 'Ausfuehrungskonto fuer Task NDTRACK (DOMAENE\Benutzer)'
if ($null -eq $credential) { throw 'Kontoabfrage abgebrochen.' }
CreateScheduledTask @(GetADServer) $credential
}
'3' { GetInventoryFiles @(GetADServer) }
'4' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; CopyFileLinux $servers $userName | Out-Null }
'5' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; RunNDTRACKRemotelyLinux $servers $userName }
'6' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; GetInventoryFilesLinux $servers $userName }
'7' { $servers = @(GetADServer); $cleared = @(DeleteScheduledTask $servers); if ($cleared.Count) { DeleteFile $cleared } }
'8' { $servers = @(GetLinuxServer); $userName = Get-LinuxUser; DeleteFileLinux $servers $userName }
'0' { return }
default { throw 'Bitte eine Option zwischen 0 und 8 waehlen.' }
}
}
if (-not $LibraryOnly) {
if ($env:OS -ne 'Windows_NT') { throw 'Auf einem Windows-Verwaltungsrechner ausfuehren; Mac nur zum Bearbeiten/Testen.' }
Initialize-Configuration
CheckDirectory
Test-SourceFiles -Path $script:SourcePath
do {
$choice = ShowMenu
if ($choice -eq '0') { break }
$transcriptStarted = $false
try {
$log = Join-Path $script:LogFolder ('NDTrack-{0}.log' -f (Get-Date -Format 'yyyyMMdd-HHmmss-fff'))
Start-Transcript -Path $log -ErrorAction Stop | Out-Null
$transcriptStarted = $true
Invoke-MenuOption $choice
} catch { Write-Warning $_.Exception.Message }
finally { if ($transcriptStarted) { Stop-Transcript | Out-Null } }
} while ($true)
}
+522
View File
@@ -0,0 +1,522 @@
# =========================
# Konfigurationsparameter
# =========================
$DocumentsPath = [Environment]::GetFolderPath('MyDocuments')
$global:SourcePath = Join-Path $DocumentsPath 'Windows'
$global:DestinationPath = "C:\ndtrack" # Zielpfad auf den Remote Servern
$global:DestinationPath_RDS = "\RDSFIXV001\workfolders$\$env:USERPROFILE\Documents\windows"
$global:TaskName = "NDTrackTask"
#$global:TestServers = "GARRDSV003","GARRDSV002"
$global:logfile = Join-Path $DocumentsPath 'NDTrack-Logs'
$global:Ergebnisordner = Join-Path $DocumentsPath 'Ergebnisse'
New-Item -Path $logfile, $Ergebnisordner -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Import-Module RemoteDesktop
# =========================
# Funktionen
# =========================
function ShowMenu(){
param()
cls
Write-Host "================================================================================"
Write-Host "Dieses Script bietet verschiedene Optionen die Softwareinventur durchzuführen."
Write-Host
Write-Host "Option 1: Remote Ausführung von NDTRACK mittels Remoting. (Windows|AD)"
Write-Host "Option 2: Lokale Ausführung von NDTRACK mittels Scheduled Task. (Windows|AD)"
Write-Host "Option 3: Lokale Ausführung von NDTRACK mittels SSH. (Linux|Textdatei)"
Write-Host "Option 4: Inventory Dateien einsammeln. (Windows|AD)"
Write-Host "Option 5: Inventory Dateien einsammeln. (Linux|Textdatei)"
Write-Host "Option 6: NDTRACK und Scheduled Task von Systemen entfernen. (Windows|AD)"
Write-Host "Option 7: NDTRACK von Systemen entfernen. (Linux|Textdatei)"
Write-Host "Option 8: RDS Server mittels NDTRACK scannen"
Write-Host "==============================================================================="
Write-Host "Option 0: Beenden"
$f_Choice = Read-Host -Prompt "Auswahl Variante (0-8)"
Write-Host
return $f_Choice
}
function GetADServer(){
param()
Write-Host "Server aus dem Active Directory werden ausgelesen ..." -ForegroundColor Cyan
$f_DomainDN = ([ADSI]"").distinguishedName
$f_Searcher = New-Object adsisearcher
$f_Searcher.SearchRoot = "LDAP://$f_DomainDN" # Muss angepasst werden
$f_Searcher.Filter = "(&(objectClass=computer)(operatingSystem=*Server*))"
$f_Searcher.PageSize = 1000
$f_Servers = $f_Searcher.FindAll() | ForEach-Object {$_.Properties.name}
return $f_Servers
}
function GetRDSServer(){
param()
Write-Host "RDSServer aus dem Active Directory werden ausgelesen ..." -ForegroundColor Cyan
$f_DomainDN = ([ADSI]"").distinguishedName
$f_Searcher = New-Object adsisearcher
$f_Searcher.SearchRoot = "LDAP://$f_DomainDN" # Muss angepasst werden
$f_rds_Servers = Get-RDServer
return $f_rds_Servers
}
function CopyFile(){
param($f_AllServers)
Write-Host "Ordner werden angelegt und Dateien kopiert ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
#write-host $DestinationPath
if (-not (Test-Path "\\$f_server\c$")){
write-host "$f_server : c$ ist nicht verfügbar"
continue
}
try{
# Zielordner prüfen
$RemoteFolder = "\\$f_Server\c$\ndtrack"
if (-not (Test-Path -LiteralPath "$SourcePath\RunNdTrackWindows_Local.cmd" `
-PathType Leaf -ErrorAction Stop)) {
throw "Startdatei fehlt in $SourcePath."
}
New-Item -Path $RemoteFolder -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$SourcePath\*" -Destination $RemoteFolder `
-Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
Write-Output $f_Server
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red
write-host $Error}
}
}
function CreateScheduledTask(){
param($f_AllServers)
Write-Host "Scheduled Tasks werden angelegt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath, $TaskName, [pscredential]$Credential)
$ErrorActionPreference = 'Stop'
$CmdPath = Join-Path $DestinationPath 'RunNdTrackWindows_Local.cmd'
if (-not (Test-Path -LiteralPath $CmdPath -PathType Leaf)) {
throw "Startdatei fehlt: $CmdPath"
}
$Action = New-ScheduledTaskAction `
-Execute "$env:SystemRoot\System32\cmd.exe" `
-Argument ('/d /s /c ""{0}""' -f $CmdPath) `
-WorkingDirectory $DestinationPath
$Trigger = New-ScheduledTaskTrigger `
-Once -At (Get-Date).AddMinutes(5)
$Settings = New-ScheduledTaskSettingsSet -StartWhenAvailable
Register-ScheduledTask -TaskName $TaskName `
-Action $Action -Trigger $Trigger -Settings $Settings `
-User $Credential.UserName `
-Password $Credential.GetNetworkCredential().Password `
-RunLevel Highest -Force | Out-Null
} -ArgumentList $DestinationPath, $TaskName, $ServiceAccount `
-ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function DeleteFile(){
param($f_AllServers)
Write-Host "Dateien werden von den Servern gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Lösche Datei von $f_Server ..." -ForegroundColor Cyan
try{
# Zielordner prüfen
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath)
if (Test-Path $DestinationPath){
Remove-Item -Path $DestinationPath -Recurse -Force
Write-Output "Datei gelöscht."
}
else{
Write-Output "Datei nicht gefunden."
}
} -ArgumentList $DestinationPath -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server entfernt." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server Entfernen fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function DeleteScheduledTask(){
param($f_AllServers)
Write-Host "Scheduled Tasks werden gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($TaskName)
if (Get-ScheduledTask -TaskName $TaskName -ErrorAction SilentlyContinue){
Unregister-ScheduledTask -TaskName $TaskName -Confirm:$false
Write-Output "Scheduled Task entfernt."
}
else{
Write-Output "Scheduled Task nicht gefunden."
}
} -ArgumentList $TaskName -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server gelöscht." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server Löschung gescheitert - $_" -ForegroundColor Red}
}
}
function RunNDTRACKRemotely(){
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath)
&"$DestinationPath\RunNdTrackWindows_Local.cmd"
} -ArgumentList $DestinationPath -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function GetInventoryFiles(){
param($f_AllServers)
Write-Host "Inventory Dateien werden eingesammelt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
if (-not (Test-Path "\\$f_server\c$")){
write-host "$f_server : c$ ist nicht verfügbar"
continue
}
try{
# Zielordner prüfen
$InventoryPath = "\\$f_Server\c$\ndtrack\inventory"
$TargetPath = Join-Path $Ergebnisordner $f_Server
if (-not (Test-Path -LiteralPath $InventoryPath `
-PathType Container -ErrorAction Stop)) {
Write-Warning "${f_Server}: Kein Inventory-Ordner gefunden."
continue
}
$Files = @(Get-ChildItem -LiteralPath $InventoryPath `
-File -Recurse -ErrorAction Stop)
if ($Files.Count -eq 0) {
Write-Warning "${f_Server}: Keine Inventardateien vorhanden."
continue
}
New-Item -Path $TargetPath -ItemType Directory `
-Force -ErrorAction Stop | Out-Null
Copy-Item -Path "$InventoryPath\*" -Destination $TargetPath `
-Recurse -Force -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server Ergebnis geholt." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function GetLinuxServer(){
param()
Do {
$f_FileLocation = Read-Host -Prompt "Bitte den vollständigen Pfad zur Textdatei eingeben"
} while (!(Test-Path $f_FileLocation))
Write-Host "Linux-Server aus Textdatei werden ausgelesen ..." -ForegroundColor Cyan
$f_Servers = Get-Content -Path $f_FileLocation
return $f_Servers
}
function CopyFileLinux(){
param($f_AllServers)
Write-Host "Ordner werden angelegt und Dateien kopiert ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Befehl erzeugen
$f_Command = "mkdir /home/$User/ndtrack"
# Ordner erstellen
ssh "$User@$f_Server" $f_Command
# Datei auf Remote Server kopieren
scp -r "$SourcePath\*" "$User@$f_Server`:/home/$User/ndtrack"
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function RunNDTRACKRemotelyLinux(){
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Befehl erzeugen
$f_Command = "/home/$User/ndtrack/RunNdTrackLinuxUnix_Local.sh"
# NDTrack ausführen
ssh "$User@$f_Server" $f_Command
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
function GetInventoryFilesLinux(){
param($f_AllServers)
Write-Host "Inventory Dateien werden eingesammelt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
# Nutzer einlesen
$f_User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
# Datei vom Remote Server kopieren
scp "$f_User@$f_Server`:/home/$f_User/ndtrack/inventory/*" "$SourcePath\Result"
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function DeleteFileLinux(){
param($f_AllServers)
Write-Host "Dateien werden von den Servern gelöscht ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Lösche Datei von $f_Server ..." -ForegroundColor Cyan
try{
# Nutzer einlesen
$f_User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
# Befehl erzeugen
$f_Command = "rm -r /home/$f_User/ndtrack"
# Ordner und Dateien löschen
ssh "$f_User@$f_Server" $f_Command
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen. - $_" -ForegroundColor Red}
}
}
function CheckDirectory() {
# test if folder exists
if (Test-Path -Path $Ergebnisordner) {
Write-Host "Ergebnis Ordner besteht bereits" -ForegroundColor yellow
} else {
"Verzeichnis existiert nicht. Wird erzeugt"
if (New-Item -ItemType Directory -Force -Path $Ergebnisordner) {
"Ergebniss Verzeichnis Erzeugt"
} else {
exit
}
}
}
function Scan_RDS_SINA () {
# special routine for KdoIT-Bws gehärtete SINA RDS Clients
param($f_AllServers)
Write-Host "NDTRACK wird ausgeführt ..." -ForegroundColor Cyan
Foreach ($f_Server in $f_AllServers){
Write-Host "Prozessiere $f_Server ..." -ForegroundColor Cyan
try{
Invoke-Command -ComputerName $f_Server -ScriptBlock {
param($DestinationPath_RDS)
&"$DestinationPath_RDS\RunNdTrackWindows_Local_RDSSINA.cmd"
} -ArgumentList $DestinationPath_RDS -AsJob -ErrorAction Stop
# Meldung geben
Write-Host "ERFOLG: $f_Server konfiguriert." -ForegroundColor Green
}
catch {Write-Host "FEHLER: $f_Server fehlgeschlagen - $_" -ForegroundColor Red}
}
}
# =========================
# Hauptprogramm
# =========================
Do {
$Choice = ShowMenu
Switch ($Choice){
1 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
write-host $Ergebnisordner
CheckDirectory
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
CopyFile $AllServers
RunNDTRACKRemotely $AllServers
Stop-Transcript
} # Windows|AD Remoting
2 {
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
$ServiceAccount = Get-Credential -Message "User für Scheduled Task eingeben"
$AllServers = GetADServer
#$AllServers = $TestServers
$CopiedServers = @(CopyFile $AllServers)
if ($CopiedServers.Count -gt 0) {
CreateScheduledTask $CopiedServers
}
Stop-Transcript
} # Windows|AD Scheduled Task
3 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
# Nutzer einlesen
$User = Read-Host -Prompt "Nutzer in Form User@Domain eingeben"
CopyFileLinux $AllServers
RunNDTRACKRemotelyLinux $AllServers
Stop-Transcript
} # Linux|Textdatei SSH
4 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
GetInventoryFiles $AllServers
Stop-Transcript
} # Windows|AD einsammeln
5 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
GetInventoryFilesLinux $AllServers
Stop-Transcript
} # Linux|Textdatei einsammeln
6 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetADServer
#$AllServers = $TestServers
DeleteFile $AllServers
DeleteScheduledTask $AllServers
Stop-Transcript
} # Windows|AD löschen
7 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetLinuxServer
DeleteFileLinux $AllServers
Stop-Transcript
} # Linux|Textdatei löschen
8 {
Write-Host "Variante $_ ausgewählt..." -ForegroundColor Green
Start-Transcript -Path "$logfile\logfile-$(Get-Date -format dd-MM-yyyy-hhmm).log" -IncludeInvocationHeader -force -append
$AllServers = GetRDSServer
DeleteFileRDS $AllServers
Stop-Transcript
} # RDS|Textdatei löschen
0 { }
default {
Write-Host "Das war wohl nix... Bitte versuche es erneut!" -ForegroundColor Red
Start-Sleep 2
}
}
} while ($Choice -ne '0')
+75
View File
@@ -0,0 +1,75 @@
#Requires -Version 5.1
# Skriptversion: 1.0.0
# Versionsstand: 2026-10-15
<#
Vorbereitung auf dem Windows-Verwaltungsrechner. Keine Serverzugriffe.
Beispiel: .\PreScript.ps1 -Platform Windows
Prueft nur vorhandene Ordner und Dateien. Bei Erfolg wird das Hauptskript gestartet.
Fehlende Ordner und Dateien muessen vorab bereitgestellt werden.
#>
[CmdletBinding()]
param(
[ValidateSet('Windows','Linux','Both')]
[string]$Platform = 'Windows',
[string]$BasePath = 'C:\SCAN'
)
$ErrorActionPreference = 'Stop'
try {
$scriptFolder = Join-Path $BasePath 'SCRIPT'
$sourceFolder = Join-Path $BasePath 'NDTRACK'
$resultFolder = Join-Path $BasePath 'RESULTS'
$logFolder = Join-Path $scriptFolder 'Logs'
foreach ($path in @($scriptFolder,$sourceFolder,$resultFolder,$logFolder)) {
if (Test-Path -LiteralPath $path) {
if (-not (Test-Path -LiteralPath $path -PathType Container)) {
throw "Pfad ist eine Datei statt eines Ordners: $path"
}
Write-Host "VORHANDEN: $path"
} else {
throw "Benoetigter Ordner fehlt: $path. Bitte vor dem Start bereitstellen."
}
}
$issues = [System.Collections.Generic.List[string]]::new()
$mainScript = Join-Path $scriptFolder 'NDTrack-Geprueft.ps1'
if (-not (Test-Path -LiteralPath $mainScript -PathType Leaf)) {
$issues.Add("Hauptskript fehlt: $mainScript. Bitte die erstellte Skriptdatei dorthin kopieren.")
} elseif ((Get-Item -LiteralPath $mainScript).Length -eq 0) {
$issues.Add("Hauptskript ist leer: $mainScript")
} else {
$tokens=$null; $parseErrors=$null
[void][System.Management.Automation.Language.Parser]::ParseFile($mainScript,[ref]$tokens,[ref]$parseErrors)
if ($parseErrors.Count) { $issues.Add("Hauptskript enthaelt PowerShell-Syntaxfehler: $($parseErrors -join '; ')") }
}
$files = @(Get-ChildItem -LiteralPath $sourceFolder -File -Recurse -Force)
if (-not $files.Count) {
$issues.Add("Keine Dateien in $sourceFolder. Bitte das vollstaendige NDTrack-Paket entpackt dort ablegen; leere Unterordner reichen nicht aus.")
} else {
Write-Host "DATEIEN: $($files.Count) in $sourceFolder (inklusive Unterordner)."
}
$launchers = @()
if ($Platform -in @('Windows','Both')) { $launchers += 'RunNdTrackWindows_Local.cmd' }
if ($Platform -in @('Linux','Both')) { $launchers += 'RunNdTrackLinuxUnix_Local.sh' }
foreach ($name in $launchers) {
$path = Join-Path $sourceFolder $name
if (-not (Test-Path -LiteralPath $path -PathType Leaf)) {
$issues.Add("Startdatei fehlt direkt im Quellordner: $path")
} elseif ((Get-Item -LiteralPath $path).Length -eq 0) {
$issues.Add("Startdatei ist leer: $path")
} else { Write-Host "STARTDATEI VORHANDEN: $name" }
}
if ($issues.Count) {
foreach ($issue in $issues) { Write-Warning $issue }
Write-Host 'VORBEREITUNG UNVOLLSTAENDIG. Fehlende Dateien ergaenzen und PreScript erneut ausfuehren.' -ForegroundColor Yellow
exit 1
}
Write-Host 'VORBEREITUNG OK: Ordner und benoetigte Startdateien vorhanden; Hauptskript syntaktisch gueltig.' -ForegroundColor Green
Write-Host 'Paketvollstaendigkeit, CMD-/SH-Inhalt und Zielserver-Erreichbarkeit wurden nicht geprueft.'
Write-Host "Starte Hauptskript: $mainScript"
& $mainScript
exit 0
} catch {
Write-Warning "Vorbereitung fehlgeschlagen: $($_.Exception.Message)"
exit 1
}
+58
View File
@@ -0,0 +1,58 @@
# NDTrack: gezielte Änderungen und Git-Anleitung
## Dateien
- `NDTrack.ps1`: dein Originalskript mit ausschließlich den zuletzt besprochenen Änderungen.
- `Aenderungen.diff`: Vergleich mit dem eingefügten Original; ohne den UTF-8-BOM der Ausgabedatei dargestellt.
Die Änderungen betreffen Benutzerpfade, Erstellen der lokalen Ausgabeordner, Kopieren auf die Server, Task-Erstellung, Übergabe erfolgreich belieferter Server, Einsammeln je Server und Beenden über Option 0. Die übrigen Funktionen wurden nicht überarbeitet. Das Skript ist für Windows; auf dem Mac kannst du es bearbeiten und mit Git verwalten.
## Auf Windows verwenden
1. `NDTrack.ps1` auf deinen Windows-Verwaltungsrechner kopieren.
2. Die NDTrack-Dateien einschließlich `RunNdTrackWindows_Local.cmd` im Dokumente-Unterordner `Windows` des ausführenden Benutzers ablegen.
3. PowerShell unter einem Konto mit Zugriff auf die administrativen Freigaben der Zielserver und Berechtigung für PowerShell-Remoting starten.
4. Im Skriptverzeichnis ` .\NDTrack.ps1 ` ausführen.
5. Option 2 verteilt die Dateien und fragt das Konto für den geplanten Task ab. Der einmalige Task startet fünf Minuten nach seiner Erstellung auf dem jeweiligen Server.
6. Nach Abschluss des Scans Option 4 wählen. Die Dateien werden unter `Dokumente\Ergebnisse\SERVERNAME` des Benutzers gespeichert, unter dessen Konto PowerShell läuft. Bei „Als anderer Benutzer ausführen“ ist dies das andere Konto, nicht automatisch der am Desktop angemeldete Benutzer.
7. Option 0 beendet das Skript. Protokolle liegen unter `Dokumente\NDTrack-Logs`.
Ohne Anpassung der vorhandenen Serverauswahl werden Server aus dem AD verwendet. Für einen Test kannst du die vorhandenen Testserver-Zeilen aktivieren und die entsprechende AD-Auswahl in Option 2 und 4 auskommentieren; dies wurde in der gelieferten Datei nicht vorgenommen.
## Bekannte, unveränderte Punkte
- Option 4 kopiert vorhandene Dateien, ohne Task-Abschluss oder Aktualität zu prüfen.
- Die CMD-Datei war nicht enthalten. Ihre Funktionsweise und die Ausgabe nach `C:\ndtrack\inventory` sind daher nicht geprüft.
- Linux-, RDS- und Löschfunktionen behalten die zuvor besprochenen Fehler. Insbesondere verweist Option 8 weiterhin auf die nicht vorhandene Funktion `DeleteFileRDS`.
- Der vorhandene Import von `RemoteDesktop` ist unverändert. Fehlt das Modul, meldet PowerShell einen Importfehler.
- Die Task-Erstellung benötigt jetzt PowerShell-Remoting und das Modul `ScheduledTasks` auf den Zielservern. Das Task-Konto benötigt die nötigen Rechte für Scan und geplante Ausführung.
Die PowerShell-Syntax wurde auf dem Mac geprüft. Es wurden keine Server angesprochen und keine Tasks erstellt.
## Git im vorhandenen Arbeitsordner
Das Skript liegt unter `NDTrack/NDTrack.ps1` im bestehenden Repository. Kein `git init` erforderlich. Im Terminal:
```bash
cd '/Users/michaeltroebs/Documents/GIT/syno-scripts'
git status --short
git add NDTrack/NDTrack.ps1 NDTrack/README.md NDTrack/Aenderungen.diff
git diff --cached -- NDTrack/
git commit -m "NDTrack: Benutzerpfade und Windows-Verteilung korrigieren" -- NDTrack/
```
Der Commit-Befehl beschränkt sich auf den Ordner NDTrack. Andere vorhandene Änderungen bleiben außerhalb dieses Commits. Der erste Commit enthält den angepassten Stand; den Vergleich zum eingefügten Original findest du in `Aenderungen.diff`.
Spätere Änderungen vor dem Vormerken prüfen:
```bash
git diff -- NDTrack/NDTrack.ps1
```
Optional nach dem Commit auf den bereits eingerichteten Remote übertragen, sofern der aktuelle Branch einen Upstream hat:
```bash
git push
```
Codex hat die Dateien nur abgelegt: nichts vorgemerkt, committed oder hochgeladen.
+26
View File
@@ -0,0 +1,26 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$saved=$env:USERDNSDOMAIN
function Assert { param($Condition) if(-not $Condition){throw 'Domaenenauswahl falsch'} }
try {
$script:TargetDomain=''; $script:DomainController=''
$env:USERDNSDOMAIN='first.example'
Assert ((Get-DirectoryEndpoint) -eq 'first.example')
$env:USERDNSDOMAIN='second.example'
Assert ((Get-DirectoryEndpoint) -eq 'second.example')
$script:TargetDomain='target.example'
Assert ((Get-DirectoryEndpoint) -eq 'target.example')
$script:DomainController='dc01.target.example'
Assert ((Get-DirectoryEndpoint) -eq 'dc01.target.example')
$script:DomainController=''; $script:TargetDomain=''; $env:USERDNSDOMAIN=''
$failed=$false
try { Get-DirectoryEndpoint } catch { $failed=$true }
Assert $failed
$script:TargetDomain='invalid/path'
$failed=$false
try { Get-DirectoryEndpoint } catch { $failed=$true }
Assert $failed
$script:TestServers=@('sql01.target.example','sql01.target.example')
Assert ((@(GetADServer)).Count -eq 1)
Write-Host '7 Domaenenauswahl-Pruefungen bestanden; keine echte AD-Verbindung.'
} finally { $env:USERDNSDOMAIN=$saved }
+102
View File
@@ -0,0 +1,102 @@
# Isolierte Tests: keine Serverzugriffe oder echten Loeschungen.
$ErrorActionPreference = 'Stop'
$path = Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1'
$t=$null; $e=$null
[void][System.Management.Automation.Language.Parser]::ParseFile($path,[ref]$t,[ref]$e)
if ($e.Count) { throw ($e | Out-String) }
. $path -LibraryOnly
$script:checks=0
function Assert { param($Condition,$Message) if(-not $Condition){throw $Message}; $script:checks++ }
function Invoke-Command { param($ComputerName,$ScriptBlock,[object[]]$ArgumentList,$ErrorAction) & $ScriptBlock @ArgumentList }
function Test-Path { $true }
function New-CimSessionOption { param($Protocol,$ErrorAction) if($Protocol -ne 'Dcom'){throw 'Falsches Protokoll'}; 'DCOM' }
function New-CimSession { param($ComputerName,$SessionOption,$ErrorAction) $ComputerName }
function Get-CimInstance { [pscustomobject]@{SystemDrive='E:'} }
function Remove-CimSession { }
$script:ServerDestinationPaths=@{}
$script:DestinationPath=''
Assert ((Resolve-WindowsFolder 'server01') -eq 'E:\ndtrack') 'Automatisches Systemlaufwerk falsch'
$script:ServerDestinationPaths=@{'server02'='E:\ndtrack'}
Assert ((Get-WindowsSharePath 'server02') -eq '\\server02\E$\ndtrack') 'Server-Ausnahme falsch'
$script:ServerDestinationPaths=@{}
$script:DestinationPath='D:\Tools\ndtrack'
Assert ((Resolve-WindowsFolder 'server01') -eq 'D:\Tools\ndtrack') 'Dynamischer Zielpfad falsch'
$rejected=$false
try { Resolve-WindowsFolder 'server;invalid' } catch { $rejected=$true }
Assert $rejected 'Ungueltiger Host akzeptiert'
$script:DestinationPath='C:\Tools\..\ndtrack'
$rejected=$false
try { Resolve-WindowsFolder 'server01' } catch { $rejected=$true }
Assert $rejected 'Pfad mit .. akzeptiert'
# Echte lokale Exitcodes; nur ein leerer PowerShell-Kindprozess.
$program=(Get-Process -Id $PID).Path
$rejected=$false
try { Invoke-NativeChecked $program @('-NoProfile','-Command','exit 7') } catch { $rejected=$true }
Assert $rejected 'Native Fehler nicht erkannt'
Invoke-NativeChecked $program @('-NoProfile','-Command','exit 0')
$script:checks++
# Alle acht Menueablaeufe mit eindeutigem Erfolg/Fehlschlag der vorgeschalteten Schritte.
function GetADServer { @('ok','failed') }
function GetRDSServer { @('rds01') }
function GetLinuxServer { @('linuxok','linuxfailed') }
function Get-LinuxUser { 'scanuser' }
function Get-Credential { [pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force)) }
$script:trace=@()
function CopyFile { param($Servers) $script:trace+='copy'; 'ok' }
function RunNDTRACKRemotely { param($Servers) Assert (($Servers -join ',') -eq 'ok') 'Option 1 startet fehlgeschlagene Server'; $script:trace+='run' }
function CreateScheduledTask { param($Servers,$Credential) Assert (($Servers -join ',') -eq 'ok,failed') 'Option 2 erhaelt falsche Ziele'; $script:trace+='task' }
function CopyFileLinux { param($Servers,$User) Assert ($User -eq 'scanuser') 'Linux-Konto fehlt'; $script:trace+='linuxcopy'; 'linuxok' }
function RunNDTRACKRemotelyLinux { param($Servers,$User) Assert (($Servers -join ',') -eq 'linuxok,linuxfailed') 'Option 5 erhaelt falsche Ziele'; $script:trace+='linuxrun' }
function GetInventoryFiles { param($Servers) $script:trace+='collect' }
function GetInventoryFilesLinux { param($Servers,$User) Assert ($User -eq 'scanuser') 'Konto Option 5 fehlt'; $script:trace+='linuxcollect' }
function DeleteScheduledTask { param($Servers) $script:trace+='stoptask'; 'ok' }
function DeleteFile { param($Servers) Assert (($Servers -join ',') -eq 'ok') 'Option 6 loescht trotz Task-Fehler'; $script:trace+='delete' }
function DeleteFileLinux { param($Servers,$User) $script:trace+='linuxdelete' }
function Scan_RDS_SINA { param($Servers) Assert (($Servers -join ',') -eq 'rds01') 'RDS-Ziele falsch'; $script:trace+='rds' }
$expected=@('copy','task','collect','linuxcopy','linuxrun','linuxcollect','stoptask,delete','linuxdelete')
foreach($option in 1..8){
$script:trace=@()
Invoke-MenuOption ([string]$option)
Assert (($script:trace -join ',') -eq $expected[$option-1]) "Ablauf Option $option falsch"
Write-Host "Option ${option}: Ablauf bestanden"
}
function CopyFile { param($Servers) }
$script:trace=@(); Invoke-MenuOption '1'; Assert ($script:trace.Count -eq 0) 'Scan trotz leerer Kopiererfolge'
$script:trace=@(); Invoke-MenuOption '0'; Assert ($script:trace.Count -eq 0) 'Option 0 fuehrt Aktionen aus'
function Get-Credential { $null }
$rejected=$false
try { Invoke-MenuOption '2' } catch { $rejected=$true }
Assert $rejected 'Abgebrochene Kontoabfrage nicht erkannt'
Write-Host "$script:checks Pruefungen bestanden. Keine echten Zielsysteme getestet."
# Originalfunktionen erneut laden und deren Fehlerpfade pruefen.
. $path -LibraryOnly
$script:DestinationPath='C:\ndtrack'
$script:TaskName='NDTrackTask'
$script:WindowsLauncher='RunNdTrackWindows_Local.cmd'
$script:LinuxSourcePath='test-source'
$script:LinuxLauncher='RunNdTrackLinuxUnix_Local.sh'
$script:Ergebnisordner='test-results'
$script:StartDelayMinutes=5
function Test-Path { $true }
function Test-SourceFiles { }
function Join-Path { param($Path,$ChildPath) "$Path/$ChildPath" }
function Invoke-Command { throw 'Simulierter Remote-Fehler' }
function Invoke-LinuxCommand { throw 'Simulierter SSH-Fehler' }
$credential=[pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force))
$cases=@(
{ CreateScheduledTask @('server01') $credential },
{ RunNDTRACKRemotely @('server01') },
{ DeleteScheduledTask @('server01') },
{ DeleteFile @('server01') },
{ GetInventoryFiles @('server01') },
{ CopyFileLinux @('server01') 'scanuser' },
{ RunNDTRACKRemotelyLinux @('server01') 'scanuser' },
{ GetInventoryFilesLinux @('server01') 'scanuser' },
{ DeleteFileLinux @('server01') 'scanuser' }
)
foreach($case in $cases){
$output=@(& $case *>&1)
Assert (@($output | Where-Object { $_ -is [System.Management.Automation.WarningRecord] }).Count -gt 0) 'Fehler wurde nicht gemeldet'
Assert (-not (($output | Out-String) -match 'START ANGEFORDERT:|GEPLANT:|BEENDET:|ENTFERNT:|EINGESAMMELT:|KOPIERT:')) 'Falsche Erfolgsmeldung nach Fehler'
}
Write-Host "Gesamt: $script:checks Pruefungen bestanden."
+33
View File
@@ -0,0 +1,33 @@
$ErrorActionPreference='Stop'
$preScript=Join-Path (Split-Path $PSScriptRoot -Parent) 'PreScript.ps1'
$root=Join-Path ([IO.Path]::GetTempPath()) ('ndtrack-pre-'+[guid]::NewGuid().ToString('N'))
$program=(Get-Process -Id $PID).Path
try {
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1){throw 'Fehlende Ordner akzeptiert'}
if(Test-Path -LiteralPath $root){throw 'PreScript hat Ordner angelegt'}
foreach($relative in @('SCRIPT','NDTRACK','RESULTS','SCRIPT/Logs')){
New-Item -Path (Join-Path $root $relative) -ItemType Directory -Force | Out-Null
}
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1){throw 'Leeres Paket akzeptiert'}
# Harmloses Test-Hauptskript dokumentiert nur seinen Start.
$fixture='Set-Content -LiteralPath (Join-Path $PSScriptRoot "started.txt") -Value "started"'
$main=Join-Path $root 'SCRIPT/NDTrack-Geprueft.ps1'
$marker=Join-Path $root 'SCRIPT/started.txt'
Set-Content -LiteralPath $main -Value $fixture
Set-Content -LiteralPath (Join-Path $root 'NDTRACK/RunNdTrackWindows_Local.cmd') -Value '@echo test'
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 0 -or -not(Test-Path -LiteralPath $marker)){throw 'Hauptskript nicht gestartet'}
Remove-Item -LiteralPath $marker
& $program -NoProfile -File $preScript -BasePath $root -Platform Both
if($LASTEXITCODE -ne 1 -or (Test-Path -LiteralPath $marker)){throw 'Start trotz fehlender Linux-Datei'}
Set-Content -LiteralPath (Join-Path $root 'NDTRACK/RunNdTrackLinuxUnix_Local.sh') -Value '#!/bin/sh'
& $program -NoProfile -File $preScript -BasePath $root -Platform Both
if($LASTEXITCODE -ne 0 -or -not(Test-Path -LiteralPath $marker)){throw 'Start fuer beide Plattformen fehlgeschlagen'}
Remove-Item -LiteralPath $marker
Set-Content -LiteralPath $main -Value 'function Broken {'
& $program -NoProfile -File $preScript -BasePath $root
if($LASTEXITCODE -ne 1 -or (Test-Path -LiteralPath $marker)){throw 'Syntaxfehler akzeptiert'}
Write-Host 'PreScript: 6 Szenarien bestanden; fehlende Ordner nicht angelegt; Hauptskript nur bei Erfolg gestartet.'
} finally { if(Test-Path -LiteralPath $root){Remove-Item -LiteralPath $root -Recurse -Force} }
+34
View File
@@ -0,0 +1,34 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$script:DestinationPath=''; $script:ServerDestinationPaths=@{}
$script:removed=0; $script:wmiFail=$false
function New-CimSessionOption { param($Protocol,$ErrorAction) if($Protocol -ne 'Dcom'){throw 'WinRM statt DCOM verwendet'}; 'DCOM' }
function New-CimSession { param($ComputerName,$SessionOption,$ErrorAction) $ComputerName }
function Get-CimInstance { param($CimSession,$ClassName,$Property,$ErrorAction)
if($script:wmiFail){throw 'WMI nicht erreichbar'}
if($CimSession -eq 'sql01.example'){[pscustomobject]@{SystemDrive='D:'}}else{[pscustomobject]@{SystemDrive='C:'}}
}
function Remove-CimSession { $script:removed++ }
$script:SourcePath='source'; $script:WindowsLauncher='Run.cmd'
$script:copied=@(); $script:shareAvailable=$true
function Test-SourceFiles { }
function Invoke-Command { throw 'WinRM darf beim Kopieren nicht verwendet werden' }
function New-PSSession { throw 'Keine WinRM-Sitzung erlaubt' }
function Test-Path { param($LiteralPath,$PathType,$ErrorAction) if($LiteralPath -like '*.ndtrack-running'){return $false}; $script:shareAvailable }
function New-Item { }
function Get-ChildItem { [pscustomobject]@{Name='Run.cmd'} }
function Copy-Item { param([Parameter(ValueFromPipeline)]$InputObject,$Destination,[switch]$Recurse,[switch]$Force) process {$script:copied += $Destination} }
$result=@(CopyFile @('win01.example','sql01.example'))
if(($result -join ',') -ne 'win01.example,sql01.example'){throw 'Falsche Erfolgsrueckgabe'}
if(($script:copied -join ',') -ne '\\win01.example\C$\ndtrack,\\sql01.example\D$\ndtrack'){throw 'Falsche SMB-Ziele'}
$script:shareAvailable=$false; $script:copied=@()
$result=@(CopyFile @('win01.example'))
if($result.Count -or $script:copied.Count){throw 'Kopiert trotz fehlender Freigabe'}
Write-Host 'SMB-Kopieren: Standard C$, Ausnahme D$, Fehlerfall und keine WinRM-Aufrufe geprueft.'
$script:shareAvailable=$true; $script:wmiFail=$true; $script:copied=@()
$result=@(CopyFile @('sql01.example'))
if($result.Count -or $script:copied.Count){throw 'Kopiert trotz WMI-Fehler'}
if($script:removed -ne 4){throw 'CIM-Sitzungen nicht bereinigt'}
Write-Host 'Dynamische Laufwerke C:/D:, WMI-Fehler und Sitzungsbereinigung bestanden.'
+39
View File
@@ -0,0 +1,39 @@
$ErrorActionPreference = 'Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$root = Join-Path ([IO.Path]::GetTempPath()) ('ndtrack-test-' + [guid]::NewGuid().ToString('N'))
$script:checks=0
function Assert { param($Condition,$Message) if(-not $Condition){throw $Message}; $script:checks++ }
function Assert-Fails { param([scriptblock]$Action,[string]$Pattern)
$message=''
try { & $Action } catch { $message=$_.Exception.Message }
Assert ($message -like $Pattern) "Erwarteter Fehler fehlt: $Pattern / $message"
}
try {
$script:ScriptFolder=Join-Path $root 'SCRIPT'
$script:SourcePath=Join-Path $root 'NDTRACK'
$script:LinuxSourcePath=$script:SourcePath
$script:Ergebnisordner=Join-Path $root 'RESULTS'
$script:LogFolder=Join-Path $script:ScriptFolder 'Logs'
CheckDirectory
foreach($path in @($script:ScriptFolder,$script:SourcePath,$script:Ergebnisordner,$script:LogFolder)) {
Assert (Test-Path -LiteralPath $path -PathType Container) "Ordner fehlt: $path"
}
CheckDirectory # Wiederholbarer Aufruf
Assert-Fails { Test-SourceFiles $script:SourcePath } '*Keine Dateien*'
New-Item -Path (Join-Path $script:SourcePath 'empty') -ItemType Directory | Out-Null
Assert-Fails { Test-SourceFiles $script:SourcePath } '*Keine Dateien*'
Set-Content -LiteralPath (Join-Path $script:SourcePath 'payload.dat') -Value 'test'
Test-SourceFiles $script:SourcePath
$script:checks++
Assert-Fails { Test-SourceFiles $script:SourcePath 'Run.cmd' } '*Startdatei fehlt*'
[IO.File]::WriteAllText((Join-Path $script:SourcePath 'Run.cmd'),'')
Assert-Fails { Test-SourceFiles $script:SourcePath 'Run.cmd' } '*Startdatei ist leer*'
Set-Content -LiteralPath (Join-Path $script:SourcePath 'Run.cmd') -Value '@echo test'
Test-SourceFiles $script:SourcePath 'Run.cmd'
$script:checks++
$script:ScriptFolder=Join-Path $root 'file-instead-of-folder'
Set-Content -LiteralPath $script:ScriptFolder -Value 'keep'
Assert-Fails { CheckDirectory } '*Datei statt eines Ordners*'
Assert ((Get-Content -LiteralPath $script:ScriptFolder) -eq 'keep') 'Bestehende Datei veraendert'
Write-Host "$script:checks Ordner-/Dateipruefungen bestanden."
} finally { if(Test-Path -LiteralPath $root){Remove-Item -LiteralPath $root -Recurse -Force} }
+30
View File
@@ -0,0 +1,30 @@
$ErrorActionPreference='Stop'
. (Join-Path (Split-Path $PSScriptRoot -Parent) 'NDTrack-Geprueft.ps1') -LibraryOnly
$script:TaskName='NDTRACK'; $script:WindowsLauncher='Run.cmd'
$script:events=@(); $script:hasFile=$true; $script:failCreate=$false
function Resolve-WindowsFolder { 'D:\ndtrack' }
function Invoke-Command { throw 'Kein WinRM erlaubt' }
function Test-Path { $script:hasFile }
function Get-Date { [datetime]'2026-10-15T14:00:00' }
function Invoke-NativeChecked { param($Program,$Arguments)
$script:events+=$Arguments[0]
if($Program -ne 'schtasks.exe' -or $Arguments[0] -ne '/Create'){throw 'Nicht Original-Erstellungsablauf'}
$expected=@{'/S'='server01';'/TN'='NDTRACK';'/TR'='D:\ndtrack\Run.cmd';'/SC'='Once';'/ST'='14:05';'/RU'='DOMAIN\scan';'/RP'='test-only';'/RL'='HIGHEST'}
foreach($key in $expected.Keys){if($Arguments[[array]::IndexOf($Arguments,$key)+1] -ne $expected[$key]){throw "Falsches Argument: $key"}}
if($Arguments -contains '/XML' -or $Arguments -contains '/Run'){throw 'XML oder Sofortstart unerwuenscht'}
if($script:failCreate){throw 'Exitcode 1'}
}
$credential=[pscredential]::new('DOMAIN\scan',(ConvertTo-SecureString 'test-only' -AsPlainText -Force))
CreateScheduledTask @('server01') $credential
if(($script:events -join ',') -ne '/Create'){throw 'Falsche Aufrufe'}
$script:events=@(); $script:hasFile=$false
CreateScheduledTask @('server01') $credential
if($script:events.Count){throw 'Task trotz fehlender CMD'}
$script:hasFile=$true; $script:failCreate=$true
$output=@(CreateScheduledTask @('server01') $credential *>&1)
if(($output | Out-String) -match 'GEPLANT:'){throw 'Falsche Erfolgsmeldung'}
$script:events=@()
function Get-Date { [datetime]'2026-10-15T23:58:00' }
CreateScheduledTask @('server01') $credential
if($script:events.Count){throw 'Ungueltige Planung ueber Tagesgrenze'}
Write-Host '4 Task-Szenarien bestanden; Originalargumente, Benutzerkonto, Exitcode-Fehler und Tagesgrenze geprueft.'
+34
View File
@@ -0,0 +1,34 @@
# LDAP-OU-Struktur für heim.lan
Das Playbook legt unter `dc=heim,dc=lan` die acht OUs main, cert, backup,
iot, service, proxy, dmz und storage an. Jede erhält die Unter-OUs
Computers, Groups und Users. Dies ist eine an AD angelehnte OU-Struktur
für OpenLDAP, keine Einrichtung von Active-Directory-Domänen.
Bestehende Einträge werden nicht verschoben oder gelöscht.
## Voraussetzungen
- Ansible auf dem Control Node und SSH-Zugriff als root auf 9.99.30.14.
- Der Basis-DN `dc=heim,dc=lan` besteht bereits.
- Der LDAP-LXC bietet den lokalen LDAP-Socket `ldapi:///` an.
- Der LDAP-Administrator heißt `cn=admin,dc=heim,dc=lan`.
Falls abweichend, `ldap_bind_dn` im Playbook anpassen.
## Ausführen auf dem Ansible Control Node
Diesen Ordner auf den Control Node kopieren und dort in den Ordner wechseln.
Anschließend:
```bash
ansible-galaxy collection install community.general
ansible -i inventory.ini ldap -m ping
ansible-playbook -i inventory.ini ldap-ous.yml
```
Das LDAP-Admin-Passwort wird verdeckt abgefragt und nicht in diesen Dateien
gespeichert. Es kann vom SSH-Root-Passwort abweichen.
Das Playbook installiert python3-ldap auf dem LXC und legt die 32 OUs an,
soweit sie noch fehlen. Die Verbindung zum LDAP-Socket erfolgt auf dem LXC.
Das Playbook wurde beim Speichern nicht auf dem Server ausgeführt.
+2
View File
@@ -0,0 +1,2 @@
[ldap]
ldap01 ansible_host=9.99.30.14 ansible_user=root ansible_python_interpreter=/usr/bin/python3
+63
View File
@@ -0,0 +1,63 @@
---
- name: OU-Struktur auf TurnKey LDAP einrichten
hosts: ldap
gather_facts: false
vars:
ldap_base_dn: "dc=heim,dc=lan"
ldap_bind_dn: "cn=admin,{{ ldap_base_dn }}"
ldap_bereiche:
- main
- cert
- backup
- iot
- service
- proxy
- dmz
- storage
ldap_unterous:
- Computers
- Groups
- Users
vars_prompt:
- name: ldap_admin_password
prompt: "Passwort des LDAP-Administrators"
private: true
module_defaults:
community.general.ldap_entry:
server_uri: "ldapi:///"
bind_dn: "{{ ldap_bind_dn }}"
bind_pw: "{{ ldap_admin_password }}"
state: present
tasks:
- name: Python-LDAP auf dem LDAP-LXC installieren
ansible.builtin.apt:
name: python3-ldap
state: present
update_cache: true
cache_valid_time: 3600
- name: Bereichs-OUs anlegen
community.general.ldap_entry:
dn: "ou={{ item }},{{ ldap_base_dn }}"
objectClass:
- top
- organizationalUnit
attributes:
ou: "{{ item }}"
loop: "{{ ldap_bereiche }}"
- name: Unter-OUs in jedem Bereich anlegen
community.general.ldap_entry:
dn: "ou={{ item.1 }},ou={{ item.0 }},{{ ldap_base_dn }}"
objectClass:
- top
- organizationalUnit
attributes:
ou: "{{ item.1 }}"
loop: "{{ ldap_bereiche | product(ldap_unterous) | list }}"
loop_control:
label: "{{ item.0 }}/{{ item.1 }}"
+23
View File
@@ -1,5 +1,28 @@
# Änderungsprotokoll # Änderungsprotokoll
## [1.3.0] – 2026-09-09
- Optionaler Logout über zwei Keycloak-Adressen (IP und FQDN) nacheinander.
- Exakt kodierte Rücksprungkette und automatische Registrierung beider benötigten
Post-Logout-Redirects am Client, ohne Wildcards.
- TLS-/Issuer-Prüfung beider Aliase und Auswahl im Einrichtungsassistenten.
- Gemeinsame URL-Erzeugung für Ansible und Patch, Test der verschachtelten Redirects.
## [1.2.1] – 2026-09-09
- Rückbau direkt über `setup.py --rollback-logout` mit Inventory-/SSH-/sudo-Abfragen.
- Nach erfolgreichem Rückbau automatische lokale Deaktivierung des Logout-Patches.
- Manueller Rückbau ohne Ansible in der README ergänzt.
## [1.2.0] – 2026-09-09
- Optionaler Desktop-Logout-Patch: lokale PVE-Abmeldung mit anschließender
Keycloak-Weiterleitung ausschließlich für den konfigurierten OIDC-Realm.
- TLS-geprüfte Endpoint-Discovery und Keycloak-Post-Logout-Redirect-Konfiguration.
- Versions-/Strukturprüfung, SHA-256-Sicherungen, idempotenter Lauf und Rückbau.
- Logout-Abfrage im Assistenten sowie separate Installations-/Rückbau-Playbooks.
- Lokale Tests für Patch-Lebenszyklus, Paketupdates und Schutz vor Überschreiben.
## [1.1.0] – 2026-09-08 ## [1.1.0] – 2026-09-08
- Interaktiver Einrichtungsassistent `setup.py` für Host/IP, SSH, OIDC, CA/Java, - Interaktiver Einrichtungsassistent `setup.py` für Host/IP, SSH, OIDC, CA/Java,
+151 -2
View File
@@ -1,6 +1,6 @@
# PVE 9 + Keycloak OIDC für HEIMLAN # PVE 9 + Keycloak OIDC für HEIMLAN
Version: **1.1.0** · [Änderungsprotokoll](CHANGELOG.md) · [Versionsdatei](VERSION) Version: **1.3.0** · [Änderungsprotokoll](CHANGELOG.md) · [Versionsdatei](VERSION)
Dieses Ansible-Setup konfiguriert den bestehenden PVE-Host **ts01** und eine bestehende **Keycloak-VM**. Es installiert die private Root-CA auf beiden Betriebssystemen sowie im Java- und Keycloak-Truststore, richtet Realm, Client, Gruppen, Mapper und Sessions ein und ergänzt PVE-ACLs ausschließlich für bereits vorhandene Gruppen. Alle Module gehören zu `ansible.builtin`. Dieses Ansible-Setup konfiguriert den bestehenden PVE-Host **ts01** und eine bestehende **Keycloak-VM**. Es installiert die private Root-CA auf beiden Betriebssystemen sowie im Java- und Keycloak-Truststore, richtet Realm, Client, Gruppen, Mapper und Sessions ein und ergänzt PVE-ACLs ausschließlich für bereits vorhandene Gruppen. Alle Module gehören zu `ansible.builtin`.
@@ -161,7 +161,7 @@ Secret-Rotation: `ansible-vault edit group_vars/vault.yml`, denselben neuen Clie
Die Realm-SSO-Werte betreffen alle Anwendungen dieses Keycloak-Realms. Client-Overrides können die globale SSO-Grenze nicht verlängern. Kürzere Client-Sessions erzwingen bei weiterhin aktiver SSO-Session nicht zwangsläufig eine neue Passworteingabe. Die Realm-SSO-Werte betreffen alle Anwendungen dieses Keycloak-Realms. Client-Overrides können die globale SSO-Grenze nicht verlängern. Kürzere Client-Sessions erzwingen bei weiterhin aktiver SSO-Session nicht zwangsläufig eine neue Passworteingabe.
Keycloak-Sessionablauf ist außerdem keine PVE-Ticket-Laufzeit: PVE-Aktivität muss Keycloak nicht aktiv halten und ein abgelaufener Keycloak-Login beendet nicht automatisch ein bereits ausgestelltes PVE-Ticket. Das Paket implementiert keinen Single-Logout-Patch; lokales PVE-Logout beendet die Keycloak-SSO-Session nicht automatisch. Keycloak-Sessionablauf ist außerdem keine PVE-Ticket-Laufzeit: PVE-Aktivität muss Keycloak nicht aktiv halten und ein abgelaufener Keycloak-Login beendet nicht automatisch ein bereits ausgestelltes PVE-Ticket. Ohne aktivierten optionalen Logout-Patch beendet lokales PVE-Logout die Keycloak-SSO-Session nicht automatisch.
## Prüfung und Fehlerdiagnose ## Prüfung und Fehlerdiagnose
@@ -190,3 +190,152 @@ Das Paket wird lokal auf YAML-/Ansible-Syntax und ausgewählte Entscheidungslogi
- [Keycloak Truststore](https://www.keycloak.org/server/keycloak-truststore) - [Keycloak Truststore](https://www.keycloak.org/server/keycloak-truststore)
- [Keycloak Session-Verwaltung](https://www.keycloak.org/docs/latest/server_admin/) - [Keycloak Session-Verwaltung](https://www.keycloak.org/docs/latest/server_admin/)
- [Keycloak Client-Session-Attributnamen](https://github.com/keycloak/keycloak/blob/main/server-spi-private/src/main/java/org/keycloak/protocol/oidc/OIDCConfigAttributes.java) - [Keycloak Client-Session-Attributnamen](https://github.com/keycloak/keycloak/blob/main/server-spi-private/src/main/java/org/keycloak/protocol/oidc/OIDCConfigAttributes.java)
## Optional: PVE-Logout → Keycloak-Logout (ab 1.2.0)
Im Einrichtungsassistenten die Logout-Frage mit `j` beantworten. Für eine bereits
vorhandene Konfiguration diese zwei Werte in `group_vars/all.yml` ergänzen
(bei JSON-Syntax innerhalb des vorhandenen Objekts):
```yaml
pve_logout_enabled: true
pve_logout_redirect_uri: https://ts01.heim.lan:8006/
```
Die Rücksprungadresse muss exakt in `pve_redirect_uris` enthalten sein. Dann entweder
den vollständigen Lauf verwenden oder bei bereits eingerichtetem CA-/OIDC-Setup:
```bash
ansible-playbook -i inventory/hosts.local.yml playbook/logout.yml --ask-vault-pass
```
`logout.yml` gleicht zunächst die vorhandene Keycloak-Konfiguration mit den
Projektvariablen ab, einschließlich Realm-Sessions, Client, Gruppen und Mappern.
Es setzt zusätzlich das Clientattribut `post.logout.redirect.uris` auf die gewählte
Rücksprungadresse (eine eventuell vorhandene Logout-Redirect-Liste wird ersetzt).
Danach prüft PVE den Discovery-Endpunkt mit TLS-CA-Verifikation und installiert den Patch.
Der Desktop-Logout merkt sich vor der lokalen Abmeldung den Benutzernamen. Nur beim
Suffix `@<pve_realm>` leitet er nach der normalen lokalen Abmeldung zum verifizierten
Keycloak-Logout-Endpunkt weiter, mit `client_id` und `post_logout_redirect_uri`.
PAM-/andere Realms bleiben im normalen Ablauf. Es werden keine Client-Secrets in
JavaScript oder URLs eingebaut. Ohne `id_token_hint` kann Keycloak eine Bestätigung
anzeigen; diese muss der Benutzer abschließen. Erst dann ist auch die Keycloak-SSO-
Session beendet. Andere Anwendungen können von der beendeten SSO-Session betroffen sein.
Der Patch gilt für den **Desktop-Logout-Button**. Er implementiert weder Backchannel-
Logout noch eine serverseitige Sperrung bereits ausgestellter PVE-Tickets, mobile
Oberflächen oder ein synchronisiertes Logout sämtlicher Browser-Tabs.
### Sicherung, Updates und Rückbau
- Ziel: `/usr/share/pve-manager/js/pvemanagerlib.js`, nur PVE 9 und genau ein bekannter
Logout-Codeblock. Unbekannte/minifizierte Varianten oder vorkomprimierte Sidecars
führen zum Abbruch; eine Major-Version allein gilt nicht als Kompatibilitätsnachweis.
- Originaldatei und SHA-256-Prüfsummen werden unter `/var/lib/pve-idm/logout` gesichert.
Identischer zweiter Lauf ändert nichts. Manuelle Änderungen an einem gepatchten
Bundle führen zum Abbruch, statt fremde Änderungen zu überschreiben.
- PVE-Paketupdates können den Patch ersetzen. Danach `logout.yml` erneut ausführen.
Der neue Originalstand wird separat gesichert. Es gibt keinen unbeaufsichtigten
Update-Hook. Bei geändertem Logout-Code ist eine erneute Anpassung erforderlich.
- Nach Installation/Rückbau die PVE-Seite vollständig neu laden, ggf. Browsercache
leeren. Bereits geöffnete Tabs enthalten noch die alte JavaScript-Version.
- Rückbau ohne Vault und ohne Keycloak-Zugriff:
```bash
ansible-playbook -i inventory/hosts.local.yml playbook/logout-remove.yml
```
Danach `pve_logout_enabled: false` speichern, damit spätere Gesamtläufe den Patch
nicht erneut aktivieren. Alternativ entfernt ein Gesamtlauf mit `false` den Patch.
Der Rückbau stellt nur die nachweislich zugehörige Originaldatei wieder her; nach
Paketupdates wird keine ältere Datei zurückkopiert. Sicherungen und die zugelassene
Keycloak-Rücksprungadresse bleiben erhalten.
### Abnahme auf den Zielhosts
1. Desktop-Seite neu laden, OIDC-Benutzer anmelden, Logout drücken.
2. Prüfen: lokale PVE-Abmeldung, Keycloak-Bestätigung, danach Rückkehr zu PVE.
3. Erneut anmelden: Keycloak sollte eine neue Authentifizierung verlangen, sofern
kein vorgeschalteter Identity Provider erneut automatisch anmeldet.
4. Mit `root@pam` prüfen, dass keine Keycloak-Weiterleitung erfolgt.
5. Zweiten Ansible-Lauf und anschließend bei Bedarf Rückbau prüfen.
Lokal getestet werden Patch/Rückbau, Idempotenz, Paketupdate-Verhalten und Ablehnung
veränderter Dateien. Ein Browser-/Integrationstest auf deinen Hosts steht aus.
### Rückbau über den Einrichtungsassistenten (ab 1.2.1)
```bash
python3 setup.py --rollback-logout
```
Fragt Inventory, SSH-/sudo-Passwortbedarf und die Ausführung ab. Nach erfolgreichem
Rückbau speichert der Assistent `pve_logout_enabled: false` in der lokalen Konfiguration,
damit spätere Gesamtläufe den Patch nicht erneut installieren. Kein Vault-Passwort nötig.
Bei fehlgeschlagenem Rückbau bleibt die lokale Einstellung unverändert.
Bei einer rein manuellen Installation ohne lokale Ansible-Konfiguration direkt auf PVE:
```bash
python3 /root/pve-idm-logout-patch.py \
--target /usr/share/pve-manager/js/pvemanagerlib.js \
--state-dir /var/lib/pve-idm/logout \
--enabled false
```
Auch dieser Rückbau ist bereits im Patch-Skript eingebaut. Anschließend die PVE-Seite
vollständig neu laden. Keycloak-Konfiguration und Sicherungsdateien bleiben erhalten.
## Keycloak-Logout über IP und FQDN (ab 1.3.0)
Im Assistenten `Keycloak über IP UND FQDN abmelden?` mit `j` beantworten und
`https://9.99.30.11:8443` sowie `https://keycloak.service.heim.lan:8443` eingeben.
Alternativ in der lokalen Konfiguration:
```yaml
pve_logout_enabled: true
pve_logout_redirect_uri: https://192.168.1.231:8006/
pve_logout_endpoints:
- https://9.99.30.11:8443/realms/main.heim.lan/protocol/openid-connect/logout
- https://keycloak.service.heim.lan:8443/realms/main.heim.lan/protocol/openid-connect/logout
```
Die Rücksprungadresse muss in `pve_redirect_uris` stehen. PVE-Zugriff per IP und DNS
ist über mehrere Einträge in dieser Liste möglich. Die Logout-Rückkehr erfolgt zur
gewählten festen Adresse. Andere PVE-Tabs/Host-Cookies werden dadurch nicht gelöscht.
Der Browser meldet die Keycloak-Sitzung zunächst über die erste, dann über die zweite
Adresse ab. Die zweite Logout-URL einschließlich ihrer kodierten Rücksprungadresse
wird als exakter erlaubter Post-Logout-Redirect am Client registriert, ebenso die finale
PVE-Adresse. Es gibt keine Wildcard-Freigabe. Der Assistent/Ansible erzeugt die Kodierung;
nicht manuell Markdown-Links in URLs einsetzen. Die vorhandene Post-Logout-Redirect-Liste
wird durch die für diesen Ablauf benötigten Einträge ersetzt.
Bis zu zwei Bestätigungsseiten sind möglich. Erst nach Abschluss der gesamten Kette
sind beide Browser-Sitzungen angesprochen worden. Abbruch, Nichterreichbarkeit eines
Hosts oder ein vorgeschalteter Identity Provider können den Ablauf unterbrechen bzw.
eine neue automatische Anmeldung verursachen. Der Ablauf ist kein serverseitiger
Global-Logout aller Sitzungen des Benutzers auf anderen Geräten.
Beide Adressen brauchen gültiges HTTPS: im Zertifikat DNS-SAN für den FQDN und IP-SAN
für `9.99.30.11` (oder passende separate Zertifikate). Die CA-Prüfung wird nicht
abgeschaltet. Ein Fehler hierbei muss an Zertifikat/Truststore behoben werden.
Es bleibt **ein kanonischer OIDC-Issuer**. IP und FQDN sind Zugriffsaliase desselben
Realms; die Discovery-Antwort beider Aliase muss denselben Issuer liefern. Die bestehende
Issuer-Konfiguration nicht allein aufgrund der Browser-URL ändern. Wenn beide Aliase
unterschiedliche Issuer ausliefern, Keycloaks Hostname-Konfiguration zuerst vereinheitlichen.
Der Logout-Modus ändert weder den Login-Issuer noch Serverzertifikate automatisch.
Installation auf bereits eingerichteten Hosts:
```bash
ansible-playbook -i inventory/hosts.local.yml playbook/logout.yml --ask-vault-pass
```
Danach PVE mit deaktiviertem Browsercache neu laden. Je einen Testlogin über die
verwendeten Keycloak-Adressen durchführen und nach vollständigem Logout die Sessions
prüfen, bevor erneut angemeldet wird. Lokal sind Kodierung, Patch, Realm-Zuordnung,
Rückbau und Wiederholung geprüft; der vollständige Ablauf auf deinem Keycloak steht aus.
+1 -1
View File
@@ -1 +1 @@
1.1.0 1.3.0
+7
View File
@@ -48,3 +48,10 @@ pve_roles:
- PVEUserAdmin - PVEUserAdmin
- PVEVMAdmin - PVEVMAdmin
- PVEVMUser - PVEVMUser
# Optionaler PVE-Desktop-Logout-Patch (Keycloak fragt ggf. nach Bestätigung).
pve_logout_enabled: false
pve_logout_redirect_uri: "{{ pve_redirect_uris[0] }}"
# Leer: Discovery-Endpunkt. Optional IP und FQDN desselben Keycloak-Realms.
# Beide TLS-Zertifikatsnamen müssen gültig sein; maximal zwei Endpunkte.
pve_logout_endpoints: []
@@ -0,0 +1,9 @@
"""Shared deterministic logout URL encoding for Ansible and the PVE patch."""
import importlib.util
from pathlib import Path
spec = importlib.util.spec_from_file_location('pve_idm_patch', Path(__file__).resolve().parents[2] / 'scripts/logout_patch.py')
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
class FilterModule:
def filters(self):
return {'pve_idm_logout_plan': module.logout_plan}
+10
View File
@@ -0,0 +1,10 @@
- name: Remove PVE logout patch without downgrading package files
hosts: pve
become: true
gather_facts: false
vars_files:
- ../group_vars/all.yml
tasks:
- ansible.builtin.import_tasks: ../tasks/logout.yml
vars:
pve_logout_enabled: false
+19
View File
@@ -0,0 +1,19 @@
- name: Register logout return URI on existing Keycloak
hosts: keycloak
become: true
gather_facts: false
vars_files:
- ../group_vars/all.yml
- ../group_vars/vault.yml
tasks:
- ansible.builtin.import_tasks: ../tasks/keycloak.yml
when: pve_logout_enabled | default(false) | bool
- name: Configure PVE desktop logout
hosts: pve
become: true
gather_facts: false
vars_files:
- ../group_vars/all.yml
tasks:
- ansible.builtin.import_tasks: ../tasks/logout.yml
+1
View File
@@ -33,3 +33,4 @@
tasks: tasks:
- ansible.builtin.import_tasks: ../tasks/pve.yml - ansible.builtin.import_tasks: ../tasks/pve.yml
- ansible.builtin.import_tasks: ../tasks/acl.yml - ansible.builtin.import_tasks: ../tasks/acl.yml
- ansible.builtin.import_tasks: ../tasks/logout.yml
+137
View File
@@ -0,0 +1,137 @@
#!/usr/bin/env python3
"""Guarded PVE 9 desktop logout patch. No credentials are used."""
import argparse
import hashlib
import json
import os
from pathlib import Path
import re
import tempfile
from urllib.parse import urlsplit, urlencode
MARK = '/* PVE-IDM LOGOUT v1 */'
ANCHOR = re.compile(r"(text:\s*gettext\('Logout'\),\s*handler:\s*function\s*\(\)\s*\{)(\s*PVE\.data\.ResourceStore\.loadData\(\[\],\s*false\);\s*me\.showLogin\(\);)")
def digest(data):
return hashlib.sha256(data).hexdigest()
def write(path, data, mode=0o600, owner=None):
fd, tmp = tempfile.mkstemp(dir=path.parent)
try:
with os.fdopen(fd, 'wb') as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
os.chmod(tmp, mode)
if owner is not None:
os.chown(tmp, *owner)
os.replace(tmp, path)
finally:
if os.path.exists(tmp):
os.unlink(tmp)
def logout_plan(endpoints, client, redirect):
if not isinstance(endpoints, list) or not 1 <= len(endpoints) <= 2 or len(set(endpoints)) != len(endpoints):
raise ValueError('Ein oder zwei unterschiedliche Keycloak-Logout-Endpunkte erforderlich.')
for url in endpoints + [redirect]:
u = urlsplit(url)
if (u.scheme != 'https' or not u.hostname or u.username or u.password or
u.fragment or u.query or any(c.isspace() for c in url) or '*' in url):
raise ValueError('Nur exakte HTTPS-Adressen ohne Query oder Zugangsdaten verwenden.')
for endpoint in endpoints:
if not urlsplit(endpoint).path.endswith('/protocol/openid-connect/logout'):
raise ValueError('Keycloak-Logout-Endpunkt erwartet.')
result = redirect
allowed = []
for endpoint in reversed(endpoints):
allowed.append(result)
result = endpoint + '?' + urlencode({'client_id': client, 'post_logout_redirect_uri': result})
return {'url': result, 'allowed_redirects': allowed, 'endpoints': endpoints}
def render(text, realm, endpoint, client, redirect, endpoints=None):
if MARK in text or len(list(ANCHOR.finditer(text))) != 1:
raise ValueError('Unbekannter oder mehrdeutiger Logout-Code; keine Änderung.')
for url in (endpoint, redirect):
u = urlsplit(url)
if u.scheme != 'https' or not u.hostname or u.username or u.password or u.fragment or u.query:
raise ValueError('Nur feste HTTPS-URLs ohne Query/Zugangsdaten erlaubt.')
if endpoints:
plan = logout_plan(endpoints, client, redirect)
logout_url = plan['url']
else:
logout_url = endpoint + '?' + urlencode({'client_id': client, 'post_logout_redirect_uri': redirect})
cfg = json.dumps(dict(realm=realm, endpoint=endpoint, client=client, redirect=redirect, logoutUrl=logout_url), ensure_ascii=True)
def replace(match):
return (match[1] + '\n' + MARK + '\n'
'const pveIdmUser = Proxmox.UserName || "";\n'
'const pveIdmConfig = ' + cfg + ';\n' + match[2] + '\n'
'if (pveIdmUser.endsWith("@" + pveIdmConfig.realm)) {\n'
' const pveIdmUrl = new URL(pveIdmConfig.logoutUrl);\n'
' window.setTimeout(function () { window.location.assign(pveIdmUrl.href); }, 0);\n'
'}\n/* END PVE-IDM LOGOUT v1 */\n')
return ANCHOR.sub(replace, text)
def apply(target, directory, enabled, version='', realm='', endpoint='', client='', redirect='', endpoints=None):
if target.is_symlink() or not target.is_file():
raise ValueError('JavaScript-Ziel muss eine reguläre Datei sein.')
current = target.read_bytes()
statefile = directory / 'state.json'
state = json.loads(statefile.read_text()) if statefile.exists() else None
base = current
if MARK.encode() in current:
if not state or state['patched_sha256'] != digest(current) or state['target'] != str(target):
raise ValueError('Veränderter Patch oder fehlende Sicherungsdaten; automatischer Eingriff gestoppt.')
base = (directory / state['backup']).read_bytes()
if digest(base) != state['original_sha256']:
raise ValueError('Sicherung beschädigt; keine Änderung.')
elif not enabled:
return False # Already removed by a package update: never restore an old bundle.
if enabled:
if not re.search(r'pve-manager/9\.', version):
raise ValueError('Nur PVE 9 wird unterstützt.')
for suffix in ('.gz', '.br'):
if Path(str(target) + suffix).exists():
raise ValueError('Vorkomprimiertes JS gefunden; Auslieferung zuerst prüfen.')
desired = render(base.decode(), realm, endpoint, client, redirect, endpoints).encode()
else:
desired = base
if desired == current:
return False
directory.mkdir(parents=True, exist_ok=True, mode=0o700)
stat = target.stat()
if enabled:
backup = digest(base) + '.js.orig'
backupfile = directory / backup
if backupfile.exists() and backupfile.read_bytes() != base:
raise ValueError('Sicherungskollision.')
if not backupfile.exists():
write(backupfile, base)
# Save recovery metadata before replacing the target; inconsistent states fail closed.
write(statefile, json.dumps(dict(target=str(target), backup=backup,
original_sha256=digest(base), patched_sha256=digest(desired), version=version)).encode())
write(target, desired, stat.st_mode & 0o777, (stat.st_uid, stat.st_gid))
return True
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--target', required=True)
parser.add_argument('--state-dir', required=True)
parser.add_argument('--enabled', choices=['true', 'false'], required=True)
for option in ('version', 'realm', 'endpoint', 'client', 'redirect'):
parser.add_argument('--' + option, default='')
parser.add_argument('--endpoints-json', default='[]', help='JSON-Liste mit maximal zwei Logout-Endpunkten')
args = vars(parser.parse_args())
args['endpoints'] = json.loads(args.pop('endpoints_json'))
args['target'] = Path(args['target'])
args['directory'] = Path(args.pop('state_dir'))
args['enabled'] = args['enabled'] == 'true'
try:
print(json.dumps({'changed': apply(**args)}))
except (ValueError, OSError, KeyError) as exc:
parser.exit(1, str(exc) + '\n')
+51 -1
View File
@@ -1,5 +1,6 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
"""Interactive configuration for PVE-IDM; Python standard library only.""" """Interactive configuration for PVE-IDM; Python standard library only."""
import argparse
import getpass import getpass
import ipaddress import ipaddress
import json import json
@@ -157,6 +158,39 @@ def atomic_write(path, content):
os.unlink(temporary) os.unlink(temporary)
def rollback_logout():
"""Remove the remote patch and disable reinstallation in local configuration."""
os.chdir(ROOT)
executable = shutil.which('ansible-playbook')
if not executable:
raise RuntimeError('Ansible fehlt. Bitte zuerst die Ansible-Python-Umgebung aktivieren.')
config_path = ROOT / 'group_vars/all.yml'
if not config_path.is_file():
raise RuntimeError('group_vars/all.yml fehlt. Für eine manuelle Installation den Rückbau-Befehl aus der README direkt auf PVE verwenden.')
try:
import yaml
config = yaml.safe_load(config_path.read_text())
except (ImportError, ValueError) as exc:
raise RuntimeError('Konfiguration kann nicht gelesen werden. Bitte die Ansible-Python-Umgebung verwenden.') from exc
if not isinstance(config, dict):
raise RuntimeError('group_vars/all.yml muss eine YAML-Zuordnung enthalten.')
inventory_default = 'inventory/hosts.local.yml' if (ROOT / 'inventory/hosts.local.yml').exists() else 'inventory/hosts.yml'
inventory = ask('Inventory für den Rückbau', inventory_default, local_file)
command = [executable, '-i', str(Path(inventory).expanduser().resolve()), 'playbook/logout-remove.yml']
if yes('SSH-Passwort abfragen?'):
command.append('--ask-pass')
if yes('sudo-Passwort abfragen?'):
command.append('--ask-become-pass')
print('Entfernt nur den verwalteten PVE-Logout-Patch. Keycloak/OIDC und Sicherungen bleiben erhalten.')
if not yes('Logout-Patch auf den PVE-Hosts dieses Inventory jetzt zurückbauen?'):
print('Abgebrochen; keine Änderung.')
return
subprocess.run(command, check=True)
config['pve_logout_enabled'] = False
atomic_write(config_path, yaml.safe_dump(config, allow_unicode=True, sort_keys=False).encode())
print('Rückbau abgeschlossen; pve_logout_enabled=false gespeichert. PVE im Browser vollständig neu laden.')
def main(): def main():
os.chdir(ROOT) os.chdir(ROOT)
if not sys.stdin.isatty(): if not sys.stdin.isatty():
@@ -197,6 +231,16 @@ def main():
https_url(url.strip(), root=True) https_url(url.strip(), root=True)
config['pve_redirect_uris'] = list(dict.fromkeys(u.strip() for u in ask( config['pve_redirect_uris'] = list(dict.fromkeys(u.strip() for u in ask(
'PVE-Browser-URLs, mehrere mit Komma trennen', 'https://ts01.heim.lan:8006/', redirects).split(','))) 'PVE-Browser-URLs, mehrere mit Komma trennen', 'https://ts01.heim.lan:8006/', redirects).split(',')))
config['pve_logout_enabled'] = yes('PVE-Logout zu Keycloak weiterleiten (optionaler WebUI-Patch)?', True)
config['pve_logout_redirect_uri'] = ask('Rücksprung nach Keycloak-Logout', config['pve_redirect_uris'][0],
lambda v: None if v in config['pve_redirect_uris'] else invalid('Eine der angegebenen PVE-Browser-URLs wählen.'))
config['pve_logout_endpoints'] = []
if config['pve_logout_enabled'] and yes('Keycloak über IP UND FQDN abmelden?'):
for label in ('Erste Keycloak-Adresse (z. B. https://9.99.30.11:8443)', 'Zweite Keycloak-Adresse (FQDN)'):
base = ask(label, '', https_url)
config['pve_logout_endpoints'].append(base + '/realms/' + config['keycloak_realm'] + '/protocol/openid-connect/logout')
if len(set(config['pve_logout_endpoints'])) != 2:
raise RuntimeError('Für dualen Logout zwei unterschiedliche Adressen verwenden.')
print('\nSessions in Sekunden: 900 = 15 Minuten; 28800 = 8 Stunden') print('\nSessions in Sekunden: 900 = 15 Minuten; 28800 = 8 Stunden')
while True: while True:
for key, label, default in [ for key, label, default in [
@@ -271,7 +315,13 @@ def main():
if __name__ == '__main__': if __name__ == '__main__':
try: try:
main() parser = argparse.ArgumentParser(description='PVE-IDM Einrichtung und Logout-Rückbau')
parser.add_argument('--rollback-logout', action='store_true', help='Logout-Patch entfernen und lokal deaktivieren')
args = parser.parse_args()
if args.rollback_logout:
rollback_logout()
else:
main()
except (KeyboardInterrupt, EOFError): except (KeyboardInterrupt, EOFError):
print('\nAbgebrochen.', file=sys.stderr) print('\nAbgebrochen.', file=sys.stderr)
sys.exit(130) sys.exit(130)
+11
View File
@@ -9,6 +9,10 @@
unredirected_headers: [Authorization] unredirected_headers: [Authorization]
timeout: 30 timeout: 30
block: block:
- name: Validate optional logout redirect before API changes
ansible.builtin.assert:
that: pve_logout_redirect_uri in pve_redirect_uris
when: pve_logout_enabled | default(false) | bool
- name: Obtain short-lived admin token - name: Obtain short-lived admin token
ansible.builtin.uri: ansible.builtin.uri:
url: "{{ keycloak_base_url }}/realms/{{ keycloak_admin_realm }}/protocol/openid-connect/token" url: "{{ keycloak_base_url }}/realms/{{ keycloak_admin_realm }}/protocol/openid-connect/token"
@@ -100,6 +104,13 @@
kc_session_attributes: kc_session_attributes:
client.session.idle.timeout: "{{ keycloak_client_idle | string }}" client.session.idle.timeout: "{{ keycloak_client_idle | string }}"
client.session.max.lifespan: "{{ keycloak_client_max | string }}" client.session.max.lifespan: "{{ keycloak_client_max | string }}"
- name: Prepare verified logout redirect chain
ansible.builtin.include_tasks: logout_plan.yml
when: pve_logout_enabled | default(false) | bool
- name: Register explicit post-logout return address
ansible.builtin.set_fact:
kc_session_attributes: "{{ kc_session_attributes | combine({'post.logout.redirect.uris': logout_plan.allowed_redirects | join('##')}) }}"
when: pve_logout_enabled | default(false) | bool
- name: Create confidential PVE client - name: Create confidential PVE client
ansible.builtin.uri: ansible.builtin.uri:
url: "{{ kc_api }}/clients" url: "{{ kc_api }}/clients"
+44
View File
@@ -0,0 +1,44 @@
- name: Reject unsupported patch dry-run
ansible.builtin.assert:
that: not ansible_check_mode
fail_msg: 'Logout-Patch bitte regulär ausführen; --check wird nicht unterstützt.'
- name: Read installed PVE version
ansible.builtin.command: pveversion
register: logout_version
changed_when: false
when: pve_logout_enabled | default(false) | bool
- name: Prepare verified logout sequence
ansible.builtin.include_tasks: logout_plan.yml
when: pve_logout_enabled | default(false) | bool
- name: Install guarded patch helper
ansible.builtin.copy:
src: ../scripts/logout_patch.py
dest: /usr/local/sbin/pve-idm-logout-patch
owner: root
group: root
mode: '0700'
- name: Apply or remove managed desktop logout patch
ansible.builtin.command:
argv:
- python3
- /usr/local/sbin/pve-idm-logout-patch
- --target
- /usr/share/pve-manager/js/pvemanagerlib.js
- --state-dir
- /var/lib/pve-idm/logout
- --enabled
- "{{ (pve_logout_enabled | default(false) | bool) | ternary('true', 'false') }}"
- --version
- "{{ logout_version.stdout | default('') }}"
- --realm
- "{{ pve_realm }}"
- --endpoint
- "{{ (logout_discovery.json | default({})).get('end_session_endpoint', '') }}"
- --endpoints-json
- "{{ (logout_plan | default({})).get('endpoints', []) | to_json }}"
- --client
- "{{ keycloak_client_id }}"
- --redirect
- "{{ pve_logout_redirect_uri | default('') }}"
register: logout_patch_result
changed_when: (logout_patch_result.stdout | from_json).changed
+31
View File
@@ -0,0 +1,31 @@
- name: Read canonical discovery with CA verification
ansible.builtin.uri:
url: "{{ pve_oidc_issuer }}/.well-known/openid-configuration"
validate_certs: true
ca_path: "{{ system_ca_bundle }}"
use_proxy: false
follow_redirects: none
register: logout_discovery
- name: Validate canonical issuer and return address
ansible.builtin.assert:
that:
- logout_discovery.json.issuer == pve_oidc_issuer
- pve_logout_redirect_uri in pve_redirect_uris
- name: Build explicit logout sequence and exact allowed redirects
ansible.builtin.set_fact:
logout_plan: "{{ (pve_logout_endpoints | default([]) or [logout_discovery.json.end_session_endpoint]) | pve_idm_logout_plan(keycloak_client_id, pve_logout_redirect_uri) }}"
- name: Verify both host certificates and realm discovery
ansible.builtin.uri:
url: "{{ item | regex_replace('/protocol/openid-connect/logout$', '/.well-known/openid-configuration') }}"
validate_certs: true
ca_path: "{{ system_ca_bundle }}"
use_proxy: false
follow_redirects: none
loop: "{{ logout_plan.endpoints }}"
register: logout_alias_discovery
- name: Require all aliases to advertise the same canonical realm issuer
ansible.builtin.assert:
that: item.json.issuer == pve_oidc_issuer
loop: "{{ logout_alias_discovery.results }}"
loop_control:
label: "{{ item.item }}"
+119
View File
@@ -0,0 +1,119 @@
import importlib.util
from pathlib import Path
import tempfile
import json
from urllib.parse import urlsplit, parse_qs
import shutil
import subprocess
import unittest
spec = importlib.util.spec_from_file_location('patch', Path(__file__).resolve().parents[1] / 'scripts/logout_patch.py')
patch = importlib.util.module_from_spec(spec)
spec.loader.exec_module(patch)
FIXTURE = """text: gettext('Logout'),
handler: function () {
PVE.data.ResourceStore.loadData([], false);
me.showLogin();
cleanup();
},"""
class LogoutTests(unittest.TestCase):
def test_two_host_redirect_chain(self):
endpoints = ['https://9.99.30.11:8443/realms/main.heim.lan/protocol/openid-connect/logout',
'https://keycloak.service.heim.lan:8443/realms/main.heim.lan/protocol/openid-connect/logout']
plan = patch.logout_plan(endpoints, 'PVE-SERVER', 'https://192.168.1.231:8006/')
first = urlsplit(plan['url'])
self.assertEqual(first.hostname, '9.99.30.11')
next_url = parse_qs(first.query)['post_logout_redirect_uri'][0]
self.assertIn(next_url, plan['allowed_redirects'])
second = urlsplit(next_url)
self.assertEqual(second.hostname, 'keycloak.service.heim.lan')
self.assertEqual(parse_qs(second.query)['post_logout_redirect_uri'], ['https://192.168.1.231:8006/'])
self.assertEqual(len(plan['allowed_redirects']), 2)
for endpoints_bad in ([], endpoints * 2, [endpoints[0]] * 2, ['http://kc/logout'],
['https://kc/logout?next=bad'], ['https://kc/not-logout']):
with self.assertRaises(ValueError):
patch.logout_plan(endpoints_bad, 'PVE-SERVER', 'https://pve/')
def test_lifecycle_and_update(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
target = root / 'bundle.js'
target.write_text(FIXTURE)
args = dict(target=target, directory=root / 'state', enabled=True,
version='pve-manager/9.0.0/test', realm='main.heim.lan',
endpoint='https://kc:8443/realms/main/protocol/openid-connect/logout',
client='PVE-SERVER', redirect='https://ts01:8006/')
self.assertTrue(patch.apply(**args))
self.assertFalse(patch.apply(**args))
self.assertIn('pveIdmUser.endsWith', target.read_text())
self.assertLess(target.read_text().index('me.showLogin();'), target.read_text().index('window.setTimeout'))
args['client'] = 'OTHER'
self.assertTrue(patch.apply(**args))
self.assertTrue(patch.apply(target, root / 'state', False))
self.assertEqual(target.read_text(), FIXTURE)
self.assertFalse(patch.apply(target, root / 'state', False))
patch.apply(**args)
# Package update replaced the entire file; rollback must not downgrade it.
target.write_text(FIXTURE + '\n// new package')
self.assertFalse(patch.apply(target, root / 'state', False))
self.assertTrue(patch.apply(**args))
self.assertTrue(patch.apply(target, root / 'state', False))
self.assertEqual(target.read_text(), FIXTURE + '\n// new package')
def test_unknown_code_rejected(self):
for text in ('unknown', FIXTURE + FIXTURE):
with self.assertRaises(ValueError):
patch.render(text, 'realm', 'https://kc/logout', 'client', 'https://pve/')
def test_tamper_rejected(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
target = root / 'bundle.js'
target.write_text(FIXTURE)
patch.apply(target, root / 'state', True, 'pve-manager/9.1/x', 'realm',
'https://kc/logout', 'client', 'https://pve/')
target.write_text(target.read_text() + '// manual edit')
with self.assertRaises(ValueError):
patch.apply(target, root / 'state', False)
@unittest.skipUnless(shutil.which('node'), 'Node.js not installed')
def test_browser_handler_order_and_realm(self):
code = patch.render(FIXTURE, 'main.heim.lan', 'https://kc/logout', 'PVE-SERVER', 'https://ts01:8006/')
javascript = r"""
const vm = require('vm');
const source = CODE;
for (const user of ['alice@main.heim.lan', 'root@pam']) {
const events = []; const timers = [];
const context = {URL, gettext: x => x,
Proxmox: {UserName: user},
PVE: {data: {ResourceStore: {loadData: () => events.push('clear')}}},
me: {showLogin: () => { events.push('local'); context.Proxmox.UserName = null; }},
cleanup: () => events.push('cleanup'),
window: {setTimeout: f => timers.push(f), location: {assign: u => events.push(u)}}};
vm.runInNewContext('({' + source + '}).handler()', context);
if (events.join(',') !== 'clear,local,cleanup') throw Error('Local cleanup/order failed');
timers.forEach(f => f());
if (user === 'root@pam' && events.length !== 3) throw Error('PAM redirected');
if (user.startsWith('alice')) {
const url = new URL(events[3]);
if (url.origin !== 'https://kc' || url.searchParams.get('client_id') !== 'PVE-SERVER'
|| url.searchParams.get('post_logout_redirect_uri') !== 'https://ts01:8006/') throw Error('Wrong redirect');
}
}
""".replace('CODE', json.dumps(code))
subprocess.run([shutil.which('node'), '-e', javascript], check=True, capture_output=True)
def test_wrong_version_no_write(self):
with tempfile.TemporaryDirectory() as tmp:
root = Path(tmp)
target = root / 'bundle.js'
target.write_text(FIXTURE)
with self.assertRaises(ValueError):
patch.apply(target, root / 'state', True, 'pve-manager/10.0/x')
self.assertEqual(target.read_text(), FIXTURE)
if __name__ == '__main__':
unittest.main()
+23
View File
@@ -5,6 +5,7 @@ import shutil
import subprocess import subprocess
import tempfile import tempfile
import unittest import unittest
from unittest.mock import patch
spec = importlib.util.spec_from_file_location('wizard', Path(__file__).resolve().parents[1] / 'setup.py') spec = importlib.util.spec_from_file_location('wizard', Path(__file__).resolve().parents[1] / 'setup.py')
wizard = importlib.util.module_from_spec(spec) wizard = importlib.util.module_from_spec(spec)
@@ -35,6 +36,28 @@ class SetupTests(unittest.TestCase):
self.assertEqual(target.stat().st_mode & 0o777, 0o600) self.assertEqual(target.stat().st_mode & 0o777, 0o600)
self.assertEqual(len(list(Path(folder).iterdir())), 1) self.assertEqual(len(list(Path(folder).iterdir())), 1)
def test_rollback_success_and_failure(self):
for fail in (False, True):
with tempfile.TemporaryDirectory() as folder:
root = Path(folder)
(root / 'group_vars').mkdir()
config = root / 'group_vars/all.yml'
config.write_text('pve_logout_enabled: true\npve_realm: main.heim.lan\n')
previous = Path.cwd()
try:
with patch.object(wizard, 'ROOT', root), patch.object(wizard.shutil, 'which', return_value='/test/ansible-playbook'), patch.object(wizard, 'ask', return_value='inventory.yml'), patch.object(wizard, 'yes', side_effect=[False, False, True]), patch.object(wizard.subprocess, 'run') as run:
if fail:
run.side_effect = subprocess.CalledProcessError(1, 'test')
with self.assertRaises(subprocess.CalledProcessError):
wizard.rollback_logout()
self.assertIn('pve_logout_enabled: true', config.read_text())
else:
wizard.rollback_logout()
self.assertIn('pve_logout_enabled: false', config.read_text())
self.assertNotIn('--ask-vault-pass', run.call_args.args[0])
finally:
os.chdir(previous)
@unittest.skipUnless(shutil.which('ansible-vault'), 'ansible-vault not installed') @unittest.skipUnless(shutil.which('ansible-vault'), 'ansible-vault not installed')
def test_real_vault_roundtrip(self): def test_real_vault_roundtrip(self):
payload = {'test': 'fake-test-value-with-umlaut-ä'} payload = {'test': 'fake-test-value-with-umlaut-ä'}
+16
View File
@@ -0,0 +1,16 @@
# Lokale Geheimnisse und Laufzeitdaten
.env
.env.*
!.env.example
*.local.*
secrets/
*.key
*.pem
*.p12
*.pfx
*.jks
kcadm.config
.kcadm.config
*.log
__pycache__/
.DS_Store
+202
View File
@@ -0,0 +1,202 @@
# PegaProx mit Keycloak über OIDC
Git-taugliche Einrichtungsanleitung, rekonstruiert aus „OIDC Endpunkte korrigieren“ vom 09.09.2026. Alle internen Adressen, Namen und IPs sind **Beispielwerte aus der Unterhaltung** und müssen für andere Umgebungen ersetzt werden. Keine Zugangsdaten enthalten.
## Nachweis und Grenzen
Der Benutzer bestätigte abschließend, dass die Anmeldung und Rollenzuordnung funktionieren. Belegt sind erfolgreiche Discovery-Abfragen mit curl und Python, der Claim `groups: ["pegaprox-admins"]` und die abschließende Zuordnung in PegaProx. Nach dem Vorschlag eines PegaProx-Neustarts und alternativ eines kurzen Tests ohne TLS-Prüfung wurde Erfolg gemeldet; welche Maßnahme tatsächlich ausgeführt wurde, ist nicht eindeutig dokumentiert. Der finale Schalterstand von „Skip SSL verification“ ist nicht belegt. Diese Anleitung setzt ihn für den sicheren Zielzustand auf OFF und fordert einen erneuten Test.
Exakte PegaProx- und Keycloak-Versionen fehlen. UI-Bezeichnungen beziehen sich auf die Unterhaltung; ergänzende CA- und CLI-Schritte sind reproduzierbare Anleitungen, keine Behauptung über bereits ausgeführte Änderungen. Ein Quellcode-Patch ist nicht als ausgeführt belegt und wird nicht benötigt, wenn Discovery funktioniert.
## Repo-Struktur
```text
README.md
docs/troubleshooting.md
docs/verification.md
example-configs/keycloak-client.example.json
example-configs/pegaprox-groups-scope.example.json
example-configs/pegaprox-oidc.example.json
example-configs/discovery.example.json
example-configs/pegaprox-ca.conf.example
scripts/check-discovery.py
.gitignore
```
## 1. Voraussetzungen und Beispielumgebung
| Zweck | Beispielwert |
|---|---|
| Keycloak | `https://9.99.30.11:8443` |
| Realm | `service.heim.lan` |
| Client ID (Großschreibung beachten) | `PegaProx` |
| PegaProx | `https://9.99.30.13:5000` |
| Callback | `https://9.99.30.13:5000/oidc/callback` |
| Zertifikats-CN | `keycloak.service.heim.lan` |
| Aussteller des Serverzertifikats | `HEIMLAN_SubCA` |
| System-CA-Bundle | `/etc/ssl/certs/ca-certificates.crt` |
| PegaProx-Dienst / Benutzer | `pegaprox` |
| Python / Anwendung | `/usr/bin/python3`, `/usr/lib/pegaprox/pegaprox_multi_cluster.py` |
Keycloak und PegaProx sind bereits installiert. Benötigt werden Realm-Administrationsrechte, ein lokaler PegaProx-Administrator, Netzwerkzugriff vom Browser auf beide Dienste und vom PegaProx-Dienst auf Keycloak:8443 sowie korrekte Systemzeiten. Für Diagnosen: curl, Python 3 mit requests; optional die Keycloak Admin CLI.
Die Adressen `9.99.30.x` wurden intern verwendet, gehören aber nicht zu den privaten RFC1918-Netzen. Nicht als frei verfügbare Lab-Adressen übernehmen. Der alternative Name `auth.service.heim.lan` war im Chat nur ein Vorschlag, kein nachgewiesener finaler Issuer. Ein Wechsel von IP auf DNS erfordert konsistente Issuer-, Zertifikats- und Client-Einstellungen.
## 2. Keycloak-Client anlegen
Im Realm `service.heim.lan`: **Clients → Create client**. Client type **OpenID Connect**, Client ID **PegaProx**.
| Einstellung | Wert |
|---|---|
| Client authentication | ON (vertraulicher Client) |
| Authorization | OFF |
| Standard flow | ON |
| Direct access grants | OFF |
| Implicit flow | OFF |
| Service accounts roles | OFF |
| Root URL / Home URL | `https://9.99.30.13:5000` |
| Valid redirect URIs | `https://9.99.30.13:5000/oidc/callback` |
| Web origins | `https://9.99.30.13:5000` |
Speichern. Unter **Credentials** das erzeugte Client Secret ausschließlich in PegaProx eintragen. Es wird weder in dieser Repo-Struktur noch in einem Export gespeichert. Die JSON-Datei ist eine Vorlage für einen neuen Client; bei vorhandenem Client die UI-Werte abgleichen, nicht blind erneut importieren.
Die beobachtete Anmeldung verwendet Authorization Code Flow mit PKCE S256 (`response_type=code`, `code_challenge_method=S256`). Eine zwingende PKCE-Clientrichtlinie war nicht nachgewiesen. Post-Logout-Redirects sind für diesen Login nicht nötig; nur bei tatsächlich eingerichtetem Logout mit dessen exaktem Rücksprungziel ergänzen. Das früher vorgeschlagene `https://9.99.30.13:5000/*` ist kein nachgewiesener finaler Logout-Wert.
## 3. TLS-Vertrauen herstellen und Discovery prüfen
Im tatsächlichen PegaProx-Host bzw. Container prüfen, nicht nur auf einem anderen Rechner:
```bash
curl --fail --show-error --silent \
'https://9.99.30.11:8443/realms/service.heim.lan/.well-known/openid-configuration'
python3 scripts/check-discovery.py
```
Erwartet: HTTP 200, JSON und exakt der konfigurierte Issuer. Die Endpunkte werden aus Discovery bezogen:
| Feld | Beispiel-URL |
|---|---|
| issuer | `https://9.99.30.11:8443/realms/service.heim.lan` |
| Discovery | `https://9.99.30.11:8443/realms/service.heim.lan/.well-known/openid-configuration` |
| authorization_endpoint | `https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/auth` |
| token_endpoint | `https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/token` |
| jwks_uri | `https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/certs` |
| userinfo_endpoint | `https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/userinfo` |
Der UserInfo-Pfad ist der Keycloak-Standard; sein vollständiger Wert war im ursprünglichen curl-Auszug abgeschnitten. Die anderen Endpunkte waren sichtbar. Keycloak dokumentiert Discovery und diese Endpunkte in der [OIDC-Dokumentation](https://www.keycloak.org/securing-apps/oidc-layers).
Falls die interne CA noch fehlt, auf Debian/Ubuntu im PegaProx-System die vertrauenswürdig beschaffte öffentliche Root-CA installieren (Dateiname hier neu gewähltes Beispiel):
```bash
sudo install -m 0644 /pfad/zur/geprueften/heimlan-root-ca.crt \
/usr/local/share/ca-certificates/heimlan-root-ca.crt
sudo update-ca-certificates
sudo systemctl restart pegaprox
```
Die Datei muss ein PEM-Zertifikat enthalten; pro `.crt` eine CA. Die Serverkette sollte benötigte Intermediate-Zertifikate liefern. Fehlende Intermediate-Ketten am Keycloak-TLS-Endpunkt korrigieren. Keine privaten Schlüssel kopieren. Bei Containern die CA dauerhaft im Image oder vorgesehenen Truststore bereitstellen; Änderungen nur am Host reichen nicht.
Im Chat vertrauten curl und Python der CA bereits: curl meldete „SSL certificate verify ok“, IP-SAN passend zu `9.99.30.11`, HTTP 200. requests und certifi verwendeten beide das System-Bundle. Ein grundsätzlich defektes Zertifikat oder ein abweichendes certifi-Bundle war damit für diese Shell nicht belegt.
Nach einer CA-/Dienständerung PegaProx neu starten und den integrierten OIDC-Test wiederholen. Bei weiterem Fehler siehe [TLS-Diagnose](docs/troubleshooting.md). „Skip SSL verification“ bleibt im Zielzustand **OFF**; ein erfolgreicher Test nur mit abgeschalteter Prüfung ist kein abgeschlossener TLS-Fix.
## 4. PegaProx-OIDC-Einstellungen
**OIDC / Entra ID** öffnen und OIDC aktivieren, soweit separat vorhanden:
| Einstellung | Wert |
|---|---|
| Provider | Generic OIDC (`generic`) |
| Issuer / Authority | `https://9.99.30.11:8443/realms/service.heim.lan` |
| Client ID | `PegaProx` |
| Client Secret | lokal aus Keycloak Credentials einsetzen |
| Scopes | `openid profile email` |
| Redirect URI | `https://9.99.30.13:5000/oidc/callback` |
| JWT-Signaturprüfung | aktiviert |
| Skip SSL verification | OFF, abschließend überprüfen |
| Allow private IP | nur bei beabsichtigtem internem IdP und konkreter SSRF-Blockierung erforderlich; finaler Chat-Wert unbekannt |
| Auto-create users on first login | ON |
| Default Role (no group match) | Viewer |
In das Issuer-Feld gehört weder die Discovery-URL noch der `/auth`-Endpunkt. **Save OIDC Settings**, anschließend OIDC-Test. Discovery muss erfolgreich sein und der Authorization-Endpunkt auf `/protocol/openid-connect/auth` enden. Bei deaktivierter Discovery verwendete die untersuchte Version einen falschen `/authorize`-Fallback.
## 5. Gruppen, Client Scope und Mapper
Im Realm unter **Groups → Create group** anlegen:
```text
pegaprox-admins
pegaprox-users
pegaprox-viewers
```
Unter **Users → Benutzer → Groups → Join Group** zuweisen. Im Chat war `svc_cm_admin` das Beispiel für die Mitgliedschaft in `pegaprox-admins`; der Name allein verleiht keine Rechte und meint hier einen interaktiv anmeldenden Benutzer, keinen Client-Credentials-Service-Account.
**Client Scopes → Create client scope**: Name `pegaprox-groups`, Protocol `OpenID Connect`. Unter **Mappers → Configure a new mapper → Group Membership**:
| Einstellung | Wert |
|---|---|
| Name | groups |
| Token Claim Name | groups |
| Full group path | OFF |
| Add to ID token | ON |
| Add to access token | ON |
| Add to userinfo | ON |
Danach **Clients → PegaProx → Client scopes → Add client scope**: `pegaprox-groups` als **Default** zuweisen. Deshalb muss der Scope nicht zusätzlich im angeforderten `openid profile email` stehen. Die Scope-JSON-Datei bildet diese Mapper-Einstellungen ab; Import allein ersetzt weder Client-Zuweisung noch Gruppenmitgliedschaften. Grundlagen: [Keycloak Client Scopes und Mapper](https://www.keycloak.org/docs/latest/server_admin/).
Unter **Clients → PegaProx → Client scopes → Evaluate** einen Gruppenbenutzer wählen. Im Generated ID Token muss stehen:
```json
{"groups": ["pegaprox-admins"]}
```
Kein führender Slash und keine Gruppen-UUID. Ein Realm-Rollen-Claim unter `realm_access.roles` ersetzt diesen Gruppen-Claim nicht. Nach Änderungen neue Tokens durch erneute Anmeldung erzeugen.
## 6. PegaProx Group → Role Mapping
Auf derselben OIDC-Seite nach unten zu **Group → Role Mapping**. Im Feld **GroupName** den Namen eingeben, rechts die Rolle wählen; weitere Zeilen über **+ Add Mapping**:
| GroupName | Rolle |
|---|---|
| pegaprox-admins | Administrator |
| pegaprox-users | User |
| pegaprox-viewers | Viewer |
**Default Role (no group match): Viewer**, **Auto-create users on first login: ON**, anschließend **Save OIDC Settings**.
Die früher im Chat vermuteten Felder „Admin Group ID“ usw. sind nicht die bestätigte UI-Anleitung. Die bestätigte Oberfläche verwendet die obige Mapping-Tabelle. Der gepostete Code unterstützt zusätzlich eingebaute Gruppenfelder und gewichtet Administrator vor User vor Viewer; er normalisiert Groß-/Kleinschreibung, entfernt aber keinen führenden Slash aus Claim-Werten. Für einfache Nachvollziehbarkeit genau die obigen Gruppennamen nutzen.
## 7. Login und Abnahme
PegaProx vollständig abmelden, bei Bedarf ein separates Browserprofil verwenden, dann **Sign in with OIDC**. Keycloak-Anmeldung durchführen; Rückkehr zur Callback-URI und Anmeldung in PegaProx prüfen. Den Account `svc_cm_admin` (Beispiel) als Administrator erwarten. Die [Testmatrix](docs/verification.md) deckt weitere Rollen ab.
Bestehende Benutzer zuerst erneut anmelden und die effektive Rolle kontrollieren. Der Codeauszug enthält einen Aktualisierungspfad für Benutzer; welche Attribute aktualisiert werden, wurde nicht vollständig gezeigt. Deshalb ist Löschen kein allgemeiner Pflichtschritt. Der Chat schlug die Neuanlage eines falsch provisionierten Accounts vor, belegt deren Ausführung aber nicht. Nur falls erforderlich, nach Prüfung von Zuordnungen und Daten sowie mit verfügbarem lokalem Admin den betroffenen PegaProx-Account gezielt neu provisionieren; nicht den Keycloak-Benutzer löschen.
## 8. Finaler funktionierender Zusammenhang
```text
Keycloak Realm service.heim.lan / Client PegaProx
→ Discovery liefert Keycloak-Endpunkte
→ Authorization Code + PKCE S256
→ Callback https://9.99.30.13:5000/oidc/callback
→ groups enthält pegaprox-admins
→ PegaProx Group → Role Mapping
→ Administrator
```
Dieser Ablauf wurde vom Benutzer als funktionierend bestätigt. Viewer als Standard und TLS-Prüfung ON sind die dokumentierte Zielkonfiguration; ein vollständiger abschließender Konfigurationsexport oder Sicherheits-Test liegt nicht vor. Die Vorlagen sind ohne Geheimnisse und keine Sicherung der laufenden Installation. `pegaprox-oidc.example.json` ist ausdrücklich eine lesbare Sollwertliste, kein zugesichertes Import-/API-Format.
## 9. In Git übernehmen
ZIP entpacken, in den entpackten Ordner wechseln:
```bash
git init
git add README.md docs example-configs scripts .gitignore
git diff --cached --check
git diff --cached
git commit -m "docs: document PegaProx Keycloak OIDC setup"
```
Vor dem Commit lokale Anpassungen auf Secrets prüfen. Ein Remote-Repository wurde nicht erstellt oder veröffentlicht. `.gitignore` schützt nur passende unversionierte Dateien; niemals echte Secrets in die versionierten Vorlagen eintragen.
+92
View File
@@ -0,0 +1,92 @@
# Troubleshooting
Alle Adressen sind Beispielwerte aus der Unterhaltung. Befehle im tatsächlichen PegaProx-System ausführen. Dienstneustarts unterbrechen laufende Sitzungen möglicherweise kurz.
## Fehlerbilder
| Symptom | Einordnung | Maßnahme |
|---|---|---|
| CERTIFICATE_VERIFY_FAILED / self-signed certificate in certificate chain | CA-Vertrauen oder Kette im anfragenden Prozess fehlt | CA, Kette, SAN und Prozessumgebung prüfen |
| Discovery doc not reachable, danach `/authorize` 404 | PegaProx fällt auf generische Endpunkte zurück | Discovery/TLS beheben, nicht Issuer um `/protocol/openid-connect` erweitern |
| `/realms/service.heim.lan/.well-known/jwks.json` schlägt fehl | Ebenfalls generischer Fallback | Discovery muss `/protocol/openid-connect/certs` liefern |
| curl/Python 200, PegaProx weiterhin TLS-Fehler | Shell und Dienst können verschiedene Umgebungen haben | Interpreter, Dienstbenutzer, CA-Variablen prüfen; Dienst neu starten |
| invalid_redirect_uri | Callback stimmt nicht exakt überein | Schema, IP/Host, Port, Pfad und Slash mit Client vergleichen |
| invalid_client | Client ID, Secret oder Client-Authentifizierung falsch | PegaProx ID und aktuelles Secret mit Client Credentials abgleichen |
| groups fehlt | Mapper, Scope-Zuweisung oder Mitgliedschaft fehlt | Evaluate prüfen, Scope Default, frische Tokens |
| `/pegaprox-admins` statt `pegaprox-admins` | Full group path aktiv | Mapper auf OFF, neu anmelden |
| Gruppe korrekt, aber Benutzer statt Administrator | PegaProx-Mapping fehlt/falsch oder bestehende Provisionierung | GroupName und Rolle speichern; erneute Anmeldung |
| SSRF guard rejected / private IP | URL-Schutz blockiert Ziel | Issuer prüfen; gezielte Allow-private-IP-Option für beabsichtigten IdP |
| kcadm invalid_grant | Anmeldung der Admin CLI fehlgeschlagen | Anmelde-Realm, Passwort, Kontostatus, Required Actions prüfen |
## TLS systematisch eingrenzen
```bash
curl -v 'https://9.99.30.11:8443/realms/service.heim.lan/.well-known/openid-configuration'
/usr/bin/python3 -c 'import requests, certifi, ssl; print(requests.certs.where()); print(certifi.where()); print(ssl.get_default_verify_paths())'
systemctl show pegaprox --property=User --property=ExecStart --property=MainPID
```
Im Chat: CA-Bundle `/etc/ssl/certs/ca-certificates.crt`, Zertifikat-CN `keycloak.service.heim.lan`, Aussteller `HEIMLAN_SubCA`, IP-SAN passte. Der CN allein wäre für IP-Zugriff nicht ausreichend. Das gezeigte Zertifikat galt vom 18.07.2026 bis 17.07.2028; das ist historischer Befund, keine Aussage über das heute installierte Zertifikat.
Mit dem Diagnose-Skript aus dem Repo und einem für den Dienstbenutzer lesbaren absoluten Pfad:
```bash
sudo -u pegaprox /usr/bin/python3 /pfad/zum/repo/scripts/check-discovery.py
# Ohne sudo, als root:
runuser -u pegaprox -- /usr/bin/python3 /pfad/zum/repo/scripts/check-discovery.py
```
Das prüft Benutzer und Interpreter, übernimmt aber nicht automatisch die systemd-Umgebung. Dienstdatei und Drop-ins lokal auf CA-Pfade prüfen; keine vollständigen Umgebungs- oder Konfigurationsdumps veröffentlichen, da diese Secrets enthalten können.
Vergleich mit explizitem Bundle:
```bash
REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt \
/usr/bin/python3 scripts/check-discovery.py
```
Funktioniert nur das, kann die mitgelieferte `example-configs/pegaprox-ca.conf.example` als systemd-Drop-in dienen. Vorhandene Overrides prüfen und ergänzen, nicht überschreiben:
```bash
sudo systemctl edit pegaprox
# Inhalt der Beispiel-Datei im Editor ergänzen und speichern.
sudo systemctl daemon-reload
sudo systemctl restart pegaprox
sudo systemctl status pegaprox --no-pager
```
Requests unterstützt `REQUESTS_CA_BUNDLE`; `SSL_CERT_FILE` ist zusätzlich für Python/OpenSSL-Verbraucher vorgesehen, die es berücksichtigen. Ein Shell-export ändert keinen bereits laufenden systemd-Dienst. Siehe [Requests TLS-Dokumentation](https://requests.readthedocs.io/en/stable/user/advanced/#ssl-cert-verification).
Danach PegaProx-OIDC-Test mit **Skip SSL verification OFF**. Ein kurzer unautorisierter Discovery-Abruf mit `curl -k` kann TLS als Ursache eingrenzen, validiert aber keine Identität. Den Login nicht als TLS-erfolgreich bewerten, solange die Zertifikatsprüfung ausgeschaltet ist. JWT-Prüfung bleibt aktiviert.
## Fallback und Cache
Der gepostete Code in `/usr/lib/pegaprox/pegaprox/utils/oidc.py` ruft Discovery per requests auf. Bei TLS-/HTTP-/JSON-Fehlern konstruiert er `<authority>/authorize`, `/token`, `/.well-known/jwks.json` und `/userinfo`. Diese Vermutungen passen nicht zu den gezeigten Keycloak-Endpunkten. Erfolgreiche Discovery-Daten werden dort bis zu 3600 Sekunden gecacht. Ein Dienstneustart setzt den Prozesszustand zurück; anschließend erneut testen.
Frühere Chat-Vermutungen über einen nachgewiesenen Codefehler oder ein separates certifi-Bundle wurden nicht bestätigt. Keine pauschale Zeichenersetzung in `oidc.py` durchführen: Sie verdeckt die eigentliche Discovery-Ursache und ist nicht der dokumentierte finale Fix.
## Admin CLI: Anmelde-Realm und Ziel-Realm unterscheiden
Auf dem Keycloak-System, Passwort interaktiv eingeben:
```bash
/opt/keycloak/bin/kcadm.sh config credentials \
--server 'https://9.99.30.11:8443' \
--realm master --user '<MASTER_ADMIN>'
/opt/keycloak/bin/kcadm.sh get clients -r 'service.heim.lan' \
-q clientId=PegaProx --fields id,clientId
```
Falls der berechtigte Administrator stattdessen im Realm `service.heim.lan` liegt, diesen Realm bei `config credentials --realm` angeben. Der Ziel-Realm der späteren Operationen bleibt `-r service.heim.lan`. Ein gleichnamiger Benutzer in beiden Realms ist nicht dieselbe Identität. Das im Chat versuchte `madzone` im Realm `master` scheiterte mit `invalid_grant`; ein späterer CLI-Erfolg ist nicht belegt. Erfolgreiche Anmeldung allein beweist zudem noch keine administrativen Rechte.
Optionale Erstellung einer noch nicht vorhandenen Gruppe:
```bash
/opt/keycloak/bin/kcadm.sh get groups -r 'service.heim.lan' \
-q search=pegaprox-admins --fields id,name
# Nur anlegen, falls die exakte Gruppe noch nicht existiert:
/opt/keycloak/bin/kcadm.sh create groups -r 'service.heim.lan' \
-s name=pegaprox-admins
```
Analog für users/viewers. Kein pauschales `|| true`: Es würde Berechtigungs- und Netzwerkfehler verschlucken. Die CLI kann eine eigene Java-Truststore-Konfiguration benötigen; ein erfolgreiches Python-TLS-Ergebnis gilt nicht automatisch für Java. CLI-Konfigurationsdateien mit Tokens außerhalb dieses Repos halten. Vollständige Gruppen-/Mapper-Automatisierung war im Chat nur angeboten, nicht ausgeführt.
+36
View File
@@ -0,0 +1,36 @@
# Tests und Abnahmeprotokoll
## Historisch belegt
- curl: Zertifikatsprüfung erfolgreich, Discovery HTTP 200.
- requests: HTTP 200, passender Issuer sowie Authorization-/JWKS-Endpunkte.
- requests und certifi zeigten auf `/etc/ssl/certs/ca-certificates.crt`.
- Browser nutzte zunächst den falschen `/authorize`-Pfad und erhielt „Page not found“.
- Nach Neustart-/TLS-Test-Vorschlag: Benutzer meldete „ok ht geholfen“.
- Geteilte Claims enthielten `groups: ["pegaprox-admins"]`.
- Nach Anleitung zum Group→Role Mapping: Benutzer meldete „es geht jatzt“.
Nicht einzeln nachgewiesen: finaler TLS-Schalter, erfolgte CA-Installation, tatsächlich ausgeführter Neustart, Benutzerlöschung, alle drei Rollentests, Logout sowie Versionsnummern.
## Wiederholbare Abnahme
| Test | Erwartung | Ergebnis / Datum |
|---|---|---|
| Discovery per curl ohne -k | TLS gültig, HTTP 200 | offen |
| Python im Dienstkontext | HTTP 200, exakter Issuer | offen |
| PegaProx-OIDC-Test | Discovery erfolgreich, korrekte auth/JWKS URLs | offen |
| TLS-Schalter | Skip SSL verification OFF | offen |
| JWT-Prüfung | aktiviert | offen |
| Token Evaluate | groups als Array ohne führenden Slash | offen |
| Frischer Admin-Login | Administrator | offen |
| Frischer User-Login | User; keine Admin-Funktionen | offen |
| Frischer Viewer-Login | Viewer; keine Schreibrechte | offen |
| Ohne passende Gruppe | Viewer | offen |
| Admin- und User-Gruppe zusammen | Administrator gemäß untersuchtem Code | offen |
| Bestehender Benutzer nach Gruppenänderung | tatsächliche Rollenaktualisierung prüfen | offen |
Viewer als Default bedeutet, dass ein Benutzer ohne passende Gruppe grundsätzlich noch Leserechte erhalten kann. Falls gar kein Zugriff gewünscht ist, muss das gesondert konfiguriert und getestet werden.
Ein HTTP 400 am Authorization-Endpunkt ohne vollständige Login-Parameter kann dessen Erreichbarkeit zeigen, beweist aber keinen erfolgreichen Login. Erst der vollständige Browser-Flow prüft Client Secret, Callback, Tokenverarbeitung und effektive Rollen gemeinsam. Ein decodiertes JWT allein beweist keine gültige Signatur; Evaluate ist ein Claim-Konfigurationstest.
Keine echten Tokens, Secrets, Cookies oder vollständigen Benutzerprofile in dieses Protokoll aufnehmen. Prüfungen der gelieferten Dateien sind keine Live-Tests der internen Installation.
@@ -0,0 +1,7 @@
{
"issuer": "https://9.99.30.11:8443/realms/service.heim.lan",
"authorization_endpoint": "https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/auth",
"token_endpoint": "https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/token",
"jwks_uri": "https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/certs",
"userinfo_endpoint": "https://9.99.30.11:8443/realms/service.heim.lan/protocol/openid-connect/userinfo"
}
@@ -0,0 +1,21 @@
{
"clientId": "PegaProx",
"name": "PegaProx",
"protocol": "openid-connect",
"enabled": true,
"publicClient": false,
"clientAuthenticatorType": "client-secret",
"standardFlowEnabled": true,
"implicitFlowEnabled": false,
"directAccessGrantsEnabled": false,
"serviceAccountsEnabled": false,
"authorizationServicesEnabled": false,
"rootUrl": "https://9.99.30.13:5000",
"baseUrl": "https://9.99.30.13:5000",
"redirectUris": [
"https://9.99.30.13:5000/oidc/callback"
],
"webOrigins": [
"https://9.99.30.13:5000"
]
}
@@ -0,0 +1,5 @@
# Ergänzende Vorlage, nicht als tatsächlich ausgeführter Chat-Fix belegt.
# Mit systemctl edit pegaprox in vorhandene Konfiguration integrieren.
[Service]
Environment="REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt"
Environment="SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"
@@ -0,0 +1,20 @@
{
"name": "pegaprox-groups",
"description": "Beispiel: nach Erstellung dem PegaProx-Client als Default zuweisen",
"protocol": "openid-connect",
"protocolMappers": [
{
"name": "groups",
"protocol": "openid-connect",
"protocolMapper": "oidc-group-membership-mapper",
"consentRequired": false,
"config": {
"full.path": "false",
"id.token.claim": "true",
"access.token.claim": "true",
"userinfo.token.claim": "true",
"claim.name": "groups"
}
}
]
}
@@ -0,0 +1,18 @@
{
"hinweis": "Dokumentarische Sollwertliste, kein PegaProx-Importformat. Alle Adressen sind Beispielwerte. Secret separat lokal eintragen. TLS-Schalter im finalen Chat nicht belegt.",
"provider": "Generic OIDC",
"issuer": "https://9.99.30.11:8443/realms/service.heim.lan",
"client_id": "PegaProx",
"scopes": "openid profile email",
"redirect_uri": "https://9.99.30.13:5000/oidc/callback",
"jwt_signature_verification": true,
"skip_ssl_verification": false,
"allow_private_ip": "Nur bei bewusstem internem Ziel und entsprechender Blockierung; Chat-Wert unbekannt",
"auto_create_users": true,
"default_role": "Viewer",
"group_role_mapping": {
"pegaprox-admins": "Administrator",
"pegaprox-users": "User",
"pegaprox-viewers": "Viewer"
}
}
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env python3
"""Nur öffentliche Discovery-Metadaten abrufen; TLS-Prüfung bleibt aktiv."""
import argparse
import sys
import requests
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--issuer", default="https://9.99.30.11:8443/realms/service.heim.lan",
help="Beispielwert aus dem Chat; für andere Umgebungen ersetzen")
args = parser.parse_args()
issuer = args.issuer.rstrip("/")
if not issuer.startswith("https://"):
parser.error("HTTPS-Issuer erforderlich")
print("CA-Bundle (Bibliotheksstandard):", requests.certs.where())
try:
response = requests.get(issuer + "/.well-known/openid-configuration", timeout=15)
response.raise_for_status()
data = response.json()
if data.get("issuer") != issuer:
raise ValueError("Issuer stimmt nicht exakt mit der Konfiguration überein")
for key in ("issuer", "authorization_endpoint", "token_endpoint", "jwks_uri", "userinfo_endpoint"):
value = data.get(key)
if not isinstance(value, str) or not value.startswith("https://"):
raise ValueError("Fehlendes/ungültiges HTTPS-Feld: " + key)
print(key + ":", value)
print("OK: Discovery erreichbar und erforderliche HTTPS-Felder vorhanden.")
print("Kein Login-, Rollen- oder JWT-Signaturtest.")
return 0
except (requests.RequestException, ValueError) as exc:
print("FEHLER:", exc, file=sys.stderr)
return 1
if __name__ == "__main__":
sys.exit(main())
+3 -3
View File
@@ -7,15 +7,15 @@
- Proxmox VE: `answer.toml` - Proxmox VE: `answer.toml`
- VMware ESXi: `ks.cfg` - VMware ESXi: `ks.cfg`
System und Version kommen aus dem Blatt **Server**. Die Windows-Server-Version, ISO-Namen und ISO-Ablage kommen aus **Staging**. Der Generator installiert selbst noch keine Server. Für Netzwerk und DHCP zuerst [Schritt 01](WINDOWS-SETUP.md), danach [Schritt 02: DNS und Reservierungen](DNS-RESERVIERUNGEN.md). PXE- und Webdienst sind noch nicht implementiert. System und Version kommen aus dem Blatt **Virtualisierer**. Die Windows-Server-Version, ISO-Namen und ISO-Ablage kommen aus **Staging**. Der Generator installiert selbst noch keine Server. Für Netzwerk und DHCP zuerst [Schritt 01](WINDOWS-SETUP.md), danach [Schritt 02: DNS und Reservierungen](DNS-RESERVIERUNGEN.md). PXE- und Webdienst sind noch nicht implementiert.
## 1. Excel ausfüllen ## 1. Excel ausfüllen
Verwende `outputs/01a07d3f/ConfigWorkbook_KIS.xlsx`. Verwende `outputs/01a07d3f/ConfigWorkbook_KIS.xlsx`.
Im Blatt **Staging** Windows-Version per Dropdown wählen und die Netzwerkwerte ergänzen. `Medienordner` bleibt der lokale Arbeitsordner. Für Schritt 03 die Felder `ISO-Name Proxmox` bzw. `ISO-Name ESXi` sowie `ISO-Ablage` ausfüllen. Im Blatt **Server** die vorgesehenen Geräte auf `Installieren = JA` setzen und ihre Angaben vervollständigen. Excel speichern, bevor du das Programm startest. Im Blatt **Staging** Windows-Version per Dropdown wählen und die Netzwerkwerte ergänzen. `Medienordner` bleibt der lokale Arbeitsordner. Für Schritt 03 die Felder `ISO-Name Proxmox` bzw. `ISO-Name ESXi` sowie `ISO-Ablage` ausfüllen. Im Blatt **Virtualisierer** die vorgesehenen Geräte auf `Installieren = JA` setzen und ihre Angaben vervollständigen. Excel speichern, bevor du das Programm startest.
**Version auswählen:** Im Blatt Server zuerst `System`, dann `Version` wählen. Das Versions-Dropdown zeigt die passende Plattformliste. Bei einem Systemwechsel die Version neu wählen. Die editierbaren Startlisten stehen im Blatt Staging in A37:C44. Eine genaue zusätzliche Medienversion dort ergänzen und danach im Dropdown auswählen; eine Erweiterung der Liste erweitert nicht automatisch die Generatorprofile. **Version auswählen:** Im Blatt Virtualisierer zuerst `System`, dann `Version` wählen. Das Versions-Dropdown zeigt die passende Plattformliste. Bei einem Systemwechsel die Version neu wählen. Die editierbaren Startlisten stehen im Blatt Staging in A37:C44. Eine genaue zusätzliche Medienversion dort ergänzen und danach im Dropdown auswählen; eine Erweiterung der Liste erweitert nicht automatisch die Generatorprofile.
**ISO-Name und Ablage getrennt eintragen:** **ISO-Name und Ablage getrennt eintragen:**
+26 -1
View File
@@ -1,6 +1,6 @@
# Änderungsverlauf # Änderungsverlauf
Die Projektversion steht in `VERSION`. Sie bezeichnet das Staging-Programm, nicht die in Excel gewählte PVE-, ESXi- oder Windows-Version. Das Workbook hat zusätzlich eine eigene Schema-Version (aktuell `0.4 KIS`). Die Projektversion steht in `VERSION`. Sie bezeichnet das Staging-Programm, nicht die in Excel gewählte PVE-, ESXi- oder Windows-Version. Das Workbook hat zusätzlich eine eigene Schema-Version (aktuell `0.7 KIS`).
Neue Änderungen werden unter `Unveröffentlicht` gesammelt. Bei einem neuen Versionsstand werden Datum und Versionsnummer ergänzt und `VERSION` aktualisiert. Vor `1.0.0` erhöhen neue Funktionen oder inkompatible Änderungen die mittlere Zahl; reine Fehlerkorrekturen erhöhen die letzte Zahl. Ab `1.0.0` gelten die üblichen Regeln für Major-, Minor- und Patch-Versionen. Neue Änderungen werden unter `Unveröffentlicht` gesammelt. Bei einem neuen Versionsstand werden Datum und Versionsnummer ergänzt und `VERSION` aktualisiert. Vor `1.0.0` erhöhen neue Funktionen oder inkompatible Änderungen die mittlere Zahl; reine Fehlerkorrekturen erhöhen die letzte Zahl. Ab `1.0.0` gelten die üblichen Regeln für Major-, Minor- und Patch-Versionen.
@@ -8,6 +8,31 @@ Neue Änderungen werden unter `Unveröffentlicht` gesammelt. Bei einem neuen Ver
Noch keine weiteren Änderungen. Noch keine weiteren Änderungen.
## 0.7.0 – 2026-09-10
- PVE Netzwerk um die Tabelle `KIS_OVS_IntPorts` mit 20 Zeilen erweitert: Host, Bridge, IntPort-Name, Zweck, VLAN-Modus/-ID, IPv4/Präfix, optionales Gateway und MTU.
- Deaktiviertes Backup-Beispiel `vlan120` mit `10.120.0.11/24` auf `vmbr1`; keine zusätzliche Default-Route.
- Hinweise für Host/Bridge-Zuordnung, doppelte Namen, VLAN-/IP-Feldkombinationen und Gateway-Prüfung. Ausfüllhilfe und Grenzen dokumentiert.
- Bestehende Zellwerte/Formeln erhalten; neue Formeln mit fehlerhaften und doppelten Eingaben geprüft, Darstellung und gespeicherte Tabelle kontrolliert. Kein Infrastruktur-Test; weiterhin Workbook-Planung ohne automatische Einrichtung.
## 0.6.0 – 2026-09-10
- Netzwerkplanung vor VM-Bereitstellung ergänzt: neue Workbook-Blätter `vCenter Netzwerk` und `PVE Netzwerk`, Schema 0.6.
- vCenter: vDS mit editierbarem Versions-Dropdown, Host-NIC/dvUplink-Zuordnung und mehrere dvPortgroups mit VLANs.
- PVE: OVS-Bond/Bridge je Host, Cluster-Zuordnung, SDN-VLAN-Zonen und VNets; Beispiel mit active-backup ohne LACP.
- Deaktivierte Beispiele für Anwendungen, Backup und DMZ (VLAN 110/120/130). VM-Netzwerk-Dropdown nach Plattform und zusätzliche Netzwerkhinweise.
- Ausfüllanleitung und geplante Reihenfolge 04 PXE, 05 Cluster/vCenter, 06 Netzwerke, 07 VMs dokumentiert. Neue Netzwerke bleiben Planung; keine automatische Einrichtung oder Netzwerk-Generator in dieser Version.
- Workbook-Formeln mit geänderten Eingaben, Querverweise, gespeicherte Tabellen/Dropdowns und Darstellung geprüft. Bestehende 144 PowerShell-Prüfungen bestanden. Keine interaktive Excel- oder Infrastruktur-Abnahme.
## 0.5.0 – 2026-09-09
- Blatt `Server` in `Virtualisierer` umbenannt; zugehörige Excel-Tabelle heißt `KIS_Virtualisierer`. Formelbezüge und aktuelle Anleitungen angepasst.
- Workbook-Import akzeptiert den neuen Blattnamen und weiterhin ältere Workbooks mit `Server`; gleichzeitige doppelte Host-Blätter werden abgewiesen.
- Neues Blatt `VM Setting` mit 20 VM-Zeilen und zwei deaktivierten Beispielen für PVE/ESXi. System aus Hostzuordnung und vCPU-Anzahl aus Sockeln/Kernen berechnet.
- Gemeinsame Angaben zu Gast-OS, RAM, Systemdisk, Storage, Controller, Netzwerk, Firmware und ISO. Eigene Felder für PVE-VM-ID/CPU-Typ/VLAN sowie ESXi-Diskformat/vCenter-Ordner.
- 144 bestehende Skriptprüfungen bestanden. Zusätzlich gespeicherte VM-Formeln bei Hostwechsel/fehlendem Host und alten Blattnamen geprüft; keine interaktive Excel- oder VM-Deployment-Abnahme.
- Auswahlfelder, Pflichtfeldhinweise und Erklärungen; Schema 0.5. VM-Bereitstellung noch nicht implementiert. Erstes Profil erfasst eine Disk und eine NIC je VM.
## 0.4.1 – 2026-09-09 ## 0.4.1 – 2026-09-09
- PVE-Dropdown gemäß Hersteller-ISO-Seite aktualisiert: 9.2-1 zuerst, 8.4-1 als ältere Alternative. ISO-Dateinamenbeispiel angepasst; keine Zielserver automatisch ausgewählt. - PVE-Dropdown gemäß Hersteller-ISO-Seite aktualisiert: 9.2-1 zuerst, 8.4-1 als ältere Alternative. ISO-Dateinamenbeispiel angepasst; keine Zielserver automatisch ausgewählt.
+1 -1
View File
@@ -13,7 +13,7 @@ Im KIS-Workbook im Blatt **Staging** stehen unten zwei neue gelbe Eingabefelder:
Damit wird `getac.lab.example` für die GETAC-IP angelegt. Der GETAC-Name ist ein DNS-Eintrag; Windows wird nicht umbenannt. Windows-Version und Netzwerkwerte bleiben in ihren bisherigen Excel-Feldern. Damit wird `getac.lab.example` für die GETAC-IP angelegt. Der GETAC-Name ist ein DNS-Eintrag; Windows wird nicht umbenannt. Windows-Version und Netzwerkwerte bleiben in ihren bisherigen Excel-Feldern.
Im Blatt **Server** für jeden gewünschten Server `Installieren = JA` setzen und diese Netzwerkwerte eintragen: Im Blatt **Virtualisierer** für jeden gewünschten Server `Installieren = JA` setzen und diese Netzwerkwerte eintragen:
| Feld | Beispiel für PVE | | Feld | Beispiel für PVE |
| --- | --- | | --- | --- |
+9 -6
View File
@@ -27,7 +27,7 @@ function Read-KisWorkbook([string]$Path) {
}) } }) }
$sheets = @{} $sheets = @{}
foreach ($sheet in $book.SelectNodes('//*[local-name()="sheet"]')) { foreach ($sheet in $book.SelectNodes('//*[local-name()="sheet"]')) {
if ($sheet.GetAttribute('name') -notin @('Staging','Server')) { continue } if ($sheet.GetAttribute('name') -notin @('Staging','Server','Virtualisierer')) { continue }
$rid = $sheet.GetAttribute('id','http://schemas.openxmlformats.org/officeDocument/2006/relationships') $rid = $sheet.GetAttribute('id','http://schemas.openxmlformats.org/officeDocument/2006/relationships')
$rel = @($rels.SelectNodes('//*[local-name()="Relationship"]') | Where-Object { $_.GetAttribute('Id') -eq $rid }) $rel = @($rels.SelectNodes('//*[local-name()="Relationship"]') | Where-Object { $_.GetAttribute('Id') -eq $rid })
if ($rel.Count -ne 1) { throw 'Ungueltige XLSX-Beziehung' } if ($rel.Count -ne 1) { throw 'Ungueltige XLSX-Beziehung' }
@@ -47,9 +47,12 @@ function Read-KisWorkbook([string]$Path) {
$cells[$address] = [string]$value $cells[$address] = [string]$value
if ($cell.SelectSingleNode('./*[local-name()="f"]')) { $formulas[$address] = $true } if ($cell.SelectSingleNode('./*[local-name()="f"]')) { $formulas[$address] = $true }
} }
$sheets[$sheet.GetAttribute('name')] = @{ Cells=$cells; Formulas=$formulas } $sheetKey=$sheet.GetAttribute('name')
if ($sheetKey -eq 'Virtualisierer') { $sheetKey='Server' }
if ($sheets.ContainsKey($sheetKey)) { throw 'Workbook darf nicht gleichzeitig Server und Virtualisierer enthalten.' }
$sheets[$sheetKey] = @{ Cells=$cells; Formulas=$formulas }
} }
if (-not $sheets.ContainsKey('Staging') -or -not $sheets.ContainsKey('Server')) { throw 'KIS-Workbook mit Staging und Server erforderlich.' } if (-not $sheets.ContainsKey('Staging') -or -not $sheets.ContainsKey('Server')) { throw 'KIS-Workbook mit Staging und Virtualisierer erforderlich (altes Blatt Server wird ebenfalls gelesen).' }
$settings = @{} $settings = @{}
foreach ($key in $sheets.Staging.Cells.Keys) { foreach ($key in $sheets.Staging.Cells.Keys) {
if ($key -notmatch '^A(\d+)$') { continue } if ($key -notmatch '^A(\d+)$') { continue }
@@ -65,7 +68,7 @@ function Read-KisWorkbook([string]$Path) {
$expected = @('Installieren','Servername','PXE-MAC-Adresse','System','Version','Installationsdatenträger','Ziel-IP','Präfix','Gateway','DNS-Server','Benutzername','Hinweis') $expected = @('Installieren','Servername','PXE-MAC-Adresse','System','Version','Installationsdatenträger','Ziel-IP','Präfix','Gateway','DNS-Server','Benutzername','Hinweis')
for ($i=0; $i -lt $expected.Count; $i++) { for ($i=0; $i -lt $expected.Count; $i++) {
$col = [string][char](65+$i) $col = [string][char](65+$i)
if ($sheets.Server.Cells["${col}6"] -cne $expected[$i]) { throw "Server!${col}6: Erwartet '$($expected[$i])'. KIS Schema 0.2 erforderlich." } if ($sheets.Server.Cells["${col}6"] -cne $expected[$i]) { throw "Virtualisierer!${col}6: Erwartet '$($expected[$i])'. KIS-Spaltenstruktur erforderlich." }
} }
foreach ($key in $sheets.Server.Cells.Keys) { foreach ($key in $sheets.Server.Cells.Keys) {
if ($key -match '^A(\d+)$' -and [int]$Matches[1] -gt 26 -and $sheets.Server.Cells[$key] -eq 'JA') { throw 'Server ausserhalb der 20 vorbereiteten Zeilen. Bereich zuerst erweitern.' } if ($key -match '^A(\d+)$' -and [int]$Matches[1] -gt 26 -and $sheets.Server.Cells[$key] -eq 'JA') { throw 'Server ausserhalb der 20 vorbereiteten Zeilen. Bereich zuerst erweitern.' }
@@ -75,11 +78,11 @@ function Read-KisWorkbook([string]$Path) {
$values = @{} $values = @{}
for ($i=0; $i -lt $expected.Count; $i++) { for ($i=0; $i -lt $expected.Count; $i++) {
$cell = "$([char](65+$i))$r" $cell = "$([char](65+$i))$r"
if ($sheets.Server.Formulas.ContainsKey($cell)) { throw "Server!${cell}: Eingabeformeln sind nicht erlaubt." } if ($sheets.Server.Formulas.ContainsKey($cell)) { throw "Virtualisierer!${cell}: Eingabeformeln sind nicht erlaubt." }
$values[$expected[$i]] = ([string]$sheets.Server.Cells[$cell]).Trim() $values[$expected[$i]] = ([string]$sheets.Server.Cells[$cell]).Trim()
} }
if ($sheets.Server.Cells['N6'] -eq 'PXE-IP') { if ($sheets.Server.Cells['N6'] -eq 'PXE-IP') {
if ($sheets.Server.Formulas.ContainsKey("N$r")) { throw "Server!N${r}: Eingabeformeln sind nicht erlaubt." } if ($sheets.Server.Formulas.ContainsKey("N$r")) { throw "Virtualisierer!N${r}: Eingabeformeln sind nicht erlaubt." }
$values['PXE-IP']=([string]$sheets.Server.Cells["N$r"]).Trim() $values['PXE-IP']=([string]$sheets.Server.Cells["N$r"]).Trim()
} }
if ($values.Installieren -notin @('','JA','NEIN')) { throw "Server Zeile ${r}: Installieren muss JA oder NEIN sein." } if ($values.Installieren -notin @('','JA','NEIN')) { throw "Server Zeile ${r}: Installieren muss JA oder NEIN sein." }
+87
View File
@@ -0,0 +1,87 @@
# Netzwerke vor den VMs planen
Die Reihenfolge ist **Virtualisierer installieren → vCenter/PVE-Cluster bereitstellen → Host-Netzwerke und VM-Netze einrichten → VMs erstellen**. Schema 0.7 enthält dafür die Blätter `vCenter Netzwerk` und `PVE Netzwerk` direkt vor `VM Setting`.
Dieser Stand erfasst die Netzwerk-Konfiguration in Excel. Die bestehenden Skripte 01–03 lesen diese neuen Blätter noch nicht. `Anlegen = JA` ist deshalb bislang nur ein Planungsschalter. Ein Netzwerk-Generator, Bestandsabgleich und die tatsächliche Einrichtung sind noch umzusetzen.
## Beispiel: drei VM-Netze
| Zweck | VLAN | VMware-Portgruppe | PVE-VNet | Beispiel-Subnetz |
| --- | --- | --- | --- | --- |
| Anwendungen | 110 | PG-APP-110 | app110 | 10.110.0.0/24 |
| Backup | 120 | PG-BACKUP-120 | bkp120 | 10.120.0.0/24 |
| DMZ | 130 | PG-DMZ-130 | dmz130 | 10.130.0.0/24 |
Alle Werte sind Beispiele. Die gleiche VLAN-ID verbindet beide Plattformen nur dann miteinander, wenn auch das physische Netz entsprechend verbunden ist. Der Name DMZ erzeugt keine Firewall-Regeln. Routing und Freigaben werden am vorhandenen Router beziehungsweise der Firewall eingerichtet.
## vCenter Netzwerk ausfüllen
1. **Zeilen 7–16, Distributed Switches:** eine eigene `Switch-ID` vergeben, z.B. `vds-lab`. Dazu vCenter-FQDN, Datacenter, vDS-Name, passende vDS-Version aus dem Dropdown, MTU und Uplink-Anzahl eintragen. Die Liste in L6:L13 lässt sich erweitern. Die vDS-Version ist eine eigene Kompatibilitätsversion, kein ESXi-ISO-Name. vCenter, Datacenter und ESXi-Hosts müssen für die spätere Einrichtung vorhanden sein. Lizenz und Versionskompatibilität prüfen.
2. **Zeilen 21–40, Host-Uplinks:** pro freier physischer NIC eine Zeile. Beispiel: `esxi01.lab.example`, `vds-lab`, `vmnic2`, `dvUplink1`, `Aktiv`; zweite Zeile mit `vmnic3` und `dvUplink2`. Der Host wird aus `Virtualisierer` gewählt. Dort kann `Installieren = NEIN` stehen, wenn er schon installiert ist.
3. **Zeilen 45–64, Portgruppen:** pro Netzwerk eine `Netzwerk-ID`, Switch-ID und eindeutigen Portgruppennamen eintragen. Für das Beispiel `VLAN`, `110`, `Static`, `128` wählen. Bei `Untagged` bleibt VLAN-ID leer; bei `Ephemeral` bleibt Ports leer, da keine feste Portzahl geplant wird.
Im ersten KIS-Profil gelten die aktiven und Standby-Uplinks gemeinsam für die Portgruppen eines vDS. Die gleiche dvUplink-Zuordnung muss auf allen Mitgliedshosts dieselbe Bedeutung haben. VMware-LACP/LAGs, VLAN-Trunks zur VM, Portgruppen-Overrides und VMkernel-Netze für Management, vMotion oder vSAN sind noch nicht erfasst. Management-NICs werden nicht als freie Uplinks vorausgesetzt.
## PVE Netzwerk ausfüllen
1. **Zeilen 7–26, OVS je Host:** Host wählen und eine gemeinsame Cluster-ID vergeben, z.B. `pve-lab`. Bridge `vmbr1`, Bond `bond1`, freie NICs `eno2,eno3`, Modus `active-backup`, LACP `off`, MTU `1500` und erlaubte VLANs `110,120,130` eintragen. Für jeden weiteren Host eine Zeile mit dessen tatsächlichen NIC-Namen ergänzen. Die Cluster-ID ordnet vorhandene Hosts zu; sie erstellt keinen Cluster.
2. **Zeilen 31–40, SDN-Zone:** Zonen-Schlüssel `zone-lab`, Cluster-ID `pve-lab`, SDN-Zone `zone1`, Typ `VLAN`, Bridge `vmbr1`, MTU `1500`. Die vorgesehenen Nodes ergeben sich aus den OVS-Zeilen mit passender Cluster-ID und Bridge. Auf jedem dieser Nodes muss die Bridge vorhanden sein. Die MTU darf die verfügbare MTU des gesamten Pfads nicht überschreiten.
3. **Zeilen 45–64, VNets:** Netzwerk-ID `pve-app`, Zonen-Schlüssel `zone-lab`, VNet-ID `app110`, Alias `Anwendungen`, VLAN-ID `110`. VNet- und Zonen-IDs kurz halten, höchstens acht Zeichen; für Beispiele nur Buchstaben und Zahlen verwenden. VNet-Namen für die eindeutige VM-Auswahl im Workbook nicht wiederverwenden.
Die offizielle SDN-Dokumentation unterstützt für VLAN-Zonen eine vorhandene Linux- oder OVS-Bridge. Das erste Profil nutzt daher OVS mit SDN-VLAN-Zonen. VXLAN/EVPN samt Peers, Routing und zusätzlichen MTU-Anforderungen sind nicht Teil dieses Profils.
`Bond-Modus` bezeichnet hier die OVS-Konfiguration. `balance-tcp` benötigt im KIS-Profil LACP `active` oder `passive` und einen passend konfigurierten Switch-Port-Channel. Das Beispiel `active-backup` mit LACP `off` benötigt keinen LACP-Port-Channel. Die auswählbaren Kombinationen sind bewusst eingeschränkt; das ist keine vollständige Liste aller OVS-Möglichkeiten. OVS-Pakete und ifupdown2 müssen auf den Hosts verfügbar sein.
Bridge und Bond erhalten keine eigene Host-IP. Ein Host-Zugang zum VLAN wird bei Bedarf über einen OVSIntPort geplant. Subnetz und externes Gateway am VNet dienen weiterhin der Planung des externen Netzes; sie richten weder einen Router noch DHCP ein. Insbesondere wird der GETAC-DHCP aus dem Installationsnetz nicht automatisch in die VM-Netze erweitert.
## OVSIntPorts ausfüllen
Im Blatt `PVE Netzwerk` stehen dafür **Zeilen 73–92** bereit, eine Zeile je Host und internem Port. Ein OVSIntPort verbindet den PVE-Host selbst mit dem OVS-Netz, etwa für Management, Migration, Storage oder Backup. VMs verwenden weiterhin die SDN-VNets.
Das deaktivierte Beispiel enthält:
| Feld | Beispiel | Bedeutung |
| --- | --- | --- |
| Virtualisierer | pve01.lab.example | vorhandenen PVE-Host auswählen |
| OVS-Bridge | vmbr1 | muss oben für genau diesen Host geplant sein |
| OVSIntPort | vlan120 | auf dem Host eindeutiger Interface-Name |
| Zweck | Backup | Auswahl beschreibt die Nutzung; aktiviert keinen Dienst |
| VLAN-Modus / VLAN-ID | Tagged / 120 | Host-Port gehört zu VLAN 120 |
| IPv4-Adresse / Präfix | 10.120.0.11 / 24 | Adresse des PVE-Hosts im Backup-Netz |
| Gateway | leer | Beispiel benötigt keine zusätzliche Default-Route |
| MTU | 1500 | muss zur Bridge und zum gesamten Netzwerkpfad passen |
Ohne Host-IP bleiben IPv4-Adresse, Präfix und Gateway leer. Bei `Untagged` bleibt VLAN-ID leer. Das gewählte VLAN muss auf Bond und physischen Switch-Uplinks erlaubt sein. Ein späterer Generator muss den IntPort als `ovs_type OVSIntPort` mit `ovs_bridge` zuordnen und in `ovs_ports` der Bridge berücksichtigen.
Ein Gateway plant eine Default-Route und erhält deshalb immer den Hinweis `Default-Route prüfen`. Bereits vorhandene Management-IP und Default-Route aus `Virtualisierer` beziehungsweise dem tatsächlichen Host müssen abgeglichen werden; keine zweite konkurrierende Route oder doppelte IP anlegen. Eine Management-Umstellung ist noch nicht automatisiert.
Die Excel-Hinweise prüfen Host/Bridge-Zuordnung, doppelte IntPort-Namen je Host, VLAN-Eingaben sowie die zusammengehörigen IP-/Präfixfelder. Vollständige IP-Syntax, Interface-Namensregeln, Kollisionen mit bestehenden Interfaces, MTU und Routing prüft dieser Stand noch nicht. Die Angaben bleiben Planung; Skripte 01–03 führen sie nicht aus.
Grundlagen: [Open vSwitch Interface- und Port-Konfiguration](https://www.openvswitch.org/support/dist-docs/ovs-vswitchd.conf.db.5.html) und [Proxmox OVS-/ifupdown-Integration](https://lists.proxmox.com/pipermail/pve-devel/2020-February/041806.html).
## VM zuordnen und prüfen
In `VM Setting` zuerst den Virtualisierer wählen. Das Dropdown in `Netzwerk` bietet dann PVE-VNets oder VMware-Portgruppen an. Die Beispiel-VMs verwenden `app110` beziehungsweise `PG-APP-110`. VLAN-ID in VM-Spalte O leer lassen, weil das VLAN bereits am VNet beziehungsweise an der Portgruppe festgelegt ist.
Die zusätzliche Spalte `Netzwerkplanung` zeigt unbekannte oder doppelte Netzwerknamen und bei PVE ein zusätzliches VM-VLAN an. **Host-Mitgliedschaft im richtigen vDS beziehungsweise in der richtigen Zone muss zusätzlich geprüft werden.** Das Dropdown enthält alle Netze der Plattform; es bestätigt keine Erreichbarkeit oder Bereitstellung auf dem gewählten Host.
Die Eingabehinweise prüfen ausgewählte Pflichtfelder, Host-Plattformen, Elternverweise, einige Duplikate, VLAN-Grenzen und KIS-LACP-Kombinationen. Sie ersetzen noch keine vollständige technische Prüfung, etwa von NIC-Kollisionen zwischen Bonds, erlaubten VLANs auf allen Uplinks, IP/Subnetzen, MTU, vDS-Lizenzen oder vorhandenen Objekten. „Erfasst – technisch prüfen“ bedeutet keine Ausführungsfreigabe. Die Beispiele bleiben deaktiviert. Keine Passwörter in Excel speichern; spätere Verbindungen sollen Zugangsdaten interaktiv abfragen.
## Geplante Skript-Reihenfolge
| Nummer | Aufgabe | Stand |
| --- | --- | --- |
| 01–03 | GETAC, DNS/Reservierungen und Installer-Antwortdateien | vorhanden |
| 04 | PXE-Dienst, Bootmedien und Hypervisor-Installation | noch offen |
| 05 | vCenter/PVE-Cluster bereitstellen oder vorhandenen Bestand prüfen | noch offen |
| 06 | Host-Netzwerke, vDS/Portgruppen und PVE OVS/SDN einrichten | Workbook vorhanden; Skript noch offen |
| 07 | VMs aus VM Setting erstellen | Workbook vorhanden; Skript noch offen |
## Grundlagen
- [Proxmox SDN: VLAN-Zonen, VNets und Subnetze](https://github.com/proxmox/pve-docs/blob/master/pvesdn.adoc)
- [Broadcom: New-VDSwitch](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.vds/commands/new-vdswitch)
- [Broadcom: New-VDPortgroup](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.vds/commands/new-vdportgroup)
- [Broadcom: vDS-Versionen und Kompatibilität](https://knowledge.broadcom.com/external/article/416520/vds-improvements-and-features-per-versio.html)
Geprüft am 10.09.2026. Die konkrete Zielversion und Hardware müssen vor der tatsächlichen Einrichtung geprüft werden.
+12 -8
View File
@@ -1,6 +1,6 @@
# Stagging # Stagging
Projektversion: **0.4.1**. Änderungen und bekannte Grenzen stehen im [Änderungsverlauf](CHANGELOG.md). Die verbindliche Versionsnummer liegt in [VERSION](VERSION) und kann mit `./03-Prepare-Unattended.ps1 -ShowVersion` angezeigt werden. Sie ist unabhängig von den Hypervisor-Versionen in Excel und vom Workbook-Schema. Projektversion: **0.7.0**. Änderungen und bekannte Grenzen stehen im [Änderungsverlauf](CHANGELOG.md). Die verbindliche Versionsnummer liegt in [VERSION](VERSION) und kann mit `./03-Prepare-Unattended.ps1 -ShowVersion` angezeigt werden. Sie ist unabhängig von den Hypervisor-Versionen in Excel und vom Workbook-Schema.
## Ausführungsreihenfolge ## Ausführungsreihenfolge
@@ -12,7 +12,7 @@ Projektversion: **0.4.1**. Änderungen und bekannte Grenzen stehen im [Änderung
Alle drei Skripte prüfen standardmäßig nur. Schritt 01 und 02 richten mit `-Apply` ein; Schritt 03 erzeugt mit `-Generate` Dateien. Am GETAC lokal als Administrator arbeiten und jeweils das Ergebnis prüfen, bevor der nächste Schritt beginnt. Die passende Testdatei unter `Tests` trägt dieselbe Nummer. Dateien unter `Modules` sind interne Bibliotheken und werden nicht einzeln gestartet. Alle drei Skripte prüfen standardmäßig nur. Schritt 01 und 02 richten mit `-Apply` ein; Schritt 03 erzeugt mit `-Generate` Dateien. Am GETAC lokal als Administrator arbeiten und jeweils das Ergebnis prüfen, bevor der nächste Schritt beginnt. Die passende Testdatei unter `Tests` trägt dieselbe Nummer. Dateien unter `Modules` sind interne Bibliotheken und werden nicht einzeln gestartet.
PXE-Dienst und Bootdateien sind der nächste, noch nicht implementierte Schritt 04. Es gibt dafür noch kein ausführbares Skript. PXE-Dienst und Bootdateien sind der nächste, noch nicht implementierte Schritt 04. Es gibt dafür noch kein ausführbares Skript. Danach folgen die vorgesehenen Schritte 05 für vCenter/Cluster, 06 für Plattform-Netzwerke und 07 für VMs. Die [Netzwerk-Anleitung](NETZWERKE.md) beschreibt die neuen Excel-Felder; Skripte 05–07 sind noch offen.
## Aktueller Programmstand ## Aktueller Programmstand
@@ -32,8 +32,9 @@ Der vom Nutzer festgelegte Umfang umfasst:
1. Proxmox VE oder VMware auf Bare-Metal-Servern installieren. 1. Proxmox VE oder VMware auf Bare-Metal-Servern installieren.
2. Cluster-Konfigurationen für Proxmox VE und VMware erstellen und ausrollen. 2. Cluster-Konfigurationen für Proxmox VE und VMware erstellen und ausrollen.
3. Virtuelle Maschinen und Container anhand des ConfigWorkbooks bereitstellen. 3. Vor den VMs: vCenter Distributed Switches/Portgruppen sowie PVE OVS-Bonds, Bridges und SDN-VLAN-Zonen/VNets konfigurieren.
4. Netzwerkkonfigurationen erstellen, zunächst für Cisco und später für weitere Switch-Hersteller. 4. Virtuelle Maschinen und Container anhand des ConfigWorkbooks bereitstellen.
5. Physische Netzwerkkonfigurationen erstellen, zunächst für Cisco und später für weitere Switch-Hersteller.
Die Auswahl der Plattform erfolgt je Zielumgebung. Konkrete Produktversionen, Hardware und Container-Technologien sind noch festzulegen. Das automatische Ausrollen von Switch-Konfigurationen ist bislang nicht Teil des festgelegten Umfangs. Die Auswahl der Plattform erfolgt je Zielumgebung. Konkrete Produktversionen, Hardware und Container-Technologien sind noch festzulegen. Das automatische Ausrollen von Switch-Konfigurationen ist bislang nicht Teil des festgelegten Umfangs.
@@ -67,12 +68,15 @@ Ob und in welcher Form ein Installer temporäre Antwortdateien mit Zugangsdaten
### Vereinfachung des Workbooks für die erste Etappe ### Vereinfachung des Workbooks für die erste Etappe
Für die erste funktionierende Installation sollen zwei Eingabeblätter genügen: Für die erste funktionierende Installation sollen die Eingabeblätter nach Aufgabe getrennt sein:
| Blatt | Eingaben | | Blatt | Eingaben |
| --- | --- | | --- | --- |
| Staging | Installations-Netzwerkkarte des GETAC, Server-IP und Präfix, DHCP-Bereich, lokaler Medienordner | | Staging | Installations-Netzwerkkarte des GETAC, Server-IP und Präfix, DHCP-Bereich, lokaler Medienordner |
| Server | Name, PXE-MAC-Adresse, Zielplattform und Version, Installationsdatenträger, spätere Management-IP und Präfix, Gateway, DNS, Benutzername | | Virtualisierer | Name, PXE-MAC-Adresse, Zielplattform und Version, Installationsdatenträger, spätere Management-IP und Präfix, Gateway, DNS, Benutzername |
| vCenter Netzwerk | vDS, Versionsauswahl, physische Host-Uplinks und dvPortgroups/VLANs |
| PVE Netzwerk | OVS-Bonds/Bridges und OVSIntPorts je Host, SDN-VLAN-Zonen und VNets |
| VM Setting | VM-Zuordnung, CPU/RAM, Systemdisk, Netzwerk-Auswahl und plattformspezifische Hardwareangaben |
Cluster, VMs, Container und Cisco-Konfigurationen bleiben im Gesamtauftrag, folgen aber nach einem funktionierenden Installationsdurchlauf. Kein umfangreicher Secret-Speicher und keine BMC-Konfiguration in dieser ersten Etappe. Cluster, VMs, Container und Cisco-Konfigurationen bleiben im Gesamtauftrag, folgen aber nach einem funktionierenden Installationsdurchlauf. Kein umfangreicher Secret-Speicher und keine BMC-Konfiguration in dieser ersten Etappe.
@@ -91,7 +95,7 @@ Vorhandene Infrastruktur muss vor Änderungen abgeglichen werden. Eine Neuinstal
## ConfigWorkbook ## ConfigWorkbook
**Aktueller Einstieg:** Das [ConfigWorkbook KIS (Schema 0.4)](outputs/01a07d3f/ConfigWorkbook_KIS.xlsx) enthält ausschließlich `Staging` und `Server`. Es enthält DNS-Zone und GETAC-Name sowie eine separate PXE-IP je Server. Windows- und Hypervisor-Versionen werden per Dropdown gewählt. ISO-Namen stehen je Plattform getrennt vom gemeinsamen Feld `ISO-Ablage` (lokaler Ordner oder UNC-Netzwerkfreigabe). Der Ablageort kann bis Schritt 03 offenbleiben. Es bietet Beispielwerte für GETAC/DHCP sowie je einen Proxmox- und ESXi-Zielserver, zunächst mit `Installieren = NEIN`. Windows-Version, Mediennamen, Zielversionen und Installationsdatenträger müssen ergänzt werden. 20 Serverzeilen sind vorbereitet. Auswahlzählung, Pflichtfeld- und Duplikathinweise sind enthalten; vollständige technische Prüfung und Installation sind noch nicht implementiert. **Aktueller Einstieg:** Das [ConfigWorkbook KIS (Schema 0.7)](outputs/01a07d3f/ConfigWorkbook_KIS.xlsx) enthält `Staging`, `Virtualisierer`, `vCenter Netzwerk`, `PVE Netzwerk` und `VM Setting`. Die [Netzwerk-Anleitung](NETZWERKE.md) erklärt die neuen Plattform-Blätter mit deaktivierten Beispielen für VLAN 110/120/130. Die Netzwerkplanung steht vor den VMs und ist noch nicht automatisiert ausführbar. Das neue Blatt `VM Setting` enthält 20 VM-Zeilen mit Beispielen für PVE und ESXi. Die [VM-Anleitung](VM-SETTING.md) erklärt gemeinsame und plattformspezifische Angaben. Es enthält DNS-Zone und GETAC-Name sowie eine separate PXE-IP je Server. Windows- und Hypervisor-Versionen werden per Dropdown gewählt. ISO-Namen stehen je Plattform getrennt vom gemeinsamen Feld `ISO-Ablage` (lokaler Ordner oder UNC-Netzwerkfreigabe). Der Ablageort kann bis Schritt 03 offenbleiben. Es bietet Beispielwerte für GETAC/DHCP sowie je einen Proxmox- und ESXi-Zielserver, zunächst mit `Installieren = NEIN`. Windows-Version, Mediennamen, Zielversionen und Installationsdatenträger müssen ergänzt werden. 20 Serverzeilen sind vorbereitet. Auswahlzählung, Pflichtfeld- und Duplikathinweise sind enthalten; vollständige technische Prüfung und Installation sind noch nicht implementiert.
Die PVE-Auswahl enthält 9.2-1 und 8.4-1, entsprechend der [Hersteller-ISO-Seite](https://www.proxmox.com/en/downloads/proxmox-virtual-environment/iso), geprüft am 09.09.2026. Weitere passende Medienversionen können in der Liste ergänzt werden. Die PVE-Auswahl enthält 9.2-1 und 8.4-1, entsprechend der [Hersteller-ISO-Seite](https://www.proxmox.com/en/downloads/proxmox-virtual-environment/iso), geprüft am 09.09.2026. Weitere passende Medienversionen können in der Liste ergänzt werden.
@@ -103,7 +107,7 @@ Die überholten umfangreichen Excel-Entwürfe und ihre Prüfdateien wurden entfe
2. Einfaches Workbook für Staging und Server erstellen; Zuordnung über PXE-MAC-Adressen vorsehen. 2. Einfaches Workbook für Staging und Server erstellen; Zuordnung über PXE-MAC-Adressen vorsehen.
3. DHCP, PXE und lokale Installationsdateien auf der Staging-Station für ein separates Installationsnetz einrichten. 3. DHCP, PXE und lokale Installationsdateien auf der Staging-Station für ein separates Installationsnetz einrichten.
4. Einen freigegebenen Testserver ohne Hersteller-Fernverwaltung installieren und das Ergebnis prüfen. 4. Einen freigegebenen Testserver ohne Hersteller-Fernverwaltung installieren und das Ergebnis prüfen.
5. Zweite Hypervisor-Plattform, Cluster-Konfiguration und VM-Bereitstellung ergänzen. 5. Zweite Hypervisor-Plattform, Cluster-Konfiguration, Plattform-Netzwerke und danach VM-Bereitstellung ergänzen.
6. Container-Technologie und Cisco-Konfigurationen ergänzen, später weitere Switch-Hersteller. 6. Container-Technologie und Cisco-Konfigurationen ergänzen, später weitere Switch-Hersteller.
## Offene Entscheidungen ## Offene Entscheidungen
+1 -1
View File
@@ -1 +1 @@
0.4.1 0.7.0
+34
View File
@@ -0,0 +1,34 @@
# VM Setting ausfüllen
Das KIS-Workbook enthält die Blätter `Staging`, `Virtualisierer`, `vCenter Netzwerk`, `PVE Netzwerk` und `VM Setting`. Vor den VMs die [Plattform-Netzwerke](NETZWERKE.md) erfassen. In `Virtualisierer` stehen die physischen Hypervisor-Hosts. In `VM Setting` steht eine Zeile je geplanter virtueller Maschine; 20 Zeilen und zwei deaktivierte Beispiele sind vorbereitet.
1. **VM-Name** eintragen und **Virtualisierer** aus dem Dropdown wählen. Das Feld **System** übernimmt PVE oder ESXi aus dem Host-Blatt. Der Host darf bereits installiert sein und dort `Installieren = NEIN` haben.
2. **Gast-OS / Version** beschreiben und die plattformspezifische **Gast-OS-ID** eintragen. Die Beispiele verwenden `l26` für PVE und `ubuntu64Guest` für ESXi. Die ID und Treiber müssen zum tatsächlichen Gast und Hypervisor passen.
3. **CPU-Sockel**, **Kerne / Sockel**, **RAM (GiB)** und **Disk (GiB)** festlegen. `vCPUs` wird als Sockel × Kerne berechnet, beispielsweise 1 × 4 = 4 vCPUs.
4. **Storage / Datastore**, **Disk-Controller**, **Netzwerk**, **NIC-Modell**, **Firmware** und **ISO / Startmedium** eintragen.
5. Die zur Plattform passenden Zusatzfelder ausfüllen. `Anlegen` und `Starten` zunächst auf `NEIN` belassen, bis die Spezifikation geprüft ist.
| Einstellung | PVE | ESXi |
| --- | --- | --- |
| Ablage der VM-Disk | Storage-ID, z.B. `local-lvm` | Datastore, z.B. `datastore1` |
| Disk-Controller | z.B. VirtIO SCSI | z.B. VMware Paravirtual oder LSI Logic SAS |
| Netzwerk | SDN-VNet aus dem Dropdown, z.B. `app110` | dvPortgroup aus dem Dropdown, z.B. `PG-APP-110` |
| VLAN | im SDN-VNet festlegen; VM-Feld leer lassen | in der Portgruppe konfigurieren; VM-Feld leer lassen |
| Netzwerkkarte | z.B. VirtIO | z.B. VMXNET3 |
| VM-ID | im PVE-Cluster eindeutige Nummer | leer lassen |
| CPU-Typ | zur Hardware/Migration passend | PVE-Feld leer lassen |
| Diskformat | vom gewählten Storage abhängig | Thin, Thick oder EagerZeroedThick |
| VM-Ordner | leer lassen | optionaler Inventarordner bei vCenter |
| ISO-Referenz | `local:iso/datei.iso` | `[datastore1] ISO/datei.iso` |
Die ISO-Referenz bezeichnet ein Startmedium auf dem Virtualisierer. Eine Datei auf der GETAC-Freigabe ist dort nicht automatisch verfügbar; Übertragung und Einbindung sind später gesondert umzusetzen. Hardwaremodelle und Gast-OS-IDs sind keine beliebig austauschbaren Bezeichnungen.
Gelbe Zellen sind Eingaben, blaue Zellen werden berechnet. Die Spalte `Eingaben` weist auf fehlende Pflichtangaben, doppelte VM-Namen und unpassende Zusatzfelder hin. „Erfasst – technisch prüfen“ bestätigt nur die Erfassung. Die numerischen Eingabegrenzen sind keine zugesicherten Plattform- oder Hardwarelimits.
Dieser Stand plant eine Systemdisk und eine Netzwerkkarte je VM. Zusätzliche Disks/NICs, Gast-IP-Konfiguration, Templates, OS-Installation, Secure Boot und vTPM sind noch nicht enthalten. Insbesondere eine Windows-11-VM benötigt weitere Prüfung dieser Funktionen. Keine Zugangsdaten in die Tabelle schreiben.
**Die Skripte 01–03 bleiben für die Vorbereitung der Virtualisierer zuständig. Sie erstellen noch keine VMs und führen die Planungsschalter im neuen Blatt nicht aus.**
Feldgrundlagen: [Proxmox-Administrationshandbuch](https://pve.proxmox.com/pve-docs/pve-admin-guide.pdf) und [Broadcom New-VM](https://developer.broadcom.com/powercli/latest/vmware.vimautomation.core/commands/new-vm/). Reale Deployment- und Kompatibilitätstests sind noch erforderlich.
Die Spalte `Netzwerkplanung` prüft den Netzwerknamen und ein zusätzliches PVE-VM-VLAN. Die Mitgliedschaft des Hosts in vDS beziehungsweise SDN-Zone bleibt separat zu prüfen; das Dropdown filtert nach Plattform, nicht nach Host.
Binary file not shown.
File diff suppressed because one or more lines are too long
@@ -0,0 +1,48 @@
#!/bin/bash
echo "Idempotentes Hinzufügen von VMs und CTs zur HA (ohne Templates)..."
# Funktion zum Prüfen, ob eine HA-Ressource bereits existiert
ha_exists() {
local res="$1"
ha-manager status | awk '{print $1}' | grep -qx "$res"
}
# --- VMs (Qemu) ---
for vmid in $(qm list | awk 'NR>1 {print $1}'); do
# Templates überspringen
if qm config "$vmid" | grep -q "^template:\s*1"; then
echo "VM $vmid ist ein Template → wird übersprungen."
continue
fi
resource="vm:$vmid"
if ha_exists "$resource"; then
echo "VM $vmid ist bereits in HA → OK."
else
echo "VM $vmid wird zur HA hinzugefügt..."
ha-manager add $resource --state started --max_restart 3 --max_relocate 3
fi
done
# --- CTs (LXC) ---
for ctid in $(pct list | awk 'NR>1 {print $1}'); do
# Templates überspringen
if pct config "$ctid" | grep -q "^template:\s*1"; then
echo "CT $ctid ist ein Template → wird übersprungen."
continue
fi
resource="ct:$ctid"
if ha_exists "$resource"; then
echo "CT $ctid ist bereits in HA → OK."
else
echo "CT $ctid wird zur HA hinzugefügt..."
ha-manager add $resource --state started --max_restart 3 --max_relocate 3
fi
done
echo "Fertig."
Binary file not shown.
@@ -0,0 +1,48 @@
logging {
debug: off
to_syslog: yes
}
nodelist {
node {
name: pve-x-1
nodeid: 1
quorum_votes: 1
ring0_addr: 10.1.99.XXX
ring1_addr: 10.3.99.XXX
}
node {
name: pve-x-2
nodeid: 2
quorum_votes: 1
ring0_addr: 10.1.99.XXX
ring1_addr: 10.3.99.XXX
}
node {
name: pve-x-3
nodeid: 3
quorum_votes: 1
ring0_addr: 10.1.99.XXX
ring1_addr: 10.3.99.XXX
}
}
quorum {
provider: corosync_votequorum
}
totem {
cluster_name: cluster-x
config_version: 4
interface {
linknumber: 0
}
interface {
linknumber: 1
}
ip_version: ipv4-6
link_mode: passive
secauth: on
version: 2
}
@@ -0,0 +1,89 @@
# network interface settings; autogenerated
# Please do NOT modify this file directly, unless you know what
# you're doing.
#
# If you want to manage parts of the network configuration manually,
# please utilize the 'source' or 'source-directory' directives to do
# so.
# PVE will preserve these directives, but will NOT read its network
# configuration from sourced files, so do not attempt to move any of
# the PVE managed interfaces into external files!
auto lo
iface lo inet loopback
auto ens18
iface ens18 inet manual
# Karte 10GBPS
auto ens19
iface ens19 inet manual
auto ens20
iface ens20 inet static
address 10.2.99.XXX/24
#Corosync Link 0
auto ens21
iface ens21 inet static
address 10.3.99.XXX/24
#Corosync Link 1
auto ens22
iface ens22 inet manual
auto ens23
iface ens23 inet manual
auto bond0
iface bond0 inet manual
bond-slaves ens18 ens19
bond-miimon 100
bond-mode active-backup
bond-primary ens18
#Bond0 nach aussen
auto bond1
iface bond1 inet manual
bond-slaves ens22 ens23
bond-miimon 100
bond-mode active-backup
bond-primary ens22
#Bond1 zum Ceph Storage
auto vmbr0
iface vmbr0 inet static
address 10.1.99.XXX/24
gateway 10.1.99.254
bridge-ports bond0
bridge-stp off
bridge-fd 0
#Bridge nach aussen
source /etc/network/interfaces.d/*
auto vmbr1
iface vmbr1 inet static
address 192.168.127.254/24
bridge-ports none
bridge-stp off
bridge-fd 0
pre-up iptables -t nat -A POSTROUTING -s '192.168.127.0/24' -o vmbr0 -j MASQUERADE
pre-up echo 1 > /proc/sys/net/ipv4/ip_forward
post-down iptables -t nat -F
# END ANSIBLE MANAGED BLOCK
auto Ceph_public
iface Ceph_public inet static
address 10.4.99.XXX/24
vlan-id 50
vlan-raw-device bond1
#Ceph_public
auto Ceph_cluster
iface Ceph_cluster inet static
address 10.5.99.XXX/24
vlan-id 51
vlan-raw-device bond1
#Ceph_cluster