R Academy · पाठ

प्रमाणीकरण और API सुरक्षा

API कुंजी सत्यापन, CORS हेडर और अनुरोध-दर सीमित करने वाले फ़िल्टर जोड़ें।

पाठ 3, कुल 4 में से13 चरण

प्रमाणीकरण और API सुरक्षा, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

API सुरक्षा क्यों महत्वपूर्ण है

Plumber API एक सार्वजनिक HTTP सर्वर होता है। प्रमाणीकरण के बिना, जो भी व्यक्ति उस पोर्ट तक पहुँच सकता है, वह आपके एंडपॉइंट को कॉल कर सकता है। सुरक्षा की परतों में प्रमाणीकरण (आप कौन हैं?), प्राधिकरण (आप क्या कर सकते हैं?), इनपुट सत्यापन और ट्रांसपोर्ट सुरक्षा शामिल हैं।

मिडलवेयर के रूप में Plumber फ़िल्टर

Plumber में फ़िल्टर रूट हैंडलर से पहले चलते हैं। प्रत्येक अनुरोध का निरीक्षण करने वाला मिडलवेयर जोड़ने के लिए pr_filter(name, function(req, res){...}) का उपयोग करें। अगले फ़िल्टर या रूट तक जाने के लिए plumber::forward() कॉल करें; अनुरोध अस्वीकार करने के लिए तुरंत लौटें।

# library(plumber)
# pr <- plumb('api.R')
# pr |>
#   pr_filter('logger', function(req, res) {
#     cat(req$REQUEST_METHOD, req$PATH_INFO, '
')
#     plumber::forward()  # must call to continue
#   }) |>
#   pr_run(port = 8000)

API कुंजी प्रमाणीकरण फ़िल्टर

सर्वर-से-सर्वर API के लिए सबसे सामान्य सरल प्रमाणीकरण तरीका हेडर में भेजी गई स्थिर API कुंजी है। फ़िल्टर प्रत्येक अनुरोध में हेडर की जाँच करता है और उसके अनुपस्थित या गलत होने पर 401 लौटाता है।

# In api.R:
# VALID_KEY <- Sys.getenv('API_SECRET_KEY')
#
# #* @filter auth
# function(req, res) {
#   key <- req$HTTP_X_API_KEY
#   if (is.null(key) || key != VALID_KEY) {
#     res$status <- 401L
#     return(list(error = 'Unauthorized'))
#   }
#   plumber::forward()
# }

Authorization हेडर की जाँच करना

Bearer टोकन Authorization: Bearer <token> हेडर में भेजे जाते हैं। इसे req$HTTP_AUTHORIZATION के माध्यम से प्राप्त करें। टोकन वाले भाग को निकालने के लिए strsplit() से पार्स करें, फिर अपने संग्रह के विरुद्ध उसका सत्यापन करें।

# #* @filter bearer_auth
# function(req, res) {
#   auth_header <- req$HTTP_AUTHORIZATION
#   if (is.null(auth_header) || !startsWith(auth_header, 'Bearer ')) {
#     res$status <- 401L
#     return(list(error = 'Bearer token required'))
#   }
#   token <- substring(auth_header, 8)  # strip 'Bearer '
#   if (!token_is_valid(token)) {
#     res$status <- 401L
#     return(list(error = 'Invalid token'))
#   }
#   plumber::forward()
# }

#* @preempt से प्रमाणीकरण छोड़ना

कुछ एंडपॉइंट (जैसे स्वास्थ्य जाँच और सार्वजनिक दस्तावेज़) को प्रमाणीकरण छोड़ देना चाहिए। जहाँ auth फ़िल्टर के नाम से मेल खाता हो, वहाँ उन्हें #* @preempt auth से एनोटेट करें। Plumber उस फ़िल्टर को छोड़कर अनुरोध को सीधे हैंडलर तक पहुँचाता है।

# #* Health check — no auth required
# #* @preempt auth
# #* @get /ping
# function() {
#   list(status = 'ok', time = as.character(Sys.time()))
# }
#
# #* Protected endpoint — goes through auth filter
# #* @get /data
# function() {
#   list(secret = 'sensitive data')
# }

pr_cors() के साथ CORS

यदि आपका API किसी दूसरे डोमेन के ब्राउज़र से कॉल किया जाता है, तो आपको CORS (क्रॉस-ओरिजिन रिसोर्स शेयरिंग) सक्षम करना होगा। कच्चे हेडर हाथ से लिखे बिना अनुमत ओरिजिन, विधियाँ और हेडर कॉन्फ़िगर करने के लिए pr_cors() का उपयोग करें।

# library(plumber)
# pr <- plumb('api.R')
# pr |>
#   pr_cors(
#     origin            = 'https://myapp.example.com',
#     methods           = c('GET', 'POST'),
#     headers           = c('Content-Type', 'X-API-Key'),
#     credentials       = TRUE
#   ) |>
#   pr_run(port = 8000)

इनपुट सैनिटाइज़ेशन — उपयोगकर्ता इनपुट पर कभी भरोसा न करें

क्वेरी या फ़ाइल संचालन में इनपुट का उपयोग करने से पहले हमेशा उसका सत्यापन और सैनिटाइज़ेशन करें:

  • प्रकार जाँचें: is.numeric(), is.character()
  • सीमा जाँचें: id >= 1 && id <= 1e9
  • अनपेक्षित वर्ण अस्वीकार करें: grepl('[^a-zA-Z0-9_]', name)
  • उपयोगकर्ता की स्ट्रिंग को सीधे SQL में कभी न डालें — पैरामीटरयुक्त क्वेरी का उपयोग करें
# #* @post /search
# function(req, res) {
#   body <- jsonlite::fromJSON(req$postBody)
#   query <- body$query
#   if (!is.character(query) || nchar(query) > 200) {
#     res$status <- 400L
#     return(list(error = 'query must be a string <= 200 chars'))
#   }
#   if (grepl('[;\'"]', query)) {
#     res$status <- 400L
#     return(list(error = 'Invalid characters in query'))
#   }
#   list(results = search_db(query))
# }

अनुरोध-दर सीमित करने की अवधारणाएँ

Plumber में अंतर्निहित अनुरोध-दर सीमक नहीं है, लेकिन अनुरोधों की संख्या को IP के अनुसार ट्रैक करने वाले साझा env का उपयोग करके फ़िल्टर में इसे लागू किया जा सकता है:

  • R env में प्रत्येक IP के अनुरोध का टाइमस्टैम्प रिकॉर्ड करें
  • यदि समय-खिड़की में संख्या सीमा से अधिक हो जाए, तो 429 के साथ अनुरोध अस्वीकार करें
  • उत्पादन परिवेश में अनुरोध-दर सीमित करने के लिए nginx जैसे रिवर्स प्रॉक्सी का उपयोग करें
# request_log <- new.env()
#
# #* @filter rate_limit
# function(req, res) {
#   ip <- req$REMOTE_ADDR
#   now <- as.numeric(Sys.time())
#   if (!exists(ip, envir = request_log)) assign(ip, c(), envir = request_log)
#   times <- get(ip, envir = request_log)
#   times <- times[times > now - 60]   # last 60 seconds
#   if (length(times) >= 60) { res$status <- 429L; return(list(error='Too Many Requests')) }
#   assign(ip, c(times, now), envir = request_log)
#   plumber::forward()
# }

API कुंजियों को सुरक्षित रूप से संग्रहित करना

स्रोत फ़ाइलों में सीक्रेट को कभी हार्डकोड न करें। उन्हें env में संग्रहित करें और स्टार्टअप पर Sys.getenv() से पढ़ें। स्थानीय रूप से .env फ़ाइल का उपयोग करें (इसे git से बाहर रखें) और उत्पादन में परिनियोजन env के माध्यम से सीक्रेट भेजें।

# In .env (never commit this file):
# API_SECRET_KEY=my_super_secret_key_here
#
# In api.R:
# VALID_KEY <- Sys.getenv('API_SECRET_KEY', unset = '')
# if (nchar(VALID_KEY) == 0) stop('API_SECRET_KEY not set')
#
# Load .env locally (devtools::load_dot_env or Sys.setenv):
# readRenviron('.env')
cat('Sys.getenv reads API keys without exposing them in source
')

अनुरोध में उपयोगकर्ता संदर्भ जोड़ना

प्रमाणीकरण फ़िल्टर में टोकन का सत्यापन करने के बाद, डिकोड की गई उपयोगकर्ता जानकारी को req ऑब्जेक्ट में जोड़ें, ताकि आगे के हैंडलर उसे दोबारा सत्यापन किए बिना उपयोग कर सकें। req में कस्टम फ़ील्ड पूरे फ़िल्टर चेन के दौरान बने रहते हैं।

# #* @filter auth
# function(req, res) {
#   token <- req$HTTP_AUTHORIZATION
#   user <- validate_token(token)  # returns list(id=1, role='admin')
#   if (is.null(user)) { res$status <- 401L; return(list(error='Unauthorized')) }
#   req$user <- user   # attach to request
#   plumber::forward()
# }
#
# #* @get /profile
# function(req) {
#   list(user_id = req$user$id, role = req$user$role)
# }

tryCatch के साथ त्रुटि प्रबंधन

अनपेक्षित त्रुटियों को पकड़ने और वर्कर के क्रैश होने या कॉल करने वाले को स्टैक ट्रेस दिखने के बजाय साफ़ 500 प्रतिक्रिया लौटाने के लिए अपने एंडपॉइंट लॉजिक को tryCatch() में लपेटें।

# #* @get /risky/<id:int>
# function(id, res) {
#   tryCatch({
#     result <- risky_db_call(id)
#     list(data = result)
#   }, error = function(e) {
#     message('Error in /risky: ', conditionMessage(e))
#     res$status <- 500L
#     list(error = 'Internal server error')
#   })
# }

त्वरित जाँच: @preempt एनोटेशन

#* @preempt auth एनोटेशन Plumber एंडपॉइंट के साथ क्या करता है?

API सुरक्षा का पुनरावलोकन

Plumber API को सुरक्षित करने में कई स्तरों वाली सुरक्षा शामिल होती है:

  • pr_filter('auth', ...) — मिडलवेयर में प्रत्येक अनुरोध का निरीक्षण करें
  • req$HTTP_AUTHORIZATION / req$HTTP_X_API_KEY — प्रमाणीकरण हेडर पढ़ें
  • #* @preempt auth — सार्वजनिक एंडपॉइंट के लिए प्रमाणीकरण छोड़ें
  • pr_cors() — ब्राउज़र की क्रॉस-ओरिजिन पहुँच कॉन्फ़िगर करें
  • किसी भी DB या फ़ाइल संचालन से पहले इनपुट का सत्यापन करें
  • सीक्रेट के लिए Sys.getenv() का उपयोग करें — कुंजियों को कभी हार्डकोड न करें
शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

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

पाठ्यक्रम
43
पाठ
159

अक्सर पूछे जाने वाले प्रश्न

क्या “प्रमाणीकरण और API सुरक्षा” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “प्रमाणीकरण और API सुरक्षा” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“प्रमाणीकरण और API सुरक्षा” में मैं क्या सीखूँगा?

API कुंजी सत्यापन, CORS हेडर और अनुरोध-दर सीमित करने वाले फ़िल्टर जोड़ें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“प्रमाणीकरण और API सुरक्षा” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. Plumber और REST का परिचय
  2. GET और POST एंडपॉइंट बनाना
  3. प्रमाणीकरण और API सुरक्षा
  4. Plumber API को उत्पादन में परिनियोजित करना
← R Academy पर वापस जाएँ