Cómo ser auténticoate y autorizar al usuario a usar JWT en NodeJS
La autenticación y autorización es el concepto básico de la seguridad informática. Utiliza sus credenciales (como un nombre de usuario y contraseña) para demostrar su identidad e identificar suself como usuario registrado y luego obtener privilegios adicionales.
Esto también se aplica cuando inicia sesión en servicios en línea utilizando sus cuentas de Facebook o Google.
En este artículo, vamos a construir una API de Nodejs con autenticación JWT (JSON Web Tokens). Las herramientas que vamos a utilizar en este tutorial son:
- expreso
- Base de datos MongoDB
- Mangosta
- Dotenv
- Bcryptjs
- jsonwebtoken
¿Qué es la autenticación?
Autenticación son los process de identificar usuarios adquiriendo credenciales como correo electrónico, contraseña y tokens. Las credenciales proporcionadas se comparan con las credenciales del usuario registrado, que están disponibles en el archivo del sistema informático local o en cualquier base de datos. Si las credenciales proporcionadas coinciden con los datos disponibles en la base de datos, la autenticación process se completa y el usuario puede acceder a los recursos.
¿Qué es la autorización?
Autorización sucede después de la autenticación. Cada autorización debe tener una autenticación. process. Es el process de permitir a los usuarios acceder a recursos de los sistemas o de un sitio web. En este tutorial, autorizaremos a los usuarios que hayan iniciado sesión a acceder a los datos del usuario. Si el usuario no ha iniciado sesión, no podrá acceder a los datos.
Los mejores ejemplos de autorización son las redes sociales. platformularios como Facebook y Twitter. No puede acceder al contenido de las redes sociales sin tener una cuenta.
Otro ejemplo de autorización es el contenido basado en suscripción, su autenticación se puede realizar iniciando sesión en el sitio web, pero no estará autorizado para acceder al contenido hasta que no se haya suscrito.
Requisito previo
Antes de seguir adelante, asumo que tienes un conocimiento básico.anding de Javascript y MongoDB y buen conocimiento de Nodejs.
Asegúrate de haberlo instalado nodo y npm en su máquina local. para comprobar si nodo y npm están instalados en su computadora, abra el símbolo del sistema y escriba nodo -v y npm -v. Esto debería mostrar el siguiente resultado.
Tus versiones pueden diferir de la mía. MNP automáticoally se descarga con el nodo. Si aún no lo has descargado, descárgalo desde Sitio web de NodeJS.
Necesitará un IDE (Integr.ated entorno de desarrollo) para escribir código. En este tutorial, estoy usando Editor de código VS. Si tienes otro, también puedes usarlo. Si no tiene ningún IDE instalado en su computadora, puede descargarlo desde el Sitio web de Visual Studio. Descárguelo según su sistema local.
Configuración del proyecto
Create un nombre de carpeta nodeapi en cualquier lugar de su computadora local y luego ábralo con vs-code. Abra el terminal vs-code y luego inicialice el administrador de paquetes de nodos escribiendo.
npm init -yAsegúrate de estar en el nodeapi directorio.
El comando anterior crearáate a package.json archivo que contiene todas las dependencias que vamos a utilizar en este proyecto.
Ahora vamos a descargar todos los paquetes mencionados anteriormente, ahora escríbelos e ingrésalos en la terminal.
npm install express dotenv jsonwebtoken mongoose bcryptjsAhora, tendrá archivos y carpetas, como se muestra a continuación.
Creación de servidor y base de datos de conexión
Ahora create un archivo llamado index.js y una carpeta llamada config. Dentro config, creaate dos archivos llamados conn.js para conectarse a la base de datos y configuración.env para declarar variables de entorno. Escriba el código dado a continuación en los archivos respectivos.
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 está utilizando dotenv, luego configúrelo en su archivo index.js antes de llamar a otros archivos que usan variables de entorno.
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}`)
})
configuración.env
URI = 'mongodb+srv://ghulamrabbani883:rabbani@nodeapi.ulxmv.mongodb.net/?retryWrites=true&w=majority'
PORT = 5000Estoy usando mongo-DB Atlas URI, también puede usar localhost.
Creación de modelos y rutas.
Modelo es un diseño de sus datos en la base de datos Mongo-DB y se almacenará como un documento JSON. para crearate un modelo, vamos a utilizar el esquema mangosta.
El enrutamiento se refiere a cómo responde una aplicación a las solicitudes de los clientes. Usaremos la función de enrutador express para crearate rutas.
Métodos de enrutamiento usually tome dos argumentos. La primera es la ruta y la segunda es la función de devolución de llamada para definir qué haría esta ruta a petición del cliente.
También se necesita un third argumento como una función de middleware cuando sea necesario, como en la autenticación process. Mientras construimos auténticosated API, también usaremos la función de middleware para autorizar y autenticarate usuarios.
Ahora crearemosate dos carpetas nombradas rutas y modelos. Dentro rutas, CREate un nombre de archivo userRoute.js y dentro del modelos carpeta, create un nombre de archivo modelo de usuario.js. Después de crear los archivos, escriba el siguiente código en los archivos respectivos.
modelo de usuario.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;rutausuario.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)=>{
})Implementación de la funcionalidad de ruta y creación de tokens JWT
¿Qué es JWT?
Tokens web JSON (JWT) es una biblioteca javascript que creaates y verificar tokens. Es un estándar abierto que se utiliza para compartir información entre dos partes: un cliente y un servidor. Usaremos dos funciones de JWT. La primera función es firmar a create un nuevo token y la segunda función es verificar para verificar el token.
¿Qué es bcryptjs?
Bcryptjs es una función hash createD por Niels Provos y David Mazières. Utiliza un algoritmo hash para codificar la contraseña. Tiene dos funciones más comunes que usaremos en este proyecto. La primera función de bcryptjs es hachís generarate valor hash y la segunda función es comparar Función para comparar contraseñas.
Implementar la funcionalidad de ruta
La función de devolución de llamada en el enrutamiento toma tres argumentos, solicita, respuesta, y Next función. El siguiente argumento es opcional; pasa esto solo cuando lo necesites. Estos argumentos deben estar en la solicitud, respuesta, y Next ordenar. Ahora modifique el rutausuario.js, configuración.env, y index.js archivos con los siguientes códigos.
rutausuario.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 estás usando Async función, use el bloque try-catch, otrowise arrojará un error de rechazo de promesa no controlado.
configuración.env
URI = 'mongodb+srv://ghulamrabbani883:rabbani@nodeapi.ulxmv.mongodb.net/?retryWrites=true&w=majority'
PORT = 5000
SECRET_KEY = KGGK>HKHVHJVKBKJKJBKBKHKBMKHB
JWT_EXPIRE = 2dindex.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}`);
})
Creando middleware para Authenticate usuario
¿Qué es el software intermedio?
El middleware es una función que tiene acceso a la solicita, respuesta objeto y Next función en el ciclo de solicitud-respuesta. La siguiente función se invoca cuando se completa la ejecución de la función. Como mencioné anteriormente, use next() cuando tenga que ejecutar otra función de devolución de llamada o función de middleware.
Ahora create una carpeta llamada middleware, y dentro de él, create nombre de archivo como autenticación.js y escribe el siguiente código.
autenticación.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;Ahora instale la biblioteca del analizador de cookies para configurar el analizador de cookies en su aplicación. cookieParser le ayuda a acceder al token almacenado en la cookie. Si no tiene configurado cookieParser en su aplicación nodejs, no podrá acceder a las cookies desde los encabezados del objeto de solicitud. Ahora, escriba en la terminal para descargar el analizador de cookies.
npm i cookie-parserAhora, tiene instalado un analizador de cookies. Configure su aplicación modificando el archivo index.js y agregue middleware al "/usuario/" ruta.
archivo 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}`);
})
rutausuario.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 ruta "/usuario" solo será accesible cuando el usuario haya iniciado sesión.
Comprobando las API en POSTMAN
Antes de verificar las API, debe modificar el package.json expediente. Agregue las siguientes líneas de código.
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "node index.js",
"dev": "nodemon index.js"
},Puede iniciar el servidor escribiendo npm inicio, pero solo se ejecutará una vez. Para mantener su servidor funcionando mientras cambia archivos, necesitará Nodemon. Descárgala tecleando en la terminal
npm install -g nodemon-g flag descargará el nodemon globally en su sistema local. No es necesario descargarlo una y otra vez para cada nuevo proyecto.
Para ejecutar el servidor, escriba npm run dev en la terminal Obtendrá el siguiente resultado.
finalally, su código está completo y el servidor se está ejecutando correctamente, vaya a postman y comprobar si está funcionando.
Que es POSTMAN?
POSTMAN es una herramienta de software para diseñar, construir, desarrollar y probar API.
Si no has descargado el postman en su computadora, descárguelo desde postman página web.
Ahora abre el postman y create un nombre de colección nodeAPItest, y dentro de él, create tres peticiones: registro de inicio de sesión, y usuario. Debes tener los siguientes archivos.
Cuando envía datos JSON al "localhost:5000/api/registrar” obtendrá el siguiente resultado.
Como también estamos creando y guardando tokens en cookies durante el registro, puede obtener los detalles del usuario cuando solicita el "localhost:5000/api/usuario" ruta. Puedes consultar el resto de solicitudes en POSTMAN.
Si desea el código completo, puede obtenerlo de mi cuenta de github.
Para Concluir
En este tutorial, hemos aprendido cómo aplicar la autenticación al NodeJS API usando tokens JWT. También autorizamos a los usuarios a acceder a los datos del usuario.
¡FELIZ CODIFICACIÓN!
