धूमकेतु - 1,000,000 उपयोगकर्ताओं के भार के साथ मोचीवेब के लिए आवेदन। भाग १/३

भाग २

भाग ३



लेखों की इस श्रृंखला में, मैं साझा करूंगा कि मैंने क्या सीखा है कि मोचीवब बड़ी संख्या में खुले कनेक्शनों को कैसे संभालता है, और यह दर्शाता है कि मोचीब का उपयोग करके एक धूमकेतु एप्लिकेशन कैसे बनाया जाए, जहां प्रत्येक कनेक्शन राउटर में पंजीकृत हो। हम एक कार्यशील अनुप्रयोग के साथ समाप्त होंगे जो 1,000,000 समवर्ती कनेक्शनों को संभाल सकता है और यह पता लगा सकता है कि हमें इसके लिए कितनी मेमोरी की आवश्यकता है।



पहले भाग में:

• एक सरल धूमकेतु बनाना - एक एप्लिकेशन जो क्लाइंट को हर 10 सेकंड में एक संदेश भेजता है।

• बड़ी संख्या में कनेक्शन का समर्थन करने के लिए लिनक्स कर्नेल को कॉन्फ़िगर करना।

• बड़ी संख्या में कनेक्शन बनाने के लिए परीक्षण उपयोगिता बनाना।

• मेमोरी की आवश्यक मात्रा का निर्धारण।



इस श्रृंखला के निम्नलिखित भाग आपको बताएंगे कि वास्तविक प्रणाली का निर्माण कैसे करें, स्मृति उपयोग को कम करने के लिए अतिरिक्त चालें दिखाएं, और 100,000 और 1,000,000 अतिरिक्त कनेक्शन के साथ परीक्षण करें।



यह माना जाता है कि आप बैश से परिचित हैं, और एरलंग के साथ थोड़ा।

टेस्ट एप्लिकेशन बनाना

संक्षेप में:



1. मोचीव्ब स्थापित करें।

2. भागो: /your-mochiweb-path/scripts/new_mochiweb.erl moiciconntest

3. एलसीडी mochiconntest और src / mochiconntest_web.erl बदलें



यह कोड (mochiconntest_web.erl) केवल कनेक्शन स्वीकार करता है और ग्रीटिंग संदेश भेजता है, और प्रत्येक ग्राहक को प्रत्येक 10 सेकंड में एक संदेश।

-module(mochiconntest_web). -export([start/1, stop/0, loop/2]). %% External API start(Options) -> {DocRoot, Options1} = get_option(docroot, Options), Loop = fun (Req) -> ?MODULE:loop(Req, DocRoot) end, %we'll set our maximum to 1 million connections. mochiweb_http:start([{max, 1000000}, {name, ?MODULE}, {loop, Loop} | Options1]). stop() -> mochiweb_http:stop(?MODULE). loop(Req, DocRoot) -> "/" ++ Path = Req:get(path), case Req:get(method) of Method when Method =:= 'GET'; Method =:= 'HEAD' -> case Path of "test/" ++ Id -> Response = Req:ok({"text/html; charset=utf-8", [{"Server","Mochiweb-Test"}], chunked}), Response:write_chunk("Mochiconntest welcomes you! Your Id: " ++ Id ++ "\n"), %% router:login(list_to_atom(Id), self()), feed(Response, Id, 1); _ -> Req:not_found() end; 'POST' -> case Path of _ -> Req:not_found() end; _ -> Req:respond({501, [], []}) end. feed(Response, Path, N) -> receive %{router_msg, Msg} -> % Html = io_lib:format("Recvd msg #~w: '~s' ", [N, Msg]), % Response:write_chunk(Html); after 10000 -> Msg = io_lib:format("Chunk ~w for id ~s\n", [N, Path]), Response:write_chunk(Msg) end, feed(Response, Path, N+1). %% Internal API get_option(Option, Options) -> {proplists:get_value(Option, Options), proplists:delete(Option, Options)}.
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Mochiweb एप्लीकेशन लॉन्च करना

 make && ./start-dev.sh
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

डिफ़ॉल्ट रूप से, मोचीवेब बंदरगाह 8000 पर सुनता है। यदि आप अपने घर के कंप्यूटर पर काम कर रहे हैं, तो आप किसी भी वेब ब्राउज़र का उपयोग करके देख सकते हैं: http: // localhost: 8000 / test / foo ।



नीचे कमांड लाइन के लिए एक परीक्षण है:

 $ lynx --source "http://localhost:8000/test/foo" Mochiconntest welcomes you! Your Id: foo<br/> Chunk 1 for id foo<br/> Chunk 2 for id foo<br/> Chunk 3 for id foo<br/> ^C
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हाँ, यह काम करता है।

बड़ी संख्या में tcp कनेक्शन के लिए लिनक्स कर्नेल को कॉन्फ़िगर करना

हम अपने आप को कुछ समय बचाएंगे और बड़ी संख्या में कनेक्शन के साथ परीक्षण करने से पहले कर्नेल को कॉन्फ़िगर करेंगे, या आपका परीक्षण काम नहीं करेगा, और आपको बहुत सारे "आउट ऑफ सॉकेट मेमोरी" संदेश दिखाई देंगे।



यहाँ sysctl सेटिंग्स हैं:

 # General gigabit tuning: net.core.rmem_max = 16777216 net.core.wmem_max = 16777216 net.ipv4.tcp_rmem = 4096 87380 16777216 net.ipv4.tcp_wmem = 4096 65536 16777216 net.ipv4.tcp_syncookies = 1 # this gives the kernel more memory for tcp # which you need with many (100k+) open socket connections net.ipv4.tcp_mem = 50576 64768 98152 net.core.netdev_max_backlog = 2500 # I was also masquerading the port comet was on, you might not need this net.ipv4.netfilter.ip_conntrack_max = 1048576
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

उन्हें / etc / sysctl.conf में डालें, फिर उन्हें लागू करने के लिए sysctl -p चलाएँ। सिस्टम को रिबूट करने की आवश्यकता नहीं है, अब कर्नेल को बहुत अधिक खुले कनेक्शनों को संभालने में सक्षम होना चाहिए।

बड़ी संख्या में कनेक्शन बनाना

ऐसा करने के कई तरीके हैं। त्सुंग काफी सेक्सी है, और यहां तक ​​कि बहुत सारे अनुरोधों के साथ httpd स्पैम बनाने के कम यौन तरीके (अब, कैंपर, httpload, आदि) पर्याप्त हैं। उनमें से कोई भी आदर्श रूप से हमारे आवेदन का परीक्षण करने के लिए उपयुक्त नहीं है, इसलिए मैंने इन उद्देश्यों के लिए एरलांग पर एक मूल परीक्षण लिखा।



सिर्फ इसलिए कि हम कर सकते हैं, इसका मतलब यह नहीं है कि हमें ... प्रत्येक कनेक्शन के लिए एक प्रक्रिया निश्चित रूप से महंगी होगी। मैंने एक फ़ाइल से URL को लोड करने के लिए एक प्रक्रिया का उपयोग किया, और एक कनेक्शन स्थापित करने के लिए एक अन्य प्रक्रिया और सभी http कनेक्शन से संदेश प्राप्त करने के लिए (और प्रत्येक 10 सेकंड में एक रिपोर्ट मुद्रित करने के लिए टाइमर के रूप में एक प्रक्रिया)। सर्वर से प्राप्त सभी डेटा को छोड़ दिया जाता है, लेकिन काउंटर बढ़ जाता है, इसलिए हम ट्रैक कर सकते हैं कि कितने HTTP संदेश वितरित किए गए थे।

 -module(floodtest). -export([start/2, timer/2, recv/1]). start(Filename, Wait) -> inets:start(), spawn(?MODULE, timer, [10000, self()]), This = self(), spawn(fun()-> loadurls(Filename, fun(U)-> This ! {loadurl, U} end, Wait) end), recv({0,0,0}). recv(Stats) -> {Active, Closed, Chunks} = Stats, receive {stats} -> io:format("Stats: ~w\n",[Stats]) after 0 -> noop end, receive {http,{_Ref,stream_start,_X}} -> recv({Active+1,Closed,Chunks}); {http,{_Ref,stream,_X}} -> recv({Active, Closed, Chunks+1}); {http,{_Ref,stream_end,_X}} -> recv({Active-1, Closed+1, Chunks}); {http,{_Ref,{error,Why}}} -> io:format("Closed: ~w\n",[Why]), recv({Active-1, Closed+1, Chunks}); {loadurl, Url} -> http:request(get, {Url, []}, [], [{sync, false}, {stream, self}, {version, 1.1}, {body_format, binary}]), recv(Stats) end. timer(T, Who) -> receive after T -> Who ! {stats} end, timer(T, Who). % Read lines from a file with a specified delay between lines: for_each_line_in_file(Name, Proc, Mode, Accum0) -> {ok, Device} = file:open(Name, Mode), for_each_line(Device, Proc, Accum0). for_each_line(Device, Proc, Accum) -> case io:get_line(Device, "") of eof -> file:close(Device), Accum; Line -> NewAccum = Proc(Line, Accum), for_each_line(Device, Proc, NewAccum) end. loadurls(Filename, Callback, Wait) -> for_each_line_in_file(Filename, fun(Line, List) -> Callback(string:strip(Line, right, $\n)), receive after Wait -> noop end, List end, [read], []).
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हमारे द्वारा बनाए गए प्रत्येक कनेक्शन के लिए एक पोर्ट की आवश्यकता होती है, और डिफ़ॉल्ट रूप से उनकी संख्या 1024 तक सीमित होती है। समस्याओं से बचने के लिए, हमें शेल के लिए ulimit पैरामीटर को बदलना होगा। यह / etc / सुरक्षा / limit.conf में किया जाता है, लेकिन इसके लिए सिस्टम रिबूट की आवश्यकता होती है।

 $ sudo bash # ulimit -n 999999
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम उपलब्ध पोर्ट की सीमा को अधिकतम तक बढ़ा सकते हैं:

 # echo "1024 65535" > /proc/sys/net/ipv4/ip_local_port_range
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम अपनी परीक्षण उपयोगिता के लिए URL के साथ एक फ़ाइल उत्पन्न करेंगे:

 ( for i in `seq 1 10000`; do echo "http://localhost:8000/test/$i" ; done ) > /tmp/mochi-urls.txt
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अगला, Erlang कंसोल का उपयोग करके हमारी उपयोगिता को संकलित करें और चलाएं:

 erl> c(floodtest). erl> floodtest:start("/tmp/mochi-urls.txt", 100).
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोड प्रति सेकंड 10 नए कनेक्शन स्थापित करेगा (अर्थात, प्रत्येक 100 एमएस में 1 कनेक्शन)।

आंकड़े {एक्टिव, क्लोज्ड, चंक्स} के रूप में प्रदर्शित किए जाएंगे, जहां एक्टिव वर्तमान में स्थापित किए गए कनेक्शनों की संख्या है, क्लोज्ड कनेक्शनों की संख्या है जो किसी कारण से पूरी हो गई है, और चंक्स Mochiweb से भेजे गए संदेशों की संख्या है। बंद 0 पर रहना चाहिए, और चंक्स सक्रिय से बड़ा होना चाहिए, क्योंकि प्रत्येक सक्रिय कनेक्शन में बहुत सारे संदेश शामिल हैं (1 हर 10 सेकंड)।



10,000 सक्रिय कनेक्शनों के साथ मोचीवब प्रक्रिया का आकार 450 एमबी था - यह प्रत्येक कनेक्शन के लिए 45 KB है। मशीन पर सीपीयू का उपयोग वस्तुतः शून्य था।

निष्कर्ष।

यह पहला प्रयास था। प्रत्येक कनेक्शन के लिए 45 Kb काफी बड़ा लगता है - आप शायद सी में कुछ का निर्माण कर सकते हैं libevent का उपयोग करके जो कुछ समान कर सकता है, उदाहरण के लिए प्रत्येक कनेक्शन के लिए 4.5Kb खर्च करना (यह सिर्फ एक धारणा है, अगर किसी के पास समान अनुभव है, तो कृपया एक टिप्पणी छोड़ दो)। यदि आप सी की तुलना में कोड की मात्रा और एर्लांग में ऐसा करने में लगने वाले समय को ध्यान में रखते हैं, तो मुझे लगता है कि उपयोग की गई मेमोरी अधिक आकर्षक है।



भविष्य के लेखों में, मैं संदेश राउटर दिखाऊंगा (इस तरह हम mochiconntest_web.erl में 25 और 41-43 लाइनों को अनइंस्टॉल कर सकते हैं) और मेमोरी उपयोग को कम करने के कुछ तरीकों के बारे में बात करेंगे। मैं 100,000 और 1,000,000 कनेक्शन के साथ परीक्षा परिणाम भी दिखाऊंगा।



अद्यतन: भाग २