Open-Source-Lizenzen verstehen: Was Entwickler bei MIT, GPL und Co. beachten sollten

⚠️ Keine Rechtsberatung: Dieser Beitrag und die folgende Übersicht dienen der allgemeinen Orientierung. Die Liste ist unvollständig, vereinfacht komplexe Lizenzbedingungen und kann Fehler enthalten. Verlasse dich deshalb bei einer konkreten Nutzungs- oder Veröffentlichungsentscheidung nicht allein auf diese Angaben. Maßgeblich sind die für die jeweilige Softwareversion geltenden Lizenzbedingungen und der konkrete Einsatz. Wende dich im Zweifel an einen Rechtsbeistand, der sich mit Softwarelizenzen auskennt.

Ein NuGet-Paket ist schnell installiert. Bei der nächsten Veröffentlichung stellt sich dann eine weniger angenehme Frage: Darf ich die Bibliothek überhaupt so einsetzen und weitergeben – und welche Hinweise muss ich beilegen?

Die Antwort steht in der Lizenz der konkreten Version. MIT, Apache, GPL oder AGPL unterscheiden sich zum Teil erheblich. Dazu kommen Lizenzen, bei denen der Quellcode zwar einsehbar ist, die Nutzung aber eingeschränkt wird. Gerade nach einem Update lohnt sich deshalb ein zweiter Blick.

Die wichtigsten Begriffe vorab

Urheberrecht: Quellcode ist grundsätzlich urheberrechtlich geschützt. Ein öffentliches Repository ist keine pauschale Erlaubnis, den Code beliebig zu übernehmen. Ohne Lizenz fehlen meist die dafür nötigen Nutzungsrechte; gesetzliche Ausnahmen und Plattformbedingungen können im Einzelfall trotzdem gelten.

Permissive Lizenz: Sie erlaubt in der Regel auch die Verwendung in proprietärer Software. Bedingungen wie das Beibehalten von Lizenz- und Urheberrechtshinweisen bleiben bestehen.

Copyleft: Die Lizenz soll sicherstellen, dass bestimmte Freiheiten bei der Weitergabe erhalten bleiben. Wie weit das reicht, hängt von der jeweiligen Lizenz und davon ab, wie die Bestandteile kombiniert werden.

Weitergabe: Die Übergabe einer Anwendung, eines Containers oder eines Geräts an Dritte kann Lizenzpflichten auslösen. Die reine Nutzung auf einem eigenen Server ist nicht automatisch eine Weitergabe. Bei Webanwendungen können allerdings Dateien wie JavaScript an den Browser ausgeliefert werden.

SPDX: Eine standardisierte Kennung wie MIT, Apache-2.0 oder GPL-3.0-only macht Lizenzangaben für Werkzeuge auswertbar. Das Suffix -or-later erlaubt zusätzlich spätere Lizenzversionen, -only beschränkt die Angabe auf die genannte Version.

Source-available: Der Quellcode ist einsehbar, seine Nutzung kann aber eingeschränkt sein. Solche Lizenzen sind nicht automatisch Open Source im Sinne der Open Source Definition. Die Open Source Initiative (OSI) veröffentlicht eine Liste der von ihr anerkannten Lizenzen.

Der schnelle Überblick

  • MIT und BSD: weitreichende Nutzung, Hinweise und Lizenztext beachten.
  • Apache-2.0: permissiv, zusätzlich mit ausdrücklicher Patentlizenz und möglichen NOTICE-Pflichten.
  • GPL: starkes Copyleft; bei Weitergabe gelten Anforderungen an Lizenz und Quellcode.
  • LGPL: schwächeres Copyleft für Bibliotheken; die Austauschbarkeit ist wichtig.
  • AGPL-3.0: ergänzt die GPL um eine Pflicht bei Netzwerkinteraktion mit einer veränderten Version.
  • MPL-2.0: Copyleft auf Dateiebene bei der Weitergabe.
  • BUSL, SSPL, Elastic License, PolyForm und FSL: je nach Lizenz eingeschränkte Nutzungsrechte; keine OSI-anerkannten Open-Source-Lizenzen.
Drei Dokumentenstapel als Symbol für unterschiedliche Lizenzbedingungen

1. MIT und BSD: unkompliziert, aber nicht ohne Bedingungen

Die MIT-Lizenz gehört zu den kurzen, permissiven Lizenzen. Du kannst entsprechend lizenzierten Code grundsätzlich auch in kommerziellen und geschlossenen Anwendungen verwenden. Der Urheberrechtsvermerk und der Lizenztext müssen gemäß den Lizenzbedingungen erhalten bleiben.

Bei BSD begegnen dir insbesondere BSD-2-Clause und BSD-3-Clause. Beide verlangen den Erhalt bestimmter Hinweise. Die Drei-Klausel-Variante verbietet zusätzlich, den Namen der Rechteinhaber oder Mitwirkenden ohne Erlaubnis zur Bewerbung abgeleiteter Produkte zu verwenden.

Für die Praxis: Auch bei einer permissiven Lizenz solltest du prüfen, welche Hinweise deine Anwendung, Dokumentation oder ein beigelegtes THIRD-PARTY-NOTICES-Dokument enthalten muss. Bei vielen Abhängigkeiten wird das schnell unübersichtlich.

2. Apache-2.0: permissiv mit Patentregelung

Die Apache License 2.0 erlaubt ebenfalls die Nutzung in proprietären Produkten. Sie enthält darüber hinaus eine ausdrückliche Patentlizenz für relevante Beiträge. Unter den im Lizenztext genannten Voraussetzungen kann diese Patentlizenz enden, wenn eine Patentklage erhoben wird.

Bei der Weitergabe sind unter anderem Lizenztext und Hinweise zu beachten. Geänderte Dateien müssen entsprechende Änderungsvermerke tragen. Enthält das Projekt eine NOTICE-Datei, sind deren relevante Hinweise entsprechend der Lizenz weiterzugeben.

Für die Praxis: Lass beim Build nicht nur die Anwendung selbst, sondern auch die erforderlichen Lizenzhinweise im Paket landen. Apache-2.0 ist mit GPL-3.0 grundsätzlich kombinierbar, aber nicht mit GPL-2.0-only. Ausnahmen und weitere Lizenzangaben des jeweiligen Projekts können die Bewertung verändern.

3. GPL-2.0 und GPL-3.0: starkes Copyleft

Die GNU General Public License erlaubt Nutzung, Änderung und Weitergabe. Wer ein unter GPL stehendes Programm oder ein entsprechendes abgeleitetes Werk weitergibt, muss die Bedingungen der jeweiligen Version einhalten. Dazu gehört bei der Weitergabe ausführbarer Programme grundsätzlich auch, den entsprechenden Quellcode auf einem von der Lizenz vorgesehenen Weg verfügbar zu machen.

Der entsprechende Quellcode kann mehr umfassen als die geänderten Dateien: Je nach Lizenz und Produkt gehören auch für Erstellung und Installation notwendige Skripte dazu. GPL-3.0 enthält unter bestimmten Voraussetzungen zusätzliche Regeln zur Installation veränderter Versionen auf Verbrauchergeräten sowie ausdrückliche Patentregelungen. Die Details stehen in der GPL-3.0.

Für die Praxis: Ob das Einbinden einer GPL-Bibliothek eine Anwendung lizenzrechtlich zu einem gemeinsamen Werk macht, hängt unter anderem von der konkreten Kombination und der anwendbaren Rechtslage ab. Das lässt sich nicht allein an „statisch“ oder „dynamisch“ festmachen. Prüfe auch, ob only oder or-later gilt.

4. LGPL: Bibliotheken auch in geschlossenen Anwendungen nutzen

Die LGPL ist für Fälle gedacht, in denen eine Bibliothek mit einer Anwendung unter anderen Lizenzbedingungen kombiniert werden soll. Eine proprietäre Anwendung muss dadurch nicht automatisch unter die LGPL gestellt werden. Änderungen an der LGPL-Bibliothek selbst bleiben bei entsprechender Weitergabe von den Lizenzpflichten erfasst.

Ein zentraler Punkt ist, dass Nutzer eine kompatible, veränderte Version der Bibliothek verwenden können. Dynamisches Einbinden kann dafür ein geeigneter Weg sein, sofern Austausch und Nutzung tatsächlich möglich sind und die weiteren Bedingungen erfüllt werden. Bei statischer Einbindung kann es nötig sein, geeignete Objektdateien oder andere Möglichkeiten zum erneuten Linken bereitzustellen.

Für die Praxis: Gerade bei mobilen Apps, Single-File-Builds und signierten Geräten sollte die Austauschbarkeit konkret geprüft werden. Einzelheiten und Ausnahmen unterscheiden sich zwischen den Versionen; siehe die LGPL-3.0 und die GNU-FAQ.

5. AGPL-3.0: wenn Software über das Netzwerk genutzt wird

Die AGPL-3.0 baut auf der GPL auf und ergänzt eine Regel für die Nutzung über ein Netzwerk. Wer eine veränderte Version betreibt, muss den Nutzern, die über das Netzwerk mit ihr interagieren, den entsprechenden Quellcode dieser Version unter den Bedingungen der Lizenz anbieten.

Das bedeutet nicht, dass jede Anwendung, die irgendeinen AGPL-Dienst über eine API anspricht, automatisch ihren gesamten Quellcode veröffentlichen muss. Entscheidend sind unter anderem die Veränderung, die Art der Kombination und der konkrete Einsatz. Die üblichen GPL-Pflichten bei Weitergabe gelten zusätzlich.

Ein aktuelles Beispiel ist Redis: Redis Open Source ab Version 8 wird laut Anbieter unter RSALv2, SSPLv1 oder AGPLv3 angeboten. Für Redis Community Edition 7.4 bis 7.8 gelten dagegen RSALv2 oder SSPLv1. Ein Versionswechsel kann also auch die verfügbaren Lizenzoptionen ändern.

Für die Praxis: Prüfe bei einem selbst gehosteten Dienst, ob du die Software unverändert nutzt oder veränderst, wer mit ihr interagiert und welche Bestandteile tatsächlich betroffen sind.

Server, Laptop und Netzwerk als Sinnbild für Softwarelizenzen bei Online-Diensten

GPLv2, GPLv3, LGPL und AGPL: Was unterscheidet sie konkret?

Alle vier erlauben grundsätzlich auch kommerzielle Nutzung. Du darfst also Geld für Software oder einen Dienst verlangen. Die entscheidenden Unterschiede liegen darin, welche Teile vom Copyleft erfasst werden und welches Ereignis die Pflichten auslöst.

GPLv2 und GPLv3: gleicher Grundgedanke, zusätzliche Regeln

Sowohl die GPLv2 als auch die GPLv3 knüpfen ihre Quellcodepflichten grundsätzlich an die Weitergabe. Die GPLv3 ergänzt insbesondere:

  • Installation veränderter Versionen: Bei bestimmten Verbraucherprodukten müssen die nötigen Installationsinformationen mitgegeben werden. Nutzer sollen eine eigene Version tatsächlich installieren und ausführen können. Diese ausdrücklich geregelte Pflicht fehlt in GPLv2.
  • Patente: GPLv3 enthält eine ausdrückliche Patentlizenz der Beitragenden und zusätzliche Schutzregeln gegen bestimmte Patentvereinbarungen. GPLv2 enthält dafür keine gleich ausgestaltete Regelung.
  • Lizenzkompatibilität: Apache-2.0-Code lässt sich grundsätzlich in ein GPLv3-Gesamtwerk einbeziehen. Mit GPL-2.0-only ist diese Kombination nicht ohne zusätzliche Erlaubnis möglich.
  • Behebung von Verstößen: GPLv3 regelt ausdrücklich, unter welchen Bedingungen beendete Rechte nach Beseitigung eines Verstoßes wieder aufleben können.

Ein Versionswechsel ist keine freie Entscheidung des Nutzers: GPL-2.0-only und GPL-3.0-only sind nicht einfach austauschbar. GPL-2.0-or-later erlaubt dagegen, GPLv3 zu wählen. Maßgeblich sind die Lizenzangaben der Rechteinhaber und mögliche Ausnahmen.

LGPL: eine Bibliothek einbinden, ohne die ganze Anwendung umzulizenzieren

Die LGPL erlaubt unter ihren Bedingungen auch die Kombination mit einer proprietären Anwendung. Bei einer Weitergabe müssen die Nutzer die LGPL-Bibliothek durch eine kompatible, veränderte Version ersetzen können. Dafür können eine austauschbare dynamische Bibliothek oder geeignete Dateien zum erneuten Linken erforderlich sein. Die LGPL-Bestandteile müssen einschließlich ihrer Änderungen nach den jeweiligen Quellcodebedingungen zugänglich sein; der eigenständige Anwendungscode muss dadurch nicht generell offengelegt werden.

LGPL-2.1 und LGPL-3.0 verfolgen diesen Ansatz mit unterschiedlichen Regelungen. LGPLv3 baut auf GPLv3 auf und erteilt zusätzliche Erlaubnisse. Je nach Fall sind auch Installationsinformationen und die Erlaubnis zum Reverse Engineering für die Fehlersuche an Bibliotheksänderungen wichtig. Eine EULA darf die erforderlichen Rechte nicht wieder ausschließen.

SaaS: Der Kunde benutzt die Anwendung im Browser

Stell dir eine Anwendung zur Geräteverwaltung vor. Sie läuft auf deinem Server, Kunden melden sich über den Browser an und bezahlen monatlich. Für die Lizenzprüfung macht es einen Unterschied, ob du nur den Dienst anbietest oder dem Kunden zusätzlich die Anwendung als Container übergibst.

  • GPLv2 oder GPLv3 auf dem Server: Allein der Zugriff auf eine rein serverseitig betriebene, auch veränderte Anwendung löst grundsätzlich keine Pflicht aus, den Kunden den Quellcode bereitzustellen. Die GPLv3 hat keine allgemeine SaaS-Klausel.
  • LGPL-Bibliothek auf dem Server: Auch hier entsteht durch den reinen Netzwerkzugriff keine zusätzliche Quellcodepflicht. Bei einer späteren Weitergabe gelten die LGPL-Bedingungen.
  • Veränderte AGPLv3-Anwendung: Den Nutzern, die über das Netzwerk mit ihr interagieren, muss gut sichtbar eine kostenlose Möglichkeit zum Abruf des entsprechenden Quellcodes angeboten werden. Ein passender Link in der Oberfläche kann dafür geeignet sein. Es geht um die tatsächlich betriebene Version einschließlich der erfassten Änderungen.
  • Container beim Kunden: Wird die Anwendung als Image oder Installationspaket an den Kunden übergeben, ist das eine Weitergabe. Dann müssen die jeweiligen GPL-, LGPL- oder AGPL-Pflichten für die erfassten Bestandteile erfüllt werden.

Browsercode zählt mit: JavaScript oder WebAssembly, das an den Browser ausgeliefert wird, ist eine übertragene Softwarekopie. „Wir bieten nur SaaS an“ beschreibt deshalb nicht automatisch alle Bestandteile der Anwendung. Die GNU-FAQ erläutert die Unterscheidung zwischen serverseitiger Nutzung und ausgeliefertem Code.

Die AGPLv3 erfasst nicht pauschal jede eigenständige Anwendung, die einen Dienst über HTTP anspricht. Eine API oder ein separater Container garantiert umgekehrt auch keine lizenzrechtliche Unabhängigkeit. Entscheidend ist, ob tatsächlich getrennte Programme oder ein erfasstes kombiniertes Werk vorliegen.

6. MPL-2.0: Copyleft auf Dateiebene

Die Mozilla Public License 2.0 liegt zwischen permissiven Lizenzen und starkem Copyleft. Änderungen an erfassten Dateien bleiben unter der MPL. Bei der Weitergabe müssen die entsprechenden MPL-Quellen nach den Lizenzbedingungen verfügbar gemacht werden.

Eigene, getrennte Dateien ohne MPL-Code können in einem größeren Werk grundsätzlich unter anderen Bedingungen stehen. Eine proprietäre Anwendung kann also MPL-Komponenten enthalten, ohne dass allein dadurch der gesamte eigene Quellcode unter die MPL fällt.

Für die Praxis: Schau dir an, welche Dateien tatsächlich MPL-Code enthalten. Eine reine Servernutzung löst nach der Mozilla-FAQ nicht schon deshalb die Weitergabepflichten aus, weil die Funktion über das Web erreichbar ist.

7. Business Source License 1.1: Quellcode sichtbar, Produktion eingeschränkt

Die Business Source License 1.1, oft als BUSL-1.1 bezeichnet, ist keine Open-Source-Lizenz. Sie erlaubt unter anderem die nichtproduktive Nutzung. Ob und in welchem Umfang ein produktiver Einsatz erlaubt ist, steht in der projektspezifischen Additional Use Grant.

Für jede Version gilt außerdem eine spätere Umstellung auf die angegebene Change License: zum genannten Datum oder spätestens am vierten Jahrestag der ersten öffentlichen Bereitstellung der jeweiligen Version – je nachdem, was früher eintritt.

Für die Praxis: Zwei Projekte mit BUSL-1.1 können unterschiedliche Regeln für den Produktivbetrieb haben. Prüfe deshalb die konkrete Version, die Additional Use Grant, das Änderungsdatum und die spätere Lizenz. Verwechsle BUSL-1.1 nicht mit BSL-1.0, der SPDX-Kennung der Boost Software License.

8. SSPL: weitreichende Bedingungen für Dienste

Die Server Side Public License 1.0 orientiert sich an der AGPL, ergänzt aber eine deutlich weitergehende Bedingung für das Anbieten der Software als Dienst. Abschnitt 13 erfasst nach seinem Wortlaut auch Software, die zur Bereitstellung und Verwaltung des Dienstes erforderlich ist, etwa für Monitoring und Automatisierung.

Die OSI ordnet die SSPL nicht als Open-Source-Lizenz ein. Ob ein konkretes Angebot unter diese Dienstregel fällt und welche Komponenten erfasst wären, sollte sorgfältig geprüft werden.

Für die Praxis: Ein intern betriebener Server und ein für Dritte angebotenes Datenbankprodukt sind unterschiedliche Szenarien. Der bloße Begriff „Cloud“ reicht für die Bewertung nicht aus.

9. Elastic License, PolyForm und Functional Source License

Auch bei diesen Lizenzen ist der Quellcode einsehbar, die Nutzung kann aber eingeschränkt sein. Sie haben unterschiedliche Texte und sollten nicht als austauschbar behandelt werden.

  • Elastic License 2.0: untersagt unter anderem bestimmte Angebote als gehosteter oder verwalteter Dienst für Dritte sowie das Umgehen von Lizenzschlüsselfunktionen. Entscheidend ist der genaue Wortlaut.
  • PolyForm: bezeichnet eine Familie verschiedener Lizenzen, darunter Noncommercial, Small Business und Shield. Die erlaubte Nutzung hängt von der gewählten Variante ab.
  • Functional Source License 1.1: erlaubt viele Nutzungen, schränkt aber konkurrierende Nutzungen nach ihrer Definition ein. Nach zwei Jahren wird die jeweilige Version unter MIT oder Apache-2.0 verfügbar – je nach gewählter FSL-Variante. Mehr dazu auf fsl.software.

Wichtig bei Produktnamen: Elastic bietet für den freien Quellcode von Elasticsearch und Kibana laut Lizenz-FAQ zusätzlich AGPLv3 als Option an. Daraus folgt nicht, dass jedes Elastic-Produkt oder jedes fertig bereitgestellte Paket automatisch unter AGPL steht.

10. Keine Lizenz, mehrere Lizenzen und Beiträge von außen

Fehlt eine Lizenz, solltest du nicht davon ausgehen, dass du den Code in dein Projekt übernehmen und weitergeben darfst. Frage beim Rechteinhaber nach oder suche eine Alternative mit klaren Bedingungen. Plattformbedingungen können bestimmte Vorgänge wie das Anzeigen oder Forken erlauben; sie ersetzen keine allgemeine Softwarelizenz.

Bei einer Mehrfachlizenzierung darfst du in der Regel eine der angebotenen Lizenzen wählen und musst deren Bedingungen erfüllen. Prüfe, ob die Wahl tatsächlich für den gesamten benötigten Code und die verwendete Version gilt.

Für Projektbetreiber sind Beiträge Dritter ein weiterer Punkt. Ein Contributor License Agreement (CLA) kann zusätzliche Rechte einräumen, etwa für eine spätere Mehrfachlizenzierung – aber nur, soweit das konkrete Abkommen sie vorsieht. Ein Developer Certificate of Origin (DCO) bestätigt dagegen typischerweise per Signed-off-by, dass der Beitrag unter den Projektbedingungen eingereicht werden darf. Es räumt nicht automatisch umfassende Rechte zur Neulizenzierung ein.

Laptop mit Abhängigkeiten und Checkliste für die Lizenzprüfung

Lizenzen im .NET-Projekt überprüfen

Ein erster Schritt ist eine Übersicht aller direkten und transitiven NuGet-Abhängigkeiten. Im Projektverzeichnis kannst du mit aktuellen .NET-SDKs beispielsweise Folgendes ausführen:

dotnet list package --include-transitive

Der Befehl zeigt Pakete und Versionen, erstellt aber noch keinen vollständigen Lizenzbericht. Prüfe anschließend die Lizenzinformationen der Pakete und vergleiche sie mit den tatsächlich verwendeten Dateien und Versionen. Lizenzscanner oder eine Software-Stückliste (SBOM) können die Arbeit unterstützen; fehlende oder ungenaue Paketmetadaten müssen manuell geklärt werden.

Für eigene Dateien lassen sich Lizenz und Urheberrecht maschinenlesbar kennzeichnen, zum Beispiel in einer C#-Datei:

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2026 Beispiel GmbH

Das Beispiel ersetzt weder den vollständigen Lizenztext noch die notwendigen Rechte am enthaltenen Code. Eine Kennzeichnung macht vorhandene Bedingungen sichtbar, schafft sie aber nicht rückwirkend.

Lizenzen überwachen: Scanner und SBOM als Grundlage

Für die laufende Prüfung gibt es Werkzeuge: ScanCode Toolkit erkennt unter anderem Lizenz- und Copyright-Angaben in Dateien. OWASP Dependency-Track kann Komponenten aus einer SBOM erfassen und auf Lizenzrisiken sowie Richtlinienverstöße prüfen. Auch die GitHub Dependency Review kann Änderungen an Abhängigkeiten bewerten und Lizenzregeln in Pull Requests durchsetzen; die Verfügbarkeit hängt vom Repository und gebuchten Funktionsumfang ab.

SBOM steht für Software Bill of Materials, also eine Software-Stückliste. Sie dokumentiert die enthaltenen Komponenten und Versionen und kann auch Lizenzinformationen enthalten. Gängige Formate sind SPDX und CycloneDX. Eine SBOM ist zunächst ein Datenbestand; die laufende Überwachung und Bewertung übernehmen darauf aufbauende Werkzeuge.

Damit lassen sich etwa unbekannte Lizenzen oder geänderte Lizenzangaben nach einem Paketupdate sichtbar machen. Vollständig und aktuell werden diese Informationen nur, wenn Erstellung, Auswertung und manuelle Klärung in den Entwicklungsprozess eingebunden sind.

Wie sich eine SBOM für ein .NET-Projekt erzeugen und in der CI-Pipeline auswerten lässt, kommt in einem späteren Beitrag. Hier bleibt es zunächst bei der Einordnung der Lizenzen.

Eine kleine Checkliste für das nächste Update

  1. Welche direkte und transitive Abhängigkeit wird in welcher Version eingesetzt?
  2. Welche Lizenz gilt für genau diese Version und für die tatsächlich verwendeten Komponenten?
  3. Wird die Software nur intern genutzt, an Kunden weitergegeben oder als Dienst angeboten?
  4. Müssen Lizenztexte, Copyright-Hinweise, NOTICE-Dateien oder Quellcode bereitgestellt werden?
  5. Gab es beim letzten Versionswechsel eine Lizenzänderung oder zusätzliche Einschränkungen?
  6. Werden die Ergebnisse dokumentiert und bei einem Update erneut geprüft?

Ein Lizenzscan in der CI-Pipeline ist dafür ein guter Anfang. Er zeigt, was Pakete deklarieren – nicht zwingend alle Ausnahmen, separat lizenzierten Dateien oder vertraglichen Vereinbarungen. Gerade auffällige und unbekannte Einträge verdienen deshalb einen Blick in die Originaldateien.

Wenn du direkt anfangen möchtest, nimm dir ein größeres Projekt vor, erstelle eine Liste seiner Abhängigkeiten und gleiche die gefundenen Lizenzen mit deiner tatsächlichen Nutzung ab. Die überraschenden Einträge sind meist die interessantesten.

Lizenzmatrix: Was darf ich, was muss ich?

So liest du die Übersicht: „Ja“ gilt jeweils unter den Lizenzbedingungen. Die Hinweispflichten beziehen sich auf die Weitergabe. „Reiner SaaS-Betrieb“ meint serverseitige Nutzung ohne Übertragung einer Softwarekopie an den Kunden; ausgelieferter Browsercode muss gesondert bewertet werden. Sondervereinbarungen und zusätzliche Ausnahmen sind hier nicht abgebildet.

Namensnennung bedeutet meist, vorhandene Copyright- und Lizenzhinweise zu erhalten. Daraus folgt nicht automatisch eine Werbenennung oder ein sichtbares Logo in der Benutzeroberfläche. Manche Lizenzen verlangen aber bestimmte rechtliche Hinweise in interaktiven Oberflächen; vorhandene Hinweise dürfen nicht einfach entfernt werden.

Quellcode bereitstellen heißt nicht grundsätzlich, ihn weltweit auf GitHub zu veröffentlichen. Bei GPL und LGPL geht es im Regelfall um den Zugang für die Empfänger und den jeweils zulässigen Bereitstellungsweg. Bei veränderter AGPL-Software kommen die interagierenden Netzwerknutzer hinzu. Diese Empfänger dürfen den Code unter den Lizenzbedingungen weitergeben.

Der Quellcode muss nicht immer direkt im Installer liegen. Je nach Lizenzversion und Weitergabeweg sind beispielsweise ein zugeordneter Download oder ein gültiges schriftliches Angebot möglich. Bei GPLv2 kann ein solches Angebot mindestens drei Jahre lang auch gegenüber Dritten gelten. Ein beliebiger Link zum Upstream-Projekt reicht nicht, wenn dort die passende Version einschließlich deiner Änderungen fehlt.

Nutzung und Änderungen

LizenzNutzung und Änderungen
MITKommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; keine zusätzliche Quellcodepflicht
BSD-2 / BSD-3Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; keine zusätzliche Quellcodepflicht
Apache-2.0Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; keine zusätzliche Quellcodepflicht
GPLv2Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; allein dadurch keine Quellcodepflicht
GPLv3Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; allein dadurch keine Quellcodepflicht
LGPL-2.1 / LGPL-3.0Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; allein dadurch keine Quellcodepflicht
AGPLv3Kommerziell: Ja
Änderungen: Ja
SaaS: Bei veränderter Version: Quellcodeangebot an interagierende Netzwerknutzer
MPL-2.0Kommerziell: Ja
Änderungen: Ja
SaaS: Erlaubt; allein dadurch keine Quellcodepflicht
BUSL-1.1Kommerziell: Produktiv nur nach Additional Use Grant oder gesonderter Erlaubnis
Änderungen: Ja, im Lizenzrahmen
SaaS: Produktive Nutzung anhand der konkreten Grant prüfen
SSPL-1.0Kommerziell: Ja, unter den Bedingungen
Änderungen: Ja
SaaS: Beim erfassten Dienstangebot weitreichende Offenlegung des Service-Quellcodes
Elastic License 2.0Kommerziell: Ja, mit Einschränkungen
Änderungen: Ja, mit Einschränkungen
SaaS: Erfasste Angebote als gehosteter / verwalteter Dienst für Dritte untersagt
PolyFormKommerziell: Abhängig von Variante und Nutzung
Änderungen: Im Rahmen der Variante
SaaS: Variante prüfen, z. B. Noncommercial oder Shield
FSL-1.1Kommerziell: Ja, außer definierten konkurrierenden Nutzungen
Änderungen: Ja, im Lizenzrahmen
SaaS: Nur soweit keine verbotene konkurrierende Nutzung
Keine LizenzKommerziell: Ohne weitere Erlaubnis regelmäßig keine ausreichenden Rechte
Änderungen: Ohne weitere Erlaubnis regelmäßig keine ausreichenden Rechte
SaaS: Nicht pauschal erlaubt

Pflichten bei der Weitergabe

LizenzHinweise und Quellcode
MITHinweise: Copyright + Lizenztext erhalten
Quellcode: Nein
BSD-2 / BSD-3Hinweise: Copyright, Bedingungen + Haftungsausschluss; BSD-3: Werbeverbot mit Namen beachten
Quellcode: Nein
Apache-2.0Hinweise: Lizenz + relevante Hinweise / NOTICE; Änderungen kennzeichnen
Quellcode: Nein
GPLv2Hinweise: Lizenz + Hinweise; Änderungen kennzeichnen
Quellcode: Ja, für das GPL-Werk, auch unverändert; zulässigen Bereitstellungsweg wählen
GPLv3Hinweise: Lizenz + Hinweise; Änderungen kennzeichnen
Quellcode: Ja, für das GPL-Werk; ggf. Installationsinformationen
LGPL-2.1 / LGPL-3.0Hinweise: Lizenztexte + Hinweise gemäß Version; Nutzung der Bibliothek kenntlich machen
Quellcode: Für LGPL-Anteile ja; Austausch / erneutes Linken ermöglichen; eigener Anwendungscode nicht generell
AGPLv3Hinweise: Lizenz + Hinweise; Änderungen kennzeichnen
Quellcode: Ja, für das AGPL-Werk nach den Weitergaberegeln
MPL-2.0Hinweise: Hinweise erhalten; über MPL und Quellcodezugang informieren
Quellcode: Ja, für erfasste Dateien einschließlich Änderungen; eigene getrennte Dateien nicht generell
BUSL-1.1Hinweise: BUSL-Text + Projektparameter sichtbar beibehalten
Quellcode: Keine allgemeine Quellcodepflicht wie bei GPL; weitere Bedingungen prüfen
SSPL-1.0Hinweise: Lizenz + Hinweise; Änderungen kennzeichnen
Quellcode: Ja, für das erfasste Werk
Elastic License 2.0Hinweise: Lizenz / Hinweise erhalten; Lizenzfunktionen beachten
Quellcode: Keine allgemeine Quellcodepflicht
PolyFormHinweise: Vorgaben der konkreten Variante beachten
Quellcode: Keine einheitliche Regel für die Lizenzfamilie
FSL-1.1Hinweise: Lizenz + vorgeschriebene Hinweise beibehalten
Quellcode: Keine allgemeine Quellcodepflicht; nach 2 Jahren MIT oder Apache-2.0
Keine LizenzHinweise: Namensnennung ersetzt keine Erlaubnis
Quellcode: Kein daraus ableitbares Nutzungs- oder Weitergaberecht

⚠️ Keine Rechtsberatung: Dieser Beitrag und die folgende Übersicht dienen der allgemeinen Orientierung. Die Liste ist unvollständig, vereinfacht komplexe Lizenzbedingungen und kann Fehler enthalten. Verlasse dich deshalb bei einer konkreten Nutzungs- oder Veröffentlichungsentscheidung nicht allein auf diese Angaben. Maßgeblich sind die für die jeweilige Softwareversion geltenden Lizenzbedingungen und der konkrete Einsatz. Wende dich im Zweifel an einen Rechtsbeistand, der sich mit Softwarelizenzen auskennt.

Veröffentlicht unter Blogroll | Verschlagwortet mit , , , , | Kommentar hinterlassen

9 .NET-Werkzeuge, die Routinearbeit im Entwickleralltag sparen

Eine API liefert sporadisch Fehler, eine Datenbankabfrage wächst, und im Log steht nur „Speichern fehlgeschlagen“. Solche Aufgaben gehören zur Entwicklung dazu. Die Infrastruktur dafür jedes Mal neu zu schreiben, bringt die eigentliche Anwendung aber selten weiter.

Die Werkzeuge im Überblick: Serilog für strukturiertes Logging; xUnit für automatisierte Tests; FluentValidation für Eingabeprüfungen; EF Core für objektorientierten Datenzugriff mit LINQ und Migrationen; Dapper für eigene SQL-Abfragen mit Objekt-Mapping; Refit für typisierte REST-Clients; Microsoft.Extensions.Http.Resilience für Timeouts, Retries und Circuit Breaker; YARP für die Weiterleitung von HTTP-Anfragen als Reverse Proxy; SignalR für Echtzeitnachrichten zwischen Server und Clients.

Als roter Faden dient eine beispielhafte Geräteverwaltung: Geräte speichern, Wartungen prüfen, eine externe API abfragen und Änderungen an verbundene Clients melden. Die Beispiele veranschaulichen einzelne Ideen; sie sind keine vollständige Anwendung.

Inhaltsverzeichnis

Lupe über Ereigniskarten und grüne Häkchen als Symbol für Diagnose und Tests.

Fehler finden und Regeln absichern

Serilog: Logs, mit denen sich etwas anfangen lässt

Ein langer Text im Log ist noch keine gute Diagnose. Serilog erfasst Ereignisse mit strukturierten Eigenschaften. Eine Geräte-ID bleibt damit ein eigenes Feld, nach dem ein geeignetes Logsystem filtern kann.

Log.Information(
    "Wartung für Gerät {DeviceId} gespeichert, Dauer {ElapsedMs} ms",
    deviceId,
    elapsedMilliseconds);

Das Beispiel nutzt einen bereits konfigurierten Serilog-Logger. Die Werte werden separat übergeben; String-Interpolation würde diese Struktur an dieser Stelle auflösen. Über sogenannte Sinks lassen sich Ereignisse beispielsweise an die Konsole, in Dateien oder an einen zentralen Logdienst ausgeben.

Der Gewinn entsteht bei der Fehlersuche: Welche Geräte sind betroffen? Welche Vorgänge dauern auffällig lange? Trotzdem gehören sinnvolle Log-Level, Aufbewahrung und der bewusste Umgang mit personenbezogenen Daten zur Konfiguration. Tokens und Passwörter haben im Log nichts verloren.

Im Projekt einbinden: In ASP.NET Core lässt sich Serilog als Provider hinter dem gewohnten ILogger<T> betreiben. Fachliche Services müssen dann nicht überall die statische Log-Klasse verwenden. Sie erhalten ihren Logger per Dependency Injection. Die Entscheidung über Ausgabeziele und Mindestlevel bleibt zentral im Anwendungsstart beziehungsweise in der Konfiguration.

Die ASP.NET-Core-Integration bietet außerdem UseSerilogRequestLogging(). Die Middleware fasst einen HTTP-Request mit Methode, Pfad, Statuscode und Laufzeit in einem Abschlussereignis zusammen. Ihre Position in der Pipeline bestimmt, welche nachfolgenden Komponenten sie erfasst. So lässt sich beispielsweise erkennen, ob eine langsame Geräteansicht regelmäßig mit einem bestimmten Endpunkt zusammenhängt.

Zusammengehörige Vorgänge erkennen: Eine einzelne Geräte-ID reicht nicht immer. Derselbe Benutzer kann mehrere Aktionen gleichzeitig auslösen. Eine Request- oder Korrelations-ID verbindet die dazugehörigen Ereignisse. Kontextinformationen lassen sich über einen passend konfigurierten Log-Kontext ergänzen, statt sie bei jedem Aufruf erneut einzutippen. In mehreren Diensten sollte diese Zuordnung durchgängig geplant werden; bloß überall ein Feld namens RequestId anzulegen, verbindet noch keine Aufrufe.

Auch die Auswahl der Eigenschaften ist eine fachliche Entscheidung. Für eine fehlgeschlagene Wartung sind Geräte-ID, Vorgangs-ID und Fehlerursache hilfreicher als ein komplett serialisiertes Benutzerobjekt. Eine sinnvolle Ausgangsbasis wäre: erfolgreiche Routinevorgänge auf Information, auffällige Situationen auf Warning, tatsächlich gescheiterte Aktionen auf Error. Während einer Diagnose lässt sich gezielt mehr protokollieren. Dauerhaft jedes Detail auf Debug zu speichern, macht Suche und Betrieb dagegen unnötig teuer. Der Produktivitätsgewinn liegt in beantwortbaren Fragen, nicht in möglichst vielen Logzeilen.

xUnit: Verhalten bei Änderungen überprüfen

xUnit ist ein Testframework für .NET. Einzelne Testfälle und datengetriebene Tests helfen, erwartetes Verhalten festzuhalten. In der Geräteverwaltung könnte das zum Beispiel die Berechnung des nächsten Wartungstermins sein: Monatswechsel, Schaltjahr und ein fehlendes Startdatum.

Solche Tests sparen nicht automatisch beim ersten Schreiben Zeit. Ihr Nutzen zeigt sich, wenn sich die Berechnung später ändert und vorhandene Fälle weiterhin stimmen müssen. Reine Unit-Tests ersetzen allerdings keinen Integrationstest gegen die tatsächlich verwendete Datenbank oder API.

Wer bereits mit NUnit arbeitet, muss dafür nicht wechseln. Wichtiger als der Name des Frameworks sind nachvollziehbare Testfälle, kurze Laufzeiten und die Ausführung in der CI-Pipeline.

Einzeltest oder Datenreihe: Mit [Fact] wird ein einzelner Test beschrieben, mit [Theory] derselbe Testablauf für mehrere Eingaben. Für Wartungsintervalle lässt sich damit eine kleine Tabelle fachlicher Erwartungen ausdrücken. Der Testname sollte das erwartete Verhalten nennen. „Test1“ hilft beim Fehlschlag wenig; „NextDate_UsesLastDay_WhenTargetMonthIsShorter“ benennt dagegen bereits die zu prüfende Regel.

[Theory]
[InlineData(2024, 1, 31, 1, 2024, 2, 29)]
[InlineData(2025, 1, 31, 1, 2025, 2, 28)]
public void NextDate_UsesLastDay_WhenTargetMonthIsShorter(
    int year, int month, int day, int interval,
    int expectedYear, int expectedMonth, int expectedDay)
{
    var start = new DateOnly(year, month, day);
    var expected = new DateOnly(expectedYear, expectedMonth, expectedDay);

    var actual = MaintenanceSchedule.NextDate(start, interval);

    Assert.Equal(expected, actual);
}

Der Ausschnitt benötigt xUnit und die beispielhafte Fachklasse MaintenanceSchedule. Deren Implementierung ist hier bewusst nicht enthalten. Die Testdaten formulieren eine angenommene Geschäftsregel: Fehlt der Tag im Zielmonat, wird dessen letzter Tag verwendet. Ob ein Termin danach wieder auf den ursprünglichen Monatstag zurückspringt, ist eine weitere fachliche Frage und braucht einen eigenen Test.

Isolation ist wichtiger als Bequemlichkeit: xUnit erzeugt für einzelne Tests neue Testklasseninstanzen. Aufwendige Testvorbereitung kann über Fixtures geteilt werden. Eine gemeinsam gestartete Testdatenbank spart beispielsweise Zeit; gemeinsam veränderbare Datensätze können jedoch Abhängigkeiten zwischen Tests erzeugen. Deshalb braucht jeder Test einen definierten Ausgangszustand, etwa eigene Datensätze oder ein kontrolliertes Zurücksetzen.

Besonders tückisch sind Tests, die nur in einer bestimmten Reihenfolge funktionieren oder von der aktuellen Uhrzeit abhängen. Übergib die benötigte Zeit beziehungsweise abstrahiere die Uhr, und mache externe Antworten kontrollierbar. So erklärt ein Fehlschlag möglichst präzise, welche Regel verletzt wurde. Ein Test, der intern bloß dieselbe Berechnung wie der Produktivcode wiederholt, liefert dagegen wenig zusätzliche Sicherheit.

FluentValidation: Eingaben an einer klaren Stelle prüfen

Wenn Pflichtfelder, Wertebereiche und voneinander abhängige Eingaben zusammenkommen, werden verteilte if-Abfragen schnell unübersichtlich. FluentValidation bündelt solche Regeln in Validatoren. Ein Gerätename darf beispielsweise nicht leer sein; ein Wartungsintervall muss größer als null sein.

Die Regeln lassen sich unabhängig vom Controller testen. Bei asynchronen Prüfungen sollte der Validator über ValidateAsync aufgerufen werden. Die ältere automatische Einbindung über FluentValidation.AspNetCore wird nicht mehr unterstützt; deren MVC-Validierungspipeline kann asynchrone Regeln nicht ausführen.

Eine Eingabeprüfung ersetzt außerdem keine Datenbank-Constraints oder Berechtigungsprüfung. Zwei gleichzeitige Anfragen können beide eine Vorabprüfung bestehen – Eindeutigkeit muss deshalb auch die Datenbank absichern.

Regeln als lesbare Klasse: Ein Validator leitet sich typischerweise von AbstractValidator<T> ab. Die Regeln beziehen sich auf Eigenschaften eines Eingabemodells. Dadurch bleibt beispielsweise ein Request zum Anlegen eines Geräts frei von Validierungslogik, die nur für diesen konkreten Anwendungsfall gilt.

public sealed class CreateDeviceValidator
    : AbstractValidator<CreateDeviceRequest>
{
    public CreateDeviceValidator()
    {
        RuleFor(x => x.Name)
            .NotEmpty()
            .MaximumLength(120);

        RuleFor(x => x.MaintenanceIntervalMonths)
            .GreaterThan(0)
            .When(x => x.HasRecurringMaintenance);
    }
}

Vorausgesetzt wird ein Eingabemodell mit den gezeigten Eigenschaften sowie using FluentValidation;. Das Intervall wird nur geprüft, wenn eine wiederkehrende Wartung aktiviert ist. Solche Bedingungen sind nützlich, müssen aber sorgfältig platziert werden: Innerhalb einer Regelkette kann eine Bedingung mehrere vorhergehende Validatoren betreffen.

Über den Cascade-Modus lässt sich außerdem steuern, ob nach einem Fehler weitere Prüfungen ausgeführt werden. Bei einer Regelkette kann ein früher Abbruch sinnvoll sein, wenn nachfolgende Prüfungen einen gültigen Ausgangswert voraussetzen. Für ein Formular ist es dagegen oft angenehmer, Fehler mehrerer unabhängiger Felder gesammelt zurückzugeben, damit der Benutzer nicht nach jeder Korrektur den nächsten Fehler entdecken muss.

Die Grenze zur Fachlogik: „Name fehlt“ ist eine Eingabeprüfung. „Dieser Benutzer darf das Gerät dieser Organisation (des Mandanten) bearbeiten“ ist eine Berechtigungsentscheidung. „Eine abgeschlossene Wartung darf nicht erneut abgeschlossen werden“ betrifft den fachlichen Zustand. Diese Verantwortlichkeiten sollten erkennbar bleiben. Ein Validator kann Datenbankabfragen nutzen, sollte aber nicht nebenbei Änderungen speichern. Für die API lohnt sich eine einheitliche Fehlerantwort mit Feldbezug; die Oberfläche kann diese dann direkt an den betroffenen Eingaben anzeigen. Und die Prüfung muss serverseitig stattfinden, auch wenn der Client dieselben Regeln bereits für eine angenehmere Bedienung ausführt.

Zwei unterschiedliche Wege führen zu einer gemeinsamen Datenbank.

Daten speichern: EF Core und Dapper passend einsetzen

EF Core: Objektmodell, LINQ und Migrationen

Entity Framework Core übernimmt viel Arbeit rund um relationale Daten: Entitäten abfragen, Beziehungen abbilden und Änderungen speichern. LINQ macht viele Abfragen direkt in C# lesbar. Migrationen halten Änderungen am Datenbankschema als versionierbaren Code fest.

Für eine Geräteverwaltung mit Räumen, Wartungen und Verantwortlichen ist das ein naheliegender Ansatz. Statt für jeden Schreibvorgang SQL und Objektzuordnung von Hand zu pflegen, arbeitet die Anwendung mit ihrem Datenmodell.

Das bedeutet nicht, dass die Datenbank unsichtbar werden darf. Abfragemenge, Indizes und erzeugtes SQL bleiben relevant. Für reine Listen lohnt es sich, nur die benötigten Felder zu projizieren und Tracking bewusst einzusetzen oder wegzulassen. Auch generierte Migrationen gehören vor dem produktiven Einsatz geprüft.

Was beim Speichern passiert: Der DbContext verwaltet bei getrackten Entitäten ihren Zustand. Wird ein geladenes Gerät umbenannt und anschließend SaveChangesAsync aufgerufen, ermittelt EF Core die zu speichernden Änderungen. Das reduziert wiederholten Zuordnungscode. Es macht den Context aber auch zu einer Arbeitseinheit mit Lebensdauer, die zum jeweiligen Vorgang passen muss.

Laut Dokumentation zur DbContext-Lebensdauer ist ein Context nicht threadsicher. Mehrere Datenbankoperationen dürfen daher nicht einfach per Task.WhenAll auf derselben Instanz gestartet werden. Für unabhängige parallele Vorgänge braucht es getrennte Instanzen. Gerade bei langlebigen Oberflächen ist „ein Context für die ganze Anwendung“ deshalb eine problematische Abkürzung.

var devices = await db.Devices
    .AsNoTracking()
    .Where(x => x.RoomId == roomId)
    .OrderBy(x => x.Name)
    .ThenBy(x => x.Id)
    .Select(x => new DeviceSummary { Id = x.Id, Name = x.Name })
    .Take(50)
    .ToListAsync(cancellationToken);

Das Beispiel setzt das passende Modell und einen DTO-Typ voraus. Es lädt eine begrenzte, stabil sortierte Liste statt vollständiger Objektgraphen. Bei dieser reinen DTO-Projektion werden ohnehin keine Entitäten getrackt; AsNoTracking macht hier zusätzlich die Leseabsicht sichtbar. Für weitere Seiten muss eine passende Pagination ergänzt werden.

Die häufigsten Kosten entstehen in der Abfrage: Wer für jedes Gerät nachträglich dessen Wartungen einzeln lädt, erzeugt schnell viele Datenbankaufrufe. Die Hinweise zu effizienten Abfragen erklären dieses N+1-Problem und den bewussten Umgang mit Projektionen und Beziehungen. Umgekehrt kann ein großes Include-Geflecht unnötig viele Daten liefern. Deshalb zuerst überlegen, welche Informationen die Ansicht wirklich braucht, dann SQL und Ausführungsplan prüfen. EF Core spart vor allem Routine beim Datenzugriff; die Entscheidung über ein sinnvolles Datenmodell und effiziente Zugriffspfade bleibt Entwicklungsarbeit.

Dapper: SQL selbst bestimmen, Mapping abgeben

Dapper ist ein schlanker Object Mapper: Du schreibst SQL, Dapper überträgt die Ergebnisse in .NET-Objekte. Das passt beispielsweise zu einer gezielten Auswertung über fällige Wartungen, deren SQL bereits feststeht.

var devices = await connection.QueryAsync<DeviceSummary>(
    "SELECT Id, Name FROM Devices WHERE RoomId = @RoomId",
    new { RoomId = roomId });

Der Ausschnitt setzt eine passende Datenbankverbindung und den Ergebnistyp DeviceSummary voraus. Der Filterwert wird als Parameter übergeben, nicht in den SQL-Text eingesetzt. Dapper bringt im Kern weder das Change Tracking noch die Schema-Migrationen von EF Core mit.

EF Core und Dapper müssen keine Grundsatzentscheidung sein. EF Core für das reguläre Datenmodell und Dapper für ausgewählte Abfragen können zusammenpassen. Zwei Zugriffswege erhöhen aber auch den Pflegeaufwand. Ob ein Wechsel tatsächlich schneller ist, sollte eine Messung mit realistischen Daten zeigen.

Die Abstraktion ist bewusst schmal: Bei Dapper bleiben Tabellen, Spalten und SQL-Dialekt sichtbar. Das ist hilfreich, wenn eine vorhandene Datenbank bereits komplexe Abfragen vorgibt. Es bedeutet aber auch: Umbenannte Spalten oder geänderte Ergebnistypen werden nicht durch ein gemeinsames LINQ-Modell abgefangen. Aussagekräftige Aliase und Integrationstests gegen den eingesetzten Datenbanktyp helfen, solche Brüche früh zu erkennen.

Für längere Vorgänge lohnt sich ein Blick auf CommandDefinition. Darüber lassen sich neben SQL und Parametern beispielsweise eine Transaktion, ein Command-Timeout und ein CancellationToken übergeben. Verlässt der Benutzer eine Ansicht, kann die Anwendung den Abbruch weiterreichen, statt die Datenbankarbeit unabhängig vom ursprünglichen Bedarf weiterlaufen zu lassen. Ob und wie schnell der Abbruch greift, hängt auch vom verwendeten Provider ab.

Mehrere Änderungen gehören zusammen: Soll eine Wartung gespeichert und zugleich der nächste Termin aktualisiert werden, braucht dieser Vorgang gegebenenfalls eine Transaktion. Die Anwendung öffnet sie auf der Verbindung und übergibt sie an die beteiligten Dapper-Aufrufe. Bei Erfolg wird bestätigt, bei einem Fehler zurückgerollt. Wenn EF Core und Dapper gemeinsam an derselben Arbeitseinheit beteiligt sind, müssen Verbindung und Transaktion ausdrücklich aufeinander abgestimmt werden.

Auch die Ergebnismenge bleibt wichtig. Die üblichen QueryAsync-Aufrufe puffern Ergebnisse; „schlanker Mapper“ bedeutet daher nicht automatisch geringen Speicherverbrauch bei riesigen Exporten. Für eine Bildschirmansicht sind begrenzte Abfragen meist sinnvoller. Bei großen Datenmengen muss zwischen Streaming, Verbindungsdauer und Verarbeitung abgewogen werden. SQL-Parameter schützen außerdem nur Werte: Dynamische Spaltennamen für eine Sortierung benötigen eine kontrollierte Zuordnung erlaubter Felder. Einfach Benutzereingaben in ORDER BY einzusetzen, wäre trotz ansonsten parametrisierter Abfrage falsch.

Zwei verbundene Server mit Schutzschild und Uhr als Symbol für robuste API-Aufrufe.

Externe APIs: weniger Routinecode, bewusster Umgang mit Ausfällen

Refit: einen HTTP-Client als Interface beschreiben

Bei REST-Clients wiederholen sich viele Aufgaben: URL zusammensetzen, Parameter übertragen, JSON lesen. Refit beschreibt den Aufruf über ein C#-Interface und erzeugt die Implementierung.

public interface IDeviceApi
{
    [Get("/devices/{id}")]
    Task<DeviceDto> GetDeviceAsync(
        Guid id,
        CancellationToken cancellationToken = default);
}

Hierfür werden Refit und ein passender DTO-Typ benötigt; Basisadresse und Registrierung kommen separat hinzu. Mit Refit.HttpClientFactory lässt sich der Client in Dependency Injection und IHttpClientFactory einbinden.

Das macht die Beschreibung der API-Aufrufe übersichtlich. Authentifizierung, Fehlerbehandlung und API-Änderungen verschwinden dadurch aber nicht. Ein C#-Interface verhindert beispielsweise nicht, dass der Server plötzlich ein anderes JSON-Format zurückliefert.

Den Client zentral konfigurieren: Das Interface beschreibt die Endpunkte, die Registrierung legt Basisadresse und HTTP-Pipeline fest. Damit bleiben Transportdetails außerhalb der Fachklasse, die beispielsweise Gerätedaten abfragt. Die HttpClientFactory-Anbindung lässt sich etwa so registrieren:

builder.Services
    .AddRefitClient<IDeviceApi>()
    .ConfigureHttpClient(client =>
        client.BaseAddress = new Uri("https://api.example.com"));

Der Ausschnitt gehört in den Anwendungsstart und benötigt Refit.HttpClientFactory. Die Adresse ist ein Platzhalter. In einer realen Anwendung kommt sie sinnvollerweise aus der Konfiguration. Authentifizierung und wiederkehrende Header können über die HTTP-Pipeline ergänzt werden. Dabei ist vor allem die Lebensdauer von Tokens zu beachten: Ein beim Start einmal gelesener Token ist keine vollständige Lösung für ablaufende Anmeldungen.

Fehlerbehandlung gehört zur API-Schnittstelle: Der Rückgabetyp beeinflusst, wie die aufrufende Anwendung mit einer Antwort arbeitet. Ein einfacher Task<DeviceDto> passt, wenn erfolgreiche Antworten direkt verarbeitet und Fehler als Exceptions behandelt werden sollen. Mit Response-Wrappern wie ApiResponse<T> lassen sich Status, Header und Fehlerinformationen gezielt auswerten. Ein HTTP-Erfolg allein garantiert dabei noch keine erfolgreich deserialisierte Antwort.

Ein nicht gefundenes Gerät, eine fehlende Berechtigung und ein nicht erreichbarer Server verdienen unterschiedliche Reaktionen. Bei 404 kann die Oberfläche erklären, dass der Datensatz nicht mehr existiert. Bei einem Verbindungsfehler sollte sie die eingegebenen Daten erhalten und einen erneuten Versuch ermöglichen. Die Entscheidung, wie die Anwendung auf diese Fehler reagiert, nimmt Refit nicht ab.

Für Tests sollte außerdem nicht nur das Interface gemockt werden. Das prüft zwar den aufrufenden Service, aber weder den tatsächlichen Pfad noch die JSON-Zuordnung. Ein zusätzlicher Test mit kontrollierter HTTP-Antwort kann Änderungen an Feldnamen, Statuscodes und leeren Antwortkörpern sichtbar machen. Refit reduziert den Transportcode; ein überprüfbarer API-Vertrag bleibt trotzdem nötig.

Microsoft.Extensions.Http.Resilience: auf Störungen vorbereitet sein

Ein externer Dienst antwortet manchmal langsam oder vorübergehend gar nicht. Microsoft.Extensions.Http.Resilience ergänzt HttpClient um Resilience-Strategien und baut dabei auf Polly auf. Dazu gehören unter anderem Timeouts, Wiederholungen und ein Circuit Breaker.

Ein Timeout begrenzt die Wartezeit. Ein Retry versucht einen geeigneten Aufruf erneut. Ein Circuit Breaker unterbricht weitere Versuche vorübergehend, wenn eine Abhängigkeit wiederholt ausfällt. Diese Mechanismen lassen sich auch mit einem über die HttpClientFactory registrierten Refit-Client kombinieren.

Ein Retry ist nicht für jeden Aufruf harmlos. Wenn der Server einen Auftrag schon gespeichert hat und nur die Antwort verloren geht, kann eine Wiederholung einen zweiten Auftrag anlegen. Der Standard-Handler wiederholt standardmäßig auch HTTP-Methoden, bei denen das problematisch sein kann. Mit DisableForUnsafeHttpMethods() lassen sich diese Wiederholungen deaktivieren; alternativ braucht der Dienst ein geeignetes Idempotenzkonzept.

Die Einstellungen müssen deshalb zum Vorgang passen. Ein robuster Client wartet weder unbegrenzt noch erzeugt er durch unbedachte Wiederholungen zusätzliche Last.

Eine maximale Gesamtwartezeit festlegen: Drei Versuche mit jeweils langer Laufzeit können einen Benutzer erheblich länger warten lassen als erwartet. Deshalb sollten Anzahl der Versuche, Wartepausen und maximale Gesamtdauer zusammen geplant werden. Für ein interaktives Formular gelten andere Grenzen als für einen Hintergrundimport, der einen vorübergehenden Ausfall überbrücken darf. Die Oberfläche muss außerdem einen Abbruch bis zum eigentlichen Aufruf weiterreichen können.

Die Retry-Strategie von Polly erlaubt unter anderem zunehmende Warteabstände und Jitter. Der zufällige Anteil verhindert, dass viele Clients nach einer Störung alle im gleichen Takt erneut anfragen. Das hilft allerdings nur bei passend ausgewählten Fehlern. Ein fachlich ungültiger Request wird durch Wiederholung nicht gültig, und ein abgelaufener Zugang benötigt eine andere Behandlung als ein kurzzeitig überlasteter Dienst.

Ein Circuit Breaker liefert keine Ersatzdaten: Er beobachtet Ergebnisse und blockiert bei überschrittener Fehlerschwelle zeitweise weitere Aufrufe. Nach einer Pause wird geprüft, ob die Abhängigkeit wieder verfügbar ist. Die Polly-Dokumentation grenzt das klar von Retries ab: Ein Breaker übernimmt weder deren Wiederholungen noch automatisch einen Fallback. Die Anwendung muss entscheiden, ob sie einen zwischengespeicherten Stand anzeigt, den Vorgang verschiebt oder einen verständlichen Fehler meldet.

Bei der beispielhaften Geräteverwaltung könnte ein externer Herstellerdienst ausfallen, während lokale Gerätedaten weiterhin bearbeitbar bleiben. Diese Trennung muss die Anwendung vorsehen. Ein technisch erfolgreicher Fallback auf eine leere Liste wäre hier möglicherweise irreführend, weil er „keine Daten vorhanden“ statt „Quelle vorübergehend nicht erreichbar“ signalisiert.

Schließlich sollten Wiederholungen nicht unbemerkt auf mehreren Ebenen stattfinden. Wenn Client, eigener Service und Hintergrundjob jeweils erneut versuchen, vervielfacht sich die Last. Deshalb Zuständigkeit und maximale Gesamtdauer aller Versuche festlegen und Versuche, Abbrüche sowie geöffnete Breaker beobachten. Microsoft.Extensions.Resilience ist der allgemeinere Baustein; die HTTP-Erweiterung richtet diese Mechanismen gezielt auf ausgehende HTTP-Aufrufe aus.

Laptop und Smartphone empfangen Nachrichten über eine zentrale Verbindung.

Anfragen weiterleiten und Änderungen live anzeigen

YARP: Reverse Proxy mit eigener .NET-Logik

YARP steht für „Yet Another Reverse Proxy“ und ist eine Reverse-Proxy-Bibliothek auf ASP.NET Core. Damit lassen sich eingehende Anfragen an konfigurierte Ziele weiterleiten und in die eigene Middleware-Pipeline einbinden.

Interessant wird das, wenn die Weiterleitung eigene Anwendungslogik benötigt – etwa bei der schrittweisen Ablösung einer alten API. Für gewöhnliches Routing am Rand einer bestehenden Infrastruktur ist eine zusätzliche selbst entwickelte Proxy-Anwendung dagegen nicht automatisch die einfachste Lösung.

YARP ist ein Baustein für solche Szenarien, kein fertig eingerichtetes API-Management. Welche Regeln für Zugriff, Betrieb und Überwachung gelten, muss weiterhin festgelegt werden.

Route, Cluster und Destination: Die YARP-Konfiguration trennt diese Begriffe. Eine Route beschreibt, welche eingehenden Anfragen passen, beispielsweise anhand eines Pfads. Sie verweist auf einen Cluster. Dieser enthält eine oder mehrere Destinations, also konkrete Zieladressen. Dadurch lässt sich die öffentliche Adresse einer API von ihren internen Instanzen entkoppeln.

Für die schrittweise Migration einer Geräteverwaltung könnte /api/devices bereits an den neuen Dienst gehen, während /api/reports noch vom Altsystem beantwortet wird. Clients müssen dafür nicht zwingend auf zwei Basisadressen umgestellt werden. Das erleichtert eine schrittweise Ablösung, verlangt aber saubere Regeln: Überlappende Pfade und deren Priorität dürfen nicht erst im Produktivbetrieb auffallen.

Weiterleitung gezielt verändern: Über Transforms lassen sich beispielsweise Pfade oder Header anpassen. So kann ein öffentliches Präfix vor der Weiterleitung entfernt werden. Solche Anpassungen sollten überschaubar bleiben. Wenn der Proxy zunehmend fachliche Daten umschreibt, wird er selbst zu einer Anwendung mit eigenem Test- und Wartungsbedarf.

Besonders wichtig ist die Vertrauensgrenze. Ein vom Client selbst gesetzter Header darf nicht ungeprüft als Identitätsnachweis beim Zielsystem ankommen. Es muss klar sein, wo authentifiziert wird, welche Informationen weitergegeben werden und welche Berechtigungen das Zielsystem selbst überprüft. Ein erreichbarer Proxy-Endpunkt bedeutet noch nicht, dass der dahinterliegende Vorgang für jeden erlaubt ist.

Auch der Betrieb gehört zur Entscheidung: Der Proxy liegt im Anfrageweg und kann damit selbst zum Engpass oder Ausfallpunkt werden. Laufzeiten, Fehlerquoten und die Erreichbarkeit der Zielserver sollten überwacht werden können. Für einen einfachen Dienst hinter einer bereits vorhandenen Traefik- oder Nginx-Konfiguration entsteht durch YARP nicht automatisch ein Vorteil. Es lohnt sich besonders dann, wenn die Weiterleitungslogik tatsächlich Teil der eigenen .NET-Anwendung sein soll.

SignalR: Aktualisierungen vom Server zum Client

Wird eine Wartung abgeschlossen, sollen andere geöffnete Ansichten den neuen Status sehen. Mit ASP.NET Core SignalR kann der Server Nachrichten an verbundene Clients senden, statt auf deren nächste regelmäßige Abfrage zu warten.

Hubs und die gezielte Ansprache von Clients oder Gruppen vereinfachen dabei die Verwaltung der Kommunikation. Das passt zu Live-Dashboards, Fortschrittsanzeigen und gemeinsam genutzten Anwendungen. Bei mehreren Serverinstanzen muss die Verteilung der Nachrichten mitgeplant werden.

SignalR ist dabei keine vollständige Offline-Synchronisation. Nach einer Unterbrechung muss die Anwendung ihren aktuellen Zustand gegebenenfalls erneut laden. Auch die Entscheidung, welcher Benutzer welche Meldung erhalten darf, bleibt Teil der Anwendung.

Vom gespeicherten Vorgang zur Meldung: Die eigentliche Änderung sollte zunächst zuverlässig gespeichert werden. Danach kann ein Anwendungsservice über IHubContext<THub> eine Nachricht senden. Dafür muss die Fachlogik nicht in die Hub-Klasse wandern. Der Hub stellt die Kommunikationsschnittstelle bereit; Speicherung und Geschäftsregeln bleiben in ihren zuständigen Services.

In der Geräteverwaltung wäre eine Meldung wie „Gerät X wurde geändert“ oft ausreichend. Der Client lädt anschließend den aktuellen Datensatz nach. Das hält Nachrichten klein und bündelt die Berechtigungsprüfung für den Lesezugriff in der API. Alternativ können passende Änderungen direkt übertragen werden. Dann müssen Nachrichtenschema, Versionskonflikte und die Reihenfolge der Verarbeitung sorgfältiger berücksichtigt werden.

Gruppen sind keine Berechtigungen: Mit SignalR-Gruppen können beispielsweise alle Client-Verbindungen einer Organisation gemeinsam angesprochen werden. Der Server muss aber vor dem Beitritt prüfen, ob der Benutzer dieser Organisation angehört und auf deren Daten zugreifen darf. Eine vom Client übergebene Organisations-ID allein ist dafür kein Berechtigungsnachweis. Wird dem Benutzer die Berechtigung entzogen, muss der Server auch den weiteren Empfang dieser Gruppennachrichten unterbinden.

Nach einem Verbindungsabbruch sollte die Oberfläche den Zustand sichtbar machen. Bei den üblichen Neuverbindungen sind Gruppenbeitritte erneut zu organisieren. Automatische Wiederverbindung und das Wiederherstellen des fachlichen Zustands sind unterschiedliche Aufgaben: Eine wieder offene Verbindung sagt noch nichts darüber aus, welche Änderungen während der Unterbrechung passiert sind.

Außerdem sind Datenbankspeicherung und anschließendes Senden nicht automatisch atomar. Stürzt der Prozess genau dazwischen ab, kann die Änderung gespeichert sein, ohne dass die Meldung ankommt. Für eine reine Aktualisierung der Anzeige reicht oft ein erneutes Laden beim Öffnen oder Verbinden. Müssen Ereignisse zuverlässig weiterverarbeitet werden, braucht es ein dauerhaftes Zustellkonzept, beispielsweise eine Outbox mit separater Verarbeitung. SignalR verbessert die unmittelbare Rückmeldung, übernimmt aber nicht die Rolle einer verlässlichen Ereignisablage.

Welche Werkzeuge gehören wirklich ins Projekt?

Für eine kleine Anwendung wäre es unnötig, alle neun Bausteine vorsorglich einzubauen. Sinnvoller ist es, beim konkreten Aufwand anzusetzen: unbrauchbare Logs verbessern, wiederholte Client-Implementierungen bündeln oder wichtige Regeln durch Tests absichern.

Jede zusätzliche Abhängigkeit bedeutet auch Updates, Kompatibilitätsfragen und Wartung. Ein Paket lohnt sich dann, wenn es mehr verständlichen, gut betreuten Code mitbringt, als die Anwendung andernfalls selbst pflegen müsste.

So entsteht Produktivität nicht durch eine möglichst lange NuGet-Liste, sondern durch weniger wiederkehrende Arbeit. Welche dieser Aufgaben kostet dich in deinen Projekten gerade am meisten Zeit?

Technische Quellen: die jeweils verlinkten Projekt- und Herstellerdokumentationen. Stand: 13. November 2026. Die Illustrationen wurden mit KI erstellt.

Veröffentlicht unter Blogroll | Verschlagwortet mit , , , , | Kommentar hinterlassen

Pocket ID: Passwortloses SSO für deine selbst gehosteten Apps

Erst läuft nur die Fotoverwaltung. Dann kommen ein Wiki, eine Dokumentenablage und ein paar interne Werkzeuge dazu. Irgendwann bedeutet eine Einladung drei neue Konten. Und wenn jemand keinen Zugriff mehr braucht, musst du dich erinnern, in welchen Anwendungen du ihn überall freigeschaltet hast.

Pocket ID zieht die Anmeldung an einer Stelle zusammen. Du betreibst den Dienst selbst und meldest dich mit einem Passkey an. Angebundene Anwendungen vertrauen Pocket ID über OpenID Connect (OIDC). Für ein Homelab oder ein kleines Team ist das ein überschaubarer Einstieg in Single Sign-on (SSO). Pocket ID im Überblick

Was den Login mit Passkeys sicherer macht

SSO und passwortloser Login lösen zwei verschiedene Probleme. SSO sorgt dafür, dass mehrere Apps dieselbe Anmeldung nutzen können. Bei Pocket ID meldest du dich im Alltag mit einem Passkey an. Je nach Gerät bestätigst du das etwa per Fingerabdruck, Gesichtserkennung oder Geräte-PIN.

Technisch signiert dein Passkey eine Anfrage. Pocket ID prüft die Signatur mit dem hinterlegten öffentlichen Schlüssel. Die Anmeldung ist an die passende Domain gebunden. Eine nachgebaute Loginseite auf einer fremden Domain kann deinen Passkey deshalb nicht für den echten Dienst einsetzen. Und beim regulären Login gibt es kein Passwort, das jemand abgreifen oder bei anderen Diensten ausprobieren könnte. FIDO Alliance zur Phishing-Resistenz von Passkeys

Wie gut das schützt, hängt auch von den anderen Anmeldewegen ab. Bleiben lokale App-Passwörter aktiv, gelten deren Risiken weiter. Aktivierst du bei Pocket ID Login-Codes auf Anfrage per E-Mail, wird auch das Postfach zum Zugang. Ein gestohlenes Sitzungscookie kann außerdem eine bereits erfolgte Anmeldung ausnutzen. Anmeldemethoden in Pocket ID

Ein Smartphone bestätigt eine Passkey-Anmeldung für drei angebundene Anwendungen.
Der Passkey bestätigt deine Identität bei Pocket ID. Die angebundenen Apps nutzen diese Anmeldung.

Ein Konto für mehrere Apps, mit getrennten Berechtigungen

Wenn du von der Fotoverwaltung ins Wiki wechselst, kann Pocket ID die bestehende Anmeldung wiederverwenden. Die Apps legen trotzdem eigene Sitzungen an. Beim ersten Besuch kann Pocket ID nachfragen, ob du deine Profildaten mit der App teilen möchtest.

In Pocket ID kannst du pro Anwendung festlegen, welche Gruppen sich anmelden dürfen. So kann die Familie auf die Fotos zugreifen, während ein internes Dashboard nur für eine Admin-Gruppe offensteht. Was jemand innerhalb der App tun darf, entscheidet weiterhin die App. Beim Entzug von Zugriffen lohnt sich ein Blick auf bestehende Sitzungen und lokale Konten, weil sie je nach App bestehen bleiben können. OIDC-Clients und Gruppenzugriff einrichten

Docker Compose, HTTPS und der erste Login

Pocket ID ist unter der BSD-2-Clause-Lizenz verfügbar. Für die Software fällt keine Lizenzgebühr an. Hosting, Updates und Backups gehören weiterhin zum Betrieb. Im Standard-Setup brauchst du mit Docker Compose einen Container und ein dauerhaft eingebundenes Datenverzeichnis. SQLite ist bereits dabei. Quellcode und Lizenz

1. Compose-Datei und .env anlegen

Vorausgesetzt sind Docker mit Compose, eine eigene Subdomain und ein HTTPS-Reverse-Proxy auf demselben Host. Lege ein Verzeichnis für Pocket ID an und speichere dort diese compose.yaml. Die Datenbank und Uploads bleiben in ./data erhalten, wenn der Container ersetzt wird.

services:
  pocket-id:
    image: ghcr.io/pocket-id/pocket-id:v2
    restart: unless-stopped
    env_file: .env
    ports:
      - "127.0.0.1:1411:1411"
    volumes:
      - ./data:/app/data

Lege daneben die Datei .env an. Ersetze die Beispieladresse durch deine eigene HTTPS-Adresse und den Platzhalter durch die Ausgabe von openssl rand -base64 32. Halte die .env privat und sichere den Schlüssel für die Wiederherstellung.

APP_URL=https://id.example.com
ENCRYPTION_KEY=HIER_DEINEN_ZUFALLSSCHLUESSEL_EINTRAGEN

2. HTTPS einrichten

Lass deine Subdomain auf den Reverse Proxy zeigen und leite sie mit gültigem TLS-Zertifikat an http://127.0.0.1:1411 weiter. Der Port ist in diesem Beispiel nur auf dem Docker-Host erreichbar. Für Caddy, der direkt auf dem Host läuft, sieht der Eintrag so aus. Verwende dieselbe Domain wie in APP_URL.

id.example.com {
    reverse_proxy 127.0.0.1:1411
}

Läuft dein Proxy selbst als Container, verbinde ihn mit Pocket ID über ein gemeinsames Docker-Netz und verwende dort pocket-id:1411 als Ziel. In diesem Fall kannst du den Abschnitt ports weglassen. Pocket-ID-Dokumentation zu Reverse Proxys

3. Starten und den ersten Admin einrichten

Führe im Verzeichnis mit der Compose-Datei diese Befehle aus.

docker compose up -d
docker compose ps

Öffne https://id.example.com/setup mit deiner eigenen Domain. Lege das erste Admin-Konto an, registriere einen Passkey und teste die Anmeldung in einem privaten Browserfenster. Halte den Zugriff auf die Setup-Seite bis zur Einrichtung auf deinen Admin-Zugang beschränkt. Sobald das erste Konto existiert, ist die Setup-Seite geschlossen. Wenn der Container nicht läuft, helfen die Meldungen aus docker compose logs --tail=50 pocket-id. Offizielle Installationsanleitung

Neue Nutzer anlegen und bestehende Konten verbinden

Wenn du ein neues Projekt aufsetzt, kannst du OIDC von Anfang an einplanen. Benutzerkonten in Pocket ID legst du zum Beispiel selbst an oder du verschickst einen Einladungslink. Die Nutzer hinterlegen ihren eigenen Passkey. Für jede App richtest du einen OIDC-Client ein, hinterlegst ihre genaue Rücksprungadresse und gibst der Anwendung die Discovery-URL, die Client-ID und bei einem vertraulichen Client das Client-Secret. Benutzerverwaltung in Pocket ID · Erste App verbinden

Immich zeigt, was das praktisch bringt. Mit Auto Register legt Immich beim ersten erfolgreichen SSO-Login selbst ein lokales Konto an. Wer schon ein Immich-Konto mit Fotos hat, kann es in den Kontoeinstellungen mit der OIDC-Identität verbinden und das vorhandene Konto weiterverwenden. Damit sparst du dir bei neuen Projekten die doppelte Kontopflege und kannst bei bestehenden Anwendungen erst mit einem Testkonto prüfen, wie die Verknüpfung funktioniert. Immich-Dokumentation zu OIDC · Immich mit Pocket ID verbinden

Wenn Konten schon vor der ersten Anmeldung bereitstehen oder zentral wieder entzogen werden sollen, kann Pocket ID Benutzer und Gruppen per SCIM an die App übertragen. Dafür braucht die Zielanwendung einen passenden SCIM-Endpunkt. Für viele kleine Projekte reicht die Kontoanlage beim ersten Login. SCIM in Pocket ID

Wenn der zentrale Login ausfällt

Pocket ID kann zum Single Point of Failure werden. Wenn der Container, der Host, DNS oder der HTTPS-Zugang ausfällt, können neue SSO-Anmeldungen an mehreren Diensten gleichzeitig scheitern. Bestehende App-Sitzungen können weiterlaufen, bis sie ablaufen oder die App erneut einen Token vom Login-Dienst braucht.

Ein unterbrochener Weg zu einem Server und drei Symbole für den Notfallplan: Sicherheitsschlüssel, Backup und unabhängiger Zugang.
Ein Ersatz-Passkey, ein getestetes Backup und ein unabhängiger Notzugang helfen in unterschiedlichen Ausfällen.

Der Praxisbericht von uptime.bet empfiehlt einen zweiten Admin-Passkey und ein Backup von Daten und Schlüssel. Für den Betrieb würde ich beides getrennt testen. Der Ersatz-Passkey hilft beim Geräteverlust. Bei einem Serverausfall brauchst du einen Weg, den Dienst wiederherzustellen oder deine wichtigsten Apps direkt zu erreichen. Pocket ID im Selfhosting-Praxisbericht von uptime.bet

  • Ersatz-Passkey hinterlegen. Registriere für Admins einen zweiten, unabhängig verfügbaren Passkey, etwa auf einem separaten Hardware-Sicherheitsschlüssel. Wenn alle Admin-Passkeys weg sind und Pocket ID läuft, kannst du mit unabhängigem Serverzugang per CLI einen zeitlich begrenzten Einmalzugang erzeugen. Kontowiederherstellung in Pocket ID
  • Wiederherstellung testen. Sichere das Datenverzeichnis konsistent, bei SQLite zum Beispiel bei gestopptem Container. Sichere auch die Compose-Konfiguration, den Verschlüsselungsschlüssel und die nötige Proxy-Konfiguration geschützt außerhalb des Hosts. Teste die Wiederherstellung isoliert und plane für den Ernstfall dieselbe Login-Domain ein, damit bestehende Passkeys weiter nutzbar sind.
  • Unabhängigen Notzugang behalten. Wo die Anwendung es unterstützt, halte für kritische Dienste ein separates lokales Admin-Konto mit starkem Passwort und MFA bereit. Sorge dafür, dass du im Ausfall sowohl die App als auch die Zugangsdaten ohne Pocket ID erreichst.
  • Von außen prüfen. Überwache die HTTPS-Adresse von einem System aus, das bei einem Ausfall des Pocket-ID-Hosts weiterläuft. Teste zusätzlich nach Änderungen einen echten Login in einer angebundenen App. Ein erreichbarer Webserver allein sagt wenig über die vollständige Anmeldung aus. Uptime Kuma auf sotzny.de

Pocket ID ist kostenlos. SSO in der Ziel-App kann trotzdem kosten.

In der Selfhosting-Szene hat diese Preisgrenze einen Namen: SSO Tax. Gemeint ist, dass du für die zentrale Anmeldung ein größeres Paket kaufen musst, obwohl du dessen übrige Funktionen kaum nutzt. Das ist gerade bei einer Handvoll Konten schwer zu rechtfertigen. Wie die Übersicht von SSD Nodes zeigt, lohnt sich aber der Blick auf die konkrete Edition. Es gibt genug Gegenbeispiele, um sich bei der App-Auswahl Spielraum zu verschaffen. Einordnung der SSO Tax bei SSD Nodes

Bei Bitwarden ist der SSO-Login für Organisationen beispielsweise Teil von Enterprise. Immich bringt OIDC auch ohne kostenpflichtiges SSO-Paket mit. Wenn du eine App ohnehin nur allein nutzt, kann der vorhandene Login ausreichen. Für neue Projekte mit mehreren Anwendungen lohnt es sich, vorab zu prüfen, ob die geplante Edition einen eigenen OIDC-Anbieter zulässt und ob der Login auch in den genutzten mobilen Apps funktioniert. Bitwarden-Editionen · Übersicht selbst gehosteter Apps mit kostenlosem OIDC

Fazit

Pocket ID ist einfach einzurichten, leichtgewichtig und absolut sinnvoll, wenn mehrere eigene Anwendungen denselben Login nutzen sollen. Gerade bei neuen Projekten lässt sich OIDC von Anfang an einplanen, bevor du überall getrennte Konten aufgebaut hast. Für den Einstieg reicht eine App. Wenn der Login, der zweite Admin-Passkey und der Wiederanlauf funktionieren, kannst du die nächsten Dienste anbinden.

Veröffentlicht unter Blogroll | Verschlagwortet mit , , , , | Kommentar hinterlassen

Thunderbird aufräumen: Infomails nach fünf Tagen verschieben und wichtige Mails markieren

Ich will meine Backup-Meldungen im Posteingang sehen. Wenn alles durchgelaufen ist, brauche ich die Meldung dort aber irgendwann nicht mehr. Bei Newslettern und anderen Benachrichtigungen ist es ähnlich. Ein paar Tage sind sie interessant, danach sammeln sie sich an. Dazwischen liegen dann die Mails, die ich eigentlich im Blick behalten will.

Ich habe mir dafür in Thunderbird zwei Filter eingerichtet. Der eine verschiebt Infomails nach fünf Tagen in den Ordner „Informationen“. Der andere gibt Mails von wichtigen Kontakten beim Eingang einen Stern. Dafür reichen die eingebauten Nachrichtenfilter von Thunderbird.

Infomails nach fünf Tagen verschieben

Die Absender pflege ich in einem eigenen Adressbuch. Wenn ein weiterer Newsletter dazukommt, ergänze ich dort die Adresse und kann den Filter so lassen, wie er ist.

  1. Lege das Adressbuch Info-Absender an und trage die E-Mail-Adressen ein, die Thunderbird einsortieren darf.
  2. Lege im Mailkonto den Ordner Informationen an. Öffne Extras → Filter, wähle das passende Konto und erstelle einen neuen Filter.
  3. Aktiviere die regelmäßige Ausführung alle 10 Minuten. Für den ersten Test aktiviere auch Manuelles Ausführen. Der regelmäßige Lauf findet statt, während Thunderbird geöffnet ist. Mozilla-Support zur regelmäßigen Ausführung
  4. Wähle Alle Bedingungen erfüllen und trage diese fünf Zeilen ein.
FeldPrüfungWert
Vonist in meinem AdressbuchInfo-Absender
Alter in Tagenist größer als5
Statusist nichtBeantwortet
Statusist nichtGekennzeichnet
Statusist nichtWeitergeleitet
  1. Wähle als Aktion Nachricht verschieben in und als Ziel den Ordner Informationen.

Wenn eine Mail älter als fünf Tage ist und alle übrigen Bedingungen erfüllt, verschiebt Thunderbird sie beim nächsten Filterlauf. Habe ich schon geantwortet, die Mail weitergeleitet oder ihr einen Stern gegeben, bleibt sie liegen. Wenn ich sie nur gelesen habe, darf sie weiterhin in den Ordner „Informationen“. Thunderbird-Quellcode zur Statusprüfung

Filterdialog mit Absender-Adressbuch, Fünf-Tage-Grenze, Statusausnahmen und Zielordner.

Wenn ein Backup-System Erfolge und Fehler von derselben Adresse meldet, würde ich zusätzlich den Betreff prüfen. So kann ich gezielt die Erfolgsmeldungen verschieben. Welcher Betreff dazu passt, hängt vom Backup-System ab.

Ein goldener Briefumschlag mit Stern hebt sich zwischen blauen Umschlägen ab.

Wichtige Mails bekommen einen Stern

Für wichtige Kontakte habe ich ein zweites Adressbuch angelegt. So kann ich die Liste nebenbei pflegen, wenn mir im Posteingang jemand auffällt, dessen Mails ich künftig schneller sehen will.

  1. Lege das Adressbuch Wichtige Kontakte an und füge die Absenderadressen hinzu.
  2. Erstelle unter Extras → Filter im passenden Mailkonto einen zweiten Filter und aktiviere Nachrichtenabruf. Für einen Test mit vorhandenen Mails kannst du auch Manuelles Ausführen aktivieren.
  3. Setze die Bedingung Von → ist in meinem Adressbuch → Wichtige Kontakte. Wähle als Aktion Nachricht kennzeichnen. Damit setzt Thunderbird den Stern beim Eingang. Thunderbird-Hilfe zur Kennzeichnung per Filter
Filterdialog mit dem Adressbuch „Wichtige Kontakte“ und der Aktion für den Stern.

Filter manuell testen

Wenn du einen einzelnen Filter testen willst, markiere im Filterfenster zuerst seine Zeile. Wähle unten den Ordner, dessen Nachrichten du prüfen willst, zum Beispiel den Posteingang. Klicke erst dann auf Jetzt ausführen. Das Filterfenster ist nicht modal. Es kann geöffnet bleiben, während du im Thunderbird-Hauptfenster weiterarbeitest. Prüfe deshalb vor dem Klick noch einmal, welche Filterzeile markiert ist. Mozilla-Support zum manuellen Filtertest

Wenn du die Filter gesammelt ausführen willst, wähle den gewünschten Ordner im Hauptfenster und gehe zu Extras → Filter auf Ordner anwenden. Thunderbird führt dann für diesen Ordner alle aktiven Filter des Kontos aus, bei denen Manuelles Ausführen eingeschaltet ist. Thunderbird-Quellcode zur Ordneraktion

Zum Gegencheck kannst du eine zweite Mail desselben Absenders nehmen, die jünger als fünf Tage ist oder einen Stern hat. Die sollte im Posteingang bleiben.

Veröffentlicht unter Nützliches | Verschlagwortet mit , , , , | Kommentar hinterlassen

Uptime Kuma: Ausfälle erkennen, bevor jemand sie meldet

Du öffnest morgens deine Website und bekommst einen 502-Fehler. Seit wann ist sie nicht erreichbar? Und war es nur ein kurzer Aussetzer oder lief die Seite die ganze Nacht nicht? Mit Uptime Kuma kannst du solche Ausfälle automatisch erkennen und im Verlauf nachsehen, seit wann die Prüfungen fehlschlagen.

Was ist Uptime Kuma?

Uptime Kuma ist ein Open-Source-Projekt von Louis Lam, das du auf einem eigenen Server betreibst. Für jeden Dienst legst du einen Monitor an und stellst ein, wie oft Kuma prüfen soll. Im Dashboard siehst du, welche Dienste gerade erreichbar sind, wie sich ihre Antwortzeiten entwickeln und wann Prüfungen fehlgeschlagen sind. Für Benachrichtigungen kannst du unter anderem E-Mail, Telegram, Discord oder Gotify einrichten.

Uptime-Kuma-Dashboard mit Monitorliste und Verlauf der Erreichbarkeit
Das Dashboard zeigt die überwachten Dienste und den Verlauf der Prüfungen. Quelle: Uptime Kuma auf GitHub.

Was sich zu überwachen lohnt

  • Website oder API: Ein HTTPS-Check prüft, ob der Endpunkt wie erwartet antwortet. Mit einem Keyword-Check kannst du zusätzlich nach einem Text suchen, der auf der richtigen Seite vorkommen muss. Das hilft, wenn eine Fehlerseite trotzdem HTTP 200 zurückgibt.
  • Dienst im Heimnetz: Ein TCP-Check prüft, ob sich eine Verbindung zum Port aufbauen lässt. Für eine Datenbank sagt dir das, ob der Port erreichbar ist. Ob eine Anmeldung oder Abfrage funktioniert, prüft der TCP-Check allein nicht.
  • Backup oder Cronjob: Bei einem Push-Monitor meldet sich das Skript selbst. Bleibt die Meldung länger als erwartet aus, kann Kuma Alarm schlagen. So fällt auch ein Job auf, der gar nicht erst gestartet ist.

Push-Monitore für Backups und geplante Jobs

Ein Backup-System sendet ein Signal an den Monitor. Eine Uhr steht für das erwartete Intervall.
Das Backup-Skript meldet seinen Status an Uptime Kuma.

Bei einem HTTPS-Monitor ruft Kuma den Dienst auf. Bei einem Push-Monitor läuft es umgekehrt: Dein Skript ruft die von Kuma erzeugte URL auf und meldet damit, dass der Job gelaufen ist. Die Benachrichtigung an dich stellst du separat ein, zum Beispiel per E-Mail oder Telegram.

Für meine Restic-Backups meldet das Skript den Erfolg an Uptime Kuma. Wichtig ist der Zeitpunkt: Die Erfolgsmeldung gehört ans Ende des Jobs, nachdem Restic erfolgreich beendet wurde. Startet der Job gar nicht oder kommt die Meldung wegen eines Netzwerkproblems nicht an, erkennt Kuma nach Ablauf des erwarteten Intervalls, dass die Rückmeldung fehlt.

Ein Fehler lässt sich auch direkt mit status=down melden. Für die Erfolgsmeldung verwendest du status=up. Bei einem täglichen Job sollte das Intervall in Kuma etwas länger als 24 Stunden sein, wenn die Laufzeit schwankt. Behandle die Push-URL wie ein Passwort. Wer den Token kennt, kann den Status des Monitors melden. Die Parameter stehen in der Projektdokumentation zur Push-Schnittstelle.

Server prüfen: vom Ping bis zur Anwendung

Eine zentrale Überwachung prüft einen Server, eine Datenbank und einen Gameserver.
Je nach Dienst prüft Uptime Kuma die Erreichbarkeit oder fragt das jeweilige Protokoll ab.

Ein Ping zeigt dir, ob der Host aus Sicht von Kuma auf ICMP antwortet. Der Webserver kann dabei längst ausgefallen sein. Ein TCP-Check geht einen Schritt weiter und versucht, eine Verbindung zum Port aufzubauen. Welcher Check passt, hängt davon ab, was ausfallen kann und was du davon mitbekommen willst.

Für Microsoft SQL Server, PostgreSQL, MySQL/MariaDB, MongoDB und Redis gibt es eigene Monitortypen. Wenn dich interessiert, ob Kuma sich tatsächlich mit der Datenbank verbinden kann, ist ein passender Datenbankmonitor aussagekräftiger als ein offener TCP-Port. Ob die Anwendung mit ihrem eigenen Konto auf die benötigten Daten zugreifen kann, prüfst du am besten zusätzlich über einen geeigneten Health-Endpunkt.

Ähnlich ist es bei Docker: Kuma kann über die Docker-Schnittstelle prüfen, ob ein Container läuft. Ob die Webanwendung darin eine brauchbare Antwort liefert, prüfst du separat mit HTTPS oder einer JSON-Abfrage. Wie du den Docker-Monitor einrichtest, steht im Projektwiki.

Für Gameserver gibt es Steam- und GameDig-Monitore. Sie fragen unterstützte Spielserver über ihr Abfrageprotokoll ab. Für andere Dienste gibt es unter anderem DNS-, MQTT- und gRPC-Monitore. So kannst du beispielsweise einen erwarteten DNS-Eintrag oder eine bestimmte Antwort eines gRPC-Dienstes prüfen. Einen Überblick findest du im Projekt-Repository.

Von wo aus wird geprüft?

Für interne Dienste wie ein NAS ist ein Monitor im Heimnetz sinnvoll. Für eine öffentliche Website lohnt sich ein Check von außerhalb. Läuft Kuma auf demselben Host wie die Website, fallen bei einem Host-Ausfall beide gleichzeitig aus. Ähnlich ist es bei einem Internetausfall zu Hause: Ein Kuma im selben Netz kann dann womöglich keine Meldung mehr verschicken. Ein Monitor auf einem unabhängigen Server kann die öffentliche Erreichbarkeit weiterhin prüfen.

Wie schnell du einen Ausfall bemerkst, hängt vom Prüfintervall, den eingestellten Wiederholungen und dem Benachrichtigungskanal ab. Eine kurze Unterbrechung zwischen zwei Prüfungen kann unbemerkt bleiben. Der Verlauf hilft dir, die Fehlersuche zeitlich einzugrenzen. Für die Ursache brauchst du je nach Problem zusätzlich Logs, Metriken oder einen Blick in die Anwendung.

Dashboard und Statusseite

Das Dashboard ist für dich als Betreiber gedacht. Über eine Statusseite kannst du ausgewählte Dienste öffentlich anzeigen. Wer gerade auf deine Website oder API angewiesen ist, kann dort nachsehen, ob eine Störung bekannt ist.

Öffentliche Uptime-Kuma-Statusseite mit Verfügbarkeitsverlauf für mehrere Dienste
Beispiel einer Statusseite mit mehreren Diensten und ihrem Verfügbarkeitsverlauf. Quelle: Uptime Kuma auf GitHub.

Uptime Kuma mit Docker Compose starten

Du brauchst einen Host mit Docker und dem Compose-Plugin. Lege dort einen Ordner für Uptime Kuma an und speichere diese Datei als compose.yaml. Das Beispiel basiert auf der Compose-Datei des Projekts.

services:
  uptime-kuma:
    image: louislam/uptime-kuma:2
    restart: unless-stopped
    ports:
      - "127.0.0.1:3001:3001"
    volumes:
      - ./data:/app/data

Starte den Container im Verzeichnis der compose.yaml und prüfe anschließend seinen Status.

docker compose up -d
docker compose ps

Sobald der Container läuft, erreichst du die Ersteinrichtung auf dem Docker-Host unter http://localhost:3001. Die Portbindung an 127.0.0.1 hält die Oberfläche lokal. Wenn Docker auf einem entfernten Server läuft, kannst du für die Einrichtung einen SSH-Tunnel nutzen.

Die Konfiguration und der Verlauf liegen im lokalen Ordner ./data neben der Compose-Datei. So bleiben sie erhalten, wenn du den Container neu erstellst. Nutze dafür ein lokales Dateisystem. NFS wird laut Installationsanleitung nicht unterstützt.

Mit einem Monitor anfangen

Wenn du Kuma erst ausprobieren möchtest, gibt es eine offizielle Live-Demo. Lege zuerst einen HTTPS-Monitor für einen wichtigen Dienst an und verbinde ihn mit deinem Benachrichtigungskanal.

Ob die Meldung wirklich ankommt, kannst du mit einem separaten Testdienst prüfen. Lass Kuma den Dienst zunächst als erreichbar anzeigen, stoppe ihn kurz und warte auf den Alarm. Starte ihn dann wieder und prüfe, ob der Monitor zurück auf „Up“ wechselt. So weißt du vor dem ersten echten Ausfall, dass die Überwachung bis zur Benachrichtigung funktioniert.

Veröffentlicht unter Nützliches | Verschlagwortet mit , , , , , | 1 Kommentar