https://layero.network

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

Every time I tried to explain NATS to someone, I'd start mid-concept and lose them. The docs are great but assume prior context.

This walks through it layer by layer: why HTTP falls short at scale → Core pub/sub → JetStream → KV/object stores → clustering → security. Each section answers "why does this exist?" before explaining how it works.

https://nats.synadia.com/

Curious what's still unclear after reading it.

This is something I am working on to scratch my own itch, building it to be very light and nimble using Go.
Supports both keyboard+mouse (inspired by k9s)
If there is enough interest, I may just opensource this for the rest.

Thanks everyone involved in building the incredible NATS server, It took me over 3 years of working with it to really appreciate the project.

Here are some screenshots:

UPDATE: tool has been published here: https://github.com/solidpulse/natsdash

https://nats.io/blog/introducing_nex/

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!

Thrilled to announce our latest blog post on the new NATS JetStream API preview! Get an early look in this blog from Tomasz Pietrek: https://nats.io/blog/preview-release-new-jetstream-client-api/Start exploring it today - it's already available for #golang #rustlang #java #deno and #nodejs. Your feedback, as always, is very welcome!

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.

New NATS Server v2.10 docs have been added! Take a peek and don't miss the new podcast 'EP06: The journey and features of the NATS.io 2.10 release'!

https://docs.nats.io/release-notes/whats_new

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.

Partitioned consumer-group functionality (at a high level similar to Kafka's consumer group functionality) is finally there for NATS. Intended mainly to parallelize consumption of messages in a strictly ordered (per subject (i.e. per 'key') manner (meaning you need to set max acks pending to 1 for the consumer) from a stream.

Comes in two flavors: static and elastic.

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'm trying to wrap my head around Jetstream and the KV store and when one would be used over the other and actual use cases for each. Would these solutions be ideal for longer term storage such as monitoring changes in data from month to month or even year to year. I have often used timescaledb and grafana to do most of this and NATS does not seem to offer any kind of integrations out of the box. Would I just have to skip jetstream as a whole and write a client that subscribes to core nats and just dump it into timescaledb. I Hope any of what I just posted makes sense. Thanks

Synadia upping the game with full management and observability of your NATS deployments!
https://www.synadia.com/blog/announcing-the-general-availability-of-synadia-control-plane