{"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\/nl\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"De ontwikkeling van webservers in Golang \u2013 van eenvoudig naar complex","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"De
\n
\nVijf jaar geleden begon ik Gophish te ontwikkelen<\/a><\/noindex>, dit gaf me de mogelijkheid om Golang te leren. Ik realiseerde me dat Go een krachtige taal is, waarvan de mogelijkheden worden aangevuld met veel bibliotheken. Go is veelzijdig: je kunt er zonder problemen serverapplicaties mee ontwikkelen.<\/p>\n

Dit artikel is gewijd aan het schrijven van een server in Go. Laten we beginnen met eenvoudige dingen, zoals \"Hello world!\", en eindigen met een applicatie met functies zoals:<\/p>\n

\u2014 Gebruik van Let\u2019s Encrypt voor HTTPS.
\n\u2014 Fungeren als API-router.
\n\u2014 Werken met middleware.
\n\u2014 Verwerken van statische bestanden.
\n\u2014 Correct afsluiten.
\n<\/a><\/noindex><\/p>\n

Skillbox raadt aan:<\/b> Praktische cursus \u00abPython-ontwikkelaar vanaf nul\u00bb<\/a><\/noindex>.<\/p>\n

Ter herinnering:<\/b> voor alle lezers van \u00abHabr\u00bb \u2014 een korting van 10.000 roebel bij inschrijving voor elke cursus van Skillbox met de promocode \u00abHabr\u00bb.<\/i>\n<\/p><\/blockquote>\n

Hallo, wereld!<\/h3>\n

\nEen webserver op Go kan heel snel worden gemaakt. Hier is een voorbeeld van een handler die de eerder beloofde \"Hallo, wereld!\" teruggeeft.<\/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, \"Hallo Wereld!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nAls je dit vervolgens uitvoert, en de pagina opent localhost<\/noindex>, dan zie je meteen de tekst \"Hallo, wereld!\" (natuurlijk, als alles goed werkt).<\/p>\n
Daarna zullen we de handler herhaaldelijk gebruiken, maar laten we eerst begrijpen hoe alles in elkaar zit.<\/p>\n
net\/http<\/h4>\n
\nIn het voorbeeld werd het pakket gebruikt net\/http<\/code><\/a><\/noindex>, dit is het belangrijkste hulpmiddel in Go voor zowel server- als HTTP-clientontwikkeling. Om de code te begrijpen, laten we de betekenis van drie belangrijke elementen bekijken: http.Handler, http.ServeMux en http.Server.<\/p>\n
HTTP-handlers<\/h4>\n
\nWanneer we een verzoek ontvangen, analyseert de handler het en vormt een antwoord. Handlers in Go zijn als volgt ge\u00efmplementeerd:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nIn het eerste voorbeeld wordt de hulpfunctie http.HandleFunc gebruikt. Deze wikkelt een andere functie in, die op haar beurt http.ResponseWriter en http.Request in ServeHTTP accepteert.<\/p>\n
Met andere woorden, handlers in Golang worden gepresenteerd als een enkele interface, wat de programmeur veel mogelijkheden biedt. Zo is middleware bijvoorbeeld ge\u00efmplementeerd met behulp van een handler, waar ServeHTTP eerst iets doet en dan de ServeHTTP-methode van een andere handler aanroept.<\/p>\n
Zoals eerder aangegeven, vormen de handlers gewoon de antwoorden op verzoeken. Maar welke handler moet je op een bepaald moment gebruiken?<\/p>\n
Routing van verzoeken<\/h4>\n
\nOm de juiste keuze te maken, gebruik je een HTTP-multiplexer. In sommige bibliotheken wordt dit een muxer of router genoemd, maar het is allemaal hetzelfde. De functie van de multiplexer is het analyseren van het pad van het verzoek en het kiezen van de bijbehorende handler.<\/p>\n
Als er complexe routingondersteuning nodig is, kun je beter externe bibliotheken gebruiken. Enkele van de meest geavanceerde zijn gorilla\/mux<\/a><\/noindex> en go-chi\/chi<\/a><\/noindex>, deze bibliotheken maken het mogelijk om middleware eenvoudig te implementeren. Hiermee kun je wildcard-routing instellen en een aantal andere taken uitvoeren. Hun voordeel is de compatibiliteit met standaard HTTP-handlers. Hierdoor kun je eenvoudige code schrijven met de mogelijkheid om deze in de toekomst te wijzigen.<\/p>\n
Werken met complexe frameworks vereist in de regel niet-standaard oplossingen, wat het gebruik van de standaard handlers aanzienlijk bemoeilijkt. Voor het merendeel van de applicaties is een combinatie van de standaardbibliotheek en een eenvoudige router voldoende.<\/p>\n
Verwerkingsverzoeken<\/h4>\n
\nBovendien hebben we een component nodig die 'luistert' naar binnenkomende verbindingen en alle verzoeken naar de juiste handler doorverbindt. Deze taak kan probleemloos door http.Server worden uitgevoerd.<\/p>\n
Hieronder is te zien dat de server verantwoordelijk is voor alle taken die verband houden met het verwerken van verbindingen. Dit omvat bijvoorbeeld het werken met het TLS-protocol. Voor de implementatie wordt de standaard HTTP-server gebruikt via http.ListenAndServer.<\/p>\n
Laten we nu naar meer complexe voorbeelden kijken.<\/p>\n
Toevoegen van Let\u2019s Encrypt<\/h3>\n
\nStandaard werkt onze applicatie via het HTTP-protocol, maar het wordt aanbevolen om het HTTPS-protocol te gebruiken. In Go is dit geen probleem. Als je een certificaat en een priv\u00e9sleutel hebt ontvangen, hoef je alleen maar ListenAndServeTLS aan te roepen met de juiste certificaat- en sleutelbestanden.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nHet kan altijd beter.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> biedt gratis certificaten met de mogelijkheid voor automatische vernieuwing. Om gebruik te maken van de service, is het pakket nodig autocert<\/code>.<\/p>\n
De eenvoudigste manier om het in te stellen is door de autocert.NewListener-methode te gebruiken in combinatie met http.Serve. Deze methode maakt het mogelijk om TLS-certificaten te verkrijgen en te vernieuwen terwijl de HTTP-server verzoeken verwerkt:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nAls we het in de browser openen example.com<\/a><\/noindex>, krijgen we een HTTPS-antwoord \"Hello, world!\".<\/p>\n
Als een meer gedetailleerde configuratie nodig is, kan de autocert.Manager worden gebruikt. Vervolgens cre\u00ebren we een eigen instantie van http.Server (tot nu toe hebben we de standaardversie gebruikt) en voegen de manager toe aan de 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
\nDit is een eenvoudige manier om volledige ondersteuning voor HTTPS met automatische certificaatvernieuwing te implementeren.<\/p>\n
Toevoegen van aangepaste routes<\/h3>\n
\nDe standaardrouter die in de standaardbibliotheek is opgenomen, is goed, maar erg eenvoudig. In de meeste applicaties is geavanceerdere routering nodig, inclusief geneste en wildcard-routes of het instellen van sjablonen en padparameters.<\/p>\n
In dat geval is het verstandig om pakketten te gebruiken gorilla\/mux<\/a><\/noindex> en go-chi\/chi<\/a><\/noindex>. Met de laatste leren we werken \u2014 hieronder staat een voorbeeld.<\/p>\n
Gegeven: het bestand api\/v1\/api.go, dat routes voor onze API bevat:<\/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 stellen een voorvoegsel api\/vq in voor de routes in het hoofdbestand.<\/p>\n
We kunnen dit dan onder de api\/v1\/ voorprefix in onze hoofdapplicatie koppelen:<\/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
\nDe eenvoud van werken met complexe routes in Go maakt het mogelijk om de structurering van grote complexe applicaties te vereenvoudigen.<\/p>\n
Werken met middleware<\/h3>\n
\nBij tussenverwerking wordt \u00e9\u00e9n HTTP-handler door een andere gewikkeld, waardoor het mogelijk is om snel authenticatie, compressie, logging en andere functies uit te voeren.<\/p>\n
Als voorbeeld bekijken we de http.Handler-interface en schrijven we een handler voor gebruikersauthenticatie.<\/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        \/\/ Aangenomen dat authentificatie is geslaagd, voer de originele handler uit\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nEr zijn externe routers, zoals chi, die de functionaliteit van middleware kunnen uitbreiden.<\/p>\n
Werken met statische bestanden<\/h3>\n
\nDe standaardbibliotheek van Go bevat mogelijkheden voor het werken met statische inhoud, inclusief afbeeldingen, evenals JavaScript- en CSS-bestanden. Toegang tot deze bestanden kan worden verkregen via de functie http.FileServer. Deze retourneert een handler die bestanden uit een bepaalde directory serveert.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Configuratie voor het serveren van statische bestanden\nstaticPath, _ := filepath.Abs(\"..\/..\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nHet is belangrijk om te onthouden dat http.Dir de inhoud van de directory alleen weergeeft als er geen hoofdindexbestand index.html in de map aanwezig is. In dit geval, om te voorkomen dat de directory gecompromitteerd wordt, moet het pakket worden gebruikt. niet-ge\u00efncludeerd<\/code><\/a><\/noindex>.<\/p>\n
Correcte afsluiting<\/h3>\n
\nIn Go is er ook een functie voor correcte afsluiting van de HTTP-server. Dit kan gedaan worden met de Shutdown()-methode. De server wordt gestart in een goroutine en vervolgens wordt een kanaal afgeluisterd om een onderbrekingssignaal te ontvangen. Zodra het signaal wordt ontvangen, schakelt de server niet onmiddellijk uit, maar na een paar seconden.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Wacht op een onderbreking\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Probeer een nette afsluiting\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
Tot slot<\/h3>\n
\nGo is een krachtige taal met een bijna universele standaardbibliotheek. De standaardfunctionaliteit is behoorlijk breed en kan worden versterkt door interfaces - dit maakt het mogelijk om echt betrouwbare HTTP-servers te ontwikkelen.<\/p>\n
Skillbox raadt aan:<\/b><\/p>\n