TLS everywhere
Produktions-sicher heißt TLS auf jeder Netzwerkoberfläche. Jede Komponente des Frameworks hat ihre eigene TLS-Konfiguration; diese Seite ist der Katalog, wo TLS zu aktivieren ist und welches Cert-Material jede Komponente braucht.
Cluster-Transport
Abschnitt betitelt „Cluster-Transport“import { TcpTransport, Cluster, ClusterOptions } from 'actor-ts/cluster';
const transport = new TcpTransport(self, log, { tls: { cert: fs.readFileSync('./tls/cluster.crt'), key: fs.readFileSync('./tls/cluster.key'), ca: fs.readFileSync('./tls/ca.crt'), rejectUnauthorized: true, },});
const clusterOptions = ClusterOptions.create() .withHost(host) .withPort(port) .withSeeds(seeds) .withTransport(transport);await Cluster.join(system, clusterOptions);Mutually authenticated TLS zwischen Cluster-Nodes. Siehe
Cluster-Sicherheit
für die vollständige Diskussion und Client-Zertifikate
für die Regel, an der die ca jedes Listeners gemessen wird.
Jedes Feld hier nimmt das Zertifikatsmaterial selbst entgegen, niemals einen Pfad darauf — deshalb liest das Beispiel die Dateien selbst ein. Nichts im Transport greift auf das Dateisystem zu, und weder Bun noch Node noch Deno akzeptiert in diesen Feldern einen Dateinamen.
cert und key sind auf einem Listener nur gemeinsam gültig.
Ein tls-Objekt mit nur einem von beiden brachte den Listener
bisher zu dem Schluss „kein TLS”, und er lauschte im Klartext —
während dieselbe Konfiguration weiterhin über TLS hinauswählte. Der
Cluster bildete sich also, und nichts sah falsch aus. Diese
Kombination wird jetzt beim Bind abgelehnt; ein so
fehlkonfigurierter Knoten degradiert damit nicht mehr still,
sondern scheitert laut.
Nicht überspringen — auch in internen Netzwerken gilt Defense in Depth.
HTTP-Server
Abschnitt betitelt „HTTP-Server“TLS ist eine Server-Option und liest sich deshalb auf jedem Backend gleich — Fastify, Express und Hono —, welches auch immer gemountet ist:
import { readFileSync } from 'node:fs';import { HttpExtensionId, HttpServerOptions } from 'actor-ts/http';
const serverOptions = HttpServerOptions.create() .withTls({ cert: readFileSync('./tls/http.crt'), key: readFileSync('./tls/http.key'), });
await system.extension(HttpExtensionId) .newServerAt('0.0.0.0', 8443) .withServerOptions(serverOptions) .bind(routes);Aus der Konfigurationsdatei sind dieselben Felder Pfade —
actor-ts.http.server.tls.cert-file, key-file und ca-file, einmal bei
bind() gelesen. Client-Zertifikate (requestClientCert) folgen der Regel
unter Client-Zertifikate; HTTP/2 ist withHttp2()
auf Fastify und Hono, während Express TLS bedient, HTTP/2 aber ablehnt. Die
Details pro Backend und Runtime stehen unter
TLS und HTTP/2.
Für HTTPS auf der Anwendungsebene. Oft am Load Balancer terminiert stattdessen — in K8s übernimmt Service/Ingress TLS, die App spricht intern Plain-HTTP. Wählen je nach Form deiner Infrastruktur.
Die eine Stelle, an der die eigene https-Factory-Option von Fastify noch zählt,
ist ein Fastify-Backend, das du selbst konstruierst: Fastify nimmt das Zertifikat
bei der Konstruktion, eine selbst gebaute Instanz braucht es also dann.
fastifyFactoryOptions(serverOptions) baut diese Option — und http2 sowie die
Größengrenzen — aus denselben Server-Optionen, beide Ebenen stimmen also
überein; ein selbst gebautes Fastify ohne TLS, dem withTls(...) übergeben wird,
wird bei bind() abgelehnt, statt reines HTTP zu servieren:
import { FastifyBackend, fastifyFactoryOptions } from 'actor-ts/http';
const backend = new FastifyBackend({ logger: false, ...fastifyFactoryOptions(serverOptions), // { https: { cert, key, … } }});
await system.extension(HttpExtensionId) .newServerAt('0.0.0.0', 8443) .useBackend(backend) .withServerOptions(serverOptions) .bind(routes);Client-Zertifikate
Abschnitt betitelt „Client-Zertifikate“Jeder Listener, der ein Client-Zertifikat verlangen kann — der HTTP-Server auf jedem Backend, der Cluster-Transport und der TCP-Listener —, misst diese Forderung an einer Regel und lehnt beim Bind ab, was ihr nicht genügt:
- Das Zertifikat wird gegen die
cageprüft, die du konfigurierst. Auf dem HTTP-Server stelltrequestClientCert: truedie Forderung; auf dem Cluster-Transport und dem TCP-Listener stellt sie einecavon sich aus. Eine Forderung ohnecawird abgelehnt. - Eine
camuss ein Zertifikat enthalten. Ein leerer oder nur aus Leerzeichen bestehender String, ein leeres Byte-Array, ein leeres Array,nulloder eineca-file, die auf eine leere Datei zeigt, wird abgelehnt, mit dem Namen des Felds, was immerrequestClientCertsagt. So sieht ein fehlendes Secret aus, wenn es ankommt — keine Bitte um einseitiges TLS; das istrequestClientCert: false, auf jedem Listener. - Auf Deno wird die Forderung abgelehnt.
Deno.servehat keine Option für Client-Zertifikate, und Denosnode:httpsnimmtrequestCertan, ohne es durchzusetzen; Hono, Fastify und Express lehnen sie dort deshalb alle ab.Deno.listenTlskann ebenfalls kein Zertifikat verlangen, also auch kein Cluster- oder TCP-Listener auf Deno. Auf Node und Bun wird sie durchgesetzt.
const clientCertificateServerOptions = HttpServerOptions.create() .withTls({ cert: readFileSync('./tls/http.crt'), key: readFileSync('./tls/http.key'), ca: readFileSync('./tls/clients-ca.crt'), // die CA, die die Zertifikate deiner Clients signiert requestClientCert: true, });Management-Endpunkt
Abschnitt betitelt „Management-Endpunkt“import { readFileSync } from 'node:fs';import { HttpServerOptions } from 'actor-ts/http';import { managementRoutes } from 'actor-ts/management';
const routes = managementRoutes(system, cluster);
const managementServerOptions = HttpServerOptions.create() .withTls({ cert: readFileSync('./tls/mgmt.crt'), key: readFileSync('./tls/mgmt.key'), });await system.http(8558) .withServerOptions(managementServerOptions) .bind(routes);Dieselben Server-Optionen nehmen eine ca und requestClientCert: true, wenn
ihn nur Clients mit einem Zertifikat deiner eigenen CA erreichen dürfen. Ein
von Hand gebautes Fastify-Backend, das als Option backend übergeben wird,
bekommt das Zertifikat über fastifyFactoryOptions(managementServerOptions),
wie oben.
Der Management-Server ist standardmäßig nur intern — aber TLS hilft trotzdem:
- Schützt vor lateraler Bewegung in einem kompromittierten Netzwerk.
- Wird von manchen Compliance-Regimen unabhängig von der Netzwerk-Topologie verlangt.
Broker-Actors
Abschnitt betitelt „Broker-Actors“Jeder Broker-Actor nimmt TLS in zwei getrennten Schritten entgegen, und die beiden zu verwechseln ist der übliche Grund dafür, dass eine Verbindung zwar TLS sagt, aber nicht das verifiziert, was gemeint war:
- TLS einschalten macht das URL-Schema —
amqps://,mqtts://,rediss://,wss://— oderwithSsl(true)bei Kafka. Der Treiber verifiziert den Broker dann gegen den System-Trust-Store, was für ein öffentlich vertrauenswürdiges Zertifikat genügt. - Zertifikatsmaterial übergeben macht
withTls({ … }): eine private CA, der vertraut werden soll, oder ein Client-Zertifikat für mTLS. Es konfiguriert den Handshake, statt einen zu starten — das TLS-Schema bleibt also zusätzlich nötig.
Wie beim Cluster-Transport trägt jedes Feld das Material selbst, nie
einen Pfad darauf — deshalb liest jedes Beispiel die Datei selbst.
cert und key ergeben nur gemeinsam Sinn; eines ohne das andere wird
beim Start des Actors abgelehnt, statt im Handshake zu werfen und als
Verbindungsfehler endlos wiederholt zu werden.
Nichts davon ist aus HOCON lesbar, und das mit Absicht: Ein Private Key
gehört nicht in eine Config-Datei. withTls gibt es nur im Code, und
Kafkas ssl-Config-Leaf bleibt boolean-only.
Kafka hat kein URL-Schema, das TLS tragen könnte — deshalb erledigt
ssl beide Aufgaben: true für den System-Trust-Store, oder das
Material selbst:
const kafkaOptions = KafkaOptions.create() .withBrokers(['kafka-1:9093']) .withSsl({ ca: fs.readFileSync('./tls/ca.crt', 'utf8'), cert: fs.readFileSync('./tls/client.crt', 'utf8'), key: fs.readFileSync('./tls/client.key', 'utf8'), }) .withSasl({ mechanism: 'scram-sha-512', username: process.env.KAFKA_USER!, password: process.env.KAFKA_PASS!, });new KafkaActor(kafkaOptions);const mqttOptions = MqttOptions.create() .withBrokerUrl('mqtts://mqtt.example.com:8883') .withCredentials(process.env.MQTT_USER, process.env.MQTT_PASS) .withTls({ ca: fs.readFileSync('./tls/ca.crt', 'utf8'), });new MqttActor(mqttOptions);mqtts:// startet den Handshake; withTls entscheidet, wem er
vertraut. Ohne withTls fällt die Verifizierung auf die Defaults des
mqtt-Pakets zurück, also auf den System-Trust-Store.
const amqpOptions = AmqpOptions.create() .withUrl('amqps://rabbitmq.example.com:5671') .withTls({ ca: fs.readFileSync('./tls/ca.crt', 'utf8'), });new AmqpActor(amqpOptions);amqps:// plus withTls, das amqplib als dessen
socketOptions-Argument erreicht. AMQP-URL-Query-Parameter tragen
heartbeat, frameMax, channelMax und locale — nie
Zertifikatsmaterial; in der URL lässt sich das also gar nicht ausdrücken.
const natsOptions = NatsOptions.create() .withServers(['nats://nats.example.com:4222']) .withTls({ ca: fs.readFileSync('./tls/ca.crt', 'utf8'), cert: fs.readFileSync('./tls/client.crt', 'utf8'), key: fs.readFileSync('./tls/client.key', 'utf8'), });new NatsActor(natsOptions);mTLS via withTls — üblich für Produktions-NATS. NATS hat kein
tls-URL-Schema, deshalb ist withTls hier zugleich das, was den
Treiber überhaupt zum TLS-Aushandeln bringt. JetStreamActor nimmt
dieselbe Option.
Redis Streams
Abschnitt betitelt „Redis Streams“const redisStreamsOptions = RedisStreamsOptions.create() .withUrl('rediss://redis.example.com:6380') .withTls({ ca: fs.readFileSync('./tls/ca.crt', 'utf8'), });new RedisStreamsActor(redisStreamsOptions);rediss://-URL-Schema (beachte das doppelte s). Producer- und
Consumer-Client werden aus demselben Material gebaut.
TCP-Listener
Abschnitt betitelt „TCP-Listener“Der einzige Broker-Actor auf der eingehenden Seite. Er nimmt dasselbe
Material wie der Cluster-Transport, und ein gesetztes ca schaltet die
Client-Zertifikatsprüfung ein, sofern nicht requestClientCert: false
etwas anderes sagt — nach der Regel unter
Client-Zertifikate:
const tcpServerOptions = TcpServerOptions.create() .withBindPort(9500) .withTarget(handler) .withTls({ cert: fs.readFileSync('./tls/server.crt', 'utf8'), key: fs.readFileSync('./tls/server.key', 'utf8'), ca: fs.readFileSync('./tls/ca.crt', 'utf8'), });new TcpServerActor(tcpServerOptions);const grpcClientOptions = GrpcClientOptions.create() .withEndpoint('orders.example.com:50051') .withCredentials({ kind: 'tls', rootCerts: fs.readFileSync('./tls/ca.crt'), });new GrpcClientActor(grpcClientOptions);Für Mutual TLS cert + key ergänzen.
WebSocket
Abschnitt betitelt „WebSocket“const webSocketClientOptions = WebsocketClientOptions.create().withUrl('wss://realtime.example.com/feed');new WebsocketClientActor(webSocketClientOptions);wss://-URL-Schema. Cert-Verifizierung folgt den TLS-Defaults der
Runtime.
Nur System-Trust-Store
Abschnitt betitelt „Nur System-Trust-Store“Zwei Client-Actors nehmen weiterhin kein Zertifikatsmaterial und erreichen einen Broker daher nur, wenn dessen Zertifikat auf eine öffentlich vertrauenswürdige Wurzel zurückführt:
WebsocketClientActor(oben).TcpSocketActor— der ausgehende TCP-Client. Sein Listener-PendantTcpServerActornimmt Material; die wählende Hälfte nicht.
Hinter einer privaten CA heißt das: TLS an einem Proxy mit öffentlichem
Zertifikat terminieren, oder die CA in den Trust-Store des Hosts
aufnehmen. Es heißt nicht NODE_TLS_REJECT_UNAUTHORIZED=0 — das
deaktiviert die Verifizierung für jede TLS-Verbindung des Prozesses,
Cluster-Transport und sämtliche HTTP-Clients eingeschlossen.
Persistence-Backends
Abschnitt betitelt „Persistence-Backends“Drei dieser Treiber lesen einen Verifizierungs-Schalter aus dem
Connection-String selbst: node-postgres, node-mssql und der
MongoDB-Treiber. Kommt dieser String aus HOCON — dem url-Blatt des
Plugin-Blocks —, lehnt das Framework einen ab, der die Verifizierung
abschaltet, mit einem ConfigError, der Blatt und Schalter nennt
(#1490). Inspiziert wird nur die Konfigurationsdatei: Derselbe String,
an withUrl(...) übergeben, ist die Entscheidung deines Codes, im
Review sichtbar, und erreicht den Treiber unverändert. Für die Datei ist
die Ablehnung strikt — die url eines Blocks wird auch dann abgelehnt,
wenn der Code eine eigene Verbindung mitgibt, und eine
${?DATABASE_URL}-Substitution wird abgelehnt wie eine ausgeschriebene
URL. Sie betrifft TLS, das niemanden authentifiziert, nicht Klartext:
sslmode=disable, Encrypt=false und tls=false bleiben erlaubt, denn
kein TLS ist eine andere Entscheidung und liest sich als das, was sie
ist. Die Abschnitte unten nennen die Schalter jedes Treibers.
Nicht zutreffend — lokaler Datei-Zugriff. TLS nicht anwendbar.PostgreSQL
Abschnitt betitelt „PostgreSQL“const postgresJournalOptions = PostgresJournalOptions.create() .withUrl(process.env.DATABASE_URL!) .withPoolConfig({ ssl: { rejectUnauthorized: true, ca: fs.readFileSync('./tls/rds-ca.pem') }, });new PostgresJournal(postgresJournalOptions);poolConfig wird über { connectionString: url } gemergt und landet
unverändert in new pg.Pool(...) — nichts filtert es, ssl ist also
genau das, was node-postgres an tls.connect übergibt. Eine
Managed-Instanz veröffentlicht ihr CA-Bundle; ca ist der Platz dafür.
Ein Connection-String kann ebenfalls auf ein Root-Zertifikat zeigen
(sslrootcert=), aber seine sslmode=-Werte stammen aus libpq — wo
require allein die Chain nicht prüft — und node-postgres hat seine
Lesart davon zwischen Releases geändert; die Objektform, die genau
sagt, was geprüft wird, ist also die zum Kopieren. Snapshot-Store und
Durable-State-Store nehmen dasselbe withPoolConfig.
Aus HOCON gibt es zwei Wege zu einer privaten CA. Im Connection-String
ist die eine Schreibweise, die ihre Bedeutung über diese Releases hinweg
behält, verify-full, mit sslrootcert=, das die CA-Datei nennt:
actor-ts.persistence.journal.postgres { url = "postgres://actor_ts@db.example.com:5432/app?sslmode=verify-full&sslrootcert=/etc/ssl/rds-ca.pem"}Oder das Blatt ca-file des Blocks nennt sie, neben einer URL ganz ohne
ssl-Parameter (#1490). Das Framework liest die Datei beim Öffnen des
Pools und übergibt sie node-postgres als ssl.ca; Nodes TLS-Default
prüft dann Chain und Namen:
actor-ts.persistence.journal.postgres { url = "postgres://actor_ts@db.example.com:5432/app" ca-file = "/etc/ssl/rds-ca.pem"}Eins von beiden, nie beides. node-postgres legt die TLS-Einstellungen,
die es aus dem Connection-String parst, über sein Config-Objekt — gegen
pg 8.23 ausgeführt, fiel eine CA neben sslmode=verify-full weg, und
neben sslmode=no-verify kam sie mit abgeschalteter Verifizierung
zurück —, der Store lehnt ca-file neben irgendeinem ssl-Parameter in
der URL deshalb beim Bau ab, und im Code ein poolConfig.ssl daneben
ebenso.
Eine aus HOCON gelesene url wird abgelehnt, wenn sie
sslmode=no-verify oder ssl=no-verify trägt — Letzteres liest pg
selbst, nach dem Parser — oder, unter uselibpqcompat=true, das
sslmode die Bedeutungen von libpq gibt, sslmode=prefer, require
oder verify-ca. Mit diesen Bedeutungen prüfen prefer und require
ohne sslrootcert gar nichts; verify-ca und require mit
Root-Zertifikat prüfen die Chain, aber nicht den Hostnamen, sodass ein
Zertifikat, das dieselbe Stelle für einen beliebigen anderen Host
ausgestellt hat, durchgeht. Ohne uselibpqcompat liest pg 8 alle drei
weiterhin als verify-full, sie werden also nicht abgelehnt; sein
Parser warnt, dass das nächste Major-Release ihnen die Bedeutungen von
libpq geben wird. Ein Kanal bleibt außerhalb der Ablehnung:
Konfigurieren weder die URL noch poolConfig noch ca-file TLS, greift
node-postgres auf die Umgebungsvariable PGSSLMODE zurück, und
no-verify dort schaltet die Verifizierung ab, ganz ohne HOCON.
MariaDB
Abschnitt betitelt „MariaDB“const mariaDbJournalOptions = MariaDbJournalOptions.create() .withPoolConfig({ host: 'db.example.com', port: 3306, database: 'app', user: 'actor_ts', password: process.env.MARIADB_PASSWORD, ssl: { rejectUnauthorized: true, ca: fs.readFileSync('./tls/rds-ca.pem') }, });new MariaDbJournal(mariaDbJournalOptions);Das ssl des Connectors nimmt Nodes eigene TLS-Optionen — wörtlich die
Postgres-Form — und poolConfig erreicht mariadb.createPool(...)
unverändert. Sein Connection-String ist die Ausnahme von der Ablehnung
oben, weil darin nichts abzulehnen ist: Der Connector liest das ssl
einer URL als Boolean (mariadb 3.5), und ssl=true prüft die Chain
gegen den Trust-Store. Eine MariaDB-url aus HOCON wird daher nicht
inspiziert — und kann auch keine CA tragen. Aus der Konfiguration wird
eine private CA stattdessen mit dem Blatt ca-file des Blocks genannt
(#1490): Das Framework liest die Datei beim Öffnen des Pools und übergibt
sie dem Connector als ssl.ca, über die URL gelegt, die so geparst wird,
wie der Connector sie parst, damit Host, Datenbank und Optionen erhalten
bleiben.
actor-ts.persistence.journal.mariadb { url = "mariadb://actor_ts@db.example.com:3306/app" ca-file = "/etc/ssl/rds-ca.pem"}Abgelehnt wird es neben einem ssl in der URL, das der Connector als
false liest — jeder Wert außer genau true, also auch ssl=TRUE —, weil
das TLS abschaltet und die CA ungenutzt ließe.
SQL Server
Abschnitt betitelt „SQL Server“const msSqlJournalOptions = MsSqlJournalOptions.create() .withPoolConfig({ server: 'db.example.com', database: 'app', user: 'actor_ts', password: process.env.MSSQL_PASSWORD, options: { encrypt: true, cryptoCredentialsDetails: { ca: fs.readFileSync('./tls/rds-ca.pem') }, serverName: 'db.example.com', }, });new MsSqlJournal(msSqlJournalOptions);mssql verschlüsselt per Default und prüft das Server-Zertifikat. Der
Treiber darunter, tedious, reicht cryptoCredentialsDetails an
tls.createSecureContext durch, ca ist also der Platz für eine private
CA, und serverName ist der Name, den das Zertifikat tragen muss, wenn
er von server abweicht. Die Alternative des Treibers — ihm zu sagen, er
solle dem Server-Zertifikat vertrauen, was ein Connection-String als
TrustServerCertificate= schreibt — ist der Schalter, den der Hinweis
unten mit einem Kreuz markiert, nur unter anderem Namen: tedious kehrt
ihn direkt in tls.connects rejectUnauthorized um, die Verbindung
bleibt also verschlüsselt und authentifiziert niemanden. Ein
Connection-String hat gar keinen Schlüssel für eine CA, im Code heißt
eine private CA also poolConfig. Das Objekt erreicht
new mssql.ConnectionPool(...) unverändert.
Aus HOCON wird dieser Schalter abgelehnt. node-mssql liest jeden Wert
von TrustServerCertificate als true außer false, no, 0 und einem
leeren — yes, 1, {true} und sogar ein gequotetes " false"
schalten die Verifizierung ab —, ein url-Blatt, dessen
Connection-String ihn auf irgendetwas anderes setzt, scheitert also, in
jeder Groß- und Kleinschreibung des Schlüssels, mit einem ConfigError.
Dasselbe gilt für den Schalter in der Query einer mssql://-URL, obwohl
node-mssql seit seinem 8.0 nur noch die Form Server=...;Database=...
parst — und ein Store lehnt eine solche URL beim Bau ohnehin ab. Ohne
Schlüssel für eine CA im Connection-String wird ein SQL Server hinter
einer privaten CA daneben mit dem Blatt ca-file des Blocks genannt
(#1490): Das Framework liest die Datei beim Öffnen des Pools und übergibt
sie tedious in cryptoCredentialsDetails.
actor-ts.persistence.journal.mssql { url = "Server=db.example.com;Database=app;User Id=actor_ts;Encrypt=true" ca-file = "/etc/ssl/rds-ca.pem"}Abgelehnt wird es neben einem Encrypt, das node-mssql als false liest
und damit TLS abschaltet, und neben einem TrustServerCertificate, das es
als true liest und damit die Verifizierung abschaltet — beides ließe die
CA ungenutzt. Einer, dessen Zertifikat auf eine öffentliche Wurzel
zurückführt, braucht nichts als den Default, Encrypt=true.
Bei allen dreien gilt: das Zertifikat kommt nie als Bytes in die
Konfiguration. Im Code gehört das Material ins Objekt, von deinem Code aus
einer Datei gelesen. Aus der Konfiguration ist es ein Pfad: ca-file, das
das Framework beim Öffnen des Pools liest, oder — bei Postgres — das
sslrootcert der URL, das der Treiber liest. Darin unterscheiden sich die
Persistence-Stores vom Cluster-Transport und den Brokern, deren
TLS-Felder das Material selbst nehmen: Ein Store wird aus seinem eigenen
Config-Block gebaut, und ein Pfad dort hält das PEM aus der Datei heraus,
ohne dass Code es lesen muss. Und das Journal ist das System of Record der
Anwendung; alles auf dem Weg dorthin, das ein eigenes Zertifikat vorlegen
kann, kann also die Historie umschreiben.
MongoDB
Abschnitt betitelt „MongoDB“const mongoJournalOptions = MongoJournalOptions.create().withUrl('mongodb://db.example.com:27017/app?tls=true&tlsCAFile=/etc/ssl/rds-ca.pem');new MongoJournal(mongoJournalOptions);Der MongoDB-Treiber nimmt seine TLS-Einstellungen aus dem
Connection-String: tls=true verschlüsselt und prüft sowohl das
Zertifikat des Servers als auch seinen Hostnamen, und tlsCAFile nennt
die Datei einer privaten CA, die der Treiber beim Verbinden selbst
liest. mongodb+srv:// schaltet TLS per Default ein.
Aus HOCON führen zwei Wege zu einer privaten CA, wie bei Postgres.
Dieselbe URL funktioniert dort unverändert, oder das Blatt ca-file des
Blocks nennt die Datei (#1490): Das Framework liest sie, wenn der Client
öffnet, und übergibt sie dem Treiber als ca, mit eingeschaltetem
tls.
actor-ts.persistence.journal.mongodb { url = "mongodb://db.example.com:27017/app" ca-file = "/etc/ssl/rds-ca.pem"}Das eine oder das andere, nie beides, und nichts daneben, das die CA
beiseiteschiebt. Der Store lehnt ca-file beim Bauen mit einem
OptionsError ab, der beide Seiten nennt, und zwar neben:
- einem
tlsCAFilein der URL oder inclientOptionsoder einemcainclientOptions— der Treiber liesttlsCAFilenur, wenn er keincabekommen hat, eines von beiden fiele also weg; - einem
tlsodersslmitfalsein einem von beiden, das die CA ungenutzt ließe; - einem
tlsInsecureodertlsAllowInvalidCertificatesin einem von beiden, das die Zertifikatsprüfung abschaltet, und einemrejectUnauthorizedmitfalseinclientOptions, in jeder Groß- und Kleinschreibung des Schlüssels — dem Schalter, dentlsInsecuresetzt und der unverändert annode:tlsgeht; - einem
secureContextinclientOptions, das einen eigenen Trust-Store mitbringt, dennode:tlsstatt der CA benutzt; - einem vorgebauten
client, der dort konfiguriert wurde, wo er gebaut wurde, undca-filenie liest — gib diesem Client seine CA dort, wo du ihn baust.
Die drei Auswege des Treibers aus der Verifizierung sind tlsInsecure,
tlsAllowInvalidCertificates — beide prüfen das Zertifikat nicht mehr —
und tlsAllowInvalidHostnames, das die Chain behält und den Namen
fallen lässt. Sie sind der Schalter, den der Hinweis unten mit einem
Kreuz markiert, nur unter anderen Namen. Eine aus HOCON gelesene url,
die einen davon auf irgendetwas außer false setzt, wird in jeder
Groß- und Kleinschreibung des Schlüssels mit einem ConfigError
abgelehnt; im Code gesetzt, mit withUrl(...) oder clientOptions,
werden sie nicht inspiziert, solange kein ca-file danebensteht — dann
gilt die Liste oben. tls=false ist Klartext und bleibt erlaubt.
Cassandra
Abschnitt betitelt „Cassandra“const cassandraJournalOptions = CassandraJournalOptions.create() .withContactPoints(['cass-1.example.com:9042']) .withClient(clientWithMtls);new CassandraJournal(cassandraJournalOptions); // mTLS-Cert-Material (cert / key / ca) wird auf dem via withClient() // übergebenen cassandra-driver-Client konfiguriertCassandra-Cluster laufen in Produktion typischerweise mit mTLS.
Object Storage
Abschnitt betitelt „Object Storage“const s3ObjectStorageOptions = S3ObjectStorageOptions.create().withRegion('eu-west-1');const objectStorageDurableStateStoreOptions = ObjectStorageDurableStateStoreOptions.create().withBackend(new S3ObjectStorageBackend(s3ObjectStorageOptions));new ObjectStorageDurableStateStore(objectStorageDurableStateStoreOptions); // S3 nutzt per Default HTTPSCloud-Object-Storage (S3, GCS, Azure Blob) nutzt immer TLS. Keine Konfiguration nötig außer dem Endpoint.
Cert-Provisionierung
Abschnitt betitelt „Cert-Provisionierung“Drei Muster in K8s-Produktion:
cert-manager
Abschnitt betitelt „cert-manager“apiVersion: cert-manager.io/v1kind: Certificatemetadata: name: actor-ts-clusterspec: secretName: actor-ts-cluster-tls issuerRef: name: actor-ts-ca kind: ClusterIssuer commonName: actor-ts dnsNames: [actor-ts-cluster.svc] duration: 8760h renewBefore: 720hcert-manager erneuert Certs automatisch vor Ablauf. Die meisten Produktions-K8s-Setups nutzen ihn.
Vault Agent
Abschnitt betitelt „Vault Agent“Vault Agent läuft als Sidecar; zieht Certs in das Pod-Filesystem; erneuert automatisch. Nützlich, wenn du schon HashiCorp Vault hast.
Manuell + geplante Rotation
Abschnitt betitelt „Manuell + geplante Rotation“Für Nicht-K8s-Umgebungen geplante Cron-Jobs, die frische Certs aus einer internen CA ziehen + die betroffenen Services neu starten. Funktioniert, erfordert aber sorgfältige operative Disziplin.
Was ist mit der CA-Kette?
Abschnitt betitelt „Was ist mit der CA-Kette?“ca: fs.readFileSync('./tls/ca.crt'),Die meisten internen Setups: eine CA, signiert alle Client- + Server-Certs. Die Cert-Verifizierung braucht das CA-Cert auf beiden Enden.
Cloud-managed Certificates (Let’s Encrypt, AWS ACM): nutze
öffentliche CA-Bundles — in den meisten Runtimes bereits
vorhanden. Kein expliziter ca nötig.
Wohin als nächstes
Abschnitt betitelt „Wohin als nächstes“- Cluster-Sicherheit — das Detail zum Cluster-Transport.
- Master-Key-Rotation — für Daten at-rest.
- Kubernetes-Deployment — das K8s-Rezept + cert-manager-Integration.
- Operations-Überblick — die Produktions-Sicherheits-Checkliste.
