गोलंग वेब सर्वर विकास - आसान से जटिल तक

पांच साल पहले, मैंने गोफिश विकसित करना शुरू कर दिया , जिससे गोलंग सीखना संभव हो गया। मैंने महसूस किया कि गो एक शक्तिशाली भाषा है, जिसकी क्षमताएँ कई पुस्तकालयों द्वारा पूरक हैं। गो सार्वभौमिक है: विशेष रूप से, इसकी सहायता से समस्याओं के बिना सर्वर अनुप्रयोगों को विकसित करना संभव है।

यह लेख गो में एक सर्वर लिखने के बारे में है। आइए सरल चीजों से शुरू करें, जैसे "नमस्ते दुनिया!", और निम्नलिखित सुविधाओं के साथ एक आवेदन के साथ समाप्त होता है:

- HTTPS के लिए लेट्स एनक्रिप्ट का उपयोग करना।
- एपीआई राउटर के रूप में काम करें।
- मिडलवेयर के साथ काम करें।
- स्थैतिक फ़ाइलों का प्रसंस्करण।
- शटडाउन सही।

स्किलबॉक्स सिफारिश करता है: स्क्रैच हैंड-ऑन कोर्स से पायथन डेवलपर ।

हम आपको याद दिलाते हैं: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रोमो कोड का उपयोग करके किसी भी स्किलबॉक्स कोर्स के लिए पंजीकरण करते समय 10,000 रूबल की छूट।

नमस्ते दुनिया!

गो पर एक वेब सर्वर बनाना बहुत तेज है। यहां एक हैंडलर का उपयोग करने का एक उदाहरण है जो "हैलो, दुनिया!" ऊपर वादा करता है।

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

उसके बाद, यदि आप एप्लिकेशन शुरू करते हैं और लोकलहोस्ट पेज खोलते हैं, तो आपको तुरंत "हैलो, वर्ल्ड!" टेक्स्ट दिखाई देगा। (बेशक, अगर सब कुछ सही ढंग से काम करता है)।

अगला, हम बार-बार हैंडलर का उपयोग करेंगे, लेकिन पहले, आइए समझते हैं कि सब कुछ कैसे काम करता है।

नेट / http

उदाहरण ने net/http पैकेज का उपयोग किया, जो सर्वर और HTTP क्लाइंट दोनों को विकसित करने के लिए Go में मुख्य उपकरण है। कोड को समझने के लिए, आइए तीन महत्वपूर्ण तत्वों का अर्थ देखें: http.Handler, http.ServeMux और http.Server।

HTTP हैंडलर्स

जब हम एक अनुरोध प्राप्त करते हैं, तो हैंडलर इसका विश्लेषण करता है और एक प्रतिक्रिया बनाता है। गो संचालकों को निम्नानुसार कार्यान्वित किया जाता है:

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

पहला उदाहरण http.HandleFunc सहायक फ़ंक्शन का उपयोग करता है। यह एक और फ़ंक्शन लपेटता है, जो बदले में http.esponseWriter और http.Request को ServeHTTP में स्वीकार करता है।

दूसरे शब्दों में, गोलंग संचालकों को एकल इंटरफ़ेस द्वारा दर्शाया जाता है, जो प्रोग्रामर के लिए कई अवसर प्रदान करता है। इसलिए, उदाहरण के लिए, मिडलवेयर एक हैंडलर का उपयोग करके कार्यान्वित किया जाता है, जहां पहले ServeHTTP कुछ करता है, और फिर दूसरे हैंडलर का ServeHTTP विधि कहता है।

जैसा कि ऊपर उल्लेख किया गया है, हैंडलर केवल अनुरोधों के लिए प्रतिक्रिया उत्पन्न करते हैं। लेकिन समय में किसी विशेष बिंदु पर किस विशेष हैंडलर का उपयोग किया जाना चाहिए?

रूटिंग का अनुरोध करें

सही विकल्प बनाने के लिए, HTTP मल्टीप्लेक्सर का उपयोग करें। इसे कई पुस्तकालयों में मक्सर या राउटर कहा जाता है, लेकिन यह सभी समान है। मल्टीप्लेक्स फ़ंक्शन अनुरोध पथ का विश्लेषण करने और उपयुक्त हैंडलर का चयन करने के लिए है।

यदि आपको जटिल मार्ग के लिए समर्थन की आवश्यकता है, तो तीसरे पक्ष के पुस्तकालयों का उपयोग करना बेहतर है। सबसे उन्नत में से एक गोरिल्ला / मक्स और गो-ची / ची है , ये पुस्तकालय बिना किसी समस्या के मध्यवर्ती प्रसंस्करण को लागू करना संभव बनाते हैं। उनकी मदद से, आप वाइल्डकार्ड रूटिंग को कॉन्फ़िगर कर सकते हैं और कई अन्य कार्य कर सकते हैं। उनका प्लस मानक HTTP हैंडलर के साथ संगतता है। नतीजतन, आप भविष्य में इसके संशोधन की संभावना के साथ सरल कोड लिख सकते हैं।

एक सामान्य स्थिति में जटिल ढांचे के साथ काम करने के लिए काफी मानक समाधान की आवश्यकता नहीं होगी, और यह डिफ़ॉल्ट हैंडलर के उपयोग को बहुत जटिल करता है। अधिकांश अनुप्रयोगों को बनाने के लिए, डिफ़ॉल्ट लाइब्रेरी और एक साधारण राउटर का संयोजन पर्याप्त है।

प्रसंस्करण का अनुरोध करें

इसके अलावा, हमें एक ऐसे घटक की आवश्यकता है जो आने वाले कनेक्शनों के लिए "सुने" और सही हैंडलर के सभी अनुरोधों को रीडायरेक्ट करे। यह काम http.Server द्वारा आसानी से किया जा सकता है।

निम्न दर्शाता है कि सर्वर उन सभी कार्यों के लिए जिम्मेदार है जो कनेक्शन प्रसंस्करण से संबंधित हैं। यह, उदाहरण के लिए, टीएलएस प्रोटोकॉल पर काम करते हैं। Http.ListenAndServer कॉल को कार्यान्वित करने के लिए, एक मानक HTTP सर्वर का उपयोग किया जाता है।

अब आइए अधिक जटिल उदाहरण देखें।

जोड़ना एनक्रिप्ट करें

डिफ़ॉल्ट रूप से, हमारा एप्लिकेशन HTTP प्रोटोकॉल पर चलता है, लेकिन HTTPS प्रोटोकॉल का उपयोग करने की अनुशंसा की जाती है। गो में, यह समस्याओं के बिना किया जा सकता है। यदि आपको एक प्रमाणपत्र और एक निजी कुंजी प्राप्त हुई है, तो बस सही प्रमाण पत्र और कुंजी फ़ाइलों के साथ ListenAndServeTLS पंजीकृत करें।

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

आप हमेशा बेहतर कर सकते हैं।

आइए एन्क्रिप्ट करें स्वचालित रूप से नवीनीकृत करने की क्षमता के साथ मुफ्त प्रमाण पत्र देता है। सेवा का उपयोग करने के लिए, आपको autocert पैकेज की आवश्यकता है।

इसे कॉन्फ़िगर करने का सबसे आसान तरीका है http.Serve के साथ संयोजन में autocert.NewListener पद्धति का उपयोग करना। यह विधि आपको टीएलएस प्रमाणपत्र प्राप्त करने और नवीनीकृत करने की अनुमति देती है, जबकि HTTP सर्वर प्रक्रिया अनुरोध करता है:

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

यदि हम ब्राउज़र में example.com खोलते हैं, तो हमें HTTPS प्रतिक्रिया मिलती है "हैलो, दुनिया!"।

यदि आपको अधिक गहन कॉन्फ़िगरेशन की आवश्यकता है, तो आपको ऑटोकार्ट का उपयोग करना चाहिए। फिर हम अपना स्वयं का 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 समर्थन को लागू करने का एक आसान तरीका है।

कस्टम मार्गों को जोड़ना

मानक लाइब्रेरी में शामिल डिफ़ॉल्ट राउटर अच्छा है, लेकिन यह बहुत सरल है। अधिकांश अनुप्रयोगों के लिए अधिक जटिल मार्ग की आवश्यकता होती है, जिसमें नेस्टेड और वाइल्डकार्ड मार्ग, या पैटर्न और पथ पैरामीटर सेट करने की प्रक्रिया शामिल है।

इस मामले में, आपको गोरिल्ला / मक्स और गो-ची / ची संकुल का उपयोग करना चाहिए। हम सीखेंगे कि उत्तरार्द्ध के साथ कैसे काम किया जाए - एक उदाहरण नीचे दिखाया गया है।

हमारे एपीआई के लिए मार्गों से युक्त एपीआई / 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 } 

हम मुख्य फ़ाइल में मार्गों के लिए एपीआई / वीक्यू उपसर्ग सेट करते हैं।

इसके बाद हम अपने मुख्य एप्लिकेशन में एपीआई / 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.andler पर विचार करें, इसकी मदद से हम सेवा के उपयोगकर्ताओं के प्रमाणीकरण के साथ एक हैंडलर लिखते हैं।

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

तीसरे पक्ष के राउटर हैं, उदाहरण के लिए, ची, जो आपको मध्यवर्ती प्रसंस्करण की कार्यक्षमता का विस्तार करने की अनुमति देता है।

स्थिर फ़ाइलों के साथ काम करें

गो मानक पुस्तकालय में स्थिर सामग्री के साथ काम करने के लिए चित्र, साथ ही जावास्क्रिप्ट और सीएसएस फाइलें भी शामिल हैं। उन्हें 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- सर्वर विकसित करने की अनुमति देता है।

स्किलबॉक्स अनुशंसा करता है:

• दो वर्षीय व्यावहारिक पाठ्यक्रम "मैं एक प्रो वेब डेवलपर हूं । "
• शैक्षिक ऑनलाइन पाठ्यक्रम "पेशे जावा-डेवलपर" ।
• व्यावहारिक वार्षिक पाठ्यक्रम "पीएचपी-डेवलपर 0 से प्रो तक" ।