El conocimiento es el nuevo dinero.
Aprender es la nueva manera en la que inviertes
Acceso Cursos

Servidor de autenticación Node.js para servicios RESTful

Protege tus API como un ninja Este sencillo artículo le guiará paso a paso para configurar su servidor de autenticación.

· 6 min de lectura
Servidor de autenticación Node.js para servicios RESTful

Obtendrá:
Instrucciones claras: Pasos fáciles de seguir con explicaciones para guiarte como un profesional.

Código fuente listo para usar: Copie, pegue y personalice para crear su servidor de autenticación en un abrir y cerrar de ojos.

API de registro de usuarios

  • Gestiona el alta de nuevos usuarios.
  • Acepta los datos del usuario (nombre de usuario, correo electrónico, contraseña).
  • Almacena de forma segura la información del usuario (contraseñas con hash y sal).

API de inicio de sesión de usuario

  • Verifica las credenciales del usuario.
  • Compara la contraseña introducida con el hash almacenado.
  • Si la autenticación tiene éxito, genera y devuelve un token (por ejemplo, JWT).

API de verificación de usuarios

  • Obten y devuelve información sobre el perfil del usuario.
  • Requiere un token de autenticación válido.

API de actualización de tokens

  • Emite nuevos tokens de acceso cuando caducan.
  • Amplía las sesiones de usuario sin necesidad de volver a iniciar sesión.
CPU
1 vCPU
MEMORIA
1 GB
ALMACENAMIENTO
10 GB
TRANSFERENCIA
1 TB
PRECIO
$ 4 mes
Para obtener el servidor GRATIS debes de escribir el cupon "LEIFER"

Registro de usuarios


Esta API está diseñada para registrar usuarios en nuestra base de datos. El acceso a nuestras API privadas está limitado únicamente a los usuarios registrados.

Instalar Dependencias Requeridas:

npm install express mongoose bcryptjs

Crear modelo de usuario

// models/user.js
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const userSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true },
});

userSchema.pre('save', async function (next) {
  if (this.isModified('password')) {
    this.password = await bcrypt.hash(this.password, 10); // Hash password with salt
  }
  next();
});

module.exports = mongoose.model('User', userSchema);

Crear ruta de registro

// routes/register.js
const express = require('express');
const router = express.Router();
const User = require('../models/user');

router.post('/', async (req, res) => {
  try {
    const { username, email, password } = req.body;

    // Validate user input here (e.g., using a validation library)

    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ message: 'Email already exists' });
    }

    const user = new User({ username, email, password });
    await user.save();

    res.status(201).json({ message: 'User registered successfully' });
  } catch (err) {
    console.error(err);
    res.status(500).json({ message: 'Registration failed' });
  }
});

module.exports = router;

Integración en el servidor principal

// app.js

const express = require('express');
const mongoose = require('mongoose');
const registerRouter = require('./routes/register');

const app = express();

// Connect to your MongoDB database
mongoose.connect('mongodb://localhost:27017/yourDatabaseName', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

app.use(express.json());
app.use('/register', registerRouter);


const port = process.env.PORT || 5000;
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

Curl para la API

 curl --location --request POST 'http://localhost:5000/register' \
--header 'Content-Type: application/json' \
--data-raw '{
    "username": "laxmi",
    "email": "laxmi@example.com",
    "password": "mypassword"
}'
Respuesta correcta de la API de registro

Inicio de sesión de usuario


Esta API da acceso a los usuarios registrados que han verificado correctamente su identidad. Proporciona un token como respuesta, que se utilizará para la verificación en todas las demás API.

Instalación Dependencias necesarias:

npm install jsonwebtoken

Crear ruta de inicio de sesión

// routes/login.js
const express = require('express');
const router = express.Router();
const User = require('../models/user');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
const REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET || 'your-refresh-token-secret'; // Add a separate secret for refresh tokens

router.post('/', async (req, res) => {
  try {
    const { email, password } = req.body;

    // Validate user input here (e.g., using a validation library)

    const user = await User.findOne({ email });

    if (!user) {
      return res.status(401).json({ message: 'Invalid email or password' });
    }

    const isMatch = await bcrypt.compare(password, user.password);

    if (!isMatch) {
      return res.status(401).json({ message: 'Invalid email or password' });
    }

    // Generate access token
    const accessToken = jwt.sign({ userId: user._id }, JWT_SECRET, { expiresIn: '1h' });

    // Generate refresh token with longer expiration
    const refreshToken = jwt.sign({ userId: user._id }, REFRESH_TOKEN_SECRET, { expiresIn: '7d' });

    res.json({
      message: 'Login successful',
      accessToken,
      refreshToken
    });
  } catch (err) {
    console.error(err);
    res.status(500).json({ message: 'Internal server error' });
  }
});

module.exports = router;

Integración en el servidor principal

// app.js
// ... (existing code for database connection and express setup)

const loginRouter = require('./routes/login');

app.use('/login', loginRouter);

// ... (rest of the code)

Curl para la API

curl --location --request POST 'http://localhost:5000/login' \
--header 'Content-Type: application/json' \
--data-raw '{
    "email": "laxmi@example.com",
    "password": "mypassword"
}'
Respuesta correcta de la API de inicio de sesión

Verificación de usuarios


Esta API lee el token para comprobar si estás en la base de datos de usuarios aprobados. Si tu token es válido, proporciona tu información de usuario como respuesta.

Crear ruta de verificación:

const express = require('express');
const jwt = require('jsonwebtoken');
const User = require('../models/user'); // Replace with your User model

const router = express.Router();
const JWT_SECRET = 'your-secret-key'; // Replace with your actual secret key

router.get('/', verifyToken, async (req, res) => {
  try {
    const user = await User.findById(req.userId);

    if (!user) {
      return res.status(404).json({ message: 'User not found' });
    }

    // Filter sensitive information if needed
    const profileData = {
      _id: user._id,
      name: user.name,
      email: user.email,
      // ...other profile fields you want to expose
    };

    res.json(profileData);
  } catch (err) {
    console.error(err);
    res.status(500).json({ message: 'Internal server error' });
  }
});

function verifyToken(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader;

  if (!token) {
    return res.status(401).json({ message: 'Unauthorized' });
  }

  jwt.verify(token, JWT_SECRET, (err, decoded) => {
    if (err) {
      res.status(401).json({ message: 'Invalid token' });
    } else {
      req.userId = decoded.userId;
      next();
    }
  });
}

module.exports = router;

Integración en el servidor principal

// app.js
// ... (existing code for database connection and express setup)

const verifyRouter = require('./routes/verification');

app.use('/verify', verifyRouter);

// ... (rest of the code)

Curl para la API

curl --location --request GET 'http://localhost:5000/verify' \
--header 'authorization: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiI2NTkxYTljOTU4ZWI1NDNkZTM3MzA4M2EiLCJpYXQiOjE3MDQyOTc0MzMsImV4cCI6MTcwNDMwMTAzM30.1iGarWoSbTKlL9Z-zSm2PlQOBDRMCee6T_1_oQro8GA'
Respuesta satisfactoria de la API de verificación

Actualización de token


Esta API crea un nuevo token de actualización cuando caduca su token de acceso, para que pueda seguir conectado sin tener que volver a introducir su contraseña.

Crear ruta de token de actualización:

const express = require('express');
const jwt = require('jsonwebtoken');

const router = express.Router();

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
const REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET || 'your-refresh-token-secret';

router.post('/', async (req, res) => {
  try {
    const refreshToken = req.body.refreshToken;

    if (!refreshToken) {
      return res.status(400).json({ message: 'Refresh token is required' });
    }

    jwt.verify(refreshToken, REFRESH_TOKEN_SECRET, (err, decoded) => {
      if (err) {
        return res.status(401).json({ message: 'Invalid refresh token' });
      }

      const userId = decoded.userId;

      // Generate a new access token
      const accessToken = jwt.sign({ userId }, JWT_SECRET, { expiresIn: '1h' });

      res.json({ accessToken });
    });
  } catch (err) {
    console.error(err);
    res.status(500).json({ message: 'Internal server error' });
  }
});

module.exports = router;

Integración en el servidor principal

// app.js
// ... (existing code for database connection and express setup)

const refreshTokenRouter = require('./routes/refreshToken');

app.use('/refresh', refreshTokenRouter);

// ... (rest of the code)

Curl para la API

curl --location --request POST 'http://localhost:5000/refresh' \
--header 'Content-Type: application/json' \
--data-raw '{
    "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiI2NThiMTc1ZmI0OGQ1YzIyYTY2MWQzNWEiLCJpYXQiOjE3MDM4NTcxNjcsImV4cCI6MTcwNDQ2MTk2N30.8qnduxMhaHx35n9bU7lA1SSqkDF6KzPb4HqKJvPnN78"
}'
Respuesta correcta de Refresh Token API

Fuente

Artículos Relacionados

Mejora tu VSCODE (PRODUCTIVDAD)
· 5 min de lectura
Generando certificados SSL TOTALMENTE GRATIS
· 3 min de lectura