🚝 🆗 🕴🏾 LUA in nginx: मेमोरी में हॉट कैश ☔️ 🍇 🤳🏽

मैंने हेबे पर लेखों के गुल्लक को लुआ के रूप में इस तरह के एक अद्भुत वाईपी के रूप में फिर से भरने का फैसला किया, जिसमें नगीन के हुड के तहत इसके उपयोग के कुछ उदाहरण हैं। दो स्वतंत्र पदों में टूट गया, यहाँ दूसरा है ।

इस पोस्ट में, nginx को वैकल्पिक ग्रुपिंग के साथ अंतराल पर ग्राहकों द्वारा अनुरोध किए गए कुछ लगातार अपडेट किए गए डेटा के "हॉट कैश" के रूप में उपयोग किया जाता है (SQL से BETWEEN और GROUP BY / AGGREGATE का एक निश्चित एनालॉग)। Redis से lua + nginx द्वारा डेटा को कैश में लोड किया गया है। Redis source का डेटा हर सेकंड में जोड़ा जाता है, और ग्राहक अभी भी इसे चाहते हैं (N (1 <= N <= 3600) सेकंड, तिथि और सॉर्ट स्वरूप में सॉर्ट करके एकत्रीकरण (सेकंड, मिनट, घंटे ... में अंतराल)।
मौजूदा मशीन पर एक अच्छी हिट्रेट के साथ, यह प्रति सेकंड 110-130k विशलिस्ट प्रदान करने के लिए निकलता है, लेकिन एक खराब के साथ - केवल 20-30k। जो, सामान्य रूप से, हमारे लिए समान नगीन उदाहरण पर भी स्वीकार्य है।

एक निश्चित स्रोत से हर सेकंड में वह डेटा आता है जो Redis ZSET में जोड़ा जाता है। एक महत्वपूर्ण बिंदु समय के साथ डेटा का बाइंडिंग है - चयन समय अंतराल पर जाएगा। एक ग्राहक आया - "मुझे अब हर एक के बाद एक दे दो", एक और आया - "लेकिन मेरे पास यह अंतराल है, लेकिन प्रति घंटा एकत्रीकरण के साथ आते हैं", तीसरे को एक आखिरी सेकंड की जरूरत है, 27 सेकंड के एकत्रीकरण के साथ एक दिन के लिए चौथा, अच्छी तरह से, आदि। डी ... रेडिस में सीधे डेटा पर दस्तक अवास्तविक है। पहले से तैयार किए गए डेटा को कैशिंग करना बहुत समस्याग्रस्त है। सामान्य मामले में आवश्यक अंतराल और एकत्रीकरण कदम, प्रत्येक ग्राहक / अनुरोध का अपना है और मनमाने ढंग से भिन्न हो सकता है। सर्वर को किसी भी उचित अनुरोध का तुरंत जवाब देने के लिए तैयार रहना चाहिए।

प्रारंभ में, विचार रेडिस पक्ष पर एकत्रीकरण का प्रदर्शन करने के लिए था, जो कि नग्नेक्स-लुआ कोड से EVAL रेडिस-लुआ कोड के माध्यम से बुला रहा था। रेडिस की एकल-पिरोया प्रकृति के कारण यह "हमें गहरी तकनीक में जाने की जरूरत नहीं थी": जल्दी से "कच्चा डेटा" वितरित करने से तैयार परिणाम को समूहीकृत करने और भरने की तुलना में बहुत तेजी से निकलता है।

Redis में डेटा को फॉर्म के json फॉर्मेट में एलिमेंट-वार किया जाता है:

ZADD ns:zs:key 1386701764 "{\"data100500\":\"hello habr\",\"dt\":\"10.12.2013 10:05:00\",\"smth\":\"else\"}"

"टाइमर" संस्करण के अनुसार, स्ट्रिंग समतुल्य है, dt स्ट्रिंग समतुल्य है।
तदनुसार, सीमा चयन:

 ZREVRANGEBYSCORE ns:zs:data:sec 1386701764 1386700653 WITHSCORES

और रेस्ट रेडिस के माध्यम से लुआ पर:

 local redis = require 'redis' local R, err = redis:new() R:connect('12.34.56.78', 6379) R:zrevrangebyscore('ns:zs:data:sec', to, from, 'WITHSCORES') --  ..

रेसी रेडिस में कनेक्शन पूल के बारे में

यह महत्वपूर्ण है कि रेकी रेडिस और आर के लिए एक कस्टम कनेक्शन पूल का उपयोग करता है: कनेक्ट () आमतौर पर एक नया कनेक्शन नहीं बनाता है। उपयोग के बाद कनेक्शन लौटना स्वचालित रूप से नहीं किया जाता है, यह R: set_keepalive () को कॉल करके किया जाना चाहिए, जो कनेक्शन को वापस पूल में लौटाता है (लौटने के बाद, आप इसे फिर से R: कनेक्ट () के बिना उपयोग नहीं कर सकते हैं)। पूल से वर्तमान कनेक्शन पुनर्प्राप्ति काउंटर R: get_reused_times () के माध्यम से पाया जा सकता है। यदि> 0, तो यह पहले से बनाया और कॉन्फ़िगर किया गया कनेक्शन है। इस स्थिति में, आपको AUTH आदि को फिर से भेजने की आवश्यकता नहीं है।

हम नाज़िनक्स (लुआ-नेगनेक्स- मॉड्यूल + लुआ-रेस्टी-रेडिस ) इकट्ठा करते हैं , जल्दी से कॉन्फ़िगर करते हैं:

 http { lua_package_path '/path/to/lua/?.lua;;'; init_by_lua_file '/path/to/lua/init.lua'; lua_shared_dict ourmegacache 1024m; server { location = /data.js { content_by_lua_file '/path/to/lua/get_data.lua'; } } }

साझा तानाशाही के साथ काम करने के बारे में

साझा किए गए तानाशाह "आउमेगैचे" को विन्यास में दर्शाया गया है, जो एक तालिका (शब्दकोश, हैश) के रूप में लुआ में उपलब्ध होगा। यह तालिका सभी nginx कार्यकर्ता प्रक्रियाओं के लिए एक है और इस पर संचालन हमारे लिए परमाणु हैं।
तालिका तक पहुंच सरल है:

 local cache = ngx.shared.ourmegacache cache:get('foo') cache:set('bar', 'spam', 3600) --  .. .

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

अनुरोधित अंतराल और एकत्रीकरण चरण की सीमाओं में विविधता लाने के लिए, हम GET अनुरोध पैरामीटर से , से और कदम तक प्राप्त करेंगे। इस समझौते के साथ, सेवा के लिए अनुरोध का अनुमानित प्रारूप इस प्रकार होगा:

/data.js?step=300&from=1386700653&to=1386701764

 local args = ngx.req.get_uri_args() local from = tonumber(args.from) or 0 ...

इसलिए, हमारे पास Redis में संग्रहीत तत्व-वार जोंस प्रविष्टियाँ हैं जो हम वहाँ से प्राप्त कर सकते हैं। ग्राहकों को कैश करने और उन्हें देने का सबसे अच्छा तरीका क्या है?

आप प्रति सेकंड व्यक्तिगत रूप से एक तालिका में संग्रहीत कर सकते हैं। हालांकि, जैसा कि अभ्यास से पता चला है, तालिका में कई दर्जन प्रश्नों के कार्यान्वयन का प्रदर्शन पर बहुत नकारात्मक प्रभाव पड़ता है। और अगर कोई अनुरोध एक दिन के लिए आता है, तो थोड़े समय के साथ प्रतिक्रिया की उम्मीद नहीं की जा सकती है;
रिकॉर्ड्स को ब्लॉकों में संग्रहीत किया जा सकता है, कुछ सामान्य विभाजक के माध्यम से संयोजन कर सकते हैं या उन्हें एक ही जसन में भी धारावाहिक कर सकते हैं। और जब संकेत दिया जाता है, तो आपको सीमांकक या डिसेरिएलाइज़ के माध्यम से सॉर्ट करने की आवश्यकता होती है। तो - विकल्प;
एकत्रीकरण के विभिन्न स्तरों पर आंशिक दोहराव के साथ, पदानुक्रम को डेटा स्टोर करें। विभिन्न आकारों के कैश ब्लॉक का उपयोग किया जाता है: 1 सेकंड (एकल रिकॉर्ड), 10 सेकंड, 1 मिनट, 10 मिनट, घंटा। प्रत्येक ब्लॉक में उसके सभी सेकंड का डेटा होता है। सबसे महत्वपूर्ण बात यह है कि ब्लॉक की सामग्री नहीं बदलती है और टुकड़ों में नहीं दी जाती है: या तो एक पूरे के रूप में या नहीं।

अंतिम विकल्प को चुना गया था, अधिक मेमोरी का उपभोग करते हुए, लेकिन टेबल एक्सेस की संख्या को काफी कम कर दिया। विभिन्न आकारों के कैश ब्लॉक का उपयोग किया जाता है: 1 सेकंड (एकल रिकॉर्ड), 10 सेकंड, 1 मिनट, 10 मिनट, घंटा। प्रत्येक ब्लॉक में उसके सभी सेकंड का डेटा होता है। प्रत्येक ब्लॉक को इसके अंतराल की सीमा से जोड़ा जाता है, उदाहरण के लिए, 10 सेकंड के अंतराल के पहले तत्व में हमेशा 9 के एक दशमलव शेष के साथ टाइमस्टैम्प होता है (ग्राहक के रूप में अवरोही क्रम में छंटनी), और समय ब्लॉक में 5:59, 59: 58, ... 00:00 शामिल हैं। तत्वों का संयोजन करते समय, उन्हें तुरंत एक विभाजक के साथ चिपकाया जाता है - एक अल्पविराम, जो आपको क्लाइंट को एक कार्रवाई के साथ इन ब्लॉकों को देने की अनुमति देता है: '[', ब्लॉक, '], और जल्दी से उन्हें बड़े टुकड़ों में भी मिलाते हैं।

अनुरोधित अंतराल को कवर करने के लिए, इसे छोटे ब्लॉकों के साथ किनारों पर पूरा करने के साथ अधिकतम संभव ब्लॉकों में विभाजित किया गया है। क्योंकि चूंकि हमारे पास एकल ब्लॉक हैं, इसलिए आवश्यक अंतराल को पूरी तरह से कवर करना हमेशा संभव होता है। अंतराल का अनुरोध करने के लिए 02: 29: 58 ... 03:11:02 हमें कैश लेआउट मिलेगा:

 1sec - 03:11:02
 1sec - 03:11:01
 1sec - 03:11:00
 1min - 03:10:59 .. 03:10:00
 10min - 03:09:59 .. 03:00:00
 30min - 02:59:59 .. 02:30:00
 1sec - 02:29:59
 1sec - 02:29:58

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

 local chunk local lock_ttl = 0.5 --     ,   local key_lock = key .. ':lock' local try_until = ngx.now() + lock_ttl local locked while true do locked = cache:add(key_lock, 1, lock_ttl) chunk = cache:get(key) if locked or chunk or (try_until < ngx.now()) then break end ngx.sleep(0.01) -- ,   nginx evloop end if locked then --   . ,   elseif chunk then --    ,        end if locked then cache:delete(key_lock) end

आवश्यक कैश लेआउट होने के बाद, रेडिस से वांछित सीमा का चयन करने की क्षमता, और एकत्रीकरण तर्क (यहां बहुत विशिष्ट है, मैं एक उदाहरण नहीं देता हूं), हमें एक उत्कृष्ट कैशिंग सर्वर मिलता है, जो गर्म होने के बाद, एक नए तत्व के लिए प्रति सेकंड केवल एक बार Redis के लिए दस्तक देता है। अगर वे अभी तक एलआरयू द्वारा नहीं चुने गए हैं या फेंक दिए गए हैं। और रेडिस में सीमित कनेक्शन पूल के बारे में मत भूलना।
हमारे मामले में, कई सेकंड के लिए 100-110Mb / s के आदेश के आने वाले ट्रैफ़िक में हीटिंग एक अल्पकालिक कूद की तरह दिखता है। नगनेक्स के साथ एक मशीन पर सीपीयू के अनुसार, हीटिंग लगभग बिल्कुल ध्यान देने योग्य नहीं है।

हेडर में छवि यहां से ली गई है ।

LUA in nginx: मेमोरी में हॉट कैश

More articles: