Building a Redis-Compatible Server in Go

Redis is a powerful in-memory data store, widely used for caching, real-time analytics, and session management. But have you ever thought about building your own Redis-compatible server? Thanks to the redcon library, creating a custom Redis server in Go is easier than you might think. In this post, we’ll explore how to use redcon to implement a simple Redis-compatible server.

What is redcon?

redcon is a Go library for building Redis-compatible servers. It handles the RESP protocol, making it straightforward to create a server that can understand and respond to Redis commands.

Getting Started

First, let’s set up our Go environment and install the redcon library.

Step 1: Install Go

If you haven’t already, download and install Go from the official website.

Step 2: Install redcon

Use go get to install the redcon library:

go get github.com/tidwall/redcon

Implementing the Redis Server

Now, let’s create a simple Redis-compatible server that supports basic commands like PING, SET, and GET.

Step 1: Setting Up the Project

Create a new directory for your project and navigate into it:

mkdir redis-server
cd redis-server

Initialize a new Go module:

go mod init redis-server

Step 2: Writing the Server Code

Create a file named main.go and open it in your favorite text editor. We’ll start by importing the necessary packages and setting up our server.

package main

import (
    "github.com/tidwall/redcon"
    "log"
    "sync"
)

var (
    // Use a map to store key-value pairs
    data = make(map[string]string)
    mu   sync.Mutex
)

func main() {
    // Create a new server
    server := redcon.NewServer(
        ":6379",
        handleCommand,
        func(conn redcon.Conn) bool {
            // This is called when a new client connects
            log.Printf("Client connected: %s", conn.RemoteAddr())
            return true
        },
        func(conn redcon.Conn, err error) {
            // This is called when a client disconnects
            log.Printf("Client disconnected: %s, error: %v", conn.RemoteAddr(), err)
        },
    )

    // Start the server
    log.Println("Starting Redis server on :6379")
    if err := server.ListenAndServe(); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

func handleCommand(conn redcon.Conn, cmd redcon.Command) {
    switch string(cmd.Args[0]) {
    case "PING":
        conn.WriteString("PONG")
    case "SET":
        if len(cmd.Args) != 3 {
            conn.WriteError("ERR wrong number of arguments for 'set' command")
            return
        }
        key := string(cmd.Args[1])
        value := string(cmd.Args[2])
        mu.Lock()
        data[key] = value
        mu.Unlock()
        conn.WriteString("OK")
    case "GET":
        if len(cmd.Args) != 2 {
            conn.WriteError("ERR wrong number of arguments for 'get' command")
            return
        }
        key := string(cmd.Args[1])
        mu.Lock()
        value, ok := data[key]
        mu.Unlock()
        if !ok {
            conn.WriteNull()
        } else {
            conn.WriteBulkString(value)
        }
    default:
        conn.WriteError("ERR unknown command")
    }
}

go run main.go

You should see the message indicating that your server is running:

Starting Redis server on :6379

Testing Your Server

Open another terminal and use redis-cli to test your server:

redis-cli -p 6379

Try running some commands:

127.0.0.1:6379> PING
PONG
127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> GET key
"value"

It’s very easy :)))

Conclusion

Congratulations! You’ve just implemented a basic Redis-compatible server using the redcon library in Go. This server handles basic PING, SET, and GET commands, demonstrating how to use redcon to parse RESP and manage client connections.

While this server is simple, redcon provides the tools to build more complex functionality, such as handling additional Redis commands, managing persistence, or implementing custom logic tailored to your specific needs. Experiment with extending this server and explore the full potential of creating custom Redis-compatible services.

If you found this tutorial helpful, don’t forget to clap and share it with others interested in diving deep into Redis and Go!