Table of Contents
- Introduction
- Prerequisites
- Building the Pub/Sub Server - Initializing the Server - Creating the Pub/Sub Functionality - Handling Subscriptions - Publishing Messages
- Testing the Pub/Sub Server
- Conclusion
Introduction
In this tutorial, we will build a scalable Pub/Sub (Publish/Subscribe) server in Go. Pub/Sub is a messaging pattern where senders of messages, called publishers, do not program the messages directly to specific receivers, called subscribers. Instead, messages are sent to channels, and any subscriber interested in receiving messages from that channel can subscribe to it.
By the end of this tutorial, you will have a basic understanding of how to create a Pub/Sub server in Go and how it can be used for messaging between different parts of a system. We will cover setting up a project, creating the server, handling subscriptions, publishing messages, and testing the server’s functionality.
Prerequisites
To follow along with this tutorial, you should have basic knowledge of the Go programming language. Familiarity with concepts like channels, goroutines, and HTTP servers will be beneficial.
Setting Up
Installing Go
First, make sure Go is installed on your machine. You can download and install it from the official Go website: https://golang.org/dl/
Creating a Project Directory
Create a new directory for your project. Open your terminal or command prompt and navigate to the desired location. Then, create the project directory with the following command:
mkdir pubsub-server
Navigate into the project directory:
cd pubsub-server
Now that we have set up the basics, let’s start building the Pub/Sub server.
Building the Pub/Sub Server
Initializing the Server
Create a new Go file called main.go in the project directory:
touch main.go
Open main.go in your preferred text editor. We will start by initializing the server with basic routing and an HTTP endpoint for subscriptions.
package main
import (
"fmt"
"log"
"net/http"
)
func main() {
http.HandleFunc("/subscribe", handleSubscription)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func handleSubscription(w http.ResponseWriter, r *http.Request) {
// TODO: Implement handleSubscription
}
The main function starts an HTTP server that listens on port 8080. We register the /subscribe endpoint with the handleSubscription function, which we will implement next.
Creating the Pub/Sub Functionality
Let’s create the data structures and functionality for our Pub/Sub server. Add the following code to main.go:
type Message struct {
Content string `json:"content"`
}
type Subscription struct {
ID string
Messages chan Message
}
type PubSubServer struct {
Subscriptions map[string]*Subscription
}
func NewPubSubServer() *PubSubServer {
return &PubSubServer{
Subscriptions: make(map[string]*Subscription),
}
}
func (p *PubSubServer) Subscribe() *Subscription {
subscriptionID := generateRandomID()
subscription := &Subscription{
ID: subscriptionID,
Messages: make(chan Message),
}
p.Subscriptions[subscriptionID] = subscription
return subscription
}
func (p *PubSubServer) Unsubscribe(subscription *Subscription) {
delete(p.Subscriptions, subscription.ID)
close(subscription.Messages)
}
func (p *PubSubServer) Publish(message Message) {
for _, subscription := range p.Subscriptions {
subscription.Messages <- message
}
}
func generateRandomID() string {
// TODO: Implement generating random IDs
return ""
}
In the code above, we define a Message struct that represents a message to be published. The Subscription struct contains an ID and a channel for receiving messages. The PubSubServer struct keeps track of all subscriptions.
The NewPubSubServer function initializes a new PubSubServer instance with an empty subscriptions map.
The Subscribe method generates a random ID, creates a new subscription with an empty message channel, and adds it to the subscriptions map.
The Unsubscribe method removes a subscription from the subscriptions map and closes its message channel.
The Publish method sends a message to all active subscriptions by iterating over the subscriptions and sending the message through their respective channels.
Finally, the generateRandomID function generates a random ID for subscriptions. In a real-world scenario, you would need to implement the actual logic for generating unique IDs.
Handling Subscriptions
Now, let’s implement the handleSubscription function to handle incoming subscription requests and manage subscriptions. Update the handleSubscription function in main.go:
func handleSubscription(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
return
}
subscription := pubsubServer.Subscribe()
w.Header().Set("Content-Type", "text/plain")
w.Write([]byte(subscription.ID))
}
In this code, we first check if the incoming request method is POST. If not, we return a 405 Method Not Allowed status error.
We then create a new subscription using the pubsubServer.Subscribe() method and return the subscription ID in the response.
Publishing Messages
To complete the Pub/Sub functionality, let’s create an endpoint for publishing messages. Add the following code to main.go:
func handlePublish(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
return
}
var message Message
err := json.NewDecoder(r.Body).Decode(&message)
if err != nil {
http.Error(w, "Invalid request body", http.StatusBadRequest)
return
}
pubsubServer.Publish(message)
w.WriteHeader(http.StatusNoContent)
}
func init() {
http.HandleFunc("/publish", handlePublish)
}
var pubsubServer = NewPubSubServer()
In this code, we first define a new handlePublish function that handles incoming publish requests. Similar to the handleSubscription function, we check if the request method is POST and return an error if not.
We then decode the request body into a Message struct, which requires importing the encoding/json package. If there is an error decoding the body, we return a 400 Bad Request error.
Next, we publish the message using the pubsubServer.Publish(message) method.
Finally, we register the handlePublish function as the handler for the /publish endpoint and create an instance of the PubSubServer using the NewPubSubServer function.
Testing the Pub/Sub Server
To test the Pub/Sub server, start the server by running the following command in the terminal:
go run main.go
Now, open another terminal window and send a subscription request to the server using the curl command:
curl -X POST http://localhost:8080/subscribe
You should receive a response containing the subscription ID.
To publish a message, use the following curl command:
curl -X POST -H "Content-Type: application/json" -d '{"content":"Hello, World!"}' http://localhost:8080/publish
This command sends a POST request to the /publish endpoint with a JSON payload containing the message content. Make sure to replace localhost:8080 with the appropriate address if you’re running the server on a different machine.
Conclusion
In this tutorial, we have built a scalable Pub/Sub server in Go. We started by setting up a basic project structure and an HTTP server. Then, we implemented the Pub/Sub functionality, including handling subscriptions and publishing messages. Finally, we tested the server by sending subscription and publish requests.
You can extend this server further by adding authentication, implementing persistence for messages, or introducing more advanced features. Understanding the Pub/Sub pattern and building scalable servers is crucial for many real-world applications.
Now that you have a working Pub/Sub server, feel free to experiment with it, explore Go’s concurrency features, and build more complex messaging systems.
Remember to always write clean and well-structured code, handle errors properly, and test your servers thoroughly before deploying them in production.
Happy coding!