{"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\/it\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Sviluppo di server web in Golang \u2014 dal semplice al complesso","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Sviluppo
\n
\nCinque anni fa ho iniziato a sviluppare Gophish<\/a><\/noindex>, questo mi ha dato l'opportunit\u00e0 di studiare Golang. Ho capito che Go \u00e8 un linguaggio potente, le cui capacit\u00e0 sono ampliate da molte librerie. Go \u00e8 versatile: in particolare, con esso \u00e8 possibile sviluppare applicazioni server senza problemi.<\/p>\n

Questo articolo \u00e8 dedicato alla scrittura di un server in Go. Iniziamo con cose semplici, come \"Hello world!\", e concludiamo con un'applicazione con le seguenti caratteristiche:<\/p>\n

\u2014 Utilizzo di Let's Encrypt per HTTPS.
\n\u2014 Funzionamento come router API.
\n\u2014 Lavorare con middleware.
\n\u2014 Gestione di file statici.
\n\u2014 Chiusura corretta dell'applicazione.
\n<\/a><\/noindex><\/p>\n

Skillbox consiglia:<\/b> Corso pratico \u00abSviluppatore Python da zero\u00bb<\/a><\/noindex>.<\/p>\n

Ricordiamo:<\/b> per tutti i lettori di \u00abHabr\u00bb \u2014 sconto di 10.000 rubli per l'iscrizione a qualsiasi corso Skillbox con il codice promozionale \u00abHabr\u00bb.<\/i>\n<\/p><\/blockquote>\n

Hello, world!<\/h3>\n

\nCreare un server web in Go \u00e8 molto veloce. Ecco un esempio di un gestore che restituisce il \"Hello, world!\" promesso sopra.<\/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
\nDopo di che, se avvi la applicazione e apri la pagina localhost<\/noindex>, vedrai subito il testo \"Hello, world!\" (ovviamente, se tutto funziona correttamente).<\/p>\n
Successivamente utilizzeremo pi\u00f9 volte il gestore, ma prima facciamo chiarezza su come funziona tutto.<\/p>\n
net\/http<\/h4>\n
\nNell'esempio \u00e8 stato utilizzato il pacchetto net\/http<\/code><\/a><\/noindex>, questo \u00e8 lo strumento principale in Go per sviluppare sia server che client HTTP. Per comprendere il codice, analizziamo tre elementi importanti: http.Handler, http.ServeMux e http.Server.<\/p>\n
I gestori HTTP<\/h4>\n
\nQuando riceviamo una richiesta, il gestore la analizza e formula una risposta. I gestori in Go sono implementati nel seguente modo:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nNel primo esempio viene utilizzata la funzione di supporto http.HandleFunc. Questa avvolge un'altra funzione che, a sua volta, accetta http.ResponseWriter e http.Request in ServeHTTP.<\/p>\n
In altre parole, i gestori in Golang sono rappresentati da un'unica interfaccia, il che offre molte possibilit\u00e0 per il programmatore. Ad esempio, il middleware \u00e8 implementato tramite un gestore, dove ServeHTTP prima fa qualcosa e poi chiama il metodo ServeHTTP di un altro gestore.<\/p>\n
Come detto sopra, i gestori semplicemente formulano risposte alle richieste. Ma quale gestore utilizzare in un dato momento?<\/p>\n
Instradamento delle richieste<\/h4>\n
\nPer fare la scelta giusta, utilizza il multiplexing HTTP. In alcune librerie viene chiamato muxer o router, ma si tratta della stessa cosa. La funzione del multiplexore consiste nell'analizzare il percorso della richiesta e selezionare il gestore corrispondente.<\/p>\n
Se hai bisogno di supporto per una routing complessa, \u00e8 meglio utilizzare librerie esterne. Tra le pi\u00f9 avanzate ci sono gorilla\/mux<\/a><\/noindex> e go-chi\/chi<\/a><\/noindex>, queste librerie consentono di implementare il middleware senza particolari problemi. Con esse puoi configurare il routing wildcard e svolgere una serie di altre attivit\u00e0. Il loro vantaggio \u00e8 la compatibilit\u00e0 con i gestori HTTP standard. Di conseguenza, puoi scrivere codice semplice con la possibilit\u00e0 di modificarlo in futuro.<\/p>\n
Lavorare con framework complessi in una situazione normale richieder\u00e0 soluzioni non standard, il che rende significativamente pi\u00f9 difficile l'uso dei gestori predefiniti. Per creare la stragrande maggioranza delle applicazioni \u00e8 sufficiente una combinazione della libreria predefinita e di un router semplice.<\/p>\n
Gestione delle richieste<\/h4>\n
\nInoltre, abbiamo bisogno di un componente che 'ascolti' le connessioni in entrata e indirizzi tutte le richieste al gestore corretto. Con questa funzione pu\u00f2 facilmente far fronte http.Server.<\/p>\n
Sotto \u00e8 mostrato che il server \u00e8 responsabile di tutte le attivit\u00e0 relative alla gestione delle connessioni. Questo include, ad esempio, il funzionamento tramite il protocollo TLS. Per attivare http.ListenAndServe viene utilizzato il server HTTP standard.<\/p>\n
Ora consideriamo esempi pi\u00f9 complessi.<\/p>\n
Aggiungere Let\u2019s Encrypt<\/h3>\n
\nPer impostazione predefinita, la nostra applicazione funziona tramite il protocollo HTTP, ma si consiglia di utilizzare il protocollo HTTPS. In Go questo \u00e8 possibile senza problemi. Se hai ottenuto un certificato e una chiave privata, \u00e8 sufficiente specificare ListenAndServeTLS indicando i corretti file del certificato e della chiave.<\/p>\n
http.ListenAndServeTLS(':443', 'cert.pem', 'key.pem', nil)<\/code><\/pre>\n
\nSi pu\u00f2 sempre fare meglio.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> fornisce certificati gratuiti con possibilit\u00e0 di aggiornamento automatico. Per utilizzare questo servizio, \u00e8 necessario il pacchetto autocert<\/code>.<\/p>\n
Il modo pi\u00f9 semplice per configurarlo \u00e8 usare il metodo autocert.NewListener in combinazione con http.Serve. Questo metodo consente di ottenere e aggiornare i certificati TLS, mentre il server HTTP gestisce le richieste:<\/p>\n
http.Serve(autocert.NewListener('example.com'), nil)<\/code><\/pre>\n
\nSe apriamo nel browser example.com<\/a><\/noindex>, otterremo la risposta HTTPS \u00abHello, world!\u00bb.<\/p>\n
Se \u00e8 necessaria una configurazione pi\u00f9 dettagliata, \u00e8 consigliabile utilizzare il gestore autocert.Manager. Quindi creiamo una nostra istanza di http.Server (fino a questo momento abbiamo utilizzato quella predefinita) e aggiungiamo il gestore alla configurazione TLSConfig del server:<\/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
\nQuesto \u00e8 un modo semplice per implementare il pieno supporto HTTPS con aggiornamento automatico del certificato.<\/p>\n
Aggiunta di rotte personalizzate<\/h3>\n
\nIl router predefinito incluso nella libreria standard \u00e8 buono, ma \u00e8 molto semplice. Nella maggior parte delle applicazioni \u00e8 necessaria una routing pi\u00f9 complesso, incluse rotte nidificate e wildcard, o anche una procedura per impostare modelli e parametri delle strade.<\/p>\n
In questo caso, \u00e8 opportuno utilizzare i pacchetti gorilla\/mux<\/a><\/noindex> e go-chi\/chi<\/a><\/noindex>. Con quest'ultimo impareremo a lavorare \u2014 di seguito \u00e8 mostrato un esempio.<\/p>\n
Dato \u2014 il file api\/v1\/api.go, contenente le rotte per la nostra 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
\nImpostiamo il prefisso delle rotte api\/v1 nel file principale.<\/p>\n
Possiamo quindi montare questo sul nostro router principale sotto il prefisso api\/v1 nella nostra applicazione principale:<\/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
\nLa semplicit\u00e0 di lavorare con rotte complesse in Go rende possibile semplificare la strutturazione della manutenzione di grandi applicazioni complesse.<\/p>\n
Lavorare con middleware<\/h3>\n
\nNel caso del middleware, si utilizza l'incapsulamento di un gestore HTTP all'interno di un altro, il che consente di effettuare rapidamente autenticazione, compressione, logging e alcune altre funzionalit\u00e0.<\/p>\n
Come esempio, consideriamo l'interfaccia http.Handler, con essa scriveremo un gestore per l'autenticazione degli utenti del servizio.<\/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        \\\/\\\/ Assumendo che l'autenticazione sia passata, esegui il gestore originale\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nCi sono router di terze parti, come chi, che consentono di estendere le funzionalit\u00e0 del middleware.<\/p>\n
Lavorare con file statici<\/h3>\n
\nLa libreria standard di Go include funzioni per lavorare con contenuti statici, comprese immagini, e file JavaScript e CSS. \u00c8 possibile accedervi attraverso la funzione http.FileServer. Questa restituisce un gestore che distribuisce file da una directory specificata.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configurazione della distribuzione dei file statici\nstaticPath, _ := filepath.Abs(\"..\/\/..\/\/static\/\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\n\u00c8 importante ricordare che http.Dir restituisce il contenuto della directory solo se non \u00e8 presente il file principale index.html. In questo caso, per evitare la compromissione della directory, \u00e8 opportuno utilizzare il pacchetto non indicizzato<\/code><\/a><\/noindex>.<\/p>\n
Chiusura corretta<\/h3>\n
\nIn Go esiste anche una funzione per la chiusura corretta del server HTTP. Questo pu\u00f2 essere fatto utilizzando il metodo Shutdown(). Il server viene avviato in una goroutine e successivamente un canale viene monitorato per ricevere un segnale di interruzione. Una volta ricevuto il segnale, il server si spegne, ma non immediatamente, bens\u00ec dopo alcuni secondi.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Attendere un'interruzione\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Tentativo di chiusura elegante\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
In conclusione<\/h3>\n
\nGo \u00e8 un linguaggio potente con una libreria standard praticamente universale. Le sue funzionalit\u00e0 predefinite sono ampie e possono essere ampliate grazie alle interfacce, il che consente di sviluppare server HTTP realmente robusti.<\/p>\n
Skillbox consiglia:<\/b><\/p>\n