Webentwicklung

HTTP HEAD für kleine Webanwendungen - GET-Semantik ohne Inhalt zu senden

HTTP HEAD für kleine Webanwendungen - GET-Semantik ohne Inhalt zu senden

Wie kann ein Client eine URL prüfen, ohne ihre Repräsentation herunterzuladen? HTTP bietet dafür eine Methode: HEAD. Sie wird oft als „GET ohne Body“ beschrieben, was als erste Annäherung hilfreich ist. Eine vollständige Implementierungsanleitung ist das jedoch noch nicht. Die schwierige Aufgabe besteht nicht darin, die Ausgabe zu unterdrücken, sondern die Bedeutung der Antwort zu erhalten, wenn Statuscodes, Weiterleitungen, Authentifizierung, Inhaltsaushandlung und Metadaten ins Spiel kommen.

Eine zuverlässige HEAD-Implementierung sollte dieselbe Frage beantworten wie GET: Was würde geschehen, wenn dieser Client diese Ressource anforderte? Der Unterschied besteht darin, dass sie die Antwort als Status und Metadaten zurückgibt, ohne die ausgewählte Repräsentation zu senden. Das macht HEAD nützlich, begrenzt aber zugleich, was die Antwort belegen kann.

Der Vertrag lautet: GET-Semantik ohne Antwortinhalt

RFC 9110 definiert HEAD als identisch mit GET, mit der Ausnahme, dass der Server keinen Inhalt in der Antwort senden darf. „Identisch“ bezieht sich auf die Semantik der Anfrage, nicht auf die Forderung, dass jedes Byte der beiden Antwort-Headerblöcke gleich sein muss.

Angenommen, GET /manual.pdf würde eine PDF-Datei auswählen, eine Authentifizierung verlangen und 200 OK zurückgeben. Eine entsprechende HEAD-Anfrage sollte nicht allein deshalb an eine generische Erfolgsmeldung geleitet werden, weil keine Dateibytes benötigt werden. Sie sollte weiterhin dieselben Entscheidungen zur Ressourcenauswahl und Autorisierung durchlaufen. Wurde die Ressource verschoben, bleibt die Weiterleitung relevant. Existiert sie nicht, bleibt 404 Not Found relevant. Wird der Zugriff verweigert, sollte die Antwort nichts anderes vortäuschen.

Die Methode gilt als sicher und idempotent. „Sicher“ bedeutet, dass ihre definierte Semantik nur lesend ist; es bedeutet nicht, dass der Server keinerlei begleitende Arbeit ausführt. Zugriffsprotokollierung, Rate-Zählung, Cache-Aktivität oder Session-Pflege können weiterhin stattfinden. Eine Route darf aus einer semantisch sicheren Anfrage keinen verborgenen zustandsändernden Befehl machen.

Header sollten übereinstimmen, aber nicht um jeden Preis

Die Spezifikation besagt, dass ein Server bei HEAD dieselben Header-Felder senden sollte, die er bei GET gesendet hätte. Sie erlaubt dem Server jedoch, Felder wegzulassen, deren Werte erst bei der Erzeugung des Inhalts bestimmt werden. Diese Einschränkung verhindert eine merkwürdige Optimierung: eine große Repräsentation vollständig zu rendern oder zu lesen, ihre Bytes zu zählen und sie anschließend zu verwerfen, nur um einen einzelnen Header bereitzustellen.

Content-Length ist die häufigste Falle. Ein Server darf das Feld in einer HEAD-Antwort senden, doch sein Wert muss die Inhaltslänge beschreiben, die ein entsprechendes GET gesendet hätte. Es ist nicht die Länge des Inhalts der HEAD-Antwort, denn dieser Inhalt existiert nicht. Kann die Anwendung die endgültige kodierte Länge nicht ohne Erzeugung der Repräsentation bestimmen, ist das Weglassen des Feldes ehrlicher als eine Schätzung.

Dieselbe Vorsicht kann für Metadaten gelten, die erst spät während der Erzeugung festgelegt werden. RFC 9110 nennt Vary als ein weiteres mögliches Beispiel. Das rechtfertigt keine beliebig voneinander abweichenden Antworten. Stabile Metadaten wie der ausgewählte Content-Type, Cache-Regeln, Validatoren, Sprache, Weiterleitungsziel und Authentifizierungsaufforderung sollten konsistent bleiben, sofern die Anwendung sie über den normalen Anfragepfad bestimmen kann.

Was HEAD einem Client sagen kann und was nicht

Ein Client kann mit HEAD einen Status prüfen, den Weiterleitungen einer Ressource folgen, einen ETag- oder Last-Modified-Wert vergleichen oder verfügbare Repräsentationsmetadaten erfahren, ohne die Repräsentation selbst zu übertragen. Link-Prüfer und Download-Werkzeuge können diese Informationen als eine Grundlage für ihre Entscheidung verwenden.

Eine erfolgreiche HEAD-Antwort beweist jedoch nicht, dass der Body eines späteren GET vollständig übertragen wird. Die zugrunde liegende Datei könnte nach der Metadatenprüfung verschwinden. Ein dynamischer Renderer könnte erst bei der Inhaltserzeugung scheitern. Die Autorisierung könnte sich zwischen den Anfragen ändern. Ein Server könnte HEAD schlicht fehlerhaft implementieren. Zwischen der Frage nach einer Repräsentation und ihrem Abruf liegt unvermeidlich ein Zeitabstand.

Die Methode garantiert außerdem keine kostengünstige Anfrage. Eine datenbankgestützte Seite benötigt möglicherweise weiterhin Routing, Autorisierung, eine Datensatzabfrage und Inhaltsaushandlung, bevor Status und Header feststehen. Der Server spart Antwortbytes und kann Rendering-Arbeit vermeiden, doch das Ausmaß hängt von der Anwendung ab. Für diese Methode gibt es keinen seriösen universellen Leistungsfaktor.

HEAD hat eine begrenzte, aber reale Cache-Rolle

HEAD-Antworten sind cachefähig. Genauer beschreibt RFC 9111, wie ein Cache HEAD verwenden kann, um eine gespeicherte GET-Antwort zu aktualisieren oder ungültig zu machen. Stimmen Validatoren wie ETag oder Last-Modified überein und stimmt auch ein vorhandener Content-Length-Wert, kann der Cache die gespeicherten Metadaten aktualisieren. Eine Abweichung kann dazu führen, dass die gespeicherte Antwort als veraltet gilt.

Das ist kein Grund, jedes bedingte GET durch HEAD zu ersetzen. Besitzt eine gespeicherte Antwort Validatoren, fragt ein bedingtes GET direkt, ob diese Repräsentation noch aktuell ist, und kann 304 Not Modified erhalten. RFC 9111 beschreibt HEAD als nützlich, wenn dieser effizientere Validierungsweg nicht verfügbar ist oder wenn geänderter Inhalt nicht empfangen werden soll. Das Cache-Verhalten gehört zur Semantik der Methode, ist aber kein Beleg dafür, dass jeder eingesetzte Cache dieselbe Optimierung vornimmt.

Ein gemeinsamer Anfragepfad ist sicherer als zwei Implementierungen

Das am besten wartbare Anwendungsdesign teilt üblicherweise Ressourcenauswahl, Autorisierung, Status und Metadatenlogik zwischen GET und HEAD. Nur die abschließende Ausgabe des Inhalts sollte sich unterscheiden. Das folgende vereinfachte PHP-Muster verdeutlicht diese Grenze:

<?php
$method = $_SERVER['REQUEST_METHOD'] ?? 'GET';

if (!in_array($method, ['GET', 'HEAD'], true)) {
    header('Allow: GET, HEAD');
    http_response_code(405);
    exit;
}

$article = findPublishedArticle($_SERVER['REQUEST_URI']);

if ($article === null) {
    http_response_code(404);
    exit;
}

header('Content-Type: text/html; charset=UTF-8');
header('Cache-Control: public, max-age=300');
header('ETag: "' . $article['etag'] . '"');

if ($method === 'HEAD') {
    exit;
}

echo renderArticle($article);

Dies ist eine Routing-Skizze und kein direkt einsetzbarer Framework-Code. Die beiden benannten Funktionen und die Erzeugung des Validators benötigen anwendungsspezifische Implementierungen. Entscheidend ist die Reihenfolge: Die Methodenbehandlung umgeht weder die Routensuche noch die Statusauswahl, während das aufwendige HTML-Rendering nur bei GET stattfindet. Da die endgültige HTML-Länge vor dem Rendern unbekannt ist, sendet das Beispiel bewusst kein Content-Length.

Ein Server für statische Dateien oder eine Anwendung mit einer gespeicherten, bereits kodierten Repräsentation kann die Länge kostengünstig kennen. Bei einer gestreamten Seite ist das häufig nicht möglich. Diese Fälle sollten nicht in dieselbe Metadatenstrategie gezwungen werden.

Methode und endgültiges Ziel testen

curl bietet einen korrekten HEAD-Modus mit -I beziehungsweise --head:

curl --head https://example.com/article
curl --head --location https://example.com/article

Der zweite Befehl folgt Weiterleitungen. Ohne --location kann die erste Weiterleitungsantwort genau das sein, was curl anzeigen soll, doch sie beschreibt nicht das endgültige Ziel. Bei einer mehrsprachigen Route, einer Anmeldegrenze oder einer kanonischen Weiterleitung sollte die gesamte Kette und nicht nur ihr erster Status geprüft werden.

Um das Ergebnis mit einem echten GET zu vergleichen, ohne dessen Body im Terminal auszugeben, kann die Anfrage normal ausgeführt und der heruntergeladene Inhalt verworfen werden:

curl --silent --show-error \
  --dump-header - \
  --output /dev/null \
  https://example.com/article

Dieser Befehl überträgt die GET-Repräsentation weiterhin; /dev/null verwirft sie nur lokal. Verglichen werden sollten Status und relevante Felder, nicht flüchtige Werte wie Date oder Tracing-IDs.

Ein subtiler curl-Fehler ist curl -X HEAD URL. Das curl-Handbuch erklärt, dass --request nur das Methodenwort ändert; curl wechselt dadurch nicht zu dem Übertragungsverhalten von --head. Dabei sollte --head verwendet werden, wenn eine korrekte HTTP-HEAD-Operation das Ziel ist.

Häufige Fehlermuster

Eine separate „schnelle“ Route weicht von GET ab

Ein eigens gebauter HEAD-Zweig könnte 200 zurückgeben, bevor Autorisierung, kanonische Weiterleitung, Sprachauswahl oder Datenbankabfrage stattfinden. Er ist schnell, weil er eine andere Frage beantwortet. Ein gemeinsamer Entscheidungspfad verringert diese Abweichung.

Die Anwendung erzeugt eine falsche Länge

Die Quelllänge eines Templates entspricht nicht zwangsläufig der Länge der übertragenen Repräsentation. Zeichenkodierung, Inhaltskodierung, Middleware und spätes Rendering können die Bytes verändern. Content-Length sollte weggelassen werden, wenn der Wert nicht der tatsächlich ausgewählten GET-Repräsentation entspricht.

Der Server rendert alles und verwirft es

Das kann genaue Metadaten liefern, gibt aber einen großen Teil der möglichen Effizienz auf. Es sollte festgelegt werden, welche Metadaten vor dem Rendern verfügbar sind; erforderlichenfalls können die von der Spezifikation erlaubten Auslassungen genutzt werden.

Monitoring behandelt HEAD als vollständigen Zustandsnachweis

HEAD kann Erreichbarkeit und Metadatenverhalten prüfen. Die Methode testet weder die vollständige Body-Erzeugung noch Streaming oder clientseitige Ausführung. Ein nützlicher Monitor wählt eine Anfrage, die zu dem zu erkennenden Fehler passt; manchmal genügt HEAD, manchmal ist nur ein echtes GET ausreichend.

Praktische Prüfliste

  • HEAD durch dieselben Entscheidungen zu Ressource, Autorisierung, Weiterleitung und Repräsentationsauswahl wie GET leiten.
  • Bei HEAD niemals Antwortinhalt senden.
  • Status und stabile Metadaten mit dem entsprechenden GET in Einklang halten.
  • Content-Length oder andere spät berechnete Felder nicht erfinden.
  • Verhindern, dass Routen für sichere Methoden beabsichtigte Zustandsänderungen ausführen.
  • Direkte Antworten, Weiterleitungsketten, fehlende und geschützte Ressourcen testen.
  • curl --head und nicht nur -X HEAD verwenden.
  • Mindestens eine echte GET-Prüfung beibehalten, wenn die vollständige Übertragung der Repräsentation wichtig ist.

Fazit

HEAD ist syntaktisch klein, aber semantisch nicht trivial. Der Wert der Methode liegt darin, die Entscheidungen von GET zu erhalten und zugleich den Antwortinhalt zurückzuhalten. Eine ehrliche Implementierung ist daher keine universelle Abkürzung zu 200 OK. Sie ist ein gemeinsamer Anfragepfad mit einer sorgfältig gesetzten Grenze vor der Erzeugung oder Ausgabe des Inhalts.

Diese Grenze kann Bandbreite und manchmal Anwendungsarbeit sparen. Sie kann keinen zukünftigen Download garantieren, nicht jede bedingte Anfrage ersetzen und aufwendige Metadaten nicht kostenlos machen. Werden diese Grenzen als Teil des Designs behandelt, wird HEAD nützlicher und nicht weniger nützlich.

References