Agora que temos entendido passaporte e como passaporte adiciona
em um middleware de autenticação simples para o nosso aplicativo NodeJS,
e fornece uma
maneira flexível fácil de configurar e fornece várias estratégias para autenticação de usuário,
vamos em uma jornada com o nosso passaporte.
Para começar este exercício,
como primeiro passo, vamos instalar
módulos de passaporte, passaporte-local e passaporte-local-mangusto em nosso servidor de confusão.
Então, no prompt, digite npm instal_passport,
passport-local,
passaporte mnus local-mangusto menos salvar e instalar esses três módulos.
Como você pode ver no momento, estamos começando com o passaporte 0.4.0,
passaporte-local 1.0.0 e passaporte-local-mangusto 5.0.1 versões neste curso.
Agora que instalamos passaporte, passaporte-local e passaporte-local-mangusto,
vamos para o servidor de confusão e ir para o arquivo user.js.
Vamos atualizar o esquema do usuário e modelo para usar o passport-local-mangusto.
Para fazer isso, aqui vamos dizer
var PassportLocalMongoose
exigem passaporte-local-mangusto.
Então isso vamos instalar como
o plugin mangusto em nossa aplicação e podemos remover o nome de usuário e
senha, porque estes seriam automaticamente adicionados
pelo plugin passport-local-mangusto aqui e
usar isso como um plugin em nosso esquema mangusto e modelo.
Nós diremos que o usuário conecte e o passaporte local-mangusto.
Então, isso será automaticamente como eu disse adicionando suporte para
nome de usuário e armazenamento hash da senha usando
o hash e salt e adicionando
métodos adicionais no esquema do usuário
e o modelo que são úteis para autenticação de passaporte.
Então, uma vez que tenhamos concluído a atualização do arquivo user.js, em seguida, em nossa pasta do projeto,
vamos criar um novo arquivo e nomeá-lo como authenticate.js.
No arquivo authentic.js,
deixe-me importar passaporte.
Então, vamos dizer exigir passaporte e vamos
usar este arquivo para armazenar as estratégias de autenticação que vamos configurar.
Então vamos dizer var. LocalStrategy requer passaporte-local, de
modo que o módulo local passaporte exporta uma estratégia que podemos usar para nossa aplicação.
Então, vamos dizer Passport-local.Strategy
e, em seguida, vamos importar usuário de modelos usuário.
Vamos agora configurar o passaporte com a nova estratégia local
e, em seguida, vamos exportar isso a partir deste arquivo porque este vai ser um módulo de nó.
Então vamos dizer exports.local e vamos dizer passaporte e você
pode ver que o passaporte suporta os vários métodos
aqui, então vamos dizer uso de passaporte e dizer
novo LocalStrategy e então é aqui que
as funções que são suportadas pelo passaporte-local-mangusto vem em nossa ajuda.
Assim, a estratégia local precisará ser fornecida com a função de verificação.
Dentro desta função, verificamos o usuário.
Esta função de verificação será chamada com o nome de usuário e senha que o
passaporte extrairá de nossa solicitação recebida.
Agora, na solicitação de entrada para o LocalStrategy, o nome de usuário e
a senha devem ser fornecidos no corpo da mensagem na forma de uma string Json.
Novamente, porque estamos fazendo corpo-parser para que será
adicionado ao corpo da mensagem e, em seguida, a partir daí passaporte
vamos recuperar isso e, em seguida, usar isso e fornecer o nome de usuário e senha
como parâmetros para a função de verificação que vamos fornecer para o LocalStrategy.
Uma vez que estamos usando plugin de mangusto passaporte,
o plugin de mangusto em si adiciona esta função chamada user.authenticate.
Então, ele adiciona esse método para o esquema do usuário e o modelo.
Vamos fornecer isso como a função
que fornecerá a autenticação para a LocalStrategy.
Agora, se você não estiver usando
passport-local-mangusto quando você configurar um plugin mangusto que fizemos,
se você não estiver usando isso,
então você precisa escrever sua própria função de autenticação de usuário aqui.
Na palestra anterior,
eu tinha mostrado uma função de autenticação de usuário simples
que pode ser usada aqui, mas a que é
fornecida pelo módulo passport-local-mangusto é mais
abrangente e é isso que vamos fazer uso em nossa aplicação.
Além disso, uma vez que ainda estamos usando sessões para rastrear usuários em nosso aplicativo,
precisamos serializar e desserializar o usuário.
Então isso basicamente leva a informação do usuário.
Agora lembre-se que a autenticação do passaporte irá montar o req.user ou a propriedade do usuário para
a mensagem de solicitação e para
que as informações do usuário serão serializadas e desserializadas realizadas usando
este dizendo serializar usuário e passaporte desserializar usuário.
Além disso, diremos usuário desserializar usuário.
Estas duas funções que serializar usuário e desserializar usuário são fornecidos
no esquema do usuário e modelo pelo uso do passport-local-mongusto plugin aqui.
Então, isso vai cuidar de tudo o que é necessário para o
nosso apoio para sessões no passaporte.
Assim que tivermos concluído esta atualização para o arquivo authenticate.js,
este arquivo será necessário onde quer que seja necessário para usarmos em nossa autenticação.
Em seguida, indo para o arquivo users.js,
no arquivo users.js,
primeiro importaremos passaporte.
Então vamos dizer passaporte var exigir passaporte.
Então, porque estamos usando o plugin de mangusto local passaporte,
o plugin de mangusto em si fornece algumas métricas que são
úteis para nós usar no processo de inscrição e no processo de login.
Então, indo até a postagem do roteador aqui,
o plugin mangusto nos fornece um método chamado register,
no esquema do usuário e modelo.
Então, vamos dizer registro de usuário e isso será transformado em dizer novo usuário.
Este novo usuário é o primeiro parâmetro que o registro toma
e o segundo parâmetro é a senha do corpo req.
Assim, a senha que vem como um segundo parâmetro no corpo da mensagem.
Portanto, lembre-se de que o nome de usuário e senha são passados
quando você se inscrever no corpo da mensagem.
Agora, neste caso,
isso resultará em uma função de retorno de chamada fornecendo erro
e o usuário como os dois valores de retorno de chamada aqui e, infelizmente,
isso então não funciona neste caso.
Então eu vou ter que cortar isso daqui e,
em vez disso, lidar com isso dentro deste método callback aqui.
Então, deixe-me apenas recuo
isso, para que seja mais fácil ver o código aqui.
Então eu vou dizer, registro de usuário eo primeiro parâmetro é
um novo usuário criado com
o nome de usuário fonte aqui eo segundo parâmetro é a senha,
e então o resultado é esta função de retorno de chamada que vai chamar,
vamos dizer erro usuário aqui.
Neste caso, temos que editar um pouco o código aqui.
Então, na primeira parte,
vamos dizer se erro,
então eles terão que enviar explicitamente de volta a resposta.
Então, eu só vou copiar estes dois aqui.
Então vamos dizer, se erro,
então res código de status,
vamos definir isso para 500 e definir tipo de conteúdo de cabeçalho e, em seguida,
vamos definir res json e, em seguida, erro, erro.
Então vamos construir um objeto json com o erro como o
valor para a propriedade error lá e, em seguida, enviar isso de volta.
Então é assim que você lidaria com o erro neste caso.
Caso contrário, o que fazemos aqui é que vamos
dizer passaporte autenticar local.
Então, se vamos usar passaporte para autenticar o usuário novamente.
Então, diremos que o passaporte autentique local.
Para garantir que o registro do usuário foi bem-sucedido.
vamos tentar autenticar o mesmo usuário que acabamos de registrar e
aqui vamos dizer req res e isso
retornará como um terceiro valor essa função dentro do qual,
vamos enviar de volta a resposta ao nosso cliente.
Então vamos dizer. Deixe-me remover isso e depois adicioná-lo aqui.
Podemos agora remover isso então,
porque isso não é necessário para nós e este é o fechamento do registro do usuário.
Na outra parte,
vamos fazer passaporte autenticar local.
Olhe para a sintaxe aqui.
Então este é o passaporte autenticar local e depois disso,
temos que chamar esta função aqui que os parâmetros req,
res e que o terceiro sendo uma função de retorno de chamada aqui.
Então esta é a maneira que isso é implementado porque passaporte espera que você faça isso dessa maneira.
Aqui, vamos definir req res código de status é 200,
definir cabeçalho conteúdo aplicativo json e, em seguida, vamos
res json registro status bem-sucedido e não vamos passar o valor do usuário aqui.
Em vez disso, o que eu vou fazer é
colocar uma bandeira chamada sucesso aqui como verdadeira aqui.
Agora, desta forma, no lado do nosso cliente quando este json é recebido,
o cliente pode simplesmente extrair a propriedade success e, em seguida, verificar se é verdade
ou não para verificar rapidamente se o registro foi bem sucedido ou não.
Então é assim que vamos lidar com o processo de registro do usuário aqui.
Então, observe como o código simplificou significativamente.
Se o usuário não se registrou corretamente
, isso enviará de volta um erro adequadamente e também a autenticação falhará.
Portanto, ambos os casos, você detectará a situação quando a autenticação do usuário falhar.
Agora, o processo de login em si também fica significativamente simplificado.
Então, não precisamos fazer tudo isso na rota de login aqui.
Então eu vou remover todo esse código e esta rota de login se torna simplificada aqui.
Agora, para a rota de login - para a postagem do roteador quando fazemos isso aqui,
aqui também esperamos que o nome de usuário e senha para ser incluído
no corpo da mensagem de post que está chegando ela.
Ao contrário do caso anterior em que estávamos incluindo isso no cabeçalho de autorização,
aqui esperamos que isso seja incluído no corpo da mensagem de postagem de entrada.
Então, para autenticar, vamos simplesmente dizer passaporte autenticar e vamos dizer local aqui.
Então esta será a segunda chamada aqui.
Então este é o segundo middleware aqui que vamos cortar.
Então, quando a postagem do roteador entra no ponto final de login,
vamos primeiro chamar o passaporte autenticar local.
Se isso for bem sucedido, então isso
entrará e a próxima função que se segue será executada.
Se houver algum erro na autenticação,
este passaporte autenticar local
enviará automaticamente uma resposta ao cliente sobre a falha da autenticação.
Então isso já está resolvido.
Portanto, observe como o código no processo de login fica significativamente simplificado.
Então, se isso passar com sucesso,
eu só preciso verificar o req e res e aqui o que eu vou fazer
é simplesmente enviar de volta uma mensagem para o lado do cliente com esta informação aqui.
Vamos dizer res código de status 200,
res definir cabeçalho conteúdo tipo aplicativo json e res json sucesso verdadeiro status.
Nós diremos, você está logado com sucesso.
É isso. Esta é a mudança que vamos fazer no arquivo users.js.
Então, observe como, por causa do passaporte do usuário,
tanto o processo de inscrição quanto o processo de login,
o código simplificou significativamente neste caso.
Agora vamos passar para atualizar o arquivo app.js indo para app.js agora.
Em app.js bem aqui
vamos inserir passaporte.
Em seguida, vamos importar
o módulo de autenticação que acabamos de implementar.
Vamos dizer var autenticar e no arquivo app.js abaixo aqui após a sessão,
adicionamos app.use (passport.initialize)
e app.use (.session).
Se o usuário estiver conectado,
então o que acontece é que quando a sessão é iniciada novamente,
você se lembra que quando você fizer login aqui,
você estará fazendo login aqui,
e uma chamada para o passaporte autenticar local,
quando isso for feito no estágio de login,
o passaporte autenticar local irá
adiciona automaticamente a propriedade do usuário à mensagem de solicitação.
Então, ele irá adicionar req.user e, em seguida,
a sessão de passaporte que fizemos aqui irá
serializar automaticamente as informações do usuário e, em seguida, armazená-lo na sessão.
Então, e posteriormente, sempre que
uma solicitação de entrada vem do lado do cliente
com o cookie de sessão já em vigor,
então isso carregará automaticamente o req.user na solicitação de entrada.
Então, é assim que a sessão de passaporte em si é organizada.
Então, uma vez feito isso,
até mesmo nosso código de autenticação se tornará muito mais simples aqui.
Então, no código de autenticação,
vamos simplesmente dizer, se req.user.
Então, o req.user será carregado pelo middleware da sessão do passaporte automaticamente,
e assim diremos req.user.
Se não req.user vamos dizer var err, novo erro,
você não está autenticado, e todas essas mensagens aqui.
Caso contrário, veja a outra parte também agora fica simplificado.
Vamos dizer outra coisa a seguir.
Então, seu código de autenticação se torna muito mais simples porque se req.user não estiver presente,
então isso significa que a autenticação não foi feita corretamente,
é por isso que você indica o erro.
Caso contrário, você está autenticado.
Se req.user estiver presente,
isso significa que o passaporte fez a autenticação e o
usuário req.user é carregado na mensagem de solicitação,
e assim você pode simplesmente ir mais para baixo.
Então, essa é a mudança que precisamos fazer para app.js.
Vamos salvar todas as alterações e, em seguida, olhar para o aplicativo no Postman.
Depois de salvar todas as alterações, reinicie o servidor.
Se o servidor estiver em execução,
pare-o e reinicie o servidor.
Deixe-me iniciar o meu servidor.
Uma vez que o servidor está funcionando,
vamos para o Postman e fazer alguns pedidos.
Indo para o Postman, deixe-me agora tentar registrar um novo usuário
fazendo uma postagem no endpoint de inscrição dos usuários.
Quando o registro é publicado,
você vê que no corpo da mensagem de resposta ele diz,
sucesso verdadeiro e registro de status bem-sucedido.
Então, o usuário foi registrado com sucesso no lado do cliente.
Então, agora, deixe-me fazer um login do usuário.
Então, diremos “Login” e ainda fornecemos
o nome de usuário e a senha no corpo da mensagem aqui.
Então, quando eu clicar no botão “Enviar”,
você notará imediatamente que na parte inferior,
ele diz, sucesso, verdadeiro e status,
você está logado e, em seguida, no cabeçalho
em si, você veria um set-cookie chegando porque estamos configurando a sessão,
e então você vê o cookie no lugar lá.
Quando você clica nos cookies,
você vê o ID da sessão no lugar bem ali.
Então, agora estamos logados com sucesso.
Vamos enviar uma solicitação para o ponto final Get localhost: 3000 pratos.
Você vê que sua solicitação entrou com sucesso e, em seguida, uma resposta foi enviada.
É claro
que, neste momento, meu banco de dados está vazio, então é por isso que ele envia de volta um array vazio
do site do servidor quando eu peço localhost: 3000/pratos.
Isto está perfeitamente bem.
Deixe-me agora fazer logout do usuário.
Então, quando eu sair do usuário, agora,
você vai notar que o usuário foi desconectado e quando você clicar nos cookies,
você vai notar que, esse cookie para localhost já foi embora.
Então, agora, se você tentar fazer um get no localhost:pratos,
você vê que a resposta diz,
você não está autenticado.
Vamos entrar mais uma vez fazendo uma postagem no login dos usuários
e, em seguida, você vê que podemos fazer login com sucesso neste ponto.
Você também percebe que,
esse novo cookie foi configurado aqui.
Então, se fizermos um get no localhost:pratos aqui,
agora, isso será bem sucedido.
Uma vez que estamos usando o mangusto local passaporte como o plugin mangusto,
vamos também verificar o nosso servidor MongoDB para ver como
as informações do usuário é realmente armazenado em nosso MongoDB.
Então, em seu terminal,
você pode abrir a ondulação Mongo,
então vamos dizer Mongo no terminal e, em seguida, conectar-se ao nosso servidor MongoDB,
e, em seguida, dizer use Confusion.
Então vamos dizer db.users.find () .pretty () e, em seguida, imprimir as informações do usuário.
Então, quando você imprime as informações do usuário como você vê aqui,
há um usuário que temos registrado anteriormente.
Então, você verá que o registro do usuário contém o ID do objeto e, em seguida,
o nome de usuário abaixo aqui,
e o sinalizador admin que é falso e, em seguida,
também notar que em vez de armazenar a senha em si o que o
plugin mongoose passaporte local faz é que ele armazena
seu valor salt aqui e um valor de hash aqui.
Agora, o plugin do Mongo faz é que ele vai usar o salt como uma forma de
criptografar a senha e instalar a senha hash neste campo de hash aqui.
Então, quando você tenta fazer login,
ele irá aplicar a mesma transformação para a senha de entrada
e, em seguida, tentar combiná-lo com esse valor de hash que é armazenado aqui.
Então, você pode ver que no próprio banco de dados,
a senha não é armazenada diretamente dentro
do valor hash da senha que é hash usando esta chave salt aqui,
que vemos aqui,
é armazenada no registro lá.
Então, é assim que o plugin Mangusto passaporte local nos permite
armazenar as informações do usuário dentro de nosso banco de dados.
Com esta rápida compreensão de como passaporte, passaporte-local
e Passaporte-local-mangusto nos ajudam a simplificar
a estratégia local de nome de usuário e senha em nossa aplicação.
Completamos este exercício.
Este é um bom momento para você fazer um commit Git com o passaporte de mensagem.