Ahora que hemos entendido el pasaporte y cómo el pasaporte añade
en un middleware de autenticación simple para nuestra aplicación NodeJS,
y proporciona una
forma flexible fácil de configurar y proporciona varias estrategias para la autenticación de usuarios,
vamos a ir en un viaje con nuestro pasaporte.
Para comenzar en este ejercicio,
como primer paso vamos a instalar los
módulos pasaporte, pasport-local y pasport-local-mangosta en nuestro servidor de confusión.
Así que en el indicador escriba npm instal_passport,
passport-local,
pasaporte local-mangosta mnus menos guardar e instalar estos tres módulos.
Como puede ver en este momento estamos comenzando con las
versiones de pasaporte 0.4.0, pasport-local 1.0.0 y pasport-local-mangosta 5.0.1 en este curso.
Ahora que hemos instalado pasaporte, passport-local y passport-local-mangosta,
vayamos al servidor de confusión y vayamos al archivo user.js.
Vamos a actualizar el esquema de usuario y el modelo para utilizar el pasaport-local-mangosta.
Para hacer eso, aquí vamos a decir
var PassportLocalMongoose
requiere pasaport-local-mangosta.
Así que esto vamos a instalar como
el plugin de mangosta en nuestra aplicación y podemos eliminar el nombre de usuario y
contraseña porque estos serían automáticamente añadidos por
el plugin passport-local-mangosta aquí y
para usarlo como un plugin en nuestro esquema y modelo de mangosta.
Diremos que el usuario enchufe y pasaporte-local-mangosta.
Por lo tanto, esto automáticamente, como dije, agregará soporte para el nombre de
usuario y el almacenamiento hash de la contraseña usando
el hash y la sal y agregará
métodos adicionales en el esquema de usuario
y el modelo que son útiles para la autenticación de pasaporte.
Así que una vez que hayamos completado la actualización del archivo user.js en nuestra carpeta del proyecto,
crearemos un nuevo archivo y lo nombraremos authenticate.js.
En el archivo authentic.js,
permítanme importar pasaporte.
Así que vamos a decir requerir pasaporte y vamos a
utilizar este archivo para almacenar las estrategias de autenticación que vamos a configurar.
Así que diremos var. LocalStrategy requiere passport-local,
por lo que el módulo local de pasaporte exporta una estrategia que podemos usar para nuestra aplicación.
Así que vamos a decir Passport-Local.strategy
y luego vamos a importar usuario de modelos de usuario.
Vamos a configurar ahora el pasaporte con la nueva estrategia local
y luego vamos a exportar esto desde este archivo porque este va a ser un módulo de nodo.
Así que vamos a decir exports.local y vamos a decir pasaporte y
se puede ver que el pasaporte es compatible con los diversos métodos
aquí, así que vamos a decir el uso de pasaporte y decir
nuevo LocalStrategy y entonces aquí es donde
las funciones que son compatibles con el pasaporte-local-mangosta vienen en nuestra ayuda.
Por lo tanto, la estrategia local tendrá que ser suministrada con la función de verificación.
Dentro de esta función verificaremos al usuario.
Esta función de verificación se llamará con el nombre de usuario y la contraseña que el
pasaporte extraerá de nuestra solicitud entrante.
Ahora en la solicitud entrante para LocalStrategy, el nombre de usuario y
la contraseña deben ser proporcionados en el cuerpo del mensaje en forma de una cadena Json.
De nuevo porque estamos haciendo body-parser para que se
agregue al cuerpo del mensaje y luego a partir de ahí el pasaporte
lo recuperaremos y luego lo usaremos y proporcionaremos el nombre de usuario y la contraseña
como parámetros a la función de verificación que proporcionaremos a la LocalStrategy.
Dado que estamos utilizando el plugin de mangosta pasaporte,
el plugin de mangosta en sí agrega esta función llamada user.authenticate.
Por lo tanto, agrega este método al esquema de usuario y al modelo.
Vamos a suministrar eso como la función
que proporcionará la autenticación para LocalStrategy.
Ahora, si no está usando
passport-local-mangoose cuando configura un plugin de mangosta que hemos hecho,
si no está usando eso,
entonces necesita escribir su propia función de autenticación de usuario aquí.
En la conferencia anterior,
le había mostrado una función de autenticación de usuario simple
que se puede utilizar aquí, pero la que es
suministrada por el módulo passport-local-mangosta es más
completa y así que eso es lo que vamos a hacer uso de en nuestra aplicación.
Además, dado que todavía estamos usando sesiones para rastrear usuarios en nuestra aplicación,
necesitamos serializar y deserializar al usuario.
Entonces, esto básicamente toma la información del usuario.
Ahora recuerde que la autenticación de pasaporte montará el req.user o la propiedad del usuario en
el mensaje de solicitud y para
que la información del usuario se serialice y deserialice realizado mediante el uso de
este dicho usuario serializar usuario y pasaporte deserializar usuario.
También diremos usuario deserializar usuario.
Estas dos funciones que serializan usuario y deserializar usuario se proporcionan en
el esquema de usuario y modelo por el uso del plugin passport-local-mangosta aquí.
Así que esto se encargará de todo lo que sea necesario para
nuestro apoyo a las sesiones en pasaporte.
Así que una vez que hayamos completado esta actualización al archivo authenticate.js,
este archivo será necesario donde sea necesario para que lo utilicemos en nuestra autenticación.
A continuación, ir al archivo users.js,
en el archivo users.js,
primero importaremos pasaporte.
Así que vamos a decir var pasaporte requiere pasaporte.
Entonces, debido a que estamos utilizando el plugin de mangosta local pasaporte,
el plugin mangosta en sí proporciona algunas métricas que son
útiles para nosotros para usar en el proceso de registro y en el proceso de inicio de sesión.
Así que bajando a la publicación del enrutador aquí,
el plugin de mangosta nos proporciona un método llamado registro,
en el esquema del usuario y el modelo.
Así que vamos a decir registro de usuario y esto se convertirá en decir nuevo usuario.
Este nuevo usuario es el primer parámetro que toma el registro
y el segundo parámetro es la contraseña del cuerpo req.
Entonces, la contraseña que viene como un segundo parámetro en el cuerpo del mensaje.
Así que recuerde que el nombre de usuario y
la contraseña se pasan cuando se registra en el cuerpo del mensaje.
Ahora, en este caso,
esto dará como resultado una función de devolución de llamada que proporciona un error
y el usuario como los dos valores de devolución de llamada aquí y, lamentablemente
, esto no funciona en este caso.
Así que tendré que cortar esto desde aquí y luego
manejar eso dentro de este método de devolución de llamada aquí.
Entonces, déjame sangrar esto, para
que sea más fácil ver el código aquí.
Así que diré, el usuario se registra y el primer parámetro es
un nuevo usuario creado con
el nombre de usuario de suministro aquí y el segundo parámetro es la contraseña,
y luego el resultado es esta función de devolución de llamada que
llamará, vamos a decir usuario de error aquí.
En este caso, tenemos que editar el código un poco aquí.
Entonces, en la primera parte,
diremos si hay error,
entonces tendrán que devolver explícitamente la respuesta.
Así que, voy a copiar estos dos aquí.
Así que diremos, si el error,
luego res código de estado,
vamos a establecer esto en 500 y establecer el tipo de contenido de encabezado y luego,
vamos a establecer res json y luego error, error.
Por lo tanto, construiremos un objeto json con el error como
el valor de la propiedad de error allí y luego enviaremos esto de vuelta.
Entonces, así es como manejarías el error en este caso.
De lo contrario, lo que hacemos aquí es que
diremos pasaporte autenticar local.
Así que si vamos a utilizar el pasaporte para autenticar al usuario de nuevo.
Así que diremos que el pasaporte autentica local.
Para asegurarse de que el registro de usuario se realizó correctamente.
intentaremos autenticar al mismo usuario que acabamos de registrar y
aquí diremos req res y esto
devolverá como un tercer valor esa función dentro del cual,
vamos a devolver la respuesta a nuestro cliente.
Así que diremos. Déjame eliminar esto y luego agregarlo aquí.
Ahora podemos eliminar esto entonces,
porque esto entonces no es necesario para nosotros y este es el cierre del registro de usuarios.
En la otra parte,
vamos a hacer pasaporte autenticar local.
Mira la sintaxis aquí.
Así que este es el pasaporte autenticar local y luego, después de eso,
tenemos que llamar a esta función aquí que los parámetros req,
res y que el tercero es una función de devolución de llamada aquí.
Así que esta es la forma en que esto se implementa porque pasaporte espera que lo hagas de esta manera.
Aquí, estableceremos el código de estado req res es 200,
estableceremos la aplicación de contenido de encabezado json y luego nos
res registro de estado json exitoso y no pasaremos el valor de usuario aquí.
En cambio, lo que voy a hacer es
establecer una bandera llamada éxito aquí a verdadero aquí.
Ahora de esta manera, en nuestro lado cliente cuando se recibe este json,
el cliente simplemente puede extraer la propiedad de éxito y luego verificar si es cierto
o no para verificar rápidamente si el registro fue exitoso o no.
Así es como manejaremos el proceso de registro de usuarios aquí.
Así que observe cómo el código se ha simplificado significativamente.
Si el usuario no se registró correctamente,
entonces esto devolverá un error apropiadamente y también la autenticación fallará.
Por lo tanto, en ambos casos, detectará la situación cuando falla la autenticación del usuario.
Ahora, el proceso de inicio de sesión en sí también se simplifica significativamente.
Por lo tanto, no necesitamos hacer todo esto en la ruta de inicio de sesión aquí.
Así que voy a eliminar todo este código y esta ruta de inicio de sesión se simplifica aquí.
Ahora, para la ruta de inicio de sesión- para la publicación del enrutador cuando lo hacemos
aquí, aquí también esperamos que el nombre de usuario y la contraseña se incluyan
en el cuerpo del mensaje de publicación que viene ella.
A diferencia del caso anterior en el que estábamos incluyendo esto en el encabezado de autorización,
aquí esperamos que esto se incluya en el cuerpo del mensaje de entrada.
Así que para autenticar, simplemente diremos autentificar pasaporte y diremos local aquí.
Así que esta será la segunda llamada aquí.
Así que este es el segundo middleware que vamos a cortar.
Por lo tanto, cuando la publicación del enrutador entra en el extremo de inicio de sesión,
primero llamaremos al pasaporte autenticar local.
Si esto es exitoso entonces esto entrará
y se ejecutará la siguiente función que sigue.
Si hay algún error en la autenticación,
este pasaporte autenticar local
enviará automáticamente una respuesta al cliente sobre el error de la autenticación.
Así que eso ya está atendido.
Así que observe cómo el código en el proceso de inicio de sesión se simplifica significativamente.
Entonces, si esto se realiza con éxito,
solo necesito verificar el req y res y aquí lo que
haré es simplemente enviaré un mensaje al lado del cliente con esta información aquí.
Vamos a decir que el código de estado de res 200,
res establecer el tipo de contenido de encabezado de la aplicación json y res json status verdadero éxito.
Vamos a decir, que ha iniciado sesión con éxito.
Eso es todo. Este es el cambio que vamos a hacer en el archivo users.js.
Así que observe cómo, debido al pasaporte de usuario,
tanto el proceso de registro como el proceso de inicio de sesión,
el código se ha simplificado significativamente en este caso.
Ahora pasaremos a actualizar el archivo app.js yendo a app.js ahora.
En app.js justo aquí,
ingresaremos pasaporte.
Luego, importaremos
el módulo de autenticación que acabamos de implementar.
Diremos var authenticate y en el archivo app.js abajo aquí después de la sesión,
agregamos app.use (passport.initialize)
y app.use (.session).
Si el usuario ha iniciado sesión,
entonces lo que sucede es que cuando se inicia la sesión de nuevo,
recuerda que cuando inicia sesión aquí,
va a iniciar sesión aquí,
y una llamada al pasaporte autenticar local,
cuando esto se hace en la etapa de inicio de sesión,
el pasaporte autenticar local se
agregue automáticamente la propiedad de usuario al mensaje de solicitud.
Por lo tanto, agregará req.user y, a continuación,
la sesión de pasaporte que hemos hecho aquí
serializará automáticamente esa información del usuario y luego la almacenará en la sesión.
Por lo tanto, y posteriormente, cada vez que
una solicitud entrante entra desde el lado del cliente
con la cookie de sesión ya en su lugar,
esto cargará automáticamente el req.user en la solicitud entrante.
Entonces, así es como se organiza la sesión de pasaporte en sí.
Entonces, una vez hecho esto,
incluso nuestro código de autenticación será mucho más simple aquí.
Entonces, en el código de autenticación,
simplemente diremos, si req.user.
Por lo tanto, el middleware de la sesión de pasaporte cargará el req.user automáticamente, por
lo que diremos req.user.
Si no req.user diremos var err, nuevo
error, no está autenticado, y todos estos mensajes aquí.
De lo contrario, ver la parte de lo demás también ahora se simplifica.
Vamos a decir lo siguiente.
Por lo tanto, su código de autenticación se vuelve mucho más simple porque si req.user no está presente,
entonces eso significa que la autenticación no se ha hecho correctamente,
por eso indica el error.
De lo contrario, se autenticará.
Si req.user está presente,
significa que el pasaporte ha realizado la autenticación y el
usuario req.user se carga en el mensaje de solicitud,
por lo que puede ir más abajo.
Entonces, ese es el cambio que tenemos que hacer a app.js.
Vamos a guardar todos los cambios y luego mirar la aplicación en Postman.
Una vez que guarde todos los cambios, reinicie el servidor.
Si el servidor se está ejecutando,
deténgalo y, a continuación, reinicie el servidor.
Déjame iniciar mi servidor.
Una vez que el servidor esté en funcionamiento,
vayamos a Postman y hagamos algunas peticiones.
Ir a Postman, permítanme ahora tratar de registrar un nuevo usuario
haciendo una publicación en el punto final de registro de los usuarios.
Cuando se registra el registro,
verá que en el cuerpo del mensaje de respuesta dice,
éxito verdadero y estado de registro exitoso.
Por lo tanto, el usuario se ha registrado correctamente en el lado del cliente.
Entonces, ahora, déjame hacer un inicio de sesión del usuario.
Entonces, diremos, «Iniciar sesión», y aún así proporcionaremos
el nombre de usuario y la contraseña en el cuerpo del mensaje aquí.
Por lo tanto, cuando haga clic en «Enviar»,
inmediatamente notará que en la parte inferior
, dice, éxito, verdadero y estado,
está conectado y luego en el encabezado mismo,
verá una cookie de conjunto entrando porque estamos configurando la sesión,
y luego verá la cookie en su lugar allí.
Al hacer clic en las cookies,
verá el ID de sesión en su lugar justo allí.
Por lo tanto, ahora hemos iniciado sesión con éxito.
Vamos a enviar una solicitud al punto final Get localhost: 3000 platos.
Ves que tu solicitud se ha enviado correctamente y, a continuación, se ha enviado una respuesta.
Por supuesto, en este momento,
mi base de datos está vacía, por lo que envía una matriz vacía
desde el sitio del servidor cuando pido localhost: 3000/platos.
Esto está perfectamente bien.
Permítanme ahora cerrar la sesión del usuario.
Por lo tanto, cuando cierre la sesión del usuario, ahora,
notará que el usuario ha sido desconectado y cuando haga clic en las cookies,
notará que, esa cookie para localhost ya se ha ido.
Entonces, ahora, si intentas hacer un get en el localhost: platos,
ves que la respuesta dice,
no estás autenticado.
Vamos a iniciar sesión una vez más haciendo una publicación en el inicio de sesión de los usuarios,
y luego, verá que podemos iniciar sesión con éxito en este punto.
También nota que,
esa nueva cookie se ha configurado aquí.
Entonces, si hacemos un get en el localhost:platos aquí,
ahora, esto será exitoso.
Dado que estamos utilizando la mangosta local de pasaporte como el plugin de mangosta,
vamos también a revisar nuestro servidor MongoDB para ver cómo
la información del usuario se almacena realmente en nuestro MongoDB.
Por lo tanto, en su terminal,
puede abrir la ondulación Mongo,
así que digamos Mongo en la terminal y luego conectarse a nuestro servidor MongoDB,
y luego decir use ConFusion.
Luego diremos db.users.find () .pretty () y luego imprimiremos la información del usuario.
Por lo tanto, cuando imprime la información del usuario como ve aquí,
hay un usuario que nos hemos registrado anteriormente.
Por lo tanto, verá que el registro del usuario contiene el ID del objeto y luego,
el nombre de usuario abajo aquí,
y el indicador de administrador que es falso y luego,
también notará que en lugar de almacenar la contraseña en sí lo que
hace el plugin mangosta local de pasaportes de Mongos es almacenar
su valor de sal aquí y un valor hash aquí.
Ahora, lo que hace el plugin de Mongo es que usará la sal como una forma de
cifrar la contraseña e instalar la contraseña hash en este campo hash aquí.
Por lo tanto, cuando intente iniciar sesión,
aplicará la misma transformación a la contraseña entrante
y luego intentará hacer coincidir con este valor hash que se almacena aquí.
Por lo tanto, puede ver que en la base de datos en sí,
la contraseña no se almacena directamente dentro
del valor hash de la contraseña que se hash usando esta clave sal aquí,
que vemos aquí,
se almacena en el registro allí.
Así, así es como el plugin mangosta local del pasaporte nos permite
almacenar la información del usuario dentro de nuestra base de datos.
Con esta rápida comprensión de cómo pasaporte, pasaporte-local
y Passport-Local-Mangoose nos ayudan a simplificar
la estrategia local de nombre de usuario y contraseña en nuestra aplicación.
Completamos este ejercicio.
Este es un buen momento para que hagas un compromiso de Git con el pasaporte de mensaje.