Benchmarking Nodejs and Golang Servers

In this test, I made two servers, one with node (express) and the other with golang (gin) and tested out their performance in handling requests. I used Apache bench for this and logged the results into a log file at the end. Let me give you a glimpse of the servers made to test out.

Make a directory named nodejs and yarn init inside it, this will spit out a package.json file which will contain all the dependencies of the app. Next, create a folder to collect all the logs we are going to do afterwards. I made a folder named express/logs to store all the logs. Then I gave sufficient permissions to the log files to be able to store logs inside it (just a UNIX thing). Then I wrote a basic javascript file named express.js which will act as the server in our case.

mkdir nodejs && cd nodejs
yarn init -y && yarn add express
mkdir express && cd express && mkdir logs && cd logs
touch test1.log test2.log test3.log
chmod 775 test1.log test2.log test3.log

// express.js
const express = require("express");
const app = express();

app.use(express.urlencoded({ extended: true }));
app.use(express.json());

let hitCount = 0;

app.get("/", (req, res) => {
  hitCount += 1;

  const healthcheck = {
    uptime: process.uptime(),
    message: "OK",
    timestamp: Date.now(),
  };
  console.log("HIT:", hitCount, healthcheck);
  console.log();
  try {
    return res.status(200).json({ message: "Hello World" });
  } catch (error) {
    healthcheck.message = error;
    return res.status(503).send();
  }
});

app.listen(3000, () => console.log("Running on port 3000"));

Pretty much everything goes the same in the case of Golang. I created a folder golang and go mod init inside it. This will create a go.mod file to store all the dependencies and their versions for the project. A github.com remote URL is given to be able to convert it to a module and be able to store it on GitHub (just in case). This will enable other people to be able to download our code as a module and use it in their codebases. Then as earlier, we created log files and gave them relevant UNIX permissions. Then I wrote a basic go file named gin.go which will act as the server in our case.

mkdir golang && cd golang
go mod init github.com/m3rashid/load-testing-golang
go get github.com/gin-gonic/gin
mkdir gin && cd gin && mkdir logs && cd logs
touch test1.log test2.log test3.log
chmod 775 test1.log test2.log test3.log

// gin.go
package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
)

var startTime time.Time

func uptime() time.Duration {
    return time.Since(startTime)
}

func init() {
    startTime = time.Now()
}

type HealthCheck struct {
    uptime    string
    message   string
    timestamp string
}

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {

        healthCheck := HealthCheck{
            uptime:    uptime().String(),
            message:   "OK",
            timestamp: time.Now().Format(time.RFC3339),
        }

        fmt.Printf("HealthCheck: %+v", healthCheck)

        c.JSON(http.StatusOK, gin.H{
            "message": "Hello World",
        })
    })
    r.Run(":4000")
}

Since golang is a compiled language, I compiled it to a binary by running go build golang/gin.go. In the end, I did three tests, and the load/concurrency goes as follows. Also, One may argue that Nodejs is single-threaded and hence cannot use all the available resources of the host machine, so just for those guys, I tested dedicated using PM2 on cluster mode at the max number of connections.

Then I tested the servers, The results came as follows.

Test 1

Test 2

Test 3

Results

Inference

In each of the cases above, Golang simply rocks in each of the parameters above. The main parameters of our concern are :

• Failed Requests (Most important): Even in the test 1 category, Nodejs fails to deliver the good performance required for a server-side application.

• Number of bytes transferred (should be lesser as both the servers are sending the same thing)

• Requests per second (determines the actual concurrency throughput): Should be maximum

• Time per request (Golang has an edge here because it is compiled and nodejs (javascript) is interpreted): Should be minimum. Responses must be as quick as possible to provide a good user experience

• Transfer rate (how much the server is capable of): Even if both the test is done on the same network and with the same bandwidth, Golang provides faster delivery (not by a very high margin)

• Waiting time (ms, Average time to wait before handling the request): Requests need to be fulfilled as quickly as possible, and waiting time must be less as a whole