L'authentification de l'utilisateur est le processus de vérification de l'identité d'un utilisateur tentant d'accéder à votre application. Cela implique l'autorisation et le transfert d'informations d'identification pour confirmer l'authenticité d'un utilisateur.
Vous pouvez implémenter un modèle d'authentification utilisateur simple dans Node.js à l'aide d'Express, Bcrypt et MongoDB, en quelques étapes seulement.
Étape 1: Configuration de l'environnement de développement
Tout d'abord, créez un dossier de projet et CD en exécutant:
mkdir authentification de l'utilisateur
CD Authentification d'utilisateur
Ensuite, initialisez npm dans votre répertoire de projet en exécutant :
npm init -y
La -y flag initialise npm et crée votre package.json fichier avec toutes ses valeurs par défaut.
Ce modèle d'authentification utilisateur nécessite quelques dépendances.
Ils comprennent:
- Exprimer: Express est un framework Node.js qui fournit un ensemble robuste de fonctionnalités pour les applications Web et mobiles. Il facilite la création d'applications backend avec Node.js.
- Bcrypt: bcrypt est un package npm qui implémente la fonction de hachage de mot de passe bcrypt. Il vous permet de créer des hachages à partir de chaînes de mot de passe simples.
- Mongoose: Mongoose est une bibliothèque de modélisation de données d'objets MongoDB. Il simplifie les interactions entre votre application et une base de données MongoDB.
- dotenv: dotenv est un package sans dépendance qui charge les variables d'environnement à partir d'un .env déposer dans processus.env.
- Validator: validator est un package qui contient diverses fonctions de validation de chaînes.
- Body-parser: le package body-parser analyse les corps de requête dans un middleware avant vos gestionnaires.
Installez les packages en exécutant :
npm installer validateur express bcrypt mongoose dotenv corps-analyseur
Ensuite, créez un app.js dans le répertoire racine de votre projet et ajoutez le bloc de code ci-dessous pour créer un serveur Express de base :
// app.js
constante exprimer = exiger('Express');
constante app = express();
constante bodyParser = exiger("body-parser");constante port = 3000;
application.utilisation(bodyParser.json());
application.utilisation(bodyParser.urlencodé({ étendu: vrai }));
app.listen (port, ()=>{
console.Journal(`L'application écoute sur le port ${port}`);
});
Ce code crée une instance d'application express en appelant la fonction express. Il utilise alors le analyseur de corps middleware pour analyser les corps de requête entrants. Ensuite, il commence à écouter le trafic sur le port 3000 en appelant la méthode listen de l'instance express et en passant la variable port comme argument.
Étape 2: Connecter votre application à une base de données
Dans le répertoire racine de votre projet, créez un .env fichier et stockez-y vos informations d'identification MongoDB. Cela évite d'exposer les informations d'identification de votre base de données dans le code, ce qui peut permettre à des utilisateurs malveillants d'accéder à votre base de données.
Ensuite, accédez à votre app.js déposer et importer mangouste :
constante mangouste = exiger("mangouste");
Ensuite, appelez import dotenv et appeler le configuration méthode dessus:
exiger("dotenv").config();
Appelant le configuration méthode sur dotenv charge les variables environnementales dans processus.env.
Enfin, appelez la méthode connect sur mangouste et passez votre URI MongoDB en argument :
mongoose.connect (process.env. MONGODB_URI).alors(() => {
console.log('Connecté à la base de données avec succès')
})
Étape 3: Création d'un modèle utilisateur
Dans le répertoire racine de votre projet, créez un "des modèles" dossier; c'est ici que vous stockerez votre modèle de mangouste :
modèles mkdir
Ensuite, créez un "userModel” fichier et ajoutez les importations suivantes :
constante mangouste = exiger('mangouste')
constante { estEmail } = exiger('validateur')
estEmail est une fonction de validation qui renvoie vrai si une chaîne donnée est un e-mail. Vous en aurez besoin pour appliquer la validation mangouste à votre modèle utilisateur.
Ensuite, ajoutez le code suivant à votre userModel dossier:
// modèles/modèleutilisateur
constante userSchema = mangouste. Schéma({
e-mail: {
taper: Chaîne de caractères,
requis: [vrai, 'L'e-mail est requis'],
valider: {
validateur: isEmail,
message: accessoires => `${props.value} n'est pas un e-mail valide`
}
},le mot de passe: {
taper: Chaîne de caractères,
requis: [vrai, 'Mot de passe requis'],
valider: {
validateur: fonction (évaluer) {
revenir valeur.longueur >= 6
},
msg: () =>'Le mot de passe doit comporter au moins six caractères'
}
}
})
module.exportations = mongoose.model('Utilisateur', userSchema)
Le code ci-dessus crée un userSchema variable qui stocke la valeur de mangouste. Schéma méthode. La mangouste. La méthode Schema mappe les propriétés à une collection MongoDB et définit la forme des documents qu'elle contient. Le schéma de la mangouste a deux propriétés—une e-mail et un le mot de passe— qui seront vos exigences d'authentification.
La propriété email est un type de chaîne et a obligatoire défini sur vrai. Le message d'erreur qui l'accompagne, "E-mail requis", s'affiche si le corps d'une requête ne contient pas de e-mail propriété. Enfin, en utilisant la validation personnalisée de la mangouste, le validateur la propriété fait référence à estEmail fonction. Cette fonction renvoie vrai ou faux en fonction de la validité de la chaîne en tant qu'e-mail. Ensuite, la propriété message prend la valeur email (accessoires) et construit un message d'erreur significatif.
La propriété de mot de passe est un type de chaîne obligatoire avec un message d'erreur indiquant « Le mot de passe est requis ». La validateur La fonction est une fonction anonyme qui renvoie true si le mot de passe comporte au moins six caractères.
La dernière ligne crée et exporte un modèle de mangouste en appelant le maquette méthode sur mangouste. Passez le nom du modèle (Utilisateur) comme premier argument et un schéma (userSchema) comme deuxième argument.
Étape 4: Implémenter les routes de connexion et d'inscription
Dans le répertoire racine de votre projet, créez un itinéraires dossier:
itinéraires mkdir
Dans votre dossier de routes, créez un userRoutes.js fichier et ajoutez les importations suivantes :
// routes/userRoutes.js
constante exprimer = exiger("Express");
constante Utilisateur = exiger(""../models/userModel");
constante bcrypt = exiger("bcrypt");
Créez une instance d'Express Router en appelant le Routeur méthode sur Express:
constante routeur = express. Routeur();
Ensuite, créez votre parcours d'inscription en ajoutant le bloc de code ci-dessous à votre userRoute.js dossier:
routeur.post("/sign-up", asynchrone (req, res) => {
essayer {
// Extrait l'email et le mot de passe de l'objet req.body
constante { email, mot de passe } = req.body ;// Vérifiersi le courriel est déjà dansutilisation
laisser userExists = attendre User.findOne({ email });si (l'utilisateur existe) {
res.statut(401).json({ message: "L'e-mail est déjà dans utilisation." });
revenir;
}// Définir les rondes de sel
constante saltRounds = 10;// Mot de passe haché
bcrypt.hash (mot de passe, saltRounds, (err, hash) => {
si (se tromper) jeterNouveauErreur("Serveur interne Erreur");// Créer un Nouveauutilisateur
laisser utilisateur = Nouveau Utilisateur({
e-mail,
le mot de passe: hacher,
});
// Enregistrer l'utilisateur dans la base de données
user.save().then(() => {
res.json({ message: "Utilisateur créé avec succès", utilisateur });
});
});
} attraper (erre) {
revenirres.statut(401).envoyer(se tromper.message);
}
});
Dans le bloc de code ci-dessus, vous avez d'abord déstructuré l'e-mail et le mot de passe du corps requis objet. Ensuite, vérifiez si un utilisateur utilise déjà l'e-mail car il doit être unique pour chaque utilisateur. Si l'e-mail a déjà été utilisé, vous revenez et arrêtez l'exécution du code avec un code d'état 401.
Le stockage de mots de passe simples dans une base de données est une énorme menace pour la sécurité, car des pirates malveillants pourraient accéder à la base de données. Vous devez hacher les mots de passe avant de les stocker dans votre base de données, donc même si un pirate les découvre, il ne devrait pas y avoir de risque pour les utilisateurs. Le hachage est le processus de conversion d'une "clé" donnée en une autre valeur. Le hachage est une fonction à sens unique, ce qui signifie que vous ne pouvez pas récupérer la valeur d'origine à partir de celle hased, contrairement au cryptage.
En utilisant bcrypt, vous avez haché votre mot de passe utilisateur en appelant la méthode de hachage sur bcrypt. La méthode de hachage prend trois paramètres: la chaîne à hacher, les arrondis salés et une fonction de rappel. Vous transmettez le mot de passe utilisateur, la variable saltRounds que vous avez créée précédemment et un rappel.
Les tours de sel font référence au temps nécessaire pour calculer un seul hachage bcrypt. Plus les tours de sel sont élevés, plus les tours de hachage sont nombreux.
Si la méthode de hachage génère une erreur, vous générez une "erreur de serveur interne". Sinon, vous définissez la propriété du mot de passe sur le hachage réussi et l'enregistrez dans votre base de données en appelant la méthode save sur le Utilisateur exemple.
Ensuite, créez votre itinéraire de connexion en ajoutant le bloc de code ci-dessous à votre userRoute.js dossier:
routeur.post("/sign-in", asynchrone (req, res) => {
essayer {
// Extrait l'email et le mot de passe de l'objet req.body
constante { email, mot de passe } = req.body ;// Vérifiersiutilisateurexistedansbase de données
laisser utilisateur = attendre User.findOne({ email });si (!utilisateur) {
renvoie res.status (401).json({ message: "Les informations d'identification invalides" });
}// Comparer les mots de passe
bcrypt.compare (password, user.password, (err, result) => {
si (résultat) {
renvoie res.status (200).json({ message: "L'utilisateur s'est connecté avec succès" });
}console.log (erreur);
renvoie res.status (401).json({ message: "Les informations d'identification invalides" });
});
} attraper (Erreur) {
res.statut(401).envoyer(se tromper.message);
}
});
module.exportations = routeur ;
Dans le bloc de code ci-dessus, commencez par déstructurer l'e-mail et le mot de passe du corps requis objet. Ensuite, vous vérifiez si un utilisateur existe dans votre base de données. Si l'utilisateur n'existe pas dans votre base de données, vous revenez avec un code d'état 401.
Ensuite, en utilisant la méthode de comparaison de bcrypt, transmettez le mot de passe fourni par l'utilisateur et le mot de passe haché que vous avez récupéré de votre base de données. Comparez les deux pour confirmer s'ils correspondent. Si les mots de passe correspondent, vous renvoyez un code d'état 200 et un message de réussite. Sinon, vous renvoyez un code d'état 401 et un message d'erreur.
Enfin, importez routeur Dans votre app.js fichier et l'utiliser comme middleware au niveau de l'application.
Ceci termine votre modèle d'authentification utilisateur; désormais, les utilisateurs peuvent s'inscrire et se connecter à votre application en toute sécurité.
L'importance de l'authentification des utilisateurs
L'authentification des utilisateurs garantit que seuls les utilisateurs légitimes peuvent accéder à votre application. Si vos données sont de quelque manière que ce soit personnelles ou privées, vous devez prendre des mesures pour empêcher les utilisateurs non authentifiés d'y accéder.
