JSON वेब टोकन के साथ फ्लास्क रेस्ट एपीआई कैसे सुरक्षित करें?

आइए जानें कि उपयोगकर्ताओं और तृतीय-पक्ष एप्लिकेशन को दुरुपयोग से रोकने के लिए JSON वेब टोकन के साथ REST API को कैसे सुरक्षित किया जाए.


हम एक डेटाबेस सेवा का उपयोग कर निर्माण करेंगे SQLite और उपयोगकर्ताओं को POST और PUT जैसे HTTP तरीकों का उपयोग करके REST API के माध्यम से इसे एक्सेस करने की अनुमति दें.

इसके अलावा, हमें पता चल जाएगा कि JSON वेब टोकन पाचन और बुनियादी प्रमाणीकरण के बजाय बाकी एपीआई की सुरक्षा के लिए एक उपयुक्त तरीका क्यों है। आगे बढ़ने से पहले, JSON वेब टोकन, REST API और फ्लास्क फ्रेमवर्क को समझें.

JSON वेब कैम

JSON वेब टोकन, के रूप में भी जाना जाता है जेडब्ल्यूटी, दो पार्टियों या संस्थाओं के बीच यादृच्छिक टोकन को स्थानांतरित करने का सुरक्षित तरीका है। JSON आमतौर पर निम्न के रूप में तीन भागों से बना होता है.

  • पेलोड
  • हैडर
  • हस्ताक्षर

JSON दो पक्षों के बीच डेटा या सूचना स्थानांतरित करते समय दो प्रकार के संरचना रूपों का उपयोग करता है.

  • धारावाहिक
  • deserialized

क्रमबद्ध रूप का उपयोग तब किया जाता है जब डेटा को प्रत्येक अनुरोध और प्रतिक्रिया के माध्यम से नेटवर्क में स्थानांतरित किया जाता है जबकि वेब टोकन पर डेटा को पढ़ने और लिखने के दौरान डीरिशियल रूप का उपयोग किया जाता है।.

क्रमबद्ध रूप में, तीन घटक होते हैं.

  • हैडर
  • पेलोड
  • हस्ताक्षर

हेडर घटक टोकन के बारे में क्रिप्टोग्राफिक जानकारी को परिभाषित करता है। उदाहरण के लिए:

  • क्या यह JWT हस्ताक्षरित या अहस्ताक्षरित है?
  • एल्गोरिथ्म तकनीकों को परिभाषित करें

निर्विवाद रूप, क्रमबद्ध रूप के विपरीत, दो घटक होते हैं.

  • पेलोड
  • हैडर

बाकी एपीआई

एपीआई (एप्लिकेशन प्रोग्रामिंग इंटरफ़ेस) डेटा को पुनः प्राप्त या सबमिट करने के लिए दो अनुप्रयोगों के बीच संचार की अनुमति देता है। एपीआई के दो लोकप्रिय प्रकार हैं – वेब और सिस्टम एपीआई.

इस लेख में, हम केवल वेब एपीआई को देखेंगे। वेब एपीआई दो प्रकार के होते हैं.

  • अनुरोध – रिस्पांस एपीआई: रेस्ट, ग्राफकैल, रिमोट प्रोसिजर कॉल (RPC)
  • ईवेंट-चालित एपीआई: वेबहूक, वेब सॉकेट, एचटीटीपी स्ट्रीमिंग

REST API अनुरोध-प्रतिक्रिया श्रेणी के अंतर्गत आता है। यह एपीआई संचालन करने के लिए HTTP विधियों जैसे GET, POST और PUT का उपयोग करता है.

एक क्लासिक उदाहरण तब होता है जब कोई उपयोगकर्ता किसी विशिष्ट संसाधन या संसाधनों के संग्रह के लिए अनुरोध करने या पुनः प्राप्त करने के लिए वेब सेवा को एक GET विधि भेजता है। सर्वर फिर विशिष्ट संसाधन या संसाधनों का संग्रह उपयोगकर्ता को वापस भेजता है जिसने यह अनुरोध किया था.

फ्लास्क फ्रेमवर्क

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

आइए इसे लागू करने के साथ आरंभ करें। मेरा सिस्टम सेटअप निम्नानुसार है.

  • उबुन्टू ओएस के रूप में
  • पायथन 2.7+
  • डाकिया

Virtualenv का उपयोग करके एक आभासी वातावरण सेट करें

हमें यह सुनिश्चित करने के लिए एक आभासी वातावरण स्थापित करने की आवश्यकता है कि कुछ पैकेज सिस्टम पैकेजों के साथ संघर्ष नहीं करेंगे। नए वर्चुअल वातावरण सेट करने के लिए virtualenv का उपयोग करें.

मान लें कि आपके पास आपके सिस्टम पर पाइप कमांड उपलब्ध है, स्थापित करने के लिए पाइप के माध्यम से निम्न कमांड चलाएं.

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

यदि आपकी मशीन पर पाइप नहीं है, तो इसका अनुसरण करें प्रलेखन अपने सिस्टम पर पाइप स्थापित करने के लिए.

इसके बाद, अपने वर्चुअल वातावरण को स्टोर या होल्ड करने के लिए एक डायरेक्टरी बनाएं। निर्देशिका बनाने के लिए नीचे दिखाए गए mkdir कमांड का उपयोग करें

mkdir फ्लास्कप्रोजेक्ट

निम्न कमांड का उपयोग करके फ्लास्कप्रोजेक्ट डायरेक्टरी में बदलें

सीडी फ्लास्कप्रोजेक्ट

फ्लास्कप्रोजेक्ट डायरेक्टरी के अंदर, वर्चुअल वातावरण बनाने के लिए virtualenv टूल का उपयोग करें जैसा कि नीचे दिखाया गया है:

वर्सेनव फ्लैस्कापी

वर्चुअल वातावरण बनाने के लिए आपने virtualenv टूल का उपयोग करने के बाद, cd कमांड को फ्लास्कापी निर्देशिका में वर्चुअल वातावरण के रूप में बदलने के लिए चलाया है और नीचे दिए गए कमांड का उपयोग करके इसे सक्रिय करें.

source बिन / सक्रिय

आभासी पर्यावरण के भीतर इस परियोजना से संबंधित सभी कार्यों को निष्पादित करें.

पाइप का उपयोग करके पैकेज स्थापित करें

अब फ्लास्क फ्रेमवर्क और PyJWT जैसे पैकेजों को स्थापित करने का समय है, जिसका उपयोग हम अपने एपीआई प्रोजेक्ट के लिए बाकी एपीआई और अन्य आवश्यक पैकेजों का निर्माण करने के लिए करेंगे।.

निम्नलिखित पैकेज के साथ एक आवश्यकताएँ बनाएँ। फ़ाइल.

कुप्पी
दिनांक और समय
UUID
कुप्पी के SQLAlchemy
PyJWT

उन्हें पाइप से स्थापित करें.

पाइप स्थापित करें -r आवश्यकताएँ

एक डेटाबेस सेट करें

SQLite स्थापित करें.

apt-get install sqlite3

लाइब्रेरी नाम का एक डेटाबेस बनाएं। इस डेटाबेस के अंदर, हम दो टेबल बनाएंगे, अर्थात् उपयोगकर्ता और लेखक तालिका.

उपयोगकर्ता तालिका में पंजीकृत उपयोगकर्ता होंगे। केवल पंजीकृत उपयोगकर्ता ही लेखक तालिका तक पहुँच सकते हैं.

लेखक तालिका लेखक की जानकारी या विवरण जैसे लेखक का नाम, जन्म का देश और पंजीकृत उपयोगकर्ताओं द्वारा प्रस्तुत की गई चीजों को संग्रहीत करेगी.

निम्नलिखित कमांड का उपयोग करके डेटाबेस बनाएं:

sqlite3 Library.db

आप नीचे दिए गए आदेश का उपयोग करके जाँच कर सकते हैं कि आपने डेटाबेस सफलतापूर्वक बनाया है या नहीं:

.डेटाबेस

एक नया टर्मिनल खोलें और हमारे द्वारा पहले बनाए गए आभासी वातावरण में निम्नलिखित को निष्पादित करें.

app.py स्पर्श करें

निम्न कोड को app.py नाम की फाइल के अंदर पेस्ट करें

फ्लास्क आयात से फ्लास्क, अनुरोध, jsonify, make_response
flask_sqlalchemy से SQLAlchemy आयात करें
werkzeug.security import generate_password_hash, check_password_hash से
आयात uuid
आयात jwt
आयात डेटाइम
फंक्शनलबल्स आयात से लपेटता है

अनुरोध और jsonify जैसे आयात पैकेज के ऊपर कोड में पहली पंक्ति। हम अनुरोध के दौरान अनुरोध-स्तर के डेटा का ट्रैक रखने के लिए अनुरोध का उपयोग करेंगे और एक में आउटपुट प्रतिक्रियाओं के लिए jsonify का उपयोग करेंगे JSON प्रारूप.

अगली पंक्ति में, हमने SQLAlchemy को फ्लास्क में एकीकृत करने के लिए, flask_sqlalchemy से SQLAlchemy को आयात किया।.

डेटाबेस में संग्रहीत उपयोगकर्ताओं के पासवर्ड के साथ उपयोगकर्ताओं द्वारा प्रस्तुत पासवर्ड की तुलना करते समय, werkzeug.security से हमने उपयोगकर्ताओं के लिए पासवर्ड हैश और check_password_hash उत्पन्न करने के लिए generate_password_hash आयात किया।.

अंत में, हमने उपयोगकर्ताओं के लिए रैंडम आईडी नंबर जेनरेट करने के लिए यूनिवर्सल यूनीक आइडेंटिफायर के रूप में जाना जाने वाला यूआईडी आयात किया.

फिर भी, app.py फ़ाइल के अंदर, App API फ़ाइल के अंदर कोड का उपयोग करके लाइब्रेरी API के लिए कॉन्फ़िगरेशन सेटिंग्स लागू करें.

आयात कथन के नीचे निम्नलिखित कोड रखें.

ऐप = फ्लास्क (__ name__)

app.config [ ‘SECRET_KEY’] = ‘Th1s1ss3cr3t’
app.config [ ‘SQLALCHEMY_DATABASE_URI’] = ‘SQLite: /////home/michael/geekdemos/geekapp/library.db’
app.config [‘SQLALCHEMY_TRACK_MODIFICATIONS’] = सत्य

db = SQLAlchemy (ऐप)

अब नीचे दिखाए गए अनुसार उपयोगकर्ता और लेखक तालिका के लिए दो मॉडल बनाएं। कोड को app.py फ़ाइल के अंदर कॉपी और पेस्ट करें.

इस डेटाबेस को db = SQLAlchemy (एप्लिकेशन) के ठीक नीचे नीचे कोड रखें

वर्ग उपयोगकर्ता (db.Model):
id = db.Column (db.Integer, Primary_key = True)
public_id = db.Column (db.Integer)
नाम = db.Column (db.String (50))
पासवर्ड = db.Column (db.String (50))
व्यवस्थापन = db.Column (db.Boolean)
वर्ग लेखक (db.Model):
id = db.Column (db.Integer, Primary_key = True)
नाम = db.Column (db.String (50), अद्वितीय = सत्य, अशक्त = गलत)
पुस्तक = db.Column (db.String (20), अद्वितीय = सत्य, अशक्त = गलत)
देश = db.Column (db.String (50), nullable = False))
booker_prize = db.Column (db.Boolean)

उपयोगकर्ता और लेखक तालिकाएँ बनाएँ

टर्मिनल पर, नीचे दिखाए गए अनुसार दोनों उपयोगकर्ताओं और लेखकों की तालिकाओं के लिए तालिकाओं को बनाने या बनाने के लिए वर्चुअल वातावरण के अंदर निम्न कोड टाइप करें

एप्लिकेशन आयात डीबी से
db.create_all ()

बाद में, वर्चुअल वातावरण के अंदर app.py फ़ाइल खोलें और एक अन्य फ़ंक्शन बनाएं.

यह फ़ंक्शन केवल पंजीकृत उपयोगकर्ताओं को लेखकों की तालिका के विरुद्ध API ऑपरेशन के सेट तक पहुंचने और प्रदर्शन करने की अनुमति देने के लिए टोकन उत्पन्न करेगा.

इस कोड को लेखक तालिका के डेटाबेस मॉडल के नीचे रखें

token_required (f) को हराया:
@wraps (च)
डी डेकोरेटर (* आर्ग्स, ** क्वार्ग्स):

टोकन = कोई नहीं

यदि अनुरोध में ‘x-access-tokens’ है। हेडर:
टोकन = request.headers [‘x-access-tokens’]

यदि टोकन नहीं है:
वापसी jsonify ({‘संदेश’: ‘एक वैध टोकन गायब है’))

प्रयत्न:
डेटा = jwt.decode (टोकन, app.config [SECRET_KEY])
current_user = Users.query.filter_by (public_id = data [‘public_id’]]) (पहले)
के सिवाय:
वापसी jsonify ({‘संदेश’: ‘टोकन अमान्य है’})

वापसी f (करेंट_उज़र, * आर्ग्स, ** क्वार्ग्स)
डेकोरेटर

उपयोगकर्ता तालिका के लिए मार्ग बनाएँ

अब उपयोगकर्ताओं को नीचे दिखाए गए अनुसार उपयोगकर्ता नाम और पासवर्ड के माध्यम से लेखक एपीआई के लिए पंजीकरण करने की अनुमति देने के लिए एक मार्ग बनाएं.

फिर से वर्चुअल वातावरण के अंदर app.py फ़ाइल खोलें और निम्नलिखित कोड को token_required (f) के नीचे पेस्ट करें

@ app.route (‘/ register’, तरीके = [‘GET’, ‘POST’]]
def sign__user ():
डेटा = request.get_json ()

hashed_password = generate_password_hash (डेटा [‘पासवर्ड’], विधि = ‘sha256’)

new_user = उपयोगकर्ता (public_id = str (uuid.uuid4 ()), नाम = डेटा [‘नाम’], पासवर्ड = hashed_password, admin = गलत)
db.session.add (new_user)
db.session.commit ()

वापसी jsonify ({‘संदेश’: ‘सफलतापूर्वक पंजीकृत’})

वर्चुअल वातावरण के अंदर, पंजीकृत उपयोगकर्ताओं को लॉगिन करने की अनुमति देने के लिए ऐप-थ्रो फ़ाइल में एक और मार्ग बनाते हैं.

जब कोई उपयोगकर्ता लॉग इन करता है, तो लाइब्रेरी एपीआई तक पहुंचने के लिए उपयोगकर्ता के लिए एक यादृच्छिक टोकन उत्पन्न होता है.

हमारे द्वारा बनाए गए पिछले मार्ग के नीचे दिए गए कोड को चिपकाएँ.

@ app.route (‘/ लॉगिन’, विधियाँ = [‘GET’, ‘POST’]]
def login_user ():

विशेषाधिकार = request.authorization

यदि नहीं या तो नहीं है।
वापसी make_response (‘सत्यापित नहीं हो सका’, 401, {‘WWW.Authentication’: ‘मूल क्षेत्र: "लॉगिन आवश्यक"’})

user = Users.query.filter_by (नाम = dif.username) .first ()।

अगर check_password_hash (user.password, dif.password):
टोकन = jwt.encode ({‘public_id’: user.public_id, ‘exp’: datetime.datetime.utcnow () + datetime.timedelta (मिनट = 30)}, app.config [‘SECRET_KEY’]]
वापसी jsonify ({‘token’: token.decode (‘UTF-8’)})

वापसी make_response (‘सत्यापित नहीं हो सका’, 401, {‘WWW.Authentication’: ‘मूल क्षेत्र: "लॉगिन आवश्यक"’})

फिर भी, आभासी वातावरण के भीतर, सभी पंजीकृत उपयोगकर्ताओं को प्राप्त करने या पुनः प्राप्त करने के लिए ऐप-थ्रो फ़ाइल में एक और मार्ग बनाएँ.

यह कोड उपयोगकर्ता तालिका में सभी पंजीकृत उपयोगकर्ताओं के लिए जाँच करता है और JSON प्रारूप में अंतिम परिणाम देता है.

लॉगिन मार्ग के नीचे कोड पेस्ट करें

@ app.route (‘/ users’, तरीके = [‘GET’]]
def get_all_users ():

उपयोगकर्ता = Users.query.all ()

परिणाम = []

उपयोगकर्ताओं में उपयोगकर्ता के लिए:
user_data = {}
user_data [‘public_id’] = user.public_id
user_data [‘नाम’] = user.name
user_data [‘पासवर्ड’] = user.password
user_data [‘admin’] = user.admin

result.append (user_data)

वापसी jsonify ({‘उपयोगकर्ता ’: परिणाम})

लेखकों की तालिका के लिए मार्ग बनाएँ 

उपयोगकर्ताओं को डेटाबेस में सभी लेखकों को पुनः प्राप्त करने की अनुमति देने के लिए लेखक तालिका के लिए मार्ग बनाएं, साथ ही लेखकों को हटा दें.

केवल मान्य टोकन वाले उपयोगकर्ता ही ये API ऑपरेशन कर सकते हैं.

App.py फ़ाइल के अंदर, नए लेखक बनाने के लिए पंजीकृत उपयोगकर्ताओं के लिए एक मार्ग बनाएँ.

मार्ग के नीचे इस कोड को चिपकाएं जो उपयोगकर्ता को सभी पंजीकृत उपयोगकर्ताओं को पुनः प्राप्त करने की अनुमति देता है.

@ app.route (‘/ लेखक’, विधियाँ = [‘पोस्ट’, ‘गेट’]]
@token_required
def create_author (current_user):

डेटा = request.get_json ()

new_authors = लेखक (नाम = डेटा [‘नाम’], देश = डेटा [‘देश’], पुस्तक = डेटा [‘पुस्तक’], booker_prize = True, user_id = current_user.id)
db.session.add (new_authors)
db.session.commit ()

वापसी jsonify ({‘संदेश’: ‘नया लेखक बनाया’})

अगला, किसी अन्य पंजीकृत उपयोगकर्ता को ऑथर्स तालिका में सभी लेखकों को पुनः प्राप्त करने के लिए एक वैध टोकन के साथ अनुमति देने के लिए एक और मार्ग बनाएं जैसा कि नीचे दिखाया गया है.

मार्ग के नीचे इस कोड को पेस्ट करें जो उपयोगकर्ता को एक नया लेखक बनाने की अनुमति देता है.

@ app.route (‘/ लेखक’, तरीके = [‘पोस्ट’, ‘गेट’]]
@token_required
def get_authors (current_user):

लेखक = लेखक.क्वेरी.फ़िल्टर_बाय (user_id = current_user.id) .all ()

उत्पादन = []
लेखकों में लेखक के लिए:

Author_data = {}
author_data [‘name’] = author.name
author_data [‘book’] = author.book
author_data [‘देश’] = author.country
author_data [‘booker_prize’] = author.booker_prize
output.append (author_data)

वापसी jsonify ({‘list_of_authors’: output})

अंत में, अभी भी app.py फ़ाइल के अंदर, एक निर्दिष्ट लेखक को हटाने के लिए एक मार्ग बनाएं जैसा कि नीचे दिखाया गया है.

मार्ग के नीचे इस कोड को चिपकाएं जो उपयोगकर्ता को लेखकों की सूची को पुनः प्राप्त करने की अनुमति देता है.

@ app.route (‘/ लेखक /’, विधियाँ = [‘DELETE’])
@token_required
def_author (current_user, author_id) हटाएं:
Author = Author.query.filter_by (id = author_id, user_id = current_user.id) .first ()
यदि लेखक नहीं है:
वापसी jsonify ({‘संदेश’: ‘लेखक मौजूद नहीं है’)

db.session.delete (लेखक)
db.session.commit ()

वापसी jsonify ({‘संदेश’: ‘लेखक हटा दिया गया’})

अगर __name__ == ‘__main__’:
app.run (डिबग = सच)

बाद में, वर्चुअल वातावरण के अंदर app.py फ़ाइल को सहेजें और बंद करें.

पोस्टमैन के साथ पुस्तकालय एपीआई का परीक्षण

इस खंड में, हम डेटाबेस सेवाओं के लिए अनुरोध भेजने के लिए एक डाकिया उपकरण का उपयोग करेंगे। यदि आपके पास अपनी मशीन पर एक डाकिया नहीं है, तो आप यह जान सकते हैं कि इसे कैसे डाउनलोड और इंस्टॉल किया जाए यहाँ.

पोस्टमैन के अलावा, हम अन्य उपकरणों जैसे कि का उपयोग कर सकते हैं कर्ल सर्वर को अनुरोध भेजने के लिए.

एक नया टर्मिनल खोलें और निम्नलिखित टाइप करें:

डाकिया

कमांड पोस्टमैन आपके वेब ब्राउज़र को नीचे पृष्ठ प्रदर्शित करने का कारण बनेगा:

postman_signup

आप नि: शुल्क खाता बनाने और साइन अप करने का निर्णय ले सकते हैं लेकिन हम लाइब्रेरी एपीआई का परीक्षण करने के लिए एप्लिकेशन को सीधे एक्सेस करेंगे और सीधे प्राप्त करेंगे जैसा कि नीचे दिखाया गया है:

पुस्तकालय एपीआई का परीक्षण करें

इस खंड में, हम उपयोगकर्ता को नीचे दिए गए चरणों का उपयोग करके POST विधि का उपयोग करके JSON प्रारूप में एक उपयोगकर्ता नाम और एक अद्वितीय पासवर्ड प्रदान करके लाइब्रेरी एपीआई के लिए पंजीकरण करने की अनुमति देंगे:

  • बॉडी लेबल वाले टैब पर क्लिक करें
  • फिर कच्चे बटन का चयन करें और JSON प्रारूप चुनें
  • स्क्रीनशॉट में दिखाए अनुसार रजिस्टर करने के लिए एक उपयोगकर्ता नाम और पासवर्ड दर्ज करें
  • भेजें बटन के बगल में, निम्न URL डालें http://127.0.0.1/register
  • अंत में, विधि को POST में बदलें और भेजें बटन दबाएं.

एक उपयोगकर्ता एक एपीआई के लिए रजिस्टर करता है

यह निम्न आउटपुट प्रदर्शित करेगा जैसा कि नीचे दिखाया गया है:

अब हमने सफलतापूर्वक एक उपयोगकर्ता पंजीकृत कर लिया है। निम्नलिखित चरणों का उपयोग करके लेखक तालिका तक पहुंचने के लिए एक अस्थायी यादृच्छिक टोकन उत्पन्न करने के लिए लॉग इन करने के लिए पंजीकरण करने वाले उपयोगकर्ता को अनुमति देने के लिए आगे बढ़ें:

  •  प्राधिकरण टैब पर क्लिक करें.
  • प्रकार अनुभाग के तहत, मूल प्रमाणीकरण का चयन करें.
  • इसके बाद उपयोगकर्ता नाम और पासवर्ड फॉर्म भरें जिसे आपने पहले पंजीकृत किया था.
  • अंत में, एक यादृच्छिक टोकन लॉगिन और उत्पन्न करने के लिए भेजें बटन दबाएं.

उपयोगकर्ता द्वारा सफलतापूर्वक लॉगिन करने के बाद, स्क्रीनशॉट में दिखाए अनुसार उपयोगकर्ता के लिए एक यादृच्छिक टोकन उत्पन्न होता है.

हम लेखक तालिका का उपयोग करने के लिए उत्पन्न यादृच्छिक टोकन का उपयोग करेंगे.

इस अनुभाग में, हम निम्न चरणों का उपयोग करके POST विधि के माध्यम से एक लेखक की जानकारी लेखक तालिका में जोड़ देंगे:

  • हेडर टैब पर क्लिक करें
  • स्क्रीनशॉट में दिखाए गए निम्नलिखित HTTP हेडर को शामिल करें

  • इसके बाद, बॉडी टैब पर क्लिक करें और नए लेखक का विवरण दर्ज करें
  • फिर लेखक के विवरण को लेखक की तालिका में जोड़ने के लिए भेजें बटन दबाएं

आप निम्न के माध्यम से लेखकों की तालिका में लेखकों की जानकारी भी प्राप्त कर सकते हैं:

  • सुनिश्चित करें कि आपका उत्पन्न टोकन हेडर अनुभाग में है। यदि यह नहीं है, तो आपको इसे अपने टोकन से भरना होगा.
  • भेजें बटन के अलावा, इस URL को दर्ज करें http://127.0.0.1/authors
  • फिर HTTP विधि को GET में बदलें और लेखकों के विवरण को पुनः प्राप्त करने के लिए भेजें बटन दबाएं.

अंत में, आप लेखक की टिप्पणियों को निम्न चरणों का उपयोग करके DELETE पद्धति के माध्यम से हटा सकते हैं:

  • सुनिश्चित करें कि आपका टोकन अभी भी हेडर अनुभाग में है। आप आवश्यक जानकारी सुनिश्चित करने के लिए हेडर टैब की जांच कर सकते हैं.
  • भेजें बटन के अलावा, इस URL को दर्ज करें http://127.0.0.1/sam
  • फिर आपके द्वारा निर्दिष्ट उपयोगकर्ता को हटाने के लिए भेजें बटन दबाएं.

आप पर पूर्ण स्रोत कोड पा सकते हैं Github.  आप इसे क्लोन कर सकते हैं और इसे अपनी मशीन पर देख सकते हैं.

टैग:

  • अजगर

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map