Course Introduction

What You'll Learn in This Course

Golang Useful Resources and Tools

The authors

The history of Go

Installing Go

Golang: An Overview of Fundamental Concepts

Introduction

A Quick Primer on Key-Value Servers and Hash Tables

How to Create a Basic hello world Webserver with Go

Build a Basic hello world JSON API Server with Go + Chi

How to Create an In-Memory Hash Table API with Go + Chi

Conclusion

A key-value server

Testing a key-value server

What is End-to-End Testing, Integration Testing, and Unit Testing?

Writing Unit Tests for JSON Functions in Go

Parallel Testing in Golang: How to Use t.Parallel()

A Brief Overview of Golang Benchmarks

Integration testing

Further testing types

Distributed key-value server

What is Distributed Consensus and How Does it Work?

An Introduction to Using Raft for Distributed Consensus

Create a Distributed Webserver using Golang and Raft

Connecting Golang Servers With a Handler and Middleware

Building a Store Package to Sync Data in Go with Raft's FSM

Testing Distributed Golang Webservers in Docker Containers

Distributed Key Value Server

Monitoring

White Box Monitoring vs Black Box Monitoring

A Introduction to Golang Logging

Defining and Implementing Distributed System Tracing with Go

Alerting

Understanding the Basics of Canary Deployments

Wait, what's a load balancer?

What aren't we doing?

So what will we be doing?

How to Create a Basic Random-per-request Load Balancer

What is Weighted Round Robin Load Balancing?

Streamlining Configuration Updates for Canary Deployments

Other considerations

Three Open-Source Load Balancers Written in Go

A canary deployment server

Chat server

Chatting about chat servers

What features don't we want (yet)?

What features do we want?

Using a SQLite database in Golang

How to Create an API for a Golang Chat Server

Creating a Frontend Interface in Go for a Chat Server

How to Deploy a Golang Webserver With Docker

Future improvements

Future thinking

Project ideas

Areas of more research

In this book we will show you the some of the concerns of backend web development through the lens of Go.

It is taught by Nat Welch (formerly an SRE at Google) and Steve McCarthy (Etsy), two Go developers who have been writing software for more than 25 years combined.

In the course, we'll be covering the creation and concerns of a number of fundamental backend building blocks or larger applications:

- A key value server, including the use of distributed consensus algorithms
- A canary deployment server
- A real time chat service
- Testing and monitoring

Regardless of your background, Go can make you a _better backend developer_, but learning Go is challenging because the language looks simple on the outside, but you won't get its full benefit unless you know what it can _really_ do. 

**By the end of the first chapter, you'll already _have built a key-value server reminiscent of similar systems like Redis and memcached._** The subsequent chapters will dive into more hands-on projects and Go concepts including:

- How to test your Go systems with unit tests and integration tests
- **Project**: create a **distributed version of the key-value server** in order to solve the typical problems of server systems such as _node failure_
- How to solve the **problem of "consensus"** in distributed Go systems
- How to write code to **keep data in sync** when running a system for servers located around the globe
- Implementing **black box and white box monitoring** systems for Go servers
- **Project**: building a **load balancer server** from scratch
- Why and how to implement a **canary deployment server** for bug-free gradual deployments
- How to build a **configuration server** to allow zero-downtime deploys 
- Understanding the various tradeoffs in the **design decisions** for Go server systems
- **Project**: build a Go chat server system from the ground up 
- **Database modeling** for backend development as part of your chat server project
- **and a lot more**...

## A Key-Value Server Like Redis And Memcached

n the early chapters of the book we learn how to build a Golang version of a key-value server that works in a manner similar to Redis and Memcached. You'll implement each of these features in Go:

- set and retrieve values by key
- adding persistent storage
- using data encodings such as `JSON` and `base64`
- testing the server with unit tests and integration tests

In these chapters, we also learn how to build a more advanced solution for the problem: **a distributed version of the key-value server**. You will learn how to use **consensus algorithms** in Go to solve the problem of keeping distributed servers in sync. The solid grounding you get in programming Go in these first chapters readies you for more complex Go projects.

## A Real-Time Chat Service

A real-time chat server implemented in Go gives you the opportunity to bring together systems thinking as well as concerns common for web apps:

- relational data modeling with SQL
- authentication
- implementing RESTful resources

Working through this comprehensive project will give you **a high degree of confidence about using Go to implement a huge project from scratch**. You will feel ready to use Go with relational databases such as PostgreSQL or MySQL, and databases in general.

## A Canary Deployment Server And Load Balancer

The work you do in the chapters covering building a canary deployment server and load balancer will open your eyes to the full power of Go. Gradual deployments are a commonly used strategy for code deployments, and the projects you build in these chapters get you familiar with building this kind of **infrastructure software**. 

Your load balancer will implement _random-per-request_ as well as _round-robin_ load balancing. These projects will give you a thorough immersion in systems problem solving with Go. You'll be able to show off your skills on bold projects of your own, in job interviews, and on the job when collaborating with colleagues.

## This book is the _fastest_ way to learn modern backend Go development

With _The newline Guide to Reliable Webservers with Go_, you won't waste time reading shallow blog posts that can't go beyond showing you the simplest Go examples or Todo apps. Instead, **within the first chapter** you'll be well on your way to creating a **Redis-like key-value server**, and the complexity of the systems you're able to build only accelerates from there.

This book opens the door to **more effective backend development** and utilizing the full power of Golang for **microservices**. As Go transforms the systems development landscape, you can use this book and the skills it teaches you to contribute to a faster, more effective systems development experience for your team.

With _The newline Guide to Reliable Webservers with Go_ you can **go from novice to proficiency in Go in a predictable way, without wasting time, and without picking up bad Go coding habits**.

So grab a copy now to advance your journey with Go.

In this book we show important concepts in backend web development through the lens of Go.

Reliable Webservers with Go

The importance of testing your web servers

How to apply distributed consensus algorithms to your key value server

Let's go through the pieces necessary to create our random-per-request load balancer.

A quick note about the code in this chapter:

 Because we won't be using any packages outside of the standard library, programs listed here won't include the 

 tool will allow you to automatically add those sections to your code.

The first thing we will need is someplace to store our state. We have two servers we will be pointing at, and these servers' structs will both be storing their reverse proxy information.

We'll also need the ratio of how many requests we want to go to one versus the other. And because we are choosing randomly, we can include our random seed in all of this state.

So create a new directory for our canary deployment server, and then we can start our 

func main() {
	// We'll fill this in later.
}

// Server defines settings for this specific server.
type Server struct {
	proxy *httputil.ReverseProxy
}

// NewServer creates a Server reverse proxy for the given URL.
func NewServer(sURL string) (Server, error) {
	serverURL, err := url.Parse(sURL)
	if err != nil {
		return Server{}, err
	}

	return Server{proxy: httputil.NewSingleHostReverseProxy(serverURL)}, nil
}

// LoadBalancer is a collection of Servers.
type LoadBalancer struct {
	servers []Server
	rng     *rand.Rand
	ratio   int // Positive int less than or equal to 10
}

 is a helper method that'll make it easier for us to set up backends in the future.

 standard library package. We're using this so we don't have to write our own reverse proxy. Even though that might be fun, there are a number of RFCs (

) that determine what headers need to be stripped from the request, among other things that we probably want to let someone else handle for us. If you want to see what you're missing, check out the 

Now that we have our state handled, we need to determine how to choose the right server to send each request to. Since we'll assume we always have two servers available, we only have to choose a random number, see if it is greater than our ratio, and use that to determine what server to send it to. It ends up looking like this.

// NextServer generates a random integer to determine if the 1st or 2nd Server should be proxied to.
// When the random integer is greater or equal to the ratio, proxy the request to the 2nd Server.
//
// We always assume there are two Servers.
func (lb *LoadBalancer) NextServer() *Server {
	index := 0
	if lb.rng.Intn(10) >= lb.ratio {
		index = 1
	}

	return lb.servers[index]
}

With that out of the way, actually handling the request becomes easy. We choose a server, and then we reverse proxy the request to it.

// ProxyRequest forwards the request to the Server.
func (lb *LoadBalancer) ProxyRequest(w http.ResponseWriter, r *http.Request) {
	server := lb.NextServer()
	server.proxy.ServeHTTP(w, r)
}

Now that we have all the pieces, we can glue them together with a 

 function. It has flags for the URLs of our servers which are used as parameters to the 

 function to create our reverse proxies. Then we can create our load balancer with the servers and start it up.

func main() {
	var (
		s1    = flag.String("s1", "http://localhost:8080/", "first server")
		s2    = flag.String("s2", "http://localhost:8081/", "second server")
		ratio = flag.Uint("ratio", 5, "How many requests out of 10 should go to server 1, default 5")
	)
	flag.Parse()

	server1, err := NewServer(*s1)
	if err != nil {
		log.Fatalf("Couldn't setup server1: %s", err)
	}
	server2, err := NewServer(*s2)
	if err != nil {
		log.Fatalf("Couldn't setup server2: %s", err)
	}

	loadBalancer := LoadBalancer{
		servers: []Server{server1, server2},
		rng:     rand.New(rand.NewSource(time.Now().UnixNano())),
		ratio:   int(*ratio),
	}

	server := &http.Server{
		Addr:    ":8888",
		Handler: http.HandlerFunc(loadBalancer.ProxyRequest),
	}

	log.Fatal(server.ListenAndServe())
}

Now that we have the code written, we should make sure it works. To do that, we need to have two servers to test with, and we'll need to start our load balancer, and then send the requests.

Let's create a new file in a different directory for this test, since it will need its own 

 function to run it all. Call the directory 

Start by creating the server functions we need to test with in our 

func main() {
	// TODO
}

// SimpleServer sets up a simple server that always returns a message on the specified port.
func SimpleServer(port, message string) {
	serveMux := http.NewServeMux()
	serveMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain")
		fmt.Fprintf(w, message+"\n")
	})

	log.Fatalln(http.ListenAndServe(":"+port, serveMux))
}

These servers are very simple. They accept any request to any path and return whatever message we set them up with.

 the server. However, that means we will need to run this method in a Go routine, by prepending 

 to it, otherwise we would never get past the server starting up.

---
title: "How to Create a Basic Random-per-request Load Balancer"
# description: desc
# privateVideoUrl: url
---

# A basic random-per-request load balancer

Let's go through the pieces necessary to create our random-per-request load balancer.

_A quick note about the code in this chapter:_ Because we won't be using any packages outside of the standard library, programs listed here won't include the `package main` line nor the imports.
Luckily, the [`goimports`](https://pkg.go.dev/golang.org/x/tools/cmd/goimports) tool will allow you to automatically add those sections to your code.

The first thing we will need is someplace to store our state. We have two servers we will be pointing at, and these servers' structs will both be storing their reverse proxy information.

We'll also need the ratio of how many requests we want to go to one versus the other. And because we are choosing randomly, we can include our random seed in all of this state.

So create a new directory for our canary deployment server, and then we can start our `load_balancer.go` file like this.

```go
func main() {
	// We'll fill this in later.
}

// Server defines settings for this specific server.
type Server struct {
	proxy *httputil.ReverseProxy
}

// NewServer creates a Server reverse proxy for the given URL.
func NewServer(sURL string) (Server, error) {
	serverURL, err := url.Parse(sURL)
	if err != nil {
		return Server{}, err
	}

	return Server{proxy: httputil.NewSingleHostReverseProxy(serverURL)}, nil
}

// LoadBalancer is a collection of Servers.
type LoadBalancer struct {
	servers []Server
	rng     *rand.Rand
	ratio   int // Positive int less than or equal to 10
}
```

`NewServer` is a helper method that'll make it easier for us to set up backends in the future.

This code notably uses `httputil`, which is in the [`"net/http/httputil"`](https://golang.org/pkg/net/http/httputil/) standard library package. We're using this so we don't have to write our own reverse proxy. Even though that might be fun, there are a number of RFCs ([RFC 7230](https://tools.ietf.org/html/rfc7230) and [RFC 2616](https://tools.ietf.org/html/rfc2616)) that determine what headers need to be stripped from the request, among other things that we probably want to let someone else handle for us. If you want to see what you're missing, check out the [`httputil.ServeHTTP`](https://github.com/golang/go/blob/go1.16.2/src/net/http/httputil/reverseproxy.go#L212) method from the Go standard library.

Now that we have our state handled, we need to determine how to choose the right server to send each request to. Since we'll assume we always have two servers available, we only have to choose a random number, see if it is greater than our ratio, and use that to determine what server to send it to. It ends up looking like this.

```go
// NextServer generates a random integer to determine if the 1st or 2nd Server should be proxied to.
// When the random integer is greater or equal to the ratio, proxy the request to the 2nd Server.
//
// We always assume there are two Servers.
func (lb *LoadBalancer) NextServer() *Server {
	index := 0
	if lb.rng.Intn(10) >= lb.ratio {
		index = 1
	}

	return lb.servers[index]
}
```

With that out of the way, actually handling the request becomes easy. We choose a server, and then we reverse proxy the request to it.

```go
// ProxyRequest forwards the request to the Server.
func (lb *LoadBalancer) ProxyRequest(w http.ResponseWriter, r *http.Request) {
	server := lb.NextServer()
	server.proxy.ServeHTTP(w, r)
}
```

Now that we have all the pieces, we can glue them together with a `main` function. It has flags for the URLs of our servers which are used as parameters to the `NewServer` function to create our reverse proxies. Then we can create our load balancer with the servers and start it up.

That gives us this:

```go
func main() {
	var (
		s1    = flag.String("s1", "http://localhost:8080/", "first server")
		s2    = flag.String("s2", "http://localhost:8081/", "second server")
		ratio = flag.Uint("ratio", 5, "How many requests out of 10 should go to server 1, default 5")
	)
	flag.Parse()

	server1, err := NewServer(*s1)
	if err != nil {
		log.Fatalf("Couldn't setup server1: %s", err)
	}
	server2, err := NewServer(*s2)
	if err != nil {
		log.Fatalf("Couldn't setup server2: %s", err)
	}

	loadBalancer := LoadBalancer{
		servers: []Server{server1, server2},
		rng:     rand.New(rand.NewSource(time.Now().UnixNano())),
		ratio:   int(*ratio),
	}

	server := &http.Server{
		Addr:    ":8888",
		Handler: http.HandlerFunc(loadBalancer.ProxyRequest),
	}

	log.Fatal(server.ListenAndServe())
}
```

And that's it!

### Making sure it works

Now that we have the code written, we should make sure it works. To do that, we need to have two servers to test with, and we'll need to start our load balancer, and then send the requests.

Let's create a new file in a different directory for this test, since it will need its own `main` function to run it all. Call the directory `test`, and the file `run_lb.go`.

Start by creating the server functions we need to test with in our `run_lb.go` file.

```go
func main() {
	// TODO
}

// SimpleServer sets up a simple server that always returns a message on the specified port.
func SimpleServer(port, message string) {
	serveMux := http.NewServeMux()
	serveMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain")
		fmt.Fprintf(w, message+"\n")
	})

	log.Fatalln(http.ListenAndServe(":"+port, serveMux))
}
```

These servers are very simple. They accept any request to any path and return whatever message we set them up with.

For convenience, this method will also _run_ the server. However, that means we will need to run this method in a Go routine, by prepending `go` to it, otherwise we would never get past the server starting up.

Now that the servers are made, we will need to run our load balancer. We can do that with the handy `exec` package, which will allow us to use shell commands, including `go build`. So we can build our load balancer binary, wait for that to finish, and then run it.

We will _also_ need to run our load balancer asynchronously, because we still need to send requests to it. It will take some time for the load balancer to start up, so we'll throw a sleep in there too.

Setting up our servers and load balancer looks like this.

```go
func main() {
	buildCmd := exec.Command("go", "build", "-o", "load_balancer", "load_balancer.go")
	if err := buildCmd.Start(); err != nil {
		log.Fatal(err)
	}
	buildCmd.Wait()