Transcription
1. Introduction du cours: Bienvenue dans le cours
Express Jazz, Model Nine, authentification
et autorisation. Je m'appelle ShenraGunhi, et je serai votre professeur
pour ce Au fil des ans, j'ai eu le privilège de
créer des systèmes dorsaux sécurisés et
évolutifs pour
une variété d'applications, et je suis ici pour partager
mon expertise avec vous L'un de mes meilleurs projets a
consisté à concevoir un système d'authentification utilisateur
pour une plateforme de commerce électronique, ce qui a considérablement amélioré
sa sécurité et sa facilité d'utilisation. Aujourd'hui, vous allez apprendre à créer quelque chose d'
aussi percutant Dans ce module, nous nous intéressons en profondeur à l'authentification
et à l'autorisation, deux aspects essentiels du développement Web
moderne. Vous apprendrez donc à enregistrer
les utilisateurs en toute sécurité à l'aide de mots de passe
hachés, authentifier les utilisateurs à l'aide de jetons Web JCN, à
protéger les
itinéraires sensibles
avec des intergiciels
et, enfin, à mettre en œuvre
une autorisation basée sur les rôles enfin, à mettre en œuvre à
authentifier les utilisateurs à l'aide de jetons Web JCN, à
protéger les
itinéraires sensibles
avec des intergiciels
et, enfin, à mettre en œuvre
une autorisation basée sur les rôles pour gérer les autorisations des utilisateurs. Ces connaissances sont cruciales pour sécuriser toute
application principale, et à la fin de ce module, vous serez en implémenter ces
fonctionnalités dans vos projets Ce module est donc conçu
pour les développeurs Bg in qui souhaitent faire passer leurs
applications Express JS au niveau supérieur. Si vous avez terminé
les modules précédents, vous êtes prêt à commencer. connaissances de base de JavaScript, pas de JS, et de Monger
DB sont recommandées L'authentification et
l'autorisation sont les pierres angulaires de toute application Web
sécurisée En maîtrisant ces concepts,
vous créerez non seulement des applications
plus sûres, mais vous augmenterez également votre
valeur en tant que développeur Ils doivent avoir les
compétences nécessaires pour créer des plateformes centrées sur
l'utilisateur
dans le monde technologique d'aujourd'hui. Enfin, pour le projet, vous allez intégrer
tout ce que vous avez appris dans l'application
Fair Wheels. Plus précisément,
vous implémenterez les fonctionnalités
d'enregistrement et de
connexion des utilisateurs, authentifierez fonctionnalités
d'enregistrement et de
connexion des utilisateurs, de
manière sécurisée les utilisateurs à
l'aide de jetons Web JCN Appliquez une autorisation basée sur les rôles pour protéger les itinéraires et les ressources. À la fin, vous disposerez d'un système de gestion des
utilisateurs sécurisé et évolutif pour l'application Fair Wheels. Ce module change la donne pour votre parcours de
développement de Bend. Créons donc ensemble
des applications sécurisées. Je vous verrai lors de la première
conférence. Commençons.
2. Authentification et autorisation - Une introduction: Très bien, alors revenons à notre application
Fair Wheels. Jusqu'à présent, nous avons créé
ces points de terminaison d'API. Nous pouvons donc gérer les entreprises, les voitures, les clients et les locations. Aujourd'hui, presque toutes les
applications nécessitent une sorte d'
authentification et d'autorisation. Dans cette section, nous
allons donc faire passer cette
application au niveau supérieur et
implémenter
l' authentification
et l'autorisation. Donc, avant d'aller plus loin, je veux m'assurer que
nous sommes sur la même longueur d'onde. L'authentification
est donc le processus déterminer si l'utilisateur est bien
celui qu'il prétend être. C'est à ce moment-là que nous nous connectons. Nous envoyons donc notre nom d'utilisateur et notre
mot de passe au serveur, qui nous authentifie L'autorisation détermine si l'utilisateur dispose de l'autorisation
appropriée pour effectuer l'opération donnée. Dans notre application Fair
Wheels,
nous voulons donc nous assurer que
seuls les utilisateurs authentifiés ou connectés peuvent effectuer des opérations de modification
des données Ainsi, si l'utilisateur est anonyme, s'il n'est pas connecté, ne peut lire que les données
provenant de ces points de terminaison S'ils souhaitent créer une nouvelle
entreprise ou mettre à jour une voiture, ils doivent d'abord être
authentifiés À titre de sécurité supplémentaire, nous voulons nous assurer que seuls les utilisateurs administrateurs
peuvent supprimer des données. Il s'agit donc d'un deuxième
niveau d'autorisation. Nous parlons ici
d'autorisations. Ce sont donc les exigences que nous allons mettre en œuvre
dans cette section. ce faire, nous devons donc
ajouter deux nouveaux points de terminaison
à notre application Tout d'abord, nous devrions être
en mesure d'enregistrer les utilisateurs. Pour cela, nous allons
envoyer une demande de publication pour réduire utilisateurs de
l'API, car nous publions,
nous créons de nouvelles ressources Dans ce cas, un nouvel utilisateur. Nous devrions également être en mesure
de connecter un utilisateur, ce qui est utilisé pour
l'authentification. Maintenant, voici une question pour toi. Quelle méthode SDDP devons-nous
utiliser pour implémenter la connexion ? Parce qu'avec la connexion, nous
ne créons pas de nouvelle ressource. Nous ne mettons pas à jour ni ne
supprimons une version existante. Alors, comment pouvons-nous implémenter
cela en termes reposants ? C'est l'un de ces
scénarios que vous pouvez rencontrer fréquemment dans les applications du monde
réel. Parfois, l'opération à laquelle vous avez affaire n'a pas
cette sémantique de création, de
lecture, de mise à jour, de suppression La façon dont nous modélisons cela
en termes reposants est de l'appeler
demande ou commande Vous créez donc une nouvelle demande de connexion ou
une nouvelle commande de connexion. Dans ce cas, nous utiliserons publication car nous
créons une nouvelle ressource, donc slash API slash Logins Maintenant, dans votre application, vous souhaitez
peut-être stocker
toutes les connexions dans
l'application dans une
collection séparée dans Mongo Deb Vous pouvez donc voir que l'utilisation de la publication est parfaitement
logique ici. Mais même si vous ne stockez pas connexions
individuelles et que vous souhaitez
simplement valider
l'utilisateur et le mot de passe, vous pouvez toujours traiter
cette ressource comme une ressource connexion et utiliser la fonction
post pour la créer Maintenant, voici un exercice pour vous. Je souhaite que vous implémentiez cette
API pour enregistrer de nouveaux utilisateurs. Donc, pour chaque utilisateur, nous voulons avoir
ces propriétés,
nom, e-mail et mot de passe. De même, lorsque
vous définissez votre schéma pour la propriété e-mail dans
l'objet de type schéma, définissez la propriété unique sur true. Ainsi, lorsque nous définissons le schéma, nous définissons le type d'e-mail pour un objet qui est notre objet de type de
schéma. Nous définissons le type ici sur chaîne et définissons également unique sur true. Ainsi, nous nous assurons
de ne pas stocker deux documents avec le
même e-mail dans Mongo Di B.
D'accord. Alors allez-y et implémentez uniquement cette API
pour enregistrer de nouveaux utilisateurs. Je vais faire de même
lors de la prochaine conférence.
3. Créer le modèle d'utilisateur: C'est bon. Je vais donc d'abord définir
un nouveau modèle d'utilisateur. Donc ici, dans le dossier des modèles
, dans un nouveau fichier, utilisez point js. Maintenant, pour gagner du temps,
je vais aller à société point js et
emprunter du code ici. Alors copiez-le à nouveau dans userdtjs,
collez-le ici. Maintenant en haut,
nous avons donc ce schéma. Je vais définir cela lors de l'
appel de la méthode model. Dans
ce cas, il n'est vraiment pas nécessaire de définir cela
comme une constante distincte. Récupérons donc cet
objet de schéma et ajoutons-le ici. Et maintenant, nous pouvons nous
débarrasser de ce schéma. OK, c'est mieux. C'est donc notre modèle. Nous devrions appeler cet utilisateur
constant. Et la collection correspondante
doit également être composée d'utilisateurs. Maintenant, nous avons la
propriété name, qui est une chaîne. C'est obligatoire, et il comporte 5 à 50 caractères. Cela me
semble bien. Ensuite, ajoutons un e-mail. Je vais donc prendre tout
ce qui est bon, le dupliquer. Et la deuxième
propriété est le courrier électronique. Encore une fois, nous avons
ces propriétés. J'aimerais augmenter
la longueur maximale à 255 caractères. Et aussi, comme je vous l'ai dit
lors de la dernière conférence, nous devrions ajouter la
propriété unique pour nous assurer que nous ne stockons pas deux utilisateurs ayant
le même email dans Manga Divi Et la dernière propriété est Passwb. Je vais donc copier tout cela, dupliquer et ajouter cette propriété
de mot de passe. Je vais maintenant définir la longueur
maximale des mots de passe à une valeur plus élevée, car nous allons hacher
ces mots de passe Et ici, nous n'avons pas besoin
de cette propriété unique. Vient ensuite notre fonction de validation. Nous devons donc le renommer
pour valider l'utilisateur. Validez l'utilisateur qui
prend un paramètre utilisateur. Ici, nous avons un nom de 5 à 50 caractères,
et c'est obligatoire. Nous avons un e-mail, qui
doit comporter de 5 à 255 caractères. Cela devrait être obligatoire.
Et ici, nous appelons également la méthode du courrier électronique pour nous
assurer qu'il s'agit d'un e-mail valide. Enfin, nous avons le mot de passe, qui est également une chaîne cinq caractères
minimum
et maximum, disons, 255, selon les besoins. Il s'agit donc du mot de passe que l'utilisateur envoie en texte brut. Nous allons hacher cette chaîne, qui
sera plus longue,
et c'est la chaîne que nous
allons stocker dans Mongo TV Nous en avons donc terminé avec notre fonction utilisateur
valide. Nous devons maintenant exporter
notre modèle utilisateur Nous n'avons
donc pas besoin de la
première instruction d'exportation destinée à la suppression de notre schéma. Ici, nous allons
l'exporter en tant qu'utilisateur, et notre
fonction de validation est également bonne. Magnifique. Nous en avons donc terminé
avec notre modèle d'utilisateur. Dans la prochaine conférence,
je vais ajouter un itinéraire pour enregistrer de nouveaux utilisateurs.
4. Enregistrer des utilisateurs: C'est bon. Nous allons maintenant créer un nouvel itinéraire pour
enregistrer de nouveaux utilisateurs. Ici, dans le dossier routes, je vais ajouter un nouveau
fichier users dot js. Maintenant, encore une fois, pour gagner du temps, je vais me rendre sur
companies point js et copier ces
instructions obligatoires
ainsi que le deuxième itinéraire
dans notre nouveau module. Alors copiez-le, collez-le ici. Encore une fois, copiez l'itinéraire de publication. Et collez ici. Au fait, je le fais uniquement parce que
je ne veux pas vous faire perdre
votre temps à me regarder
taper tout ça à la main. Dans le monde réel,
vous devez éviter approche du
copier-coller, sauf si
vous faites très attention et que vous devez lire
chaque ligne
du code copié pour
vous assurer que vous n'avez pas commis d'erreur. Il est toujours préférable de
taper le code à la main. Maintenant, apportons des modifications. Donc, en haut de la page, nous devons importer le
modèle utilisateur plutôt que l'entreprise. Ainsi, à partir de models user, nous importons la classe utilisateur, ainsi que la fonction de
validation. Nous avons également besoin d'Express et de Router. Voici donc notre nouvel itinéraire qui est proposé pour créer de nouveaux utilisateurs. Enfin, nous devons
exporter ce routeur. Donc le module point Exports. Nous l'avons configuré sur ce routeur. Maintenant, nous devons revenir à notre point d'index JS
et dire à Express que pour tous les itinéraires
commençant par une barre oblique ABS SRS, nous devons utiliser le routeur
que nous exportons Passons donc à Index ou Js. En haut,
importons ce nouveau module. Donc des utilisateurs constants. Nous l'avons configuré pour exiger des utilisateurs
du dossier de routes. Et puis ici, nous appelons une
application qui donne à notre chemin barre oblique aux utilisateurs de l'APA et à notre
routeur, c'est-à-dire OK, nous avons donc construit
une vue d'ensemble. Revenons maintenant à notre
module utilisateurs et implémentons
cette nouvelle route. Nous allons donc ici
valider la demande. Si ce n'est pas valide, nous
allons renvoyer une erreur 400, ce qui
est une mauvaise demande. Sinon, nous
allons créer un nouvel objet utilisateur et l'
enregistrer dans la base de données. Nous allons donc garder les deux premières lignes
exactement telles quelles. Nous voulons valider la demande. Nous utilisons notre fonction de
validation Joy. Donc, si les propriétés du nom, de l'e-mail ou du mot de passe ne
sont pas valides, nous allons renvoyer une erreur
400 au client. Maintenant, nous devons effectuer
un autre type de validation. Vous voulez vous assurer que cet utilisateur n'est pas
déjà inscrit. Nous appelons donc user point Fine one, transmettons un objet de requête ici. Nous recherchons un utilisateur avec un e-mail donné qui est
request point body point email. Notez donc qu'ici, je n'ai pas utilisé fine by
ID car nous
ne recherchons pas l'
utilisateur par son identifiant. Nous les recherchons par
l'une de leurs propriétés. C'est tellement beau. Maintenant, cela
renvoie une promesse. Nous l'attendons donc et
obtenons un objet utilisateur. Maintenant, dans ce cas, je
définis une variable au lieu d' une constante car
nous allons la
réinitialiser comme vous le
verrez dans une seconde. Donc, dans ce cas, si
nous avons cet
objet utilisateur dans la base de données, nous devrions renvoyer une erreur de
demande incorrecte au client. Donc, renvoyez le
point de réponse status 400, qui est un mauvais point de demande
SEND et voici le message que
l'utilisateur est déjà enregistré. À ce stade, nous avons
un objet utilisateur valide. Cet utilisateur n'est pas enregistré
dans la base de données, nous devons
donc enregistrer cet
utilisateur dans la base de données. Donc, ici, je vais réinitialiser cet objet utilisateur car à
ce stade, il devrait être non. Nous l'attribuons à un nouvel utilisateur, et nous définissons ici les propriétés. Donc, nom, nous l'avons défini pour
demander le corps du point, le nom du point. Email pour demander
point body point email. Et un mot de passe pour demander le mot de passe
Dot Body. Il s'agit donc de notre objet utilisateur. Maintenant, nous le sauvegardons. Alors attendez, l'utilisateur n'enregistre pas, et enfin,
renvoyez le fichier au client. Nous n'avons donc pas besoin de ces deux lignes pour travailler avec l'entreprise. Supprimer. Enfin, renvoyez ce nouvel utilisateur au client.
Maintenant, testons cela. Donc, de retour dans Postman, je vais envoyer
une demande de publication au port
Local Host 3,000
slash APAS Ensuite, dans le corps
de la requête, je vais définir ce paramètre sur Raw
et définir le type sur JSON. Ici, nous passons en tant qu'objet JSON
avec trois propriétés, name, Shiv, puis nous définissons l'e-mail Je vais définir
une adresse e-mail non valide, et je ne vais pas définir
le mot de passe non plus. Je veux m'assurer que notre fonction de
validation
fonctionne correctement. Alors envoyez. OK, nous avons
reçu une mauvaise demande. C'est une bonne chose. Le nom doit comporter au moins cinq
caractères. Alors laisse-moi changer ça
en Hewnder Alright. Maintenant, envoyons une autre demande. Nous avons reçu une autre mauvaise demande. La longueur de l'e-mail doit être d'au
moins cinq caractères. Modifions-le
donc en 12, trois, quatre, cinq, six, mais ce n'
est pas un e-mail valide. Alors maintenant, nous devrions avoir
une erreur différente. L'e-mail doit être un e-mail valide. Magnifique. Modifions-le donc pour tester 123 sur regmil.com Nous allons envoyer une autre demande. OK, maintenant, nous avons besoin d'un
mot de passe. Magnifique. Enfin, ajoutons un mot de passe d'au moins
cinq caractères. Donc un, deux, trois,
quatre, cinq, envoyez. Cette fois, nous avons reçu 200 réponses. Magnifique. Il s'agit de l'objet utilisateur que vous avez
enregistré dans la base de données. Vous avez donc la propriété ID
ainsi que le nom, l'e-mail
et le mot de passe. Désormais, lors de l'enregistrement d'
un nouvel utilisateur, nous ne voulons pas renvoyer son
mot de passe au client. C'est donc quelque chose que
nous allons
corriger lors de la prochaine conférence. Mais envoyons une autre demande avec exactement les mêmes valeurs. Cette fois, nous devrions
avoir une erreur différente, nous
indiquant que l'utilisateur
est déjà enregistré. Alors envoyez. OK, nous avons reçu
une autre mauvaise demande, et voici le message. L'utilisateur est déjà
inscrit. Magnifique. Dans la prochaine conférence,
nous allons donc modifier la
réponse de cette API et de ce point.
5. Utiliser Lodash: Pour revenir à notre méthode de publication, nous voulons modifier la
réponse au client. Il y a donc deux options ici. Une approche consiste à renvoyer
un objet personnalisé comme celui-ci, définissant le nom sur le nom
de point d'utilisateur et l'e-mail sur l'e-mail point de l'utilisateur. Ainsi, nous pouvons exclure le mot de passe et les propriétés de
version. Cette approche
convient parfaitement, mais dans cette conférence, je vais vous
présenter une bibliothèque utile qui vous
donne de nombreuses fonctions
utilitaires pour travailler avec des objets. Si vous êtes un développeur
JavaScript expérimenté, vous savez probablement de quoi je parle. C'est Lourdes. Rendez-vous donc sur lodash.com. Il s'agit de Lodash, qui est essentiellement la
version optimisée de Underscore Underscore
existe depuis longtemps. Il possède de nombreux moteurs utilitaires
pour travailler avec des objets, des chaînes, des tableaux, etc. Donc, si vous regardez dans
la documentation, nous pouvons voir
ici toutes
les fonctions utilitaires dont nous disposons pour travailler
avec différents types. Nous avons de nombreuses fonctions
utilitaires pour travailler avec des tableaux, des nombres, des chaînes,
des objets, etc. Lodash est donc extrêmement puissant. Dans cette conférence,
je vais
vous montrer comment l'utiliser dans
votre application de nœud. Donc, de retour dans le terminal,
NPM installe lodash. Notez donc que dans la
version actuelle, j'utilise 4.17 0.21. Bon, maintenant, revenons au code. Donc, dans le
modèle de notre utilisateur en haut, je vais importer Lodash Il faut donc Lodash. Maintenant, par convention, nous stockons le résultat dans une constante
appelée trait de soulignement Vous pouvez l'appeler comme vous le souhaitez, vous pouvez l'appeler Lodash, mais par convention, nous utilisons soulignement parce
que c'est court et clair Maintenant, cet
objet de soulignement que nous
avons ici possède une méthode
utilitaire appelée pick so underscore point PIC Nous lui donnons un objet. Dans ce cas, notre objet utilisateur, puis transmettez un tableau
de propriétés dans cet objet utilisateur que
nous voulons sélectionner. Et cela
renverra un nouvel objet avec uniquement ces propriétés. Donc, dans ce tableau, je vais transmettre le
nom et l'e-mail. Ainsi, lorsque nous appelons
cette méthode de sélection, nous obtenons un nouvel objet avec ces deux propriétés,
nom et e-mail. Maintenant, au lieu de
répéter manuellement le point utilisateur, nous pouvons utiliser cette méthode Pi. C'est plus élégant. Nous pouvons donc remplacer cet objet ici par ce que nous obtenons
de la méthode PI. est aussi simple que ça.
Maintenant, peut-être ici, vous souhaiterez peut-être également inclure
la propriété IR. C'est ainsi que nous
utilisons la méthode PIC. De même, nous pouvons
modifier ce code, et au lieu de répéter le point de corps du point de
demande, le point de corps du point de
demande, le point corps du point de
demande
avec le point de soulignement PIC Je vais donc
remplacer cet objet point
de soulignement. Nous lui avons fait la demande point py. Maintenant, ici, nous
avons peut-être 50 propriétés. Un utilisateur malveillant peut
nous envoyer des propriétés à
stocker dans la base de données. Nous voulons seulement en
sélectionner quelques-uns. Nous passons donc un tableau. Nous ne sommes intéressés que par le
nom, l'e-mail et le mot de passe. OK, nous créons donc
l'utilisateur et l'
enregistrons , puis nous renvoyons cet objet
personnalisé au client. Testons cela une fois de plus pour nous assurer que
tout fonctionne. Donc terminal principal. Lancez l'application. Magnifique. Maintenant, revenons
au Postman Je vais envoyer une nouvelle demande
via le serveur. Envoyer. OK, voici notre
nouvel objet utilisateur. Nous n'avons qu'un identifiant, un
nom et un e-mail. ce jour, dans toutes ces
demandes, j'ai envoyé des mots de passe très
simples. Si vous souhaitez renforcer la complexité des
mots de passe, il existe un package NPM
construit sur Joy, appelé
Joi
password Complexity appelé
Joi
password Revenons donc dans Google, recherchez
Joy Password Complexity. C'est le package NPM. Ainsi, vous pouvez
configurer un objet qui détermine la
complexité du mot de passe dans votre application. Nombre minimum de
caractères, maximum, nombre de minuscules ou de
majuscules que vous souhaitez avoir, combien de chiffres, etc. Le nom du package
est donc Joy Password Complexity. Dans ce cours, nous n'allons pas l'
utiliser car c'est quelque chose que vous pouvez
faire vous-même. , notre nouveau point de
terminaison d'API est en bon état, mais nous stockons nos
mots de passe en texte brut, ce qui est très, très mauvais. Dans la prochaine conférence,
je vais donc vous montrer comment
hacher ces mots de passe
6. Hachage des mots de passe: Dans cette conférence,
je vais
vous montrer comment hacher des mots de passe Pour cela, nous allons utiliser une bibliothèque très populaire
appelée B crypt Donc, ici, dans le terminal, installons B crypt Installez. Notez la
version que j'utilise. Il s'agit de la version 5.1 0.1. Maintenant, je vais
créer un fichier Playground, afin que vous appreniez à travailler
avec cette bibliothèque BCRP, puis nous allons
prendre ce code
et le mettre dans une route pour hacher le
mot de passe des Créons donc un nouveau
fichier, hash point js. Dans ce fichier,
nous devons d'abord charger le BCRP Cela permet de conserver un objet. Nous le stockons ici. Crypte B. Maintenant, pour avoir un mot de passe, il
nous faut un sel. Qu'est-ce qu'un sel ? Eh bien, imaginez que notre mot de passe
est un, deux, trois, quatre. Lorsque nous le hachons,
imaginons que nous obtenions
une chaîne comme celle-ci Maintenant, cet
algorithme de hachage est un moyen. Donc, si nous avons A, B, CD, nous ne pouvons pas le déchiffrer et
obtenir un, deux, trois, quatre Donc, du point
de vue de la sécurité, c'est génial. Si un pirate informatique
consulte notre base de données, il ne peut pas déchiffrer
ces mots de passe hachés Cependant, ils peuvent
compiler une liste de mots de passe
populaires et les hacher Ensuite, ils peuvent consulter
la base de données de notre application. Ils trouvent ce mot de passe de hachage, et ils savent que ABCD
représente un, deux, trois, quatre C'est pourquoi nous avons besoin d'un SALT. Comme SALT est essentiellement une chaîne aléatoire qui est ajoutée avant ou
après ce mot de passe. Le mot de
passe haché obtenu sera donc différent. Chaque fois en fonction de l'
assaut utilisé. OK, laissez-moi
vous montrer ceci en action. Nous appelons donc ici B
crypt point Gen SLT. Notez que cette méthode existe
en deux versions. Le premier est asynchrone. Le second est synchrone. des méthodes
asynchrones car, Il est recommandé de toujours utiliser comme je vous l'ai dit au
début du cours,
dans les applications de nœuds, nous
n'avons qu'un seul thread Nous ne voulons pas occuper
ce fil car nous ne pourrons alors pas
servir d'autres clients. Nous appelons donc GenSLT
comme argument. Nous passons le nombre de froncements de sourcils. Nous voulons exécuter cet algorithme
pour générer le SLT. Plus ce chiffre est élevé,
plus il faudra de temps pour
générer le sel. De plus, le SOT
sera plus complexe et
plus difficile à déchiffrer. La valeur par défaut est donc dix. Nous allons l'utiliser maintenant
car il s'agit d'une méthode
asynchrone. Nous pouvons soit passer un
rappel ici, et c'est ce que vous pouvez voir dans
leur documentation officielle, ainsi que dans de nombreux
tutoriels sur le Web Mais cette méthode comporte également une surcharge qui
renvoie une promesse. Ainsi, au lieu de
passer un rappel, nous recevons une promesse, nous l'attendons, puis nous prenons le sel Nous devons donc maintenant intégrer cela dans une fonction acing telle que run OK, bloquons donc ce
sel sur la console. Et enfin, appelons
cette fonction d'exécution. Maintenant, de retour dans le
terminal, le nœud doit utiliser Js. Voici donc un exemple de sel. Vous pouvez voir le nombre de cartouches que nous avons utilisées inclus dans le sel. Donc, si nous en utilisons 20 ici au lieu
de dix, nous en aurons 20. Nous avons donc ici une
longue chaîne aléatoire qui est incluse dans le hachage
de nos mots de passe Ainsi, chaque fois que nous
hachons notre mot de passe
avec un nouveau Salt, nous obtenons des résultats différents Maintenant que nous avons un Salt, nous pouvons l'utiliser pour
hacher notre mot de passe Nous avons une autre méthode ici sur cet objet de crypte B
qui est le hachage Nous lui communiquons donc nos données. Imaginons que notre
mot de passe soit un, deux ,
trois, quatre,
et ajoutons-le. Et encore une fois, regardez, le troisième
argument peut être un rappel. Nous n'allons pas nous en servir. Au lieu de cela, nous allons obtenir la promesse
renvoyée par cette méthode. Nous attendons donc cette promesse et
obtenons le mot de passe haché. Alors maintenant, enregistrons également cela
sur la console. Haché. OK, revenez dans le nœud
terminal, hash ou chase OK, écoutez, en première
ligne, nous avons notre sel. Sur la deuxième ligne, vous pouvez également
voir le sel ici. Le SALT est donc inclus
dans le mot de passe haché. Cela est inclus parce que plus tard, lorsque nous voulons
authentifier l'utilisateur, nous voulons valider son
nom d'utilisateur et son mot de passe L'utilisateur envoie donc un
mot de passe en texte brut. Nous devons le hacher à nouveau, mais nous devons avoir
le sel d'origine qui a été utilisé pour
générer ce hachage Ainsi, lors de la comparaison du mot de passe en texte
brut avec le mot de passe haché, B crypt doit connaître le sel d'origine
utilisé pour hacher Maintenant que vous savez
comment fonctionne B Crypt, prenons ces deux lignes et ajoutons-les dans
notre gestionnaire d'itinéraires Alors coupez-les d'ici. Passons à users dot js. OK, voici notre objet utilisateur. Passons ces lignes ici. Nous générons donc un sel, puis nous devons avoir
le mot de passe. Au lieu d'un,
deux, trois, quatre, nous allons utiliser un mot de passe
utilisateur point. C'est un mot de passe en texte brut. Nous le hachons donc avec un
sel, puis nous le réinitialisons. Donc, mot de passe utilisateur point. Maintenant, en haut, nous
devons également importer une crypte B, donc une crypte B constante Nous l'avons configuré pour exiger Bcrypt. Maintenant, ici dans Compass, je souhaite supprimer la collection de l'
utilisateur car tous les utilisateurs que
nous avons jusqu'à présent ont passe en texte brut. Supprimez donc. C'est bon. Maintenant, de retour dans le terminal, lançons le mod Node. Ensuite, ici à Postman, nous allons
envoyer une nouvelle demande S. Magnifique. Nous avons donc ici un nouvel utilisateur. De retour dans Compass, actualisons la liste. Nous avons la collection de l'utilisateur, et voici notre nouvel utilisateur
avec un mot de passe haché Magnifique. Nous avons donc implémenté ce point de terminaison
pour enregistrer de nouveaux utilisateurs. Nous en avons terminé ici. Ensuite, nous allons examiner l'
authentification des utilisateurs
7. Authentifier les utilisateurs: Très bien, alors dans
le dossier routes, ajoutons un nouveau fichier. Nous appelons cela logins
dojs ou auth dot js. L'un ou l'autre fonctionne, mais
l'authentification est plus courante. Alors, authentifiez Js. Encore une fois, vous gagnez du temps, je vais emprunter du code. Passons donc à users dot js. Je vais copier tout le code que nous avons écrit dans cette section, puis le coller dans auth point js Avant d'
entrer dans les détails, passons à l'index point JS. Importez
ce nouveau module en un clin d'œil. Donc Cs OT, nous l'avons défini
pour requérir les routes OT. Donc, si nous avons une demande
à ce point de terminaison, slash API OT ou à l'un de
ses points de terminaison enfants, nous allons la
déléguer au routeur OT La vue d'ensemble est donc terminée. Regardons maintenant les détails. Donc, de retour dans le module Auth, en haut,
nous devons d'abord valider le
corps de la demande Mais cette
fonction de validation que nous avons ici, c'est celle que nous avons
importée depuis notre module utilisateur. Cela confirme donc cela. Dans le corps de la demande, nous avons trois propriétés : le
nom, l'e-mail et le mot de passe. Et dans l'application
du monde réel, vous pouvez avoir d'autres propriétés dans
le cadre de l'enregistrement d'un utilisateur. Cette fonction de validation sert donc
à valider un nouvel utilisateur. Il ne s'agit pas de valider
l'e-mail et le mot de passe que nous attendons de ce point
de terminaison Nous avons donc besoin d'une fonction de
validation différente. Je vais donc supprimer cette fonction de
validation d' ici et définir une
fonction de validation distincte dans ce module. Maintenant, pour gagner du temps,
je vais aller dans le module
utilisateur et copier
cette fonction de validation. Nous avons donc un utilisateur validé. Copions-le de nouveau
dans le module Auth, collons-le ici, puis
modifions-le pour le valider Nous pouvons maintenant modifier le
paramètre à demander. Maintenant, pour cet objet de schéma, nous n'avons besoin que de deux propriétés,
e-mail et mot de passe. Supprimons donc le
nom et c'est terminé. Pour en revenir à notre gestionnaire d'itinéraires, il s'agit de notre première validation Ensuite, nous devons nous assurer que nous avons un utilisateur
avec un e-mail donné. Nous chargeons donc l'utilisateur. Si nous n'avons pas l'utilisateur, nous appliquons ici
l'opérateur not. Si nous n'avons pas l'utilisateur, nous devons envoyer une
erreur 400 au client,
ce qui signifie que l' e-mail ou le mot de passe de la demande
et du message doivent être invalides. Notez qu'ici, je n'
envoie pas de quatre ou quatre, ce qui signifie qu'il n'a pas été trouvé,
car nous ne voulons pas dire au client pourquoi l'
authentification échoue. Nous ne voulons pas
savoir si cet e-mail est correct ou si le mot de passe est correct. Nous ne voulons donc pas dire que nous
n'avons aucun utilisateur
avec un e-mail donné. Nous disons simplement au client
qu'il s'agit d'une mauvaise demande. Il ne dispose pas des bonnes
données à traiter. C'est donc pour valider le nom d'utilisateur et l'
e-mail dans ce cas Ensuite, nous devons
valider le mot de passe. Pour cela, nous devons utiliser le BCRP. Supprimons donc tout ce code. Cet objet B crypt que nous
avons possède une méthode de comparaison. Nous l'utilisons pour comparer un mot de passe en texte brut
à un mot de passe haché Notre mot de passe en texte brut
se trouve donc dans
le corps de la demande,
et notre mot de passe de hachage se trouve
dans ce mot de passe utilisateur Ainsi, comme vous l'avez vu précédemment, ce mot de passe de hachage
inclut le SLT Ainsi, lorsque nous appelons la méthode de
comparaison, B crypt va
récupérer ce sel et l'utiliser pour réinitialiser ce mot de passe en texte
brut S'ils sont égaux,
cela redeviendra vrai. Nous devons donc attendre cette promesse et stocker le
résultat ici dans un mot de passe valide. Maintenant, si le mot de passe n'
est pas valide, encore une fois, nous allons
renvoyer une erreur 400 avec ce message vague, e-mail ou mot de passe
invalide. Je vais donc simplement le copier
et le coller ici. Enfin, si nous en
arrivons là, cela signifie
qu'il s'
agit d'un identifiant valide. Donc pour l'instant, je
veux juste envoyer une valeur simple et
vraie au lint.
8. Tester l'authentification: Pour l'instant, testons
cette voie d'authentification. Avant cela, donc un ou un point est. Ici, j'ai oublié de
mentionner Load Joy. Permettez-moi donc de le faire rapidement. Last Joy, configurez ce
paramètre pour exiger Joy. OK. Et en bas
pour la fonction de validation, nous devons renvoyer
ici la demande de validation par points du
schéma. OK, donc tout est prêt. Ouvrons postmin. Je vais donc
ouvrir un nouvel onglet. Sélectionnons le post ici. Permettez-moi de saisir le point de terminaison. C'est TP, hôte local OT, API OT. Et dans le corps de la demande, je vais envoyer le GSN. Permettez-moi donc de sélectionner Json ici. Nous avons maintenant deux paramètres. Le premier est donc le courrier électronique. L'e-mail que nous
avons utilisé est un 23, quatre, cinq, six, sept, au tarif gmail.com Et notre mot de passe est un, deux, trois, quatre, cinq. Permettez-moi donc d'envoyer cette demande, SN. Magnifique. Nous avons
un statut 200. OK. Et voici notre réponse. Maintenant, laissez-moi changer
le mot de passe ici
en un autre, par exemple 67
, puis renvoyer la demande. voyez, nous avons une demande incorrecte de 400
et la commande générique, qui est un
e-mail ou un mot de passe invalide. Maintenant, changeons l'e-mail en un autre avec
le mot de passe correct. Donc quelque chose comme ça. Et permettez-moi de vous envoyer à nouveau la
demande. Alors envoyez. voyez, encore une fois, nous avons
une mauvaise demande de 400 et le message générique qui est un
e-mail ou un mot de passe invalide. Notre point de
terminaison d'authentification fonctionne donc correctement. Dans la prochaine conférence, nous allons voir la réponse
que nous envoyons ici et la remplacer ce que nous appelons un jeton Web
adjacent.
9. Jetons Web JSON: Nous avons donc un point de terminaison
pour authentifier les utilisateurs. Maintenant, nous devons modifier
la réponse ici, et au lieu de
renvoyer une valeur vraie, nous devons renvoyer
un jeton Web JCN jeton Web AJCN est essentiellement une longue chaîne qui
identifie un utilisateur En guise de métaphore, vous
pouvez le considérer comme votre permis de conduire
ou votre passeport C'est très similaire à ça. Ainsi, lorsque l'utilisateur se connecte
au serveur,
nous supprimons ce jeton Web JCN, qui ressemble à un
permis de conduire ou à un passeport, nous le donnons au client,
puis nous lui disons : « Hé, prochaine fois que vous voudrez
revenir ici et appeler l'un de
nos points de terminaison API, vous devrez présenter Vous devez présenter votre
permis de conduire. Il s'agit de votre identifiant. Sur le client, nous devons donc
stocker ce jeton Web JCN, qui est une longue chaîne, afin de pouvoir le renvoyer au serveur pour
les futurs appels d'API Désormais, le client peut être une application Web ou
une application mobile. S'il s'agit d'une application Web, si vous créez une application
avec angular ou react, vous pouvez utiliser le stockage local. Il s'agit d'un espace
de stockage spécial qui est disponible dans tous les
navigateurs. Si vous créez une application mobile, vous disposez d'une option similaire en fonction de la
plateforme que vous utilisez. Alors maintenant, permettez-moi de vous montrer un
exemple d'AJCNWBTken. Dirigez-vous vers tojwt point II. Sur ce site Web, nous avons ici un débogueur pour travailler
avec JS et Ici, dans la section encodée, vous pouvez voir un exemple réel
de jeton Web AJCN Cette longue chaîne que vous voyez dans la
section encodée représente un JCNOBR. Ainsi, lorsque nous le décoderons, nous obtiendrons un D'accord ? Nous pouvons maintenant voir que
cette chaîne comporte trois parties, et chaque partie est un code couleur. Ainsi, la première partie est rouge, la deuxième est violette et la troisième est bleue. Sur le côté droit, vous pouvez
voir cette chaîne décodée. La partie rouge est donc ce que nous appelons l'en-tête d'
un jeton Web JCN Dans cet en-tête, nous
avons deux propriétés. L'un est L, qui est l'
abréviation d'algorithme qui détermine l'algorithme utilisé pour coder ce jeton. Le type est GWT, qui est un jeton Web JCN Désormais, nous n'avons plus à nous
soucier de cet en-tête. Ce n'est qu'un standard. Ce qui compte pour nous,
c'est la deuxième partie, la charge utile, qui
est la partie violette Nous avons donc ici un objet JCN
avec trois propriétés,
sub, qui est comme un
ID utilisateur, un nom et un administrateur Maintenant, la charge utile que vous voyez est différente de
la charge utile que j'ai
parce que j'ai modifié le fold JS et le webtog et
qu'elle se trouve J'ai donc généré un jeton
Web personnalisé, je l'ai mis ici. Ce que je tiens à
souligner ici, c'est que cette charge utile inclut des
propriétés publiques concernant l'utilisateur Tout comme sur votre passeport, vous avez certaines propriétés vous
concernant, comme votre nom,
votre date de naissance, votre lieu de naissance, etc. Nous avons donc exactement le même
concept pour le jeton Web adjacent. Peut inclure quelques
propriétés publiques de base concernant l'utilisateur. Ainsi, chaque fois que nous
envoyons un jeton du
client au serveur, nous pouvons facilement extraire l'ID
utilisateur de la charge utile Si nous avons besoin de connaître
le nom de l'utilisateur, nous pouvons simplement
l'extraire ici également. Nous n'avons pas à
interroger la base de données, envoyer cet ID pour
obtenir un objet utilisateur ,
puis à extraire
la propriété name. De même,
si vous voulez savoir si l'utilisateur est un utilisateur
administrateur ou non, nous pouvons l'inclure ici. Encore une fois, nous n'avons pas besoin d'
envoyer de requête supplémentaire à la base de données pour voir si l'utilisateur avec un
identifiant donné est administrateur ou non. peut vous inquiéter Cette approche peut vous inquiéter du point de vue de
la sécurité, car vous pensez peut-être que
n'importe qui peut simplement définir cette propriété
d'administrateur sur true, puis il sera traité
comme un administrateur sur le serveur. Mais ce n'est pas ainsi que fonctionnent les potcans
Jason. La troisième partie de
ce jeton Web JCN, qui est en bleu, est
une signature numérique Cette signature numérique est
créée sur la base du contenu de ce JCN WebTken avec
une clé secrète ou privée La clé secrète ou privée n'
est disponible que sur le serveur. Ainsi, si un utilisateur malveillant obtient le JCN WebTken et modifie
la propriété d'administration,
la signature numérique
ne sera pas valide car le contenu du
JCN Nous avons maintenant besoin d'une nouvelle signature
numérique, mais le pirate ne peut pas générer cette signature numérique
car il aura besoin de la clé privée, qui n'est disponible que
sur le serveur. Ainsi, s'ils n'ont pas
accès au serveur, ils ne peuvent pas créer de signature numérique
valide. Et lorsqu'ils envoient ce jeton Web JCN
tempéré au serveur, celui-ci
le refuse Le serveur indiquera qu'il ne s'agit
pas d'un jeton Web JCN valide. Voici donc comment fonctionnent les jetons
Web JCN.
10. Générer des jetons d'authentification: Donc, sur cette page, si vous
regardez les bibliothèques, vous
trouverez
différents modules ou bibliothèques pour
différentes plateformes. Donc,
si vous faites défiler l'écran vers le bas, vous verrez que vous avez Tad net one
C B, C, C plus plus, node, etc. Ouvrons donc le terminal
et installons JCN Webtook et BM et installons ASN D'accord, si vous regardez
le package au format JSON, vous verrez que la version que
nous utilisons est 9.0 0.2. Clôturons donc ceci. Nous avons le chemin pour
authentifier les utilisateurs. Maintenant, nous devons créer un
WebTken JCN avant d'envoyer une
réponse au client Donc, avant cela, vous devez
charger JCN WebTken. Donc, en haut,
demandez à Jason de le répéter, étrangler et de le stocker dans
une constante appelée Génial. Ici, nous allons utiliser la méthode
sinusoïdale de JWT. Donc, JW point sinus pour
accepter deux arguments. premier est la charge utile et le second est le roi
secret ou privé La charge utile peut donc
être une simple chaîne ou un objet comme
celui que vous voyez ici Faisons donc notre objet
avec une seule propriété. Nous inclurons un identifiant de soulignement, et nous l'enverrons à
l'utilisateur point underscore Maintenant, selon le deuxième argument, nous allons l'envoyer à une chaîne. Mais idéalement, vous ne
devez pas stocker votre secret ou votre
clé privée dans votre code source. Plus tard, je vous montrerai comment stocker dans un
environnement où o. Mais pour l'instant,
mettons-le simplement dans le secret de JWT Il n'est pas nécessaire que ce
soit la clé secrète JWT. Cela peut être n'importe quoi,
n'importe quelle chaîne. Mais pour l'instant, utilisons-le. Nous avons donc utilisé une méthode de signature, et par conséquent, nous obtenons un jeton. Stockons-le donc dans une constante
et nous l'appellerons jeton. Et maintenant, nous allons renvoyer ou envoyer la réponse
à notre client sous forme de hook. Donc, revenons
au terminal. Passons en revue. Passons maintenant au facteur. Ici, nous enverrons l'e-mail et le mot de passe
corrects à cette
voie d'authentification. Alors envoyons ceci. Et voici notre jeton Web JCN. Alors laisse-moi le copier. Et revenons
au débogueur. Dans cette section encodée, vous pouvez simplement supprimer
celle-ci et coller
celle que nous copions. Et ici, dans la section
décodée, vous pouvez voir notre objet
que nous envoyons sous forme
de jeton. Nous avons
donc ici la propriété ID, qui est définie sur l'
ID de l'objet dans la base de données Mongaim De plus, nous
avons l'IAT qui indique l'heure actuelle et l'heure laquelle ce jeton est créé. Ceci est utilisé pour H le jeton. Nous avons donc créé avec succès le jeton et l'avons envoyé
en réponse à notre climat. Dans la vidéo suivante,
je vais vous montrer comment inclure cette clé secrète dans
une variable d'environnement.
11. Stockage des secrets dans des variables d'environnement: Plus tôt dans le cours, lorsque je parlais des sujets avancés d'
Express, je vous ai présenté un
package de nœuds appelé Config. Nous utilisons ce package pour stocker les
paramètres de configuration de notre application dans des fichiers JSON
ou des variables d'environnement. Dans cette conférence, nous
allons donc retirer
cette clé secrète et la stocker dans une variable d'environnement
car, comme je vous l'ai déjà dit, vous ne devez jamais stocker vos
secrets dans votre base de code. Dans le cas contraire, ces secrets seront
visibles par toute personne ayant
accès à votre source. De retour dans le terminal, installons le module de configuration. Je peux noter que le
numéro de version est 3.3 0.11. Maintenant, nous devons d'abord créer
un nouveau dossier qui est config. Dans ce dossier, nous ajoutons un fichier de configuration par défaut
qui est le point JSM par défaut Donc, un simple objet SN. Nous pourrions avoir plusieurs
réglages ici. Mais pour l'instant, je
veux juste ajouter un paramètre. C'est la clé secrète de JWT. Maintenant, dans ce fichier GSN par défaut, nous allons le définir
sur une chaîne vide La valeur réelle n'est pas ici. Nous ne faisons donc que définir un modèle pour tous les
paramètres de notre application. Nous devons maintenant créer
un autre fichier contenant variables d'environnement
personnalisées point JS. Notez l'orthographe,
assurez-vous de bien l'écrire. Sinon, ce que je
vais vous montrer dans cette conférence ne fonctionnera
pas sur votre machine. Donc, comme je vous l'ai
déjà dit, dans ce fichier, nous avons spécifié le mappage entre les paramètres de
notre application
et les variables d'environnement. Je vais donc revenir
à notre point par défaut Son, copier tout cela, le coller ici. Voici donc la structure de
notre objet de configuration d'application. Nous voulons maintenant associer
cela au paramètre à une variable d'environnement
appelée clé secrète JWT Mais comme je vous l'ai déjà dit
, il est préférable, comme je vous l'ai déjà dit, de le préfixer par nom de
notre application afin d'éviter paramètre d'application
ne remplace un autre
paramètre d'
application Donc, Fair Wheels aligne la clé secrète
JWT. Maintenant, avec cela, nous pouvons revenir
à notre module Auth, donc Js. C'est donc ici
que nous avons référencé le secret que nous allons
remplacer par un appel
à la méthode Config point get Donc, tout d'abord, nous devons
importer l'objet de configuration. Donc la configuration de CS. Nous l'avons configuré pour
exiger du confit. OK. Maintenant, de retour dans la méthode post, nous appelons config point cat et passons le nom du paramètre de l'
application. Dans ce cas, le secret de JWT K.
Donc maintenant, ce n'est pas un secret. C'est le nom du paramètre de notre
application. La valeur réelle,
le secret réel se trouveront dans une variable d'
environnement. Dernière modification, nous devons
passer à index point js. Lorsque l'application démarre, vous devez vous assurer que cette
variable d'environnement est définie. Dans le cas contraire, nous devons
mettre fin à l'application car notre point de terminaison
d'authentification ne peut pas fonctionner correctement. Encore une fois, en haut, nous chargeons le module de configuration. Config, nous l'avons défini
pour requérir une configuration. Maintenant, une fois de plus,
nous allons appeler config point get pass le nom de l' application définissant
la clé secrète
JWT Maintenant, si cela n'est pas défini, nous allons enregistrer
une erreur fatale. La clé secrète JWT n'est pas définie. Ensuite, nous devons
quitter le processus. Plus haut, vous avez découvert
cet objet de processus. Il s'agit de l'un des objets
globaux du nœud. Nous avons ici une
méthode appelée exit. Nous lui donnons un code, zéro
indique le succès. Tout sauf zéro signifie un échec. Très souvent, nous utilisons exit one si vous souhaitez quitter le
processus en cas d'erreur. Donc, actuellement, je n'ai pas défini
cette variable d'environnement. Lancez l'application
et voyons ce qui se passe. Donc Norman index point JS, OK, regardez, nous avons eu
cette erreur fatale. L'application s'est écrasée, en attente de modifications de
fichiers avant de démarrer. Maintenant, vous pensez peut-être que
l'application est toujours en cours d'exécution parce que
Norman est toujours là. Il n'est pas terminé. Mais si vous allez chez
Postman et envoyez une demande SDDP à
l'application, vous verrez que notre
application ne répond Donc, si l'application plante, Norman fonctionne toujours Norman court toujours. Laissez-moi vous montrer ce que je veux dire. Donc, si au lieu de ne pas utiliser le mod,
je lance une application avec nœud, l'
application se
bloque, et maintenant nous sommes de retour
dans le terminal. Nous ne répondons donc à aucune demande
reçue des clients. Maintenant, définissons la variable d'
environnement. Comme je vous l'ai déjà dit, sur Mac, vous utilisez Export, sous Windows, vous utilisez set pour invite de
commande et la colonne dollar
ENV pour Power Shell Colonne Dollar ENV, roues plates,
soulignement, clé JWT Secret
. Nous l'avons également défini. Disons ma clé de sécurité. Maintenant, exécutons à nouveau l'
application. Index des nœuds ou Js.
OK, c'est beau. Nous le connectons à
Mongadib et si nous
retournons à Postman et envoyons
une autre demande à Login, voici notre fromage valide et jeton
Web signés
avec notre clé secrète, qui est stockée dans
12. Définir les en-têtes de réponse: Ainsi, dans l'
implémentation actuelle, lorsque l'utilisateur se connecte, nous générons un jeton Web JCN et le renvoyons dans le
corps de la réponse Passons maintenant à
l'étape suivante avec cette application. Imaginons que lorsque
l'utilisateur s'enregistre, nous voulons supposer
qu'il est connecté, afin qu'il n'ait pas à
se connecter séparément. Bien entendu, cette exigence ne s'applique
pas à toutes les demandes. Parfois, vous souhaitez obliger l'utilisateur à vérifier
son adresse e-mail. Donc, une fois qu'ils se sont inscrits, vous
leur envoyez un e-mail, ils
cliquent sur un lien. Le processus est donc différent. Mais dans ce cours,
imaginons que Fair Wheels soit une application qui s'exécute
localement dans le cadre d'une location de voiture. Les personnes qui utilisent
cette application sont donc des personnes
qui travaillent dans cette location de voiture. Nous n'avons pas besoin de vérifier
leur adresse e-mail. Donc, le premier jour où
ils rejoignent la boutique, ils doivent créer un compte, et boum, ils sont connectés. Passons donc au module de notre
utilisateur. OK, voici la méthode de publication. C'est ici que nous
enregistrons un nouvel utilisateur. Maintenant, si vous regardez la
réponse que nous renvoyons ici, nous renvoyons un objet
avec ces trois propriétés. Nous pouvons maintenant ajouter le
jeton Web JCN en tant que propriété supplémentaire ici, mais c'est un peu moche car ce n'est pas la
propriété d'un utilisateur Une meilleure approche consiste à renvoyer le jeton Web JCN
dans un en-tête SDDP Donc, tout comme nous avons
des en-têtes dans notre requête, nous avons également des en-têtes dans
notre objet de réponse Je vais donc retourner à notre module Auth et emprunter cette ligne de code
pour générer le jeton Copiez-le donc maintenant dans
le module de l'utilisateur. Avant d'envoyer la
réponse au client, nous générons le jeton,
puis nous appelons un en-tête à point de
réponse. Avec cela, nous pouvons définir un en-tête. Maintenant, pour tous les en-têtes personnalisés que nous définissons dans
notre application, nous devons les préfixer
par X. Maintenant, nous leur donnons un nom arbitraire comme authentication Il s'agit du premier argument, qui est le nom de l'en-tête. Le deuxième argument
est la valeur, qui est dans ce
cas notre jeton. Donc, avec cette simple modification, nous définissons cet en-tête
, puis nous envoyons cette réponse
au client. D'accord ? Maintenant à la ligne 20, nous utilisons JWT
ainsi que le module confit Nous devons donc
les importer par le haut. Donc, nous avons défini ce paramètre pour qu'
il nécessite un jeton Web JCN. Et de même, pour une configuration constante, nous l'avons définie pour requérir une confit Maintenant, testons cela. Ainsi,
lors de la dernière conférence, j'ai lancé l'application avec le mode
node au lieu du mode nor. Mes modifications ne sont donc pas visibles. Nous devons donc arrêter l'
application et l'exécuter en mode
nœud. OK, c'est beau. Maintenant, de retour dans Postman sur
cet onglet pour
enregistrer un utilisateur, je vais remplacer cet e-mail par un e-mail que je
n'ai pas enregistré auparavant Envoyé. OK, jetez un œil. Voici donc le corps de la
réponse exactement comme avant. Maintenant, dans l'onglet Headertab Look, nous avons ce nouvel
en-tête, le jeton X. Et cela est réglé sur
notre JCN WebTken. Ainsi, dans notre application cliente, lorsque nous enregistrons un utilisateur, nous pouvons lire cet en-tête. Nous pouvons stocker ce JCN
WebTGen sur le client. Et la prochaine fois que nous ferons
un appel d'API, nous l'enverrons au serveur.
13. Encapsuler la logique dans des modèles de mangouste: Maintenant, il y a un problème dans
notre implémentation actuelle. Dans le module utilisateur de la ligne 22,
voici comment nous générons
un jeton Web JCN Nous avons exactement le même noyau
dans le module Auth sur la ligne 20. Examinez maintenant la charge utile
de ce jeton Web JCN. Dans cette charge utile,
nous n'avons actuellement que la propriété ID Demain, il y a de fortes chances que
nous ajoutions une autre propriété à ce salaire,
peut-être le nom de l'utilisateur, peut-être son adresse e-mail,
peut-être son rôle. Nous voulons savoir s'il
existe un utilisateur administrateur ou non. Avec l'implémentation actuelle, chaque fois que nous voulons
modifier cette charge utile, nous devons nous rappeler
que nous devons passer à un autre module et apporter exactement
la même modification Et à long terme, vous
allez oublier
ces exigences. Dans cette conférence,
je vais donc vous montrer comment encapsuler cette
logique en un seul endroit Maintenant, où devons-nous
déplacer cette logique ? Un programmeur amateur
peut penser : « D'accord, je vais créer une fonction
comme générer un jeton
d'authentification, placer cette fonction quelque part pour
que nous puissions la réutiliser, peut-être dans un autre
module que nous pouvons importer à la fois dans Earth
et dans les modules utilisateur ». Et avec cela, nous avons la
logique en un seul endroit. Eh bien, c'est vrai. Cela fonctionne. Mais avec cette approche, vous vous retrouverez avec de nombreuses fonctions
éparpillées. Dans la programmation orientée objet, nous avons un principe appelé principe de l'expert en
information. Cela signifie un objet qui possède suffisamment d'informations et qui est
expert dans un domaine donné. Cet objet doit
être responsable de la
prise de décisions et de l'
exécution des tâches. À titre d'exemple concret,
pensez à un chef. Un chef possède des
connaissances culinaires. C'est pourquoi l'acte de cuisiner dans un restaurant est effectué par un
chef et non par un serveur Le serveur n'a pas
les bonnes connaissances, les bonnes informations sur
la cuisine au restaurant Donc, si le chef est un objet, nous devons lui confier
l'acte de cuisiner. Maintenant, prenez ce principe
et appliquez-le dans ce code. Alors, dans le cadre de la création de
ce Chase et de ce jeton Web, quoi avons-nous besoin dans la charge utile Nous avons besoin de l'identifiant de l'utilisateur. Demain, nous aurons peut-être besoin du nom de l'utilisateur
ou de son e-mail. Toutes ces informations sont donc encapsulées ici
dans l'objet utilisateur C'est donc l'
objet utilisateur qui doit être responsable de la génération de
ce jeton d'authentification. Donc, la fonction
que j'ai écrite ici, générer un jeton d'authentification, ne devrait pas être suspendue quelque part
dans un module. Cela devrait être une méthode
dans l'objet utilisateur. Nous avons donc ici un objet utilisateur que nous chargeons depuis la base de données. Nous devons ajouter une méthode comme celle-ci dans
cet objet utilisateur. Utilisateur qui génère le jeton
d'authentification. Et cela nous donnera un
gage, aussi simple que cela. Maintenant, comment pouvons-nous ajouter cela ? Nous devons accéder à notre
module utilisateur où nous définissons le modèle utilisateur et y apportons une modification
simple. C'est bon. Ici, dans notre modèle utilisateur, nous devons extraire la définition
de ce schéma et la
placer dans une constante distincte car nous allons
travailler avec celle-ci séparément. Je vais donc
sélectionner tout ce code. Ainsi, lors de la création du
modèle utilisateur en tant que deuxième argument, nous transmettons le schéma utilisateur, et nous ne l'avons pas encore
créé. C'est ce que nous allons faire maintenant. Donc, schéma utilisateur constant, et nous l'avons défini sur cette
expression comme ceci. OK. Voici donc notre schéma utilisateur. Vous souhaitez maintenant ajouter une
méthode dans ce schéma. Donc, le schéma utilisateur selon lequel
nous avons une propriété, des méthodes, renvoie un objet. Nous pouvons ajouter des paires
clé-valeur supplémentaires dans cet objet. Nous pouvons donc ajouter une clé, générer une
authentification ou un jeton. Nous lui attribuons une fonction.
Donc, paire clé-valeur. Lorsque nous faisons cela, notre objet
utilisateur aura une méthode appelée generate
authentication token. Maintenant, dans cette fonction, nous pouvons avoir des paramètres. Donc, si nous avons un paramètre ici, alors lors de l'appel de cette méthode, nous pouvons passer des arguments. Dans ce cas, nous n'avons pas
besoin de paramètres, me suffit
donc de saisir cette logique pour
générer le jeton, il me suffit
donc de saisir
cette logique pour
générer le jeton, de le
récupérer d'ici et de
le déplacer dans cette nouvelle méthode. Ici, dans la charge utile, nous avons besoin du D de l'
utilisateur. Comment y parvient-on ? Eh bien, cette méthode fera
partie de l'objet utilisateur. Ainsi, afin de référencer
l'objet lui-même, nous remplaçons user par celui-ci. Cela signifie que vous
devez utiliser ici la syntaxe normale des
fonctions. Vous ne pouvez pas le
remplacer par une fonction flèche. Parce que, comme je vous l'ai déjà dit, les fonctions de
flèche n'
ont pas leur place ici. Cette
fonction en forme de flèche fait référence à
la fonction d'appel. Nous utilisons donc généralement fonctions de
flèche pour les fonctions
autonomes. Si vous souhaitez créer une méthode
faisant partie d'un objet, vous ne devez pas utiliser de fonction
flèche. Maintenant, inversons cela. Nous avons donc le jeton, et enfin, nous le
renvoyons aussi simplement que cela. Nous faisons ici référence à
JWT et aux modules de conflit. Nous devons donc l'importer
par le haut. Je vais donc revenir à
notre module Auth en haut. Nous n'avons plus besoin de ces déclarations
obligatoires. Je vais donc
les récupérer d'ici. Et placez-les au-dessus
du module utilisateur. Maintenant, revenons dans le module
d'authentification, nous générons le jeton
puis nous l'envoyons au client. Nous devons apporter les mêmes
modifications dans le module de notre utilisateur. Module utilisateur, nous
supprimons cette ligne et définissons le jeton sur l'utilisateur
qui génère AuthToken Enfin, testons cela et vérifions-nous que
tout fonctionne. Je vais donc enregistrer
un nouvel utilisateur ici. Envoyez, ma belle. Et voici notre jeton
d'authentification.
14. Middleware d'autorisation: Au début
de cette section,
nous avons donc décidé de protéger
les opérations qui modifient les données et de les rendre accessibles uniquement aux utilisateurs
authentifiés Passons donc à nos entreprises, point CHASE Piers, la méthode de publication
pour créer une nouvelle entreprise. Ce point de terminaison d'API ne doit être appelé que par un utilisateur
authentifié. Alors, comment pouvons-nous faire appliquer cela ? Eh bien, ici, nous avons
suivi une logique comme celle-ci. Nous devons lire les en-têtes des
demandes. Cet objet de requête possède donc
une méthode appelée header. Ici, nous indiquons le
nom de l'en-tête, c'
est-à-dire le jeton X. Nous attendons un jeton Web JCN
stocké dans cet en-tête. Nous le stockons donc
sous forme de jeton constant. Maintenant, nous voulons valider cela. Si cela est valide, nous donnons accès à
ce point de terminaison d'API. Dans le cas contraire, nous vous enverrons
une réponse comme celle-ci. Réponse pour le
code d'état de quatre contre un, ce qui signifie que le
client n'a pas les informations d'authentification nécessaires
pour accéder à cette ressource. Voici donc la situation dans son ensemble. présent, nous ne voulons pas
répéter cette logique
au début de chaque
gestionnaire de route qui modifie Nous devons donc intégrer cette logique
dans une fonction intergicielle. N'oubliez pas que nous avons parlé
des fonctions du middleware dans
la section intitulée Sujets avancés d'
Express Nous avons donc intégré cette logique dans
une fonction intergicielle, puis nous pouvons appliquer
cette fonction aux gestionnaires d' itinéraires qui doivent modifier
les données. Laisse-moi te montrer. Alors partons d'ici. Bien, nous voulons ajouter ici un nouveau dossier appelé middleware Nous avons donc placé toutes nos fonctions
intergicielles ici. Dans ce dossier, nous avions
un nouveau fichier. Nous voulons maintenant
définir une fonction appelée OT qui prend trois paramètres, réponse à la
demande et la suivante, nous avons utilisée pour passer le contrôle à la fonction intergicielle suivante dans le pipeline de
traitement des demandes Si ce concept ne vous semble
pas familier, vous devez retourner
à la section intitulée Express Advanced Topics, car nous
y explorons en détail les
fonctions du middleware Ici, dans cette fonction, nous devons implémenter cette
logique. Nous obtenons le jeton. Il y a de fortes chances que nous n'
ayons aucun jeton. Dans ce cas, nous renvoyons une réponse 41 avec un
message comme celui-ci. Accès refusé. Aucun jeton n'est fourni. Cela aide donc le
client à
comprendre pourquoi il ne peut pas
accéder à cette ressource. Maintenant, sinon,
il y a un jeton. Nous devons vérifier qu'il
s'agit d'un jeton valide. Nous devons donc utiliser ici
notre module de jeton Web JCN. Donc, en haut,
exigeons le jeton Web JCN et stockons-le dans JW Nous appelons maintenant jwt point Verifi. Comme premier argument,
nous passons le jeton, et comme second argument, nous passons la clé secrète
pour décoder ce jeton Nous avons donc stocké cette clé secrète
dans une variable d'environnement. Nous devons utiliser un
module de configuration pour les lire. Exigez donc une configuration
et stockez-la ici. Donc, comme avant,
nous appelons config point g JWT Ccret key. Maintenant, cette méthode de vérification vérifiera notre JCN
WebTken S'il est valide, il le décodera et
renverra la charge utile. Nous obtenons donc ici la charge utile
décodée. Toutefois, si ce
jeton n'est pas valide, il déclenchera une exception. Nous devons donc envelopper cette ligne
avec un bloc de cache try. Essayez donc Cache, nous
obtenons une exception. Si nous arrivons ici, nous voulons informer le client qu'il s'
agit d'un jeton non valide. Nous avons fixé ce statut à
400 car il y a une mauvaise demande car ce que le client nous envoie ne contient pas les
bonnes données. Envoyez donc un jeton non valide. Encore une fois, avec ce message d'erreur, nous pouvons résoudre les problèmes
d'authentification Donc, si sur le client, nous ne pouvons pas accéder à un point de terminaison d'API donné, nous examinerons le message d'erreur. Nous nous rendons compte que nous envoyons
un jeton non valide. Ensuite, nous examinerons la logique du client selon lequel nous obtenons le jeton et l'
envoyons au serveur. Voici donc notre bloc de cache. Maintenant, revenons au bloc des trois, où nous avons la masse salariale. Nous pouvons donc le mettre
dans la demande. Donc, à notre objet de requête, nous y ajoutons la propriété user, et nous la définissons sur ce décodage Tout à l'heure, nous
n'avons mis que l'identifiant de l'
utilisateur dans la charge utile Laisse-moi te montrer.
Passons donc à notre module utilisateur. Voici le schéma de notre utilisateur. Nous avons ajouté cette méthode de génération de jeton
d'authentification. Nous avons créé le JCN WebTken
et voici notre charge utile. Ainsi, lorsque nous décoderons ce JWT, c'est l'objet que nous obtiendrons Et nous allons le mettre dans la
requête en tant qu'objet utilisateur. Ainsi, dans notre gestionnaire d'itinéraires, nous pouvons accéder à request point user point underline
point ID et SOW D'accord ? Ainsi, dans le bloc tri, nous définissons request point user, puis nous devons passer le contrôle
à la fonction middleware suivante dans le pipeline de
traitement des demandes Dans ce cas, il s'agit de notre
gestionnaire d'itinéraires. Nous appelons donc le suivant. Donc, comme je vous l'ai déjà dit,
dans les fonctions middleware, soit
nous mettons fin au
cycle sl de réponse à la
requête , soit nous passons le contrôle à la fonction middleware
suivante Maintenant, juste un petit
problème dans ce code, au cas où nous n'aurions pas de jeton, nous allons envoyer cette
réponse au client. Mais je veux m'assurer que
nous quittons cette fonction. Très bien, nous en avons terminé avec
notre fonction intergiciel. Maintenant, à la fin, nous avons défini les exportations par points du
module OTO, un raccourci pour cela
consiste à le définir ici. Nous avons donc défini les exportations par points du module, nous lui avons attribué une fonction. Nous n'en avons pas besoin ici. Ensuite, nous pourrons nous
débarrasser de la ligne 17. Terminé.
15. Protéger les routes: Maintenant que nous avons une fonction
middleware, nous pouvons passer à index point JS.
Regardez, nous appliquons ici des fonctions
middleware Nous pouvons donc l'ajouter ici, puis il sera exécuté
avant chaque gestionnaire de route Mais nous ne voulons pas le
faire car tous les points de terminaison de l'API
ne
doivent pas être protégés Certains de nos points de terminaison d'API
doivent être publics, comme l'enregistrement d'
un utilisateur, la connexion
ou l'obtention de la liste des
entreprises ou des clients Dans ce cas,
nous voulons donc appliquer cette fonction intergicielle manière sélective à
certains Revenons donc au module de l'entreprise, voici notre gestionnaire d'itinéraires postaux Le premier argument est un itinéraire. Le second est
optionnellement un intergiciel, et le troisième sera le
véritable gestionnaire de route Passons donc au début,
conférons cette fonction d'intergiciel
. Donc, exigez. Nous devons maintenant monter d'un
niveau, puis accéder
au dossier middleware et
charger le module Earth Nous le récupérons et le mettons ici. Enfin, ici
dans la méthode post, nous transmettons OT en
tant que fonction middleware à
exécuter avant cette autre fonction
middleware, qui est dans ce cas Alors maintenant, testons
cela dans Postman. Je vais ouvrir un nouvel onglet,
envoyer une demande de publication au point de terminaison de
l'entreprise. Donc, hôte local STDP,
API Companies. Maintenant, dans ce cas, je ne m'
inquiète pas pour le
corps de la demande. Je veux juste savoir si nous pouvons appeler ce point de terminaison d'API ou non. Alors envoyez OK, regardez, nous avons reçu cette erreur 401 ou une erreur
non autorisée. Et voici le message d'erreur. Accès refusé, Noto peut le fournir. Fournissons maintenant
un jeton non valide. Nous allons donc dans l'onglet des en-têtes, définissons la clé qui est le jeton X. J'ai mis un jeton non valide, envoyé, nous en avons reçu 400 ou
une mauvaise demande avec ce message. Jeton non valide.
Magnifique. Enfin, revenons à notre
registre, en utilisant un onglet. Nous avons un jeton
d'authentification valide. Copions-le donc
dans le troisième onglet. Mets-le ici, puis envoie-le. OK, maintenant nous avons reçu une mauvaise demande, mais ce n'est pas à cause
de l'authentification. Cela est dû au fait que nous nous attendions à la propriété name
figure dans le corps de la demande. Donc, si j'ajoute un
objet JSON ici dans le corps, nommez la nouvelle entreprise. Maintenant, nous devrions être bons. Envoyer.
Nous avons donc reçu 200 réponses, et voici la nouvelle société. Donc, à titre d'exercice, je souhaite que vous appliquiez cette fonction
intergicielle à d'autres gestionnaires d'itinéraires
qui
16. Attirer l'utilisateur actuel: Dans de nombreuses applications, nous avons parfois
besoin d'obtenir des informations sur l'utilisateur
actuellement connecté. Dans cette conférence,
nous allons donc ajouter un nouveau point de terminaison d'API pour
obtenir l'utilisateur actuel. Passons donc à notre module utilisateurs. Actuellement, nous n'avons qu'
un seul gestionnaire de route. C'est pour créer un nouvel utilisateur. Nous devons maintenant ajouter un autre
gestionnaire pour les méthodes get. Maintenant, ajoutez un chemin ou un itinéraire. Nous pouvons passer un paramètre, mais cela signifie que le client doit envoyer l'
identifiant au serveur. Bien que cette approche
soit parfaitement acceptable, il arrive parfois que,
pour des raisons de sécurité, vous ne souhaitiez pas
avoir un point de terminaison comme
celui-ci , car je
pourrais alors envoyer l'identifiant d' un autre utilisateur et examiner son
compte où se trouvent certaines informations qui ne devraient
peut-être pas
être visibles pour moi. L'approche que nous utilisons
assez souvent pour obtenir des
informations sur
l'utilisateur actuel consiste donc assez souvent pour obtenir des
informations sur à avoir
un point de terminaison d'API comme moi. Dans ce cas, le client n'
enverra pas l'ID utilisateur. Nous l'obtenons grâce à l'outil Web JCN. Je ne peux donc pas falsifier JCN WebTken de
quelqu'un d'autre car je vous ai dit que
pour ce faire,
je devais créer une
nouvelle signature numérique pour ce Ajoutons donc le gestionnaire de route, requête
asynchrone et la réponse sont envoyées à
ce bloc de code Désormais, ce point de terminaison d'API
ne devrait être disponible que pour les utilisateurs
authentifiés. Nous devons donc ajouter ici
notre intergiciel OT. En haut, chargeons
OT depuis le middleware Auth. Juste pour clarifier, ici, l'auteur
représente l'autorisation, et
non l'authentification, car l'authentification consiste à valider
le mot de passe du nom d'utilisateur Ici, nous voulons voir si l'utilisateur est autorisé à accéder à
une ressource ou non, et c'est une autorisation. Nous ajoutons notre intergiciel ici. Maintenant, avec ce middleware, si un client n'envoie pas de jeton Web JCN
valide,
nous n'arriverons jamais à
ce Cependant, si vous arrivez ici, comme vous l'avez vu lors de l'
implémentation de cette fonction middleware ici, nous aurons un objet utilisateur request
point Nous pouvons donc accéder à la propriété
ID ici. Ainsi, au lieu de transmettre la propriété ID dans le
chemin ou dans la route, nous l'obtenons à partir de request
point user point ID, qui
provient en fait de notre jeton Web JSON. Il s'agit donc d'une approche plus sûre. Maintenant, nous voulons trouver un
utilisateur à l'aide de l'identifiant donné. Nous appelons donc l'utilisateur point fine par identifiant. Pré-transmettez cette valeur, puis attendez la promesse et
obtenez l'objet utilisateur ici. À présent, nous ne voulons pas renvoyer le mot de passe de l'utilisateur
au client. Alors ici, appelons
Select et excluons la propriété du
mot de passe. Dans votre application,
vous souhaiterez peut-être également exclure d'autres
propriétés. Peut-être l'adresse,
peut-être le numéro de téléphone. Nous avons donc ici un objet utilisateur. Enfin, nous l'
envoyons au client. Envoyez donc un utilisateur aussi simple
que cela. Maintenant, testons cela. Ici, dans Postman, je vais ajouter un nouvel onglet,
envoyer une requête Get à l'
hôte local pour 3 000 utilisateurs de l'API Maintenant, au départ, je ne
veux pas envoyer de JCN WebTken. Donc send Xs n'a refusé aucun jeton,
fourni. Magnifique. Passons maintenant à l'onglet des en-têtes. Ajoutez un X ou un jeton ici, puis passez un
fromage marié et un jeton Web SN. Il s'agit de mon compte utilisateur. Nous pouvons voir que le mot de passe est exclu.
17. Déconnexion des utilisateurs: Dans notre module Auth,
nous définissons donc cette route pour
authentifier les utilisateurs. Qu'en est-il de la déconnexion des utilisateurs ? Avons-nous besoin d'un
itinéraire distinct pour cela ? Non, car nous ne
stockons ce jeton
nulle part sur le serveur. Nous n'avons donc pas besoin d'un gestionnaire de route
distinct pour supprimer ce jeton Techniquement, vous
devez donc implémenter la fonctionnalité de déconnexion sur le
client, pas sur le serveur. Ainsi, dans l'application cliente, lorsque l'utilisateur souhaite se déconnecter, il
vous suffit de supprimer ce
jeton du client. Maintenant, j'ai vu des cours
et des didacticiels qui vous
apprennent à stocker ce jeton sur le serveur dans la base de données. Il s'agit d'une très mauvaise pratique
car ces jetons sont comme clés qui permettent à un client d'accéder à des points de terminaison d'API protégés Si un pirate informatique peut
accéder à votre base de données,
il peut voir tous ces jetons
pour les utilisateurs authentifiés Ils n'ont même pas besoin de connaître
le mot de passe d'un utilisateur. Ils peuvent simplement obtenir
leur
jeton d'authentification et
l'envoyer au serveur pour exécuter une
demande au nom d'un utilisateur. Vous ne devez pas stocker de
jetons dans votre base de données. Et si vous savez
ce que vous faites et que vous voulez vraiment stocker
le jeton dans la base de données, assurez-vous de le chiffrer.
Assurez-vous de le hacher Tout comme les mots de passe. Stocker un jeton sous forme de texte brut dans
une base de données revient à obtenir le passeport ou le
permis de conduire de tous les utilisateurs, à les
placer dans un endroit central, puis n'importe quel utilisateur malveillant ayant
accès à cet endroit central, pourra simplement obtenir
ces passeports. Ils peuvent obtenir ces permis de
conduire et imiter d'autres
utilisateurs, d'autres clients Encore une fois, ne stockez pas
les jetons sur le serveur, stockez-les sur le client. Et pour des raisons de sécurité, chaque fois que vous
envoyez le jeton du client au serveur, assurez-vous d'utiliser le protocole HTTPS. Ainsi,
un pirate informatique assis au
milieu du trafic ne peut pas lire le jeton envoyé par le client
au serveur. Les données sont
donc cryptées entre le client
et le
18. Autorisation basée sur les rôles: Jusqu'à présent, nous avons mis en œuvre l'authentification et l'autorisation avec succès. Passons maintenant à
l'étape suivante avec cette application. Imaginons que certaines
opérations, telles que la suppression de données, ne puissent
être effectuées que par les administrateurs Je vais donc vous montrer comment
implémenter une autorisation
basée sur les rôles. Tout d'abord, nous devons passer
à notre modèle d'utilisateur. Voici donc notre schéma utilisateur. Actuellement, nous avons
trois propriétés
: nom, e-mail et mot de passe. Maintenant, nous devons ajouter
une autre propriété pour voir si un utilisateur donné
est un administrateur ou non. Ajoutons donc une nouvelle propriété admin
de type booléen. C'est donc la première étape. Maintenant, je vais aller
dans Mongo DB Compass, prendre l'un de ces utilisateurs et en
faire un administrateur. Alors, éditez. Je vais ajouter un
champ après le mot de passe, et l'ordre n'a pas
vraiment d'importance. va de même pour admin et par défaut, vous pouvez voir que le type
de cette chaîne est une chaîne. Nous allons changer
cela en booléen. Disons donc que c'est vrai
, puis appliquons enfin la mise à jour. J'ai donc ici un utilisateur
qui est un administrateur. Maintenant, lors de la connexion,
je souhaite inclure cette propriété dans notre charge utile
JSON Web Token Ainsi, la prochaine fois qu'ils
enverront ce JCN WebTken au serveur, nous pourrons extraire cette propriété
directement du Nous n'avons pas à obtenir l'identifiant, accéder à la base de données et à voir
s'ils sont administrateurs ou non. Et encore une fois, comme je vous l'ai déjà dit, avec la signature numérique
incluse dans un webtken JCN, un utilisateur malveillant ne peut pas modifier la valeur de son administrateur
pour son S'ils apportent des modifications, ils doivent régénérer
la signature numérique, ce qui nécessite
de
connaître la clé privée que nous avons stockée dans une
variable d'environnement sur le serveur Maintenant, dans notre module utilisateur, lorsque nous générons le jeton
d'authentification, nous voulons ajouter cette
propriété dans la charge utile Voici donc notre charge utile. Ajoutons une nouvelle propriété
: admin. Nous l'avons réglé sur. Ce point est Admin. C'est donc l'avantage d' encapsuler cette logique
dans l'objet utilisateur Il y a donc un seul endroit
que nous devons modifier. Auparavant, nous l'avions
à deux endroits différents. Et avec ce changement de symbole, nous avons dû penser à appliquer ce changement à deux
endroits différents dans le code. Voici donc notre emblème de genou. Maintenant, sur le serveur, nous avons besoin d'une nouvelle
fonction middleware pour vérifier si l'utilisateur actuel est
un administrateur ou non Ici, dans le dossier
middleware, je vais ajouter un
nouveau fichier, admin Nous définissons donc ici un module qui exporte vers une fonction
middleware Et prend une demande, une réponse et une référence à la fonction middleware
suivante dans le pipeline de
traitement des demandes Nous supposons donc ici que
cette fonction d'intergiciel
sera exécutée après
notre fonction sera exécutée après d'
intergiciel d'autorisation Notre fonction d'
intergiciel d'autorisation définit donc demande et non l'utilisateur, nous pouvons
donc y accéder
dans cette Je demande donc à cet
utilisateur qui est administrateur, ou disons que s'
il n'est pas administrateur, nous allons renvoyer l'état de
la réponse. Nous avons défini le statut 24 sur
3, ce qui est interdit. C'est l'un des domaines dans lesquels de nombreux développeurs se trompent. Nous en avons donc 41, ce qui signifie non autorisé, et nous avons quatre sur trois,
ce qui signifie interdit. Nous utilisons des données non autorisées lorsque l'utilisateur essaie d'accéder à
une ressource protégée, mais qu'il ne fournit pas de
WebTken JSN valide Nous leur donnons donc la possibilité de
réessayer d'envoyer un JCN WebTken valide S'ils envoient un jeton Web GSN
valide et qu'ils ne sont toujours pas autorisés à accéder à la ressource cible, c'est alors
que nous utilisons
quatre ou trois, ce qui signifie interdit, ce qui signifie ne pas réessayer,
nous ne pouvons tout simplement pas nous ne pouvons tout simplement De retour ici, nous définissons le statut et envoyons un
message tel que l'accès est refusé. Sinon, si
l'utilisateur est administrateur, nous passons le contrôle à la fonction intergicielle
suivante,
qui est, dans ce cas,
le gestionnaire de route Nous allons maintenant appliquer cette fonction intermédiaire
sur l'un de nos itinéraires. Revenons donc à companies point JS, examinons la méthode de suppression. Voici donc notre méthode de suppression. Nous voulons appliquer ici deux fonctions
intergicielles. Nous devons donc transmettre un tableau. Le premier est OT et
le second est admin. Ces fonctions intergicielles
seront donc exécutées en séquence Tout d'abord, si le client
envoie un Jas varié dans Webtken, nous passerons
ensuite à la deuxième fonction
milware L'utilisateur est un administrateur, puis la troisième fonction
intergicielle ou gestionnaire de route
sera exécutée Maintenant, nous devons l'importer
sur le TA. Donc, en tant qu'administrateur constant,
nous l'avons configuré pour exiger d'aller dans le dossier du
middleware et de charger le module d'administration Maintenant, testons cela.
De retour à Postman Je vais ouvrir
un nouvel onglet et envoyer
une demande de suppression
à ce point de terminaison, hôte local
STDP pour
3 000 sociétés d'API Maintenant, permettez-moi de trouver l'identifiant d' une entreprise dans la base de données
Mongo IV Accédez donc à Companies
Collection, ici, copiez cet identifiant et mettez-le dans
notre point de terminaison comme ceci. N'oubliez pas d'
inclure le jeton de cotes. Dans le cas contraire, vous obtiendrez
l'erreur d'autorisation. Excédent refusé, aucun
jeton ne le fournit. Nous allons donc mettre le jeton
et maintenant l'envoyer. Magnifique. Nous avons
reçu 200 réponses, et voici l'entreprise
qui a été supprimée.