Go में नेटवर्क सर्वर बनाना: TCP से HTTP तक एक शाम में

Go नेटवर्क प्रोग्रामिंग के लिए सबसे अच्छी भाषा क्यों है?

अगर आपने कभी Python में नेटवर्क सर्वर लिखा है (खासकर socket या asyncio का उपयोग करके), तो आप जानते हैं कि कोड कैसे कॉलबैक और इवेंट लूप की भूलभुलैया में बदल सकता है। Go (Golang) इस समस्या को आर्किटेक्चर स्तर पर हल करता है: गोरूटीन और चैनल नेटवर्क के साथ एसिंक्रोनस काम को उतना ही सरल बनाते हैं जितना कि सीक्वेंशियल कोड लिखना।

इस लेख में हम Go में नेटवर्क प्रोग्रामिंग को व्यावहारिक रूप से समझेंगे। आप सीखेंगे कि 15 मिनट में एक पूर्ण TCP चैट, UDP पैकेट भेजना और रूटिंग के साथ HTTP सर्वर कैसे बनाया जाए। सभी उदाहरण काम करने वाले हैं, इन्हें कॉपी करके चलाया जा सकता है।

मूल बातें: net पैकेज और इसकी सुपरपावर

Go में सारा नेटवर्क जादू स्टैंडर्ड net पैकेज में रहता है। यह TCP, UDP, Unix-सॉकेट और यहां तक कि SSL/TLS के साथ काम करने के लिए एक यूनिफाइड इंटरफेस प्रदान करता है। मुख्य विशेषता यह है कि Listen, Dial और Accept फंक्शन सिंक्रोनस रूप से काम करते हैं, लेकिन पूरे प्रोग्राम को ब्लॉक नहीं करते, क्योंकि प्रत्येक गोरूटीन हल्की होती है।

चलिए सीधे मुद्दे पर आते हैं।

TCP सर्वर: 10 लाइनों में चैट

हम एक सरल इको सर्वर बनाएंगे जो कनेक्शन स्वीकार करता है और जो प्राप्त करता है उसे वापस भेजता है। यह Go में नेटवर्क प्रोग्रामिंग का क्लासिक उदाहरण है।

package main\n\nimport (\n    "bufio"\n    "fmt"\n    "net"\n)\n\nfunc handleConnection(conn net.Conn) {\n    defer conn.Close()\n    scanner := bufio.NewScanner(conn)\n    for scanner.Scan() {\n        message := scanner.Text()\n        fmt.Printf("प्राप्त: %s\\n", message)\n        conn.Write([]byte("इको: " + message + "\\n"))\n    }\n}\n\nfunc main() {\n    listener, _ := net.Listen("tcp", ":8080")\n    fmt.Println("TCP सर्वर :8080 पर शुरू हुआ")\n    for {\n        conn, _ := listener.Accept()\n        go handleConnection(conn) // प्रत्येक गोरूटीन एक अलग क्लाइंट\n    }\n}

यहाँ क्या हो रहा है?

\n
• net.Listen("tcp", ":8080") — पोर्ट 8080 पर TCP लिसनर बनाता है।
\n
• अनंत लूप for Accept() के माध्यम से नए कनेक्शन स्वीकार करता है।
\n
• प्रत्येक कनेक्शन को एक अलग गोरूटीन go handleConnection() में हैंडल किया जाता है।
\n
• फंक्शन के अंदर, हम bufio.Scanner के माध्यम से लाइनें पढ़ते हैं और जवाब भेजते हैं।
\n

इस कोड को चलाएं, टर्मिनल खोलें और nc localhost 8080 (या Putty) के माध्यम से कनेक्ट करें। कोई भी संदेश "इको:" प्रीफिक्स के साथ वापस आएगा। हैरानी की बात है, लेकिन यह एक पूर्ण नेटवर्क सर्वर है जो बिना किसी कॉलबैक के हजारों क्लाइंट को सेवा दे सकता है।

UDP: बिना गारंटी के तेज़ डिलीवरी

अगर TCP एक फोन कॉल की तरह है (कनेक्शन स्थापित करें - बात करें), तो UDP पोस्टकार्ड की तरह है: भेजें और भूल जाएं। Go UDP के साथ काम करना उतना ही आसान बनाता है।

UDP क्लाइंट और सर्वर

// सर्वर\npackage main\n\nimport (\n    "fmt"\n    "net"\n)\n\nfunc main() {\n    addr, _ := net.ResolveUDPAddr("udp", ":8081")\n    conn, _ := net.ListenUDP("udp", addr)\n    defer conn.Close()\n\n    buffer := make([]byte, 1024)\n    for {\n        n, clientAddr, _ := conn.ReadFromUDP(buffer)\n        message := string(buffer[:n])\n        fmt.Printf("%s से प्राप्त: %s\\n", clientAddr, message)\n        conn.WriteToUDP([]byte("स्वीकृत: "+message+"\\n"), clientAddr)\n    }\n}\n\n// क्लाइंट\n// अलग फ़ाइल या गोरूटीन में:\nconn, _ := net.Dial("udp", "localhost:8081")\ndefer conn.Close()\nconn.Write([]byte("नमस्ते, UDP!"))\nbuffer := make([]byte, 1024)\nn, _ := conn.Read(buffer)\nfmt.Println(string(buffer[:n]))

TCP से मुख्य अंतर:

\n
• कोई Accept() नहीं है — हम सिर्फ पोर्ट सुनते हैं और डेटाग्राम पढ़ते हैं।
\n
• प्रत्येक पैकेट अपने भेजने वाले के पते के साथ आता है।
\n
• Go स्वयं बफरिंग का प्रबंधन करता है: ReadFromUDP एक बार में एक पैकेट पढ़ता है।
\n

UDP उन अनुप्रयोगों के लिए एकदम सही है जहां गति महत्वपूर्ण है और कुछ पैकेट का खो जाना स्वीकार्य है, जैसे गेमिंग या लाइव स्ट्रीमिंग।