Maîtriser l'authentification dans Node.js et Express : un guide complet

L'authentification est un élément crucial des applications Web modernes, permettant aux développeurs de garantir que seuls les utilisateurs autorisés peuvent accéder à des fonctionnalités ou à des données spécifiques. Dans une application basée sur Node.js et Express, l'authentification est généralement gérée à l'aide de jetons, le plus souvent des jetons Web JSON (JWT), en raison de leur efficacité et de leur sécurité.

Dans ce guide, nous explorerons comment configurer l'authentification des utilisateurs dans une application Node.js et Express à l'aide de JWT. À la fin, vous aurez une solide compréhension de la façon de mettre en œuvre une authentification sécurisée pour vos propres projets.

Qu'est-ce que l'authentification ?

L'authentification est le processus de vérification de l'identité d'un utilisateur ou d'un système. Dans les applications Web, cela implique de vérifier les informations d'identification des utilisateurs, telles qu'un nom d'utilisateur et un mot de passe. Une fois la vérification réussie, le système permet à l'utilisateur d'interagir avec l'application. Pour une sécurité renforcée, l'authentification basée sur des jetons, telle que les JWT, est couramment utilisée.

Pourquoi utiliser les jetons Web JSON (JWT) ?

Les JWT sont une norme industrielle (RFC 7519) pour une authentification sécurisée et sans état basée sur des jetons. Ils permettent aux informations d'être transmises de manière sécurisée entre les parties sous forme d'objet JSON. Les jetons sont souvent utilisés pour vérifier l'identité d'un utilisateur sans avoir besoin de stocker les données de session sur le serveur, ce qui fait de JWT un excellent choix pour les applications sans état.

Étape par étape : implémentation de l'authentification dans Node.js et Express

Décomposons la mise en œuvre d'un système d'authentification de base utilisant JWT dans Node.js et Express.

1. Configuration de votre application Node.js

Avant de plonger dans l'authentification, nous devons configurer une application de base Node.js et Express. Suivez ces étapes pour initialiser votre projet :

mkdir auth-demo
cd auth-demo
npm init -y
npm install express bcryptjs jsonwebtoken mongoose dotenv

Voici à quoi sert chaque dépendance :

• express : Framework pour construire notre serveur Node.js.
• bcryptjs : Pour hacher et comparer les mots de passe en toute sécurité.
• jsonwebtoken : pour générer et vérifier des JWT.
• mangouste : Pour interagir avec MongoDB.
• dotenv : pour gérer les variables d'environnement telles que les secrets et les chaînes de connexion à la base de données.

2. Configuration des variables d'environnement

Créez un fichier .env dans le répertoire racine de votre projet pour stocker des informations sensibles telles que l'URI de votre base de données et la clé secrète JWT.

MONGODB_URI=mongodb://localhost:27017/auth-demo
JWT_SECRET=your_jwt_secret_key

3. Connexion à MongoDB

À la racine du projet, créez un fichier db.js dans un dossier de configuration pour gérer la connexion MongoDB.

// config/db.js
const mongoose = require('mongoose');
const dotenv = require('dotenv');

dotenv.config();

const connectDB = async () => {
  try {
    await mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    });
    console.log('MongoDB connected');
  } catch (err) {
    console.error('Error connecting to MongoDB:', err.message);
    process.exit(1);
  }
};

module.exports = connectDB;

4. Création du modèle utilisateur

Ensuite, créez un modèle utilisateur pour définir la structure des documents utilisateur dans MongoDB. Dans un dossier models, créez User.js :

// models/User.js
const mongoose = require('mongoose');

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

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

5. Implémentation de l'enregistrement des utilisateurs

Nous allons maintenant configurer l’itinéraire pour l’enregistrement des utilisateurs. Dans le dossier des contrôleurs, créez un fichier appelé authController.js et implémentez la logique d'enregistrement.

// controllers/authController.js
const User = require('../models/User');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');

// User registration
exports.register = async (req, res) => {
  const { username, password } = req.body;

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

    const hashedPassword = await bcrypt.hash(password, 10);
    const newUser = new User({ username, password: hashedPassword });

    await newUser.save();
    res.status(201).json({ message: 'User registered successfully' });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
};

Cette logique hache le mot de passe à l'aide de bcrypt avant de stocker les informations de l'utilisateur dans MongoDB.

6. Implémentation de la connexion utilisateur

La connexion est cruciale pour générer et renvoyer des JWT, que le client utilisera pour authentifier les futures demandes. Voici comment implémenter la logique de connexion :

// controllers/authController.js (continue)
exports.login = async (req, res) => {
  const { username, password } = req.body;

  try {
    const user = await User.findOne({ username });
    if (!user) {
      return res.status(401).json({ message: 'Invalid username or password' });
    }

    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      return res.status(401).json({ message: 'Invalid username or password' });
    }

    const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '1h' });
    res.json({ token });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
};

Si la connexion réussit, nous générons un JWT en utilisant jsonwebtoken et l'envoyons au client.

7. Configuration d'un middleware pour les routes protégées

Les JWT sont utiles pour protéger les routes qui nécessitent une authentification. Nous créerons un middleware pour vérifier le jeton et garantir que seuls les utilisateurs autorisés peuvent accéder à des points de terminaison spécifiques.

// middleware/authMiddleware.js
const jwt = require('jsonwebtoken');

exports.verifyToken = (req, res, next) => {
  const token = req.headers['authorization'];
  if (!token) return res.sendStatus(403);

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
};

8. Application d'un middleware d'authentification

Enfin, appliquons le middleware pour protéger une route. Par exemple, vous souhaiterez peut-être que les utilisateurs accèdent à leur profil uniquement après s'être connectés :

// routes/userRoutes.js
const express = require('express');
const { verifyToken } = require('../middleware/authMiddleware');
const { getUserProfile } = require('../controllers/userController');

const router = express.Router();

router.get('/profile', verifyToken, getUserProfile);

module.exports = router;

Le middleware verifyToken vérifie un JWT valide dans les en-têtes de la requête et permet l'accès à la route si le jeton est vérifié.

Conclusion

Dans ce guide, nous avons couvert l'essentiel de la mise en œuvre de l'authentification des utilisateurs à l'aide de JWT dans une application Node.js et Express. Nous avons parcouru la configuration de l'enregistrement des utilisateurs, de la connexion et de la protection des itinéraires à l'aide de l'authentification basée sur des jetons. Avec cette base, vous pouvez créer des systèmes d’authentification robustes et sécurisés dans vos propres applications. Au fur et à mesure de votre développement, envisagez d'ajouter des jetons d'actualisation, une fonctionnalité de réinitialisation de mot de passe et une authentification multifacteur pour une sécurité renforcée.

En maîtrisant l'authentification avec Node.js et Express, vous êtes sur la bonne voie pour créer des applications Web évolutives et sécurisées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!