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

\"Entwicklung
\n
\nVor f\u00fcnf Jahren begann ich Gophish zu entwickeln<\/a><\/noindex>, was mir die M\u00f6glichkeit gab, Golang zu lernen. Ich erkannte, dass Go eine m\u00e4chtige Sprache ist, deren F\u00e4higkeiten durch zahlreiche Bibliotheken erg\u00e4nzt werden. Go ist vielseitig: Insbesondere k\u00f6nnen mit ihm problemlos Serveranwendungen entwickelt werden.<\/p>\n

Dieser Artikel ist der Erstellung eines Servers mit Go gewidmet. Wir beginnen mit einfachen Dingen wie \u201eHello World!\u201c, und enden mit einer Anwendung, die folgende Funktionen bietet:<\/p>\n

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

Skillbox empfiehlt:<\/b> Praktischer Kurs \u201ePython-Entwickler von Grund auf\u201c<\/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

\nEinen Web-Server in Go kann man sehr schnell erstellen. Hier ist ein Beispiel f\u00fcr die Verwendung eines Handlers, 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, \"Hello World!\")\n})\nhttp.ListenAndServe(\":80\", nil)\n}<\/code><\/pre>\n
\nNachdem Sie dies getan haben, starten Sie die Anwendung und \u00f6ffnen die Seite localhost<\/noindex>, dann sehen Sie sofort den Text \u201eHallo, Welt!\u201c (vorausgesetzt, alles funktioniert richtig).<\/p>\n
Als n\u00e4chstes werden wir den Handler mehrfach verwenden, aber zuerst lassen Sie uns verstehen, wie alles aufgebaut ist.<\/p>\n
net\/http<\/h4>\n
\nIm Beispiel wurde das Paket net\/http<\/code><\/a><\/noindex>, das Hauptwerkzeug in Go zur Entwicklung sowohl von Servern als auch von HTTP-Clients. 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 eine Antwort. Die Handler in Go sind folgenderma\u00dfen implementiert:<\/p>\n
type Handler interface {\n        ServeHTTP(ResponseWriter, *Request)\n}<\/code><\/pre>\n
\nIm ersten Beispiel wird die Hilfsfunktion http.HandleFunc verwendet. Sie wickelt eine andere Funktion ein, die wiederum http.ResponseWriter und http.Request in ServeHTTP entgegennimmt.<\/p>\n
Anders gesagt, die Handler in Golang werden durch ein einheitliches Interface dargestellt, was den Programmierern viele M\u00f6glichkeiten bietet. Zum Beispiel wird Middleware durch einen Handler implementiert, bei dem ServeHTTP zuerst etwas macht und dann die Methode ServeHTTP eines anderen Handlers aufruft.<\/p>\n
Wie bereits erw\u00e4hnt, erstellen Handler einfach Antworten auf Anfragen. Aber welchen Handler sollte man zu einem bestimmten Zeitpunkt verwenden?<\/p>\n
Routing von Anfragen<\/h4>\n
\nUm die richtige Wahl zu treffen, nutzen Sie einen HTTP-Multiplexer. In verschiedenen 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
Sollte jedoch komplexes Routing ben\u00f6tigt werden, 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 einfache Implementierung der Middleware. Mit ihnen k\u00f6nnen Sie Wildcard-Routing einrichten und eine Reihe anderer Aufgaben durchf\u00fchren. Ihr Vorteil ist die Kompatibilit\u00e4t mit den standardm\u00e4\u00dfigen HTTP-Handlern. Das Ergebnis ist, dass Sie einfachen Code schreiben k\u00f6nnen, der zuk\u00fcnftig modifiziert werden kann.<\/p>\n
Die Arbeit mit komplexen Frameworks erfordert in der Regel nicht standardisierte L\u00f6sungen, was die Nutzung der Standard-Handler erheblich erschwert. F\u00fcr die meisten Anwendungen reicht eine Kombination aus der Standardbibliothek und einem einfachen Router aus.<\/p>\n
Anfragebearbeitung<\/h4>\n
\nZus\u00e4tzlich ben\u00f6tigen wir eine Komponente, die eingehende Verbindungen \u00bb\u00fcberwacht\u00ab und alle Anfragen an den richtigen Handler weiterleitet. Diese Aufgabe kann problemlos vom http.Server \u00fcbernommen werden.<\/p>\n
Im Folgenden 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. Der Aufruf von http.ListenAndServer nutzt den Standard-HTTP-Server.<\/p>\n
Nun 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, jedoch wird empfohlen, das HTTPS-Protokoll zu verwenden. In Go ist das problemlos m\u00f6glich. Wenn Sie ein Zertifikat und einen privaten Schl\u00fcssel erhalten haben, gen\u00fcgt es, ListenAndServeTLS mit den richtigen Zertifikat- und Schl\u00fcsseldateien zu konfigurieren.<\/p>\n
http.ListenAndServeTLS(\":443\", \"cert.pem\", \"key.pem\", nil)<\/code><\/pre>\n
\nMan kann immer besser werden.<\/p>\n
Let\u2019s Encrypt<\/a><\/noindex> bietet kostenlose Zertifikate mit automatischer Erneuerungsm\u00f6glichkeit an. Um den Service nutzen zu k\u00f6nnen, ben\u00f6tigen Sie ein Paket autocert<\/code>.<\/p>\n
Die einfachste M\u00f6glichkeit, es einzurichten, besteht darin, die Methode autocert.NewListener in Kombination mit http.Serve zu verwenden. Diese Methode erm\u00f6glicht es, TLS-Zertifikate zu erhalten und zu erneuern, w\u00e4hrend der HTTP-Server die Anfragen verarbeitet:<\/p>\n
http.Serve(autocert.NewListener(\"example.com\"), nil)<\/code><\/pre>\n
\nWenn wir im Browser \u00f6ffnen example.com<\/a><\/noindex>, erhalten wir eine HTTPS-Antwort \"Hello, world!\".<\/p>\n
F\u00fcr eine genauere Konfiguration sollten Sie den Manager autocert.Manager verwenden. Dann erstellen wir unsere eigene Instanz von http.Server (bis jetzt haben wir den Standardserver verwendet) und f\u00fcgen den Manager in die TLSConfig des Servers ein:<\/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 umzusetzen.<\/p>\n
Hinzuf\u00fcgen von benutzerdefinierten Routen<\/h3>\n
\nDer standardm\u00e4\u00dfig integrierte Router ist einfach und gut, reicht jedoch oft nicht aus. In den meisten Anwendungen werden komplexere Routing-Optionen ben\u00f6tigt, einschlie\u00dflich verschachtelter und Wildcard-Routen sowie Verfahren zur Einrichtung von Vorlagen und Pfadparametern.<\/p>\n
In diesem Fall sollten Pakete verwendet werden gorilla\/mux<\/a><\/noindex> und go-chi\/chi<\/a><\/noindex>. Mit dem Letzten werden wir arbeiten lernen \u2014 ein Beispiel finden Sie weiter unten.<\/p>\n
Gegeben sei die Datei api\/v1\/api.go, die die Routen f\u00fcr unser 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 f\u00fcgen den Routen im Hauptdatei den Pr\u00e4fix api\/vq hinzu.<\/p>\n
Dann k\u00f6nnen wir dies in unserem Hauptanwendungsrouter unter dem Prefix api\/v1\/ einbinden:<\/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 eine vereinfachte Strukturierung bei der Verwaltung gro\u00dfer, komplexer Anwendungen.<\/p>\n
Zusammenarbeit mit Middleware<\/h3>\n
\nBei der Verarbeitung durch Middleware wird ein HTTP-Handler in einen anderen eingekapselt, was es erm\u00f6glicht, schnell Authentifizierung, Komprimierung, Protokollierung und einige andere Funktionen durchzuf\u00fchren.<\/p>\n
Als Beispiel betrachten wir das Interface http.Handler, mit dem wir einen Handler f\u00fcr die Benutzerauthentifizierung des Dienstes erstellen.<\/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        \/\/ Vorausgesetzt, die Authentifizierung war erfolgreich, f\u00fchren Sie den urspr\u00fcnglichen Handler aus\n        next.ServeHTTP(w, r)\n    })\n}<\/code><\/pre>\n
\nEs gibt Drittanbieter-Router wie chi, die die Funktionalit\u00e4t der Middleware erweitern.<\/p>\n
Arbeiten mit statischen Dateien<\/h3>\n
\nDie Standardbibliothek von Go umfasst Funktionen zur Handhabung von statischen Inhalten, einschlie\u00dflich Bildern sowie JavaScript- und CSS-Dateien. Der Zugriff erfolgt \u00fcber die Funktion http.FileServer, die einen Handler zur\u00fcckgibt, der Dateien aus einem bestimmten Verzeichnis bereitstellt.<\/p>\n
func NewRouter() http.Handler {\n    router := chi.NewRouter()\n    r.Get(\"\/{name}\", HelloName)\n \n\/\/ Einrichtung 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 anzeigt, wenn keine Hauptdatei index.html vorhanden ist. In diesem Fall sollte das Paket verwendet werden, um eine Kompromittierung des Verzeichnisses zu verhindern. unindexed<\/code><\/a><\/noindex>.<\/p>\n
Korrekte Beendigung der Arbeit<\/h3>\n
\nIn Go gibt es eine Funktion f\u00fcr das ordnungsgem\u00e4\u00dfe Herunterfahren eines HTTP-Servers. Dies kann mit der Methode Shutdown() erfolgen. Der Server wird in einer Goroutine gestartet und anschlie\u00dfend wird auf ein Signal zum Abbruch gewartet. Sobald das Signal empfangen wird, schaltet sich der Server ab, allerdings nicht sofort, sondern nach ein paar Sekunden.<\/p>\n
handler := server.NewRouter()\nsrv := &http.Server{\n    Handler: handler,\n}\n\ngo func() {\nsrv.Serve(autocert.NewListener(domains...))\n}()\n\n\/\/ Warten auf ein Interrupt-Signal\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
Zusammenfassend<\/h3>\n
\nGo ist eine leistungsstarke Programmiersprache mit einer nahezu universellen Standardbibliothek. Die standardm\u00e4\u00dfigen Funktionen sind bereits sehr umfangreich und k\u00f6nnen durch Schnittstellen erweitert werden, was die Entwicklung wirklich zuverl\u00e4ssiger HTTP-Server erm\u00f6glicht.<\/p>\n
Skillbox empfiehlt:<\/b><\/p>\n