Zum Inhalt springen
Deutsch

Cluster-Sicherheit

Der Cluster-Transport ist standardmäßig unauthentifiziertes Plain-TCP. In Ordnung innerhalb eines privaten Netzwerks, in dem jeder Host bereits vertrauenswürdig ist. Nicht in Ordnung irgendwo sonst — öffentliches Internet, Multi-Tenant-K8s, nicht vertrauenswürdige Vermittler.

Diese Seite ist die How-to zur Absicherung des Cluster-Transports. Für den operativen Kontext siehe Operations — Cluster-Sicherheit.

BedrohungMaßnahme
LauschangriffTLS auf dem Cluster-Transport
MITM (Abfangen + Verändern)TLS + Zertifikatsprüfung
Unautorisierter Join (jeder mit Port-Zugriff kann joinen)mTLS (zertifikatsbasierte Peer-Authentifizierung)
Kompromittiertes Zertifikat (für gestohlene Identität ausgestellt)Cert-Rotation + Revocation
Replay eines mitgeschnittenen Gossip-FramesTLS, dazu die Sequence pro Sender, die jeder Cluster durchsetzt
Ein Mitglied spricht im Payload für einen anderen NodeFramework-Handler halten die im Payload behauptete Identität gegen den Peer der Verbindung — siehe was eine Replica ihren Peers glaubt
Ein Peer adressiert einen Framework-Aktor (/system/…) namentlichWird bedingungslos abgelehnt: Framework-Aktoren sind nur über den Pro-Pfad-Handler erreichbar, den jeder registriert — an der Cluster-Verbindung wie am ClusterClientReceptionist
Ein Peer adressiert beliebige Anwendungsaktoren namentlichactor-ts.remote.untrusted-mode = true plus trusted-selection-paths — siehe Konfiguration

Für die /system-Zeile ist nichts zu konfigurieren, und sie lässt sich nicht abschalten. Ein envelope trägt den Pfad, den der Absender gewählt hat, und ihn gegen den Aktor-Baum aufzulösen ist die eine Stelle, an der eine Gegenstelle das Ziel wählt — einen Coordinator, einen Singleton-Manager oder den PubSub-Mediator so zu erreichen ging an dem Handler vorbei, der gewusst hätte, über welche Verbindung das Frame kam. Die Zeile darunter ist dieselbe Frage für /user, und dort gehört die Antwort dem Deployment: einen Anwendungsaktor zu benennen ist genau die Art, wie eine ActorRef über Knoten hinweg funktioniert, also bleibt das offen, bis ihr es einengt. Ablehnungen landen auf cluster_envelope_refusals_total{reason, frame}.

mTLS ist das, was die Zeile zum Sprechen für einen anderen Node überhaupt trägt, und nicht etwas, das sie doppelt: eine Behauptung gegen den Peer der Verbindung zu halten, ist erst dann etwas wert, wenn dieser Peer authentifiziert ist.

Diese Zeile gilt auch für das In-Process-Worker-Mesh — den einzigen Pfad, auf dem sie früher nicht hielt: Der WorkerBroker adressiert jeden Frame auf den MessagePort um, über den er hereinkam, ein Worker kann also nicht die Adresse eines Geschwisters in from schreiben. Dafür ist nichts zu konfigurieren, und kein mTLS trägt es — der Host vergibt jedem Worker seine Adresse und hält dessen Port, die Bindung ist also strukturell statt authentifiziert.

Eine Behauptung lehnt der Cluster-Transport mit wie ohne Zertifikat ab: Ein Node lehnt einen Peer ab, der die eigene Adresse des Nodes beansprucht, und schließt die Verbindung.

import { TcpTransport, TcpTransportOptions, NodeAddress, Cluster, ClusterOptions } from 'actor-ts/cluster';
import fs from 'node:fs';
const transportOptions = TcpTransportOptions.create().withTls({
cert: fs.readFileSync('./tls/cluster.crt'),
key: fs.readFileSync('./tls/cluster.key'),
ca: fs.readFileSync('./tls/ca.crt'),
rejectUnauthorized: true,
});
const transport = new TcpTransport(
NodeAddress.parse('my-app@10.0.0.5:2552'),
system.log,
transportOptions,
);
const clusterOptions = ClusterOptions.create()
.withHost('10.0.0.5')
.withPort(2552)
.withSeeds(seeds)
.withTransport(transport);
await Cluster.join(
system,
clusterOptions,
);

TLS-gewrapptes TCP, alles-oder-nichts pro Cluster. Jeder Node verwendet dieselbe TLS-Konfiguration; gemischtes Plain + TLS funktioniert nicht. Die Adresse des Transports ist die eigene des Nodes — my-app ist der Name des Actor-Systems, und withHost / withPort wiederholen seinen Host und Port. Ein Node, der wie hier über eine IP adressiert wird, wird gegen ein IP-SAN in seinem Zertifikat geprüft, das das Cert-Layout unten dort einträgt.

Das Minimum:

  • Ein CA-Cert + privater Schlüssel (zum Signieren von Per-Node-Certs).
  • Ein Per-Node-Cert + privater Schlüssel (von der CA signiert).
Terminal-Fenster
# CA erzeugen (einmalig):
openssl req -x509 -newkey rsa:4096 -keyout ca.key -out ca.crt -days 3650 -nodes \
-subj "/CN=actor-ts-ca"
# Per-Node-Cert, mit jeder Adresse, unter der der Node gewählt wird:
openssl req -newkey rsa:4096 -keyout node-1.key -out node-1.csr -nodes \
-subj "/CN=node-1.cluster.local"
printf 'subjectAltName=IP:10.0.0.5,DNS:node-1.cluster.local\n' > node-1.ext
openssl x509 -req -in node-1.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
-out node-1.crt -days 365 -extfile node-1.ext

Die Subject Alternative Names sind das, was ein Peer prüft. Ein Node, der über ein IP-Literal gewählt wird, wird gegen einen IP:-Eintrag geprüft — für eine IP wird kein Servername angekündigt, es gibt also nichts anderes zu prüfen —, einer, der über einen Hostnamen gewählt wird, gegen einen DNS:-Eintrag.

Jeder Node lädt:

  • Sein eigenes Cert + Key.
  • Das CA-Cert (um die Certs der Peers zu verifizieren).
{
cert: fs.readFileSync('./tls/this-node.crt'),
key: fs.readFileSync('./tls/this-node.key'),
ca: fs.readFileSync('./tls/ca.crt'),
rejectUnauthorized: true, // ← Peers ohne gültiges Cert ablehnen
}

Mit rejectUnauthorized: true + einer gemeinsamen CA verlangt jede Verbindung von beiden Seiten ein gültiges, von der CA signiertes Cert. Keine anonymen Joins; kein Plain-Text-Fallback.

cert-manager + Secrets ist das Standardmuster:

# Cert verwaltet von cert-manager:
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
name: actor-ts-cluster
spec:
secretName: actor-ts-cluster-tls
issuerRef:
name: actor-ts-ca
kind: ClusterIssuer
commonName: actor-ts
dnsNames:
- actor-ts-cluster.svc
duration: 8760h
renewBefore: 720h
---
# Pod mounted das TLS-Secret:
apiVersion: v1
kind: Pod
spec:
containers:
- name: app
volumeMounts:
- name: tls
mountPath: /etc/tls
readOnly: true
volumes:
- name: tls
secret:
secretName: actor-ts-cluster-tls

cert-manager erneuert Certs automatisch; Pods laden sie beim Neustart neu. Für Cert-Rotation ohne Downtime nutze einen Rolling Restart, nachdem neue Certs bereitliegen.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: cluster-internal-only
spec:
podSelector:
matchLabels:
app: actor-ts
ingress:
- from:
- podSelector:
matchLabels:
app: actor-ts
ports:
- protocol: TCP
port: 2552

Nur app=actor-ts-Pods können Port 2552 erreichen. Kombiniert mit mTLS sind das zwei unabhängige Schichten.

TLS fügt ~5-15 % Overhead pro Byte auf dem Transport hinzu. Für typische Actor-Nachrichten (kleine Payloads, moderater Durchsatz) unbemerkbar. Für hochfrequenten Cluster-Verkehr messbar, aber selten der Flaschenhals.