TP-Link Omada per Syslog mit Fluent Bit und OpenObserve auswerten

TP-Link Omada per Syslog mit Fluent Bit und OpenObserve auswerten
Photo by JOSHUA COLEMAN / Unsplash

Wer im Homelab ein Netzwerk mit TP-Link Omada betreibt, hat im Controller zwar eine Übersicht über Clients und Geräte. Für eine längere Historie, eigene Auswertungen oder Alarme reicht das aber schnell nicht mehr aus. Gerade Firewall-Blocks, WLAN-Anmeldungen oder Roaming-Vorgänge möchte man gerne zentral und durchsuchbar ablegen.

Omada kann dafür alle Meldungen per Syslog an einen zentralen Server senden. Dort nimmt Fluent Bit die Daten an, bereitet sie auf und schreibt sie nach OpenObserve. In OpenObserve werden die Meldungen per VRL-Funktion in Felder zerlegt und in einem Dashboard ausgewertet.

In diesem Beitrag zeige ich Schritt für Schritt:

  • Welche Daten Omada per Syslog sendet und wo die Fallstricke liegen
  • Einrichtung von Fluent Bit mit eigenem Parser und Lua-Filter
  • Aufteilung in zwei Streams für Client-Verkehr und Ereignisse
  • Zerlegung der Meldungen mit VRL-Funktionen in OpenObserve
  • Anreicherung blockierter IP-Adressen mit GeoIP (Land, Stadt, Provider)
  • Aufbau eines Dashboards mit Weltkarte

Ziel des Setups

Das Ziel ist eine zentrale, durchsuchbare Auswertung aller Omada-Meldungen mit folgenden Eigenschaften:

  • Fluent Bit als zentraler Syslog-Empfänger
  • Vollständige Zerlegung der gebündelten AP-Pakete
  • Getrennte Streams für Client-Verkehr und Ereignisse
  • Korrekte Zeitstempel, auch bei falsch eingestellter Uhrzeit auf den APs
  • Firewall-Blocks mit Land, Stadt und Provider der Quell-IP
  • WLAN-Anmeldungen, Trennungen und Roaming mit Client-, AP- und SSID-Namen
  • Dashboard mit Weltkarte, Client-Verzeichnis und Firewall-Übersicht

Architektur

Fluent Bit läuft auf demselben Host wie OpenObserve. Die Konfiguration liegt im Standardverzeichnis:

/etc/fluent-bit
├── fluent-bit.conf
├── parsers.conf
└── omada_split.lua

In OpenObserve entstehen zwei Streams mit je einer Pipeline und einer Funktion:

network_tplink_omada_flows   →  pl_network_tplink_omada_flows  →  norm_network_tplink_omada_flows
network_tplink_omada         →  pl_network_tplink_omada        →  norm_network_tplink_omada

Die Namen folgen dem Schema <kategorie>_<hersteller>_<produkt>. Funktionen beginnen mit norm_, Pipelines mit pl_.

Die Trennung in zwei Streams hat einen einfachen Grund: Der Client-Verkehr der Access Points erzeugt rund 1 Million Einträge pro Tag, die Ereignisse nur einige hundert. Der Verkehr bekommt deshalb eine kurze Aufbewahrungszeit, die Ereignisse eine lange.


Voraussetzungen

Für dieses Setup werden folgende Komponenten vorausgesetzt:

  • TP-Link Omada mit Controller (Software, OC200/OC300 oder Cloud), Gateway und Access Points
  • Ein Linux-Server mit Fluent Bit (getestet mit Version 5.1)
  • Eine laufende OpenObserve-Instanz
  • Optional: MaxMind-Tabellen maxmind_city und maxmind_asn in OpenObserve für GeoIP
  • UDP-Port 5514 vom Omada-Netz zum Fluent-Bit-Host erreichbar

Beispiel-Adressen in diesem Beitrag:

openobserve.domain.tld   # OpenObserve
192.168.1.10             # Fluent-Bit-Host

Teil 1: Was Omada per Syslog sendet

Remote Logging in Omada aktivieren

Im Omada Controller wird in den Site-Einstellungen unter Services → Remote Logging der Syslog-Server eingetragen. Die genaue Bezeichnung kann je nach Controller-Version leicht abweichen.

  • Syslog-Server: 192.168.1.10
  • Port: 5514

Danach senden Gateway, Access Points und Controller ihre Meldungen an Fluent Bit.

Drei Absender, drei Formate

Auf einem einzigen Port kommen drei völlig unterschiedliche Formate an. Ein einzelner Standard-Parser reicht deshalb nicht aus.

Absender

Format

Inhalt

Access Points

RFC 3164, rund 12 Einträge pro Paket, getrennt durch \r\n

Client-Verkehr: Client-MAC, Quell- und Ziel-IP, Protokoll, Ports

Gateway

RFC 3164 mit zweitem Zeitstempel, Modul und Level

Firewall-ACL, DHCP

Controller

RFC-5424-ähnlich, Leerzeichen in Zeit und Hostname

Client online/offline, Roaming, DHCP

Access Points

Ein einzelner Eintrag sieht so aus:

[1792692377.958731137] AP MAC=aa:bb:cc:00:00:01 MAC SRC=aa:bb:cc:00:00:02 IP SRC=192.168.10.20 IP DST=192.168.10.5 IP proto=6 SPT=51234 DPT=443

Die Zahl in eckigen Klammern ist ein Unix-Zeitstempel. Er ist wichtiger als die Uhrzeit im Syslog-Header, dazu später mehr.

Gateway

Firewall-Blocks kommen als Schlüssel-Wert-Liste:

<13>Oct 22 20:13:26 ER7406: 2026-10-22 20:13:26 firewall<5>: [ACL]GATEWAY=…,DESC=1009206213,ACTION=Block,SRC=203.0.113.10,DST=192.168.20.5,PROTO=TCP,Sport=34818,Dport=443

Controller

Der Controller liefert die lesbarsten Meldungen, inklusive Client-, AP- und SSID-Namen:

<142>1 2026-10-22 20:22:00 Omada Controller - - - [client:sensor-01:AA-BB-CC-00-00-03] is roaming from [ap:AP Flur:…][Channel 11] to [ap:AP Garten:…][Channel 6] with SSID "Heimnetz"

Die Fallstricke

Beim Aufbau sind mir einige Besonderheiten begegnet, die man kennen sollte:

  • Mehrere Einträge pro Paket: Die APs bündeln etwa 12 Einträge in ein UDP-Paket. Ein Parser mit .* endet beim ersten Zeilenumbruch, und von jedem Paket bleibt nur der erste Eintrag übrig.
  • IP-Fragmentierung: Die AP-Pakete sind rund 1.750 Byte groß und werden fragmentiert. Für Fluent Bit ist das kein Problem, für einen Mitschnitt mit tcpdump schon (siehe Fehlersuche).
  • Falsche Uhrzeit: Bei mir schreiben vier von fünf APs eine Stunde zu früh in den Syslog-Header. Der Unix-Zeitstempel im Eintrag ist bei allen korrekt.
  • Ungültiges RFC 5424: Der Controller schreibt Leerzeichen in Zeitstempel und Hostname. Standard-Parser scheitern daran.
  • DHCP doppelt: Gateway und Controller melden dieselben DHCP-Vergaben.

Teil 2: Fluent Bit einrichten

Parser für ganze Pakete anlegen

Der Parser muss das komplette UDP-Paket übernehmen, auch über Zeilenumbrüche hinweg. Dazu wird er in der parsers.conf ergänzt:

nano /etc/fluent-bit/parsers.conf

Inhalt:

[PARSER]
    Name    raw-datagram
    Format  regex
    Regex   (?<message>[\s\S]+)

Erklärung

  • [\s\S]+ passt auf jedes Zeichen, auch auf Zeilenumbrüche
  • Mit .* würde der Parser beim ersten \r\n aufhören und alle weiteren Einträge im Paket verwerfen
  • Der Syslog-Header bleibt erhalten und wird später in OpenObserve ausgewertet

Lua-Filter zum Zerlegen der AP-Pakete erstellen

Der Lua-Filter teilt jedes AP-Paket in einzelne Datensätze auf. Meldungen von Gateway und Controller reicht er unverändert durch.

nano /etc/fluent-bit/omada_split.lua

Inhalt:

-- omada_split.lua – Fluent-Bit-Filter für TP-Link Omada
-- Zerlegt die gebündelten Client-Traffic-Einträge der Access Points
-- in einen Datensatz pro Eintrag.
function split_omada(tag, ts, record)
  local msg = record["message"]
  if type(msg) ~= "string" or not string.find(msg, "AP MAC=", 1, true) then
    return 0, ts, record
  end
  msg = string.gsub(msg, "%z", "")
  local hdr_time = string.match(msg, "^<%d+>(%a%a%a +%d+ %d+:%d+:%d+) ")

  -- vollständige Einträge enden mit \r\n
  local segments, pos = {}, 1
  while true do
    local s, e = string.find(msg, "\r\n", pos, true)
    if not s then break end
    table.insert(segments, string.sub(msg, pos, s - 1))
    pos = e + 1
  end
  local tail = string.sub(msg, pos)
  local truncated = string.find(tail, "%S") ~= nil
  if #segments == 0 then
    table.insert(segments, tail)
    truncated = false
  end

  local out = {}
  for _, seg in ipairs(segments) do
    local entry = string.match(seg, "(%[%d+%.%d+%] AP MAC=.*)$")
    if entry then
      local r = {}
      for k, v in pairs(record) do r[k] = v end
      r["message"] = entry
      r["omada_type"] = "flow"
      if hdr_time then r["syslog_time"] = hdr_time end
      table.insert(out, r)
    end
  end
  if #out == 0 then return 0, ts, record end
  out[1]["batch_first"] = true
  out[1]["batch_entries"] = #out
  if truncated then out[#out]["batch_truncated"] = true end
  return 2, ts, out
end

Rechte setzen:

chmod 644 /etc/fluent-bit/omada_split.lua

Erklärung

  • return 2, ts, out mit einer Liste erzeugt in Fluent Bit mehrere einzelne Datensätze
  • omada_type = flow markiert die Einträge für die spätere Aufteilung
  • syslog_time übernimmt die Uhrzeit aus dem Header, damit die Abweichung je AP sichtbar wird
  • batch_first, batch_entries und batch_truncated sind Kontrollwerte für unvollständige Pakete

💡 Wichtig: Fehlt die Lua-Datei oder ist sie nicht lesbar, startet Fluent Bit gar nicht. Damit fallen auch alle anderen Quellen aus.


Input, Filter und Outputs konfigurieren

nano /etc/fluent-bit/fluent-bit.conf

Inhalt:

# TP-Link Omada: Access Points, Gateway, Controller (Port 5514)
[INPUT]
    Name               syslog
    Listen             0.0.0.0
    Port               5514
    Mode               udp
    Parser             raw-datagram
    Tag                omada
    Buffer_Chunk_Size  64KB
    Buffer_Max_Size    64KB
    Mem_Buf_Limit      10MB
    Source_Address_Key source_address

# AP-Pakete in einzelne Einträge zerlegen
[FILTER]
    Name    lua
    Match   omada
    script  /etc/fluent-bit/omada_split.lua
    call    split_omada

# Client-Verkehr in einen eigenen Stream
[FILTER]
    Name                  rewrite_tag
    Match                 omada
    Rule                  $omada_type ^flow$ omada.flows false
    Emitter_Name          re_emitted_omada_flows
    Emitter_Mem_Buf_Limit 20MB

[OUTPUT]
    Name             http
    Alias            o2_omada_events
    Match            omada
    URI              /api/default/network_tplink_omada/_json
    Host             openobserve.domain.tld
    Port             443
    tls              On
    Format           json
    Json_date_key    _timestamp
    Json_date_format iso8601
    HTTP_User        <BENUTZER>
    HTTP_Passwd      ${O2_PASSWORD}
    compress         gzip

[OUTPUT]
    Name             http
    Alias            o2_omada_flows
    Match            omada.flows
    URI              /api/default/network_tplink_omada_flows/_json
    Host             openobserve.domain.tld
    Port             443
    tls              On
    Format           json
    Json_date_key    _timestamp
    Json_date_format iso8601
    HTTP_User        <BENUTZER>
    HTTP_Passwd      ${O2_PASSWORD}
    compress         gzip

Erklärung

  • Source_Address_Key schreibt die Absender-IP in jeden Datensatz. So ist später sichtbar, welcher AP was gemeldet hat.
  • Die Reihenfolge der Filter ist wichtig: erst Lua, dann rewrite_tag
  • rewrite_tag vergibt dem Client-Verkehr den Tag omada.flows. Das false am Ende verwirft das Original, damit kein Eintrag doppelt ankommt.
  • Match omada greift nur genau auf diesen Tag, nicht auf omada.flows
  • Alias gibt den Outputs lesbare Namen in den Metriken
  • ${O2_PASSWORD} liest das Passwort aus einer Umgebungsvariable, zum Beispiel aus /etc/default/fluent-bit

Das Passwort sollte niemals im Klartext in der Konfiguration stehen oder in Git landen.


Konfiguration prüfen und Fluent Bit starten

Vor jedem Neustart lohnt sich ein Trockenlauf:

/opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.conf --dry-run

Danach neu starten:

systemctl restart fluent-bit

Logs prüfen:

journalctl -u fluent-bit --since "-1min" --no-pager | grep -E 'error|lua|emitter'

Im Log sollte der Emitter re_emitted_omada_flows initialisiert werden, ohne error-Zeilen.


Teil 3: OpenObserve einrichten

In OpenObserve werden die Rohmeldungen per VRL-Funktion in Felder zerlegt. Jede Funktion hängt in einer Pipeline, die den Stream als Quelle und als Ziel verwendet. Jede Funktion schreibt außerdem ein Feld norm_version. Daran lässt sich sofort erkennen, welche Fassung einen Datensatz verarbeitet hat.

Funktion für den Client-Verkehr

Die Funktion wird in OpenObserve unter Pipelines → Funktionen angelegt.

Name:

norm_network_tplink_omada_flows

Inhalt:

# norm_network_tplink_omada_flows
# Ein Client-Traffic-Eintrag eines Access Points je Datensatz:
#   [1792692377.958731137] AP MAC=<ap> MAC SRC=<client> IP SRC=<ip> IP DST=<ip>
#   IP proto=<n> [SPT=<n> DPT=<n>]
# Ergebnis: event = client_flow; event fehlt → Zeile nicht erkannt
.norm_version = "2026-10-22c"
msg = to_string(.message) ?? ""

if exists(.source_address) {
  sa, serr = parse_regex(.source_address, r'(?P<ip>[0-9a-fA-F:.]+):\d+$')
  if serr == null { .ap_ip = sa.ip }
}

p, err = parse_regex(msg, r'^\[(?P<epoch>\d+)\.(?P<frac>\d+)\] AP MAC=(?P<ap>\S+) MAC SRC=(?P<cmac>\S+) IP SRC=(?P<src>\S+) IP DST=(?P<dst>\S+) IP proto=(?P<proto>\d+)(?: SPT=(?P<spt>\d+) DPT=(?P<dpt>\d+))?\s*$')
if err == null {
  .event = "client_flow"
  # Zeitstempel aus der Epoche des AP – die Uhrzeit im Syslog-Header
  # ist bei manchen APs falsch
  ep = to_int(p.epoch) ?? 0
  us = to_int(slice(string!(p.frac) + "000000", 0, 6) ?? "0") ?? 0
  ._timestamp = ep * 1000000 + us
  .ap_mac = downcase(string!(p.ap))
  .client_mac = downcase(string!(p.cmac))
  .src_ip = p.src
  .dst_ip = p.dst
  proto = to_int(p.proto) ?? -1
  .ip_proto = proto
  .proto_name = if proto == 6 { "tcp" } else if proto == 17 { "udp" } else if proto == 1 { "icmp" } else if proto == 2 { "igmp" } else if proto == 58 { "icmpv6" } else { to_string(proto) }
  svc = null
  if p.spt != null {
    spt = to_int(p.spt) ?? 0
    dpt = to_int(p.dpt) ?? 0
    .src_port = spt
    .dst_port = dpt
    # Dienst-Port: der kleinere der beiden Ports
    svc = if dpt <= spt { dpt } else { spt }
    .service_port = svc
    .is_server_reply = spt < dpt
  }
  names = {"20": "ftp-data", "21": "ftp", "22": "ssh", "23": "telnet", "25": "smtp", "53": "dns", "67": "dhcp", "68": "dhcp", "69": "tftp",
           "80": "http", "110": "pop3", "123": "ntp", "137": "netbios", "138": "netbios", "139": "netbios", "143": "imap", "161": "snmp",
           "389": "ldap", "443": "https", "445": "smb", "465": "smtps", "514": "syslog", "554": "rtsp", "587": "submission", "636": "ldaps",
           "853": "dns-over-tls", "993": "imaps", "995": "pop3s", "1400": "sonos", "1883": "mqtt", "1900": "ssdp", "2323": "telnet-alt",
           "3389": "rdp", "3478": "stun", "5060": "sip", "5353": "mdns", "5355": "llmnr", "5683": "coap", "6053": "esphome-api",
           "8006": "proxmox", "8080": "http-alt", "8123": "home-assistant", "8443": "https-alt", "8883": "mqtts", "51820": "wireguard"}
  if svc != null {
    .service = get(names, [to_string(svc)]) ?? null
  } else if proto != 6 && proto != 17 {
    .service = .proto_name
  }

  # Zielbereich
  d = string!(p.dst)
  .dst_scope = if starts_with(d, "224.") || starts_with(d, "239.") || match(d, r'^2(2[4-9]|3\d)\.') || starts_with(d, "ff") {
    "multicast"
  } else if d == "255.255.255.255" || ends_with(d, ".255") {
    "broadcast"
  } else if is_ipv4(d) && (ip_cidr_contains!("10.0.0.0/8", d) || ip_cidr_contains!("172.16.0.0/12", d) || ip_cidr_contains!("192.168.0.0/16", d)) {
    "lan"
  } else if is_ipv4(d) && (ip_cidr_contains!("169.254.0.0/16", d) || ip_cidr_contains!("127.0.0.0/8", d)) {
    "lokal"
  } else if is_ipv6(d) && (ip_cidr_contains!("fc00::/7", d) || ip_cidr_contains!("fe80::/10", d)) {
    "lan"
  } else {
    "extern"
  }
  # zufällige (private) MAC-Adresse: Bit "lokal verwaltet" gesetzt
  first = parse_int(slice(.client_mac, 0, 2) ?? "00", base: 16) ?? 0
  .client_mac_random = mod(first, 4) >= 2

  # Uhrzeit im Syslog-Header gegen Epoche: Abweichung des AP in Stunden
  if exists(.syslog_time) {
    # RFC 3164 kennt kein Jahr → Jahr aus der AP-Epoche ergänzen
    yr = format_timestamp!(from_unix_timestamp!(ep), format: "%Y")
    ht, herr = parse_timestamp(string!(.syslog_time) + " " + yr, "%b %e %H:%M:%S %Y", timezone: "Europe/Berlin")
    if herr == null {
      .ap_clock_offset_h = round((to_unix_timestamp(ht) - ep) / 3600.0)
    }
  }
}
.

Erklärung der Felder

  • _timestamp - Zeitpunkt aus dem Unix-Zeitstempel des AP, nicht aus dem Syslog-Header
  • ap_ip, ap_mac - Access Point, der den Eintrag gemeldet hat
  • client_mac, src_ip, dst_ip - Client und Ziel
  • proto_name - tcp, udp, icmp oder igmp
  • service_port, service - Dienst aus dem kleineren der beiden Ports, da Antwortpakete eines Servers den Dienst-Port als Quellport tragen
  • dst_scope - lan, extern, multicast, broadcast oder lokal
  • client_mac_random - private, zufällige MAC-Adresse, wie sie Smartphones verwenden
  • ap_clock_offset_h - Abweichung der Header-Uhr in Stunden, Sollwert 0

Funktion für Ereignisse mit GeoIP

Die zweite Funktion erkennt Gateway und Controller am Format und ordnet jede Meldung einem Ereignistyp zu. Für Firewall-Blocks mit öffentlicher Quell-IP fragt sie zusätzlich die MaxMind-Tabellen ab.

Name:

norm_network_tplink_omada

Inhalt:

# norm_network_tplink_omada
# Gateway (RFC 3164 mit eingebetteter Zeit) und Controller (RFC-5424-ähnlich)
# Ergebnis: event = firewall_block | firewall_allow | dhcp_lease | dhcp_reject |
#           client_connect | client_disconnect | client_roam | auth_failure |
#           login | omada_event; event fehlt → Kopf nicht erkannt
.norm_version = "2026-10-22c"
raw = to_string(.message) ?? ""
.raw_message = raw

if exists(.source_address) {
  sa, serr = parse_regex(.source_address, r'(?P<ip>[0-9a-fA-F:.]+):\d+$')
  if serr == null { .sender_ip = sa.ip }
}

sev_names = ["emergency", "alert", "critical", "error", "warning", "notice", "info", "debug"]
text = null

gw, gerr = parse_regex(raw, r'^<(?P<pri>\d+)>(?P<hts>\w{3} +\d+ [\d:]+) (?P<host>[^\s:]+): (?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (?P<module>[\w.-]+)<(?P<lvl>\d)>: (?P<msg>.*)$')
if gerr == null {
  .source_type = "gateway"
  .device_name = gw.host
  .module = gw.module
  lvl = to_int(gw.lvl) ?? 6
  .log_level = get(sev_names, [lvl]) ?? null
  ts, terr = parse_timestamp(string!(gw.ts), "%Y-%m-%d %H:%M:%S", timezone: "Europe/Berlin")
  if terr == null { ._timestamp = to_unix_timestamp(ts, unit: "microseconds") }
  .syslog_pri = to_int(gw.pri) ?? null
  text = gw.msg
} else {
  ct, cerr = parse_regex(raw, r'^<(?P<pri>\d+)>1 (?P<ts>\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2})\S* (?P<host>.+?)(?: -){3} ?(?P<msg>.*)$')
  if cerr == null {
    .source_type = "controller"
    .device_name = ct.host
    pri = to_int(ct.pri) ?? 6
    .syslog_pri = pri
    .log_level = get(sev_names, [mod(pri, 8)]) ?? null
    ts, terr = parse_timestamp(replace(string!(ct.ts), "T", " "), "%Y-%m-%d %H:%M:%S", timezone: "Europe/Berlin")
    if terr == null { ._timestamp = to_unix_timestamp(ts, unit: "microseconds") }
    text = ct.msg
  }
}

if text != null {
  t = string!(text)
  tg, tgerr = parse_regex(t, r'^\[(?P<tag>[A-Z]+)\](?P<rest>.*)$')
  if tgerr == null {
    .omada_tag = tg.tag
    t = string!(tg.rest)
  }
  t = strip_whitespace(t)
  .message = t

  # Client: [client:<Name>:<MAC>] oder [client:<MAC>]
  cl, clerr = parse_regex(t, r'\[client:(?:(?P<name>[^\]]*?):)?(?P<mac>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]')
  if clerr == null {
    .client_mac = downcase(replace(string!(cl.mac), "-", ":"))
    if cl.name != null && cl.name != "" && downcase(replace(string!(cl.name), "-", ":")) != .client_mac {
      .client_name = cl.name
    }
  }
  ipm, iperr = parse_regex(t, r'\(IP: (?P<ip>[0-9a-fA-F:.]+)\)')
  if iperr == null { .client_ip = ipm.ip }

  if .omada_tag == "ACL" {
    # Firewall (ACL)
    kv = parse_key_value(t, key_value_delimiter: "=", field_delimiter: ",") ?? {}
    act = downcase(to_string(kv.ACTION) ?? "")
    .event = if act == "block" || act == "deny" || act == "drop" { "firewall_block" } else { "firewall_allow" }
    .fw_action = act
    .fw_rule_id = kv.DESC
    .gateway_mac = downcase(replace(to_string(kv.GATEWAY) ?? "", "-", ":"))
    .src_mac = downcase(to_string(kv.SRC_MAC) ?? "")
    .dst_mac = downcase(to_string(kv.DST_MAC) ?? "")
    .src_ip = kv.SRC
    .dst_ip = kv.DST
    .ip_proto = downcase(to_string(kv.PROTO) ?? "")
    .src_port = to_int(kv.Sport) ?? null
    .dst_port = to_int(kv.Dport) ?? null
    sip = to_string(kv.SRC) ?? ""
    priv4 = ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "127.0.0.0/8", "169.254.0.0/16",
             "100.64.0.0/10", "0.0.0.0/8", "224.0.0.0/4", "240.0.0.0/4"]
    priv6 = ["fc00::/7", "fe80::/10", "::1/128", "ff00::/8", "::/128"]
    pub = (is_ipv4(sip) && !(ip_cidr_contains(priv4, sip) ?? true)) || (is_ipv6(sip) && !(ip_cidr_contains(priv6, sip) ?? true))
    .src_scope = if pub { "extern" } else { "lan" }
    del(.client_ip)

    # GeoIP/ASN der öffentlichen Quelle (MaxMind), fehlertolerant
    if pub {
      city, gerr = get_enrichment_table_record("maxmind_city", {"ip": sip})
      if gerr == null {
        .geo_latitude  = city.latitude
        .geo_longitude = city.longitude
        country = city.country_name
        if country == null { country = city.country }
        if country == null { country = city.country_names.de }
        if country == null { country = city.country_names.en }
        if country != null && country != "" { .geo_country = country }
        code = city.country_iso_code
        if code == null { code = city.country_code }
        if code == null { code = city.iso_code }
        if code != null { .geo_country_code = upcase(to_string(code) ?? "") }
        cty = city.city_name
        if cty == null { cty = city.city }
        if cty == null { cty = city.city_names.de }
        if cty == null { cty = city.city_names.en }
        if cty != null && cty != "" { .geo_city = cty }
        # .geo_debug = encode_json(city)
      }
      asn, aerr = get_enrichment_table_record("maxmind_asn", {"ip": sip})
      if aerr == null {
        .geo_asn = to_int(asn.autonomous_system_number) ?? null
        .geo_org = asn.autonomous_system_organization
      }
    }
  } else if contains(t, "DHCP Server allocated") {
    .event = "dhcp_lease"
    dl, dlerr = parse_regex(t, r'allocated IP address (?P<ip>[0-9a-fA-F:.]+)')
    if dlerr == null { .client_ip = dl.ip }
  } else if contains(t, "DHCP Server rejected") {
    .event = "dhcp_reject"
  } else if contains(t, "is roaming from") {
    .event = "client_roam"
    .connection_type = "wireless"
    rm, rerr = parse_regex(t, r'is roaming from \[ap:(?P<n1>.*?):(?P<m1>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]\[Channel (?P<c1>\d+)\] to \[ap:(?P<n2>.*?):(?P<m2>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]\[Channel (?P<c2>\d+)\](?: with SSID "(?P<ssid>[^"]*)")?')
    if rerr == null {
      .ap_name_from = rm.n1
      .ap_mac_from = downcase(replace(string!(rm.m1), "-", ":"))
      .channel_from = to_int(rm.c1) ?? null
      .ap_name = rm.n2
      .ap_mac = downcase(replace(string!(rm.m2), "-", ":"))
      .channel = to_int(rm.c2) ?? null
      .ssid = rm.ssid
    }
  } else if contains(t, "went online") {
    .event = "client_connect"
    w, werr = parse_regex(t, r'went online on \[ap:(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\](?: with SSID "(?P<ssid>[^"]*)")?(?: on channel (?P<ch>\d+))?')
    if werr == null {
      .connection_type = "wireless"
      .ap_name = w.n
      .ap_mac = downcase(replace(string!(w.m), "-", ":"))
      .ssid = w.ssid
      if w.ch != null { .channel = to_int(w.ch) ?? null }
    } else {
      sw, swerr = parse_regex(t, r'went online on \[switch:(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\](?: on (?P<net>.+?) network)?')
      if swerr == null {
        .connection_type = "wired"
        .switch_name = sw.n
        .switch_mac = downcase(replace(string!(sw.m), "-", ":"))
        .network = sw.net
      }
    }
  } else if contains(t, "went offline") {
    .event = "client_disconnect"
    of, oferr = parse_regex(t, r'went offline from (?:network )?"(?P<net>[^"]*)" on \[(?P<dt>ap|switch):(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]')
    if oferr == null {
      if of.dt == "ap" {
        .connection_type = "wireless"
        .ssid = of.net
        .ap_name = of.n
        .ap_mac = downcase(replace(string!(of.m), "-", ":"))
      } else {
        .connection_type = "wired"
        .network = of.net
        .switch_name = of.n
        .switch_mac = downcase(replace(string!(of.m), "-", ":"))
      }
    }
    # Verbindungsdauer "2d3h49m" → Minuten, Datenmenge "12.5MBytes" → Bytes
    cm, cmerr = parse_regex(t, r'connected time:\s*(?:(?P<d>\d+)d)?\s*(?:(?P<h>\d+)h)?\s*(?:(?P<m>\d+)m)?\s*(?:(?P<s>\d+)s)?')
    if cmerr == null {
      mins = (to_int(cm.d) ?? 0) * 1440 + (to_int(cm.h) ?? 0) * 60 + (to_int(cm.m) ?? 0)
      .connected_minutes = mins
    }
    tb, tberr = parse_regex(t, r'traffic:\s*(?P<v>[\d.]+)\s*(?P<u>[KMGT]?)B')
    if tberr == null {
      f = to_float(tb.v) ?? 0.0
      u = string!(tb.u)
      mult = if u == "K" { 1024.0 } else if u == "M" { 1048576.0 } else if u == "G" { 1073741824.0 } else if u == "T" { 1099511627776.0 } else { 1.0 }
      .traffic_bytes = to_int(f * mult)
    }
  } else {
    tl = downcase(t)
    .event = if match(tl, r'fail|denied|invalid|wrong password|incorrect|reject') {
      "auth_failure"
    } else if match(tl, r'log(ged)? ?in|log(ged)? ?out') {
      "login"
    } else {
      "omada_event"
    }
  }
}
.

Erklärung der Ereignisse

  • firewall_block - vom Gateway per ACL verworfene Verbindung, mit src_ip, dst_ip, dst_port, fw_rule_id und Geo-Feldern
  • dhcp_lease, dhcp_reject - DHCP-Vergabe bzw. Ablehnung mit client_mac und client_ip
  • client_connect, client_disconnect - Client online/offline mit client_name, ap_name oder switch_name, ssid oder network
  • client_roam - Wechsel zwischen APs mit ap_name_from, ap_name, channel_from und channel
  • omada_event - nicht zugeordnete Meldung, Kandidat für ein neues Muster

💡

Wichtig: get_enrichment_table_record wird bewusst ohne ! aufgerufen. Mit ! bricht die Funktion bei jeder IP ohne MaxMind-Treffer ab, und die Pipeline schreibt für jeden Datensatz einen Fehler.


Pipelines anlegen

Für jeden Stream wird unter Pipelines eine Echtzeit-Pipeline angelegt:

  • pl_network_tplink_omada_flows - Quelle und Ziel network_tplink_omada_flows, dazwischen norm_network_tplink_omada_flows
  • pl_network_tplink_omada - Quelle und Ziel network_tplink_omada, dazwischen norm_network_tplink_omada

Nach jeder Änderung an einer Funktion sollte die zugehörige Pipeline einmal geöffnet und gespeichert werden. So verwendet sie sicher die neue Fassung.


Schema-Seeds einspielen

Felder wie channel_from oder geo_asn tauchen nur selten auf. Bis sie das erste Mal vorkommen, kennt OpenObserve sie nicht, und Dashboard-Panels melden „No field named …“. Ein Seed ist ein einzelner Datensatz mit allen Feldern im richtigen Typ.

nano seed_network_tplink_omada.json

Inhalt:

[{"event": "schema_seed", "norm_version": "", "message": "", "raw_message": "", "source_address": "", "sender_ip": "", "source_type": "", "device_name": "", "module": "", "log_level": "", "syslog_pri": 0, "omada_tag": "", "client_mac": "", "client_ip": "", "client_name": "", "connection_type": "", "ap_name": "", "ap_mac": "", "ap_name_from": "", "ap_mac_from": "", "channel": 0, "channel_from": 0, "ssid": "", "switch_name": "", "switch_mac": "", "network": "", "connected_minutes": 0, "traffic_bytes": 0, "fw_action": "", "fw_rule_id": "", "gateway_mac": "", "src_mac": "", "dst_mac": "", "src_ip": "", "dst_ip": "", "ip_proto": "", "src_port": 0, "dst_port": 0, "src_scope": "", "geo_country": "", "geo_country_code": "", "geo_city": "", "geo_latitude": 0.0, "geo_longitude": 0.0, "geo_asn": 0, "geo_org": ""}]
nano seed_network_tplink_omada_flows.json

Inhalt:

[{"event": "schema_seed", "norm_version": "", "message": "", "source_address": "", "ap_ip": "", "ap_mac": "", "client_mac": "", "client_mac_random": false, "src_ip": "", "dst_ip": "", "ip_proto": 0, "proto_name": "", "src_port": 0, "dst_port": 0, "service_port": 0, "service": "", "is_server_reply": false, "dst_scope": "", "ap_clock_offset_h": 0.0, "syslog_time": "", "omada_type": "", "batch_first": false, "batch_entries": 0, "batch_truncated": false}]

Eingespielt werden beide Seeds über die Ingest-API:

read -rsp 'OpenObserve-Passwort: ' O2_PASSWORD; echo

for s in network_tplink_omada network_tplink_omada_flows; do
  curl -s -u "<BENUTZER>:${O2_PASSWORD}" \
       -H 'Content-Type: application/json' \
       --data-binary @"seed_${s}.json" \
       "https://openobserve.domain.tld/api/default/${s}/_json"
  echo
done
unset O2_PASSWORD

Die Antwort muss "successful":1 enthalten. Da der Seed event = 'schema_seed' trägt, filtern ihn alle Dashboard-Abfragen heraus.


Aufbewahrungszeit setzen

Unter Streams wird für network_tplink_omada_flows eine kurze Aufbewahrungszeit eingestellt, zum Beispiel 31 Tage. Bei rund 1 Million Einträgen pro Tag hält das den Speicherbedarf überschaubar. Der Stream network_tplink_omada kann deutlich länger aufbewahrt werden.


Teil 4: Dashboard aufbauen

Das Dashboard liest beide Streams. Bei mir besteht es aus 42 Panels in sechs Tabs:

Tab Inhalt
Überblick Kennzahlen (Einträge, Clients, APs, externe Ziele, Firewall-Blocks), Verkehr je AP, Ereignisse nach Typ, AP-Tabelle mit Uhr-Abweichung
Clients Top-Clients, Clients je AP, Anteil zufälliger MACs, Clients an mehreren APs
Ziele & Dienste häufigste Dienste, externe Ziele, Server im LAN, unsichere Dienste, DNS am lokalen Server vorbei
Verbindungen Online/Offline/Roaming über Zeit, Client-Verzeichnis, Roaming-Historie mit Kanälen, häufig getrennte Clients
Firewall Weltkarte, Blocks nach Land und Provider, Top blockierte Quellen, blockierte Ziele mit Regel-ID
Ereignisse letzte Meldungen, DHCP-Zuordnungen, Anmeldefehler, nicht zerlegte Meldungen

Die Panels verwenden eigene SQL-Abfragen (Custom SQL). Drei Beispiele zeigen das Prinzip.

Weltkarte der Firewall-Blocks

Paneltyp: Geo Map

SELECT geo_latitude AS latitude, geo_longitude AS longitude, COUNT(*) AS weight
FROM "network_tplink_omada"
WHERE event = 'firewall_block' AND geo_latitude IS NOT NULL
GROUP BY latitude, longitude

Im Panel werden latitude, longitude und weight den gleichnamigen Feldern der Karte zugeordnet. Die Punktgröße zeigt dann die Anzahl der Blocks.

Top blockierte Quellen

Paneltyp: Table

SELECT src_ip, MAX(geo_country) AS land, MAX(geo_city) AS stadt, MAX(geo_org) AS provider,
       COUNT(*) AS blocks, COUNT(DISTINCT src_port) AS verbindungen,
       to_timestamp_micros(MAX(_timestamp)) AS zuletzt
FROM "network_tplink_omada"
WHERE event = 'firewall_block'
GROUP BY src_ip
ORDER BY blocks DESC
LIMIT 50

Mehrere Blocks mit demselben Quellport sind TCP-Wiederholungen derselben Verbindung. Deshalb zählt verbindungen die verschiedenen Quellports.

Client-Verzeichnis

Paneltyp: Table

SELECT client_mac, MAX(client_name) AS name, MAX(client_ip) AS ip,
       MAX(COALESCE(ap_name, switch_name)) AS anschluss,
       MAX(COALESCE(ssid, network)) AS netz,
       to_timestamp_micros(MAX(_timestamp)) AS zuletzt
FROM "network_tplink_omada"
WHERE client_mac IS NOT NULL
  AND event IN ('client_connect', 'client_disconnect', 'client_roam', 'dhcp_lease')
GROUP BY client_mac
ORDER BY zuletzt DESC

Das Verzeichnis verbindet die Namen aus den Controller-Meldungen mit den IP-Adressen aus DHCP. So entsteht eine Liste aller Geräte mit Name, IP und letztem Anschlusspunkt.

💡 Wichtig: DHCP-Vergaben melden Gateway und Controller doppelt. In DHCP-Auswertungen sollte deshalb zusätzlich source_type = 'gateway' gefiltert werden.


Fehlersuche

Fluent Bit startet nicht

Im Log steht:

[filter:lua:lua.2] cannot access script '/etc/fluent-bit/omada_split.lua'
[engine] filter initialization failed

Typische Ursachen:

  • Lua-Datei fehlt oder liegt im falschen Verzeichnis
  • Fluent Bit läuft nicht als root und darf die Datei nicht lesen

Prüfen:

ls -l /etc/fluent-bit/omada_split.lua
systemctl show fluent-bit -p User

Pro AP-Paket kommt nur ein Eintrag an

Wahrscheinliche Ursache: Der Parser verwendet .* statt [\s\S]+ und endet beim ersten Zeilenumbruch.

Prüfen lässt sich das direkt in OpenObserve:

SELECT ap_ip, AVG(batch_entries) AS eintraege_je_paket, COUNT(*) AS pakete
FROM "network_tplink_omada_flows"
WHERE batch_first = true
GROUP BY ap_ip

Erwartet werden etwa 10 bis 12 Einträge pro Paket.

Pakete erscheinen im Mitschnitt abgeschnitten

Wer die AP-Pakete mit tcpdump prüft, sieht mit diesem Filter nur 1472 Byte pro Paket und einen abgeschnittenen letzten Eintrag:

tcpdump -i any -nn -s 0 -w /tmp/omada.pcap udp port 5514

Das ist kein Datenverlust. Die Pakete werden IP-fragmentiert, und nur das erste Fragment trägt einen UDP-Header. Der Filter udp port 5514 verwirft deshalb alle Folgefragmente. Der Kernel setzt die Fragmente korrekt zusammen, und Fluent Bit erhält vollständige Pakete.

Besser ist ein Filter auf die IP-Adresse des Access Points:

tcpdump -i any -nn -s 0 -w /tmp/omada.pcap host <AP-IP>

Uhrzeit der APs weicht ab

Im Dashboard zeigt die Spalte ap_clock_offset_h eine Abweichung von einer Stunde. Die Daten selbst sind korrekt, weil der Zeitstempel aus dem Eintrag stammt. Die Ursache ist eine falsche Zeitzonen- oder Sommerzeit-Einstellung am AP.

Dashboard meldet „No field named …“

Der Schema-Seed wurde noch nicht eingespielt. Das betrifft vor allem Felder, die selten vorkommen, etwa channel_from, geo_asn oder batch_truncated.

Geo-Felder bleiben leer

Typische Ursachen:

  • Die Tabellen maxmind_city und maxmind_asn fehlen in OpenObserve
  • Die Pipeline verwendet noch eine alte Fassung der Funktion
  • Die Länderfelder heißen in der eigenen MaxMind-Tabelle anders

Im letzten Fall wird in der Funktion die Zeile # .geo_debug = encode_json(city) einkommentiert. Das Feld geo_debug zeigt dann die tatsächlichen Schlüssel.

Meldungen landen als omada_event

Der Controller hat eine Meldung geschickt, für die es noch kein Muster gibt. Die Tabelle „Unbekannte Meldungen“ im Dashboard zeigt diese Fälle. Daraus lässt sich ein neuer Zweig in der Funktion ableiten.


Schnelle Admin-Shortlist (Daily Use)

Für den Betrieb sehr nützlich:

# Konfiguration prüfen, ohne Fluent Bit neu zu starten
/opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.conf --dry-run

# Fehler und Warnungen der letzten Minuten
journalctl -u fluent-bit --since "-10min" --no-pager | grep -iE 'error|warn'

# Kommen Omada-Pakete überhaupt an? (je Absender-IP)
timeout 60 tcpdump -i any -nn host <AP-IP> or host <GATEWAY-IP> | awk '{print $3}' | sort | uniq -c

Prüfen, ob die Pipeline die aktuelle Funktion verwendet:

SELECT norm_version, COUNT(*) AS anzahl
FROM "network_tplink_omada"
GROUP BY norm_version

Fazit

Mit Fluent Bit, einem kleinen Lua-Filter und zwei VRL-Funktionen lässt sich das Syslog von TP-Link Omada vollständig in OpenObserve auswerten. Fluent Bit übernimmt den Empfang, zerlegt die gebündelten AP-Pakete und trennt Client-Verkehr von Ereignissen. OpenObserve zerlegt die Meldungen in Felder, reichert Firewall-Blocks mit GeoIP an und stellt alles in einem Dashboard dar.

Die wichtigste Erkenntnis aus dem Aufbau: Jede Annahme über das Format sollte gegen echte Daten geprüft werden. Bei mir waren die gebündelten AP-Pakete, die falsche AP-Uhrzeit und das ungültige RFC 5424 des Controllers erst im Mitschnitt sichtbar. Mehrere Muster für die Controller-Meldungen haben sich erst an einem 15-minütigen Mitschnitt mit echtem Verkehr ergeben.

Schon nach wenigen Minuten zeigt das Dashboard Dinge, die im Controller untergehen: Geräte, die DNS am lokalen Server vorbei auflösen, unverschlüsselte Verbindungen ins Internet oder Scanner, die an der Firewall abprallen. Damit entsteht eine solide Grundlage für Alarme und eine langfristige Auswertung des eigenen Netzes.