So authentifizieren Sieate und Benutzer mithilfe von JWT in NodeJS autorisieren

Authentifizierung und Autorisierung sind das Grundkonzept der Computersicherheit. Sie verwenden Ihre Anmeldeinformationen (z. B. einen Benutzernamen und ein Passwort), um Ihre Identität nachzuweisen und Ihre Identität zu identifizierenself als registrierter Benutzer und erhalten Sie dann zusätzliche Berechtigungen.

Dies gilt auch, wenn Sie sich mit Ihrem Facebook- oder Google-Konto bei Online-Diensten anmelden.

In diesem Artikel werden wir eine Nodejs-API mit JWT-Authentifizierung (JSON Web Tokens) erstellen. Die Tools, die wir in diesem Tutorial verwenden werden, sind:

• Expressjs
• MongoDB-Datenbank
• Mungo
• Dotenv
• Bcryptjs
• Jsonwebtoken

Authentifizierung vs. Genehmigung

Was ist Authentifizierung?

Beglaubigung lernen muss die process der Identifizierung von Benutzern durch den Erwerb von Anmeldeinformationen wie E-Mail, Passwort und Token. Die angegebenen Anmeldeinformationen werden mit den Anmeldeinformationen des registrierten Benutzers verglichen, die in der Datei des lokalen Computersystems oder in beliebigen Datenbanken verfügbar sind. Wenn die angegebenen Anmeldeinformationen mit den verfügbaren Daten in der Datenbank übereinstimmen, erfolgt die Authentifizierung process ist abgeschlossen und der Benutzer darf auf die Ressourcen zugreifen.

Was ist Autorisierung?

Genehmigung geschieht nach der Authentifizierung. Jede Autorisierung muss über eine Authentifizierung verfügen process. Es ist die process Benutzern den Zugriff auf Ressourcen aus den Systemen oder einer Website zu ermöglichen. In diesem Tutorial autorisieren wir angemeldete Benutzer, auf ihre Daten zuzugreifen. Wenn der Benutzer nicht angemeldet ist, kann er nicht auf die Daten zugreifen.

Die besten Beispiele für Autorisierung sind soziale Medien platFormulare wie Facebook und Twitter. Ohne ein Konto können Sie nicht auf Social-Media-Inhalte zugreifen.

Ein weiteres Beispiel für die Autorisierung sind abonnementbasierte Inhalte. Ihre Authentifizierung kann durch Anmeldung bei der Website erfolgen, aber Sie werden nicht autorisiert, auf die Inhalte zuzugreifen, bis Sie sich nicht angemeldet haben.

Voraussetzung

Bevor Sie fortfahren, gehe ich davon aus, dass Sie über ein grundlegendes Verständnis verfügenandiKenntnisse in Javascript und MongoDB sowie gute Kenntnisse in Nodejs.

Stellen Sie sicher, dass Sie installiert haben Knoten und npm auf Ihrem lokalen Rechner. Um zu prüfen, ob Knoten und npm auf Ihrem Computer installiert sind, öffnen Sie die Eingabeaufforderung und geben Sie ein Knoten -v und npm -v. Dies sollte das folgende Ergebnis zeigen.

Ihre Versionen können von meinen abweichen. NPM-Automatikally wird mit dem Knoten heruntergeladen. Wenn Sie es noch nicht heruntergeladen haben, laden Sie es von herunter NodeJS-Website.

Sie benötigen eine IDE (Integrated-Entwicklungsumgebung), um Code zu schreiben. In diesem Tutorial verwende ich VS-Code-Editor. Wenn Sie eine andere haben, können Sie diese auch verwenden. Wenn Sie keine IDE auf Ihrem Computer installiert haben, können Sie sie von herunterladen Visual Studio-Website. Laden Sie es basierend auf Ihrem lokalen System herunter.

Projektaufbau

Create einen Ordnernamen Knotenapi irgendwo auf Ihrem lokalen Computer, und öffnen Sie es dann mit vs-code. Öffnen Sie das vs-code-Terminal und initialisieren Sie dann den Node-Paketmanager, indem Sie Folgendes eingeben.

npm init -y

Stellen Sie sicher, dass Sie auf der Knotenapi Verzeichnis.

Der obige Befehl wird erstelltate a paket.json Datei, die alle Abhängigkeiten enthält, die wir in diesem Projekt verwenden werden.

Jetzt werden wir alle oben genannten Pakete herunterladen, jetzt tippen und in das Terminal eingeben.

npm install express dotenv jsonwebtoken mongoose bcryptjs

Jetzt haben Sie Dateien und Ordner, wie unten gezeigt.

Server erstellen und Datenbank verbinden

Jetzt create eine Datei mit dem Namen index.js und ein Ordner namens Config. Innerhalb Config, create zwei Dateien mit dem Namen conn.js um sich mit der Datenbank zu verbinden und config.env Umgebungsvariablen zu deklarieren. Schreiben Sie den unten angegebenen Code in die entsprechenden Dateien.

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

Wenn Sie dotenv, konfigurieren Sie es dann in Ihrer index.js-Datei, bevor Sie andere Dateien aufrufen, die Umgebungsvariablen verwenden.

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

Ich verwende Mongo-DB Atlas URI, Sie können auch localhost verwenden.

Erstellen von Modellen und Routen

Modell ist ein Layout Ihrer Daten in der Mongo-DB-Datenbank und wird als JSON-Dokument gespeichert. Create Als Modell verwenden wir das Mongoose-Schema.

Routing bezieht sich darauf, wie eine Anwendung auf Clientanfragen reagiert. Wir werden die Express-Router-Funktion zum Erstellen verwendenate Routen.

Routing-Methoden üblichally Nimm zwei Argumente. Die erste ist Route und die zweite ist die Callback-Funktion, um zu definieren, was diese Route auf Anfrage des Clients tun würde.

Es dauert auch eine third Argument als Middleware-Funktion bei Bedarf, wie bei der Authentifizierung process. Denn wir bauen authentischated-API verwenden wir auch die Middleware-Funktion zur Autorisierung und Authentifizierungate Benutzer.

Jetzt werden wir erstellenate zwei Ordner mit dem Namen Routen und für. Innerhalb Routen, CREate ein Dateiname userRoute.js und darin für Ordner, create ein Dateiname userModel.js. Schreiben Sie nach dem Erstellen von Dateien den folgenden Code in die entsprechenden Dateien.

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)=>{

})

Implementieren der Routenfunktionalität und Erstellen von JWT-Tokens

Was ist JWT?

JSON-Web-Token (JWT) ist eine Javascript-Bibliothek, die erstelltates und Überprüfungstoken. Es handelt sich um einen offenen Standard, der zum Austausch von Informationen zwischen zwei Parteien – einem Client und einem Server – verwendet wird. Wir werden zwei Funktionen von JWT verwenden. Die erste Funktion ist Schild zu create ein neues Token und die zweite Funktion ist überprüfen um das Token zu verifizieren.

Was ist bcryptjs?

Bcryptjs ist eine Hashing-Funktion von createvon Niels Provos und David Mazières. Es verwendet einen Hash-Algorithmus, um das Passwort zu hashen. Es verfügt über zwei häufigste Funktionen, die wir in diesem Projekt verwenden werden. Die erste bcryptjs-Funktion ist Hash- zu generierenate Hashwert und die zweite Funktion ist vergleichen Funktion zum Vergleichen von Passwörtern.

Implementieren Sie die Routenfunktion

Die Callback-Funktion im Routing benötigt drei Argumente, Anforderung, Antwort, und weiter Funktion. Das nächste Argument ist optional; Übergeben Sie dies nur, wenn Sie dies benötigen. Diese Argumente sollten in der Anfrage, Antwort, und weiter bestellen. Ändern Sie nun die userRoute.js, config.env, und index.js Dateien mit den folgenden Codes.

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;

Wenn Sie A verwendensync Funktion, Try-Catch-Block verwenden, anderewise Es wird ein Fehler bei der Ablehnung eines nicht behandelten Versprechens ausgegeben.

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

Middleware für Authentic erstellenate Benutzer

Was ist Middleware?

Middleware ist eine Funktion, die Zugriff auf die hat Anforderung, Antwort Objekt und weiter Funktion im Anfrage-Antwort-Zyklus. Die nächste Funktion wird aufgerufen, wenn die Ausführung der Funktion abgeschlossen ist. Wie oben erwähnt, verwenden Sie next(), wenn Sie eine andere Callback-Funktion oder Middleware-Funktion ausführen müssen.

Jetzt create ein Ordner namens Middleware, und darin, create Dateiname als auth.js und schreiben Sie den folgenden Code.

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;

Installieren Sie nun die Cookie-Parser-Bibliothek, um den cookieParser in Ihrer App zu konfigurieren. cookieParser hilft Ihnen, auf das im Cookie gespeicherte Token zuzugreifen. Wenn Sie cookieParser nicht in Ihrer nodejs-App konfiguriert haben, können Sie nicht auf die Cookies aus den Headern des Anforderungsobjekts zugreifen. Schreiben Sie jetzt in das Terminal, um den Cookie-Parser herunterzuladen.

npm i cookie-parser

Jetzt haben Sie einen cookieParser installiert. Konfigurieren Sie Ihre App, indem Sie die Datei index.js ändern und Middleware zur hinzufügen "/Benutzer/" Route.

index.js-Datei

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;

Die „/user“-Route ist nur zugänglich, wenn der Benutzer angemeldet ist.

Überprüfen Sie die APIs POSTMAN

Bevor Sie APIs überprüfen, müssen Sie die ändern paket.json Datei. Fügen Sie die folgenden Codezeilen hinzu.

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

Sie können den Server starten, indem Sie eingeben npm starten, aber es wird nur einmal ausgeführt. Um Ihren Server beim Ändern von Dateien am Laufen zu halten, benötigen Sie Knotenmon. Laden Sie es herunter, indem Sie es im Terminal eingeben

npm install -g nodemon

-g Flag lädt den Nodemon-Glob herunterally auf Ihrem lokalen System. Sie müssen es nicht für jedes neue Projekt erneut herunterladen.

Um den Server auszuführen, geben Sie ein npm run dev im Endgerät. Sie erhalten das folgende Ergebnis.

Finally, Ihr Code ist fertig und der Server läuft ordnungsgemäß, gehen Sie zu postman und prüfen Sie, ob es funktioniert.

Was ist POSTMAN?

POSTMAN ist ein Softwaretool zum Entwerfen, Erstellen, Entwickeln und Testen von APIs.

Wenn Sie das nicht heruntergeladen haben postman Laden Sie es auf Ihrem Computer herunter postman Website .

Öffne jetzt die postman und Create eine Sammlung mit dem Namen nodeAPItest und darin create drei Bitten: registrieren, einloggen, und Benutzer. Sie sollten die folgenden Dateien haben.

Wenn Sie JSON-Daten an die „localhost:5000/api/register“ erhalten Sie das folgende Ergebnis.

Da wir während der Registrierung auch Tokens in Cookies erstellen und speichern, können Sie die Benutzerdetails haben, wenn Sie die „localhost:5000/api/user" Route. Den Rest der Anfragen können Sie hier einsehen POSTMAN.

Wenn Sie den vollständigen Code möchten, können Sie ihn von my erhalten github-Konto.

Schlussfolgerung

In diesem Lernprogramm haben wir gelernt, wie Sie die Authentifizierung auf die anwenden KnotenJS API mit JWT-Token. Wir haben auch Benutzer autorisiert, auf die Benutzerdaten zuzugreifen.

GLÜCKLICHES CODE!