0Pricing
DevOps Bootcamp · Lektion

Muster, Bereiche und BEGIN-/END-Blöcke

Filtern Sie Datensätze mit bedingten Mustern und erzeugen Sie Kopfzeilen und Summen mithilfe von BEGIN- und END-Blöcken.

Muster, Bereiche und BEGIN-/END-Blöcke ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 2 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 DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was sind awk-Muster?

In awk ist ein Muster eine Bedingung, die steuert, ob ein Aktionsblock für eine bestimmte Eingabezeile ausgeführt wird. Die allgemeine Form lautet:

awk 'pattern { action }' file

Wenn das Muster auf den aktuellen Datensatz zutrifft, wird die Aktion ausgeführt. Wenn keine Aktion angegeben ist, gibt awk standardmäßig die gesamte Zeile aus. Muster können Folgendes sein:

  • Reguläre Ausdrücke — /regex/
  • Vergleichsausdrücke — $3 > 100
  • Zusammengesetzte Ausdrücke — $1 == "ERROR" && $4 > 500
  • Bereichsmuster — /start/,/end/
  • Spezielle Muster — BEGIN und END

Das Verständnis von Mustern ist der Einstieg in die Verwendung von awk als leistungsfähigem Datenfilter und nicht nur als Werkzeug zur Ausgabe von Spalten.

Reguläre Ausdrucksmuster zum Filtern von Zeilen

Der häufigste Mustertyp ist ein in Schrägstriche eingeschlossener regulärer Ausdruck. awk prüft jede Zeile anhand des regulären Ausdrucks und führt die Aktion nur bei Übereinstimmungen aus.

Im Folgenden filtern wir eine Datei im Stil von /var/log/syslog, sodass nur Zeilen angezeigt werden, die das Wort ERROR enthalten:

#!/usr/bin/env bash
# Simulate a log file and filter ERROR lines
log=$(cat <<'EOF'
2026-06-11 08:01:22 INFO  service started
2026-06-11 08:02:05 ERROR disk quota exceeded on /dev/sda1
2026-06-11 08:02:44 WARN  memory usage at 80%
2026-06-11 08:03:10 ERROR connection timeout to 10.0.0.5
2026-06-11 08:03:55 INFO  backup completed
EOF
)

echo "=== ERROR lines only ==="
echo "$log" | awk '/ERROR/ { print NR": "$0 }'

Negierte und zusammengesetzte Muster

Setzen Sie einem regulären Ausdrucksmuster ein ! voran, um es zu negieren — dadurch werden Zeilen gefunden, die das Muster nicht enthalten. Kombinieren Sie mehrere Bedingungen mit && (UND) oder || (ODER), um die Auswahl genau zu steuern.

  • !/DEBUG/ — Debug-Zeilen überspringen
  • $3 > 500 && $5 == "POST" — große POST-Anfragen
  • /WARN/ || /ERROR/ — eine der beiden Schweregradstufen

Das folgende Beispiel analysiert ein vereinfachtes Access-Log und gibt nur POST-Anfragen mit einer Antwortgröße von mehr als 1000 Bytes aus:

#!/usr/bin/env bash
access=$(cat <<'EOF'
10.0.0.1 GET  /api/ping     200  48
10.0.0.2 POST /api/upload   201  2048
10.0.0.3 GET  /api/users    200  512
10.0.0.4 POST /api/data     200  3500
10.0.0.5 POST /api/health   200  60
EOF
)

echo "Large POST requests (>1000 bytes):"
echo "$access" | awk '$2 == "POST" && $5 > 1000 { print $1, $3, "size="$5 }'

Bereichsmuster: /start/,/end/

Ein Bereichsmuster wählt einen zusammenhängenden Block von Datensätzen aus — von der Zeile, die auf /start/ passt, bis einschließlich der Zeile, die auf /end/ passt. Die Syntax lautet:

awk '/start/,/end/ { action }' file

Wichtige Verhaltensweisen:

  • Der Bereich wird bei der ersten Zeile aktiviert, die auf /start/ passt, und nach der ersten darauffolgenden Zeile deaktiviert, die auf /end/ passt.
  • Wenn /end/ nie gefunden wird, bleibt der Bereich bis zum Dateiende aktiv.
  • Mehrere nicht überlappende Bereiche in derselben Datei werden jeweils unabhängig voneinander verarbeitet.

Dadurch eignen sich Bereichsmuster ideal zum Extrahieren markierter Abschnitte aus Konfigurationsdateien, Logs mit Trennzeilen in den Kopfzeilen oder Berichten mit mehreren Blöcken.

Abschnitte mit Bereichsmustern extrahieren

Betrachten Sie eine Serverkonfiguration mit mehreren benannten Abschnitten, die durch Kopfzeilen im Format [section] abgegrenzt sind. Wir möchten nur die Zeilen innerhalb von [database]:

#!/usr/bin/env bash
config=$(cat <<'EOF'
[server]
host = 0.0.0.0
port = 8080

[database]
host = 127.0.0.1
port = 5432
name = appdb
user = admin

[cache]
host = 127.0.0.1
port = 6379
EOF
)

echo "=== [database] section ==="
echo "$config" | awk '/\[database\]/,/^\[/' \
  | awk 'NR > 1 && !/^\[/ && NF'

Der BEGIN-Block

Der BEGIN-Block wird einmal ausgeführt, bevor irgendeine Eingabe gelesen wird. Er eignet sich ideal für:

  • Ausgeben einer Berichtskopfzeile
  • Initialisieren von Variablen und Zählern
  • Setzen des Feldtrenners (FS) oder anderer integrierter Variablen
  • Ausführen eigenständiger awk-Programme, die keine Eingabe benötigen

Syntax:

awk 'BEGIN { setup } pattern { action }' file

Das Setzen von FS in BEGIN ist die übersichtlichere Alternative zum -F-Flag — besonders nützlich beim Schreiben von Programmen mit mehreren Regeln, bei denen die Logik für den Trenner im Skript enthalten ist.

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk 'BEGIN {
  FS = ","
  printf "%-10s %-15s %10s\n", "Name", "Department", "Salary"
  print "--------------------------------------------"
}'

Der END-Block

Der END-Block wird einmal ausgeführt, nachdem der letzte Datensatz verarbeitet wurde. Er ist der passende Ort, um:

  • Während der Verarbeitung ermittelte Summen, Mittelwerte und Zusammenfassungen auszugeben
  • Ausgabedateien zu leeren oder zu schließen
  • Fußzeilen für formatierte Berichte auszugeben

Variablen, die während der Hauptregeln gesetzt wurden, sind auch innerhalb von END weiterhin gültig — so werden laufende Summen gebildet. Das folgende Beispiel summiert Gehaltswerte aus einer CSV-Datei und gibt die Gesamtsumme in der Fußzeile aus:

#!/usr/bin/env bash
csv=$(cat <<'EOF'
alice,engineering,95000
bob,marketing,72000
carol,engineering,105000
dave,hr,68000
EOF
)

echo "$csv" | awk -F',' '
  { total += $3; count++ }
  END { printf "Employees: %d  Total payroll: $%d\n", count, total }
'

BEGIN, Regeln und END kombinieren

Die eigentliche Stärke zeigt sich, wenn Sie alle drei Blöcke zu einem einzigen eigenständigen awk-Programm kombinieren, das eine Kopfzeile ausgibt, jeden Datensatz verarbeitet und eine Zusammenfassung ausgibt. Dieses Muster bildet das Rückgrat von Reporting-Pipelines auf Shell-Basis.

Im Folgenden sehen Sie einen vollständigen Berichtsgenerator, der eine CSV-Datei mit Webanfragen liest, Details pro Zeile ausgibt und abschließend die Anzahl der Anfragen zählt, die länger als 1 Sekunde dauerten:

#!/usr/bin/env bash
data=$(cat <<'EOF'
/api/ping,0.03
/api/users,1.45
/api/login,0.88
/api/upload,2.10
/api/health,0.02
/api/report,1.73
EOF
)

echo "$data" | awk -F',' '
BEGIN {
  printf "%-20s %10s %s\n", "Endpoint", "Latency(s)", "Status"
  print "--------------------------------------"
}
{
  status = ($2 > 1.0) ? "SLOW" : "OK"
  if (status == "SLOW") slow++
  printf "%-20s %10s %s\n", $1, $2, status
}
END {
  print "--------------------------------------"
  printf "Slow requests: %d / %d\n", slow, NR
}
'

OFS und ORS mit BEGIN setzen

Zwei häufig übersehene Ausgabevariablen können übersichtlich in BEGIN gesetzt werden:

  • OFS (Ausgabefeldtrenner) — wird zwischen Felder eingefügt, wenn Sie einen Datensatz mit $1=$1 neu aufbauen oder print $1, $2 verwenden
  • ORS (Ausgabedatensatztrenner) — wird an jeden print-Aufruf angehängt (Standardwert ist \n)

Mit OFS="," können Sie eine TSV-Datei in einem Durchlauf ohne Zeichenkettenverkettung in CSV umformatieren. Wenn Sie ORS auf "\n---\n" ändern, werden automatisch Trennlinien zwischen Datensätzen eingefügt.

#!/usr/bin/env bash
# Convert whitespace-delimited data to CSV with a header
data=$(cat <<'EOF'
alice   engineering  95000
bob     marketing    72000
carol   engineering  105000
EOF
)

echo "$data" | awk 'BEGIN { OFS=","; print "name,dept,salary" }
{ $1=$1; print }'

Praktisches Bereichsmuster: Zeitfenster von Log-Vorfällen

Bereichsmuster sind besonders nützlich bei der Analyse von Betriebs-Logs. Eine häufige Aufgabe besteht darin, alle Logzeilen zwischen Beginn und Ende eines Vorfalls zu extrahieren, der durch Signalnachrichten wie INCIDENT START und INCIDENT END gekennzeichnet ist.

Im folgenden Beispiel extrahiert awk nur die Zeilen innerhalb des Vorfalls und zählt darin die ERROR-Ereignisse — dabei werden ein Bereichsmuster, ein Akkumulator und eine Zusammenfassung in END kombiniert:

#!/usr/bin/env bash
log=$(cat <<'EOF'
08:00:01 INFO  Normal operation
08:01:00 INFO  INCIDENT START: disk pressure detected
08:01:05 ERROR write failed on /dev/sda1
08:01:09 ERROR inode table corruption
08:01:14 WARN  remounting read-only
08:01:22 INFO  INCIDENT END: disk replaced
08:02:00 INFO  Normal operation resumed
EOF
)

echo "$log" | awk '
/INCIDENT START/,/INCIDENT END/ {
  print
  if (/ERROR/) errors++
}
END { print "Errors during incident:", errors+0 }
'

Trennzeilen in einem Bereich überspringen

Standardmäßig schließen Bereichsmuster die Zeilen ein, die selbst auf /start/ und /end/ passen. Um diese Trennzeilen zu überspringen und nur den Inhalt dazwischen beizubehalten, versehen Sie die Aktion mit einer Negation oder verwenden Sie eine Variablenmarkierung:

  • Ansatz mit Negation: /start/,/end/ { if (!/start/ && !/end/) print }
  • Ansatz mit Markierungsvariable: Setzen Sie eine Variable bei /start/ manuell auf 1 und bei /end/ auf 0.

Der Ansatz mit einer Markierungsvariable ist robuster, wenn der Text des Trenners auch im eigentlichen Inhalt vorkommen kann:

#!/usr/bin/env bash
doc=$(cat <<'EOF'
## preamble
some intro text
## BEGIN_REPORT
row1: alpha 100
row2: beta  200
row3: gamma 150
## END_REPORT
## appendix
EOF
)

echo "$doc" | awk '
/## BEGIN_REPORT/ { capture=1; next }
/## END_REPORT/   { capture=0 }
capture           { print }
'

Wissenscheck: Verhalten des BEGIN-Blocks

Testen Sie Ihr Verständnis davon, wie BEGIN- und END-Blöcke mit der Eingabeverarbeitung in awk zusammenwirken.

Lektionsrückblick: Muster, Bereiche und BEGIN/END

In dieser Lektion haben Sie die drei leistungsfähigsten strukturellen Merkmale von awk-Programmen gemeistert:

  • Muster — reguläre Ausdrücke (/ERROR/), Vergleichsausdrücke ($3 > 1000), negierte Muster (!/DEBUG/) und zusammengesetzte Ausdrücke (&&, ||) bestimmen, welche Datensätze eine Aktion auslösen, ohne dass explizite if-Anweisungen erforderlich sind.
  • Bereichsmuster (/start/,/end/) wählen zusammenhängende Datensatzblöcke aus und eignen sich hervorragend zum Extrahieren von Log-Zeitfenstern zu Vorfällen, Konfigurationsabschnitten und Berichtsteilen. Verwenden Sie eine Markierungsvariable (next + boolescher Wert), wenn die Trennzeilen selbst ausgeschlossen werden sollen.
  • BEGIN-Block — wird einmal vor jeder Eingabe ausgeführt; ideal zum Setzen von FS, OFS und ORS, zum Initialisieren von Zählern und zum Ausgeben von Berichtskopfzeilen.
  • END-Block — wird einmal nach der gesamten Eingabe ausgeführt; der richtige Ort, um Summen, Mittelwerte und Fußzeilen mithilfe der in den Hauptregeln gesammelten Variablen auszugeben.

Zusammen ermöglichen diese Funktionen vollständige, selbstdokumentierende awk-Programme, die Rohtext einlesen und strukturierte, für Menschen verständliche Berichte ausgeben — und das in einer einzigen Pipeline-Stufe ohne temporäre Dateien oder externe Werkzeuge.

Häufig gestellte Fragen

Ist die Lektion „Muster, Bereiche und BEGIN-/END-Blöcke“ kostenlos?

Ja — der vollständige Text von „Muster, Bereiche und BEGIN-/END-Blöcke“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Muster, Bereiche und BEGIN-/END-Blöcke“?

Filtern Sie Datensätze mit bedingten Mustern und erzeugen Sie Kopfzeilen und Summen mithilfe von BEGIN- und END-Blöcken. Du übst DevOps Bootcamp 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 DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp 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 2 von 4.

Wie lange dauert die Lektion „Muster, Bereiche und BEGIN-/END-Blöcke“?

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 DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-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. Datensätze, Felder und benutzerdefinierte Trennzeichen in awk
  2. Muster, Bereiche und BEGIN-/END-Blöcke
  3. Aggregation mit awk-Arrays und Gruppierung
  4. awk-Funktionen, printf-Formatierung und Berichtserstellung
← Zurück zu DevOps Bootcamp