Download as PDF, PPTX
![RUBY
require 'nats/client'
NATS.start do |nc|
nc.subscribe("hello") do |msg|
puts "[Received] #{msg}"
end
nc.publish("hello", "world")
end](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-39-2048.jpg)
![GO
nc, err := nats.Connect()
// ...
nc.Subscribe("hello", func(m *nats.Msg){
fmt.Printf("[Received] %s", m.Data)
})
nc.Publish("hello", []byte("world"))](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-40-2048.jpg)
![ASYNCHRONOUS IO
Note: Most clients have asynchronous behavior
nc, err := nats.Connect()
// ...
nc.Subscribe("hello", func(m *nats.Msg){
fmt.Printf("[Received] %s", m.Data)
})
for i := 0; i < 1000; i ++ {
nc.Publish("hello", []byte("world"))
}
// No guarantees of having sent the bytes yet!
// They may still just be in the flushing queue.](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-42-2048.jpg)
![ASYNCHRONOUS IO
In order to guarantee that the published messages have
been processed by the server, we can do an extra
ping/pong to con rm they were consumed:
nc.Subscribe("hello", func(m *nats.Msg){
fmt.Printf("[Received] %s", m.Data)
})
for i := 0; i < 1000; i ++ {
nc.Publish("hello", []byte("world"))
}
// Do a PING/PONG roundtrip with the server.
nc.Flush()
SUB hello 1rnPUB hello 5rnworldrn..PINGrn
Then ush the bu er and wait for PONGfrom server](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-43-2048.jpg)
![ASYNCHRONOUS IO
Worst way of measuring NATS performance
nc, _ := nats.Connect(nats.DefaultURL)
msg := []byte("hi")
nc.Subscribe("hello", func(_ *nats.Msg) {})
for i := 0; i < 100000000; i++ {
nc.Publish("hello", msg)
}](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-44-2048.jpg)
![SUBJECTS AUTHORIZATION
Can customize disallowing pub/sub on certain subjects via
server con g too:
authorization {
admin = { publish = ">", subscribe = ">" }
requestor = {
publish = ["req.foo", "req.bar"]
subscribe = "_INBOX.*"
}
users = [
{user: alice, password: foo, permissions: $admin}
{user: bob, password: bar, permissions: $requestor}
]
}](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-52-2048.jpg)
![DISTRIBUTION QUEUES
Service A workers subscribe to service.Aand create
workersdistribution queue group for balancing the work.
nc, _ := nats.Connect(nats.DefaultURL)
// SUB service.A workers 1rn
nc.QueueSubscribe("service.A", "workers",
func(m *nats.Msg) {
nc.Publish(m.Reply, []byte("hi!"))
})](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-77-2048.jpg)
![LOWEST LATENCY RESPONSE
NATS requests were designed exactly for this
nc, _ := nats.Connect(nats.DefaultURL)
t := 250*time.Millisecond
// Request sets to AutoUnsubscribe after 1 response
msg, err := nc.Request("service.B", []byte("help"), t)
if err == nil {
fmt.Println(string(msg.Data))
// => sure!
}
nc, _ := nats.Connect(nats.DefaultURL)
nc.Subscribe("service.B", func(m *nats.Msg) {
nc.Publish(m.Reply, []byte("sure!"))
})](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-82-2048.jpg)
![UNDERSTANDING NATS TIMEOUT
Note: Making a request involves establishing a client
timeout.
t := 250*time.Millisecond
_, err := nc.Request("service.A", []byte("help"), t)
fmt.Println(err)
// => nats: timeout
This needs special handling!](https://image.slidesharecdn.com/strangeloop-nats-talk-160920042725-160926155339/75/The-Zen-of-High-Performance-Messaging-with-NATS-83-2048.jpg)
Uploaded byApcera
The Zen of High Performance Messaging with NATS
The document presents an overview of NATS, a high-performance messaging system designed for simplicity and reliability in distributed systems. It details the architecture, operational concepts like publish/subscribe messaging, and illustrates various use cases including service communication and distributed load balancing. The talk emphasizes that while NATS prioritizes performance and simplicity, it allows for building higher-level guarantees on top of its basic functionalities.
More Related Content
Similar to The Zen of High Performance Messaging with NATS
![Vibe Coding vs. Spec-Driven Development [Free Meetup]](https://cdn.slidesharecdn.com/ss_thumbnails/vibecodingvsspecdrivendevelopment-251209105622-43f455e7-thumbnail.jpg?width=640&height=640&fit=bounds)
The Zen of High Performance Messaging with NATS
- 1. The Zen ofHigh Performance Messaging with NATS Waldemar Quevedo / @wallyqs Strange Loop 2016
- 2. ABOUT Waldemar Quevedo / SoftwareDeveloper at in SF Development of the Apcera Platform Past: PaaS DevOps at Rakuten in Tokyo NATS client maintainer (Ruby, Python) @wallyqs Apcera
- 3. ABOUT THIS TALK Whatis NATS Design from NATS Building systems with NATS
- 4.
- 5. NATS High Performance MessagingSystem Created by First written in in 2010 Originally built for Cloud Foundry Rewritten in in 2012 Better performance Open Source, MIT License Derek Collison Ruby Go https://github.com/nats-io
- 6. THANKS GO TEAM Smallbinary → Lightweight Docker image No deployment dependencies ✌
- 7. Acts as analways available dial-tone
- 8.
- 9. single byte message Around10M messages/second
- 10. MUCH BETTER BENCHMARK From's awesome blog@tyler_treat (2014)http://bravenewgeek.com/dissecting-message-queues/
- 11. NATS = Performance+ Simplicity
- 12.
- 13. NATS Design constrained tokeep it as operationally simple and reliable as possible while still being both performant and scalable.
- 14.
- 15. Simplicity buys youopportunity. ー Rich Hickey, Cognitect Link: https://www.youtube.com/watch?v=rI8tNMsozo0
- 16. LESS IS BETTER Concisefeature set (pure pub/sub) No built-in persistence of messages No exactly-once-delivery promises either Those concerns are simpli ed away from NATS
- 17.
- 18. What could bethe fastest, simplest and most reliable way of writing and reading to a socket to communicate with N nodes?
- 19. DESIGN TCP/IP based Plain textprotocol Pure pub/sub re and forget at most once
- 20.
- 21.
- 22. Connecting to thepublic demo server… telnet demo.nats.io 4222 INFO {"tls_required":false,"max_payload":1048576,...}
- 23. Optionally giving aname to the client connect {"name":"nats-strangeloop-client"} +OK
- 24. Pinging the server,we should get a pong back ping PONG
- 25. Not following ping/ponginterval, results in server disconnecting us. INFO {"auth_required":false,"max_payload":1048576,...} PING PING -ERR 'Stale Connection' Connection closed by foreign host.
- 26. Subscribe to thehellosubject identifying it with the arbitrary number 10 sub hello 10 +OK
- 27. Publishing on hellosubjecta payload of 5 bytes sub hello 10 +OK pub hello 5 world
- 28. Message received! telnet demo.nats.io4222 sub hello 10 +OK pub hello 5 world MSG hello 10 5 world Payload is opaque to the server! It is just bytes, but could be json, msgpack, etc…
- 29.
- 30. PROBLEM How can wesend a request and expect a response back with pure pub/sub?
- 31. NATS REQUESTS Initially, clientmaking the request creates a subscription with a string:unique identi er SUB _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 2 +OK NATS clients libraries have helpers for generating these: nats.NewInbox() // => _INBOX.ioL1Ws5aZZf5fyeF6sAdjw
- 32. NATS REQUESTS Then itexpresses in the topic:limited interest SUB _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 2 UNSUB 2 1 tells the server to unsubscribe from subscription with sid=2 after getting 1 message
- 33. NATS REQUESTS Then therequest is published to a subject (help), tagging it with the ephemeral inbox just for the request to happen: SUB _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 2 UNSUB 2 1 PUB help _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 6 please
- 34. NATS REQUESTS Then ithere is another subscriber connected and interested in the helpsubject, it will receive a message with that inbox: # Another client interested in the help subject SUB help 90 # Receives from server a message MSG help 90 _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 6 please # Can use that inbox to reply back PUB _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 11 I can help!
- 35. NATS REQUESTS Finally, ithe client which sent the request is still connected and interested, it will be receiving that message: SUB _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 2 UNSUB 2 1 PUB help _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 6 please MSG _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 2 11 I can help!
- 36. Simple Protocol ==Simple Clients
- 37. Given the protocolis simple, NATS clients libraries tend to have a very small footprint as well.
- 38.
- 39. RUBY require 'nats/client' NATS.start do|nc| nc.subscribe("hello") do |msg| puts "[Received] #{msg}" end nc.publish("hello", "world") end
- 40. GO nc, err :=nats.Connect() // ... nc.Subscribe("hello", func(m *nats.Msg){ fmt.Printf("[Received] %s", m.Data) }) nc.Publish("hello", []byte("world"))
- 41. MANY MORE AVAILABLE CC# Java Python NGINX Spring Node.js Elixir Rust Lua Erlang PHP Haskell Scala Perl Many thanks to the community!
- 42. ASYNCHRONOUS IO Note: Mostclients have asynchronous behavior nc, err := nats.Connect() // ... nc.Subscribe("hello", func(m *nats.Msg){ fmt.Printf("[Received] %s", m.Data) }) for i := 0; i < 1000; i ++ { nc.Publish("hello", []byte("world")) } // No guarantees of having sent the bytes yet! // They may still just be in the flushing queue.
- 43. ASYNCHRONOUS IO In orderto guarantee that the published messages have been processed by the server, we can do an extra ping/pong to con rm they were consumed: nc.Subscribe("hello", func(m *nats.Msg){ fmt.Printf("[Received] %s", m.Data) }) for i := 0; i < 1000; i ++ { nc.Publish("hello", []byte("world")) } // Do a PING/PONG roundtrip with the server. nc.Flush() SUB hello 1rnPUB hello 5rnworldrn..PINGrn Then ush the bu er and wait for PONGfrom server
- 44. ASYNCHRONOUS IO Worst wayof measuring NATS performance nc, _ := nats.Connect(nats.DefaultURL) msg := []byte("hi") nc.Subscribe("hello", func(_ *nats.Msg) {}) for i := 0; i < 100000000; i++ { nc.Publish("hello", msg) }
- 45.
- 46. The client isa slow consumer since it is not consuming the messages which the server is sending fast enough. Whenever the server cannot ush bytes to a client fast enough, it will disconnect the client from the system as this consuming pace could a ect the whole service and rest of the clients. NATS Server is protecting itself
- 47. NATS = Performance+ Simplicity + Resiliency
- 48. ALSO INCLUDED Subject routingwith wildcards Authorization Distribution queue groups for balancing Cluster mode for high availability Auto discovery of topology Secure TLS connections with certi cates /varzmonitoring endpoint used by nats-top
- 49. SUBJECTS ROUTING Wildcards: * SUBfoo.*.bar 90 PUB foo.hello.bar 2 hi MSG foo.hello.bar 90 2 hi e.g. subscribe to all NATS requests being made on the demo site: telnet demo.nats.io 4222 INFO {"auth_required":false,"version":"0.9.4",...} SUB _INBOX.* 99 MSG _INBOX.ioL1Ws5aZZf5fyeF6sAdjw 99 11 I can help!
- 50. SUBJECTS ROUTING Full wildcard:> SUB hello.> 90 PUB hello.world.again 2 hi MSG hello.world.again 90 2 hi Subscribe to all subjects and see whole tra c going through the server: telnet demo.nats.io 4222 INFO {"auth_required":false,"version":"0.9.4",...} sub > 1 +OK
- 51. SUBJECTS AUTHORIZATION Clients arenot allowed to publish on _SYSfor example: PUB _SYS.foo 2 hi -ERR 'Permissions Violation for Publish to "_SYS.foo"'
- 52. SUBJECTS AUTHORIZATION Can customizedisallowing pub/sub on certain subjects via server con g too: authorization { admin = { publish = ">", subscribe = ">" } requestor = { publish = ["req.foo", "req.bar"] subscribe = "_INBOX.*" } users = [ {user: alice, password: foo, permissions: $admin} {user: bob, password: bar, permissions: $requestor} ] }
- 53.
- 54. FAMILIAR SCENARIO Service Aneeds to talk to services B and C
- 55.
- 56. COMMUNICATING WITHIN A DISTRIBUTEDSYSTEM Just use HTTP everywhere? Use some form of point to point RPC? What about service discovery and load balancing? What if sub ms latency performance is required?
- 57.
- 58. WHAT NATS GIVESUS publish/subscribe based low latency mechanism for communicating with 1 to 1, 1 to N nodes An established TCP connection to a server A dial tone
- 59. COMMUNICATING THROUGH NATS UsingNATS for internal communication
- 60. HA WITH NATSCLUSTER Avoid SPOF on NATS by assembling a full mesh cluster
- 61. HA WITH NATSCLUSTER Clients reconnect logic is triggered
- 62. HA WITH NATSCLUSTER Connecting to a NATS cluster of 2 nodes explicitly srvs := "nats://10.240.0.11:4222,nats://10.240.0.21:4223" nc, _ := nats.Connect(srvs) Bonus: Cluster topology can be discovered dynamically too!
- 63.
- 64. We can startwith a single node…
- 65. Then have newnodes join the cluster…
- 66. As new nodesjoin, server announces INFOto clients.
- 67. Clients auto recongure to be aware of new nodes.
- 68. Clients auto recongure to be aware of new nodes.
- 69.
- 70. On failure, clientsreconnect to an available node.
- 71.
- 72. HEARTBEATS For announcing liveness,services could publish heartbeats
- 73. HEARTBEATS → DISCOVERY Heartbeatscan help too for discovering services via wildcard subscriptions. nc, _ := nats.Connect(nats.DefaultURL) // SUB service.*.heartbeats 1rn nc.Subscribe("service.*.heartbeats", func(m *nats.Msg) { // Heartbeat from service received })
- 74. DISTRIBUTION QUEUES Balance workamong nodes randomly
- 75. DISTRIBUTION QUEUES Balance workamong nodes randomly
- 76. DISTRIBUTION QUEUES Balance workamong nodes randomly
- 77. DISTRIBUTION QUEUES Service Aworkers subscribe to service.Aand create workersdistribution queue group for balancing the work. nc, _ := nats.Connect(nats.DefaultURL) // SUB service.A workers 1rn nc.QueueSubscribe("service.A", "workers", func(m *nats.Msg) { nc.Publish(m.Reply, []byte("hi!")) })
- 78. DISTRIBUTION QUEUES Note: NATSdoes not assume the audience!
- 79. DISTRIBUTION QUEUES All interestedsubscribers receive the message
- 80. LOWEST LATENCY RESPONSE ServiceA communicating with fastest node from Service B
- 81. LOWEST LATENCY RESPONSE ServiceA communicating with fastest node from Service B
- 82. LOWEST LATENCY RESPONSE NATSrequests were designed exactly for this nc, _ := nats.Connect(nats.DefaultURL) t := 250*time.Millisecond // Request sets to AutoUnsubscribe after 1 response msg, err := nc.Request("service.B", []byte("help"), t) if err == nil { fmt.Println(string(msg.Data)) // => sure! } nc, _ := nats.Connect(nats.DefaultURL) nc.Subscribe("service.B", func(m *nats.Msg) { nc.Publish(m.Reply, []byte("sure!")) })
- 83. UNDERSTANDING NATS TIMEOUT Note:Making a request involves establishing a client timeout. t := 250*time.Millisecond _, err := nc.Request("service.A", []byte("help"), t) fmt.Println(err) // => nats: timeout This needs special handling!
- 84. UNDERSTANDING NATS TIMEOUT NATSis re and forget, reason for which a client times out could be many things: No one was connected at that time service unavailable Service is actually still processing the request service took too long Service was processing the request but crashed service error
- 85. CONFIRM AVAILABILITY OF SERVICENODE WITH REQUEST Each service node could have its own inbox A request is sent to service.Bto get a single response, which will then reply with its own inbox, (no payload needed). If there is not a fast reply before client times out, then most likely the service is unavailable for us at that time. If there is a response, then use that inbox in a request SUB _INBOX.123available 90 PUB _INBOX.123available _INBOX.456helpplease...
- 86.
- 87. NATS is asimple, fast and reliable solution for the internal communication of a distributed system. It chooses simplicity and reliability over guaranteed delivery. Though this does not necessarily mean that guarantees of a system are constrained due to NATS! → https://en.wikipedia.org/wiki/End-to-end_principle
- 88. We can alwaysbuild strong guarantees on top, but we can't always remove them from below. Tyler Treat, Simple Solutions to Complex Problems Replayability can be better than guaranteed delivery Idempotency can be better than exactly once delivery Commutativity can be better than ordered delivery Related NATS project: NATS Streaming
- 89. REFERENCES High Performance Systemsin Go (Gophercon 2014) Derek Collison ( ) Dissecting Message Queues (2014) Tyler Treat ( ) Simplicity Matters (RailsConf 2012) Rich Hickey ( ) Simple Solutions for Complex Problems (2016) Tyler Treat ( ) End To End Argument (1984) J.H. Saltzer, D.P. Reed and D.D. Clark ( ) link link link link link
- 90. THANKS! /github.com/nats-io @nats_io Play withthe demo site! telnet demo.nats.io 4222