ప్రోహోస్టర్ > బ్లాగ్ > పరిపాలన > గోలాంగ్‌లో వెబ్ సర్వర్ డెవలప్‌మెంట్ - సింపుల్ నుండి కాంప్లెక్స్ వరకు

గోలాంగ్‌లో వెబ్ సర్వర్ డెవలప్‌మెంట్ - సింపుల్ నుండి కాంప్లెక్స్ వరకు

గోలాంగ్‌లో వెబ్ సర్వర్ డెవలప్‌మెంట్ - సింపుల్ నుండి కాంప్లెక్స్ వరకు

ఐదు సంవత్సరాల క్రితం నేను ప్రారంభించాను గోఫిష్‌ను అభివృద్ధి చేయండి, ఇది గోలాంగ్ నేర్చుకునే అవకాశాన్ని అందించింది. గో అనేది చాలా లైబ్రరీలతో అనుబంధించబడిన శక్తివంతమైన భాష అని నేను గ్రహించాను. గో బహుముఖమైనది: ప్రత్యేకించి, ఎటువంటి సమస్యలు లేకుండా సర్వర్ వైపు అప్లికేషన్‌లను అభివృద్ధి చేయడానికి దీనిని ఉపయోగించవచ్చు.

ఈ కథనం గోలో సర్వర్‌ని వ్రాయడం గురించి. "హలో వరల్డ్!" వంటి సాధారణ విషయాలతో ప్రారంభించి, కింది సామర్థ్యాలతో కూడిన అప్లికేషన్‌తో ముగించండి:

- HTTPS కోసం లెట్స్ ఎన్‌క్రిప్ట్ ఉపయోగించి.
- API రూటర్‌గా పని చేస్తోంది.
- మిడిల్‌వేర్‌తో పని చేయడం.
— స్టాటిక్ ఫైళ్ల ప్రాసెసింగ్.
- సరైన షట్డౌన్.

Skillbox సిఫార్సు చేస్తోంది: ప్రాక్టికల్ కోర్సు "మొదటి నుండి పైథాన్ డెవలపర్".

మేము గుర్తు చేస్తున్నాము: Habr పాఠకులందరికీ - Habr ప్రోమో కోడ్‌ని ఉపయోగించి ఏదైనా Skillbox కోర్సులో నమోదు చేసుకున్నప్పుడు 10 రూబుల్ తగ్గింపు.

హలో, ప్రపంచం!

మీరు గోలో చాలా త్వరగా వెబ్ సర్వర్‌ని సృష్టించవచ్చు. పైన వాగ్దానం చేసిన "హలో, వరల్డ్!"ని తిరిగి ఇచ్చే హ్యాండ్లర్‌ను ఉపయోగించడం కోసం ఇక్కడ ఒక ఉదాహరణ ఉంది.

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

దీని తర్వాత, మీరు అప్లికేషన్‌ను అమలు చేసి, పేజీని తెరిస్తే localhost, అప్పుడు మీరు వెంటనే “హలో, వరల్డ్!” అనే వచనాన్ని చూస్తారు. (అంతా సరిగ్గా పని చేస్తే, కోర్సు).

మేము హ్యాండ్లర్‌ను తర్వాత చాలాసార్లు ఉపయోగిస్తాము, అయితే ముందుగా ప్రతిదీ ఎలా పని చేస్తుందో అర్థం చేసుకుందాం.

నికర/http

ఉదాహరణ ప్యాకేజీని ఉపయోగించింది net/http, సర్వర్‌లు మరియు HTTP క్లయింట్‌లు రెండింటినీ అభివృద్ధి చేయడానికి గోలో ఇది ప్రాథమిక సాధనం. కోడ్‌ను అర్థం చేసుకోవడానికి, మూడు ముఖ్యమైన అంశాల అర్థాన్ని అర్థం చేసుకుందాం: http.Handler, http.ServeMux మరియు http.Server.

HTTP హ్యాండ్లర్లు

మేము అభ్యర్థనను స్వీకరించినప్పుడు, హ్యాండ్లర్ దానిని విశ్లేషిస్తుంది మరియు ప్రతిస్పందనను రూపొందిస్తుంది. గోలోని హ్యాండ్లర్లు క్రింది విధంగా అమలు చేయబడతాయి:

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

మొదటి ఉదాహరణ http.HandleFunc సహాయక ఫంక్షన్‌ని ఉపయోగిస్తుంది. ఇది మరొక ఫంక్షన్‌ను చుట్టేస్తుంది, ఇది సర్వ్‌హెచ్‌టిటిపిలోకి http.ResponseWriter మరియు http.Requestని తీసుకుంటుంది.

మరో మాటలో చెప్పాలంటే, గోలాంగ్‌లోని హ్యాండ్లర్లు ఒకే ఇంటర్‌ఫేస్‌లో ప్రదర్శించబడతాయి, ఇది ప్రోగ్రామర్‌కు చాలా ఎంపికలను ఇస్తుంది. కాబట్టి, ఉదాహరణకు, మిడిల్‌వేర్ హ్యాండ్లర్‌ని ఉపయోగించి అమలు చేయబడుతుంది, ఇక్కడ ServeHTTP మొదట ఏదైనా చేసి, ఆపై మరొక హ్యాండ్లర్ యొక్క ServeHTTP పద్ధతిని పిలుస్తుంది.

పైన పేర్కొన్న విధంగా, హ్యాండ్లర్లు కేవలం అభ్యర్థనలకు ప్రతిస్పందనలను రూపొందిస్తారు. అయితే నిర్దిష్ట సమయంలో ఏ నిర్దిష్ట హ్యాండ్లర్‌ని ఉపయోగించాలి?

రూటింగ్ అభ్యర్థించండి

సరైన ఎంపిక చేయడానికి, HTTP మల్టీప్లెక్సర్‌ని ఉపయోగించండి. అనేక లైబ్రరీలలో దీనిని మక్సర్ లేదా రౌటర్ అంటారు, కానీ అవన్నీ ఒకటే. అభ్యర్థన మార్గాన్ని విశ్లేషించి, తగిన హ్యాండ్లర్‌ను ఎంచుకోవడం మల్టీప్లెక్సర్ యొక్క విధి.

సంక్లిష్ట రౌటింగ్‌కు మీకు మద్దతు అవసరమైతే, మూడవ పార్టీ లైబ్రరీలను ఉపయోగించడం మంచిది. అత్యంత అధునాతనమైన వాటిలో కొన్ని - గొరిల్లా/మక్స్ и గో-చి/చి, ఈ లైబ్రరీలు ఎటువంటి సమస్యలు లేకుండా ఇంటర్మీడియట్ ప్రాసెసింగ్‌ని అమలు చేయడం సాధ్యం చేస్తాయి. వారి సహాయంతో, మీరు వైల్డ్‌కార్డ్ రూటింగ్‌ను కాన్ఫిగర్ చేయవచ్చు మరియు అనేక ఇతర పనులను చేయవచ్చు. వారి ప్రయోజనం ప్రామాణిక HTTP హ్యాండ్లర్‌లతో అనుకూలత. ఫలితంగా, మీరు భవిష్యత్తులో సవరించగలిగే సాధారణ కోడ్‌ను వ్రాయవచ్చు.

సాధారణ పరిస్థితిలో సంక్లిష్టమైన ఫ్రేమ్‌వర్క్‌లతో పనిచేయడానికి ప్రామాణికం కాని పరిష్కారాలు అవసరమవుతాయి మరియు ఇది డిఫాల్ట్ హ్యాండ్లర్ల వినియోగాన్ని గణనీయంగా క్లిష్టతరం చేస్తుంది. అధిక సంఖ్యలో అనువర్తనాలను సృష్టించడానికి, డిఫాల్ట్ లైబ్రరీ మరియు సాధారణ రూటర్ కలయిక సరిపోతుంది.

ప్రశ్న ప్రాసెసింగ్

అదనంగా, ఇన్‌కమింగ్ కనెక్షన్‌ల కోసం "వినండి" మరియు అన్ని అభ్యర్థనలను సరైన హ్యాండ్లర్‌కు మళ్లించే ఒక భాగం మాకు అవసరం. http.Server ఈ పనిని సులభంగా నిర్వహించగలదు.

కనెక్షన్ ప్రాసెసింగ్‌కు సంబంధించిన అన్ని పనులకు సర్వర్ బాధ్యత వహిస్తుందని క్రింది చూపిస్తుంది. ఇది, ఉదాహరణకు, TLS ప్రోటోకాల్‌ని ఉపయోగించి పని చేస్తుంది. http.ListenAndServer కాల్‌ని అమలు చేయడానికి, ప్రామాణిక HTTP సర్వర్ ఉపయోగించబడుతుంది.

ఇప్పుడు మరింత క్లిష్టమైన ఉదాహరణలను చూద్దాం.

లెట్స్ ఎన్‌క్రిప్ట్ జోడిస్తోంది

డిఫాల్ట్‌గా, మా అప్లికేషన్ HTTP ప్రోటోకాల్‌పై నడుస్తుంది, అయితే HTTPS ప్రోటోకాల్‌ని ఉపయోగించమని సిఫార్సు చేయబడింది. ఇది గోలో సమస్యలు లేకుండా చేయవచ్చు. మీరు సర్టిఫికేట్ మరియు ప్రైవేట్ కీని స్వీకరించినట్లయితే, ListenAndServeTLSని సరైన సర్టిఫికేట్ మరియు కీ ఫైల్‌లతో నమోదు చేసుకోవడం సరిపోతుంది.

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

మీరు ఎల్లప్పుడూ బాగా చేయగలరు.

ఎన్క్రిప్ట్ లెట్ స్వయంచాలక పునరుద్ధరణతో ఉచిత ధృవపత్రాలను అందిస్తుంది. సేవను ఉపయోగించడానికి, మీకు ప్యాకేజీ అవసరం autocert.

http.Serveతో కలిపి autocert.NewListener పద్ధతిని ఉపయోగించడం దీన్ని కాన్ఫిగర్ చేయడానికి సులభమైన మార్గం. HTTP సర్వర్ అభ్యర్థనలను ప్రాసెస్ చేస్తున్నప్పుడు TLS ప్రమాణపత్రాలను పొందేందుకు మరియు నవీకరించడానికి ఈ పద్ధతి మిమ్మల్ని అనుమతిస్తుంది:

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

మనం బ్రౌజర్‌లో ఓపెన్ చేస్తే example.com, మేము HTTPS ప్రతిస్పందనను అందుకుంటాము “హలో, ప్రపంచం!”

మీకు మరింత వివరణాత్మక కాన్ఫిగరేషన్ అవసరమైతే, మీరు autocert.Manager మేనేజర్‌ని ఉపయోగించాలి. అప్పుడు మేము మా స్వంత http.Server ఉదాహరణను సృష్టించాము (ఇప్పటి వరకు మేము దానిని డిఫాల్ట్‌గా ఉపయోగించాము) మరియు 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("", "")

ఆటోమేటిక్ సర్టిఫికెట్ పునరుద్ధరణతో పూర్తి HTTPS మద్దతును అమలు చేయడానికి ఇది సులభమైన మార్గం.

అనుకూల మార్గాలను జోడిస్తోంది

ప్రామాణిక లైబ్రరీలో చేర్చబడిన డిఫాల్ట్ రూటర్ మంచిది, కానీ ఇది చాలా ప్రాథమికమైనది. చాలా అప్లికేషన్‌లకు నెస్టెడ్ మరియు వైల్డ్‌కార్డ్ రూట్‌లు లేదా పాత్ ప్యాటర్న్‌లు మరియు పారామితులను సెట్ చేసే విధానంతో సహా మరింత సంక్లిష్టమైన రూటింగ్ అవసరం.

ఈ సందర్భంలో ప్యాకేజీలను ఉపయోగించడం విలువ గొరిల్లా/మక్స్ и గో-చి/చి. మేము తరువాతి వారితో పనిచేయడం నేర్చుకుంటాము - ఒక ఉదాహరణ క్రింద చూపబడింది.

మా API కోసం మార్గాలను కలిగి ఉన్న api/v1/api.go ఫైల్ అందించబడింది:

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

మేము ప్రధాన ఫైల్‌లోని మార్గాల కోసం api/vq ఉపసర్గను సెట్ చేసాము.

మేము దీన్ని మా ప్రధాన అప్లికేషన్‌లో తిరిగి api/v1/ ఉపసర్గ కింద మా ప్రధాన రౌటర్‌కి మౌంట్ చేయవచ్చు:

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

సంక్లిష్ట మార్గాలతో పని చేసే గో యొక్క సౌలభ్యం పెద్ద, సంక్లిష్టమైన అప్లికేషన్‌ల నిర్మాణం మరియు నిర్వహణను సులభతరం చేస్తుంది.

మిడిల్‌వేర్‌తో పని చేస్తోంది

స్టేజింగ్ అనేది ఒక HTTP హ్యాండ్లర్‌ను మరొకదానితో చుట్టడం, ప్రామాణీకరణ, కుదింపు, లాగింగ్ మరియు అనేక ఇతర విధులను త్వరగా చేయడం సాధ్యపడుతుంది.

ఉదాహరణగా, http.Handler ఇంటర్‌ఫేస్‌ని చూద్దాం; సేవా వినియోగదారులను ప్రామాణీకరించే హ్యాండ్లర్‌ను వ్రాయడానికి మేము దానిని ఉపయోగిస్తాము.

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

మిడిల్‌వేర్ కార్యాచరణను విస్తరించడానికి మిమ్మల్ని అనుమతించే చి వంటి మూడవ పక్ష రౌటర్‌లు ఉన్నాయి.

స్టాటిక్ ఫైళ్ళతో పని చేస్తోంది

గో స్టాండర్డ్ లైబ్రరీలో ఇమేజ్‌లు, జావాస్క్రిప్ట్ మరియు CSS ఫైల్‌లతో సహా స్టాటిక్ కంటెంట్‌తో పని చేసే సామర్థ్యాలు ఉన్నాయి. వాటిని http.FileServer ఫంక్షన్ ద్వారా యాక్సెస్ చేయవచ్చు. ఇది నిర్దిష్ట డైరెక్టరీ నుండి ఫైల్‌లను అందించే హ్యాండ్లర్‌ను అందిస్తుంది.

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 r

ఇది ఖచ్చితంగా గుర్తుంచుకోవడం విలువ http.Dir ప్రధాన index.html ఫైల్‌ను కలిగి ఉండకపోతే డైరెక్టరీలోని కంటెంట్‌లను ప్రదర్శిస్తుంది. ఈ సందర్భంలో, డైరెక్టరీ రాజీ పడకుండా నిరోధించడానికి, మీరు ప్యాకేజీని ఉపయోగించాలి unindexed.

సరైన షట్డౌన్

గోలో HTTP సర్వర్ యొక్క గ్రేస్‌ఫుల్ షట్‌డౌన్ అనే ఫీచర్ కూడా ఉంది. ఇది షట్‌డౌన్() పద్ధతిని ఉపయోగించి చేయవచ్చు. సర్వర్ గోరౌటిన్‌లో ప్రారంభించబడింది, ఆపై ఛానెల్ అంతరాయ సిగ్నల్‌ను స్వీకరించడానికి వినబడుతుంది. సిగ్నల్ అందుకున్న వెంటనే, సర్వర్ ఆఫ్ అవుతుంది, కానీ వెంటనే కాదు, కానీ కొన్ని సెకన్ల తర్వాత.

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)

ఒక ముగింపుగా

గో అనేది దాదాపు సార్వత్రిక ప్రామాణిక లైబ్రరీతో శక్తివంతమైన భాష. దీని డిఫాల్ట్ సామర్థ్యాలు చాలా విస్తృతంగా ఉన్నాయి మరియు అవి ఇంటర్‌ఫేస్‌లను ఉపయోగించి మెరుగుపరచబడతాయి - ఇది నిజంగా నమ్మదగిన HTTP సర్వర్‌లను అభివృద్ధి చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

Skillbox సిఫార్సు చేస్తోంది:

మూలం: www.habr.com

ఒక వ్యాఖ్యను జోడించండి