हर Rails, Sinatra, और अन्य Ruby वेब फ्रेमवर्क्स के पीछे क्या हो रहा है?
उत्तर है Rack, वह प्रमुख घटक जो इसे संभव बनाता है।
लेकिन Rack वास्तव में क्या है?
Rack फ्रेमवर्क (Rails) और एप्लिकेशन सर्वर (Puma) के बीच एक परत है।
यह वह गोंद है जो उन्हें संवाद करने की अनुमति देता है।
हम Rack का उपयोग क्यों करते हैं?
हम Rack का उपयोग इसलिए करते हैं क्योंकि यह विभिन्न फ्रेमवर्क्स और सर्वर्स को विनिमेय (interchangeable) बनाता है।
वे घटक बन जाते हैं जिन्हें आप प्लग-इन कर सकते हैं।
इसका मतलब है कि आप Puma का उपयोग Rails, Sinatra और किसी अन्य Rack-संगत फ्रेमवर्क के साथ कर सकते हैं। इससे कोई फर्क नहीं पड़ता कि आप किस फ्रेमवर्क या सर्वर का उपयोग कर रहे हैं यदि वे Rack इंटरफेस को लागू करते हैं।
Rack के साथ, हर घटक अपना काम करता है और हर कोई खुश होता है!
Rack मिडलवेयर क्या है?
Rack हर वेब रिक्वेस्ट और रिस्पांस के बीच में बैठता है।
परिणामस्वरूप, यह एक अभिभावक के रूप में कार्य कर सकता है, अवांछित रिक्वेस्ट्स को अस्वीकार करके, या यह एक इतिहासकार के रूप में कार्य कर सकता है, धीमी प्रतिक्रियाओं का ट्रैक रखकर।
यही Rack मिडलवेयर है!
छोटे Ruby प्रोग्राम्स जो रिक्वेस्ट-रिस्पांस साइकिल के हिस्से के रूप में कॉल किए जाते हैं और इसके साथ कुछ करने का मौका पाते हैं।
इसका उपयोग किस तरह की चीजों के लिए किया जाता है?
- लॉगिंग
- सेशन्स
- प्रोफाइलिंग (पता करें कि रिक्वेस्ट को पूरा होने में कितना समय लगता है)
- कैशिंग
- सुरक्षा (IP पते के आधार पर रिक्वेस्ट्स को अस्वीकार करें, या रिक्वेस्ट्स की संख्या सीमित करें)
- स्टेटिक फाइल्स सर्व करना (css, js, png...)
ये काफी उपयोगी हैं और Rails अपनी कुछ कार्यक्षमता को लागू करने के लिए मिडलवेयर का अच्छा उपयोग करता है।
आप rake middleware के साथ Rails प्रोजेक्ट के अंदर मिडलवेयर की सूची देख सकते हैं।
अब, मैंने पहले जिस Rack इंटरफेस का उल्लेख किया था।
यह कैसा दिखता है?
आइए एक उदाहरण के साथ आपको दिखाते हैं...
अपना खुद का Rack एप्लिकेशन कैसे लिखें
आप अपना खुद का एप्लिकेशन लिखकर सीख सकते हैं कि Rack कैसे काम करता है।
चलिए करते हैं!
एक Rack एप्लिकेशन एक क्लास है जिसमें एक मेथड है: call।
यह ऐसा दिखता है:
require 'rack' handler = Rack::Handler::Thin class RackApp def call(env) [200, {"Content-Type" => "text/plain"}, "Hello from Rack"] end end handler.run RackApp.new
यह कोड पोर्ट 8080 पर एक सर्वर शुरू करेगा (इसे आज़माएं!)।
वापस की जा रही इस सरणी का क्या मतलब है?
- HTTP स्टेटस कोड (200)
- HTTP हेडर्स ("Content-Type")
- कंटेंट ("Hello from Rack")
यदि आप रिक्वेस्ट विवरण तक पहुंचना चाहते हैं तो आप env आर्गुमेंट का उपयोग कर सकते हैं।
इस तरह:
req = Rack::Request.new(env)
ये मेथड्स उपलब्ध हैं:
- path_info (/articles/1)
- ip (उपयोगकर्ता का)
- user_agent (Chrome, Firefox, Safari...)
- request_method (get / post)
- body (कंटेंट)
- media_type (plain, json, html)
आप इस जानकारी का उपयोग अपना Rack एप्लिकेशन बनाने के लिए कर सकते हैं।
उदाहरण के लिए, हम अपनी सामग्री तक पहुंच से इनकार कर सकते हैं यदि IP पता 5.5.5.5 है।
यहां कोड है:
require 'rack' handler = Rack::Handler::Thin class RackApp def call(env) req = Rack::Request.new(env) if req.ip == "5.5.5.5" [403, {}, ""] else [200, {"Content-Type" => "text/plain"}, "Hello from Rack"] end end end handler.run RackApp.new
यदि आप प्रभाव देखना चाहते हैं तो पते को 127.0.0.1 में बदल सकते हैं।
यदि वह काम नहीं करता तो ::1 आज़माएं, localhost का IPv6 संस्करण।
Rack मिडलवेयर कैसे लिखें और उपयोग करें
अब:
आप एप्लिकेशन और मिडलवेयर को कैसे चेन करते हैं ताकि वे एक साथ काम करें?
Rack::Builder का उपयोग करके।
समझने का सबसे अच्छा तरीका एक उदाहरण के साथ है।
यहां हमारा Rack ऐप है:
require 'rack' handler = Rack::Handler::Thin class RackApp def call(env) req = Rack::Request.new(env) [200, {"Content-Type" => "text/plain"}, "Hello from Rack - #{req.ip}"] end end
यह मिडलवेयर है:
class FilterLocalHost def initialize(app) @app = app end def call(env) req = Rack::Request.new(env) if req.ip == "127.0.0.1" || req.ip == "::1" [403, {}, ""] else @app.call(env) end end end
यह है कि हम उन्हें कैसे जोड़ते हैं:
app = Rack::Builder.new do |builder| builder.use FilterLocalHost builder.run RackApp.new end handler.run app
इस उदाहरण में हमारे पास दो Rack एप्लिकेशन्स हैं:
- IP जांच के लिए एक (
FilterLocalHost) - कंटेंट डिलीवर करने के लिए एप्लिकेशन खुद (HTML, JSON, आदि)
ध्यान दें कि @app.call(env), यही FilterLocalHost को मिडलवेयर बनाता है।
दो चीजों में से एक हो सकती है:
- हम एक प्रतिक्रिया लौटाते हैं, जो मिडलवेयर चेन को रोक देता है
- हम
@app.call(env)के साथ अगले मिडलवेयर, या ऐप को रिक्वेस्ट पास करते हैं
आपके Rack ऐप के किसी भी हिस्से में, मिडलवेयर सहित, आप प्रतिक्रिया को बदल सकते हैं।
उदाहरण:
class UpcaseAll def initialize(app) @app = app end def call(env) status, headers, response = @app.call(env) response.upcase! [status, headers, response] end end
यही ठीक से Rack काम करता है 🙂
सारांश
आपने Rack के बारे में सीखा, वह इंटरफेस जो Ruby वेब फ्रेमवर्क्स और सर्वर्स के बीच इंटरैक्शन को चला रहा है। आपने यह भी सीखा कि यह कैसे काम करता है यह समझने के लिए अपना खुद का Rack एप्लिकेशन कैसे लिखें।
यदि आपके कोई प्रश्न या प्रतिक्रिया है तो बेझिझक नीचे कमेंट छोड़ें।
पढ़ने के लिए धन्यवाद!
