आजकल APIs (एप्लिकेशन प्रोग्रामिंग इंटरफेस) पर बहुत अधिक भरोसा करना एक आम बात है। न केवल फेसबुक और ट्विटर जैसी बड़ी सेवाएं उनका उपयोग करती हैं—APIs क्लाइंट-साइड फ्रेमवर्क जैसे React, Angular, और कई अन्य के प्रसार के कारण बहुत लोकप्रिय हैं। Ruby on Rails इस प्रवृत्ति का अनुसरण कर रहा है, और नवीनतम संस्करण API-ओनली एप्लिकेशन बनाने की अनुमति देने वाली एक नई सुविधा प्रस्तुत करता है।
प्रारंभ में यह कार्यक्षमता rails-api नामक एक अलग जेम में पैक की गई थी, लेकिन Rails 5 के रिलीज़ के बाद से, यह अब फ्रेमवर्क के कोर का हिस्सा है। ActionCable के साथ यह सुविधा शायद सबसे अधिक प्रत्याशित थी, और इसलिए आज हम इस पर चर्चा करने जा रहे हैं।
यह लेख कवर करता है कि API-ओनली Rails एप्लिकेशन कैसे बनाएं और बताता है कि अपने रूट्स और कंट्रोलर्स को कैसे संरचित करें, JSON प्रारूप के साथ प्रतिक्रिया दें, सीरियलाइज़र जोड़ें, और CORS (क्रॉस-ओरिजिन रिसोर्स शेयरिंग) सेट अप करें। आप API को सुरक्षित करने और इसे दुरुपयोग से बचाने के कुछ विकल्पों के बारे में भी जानेंगे।
इस लेख का स्रोत GitHub पर उपलब्ध है।
API-ओनली एप्लिकेशन बनाना
शुरू करने के लिए, निम्न कमांड चलाएं:
rails new RailsApiDemo --api
यह RailsApiDemo नामक एक नया API-ओनली Rails एप्लिकेशन बनाने जा रहा है। यह न भूलें कि --api विकल्प के लिए समर्थन केवल Rails 5 में जोड़ा गया था, इसलिए सुनिश्चित करें कि आपके पास यह या नया संस्करण इंस्टॉल है।
Gemfile खोलें और ध्यान दें कि यह सामान्य से बहुत छोटा है: coffee-rails, turbolinks, और sass-rails जैसे जेम चले गए हैं।
config/application.rb फ़ाइल में एक नई लाइन है:
config.api_only = true
इसका मतलब है कि Rails मिडलवेयर का एक छोटा सेट लोड करने जा रहा है: उदाहरण के लिए, कुकीज़ और सत्रों के लिए कोई समर्थन नहीं है। इसके अलावा, यदि आप स्कैफोल्ड जनरेट करने का प्रयास करते हैं, तो व्यू और एसेट्स नहीं बनाए जाएंगे। वास्तव में, यदि आप views/layouts निर्देशिका की जांच करते हैं, तो आप देखेंगे कि application.html.erb फ़ाइल भी गायब है।
एक और महत्वपूर्ण अंतर यह है कि ApplicationController ActionController::Base के बजाय ActionController::API से विरासत में मिलता है।
यह बहुत अधिक है—कुल मिलाकर, यह एक बुनियादी Rails एप्लिकेशन है जिसे आपने कई बार देखा है। अब कुछ मॉडल जोड़ते हैं ताकि हमारे पास काम करने के लिए कुछ हो:
rails g model User name:string rails g model Post title:string body:text user:belongs_to rails db:migrate
यहां कुछ खास नहीं हो रहा है: एक शीर्षक और बॉडी वाली पोस्ट एक उपयोगकर्ता से संबंधित है।
सुनिश्चित करें कि उचित एसोसिएशन सेट अप हैं और कुछ सरल वैलिडेशन चेक भी प्रदान करें:
models/user.rb
has_many :posts validates :name, presence: true
models/post.rb
belongs_to :user validates :title, presence: true validates :body, presence: true
शानदार! अगला कदम नवनिर्मित टेबल में कुछ नमूना रिकॉर्ड लोड करना है।
डेमो डेटा लोड करना
कुछ डेटा लोड करने का सबसे आसान तरीका db निर्देशिका के अंदर seeds.rb फ़ाइल का उपयोग करना है। हालांकि, मैं आलसी हूं (जैसा कि कई प्रोग्रामर होते हैं) और किसी नमूना सामग्री के बारे में सोचना नहीं चाहता। इसलिए, क्यों न faker जेम का लाभ उठाया जाए जो विभिन्न प्रकार के यादृच्छिक डेटा उत्पन्न कर सकता है: नाम, ईमेल, हिप्स्टर शब्द, "लोरम इप्सम" टेक्स्ट, और बहुत कुछ।
Gemfile
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/ पथ के तहत नेस्ट करना एक आम बात है। साथ ही, डेवलपर्स आमतौर पर पथ में 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
आप namespace के बजाय scope विधि का उपयोग कर सकते हैं, लेकिन तब डिफ़ॉल्ट रूप से यह controllers निर्देशिका के अंदर UsersController और PostsController की तलाश करेगा, controllers/api/v1 के अंदर नहीं, इसलिए सावधान रहें।
controllers के अंदर नेस्टेड डायरेक्टरी v1 के साथ api फोल्डर बनाएं। इसे अपने कंट्रोलर्स से भरें:
controllers/api/v1/users_controller.rb
module Api
module V1
class UsersController < ApplicationController
end
end
end
controllers/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 में डालें:
Gemfile
gem 'jbuilder', '~> 2.5' gem 'active_model_serializers', '~> 0.10.0'
फिर चलाएं:
bundle install
jBuilder जेम का उपयोग करना
jBuilder Rails टीम द्वारा अनुरक्षित एक लोकप्रिय जेम है जो एक सरल DSL (डोमेन-स्पेसिफिक लैंग्वेज) प्रदान करता है जो आपको अपने व्यू में JSON संरचनाओं को परिभाषित करने की अनुमति देता है।
मान लीजिए हम सभी पोस्ट प्रदर्शित करना चाहते थे जब कोई उपयोगकर्ता index एक्शन को हिट करता है:
controllers/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 फ़ाइलों की सामग्री सादा Ruby कोड है, इसलिए आप हमेशा की तरह सभी बुनियादी ऑपरेशन का उपयोग कर सकते हैं।
ध्यान दें कि jBuilder किसी भी सामान्य Rails व्यू की तरह पार्शियल का समर्थन करता है, इसलिए आप यह भी कह सकते हैं:
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-api का प्रबंधन किया था। दस्तावेज़ीकरण में कहा गया है कि rails_model_serializers आपके JSON जनरेशन में कन्वेंशन ओवर कॉन्फ़िगरेशन लाता है। मूल रूप से, आप परिभाषित करते हैं कि सीरियलाइज़ेशन (यानी, JSON जनरेशन) पर किन फ़ील्ड का उपयोग किया जाना चाहिए।
यहां हमारा पहला सीरियलाइज़र है:
serializers/post_serializer.rb
class PostSerializer < ActiveModel::Serializer attributes :id, :title, :body end
यहां हम कहते हैं कि इन सभी फ़ील्ड को परिणामी JSON में मौजूद होना चाहिए। अब to_json और as_json जैसी विधियाँ जब किसी पोस्ट पर कॉल की जाती हैं, तो इस कॉन्फ़िगरेशन का उपयोग करेंगी और उचित सामग्री वापस करेंगी।
इसे क्रिया में देखने के लिए, index एक्शन को इस तरह संशोधित करें:
controllers/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/user_serializer.rb
class UserSerializer < ActiveModel::Serializer attributes :name end
तब @user.as_json उपयोगकर्ता की आईडी वापस नहीं करेगा। फिर भी, @post.as_json उपयोगकर्ता का नाम और आईडी दोनों वापस करेगा, इसलिए इसे ध्यान में रखें।
API को सुरक्षित करना
कई मामलों में, हम नहीं चाहते कि कोई भी API का उपयोग करके कोई भी कार्रवाई करे। तो आइए एक सरल सुरक्षा जांच पेश करें और अपने उपयोगकर्ताओं को पोस्ट बनाते और हटाते समय अपने टोकन भेजने के लिए मजबूर करें।
टोकन की असीमित जीवन अवधि होगी और उपयोगकर्ता के पंजीकरण पर बनाया जाएगा। सबसे पहले, users टेबल में एक नया token कॉलम जोड़ें:
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 कॉलबैक जोड़ें:
models/user.rb
before_create -> { self.token = generate_token }
generate_token प्राइवेट विधि एक अंतहीन चक्र में एक टोकन बनाएगी और जांचेगी कि यह अद्वितीय है या नहीं। जैसे ही एक अद्वितीय टोकन मिल जाता है, इसे वापस करें:
models/user.rb
private
def generate_token
loop do
token = SecureRandom.hex
return token unless User.exists?({token: token})
end
end
आप टोकन उत्पन्न करने के लिए एक और एल्गोरिदम का उपयोग कर सकते हैं, उदाहरण के लिए उपयोगकर्ता के नाम और कुछ सॉल्ट के MD5 हैश पर आधारित।
उपयोगकर्ता पंजीकरण
बेशक, हमें उपयोगकर्ताओं को पंजीकरण करने की अनुमति देने की भी आवश्यकता है, क्योंकि अन्यथा वे अपना टोकन प्राप्त नहीं कर पाएंगे। मैं अपने एप्लिकेशन में कोई HTML व्यू पेश नहीं करना चाहता, इसलिए इसके बजाय एक नई API विधि जोड़ते हैं:
controllers/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 फ़ाइल के साथ रह सकते हैं। मैं बाद वाले संस्करण को पसंद करता हूं (इसलिए मैं render विधि को :json विकल्प पास नहीं करता), लेकिन आप उनमें से किसी को भी चुनने के लिए स्वतंत्र हैं। ध्यान दें, हालांकि, कि टोकन को हमेशा सीरियलाइज़ नहीं किया जाना चाहिए, उदाहरण के लिए जब आप सभी उपयोगकर्ताओं की सूची वापस करते हैं—इसे सुरक्षित रखा जाना चाहिए!
views/api/v1/users/create.json.jbuilder
json.id @user.id json.name @user.name json.token @user.token
अगला कदम यह जांचना है कि सब कुछ ठीक से काम कर रहा है। आप या तो curl कमांड का उपयोग कर सकते हैं या कुछ Ruby कोड लिख सकते हैं। चूंकि यह लेख Ruby के बारे में है, मैं कोडिंग विकल्प के साथ जाऊंगा।
उपयोगकर्ता के पंजीकरण का परीक्षण
HTTP अनुरोध करने के लिए, हम Faraday जेम का उपयोग करेंगे, जो कई एडाप्टर्स (डिफ़ॉल्ट Net::HTTP है) पर एक सामान्य इंटरफ़ेस प्रदान करता है। एक अलग Ruby फ़ाइल बनाएं, Faraday शामिल करें, और क्लाइंट सेट अप करें:
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 मॉड्यूल का एक हिस्सा है, इसलिए इसे शामिल करना न भूलें:
controllers/api/v1/posts_controller.rb
class PostsController < ApplicationController include ActionController::HttpAuthentication::Token::ControllerMethods # ... end
एक नया before_action और संबंधित विधि जोड़ें:
controllers/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 प्रोटोकॉल का उपयोग करना बेहतर होता है। कम से कम दो जेम हैं जो इस सुविधा का समर्थन करने की प्रक्रिया को बहुत सरल बनाते हैं: Doorkeeper और oPRO।
पोस्ट बनाना
हमारे प्रमाणीकरण को क्रिया में देखने के लिए, PostsController में create एक्शन जोड़ें:
controllers/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 एक्शन जोड़ें:
controllers/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 सेट करना
यदि आप अन्य वेब सेवाओं को अपने API तक पहुंचने में सक्षम बनाना चाहते हैं (क्लाइंट-साइड से), तो CORS (क्रॉस-ओरिजिन रिसोर्स शेयरिंग) को ठीक से सेट अप किया जाना चाहिए। मूल रूप से, CORS वेब एप्लिकेशन को थर्ड-पार्टी सेवाओं पर AJAX अनुरोध भेजने की अनुमति देता है। सौभाग्य से, rack-cors नामक एक जेम है जो हमें सब कुछ आसानी से सेट अप करने में सक्षम बनाता है। इसे Gemfile में जोड़ें:
Gemfile
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
दुरुपयोग रोकना
इस गाइड में मैं जिस आखिरी चीज का उल्लेख करने जा रहा हूं वह है अपने API को दुरुपयोग और डिनायल ऑफ सर्विस हमलों से कैसे बचाया जाए। rack-attack नामक एक अच्छा जेम है (किकस्टार्टर के लोगों द्वारा बनाया गया) जो आपको क्लाइंट को ब्लैकलिस्ट या व्हाइटलिस्ट करने, सर्वर को अनुरोधों से भरने से रोकने, और बहुत कुछ करने की अनुमति देता है।
जेम को Gemfile में डालें:
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
एक और चीज जो करने की आवश्यकता है वह है RackAttack को मिडलवेयर के रूप में शामिल करना:
config/application.rb
config.middleware.use Rack::Attack
निष्कर्ष
हम इस लेख के अंत में आ गए हैं। उम्मीद है, अब तक आप Rails के साथ API बनाने के बारे में अधिक आत्मविश्वास महसूस करते हैं! ध्यान दें कि यह एकमात्र उपलब्ध विकल्प नहीं है—एक और लोकप्रिय समाधान जो काफी समय से मौजूद है वह है Grape फ्रेमवर्क, इसलिए आप इसे भी देखना चाह सकते हैं।
यदि कुछ अस्पष्ट लगा तो अपने प्रश्न पोस्ट करने में संकोच न करें। मेरे साथ बने रहने के लिए धन्यवाद, और हैप्पी कोडिंग!
