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 | 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

8 KI-Begriffe einfach erklärt – von MCP bis Superintelligenz

Du bittest eine KI, einen Blogbeitrag vorzubereiten. Sie schreibt den Text, legt einen Entwurf in WordPress an und fügt Bilder ein. Hinter diesem Ablauf stecken gleich mehrere Dinge, die in KI-Diskussionen schnell durcheinandergeraten. Da ist vom Agenten die Rede, von MCP, von Skills und manchmal auch vom Harness. Was davon macht eigentlich was?

Hier sind acht Begriffe, die dir helfen, solche Funktionen einzuordnen. Los geht’s mit dem Teil, der ein Sprachmodell überhaupt erst mit Werkzeugen verbindet.

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