Building a Production-Grade WebSocket for Notifications with GoLang and Gin: A Detailed Guide

Explore this detailed guide on building a robust, scalable WebSocket for real-time notifications using GoLang and Gin. From setup to tackling production issues, we cover it all!

Jul 18, 2023

Photo by Christopher Robin Ebbinghaus on Unsplash

Hello, brave coders! Today we’ll tackle the exciting world of WebSockets, armed with the simplicity and power of GoLang and Gin. So grab a cup of coffee and let’s get started!

WebSockets, GoLang, and Gin: An Introduction

WebSockets provide a real-time, two-way communication channel between a client and a server. This powerful technology allows us to transform static pages into live, interactive platforms.

GoLang, or Go, is a statically typed, compiled language known for its simplicity, efficiency, and strong support for concurrent programming. When we combine GoLang with Gin, a high-performance HTTP web framework, we have a dynamic duo that can handle robust applications with ease.

Prepping the Field: Setting Up

First, we need to install GoLang. Once you have GoLang set up, verify the installation by typing:

go version

After ensuring GoLang is installed correctly, let’s get the Gin package:

go get -u github.com/gin-gonic/gin

Finally, we’ll need the gorilla/websocket package, which makes working with WebSocket in Go a breeze:

go get github.com/gorilla/websocket

With the necessary tools in our toolbox, we’re ready to start building.

Building a Basic WebSocket with GoLang and Gin

Our first task is to build a simple WebSocket server that sends a message every second. Here’s the basic blueprint:

package main
import (
 "github.com/gin-gonic/gin"
 "github.com/gorilla/websocket"
 "net/http"
 "time"
)
var upgrader = websocket.Upgrader{
 ReadBufferSize:  1024,
 WriteBufferSize: 1024,
}
func main() {
 router := gin.Default()
 router.GET("/ws", func(c *gin.Context) {
  conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
  if err != nil {
   return
  }
  defer conn.Close()
  for {
   conn.WriteMessage(websocket.TextMessage, []byte("Hello, WebSocket!"))
   time.Sleep(time.Second)
  }
 })
 router.Run(":8080")
}

This basic server does three things:

It upgrades the HTTP connection to a WebSocket connection using the websocket.Upgrader.
It starts a loop that continuously sends a message, “Hello, WebSocket!”, every second.
It serves this on the :8080 port.

Incorporating Real-Time Notifications

Now, let’s add some real-world functionality: notifications. For this example, we’ll send a “new message” notification every second:

func main() {
	router := gin.Default()
	router.GET("/ws", func(c *gin.Context) {
		conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
		if err != nil {
			return
		}
		defer conn.Close()		
                i := 0
		for {
			i++
			conn.WriteMessage(websocket.TextMessage, []byte("New message (#"+strconv.Itoa(i)+")"))
			time.Sleep(time.Second)
		}
	})
      router.Run(":8080")
}

Now, instead of a simple greeting, we send a “New message (#i)” every second, where i is a counter increasing with each sent message.

The Reality Check: WebSocket Issues in Production

As amazing as WebSockets are, they can present challenges when you scale up for production. Some of the common issues include:

Scaling: WebSockets require a persistent connection for each user, which can be resource-intensive as the number of users increases.
Connection Limitations: There may be a limit to the number of simultaneous connections a single server can handle, which depends on your server configuration and hardware.
Connection Drops: WebSocket connections can drop due to network issues or client disconnections. It’s crucial to have a reconnection strategy in place.
Cross-Origin Issues: WebSocket follows the same-origin policy, which might be a hurdle if not handled correctly.

Tactics for Scaling WebSocket Applications

Here are some approaches to scale your WebSocket application effectively:

Load Balancing: Distribute WebSocket connections among multiple servers with a load balancer. Ensure your load balancer supports WebSocket protocol.
Horizontal Scaling: Instead of upgrading a single server (vertical scaling), consider adding more servers (horizontal scaling).
Connection Management: Reuse connections whenever possible by using a connection pool.
Message Broker: A message broker like RabbitMQ or Redis can distribute messages across different servers, handling a higher load.

Integrating RabbitMQ: Message Broker to the Rescue

To showcase how a message broker can help, let’s integrate RabbitMQ into our application. Here’s how it can be done:

package main
import (
 "github.com/gin-gonic/gin"
 "github.com/gorilla/websocket"
 "github.com/streadway/amqp"
 "log"
 "net/http"
 "os"
)
var upgrader = websocket.Upgrader{
 ReadBufferSize:  1024,
 WriteBufferSize: 1024,
}
func main() {
 conn, err := amqp.Dial(os.Getenv("AMQP_URL"))
 if err != nil {
  log.Fatal(err)
 }
 defer conn.Close()
 ch, err := conn.Channel()
 if err != nil {
  log.Fatal(err)
 }
 defer ch.Close()
 msgs, err := ch.Consume(
  "notification_queue",
  "",
  true,
  false,
  false,
  false,
  nil,
 )
 if err != nil {
  log.Fatal(err)
 }
 router := gin.Default()
 router.GET("/ws", func(c *gin.Context) {
  ws, err := upgrader.Upgrade(c.Writer, c.Request, nil)
  if err != nil {
   log.Print("upgrade:", err)
   return
  }
  defer ws.Close()
  for msg := range msgs {
   ws.WriteMessage(websocket.TextMessage, msg.Body)
  }
 })
 router.Run(":8080")
}

In this updated code, we first connect to our RabbitMQ server and start consuming messages from the “notification_queue”. Then, we push these messages to the client via the WebSocket.

Visualizing the System: Mermaid Diagram

Understanding how all these pieces fit together is crucial. Here’s a simple system diagram :

This diagram illustrates how the client connects to the GoLang Gin Server via a WebSocket connection. The GoLang Gin Server interacts with the RabbitMQ Message Broker, consuming messages and pushing them to the client.

Wrapping It Up

Building a scalable WebSocket service with GoLang and Gin can be a fun and enlightening journey. Although production environments bring their share of challenges, with proper design, resource management, and the aid of tools like RabbitMQ, you can conquer them all.

So keep coding, keep exploring, and may your WebSocket applications be ever robust and efficient!

🔗 Connect with me on LinkedIn!

I hope you found this article helpful! If you’re interested in learning more and staying up-to-date with my latest insights and articles, don’t hesitate to connect with me on LinkedIn.

Let’s grow our networks, engage in meaningful discussions, and share our experiences in the world of software development and beyond. Looking forward to connecting with you! 😊

Follow me on LinkedIn ➡️

Hacktivate

Discussion about this post