Node.js + MongoDB पर RESTful API

एक मोबाइल ऐप डेवलपर के रूप में, मुझे अक्सर उपयोगकर्ता डेटा, प्राधिकरण, और बहुत कुछ संग्रहीत करने के लिए बैकएंड सेवाओं की आवश्यकता होती है। बेशक, ऐसे कार्यों के लिए आप बीएएएस (पार्स, बैकएंडलेस, आदि ...) का उपयोग कर सकते हैं। लेकिन आपका निर्णय हमेशा अधिक सुविधाजनक और व्यावहारिक होता है।

और फिर भी मैंने पूरी तरह से अज्ञात के लिए प्रौद्योगिकियों का अध्ययन करने का फैसला किया, जो अब बहुत लोकप्रिय हैं और शुरुआती लोगों द्वारा आसानी से महारत हासिल कर लेते हैं और बड़े पैमाने पर परियोजनाओं को लागू करने के लिए गहन ज्ञान और अनुभव की आवश्यकता नहीं होती है। तो चलो एक साथ जांचें कि क्या एक आम आदमी अपने प्रभावी और सही बैकएंड लिख सकता है।

यह लेख MongoDB के साथ काम करने के लिए Express.js फ्रेमवर्क और Mongoose.js मॉड्यूल का उपयोग करके Node.js पर एक मोबाइल एप्लिकेशन के लिए REST API के निर्माण पर चर्चा करेगा। पहुंच को नियंत्रित करने के लिए, हम OAuth2orize और Passport.js मॉड्यूल का उपयोग करके OAuth 2.0 तकनीक का सहारा लेंगे।

मैं एक निरपेक्ष शुरुआत के परिप्रेक्ष्य से लिख रहा हूं। कोड और तर्क पर किसी भी प्रतिक्रिया और सुधार पर खुशी!

सामग्री

1. Node.js + Express.js, एक साधारण वेब सर्वर
2. हैंडलिंग में त्रुटि
3. प्रतिष्ठित एपीआई समापन बिंदु, CRUD
4. MongoDB और Mongoose.js
5. अभिगम नियंत्रण - OAuth 2.0, Passport.js

मैं OSX, IDE - JetBrains WebStorm में काम करता हूं ।

मैंने इलिया कैंटर के स्क्रैनास्ट में Node.js की मूल बातें सीखीं, मैं इसकी अत्यधिक अनुशंसा करता हूं! ( और यहां हब पर उनके बारे में एक पोस्ट है )

अंतिम चरण में तैयार परियोजना GitHub पर ली जा सकती है । सभी मॉड्यूल को स्थापित करने के लिए, प्रोजेक्ट फ़ोल्डर में npm इंस्टॉल कमांड चलाएं।

1. Node.js + Express.js, एक साधारण वेब सर्वर

Node.js में गैर-अवरोधक I / O है, जो एक एपीआई के लिए अच्छा है जो कई क्लाइंट एक्सेस करेगा। Express.js एक विकसित, हल्का ढांचा है जो आपको उन सभी रास्तों (एपीआई समापन बिंदु) का वर्णन करने की अनुमति देता है जिन्हें हम संसाधित करेंगे। आप इसके लिए कई उपयोगी मॉड्यूल भी पा सकते हैं।

एक एकल server.js फ़ाइल के साथ एक नई परियोजना बनाएँ। चूंकि एप्लिकेशन पूरी तरह से Express.js पर निर्भर करेगा, इसे इंस्टॉल करें। थर्ड-पार्टी मॉड्यूल नोड फ़ोल्डर में प्रोजेक्ट फ़ोल्डर में npm install modulename ।

 cd NodeAPI npm i express 

Express नोड_मॉडल फ़ोल्डर में स्थापित है। इसे एप्लिकेशन से कनेक्ट करें:

 var express = require('express'); var app = express(); app.listen(1337, function(){ console.log('Express server listening on port 1337'); }); 

IDE या कंसोल ( node server.js ) के माध्यम से एप्लिकेशन चलाएँ। यह कोड लोकलहोस्ट: 1337 पर एक वेब सर्वर बनाएगा। यदि आप इसे खोलने का प्रयास करते हैं, तो यह संदेश Cannot GET / । ऐसा इसलिए है क्योंकि हमने अभी तक एक भी मार्ग निर्धारित नहीं किया है। अगला, कई पथ बनाएं और मूल एक्सप्रेस सेटिंग्स बनाएं।

 var express = require('express'); var path = require('path'); //     var app = express(); app.use(express.favicon()); //   ,      app.use(express.logger('dev')); //        app.use(express.bodyParser()); //  ,   JSON   app.use(express.methodOverride()); //  put  delete app.use(app.router); //       app.use(express.static(path.join(__dirname, "public"))); //    ,     public/ (    index.html) app.get('/api', function (req, res) { res.send('API is running'); }); app.listen(1337, function(){ console.log('Express server listening on port 1337'); }); 

अब लोकलहोस्ट: 1337 / एपी हमारा संदेश लौटा देगा। localhost: 1337 index.html प्रदर्शित करेगा।

यहाँ हम एरर हैंडलिंग पर आगे बढ़ते हैं।

2. त्रुटि से निपटने

सबसे पहले, सुविधाजनक विंस्टन लॉगिंग मॉड्यूल को कनेक्ट करें। हम अपने आवरण के माध्यम से इसका उपयोग करेंगे। npm i winston को प्रोजेक्ट रूट में स्थापित करें, फिर वहां libs / folder और log.js. फाइल बनाएं

 var winston = require('winston'); function getLogger(module) { var path = module.filename.split('/').slice(-2).join('/'); //    ,    return new winston.Logger({ transports : [ new winston.transports.Console({ colorize: true, level: 'debug', label: path }) ] }); } module.exports = getLogger; 

हमने लॉग के लिए 1 परिवहन बनाया - कंसोल को। हम संदेशों को अलग से भी सॉर्ट और सहेज सकते हैं, उदाहरण के लिए, डेटाबेस या फ़ाइल में। लकड़हारे को हमारे server.js से कनेक्ट करें।

 var express = require('express'); var path = require('path'); //     var log = require('./libs/log')(module); var app = express(); app.use(express.favicon()); //   ,      app.use(express.logger('dev')); //        app.use(express.bodyParser()); //  ,   JSON   app.use(express.methodOverride()); //  put  delete app.use(app.router); //       app.use(express.static(path.join(__dirname, "public"))); //    ,     public/ (    index.html) app.get('/api', function (req, res) { res.send('API is running'); }); app.listen(1337, function(){ log.info('Express server listening on port 1337'); }); 

हमारा न्यूज़लेटर अब कंसोल में अलग से खूबसूरती से प्रदर्शित किया गया है। 404 और 500 को संभालने में त्रुटि जोड़ें।

 app.use(function(req, res, next){ res.status(404); log.debug('Not found URL: %s',req.url); res.send({ error: 'Not found' }); return; }); app.use(function(err, req, res, next){ res.status(err.status || 500); log.error('Internal error(%d): %s',res.statusCode,err.message); res.send({ error: err.message }); return; }); app.get('/ErrorExample', function(req, res, next){ next(new Error('Random error!')); }); 

अब, यदि रास्ते उपलब्ध नहीं हैं, तो एक्सप्रेस हमारे संदेश को वापस कर देगा। एक आंतरिक अनुप्रयोग त्रुटि के मामले में, हमारा हैंडलर भी काम करेगा, इसे लोकलहोस्ट: 1337 / ErrorExample से संपर्क करके देखा जा सकता है।

3. RESTful API एंडपॉइंट, CRUD

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

 app.get('/api/articles', function(req, res) { res.send('This is not implemented now'); }); app.post('/api/articles', function(req, res) { res.send('This is not implemented now'); }); app.get('/api/articles/:id', function(req, res) { res.send('This is not implemented now'); }); app.put('/api/articles/:id', function (req, res){ res.send('This is not implemented now'); }); app.delete('/api/articles/:id', function (req, res){ res.send('This is not implemented now'); }); 

पोस्ट / पुट / डिलीट के परीक्षण के लिए, मैं cURL - httpie पर एक अद्भुत आवरण की सिफारिश करूंगा । आगे मैं इस टूल का उपयोग करके प्रश्नों के उदाहरण दूंगा।

4. MongoDB और Mongoose.js

एक DBMS का चयन, मैं फिर से कुछ नया सीखने की इच्छा द्वारा निर्देशित किया गया था। MongoDB सबसे लोकप्रिय NoSQL दस्तावेज़-उन्मुख DBMS है। Mongoose.js - एक आवरण जो आपको सुविधाजनक और कार्यात्मक दस्तावेज़ योजनाएं बनाने की अनुमति देता है।

डाउनलोड करें और MongoDB स्थापित करें। npm i mongoose स्थापित करें: npm i mongoose । मैंने डेटाबेस के साथ काम को लिबास / मोंगोज़ो.जेएस फाइल में चुना है।

 var mongoose = require('mongoose'); var log = require('./log')(module); mongoose.connect('mongodb://localhost/test1'); var db = mongoose.connection; db.on('error', function (err) { log.error('connection error:', err.message); }); db.once('open', function callback () { log.info("Connected to DB!"); }); var Schema = mongoose.Schema; // Schemas var Images = new Schema({ kind: { type: String, enum: ['thumbnail', 'detail'], required: true }, url: { type: String, required: true } }); var Article = new Schema({ title: { type: String, required: true }, author: { type: String, required: true }, description: { type: String, required: true }, images: [Images], modified: { type: Date, default: Date.now } }); // validation Article.path('title').validate(function (v) { return v.length > 5 && v.length < 70; }); var ArticleModel = mongoose.model('Article', Article); module.exports.ArticleModel = ArticleModel; 

इस फ़ाइल में, डेटाबेस से एक कनेक्शन बनाया जाता है, और ऑब्जेक्ट स्कीम भी घोषित की जाती हैं। लेख में चित्र वस्तुएं होंगी। यहां विभिन्न प्रकार के जटिल मान्यताओं का भी वर्णन किया जा सकता है।

इस स्तर पर, मेरा सुझाव है कि इसमें डेटाबेस के लिए पथ को संग्रहीत करने के लिए nconf मॉड्यूल को जोड़ना । कॉन्फ़िगरेशन में भी, उस पोर्ट को सहेजें जिस पर सर्वर बनाया गया है। मॉड्यूल npm i nconf साथ स्थापित है। आवरण लिब / config.js होगा

 var nconf = require('nconf'); nconf.argv() .env() .file({ file: './config.json' }); module.exports = nconf; 

यह इस प्रकार है कि हमें प्रोजेक्ट के रूट में config.json बनाना होगा।

 { "port" : 1337, "mongoose": { "uri": "mongodb://localhost/test1" } } 

Mongoose.js में परिवर्तन (केवल हेडर में):

 var config = require('./config'); mongoose.connect(config.get('mongoose:uri')); 

Server.js परिवर्तन:

 var config = require('./libs/config'); app.listen(config.get('port'), function(){ log.info('Express server listening on port ' + config.get('port')); }); 

अब हमारे मौजूदा रास्तों में CRUD कार्रवाई जोड़ें।

 var log = require('./libs/log')(module); var ArticleModel = require('./libs/mongoose').ArticleModel; app.get('/api/articles', function(req, res) { return ArticleModel.find(function (err, articles) { if (!err) { return res.send(articles); } else { res.statusCode = 500; log.error('Internal error(%d): %s',res.statusCode,err.message); return res.send({ error: 'Server error' }); } }); }); app.post('/api/articles', function(req, res) { var article = new ArticleModel({ title: req.body.title, author: req.body.author, description: req.body.description, images: req.body.images }); article.save(function (err) { if (!err) { log.info("article created"); return res.send({ status: 'OK', article:article }); } else { console.log(err); if(err.name == 'ValidationError') { res.statusCode = 400; res.send({ error: 'Validation error' }); } else { res.statusCode = 500; res.send({ error: 'Server error' }); } log.error('Internal error(%d): %s',res.statusCode,err.message); } }); }); app.get('/api/articles/:id', function(req, res) { return ArticleModel.findById(req.params.id, function (err, article) { if(!article) { res.statusCode = 404; return res.send({ error: 'Not found' }); } if (!err) { return res.send({ status: 'OK', article:article }); } else { res.statusCode = 500; log.error('Internal error(%d): %s',res.statusCode,err.message); return res.send({ error: 'Server error' }); } }); }); app.put('/api/articles/:id', function (req, res){ return ArticleModel.findById(req.params.id, function (err, article) { if(!article) { res.statusCode = 404; return res.send({ error: 'Not found' }); } article.title = req.body.title; article.description = req.body.description; article.author = req.body.author; article.images = req.body.images; return article.save(function (err) { if (!err) { log.info("article updated"); return res.send({ status: 'OK', article:article }); } else { if(err.name == 'ValidationError') { res.statusCode = 400; res.send({ error: 'Validation error' }); } else { res.statusCode = 500; res.send({ error: 'Server error' }); } log.error('Internal error(%d): %s',res.statusCode,err.message); } }); }); }); app.delete('/api/articles/:id', function (req, res){ return ArticleModel.findById(req.params.id, function (err, article) { if(!article) { res.statusCode = 404; return res.send({ error: 'Not found' }); } return article.remove(function (err) { if (!err) { log.info("article removed"); return res.send({ status: 'OK' }); } else { res.statusCode = 500; log.error('Internal error(%d): %s',res.statusCode,err.message); return res.send({ error: 'Server error' }); } }); }); }); 

मानगो और वर्णित योजनाओं के लिए धन्यवाद - सभी ऑपरेशन बेहद स्पष्ट हैं। अब, नोड.जेएस के अलावा, आपको mongod कमांड शुरू करना चाहिए। mongo - डेटाबेस के साथ काम करने के लिए एक उपयोगिता, सेवा ही mongod । आपको डेटाबेस में पहले से कुछ भी बनाने की आवश्यकता नहीं है।

Httpie का उपयोग करके नमूना अनुरोध:

 http POST http://localhost:1337/api/articles title=TestArticle author='John Doe' description='lorem ipsum dolar sit amet' images:='[{"kind":"thumbnail", "url":"http://habrahabr.ru/images/write-topic.png"}, {"kind":"detail", "url":"http://habrahabr.ru/images/write-topic.png"}]' http http://localhost:1337/api/articles http http://localhost:1337/api/articles/52306b6a0df1064e9d000003 http PUT http://localhost:1337/api/articles/52306b6a0df1064e9d000003 title=TestArticle2 author='John Doe' description='lorem ipsum dolar sit amet' images:='[{"kind":"thumbnail", "url":"http://habrahabr.ru/images/write-topic.png"}, {"kind":"detail", "url":"http://habrahabr.ru/images/write-topic.png"}]' http DELETE http://localhost:1337/api/articles/52306b6a0df1064e9d000003 

इस स्तर पर परियोजना GitHub पर एक नज़र डाल सकती है ।

5. अभिगम नियंत्रण - OAuth 2.0, Passport.js

पहुंच को नियंत्रित करने के लिए, मैं OAuth 2 का सहारा लूंगा। शायद यह बेमानी है, लेकिन भविष्य में यह दृष्टिकोण अन्य OAuth प्रदाताओं के साथ एकीकरण की सुविधा प्रदान करता है। इसके अलावा, मुझे Node.js. के लिए उपयोगकर्ता-पासवर्ड OAuth2 प्रवाह के काम के उदाहरण नहीं मिले।
Passport.js सीधे पहुंच नियंत्रण की निगरानी करेगा। OAuth2 सर्वर के लिए, एक ही लेखक, oauth2orize से एक समाधान उपयोगी है । उपयोगकर्ता, टोकन MongoDB में संग्रहीत किए जाएंगे।
पहले हमें उन सभी मॉड्यूल को स्थापित करना होगा जिनकी हमें आवश्यकता है:

• ठग
• oauth2orize
• पासपोर्ट
• पासपोर्ट http
• पासपोर्ट http-वाहक
• पासपोर्ट OAuth2-क्लाइंट पासवर्ड

फिर, mongoose.js में आपको उपयोगकर्ताओं और टोकन के लिए योजनाएँ जोड़ने की आवश्यकता है:

 var crypto = require('crypto'); // User var User = new Schema({ username: { type: String, unique: true, required: true }, hashedPassword: { type: String, required: true }, salt: { type: String, required: true }, created: { type: Date, default: Date.now } }); User.methods.encryptPassword = function(password) { return crypto.createHmac('sha1', this.salt).update(password).digest('hex'); //more secure - return crypto.pbkdf2Sync(password, this.salt, 10000, 512); }; User.virtual('userId') .get(function () { return this.id; }); User.virtual('password') .set(function(password) { this._plainPassword = password; this.salt = crypto.randomBytes(32).toString('base64'); //more secure - this.salt = crypto.randomBytes(128).toString('base64'); this.hashedPassword = this.encryptPassword(password); }) .get(function() { return this._plainPassword; }); User.methods.checkPassword = function(password) { return this.encryptPassword(password) === this.hashedPassword; }; var UserModel = mongoose.model('User', User); // Client var Client = new Schema({ name: { type: String, unique: true, required: true }, clientId: { type: String, unique: true, required: true }, clientSecret: { type: String, required: true } }); var ClientModel = mongoose.model('Client', Client); // AccessToken var AccessToken = new Schema({ userId: { type: String, required: true }, clientId: { type: String, required: true }, token: { type: String, unique: true, required: true }, created: { type: Date, default: Date.now } }); var AccessTokenModel = mongoose.model('AccessToken', AccessToken); // RefreshToken var RefreshToken = new Schema({ userId: { type: String, required: true }, clientId: { type: String, required: true }, token: { type: String, unique: true, required: true }, created: { type: Date, default: Date.now } }); var RefreshTokenModel = mongoose.model('RefreshToken', RefreshToken); module.exports.UserModel = UserModel; module.exports.ClientModel = ClientModel; module.exports.AccessTokenModel = AccessTokenModel; module.exports.RefreshTokenModel = RefreshTokenModel; 

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

तो, डेटाबेस में ऑब्जेक्ट्स:

1. उपयोगकर्ता - एक उपयोगकर्ता जिसका नाम, पासवर्ड हैश और उसके पासवर्ड का नमक है।
2. क्लाइंट - एक क्लाइंट एप्लिकेशन जिसे उपयोगकर्ता की ओर से एक्सेस दी जाती है। उनका एक नाम और एक गुप्त कोड है।
3. AccessToken - क्लाइंट एप्लिकेशन को जारी किया गया एक टोकन (वाहक प्रकार) समय में सीमित है।
4. RefreshToken - एक अन्य प्रकार का टोकन, आपको उपयोगकर्ता से पासवर्ड पुन: अनुरोध किए बिना एक नए वाहक टोकन का अनुरोध करने की अनुमति देता है।

Config.json में, टोकन जीवनकाल जोड़ें:

 { "port" : 1337, "security": { "tokenLife" : 3600 }, "mongoose": { "uri": "mongodb://localhost/testAPI" } } 

हम OAuth2 सर्वर और प्राधिकरण तर्क को अलग-अलग मॉड्यूल में अलग करते हैं। Oauth.js ने पासपोर्ट.js की "रणनीतियों" का वर्णन किया है, हम उनमें से 3 को कनेक्ट करते हैं - 2 को OAuth2 उपयोगकर्ता नाम-पासवर्ड प्रवाह, 1 टोकन की जांच करने के लिए।

 var config = require('./config'); var passport = require('passport'); var BasicStrategy = require('passport-http').BasicStrategy; var ClientPasswordStrategy = require('passport-oauth2-client-password').Strategy; var BearerStrategy = require('passport-http-bearer').Strategy; var UserModel = require('./mongoose').UserModel; var ClientModel = require('./mongoose').ClientModel; var AccessTokenModel = require('./mongoose').AccessTokenModel; var RefreshTokenModel = require('./mongoose').RefreshTokenModel; passport.use(new BasicStrategy( function(username, password, done) { ClientModel.findOne({ clientId: username }, function(err, client) { if (err) { return done(err); } if (!client) { return done(null, false); } if (client.clientSecret != password) { return done(null, false); } return done(null, client); }); } )); passport.use(new ClientPasswordStrategy( function(clientId, clientSecret, done) { ClientModel.findOne({ clientId: clientId }, function(err, client) { if (err) { return done(err); } if (!client) { return done(null, false); } if (client.clientSecret != clientSecret) { return done(null, false); } return done(null, client); }); } )); passport.use(new BearerStrategy( function(accessToken, done) { AccessTokenModel.findOne({ token: accessToken }, function(err, token) { if (err) { return done(err); } if (!token) { return done(null, false); } if( Math.round((Date.now()-token.created)/1000) > config.get('security:tokenLife') ) { AccessTokenModel.remove({ token: accessToken }, function (err) { if (err) return done(err); }); return done(null, false, { message: 'Token expired' }); } UserModel.findById(token.userId, function(err, user) { if (err) { return done(err); } if (!user) { return done(null, false, { message: 'Unknown user' }); } var info = { scope: '*' } done(null, user, info); }); }); } )); 

टोकन जारी करने और अद्यतन करने के लिए Oauth2.js जिम्मेदार है। एक एक्सचेंज रणनीति उपयोगकर्ता नाम-पासवर्ड प्रवाह का उपयोग करके एक टोकन प्राप्त करने के लिए है, एक अन्य ताज़ा_टोकन का आदान-प्रदान करना है।

 var oauth2orize = require('oauth2orize'); var passport = require('passport'); var crypto = require('crypto'); var config = require('./config'); var UserModel = require('./mongoose').UserModel; var ClientModel = require('./mongoose').ClientModel; var AccessTokenModel = require('./mongoose').AccessTokenModel; var RefreshTokenModel = require('./mongoose').RefreshTokenModel; // create OAuth 2.0 server var server = oauth2orize.createServer(); // Exchange username & password for access token. server.exchange(oauth2orize.exchange.password(function(client, username, password, scope, done) { UserModel.findOne({ username: username }, function(err, user) { if (err) { return done(err); } if (!user) { return done(null, false); } if (!user.checkPassword(password)) { return done(null, false); } RefreshTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) { if (err) return done(err); }); AccessTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) { if (err) return done(err); }); var tokenValue = crypto.randomBytes(32).toString('base64'); var refreshTokenValue = crypto.randomBytes(32).toString('base64'); var token = new AccessTokenModel({ token: tokenValue, clientId: client.clientId, userId: user.userId }); var refreshToken = new RefreshTokenModel({ token: refreshTokenValue, clientId: client.clientId, userId: user.userId }); refreshToken.save(function (err) { if (err) { return done(err); } }); var info = { scope: '*' } token.save(function (err, token) { if (err) { return done(err); } done(null, tokenValue, refreshTokenValue, { 'expires_in': config.get('security:tokenLife') }); }); }); })); // Exchange refreshToken for access token. server.exchange(oauth2orize.exchange.refreshToken(function(client, refreshToken, scope, done) { RefreshTokenModel.findOne({ token: refreshToken }, function(err, token) { if (err) { return done(err); } if (!token) { return done(null, false); } if (!token) { return done(null, false); } UserModel.findById(token.userId, function(err, user) { if (err) { return done(err); } if (!user) { return done(null, false); } RefreshTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) { if (err) return done(err); }); AccessTokenModel.remove({ userId: user.userId, clientId: client.clientId }, function (err) { if (err) return done(err); }); var tokenValue = crypto.randomBytes(32).toString('base64'); var refreshTokenValue = crypto.randomBytes(32).toString('base64'); var token = new AccessTokenModel({ token: tokenValue, clientId: client.clientId, userId: user.userId }); var refreshToken = new RefreshTokenModel({ token: refreshTokenValue, clientId: client.clientId, userId: user.userId }); refreshToken.save(function (err) { if (err) { return done(err); } }); var info = { scope: '*' } token.save(function (err, token) { if (err) { return done(err); } done(null, tokenValue, refreshTokenValue, { 'expires_in': config.get('security:tokenLife') }); }); }); }); })); // token endpoint exports.token = [ passport.authenticate(['basic', 'oauth2-client-password'], { session: false }), server.token(), server.errorHandler() ] 

इन मॉड्यूल को जोड़ने के लिए, server.js में जोड़ें:

 var oauth2 = require('./libs/oauth2'); app.use(passport.initialize()); require('./libs/auth'); app.post('/oauth/token', oauth2.token); app.get('/api/userInfo', passport.authenticate('bearer', { session: false }), function(req, res) { // req.authInfo is set using the `info` argument supplied by // `BearerStrategy`. It is typically used to indicate scope of the token, // and used in access control checks. For illustrative purposes, this // example simply returns the scope in the response. res.json({ user_id: req.user.userId, name: req.user.username, scope: req.authInfo.scope }) } ); 

उदाहरण के लिए, सुरक्षा स्थानीय होस्ट पते पर है: 1337 / एपीआई / userInfo।

प्राधिकरण तंत्र के संचालन की जांच करने के लिए, आपको डेटाबेस में एक उपयोगकर्ता और ग्राहक बनाना चाहिए। मैं Node.js पर एक आवेदन दूंगा, जो आवश्यक वस्तुओं का निर्माण करेगा और संग्रह से अनावश्यक को हटा देगा। यह परीक्षण के दौरान टोकन और उपयोगकर्ताओं के डेटाबेस को जल्दी से साफ करने में मदद करता है, मुझे लगता है कि एक लॉन्च पर्याप्त होगा :)

 var log = require('./libs/log')(module); var mongoose = require('./libs/mongoose').mongoose; var UserModel = require('./libs/mongoose').UserModel; var ClientModel = require('./libs/mongoose').ClientModel; var AccessTokenModel = require('./libs/mongoose').AccessTokenModel; var RefreshTokenModel = require('./libs/mongoose').RefreshTokenModel; var faker = require('Faker'); UserModel.remove({}, function(err) { var user = new UserModel({ username: "andrey", password: "simplepassword" }); user.save(function(err, user) { if(err) return log.error(err); else log.info("New user - %s:%s",user.username,user.password); }); for(i=0; i<4; i++) { var user = new UserModel({ username: faker.random.first_name().toLowerCase(), password: faker.Lorem.words(1)[0] }); user.save(function(err, user) { if(err) return log.error(err); else log.info("New user - %s:%s",user.username,user.password); }); } }); ClientModel.remove({}, function(err) { var client = new ClientModel({ name: "OurService iOS client v1", clientId: "mobileV1", clientSecret:"abc123456" }); client.save(function(err, client) { if(err) return log.error(err); else log.info("New client - %s:%s",client.clientId,client.clientSecret); }); }); AccessTokenModel.remove({}, function (err) { if (err) return log.error(err); }); RefreshTokenModel.remove({}, function (err) { if (err) return log.error(err); }); setTimeout(function() { mongoose.disconnect(); }, 3000); 

यदि आपने एक स्क्रिप्ट के साथ डेटा बनाया है, तो निम्नलिखित प्राधिकरण आदेश आपके अनुरूप होंगे। मैं आपको याद दिला दूं कि मैं httpie का उपयोग कर रहा हूं ।

 http POST http://localhost:1337/oauth/token grant_type=password client_id=mobileV1 client_secret=abc123456 username=andrey password=simplepassword http POST http://localhost:1337/oauth/token grant_type=refresh_token client_id=mobileV1 client_secret=abc123456 refresh_token=TOKEN http http://localhost:1337/api/userinfo Authorization:'Bearer TOKEN' 

चेतावनी! उत्पादन सर्वर पर HTTPS का उपयोग करना सुनिश्चित करें, यह OAuth 2 विनिर्देशन द्वारा निहित है। और सही पासवर्ड हैशिंग के बारे में मत भूलना। इस उदाहरण के साथ https को लागू करना मुश्किल नहीं है, नेटवर्क पर कई उदाहरण हैं।
आपको याद दिला दूं कि GitHub के रिपॉजिटरी में सभी कोड निहित हैं।
काम करने के लिए, आपको निर्देशिका में mongod npm install चलाने की जरूरत है, mongod , node dataGen.js (निष्पादन के लिए प्रतीक्षा करें), और फिर node server.js ।

यदि लेख के किसी भी भाग को अधिक विवरण में वर्णित किया जाना चाहिए, तो कृपया टिप्पणियों में इसे इंगित करें। सामग्री को संसाधित किया जाएगा और समीक्षाएँ उपलब्ध होने के रूप में अपडेट किया जाएगा।

संक्षेप में, मैं कहना चाहता हूं कि नोड.जेएस एक अच्छा, सुविधाजनक सर्वर समाधान है। दस्तावेज़-उन्मुख दृष्टिकोण के साथ MongoDB एक बहुत ही असामान्य, लेकिन निस्संदेह उपयोगी उपकरण है, जिनमें से अधिकांश विशेषताओं का मैंने अभी तक उपयोग नहीं किया है। Node.js के आसपास एक बहुत बड़ा समुदाय है, जहां कई ओपन-सोर्स विकास हैं। उदाहरण के लिए, oauth2orize और पासपोर्ट के निर्माता, जेरेड हैन्सन ने अद्भुत परियोजनाएं की हैं जो कि ठीक से संरक्षित प्रणालियों के कार्यान्वयन को यथासंभव आसान बनाते हैं।