{"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\/ro\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Dezvoltarea serverelor web pe Golang \u2014 de la simplu la complex","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Dezvoltarea
\n
\nAcum cinci ani, am \u00eenceput s\u0103 dezvolt Gophish<\/a><\/noindex>, ceea ce mi-a permis s\u0103 \u00eenv\u0103\u021b Golang. Am realizat c\u0103 Go este un limbaj puternic, al c\u0103rui poten\u021bial este completat de numeroase biblioteci. Go este versatil: \u00een special, cu ajutorul s\u0103u, este u\u0219or s\u0103 dezvol\u021bi aplica\u021bii server.<\/p>\n

Acest articol este dedicat scrierii unui server \u00een Go. Vom \u00eencepe cu lucruri simple, cum ar fi \u201eHello world!\u201d, \u0219i vom termina cu o aplica\u021bie cu urm\u0103toarele func\u021bionalit\u0103\u021bi:<\/p>\n

\u2014 Utilizarea Let\u2019s Encrypt pentru HTTPS.
\n\u2014 Func\u021bionarea ca API router.
\n\u2014 Lucrul cu middleware.
\n\u2014 Gestionarea fi\u0219ierelor statice.
\n\u2014 \u00cencheiere corect\u0103.
\n<\/a><\/noindex><\/p>\n

Skillbox recomand\u0103:<\/b> Curs practic \u201eDezvoltator Python de la zero\u201d<\/a><\/noindex>.<\/p>\n

V\u0103 reamintim:<\/b> pentru to\u021bi cititorii \u201eHabr\u201d \u2014 reducere de 10.000 de ruble la \u00eenscrierea la orice curs Skillbox cu codul de promovare \u201eHabr\u201d.<\/i>\n<\/p><\/blockquote>\n

Hello, world!<\/h3>\n

\nCrearea unui server web \u00een Go se poate face foarte repede. Iat\u0103 un exemplu de utilizare a unui handler care returneaz\u0103 celebrul \u201eHello, world!\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
\nDup\u0103 aceasta, dac\u0103 rula\u021bi aplica\u021bia \u0219i deschide\u021bi pagina localhost<\/noindex>, ve\u021bi vedea imediat textul \u201eHello, world!\u201d (desigur, dac\u0103 totul func\u021bioneaz\u0103 corect).<\/p>\n
Apoi, vom folosi repetat handler-ul, dar mai \u00eent\u00e2i haide\u021bi s\u0103 \u00een\u021belegem cum func\u021bioneaz\u0103 totul.<\/p>\n
net\/http<\/h4>\n
\n\u00cen exemplu a fost folosit pachetul net\/http<\/code><\/a><\/noindex>, care este principalul instrument \u00een Go pentru dezvoltarea at\u00e2t a serverelor, c\u00e2t \u0219i a clien\u021bilor HTTP. Pentru a \u00een\u021belege codul, s\u0103 analiz\u0103m semnifica\u021bia a trei elemente importante: http.Handler, http.ServeMux \u0219i http.Server.<\/p>\n
Handler-ele HTTP<\/h4>\n
\nC\u00e2nd primim o cerere, handler-ul o analizeaz\u0103 \u0219i genereaz\u0103 un r\u0103spuns. Handler-ele \u00een Go sunt implementate astfel:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\n\u00cen primul exemplu se folose\u0219te func\u021bia utilitar\u0103 http.HandleFunc. Aceasta \u00eenv\u0103luie o alt\u0103 func\u021bie, care, la r\u00e2ndul s\u0103u, prime\u0219te http.ResponseWriter \u0219i http.Request \u00een ServeHTTP.<\/p>\n
Cu alte cuvinte, handler-ele \u00een Golang sunt reprezentate printr-un singur interfa\u021b\u0103, ceea ce ofer\u0103 numeroase oportunit\u0103\u021bi pentru programatori. De exemplu, middleware-ul este implementat printr-un handler, unde ServeHTTP ini\u021bial face ceva \u0219i apoi apeleaz\u0103 metoda ServeHTTP a altui handler.<\/p>\n
A\u0219a cum s-a men\u021bionat mai sus, handler-ele doar genereaz\u0103 r\u0103spunsuri la cereri. Dar ce handler specific trebuie utilizat \u00een fiecare moment?<\/p>\n
Rutarea cererilor<\/h4>\n
\nPentru a face o alegere corect\u0103, utiliza\u021bi multiplexorul HTTP. \u00cen unele biblioteci, acesta este denumit muxer sau router, \u00eens\u0103 toate acestea se refer\u0103 la acela\u0219i lucru. Func\u021bia multiplexorului const\u0103 \u00een analizarea c\u0103ii cererii \u0219i alegerea handler-ului corespunz\u0103tor.<\/p>\n
Dac\u0103 ave\u021bi nevoie de suport pentru rutare complex\u0103, atunci este mai bine s\u0103 folosi\u021bi biblioteci externe. Unele dintre cele mai avansate sunt gorilla\/mux<\/a><\/noindex> \u0219i go-chi\/chi<\/a><\/noindex>, aceste biblioteci ofer\u0103 posibilitatea de a implementa tratarea intermediar\u0103 f\u0103r\u0103 probleme semnificative. Cu ajutorul lor, pute\u021bi configura rutare wildcard \u0219i realiza o serie de alte sarcini. Avantajul lor este compatibilitatea cu handler-ele HTTP standard. Ca rezultat, pute\u021bi scrie cod simplu cu posibilitatea de a-l modifica \u00een viitor.<\/p>\n
Lucrul cu framework-uri complexe \u00een situa\u021bii obi\u0219nuite va necesita solu\u021bii oarecum neobi\u0219nuite, ceea ce complic\u0103 semnificativ utilizarea handler-elor implicite. Pentru crearea celor mai multe aplica\u021bii, combina\u021bia dintre biblioteca implicit\u0103 \u0219i un router simplu este suficient\u0103.<\/p>\n
Tratarea cererilor<\/h4>\n
\n\u00cen plus, avem nevoie de un component care s\u0103 \u201easculte\u201d conexiunile intrante \u0219i s\u0103 redirec\u021bioneze toate cererile c\u0103tre handler-ul corect. Acest lucru poate fi realizat cu u\u0219urin\u021b\u0103 prin http.Server.<\/p>\n
Mai jos este ar\u0103tat c\u0103 serverul este responsabil pentru toate sarcinile legate de tratarea conexiunilor. Acestea includ, de exemplu, lucrul cu protocolul TLS. Pentru a implementa apelul http.ListenAndServer, se folose\u0219te serverul HTTP standard.<\/p>\n
Acum haide\u021bi s\u0103 analiz\u0103m exemple mai complexe.<\/p>\n
Ad\u0103ugarea Let\u2019s Encrypt<\/h3>\n
\n\u00cen mod implicit, aplica\u021bia noastr\u0103 func\u021bioneaz\u0103 pe protocolul HTTP, \u00eens\u0103 se recomand\u0103 utilizarea protocolului HTTPS. \u00cen Go, acest lucru se poate face f\u0103r\u0103 probleme. Dac\u0103 a\u021bi ob\u021binut un certificat \u0219i o cheie privat\u0103, atunci este suficient s\u0103 specifica\u021bi ListenAndServeTLS cu indicarea fi\u0219ierelor corecte pentru certificat \u0219i cheie.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\n\u00centotdeauna se poate face mai bine.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> ofer\u0103 certificate gratuite cu posibilitatea de actualizare automat\u0103. Pentru a folosi serviciul, ave\u021bi nevoie de pachetul autocert<\/code>.<\/p>\n
Cel mai simplu mod de a-l configura este s\u0103 folosi\u021bi metoda autocert.NewListener \u00een combina\u021bie cu http.Serve. Metoda permite ob\u021binerea \u0219i actualizarea certificatelor TLS, \u00een timp ce serverul HTTP proceseaz\u0103 cererile:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nDac\u0103 deschidem \u00een browser example.com<\/a><\/noindex>, atunci vom ob\u021bine un r\u0103spuns HTTPS \u201eHello, world!\u201d\u3002<\/p>\n
Dac\u0103 ave\u021bi nevoie de o configurare mai detaliat\u0103, ar trebui s\u0103 folosi\u021bi managerul autocert.Manager. Apoi, cre\u0103m propria instan\u021b\u0103 http.Server (p\u00e2n\u0103 acum am folosit-o pe cea implicit\u0103) \u0219i ad\u0103ug\u0103m managerul \u00een server 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
\nAceasta este o modalitate simpl\u0103 de a implementa suport complet pentru HTTPS cu actualizare automat\u0103 a certificatului.<\/p>\n
Ad\u0103ugarea de rute personalizate<\/h3>\n
\nRouterul implicit, inclus \u00een biblioteca standard, este bun, dar foarte simplu. \u00cen majoritatea aplica\u021biilor, este necesar\u0103 o rutare mai complex\u0103, inclusiv rute imbricate \u0219i wildcard sau o procedur\u0103 de configurare a modelului \u0219i a parametrilor de cale.<\/p>\n
\u00cen acest caz, ar trebui s\u0103 folosi\u021bi pachetele gorilla\/mux<\/a><\/noindex> \u0219i go-chi\/chi<\/a><\/noindex>. Cu acesta vom \u00eenv\u0103\u021ba s\u0103 lucr\u0103m \u2014 mai jos este un exemplu.<\/p>\n
Avem un fi\u0219ier api\/v1\/api.go, care con\u021bine rutele pentru API-ul nostru:<\/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
\nSet\u0103m un prefix pentru rutele api\/vq \u00een fi\u0219ierul principal.<\/p>\n
Putem atunci s\u0103 le mont\u0103m pe routerul nostru principal sub prefixul api\/v1\/ \u00een aplica\u021bia principal\u0103:<\/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
\nSimplitatea lucrului cu rutele complexe \u00een Go permite o structurare mai u\u0219oar\u0103 \u00een \u00eentre\u021binerea aplica\u021biilor mari \u0219i complexe.<\/p>\n
Lucrul cu middleware<\/h3>\n
\n\u00cen cazul proces\u0103rii intermediare, este folosit\u0103 \u00eenvelirea unui handler HTTP de c\u0103tre altul, ceea ce permite o autentificare rapid\u0103, comprimare, jurnalizare \u0219i unele alte func\u021bii.<\/p>\n
Ca exemplu, s\u0103 lu\u0103m interfa\u021ba http.Handler, cu ajutorul c\u0103reia vom scrie un handler cu autentificarea utilizatorilor serviciului.<\/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        \/\/ Presupun\u00e2nd c\u0103 autentificarea a fost aprobat\u0103, rula\u021bi handlerul original\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nExist\u0103 routere ter\u021be, cum ar fi chi, care permit extinderea func\u021bionalit\u0103\u021bii proces\u0103rii intermediare.<\/p>\n
Lucrul cu fi\u0219iere statice<\/h3>\n
\nBiblioteca standard Go include func\u021bionalit\u0103\u021bi pentru a gestiona con\u021binutul static, inclusiv imagini, precum \u0219i fi\u0219iere JavaScript \u0219i CSS. Accesul la acestea se poate face prin func\u021bia http.FileServer. Aceasta returneaz\u0103 un handler care serve\u0219te fi\u0219iere dintr-un director specific.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configurarea distribuirii fi\u0219ierelor statice\nstaticPath, _ := filepath.Abs(\"..\/..\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nEste important s\u0103 re\u021bii c\u0103 http.Dir va afi\u0219a con\u021binutul unui director doar dac\u0103 nu exist\u0103 un fi\u0219ier index.html principal \u00een acesta. \u00cen acest caz, pentru a evita compromiterea directorului, ar trebui s\u0103 folose\u0219ti pachetul neindexat<\/code><\/a><\/noindex>.<\/p>\n
\u00cenchidere corect\u0103<\/h3>\n
\n\u00cen Go, exist\u0103 \u0219i o func\u021bie pentru \u00eenchiderea corect\u0103 a serverului HTTP. Acest lucru se poate face folosind metoda Shutdown(). Serverul porne\u0219te \u00eentr-o gorutin\u0103, iar apoi se ascult\u0103 un canal pentru a primi semnale de \u00eentrerupere. Odat\u0103 ce semnalul este primit, serverul se opre\u0219te, dar nu imediat, ci dup\u0103 c\u00e2teva secunde.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ A\u0219teapt\u0103 o \u00eentrerupere\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ \u00cencearc\u0103 o oprire gra\u021bioas\u0103\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
\u00cen concluzie<\/h3>\n
\nGo este un limbaj puternic cu o bibliotec\u0103 standard practic universal\u0103. Capabilit\u0103\u021bile sale implicite sunt destul de vaste, iar acestea pot fi \u00eembun\u0103t\u0103\u021bite prin intermediul interfe\u021belor \u2014 ceea ce permite dezvoltarea de servere HTTP cu adev\u0103rat fiabile.<\/p>\n
Skillbox recomand\u0103:<\/b><\/p>\n