load balancing in a queue group

[jaijiv]

I was experimenting with nats and testing how messages are handled by consumers in a q group. I see that docs says that messages are spread randomly to consumers but was wondering if there is an option somewhere to set to make it process say in a round robin manner? I see reference to this (#610) which implies messages more evenly split among consumers. I have this code and multiple runs indicates that split is not even

package main
import (
     "fmt"
     "log"
     "sync"
     "time"
     "github.com/nats-io/nats.go"
 )
 func main() {
     nc, err := nats.Connect(nats.DefaultURL)
     if err != nil {
         log.Fatalln(err)
     }
     defer nc.Close()
     for i := 1; i <= 10; i++ {
         i := i
         nc.QueueSubscribe("foo.*", "queue.foo", func(msg *nats.Msg) {
             str := fmt.Sprintln("Subscriber :", i, msg.Subject, string(msg.Data))
             msg.Respond([]byte(str))
         })
     }
     var wg sync.WaitGroup
     for i := 1; i <= 10; i++ {
         wg.Add(1)
         i := i
         go func() {
             subject := fmt.Sprintf("foo.%d", i)
             message := fmt.Sprintf("message %d", i)
             if resp, err := nc.Request(subject, []byte(message), 1*time.Second); err != nil {
                 log.Fatalln(err)
             } else {
                 fmt.Print(string(resp.Data))
             }
             wg.Done()
         }()
     }
     wg.Wait()
 }

this is o/p i get - subscriber 5 getting 3 messages, subscriber 2 getting twice
Subscriber : 8 foo.4 message 4
Subscriber : 10 foo.1 message 1
Subscriber : 5 foo.5 message 5
Subscriber : 1 foo.7 message 7
Subscriber : 5 foo.2 message 2
Subscriber : 5 foo.9 message 9
Subscriber : 4 foo.8 message 8
Subscriber : 2 foo.6 message 6
Subscriber : 1 foo.10 message 10
Subscriber : 2 foo.3 message 3

[derekcollison]

For round robin type of behavior, look to JetStream and pull consumers which are round robin.

[Jarema]

This is the best place to look for examples how to leverage Pull Consumers @derekcollison mentioned:

https://github.com/nats-io/nats.go/blob/v1.31.0/jetstream/README.md#continuous-polling

[jaijiv]

Thanks for the pointer. This worked to get round-robin functionality doing js.Publish and cons.Messages(1) / msg.Ack on consumer. Does req/reply semantics work with jetstream?

[Jarema]

You do not need cons.Messages(1) to get round robin. Server will round robin across all fetches.

request/reply across JetStream is somethig we are considering. You can achieve yourserlf in many ways already, for example by providing the destination response subject in requests messages. Can be a header or payload.

[jaijiv]

got it. Thanks for the prompt reply

we are basically trying if nats can be used as a replacement for rabbitmq (primarily req/reply).

use case is a single threaded c service (binary) with multiple endpoints listening on rabbitmq which either processes messages in round robin (across multiple processes of service) or be set up to use consumer priority feature of rabbitmq (multiple processes acting as a pool - preferred as it saves resources like db conns due to service doing lazy boot).

Per your suggestion using jetstream and pull consumers, we should achieve equivalent round robin req/reply functionality. Any suggestions for consumer priority?

It looks like that ideally if core nats could do round robin and consumer priority, it could be the most seamless rmq replacement in our use case (using jetstream opens up possibility of reprocess of req/reply calls by another durable consumer which we absolutely do not want).