गोलांग मधील वेब सर्व्हर विकास - साध्या ते जटिल पर्यंत

पाच वर्षांपूर्वी मी सुरुवात केली गोफिश विकसित करा, यामुळे गोलंग शिकण्याची संधी मिळाली. मला जाणवले की गो ही एक शक्तिशाली भाषा आहे, जी अनेक लायब्ररींनी पूरक आहे. गो बहुमुखी आहे: विशेषतः, कोणत्याही समस्यांशिवाय सर्व्हर-साइड अनुप्रयोग विकसित करण्यासाठी याचा वापर केला जाऊ शकतो.

हा लेख गो मध्ये सर्व्हर लिहिण्याबद्दल आहे. चला "हॅलो वर्ल्ड!" सारख्या सोप्या गोष्टींपासून सुरुवात करू आणि खालील क्षमतांसह अनुप्रयोगासह समाप्त करू:

- HTTPS साठी लेट्स एनक्रिप्ट वापरणे.
— API राउटर म्हणून काम करत आहे.
- मिडलवेअरसह कार्य करणे.
- स्थिर फाइल्सवर प्रक्रिया करणे.
- योग्य शटडाउन.

स्किलबॉक्स शिफारस करतो: प्रॅक्टिकल कोर्स "पायथन विकसक सुरवातीपासून".

आम्ही आठवण करून देतो: सर्व Habr वाचकांसाठी - Habr प्रोमो कोड वापरून कोणत्याही स्किलबॉक्स कोर्समध्ये नावनोंदणी करताना 10 रूबल सवलत.

नमस्कार, जग!

तुम्ही Go मध्ये खूप लवकर वेब सर्व्हर तयार करू शकता. येथे एक हँडलर वापरण्याचे एक उदाहरण आहे जे वर वचन दिलेले “हॅलो, वर्ल्ड!” परत करते.

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 क्लायंट दोन्ही विकसित करण्यासाठी हे Go मधील प्राथमिक साधन आहे. कोड समजून घेण्यासाठी, तीन महत्त्वाच्या घटकांचा अर्थ समजून घेऊ: http.Handler, http.ServeMux आणि http.Server.

HTTP हँडलर

जेव्हा आम्हाला विनंती प्राप्त होते, तेव्हा हँडलर त्याचे विश्लेषण करतो आणि प्रतिसाद तयार करतो. Go मधील हँडलर खालीलप्रमाणे लागू केले जातात:

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

पहिले उदाहरण http.HandleFunc हेल्पर फंक्शन वापरते. हे दुसरे फंक्शन रॅप करते, जे यामधून http.ResponseWriter आणि http.Request ला ServeHTTP मध्ये घेते.

दुसऱ्या शब्दांत, गोलंगमधील हँडलर एकाच इंटरफेसमध्ये सादर केले जातात, जे प्रोग्रामरला बरेच पर्याय देतात. म्हणून, उदाहरणार्थ, मिडलवेअर हँडलर वापरून लागू केले जाते, जेथे सर्व्हेएचटीटीपी प्रथम काहीतरी करते आणि नंतर दुसर्‍या हँडलरच्या सर्व्हेएचटीटीपी पद्धतीला कॉल करते.

वर नमूद केल्याप्रमाणे, हँडलर फक्त विनंत्यांना प्रतिसाद तयार करतात. परंतु विशिष्ट वेळी कोणत्या विशिष्ट हँडलरचा वापर करावा?

राउटिंगची विनंती करा

योग्य निवड करण्यासाठी, HTTP मल्टीप्लेक्सर वापरा. अनेक लायब्ररींमध्ये याला मक्सर किंवा राउटर म्हणतात, परंतु ते सर्व समान आहेत. मल्टिप्लेक्सरचे कार्य विनंती मार्गाचे विश्लेषण करणे आणि योग्य हँडलर निवडणे आहे.

आपल्याला जटिल राउटिंगसाठी समर्थन आवश्यक असल्यास, तृतीय-पक्ष लायब्ररी वापरणे चांगले. काही सर्वात प्रगत - गोरिला/मक्स и go-chi/chi, ही लायब्ररी कोणत्याही समस्यांशिवाय इंटरमीडिएट प्रक्रिया राबविणे शक्य करतात. त्यांच्या मदतीने, आपण वाइल्डकार्ड राउटिंग कॉन्फिगर करू शकता आणि इतर अनेक कार्ये करू शकता. त्यांचा फायदा मानक HTTP हँडलर्ससह सुसंगतता आहे. परिणामी, तुम्ही सोपा कोड लिहू शकता जो भविष्यात सुधारला जाऊ शकतो.

सामान्य परिस्थितीत जटिल फ्रेमवर्कसह कार्य करण्यासाठी मानक नसलेल्या उपायांची आवश्यकता असेल आणि यामुळे डीफॉल्ट हँडलर्सचा वापर लक्षणीयरीत्या गुंतागुंतीचा होतो. बहुसंख्य अनुप्रयोग तयार करण्यासाठी, डीफॉल्ट लायब्ररी आणि एक साधे राउटर यांचे संयोजन पुरेसे असेल.

क्वेरी प्रक्रिया

याव्यतिरिक्त, आम्हाला एक घटक आवश्यक आहे जो येणार्‍या कनेक्शनसाठी "ऐकतो" आणि सर्व विनंत्या योग्य हँडलरकडे पुनर्निर्देशित करेल. http.Server हे कार्य सहजपणे हाताळू शकते.

खालील दर्शविते की सर्व्हर कनेक्शन प्रक्रियेशी संबंधित असलेल्या सर्व कार्यांसाठी जबाबदार आहे. हे, उदाहरणार्थ, TLS प्रोटोकॉल वापरून कार्य करते. http.ListenAndServer कॉलची अंमलबजावणी करण्यासाठी, एक मानक HTTP सर्व्हर वापरला जातो.

आता अधिक जटिल उदाहरणे पाहू.

लेट्स एनक्रिप्ट जोडत आहे

डीफॉल्टनुसार, आमचा अनुप्रयोग HTTP प्रोटोकॉलवर चालतो, परंतु HTTPS प्रोटोकॉल वापरण्याची शिफारस केली जाते. हे Go मध्ये समस्यांशिवाय केले जाऊ शकते. जर तुम्हाला प्रमाणपत्र आणि खाजगी की प्राप्त झाली असेल, तर योग्य प्रमाणपत्र आणि की फाइल्ससह 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 समर्थन लागू करण्याचा हा एक सोपा मार्ग आहे.

सानुकूल मार्ग जोडत आहे

मानक लायब्ररीमध्ये समाविष्ट केलेला डीफॉल्ट राउटर चांगला आहे, परंतु तो अगदी मूलभूत आहे. बर्‍याच ऍप्लिकेशन्सना नेस्टेड आणि वाइल्डकार्ड मार्गांसह किंवा पथ पॅटर्न आणि पॅरामीटर्स सेट करण्याची प्रक्रिया यासह अधिक जटिल राउटिंगची आवश्यकता असते.

या प्रकरणात पॅकेजेस वापरणे फायदेशीर आहे गोरिला/मक्स и go-chi/chi. आम्ही नंतरचे कसे कार्य करावे ते शिकू - एक उदाहरण खाली दर्शविले आहे.

आमच्या 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())

Go च्या जटिल मार्गांसह कार्य करणे सुलभतेमुळे मोठ्या, जटिल अनुप्रयोगांची संरचना आणि देखभाल सुलभ करणे शक्य होते.

मिडलवेअरसह कार्य करणे

स्टेजिंगमध्ये एका 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)
    })
}

ची सारखे तृतीय पक्ष राउटर आहेत, जे तुम्हाला मिडलवेअर कार्यक्षमता वाढवण्याची परवानगी देतात.

स्थिर फाइल्ससह कार्य करणे

गो मानक लायब्ररीमध्ये प्रतिमा, JavaScript आणि 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 सर्व्हर विकसित करण्यास अनुमती देते.

स्किलबॉक्स शिफारस करतो:

• दोन वर्षांचा प्रॅक्टिकल कोर्स "मी प्रो वेब डेव्हलपर आहे".
• शैक्षणिक ऑनलाइन अभ्यासक्रम "प्रोफेशन जावा डेव्हलपर".
• एक वर्षाचा प्रॅक्टिकल कोर्स "PHP विकसक 0 ते PRO".

स्त्रोत: www.habr.com