Lua Academy · पाठ

सर्वर बनाना

आने वाले कनेक्शन स्वीकार करें।

पाठ 3, कुल 4 में से13 चरण

सर्वर बनाना, CoddyKit पर Lua Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Lua Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

सर्वर का जीवन-चक्र

TCP सर्वर किसी पते से जुड़ता है, कनेक्शन के लिए सुनता है, फिर क्लाइंट स्वीकार करने और उन्हें सेवा देने का लूप चलाता है।

LuaSocket में आप socket.tcp() से मुख्य ऑब्जेक्ट बनाते हैं, उसे bind/listen से सुनने वाले सर्वर में बदलते हैं और accept से कतार में प्रतीक्षा कर रहे क्लाइंट लेते हैं।

local socket = require("socket")
local server = assert(socket.tcp())

पोर्ट से जुड़ना

server:bind(host, port) स्थानीय पता आरक्षित करता है। हर इंटरफ़ेस पर कनेक्शन स्वीकार करने के लिए "*" या "0.0.0.0" का उपयोग करें, या केवल स्थानीय कनेक्शन के लिए "127.0.0.1" का उपयोग करें।

यदि कोई अन्य प्रक्रिया पोर्ट पर कब्ज़ा किए हुए हो, तो bind "address already in use" त्रुटि के साथ विफल हो जाता है।

server:setoption("reuseaddr", true)
local ok, err = server:bind("*", 8080)
if not ok then error("bind failed: " .. err) end

क्लाइंट के लिए सुनना

server:listen(backlog) सॉकेट को निष्क्रिय मोड में रखता है और आने वाले हैंडशेक को कतार में रखना शुरू करता है। backlog उन कनेक्शनों की अधिकतम संख्या है जो प्रतीक्षा कर सकते हैं।

संक्षिप्त तरीका socket.bind(host, port, backlog) एक ही कॉल में bind और listen करता है और तैयार सर्वर ऑब्जेक्ट लौटाता है।

local socket = require("socket")
local server = assert(socket.bind("*", 8080, 32))
print("listening on", server:getsockname())

कनेक्शन स्वीकार करना

server:accept() तब तक रुकता है, जब तक कोई क्लाइंट कनेक्ट न कर ले। इसके बाद वह उस समकक्ष के लिए एक बिल्कुल नया TCP क्लाइंट ऑब्जेक्ट लौटाता है। सर्वर सॉकेट स्वयं सुनता रहता है।

समय-सीमा वाले सर्वर सॉकेट पर accept nil, "timeout" लौटाता है, जिससे आप अन्य कामों के बीच इसे चला सकते हैं।

local client, err = server:accept()
if client then
  print("client from", client:getpeername())
end

एक क्लाइंट को सेवा देना

स्वीकार करने के बाद लौटाए गए ऑब्जेक्ट को क्लाइंट सॉकेट की तरह ही मानें: receive से अनुरोध और send से उत्तर सँभालें।

हर क्लाइंट सॉकेट के लिए अपनी समय-सीमा निर्धारित करें, ताकि एक धीमा क्लाइंट पूरे सर्वर को रोक न सके।

client:settimeout(10)
local line = client:receive("*l")
if line then client:send(line .. "\n") end
client:close()

स्वीकार करने वाला लूप

एक पारंपरिक क्रमिक सर्वर अनंत लूप चलाता है: क्लाइंट स्वीकार करता है, उसे सेवा देता है, बंद करता है और फिर दोहराता है। इससे एक समय में एक ही क्लाइंट सँभाला जाता है।

यह सरल और सही है, लेकिन एक साथ कई क्लाइंट को सेवा नहीं दे सकता, क्योंकि धीमा अनुरोध उसके पीछे प्रतीक्षा कर रहे सभी लोगों को रोक देता है।

while true do
  local c = server:accept()
  if c then
    local msg = c:receive("*l")
    if msg then c:send(msg .. "\r\n") end
    c:close()
  end
end

एक न्यूनतम प्रतिध्वनि सर्वर

सब कुछ जोड़ने पर, एक प्रतिध्वनि सर्वर bind करता है, सुनता है और फिर हर क्लाइंट की पहली पंक्ति वापस भेजने का लूप चलाता है।

यह सबसे छोटा संपूर्ण LuaSocket सर्वर है और आपके पहले बनाए गए क्लाइंट के लिए एक उपयोगी लक्ष्य है।

local socket = require("socket")
local s = assert(socket.bind("*", 8080))
while true do
  local c = s:accept()
  c:send((c:receive("*l") or "") .. "\r\n")
  c:close()
end

select के साथ समवर्तीता

थ्रेड के बिना एक साथ कई क्लाइंट को सेवा देने के लिए socket.select का उपयोग करें। यह पढ़ने के लिए तैयार सॉकेट लौटाता है, जिसमें सुनने वाला सर्वर भी शामिल होता है, जब कोई नया क्लाइंट प्रतीक्षा कर रहा हो।

आप सक्रिय क्लाइंट का एक table सँभालते हैं और केवल उन्हीं क्लाइंट को संसाधित करते हैं जिनके पास डेटा है। इससे एकल-थ्रेड वाला इवेंट लूप सक्रिय बना रहता है।

local readable = socket.select(watch, nil, 1)
for _, sock in ipairs(readable) do
  if sock == server then
    table.insert(watch, server:accept())
  end
end

गैर-अवरुद्ध स्वीकार

server:settimeout(0) निर्धारित करें, ताकि accept कभी रुक न जाए। इसे select के साथ जोड़ें, ताकि accept को तभी कॉल करें जब सुनने वाला सॉकेट वास्तव में पढ़ने योग्य हो।

यह ऐसे विस्तार योग्य एकल-प्रक्रिया सर्वर का आधार है, जो सैकड़ों कनेक्शन को एक साथ सँभाल सकता है।

server:settimeout(0)
local ready = socket.select({server}, nil, 5)
if #ready > 0 then
  local c = server:accept()
end

क्लाइंट की त्रुटियाँ सँभालना

क्लाइंट अचानक कनेक्शन तोड़ सकते हैं। जब receive nil, "closed" या आंशिक बफ़र लौटाए, तो उस क्लाइंट को अपनी निगरानी table से हटाकर उसका सॉकेट बंद कर दें।

किसी एक खराब कनेक्शन को स्वीकार करने वाले लूप को बंद न करने दें; हर क्लाइंट की विफलताओं को अलग रखें।

local data, err = client:receive("*l")
if err == "closed" then
  client:close()
  remove_from_watch(client)
end

साफ़ तरीके से बंद करना

बंद करते समय नए कनेक्शन स्वीकार करना रोकें, हर सक्रिय क्लाइंट सॉकेट बंद करें और फिर पोर्ट मुक्त करने के लिए सुनने वाला सर्वर बंद करें।

bind के समय reuseaddr निर्धारित करने से आप TCP के TIME_WAIT अवधि समाप्त होने की प्रतीक्षा किए बिना तुरंत सर्वर फिर शुरू कर सकते हैं।

for _, c in ipairs(clients) do c:close() end
server:close()
print("server stopped")

त्वरित जाँच

वह कॉल-क्रम चुनें जो नए मुख्य सॉकेट को काम करने वाले सुनने वाले सॉकेट में बदलता है।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने TCP सर्वर बनाया: reuseaddr के साथ bind किया, backlog के साथ सुना और क्लाइंट को सेवा देने के लिए accept पर लूप चलाया।

आपने सरल क्रमिक लूप देखा, फिर गैर-अवरुद्ध समवर्तीता के लिए socket.select से उसका विस्तार किया, साथ ही त्रुटियों को अलग रखना और साफ़ तरीके से बंद करना भी सीखा। अगले पाठ में आप एचटीटीपी की ओर बढ़ेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Lua सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 40
पाठ: 159

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “सर्वर बनाना” पाठ निःशुल्क है?

हाँ — Lua Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “सर्वर बनाना” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Lua Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“सर्वर बनाना” में मैं क्या सीखूँगा?

आने वाले कनेक्शन स्वीकार करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Lua Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Lua Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Lua Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“सर्वर बनाना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Lua Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Lua Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Lua Academy पर वापस जाएँ