This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-kamelets.git
The following commit(s) were added to refs/heads/main by this push:
new 01162ebb8 chore: the NATS Kamelets can use TLS and a credentials file,
and nats-source a queue group (#3170) (#3205)
01162ebb8 is described below
commit 01162ebb8623b046a10f97c24f264084ff864a3a
Author: Claus Ibsen <[email protected]>
AuthorDate: Wed Nov 18 21:37:50 2026 +0100
chore: the NATS Kamelets can use TLS and a credentials file, and
nats-source a queue group (#3170) (#3205)
nats-source and nats-sink take two new optional options:
- secure: connect with TLS, which a NATS server with TLS in its
configuration requires. The certificate of the server is checked
against the certificate authorities that Java trusts, or against the
global camel.ssl trust store when
camel.component.nats.useGlobalSslContextParameters is true. camel-nats
takes its TLS settings only as an SSLContextParameters object, so the
Kamelets point to the global camel.ssl settings for a private
certificate authority, as http-sink does, rather than adding a trust
store file option.
- credentialsFilePath: a NATS credentials file (.creds, a user JWT and
its NKey seed), for servers with decentralized authentication.
nats-source also takes queueName: the copies of an integration that use
the same queue group share the messages, so each message is received
once. Without JetStream only: with jetstreamEnabled each copy still
receives every message of the stream, as each creates its own consumer.
The servers descriptions now also say that a token can be put in the
address. With the new options unset, the endpoint URIs are the same as
before. The descriptions and the partial pages say how to set up TLS
with a private certificate authority, with examples that were run
against nats-server.
Co-authored-by: Claude Opus 5.5 <[email protected]>
---
.../ROOT/partials/nats-sink-description.adoc | 52 ++++++++++++++++++++-
.../ROOT/partials/nats-source-description.adoc | 54 ++++++++++++++++++++--
kamelets/nats-sink.kamelet.yaml | 16 ++++++-
kamelets/nats-source.kamelet.yaml | 23 ++++++++-
.../main/resources/META-INF/kamelets-index.json | 4 +-
.../main/resources/kamelets/nats-sink.kamelet.yaml | 16 ++++++-
.../resources/kamelets/nats-source.kamelet.yaml | 23 ++++++++-
7 files changed, 173 insertions(+), 15 deletions(-)
diff --git a/docs/modules/ROOT/partials/nats-sink-description.adoc
b/docs/modules/ROOT/partials/nats-sink-description.adoc
index d5077fd03..b3a0b6c0d 100644
--- a/docs/modules/ROOT/partials/nats-sink-description.adoc
+++ b/docs/modules/ROOT/partials/nats-sink-description.adoc
@@ -21,6 +21,54 @@ NATS is designed for cloud-native environments with features
like:
- Multi-tenancy support
- Service mesh integration
-=== Authentication and Security
+=== Login
-NATS supports various authentication mechanisms and secure connections. This
Kamelet takes a user and password in the server address, as
`nats://user:password@host:4222`, and has no options for TLS or for other kinds
of login.
\ No newline at end of file
+For a server that needs a user and password, put them in the address in
`servers`, as `nats://user:password@host:4222`, or put a token there, as
`nats://token@host:4222`.
+
+For a server with decentralized authentication, such as Synadia Cloud, log in
with a NATS credentials file (`.creds`), which holds a user JWT and the NKey
seed of the user. Set its location in `credentialsFilePath`, as `file:`
followed by the path of the file. The `nsc generate creds` command makes one:
+
+[source,bash]
+----
+nsc generate creds --account APP --name app-user > app-user.creds
+----
+
+=== TLS with a Private Certificate Authority
+
+With `secure: true` the Kamelet connects with TLS, which a server with TLS in
its configuration requires, and checks the certificate of the server against
the certificate authorities that Java trusts. When the server has a certificate
from a private or self-signed authority, put the certificate of that authority
in a trust store file (JKS or PKCS12):
+
+[source,bash]
+----
+keytool -importcert -alias nats-ca -file ca.pem -keystore truststore.p12
-storetype PKCS12 -storepass changeit
+----
+
+The Kamelet has no option for the trust store. Set it in the application
properties, as the global TLS settings of Camel, and tell the NATS component to
use them. With Camel JBang or Camel Main, in `application.properties`:
+
+[source,properties]
+----
+camel.ssl.enabled=true
+camel.ssl.trustStore=file:/etc/nats/truststore.p12
+camel.ssl.trustStorePassword=changeit
+camel.component.nats.useGlobalSslContextParameters=true
+----
+
+That trust store then replaces the one of Java for every NATS connection of
the application that has `secure` set. An address that starts with `tls://`
also connects with TLS, but it uses that trust store only when `secure` is true.
+
+=== Example with TLS and a Credentials File
+
+[source,yaml,subs='+attributes,macros']
+----
+- route:
+ from:
+ uri: "kamelet:timer-source"
+ parameters:
+ message: "hello"
+ period: 5000
+ steps:
+ - to:
+ uri: "kamelet:nats-sink"
+ parameters:
+ servers: "tls://nats.example.com:4222"
+ topic: "orders.created"
+ secure: true
+ credentialsFilePath: "file:/etc/nats/app-user.creds"
+----
diff --git a/docs/modules/ROOT/partials/nats-source-description.adoc
b/docs/modules/ROOT/partials/nats-source-description.adoc
index f92eaa561..45680c6bd 100644
--- a/docs/modules/ROOT/partials/nats-source-description.adoc
+++ b/docs/modules/ROOT/partials/nats-source-description.adoc
@@ -1,9 +1,39 @@
== NATS Source Kamelet Description
-=== Authentication
+=== Login
-The Kamelet has no login options. For a server that needs a user and password,
put them in the address in `servers`,
-as `nats://user:password@host:4222`. The Kamelet has no TLS options.
+For a server that needs a user and password, put them in the address in
`servers`, as
+`nats://user:password@host:4222`, or put a token there, as
`nats://token@host:4222`.
+
+For a server with decentralized authentication, such as Synadia Cloud, log in
with a NATS credentials file (`.creds`),
+which holds a user JWT and the NKey seed of the user. Set its location in
`credentialsFilePath`, as `file:` followed by
+the path of the file. The `nsc generate creds` command makes one.
+
+=== TLS with a Private Certificate Authority
+
+With `secure: true` the Kamelet connects with TLS, which a server with TLS in
its configuration requires, and checks
+the certificate of the server against the certificate authorities that Java
trusts. When the server has a certificate
+from a private or self-signed authority, put the certificate of that authority
in a trust store file (JKS or PKCS12),
+and set it in the application properties, as the global TLS settings of Camel.
With Camel JBang or Camel Main, in
+`application.properties`:
+
+[source,properties]
+----
+camel.ssl.enabled=true
+camel.ssl.trustStore=file:/etc/nats/truststore.p12
+camel.ssl.trustStorePassword=changeit
+camel.component.nats.useGlobalSslContextParameters=true
+----
+
+That trust store then replaces the one of Java for every NATS connection of
the application that has `secure` set.
+An address that starts with `tls://` also connects with TLS, but it uses that
trust store only when `secure` is true.
+
+=== Running several copies: queue groups
+
+Each copy of the integration receives every message of the subject. To share
the messages instead, so that each
+message is processed by only one copy, give every copy the same `queueName`.
NATS then delivers each message to one
+member of the queue group. This works only without JetStream: with
`jetstreamEnabled`, each copy still receives every
+message of the stream.
=== Output format
@@ -29,3 +59,21 @@ the subject in `topic` when it does not exist. Each time it
starts, it reads the
- to:
uri: "kamelet:log-sink"
----
+
+=== Example with TLS, a Credentials File and a Queue Group
+
+[source,yaml,subs='+attributes,macros']
+----
+- route:
+ from:
+ uri: "kamelet:nats-source"
+ parameters:
+ servers: "tls://nats.example.com:4222"
+ topic: "orders.created"
+ secure: true
+ credentialsFilePath: "file:/etc/nats/app-user.creds"
+ queueName: "order-workers"
+ steps:
+ - to:
+ uri: "kamelet:log-sink"
+----
diff --git a/kamelets/nats-sink.kamelet.yaml b/kamelets/nats-sink.kamelet.yaml
index 3bfb4e2e6..e7684b3e0 100644
--- a/kamelets/nats-sink.kamelet.yaml
+++ b/kamelets/nats-sink.kamelet.yaml
@@ -39,7 +39,7 @@ spec:
Output: the message is unchanged.
- Good to know: a plain NATS subject stores nothing: only the receivers
subscribed at that moment get the message. With `jetstreamEnabled`, the message
is stored in the stream `jetstreamName`, which must exist already, for example
created by `nats-source`; otherwise sending fails. It connects with no TLS, and
the integration fails to start when no server can be reached. It publishes the
message and does not wait for a reply, even when the incoming message expects
one, as one from `we [...]
+ Good to know: a plain NATS subject stores nothing: only the receivers
subscribed at that moment get the message. With `jetstreamEnabled`, the message
is stored in the stream `jetstreamName`, which must exist already, for example
created by `nats-source`; otherwise sending fails. It connects with TLS when
`secure` is true. The certificate of the server is checked against the
certificate authorities that Java trusts. To trust a private one with Camel
JBang or Camel Main, set the appl [...]
required:
- topic
- servers
@@ -52,12 +52,22 @@ spec:
type: string
servers:
title: "Servers"
- description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`."
+ description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`, or a token, as
`nats://token@host:4222`. To log in with a NATS credentials file instead, use
`credentialsFilePath`."
example: "nats://localhost:4222"
type: string
format: password
x-descriptors:
- urn:camel:group:credentials
+ secure:
+ title: "Secure (TLS)"
+ description: "If true, it connects with TLS, which a server with TLS
in its configuration requires; without it, such a server refuses the connection
with `SSL required by server`. The certificate of the server is checked against
the certificate authorities that Java trusts, or against the trust store set in
the `camel.ssl` application properties when
`camel.component.nats.useGlobalSslContextParameters` is true. An address that
starts with `tls://` also connects with TLS, but uses [...]
+ type: boolean
+ credentialsFilePath:
+ title: "Credentials File"
+ description: "A NATS credentials file (`.creds`) to log in with, which
holds a user JWT and the NKey seed of the user. Servers with decentralized
authentication, such as Synadia Cloud, use it. Start it with `file:` followed
by the path of the file, or with `classpath:`, `http:` or `https:`. The `nsc
generate creds` command makes one. A file that does not exist makes the
integration fail to start, and a user that the server does not know is refused
with `Authorization Violation`."
+ example: "file:/etc/nats/user.creds"
+ type: string
+ pattern: "^(file|classpath|http|https):.+"
jetstreamEnabled:
title: "JetStream Enabled"
description: "If true, each message is published to the JetStream
stream `jetstreamName`, which stores it, instead of to plain NATS. The stream
must exist and take in the subject in `topic`."
@@ -89,3 +99,5 @@ spec:
jetstreamEnabled: "{{?jetstreamEnabled}}"
jetstreamName: "{{?jetstreamName}}"
servers: "{{servers}}"
+ secure: "{{?secure}}"
+ credentialsFilePath: "{{?credentialsFilePath}}"
diff --git a/kamelets/nats-source.kamelet.yaml
b/kamelets/nats-source.kamelet.yaml
index 4d4e9ed6f..ba21f90b1 100644
--- a/kamelets/nats-source.kamelet.yaml
+++ b/kamelets/nats-source.kamelet.yaml
@@ -37,7 +37,7 @@ spec:
Output: the body is the payload, as bytes, unchanged. The
`CamelNatsSubject` header is the subject, and the NATS headers of the message
become headers too.
- Good to know: without JetStream, it receives only the messages published
while it is connected. With `jetstreamEnabled`, it creates the stream
`jetstreamName` for the subject when it does not exist, and each time it starts
it reads the stream from the beginning, so messages already read are received
again. The integration fails to start when no server can be reached.
+ Good to know: without JetStream, it receives only the messages published
while it is connected. With `jetstreamEnabled`, it creates the stream
`jetstreamName` for the subject when it does not exist, and each time it starts
it reads the stream from the beginning, so messages already read are received
again. When several copies of the integration run, each copy receives every
message, unless they share a `queueName`: then each message goes to only one of
them. This works only without [...]
required:
- topic
- servers
@@ -50,12 +50,28 @@ spec:
type: string
servers:
title: "Servers"
- description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`."
+ description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`, or a token, as
`nats://token@host:4222`. To log in with a NATS credentials file instead, use
`credentialsFilePath`."
example: "nats://localhost:4222"
type: string
format: password
x-descriptors:
- urn:camel:group:credentials
+ queueName:
+ title: "Queue Group"
+ description: "The name of a NATS queue group to join. The subscribers
of `topic` that use the same queue group share its messages: each message goes
to only one of them. Set the same name on every copy of the integration when
you run several of them, so that each message is processed once; without it,
each copy receives every message. Only used without JetStream: with
`jetstreamEnabled`, each copy still receives every message of the stream."
+ example: "order-workers"
+ type: string
+ pattern: "^\\S+$"
+ secure:
+ title: "Secure (TLS)"
+ description: "If true, it connects with TLS, which a server with TLS
in its configuration requires; without it, such a server refuses the connection
with `SSL required by server`. The certificate of the server is checked against
the certificate authorities that Java trusts, or against the trust store set in
the `camel.ssl` application properties when
`camel.component.nats.useGlobalSslContextParameters` is true. An address that
starts with `tls://` also connects with TLS, but uses [...]
+ type: boolean
+ credentialsFilePath:
+ title: "Credentials File"
+ description: "A NATS credentials file (`.creds`) to log in with, which
holds a user JWT and the NKey seed of the user. Servers with decentralized
authentication, such as Synadia Cloud, use it. Start it with `file:` followed
by the path of the file, or with `classpath:`, `http:` or `https:`. The `nsc
generate creds` command makes one. A file that does not exist makes the
integration fail to start, and a user that the server does not know is refused
with `Authorization Violation`."
+ example: "file:/etc/nats/user.creds"
+ type: string
+ pattern: "^(file|classpath|http|https):.+"
jetstreamEnabled:
title: "JetStream Enabled"
description: "If true, the messages are read from the JetStream stream
`jetstreamName`, which keeps them, instead of from plain NATS. The stream is
created for the subject in `topic` when it does not exist."
@@ -98,6 +114,9 @@ spec:
jetstreamEnabled: "{{?jetstreamEnabled}}"
jetstreamName: "{{?jetstreamName}}"
servers: "{{servers}}"
+ secure: "{{?secure}}"
+ credentialsFilePath: "{{?credentialsFilePath}}"
+ queueName: "{{?queueName}}"
steps:
- to:
uri: kamelet:sink
diff --git
a/library/camel-kamelets/src/main/resources/META-INF/kamelets-index.json
b/library/camel-kamelets/src/main/resources/META-INF/kamelets-index.json
index 9dd5aed90..7256f6eb0 100644
--- a/library/camel-kamelets/src/main/resources/META-INF/kamelets-index.json
+++ b/library/camel-kamelets/src/main/resources/META-INF/kamelets-index.json
@@ -1665,7 +1665,7 @@
"supportLevel" : "Stable",
"title" : "NATS Sink",
"summary" : "Publishes each message to a subject on a NATS server, or to a
JetStream stream that stores the messages.",
- "description" : "Publishes each message to a subject on a NATS server, or
to a JetStream stream that stores the messages.\n\nUse it to send events or
commands to services that listen on NATS, such as microservices or edge
devices. Use `nats-source` to receive them.\n\nInput: the body is the payload,
as text or bytes. A Map is sent as its Java text form, such as `{a=1, b=x}`, so
turn it into JSON text first, for example with `json-serialize-action`. Headers
of the message, such as `Co [...]
+ "description" : "Publishes each message to a subject on a NATS server, or
to a JetStream stream that stores the messages.\n\nUse it to send events or
commands to services that listen on NATS, such as microservices or edge
devices. Use `nats-source` to receive them.\n\nInput: the body is the payload,
as text or bytes. A Map is sent as its Java text form, such as `{a=1, b=x}`, so
turn it into JSON text first, for example with `json-serialize-action`. Headers
of the message, such as `Co [...]
"group" : "NATS",
"namespace" : "Messaging",
"provider" : "Apache Software Foundation"
@@ -1675,7 +1675,7 @@
"supportLevel" : "Stable",
"title" : "NATS Source",
"summary" : "Receives each message published to a subject on a NATS
server, or stored in a JetStream stream.",
- "description" : "Receives each message published to a subject on a NATS
server, or stored in a JetStream stream.\n\nUse it to react to events or
commands that services publish on NATS. Use `nats-sink` to publish
them.\n\nOutput: the body is the payload, as bytes, unchanged. The
`CamelNatsSubject` header is the subject, and the NATS headers of the message
become headers too.\n\nGood to know: without JetStream, it receives only the
messages published while it is connected. With `jetstr [...]
+ "description" : "Receives each message published to a subject on a NATS
server, or stored in a JetStream stream.\n\nUse it to react to events or
commands that services publish on NATS. Use `nats-sink` to publish
them.\n\nOutput: the body is the payload, as bytes, unchanged. The
`CamelNatsSubject` header is the subject, and the NATS headers of the message
become headers too.\n\nGood to know: without JetStream, it receives only the
messages published while it is connected. With `jetstr [...]
"group" : "NATS",
"namespace" : "Messaging",
"provider" : "Apache Software Foundation"
diff --git
a/library/camel-kamelets/src/main/resources/kamelets/nats-sink.kamelet.yaml
b/library/camel-kamelets/src/main/resources/kamelets/nats-sink.kamelet.yaml
index 3bfb4e2e6..e7684b3e0 100644
--- a/library/camel-kamelets/src/main/resources/kamelets/nats-sink.kamelet.yaml
+++ b/library/camel-kamelets/src/main/resources/kamelets/nats-sink.kamelet.yaml
@@ -39,7 +39,7 @@ spec:
Output: the message is unchanged.
- Good to know: a plain NATS subject stores nothing: only the receivers
subscribed at that moment get the message. With `jetstreamEnabled`, the message
is stored in the stream `jetstreamName`, which must exist already, for example
created by `nats-source`; otherwise sending fails. It connects with no TLS, and
the integration fails to start when no server can be reached. It publishes the
message and does not wait for a reply, even when the incoming message expects
one, as one from `we [...]
+ Good to know: a plain NATS subject stores nothing: only the receivers
subscribed at that moment get the message. With `jetstreamEnabled`, the message
is stored in the stream `jetstreamName`, which must exist already, for example
created by `nats-source`; otherwise sending fails. It connects with TLS when
`secure` is true. The certificate of the server is checked against the
certificate authorities that Java trusts. To trust a private one with Camel
JBang or Camel Main, set the appl [...]
required:
- topic
- servers
@@ -52,12 +52,22 @@ spec:
type: string
servers:
title: "Servers"
- description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`."
+ description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`, or a token, as
`nats://token@host:4222`. To log in with a NATS credentials file instead, use
`credentialsFilePath`."
example: "nats://localhost:4222"
type: string
format: password
x-descriptors:
- urn:camel:group:credentials
+ secure:
+ title: "Secure (TLS)"
+ description: "If true, it connects with TLS, which a server with TLS
in its configuration requires; without it, such a server refuses the connection
with `SSL required by server`. The certificate of the server is checked against
the certificate authorities that Java trusts, or against the trust store set in
the `camel.ssl` application properties when
`camel.component.nats.useGlobalSslContextParameters` is true. An address that
starts with `tls://` also connects with TLS, but uses [...]
+ type: boolean
+ credentialsFilePath:
+ title: "Credentials File"
+ description: "A NATS credentials file (`.creds`) to log in with, which
holds a user JWT and the NKey seed of the user. Servers with decentralized
authentication, such as Synadia Cloud, use it. Start it with `file:` followed
by the path of the file, or with `classpath:`, `http:` or `https:`. The `nsc
generate creds` command makes one. A file that does not exist makes the
integration fail to start, and a user that the server does not know is refused
with `Authorization Violation`."
+ example: "file:/etc/nats/user.creds"
+ type: string
+ pattern: "^(file|classpath|http|https):.+"
jetstreamEnabled:
title: "JetStream Enabled"
description: "If true, each message is published to the JetStream
stream `jetstreamName`, which stores it, instead of to plain NATS. The stream
must exist and take in the subject in `topic`."
@@ -89,3 +99,5 @@ spec:
jetstreamEnabled: "{{?jetstreamEnabled}}"
jetstreamName: "{{?jetstreamName}}"
servers: "{{servers}}"
+ secure: "{{?secure}}"
+ credentialsFilePath: "{{?credentialsFilePath}}"
diff --git
a/library/camel-kamelets/src/main/resources/kamelets/nats-source.kamelet.yaml
b/library/camel-kamelets/src/main/resources/kamelets/nats-source.kamelet.yaml
index 4d4e9ed6f..ba21f90b1 100644
---
a/library/camel-kamelets/src/main/resources/kamelets/nats-source.kamelet.yaml
+++
b/library/camel-kamelets/src/main/resources/kamelets/nats-source.kamelet.yaml
@@ -37,7 +37,7 @@ spec:
Output: the body is the payload, as bytes, unchanged. The
`CamelNatsSubject` header is the subject, and the NATS headers of the message
become headers too.
- Good to know: without JetStream, it receives only the messages published
while it is connected. With `jetstreamEnabled`, it creates the stream
`jetstreamName` for the subject when it does not exist, and each time it starts
it reads the stream from the beginning, so messages already read are received
again. The integration fails to start when no server can be reached.
+ Good to know: without JetStream, it receives only the messages published
while it is connected. With `jetstreamEnabled`, it creates the stream
`jetstreamName` for the subject when it does not exist, and each time it starts
it reads the stream from the beginning, so messages already read are received
again. When several copies of the integration run, each copy receives every
message, unless they share a `queueName`: then each message goes to only one of
them. This works only without [...]
required:
- topic
- servers
@@ -50,12 +50,28 @@ spec:
type: string
servers:
title: "Servers"
- description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`."
+ description: "The addresses of one or more NATS servers, as
`host:port` or `nats://host:port`, separated by commas. The usual NATS port is
4222. For a server that needs a login, put the user and password in the
address, as `nats://user:password@host:4222`, or a token, as
`nats://token@host:4222`. To log in with a NATS credentials file instead, use
`credentialsFilePath`."
example: "nats://localhost:4222"
type: string
format: password
x-descriptors:
- urn:camel:group:credentials
+ queueName:
+ title: "Queue Group"
+ description: "The name of a NATS queue group to join. The subscribers
of `topic` that use the same queue group share its messages: each message goes
to only one of them. Set the same name on every copy of the integration when
you run several of them, so that each message is processed once; without it,
each copy receives every message. Only used without JetStream: with
`jetstreamEnabled`, each copy still receives every message of the stream."
+ example: "order-workers"
+ type: string
+ pattern: "^\\S+$"
+ secure:
+ title: "Secure (TLS)"
+ description: "If true, it connects with TLS, which a server with TLS
in its configuration requires; without it, such a server refuses the connection
with `SSL required by server`. The certificate of the server is checked against
the certificate authorities that Java trusts, or against the trust store set in
the `camel.ssl` application properties when
`camel.component.nats.useGlobalSslContextParameters` is true. An address that
starts with `tls://` also connects with TLS, but uses [...]
+ type: boolean
+ credentialsFilePath:
+ title: "Credentials File"
+ description: "A NATS credentials file (`.creds`) to log in with, which
holds a user JWT and the NKey seed of the user. Servers with decentralized
authentication, such as Synadia Cloud, use it. Start it with `file:` followed
by the path of the file, or with `classpath:`, `http:` or `https:`. The `nsc
generate creds` command makes one. A file that does not exist makes the
integration fail to start, and a user that the server does not know is refused
with `Authorization Violation`."
+ example: "file:/etc/nats/user.creds"
+ type: string
+ pattern: "^(file|classpath|http|https):.+"
jetstreamEnabled:
title: "JetStream Enabled"
description: "If true, the messages are read from the JetStream stream
`jetstreamName`, which keeps them, instead of from plain NATS. The stream is
created for the subject in `topic` when it does not exist."
@@ -98,6 +114,9 @@ spec:
jetstreamEnabled: "{{?jetstreamEnabled}}"
jetstreamName: "{{?jetstreamName}}"
servers: "{{servers}}"
+ secure: "{{?secure}}"
+ credentialsFilePath: "{{?credentialsFilePath}}"
+ queueName: "{{?queueName}}"
steps:
- to:
uri: kamelet:sink