{"id":30782,"date":"2019-10-31T21:37:25","date_gmt":"2019-10-31T18:37:25","guid":{"rendered":"https:\/\/prohoster.info\/blog\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu\/"},"modified":"2019-10-31T21:37:25","modified_gmt":"2019-10-31T18:37:25","slug":"razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","status":"publish","type":"post","link":"https:\/\/prohoster.info\/en\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Developing Web Servers with Golang \u2014 From Simple to Complex","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Developing
\n
\nFive years ago, I started developing Gophish<\/a><\/noindex>, which allowed me to learn Golang. I realized that Go is a powerful language, and its capabilities are enhanced by numerous libraries. Go is versatile: in particular, it allows for seamless server application development.<\/p>\n

This article is dedicated to writing a server in Go. We'll start with simple things like \"Hello, world!\" and finish with an application featuring the following capabilities:<\/p>\n

\u2014 Using Let\u2019s Encrypt for HTTPS.
\n\u2014 Functioning as an API router.
\n\u2014 Working with middleware.
\n\u2014 Handling static files.
\n\u2014 Graceful shutdown.
\n<\/a><\/noindex><\/p>\n

Skillbox recommends:<\/b> Practical Course \"Python Developer from Scratch\"<\/a><\/noindex>.<\/p>\n

Reminder:<\/b> for all readers of 'Habr' - a discount of 10,000 rubles when enrolling in any Skillbox course with the promo code 'Habr'.<\/i>\n<\/p><\/blockquote>\n

Hello, world!<\/h3>\n

\nCreating a web server in Go can be done very quickly. Here\u2019s an example of a handler that returns the previously mentioned \"Hello, world!\".<\/p>\n

package main\n \nimport (\n\"fmt\"\n\"net\/http\"\n)\n \nfunc main() {\nhttp.HandleFunc(\"\/\", func(w http.ResponseWriter, r *http.Request) {\nfmt.Fprintf(w, \"Hello World!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nAfter this, if you run the application and open the page localhost<\/noindex>, you will immediately see the text \"Hello, world!\" (of course, if everything works correctly).<\/p>\n
Next, we will repeatedly use the handler, but first, let\u2019s understand how everything works.<\/p>\n
net\/http<\/h4>\n
\nIn the example, the package was used net\/http<\/code><\/a><\/noindex>, which is the primary tool in Go for developing both servers and HTTP clients. To understand the code, let\u2019s clarify the meaning of three essential elements: http.Handler, http.ServeMux, and http.Server.<\/p>\n
HTTP Handlers<\/h4>\n
\nWhen we receive a request, the handler analyzes it and generates a response. Handlers in Go are implemented as follows:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nIn the first example, the helper function http.HandleFunc is used. It wraps another function that, in turn, accepts http.ResponseWriter and http.Request in ServeHTTP.<\/p>\n
In other words, handlers in Golang are represented by a unified interface, which provides many opportunities for the programmer. For instance, middleware is implemented using a handler, where ServeHTTP first does something, and then calls the ServeHTTP method of another handler.<\/p>\n
As mentioned earlier, handlers simply create responses to requests. But which specific handler should be used at a given moment?<\/p>\n
Routing Requests<\/h4>\n
\nTo make the right choice, use an HTTP multiplexer. In some libraries, it's called a muxer or router, but they all refer to the same thing. The function of the multiplexer is to analyze the request path and select the appropriate handler.<\/p>\n
If you need support for complex routing, it's better to use third-party libraries. Some of the most advanced ones are gorilla\/mux<\/a><\/noindex> and go-chi\/chi<\/a><\/noindex>, these libraries allow for intermediate processing without much hassle. With their help, you can set up wildcard routing and perform a number of other tasks. Their advantage is compatibility with standard HTTP handlers. As a result, you can write simple code with the possibility of future modifications.<\/p>\n
Working with complex frameworks in a normal situation will require somewhat non-standard solutions, which significantly complicates the use of default handlers. For the overwhelming majority of applications, a combination of the default library and a simple router will suffice.<\/p>\n
Request handling<\/h4>\n
\nIn addition, we need a component that will \"listen\" for incoming connections and redirect all requests to the correct handler. This task can be easily handled by http.Server.<\/p>\n
Below it is shown that the server is responsible for all tasks related to connection handling. This includes, for example, working with the TLS protocol. The standard HTTP server is used for the implementation of http.ListenAndServe.<\/p>\n
Now let\u2019s look at more complex examples.<\/p>\n
Adding Let\u2019s Encrypt<\/h3>\n
\nBy default, our application works over the HTTP protocol, but it is recommended to use the HTTPS protocol. In Go, this can be done effortlessly. If you have obtained a certificate and a private key, then it is sufficient to specify ListenAndServeTLS with the correct certificate and key file paths.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nThere is always room for improvement.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> provides free certificates with the ability to automatically renew them. To use the service, you need the package autocert<\/code>.<\/p>\n
The simplest way to set it up is to use the autocert.NewListener method in combination with http.Serve. This method allows obtaining and renewing TLS certificates while the HTTP server handles requests:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nIf we open in the browser example.com<\/a><\/noindex>, we get the HTTPS response \"Hello, world!\".<\/p>\n
If more detailed configuration is needed, it's worth using the autocert.Manager. Then we create our own instance of http.Server (up to this point we have used the default one) and add the manager to the server's TLSConfig:<\/p>\n
m := &autocert.Manager{\nCache:      autocert.DirCache(\"golang-autocert\"),\nPrompt:     autocert.AcceptTOS,\nHostPolicy: autocert.HostWhitelist(\"example.org\", \"www.example.org\"),\n}\nserver := &http.Server{\n    Addr:      \":443\",\n    TLSConfig: m.TLSConfig(),\n}\nserver.ListenAndServeTLS(\"\", \"\")<\/code><\/pre>\n
\nThis is a simple way to implement full HTTPS support with automatic certificate renewal.<\/p>\n
Adding custom routes<\/h3>\n
\nThe default router included in the standard library is good, but it is very basic. Most applications require more complex routing, including nested and wildcard routes or a procedure for setting up templates and path parameters.<\/p>\n
In this case, it's worth using packages gorilla\/mux<\/a><\/noindex> and go-chi\/chi<\/a><\/noindex>. We will learn to work with the latter \u2014 an example is shown below.<\/p>\n
Given \u2014 the file api\/v1\/api.go, containing routes for our API:<\/p>\n
\/ HelloResponse is the JSON representation for a customized message\ntype HelloResponse struct {\nMessage string `json:\"message\"`\n}\n \n\/\/ HelloName returns a personalized JSON message\nfunc HelloName(w http.ResponseWriter, r *http.Request) {\nname := chi.URLParam(r, \"name\")\nresponse := HelloResponse{\nMessage: fmt.Sprintf(\"Hello %s!\", name),\n}\njsonResponse(w, response, http.StatusOK)\n}\n \n\/\/ NewRouter returns an HTTP handler that implements the routes for the API\nfunc NewRouter() http.Handler {\nr := chi.NewRouter()\nr.Get(\"\/{name}\", HelloName)\nreturn r\n}<\/code><\/pre>\n
\nWe set a prefix api\/vq for routes in the main file.<\/p>\n
We can then mount this to our main router under the api\/v1\/ prefix back in our main application:<\/p>\n
\/\/ NewRouter returns a new HTTP handler that implements the main server routes\nfunc NewRouter() http.Handler {\nrouter := chi.NewRouter()\n    router.Mount(\"\/api\/v1\/\", v1.NewRouter())\n    return router\n}\nhttp.Serve(autocert.NewListener(\"example.com\"), NewRouter())<\/code><\/pre>\n
\nThe simplicity of handling complex routes in Go makes it possible to simplify the structure of maintaining large complex applications.<\/p>\n
Working with middleware<\/h3>\n
\nIn the case of middleware, it involves wrapping one HTTP handler with another, allowing for quick authentication, compression, logging, and some other functions.<\/p>\n
For example, let's consider the http.Handler interface, and using it, we'll write a handler for authenticating service users.<\/p>\n
func RequireAuthentication(next http.Handler) http.Handler {\n    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n        if !isAuthenticated(r) {\n            http.Redirect(w, r, \"\/login\", http.StatusTemporaryRedirect)\n            return\n        }\n        \/\/ Assuming authentication passed, run the original handler\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nThere are external routers, for example, chi, that allow extending the functionality of middleware.<\/p>\n
Working with static files<\/h3>\n
\nThe standard library of Go includes capabilities for working with static content, including images, as well as JavaScript and CSS files. They can be accessed through the http.FileServer function. It returns a handler that serves files from a specified directory.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Setting up static file distribution\nstaticPath, _ := filepath.Abs(\"..\/..\/\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nIt is important to remember that http.Dir outputs the contents of the directory if there is no main index.html file in it. In this case, to prevent directory compromise, it is advisable to use the package. unindexed<\/code><\/a><\/noindex>.<\/p>\n
Graceful Shutdown<\/h3>\n
\nIn Go, there is also a function for the graceful shutdown of an HTTP server. This can be done using the Shutdown() method. The server is started in a goroutine, and then a channel is listened to for an interrupt signal. Once the signal is received, the server shuts down, not immediately, but after a few seconds.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Wait for an interrupt\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Attempt a graceful shutdown\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
In conclusion<\/h3>\n
\nGo is a powerful language with an almost universal standard library. Its default capabilities are quite broad, and they can be enhanced through interfaces \u2014 this allows for the development of truly reliable HTTP servers.<\/p>\n
Skillbox recommends:<\/b><\/p>\n