Creating a basic HTTP server with Go

Go (or Golang) is a powerful and efficient programming language that excels in building scalable and concurrent applications. In this occasion, we'll walk through the process of creating a simple HTTP server using Go. By the end of this guide, you'll have a basic understanding of how to handle HTTP requests and responses. Today, I'm going to share what I've learnt so far about building an HTTP server wiht Go.

Prerequisites

Before we begin, make sure you have Go installed on your machine. You can download it from the official Go website.

Project Setup

mkdir go-http-server
cd go-http-server

Now, create a file named main.go for our Go code.

// main.go

package main

import (
	"fmt"
	"net/http"
)

func main() {
	// Your HTTP server code will go here
}

Handling an HTTP Request

To handle HTTP requests, we'll use the http package provided by Go. Let's create a simple HTTP handler function that responds to incoming requests.

import (
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
)

func get(w http.ResponseWriter, r *http.Request) {
	fmt.Printf("Responding to GET / /\n")
	io.WriteString(w, "Hello World!\n")
}

Now, let's register this handler function in our HTTP server

func main() {
	http.HandleFunc("/", get)

	err := http.ListenAndServe(":8080", nil)
    if errors.Is(err, http.ErrServerClosed) {
		fmt.Printf("Server closed\n")
	} else if err != nil {
		fmt.Printf("Error starting server: %s\n", err)
		os.Exit(1)
	}
}

Run Your HTTP Server

Save the changes applied to main.go, and you can now run your HTTP server.

go run main.go

Visit http://localhost:8080 in your web browser, and you should see the message "Hello World!".

You can also use the curl command in cmd and you'll also get the same response

curl http://localhost:8080/

And that's it! You have your first HTTP server built with Go.

You can expand it a bit further by using mux to multiplex a server and http.Handler implementation by net/http package, which you can use for a case like this.

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"math/rand"
	"net/http"
	"os"
)

type User struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

var users map[string]User
var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func generateId(n int) string {
	b := make([]rune, n)
	for i := range b {
		b[i] = letterRunes[rand.Intn(len(letterRunes))]
	}

	return string(b)
}

func getUsers(w http.ResponseWriter, r *http.Request) {
	fmt.Printf("Responding to GET /\n")

	usersList := make([]User, 0, len(users))

	for _, user := range users {
		usersList = append(usersList, user)
	}

	res, err := json.Marshal(usersList)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(res)
}

func createUser(w http.ResponseWriter, r *http.Request) {
	fmt.Printf("Responding to POST /")

	var newUser User
	decoder := json.NewDecoder(r.Body)
	err := decoder.Decode(&newUser)

	if err != nil {
		http.Error(w, "Bad Request", http.StatusBadRequest)
		return
	}

	newUser.ID = generateId(12)
	users[newUser.ID] = newUser

	res, err := json.Marshal(newUser)
	if err != nil {
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	w.Write(res)
}

func main() {
	users = make(map[string]User)

	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			getUsers(w, r)
		case http.MethodPost:
			createUser(w, r)
		}
	})

	err := http.ListenAndServe(":8080", mux)

	if errors.Is(err, http.ErrServerClosed) {
		fmt.Printf("Server closed")
	} else if err != nil {
		fmt.Printf("Error starting server: %s\n", err)
		os.Exit(1)
	}
}