रेल के साथ एपीआई तैयार करना

आजकल एपीआई (एप्लिकेशन प्रोग्रामिंग इंटरफेस) पर बहुत अधिक भरोसा करना एक आम बात है। न केवल फेसबुक और ट्विटर जैसी बड़ी सेवाएं उन्हें रोजगार देती हैं- एपीआई बहुत लोकप्रिय हैं क्योंकि क्लाइंट-साइड फ्रेमवर्क जैसे रिएक्ट, एंगुलर और कई अन्य लोगों के प्रसार के कारण। रूबी ऑन रेल्स इस प्रवृत्ति का अनुसरण कर रहा है, और नवीनतम संस्करण एक नई सुविधा प्रस्तुत करता है जिससे आप एपीआई-केवल एप्लिकेशन बना सकते हैं।

प्रारंभ में इस कार्यक्षमता को रेल-एपीआई नामक एक अलग रत्न में पैक किया गया था, लेकिन रेल 5 के रिलीज होने के बाद से, यह अब ढांचे के मूल का हिस्सा है। एक्शनकेबल के साथ यह सुविधा शायद सबसे प्रत्याशित थी, और इसलिए आज हम इस पर चर्चा करने जा रहे हैं।

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

इस लेख का स्रोत GitHub पर उपलब्ध है।

केवल-एपीआई एप्लिकेशन बनाना

प्रारंभ करने के लिए, निम्न आदेश चलाएँ:

rails new RailsApiDemo --api

यह एक नया एपीआई-ओनली रेल एप्लिकेशन बनाने जा रहा है जिसे RailsApiDemo . कहा जाता है . यह न भूलें कि --api . के लिए समर्थन विकल्प केवल रेल 5 में जोड़ा गया था, इसलिए सुनिश्चित करें कि आपके पास यह या एक नया संस्करण स्थापित है।

Gemfile  खोलें और ध्यान दें कि यह सामान्य से बहुत छोटा है:रत्न जैसे coffee-rails , turbolinks , और sass-rails चले गए हैं।

config/application.rb  फ़ाइल में एक नई लाइन है:

config.api_only = true

इसका मतलब है कि रेल मिडलवेयर का एक छोटा सेट लोड करने जा रहा है:उदाहरण के लिए, कोई कुकीज़ और सत्र समर्थन नहीं है। इसके अलावा, यदि आप एक मचान बनाने का प्रयास करते हैं, तो दृश्य और संपत्तियां नहीं बनाई जाएंगी। दरअसल, अगर आप दृश्य/लेआउट  . की जांच करते हैं निर्देशिका, आप देखेंगे कि application.html.erb फ़ाइल भी गायब है।

एक और महत्वपूर्ण अंतर यह है कि ApplicationController ActionController::API . से इनहेरिट करता है , नहीं ActionController::Base ।

बस इतना ही - कुल मिलाकर, यह एक बुनियादी रेल एप्लिकेशन है जिसे आपने कई बार देखा है। अब कुछ मॉडल जोड़ते हैं ताकि हमारे पास काम करने के लिए कुछ हो:

rails g model User name:string
rails g model Post title:string body:text user:belongs_to
rails db:migrate

यहां कुछ भी फैंसी नहीं चल रहा है:एक शीर्षक के साथ एक पोस्ट, और एक शरीर उपयोगकर्ता का है।

सुनिश्चित करें कि उचित संघ स्थापित किए गए हैं और कुछ सरल सत्यापन जांच भी प्रदान करते हैं:

मॉडल/user.rb

  has_many :posts

  validates :name, presence: true

मॉडल/पोस्ट.आरबी

  belongs_to :user

  validates :title, presence: true
  validates :body, presence: true

बहुत खूब! अगला चरण कुछ नमूना रिकॉर्ड को नई बनाई गई तालिकाओं में लोड करना है।

डेमो डेटा लोड हो रहा है

कुछ डेटा लोड करने का सबसे आसान तरीका है seeds.rb . का उपयोग करना db . के अंदर फ़ाइल करें निर्देशिका। हालांकि, मैं आलसी हूं (जितने प्रोग्रामर हैं) और मैं किसी भी नमूना सामग्री के बारे में नहीं सोचना चाहता। इसलिए, हम नकली रत्न का लाभ क्यों नहीं उठाते हैं जो विभिन्न प्रकार के यादृच्छिक डेटा का उत्पादन कर सकता है:नाम, ईमेल, हिप्स्टर शब्द, "लोरेम इप्सम" टेक्स्ट, और बहुत कुछ।

जेमफाइल

group :development do
    gem 'faker'
end

मणि स्थापित करें:

bundle install

अब seeds.rb में बदलाव करें :

db/seeds.rb

5.times do
  user = User.create({name: Faker::Name.name})
  user.posts.create({title: Faker::Book.title, body: Faker::Lorem.sentence})
end

अंत में, अपना डेटा लोड करें:

rails db:seed

JSON के साथ प्रतिसाद करना

अब, निश्चित रूप से, हमें अपने एपीआई को तैयार करने के लिए कुछ मार्गों और नियंत्रकों की आवश्यकता है। एपीआई के मार्गों को api/ . के अंतर्गत घोंसला बनाना एक आम बात है रास्ता। साथ ही, डेवलपर आमतौर पर पथ में API का संस्करण प्रदान करते हैं, उदाहरण के लिए api/v1/ . बाद में, यदि कुछ महत्वपूर्ण परिवर्तन करने हैं, तो आप बस एक नया नाम स्थान बना सकते हैं (v2 ) और एक अलग नियंत्रक।

यहां बताया गया है कि आपके मार्ग कैसे दिख सकते हैं:

config/routes.rb

namespace 'api' do
    namespace 'v1' do
      resources :posts
      resources :users
    end
end

यह इस तरह के मार्ग उत्पन्न करता है:

api_v1_posts GET    /api/v1/posts(.:format)     api/v1/posts#index
             POST   /api/v1/posts(.:format)     api/v1/posts#create
 api_v1_post GET    /api/v1/posts/:id(.:format) api/v1/posts#show

आप एक scope . का उपयोग कर सकते हैं namespace . के बजाय विधि , लेकिन फिर डिफ़ॉल्ट रूप से यह UsersController . की तलाश करेगा और PostsController नियंत्रकों . के अंदर निर्देशिका, नियंत्रकों/api/v1 . के अंदर नहीं , इसलिए सावधान रहें।

एपीआई बनाएं नेस्टेड निर्देशिका के साथ फ़ोल्डर v1 नियंत्रकों . के अंदर . इसे अपने नियंत्रकों के साथ पॉप्युलेट करें:

नियंत्रक/api/v1/users_controller.rb

module Api
    module V1
        class UsersController < ApplicationController
        end
    end
end

नियंत्रक/api/v1/posts_controller.rb

module Api
    module V1
        class PostsController < ApplicationController
        end
    end
end

ध्यान दें कि आपको न केवल नियंत्रक की फ़ाइल को api/v1 . के अंतर्गत घोंसला बनाना है पथ, लेकिन कक्षा को भी Api . के अंदर नामित किया जाना है और V1 मॉड्यूल।

अगला प्रश्न यह है कि JSON-स्वरूपित डेटा के साथ ठीक से प्रतिक्रिया कैसे करें? इस लेख में हम इन समाधानों को आजमाएंगे:jBuilder और active_model_serializers रत्न। तो अगले भाग पर जाने से पहले, उन्हें Gemfile . में छोड़ दें :

जेमफाइल

gem 'jbuilder', '~> 2.5'
gem 'active_model_serializers', '~> 0.10.0'

फिर दौड़ें:

bundle install

जेबिल्डर जेम का उपयोग करना

jBuilder रेल टीम द्वारा अनुरक्षित एक लोकप्रिय रत्न है जो एक सरल DSL (डोमेन-विशिष्ट भाषा) प्रदान करता है जिससे आप अपने विचारों में JSON संरचनाओं को परिभाषित कर सकते हैं।

मान लीजिए कि जब कोई उपयोगकर्ता index . हिट करता है तो हम सभी पोस्ट प्रदर्शित करना चाहते हैं क्रिया:

नियंत्रक/api/v1/posts_controller.rb

 def index
    @posts = Post.order('created_at DESC')
end

आपको केवल .json.jbuilder के साथ संबंधित क्रिया के नाम पर दृश्य बनाना है विस्तार। ध्यान दें कि दृश्य को api/v1 . के अंतर्गत रखा जाना चाहिए पथ भी:

views/api/v1/posts/index.json.jbuilder

json.array! @posts do |post|
  json.id post.id
  json.title post.title
  json.body post.body
end

json.array! @posts . को पार करता है सरणी। json.id , json.title और json.body तर्कों को मानों के रूप में सेट करते हुए संबंधित नामों के साथ कुंजियाँ उत्पन्न करें। अगर आप https://localhost:3000/api/v1/posts.json पर नेविगेट करते हैं, तो आपको इसके जैसा आउटपुट दिखाई देगा:

[
    {"id": 1, "title": "Title 1", "body": "Body 1"},
    {"id": 2, "title": "Title 2", "body": "Body 2"}
]

क्या होगा अगर हम प्रत्येक पोस्ट के लिए लेखक को भी प्रदर्शित करना चाहते हैं? यह आसान है:

json.array! @posts do |post|
  json.id post.id
  json.title post.title
  json.body post.body
  json.user do
    json.id post.user.id
    json.name post.user.name
  end
end

आउटपुट में बदल जाएगा:

[
    {"id": 1, "title": "Title 1", "body": "Body 1", "user": {"id": 1, "name": "Username"}}
]

.jbuilder . की सामग्री फ़ाइलें सादा रूबी कोड है, इसलिए आप हमेशा की तरह सभी बुनियादी कार्यों का उपयोग कर सकते हैं।

ध्यान दें कि jBuilder किसी भी सामान्य रेल दृश्य की तरह आंशिक समर्थन करता है, इसलिए आप यह भी कह सकते हैं: 

json.partial! partial: 'posts/post', collection: @posts, as: :post

और फिर views/api/v1/posts/_post.json.jbuilder बनाएं निम्नलिखित सामग्री के साथ फाइल करें:

json.id post.id
json.title post.title
json.body post.body
json.user do
    json.id post.user.id
    json.name post.user.name
end

तो, जैसा कि आप देख सकते हैं, jBuilder आसान और सुविधाजनक है। हालाँकि, एक विकल्प के रूप में, आप धारावाहिकों के साथ रह सकते हैं, तो चलिए अगले भाग में उनकी चर्चा करते हैं।

सीरियलाइज़र का उपयोग करना

Rails_model_serializers रत्न एक टीम द्वारा बनाया गया था, जिसने शुरू में रेल-एपीआई को प्रबंधित किया था। जैसा कि दस्तावेज़ीकरण में बताया गया है, Rails_model_serializers आपकी JSON पीढ़ी में कॉन्फ़िगरेशन पर कन्वेंशन लाता है। मूल रूप से, आप परिभाषित करते हैं कि क्रमांकन (अर्थात, JSON पीढ़ी) पर किन क्षेत्रों का उपयोग किया जाना चाहिए।

यहाँ हमारा पहला धारावाहिक है:

serializers/post_serializer.rb

class PostSerializer < ActiveModel::Serializer
  attributes :id, :title, :body
end

यहां हम कहते हैं कि ये सभी क्षेत्र परिणामी JSON में मौजूद होने चाहिए। अब to_json . जैसी विधियां और as_json किसी पोस्ट को कॉल करने पर इस कॉन्फ़िगरेशन का उपयोग किया जाएगा और उचित सामग्री वापस कर दी जाएगी।

इसे क्रिया में देखने के लिए, index . को संशोधित करें इस तरह की कार्रवाई:

नियंत्रक/api/v1/posts_controller.rb

def index
    @posts = Post.order('created_at DESC')
    
    render json: @posts
end

as_json स्वचालित रूप से @posts . पर कॉल किया जाएगा वस्तु।

उपयोगकर्ताओं के बारे में क्या? सीरियलाइज़र आपको मॉडल की तरह ही संबंधों को इंगित करने की अनुमति देते हैं। इसके अलावा, धारावाहिकों को नेस्ट किया जा सकता है:

serializers/post_serializer.rb

class PostSerializer < ActiveModel::Serializer
  attributes :id, :title, :body
  belongs_to :user

  class UserSerializer < ActiveModel::Serializer
    attributes :id, :name
  end
end

अब जब आप पोस्ट को क्रमबद्ध करते हैं, तो उसमें स्वचालित रूप से नेस्टेड user शामिल हो जाएगा इसकी आईडी और नाम के साथ कुंजी। यदि बाद में आप उपयोगकर्ता के लिए :id . के साथ एक अलग धारावाहिक बनाते हैं विशेषता बहिष्कृत:

serializers/post_serializer.rb

class UserSerializer < ActiveModel::Serializer
    attributes :name
end

फिर @user.as_json उपयोगकर्ता की आईडी वापस नहीं करेगा। फिर भी, @post.as_json उपयोगकर्ता का नाम और आईडी दोनों लौटाएगा, इसलिए इसे ध्यान में रखें।

एपीआई सुरक्षित करना

कई मामलों में, हम नहीं चाहते कि कोई भी केवल API का उपयोग करके कोई कार्रवाई करे। तो चलिए एक साधारण सुरक्षा जांच पेश करते हैं और पोस्ट बनाते और हटाते समय हमारे उपयोगकर्ताओं को अपने टोकन भेजने के लिए बाध्य करते हैं।

टोकन का असीमित जीवन काल होगा और उपयोगकर्ता के पंजीकरण पर बनाया जाएगा। सबसे पहले, एक नया tokenजोड़ें users . के लिए कॉलम तालिका:

rails g migration add_token_to_users token:string:index

इस इंडेक्स को विशिष्टता की गारंटी देनी चाहिए क्योंकि एक ही टोकन वाले दो उपयोगकर्ता नहीं हो सकते:

db/migrate/xyz_add_token_to_users.rb

add_index :users, :token, unique: true

माइग्रेशन लागू करें:

rails db:migrate

अब before_save जोड़ें कॉलबैक:

मॉडल/user.rb

before_create -> {self.token = generate_token}

generate_token निजी विधि एक अंतहीन चक्र में एक टोकन बनाएगी और जांच करेगी कि यह अद्वितीय है या नहीं। जैसे ही एक अद्वितीय टोकन मिलता है, उसे वापस कर दें:

मॉडल/user.rb

private

def generate_token
    loop do
      token = SecureRandom.hex
      return token unless User.exists?({token: token})
    end
end

आप टोकन उत्पन्न करने के लिए किसी अन्य एल्गोरिदम का उपयोग कर सकते हैं, उदाहरण के लिए उपयोगकर्ता के नाम के MD5 हैश और कुछ नमक के आधार पर।

उपयोगकर्ता पंजीकरण

बेशक, हमें उपयोगकर्ताओं को पंजीकरण की अनुमति देने की भी आवश्यकता है, क्योंकि अन्यथा वे अपना टोकन प्राप्त करने में सक्षम नहीं होंगे। मैं अपने एप्लिकेशन में कोई HTML दृश्य नहीं देना चाहता, इसलिए इसके बजाय आइए एक नई API विधि जोड़ें:

नियंत्रक/api/v1/users_controller.rb

def create
    @user = User.new(user_params)
    if @user.save
      render status: :created
    else
      render json: @user.errors, status: :unprocessable_entity
    end
end

private

def user_params
    params.require(:user).permit(:name)
end

अर्थपूर्ण HTTP स्थिति कोड लौटाना एक अच्छा विचार है ताकि डेवलपर्स समझ सकें कि वास्तव में क्या हो रहा है। अब आप या तो उपयोगकर्ताओं के लिए एक नया धारावाहिक प्रदान कर सकते हैं या .json.jbuilder के साथ चिपका सकते हैं फ़ाइल। मैं बाद वाले संस्करण को पसंद करता हूं (इसीलिए मैं :json . पास नहीं करता हूं render . का विकल्प विधि), लेकिन आप उनमें से किसी को भी चुनने के लिए स्वतंत्र हैं। हालांकि, ध्यान दें कि टोकन नहीं होना चाहिए हमेशा क्रमबद्ध, उदाहरण के लिए जब आप सभी उपयोगकर्ताओं की सूची लौटाते हैं—तो इसे सुरक्षित रखा जाना चाहिए!

views/api/v1/users/create.json.jbuilder

json.id @user.id
json.name @user.name
json.token @user.token

अगला कदम यह जांचना है कि सब कुछ ठीक से काम कर रहा है या नहीं। आप या तो curl . का उपयोग कर सकते हैं कुछ रूबी कोड कमांड या लिखें। चूंकि यह लेख रूबी के बारे में है, इसलिए मैं कोडिंग विकल्प के साथ जाऊंगा।

उपयोगकर्ता के पंजीकरण का परीक्षण

HTTP अनुरोध करने के लिए, हम फैराडे रत्न का उपयोग करेंगे, जो कई एडेप्टर पर एक सामान्य इंटरफ़ेस प्रदान करता है (डिफ़ॉल्ट है Net::HTTP ) एक अलग रूबी फ़ाइल बनाएँ, फैराडे को शामिल करें, और क्लाइंट सेट करें:

api_client.rb

require 'faraday'

client = Faraday.new(url: 'https://localhost:3000') do |config|
  config.adapter  Faraday.default_adapter
end

response = client.post do |req|
  req.url '/api/v1/users'
  req.headers['Content-Type'] = 'application/json'
  req.body = '{ "user": {"name": "test user"} }'
end

ये सभी विकल्प बहुत ही आत्म-व्याख्यात्मक हैं:हम डिफ़ॉल्ट एडेप्टर चुनते हैं, अनुरोध URL को https://localhost:300/api/v1/users पर सेट करते हैं, सामग्री प्रकार को application/json में बदलते हैं। , और हमारे अनुरोध का मुख्य भाग प्रदान करें।

सर्वर की प्रतिक्रिया में JSON होगा, इसलिए इसे पार्स करने के लिए मैं Oj रत्न का उपयोग करूंगा:

api_client.rb

require 'oj'

# client here...

puts Oj.load(response.body)
puts response.status

पार्स की गई प्रतिक्रिया के अलावा, मैं डिबगिंग उद्देश्यों के लिए स्थिति कोड भी प्रदर्शित करता हूं।

अब आप बस इस स्क्रिप्ट को चला सकते हैं:

ruby api_client.rb

और प्राप्त टोकन को कहीं स्टोर करें—हम इसे अगले भाग में उपयोग करेंगे।

टोकन के साथ प्रमाणीकरण

टोकन प्रमाणीकरण लागू करने के लिए, authenticate_or_request_with_http_token विधि का प्रयोग किया जा सकता है। यह ActionController::HttpAuthentication::Token::ControllerMethods मॉड्यूल का एक हिस्सा है, इसलिए इसे शामिल करना न भूलें:

नियंत्रक/api/v1/posts_controller.rb 

class PostsController < ApplicationController
    include ActionController::HttpAuthentication::Token::ControllerMethods
    # ...
end

एक नया before_action जोड़ें और संबंधित विधि:

नियंत्रक/api/v1/posts_controller.rb 

before_action :authenticate, only: [:create, :destroy]

# ...

private

# ...

def authenticate
    authenticate_or_request_with_http_token do |token, options|
      @user = User.find_by(token: token)
    end
end

अब यदि टोकन सेट नहीं है या यदि इस तरह के टोकन वाला उपयोगकर्ता नहीं मिल सकता है, तो 401 त्रुटि लौटा दी जाएगी, कार्रवाई को निष्पादित करने से रोक दिया जाएगा।

ध्यान दें कि क्लाइंट और सर्वर के बीच संचार HTTPS पर किया जाना है, क्योंकि अन्यथा टोकन आसानी से खराब हो सकते हैं। बेशक, प्रदान किया गया समाधान आदर्श नहीं है, और कई मामलों में प्रमाणीकरण के लिए OAuth 2 प्रोटोकॉल का उपयोग करना बेहतर होता है। कम से कम दो रत्न हैं जो इस सुविधा का समर्थन करने की प्रक्रिया को बहुत सरल करते हैं:द्वारपाल और oPRO।

पोस्ट बनाना

हमारे प्रमाणीकरण को कार्य में देखने के लिए, create . जोड़ें PostsController . पर कार्रवाई :

नियंत्रक/api/v1/posts_controller.rb 

def create
    @post = @user.posts.new(post_params)
    if @post.save
        render json: @post, status: :created
    else
        render json: @post.errors, status: :unprocessable_entity
    end
end

उचित JSON प्रदर्शित करने के लिए हम यहां धारावाहिक का लाभ उठाते हैं। @user पहले से ही before_action . के अंदर सेट किया गया था ।

अब इस सरल कोड का उपयोग करके सब कुछ जांचें:

api_client.rb

client = Faraday.new(url: 'https://localhost:3000') do |config|
  config.adapter  Faraday.default_adapter
  config.token_auth('127a74dbec6f156401b236d6cb32db0d')
end

response = client.post do |req|
  req.url '/api/v1/posts'
  req.headers['Content-Type'] = 'application/json'
  req.body = '{ "post": {"title": "Title", "body": "Text"} }'
end

पारित तर्क को token_auth . में बदलें पंजीकरण पर प्राप्त टोकन के साथ, और स्क्रिप्ट चलाएँ।

ruby api_client.rb

पोस्ट हटाना

उसी तरह किसी पोस्ट को डिलीट किया जाता है। destroy जोड़ें क्रिया:

नियंत्रक/api/v1/posts_controller.rb 

def destroy
    @post = @user.posts.find_by(params[:id])
    if @post
      @post.destroy
    else
      render json: {post: "not found"}, status: :not_found
    end
end

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

इस नई सुविधा का परीक्षण करने के लिए कोड का अंश यहां दिया गया है:

api_client.rb

response = client.delete do |req|
  req.url '/api/v1/posts/6'
  req.headers['Content-Type'] = 'application/json'
end

पोस्ट की आईडी को उस नंबर से बदलें जो आपके लिए कारगर हो।

CORS सेट करना

यदि आप अन्य वेब सेवाओं को अपने एपीआई (क्लाइंट-साइड से) तक पहुँचने के लिए सक्षम करना चाहते हैं, तो CORS (क्रॉस-ओरिजिनल रिसोर्स शेयरिंग) को ठीक से सेट किया जाना चाहिए। मूल रूप से, CORS वेब अनुप्रयोगों को तृतीय-पक्ष सेवाओं के लिए AJAX अनुरोध भेजने की अनुमति देता है। सौभाग्य से, रैक-कॉर्स नामक एक रत्न है जो हमें सब कुछ आसानी से सेट करने में सक्षम बनाता है। इसे जेमफाइल . में जोड़ें :

जेमफाइल

gem 'rack-cors'

इसे स्थापित करें:

bundle install

और फिर config/initializers/cors.rb . के अंदर कॉन्फ़िगरेशन प्रदान करें फ़ाइल। दरअसल, यह फ़ाइल आपके लिए पहले से ही बनाई गई है और इसमें एक उपयोग उदाहरण है। आप रत्न के पृष्ठ पर कुछ विस्तृत दस्तावेज भी पा सकते हैं।

निम्न कॉन्फ़िगरेशन, उदाहरण के लिए, किसी को भी किसी भी विधि का उपयोग करके आपके API तक पहुंचने की अनुमति देगा:

config/initializers/cors.rb

Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
    origins '*'

    resource '/api/*',
      headers: :any,
      methods: [:get, :post, :put, :patch, :delete, :options, :head]
  end
end

दुरुपयोग को रोकना

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

रत्न को Gemfile . में छोड़ दें :

जेमफाइल

gem 'rack-attack'

इसे स्थापित करें:

bundle install

और फिर rack_attack.rb . के अंदर कॉन्फ़िगरेशन प्रदान करें प्रारंभकर्ता फ़ाइल। मणि का दस्तावेज़ीकरण सभी उपलब्ध विकल्पों को सूचीबद्ध करता है और कुछ उपयोग के मामलों का सुझाव देता है। यहां नमूना कॉन्फ़िगरेशन है जो आपके अलावा किसी को भी सेवा तक पहुंचने से प्रतिबंधित करता है और अनुरोधों की अधिकतम संख्या को 5 प्रति सेकंड तक सीमित करता है:

config/initializers/rack_attack.rb

class Rack::Attack
  safelist('allow from localhost') do |req|
    # Requests are allowed if the return value is truthy
    '127.0.0.1' == req.ip || '::1' == req.ip
  end

  throttle('req/ip', :limit => 5, :period => 1.second) do |req|
    req.ip
  end
end

एक और चीज जो करने की जरूरत है वह है रैकअटैक को एक मिडलवेयर के रूप में शामिल करना:

config/application.rb

config.middleware.use Rack::Attack

निष्कर्ष

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

अगर आपको कुछ अस्पष्ट लग रहा हो तो अपने प्रश्न पोस्ट करने में संकोच न करें। मेरे साथ बने रहने और कोडिंग के लिए मैं आपको धन्यवाद देता हूं!