How do I produce and consume messages in NATS using Go?

NATS (Neural Autonomic Transport System) is a lightweight messaging system that is designed for cloud-native applications and microservices. It allows for high-throughput, low-latency messaging and is a great choice for producing and consuming messages in Go.

Producing Messages in NATS

To produce messages, you first need to establish a connection to the NATS server and then publish messages to a specific subject. Here is an example of how to do that in Go:

package main import ( "fmt" "github.com/nats-io/nats.go" ) func main() { // Connect to NATS nc, err := nats.Connect(nats.DefaultURL) if err != nil { fmt.Println("Error connecting to NATS:", err) return } defer nc.Close() // Publish a message msg := "Hello, NATS!" err = nc.Publish("updates", []byte(msg)) if err != nil { fmt.Println("Error publishing message:", err) return } fmt.Println("Message published successfully!") }

Consuming Messages in NATS

To consume messages, you need to subscribe to a specific subject. The following example demonstrates how to subscribe and handle incoming messages:

package main import ( "fmt" "github.com/nats-io/nats.go" ) func main() { // Connect to NATS nc, err := nats.Connect(nats.DefaultURL) if err != nil { fmt.Println("Error connecting to NATS:", err) return } defer nc.Close() // Subscribe to the subject nc.Subscribe("updates", func(m *nats.Msg) { fmt.Printf("Received message: %s\n", string(m.Data)) }) // Keep the program running to listen for messages select {} }

NATS Go messaging publish subscribe microservices cloud-native message queue

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?