Cúig bliana ó shin thosaigh mé , thug sé seo deis chun Golang a fhoghlaim. Thuig mé gur teanga chumhachtach í Go, comhlánaithe ag go leor leabharlann. Tá Go versatile: go háirithe, is féidir é a úsáid chun feidhmchláir ar thaobh an fhreastalaí a fhorbairt gan aon fhadhbanna.
Baineann an t-alt seo le freastalaí a scríobh in Go. Cuirimis tús le rudaí simplí cosúil le “Dia duit a dhomhan!” agus críochnóimid le feidhmchlár leis na cumais seo a leanas:
- Ag baint úsáide as Let's Encrypt le haghaidh HTTPS.
— Ag obair mar ródaire API.
— Ag obair le meánearraí.
— Comhaid statacha a phróiseáil.
— Múchadh ceart.
Molann Skillbox: Cúrsa praiticiúil .
Meabhraímid: do léitheoirí uile "Habr" - lascaine de 10 rúbal nuair a chláraíonn siad in aon chúrsa Scilbox ag baint úsáide as an gcód bolscaireachta "Habr".
Dia duit, a shaoghail!
Is féidir leat freastalaí gréasáin a chruthú in Téigh go han-tapa. Seo sampla de láimhseálaí a úsáid a thugann an “Dia duit, an domhan!” a gealladh thuas.
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)
}Tar éis seo, má ritheann tú an t-iarratas agus an leathanach a oscailt , ansin feicfidh tú láithreach an téacs "Dia duit, a domhan!" (má oibríonn gach rud i gceart, ar ndóigh).
Bainfimid úsáid as an láimhseálaí go minic níos déanaí, ach ar dtús a ligean ar a thuiscint conas a oibríonn gach rud.
glan/http
D'úsáid an sampla an pacáiste , is é an príomh-uirlis i Téigh chun freastalaithe agus cliaint HTTP araon a fhorbairt. Chun an cód a thuiscint, déanaimis brí na dtrí ghné thábhachtacha a thuiscint: http.Handler, http.ServeMux agus http.Server.
Láimhseálaithe HTTP
Nuair a fhaighimid iarratas, déanann an láimhseálaí anailís air agus gineann sé freagra. Cuirtear Handlers in Go i bhfeidhm mar seo a leanas:
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}Úsáideann an chéad sampla an fheidhm cúntóir http.HandleFunc. Filleann sé feidhm eile, rud a thógann http.ResponseWriter agus http.Request isteach i ServeHTTP.
I bhfocail eile, cuirtear láimhseálaithe i Golang i láthair i gcomhéadan amháin, rud a thugann go leor roghanna don ríomhchláraitheoir. Mar sin, mar shampla, cuirtear lárearraí i bhfeidhm ag baint úsáide as láimhseálaí, áit a ndéanann ServeHTTP rud éigin ar dtús agus ansin glaonna ar mhodh ServeHTTP láimhseálaí eile.
Mar a luadh thuas, gineann láimhseálaithe freagraí ar iarratais. Ach cén láimhseálaí ar leith ar cheart a úsáid ag pointe áirithe ama?
Ródú Iarratas
Chun an rogha ceart a dhéanamh, bain úsáid as ilphléacsóir HTTP. I roinnt leabharlann tugtar muxer nó ródaire air, ach is é an rud céanna iad go léir. Is í feidhm an ilphléacsálaí anailís a dhéanamh ar chonair an iarratais agus an láimhseálaí cuí a roghnú.
Má theastaíonn tacaíocht uait le haghaidh ródú casta, is fearr leabharlanna tríú páirtí a úsáid. Cuid de na cinn is airde - и , déanann na leabharlanna seo próiseáil idirmheánach a chur i bhfeidhm gan aon fhadhbanna. Le cabhair uathu, is féidir leat ródú saoróg a chumrú agus roinnt tascanna eile a dhéanamh. Is é an buntáiste a bhaineann leo ná comhoiriúnacht le láimhseálaithe caighdeánach HTTP. Mar thoradh air sin, is féidir leat cód simplí a scríobh is féidir a mhodhnú sa todhchaí.
Teastóidh réitigh neamhchaighdeánacha le hoibriú le creataí casta i ngnáthstaid, agus cuireann sé seo go mór le húsáid na láimhseálaithe réamhshocraithe. Chun formhór mór na n-iarratas a chruthú, is leor meascán den leabharlann réamhshocraithe agus ródaire simplí.
Próiseáil Iarratas
Ina theannta sin, teastaíonn comhpháirt uainn a “éistfidh” le haghaidh naisc isteach agus a atreoróidh gach iarratas chuig an láimhseálaí ceart. Is féidir le http.Server an tasc seo a láimhseáil go héasca.
Léiríonn an méid seo a leanas go bhfuil an freastalaí freagrach as na tascanna go léir a bhaineann le próiseáil nasc. Oibríonn sé seo, mar shampla, ag baint úsáide as an bprótacal TLS. Chun an glao http.ListenAndServer a chur i bhfeidhm, úsáidtear freastalaí caighdeánach HTTP.
Anois, déanaimis féachaint ar shamplaí níos casta.
Nuair a chuirfear Let's Encrypt
De réir réamhshocraithe, ritheann ár n-iarratas thar an bprótacal HTTP, ach moltar prótacal HTTPS a úsáid. Is féidir é seo a dhéanamh gan fadhbanna i Go. Má tá teastas agus eochair phríobháideach faighte agat, is leor ListenAndServeTLS a chlárú leis an teastas ceart agus na heochairchomhaid.
http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)Is féidir leat a dhéanamh i gcónaí níos fearr.
soláthraíonn sé deimhnithe saor in aisce le hathnuachan uathoibríoch. Chun an tseirbhís a úsáid, is gá duit pacáiste autocert.
Is é an bealach is éasca chun é a chumrú ná an modh autocert.NewListener a úsáid i gcomhar le http.Serve. Ligeann an modh duit teastais TLS a fháil agus a nuashonrú agus iarratais á bpróiseáil ag an bhfreastalaí HTTP:
http.Serve(autocert.NewListener("example.com"), nil)Má osclaíonn muid sa bhrabhsálaí , gheobhaidh muid freagra HTTPS "Dia duit, a domhan!"
Má theastaíonn cumraíocht níos mionsonraithe uait, ba cheart duit an bainisteoir autocert.Manager a úsáid. Ansin cruthaímid ár sampla http.Server féin (go dtí seo gur úsáideamar é de réir réamhshocraithe) agus cuirimid an bainisteoir leis an bhfreastalaí 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("", "")Is bealach éasca é seo chun tacaíocht iomlán HTTPS a chur i bhfeidhm le hathnuachan deimhnithe uathoibríoch.
Ag cur bealaí saincheaptha
Tá an ródaire réamhshocraithe atá san áireamh sa leabharlann caighdeánach go maith, ach tá sé an-bhunúsach. Teastaíonn ródú níos casta ó fhormhór na n-iarratas, lena n-áirítear bealaí neadaithe agus saoróg, nó nós imeachta chun patrúin cosáin agus paraiméadair a shocrú.
Sa chás seo is fiú pacáistí a úsáid и . Beidh muid ag foghlaim conas oibriú leis an dara ceann - tá sampla léirithe thíos.
Tugtar an comhad api/v1/api.go ina bhfuil bealaí dár 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
}Shocraigh muid an réimír api/vq le haghaidh bealaí sa phríomhchomhad.
Is féidir linn é seo a shuiteáil ar ár bpríomh-ródaire faoin réimír api/v1/ ar ais inár bpríomhfheidhmchlár:
// 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())Mar gheall ar éascaíocht Go oibriú le bealaí casta is féidir struchtúrú agus cothabháil feidhmeanna móra casta a shimpliú.
Ag obair le meánearraí
Is éard atá i gceist le céimniú láimhseálaí HTTP amháin a fhilleadh le ceann eile, rud a fhágann gur féidir fíordheimhniú, comhbhrú, logáil agus go leor feidhmeanna eile a dhéanamh go tapa.
Mar shampla, déanaimis féachaint ar an gcomhéadan http.Handler; úsáidfimid é chun láimhseálaí a scríobh a fhíordheimhníonn úsáideoirí seirbhíse.
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
}
// Assuming authentication passed, run the original handler
next.ServeHTTP(w, r)
})
}Tá ródairí tríú páirtí ann, mar chi, a ligeann duit feidhmiúlacht na meánearraí a leathnú.
Ag obair le comhaid statacha
Áirítear leis an leabharlann chaighdeánach Go cumais chun oibriú le hábhar statach, lena n-áirítear íomhánna, JavaScript agus comhaid CSS. Is féidir iad a rochtain tríd an bhfeidhm http.FileServer. Filleann sé láimhseálaí a fhreastalaíonn ar chomhaid ó eolaire ar leith.
func NewRouter() http.Handler {
router := chi.NewRouter()
r.Get("/{name}", HelloName)
// Настройка раздачи статических файлов
staticPath, _ := filepath.Abs("../../static/")
fs := http.FileServer(http.Dir(staticPath))
router.Handle("/*", fs)
return rIs cinnte gur fiú cuimhneamh go dtaispeánann http.Dir a bhfuil san eolaire mura bhfuil an príomhchomhad index.html ann. Sa chás seo, chun an t-eolaire a chosc ó bheith i gcontúirt, ba cheart duit an pacáiste a úsáid .
Múchadh ceart
Tá gné ag Go freisin ar a dtugtar múchadh galánta an fhreastalaí HTTP. Is féidir é seo a dhéanamh leis an modh Múchadh(). Tosaítear an freastalaí i ngroutine, agus ansin éistear leis an gcainéal chun comhartha idirbhriste a fháil. Chomh luath agus a fhaightear an comhartha, casfaidh an freastalaí as, ach ní láithreach, ach tar éis cúpla soicind.
handler := server.NewRouter()
srv := &http.Server{
Handler: handler,
}
go func() {
srv.Serve(autocert.NewListener(domains...))
}()
// Wait for an interrupt
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
// Attempt a graceful shutdown
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)Mar chonclúid
Is teanga chumhachtach í Go le leabharlann chaighdeánach beagnach uilíoch. Tá a chumais réamhshocraithe an-leathan, agus is féidir iad a fheabhsú trí úsáid a bhaint as comhéadain - ligeann sé seo duit freastalaithe HTTP fíor-iontaofa a fhorbairt.
Molann Skillbox:
- Cúrsa praiticiúil dhá bhliain .
- Cúrsa oideachais ar líne .
- Cúrsa bliana praiticiúla .
Foinse: will.com