Comment authentifier et autoriser un utilisateur à l'aide d'un JWT dans NodeJS

L'authentification et l'autorisation constituent le concept de base de la sécurité informatique. Vous utilisez vos données d'identification (telles qu'un nom d'utilisateur et un mot de passe) pour prouver votre identité et vous identifier en tant qu'utilisateur enregistré, puis vous obtenez des privilèges supplémentaires.

Il en va de même lorsque vous vous connectez à des services en ligne à l'aide de vos comptes Facebook ou Google.

Dans cet article, nous allons construire une API Nodejs avec une authentification JWT (JSON Web Tokens). Les outils que nous allons utiliser dans ce tutoriel sont :

• Expressjs
• Base de données MongoDB
• Mangouste
• Dotenv
• Bcryptjs
• Jsonwebtoken

Authentification et autorisation

Qu'est-ce que l'authentification ?

Authentification est le processus d'identification des utilisateurs par l'acquisition d'informations d'identification telles que l'adresse électronique, le mot de passe et les jetons. Les informations d'identification données sont comparées aux informations d'identification de l'utilisateur enregistré, qui sont disponibles dans le fichier du système informatique local ou dans toute autre base de données. Si les informations d'identification données correspondent aux données disponibles dans la base de données, le processus d'authentification est terminé et l'utilisateur est autorisé à accéder aux ressources.

Qu'est-ce que l'autorisation ?

Autorisation se produit après l'authentification. Toute autorisation doit être assortie d'un processus d'authentification. C'est le processus qui permet aux utilisateurs d'accéder aux ressources des systèmes ou d'un site web. Dans ce tutoriel, nous allons autoriser les utilisateurs connectés à accéder aux données de l'utilisateur. Si l'utilisateur n'est pas connecté, il ne pourra pas accéder aux données.

Les meilleurs exemples d'autorisation sont les plateformes de médias sociaux comme Facebook et Twitter. Vous ne pouvez pas accéder au contenu des médias sociaux sans avoir un compte.

Un autre exemple d'autorisation est le contenu basé sur un abonnement, votre authentification peut se faire en vous connectant au site web, mais vous ne serez pas autorisé à accéder au contenu tant que vous n'aurez pas souscrit un abonnement.

Pré-requis

Avant d'aller plus loin, je suppose que vous avez une compréhension de base de Javascript et MongoDB et une bonne connaissance de Nodejs.

Assurez-vous d'avoir installé nœud et npm sur votre machine locale. Pour vérifier si nœud et npm sont installés sur votre ordinateur, ouvrez l'invite de commande et tapez node -v et npm -v. Le résultat devrait être le suivant.

Vos versions peuvent être différentes de la mienne. NPM est automatiquement téléchargé avec le nœud. Si vous ne l'avez pas encore téléchargé, téléchargez-le à partir de la page Site web NodeJS.

Vous aurez besoin d'un IDE (environnement de développement intégré) pour écrire du code. Dans ce tutoriel, j'utilise Editeur de code VS. Si vous en avez un autre, vous pouvez également l'utiliser. Si vous n'avez pas d'IDE installé sur votre ordinateur, vous pouvez le télécharger à partir du site web Site web de Visual Studio. Téléchargez-le en fonction de votre système local.

Mise en place du projet

Créer un nom de dossier nodeapi n'importe où sur votre ordinateur local, puis ouvrez-le avec vs-code. Ouvrez le terminal vs-code et initialisez le gestionnaire de paquets node en tapant.

npm init -y

Assurez-vous d'être sur le site nodeapi répertoire.

La commande ci-dessus créera un package.json qui contient toutes les dépendances que nous allons utiliser dans ce projet.

Nous allons maintenant télécharger tous les paquets mentionnés ci-dessus, tapez-les et entrez-les dans le terminal.

npm install express dotenv jsonwebtoken mongoose bcryptjs

Vous avez maintenant des fichiers et des dossiers, comme indiqué ci-dessous.

Création du serveur et connexion de la base de données

Créez maintenant un fichier nommé index.js et un dossier nommé config. A l'intérieur configcréer deux fichiers nommés conn.js pour se connecter à la base de données et config.env pour déclarer des variables d'environnement. Ecrivez le code donné ci-dessous dans les fichiers respectifs.

index.js

const express = require('express');
const dotenv = require('dotenv');

//Configure dotenv files above using any other library and files
dotenv.config({path:'./config/config.env'}); 

//Creating an app from express
const app = express();

//Using express.json to get request of json data
app.use(express.json());



//listening to the server
app.listen(process.env.PORT,()=>{
    console.log(`Server is listening at ${process.env.PORT}`);
})

Si vous utilisez dotenvpuis configurez-le dans votre fichier index.js avant d'appeler un autre fichier qui utilise des variables d'environnement.

conn.js

const mongoose = require('mongoose');

mongoose.connect(process.env.URI, 
    { useNewUrlParser: true,
     useUnifiedTopology: true })
    .then((data) => {
        console.log(`Database connected to ${data.connection.host}`)
})

config.env

URI = 'mongodb+srv://ghulamrabbani883:rabbani@nodeapi.ulxmv.mongodb.net/?retryWrites=true&w=majority'
PORT = 5000

J'utilise l'URI de l'Atlas de Mongo-DB, mais vous pouvez également utiliser localhost.

Création de modèles et d'itinéraires

Modèle est une présentation de vos données dans la base de données Mongo-DB et sera stockée sous la forme d'un document JSON. Pour créer un modèle, nous allons utiliser le schéma Mongoose.

Le routage fait référence à la manière dont une application répond aux demandes des clients. Nous utiliserons la fonction express router pour créer des routes.

Les méthodes de routage prennent généralement deux arguments. Le premier est l'itinéraire et le second est la fonction de rappel qui définit ce que l'itinéraire doit faire à la demande du client.

Elle prend également un troisième argument en tant que fonction d'intergiciel lorsque cela est nécessaire, comme dans le processus d'authentification. Comme nous construisons une API authentifiée, nous utiliserons également la fonction d'intergiciel pour autoriser et authentifier les utilisateurs.

Nous allons maintenant créer deux dossiers nommés itinéraires et modèles. A l'intérieur les itinéraires, créer un fichier nommé userRoute.js et à l'intérieur du fichier modèles créer un nom de fichier userModel.js. Après avoir créé les fichiers, écrivez le code suivant dans les fichiers respectifs.

userModel.js

const mongoose = require('mongoose');

//Creating Schema using mongoose
const userSchema = new mongoose.Schema({
    name: {
        type:String,
        required:true,
        minLength:[4,'Name should be minimum of 4 characters']
    },
    email:{
        type:String,
        required:true,
        unique:true,
    },
    password:{
        type:String,
        required:true,
        minLength:[8,'Password should be minimum of 8 characters']
    },
    token:{
        type:String
    }
})

//Creating models
const userModel = mongoose.model('user',userSchema);
module.exports = userModel;

userRoute.js

const express = require('express');
//Creating express router
const route = express.Router();
//Importing userModel
const userModel = require('../models/userModel');

//Creating register route
route.post('/register',(req,res)=>{

})
//Creating login routes
route.post('/login',(req,res)=>{

})

//Creating user routes to fetch users data
route.get('/user',(req,res)=>{

})

Mise en œuvre de la fonctionnalité des routes et création de jetons JWT

Qu'est-ce que JWT ?

Jetons web JSON (JWT) est une bibliothèque javascript qui permet de créer et de vérifier des jetons. Il s'agit d'un standard ouvert utilisé pour partager des informations entre deux parties - un client et un serveur. Nous utiliserons deux fonctions de JWT. La première fonction est signe pour créer un nouveau jeton et la seconde fonction est vérifier pour vérifier le jeton.

Qu'est-ce que bcryptjs ?

Bcryptjs est une fonction de hachage créée par Niels Provos et David Mazières. Elle utilise un algorithme de hachage pour hacher le mot de passe. Elle possède deux fonctions les plus courantes que nous utiliserons dans ce projet. La première fonction de bcryptjs est hachage pour générer une valeur de hachage et la seconde fonction est comparer pour comparer les mots de passe.

Mise en œuvre de la fonctionnalité d'acheminement

La fonction de rappel dans le routage prend trois arguments, demande, réponse, et suivant fonction. L'argument suivant est facultatif ; ne le transmettez que si vous en avez besoin. Ces arguments doivent figurer dans la requête et la réponse, et suivant l'ordre. Modifiez maintenant le userRoute.js, config.env, et index.js avec les codes suivants.

userRoute.js

//Requiring all the necessary files and libraries
const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');

//Creating express router
const route = express.Router();
//Importing userModel
const userModel = require('../models/userModel');

//Creating register route
route.post("/register", async (req, res) => {

    try {
        const { name, email, password } = req.body;
        //Check emptyness of the incoming data
        if (!name || !email || !password) {
            return res.json({ message: 'Please enter all the details' })
        }

        //Check if the user already exist or not
        const userExist = await userModel.findOne({ email: req.body.email });
        if (userExist) {
            return res.json({ message: 'User already exist with the given emailId' })
        }
        //Hash the password
        const salt = await bcrypt.genSalt(10);
        const hashPassword = await bcrypt.hash(req.body.password, salt);
        req.body.password = hashPassword;
        const user = new userModel(req.body);
        await user.save();
        const token = await jwt.sign({ id: user._id }, process.env.SECRET_KEY, {
            expiresIn: process.env.JWT_EXPIRE,
        });
        return res.cookie({ 'token': token }).json({ success: true, message: 'User registered successfully', data: user })
    } catch (error) {
        return res.json({ error: error });
    }

})
//Creating login routes
route.post('/login', async (req, res) => {
    try {
        const { email, password } = req.body;
        //Check emptyness of the incoming data
        if (!email || !password) {
            return res.json({ message: 'Please enter all the details' })
        }
        //Check if the user already exist or not
        const userExist = await userModel.findOne({email:req.body.email});
        if(!userExist){
            return res.json({message:'Wrong credentials'})
        }
        //Check password match
        const isPasswordMatched = await bcrypt.compare(password,userExist.password);
        if(!isPasswordMatched){
            return res.json({message:'Wrong credentials pass'});
        }
        const token = await jwt.sign({ id: userExist._id }, process.env.SECRET_KEY, {
            expiresIn: process.env.JWT_EXPIRE,
        });
        return res.cookie({"token":token}).json({success:true,message:'LoggedIn Successfully'})
    } catch (error) {
        return res.json({ error: error });
    }

})

//Creating user routes to fetch users data
route.get('/user', async (req, res) => {
    try {
        const user  = await userModel.find();
        if(!user){
            return res.json({message:'No user found'})
        }
        return res.json({user:user})
    } catch (error) {
        return res.json({ error: error });  
    }
})

module.exports = route;

Si vous utilisez une fonction asynchrone, utilisez le bloc try-catch, sinon une erreur de rejet de promesse non gérée sera générée.

config.env

URI = 'mongodb+srv://ghulamrabbani883:rabbani@nodeapi.ulxmv.mongodb.net/?retryWrites=true&w=majority'
PORT = 5000
SECRET_KEY = KGGK>HKHVHJVKBKJKJBKBKHKBMKHB
JWT_EXPIRE = 2d

index.js

const express = require('express');
const dotenv = require('dotenv');

//Configure dotenv files above using any other library and files
dotenv.config({path:'./config/config.env'}); 
require('./config/conn');
//Creating an app from express
const app = express();
const route = require('./routes/userRoute');

//Using express.json to get request of json data
app.use(express.json());
//Using routes

app.use('/api', route);

//listening to the server
app.listen(process.env.PORT,()=>{
    console.log(`Server is listening at ${process.env.PORT}`);
})

Création d'un intergiciel pour l'authentification de l'utilisateur

Qu'est-ce qu'un intergiciel ?

L'intergiciel est une fonction qui a accès à la base de données de l demande, réponse objetet suivant dans le cycle demande-réponse. La fonction next est invoquée lorsque l'exécution de la fonction est terminée. Comme je l'ai mentionné plus haut, utilisez next() lorsque vous devez exécuter une autre fonction de rappel ou une fonction d'intergiciel.

Créez maintenant un dossier nommé intergicielet à l'intérieur de celui-ci, créez un nom de fichier comme auth.js et écrire le code suivant.

auth.js

const userModel = require('../models/userModel');
const jwt = require('jsonwebtoken');
const isAuthenticated = async (req,res,next)=>{
    try {
        const {token} = req.cookies;
        if(!token){
            return next('Please login to access the data');
        }
        const verify = await jwt.verify(token,process.env.SECRET_KEY);
        req.user = await userModel.findById(verify.id);
        next();
    } catch (error) {
       return next(error); 
    }
}

module.exports = isAuthenticated;

Installez maintenant la bibliothèque cookie-parser pour configurer cookieParser dans votre application. cookieParser vous aide à accéder au jeton stocké dans le cookie. Si vous n'avez pas configuré cookieParser dans votre application nodejs, vous ne pourrez pas accéder aux cookies à partir des en-têtes de l'objet de requête. Maintenant, écrivez dans le terminal pour télécharger cookie-parser.

npm i cookie-parser

Vous avez maintenant installé un cookieParser. Configurez votre application en modifiant le fichier index.js et ajoutez l'intergiciel au fichier "/utilisateur/" l'itinéraire.

fichier index.js

const cookieParser = require('cookie-parser');
const express = require('express');
const dotenv = require('dotenv');

//Configure dotenv files above using any other library and files
dotenv.config({path:'./config/config.env'}); 
require('./config/conn');
//Creating an app from express
const app = express();
const route = require('./routes/userRoute');

//Using express.json to get request of json data
app.use(express.json());
//Configuring cookie-parser
app.use(cookieParser()); 

//Using routes
app.use('/api', route);

//listening to the server
app.listen(process.env.PORT,()=>{
    console.log(`Server is listening at ${process.env.PORT}`);
})

userRoute.js

//Requiring all the necessary files and libraries
const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const isAuthenticated = require('../middleware/auth');

//Creating express router
const route = express.Router();
//Importing userModel
const userModel = require('../models/userModel');

//Creating user routes to fetch users data
route.get('/user', isAuthenticated, async (req, res) => {
    try {
        const user = await userModel.find();
        if (!user) {
            return res.json({ message: 'No user found' })
        }
        return res.json({ user: user })
    } catch (error) {
        return res.json({ error: error });
    }
})

module.exports = route;

La route "/user" n'est accessible que lorsque l'utilisateur est connecté.

Vérification des API sur POSTMAN

Avant de vérifier les API, vous devez modifier le fichier package.json fichier. Ajoutez les lignes de code suivantes.

"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node index.js",
    "dev": "nodemon index.js"
  },

Vous pouvez démarrer le serveur en tapant npm startmais il ne s'exécutera qu'une seule fois. Pour que votre serveur continue à fonctionner pendant que vous modifiez des fichiers, vous aurez besoin des éléments suivants nodemon. Téléchargez-le en tapant dans le terminal

npm install -g nodemon

-g téléchargera globalement le nodemon sur votre système local. Vous n'avez pas besoin de le télécharger à chaque nouveau projet.

Pour lancer le serveur, tapez npm run dev dans le terminal. Vous obtiendrez le résultat suivant.

Enfin, votre code est terminé, et le serveur fonctionne correctement, allez sur postman et vérifiez qu'il fonctionne.

Qu'est-ce que le POSTMAN ?

POSTMAN est un outil logiciel permettant de concevoir, construire, développer et tester des API.

Si vous n'avez pas téléchargé le facteur sur votre ordinateur, téléchargez-le à partir de l'adresse suivante site web du facteur.

Ouvrez maintenant le facteur et créez une collection nommée nodeAPItest, et à l'intérieur de celle-ci, créez trois requêtes : s'inscrire, se connecter, et utilisateur. Vous devriez avoir les fichiers suivants.

Lorsque vous envoyez des données JSON à l'interface "localhost:5000/api/register"Vous obtiendrez le résultat suivant.

Comme nous créons et sauvegardons des jetons dans des cookies lors de l'enregistrement, vous pouvez obtenir les coordonnées de l'utilisateur lorsque vous demandez la fonction "localhost:5000/api/user". Vous pouvez consulter le reste des demandes sur POSTMAN.

Si vous voulez le code complet, vous pouvez l'obtenir à partir de mon site web. compte github.

Conclusion

Dans ce tutoriel, nous avons appris à appliquer l'authentification à l'élément NodeJS à l'aide de jetons JWT. Nous avons également autorisé les utilisateurs à accéder à leurs données.

BON CODAGE !