Zum Inhalt springen
actor-ts
Deutsch

UDP

UdpSocketActor umschließt einen UDP-Socket — verbindungslos, keine ACKs, keine Retries, paketorientiert. Nimm ihn, wenn Best-Effort- Zustellung in Ordnung ist und Latenz wichtiger ist als Zuverlässigkeit.

import { ActorSystem, Props, UdpSocketActor } from 'actor-ts';


const udp = system.spawn(
  Props.create(() => new UdpSocketActor({
    bindHost: '0.0.0.0',
    bindPort: 8125,         // bind zum Empfangen
  })),
  'udp',
);


// An einen Remote-Endpoint senden:
udp.tell({
  kind:    'send',
  host:    'collector.example.com',
  port:    8125,
  payload: new TextEncoder().encode('cpu.usage:0.42|g'),
});


// Eingehende Pakete subscribieren:
udp.tell({ kind: 'subscribe', subscriber: packetHandler });

Settings

Abschnitt betitelt „Settings“
interface UdpSocketActorSettings extends BrokerCommonSettings {
  bindHost?: string;             // Default '0.0.0.0'; '' deaktiviert Empfang
  bindPort?: number;             // 0 = zufällig; weglassen deaktiviert Empfang
  reuseAddr?: boolean;           // Default false
  ipv6Only?: boolean;            // Default false
  multicast?: {
    address:   string;
    interface?: string;
    ttl?:      number;
    loopback?: boolean;
  };
}

Nur Senden

Abschnitt betitelt „Nur Senden“
new UdpSocketActor({ bindHost: '', bindPort: undefined });   // ✓ nur senden

Ohne bindPort lauscht der Actor nicht — er ist ein reiner Sender. Nützlich für einseitige Telemetrie (statsd, syslog).

Eingehende Pakete

Abschnitt betitelt „Eingehende Pakete“
class PacketHandler extends Actor<UdpInbound> {
  override onReceive(msg: UdpInbound): void {
    if (msg.kind === 'packet') {
      // msg.payload — Uint8Array
      // msg.from   — { host, port } des Senders
      this.handleDatagram(msg.payload, msg.from);
    }
  }
}

Jedes Paket ist eine logische Nachricht — UDP erhält Paketgrenzen (anders als TCPs Byte-Stream).

Multicast

Abschnitt betitelt „Multicast“
new UdpSocketActor({
  bindPort: 5353,
  multicast: {
    address: '224.0.0.251',     // mDNS
    interface: '0.0.0.0',
    ttl: 1,
    loopback: false,
  },
});

Tritt der Multicast-Gruppe auf dem angegebenen Interface bei. Nützlich für Service Discovery (mDNS, SSDP), Statusverteilung im LAN.

Für routbares Multicast über Cluster-Knoten muss das Netz Multicast erlauben (die meisten Cloud-Netze blockieren es; viele On-prem-Netze auch).

Wann UDP

Abschnitt betitelt „Wann UDP“

Drei gute Einsatzfälle:

  1. Telemetrie — Metriken an einen Collector senden (statsd, DogStatsD). Verlust eines Pakets ist akzeptabel; Latenz zählt.
  2. Service Discovery im LAN — mDNS / SSDP / proprietäre Broadcast-Schemata.
  3. Hochfrequente Low-Stakes-Daten — Spielpositionen, Sensor-Streams, bei denen das nächste Paket das vorherige ersetzt.

Nicht die richtige Form für:

  • Alles, was Zustellgarantie braucht — nimm TCP oder ein höherrangiges, zuverlässiges Protokoll.
  • Alles, was Reihenfolge braucht — UDP-Pakete kommen in beliebiger Reihenfolge an.
  • Alles, das größer als die MTU ist — Pakete >1500 Bytes fragmentieren + können leichter verloren gehen.

Wohin als Nächstes

Abschnitt betitelt „Wohin als Nächstes“