🥇Veebiserverite arendamine Golangis — lihtsast keeruliseks

Viis aastat tagasi alustasin ma Gophishi arendamist, see andis võimaluse õppida Golangi. Ma mõistsin, et Go on võimas keel, mille võimalusi täiendab arvukalt teeke. Go on universaalne: näiteks saab seda kasutada serverirakenduste arendamiseks probleemideta.

See artikkel on pühendatud serveri kirjutamisele Go-s. Alustame lihtsatest asjadest, nagu „Tere maailm!“, ja lõpetame rakendusega, millel on järgmised võimalused:

— Let’s Encrypti kasutamine HTTPS-iks.
— Töötamine API marsruutijana.
— Töötamine middleware'iga.
— Staatiliste failide töötlemine.
— Korralik väljalülitamine.

Skillbox soovitab: Praktiline kursus „Python-arendaja nullist“.
Tuletame meelde: kõigile «Habr» lugejatele – 10 000 rubla allahindlus igale Skillboxi kursusele, kasutades sooduskoodi «Habr».

Tere, maailm!

Veebiserveri loomine Go-s on väga kiire. Siin on näide toimimisest töötlusest, mis tagastab eelnevalt mainitud „Tere, maailm!“.

package main

import (
"fmt"
"net/http"
)

func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Tere maailm!")
})
http.ListenAndServe(":80", nil)
}

Pärast seda, kui rakendus käivitada ja leht avada localhost, näete kohe teksti „Tere, maailm!“ (muidugi, kui kõik töötab õigesti).

Edasi kasutame töötlust korduvalt, kuid kõigepealt võtame aega mõistmiseks, kuidas kõik toimib.

net/http

Näites kasutati paketti net/http, see on Go põhivahend serverite ja HTTP-kliendi arendamiseks. Koodi mõistmiseks vaatame kolme olulise elemendi tähendust: http.Handler, http.ServeMux ja http.Server.

HTTP-töötlustooted

Kui me saame päringu, analüüsib töötlus selle ja koostab vastuse. Go-s on töötlejad rakendatud järgmiselt:

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

Esimeses näites kasutatakse abifunktsiooni http.HandleFunc. See ümbritseb teist funktsiooni, mis omakorda võtab http.ResponseWriter ja http.Request'i ServeHTTP-s.

Teisisõnu, töötlejad Golangis esindavad ühtset liidest, mis pakub programmeerijale palju võimalusi. Näiteks on middleware rakendatud läbi töötleja, kus ServeHTTP teeb esmalt midagi ja seejärel kutsub teise töötleja ServeHTTP meetodi.

Nagu eelpool öeldud, töötlejad koostavad lihtsalt vastuseid päringutele. Kuid millist töötlejat tuleks kasutada konkreetsel hetkel?

Päringute marsruutimine

Õige valiku tegemiseks kasutage HTTP-multiplexerit. Mõnedes raamatukogudes nimetatakse seda muxeriks või ruuteriks, kuid kõik need on sama asi. Multiplexer'i funktsioon on analüüsida päringu teed ja valida vastav töötleja.

Kui on vajalik keerulise marsruutimise tugi, on parem kasutada kolmandate osapoolte raamatukogusid. Mõned kõige arenenumad on: gorilla/mux ja go-chi/chi, need raamatukogud võimaldavad rakendada vahepealseid töötlemisi ilma eriliste probleemideta. Nende abil on võimalik seadistada wildcards-marsruutimist ja lahendada mitmeid muid ülesandeid. Nende eeliseks on ühilduvus standardsete HTTP-töötlejatega. Tulemuseks on, et saate kirjutada lihtsa koodi, millel on tulevikus muudetava koodi võimalus.

Töökeeruliste raamistikudega tavaliselt nõuab ebatavalisi lahendusi, mis oluliselt keerukamaks muudab standardsete töötlejate kasutamise. Enamikule rakendustele piisab vaikimisi raamatukogu ja lihtsa ruuteri kombinatsioonist.

Päringute töötlemine

Lisaks on meil vajalik komponent, mis „kuulab” sissetulevaid ühendusi ja suunab kõik päringud õigele töötlejale. Selle ülesandega saab hõlpsasti hakkama http.Server.

Allpool on näidatud, et server vastutab kõigi ülesannete eest, mis on seotud ühenduste töötlemisega. See hõlmab näiteks TLS-protokolli tööd. http.ListenAndServe'i kutsumise rakendamiseks kasutatakse standardset HTTP-serverit.

Nüüd vaatame keerulisemaid näiteid.

Let’s Encrypti lisamine

Vaikimisi töötab meie rakendus HTTP-protokolli abil, kuid soovitatakse kasutada HTTPS-protokolli. Go-s saab seda teha probleemideta. Kui olete saanud sertifikaadi ja privaatvõtme, piisab, kui määrata ListenAndServeTLS koos õige sertifikaadi ja võtmefailiga.

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

Alati on võimalik paremini teha.

Let’s Encrypt pakub tasuta sertifikaate automaatse uuendamise võimalusega. Teenuse kasutamiseks on vajalik pakett autocert.

Lihtsaim viis selle seadistamiseks on kasutada meetodit autocert.NewListener koos http.Serve'iga. Meetod võimaldab saada ja uuendada TLS-sertifikaate, samal ajal kui HTTP-server töötleb päringuid:

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

Kui avame brauseris example.com, siis saame HTTPS-reaktsiooni «Tere, maailm!».

Kui vajate põhjalikumat seadistamist, siis tasub kasutada autocert.Manager'i. Seejärel loome oma http.Server'i instantsi (kuni praeguseni oleme kasutanud vaikeseadet) ja lisame halduri TLSConfig'i serverisse:

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("", "")

See on lihtne viis kogu HTTPS-toe rakendamiseks automaatse sertifikaadi uuendamisega.

Mitte-standardsete marsruutide lisamine

Vaikimisi marsruuter, mis on kaasatud standardteekidesse, on hea, kuid väga lihtne. Enamikes rakendustes on vajalik keerulisem marsruutimine, sealhulgas pesakonnad ja wildcard-marsruudid või šabloonide ja teeparameetrite seadistamise protseduur.

Selles olukorras tasub kasutada pakette gorilla/mux ja go-chi/chi. Viimasega õpime me töötama — allpool on näide.

Antud on fail api/v1/api.go, mis sisaldab meie API marsruute:

/ 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
}

Seame marsruutidele api/vq prefiksi peafailis.

Saame seejärel selle meie peamisse marsruuterisse lisada api/v1/ prefiksi all tagasi meie põhitarvutis:

// 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())

Töötamine keeruliste marsruutidega Go-s võimaldab lihtsustada suure keeruliste rakenduste haldust.

Töötamine middleware'iga

Vahepealse töötlemise korral kasutatakse ühe HTTP-käitja mähkimist teise, mis võimaldab kiiresti teha autentimist, tihendamist, logimist ja mõned muud funktsioonid.

Näiteks vaatame http.Handler'i liidest, mille abil kirjutame kasutajate autentimisega käitja.

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
        }
        \/\/ Eeldades, et autentimine on läbitud, käitame originaalkäitjat
        next.ServeHTTP(w, r)
    })
}

On olemas kolmanda osapoole marsruutijad, nagu chi, mis võimaldavad vahepealse töötlemise funktsionaalsust laiendada.

Töötamine staatiliste failidega

Go standardteek sisaldab võimalusi staatilise sisu käsitlemiseks, sealhulgas pilte ja JavaScripti ja CSS-faile. Neile pääseb juurde http.FileServer'i funktsiooni kaudu. See tagastab käitja, mis edastab faile kindlast kataloogist.

func NewRouter() http.Handler {
    router := chi.NewRouter()
    r.Get("/{name}", HelloName)
 
// Kuidas seadistada staatiliste failide jagamist
staticPath, _ := filepath.Abs("../../static/")
fs := http.FileServer(http.Dir(staticPath))
    router.Handle("/*", fs)
    
    return r

Oluline on meeles pidada, et http.Dir kuvab kausta sisu vaid juhul, kui seal pole põhifaili index.html. Sellisel juhul tuleks kausta kompromiteerimise vältimiseks kasutada paketti indeksimata.

Korralik sulgemine

Go-s on olemas ka selline funktsioon nagu HTTP-serveri korralik sulgemine. Seda saab teha Shutdown() meetodi abil. Server käivitub goroutines ja seejärel kuulatakse signaali katkestamiseks. Kui signaal on saadud, lülitatakse server välja, kuid mitte kohe, vaid mõne sekundi pärast.

handler := server.NewRouter()
srv := &http.Server{
    Handler: handler,
}
 
go func() {
srv.Serve(autocert.NewListener(domains...))
}()
 
// Oota katkestust
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
 
// Proovi korralikku sulgemist
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)

Kokkuvõtteks

Go on võimas keel, millel on quasi-üksne standardteek. Selle vaikimisi võimalused on ulatuslikud, ja neid saab tugevdada liideste abil — see võimaldab arendada tõeliselt usaldusväärseid HTTP-servereid.

Skillbox soovitab:

Kaks aastat praktilist kursust „Mina olen PRO veebiarendaja“.

Haridusalane veebikursus «Java-arendaja amet».

Praktiline aastakursus «PHP-arendaja 0-st PRO-ni».

Allikas: habr.com