Utveckling av webbservrar i Golang – från enkelt till komplext

För fem år sedan började jag utveckla Gophish, vilket gav mig möjlighet att lära mig Golang. Jag insåg att Go är ett kraftfullt språk vars möjligheter kompletteras av många bibliotek. Go är mångsidigt: framför allt kan man utan problem utveckla serverapplikationer med det.

Denna artikel handlar om att skriva en server i Go. Vi börjar med enkla saker, som "Hello world!", och avslutar med en applikation med följande funktioner:

— Användning av Let's Encrypt för HTTPS.
— Arbetar som en API-ruttare.
— Arbetar med middleware.
— Hantering av statiska filer.
— Korrekt avslutande av arbetet.

Skillbox rekommenderar: Praktisk kurs «Python-utvecklare från grunden».

Påminnelse: för alla läsare av "Habr" — 10 000 rubel rabatt vid registrering för vilken kurs som helst på Skillbox med rabattkoden "Habr".

Hej, världen!

Att skapa en webbserver i Go går mycket snabbt. Här är ett exempel på en hanterare som returnerar den ovan nämnda "Hello, world!".

package main
 
import (
"fmt"
"net/http"
)
 
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello World!")
})
http.ListenAndServe(":80", nil)
}

Efter detta, om du startar applikationen och öppnar sidan localhost, kommer du omedelbart att se texten "Hello, world!" (naturligtvis om allt fungerar som det ska).

Därefter kommer vi att använda hanteraren flera gånger, men först låt oss förstå hur allt fungerar.

net/http

I exemplet användes paketet net/http, det är huvudsakligt verktyg i Go för att utveckla både servrar och HTTP-klienter. För att förstå koden, låt oss gå igenom betydelsen av tre viktiga element: http.Handler, http.ServeMux och http.Server.

HTTP-hanterare

När vi får en begäran analyserar hanteraren den och formar ett svar. Hanterarna i Go implementeras på följande sätt:

type Handler interface {
        ServeHTTP(ResponseWriter, *Request)
}

I det första exemplet används hjälpfunktionen http.HandleFunc. Den omsluter en annan funktion som i sin tur tar http.ResponseWriter och http.Request i ServeHTTP.

Med andra ord, hanterarna i Golang representeras av ett enda gränssnitt, vilket ger många möjligheter för programmeraren. Till exempel, middleware implementeras med hjälp av en hanterare, där ServeHTTP först gör något och sedan anropar ServeHTTP-metoden för en annan hanterare.

Som tidigare nämnts formar hanterarna helt enkelt svar på begärningar. Men vilken specifik hanterare ska man använda vid ett givet tillfälle?

Ruttning av begärningar

För att göra ett korrekt val, använd HTTP-multiplexern. I flera bibliotek kallas den muxer eller router, men allt detta är samma sak. Multiplexerns funktion är att analysera sökvägen för förfrågan och välja motsvarande hanterare.

Om du behöver stöd för mer komplexa ruttningar, är det bättre att använda externa bibliotek. Några av de mest avancerade är gorilla/mux och go-chi/chi, dessa bibliotek möjliggör mellanliggande bearbetning utan större problem. Med deras hjälp kan du konfigurera wildcard-routing och utföra en rad andra uppgifter. Deras fördel är kompatibilitet med standard HTTP-hanterare. Som ett resultat kan du skriva enkel kod med möjlighet till framtida modifieringar.

Arbete med komplexa ramverk i vanliga situationer kräver inte helt standardlösningar, vilket väsentligt komplicerar användningen av standardhanterare. För att skapa majoriteten av applikationerna räcker det med en kombination av det standardbiblioteket och en enkel router.

Begärningshantering

Dessutom behöver vi en komponent som 'lyssnar' på inkommande anslutningar och dirigerar alla förfrågningar till rätt hanterare. Denna uppgift klarar http.Server utan problem.

Nedan visas att servern ansvarar för alla uppgifter relaterade till behandlingen av anslutningar. Det handlar till exempel om arbete enligt TLS-protokollet. För att implementera anropet http.ListenAndServer används standard HTTP-servern.

Nu ska vi titta på mer komplexa exempel.

Tillägg av Let’s Encrypt

Som standard fungerar vår applikation via HTTP-protokollet, men det rekommenderas att använda HTTPS-protokollet. I Go går detta utan problem. Om du har fått ett certifikat och en privat nyckel, räcker det med att ange ListenAndServeTLS med rätt filer för certifikatet och nyckeln.

http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)

Det går alltid att göra det bättre.

Let's Encrypt erbjuder gratis certifikat med möjlighet till automatisk förnyelse. För att använda tjänsten behövs paketet autocert.

Det enklaste sättet att konfigurera det är att använda metoden autocert.NewListener i kombination med http.Serve. Metoden gör det möjligt att få och förnya TLS-certifikat, medan HTTP-servern hanterar förfrågningarna:

http.Serve(autocert.NewListener("example.com"), nil)

Om vi öppnar i webbläsaren example.com, får vi HTTPS-svar "Hello, world!".

Om du behöver en mer noggrann konfiguration, bör du använda autocert.Manager. Skapa sedan din egen instans av http.Server (hittills har vi använt standardinstansen) och lägg till managern i serverns TLSConfig:

m := &autocert.Manager{
Cache:      autocert.DirCache("golang-autocert"),
Prompt:     autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.org", "www.example.org"),
}
server := &http.Server{
    Addr:      ":443",
    TLSConfig: m.TLSConfig(),
}
server.ListenAndServeTLS("", "")

Detta är ett enkelt sätt att implementera fullständigt stöd för HTTPS med automatisk certifikatförnyelse.

Lägga till icke-standardrutter

Den standardrouter som ingår i standardbiblioteket är bra, men den är mycket enkel. De flesta applikationer behöver en mer komplicerad routing, inklusive inbäddade och wildcard-rutter eller en process för att ställa in mallar och vägparameterar.

I det här fallet bör vi använda paketen gorilla/mux och go-chi/chi. Vi kommer att lära oss att arbeta med det — en exempel visas nedan.

Givet — filen api/v1/api.go, som innehåller rutter för vårt API:

/ HelloResponse is the JSON representation for a customized message
type HelloResponse struct {
Message string `json:"message"`
}
 
// HelloName returns a personalized JSON message
func HelloName(w http.ResponseWriter, r *http.Request) {
name := chi.URLParam(r, "name")
response := HelloResponse{
Message: fmt.Sprintf("Hello %s!", name),
}
jsonResponse(w, response, http.StatusOK)
}
 
// NewRouter returns an HTTP handler that implements the routes for the API
func NewRouter() http.Handler {
r := chi.NewRouter()
r.Get("/{name}", HelloName)
return r
}

Vi sätter en prefix för rutter api/vq i huvudfilen.

Vi kan sedan montera detta på vår huvudrouter under prefixet api/v1 i vår huvudapplikation:

// NewRouter returns a new HTTP handler that implements the main server routes
func NewRouter() http.Handler {
router := chi.NewRouter()
    router.Mount("/api/v1/", v1.NewRouter())
    return router
}
http.Serve(autocert.NewListener("example.com"), NewRouter())

Enkelheten i att arbeta med komplexa rutter i Go gör det möjligt att förenkla strukturen för att hantera stora och komplexa applikationer.

Arbeta med mellanprogram

Vid användning av mellanprogram omger man en HTTP-behandlare med en annan, vilket möjliggör snabb autentisering, komprimering, loggning och några andra funktioner.

Som exempel, låt oss titta på gränssnittet http.Handler, med hjälp av detta skriver vi en behandlare med autentisering för användare av tjänsten.

func RequireAuthentication(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !isAuthenticated(r) {
            http.Redirect(w, r, "/login", http.StatusTemporaryRedirect)
            return
        }
        // Om autentiseringen lyckades, kör den ursprungliga behandlaren
        next.ServeHTTP(w, r)
    })
}

Det finns externa routrar som chi, som möjliggör utökning av funktionaliteten för mellanprogram.

Arbeta med statiska filer

Standardbiblioteket i Go inkluderar funktioner för att hantera statiskt innehåll, inklusive bilder, samt JavaScript- och CSS-filer. Åtkomst till dem kan göras via funktionen http.FileServer. Den returnerar en behandlare som serverar filer från en specifik katalog.

func NewRouter() http.Handler {
    router := chi.NewRouter()
    r.Get("/{name}", HelloName)
 
// Konfigurera distribution av statiska filer
staticPath, _ := filepath.Abs("../..//static/")
fs := http.FileServer(http.Dir(staticPath))
    router.Handle("/*", fs)
    
    return r

Det är viktigt att komma ihåg att http.Dir visar innehållet i katalogen om det inte finns någon huvudfil index.html i den. I detta fall, för att undvika katalogkompromiss, bör paketet användas oberoende.

Korrekt avstängning

I Go finns det också en funktion för korrekt avstängning av HTTP-servern. Detta kan göras med hjälp av metoden Shutdown(). Servern startas i en goroutine, och sedan lyssnas på kanalen för att ta emot avbrottssignaler. Så snart signalen tas emot stängs servern ner, men inte omedelbart, utan efter några sekunder.

handler := server.NewRouter()
srv := &http.Server{
    Handler: handler,
}
 
go func() {
srv.Serve(autocert.NewListener(domains...))
}()
 
// Vänta på ett avbrott
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
 
// Försök en smidig avstängning
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)

Som en avslutning

Go är ett kraftfullt språk med en praktiskt taget universell standardbibliotek. Dess standardfunktioner är ganska omfattande, och de kan förstärkas med hjälp av gränssnitt — detta möjliggör utveckling av verkligt tillförlitliga HTTP-servrar.

Skillbox rekommenderar:

• Tvåårig praktisk kurs «Jag är webbutvecklare PRO».
• Utbildningskurs online "Yrket Java-utvecklare".
• Praktisk årskurs PHP-utvecklare från grunden till PRO.

Källa: habr.com