MongoDB
 sql >> Database >  >> NoSQL >> MongoDB

Autenticazione dell'applicazione NodeJS e MongoDB tramite JWT

In questo blog implementeremo l'autenticazione con JWT in un'applicazione Web NodeJS. Per questo, utilizzeremo jsonwebtoken pacchetto

Cos'è JWT?

JWT(JSON Web Token) è un formato di token. È firmato digitalmente, autonomo e compatto. Fornisce un comodo meccanismo per il trasferimento dei dati. JWT non è intrinsecamente sicuro, ma l'uso di JWT può garantire l'autenticità del messaggio fintanto che la firma è verificata e l'integrità del carico utile può essere garantita. JWT viene spesso utilizzato per l'autenticazione senza stato in casi d'uso semplici che coinvolgono sistemi non complessi.

Ecco un esempio di JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsIm

Ora autentichiamo/proteggiamo alcuni percorsi.

Prerequisiti:

  • Conoscenza di base di HTML/JavaScript
  • NodeJS dovrebbe essere installato nel tuo sistema.
  • modulo express per la creazione del server.
  • Modulo mangusta per connessione e query MongoDB.
  • Modulo bcrypt per l'hashing.

puoi installare tutti i pacchetti richiesti usando il seguente comando:

npm install express mongoose bcrypt  --save

Passaggio 1. Innanzitutto, crea una struttura di directory come di seguito:

JWTApp 

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

Passaggio 2. Installa “jsonwebtoken ” pacchetto usando il seguente comando

 npm install jsonwebtoken -- save

Passaggio 3. Crea il modello utente

Nella cartella api/models, crea un file chiamato user userModel.js eseguendo touch api/models/userModel.js.

In questo file, crea uno schema mangusta con le seguenti proprietà:

  • nome completo
  • indirizzo email
  • password
  • la data di creazione

Aggiungi il seguente codice

'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);

Passaggio 4. Crea i gestori utente

In api/controller cartella, crea un file chiamato user userController.js eseguendo touch api/controllers/userController.js

Nel file userController, crea tre diversi gestori da gestire usando il codice seguente

'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' });
  }
};

Nota: Una password hash è stata salvata nel database utilizzando bcrypt.

Passaggio 6. In api/percorso cartella, crea un file chiamato user userRoute.js e aggiungi il seguente codice:

'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);
};

Passaggio 7. Aggiungi il seguente codice in server.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;

Passaggio 9. Ora devi solo eseguire il progetto utilizzando il comando seguente e provare a registrare utilizzando JWT.

npm start

Passaggio 10. Apri Postman e crea una richiesta di pubblicazione su localhost:3000/auth/register come di seguito:

Passaggio 11. Dopodiché, firmiamo con questo URL localhost:3000/auth/sign_in . Immettere le chiavi e i valori per e-mail e password

Sotto il valore, aggiungi JWT e il token con uno spazio tra, in questo modo:

JWT eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImZ1bGxOYW1lIjoiT2xhdHVuZGUgR2FydWJhIiwiX2lkIjoiNThmMjYzNDdiMTY1YzUxODM1NDMxYTNkIiwiaWF0IjoxNDkyMjgwMTk4fQ.VcMpybz08cB5PsrMSr25En4_EwCGWZVFgciO4M-3ENE

Passaggio 11. Quindi, immettere i parametri per la chiave e il valore per recuperare il profilo. Vuoi creare come mostrato di seguito e inviare:

Come abbiamo visto è abbastanza facile costruire un sistema di autenticazione JWT con NodeJS, puoi trovare il codice completo utilizzato in questo tutorial qui.

Nota:puoi decodificare o verificare i dettagli del tuo token JWT con questo strumento