Jetzt, da wir verstanden haben, Pass und wie Passport fügt
in eine einfache Authentifizierung Middleware für unsere NodeJS-Anwendung,
und bietet eine flexible, einfach zu konfigurieren
Weg und bietet verschiedene Strategien für die Benutzerauthentifizierung,
lassen Sie uns auf eine Reise mit unserem Pass gehen.
Um mit dieser Übung zu beginnen,
als der erste Schritt lassen Sie uns Passport,
Passport-lokale und Passport-local-Mungo Knoten Module in unserem Verwirrungsserver installieren.
Also geben Sie an der Eingabeaufforderung npm instal_passport,
pass-local,
pass-local-mongoose mnus minus speichern und installieren Sie diese drei module.
Wie Sie im Moment sehen können, beginnen wir mit Pass 0.4.0,
Pass-local 1.0.0 und Pass-local-Mungo 5.0.1 Versionen in diesem Kurs.
Jetzt, da wir Passport, Reisepass-lokale und Pass-Lokal-Mungo installiert haben,
gehen wir zum Verwirrungsserver und gehen Sie zur Datei user.js.
Wir werden das Benutzerschema und das Modell aktualisieren, um den Pass-local-Mungo zu verwenden.
Um dies zu tun, werden wir hier sagen,
var passportLocalMongoose
benötigen Pass-local-Mungo.
Dies werden wir also als
Mungo Plugin in unserer Anwendung installieren und wir können den Benutzernamen und
das Passwort entfernen, da diese automatisch vom
Pass-Lokal-Mungo Plugin hier hinzugefügt werden und
das als Plugin in unserem Mungo Schema und Modell zu verwenden.
Wir werden sagen, Benutzer Plug in und Pass-Lokal-Mungo.
Also, dies wird automatisch, wie ich sagte, Unterstützung für
Benutzernamen und Hash-Speicherung des Passworts mit
dem Hash und Salz hinzufügen und
zusätzliche Methoden für das Benutzerschema
und das Modell hinzufügen, die für die Passauthentifizierung nützlich sind.
Sobald wir die Aktualisierung der Datei user.js abgeschlossen haben, dann in unserem Projektordner,
erstellen wir eine neue Datei und benennen sie als authenticate.js.
Lassen Sie mich in der Datei authentic.js den Reisepass importieren.
Wir werden also sagen, dass Reisepass erforderlich ist und wir werden
diese Datei verwenden, um die Authentifizierungsstrategien zu speichern, die wir konfigurieren werden.
Also sagen wir var. LocalStrategy erfordert pass-local,
so dass das Passport-lokale Modul exportiert eine Strategie, die wir für unsere Anwendung verwenden können.
Also sagen wir Passport-local.Strategy
und dann werden wir Benutzer von Modellen Benutzer importieren.
Lassen Sie uns nun den Pass mit der neuen lokalen Strategie konfigurieren
und dann werden wir diese aus dieser Datei exportieren, da dies ein Knotenmodul sein wird.
Also sagen wir exports.local und wir werden Pass sagen und Sie
können sehen, dass der Pass die verschiedenen Methoden
hier unterstützt, so dass wir sagen, Pass-Verwendung und sagen
neue LocalStrategy und dann ist dies, wo
die Funktionen, die von der Pass-lokalen Mungo unterstützt werden, zu unserer Hilfe kommen.
Daher muss die lokale Strategie mit der Verifizierungsfunktion geliefert werden.
Innerhalb dieser Funktion werden wir den Benutzer überprüfen.
Diese Verifizierungsfunktion wird mit dem Benutzernamen und dem Passwort aufgerufen, das der
Reisepass aus unserer eingehenden Anfrage extrahiert.
Nun
sollten in der eingehenden Anfrage für die LocalStrategy der Benutzername und das Passwort im Textkörper der Nachricht in Form einer Json-Zeichenfolge angegeben werden.
Wieder, weil wir Bodyy-Parser tun, so dass wird
in den Körper der Nachricht und dann von dort Pass hinzugefügt
werden wir abrufen, dass und dann verwenden, dass und geben Sie den Benutzernamen und das Passwort
als Parameter für die Verifizierungsfunktion, die wir an die LocalStrategy liefern.
Da wir Passport-Mungo Plugin verwenden,
fügt das Mungo Plugin selbst diese Funktion namens user.authenticate hinzu.
Daher fügt es diese Methode dem Benutzerschema und dem Modell hinzu.
Wir werden das als die Funktion liefern, die die
Authentifizierung für die LocalStrategy zur Verfügung stellt.
Wenn Sie nun keinen
Passport-local-Mungo verwenden, wenn Sie ein Mungo Plugin einrichten, das wir getan haben,
wenn Sie das nicht verwenden,
dann müssen Sie hier Ihre eigene Benutzerauthentifizierungsfunktion schreiben.
In der Vorlesung zuvor
hatte ich Ihnen eine einfache Benutzerauthentifizierungsfunktion gezeigt
, die hier verwendet werden kann, aber die,
die vom Passport-local-mongoose-Modul geliefert wird
, ist umfassender und so werden wir in unserer Anwendung verwenden.
Da wir immer noch Sitzungen verwenden, um Benutzer in unserer Anwendung
zu verfolgen, müssen wir den Benutzer serialisieren und deserialisieren.
Dies nimmt also im Grunde die Benutzerinformationen.
Nun erinnern Sie sich, dass die Passauthentifizierung wird die req.user oder die Benutzereigenschaft auf
die Anforderungsnachricht einhängen und so
, dass Benutzerinformationen serialisiert und deserialisiert werden realisiert mit
diesem Sprichwort serialisieren Benutzer und Reisepass deserialisieren Benutzer.
Auch werden wir sagen, Benutzer deserialisieren Benutzer.
Diese beiden Funktionen, die sie serialisieren Benutzer und deserialisieren Benutzer werden auf
dem Benutzerschema und Modell durch die Verwendung des Pass-local-Mongoose Plugin hier zur Verfügung gestellt.
So wird dies kümmern, was auch immer es für
unsere Unterstützung für Sitzungen im Pass erforderlich ist.
Sobald wir diese Aktualisierung der Datei authenticate.js abgeschlossen haben,
wird diese Datei benötigt, wo immer sie für uns benötigt wird, um in unserer Authentifizierung zu verwenden.
Als nächstes werden
wir in der Datei users.js in der Datei users.js zuerst den Reisepass importieren.
Also werden wir sagen, var Pass erfordern Pass.
Dann, weil wir das Passport-lokale Mungo Plugin verwenden,
liefert das Mungo Plugin selbst einige Metriken, die
für uns nützlich sind, um im Anmeldeprozess und im Anmeldeprozess zu verwenden.
Also gehen Sie zum Router-Post hier,
das Mungo Plugin bietet uns mit einer Methode namens Register,
auf dem Benutzerschema und Modell.
Also werden wir sagen, Benutzer registrieren und dies wird in sagen neuen Benutzer umgewandelt werden.
Dieser neue Benutzer ist der erste Parameter, den das Register übernimmt
und der zweite Parameter ist das req body Passwort.
Also das Passwort, das als zweiter Parameter im Hauptteil der Nachricht kommt.
Erinnern Sie sich also daran, dass der Benutzername und das Passwort übergeben werden,
wenn Sie sich im Nachrichtentext anmelden.
Nun, in diesem Fall
wird dies zu einer Callback-Funktion führen, die Fehler
und den Benutzer als die beiden Callback-Werte hier liefert und leider
funktioniert das dann in diesem Fall nicht.
Also muss ich das von hier aus ausschneiden und dann
das in dieser Callback-Methode hier behandeln.
Also, lassen Sie mich das einfach einrücken,
damit es einfacher ist, den Code hier zu sehen.
Also werde ich sagen, Benutzerregistrierung und der erste Parameter ist
ein neuer Benutzer,
der mit dem Benutzernamen hier erstellt wurde und der zweite Parameter ist das Passwort,
und dann ist das Ergebnis diese Callback-Funktion, die aufruft,
wir sagen Fehler Benutzer hier.
In diesem Fall müssen wir den Code hier ein wenig bearbeiten.
Also im ersten Teil
werden wir sagen, wenn Fehler,
dann müssen sie die Antwort explizit zurücksenden.
Also, ich werde diese beiden hier kopieren.
Also werden wir sagen, wenn Fehler,
dann Res-Status-Code,
wir werden dies auf 500 setzen und Header-Inhaltstyp
setzen und dann, wir werden res json und dann Fehler, Fehler setzen.
Also werden wir ein JSON-Objekt mit dem Fehler als
Wert für die Fehlereigenschaft dort konstruieren und dann zurücksenden.
So würden Sie den Fehler in diesem Fall behandeln.
Andernfalls, was wir hier tun, ist, dass wir
sagen, Pass authentifizieren lokale.
Also, wenn wir gehen, um Pass verwenden, um den Benutzer wieder zu authentifizieren.
Also sagen wir, Reisepass authentifizieren lokal.
Um sicherzustellen, dass die Benutzerregistrierung erfolgreich war.
Wir werden versuchen, den gleichen Benutzer zu authentifizieren, den wir gerade registriert haben, und
hier werden wir sagen, req res und dies
wird als dritter Wert die Funktion zurückgeben, in der
wir die Antwort an unseren Kunden zurücksenden werden.
Also werden wir sagen. Lassen Sie mich das entfernen und fügen Sie es hier hinzu.
Das können wir nun entfernen,
denn dies ist dann für uns nicht notwendig und dies ist das Schließen der Benutzerregistrierung.
Im anderen Teil
werden wir tun Reisepass authentifizieren lokalen.
Sehen Sie sich die Syntax hier an.
Also das ist Passauthentifizierung lokal und dann im Anschluss daran
müssen wir diese Funktion hier aufrufen, dass die Parameter req,
res und dass der dritte eine Callback-Funktion hier ist.
Dies ist also die Art und Weise, wie dies umgesetzt wird, weil der Pass erwartet, dass Sie es auf diese Weise tun.
In hier setzen wir req res Statuscode ist 200,
setzen Header Inhalt Anwendung json und dann werden wir
res json Status Registrierung erfolgreich und wir werden den Benutzerwert hier nicht übergeben.
Stattdessen werde ich
hier eine Flagge namens Erfolg setzen.
Auf diese Weise
kann der Client auf unserer Client-Seite, wenn dieser JSON empfangen wird, einfach die Erfolgseigenschaft extrahieren und dann überprüfen, ob es wahr ist
oder nicht, um schnell zu überprüfen, ob die Registrierung erfolgreich war oder nicht.
So werden wir hier mit dem Benutzerregistrierungsprozess umgehen.
Beachten Sie also, wie der Code erheblich vereinfacht wurde.
Wenn sich der Benutzer nicht richtig registriert hat,
sendet dies einen Fehler entsprechend zurück und auch die Authentifizierung schlägt fehl.
Daher werden Sie in beiden Fällen die Situation erfassen, wenn die Benutzerauthentifizierung fehlschlägt.
Nun wird auch der Anmeldeprozess selbst deutlich vereinfacht.
Also, wir müssen das nicht alles in der Login-Route hier tun.
Also werde ich all diesen Code entfernen und diese Login-Route wird hier vereinfacht.
Jetzt für die Login-Route- für den Router-Post, wenn wir es hier tun,
auch hier erwarten wir, dass der Benutzername und das Passwort
in den Körper der Post Nachricht aufgenommen werden, die sie kommt.
Im Gegensatz zu dem früheren Fall, in dem wir dies in den Autorisierungs-Header aufgenommen haben,
erwarten wir hier, dass dies im Hauptteil der eingehenden Postnachricht enthalten ist.
Um sich zu authentifizieren, sagen wir einfach Pass authentifizieren und wir sagen hier lokal.
Das wird also der zweite Anruf hier sein.
Das ist also die zweite Middleware hier, die wir schneiden werden.
Wenn also der Routerpost auf dem Anmeldeendpunkt kommt,
rufen wir zuerst den Reisepass authentifizieren lokal.
Wenn dies erfolgreich ist, wird dies
eintreten und die nächste Funktion, die folgt, wird ausgeführt.
Wenn es einen Fehler in der Authentifizierung gibt,
sendet dieser Reisepass authentifizieren lokale automatisch eine Antwort an den Client über den Fehler der Authentifizierung zurück.
Das ist also schon gesorgt.
Beachten Sie also, wie der Code im Anmeldeprozess erheblich vereinfacht wird.
Also, wenn das erfolgreich durchläuft,
muss ich nur nach den req und res suchen und hier drin, was ich tun werde,
ist, dass ich einfach eine Nachricht an die Client-Seite mit diesen Informationen hier senden werde.
Wir sagen res Statuscode 200,
res set Header Inhaltstyp Anwendung json und res json Erfolg true status.
Wir sagen, Sie sind erfolgreich eingeloggt.
Das war's. Dies ist die Änderung, die wir an der Datei users.js vornehmen werden.
Beachten Sie also, dass der
Code aufgrund des Benutzerpasses sowohl des Anmeldeprozesses als auch des Anmeldeprozesses in diesem Fall erheblich vereinfacht wurde.
Jetzt werden wir fortfahren, um app.js Datei zu aktualisieren gehen auf app.js jetzt.
In app.js rechts hier oben
werden wir Pass eingeben.
Dann werden wir
das Authentifizierungsmodul importieren, das wir gerade implementiert haben.
Wir werden sagen, var authenticate und in der app.js Datei unten unten hier nach der Sitzung
fügen wir app.use (passport.initialize)
und app.use (.session) hinzu.
Wenn der Benutzer angemeldet ist,
dann was passiert, ist, dass, wenn die Sitzung erneut initiiert wird,
Sie daran erinnern, dass, wenn Sie sich hier anmelden,
werden Sie sich hier anmelden,
und ein Anruf an den Reisepass authentifizieren lokale,
wenn dies in der Anmeldephase getan wird,
wird der Reisepass authentifizieren lokale
automatisch die Benutzereigenschaft zur Anforderungsnachricht hinzufügen.
Es wird also req.user hinzugefügt und dann
wird die Passsitzung, die wir hier gemacht haben, automatisch
diese Benutzerinformationen serialisieren und dann in der Sitzung speichern.
Wenn also
eine eingehende Anfrage von der Clientseite
mit dem Sitzungs-Cookie bereits vorhanden ist,
lädt dies automatisch den req.user auf die eingehende Anfrage.
So wird die Passsitzung selbst organisiert.
Sobald dies geschehen ist,
wird auch unser Authentifizierungscode hier viel einfacher.
Also, im Authentifizierungscode,
werden wir einfach sagen, wenn req.user.
So wird der req.user automatisch von der Passsitzung Middleware geladen,
und so sagen wir req.user.
Wenn nicht req.user sagen wir var err, neuer Fehler,
Sie sind nicht authentifiziert, und alle diese Nachrichten hier.
Andernfalls wird der else Teil jetzt auch vereinfacht.
Als Nächstes sagen wir noch etwas.
Ihr Authentifizierungscode wird also viel einfacher, denn wenn req.user nicht vorhanden ist,
bedeutet dies, dass die Authentifizierung nicht korrekt durchgeführt wurde,
deshalb geben Sie den Fehler an.
Andernfalls werden Sie authentifiziert.
Wenn req.user vorhanden ist,
bedeutet das, dass der Reisepass die Authentifizierung durchgeführt hat und der Benutzer
req.user in die Anforderungsnachricht geladen wird,
und so können Sie einfach weiter unten gehen.
Also, das ist die Änderung, die wir an app.js vornehmen müssen.
Lassen Sie uns alle Änderungen speichern und dann die Anwendung in Postman betrachten.
Sobald Sie alle Änderungen gespeichert haben, starten Sie den Server neu.
Wenn der Server ausgeführt wird,
beenden Sie ihn, und starten Sie den Server neu.
Lassen Sie mich meinen Server starten.
Sobald der Server betriebsbereit ist,
gehen wir zu Postman und machen ein paar Anfragen.
Gehen Sie zu Postman, lassen Sie mich jetzt versuchen, einen neuen Benutzer zu registrieren,
indem Sie einen Beitrag auf dem Benutzerregistrierungsendpunkt tun.
Wenn die Registrierung veröffentlicht wird,
sehen Sie, dass im Textkörper der Antwortnachricht „
Erfolg wahr“ und die Statusregistrierung erfolgreich ist.
So wurde der Benutzer erfolgreich auf der Client-Seite registriert.
Also, jetzt, lassen Sie mich einen Login des Benutzers machen.
Also, wir werden sagen, „Login“, und immer noch geben
Sie den Benutzernamen und das Passwort im Textkörper der Nachricht hier.
Also, wenn ich auf „Senden“ klicke,
werden Sie sofort bemerken, dass unten,
es heißt, Erfolg, wahr und Status,
Sie sind angemeldet und dann in der Kopfzeile selbst,
würden Sie sehen, ein Set-Cookie kommen, weil wir die Sitzung einrichten,
und dann sehen Sie das Cookie an Ort und Stelle dort.
Wenn Sie auf die Cookies klicken,
sehen Sie die Sitzungs-ID direkt dort.
Also, jetzt sind wir erfolgreich eingeloggt.
Lassen Sie uns eine Anfrage an den Get localhost: 3000 Gerichte Endpunkt senden.
Sie sehen, dass Ihre Anfrage erfolgreich eingegangen ist und dann eine Antwort gesendet wurde.
Natürlich
ist meine Datenbank in diesem Moment leer, deshalb sendet sie ein leeres Array
von der Server-Site zurück, wenn ich nach localhost frage: 3000/Gerichte.
Das ist vollkommen in Ordnung.
Lassen Sie mich jetzt den Benutzer abmelden.
Also, wenn ich den Benutzer abmelde, jetzt,
werden Sie feststellen, dass der Benutzer abgemeldet wurde und wenn Sie auf die Cookies klicken,
werden Sie feststellen, dass, dass das Cookie für localhost bereits verschwunden ist.
Also, jetzt, wenn Sie versuchen, ein get auf dem localhost zu tun: Gerichte,
Sie sehen, dass die Antwort sagt,
Sie sind nicht authentifiziert.
Lassen Sie uns noch einmal anmelden, indem Sie einen Beitrag auf der Benutzeranmeldung machen,
und dann sehen Sie, dass wir sich an dieser Stelle erfolgreich anmelden können.
Sie bemerken auch,
dass, das neue Cookie wurde hier eingerichtet.
Dann, wenn wir ein get auf der localhost: Gerichte hier,
jetzt, wird dies erfolgreich sein.
Da wir passport-lokale Mungo als Mungo Plugin verwenden,
lassen Sie uns auch gehen und unseren MongoDB-Server überprüfen, um zu sehen, wie
die Informationen des Benutzers tatsächlich in unserer MongoDB gespeichert werden.
Also, in Ihrem Terminal,
können Sie die Mongo-Welligkeit öffnen,
also sagen wir Mongo am Terminal und dann eine Verbindung zu unserem MongoDB-Server,
und dann sagen, verwenden Sie ConFusion.
Dann sagen wir db.users.find () .pretty () und drucken Sie dann die Informationen des Benutzers aus.
Wenn Sie also die Informationen des Benutzers ausdrucken, wie Sie hier sehen,
gibt es einen Benutzer, den wir früher registriert haben.
Sie werden also sehen, dass der Datensatz des Benutzers die Objekt-ID enthält und dann
den Benutzernamen unten hier
und das Admin-Flag, das falsch ist und dann
auch bemerken, dass statt das Passwort selbst zu speichern, was das Mongos
passport-local mongoose Plugin tut, es
seinen Salzwert speichert hier und einen Hash-Wert hier.
Nun, was Mongos Plugin tut, ist, dass es das Salz als eine Möglichkeit verwendet,
das Passwort zu verschlüsseln und das Hash-Passwort in diesem Hashfeld hier zu installieren.
Also, wenn Sie versuchen, sich anzumelden,
wird es die gleiche Transformation auf das eingehende Passwort anwenden
und dann versuchen, es mit diesem Hash-Wert, der hier gespeichert ist, abzugleichen.
So können Sie sehen, dass in der Datenbank selbst,
das Passwort nicht direkt in
dem Hash-Wert des Passworts gespeichert wird, das mit diesem Salzschlüssel gehasht wird
, den wir hier sehen,
in dem Datensatz dort gespeichert ist.
So ermöglicht es uns das Pass-lokale Mongoose-Plugin,
die Benutzerinformationen in unserer Datenbank zu speichern.
Mit diesem schnellen Verständnis, wie Reisepass, Reisepass
und Reisepass Local-Mongoose uns helfen,
die lokale Strategie für Benutzername und Passwort in unserer Anwendung zu vereinfachen.
Wir schließen diese Übung ab.
Dies ist ein guter Zeitpunkt für Sie, ein Git-Commit mit dem Nachrichtenpass zu machen.