Definition „Fault Tolerance“ Was ist Fehlertoleranz?

Weder der Mensch noch Software ist frei von Fehlern. In Schnittstellen und Systemen kann Funktionalität daher nur gewährleistet werden, wenn nicht jeder Fehler verheerende Auswirkungen hat. Der Schlüsselfaktor lautet Fehlertoleranz.

Wenn Entwicklerinnen und Entwickler Systeme programmieren und Schnittstellen entwerfen, dann werden während der Entwicklung die meisten und die gröbsten Fehler beseitigt, um volle Lauffähigkeit zu gewährleisten. Doch selbst ein rigoroses und umfassendes Testverfahren kann niemals gründlich genug sein, um alle Fehler vollkommen auszuschließen.

Je größer Systeme sind, desto eher kann es zu Fehlern kommen. Trotzdem bleiben selbst gigantische und komplex ineinander verwobene Systeme wie Google und Facebook bleiben rund um die Uhr ohne Downtime lauffähig und das nicht, weil Fehler unmöglich sind. Vielmehr ist eine eingerichtete Fehlertoleranz dafür verantwortlich, dass auch einzelne Ausfallstellen nicht zu einem kompletten Systemausfall führen.

Was bedeutet Fehlertoleranz in der Praxis?

Fehlertolerante Systeme gibt es in unterschiedlichen IT-Zusammenhängen (bei Hardware, Software, in Netzwerken oder bei verteilten Systemen), wobei stets andere Lösungen gefunden werden müssen, um das System unanfälllig genug gegenüber Fehlern zu gestalten. Anhand einfacher Beispiele sei dies verdeutlicht:

Hardware: Hardware-Systeme können beispielsweise durch identische oder gleichwertige Systeme unterstützt werden, so dass gespiegelte Festplatten oder parallel laufende Server bei Ausfällen die Aufgaben des fehlerhaften Systems bis zur Ausmerzung des Fehlers übernehmen können. RAID-Speicherlösungen fallen etwa in diese Kategorie.

Software: Datenbanken, Speichersysteme oder Programmversionen können durch ständige Backups fehlerresistent gemacht werden, da der Ausfall der primär laufenden Software nicht zum kompletten Absturz führt. Stattdessen kann auf sekundär laufende Software zurückgegriffen werden.

Energieversorgung: Einen besonderen Teil des Hardwareschutzes stellt die Gewährleistung der Energieversorgung dar, weswegen kritische Server oftmals auf Notfallgeneratoren setzen, um auch für Katastrophenfälle gewappnet zu sein.

Fehlerquelle Mensch – Fehlertoleranz in Schnittstellen

Irren ist menschlich – und so dürfte es kaum überraschen, dass Anwender und Nutzerinnen oftmals für einen großen Teil antizipierbarer und unvorhersehbarer Fehler verantwortlich sind. An Schnittstellen ist es daher besonders wichtig, eine Fehlertoleranz einzurichten, damit User Software nicht durch unbeabsichtigt oder vorsätzlich falsche Eingaben zum Absturz bringen können. Daher stellt Fehlertoleranz auch einen Schutz gegen vorsätzlich bösartige DoS-Attacken und ähnliches dar.

Fehlerkategorien in Schnittstellen

Vermeidbare Fehler

Dieser Form des Fehlers liegt meist ein Irrtum beim UI-Design zugrunde, da die Zielgruppe nicht korrekt eingeschätzt wurde oder aber das Navigationsverhalten nicht ausreichend untersucht. User verhalten sich dann in der Praxis anders, füllen Formulare falsch aus oder klicken auf den falschen Link. Erfahrung und vor allem lange Tests können diese Fehler tatsächlich meist vermeiden.

Bekannte, aber nicht vermeidbare Fehler

Diese Art Fehler ist an der Schnittstelle bekannt, kann aber nicht gänzlich ausgeschlossen werden. Hierbei füllen User*innen Formulare nicht vollständig aus, verschicken Formulare unbesehen oder kreuzen wichtige Erklärungen nicht an. Solche Schnittstellenfehler sollten das Interface nicht komplett zurücksetzen oder zu einem Fehlerstatus führen, sondern zu entsprechenden Korrekturseiten führen.

Nicht vorhersehbare Fehler

Die schwerste Art des Fehlers ist der nicht vorhersehbare, da Programmierer*innen hier schlichtweg nicht vorhergesagt werden kann, was letztlich an der Schnittstelle zu einem Fehler führt. Oftmals sind es auch Attacken, die zu nicht vorhersehbaren Fehlern führen können.

Wie Robustheit auf Software-Ebene entsteht

Um Software und Schnittstellen weiterhin lauffähig zu halten, führt die Fehlertoleranz in der Regel zu einem von zwei unterschiedlichen Pfaden.

Die Fehlervorwärtskorrektur ignoriert den Fehler einfach und ersetzt Eingaben oder Ergebnisse durch Erfahrungswert oder erwartete Werte. Was der Fehler tatsächlich war, spielt hierfür keine Rolle, da das Programm einfach wie gehabt weitermacht. Das funktioniert analog zur Autokorrektur auf dem Smartphone, bei der eine falsche Eingabe durch prädiktiv ermittelbare Werte ersetzt/ergänzt wird.

Die Rückwärtsfehlerkorrektur nimmt den Fehler zur Kenntnis und setzt die Software auf einen Zustand vor dem Fehler zurück, um vom letzten bekannt richtigen Status aus weiter zu arbeiten. Ein Beispiel hierfür wäre ein RAID-Festplattensystem, bei dem der Ausfall eines Drives rückwärts ignoriert wird und vom letzten gespeicherten Status der arbeitsfähigen Laufwerke aus geladen wird.

Fehlertolerante Systeme in der Praxis erstellen

Für die praktische Programmieranwendung gibt es unterschiedliche Methoden, mit denen Fehlertolerante Software, Schnittstellen und Systeme entwickelt werden können. Ein Beispiel dafür sind Circuit-Breaker, welche im Fehlerfall einfach umleiten. Zu den Nutzern zählt etwa Netflix, hier werden gescheiterte Service-Anfragen umgeleitet – Tools wie Hystrix oder Resilience4j stehen Ihnen hierfür zur Verfügung.

Ein anderes Beispiel praktischer Fehlertoleranz ist das Load Balancing, bei dem Überlastungen in redundante Kapazitäten umgeleitet werden. Hier wird Software-seitig eine hohe Auslastung über verschiedene Knoten verteilt, um die Ressourcen besser zu verwalten und Downtime zu verhindern. HaProxy und Nginx sind beliebte Tools hierfür.

Theoretische Fehlertoleranz ist praktische Robustheit

Keine Schnittstelle, keine Software, kein System und kein Webservice kommen ohne Fehler aus. Mit zunehmender Komplexität und Dauer des Betriebes lassen sich auch Fehler immer weniger ausschließen.

Umso mehr Augenmerk sollte auf Fehlertoleranz, Fehlerkorrektur und Systemrobustheit bei minimalen Ausfallzeiten gelegt werden. Im Idealfall ist die Fehlertoleranz so hoch, dass User nicht einmal bemerken, dass hinter den Kulissen oder an der Tastatur ein Fehler passierte.

(ID:47532911)