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

\"Sviluppo
\n
\nCinque anni fa ho iniziato a sviluppare Gophish<\/a><\/noindex>, il che mi ha permesso di approfondire Golang. Ho capito che Go \u00e8 un linguaggio potente, le cui funzionalit\u00e0 sono ampliate da numerose librerie. Go \u00e8 versatile: in particolare, consente di sviluppare senza problemi applicazioni server.<\/p>\n

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

\u2014 Utilizzo di Let's Encrypt per HTTPS.
\n\u2014 Funziona come router API.
\n\u2014 Gestione di middleware.
\n\u2014 Elaborazione di file statici.
\n\u2014 Chiusura corretta.
\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

Ciao, mondo!<\/h3>\n

\nCreare un server web in Go \u00e8 molto veloce. Ecco un esempio di utilizzo di un gestore che restituisce il promettente \"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
\nDopo di che, se esegui l'applicazione e apri la pagina localhost<\/noindex>, vedrai immediatamente il testo \"Hello, world!\" (certo, se tutto funziona correttamente).<\/p>\n
In seguito utilizzeremo ripetutamente il gestore, ma prima facciamo un po' di chiarezza su come funziona tutto.<\/p>\n
net\/http<\/h4>\n
\nNell'esempio \u00e8 stato utilizzato il pacchetto net\/http<\/code><\/a><\/noindex>, il principale strumento in Go per sviluppare sia server che client HTTP. Per comprendere il codice, vediamo il significato di tre elementi chiave: http.Handler, http.ServeMux e http.Server.<\/p>\n
Gestori HTTP<\/h4>\n
\nQuando riceviamo una richiesta, il gestore la analizza e forma 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 si utilizza una 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 opportunit\u00e0 per il programmatore. Ad esempio, il middleware \u00e8 implementato tramite un gestore, dove ServeHTTP prima esegue un'azione e poi chiama il metodo ServeHTTP di un altro gestore.<\/p>\n
Come gi\u00e0 detto, i gestori semplicemente formano risposte alle richieste. Ma quale gestore usare in un dato momento?<\/p>\n
Routing delle richieste<\/h4>\n
\nPer fare la scelta giusta, utilizza un multiplexor HTTP. In alcune librerie, \u00e8 chiamato muxer o router, ma sono tutti sinonimi. La funzione del multiplexor consiste nell'analizzare il percorso della richiesta e scegliere il gestore appropriato.<\/p>\n
Se hai bisogno di supporto per una routing complessa, \u00e8 meglio utilizzare librerie di terze parti. Alcune delle pi\u00f9 avanzate sono: gorilla\/mux<\/a><\/noindex> e go-chi\/chi<\/a><\/noindex>, queste librerie offrono la possibilit\u00e0 di implementare il middleware senza particolari problemi. Grazie a loro puoi configurare la routing wildcard e svolgere 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 situazioni normali richieder\u00e0 soluzioni non standard, il che complica notevolmente l'utilizzo dei gestori predefiniti. Per la creazione della stragrande maggioranza delle applicazioni, \u00e8 sufficiente una combinazione della libreria predefinita e di un router non complesso.<\/p>\n
Elaborazione delle richieste<\/h4>\n
\nInoltre, abbiamo bisogno di un componente che \"ascolti\" le connessioni in entrata e reindirizzi tutte le richieste al corretto gestore. Questa attivit\u00e0 pu\u00f2 essere gestita facilmente da http.Server.<\/p>\n
Di seguito, viene mostrato che il server si occupa di tutte le operazioni relative alla gestione delle connessioni. Ad esempio, il lavoro con il protocollo TLS. Per implementare la chiamata http.ListenAndServer si utilizza il server HTTP standard.<\/p>\n
Ora vediamo esempi pi\u00f9 complessi.<\/p>\n
Aggiunta di Let\u2019s Encrypt<\/h3>\n
\nPer default, la nostra applicazione funziona con il protocollo HTTP, ma \u00e8 consigliato utilizzare il protocollo HTTPS. In Go, questo \u00e8 facilmente realizzabile. Se hai ottenuto il certificato e la chiave privata, devi semplicemente impostare ListenAndServeTLS specificando i file corretti 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> offre certificati gratuiti con possibilit\u00e0 di aggiornamento automatico. Per usufruire del servizio, \u00e8 necessario il pacchetto autocert<\/code>.<\/p>\n
Il modo pi\u00f9 semplice per configurarlo \u00e8 utilizzare 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>, riceveremo una risposta HTTPS \"Hello, world!\".<\/p>\n
Se hai bisogno di una configurazione pi\u00f9 dettagliata, puoi utilizzare il gestore autocert.Manager. Quindi creiamo un'istanza personalizzata di http.Server (fino ad ora abbiamo usato l'istanza predefinita) e aggiungiamo il gestore a 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 supporto completo per HTTPS con aggiornamento automatico del certificato.<\/p>\n
Aggiunta di percorsi personalizzati<\/h3>\n
\nIl router predefinito incluso nella libreria standard \u00e8 buono, ma \u00e8 molto semplice. La maggior parte delle applicazioni richiede una gestione pi\u00f9 complessa dei percorsi, incluse le routes annidate e wildcard, o la procedura per impostare modelli e parametri dei percorsi.<\/p>\n
In questo caso, \u00e8 consigliabile utilizzare i pacchetti gorilla\/mux<\/a><\/noindex> e go-chi\/chi<\/a><\/noindex>. Con l'ultimo impareremo a lavorare \u2014 di seguito \u00e8 mostrato un esempio.<\/p>\n
Data \u2014 file api\/v1\/api.go contenente i percorsi 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 api\/vq per i percorsi nel file principale.<\/p>\n
Possiamo poi montarlo 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 nel gestire percorsi complessi in Go rende possibile semplificare la strutturazione nella gestione di grandi applicazioni complesse.<\/p>\n
Lavorare con middleware<\/h3>\n
\nNel caso del middleware, viene utilizzato l'inserimento di un gestore HTTP all'interno di un altro, il che consente una rapida autenticazione, compressione, registrazione e altre funzioni.<\/p>\n
Come esempio, consideriamo l'interfaccia http.Handler e scriviamo un gestore con 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        \/\/ Assuming authentication passed, run the original handler\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nCi sono router di terze parti, come chi, che permettono di estendere le funzionalit\u00e0 del middleware.<\/p>\n
Gestire file statici<\/h3>\n
\nLa libreria standard di Go include funzionalit\u00e0 per lavorare con contenuti statici, comprese immagini, file JavaScript e CSS. \u00c8 possibile accedervi tramite la funzione http.FileServer. Questa restituisce un gestore che serve file da una directory specificata.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configurazione per la distribuzione di 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 un file principale index.html. In questo caso, per evitare la compromissione della directory, \u00e8 consigliabile utilizzare il pacchetto non indicizzato<\/code><\/a><\/noindex>.<\/p>\n
Terminazione corretta<\/h3>\n
\nIn Go \u00e8 presente anche una funzione per la terminazione corretta del server HTTP. Questo pu\u00f2 essere fatto utilizzando il metodo Shutdown(). Il server viene avviato in una goroutine, quindi il 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\/\/ Aspetta un'interruzione\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Tentativo di arresto controllato\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
In conclusione<\/h3>\n
\nGo \u2014 un linguaggio potente con una libreria standard praticamente universale. Le sue funzionalit\u00e0 di default sono molto ampie e possono essere ampliate grazie alle interfacce, il che consente di sviluppare server HTTP veramente affidabili.<\/p>\n
Skillbox consiglia:<\/b><\/p>\n