0Pricing
Linux Command Line & Bash Scripting Mastery · Lektion

Web- und Anwendungsprotokolle in großem Maßstab auswerten

Extrahieren Sie Statuscodes, Latenzen und Clientfelder aus Zugriffsprotokollen mit grep, cut und awk.

Web- und Anwendungsprotokolle in großem Maßstab auswerten ist eine kostenlose Linux Command Line & Bash Scripting Mastery-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Linux Command Line & Bash Scripting Mastery-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Was ist ein Webzugriffslog?

Jeder HTTP-Server – Apache, Nginx, Caddy – schreibt für jede Anfrage eine Zeile in ein Zugriffslog. Wenn Sie die Struktur dieser Zeilen verstehen, verfügen Sie über die Grundlage für jede Art der Loganalyse.

Eine typische Zeile im Combined Log Format (CLF) sieht so aus:

  • Client-IP – wer die Anfrage gestellt hat
  • Zeitstempel – wann sie gestellt wurde
  • Anfragezeile – Methode, Pfad, Protokoll
  • Statuscode – HTTP-Antwort (200, 404, 500…)
  • Gesendete Bytes – Größe des Antworttexts
  • Referer – Ursprungsseite
  • User-Agent – Kennung des Browsers oder Bots

Beispielzeile aus /var/log/nginx/access.log:

192.168.1.10 - alice [11/Jun/2026:14:32:01 +0000] "GET /api/orders HTTP/1.1" 200 1482 "-" "curl/7.88.1"

Bei großem Datenaufkommen wachsen diese Dateien auf mehrere Millionen Zeilen pro Tag an. Ziel dieser Lektion ist es, mithilfe von standardmäßigen BASH-Tools Felder daraus effizient zu extrahieren, zu filtern und zu aggregieren.

Ein Live-Log mit tail und grep untersuchen

Bevor Sie eine Pipeline schreiben, untersuchen Sie das Log, um seine Struktur zu verstehen. Mit tail können Sie einen Live-Datenstrom beobachten; grep schränkt ihn sofort auf relevante Zeilen ein.

Häufige Muster:

  • tail -n 1000 access.log – die letzten 1000 Zeilen
  • tail -f access.log – in Echtzeit verfolgen
  • tail -f access.log | grep '" 5' – nur eintreffende 5xx-Fehler

Wichtig ist, dass grep die gesamte Zeile durchsucht. Daher ist es wichtig, das Muster korrekt zu verankern. Durch die Suche nach ' 500 ' (mit Leerzeichen) vermeiden Sie, versehentlich einen URL-Pfad zu finden, der die Zeichenfolge 500 enthält.

#!/usr/bin/env bash
# Watch only HTTP 5xx errors arriving in real time
tail -f /var/log/nginx/access.log \
  | grep --line-buffered '" 5[0-9][0-9] '

Den Statuscode mit cut extrahieren

cut teilt jede Zeile anhand eines Trennzeichens auf und gibt ausgewählte Felder aus. Im Combined Log Format steht der Statuscode beim Aufteilen an Leerzeichen in Feld 9. Da die Anfragezeile jedoch von Anführungszeichen umgeben ist, ist es sicherer, von einem bekannten Anker aus zu zählen.

Ein zuverlässiger Trick: Da die Anfragezeile immer in Anführungszeichen steht, ist der Statuscode immer das erste Token nach dem schließenden Anführungszeichen des Anfragefelds. Mit cut -d'"' -f3 isolieren Sie alles nach dem Anführungszeichen der Anfrage. Ein zweites cut -d' ' -f2 wählt anschließend den Statuscode aus.

Dieses zweistufige cut ist ein klassisches Idiom für CLF-Logs – schnell und ohne externe Abhängigkeiten.

#!/usr/bin/env bash
# Print only the HTTP status code from each log line
# Input format: ... "GET /path HTTP/1.1" 200 1482 ...
cut -d'"' -f3 /var/log/nginx/access.log \
  | cut -d' ' -f2 \
  | sort \
  | uniq -c \
  | sort -rn

Statuscodes mit awk zählen

awk ist leistungsfähiger als cut, weil damit über mehrere Zeilen hinweg Zustände akkumuliert werden können. Das idiomatische Muster zum Zählen von Vorkommen ist ein assoziatives Array, dessen Schlüssel der gesuchte Wert ist.

Im CLF ist Feld $9 (beginnend bei 1, durch Leerzeichen getrennt) der Statuscode. awk verarbeitet jede Zeile, erhöht einen Zähler und gibt im END-Block eine sortierte Zusammenfassung aus.

Warum sollte man awk gegenüber cut | sort | uniq -c bevorzugen? Weil awk dies in einem einzigen Durchlauf erledigt, ohne die gesamte Datei vorher zu sortieren – entscheidend, wenn das Log mehrere hundert Gigabyte groß ist.

#!/usr/bin/env bash
# Count HTTP status codes in a single awk pass
awk '{ count[$9]++ }
END {
  for (status in count)
    printf "%6d  %s\n", count[status], status
}' /var/log/nginx/access.log \
  | sort -rn

Fehler filtern und Client-IPs extrahieren

Eine der häufigsten Aufgaben im Betrieb besteht darin, herauszufinden, welche Client-IPs die meisten Fehler verursachen. Dabei werden Filterung (nur Fehlerzeilen) und Feldextraktion (die IP in Feld 1) kombiniert.

Die Strategie für die Pipeline:

  • Verwenden Sie awk, um in einem Schritt nach dem Statuscodebereich zu filtern und die IP zu extrahieren – vermeiden Sie einen separaten grep-Durchlauf
  • Leiten Sie die Ausgabe mit sort | uniq -c | sort -rn | head weiter, um schnell die häufigsten Werte anzuzeigen

Dieses Muster ist schnell genug, um auf einem einzelnen Server gegen eine 10-GB-Logdatei ausgeführt zu werden, ohne die Datei in den Arbeitsspeicher zu laden.

#!/usr/bin/env bash
# Top 10 IPs generating HTTP 4xx or 5xx errors
awk '$9 ~ /^[45][0-9][0-9]$/ { print $1 }' \
    /var/log/nginx/access.log \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -10

Antwortlatenz aus Anwendungslogs auswerten

Anwendungsserver (Rails, Gunicorn, Express mit morgan usw.) protokollieren häufig die Dauer von Anfragen. Nginx kann so konfiguriert werden, dass $request_time als zusätzliches Feld am Ende jeder Zeile ausgegeben wird.

Beispiel für ein benutzerdefiniertes Nginx-Logformat in nginx.conf:

log_format timed '$remote_addr - $remote_user [$time_local] "$request" $status $body_bytes_sent "$http_referer" "$http_user_agent" rt=$request_time';

Sobald die Latenz im Log enthalten ist, können Sie mit awk über Millionen von Anfragen hinweg Durchschnitt, Maximum und Perzentil-Annäherungen berechnen, ohne die Daten in eine Datenbank zu laden.

#!/usr/bin/env bash
# Compute average and max request_time from Nginx timed log
# Assumes last field is rt=<seconds> e.g. rt=0.042
awk '{
  # Extract numeric value after rt=
  n = split($NF, a, "=")
  if (n == 2 && a[1] == "rt") {
    t = a[2] + 0
    sum += t
    count++
    if (t > max) max = t
  }
}
END {
  if (count > 0)
    printf "Requests: %d  Avg: %.4fs  Max: %.4fs\n", count, sum/count, max
}' /var/log/nginx/timed_access.log

Ein Latenzhistogramm mit awk erstellen

Ein einzelner Durchschnittswert verbirgt die Latenz am Ende der Verteilung. Ein Histogramm macht die Verteilung sichtbar – ob die meisten Anfragen schnell und einige wenige sehr langsam sind (langer Nachlauf) oder ob die Verteilung gleichmäßig ist.

Der Trick besteht darin, jeden Wert mithilfe von Ganzzahlarithmetik innerhalb von awk einem gerundeten Bereich zuzuordnen. Durch die Multiplikation mit 1000 (Umrechnung von Sekunden in Millisekunden) und anschließende Ganzzahldivision entstehen klare Bereichsgrenzen.

So entsteht ein Texthistogramm, das Sie direkt in einem Terminal lesen können. Für eine schnelle Untersuchung ist das oft schneller, als die Daten an Grafana zu übertragen.

#!/usr/bin/env bash
# Latency histogram (50ms buckets) from Nginx timed log
awk '{
  n = split($NF, a, "=")
  if (n == 2 && a[1] == "rt") {
    ms = int(a[2] * 1000)      # convert to ms
    bucket = int(ms / 50) * 50 # round down to 50ms boundary
    hist[bucket]++
  }
}
END {
  for (b in hist)
    printf "%6dms  %d\n", b, hist[b]
}' /var/log/nginx/timed_access.log \
  | sort -n

User-Agent extrahieren und Bots erkennen

Das User-Agent-Feld (Feld 6 beim Aufteilen an ") identifiziert Clients. Crawler, Scraper und bösartige Bots verfälschen häufig Ihre Metriken und erhöhen die Fehlerzahlen. Wenn Sie sie herausfiltern, erhalten Sie ein genaueres Bild des Datenverkehrs echter Nutzer.

Häufige Bot-Signaturen: bot, crawler, spider, curl, python-requests, Googlebot, Bingbot.

Verwenden Sie grep -iv (Groß-/Kleinschreibung ignorieren und Suche umkehren), um bekannte Bots auszuschließen, oder verwenden Sie awk, um an " aufzuteilen und direkt im UA-Feld zu suchen.

#!/usr/bin/env bash
# Count top 15 User-Agent strings, excluding known bots
awk -F'"' '{ print $6 }' /var/log/nginx/access.log \
  | grep -iv -e 'bot' -e 'crawler' -e 'spider' -e 'curl' \
              -e 'python' -e 'wget' -e 'Go-http-client' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -15

Datenverkehr nach Endpunkt aggregieren

Wenn Sie wissen, welche Endpunkte den meisten Datenverkehr erhalten – und die meisten Fehler erzeugen –, können Sie Optimierungen und die Kapazitätsplanung besser priorisieren. Der Anfragepfad befindet sich im Anführungszeichen eingeschlossenen Anfragefeld.

Teilen Sie an " auf und nehmen Sie Feld 2 (die Anfragezeile). Entfernen Sie anschließend Methode und Protokoll, um den Pfad zu isolieren. Bei APIs mit Pfadparametern wie /users/12345 möchten Sie IDs möglicherweise mit sed oder einem komplexeren awk-Muster normalisieren und in /users/:id umwandeln.

#!/usr/bin/env bash
# Top 20 requested endpoints (method + path, no query string)
awk -F'"' '{ print $2 }' /var/log/nginx/access.log \
  | awk '{ print $1, $2 }' \
  | sed 's|/[0-9][0-9]*\b|/:id|g' \
  | sort \
  | uniq -c \
  | sort -rn \
  | head -20

Fehler mit awk Endpunkten zuordnen

Die leistungsfähigste Analyse in einem einzigen Durchlauf kombiniert mehrere Felder gleichzeitig: Endpunkt, Statuscode und optional die Latenz. Assoziative awk-Arrays mit zusammengesetzten Schlüsseln machen dies übersichtlich und schnell.

Das folgende Muster zählt 5xx-Fehler pro Endpunkt in einem Durchlauf – ohne temporäre Dateien und ohne Zwischensortierungen bis ganz zum Schluss. Dieser Ansatz wird in Observability-Skripten für Produktionssysteme verwendet, wenn auf einem großen Log innerhalb von weniger als einer Minute Antworten benötigt werden.

#!/usr/bin/env bash
# Count 5xx errors per endpoint path in a single pass
awk -F'"' '{
  # $2 = request line e.g. "GET /api/orders HTTP/1.1"
  # $0 in original space-split: $9 = status
  split($0, fields, " ")
  status = fields[9]
  if (status ~ /^5/) {
    split($2, req, " ")
    path = req[2]
    # Normalise numeric IDs
    gsub(/\/[0-9]+/, "/:id", path)
    errors[path]++
  }
}
END {
  for (p in errors)
    printf "%6d  %s\n", errors[p], p
}' /var/log/nginx/access.log \
  | sort -rn \
  | head -20

Rotierte und komprimierte Logs verarbeiten

Auf den meisten Servern werden Logs täglich rotiert. Ältere Dateien werden mit gzip als access.log.1.gz, access.log.2.gz usw. komprimiert. Standardtools können sie nicht direkt lesen, aber zwei Ansätze funktionieren problemlos:

  • zcat – dekomprimiert nach stdout und leitet die Ausgabe in Ihre Pipeline weiter
  • zgrep – durchsucht gzip-Dateien direkt, ohne sie zu entpacken

Um eine vollständige Woche mit sowohl unkomprimierten als auch komprimierten Logs zu analysieren, verwenden Sie Prozesssubstitution oder verketten Sie die Dateien mit zcat. Das folgende Snippet verarbeitet die letzten 7 rotierten Dateien sowie das aktuelle Live-Log in einem einzigen awk-Aufruf – temporäre Dateien sind nicht erforderlich.

#!/usr/bin/env bash
# Aggregate status codes across a week of rotated logs
# Handles both plain and gzip-compressed rotation files

LOG_DIR="/var/log/nginx"

{
  cat  "${LOG_DIR}/access.log" 2>/dev/null
  zcat "${LOG_DIR}/access.log".*.gz 2>/dev/null
} | awk '
{ count[$9]++ }
END {
  for (s in count)
    printf "%6d  %s\n", count[s], s
}' | sort -rn

Welches awk-Feld enthält den HTTP-Statuscode im Combined Log Format?

Sie schreiben eine einzeilige awk-Anweisung, um aus einem standardmäßigen Nginx-Zugriffsprotokoll im Combined Log Format (durch Leerzeichen getrennt, mit einer in Anführungszeichen gesetzten Request-Zeile) ausschließlich HTTP-4xx-Antworten herauszufiltern. Welche Feldnummer identifiziert den HTTP-Statuscode korrekt?

Zusammenfassung der Lektion: Pipelines zur Protokollanalyse

In dieser Lektion haben Sie mit ausschließlich standardmäßigen BASH-Werkzeugen ein vollständiges Toolkit für die Analyse von Web- und Anwendungsprotokollen in großem Maßstab entwickelt.

Behandelte Schlüsseltechniken:

  • Struktur zuerst — Das Combined Log Format hat eine vorhersehbare Feldstruktur. Wenn Sie diese kennen, können Sie die Daten zuverlässig mit cut -d'"' oder Feldreferenzen in awk aufteilen.
  • Extraktion von Statuscodes — awk '{ count[$9]++ }' zählt alle Codes in einem einzigen Durchlauf. Mit $9 ~ /^5/ filtern Sie Serverfehler heraus.
  • Latenzanalyse — Analysieren Sie das benutzerdefinierte Feld rt= mit awk, um ohne externe Werkzeuge Durchschnittswerte, Maximalwerte und Histogrammklassen zu berechnen.
  • Analyse von Clients und Bots — Teilen Sie mit -F'"' am Zeichen ", um das User-Agent-Feld zu erreichen, und leiten Sie die Ausgabe durch grep -iv, um Bots vor der Aggregation auszuschließen.
  • Normalisierung von Endpunkten — Verwenden Sie innerhalb von awk gsub(/\/[0-9]+/, "/:id"), um parametrisierte Pfade vor dem Zählen zusammenzufassen.
  • Rotierte Protokolle — Kombinieren Sie cat und zcat in einer Subshell, um alle Rotationsdateien in einem einzigen Pipeline-Durchlauf zu verarbeiten.

Diese Muster lassen sich kombinieren: Sie können Filtern, Extraktion, Normalisierung und Aggregation in einer einzigen Pipeline verketten, die Hunderte Millionen Zeilen auf handelsüblicher Hardware verarbeitet. Wenn Sie diese Grundbausteine beherrschen, benötigen Sie für Ad-hoc-Untersuchungen von Vorfällen nur selten einen dedizierten Protokollaggregationsdienst.

Häufig gestellte Fragen

Ist die Lektion „Web- und Anwendungsprotokolle in großem Maßstab auswerten“ kostenlos?

Ja — der vollständige Text von „Web- und Anwendungsprotokolle in großem Maßstab auswerten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Linux Command Line & Bash Scripting Mastery-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Web- und Anwendungsprotokolle in großem Maßstab auswerten“?

Extrahieren Sie Statuscodes, Latenzen und Clientfelder aus Zugriffsprotokollen mit grep, cut und awk. Du übst Linux Command Line & Bash Scripting Mastery mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Linux Command Line & Bash Scripting Mastery zu starten?

Keine Vorkenntnisse erforderlich. Linux Command Line & Bash Scripting Mastery auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Web- und Anwendungsprotokolle in großem Maßstab auswerten“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Linux Command Line & Bash Scripting Mastery-Lektion Code schreiben und ausführen?

Ja. Jede Linux Command Line & Bash Scripting Mastery-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Web- und Anwendungsprotokolle in großem Maßstab auswerten
  2. Echtzeit-Überwachung von Protokollen und Streaming-Warnmeldungen
  3. journald mit journalctl in Skripten abfragen
  4. Metriken und Histogramme aus Protokollströmen berechnen
← Zurück zu Linux Command Line & Bash Scripting Mastery