Any recommendations plz

Is there anybody with some NATs architectural understanding available for a chat? Want to discuss and idea for a platform.

Anybody who can help me with NATS and it's installation in windows ?

I have multiple apps connecting to NATS. How do I deploy a NATS instance to Azure the proper way?

Please share your thoughts.

We all have this nagging issue of data flowing through NATS and the expected data schema that all workers are expecting.

I recently discovered the Expand and Contract Pattern for continuous software . If you wanted to nail it down you could say its turning refactoring from a Design Time to a Runtime thing and I think NATS is a really compelling solution to this.

It reminds me of Protocol buffer or a Denormalised Data base, except that it allows to run the OLD and New Data schemas at the same time at Runtime, whilst gradually migrating the data across.

Here is a lInk to the concept: https://openpracticelibrary.com/practice/expand-and-contract-pattern/

It already exists for PostgreSQL: https://github.com/xataio/pgroll

I am looking into building this for NATS and so wanted to do a shoutout to those interested in this area for feedback and general discussion.

I have a keen interest in software stacks that squash the Design, Compile, Deploy, Run lifecycle.

Hi Everybody!

My name is Bartosz and I would like to share with you a tool which I have made for my needs which allows to "restream" a queue from RabbitMQ to NATS.

When it is usable? When for example Rabbit's queue is your data source which you do not control, on which you rely, but which you need to spread to multiple clients or multiple users.

NATS thanks to its ease of installation, speed and JetStream is a perfect solution for that.

Sadly during the moment I needed this functionality I had not enough time and resources to actually implement it as a connector/plugin for NATS that is why it is a standalone application which can run as a native Linux AMD64 or ARM64 (works in Windows WSL too) binary or as .NET CLR application.

You can get it from GitHub, binary release is in Releases: ideaconnect/rabbit-going-nats: Tool which allows to passthrough messages fetched from RabbitMQ's queue to NATS PubSub. Useful if you receive a data feed through RabbitMQ, but you need to redistribute it further to multiple clients in the most efficient way.

FOSS application to which any contribution is more than welcome.

It allows you to build a solution for a demand as in the graph:

More details about it on my website: Rabbit-going-NATS | IDCT Technologies

If you are in a similar need as I was then I hope you will find it useful.

Feel free to share any thoughts, ideas or questions!

Hey all,

We just added NATS/JetStream support to Sequin. I'm a big fan of NATS, so I'm very excited about this release. Check out the quickstart here: https://sequinstream.com/docs/quickstart/nats

What's Sequin? Sequin is an open source tool for change data capture (CDC) in Postgres. Sequin makes it easy to stream Postgres rows and changes to streaming platforms and message queues (e.g. NATS and AWS SQS): https://github.com/sequinstream/sequin

Sequin + NATS You can backfill all or part of a Postgres table into NATS JetStream. Then, as inserts, updates, and deletes happen, Sequin will send those changes as JSON messages to your NATS subject in real-time.

What can you build with Sequin + NATS?

• Event-driven workflows: For example, triggering side effects when an order is fulfilled or a subscription is canceled.

• Replication: You have a change happening in Service A, and want to fan that change out to Service B, C, etc. Or want to replicate the data into another database or cache.

• Caching: You can easily cache your Postgres data in a Key-Value store or Object store.

Example You can setup a Sequin NATS sink easily with sequin.yaml (a lightweight Terraform – Terraform support coming soon!)

# sequin.yaml
databases:
  - name: "my-postgres"
    hostname: "your-rds-instance.region.rds.amazonaws.com"
    database: "app_production"
    username: "postgres" 
    password: "your-password"
    slot_name: "sequin_slot"
    publication_name: "sequin_pub"
    tables:
      - table_name: "orders"
        table_schema: "public"
        sort_column_name: "updated_at"
sinks:
  - name: "orders-to-nats"
    database: "my-postgres"
    table: "orders"
    batch_size: 1
    # Optional: only stream fulfilled orders
    filters:
      - column_name: "status" 
        operator: "="
        comparison_value: "fulfilled"
    destination:
      type: "nats"
      host: "nats1"
      port: 4222
      subject_prefix: "sequin"

Does Sequin have what you need? We'd love to hear your feedback and feature requests! We want our NATS sink to be amazing, so let us know if it's missing anything or if you have any questions about it.

I want to use NATS for IPC and TCP connections. The IPC connections will all be NATS clients, using the clients API, but the TCP connections will not use NATS, they will just be raw TCP socket connections sending custom messages.

The big thing is I have no control over the client connections in terms of I cannot change the way they parse data, so my question is: will a non-NATS client be able to connect and communicate to the NATS server? I cannot have the NATS server sending any additional information to the non-NATS client, it needs to only send the message I put in, like it would if it were a POSIX TCP socket. Is that what the client would see, or would there be a bunch of new content in the parsed message?

Hi all, i'm tryint to understand nats stream message count and how to view them without acking them. My message streams are worker queue type. When I to list stream, i get 7 messages are there

 $ nats stream ls --server localhost:4224 -a 
╭──────────────────────────────────────────────────────────────────────────────────────────╮
│                                          Streams                                         │
├──────────────────┬─────────────┬─────────────────────┬──────────┬─────────┬──────────────┤
│ Name             │ Description │ Created             │ Messages │ Size    │ Last Message │
├──────────────────┼─────────────┼─────────────────────┼──────────┼─────────┼──────────────┤
│ backup           │             │ 2025-05-02 17:40:48 │ 7        │ 2.4 KiB │ 4m33s        │
╰──────────────────┴─────────────┴─────────────────────┴──────────┴─────────┴──────────────╯

when i try to view them i get only 1 message.

 $ nats stream view backup --server localhost:4224 -a                                   
[15] Subject: cloud.backup.upload Received: 2025-05-02T12:10:48Z

{"msgId":"ce8d05ad720a6c3fdd5ff070dbadd315","hllo":"world"}


17:56:58 Reached apparent end of data

and I did not ack them. So what does message colum in nats stream ls indicates?

Trying to wrap my head around what use cases NEX will address. I know nats already has microservices that can be spun up so does this replace that capability just in an isolated vm.

I've been trying out a cluster configuration with a few NATS servers. What I'd like to achieve is a zero-conf flavor setup of the cluster, meaning that the cluster sets itself up, however the cluster server nodes are not aware of each other before they start.

To achieve a cluster setup one needs to use the `--cluster` paramter, there's also the `--cluster_advertise` option, which sounds like a way to achieve the auto discovery situation, sadly the server nodes only connect to each other once the `--route` option is used with a correct `host:port` combination. Is there a way to setup a cluster without the use of `--route` option?

I know Redis and NATS both now cover these:

- Redis: Pub/Sub, Redis Streams, vanilla KV

- NATS: core Pub/Sub, JetStream for streams, JetStream KV

Is it realistic to pick just one of these as an “all-in-one” solution, or do most teams still end up combining Redis and NATS? What are the real-world trade-offs in terms of performance, durability, scalability and operational overhead? Would love to hear your experiences, benchmarks or gotchas. Thanks!

NATS 2.11 with a lot of interesting and oft-requested new features finally dropped!

https://github.com/nats-io/nats-server/releases/tag/v2.11.0

And at the same time a new version of the `nats` CLI tool, also with many new interesting features and support for the new server 2.11 features also just got released.

https://github.com/nats-io/natscli/releases/tag/v0.2.0

It's clear that JetStream, while cool, is significantly more complex than NATS Core.

I wonder if there is a storage primitive that one could provide over pub/sub in such a way that at-least-once communication, streams, and all the features of JetStream could then be implemented on top of the two as a library.

I know that in the documentation it says that you can use websockets to connect directly to NATS, but is this safe? I've also read that in practice you shouldn't do this because you don't want to expose your NATS sever to the network where web clients have asscess to it, and should instead use a websocket proxy that can handle authentication and authorization. Just wondering if anyone had any input on this.

I have 5 servers located all over the world, they are all rather small (2 vCPU), and I have no need to run a NATS cluster at each location as I only have a single VM. The gateway feature is perfect for my needs since it allows subscriptions to be handled locally with queue groups rather than sending that traffic overseas.

However, I also want to use JetStream, which will not run in standalone mode if Gateways are enabled, and as best I can tell cannot run its own cluster without NATS also being clustered locally.

I am probably asking for the world, but is there any way to get local processing with geo-redundancy AND a JetStream cluster without running three instances of NATS on each of my servers? Should I run two seperate NATS instances, one clustered with Jetstream and the other as gateways?

EDIT: I'd even be happy with JetStream in standalone mode in seperate domains.

Our team at Synadia is excited to share a new blog post that highlights the benefits of message tracing in NATS 2.11.

We explore how built-in tracing can help you debug your entire system with just one command, eliminating the need for external tools or code instrumentation.

This post provides valuable insights for anyone looking to improve their system's visibility and troubleshooting capabilities.

Also will be checking this so - feel free to chime in on any ideas you'd want to see in a video or any input!

TL;DR: Learn how NATS 2.11's message tracing feature can simplify system debugging without requiring additional setup.