NGINX में MySQL: नॉन-ब्लॉकिंग सर्वर में ब्लॉकिंग लाइब्रेरी का उपयोग करना

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

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

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

प्रसंग स्विचिंग और इंटरसेप्ट्स

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

सबसे पहले, पता करें कि क्या कॉल निष्पादन के धागे को अवरुद्ध कर सकते हैं।
यहाँ मुख्य हैं:

• स्वीकार करना
• कनेक्ट
• पढ़ें / फिर से पढ़ें
• लिखना / भेजना
• मतदान

इस सूची में अंतिम कार्य - जनमत - क्योंकि बहुत ईमानदार नहीं दिखता है स्वयं कभी-कभी गैर-अवरुद्ध व्यवहार का संकेत होता है। हालाँकि, libmysqlclient इसका उपयोग करता है, इसलिए हमें इसे रोकना होगा। जाहिर है, epoll_wait भी अवरुद्ध है, लेकिन हम आशा करते हैं कि अवरुद्ध कोड इसका उपयोग नहीं करेगा। अभी भी एक चुनिंदा कॉल है, हालांकि, इसमें कई समस्याएं हैं और इसलिए (भगवान का शुक्र है!) का उपयोग कम और कम किया जाता है। को भी बाहर कर दिया।

इन कार्यों को लिबास में परिभाषित किया गया है, इसलिए यदि हमारा कोड गतिशील रूप से लिंक कर रहा है, तो हमारे पास मानक अवरोधन तकनीक का उपयोग करने का हर अवसर है। मैं पढ़ने के लिए एक उदाहरण दूंगा:

typedef ssize_t (*read_pt)(int fd, void *buf, size_t count); static read_pt orig_read; ssize_t read(int fd, void *buf, size_t count) { ssize_t ret; for(;;) { /*   read */ ret = orig_read(fd, buf, count); if (!mtask_scheduled || ret != -1 || errno != EAGAIN) return ret; /*   ;    */ if (mtask_yield(fd, NGX_READ_EVENT)) { errno = EIO; return -1; } } } ... /* -   */ orig_read = (read_pt)dlsym(RTLD_NEXT, "read"); 

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

यह भी ध्यान दिया जाना चाहिए कि जिस सॉकेट पर read ऑपरेशन किया जाता है उसे नॉन-ब्लॉकिंग मोड में डाला जाना चाहिए, जिसके लिए हुक connect और accept में fcntl को संबंधित कॉल करना आवश्यक है।

संदर्भों

उपयोगकर्ता-विशिष्ट निष्पादन संदर्भ क्या है? यह एक स्टैक + रजिस्टर है (संकेतों को प्राप्त करने के लिए एक मुखौटा भी है, लेकिन हम संकेतों से नहीं कूदते हैं, इसलिए अब हमें कोई दिलचस्पी नहीं है)। यदि सब कुछ इतना सरल है, तो यह स्पष्ट है कि संदर्भ को एक प्रक्रिया के ढांचे के भीतर स्विच किया जा सकता है जब हम इसे महसूस करते हैं। इसके लिए मानक उपकरण हैं।

• makecontext - एक संदर्भ बनाता है, हम स्टैक और फ़ंक्शन को निर्दिष्ट करते हैं
• swapcontext - स्विच संदर्भ
• setcontext / getcontext - संदर्भ सेट / पढ़ता है

हम एनजीआईएनएक्स को उपवास करते हैं

NGINX में, उत्पन्न होने वाली सामग्री एक दृश्य हैंडलर द्वारा बनाई गई है:

static ngx_int_t ngx_http_mtask_handler(ngx_http_request_t *r);

यह हैंडलर NGX_HTTP_CONTENT_PHASE चरण के हैंडलर की सूची में जोड़ा गया है:

 h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers); *h = ngx_http_mtask_handler; 

सामान्य उपयोग में, हैंडलर जंजीरों (ngx_chain_t) को बफ़र्स के साथ क्लाइंट को वापस करने के लिए बनाता है, इसके बाद यह कार्य करता है

• ngx_http_send_header - HTTP शीर्ष लेख वापस करने के लिए
• ngx_http_output_filter - शरीर को वापस करने के लिए।

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

इसलिए, हम चाहते हैं कि हैंडलर अवरुद्ध संचालन करने में सक्षम हो। ऐसा करने के लिए, निम्नलिखित करें।

 /*  ,   */ getcontext(&ctx->wctx); ctx->wctx.uc_stack.ss_sp = ngx_palloc(r->pool, mlcf->stack_size); ctx->wctx.uc_stack.ss_size = mlcf->stack_size; ctx->wctx.uc_stack.ss_flags = 0; ctx->wctx.uc_link = NULL; makecontext(&ctx->wctx, &mtask_proc, 0); /*     */ mtask_wake(r, MTASK_WAKE_NOFINALIZE); /*  NGINX',        ,   ,      ;    */ r->main->count++; 

Mtask_wake फ़ंक्शन निम्न बुनियादी चीज़ें करता है:

 /*      */ /*        - */ mtask_setcurrent( r ); /*    */ /*       ! */ swapcontext(&ctx->rctx, &ctx->wctx); /*   ,  ,    ! */ if (!mtask_scheduled) { /*   */ if (!(flags & MTASK_WAKE_NOFINALIZE)) ngx_http_finalize_request(r, NGX_OK); return 1; } /*   ,   -   */ /*    -    */ /*         */ mtask_resetcurrent(); 

Mtask_yield फ़ंक्शन सबसे महत्वपूर्ण कार्य करता है - यह अवरुद्ध कॉल को NGINX घटनाओं में परिवर्तित करता है और मुख्य सीमा पर नियंत्रण लौटाता है:

 /*    NGINX        */ c = ngx_get_connection(fd, mtask_current->connection->log); c->data = mtask_current; /*   /  NGINX */ if (event == NGX_READ_EVENT) e = c->read; else e = c->write; e->data = c; e->handler = &mtask_event_handler; e->log = mtask_current->connection->log; ngx_add_event(e, event, 0); /*         ,     */ swapcontext(&ctx->wctx, &ctx->rctx); /*  !    /.  */ ngx_del_event(e, event, 0); ngx_free_connection( c ); 

NGINX ईवेंट हैंडलर एक बुनियादी काम करता है: I / O ईवेंट होने पर संदर्भ बदलता है:

 static void mtask_event_handler(ngx_event_t *ev) { ... mtask_wake(r, wf); ... } 

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

 c->write->delayed = 1 

धागे के अंत में, यह ध्वज रीसेट है और डेटा क्लाइंट को प्रेषित किया जाता है। जाहिर है, यह समाधान बड़ी मात्रा में डेटा आउटपुट के लिए उपयुक्त नहीं है, लेकिन ज्यादातर मामलों में यह कार्य इसके लायक नहीं है (और जब यह होता है, तब भी इसे थोड़ा कम सुंदर तरीके से हल किया जा सकता है)।

हम libmysqlclient को फास्ट करते हैं

अवरुद्ध कोड को निष्पादित करने के लिए एक तंत्र के साथ, MySQL तक पहुंचना आसान है। शुरुआत के लिए, सबसे आम CONTENT_PHASE हैंडलर बनाया गया है। याद रखें कि उपयोगकर्ता-स्पेस थ्रेड का प्रोटोटाइप फ़ंक्शन पूरी तरह से एक नियमित हैंडलर के प्रोटोटाइप के साथ मेल खाता है। इस प्रकार, हमारे कोड की अवरुद्ध प्रकृति के बारे में भूलकर, हम libmysqlclient लाइब्रेरी के मानक टूल का मानक मानक हैंडलर में उपयोग करते हैं:

 ngx_int_t ngx_http_mysql_handler(ngx_http_request_t *r) { ... mysql_real_connect(...) ... mysql_query(...) ... mysql_store_result(...) ... mysql_fetch_row(...) ... } 

डेटा को सादे पाठ में, फ़ील्ड द्वारा फ़ील्ड में प्रदर्शित किया जाता है, और हम ngx_chain_t श्रृंखला प्रति फ़ील्ड में एक लिंक का उपयोग करते हैं। यह हमें NGINX के अंदर क्वेरी परिणामों का लाभ उठाने का एक सरल अवसर देता है। ऐसा करने के लिए, mysql_subrequest निर्देश को लागू किया जाता है, जो किसी अन्य स्थान पर वर्णित MySQL क्वेरी को निष्पादित करता है, और फिर इस आदेश के तर्क के रूप में पारित चर के क्रम में इसके परिणाम निर्दिष्ट करता है (नीचे उदाहरण देखें)। तब चर का उपयोग किया जा सकता है, उदाहरण के लिए, कनेक्शन को वांछित बैकएंड (डेटाबेस से प्राप्त) को प्रॉक्सी करने के लिए या अपने मूल्यों को कुछ स्क्रिप्ट में स्थानांतरित करने के लिए जिनके पास डेटाबेस तक पहुंच नहीं है।

हैंडलर स्वयं सामान्य रूप से पंजीकृत नहीं है (CONTENT_PHASE चरण में - यहां आपको "ईमानदार" गैर-अवरोधक कोड की आवश्यकता है), लेकिन mtask मॉड्यूल के कॉन्फ़िगरेशन में।

 ngx_http_mtask_loc_conf_t *mlcf; mlcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_mtask_module); mlcf->handler = &ngx_http_mysql_handler; 

उदाहरण

एक उदाहरण nginx.conf config जो इस मॉड्यूल की क्षमताओं को प्रदर्शित करता है।

 server { ... #      server # unix socket access (default) mysql_host localhost; #mysql_user theuser; #mysql_password thepass; #mysql_port theport; mysql_database test; mysql_connections 32; #          # .. NGINX       #       . mtask_stack 65536; #  ! location /select { mysql_query "SELECT name FROM users WHERE id='$arg_id'"; } location /insert { mysql_query "INSERT INTO users(name) VALUES('$arg_name')"; } location /update { mysql_query "UPDATE users SET name='$arg_name' WHERE id=$arg_id"; } location /delete { mysql_query "DELETE FROM users WHERE id=$arg_id"; } #     location /pass { #  name       $name mysql_subrequest /select?id=$arg_id $name; #   $name   proxy_pass http://myserver.com/path?name=$name; } ... } 

आप पते पर मॉड्यूल देख और डाउनलोड कर सकते हैं

github.com/arut/nginx-mtask-module
github.com/arut/nginx-mysql-module

आप सभी को धन्यवाद!