{"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\/de\/blog\/news\/razrabotka-veb-serverov-na-golang-ot-prostogo-k-slozhnomu","title":{"rendered":"Entwicklung von Webservern in Golang \u2014 von einfach bis komplex","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

\"Entwicklung
\n
\nVor f\u00fcnf Jahren habe ich begonnen Gophish zu entwickeln<\/a><\/noindex>, was mir die M\u00f6glichkeit gab, Golang zu lernen. Ich erkannte, dass Go eine leistungsstarke Sprache ist, deren M\u00f6glichkeiten durch eine Vielzahl von Bibliotheken erweitert werden. Go ist vielseitig: insbesondere kann man damit problemlos serverseitige Anwendungen entwickeln.<\/p>\n

Dieser Artikel ist dem Schreiben eines Servers in Go gewidmet. Lassen Sie uns mit einfachen Dingen wie \u201eHello World!\u201c beginnen und enden mit einer Anwendung, die folgende Funktionen bietet:<\/p>\n

\u2014 Verwendung von Let\u2019s Encrypt f\u00fcr HTTPS.
\n\u2014 Funktion als API-Router.
\n\u2014 Arbeiten mit Middleware.
\n\u2014 Verarbeitung statischer Dateien.
\n\u2014 Ordentliches Herunterfahren.
\n<\/a><\/noindex><\/p>\n

Skillbox empfiehlt:<\/b> Praktischer Kurs \u201ePython-Entwickler von Grund auf\u201e<\/a><\/noindex>.<\/p>\n

Wir erinnern daran:<\/b> alle Leser von \u201eHabr\u201c erhalten einen Rabatt von 10.000 Rubel bei der Anmeldung zu einem beliebigen Kurs von Skillbox mit dem Aktionscode \u201eHabr\u201c.<\/i>\n<\/p><\/blockquote>\n

Hallo, Welt!<\/h3>\n

\nEs ist sehr einfach, einen Webserver in Go zu erstellen. Hier ist ein Beispiel, das einen Handler verwendet, der das oben versprochene \u201eHallo, Welt!\u201c zur\u00fcckgibt.<\/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 Welt!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nNachdem Sie dies getan haben, starten Sie die Anwendung und \u00f6ffnen die Seite localhost<\/noindex>, werden Sie sofort den Text \u201eHallo, Welt!\u201c sehen (vorausgesetzt, alles funktioniert richtig).<\/p>\n
Im Folgenden werden wir den Handler mehrfach verwenden, aber lassen Sie uns zun\u00e4chst verstehen, wie alles funktioniert.<\/p>\n
net\/http<\/h4>\n
\nIm Beispiel wurde das Paket net\/http<\/code><\/a><\/noindex>, welches das Hauptwerkzeug in Go f\u00fcr die Entwicklung sowohl von Servern als auch von HTTP-Clients ist, verwendet. Um den Code zu verstehen, lassen Sie uns die Bedeutung von drei wichtigen Elementen kl\u00e4ren: http.Handler, http.ServeMux und http.Server.<\/p>\n
HTTP-Handler<\/h4>\n
\nWenn wir eine Anfrage erhalten, analysiert der Handler sie und formt die Antwort. Handler in Go sind wie folgt implementiert:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nIm ersten Beispiel wird die Hilfsfunktion http.HandleFunc verwendet. Sie umschlie\u00dft eine andere Funktion, die wiederum http.ResponseWriter und http.Request in ServeHTTP akzeptiert.<\/p>\n
Anders ausgedr\u00fcckt, sind die Handler in Golang durch ein einheitliches Interface dargestellt, was den Programmierern viele M\u00f6glichkeiten bietet. So wird beispielsweise Middleware durch einen Handler realisiert, bei dem ServeHTTP zun\u00e4chst etwas macht und dann die Methode ServeHTTP eines anderen Handlers aufruft.<\/p>\n
Wie bereits erw\u00e4hnt, formt der Handler einfach die Antworten auf die Anfragen. Aber welchen Handler sollten wir zu einem bestimmten Zeitpunkt verwenden?<\/p>\n
Routing von Anfragen<\/h4>\n
\nUm eine fundierte Entscheidung zu treffen, nutzen Sie den HTTP-Multiplexer. In einigen Bibliotheken wird er als muxer oder Router bezeichnet, aber das ist alles dasselbe. Die Funktion des Multiplexers besteht darin, den Pfad der Anfrage zu analysieren und den entsprechenden Handler auszuw\u00e4hlen.<\/p>\n
Wenn jedoch Unterst\u00fctzung f\u00fcr komplexe Routen erforderlich ist, ist es besser, auf externe Bibliotheken zur\u00fcckzugreifen. Einige der fortschrittlichsten sind gorilla\/mux<\/a><\/noindex> und go-chi\/chi<\/a><\/noindex>, diese Bibliotheken erm\u00f6glichen eine problemlose Implementierung von Middleware. Mit ihrer Hilfe kann Wildcard-Routing konfiguriert und eine Reihe anderer Aufgaben erledigt werden. Ihr Vorteil ist die Kompatibilit\u00e4t mit den Standard-HTTP-Handlern. So k\u00f6nnen Sie einfachen Code schreiben, den Sie in Zukunft modifizieren k\u00f6nnen.<\/p>\n
Die Arbeit mit komplexen Frameworks erfordert in der Regel nicht ganz standardisierte L\u00f6sungen, was die Verwendung von Standard-Handlern erheblich kompliziert. F\u00fcr die meisten Anwendungen reicht die Kombination aus der Standardbibliothek und einem einfachen Router aus.<\/p>\n
Anfragenverarbeitung<\/h4>\n
\nZudem ben\u00f6tigen wir eine Komponente, die eingehende Verbindungen \"\u00fcberwacht\" und alle Anfragen an den richtigen Handler weiterleitet. Diese Aufgabe kann problemlos von http.Server \u00fcbernommen werden.<\/p>\n
Unten sehen Sie, dass der Server f\u00fcr alle Aufgaben verantwortlich ist, die mit der Verarbeitung von Verbindungen zu tun haben. Dazu geh\u00f6rt beispielsweise die Arbeit mit dem TLS-Protokoll. F\u00fcr den Aufruf von http.ListenAndServer wird der Standard-HTTP-Server verwendet.<\/p>\n
Jetzt schauen wir uns komplexere Beispiele an.<\/p>\n
Hinzuf\u00fcgen von Let\u2019s Encrypt<\/h3>\n
\nStandardm\u00e4\u00dfig l\u00e4uft unsere Anwendung \u00fcber das HTTP-Protokoll, es wird jedoch empfohlen, das HTTPS-Protokoll zu verwenden. In Go kann dies problemlos umgesetzt werden. Wenn Sie ein Zertifikat und einen privaten Schl\u00fcssel erhalten haben, reicht es aus, ListenAndServeTLS mit den richtigen Zertifikat- und Schl\u00fcsseldateien zu verwenden.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nEs gibt immer Raum f\u00fcr Verbesserungen.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> bietet kostenlose Zertifikate mit automatischer Verl\u00e4ngerung. Um den Dienst zu nutzen, ben\u00f6tigen Sie das Paket autocert<\/code>.<\/p>\n
Die einfachste M\u00f6glichkeit, es einzurichten, besteht darin, die Methode autocert.NewListener in Kombination mit http.Serve zu verwenden. Die Methode erm\u00f6glicht es, TLS-Zertifikate zu erhalten und zu aktualisieren, w\u00e4hrend der HTTP-Server die Anfragen verarbeitet:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nWenn wir es im Browser \u00f6ffnen example.com<\/a><\/noindex>, dann erhalten wir eine HTTPS-Antwort \u201eHallo, Welt!\u201c.<\/p>\n
Wenn eine genauere Konfiguration erforderlich ist, sollten Sie den Manager autocert.Manager verwenden. Dann erstellen wir unsere eigene Instanz von http.Server (bis jetzt haben wir die Standardinstanz verwendet) und f\u00fcgen den Manager zum Server TLSConfig hinzu:<\/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
\nDies ist eine einfache M\u00f6glichkeit, vollst\u00e4ndige Unterst\u00fctzung f\u00fcr HTTPS mit automatischer Zertifikatserneuerung zu implementieren.<\/p>\n
Hinzuf\u00fcgen von benutzerdefinierten Routen<\/h3>\n
\nDer Standard-Router, der in die Standardbibliothek integriert ist, ist zwar gut, aber er ist sehr einfach. In den meisten Anwendungen wird eine komplexere Routing-L\u00f6sung ben\u00f6tigt, einschlie\u00dflich verschachtelter und Wildcard-Routen oder einer Methode zur Festlegung von Mustern und Routenparametern.<\/p>\n
In diesem Fall sollten Sie die Pakete verwenden gorilla\/mux<\/a><\/noindex> und go-chi\/chi<\/a><\/noindex>. Mit dem Letzten werden wir arbeiten lernen \u2014 ein Beispiel ist unten dargestellt.<\/p>\n
Gegeben ist eine Datei api\/v1\/api.go, die die Routen f\u00fcr unsere API enth\u00e4lt:<\/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
\nWir setzen den Routen-Prefix api\/vq in der Hauptdatei fest.<\/p>\n
Dann k\u00f6nnen wir dies in unseren Haupt-Router unter dem Prefix api\/v1\/ in unserer Hauptanwendung einf\u00fcgen:<\/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
\nDie einfache Handhabung komplexer Routen in Go erm\u00f6glicht es, die Strukturierung der Wartung gro\u00dfer komplexer Anwendungen zu vereinfachen.<\/p>\n
Arbeiten mit Middleware<\/h3>\n
\nIm Fall der Middleware wird ein HTTP-Handler in einen anderen gewickelt, was schnelle Authentifizierung, Kompression, Protokollierung und einige andere Funktionen erm\u00f6glicht.<\/p>\n
Als Beispiel betrachten wir das Interface http.Handler, mit dem wir einen Handler f\u00fcr die Benutzer-Authentifizierung des Dienstes schreiben werden.<\/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        \/\/ Angenommen, die Authentifizierung war erfolgreich, f\u00fchre den urspr\u00fcnglichen Handler aus\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nEs gibt externe Router wie chi, die die Funktionalit\u00e4t der Middleware erweitern.<\/p>\n
Arbeiten mit statischen Dateien<\/h3>\n
\nDie Standardbibliothek von Go enth\u00e4lt Funktionen zur Arbeit mit statischen Inhalten, einschlie\u00dflich Bildern sowie JavaScript- und CSS-Dateien. Der Zugriff erfolgt \u00fcber die Funktion http.FileServer. Diese gibt einen Handler zur\u00fcck, der Dateien aus einem bestimmten Verzeichnis ausliefert.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Konfiguration der Bereitstellung statischer Dateien\nstaticPath, _ := filepath.Abs(\"..\/..\/static\/\")\nfs := http.FileServer(http.Dir(staticPath))\n    router.Handle(\"\/*\", fs)\n    \n    return r<\/code><\/pre>\n
\nEs ist wichtig zu beachten, dass http.Dir den Inhalt eines Verzeichnisses nur anzeigt, wenn darin keine index.html-Datei vorhanden ist. In diesem Fall sollte das Paket verwendet werden, um eine Kompromittierung des Verzeichnisses zu vermeiden. nicht indiziert<\/code><\/a><\/noindex>.<\/p>\n
Sanftes Herunterfahren<\/h3>\n
\nIn Go gibt es auch eine Funktion zum sanften Herunterfahren des HTTP-Servers. Dies kann mit der Methode Shutdown() erfolgen. Der Server wird in einer Goroutine gestartet, und dann wird ein Kanal abgeh\u00f6rt, um ein Unterbrechungssignal zu empfangen. Sobald das Signal empfangen wird, wird der Server abgeschaltet, jedoch nicht sofort, sondern nach einigen Sekunden.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n \ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n \n\/\/ Auf ein Interrupt warten\nc := make(chan os.Signal, 1)\nsignal.Notify(c, os.Interrupt)\n<-c\n \n\/\/ Versuch eines sanften Herunterfahrens\nctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)\ndefer cancel()\nsrv.Shutdown(ctx)<\/code><\/pre>\n
<\/p>\n
Als Fazit<\/h3>\n
\nGo ist eine leistungsstarke Sprache mit einer nahezu universellen Standardbibliothek. Ihre Standardfunktionen sind sehr umfassend, und man kann sie durch Schnittstellen erweitern, was die Entwicklung wirklich zuverl\u00e4ssiger HTTP-Server erm\u00f6glicht.<\/p>\n
Skillbox empfiehlt:<\/b><\/p>\n