Building a Web Server in Go from Scratch

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up Go
  4. Creating an HTTP Server
  5. Handling HTTP Requests
  6. Sending HTTP Responses
  7. Conclusion

Introduction

Welcome to the tutorial on building a web server in Go from scratch! In this tutorial, we will walk through the process of creating a basic HTTP server using the Go programming language. By the end, you will have a solid understanding of how to build a web server that can handle HTTP requests and send responses.

Prerequisites

Before getting started, make sure you have the following prerequisites:

  1. Basic knowledge of the Go programming language.

  2. Go installed on your system.

Setting Up Go

First, let’s make sure you have Go properly installed on your system. Follow these steps:

  1. Download the latest version of Go from the official website: https://golang.org/dl/

  2. Install Go by running the downloaded installer.

  3. Verify the installation by opening a terminal or command prompt and running the following command:

     go version

    If Go is successfully installed, you should see the version displayed in the terminal.

Creating an HTTP Server

Now that we have Go set up, let’s start by creating a basic HTTP server.

Create a new Go file called main.go and open it in your preferred text editor.

package main

import (
	"fmt"
	"net/http"
)

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "Hello, World!")
}

In the above code, we import the necessary packages, define a main function, and register a handler function using http.HandleFunc(). The handler function will be called whenever an HTTP request is received at the root URL (“/”). Inside the handler function, we use fmt.Fprint() to send a simple “Hello, World!” response back to the client.

Save the file and open a terminal or command prompt in the same directory as the main.go file. Run the following command to start the HTTP server:

go run main.go

If everything goes well, you should see the following output:

Listening on :8080...

Congratulations! You have just created a basic HTTP server in Go.

Handling HTTP Requests

Now that our server is up and running, let’s learn how to handle different types of HTTP requests.

Modify the handler function in your main.go file as follows:

func handler(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		handleGetRequest(w, r)
	case http.MethodPost:
		handlePostRequest(w, r)
	default:
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	}
}

func handleGetRequest(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "This is a GET request!")
}

func handlePostRequest(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, "This is a POST request!")
}

In the modified code, we use a switch statement to determine the HTTP request method (r.Method). If it’s a GET request, we call the handleGetRequest function; if it’s a POST request, we call the handlePostRequest function. For any other request method, we return a “Method Not Allowed” response using http.Error().

Save the file and restart the server using go run main.go. The server will now respond differently based on the type of the HTTP request it receives.

Sending HTTP Responses

Let’s take our server a step further and understand how to send more complex HTTP responses.

Modify the handleGetRequest function in your main.go file as follows:

func handleGetRequest(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	response := `{"message": "Hello, World!"}`
	fmt.Fprint(w, response)
}

In the updated code, we set the Content-Type header to application/json using w.Header().Set(). Then, we create a simple JSON response string and send it using fmt.Fprint().

Save the file and restart the server. Now, when you make a GET request to the server, you will receive a JSON response containing the “message” field.

Conclusion

In this tutorial, we covered the process of building a basic web server in Go from scratch. We learned how to set up Go, create an HTTP server, handle different types of HTTP requests, and send appropriate responses. With the knowledge gained from this tutorial, you can now expand your web server to handle more complex scenarios and start building real-world applications with Go.

Remember that this is just the beginning, and there is much more to explore in the world of web programming with Go. Continue to practice and explore the various libraries and frameworks available to enhance your Go web development skills.

Happy coding!

Published:

Related Articles