mitmario.dev

Synthese: der Server, der nicht umfällt

Node.js Sandbox 4 Min Lesezeit 3 BeispieleLektion 6 von 7

Fehlerklassen allein bringen wenig, wenn niemand sie in Statuscodes übersetzt. Ein Fehler-Handler bringt wenig, wenn im Protokoll nicht steht, zu welcher Anfrage ein Eintrag gehört. Und beides hilft nichts, wenn der Prozess bei der ersten unbehandelten Ablehnung mitten in einer Antwort stirbt.

Die Reihenfolge der Middleware

Die vier Schichten in Reihenfolge
import express from "express";

const app = express();

// 1. Ganz oben: alles, was jede Anfrage betrifft.
app.use((req, res, next) => {
  req.anfrageId = "a1b2c3";
  res.setHeader("X-Anfrage-Id", req.anfrageId);
  next();
});

// 2. Die Routen.
app.get("/ok", (req, res) => res.json({ ok: true }));
app.get("/kaputt", (req, res, next) => next(new Error("etwas ging schief")));

// 3. Der Standardfall fuer unbekannte Pfade, drei Argumente.
app.use((req, res, next) => {
  res.status(404).json({
    fehler: { code: "nicht_gefunden", meldung: "Diese Adresse gibt es nicht.", anfrageId: req.anfrageId },
  });
});

// 4. Ganz unten der Fehler-Handler, vier Argumente.
app.use((fehler, req, res, next) => {
  console.error(`ins Protokoll: ${fehler.message} (${req.anfrageId})`);
  res.status(500).json({
    fehler: { code: "serverfehler", meldung: "Da ist etwas schiefgegangen.", anfrageId: req.anfrageId },
  });
});

app.listen(3000);

Im Reiter Browser steht der gute Fall. Mit /kaputt in der Adresszeile siehst du, was passiert, wenn eine Route wirft. Es kommt eine kurze Antwort statt eines Stacktraces, und der Server läuft weiter.

Express geht die Middleware von oben nach unten durch, und das legt die Reihenfolge fest:

  1. Ganz oben, was jede Anfrage betrifft. Die Anfragekennung gehört hierhin, weil alles darunter sie braucht, die Kopfzeile in der Antwort, jede Protokollzeile und am Ende der Fehler-Handler.
  2. Dann die Routen. Sie antworten oder reichen einen Fehler an next() weiter und bauen selbst keine Fehlerantwort.
  3. Dann der Standardfall, eine Middleware ohne Pfad, die alles einsammelt, was keine Route getroffen hat. Sie hat drei Argumente und macht daraus einen gewöhnlichen 404 in der eigenen Form.
  4. Ganz unten der Fehler-Handler, mit vier Argumenten. An dieser Zahl erkennt Express ihn, und ohne das vierte Argument wird er nie aufgerufen.

Was diese Reihenfolge bringt, sieht man an der Kennung. Ob /ok, /kaputt oder eine Adresse, die es nicht gibt, alle Antworten tragen dieselbe Kennung als X-Anfrage-Id. Bei den beiden Fehlern steht sie auch im Rumpf. Und dieselbe Kennung steht in der Zeile, die der Fehler-Handler für /kaputt ins Protokoll schreibt. curl -si zeigt die Kopfzeile, tail -1 /tmp/lern-web.log im Terminal die Protokollzeile. Im Beispiel ist die Kennung der Kürze halber fest, in der Aufgabe bekommt jede Anfrage ihre eigene. Schreibt jemand „ich bekomme einen Fehler a1b2c3“, ist die Zeile in einer Sekunde gefunden.

Was die Zustandsabfrage prüft

Umgebungen wie ein Container-Dienst oder ein Lastverteiler fragen regelmäßig nach, ob ein Prozess noch gesund ist, und nehmen ihn aus dem Verkehr, wenn nicht. Der übliche Name dafür ist /health.

Eine Zustandsabfrage, die die Wahrheit sagt
import { DatabaseSync } from "node:sqlite";

const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE buecher (id INTEGER PRIMARY KEY)");

// Sagt immer ja, ohne nachzusehen. Eine Zustandsabfrage ist das nicht.
function immerOk() {
  return { status: 200, rumpf: { status: "ok" } };
}

// Fragt wirklich nach, und zwar das Billigste, was etwas aussagt.
function ehrlich() {
  try {
    db.prepare("SELECT 1 AS eins").get();
    return { status: 200, rumpf: { status: "ok", datenbank: "ok" } };
  } catch (fehler) {
    return { status: 503, rumpf: { status: "fehler", datenbank: "weg" } };
  }
}

console.log(`läuft alles:     immerOk ${JSON.stringify(immerOk())}`);
console.log(`                 ehrlich ${JSON.stringify(ehrlich())}`);

db.close();

console.log(`Datenbank weg:   immerOk ${JSON.stringify(immerOk())}`);
console.log(`                 ehrlich ${JSON.stringify(ehrlich())}`);

Die erste Fassung sagt immer ja und ist schlimmer als gar keine. Sie beantwortet nur, ob der Node-Prozess noch läuft. Liefe er nicht mehr, käme gar keine Antwort. Die Frage beantwortet sich also von selbst.

Eine Umgebung, die eine Zustandsabfrage hat, vertraut ihr. Steht dort 200, schickt sie weiter Anfragen an einen Prozess, der seit einer Stunde bei jeder Datenbankabfrage scheitert. Der Betreiber sieht ein grünes Feld, und die Kunden bekommen Fehler. Ohne die Abfrage hätte er wenigstens nichts geglaubt.

Die zweite Fassung fragt wirklich nach, mit dem Billigsten, was etwas aussagt, SELECT 1. Klappt es, ist die Verbindung da. Klappt es nicht, ist der ehrliche Statuscode 503.

Die Abfrage läuft regelmäßig und darf deshalb selbst nicht teuer sein, sonst legt die Überwachung genau den Server lahm, den sie eigentlich nur beobachten soll. Also kein count(*) über eine große Tabelle und kein Aufruf nach draußen bei jeder Prüfung. Verraten darf sie auch nichts. Versionsnummern, Verbindungszeichenketten und Fehlermeldungen gehören dort genauso wenig hin wie in eine Fehlerantwort, denn /health ist öffentlich erreichbar.

Was in echt noch dazugehört

Zwei Bausteine behandelt dieser Kurs nicht mehr eigens, und sie werden wichtig, sobald der Server mit einem anderen Dienst redet.

Eine Zeitgrenze für einen langsamen Aufruf
async function langsam(ms, ergebnis) {
  await new Promise((fertig) => setTimeout(fertig, ms));
  return ergebnis;
}

/** Eine Zeitgrenze um einen Aufruf, der sonst ewig laufen koennte. */
async function mitZeitgrenze(promise, ms) {
  let timer;
  const grenze = new Promise((_, ablehnen) => {
    timer = setTimeout(() => ablehnen(new Error(`Zeitgrenze nach ${ms} ms`)), ms);
  });

  try {
    return await Promise.race([promise, grenze]);
  } finally {
    clearTimeout(timer);
  }
}

const schnell = await mitZeitgrenze(langsam(20, "Antwort"), 100);
console.log(`schnell genug: ${schnell}`);

try {
  await mitZeitgrenze(langsam(500, "Antwort"), 100);
} catch (fehler) {
  console.log(`zu langsam:    ${fehler.message}`);
}

Eine Zeitgrenze gehört um jeden Aufruf nach draußen. Ohne sie erbt der Server die Geduld des anderen Dienstes. Braucht der zehn Minuten, hängt die Anfrage zehn Minuten, und mit ihr eine Verbindung, ein Stück Speicher und ein wartender Nutzer. Ein hängender Aufruf ist gefährlicher als ein schnell gescheiterter, weil er sich aufstaut. Das finally aus Lektion 16.2 räumt im Beispiel den Timer ab. Ohne clearTimeout liefe er nach einer schnellen Antwort bis zur Zeitgrenze weiter und hielte den Prozess so lange am Leben.

Der zweite Baustein ist Wiederholen mit wachsendem Abstand, wenn ein Fehler vorübergehend sein kann. Wachsend deshalb, weil sofortige Wiederholungen einen überlasteten Dienst nur weiter belasten. Wiederholt wird nur, was vorübergehen kann, ein 500 oder eine Zeitüberschreitung, ein 400 nicht. Ein POST zu wiederholen legt außerdem womöglich zwei Bestellungen an, und das ist ein anderes Thema.

In der Aufgabe ziehst du die vier Schichten in die Bücher-API ein.

Zum Mitnehmen

Oben die Anfragekennung, dann die Routen, der Standardfall und ganz unten der Fehler-Handler, und beim Beenden ein sauberes Herunterfahren. Eine Zustandsabfrage fragt die Datenbank wirklich und antwortet sonst mit 503.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.