{"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\/pl\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Rozw\u00f3j serwer\u00f3w internetowych na Golang \u2014 od prostego do skomplikowanego","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Rozw\u00f3j
\n
\nPi\u0119\u0107 lat temu zacz\u0105\u0142em opracowywa\u0107 Gophish<\/a><\/noindex>, co da\u0142o mi mo\u017cliwo\u015b\u0107 nauczenia si\u0119 Golanga. Zrozumia\u0142em, \u017ce Go to pot\u0119\u017cny j\u0119zyk, kt\u00f3rego mo\u017cliwo\u015bci s\u0105 wzbogacane przez liczne biblioteki. Go jest wszechstronny: w szczeg\u00f3lno\u015bci umo\u017cliwia bezproblemowe opracowywanie aplikacji serwerowych.<\/p>\n

Ten artyku\u0142 po\u015bwi\u0119cony jest tworzeniu serwera w Go. Zacznijmy od prostych rzeczy, jak \u201eHello world!\u201d, a sko\u0144czymy na aplikacji z nast\u0119puj\u0105cymi funkcjami:<\/p>\n

\u2014 U\u017cycie Let\u2019s Encrypt do HTTPS.
\n\u2014 Dzia\u0142a jako router API.
\n\u2014 Praca z middleware.
\n\u2014 Obs\u0142uga plik\u00f3w statycznych.
\n\u2014 Poprawne zako\u0144czenie pracy.
\n<\/a><\/noindex><\/p>\n

Skillbox poleca:<\/b> Praktyczny kurs \u201ePython-developer od podstaw\u201d<\/a><\/noindex>.<\/p>\n

Przypominamy:<\/b> dla wszystkich czytelnik\u00f3w \u201eHabra\u201d \u2014 zni\u017cka 10 000 rubli przy zapisie na dowolny kurs Skillbox z kodem promocyjnym \u201eHabra\u201d.<\/i>\n<\/p><\/blockquote>\n

Witaj, \u015bwiecie!<\/h3>\n

\nStworzenie serwera WWW w Go jest bardzo szybkie. Oto przyk\u0142ad u\u017cycia handlera, kt\u00f3ry zwraca obiecane wy\u017cej \u201eWitaj, \u015bwiecie!\u201d.<\/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
\nPo tym, je\u015bli uruchomisz aplikacj\u0119 i otworzysz stron\u0119 localhost<\/noindex>, od razu zobaczysz tekst \u201eWitaj, \u015bwiecie!\u201d (oczywi\u015bcie, je\u015bli wszystko dzia\u0142a poprawnie).<\/p>\n
Nast\u0119pnie wielokrotnie b\u0119dziemy korzysta\u0107 z handlera, ale najpierw zrozummy, jak to wszystko dzia\u0142a.<\/p>\n
net\/http<\/h4>\n
\nW przyk\u0142adzie u\u017cyto pakietu net\/http<\/code><\/a><\/noindex>, co jest podstawowym narz\u0119dziem w Go do tworzenia zar\u00f3wno serwer\u00f3w, jak i klient\u00f3w HTTP. Aby zrozumie\u0107 kod, rozwa\u017cmy znaczenie trzech wa\u017cnych element\u00f3w: http.Handler, http.ServeMux i http.Server.<\/p>\n
HTTP-handlery<\/h4>\n
\nGdy otrzymujemy zapytanie, handler je analizuje i formu\u0142uje odpowied\u017a. Handlery w Go s\u0105 zaimplementowane w nast\u0119puj\u0105cy spos\u00f3b:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nW pierwszym przyk\u0142adzie u\u017cyto funkcji pomocniczej http.HandleFunc. Owrapowuje ona inn\u0105 funkcj\u0119, kt\u00f3ra z kolei przyjmuje http.ResponseWriter i http.Request w ServeHTTP.<\/p>\n
Innymi s\u0142owy, handlery w Golangu s\u0105 reprezentowane przez jeden interfejs, co daje programi\u015bcie liczne mo\u017cliwo\u015bci. Na przyk\u0142ad middleware jest wdra\u017cane za pomoc\u0105 handlera, gdzie ServeHTTP najpierw co\u015b robi, a potem wywo\u0142uje metod\u0119 ServeHTTP innego handlera.<\/p>\n
Jak wspomniano powy\u017cej, handlery po prostu formu\u0142uj\u0105 odpowiedzi na zapytania. Ale kt\u00f3ry konkretnie handler nale\u017cy u\u017cy\u0107 w danym momencie?<\/p>\n
Trasowanie zapyta\u0144<\/h4>\n
\nAby dokona\u0107 w\u0142a\u015bciwego wyboru, skorzystaj z HTTP-multiplexer. W wielu bibliotekach nazywa si\u0119 go muxer lub router, ale wszystko to jest to samo. Funkcja multiplexer polega na analizie \u015bcie\u017cki zapytania i wyborze odpowiedniego obs\u0142uguj\u0105cego.<\/p>\n
Je\u015bli jednak potrzebujesz wsparcia dla zaawansowanego routingu, lepiej skorzysta\u0107 z zewn\u0119trznych bibliotek. Niekt\u00f3re z najbardziej zaawansowanych to gorilla\/mux<\/a><\/noindex> i go-chi\/chi<\/a><\/noindex>, te biblioteki umo\u017cliwiaj\u0105 realizacj\u0119 przetwarzania po\u015bredniego bez wi\u0119kszych problem\u00f3w. Dzi\u0119ki nim mo\u017cna skonfigurowa\u0107 routing z wildcardami i wykona\u0107 szereg innych zada\u0144. Ich zalet\u0105 jest kompatybilno\u015b\u0107 ze standardowymi HTTP-handlerami. W rezultacie mo\u017cesz napisa\u0107 prosty kod z mo\u017cliwo\u015bci\u0105 jego modyfikacji w przysz\u0142o\u015bci.<\/p>\n
Praca z bardziej z\u0142o\u017conymi frameworkami w zwyk\u0142ej sytuacji wymaga\u0107 b\u0119dzie niezbyt standardowych rozwi\u0105za\u0144, co znacznie komplikuje korzystanie z domy\u015blnych obs\u0142uguj\u0105cych. Do stworzenia zdecydowanej wi\u0119kszo\u015bci aplikacji wystarczy kombinacja domy\u015blnej biblioteki oraz prostego routera.<\/p>\n
Obs\u0142uga zapyta\u0144<\/h4>\n
\nPonadto potrzebujemy komponentu, kt\u00f3ry b\u0119dzie 'ws\u0142uchiwa\u0142 si\u0119' w przychodz\u0105ce po\u0142\u0105czenia i przekierowywa\u0142 wszystkie zapytania do odpowiedniego obs\u0142uguj\u0105cego. Z tym zadaniem bez trudu poradzi sobie http.Server.<\/p>\n
Poni\u017cej wida\u0107, \u017ce serwer odpowiada za wszystkie zadania zwi\u0105zane z obs\u0142ug\u0105 po\u0142\u0105cze\u0144. Nale\u017cy do nich na przyk\u0142ad praca z protoko\u0142em TLS. Standardowy serwer HTTP jest wykorzystywany do realizacji wywo\u0142ania http.ListenAndServer.<\/p>\n
Teraz przyjrzyjmy si\u0119 bardziej z\u0142o\u017conym przyk\u0142adom.<\/p>\n
Dodawanie Let\u2019s Encrypt<\/h3>\n
\nDomy\u015blnie nasze aplikacje dzia\u0142aj\u0105 w protokole HTTP, jednak zaleca si\u0119 korzystanie z protoko\u0142u HTTPS. W Go mo\u017cna to zrobi\u0107 bez problem\u00f3w. Je\u015bli uzyska\u0142e\u015b certyfikat i klucz prywatny, wystarczy wskaza\u0107 ListenAndServeTLS z odpowiednimi plikami certyfikatu i klucza.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nZawsze mo\u017cna zrobi\u0107 lepiej.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> oferuje bezp\u0142atne certyfikaty z mo\u017cliwo\u015bci\u0105 automatycznego odnawiania. Aby skorzysta\u0107 z us\u0142ugi, potrzebny jest pakiet autocert<\/code>.<\/p>\n
Naj\u0142atwiejszym sposobem jego skonfigurowania jest skorzystanie z metody autocert.NewListener w kombinacji z http.Serve. Metoda ta pozwala uzyskiwa\u0107 i odnawia\u0107 certyfikaty TLS, podczas gdy serwer HTTP obs\u0142uguje zapytania:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nJe\u015bli otworzymy w przegl\u0105darce example.com<\/a><\/noindex>, otrzymamy odpowied\u017a HTTPS \u201eHello, world!\u201d.<\/p>\n
Je\u015bli potrzebna jest dok\u0142adniejsza konfiguracja, warto skorzysta\u0107 z mened\u017cera autocert.Manager. Nast\u0119pnie tworzymy w\u0142asn\u0105 instancj\u0119 http.Server (dotychczas u\u017cywali\u015bmy domy\u015blnej) i dodajemy mened\u017cera do TLSConfig serwera:<\/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
\nTo prosty spos\u00f3b na wdro\u017cenie pe\u0142nej obs\u0142ugi HTTPS z automatycznym odnawianiem certyfikatu.<\/p>\n
Dodawanie niestandardowych tras<\/h3>\n
\nDomy\u015blny router zawarty w standardowej bibliotece jest dobry, ale bardzo prosty. W wi\u0119kszo\u015bci aplikacji potrzebne s\u0105 bardziej skomplikowane trasy, w tym zagnie\u017cd\u017cone i wildcard, oraz procedura ustawiania szablon\u00f3w i parametr\u00f3w \u015bcie\u017cek.<\/p>\n
W takim przypadku warto u\u017cy\u0107 pakiet\u00f3w gorilla\/mux<\/a><\/noindex> i go-chi\/chi<\/a><\/noindex>. Z ostatnim nauczymy si\u0119 pracowa\u0107 \u2014 poni\u017cej znajduje si\u0119 przyk\u0142ad.<\/p>\n
Dane \u2014 plik api\/v1\/api.go, zawieraj\u0105cy trasy dla naszego 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
\nUstawiamy dla tras prefiks api\/v1 w g\u0142\u00f3wnym pliku.<\/p>\n
Mo\u017cemy nast\u0119pnie zamontowa\u0107 go do naszego g\u0142\u00f3wnego routera pod prefiksem api\/v1 w naszej g\u0142\u00f3wnej aplikacji:<\/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
\n\u0141atwo\u015b\u0107 pracy ze z\u0142o\u017conymi trasami w Go umo\u017cliwia uproszczenie struktury w obs\u0142udze du\u017cych, z\u0142o\u017conych aplikacji.<\/p>\n
Praca z middleware<\/h3>\n
\nW przypadku przetwarzania po\u015bredniego polega to na owijaniu jednego HTTP-handlera innym, co pozwala szybko przeprowadzi\u0107 autoryzacj\u0119, kompresj\u0119, logowanie oraz inne funkcje.<\/p>\n
Jako przyk\u0142ad rozwa\u017cmy interfejs http.Handler, kt\u00f3rego u\u017cyjemy do napisania handlera z autoryzacj\u0105 u\u017cytkownik\u00f3w serwisu.<\/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        \\\/\\\/ Zak\u0142adaj\u0105c, \u017ce autoryzacja przesz\u0142a, uruchom oryginalny handler\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nS\u0105 te\u017c zewn\u0119trzne routery, na przyk\u0142ad chi, kt\u00f3re pozwalaj\u0105 rozszerzy\u0107 funkcjonalno\u015b\u0107 przetwarzania po\u015bredniego.<\/p>\n
Praca ze statycznymi plikami<\/h3>\n
\nStandardowa biblioteka Go zawiera mo\u017cliwo\u015bci pracy ze statycznymi tre\u015bciami, w tym obrazami oraz plikami JavaScript i CSS. Mo\u017cna uzyska\u0107 do nich dost\u0119p za pomoc\u0105 funkcji http.FileServer. Zwraca ona handler, kt\u00f3ry udost\u0119pnia pliki z okre\u015blonego katalogu.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Konfiguracja serwera plik\u00f3w statycznych\nstaticPath, _ := filepath.Abs(\"..\/..\/..\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nNale\u017cy pami\u0119ta\u0107, \u017ce http.Dir wy\u015bwietla zawarto\u015b\u0107 katalogu tylko wtedy, gdy nie ma w nim g\u0142\u00f3wnego pliku index.html. W takim przypadku, aby unikn\u0105\u0107 kompromitacji katalogu, warto u\u017cy\u0107 pakietu nieindeksowany<\/code><\/a><\/noindex>.<\/p>\n
Poprawne zako\u0144czenie pracy<\/h3>\n
\nW Go istnieje r\u00f3wnie\u017c funkcja, kt\u00f3ra pozwala na poprawne zako\u0144czenie pracy serwera HTTP. Mo\u017cna to zrobi\u0107 za pomoc\u0105 metody Shutdown(). Serwer uruchamia si\u0119 w gorutinie, po czym kana\u0142 nas\u0142uchuje sygna\u0142u przerwania. Gdy tylko sygna\u0142 zostanie odebrany, serwer si\u0119 wy\u0142\u0105cza, jednak nie od razu, a po kilku sekundach.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Czekaj na przerwanie\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Pr\u00f3ba poprawnego zamkni\u0119cia\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
Na zako\u0144czenie<\/h3>\n
\nGo to pot\u0119\u017cny j\u0119zyk z niemal uniwersaln\u0105 standardow\u0105 bibliotek\u0105. Jego domy\u015blne mo\u017cliwo\u015bci s\u0105 szerokie, a mo\u017cna je wzmocni\u0107 za pomoc\u0105 interfejs\u00f3w \u2014 co pozwala na tworzenie naprawd\u0119 niezawodnych serwer\u00f3w HTTP.<\/p>\n
Skillbox poleca:<\/b><\/p>\n