Ora che abbiamo capito passaporto e come passaporto aggiunge
in un semplice middleware di autenticazione per la nostra applicazione NodeJS,
e fornisce un
modo flessibile facile da configurare e fornisce varie strategie per l'autenticazione utente,
andiamo in un viaggio con il nostro passaporto.
Per iniziare a questo esercizio,
come primo passo, installiamo i
moduli del nodo passaporto, passport-local e passport-local-mangusta nel nostro server di confusione.
Quindi al prompt digitare npm instal_passport,
passport-local,
passaporto local-mangusta mnus meno salvare e installare questi tre moduli.
Come potete vedere al momento stiamo iniziando con il passaporto 0.4.0, il
passaporto locale 1.0.0 e il passport-local-mangusta 5.0.1 versioni in questo corso.
Ora che abbiamo installato passaporto, passport-local, e
passport-local-mangusta, andiamo al server confusione e andiamo al file user.js.
Aggiorneremo lo schema utente e il modello per utilizzare il passport-local-mangusta.
Per fare questo, qui diremo
var PassportLocalMongoose
richiedono passaporto-local-mangusta.
Quindi questo installeremo come
il plugin mangusta nella nostra applicazione e siamo
in grado di rimuovere il nome utente e la password perché questi sarebbero automaticamente aggiunti
dal passport-local-mangusta plugin qui e di
utilizzare che come plugin nel nostro schema mangusta e modello.
Diciamo l'utente plug in e passport-local-mangusta.
Quindi, questo sarà automaticamente come ho detto aggiungendo il supporto per il
nome utente e l'archiviazione hash della password usando
l'hash e il sale e aggiungendo
metodi aggiuntivi sullo schema utente
e sul modello che sono utili per l'autenticazione del passaporto.
Quindi, una volta completato l'aggiornamento del file user.js poi nella nostra cartella di progetto,
creeremo un nuovo file e chiamarlo come authenticate.js.
Nel file authentic.js,
lasciami importare il passaporto.
Quindi diremo richiedono passaporto e
useremo questo file per memorizzare le strategie di autenticazione che configureremo.
Quindi diremo var. LocalStrategy richiede passport-local,
quindi il modulo locale passaporto esporta una strategia che possiamo utilizzare per la nostra applicazione.
Quindi diremo Passport-local.Strategy
e poi importeremo utente da modelli utente.
Vediamo ora configurare il passaporto con la nuova strategia locale
e quindi esporteremo questo da questo file perché questo sta per essere un modulo nodo.
Quindi diremo exports.local e diremo passaporto e si
può vedere che il passaporto supporta i vari metodi
qui quindi diremo l'uso del passaporto e dire
nuova LocalStrategy e poi questo è dove
le funzioni che sono supportate dal passaporto-local-mangusta viene in nostro aiuto.
Quindi la strategia locale dovrà essere fornita con la funzione di verifica.
All' interno di questa funzione verificheremo l'utente.
Questa funzione di verifica verrà chiamata con il nome utente e la password che il
passaporto estrarrà dalla nostra richiesta in arrivo.
Ora nella richiesta in arrivo per LocalStrategy il nome utente e la password
devono essere forniti nel corpo del messaggio sotto forma di una stringa Json.
Ancora una volta perché stiamo facendo corpo-parser in modo che venga
aggiunto nel corpo del messaggio e poi da lì passaporto
lo recupereremo e quindi useremo e fornire il nome utente e la password
come parametri per la funzione di verifica che forniremo al LocalStrategy.
Dal momento che stiamo usando il plugin mangusta passaporto,
il plugin mangusta stesso aggiunge questa funzione chiamata user.authenticate.
Quindi aggiunge questo metodo allo schema utente e al modello.
Stiamo andando a fornire che come la funzione
che fornirà l'autenticazione per la LocalStrategy.
Ora, se non si utilizza
passport-local-mangusta quando si imposta un plugin mangusta che abbiamo fatto,
se non si utilizza questo,
allora è necessario scrivere la propria funzione di autenticazione utente qui.
Nella lezione precedente,
ti avevo mostrato una semplice funzione di autenticazione utente
che può essere utilizzata qui, ma quella
fornita dal modulo passport-local-mangusta è più
completa e quindi questo è ciò che faremo uso nella nostra applicazione.
Anche dal momento che stiamo ancora utilizzando sessioni per monitorare gli utenti nella nostra applicazione,
abbiamo bisogno di serializzare e deserializzare l'utente.
Quindi questo fondamentalmente prende le informazioni dell'utente.
Ora ricordare che l'autenticazione passaporto monterà la proprietà req.user o utente
al messaggio di richiesta e in modo
che le informazioni utente saranno serializzate e deserializzate realizzato utilizzando
questo dicendo serializzare utente e passaporto deserializzare utente.
Inoltre diremo utente deserializzare utente.
Queste due funzioni che serializzano utente e deserializzare utente sono forniti
sullo schema utente e modello dall'uso del passport-local-mangusta plugin qui.
Quindi questo si prenderà cura di tutto ciò che è necessario per
il nostro supporto per le sessioni sul passaporto.
Quindi, una volta completato questo aggiornamento al file authenticate.js,
questo file sarà richiesto ovunque sia necessario per noi da utilizzare nella nostra autenticazione.
Avanti andando al file users.js,
nel file users.js,
prima importeremo il passaporto.
Quindi diremo passaporto var richiedono passaporto.
Quindi, poiché stiamo usando il plugin mangusta locale passaporto,
il plugin mangusta fornisce alcune metriche che sono
utili per noi da utilizzare nel processo di registrazione e nel processo di login.
Quindi, andando giù al post del router qui,
il plugin mangusta ci fornisce un metodo chiamato registro,
sullo schema utente e sul modello.
Quindi diremo registro utente e questo sarà trasformato in dire nuovo utente.
Questo nuovo utente è il primo parametro che il registro prende
e il secondo parametro è la password del corpo req.
Quindi la password che arriva come secondo parametro nel corpo del messaggio.
Quindi ricorda che il nome utente e la password vengono passati
quando ti iscrivi nel corpo del messaggio.
Ora, in questo caso,
ciò comporterà una funzione di richiamo che fornisce errore
e l'utente come i due valori di callback qui e sfortunatamente
, questo non funziona in questo caso.
Quindi dovrò ritagliarlo da qui e poi
invece gestirlo all'interno di questo metodo di callback qui.
Quindi, lasciami solo indentare questo,
in modo che sia più facile vedere il codice qui.
Quindi dirò, registro utente e il primo parametro è
un nuovo utente creato con
il nome utente fornito qui e il secondo parametro è la password,
e quindi il risultato è questa funzione di callback che
chiamerà, diremo utente errore qui.
In questo caso, dobbiamo modificare un po 'il codice qui.
Quindi nella prima parte,
diremo se errore,
quindi dovranno inviare esplicitamente la risposta.
Quindi, ho intenzione di copiare questi due qui.
Quindi diremo, se l'errore,
quindi res codice di stato,
imposteremo questo a 500 e impostare il tipo di contenuto di intestazione e poi,
imposteremo res json e poi errore, errore.
Quindi costruiremo un oggetto json con l'errore come
valore per la proprietà error in lì e quindi invieremo questo indietro.
Quindi questo è il modo in cui gestiresti l'errore in questo caso.
Altrimenti, quello che facciamo qui è che
diremo passaporto autenticare locale.
Quindi, se abbiamo intenzione di utilizzare il passaporto per autenticare nuovamente l'utente.
Quindi diremo passaporto autenticare locale.
Per garantire che la registrazione dell'utente abbia avuto successo.
cercheremo di autenticare lo stesso utente che abbiamo appena registrato e
qui diremo req res e questo
restituirà come terzo valore quella funzione all'interno della quale,
invieremo la risposta al nostro cliente.
Quindi diremo. Lasciami rimuovere questo e poi aggiungerlo qui.
Ora possiamo rimuovere questo allora,
perché questo allora non è necessario per noi e questa è la chiusura del registro utente.
Nella parte altra,
faremo passaporto autenticare locale.
Guarda la sintassi qui.
Quindi questo è passaporto autenticare locale e quindi seguendo che,
dobbiamo chiamare questa funzione qui che i parametri req,
res e che il terzo è una funzione di callback qui.
Quindi questo è il modo in cui questo è implementato perché passaporto si aspetta che tu lo faccia in questo modo.
Qui, imposteremo req res codice di stato è 200,
impostare intestazione contenuto applicazione json e poi ci
res registrazione di stato json successo e non passeremo il valore utente qui.
Invece, quello che farò è
impostare una bandiera chiamata successo qui a true qui.
Ora in questo modo, dal lato client quando questo json viene ricevuto,
il client può semplicemente estrarre la proprietà di successo e quindi verificare se è vero
o meno per verificare rapidamente se la registrazione ha avuto successo o meno.
Quindi questo è il modo in cui gestiremo il processo di registrazione degli utenti qui.
Quindi nota come il codice si è notevolmente semplificato.
Se l'utente non si è registrato correttamente
, questo invierà un errore in modo appropriato e anche l'autenticazione fallirà.
Quindi entrambi i casi, capirai la situazione quando l'autenticazione dell'utente fallisce.
Ora, anche il processo di login stesso viene notevolmente semplificato.
Quindi, non abbiamo bisogno di fare tutto questo nel percorso di accesso qui.
Quindi ho intenzione di rimuovere tutto questo codice e questo percorso di accesso diventa semplificato qui.
Ora per il percorso di accesso- per il post router quando lo facciamo qui,
anche qui ci aspettiamo che il nome utente e la password siano inclusi
nel corpo del messaggio post che sta arrivando lei.
A differenza del caso precedente in cui lo includevamo nell'intestazione di autorizzazione,
qui ci aspettiamo che questo sia incluso nel corpo del messaggio post in arrivo.
Quindi, per autenticare, diremo semplicemente l'autenticazione del passaporto e diremo locale qui.
Quindi questa sarà la seconda chiamata qui.
Quindi questo è il secondo middleware qui che stiamo per tagliare.
Quindi, quando il post del router arriva sull'endpoint di accesso,
chiameremo prima il passaporto autenticare locale.
Se questo ha successo, questo entrerà
e verrà eseguita la funzione successiva che segue.
Se si verifica un errore nell'autenticazione,
questo passaporto autenticare locale
invierà automaticamente una risposta al client circa l'errore dell'autenticazione.
Quindi questo è già preso cura di.
Quindi nota come il codice nel processo di login viene notevolmente semplificato.
Quindi, se questo va avanti con successo,
ho solo bisogno di controllare la req e res e qui quello che
farò è semplicemente inviare un messaggio al lato client con queste informazioni qui dentro.
Diciamo res codice di stato 200,
res set intestazione tipo di contenuto applicazione json e res json successo vero stato.
Diciamo che hai effettuato l'accesso con successo.
Questo è tutto. Questa è la modifica che faremo al file users.js.
Quindi nota come, a causa del passaporto utente,
sia il processo di registrazione che il processo di login,
il codice si è notevolmente semplificato in questo caso.
Ora passeremo ad aggiornare il file app.js andando a app.js ora.
In app.js proprio qui
inseriremo il passaporto.
Quindi, importeremo
il modulo di autenticazione che abbiamo appena implementato.
Diremo var authenticate e nel file app.js qui sotto dopo la sessione,
aggiungiamo app.use (passport.initialize)
e app.use (.session).
Se l'utente è connesso,
allora ciò che accade è che quando la sessione viene avviata di nuovo,
si ricorda che quando si accede qui,
si accede qui,
e una chiamata al passaporto autenticare locale,
quando questo viene fatto nella fase di login,
il passaporto autenticare locale
aggiunge automaticamente la proprietà utente al messaggio di richiesta.
Quindi, aggiungerà req.user e poi,
la sessione di passaporto che abbiamo fatto qui
serializzerà automaticamente le informazioni dell'utente e quindi memorizzarlo nella sessione.
Quindi, e successivamente, ogni volta che
una richiesta in arrivo arriva dal lato client
con il cookie di sessione già in atto,
questo caricherà automaticamente il req.user sulla richiesta in arrivo.
Quindi, è così che viene organizzata la sessione del passaporto stessa.
Quindi, una volta fatto questo,
anche il nostro codice di autenticazione diventerà molto più semplice qui.
Quindi, nel codice di autenticazione,
diremo semplicemente, se req.user.
Quindi, il req.user verrà caricato automaticamente dal middleware sessione passaporto,
quindi diremo req.user.
Se non req.user diremo var err, nuovo errore,
non sei autenticato, e tutti questi messaggi qui.
Altrimenti, vedi anche la parte else ora viene semplificata.
Diremo altro.
Quindi, il tuo codice di autenticazione diventa molto più semplice perché se req.user non è presente,
significa che l'autenticazione non è stata eseguita correttamente, quindi
è per questo che indichi l'errore.
In caso contrario, si è autenticati.
Se req.user è presente,
significa che il passaporto ha eseguito l'autenticazione e l'utente
req.user viene caricato sul messaggio di richiesta,
e quindi puoi semplicemente andare più in basso.
Quindi, questo è il cambiamento che dobbiamo fare a app.js.
Salviamo tutte le modifiche e poi guardiamo l'applicazione in Postman.
Una volta salvate tutte le modifiche, riavviare il server.
Se il server è in esecuzione,
arrestarlo e riavviare il server.
Fammi avviare il mio server.
Una volta che il server è attivo e funzionante,
andiamo a Postman e fare un paio di richieste.
Andando a Postman, lasciami ora provare a registrare un nuovo utente
facendo un post sull'endpoint di registrazione degli utenti.
Quando la registrazione viene pubblicata,
si vede che nel corpo del messaggio di risposta dice,
successo vero e registrazione stato riuscita.
Quindi, l'utente è stato registrato con successo sul lato client.
Quindi, ora, fammi fare un login dell'utente.
Quindi, diremo «Accedi» e forniremo comunque
il nome utente e la password nel corpo del messaggio qui.
Quindi, quando clicco su «Invia»,
noterai immediatamente che
in basso, dice, successo, vero e stato, sei loggato e poi nell'intestazione stessa,
vedrai un set-cookie in arrivo perché stiamo impostando la sessione,
e poi vedi il cookie in atto lì.
Quando si fa clic sui cookie,
si vede l'ID di sessione proprio lì.
Quindi, ora abbiamo effettuato l'accesso con successo.
Inviamo una richiesta all'endpoint Get localhost: 3000 piatti.
Si vede che la richiesta è stata inviata correttamente e quindi è stata inviata una risposta.
Naturalmente, in questo momento,
il mio database è vuoto, ecco perché invia un array vuoto
dal sito del server quando chiedo localhost: 3000/piatti.
Questo va benissimo.
Permettetemi ora di disconnettere l'utente.
Quindi, quando disconnetto l'utente, ora,
noterai che l'utente è stato disconnesso e quando fai clic sui cookie,
noterai che, quel cookie per localhost è già andato.
Quindi, ora, se si tenta di fare un get sul localhost: piatti,
si vede che la risposta dice,
non si è autenticati.
Accediamo ancora una volta facendo un post sul login degli utenti,
e poi, si vede che possiamo accedere con successo a questo punto.
Si nota anche che,
che il nuovo cookie è stato impostato qui.
Poi, se facciamo un get sul localhost: piatti qui,
ora, questo avrà successo.
Dal momento che stiamo usando mangusta locale come plugin mangusta,
andiamo anche a controllare il nostro server MongoDB per vedere come
le informazioni dell'utente sono effettivamente memorizzate nel nostro MongoDB.
Quindi, nel tuo terminale,
puoi aprire l'ondulazione Mongo,
quindi diciamo Mongo al terminale e poi connetterti al nostro server MongoDB,
e poi dire usa Confusione.
Quindi diremo db.users.find () .pretty () e quindi stampare le informazioni dell'utente.
Quindi, quando si stampano le informazioni dell'utente come si vede qui,
c'è un utente che abbiamo registrato in precedenza.
Quindi, vedrai che il record dell'utente contiene l'ID dell'oggetto e quindi,
il nome utente qui sotto,
e il flag admin che è falso e poi,
nota anche che invece di memorizzare la password stessa ciò che
fa il plugin mangusta locale Mongos è memorizza
il suo valore salt qui e un valore hash qui.
Ora, quello che fa il plugin di Mongo è che userà il sale come modo di
crittografare la password e installare la password hash in questo campo hash qui.
Quindi, quando si tenta di accedere,
si applicherà la stessa trasformazione alla password in entrata
e quindi si tenta di abbinarlo a questo valore hash memorizzato qui.
Quindi, puoi vedere che nel database stesso,
la password non viene memorizzata direttamente
all'interno del valore hash della password che viene hash usando questa chiave salt qui,
che vediamo qui,
è memorizzata nel record lì.
Quindi, questo è il modo in cui il plugin Mongoose locale del passaporto ci permette di
memorizzare le informazioni dell'utente all'interno del nostro database.
Con questa rapida comprensione di come passaporto, passport-local
e Passport-Local-Mongoose ci aiutano a semplificare
la strategia locale per nome utente e password nella nostra applicazione.
Completiamo questo esercizio.
Questo è un buon momento per fare un commit Git con il passaporto del messaggio.