JWT द्वारा NodeJS और MongoDB एप्लिकेशन प्रमाणीकरण

इस ब्लॉग में, हम NodeJS वेब एप्लिकेशन में JWT के साथ प्रमाणीकरण लागू करेंगे। इसके लिए हम jsonwebtoken . का उपयोग करेंगे पैकेज

JWT क्या है?

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

यहाँ JWT का एक उदाहरण दिया गया है:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsIm

अब, कुछ मार्गों को प्रमाणित/सुरक्षित करते हैं।

पूर्व-आवश्यकताएं:

• एचटीएमएल/जावास्क्रिप्ट का बुनियादी ज्ञान
• आपके सिस्टम में NodeJS इंस्टॉल होना चाहिए।
• सर्वर बनाने के लिए एक्सप्रेस मॉड्यूल।
• मोंगोडीबी कनेक्शन और प्रश्नों के लिए नेवला मॉड्यूल।
• हैशिंग के लिए bcrypt मॉड्यूल।

आप निम्न आदेश का उपयोग करके सभी आवश्यक पैकेज स्थापित कर सकते हैं:

npm install express mongoose bcrypt  --save

चरण 1. सबसे पहले, नीचे दी गई निर्देशिका संरचना बनाएं:

JWTApp

-api
--models
----userModel.js
--controllers
----userController.js
--route
----userRoute.js
--server.js

चरण 2. "jsonwebtoken इंस्टॉल करें। "पैकेजनिम्न आदेश का उपयोग करके

 npm install jsonwebtoken -- save

चरण 3. उपयोगकर्ता मॉडल बनाएं

एपीआई/मॉडल फ़ोल्डर में, टच एपीआई/मॉडल/यूजरमॉडल.जेएस चलाकर उपयोगकर्ता userModel.js नामक फ़ाइल बनाएं।

इस फ़ाइल में, निम्न गुणों के साथ एक नेवला स्कीमा बनाएँ:

• पूरा नाम
• ईमेल पता
• पासवर्ड
• बनाई गई तारीख

निम्नलिखित कोड जोड़ें

'use strict';

var mongoose = require('mongoose'),
  bcrypt = require('bcrypt'),
  Schema = mongoose.Schema;

/**
 * User Schema
 */
var UserSchema = new Schema({
  fullName: {
    type: String,
    trim: true,
    required: true
  },
  email: {
    type: String,
    unique: true,
    lowercase: true,
    trim: true,
    required: true
  },
  hash_password: {
    type: String
  },
  created: {
    type: Date,
    default: Date.now
  }
});

UserSchema.methods.comparePassword = function(password) {
  return bcrypt.compareSync(password, this.hash_password);
};

mongoose.model('User', UserSchema);

चरण 4. उपयोगकर्ता हैंडलर बनाएं

एपीआई/नियंत्रक . में फोल्डर, टच api/controllers/userController.js

उपयोगकर्ता नियंत्रक फ़ाइल में, निम्नलिखित कोड का उपयोग करके संभालने के लिए तीन अलग-अलग हैंडलर बनाएं

'use strict';

var mongoose = require('mongoose'),
  jwt = require('jsonwebtoken'),
  bcrypt = require('bcrypt'),
  User = mongoose.model('User');

exports.register = function(req, res) {
  var newUser = new User(req.body);
  newUser.hash_password = bcrypt.hashSync(req.body.password, 10);
  newUser.save(function(err, user) {
    if (err) {
      return res.status(400).send({
        message: err
      });
    } else {
      user.hash_password = undefined;
      return res.json(user);
    }
  });
};

exports.sign_in = function(req, res) {
  User.findOne({
    email: req.body.email
  }, function(err, user) {
    if (err) throw err;
    if (!user || !user.comparePassword(req.body.password)) {
      return res.status(401).json({ message: 'Authentication failed. Invalid user or password.' });
    }
    return res.json({ token: jwt.sign({ email: user.email, fullName: user.fullName, _id: user._id }, 'RESTFULAPIs') });
  });
};

exports.loginRequired = function(req, res, next) {
  if (req.user) {
    next();
  } else {

    return res.status(401).json({ message: 'Unauthorized user!!' });
  }
};
exports.profile = function(req, res, next) {
  if (req.user) {
    res.send(req.user);
    next();
  } 
  else {
   return res.status(401).json({ message: 'Invalid token' });
  }
};

नोट: डेटाबेस में bcrypt का उपयोग करके एक हैश पासवर्ड सहेजा गया था।

चरण 6. एपीआई/मार्ग . में फ़ोल्डर, उपयोगकर्ता userRoute.js नामक एक फ़ाइल बनाएँ और निम्नलिखित कोड जोड़ें:

'use strict';
module.exports = function(app) {
    var userHandlers = require('../controllers/userController.js');
    // todoList Routes
    app.route('/tasks')
        .post(userHandlers.loginRequired, userHandlers.profile);
    app.route('/auth/register')
        .post(userHandlers.register);
   app.route('/auth/sign_in')
        .post(userHandlers.sign_in);
};

चरण 7. सर्वर.js में निम्न कोड जोड़ें

'use strict';

var express = require('express'),
  app = express(),
  port = process.env.PORT || 3000,


  User = require('./api/models/userModel'),
  bodyParser = require('body-parser'),
  jsonwebtoken = require("jsonwebtoken");

const mongoose = require('mongoose');
const option = {
    socketTimeoutMS: 30000,
    keepAlive: true,
    reconnectTries: 30000
};

const mongoURI = process.env.MONGODB_URI;
mongoose.connect('mongodb://127.0.0.1:27017/?compressors=disabled&gssapiServiceName=mongodb', option).then(function(){
    //connected successfully
}, function(err) {
    //err handle
});

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

app.use(function(req, res, next) {
  if (req.headers && req.headers.authorization && req.headers.authorization.split(' ')[0] === 'JWT') {
    jsonwebtoken.verify(req.headers.authorization.split(' ')[1], 'RESTFULAPIs', function(err, decode) {
      if (err) req.user = undefined;
      req.user = decode;
      next();
    });
  } else {
    req.user = undefined;
    next();
  }
});
var routes = require('./api/routes/userRoutes');
routes(app);

app.use(function(req, res) {
  res.status(404).send({ url: req.originalUrl + ' not found' })
});

app.listen(port);

console.log(' RESTful API server started on: ' + port);

module.exports = app;

चरण 9. अब आपको बस निम्न कमांड का उपयोग करके प्रोजेक्ट को चलाने की आवश्यकता है और JWT का उपयोग करके लॉगिंग करने का प्रयास करें।

npm start

चरण 10. पोस्टमैन खोलें और लोकलहोस्ट:3000/auth/register . के लिए एक पोस्ट अनुरोध बनाएं नीचे के रूप में:

Step 11. इसके बाद इस URL localhost:3000/auth/sign_in से साइन इन करें। . ईमेल और पासवर्ड के लिए कुंजी और मान दर्ज करें

मान के तहत, JWT और टोकन को बीच की जगह के साथ जोड़ें, जैसे:

JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImZ1bGxOYW1lIjoiT2xhdHVuZGUgR2FydWJhIiwiX2lkIjoiNThmMjYzNDdiMTY1YzUxODM1NDMxYTNkIiwiaWF0IjoxNDkyMjgwMTk4fQ.VcMpybz08cB5PsrMSr25En4_EwCGWZVFgciO4M-3ENE

चरण 11. फिर, प्रोफ़ाइल लाने के लिए कुंजी और मान के लिए पैरामीटर दर्ज करें। आप नीचे दिखाए अनुसार बनाना चाहते हैं और भेजना चाहते हैं:

जैसा कि हमने देखा है कि NodeJS के साथ JWT प्रमाणीकरण प्रणाली बनाना काफी आसान है, आप इस ट्यूटोरियल में इस्तेमाल किया गया पूरा कोड यहाँ पा सकते हैं।

नोट:आप इस टूल से अपने JWT टोकन विवरण को डीकोड या सत्यापित कर सकते हैं