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

Reply via email to