रूबी डेवलपर्स के लिए रैक समझाया गया

प्रत्येक रेल, सिनात्रा, और अन्य रूबी वेब ढांचे के पर्दे के पीछे क्या हो रहा है?

इसका उत्तर है रैक, प्रमुख घटक जो इसे संभव बनाता है।

लेकिन रैक वास्तव में क्या है?

रैक फ्रेमवर्क (रेल) और एप्लिकेशन सर्वर (प्यूमा) के बीच की एक परत है।

यह गोंद है जो उन्हें संवाद करने की अनुमति देता है।

हम रैक का उपयोग क्यों करते हैं?

हम रैक का उपयोग करते हैं क्योंकि यह विभिन्न ढांचे और सर्वर को अदला-बदली करने की अनुमति देता है।

वे घटक बन जाते हैं जिन्हें आप प्लग-इन कर सकते हैं ।

इसका मतलब है कि आप रेल, सिनात्रा और किसी अन्य रैक-संगत ढांचे के साथ प्यूमा का उपयोग कर सकते हैं। इससे कोई फर्क नहीं पड़ता कि आप किस फ्रेमवर्क या सर्वर का उपयोग कर रहे हैं यदि वे रैक इंटरफ़ेस को लागू करते हैं ।

रैक के साथ, हर घटक अपना काम करता है और हर कोई खुश है!

रैक मिडलवेयर क्या है?

रैक हर वेब अनुरोध और प्रतिक्रिया के बीच में बैठता है।

नतीजतन, यह अवांछित अनुरोधों तक पहुंच से इनकार करके एक अभिभावक के रूप में कार्य कर सकता है, या धीमी प्रतिक्रियाओं का ट्रैक रखते हुए एक इतिहासकार के रूप में कार्य कर सकता है।

यही है रैक मिडलवेयर है!

छोटे रूबी प्रोग्राम जिन्हें अनुरोध-प्रतिक्रिया चक्र के हिस्से के रूप में बुलाया जाता है और इसके साथ कुछ करने का मौका मिलता है।

इसका उपयोग किस प्रकार की चीज़ों के लिए किया जाता है?

• लॉगिंग
• सत्र
• प्रोफाइलिंग (पता लगाएं कि अनुरोध पूरा होने में कितना समय लगता है)
• कैशिंग
• सुरक्षा (आईपी पते के आधार पर अनुरोध अस्वीकार करें, या अनुरोध की # सीमा)
• स्थिर फ़ाइलें (css, js, png…) परोसना

ये बहुत उपयोगी हैं और रेल अपनी कुछ कार्यक्षमता को लागू करने के लिए मिडलवेयर का अच्छा उपयोग करता है ।

आप rake middleware के साथ मिडलवेयर की सूची देख सकते हैं एक रेल परियोजना के अंदर।

अब, यह रैक इंटरफ़ेस मैंने पहले उल्लेख किया था।

यह कैसा दिखता है?

मैं आपको एक उदाहरण के साथ दिखाता हूँ…

अपना खुद का रैक एप्लिकेशन कैसे लिखें

आप अपना खुद का एप्लिकेशन लिखकर सीख सकते हैं कि रैक कैसे काम करता है।

चलो यह करते हैं!

एक रैक एप्लिकेशन एक विधि वाला एक वर्ग है: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 हेडर ("सामग्री-प्रकार")
• सामग्री ("रैक से नमस्ते")

यदि आप अनुरोध विवरण तक पहुंचना चाहते हैं तो आप env . का उपयोग कर सकते हैं तर्क।

इसे पसंद करें :

req = Rack::Request.new(env)

ये विधियां उपलब्ध हैं :

• path_info (/लेख/1)
• आईपी (उपयोगकर्ता का)
• user_agent (Chrome, Firefox, Safari…)
• अनुरोध_विधि (प्राप्त करें / पोस्ट करें)
• शरीर (सामग्री)
• media_type (सादा, json, html)

आप इस जानकारी का उपयोग अपना रैक एप्लिकेशन बनाने . के लिए कर सकते हैं ।

उदाहरण के लिए, यदि 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 try आज़माएं , लोकलहोस्ट का IPv6 संस्करण।

रैक मिडलवेयर कैसे लिखें और उपयोग करें

अब:

आप एप्लिकेशन और मिडलवेयर को कैसे श्रृंखलाबद्ध करते हैं ताकि वे एक साथ काम करें?

Rack::Builder का उपयोग करना ।

समझने का सबसे अच्छा तरीका एक उदाहरण है।

यह रहा हमारा रैक ऐप :

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

इस उदाहरण में हमारे पास दो रैक एप्लिकेशन हैं:

• आईपी जांच के लिए एक (FilterLocalHost )
• एक आवेदन के लिए स्वयं सामग्री वितरित करने के लिए (एचटीएमएल, जेएसओएन, आदि)

ध्यान दें कि @app.call(env) , यही FilterLocalHost . बनाता है एक मिडलवेयर।

दो चीजों में से एक हो सकता है :

• हम एक प्रतिक्रिया देते हैं, जो मिडलवेयर श्रृंखला को रोकता है
• हम अनुरोध को @app.call(env) . के साथ पास करते हैं अगले मिडलवेयर, या ऐप पर ही

अपने रैक ऐप के किसी भी हिस्से के अंदर, मिडलवेयर सहित, आप प्रतिक्रिया बदल सकते हैं।

उदाहरण :

class UpcaseAll
  def initialize(app)
    @app = app
  end

  def call(env)
    status, headers, response = @app.call(env)

    response.upcase!

    [status, headers, response]
  end
end

रैक ठीक इसी तरह काम करता है 🙂

सारांश

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

यदि आपके कोई प्रश्न या प्रतिक्रिया है तो नीचे एक टिप्पणी छोड़ने के लिए स्वतंत्र महसूस करें।

पढ़ने के लिए धन्यवाद!