Writing Server Software With Go

Writing Server Software With Go

Mekardo.com - Server software development plays a crucial role in providing specific services and functionalities on a server computer. If you're wondering what exactly server software entails, it refers to the programs and applications installed on a server computer that enable it to handle client requests, manage data storage and retrieval, facilitate communication between devices or applications, and perform various other tasks related to server operations.

In the realm of server software, popular names like Apache, MySQL, MongoDB, Postfix, Redis, and Memcache have become synonymous with the efficient delivery of network services. In this article, we will focus on the development of server software using Go, with a specific emphasis on Linux, the operating system powering the majority of servers on the internet.

1. Why Choose Go for Server Software Development

When it comes to developing server software, many opt for standard tech stacks like Linux, Apache, MySQL, Nginx, Redis, or MongoDB. While these stacks serve well for basic business applications, more complex applications that involve audio, video, instant messaging, or complex data structures require bespoke server software development.

Enter Go, the programming language that has gained popularity due to its simplicity and ability to deliver excellent runtime performance. With Go, developing system applications and server software has become faster and easier. Therefore, it's worth reconsidering the conventional approach of relying solely on a standard tech stack and considering the advantages of crafting tailor-made server software applications.

2. Unveiling the Components of Linux Server Software

Linux, renowned for its stringent approach to system service management with systemd, follows specific guidelines for file organization:

  • Configuration files belong in "/etc/<myserver>"
  • Log files should be written to "/var/log/<myserver>"
  • The binary file resides in "/usr/bin"
  • Data storage is typically located in "/var/<myserver>"

For programming languages such as C, C++, Rust, and Go that compile into a single binary, the binary file is placed in the "/usr/bin" directory. This practice has become a standard convention for Linux development. However, interpreted languages like JavaScript or Python introduce complexity, requiring multiple files to be shipped. In such cases, the "/opt" directory is often utilized. An example of a daemon written in Node.js is the HTTP Time Travel Proxy.

To ensure seamless installation on various Linux distributions, it is ideal to package your server software into "deb" (Debian, Ubuntu, Linux Mint, Kali Linux, Elementary OS, Raspberry Pi OS) or "rpm" (Red Hat, Fedora, CentOS, SUSE) packages. Additionally, providing your server software as a Docker image facilitates quick deployment for users.

3. The Advantages of Go for Server Development Compared to C++ and Node.js

Historically, server products like Apache Webserver, Nginx, MySQL, Postgres, Memcache, and Redis have been predominantly written in C or C++. These languages were chosen for their performance and portability, enabling compilation for various Linux distributions. However, the development process using C and C++ often led to slower progress, increased complexity, and a higher error rate. Memory management in these languages can be extremely intricate, necessitating the use of numerous libraries for satisfactory developer ergonomics.

On the other hand, while it is possible to develop server software in JavaScript or TypeScript using Node.js, there are significant disadvantages. Firstly, shipping the entire source code to the target system exposes your application's code to users, which can be a security concern when marketed through platforms

 like the AWS marketplace or Application Service Providers (ASPs). Moreover, Node.js itself becomes a substantial and sizeable dependency for your application.

Go presents a compelling alternative to C and C++ for server software development. Most server software does not require the extreme runtime performance achieved by C or C++. Considering the success of projects like Kubernetes, written in Go, it becomes evident that Go can be the perfect choice for developing both commercial and open-source server software applications. Go's concurrency, memory management, and compiler make it possible to achieve comparable results to C or C++ with an acceptable compromise in runtime performance.

4. Interacting with the System Using Go

Go provides a straightforward way to "daemonize" any application without extensive modifications to the code. However, it is essential for your Go application to handle signals from the system effectively. For example:

  • Reload the configuration upon receiving SIGHUP
  • Shut down gracefully when SIGINT or SIGTERM is received

Users typically control servers or daemons using the systemd tools available on their Linux systems. The "service" command is commonly employed to manage daemons or system services.

# start the system service
sudo service myserver start

# stop the system service (SIGTERM signal)
sudo service myserver stop

# stop and start the system service (SIGTERM signal)
sudo service myserver restart

# reload the configuration (SIGHUP signal)
sudo service myserver reload

Below is a basic Go application that handles a SIGHUP system call to reload the service configuration:

package main

import "os/signal"
import "os"
import "fmt"
import "syscall"
import "time"

func main() {
  c := make(chan os.Signal, 1)
  signal.Notify(c, syscall.SIGHUP)

  go func(){
    for sig := range c {
      fmt.Println("SIGHUP. Reloading config...")
  for {
    time.Sleep(5000 * time.Millisecond)

Once the SIGHUP signal is received, the application should reload its configuration file, typically located in "/etc/myserver." This signal indicates that a user has made changes to the configuration file and wants the application to apply the updated settings.

a. Setting Up the System Service

System service management with systemd has become relatively straightforward. While ensuring your service has sufficient privileges, it is crucial to follow the least privilege paradigm for enhanced security. To set up your service, you need a "*.service" file in "/etc/systemd/system." Once the service file is stored in this directory, you can execute the command "sudo systemctl daemon-reload" to reload all daemon configurations and your service file. Subsequently, you can start your service using "sudo service myserver start." These simple additions to your Go application enable easy daemonization.

5. Compiling for Different Platforms

With the aforementioned considerations, you have fulfilled the prerequisites for compiling your server software for various platforms, including x86_64 (Intel and AMD) and arm64 (Ampere, Graviton). The following commands enable you to compile your software for different architectures.

Creating a personalized build pipeline for your desired architectures is entirely manageable. However, it is highly recommended to utilize the openSUSE Build Service (OBS) for automated application builds. OBS simplifies the process by providing a comprehensive platform for building applications. To get started, you can refer to the Beginner's Guide for OBS and the Packaging Go article in the help section. While not mandatory, transitioning from manual builds to OBS can streamline your development workflow.

6. Packaging Server Software for Linux

Once your software is ready for release, packaging it as "deb" and "rpm" packages, as well as a Docker image, becomes essential. However, creating packages and images can be a tedious task due to different package managers and formats. To simplify this process, consider leveraging GoReleaser. GoReleaser enables you to create all the necessary packages and images in a single, streamlined process.

a. Commercial Licensing Considerations

If your server software is intended for commercial use, it may be prudent to implement a licensing mechanism such as adding a serial number or activation code to the configuration file. This approach allows you to distribute the binaries freely and require customers to provide the license information in a configuration file.

7. The Evolution of Server Software

For a long time, writing server software predominantly relied on languages like C and C++. However, the emergence of Go and Rust has introduced simpler and more accessible alternatives, facilitating faster development cycles and increased efficiency. Consequently, we are witnessing a shift away from general-purpose software solutions, including relational databases, search engines, and document stores.

In recent years, new database systems, networking services, container services, and various other tools have emerged. Projects like Kubernetes, written in Go, have demonstrated that complex, performance-intensive software can be effectively developed using Go.

The future of server software is being shaped by modern programming languages like Go, enabling developers to build robust and efficient applications that cater to the evolving needs of the industry.

Remember, the key to successful server software development lies not only in choosing the right technology but also in understanding the specific requirements of your application. With Go's simplicity, concurrency, and performance, you have a powerful tool at your disposal to create high-performing server software tailored to your unique needs.

Post a Comment

Previous Post Next Post