Agora que entendemos a autenticação baseada em token usando os Tokens Web JSON,
e também compreendemos as vantagens de usar essa abordagem.
O fato de que agora estamos construindo um servidor baseado em API Rest,
neste curso significa que
a autenticação baseada em JSON Web Token
é mais adequada para este servidor que estamos construindo.
Então, vamos atualizar nosso servidor de API Rest para fazer uso de JSON Web Tokens neste exercício.
Para começar a atualizar o servidor em seu terminal,
vamos primeiro instalar o JSON Web Token e o módulo Nó JWT passaporte.
Então, no prompt, digite npm, instale,
passaporte JWT JSON Web Token e menos menos salvar.
Como você pode ver, estou usando JSON Web Token 8.3.0 e passaporte JWT 4.0.0 neste curso.
Agora que concluímos a instalação, vamos atualizar nosso servidor expresso.
Indo agora para o nosso código,
vamos adicionar um arquivo chamado
conflict.js na pasta raiz do nosso projeto.
Agora, este arquivo conflict.js eu vou usá-lo
para armazenar algumas informações de configuração para o nosso servidor.
Agora, esta é uma maneira de centralizar toda a configuração para o nosso servidor.
Neste arquivo conflict.js,
deixe-me exportar um objeto JSON aqui.
Então vamos dizer, secretKey,
e este é o lugar onde
eu vou especificar a chave secreta que eu vou estar usando para assinar meu JSON Web Token,
e também deixe-me especificar um URL Mongo aqui,
que será o URL para o
meu servidor localhost 27017 MongoDB.
Uma vez que tenhamos concluído isso,
então vamos para o arquivo authenticate.js,
e no arquivo authenticate.js vamos
agora criar a estratégia JWT.
Esta é a estratégia de token da web JSON que é fornecida pelo
nosso módulo de nó JWT passaporte que acabamos de incluir e assim vamos dizer,
generatividade estratégia passaporte generatividy.strategy.
Isso nos fornecerá
uma estratégia baseada em JSON Web Token para configurar nosso módulo de passaporte,
em seguida, extrair JWT, que eu
também obterá do passaporte JWT.
Vamos precisar do passaporte JWT,
então vamos dizer “Extrair JWT”.
Então vamos importar
o módulo JSON Web Token
que acabamos de instalar.
Uma vez que tenhamos importado estes,
vamos em frente e começar a configurar algumas coisas.
Junto com estes, deixe-me importar a configuração que
criei o arquivo config.js que acabei de adicionar ao meu projeto.
Uma vez que eu completar isso, então deixe-me ir em frente e
introduzir algumas funções adicionais que eu vou exportar a partir daqui.
Vamos dizer, exports.getToken,
esta função quando fornecer com um parâmetro lá que eu vou simplesmente chamar usuário,
que será um objeto JSON,
isso irá criar o token e dar-lhe para nós.
Para criar o token, estaremos usando o módulo jsonwebtoken que acabamos de importar.
Então, aqui vamos dizer retorno JWT.sign,
isso nos ajuda a criar o JSON Web Token e assim dentro que ele vai
me permitir fornecer a carga útil e
a carga aqui vem como o parâmetro aqui chamado usuário,
e então o segundo parâmetro é
a chave secreta ou privada que eu recebo da configuração. chave secreta,
que eu acabei de configurar um pouco mais cedo.
Podemos fornecer opções adicionais aqui.
Uma opção que vou fornecer a isto é...
Ok, deixe-me ir para a próxima linha aqui,
a opção que eu vou fornecer é ExpireSin.
O ExpireSin irá dizer-lhe quanto tempo o jsonwebtoken será
válido então, neste caso, eu digo 3.600 significando 3.600 segundos ou cerca de uma hora.
Uma hora depois, você terá que renovar o jsonwebtoken.
Uma hora é tempo suficiente para podermos testar nossa aplicação.
Você pode definir isso para ser muito mais longo se você escolher.
Em um aplicativo real você pode definir isso para ser um valor muito mais longo talvez
alguns dias e esperar que o usuário se autentique novamente a cada poucos dias.
Agora, vamos também configurar
a estratégia baseada em jsonwebtoken para a nossa aplicação de passaporte.
Então, deixe-me declarar uma variável chamada opts,
que não é nada além das opções que eu vou especificar para a minha estratégia baseada em JWT.
Então, vamos dizer opts JWTFromRequest.
Agora esta opção especifica
como o jsonwebtoken deve ser extraído da mensagem de solicitação recebida.
Aqui é onde vamos usar o extrato JWT.
Esta extração JWT suporta vários métodos
para extrair informações do cabeçalho.
Ele vai dizer de AuthHeader de AuthHeader como token portador,
do cabeçalho qual esquema e assim por diante.
Se você ler a documentação, ele irá
dizer-lhe várias maneiras de extrair o jsonwebtoken.
Você pode passar o token no corpo da
mensagem de solicitação de entrada e, em seguida, você pode extraí-lo de lá,
você também pode usar extratores personalizados e assim por diante.
Neste curso, eu vou usar o método mais simples chamado
de cabeçalho de autenticação como um token portador.
Já estamos familiarizados com
o cabeçalho de autenticação porque como temos usado isso com
a autenticação básica e a autenticação baseada em cookies anteriormente.
Então, eu só vou usar
esse mesmo campo de cabeçalho na mensagem de solicitação para carregar o jsonwebtoken.
Então eu vou dizer opts como portador token jsonwebtoken.
O próximo, vamos dizer opts.secretorKey,
este é o segundo parâmetro que me ajuda a
fornecer a chave secreta que eu vou estar usando dentro da minha estratégia para o login.
Então essa é a outra opção que eu vou especificar aqui.
Uma vez que eu estou especificando esses dois,
deixe-me exportar a estratégia Passport
que eu vou configurar aqui então vamos dizer ExportJWTPassport,
então vamos dizer passport.use.
Lembre-se da forma como especificou a estratégia local anteriormente.
Aqui estamos especificando a estratégia baseada em JWT,
então vamos criar uma nova estratégia JWT,
lembre-se que acabamos de importar a estratégia JWT
aqui que é o que vamos usar para criar uma nova estratégia.
Esta estratégia JWT leva
o objeto opções que eu acabei de criar como o primeiro parâmetro.
As opções de estratégia e a segunda é a função de verificação que eu preciso fornecer,
e assim a função de verificação eu vou fornecê-lo na próxima linha aqui,
vamos dizer FunctionJWT_PayLoad.
Feito. Então, quando esta função é chamada,
o feito é o retorno de chamada que é fornecido pelo passaporte.
Então, sempre que você tem passaporte que você está configurando com uma nova estratégia,
você precisa fornecer o segundo parâmetro feito.
Através deste parâmetro feito,
você estará passando de volta informações para o passaporte que ele irá então
usar para carregar coisas na mensagem de solicitação.
Então, quando passaporte analisa a mensagem de solicitação,
ele vai usar a estratégia e, em seguida, extrair informações
e, em seguida, carregá-lo em nossa mensagem de solicitação.
Então, como isso acontece de ser uma função,
eu só vou usar uma função de seta aqui,
eu tenho gostado de funções de seta.
Então, deixe-me criar isso como uma função de seta aqui,
e dentro desta função,
estaremos definindo a função.
Então, o que fazemos dentro da função?
Deixe-me fazer um console.log de
JWT payload e,
em seguida, deixe-me apenas logout a opção vindo aqui,
a JWT payload Option vindo aqui,
para que você possa ver o que está dentro da carga JWT.
Em seguida, vamos procurar um usuário dizendo user.findOne,
e então eu sei que no jwt.payload,
há um campo ID que entra.
Então, isso é o que eu vou ser atribuindo como o campo ID aqui.
Então, eu vou dizer, User.Findone e o segundo
é uma função de retorno de chamada.
Como você percebe, este método de mangusto usuário e você tenta encontrar.
Então, vamos dizer que se errar então, retorno feito.
O que é que isto fez? Isto feito é o retorno de chamada que o
passaporte passará para a sua estratégia aqui.
Então, vamos chamar essa função feita.
Isso feito no passaporte leva três parâmetros.
Então, você pode ver as três peças de informação que isso feito espera que ele diz, erro: qualquer.
Então, se você tiver um erro, você irá passá-lo como o primeiro parâmetro.
O segundo parâmetro, usuário? ,
Se um usuário existir,
então o valor do usuário será passado em e, em seguida, se alguma informação? :, qualquer.
Então, estes dois são parâmetros opcionais e assim,
se você passar em qualquer informação,
então que será usado dentro do aplicativo.
Se eu passar false como o segundo parâmetro,
então isso significa que o usuário não existe ou isso.
Então, ele vai interpretar que o usuário não existe.
Então, eu poderia dizer, err,
falso, porque isso é um erro.
Então, eu não vou estar passando em um valor de usuário lá,
eu vou apenas passar em falso.
Lá, o próximo,
podemos dizer, else if (usuário).
Então, se o usuário não é nulo,
vamos dizer retorno feito (nulo).
Não há erro, então, o primeiro parâmetro será
nulo e o segundo parâmetro é o usuário,
mas acabamos de receber do MongoDB.
Caso contrário, vamos retornar
feito com null, false.
Então, no último caso,
não conseguimos encontrar o usuário,
então vamos passar em falso.
Então, vamos lidar com isso assim.
Se você quiser, você pode criar uma nova conta de usuário neste momento,
mas eu vou manter isso simples apenas para que seja fácil para nós entender.
Então, vamos apenas dizer, nulo, falso. Isso é seis.
Então, esta é a estratégia de passaporte JSONWebToken que acabei de configurar aqui.
Além disso, deixe-me exportar
mais uma função daqui chamada VerifyUser.
Agora, esta função
VerifyUser, eu vou usá-lo para verificar um usuário de entrada.
Então, é aqui que vou usar passaporte.authenticate.
Então, o passport.authenticate, a estratégia é estratégia jwt que eu acabei de configurar,
a estratégia JSONWebToken que eu acabei de configurar.
Então, a segunda parte,
eu diria, sessão: falsa.
Então, isso significa que,
nós não vamos criar sessões neste caso.
Como você se lembra, um aplicativo inverso,
estamos usando autenticação baseada em tokens.
Então não vamos criar sessões.
Então, é por isso que eu defini esta sessão
de opção como false aqui, e claro, o primeiro especificou a estratégia que eu vou usar.
Então, para verificar um usuário,
usarei a estratégia JWT.
Como funciona a estratégia JWT?
Na solicitação de entrada,
o token será incluído no cabeçalho de autenticação como vimos aqui.
Nós dissemos cabeçalho de autenticação como token portador.
Se isso estiver incluído, então isso será extraído e que será
usado para autenticar o usuário com base no token.
Uma pequena correção aqui, deve ser user.findone_id é igual a jwt_payload. _id,
porque esse é o valor de id que está dentro da carga do meu JSONWebToken.
Então, estamos procurando o usuário com esse ID fornecido.
Então, uma vez que tenhamos concluído isso, então agora,
a segunda parte que precisamos fazer é que precisamos criar o token em algum lugar.
Agora, onde criamos o token?
Então, é aqui que algo que estamos fazendo no arquivo users.js é muito útil para nós.
No arquivo users.js,
lembre-se de que você já tem esse endpoint chamado login.
No ponto de extremidade de login,
você estava usando o nome de usuário e a senha para autenticar o usuário.
Então, mesmo com o JSONWebToken para emitir o JSONWebToken,
primeiro você precisa autenticar o usuário usando uma das outras estratégias,
e se você estiver usando a estratégia local primeiro,
vamos autenticar o usuário usando o nome de usuário e senha.
Uma vez que o usuário é autenticado com o nome de usuário e senha,
então emitiremos o token para o usuário dizendo:
“Ok, você é um usuário válido,
eu vou lhe dar o token”.
Todas as solicitações subseqüentes simplesmente carregarão o token
no cabeçalho da mensagem de solicitação de entrada.
Então, anteriormente, nós usamos para criar sessões.
Quando o usuário é autenticado,
não vamos usar mais sessões.
Em vez disso, quando o usuário é autenticado usando a estratégia local,
emitiremos um token para o usuário.
Então, dentro deste método Router.post que fizemos naquele ponto de extremidade /login,
eu vou criar um token e passar esse token de volta para o usuário.
Então, aqui, vamos dizer um roteador.post.
Deixe-me criar um token.
Para criar um token,
temos essa função no módulo de autenticação chamado Authenticate.getToken.
Então, lembre-se, que já temos,
para fazer uso disso, é claro,
mesmo antes de começarmos lá,
eu preciso importar o autenticado.
Módulo aqui. Então, vamos dizer autenticar exigir. /autenticar.
Então, então, quando em seu código aqui,
podemos agora dizer Authenticate.getToken,
e o getToken toma parâmetro aqui.
Agora, lembre-se, voltando arquivo authenticate.js.
O arquivo authenticate.js tem um parâmetro aqui
que será usado como a carga útil quando você estiver criando o JSONWebToken.
Então, no arquivo users.js,
vou criar um token dando uma carga útil,
que contém apenas o ID do usuário.
Então, vamos dizer id: req.user. _id.
Isso é suficiente para criar o JSONWebToken.
Não queremos incluir nenhuma outra informação do usuário.
Se você optar por, você pode incluir outras partes das informações do usuário,
mas eu sugiro que mantenha o JSONWebToken pequeno.
O ID do usuário é suficiente porque se você precisa procurar o usuário,
o ID do usuário é suficiente para pesquisar no MongoDB para o usuário.
Então, eu só vou codificar apenas o ID do usuário aqui.
Agora, você sabe que o req.user já estaria presente,
porque quando o passport.authenticate ('local') autenticar com êxito o usuário,
isso irá carregar a propriedade user na mensagem request.
Então, é por isso que eu sou capaz de fazer isso aqui.
Então, isso é o que vou usar para criar o token.
Agora, uma vez que o token é criado,
eu quero passar esse token de volta para o usuário.
Então, no objeto rest.json que estou fornecendo aqui, eu
já estou carregando a verdadeira bandeira de sucesso e também,
uma mensagem de status aqui.
Deixe-me adicionar o token
como uma das propriedades na mensagem de resposta aqui.
Então, o token que eu acabei de criar,
vou passar isso de volta como a segunda propriedade dentro desta string Json aqui.
Então agora, quando meu cliente recebe essa string Json no corpo da mensagem de resposta,
ele pode entrar e extrair o token de lá.
É isso. Então, agora atualizamos o arquivo users.js,
e agora você pode ver como o token será
criado e enviado de volta ao usuário quando o usuário for autenticado com sucesso.
Agora, este esquema também pode ser usado
quando você usa autenticação de terceiros como baseado em OAuth 2.0,
que vamos examinar no próximo módulo.
Agora, o procedimento será semelhante.
Você criará um token quando o usuário for autenticado
pelo provedor de autenticação de terceiros ou OAuth
e, em seguida, passará o token de volta para o usuário,
em uma abordagem semelhante à que você vê aqui.
Agora, uma vez que fizemos isso,
então vamos para o arquivo app.js.
No arquivo app.js, porque incluímos um arquivo de configuração aqui.
Então, deixe-me exigir o arquivo de configuração aqui,
e então a URL que eu estou usando aqui em vez de codificar este URL,
eu vou dizer config.Mongourl.
Então, agora, você vê como meu arquivo config.js pode ser usado como
um lugar centralizado onde eu posso preparar a configuração para o meu aplicativo.
É isso. Então, o que acontece agora é que quando o usuário
se autentica no ponto de extremidade /login e o usuário é autenticado com sucesso,
então o token será criado pelo servidor e enviado de volta para o cliente ou o usuário.
Assim, o cliente incluirá o token em
cada solicitação de entrada subseqüente no cabeçalho de autorização.
Agora, como ele inclui o cabeçalho de autorização?
Vamos voltar para authentic.js e aqui,
você vê que dissemos extractJwt.FromAuthHeaderasBearerToken aqui.
Então, isso será incluído no cabeçalho de autenticação como um token portador.
Vou mostrar-lhe como isso é feito,
em seguida, usamos o carteiro para incluir o token portador no cabeçalho de autenticação.
Agora, quando isso chega,
então você se lembra que logo abaixo aqui,
você configurou este método aqui chamado VerifyUser,
que chama o passaporte autenticar com JWT.
Então, este usa o token que
vem no cabeçalho de autenticação e, em seguida, verifica o usuário.
Então, sempre que eu quiser verificar a autenticidade do usuário,
eu posso simplesmente chamar verificar usuário,
e que irá iniciar a chamada para o passport.authenticate e verificar o sser.
Se isto for bem sucedido,
permitir-me-á prosseguir.
Este procedimento é muito semelhante ao que você fez no
arquivo users.js, onde você chama o mesmo passport.authenticate ('local').
Então, se isso for bem sucedido,
então vá em frente.
Se falhar, a função de autenticação retornará a mensagem de erro
ao cliente dizendo que o usuário não está autorizado.
Então, isso já está resolvido.
Então, agora, que incluímos isso no meu arquivo authenticate.js,
qualquer lugar que eu queira verificar o usuário,
eu posso simplesmente chamar
essa função VerifyUser
que eu especifiquei aqui ou a exportação que eu especifiquei aqui,
que vamos chamar o passport.authenticate usando
a estratégia JWT para autenticar o usuário.
Agora, como fazemos uso disso?
Agora, o que vamos fazer é entrar em cada um de nossos roteadores,
e controlar as opções em todas as rotas que queremos controlar.
Então, voltando para o arquivo app.js, agora,
que nós não estamos usando sessões eu vou remover esta sessão daqui,
porque nós não estamos mais usando sessões.
Da mesma forma, vou remover este passaporte.session daqui também.
Isso também não é necessário.
Além disso, essa autenticação, consulte anteriormente,
quando configurei essa autenticação,
essa autenticação foi aplicada a cada solicitação de entrada.
Agora, eu vou mudar meu aplicativo,
pelo qual eu vou exigir autenticação apenas em certas rotas e não em todas as rotas.
Então, deixe-me remover esta autenticação completamente de app.js.
Então, agora, quando a solicitação chega,
se ela estiver em/endpoint,
o índice será atendido.
Se ele estiver no endpoint /users, ele permitirá que você navegue para
as várias rotas que são montadas no /users no users.js
e, posteriormente, o resto dos outros.
O que vou fazer agora é deixar
a pasta pública aberta para qualquer um acessar.
Agora, em muitas aplicações,
isso pode ser muito bom.
Então, vou deixar isso aberto.
Agora, sobre os pratos,
promoções, e o ponto final dos líderes,
todos os pedidos de obter.
Deixarei que essas pessoas sejam respondidas sem exigir nenhuma autenticação.
Agora, por que eu iria querer fazer isso?
Se um usuário estiver fazendo uma solicitação get,
o usuário só deseja recuperar informações.
Então, por exemplo, no lado do cliente, se eu estou implementando um aplicativo web usando Angular
ou um aplicativo cliente usando Ionic ou script nativo,
então talvez eu queira implementar meu aplicativo
de tal forma que a página principal irá exibir informações já,
a informação genética que você deseja disponibilizar para qualquer pessoa que
visite seu site ou que abra seu aplicativo.
Assim, informações básicas podem ser exibidas lá.
Mas se você quiser alterar qualquer coisa,
então você espera que o usuário seja autenticado.
Assim, você permitirá que as operações POST, operações de
colocação e operações de exclusão sejam feitas somente por usuários autenticados.
Da mesma forma, para comentários, por exemplo,
você pode dizer que os comentários só podem ser postados ou modificados por usuários autenticados.
Assim, você pode restringir apenas algumas rotas para usuários autenticados,
a outra rota que você pode deixá-los abertos. Como é que fazemos isso?
Agora é aqui que o usuário de verificação que
exportamos do arquivo authenticate.js vem a calhar.
Agora, em vez de controlar todos os pontos finais,
todas as várias operações sobre os pratos, promoções
e líderes em pontos,
abriremos apenas as operações get para qualquer um,
mas as
operações post, put e delete serão restritas apenas a usuários autenticados.
Na atribuição, você adicionará mais uma categoria de usuários chamados usuários administradores.
Agora você restringe determinadas operações a serem executadas apenas por usuários administradores.
Assim, por exemplo, modificar os pratos
ou excluir as informações dos pratos do banco de dados,
será restrito apenas aos usuários administrativos.
Mas os usuários básicos podem postar comentários,
modificar os comentários que eles publicaram
e talvez até salvar alguns pratos favoritos.
Faremos essa parte no quarto módulo.
Então, como controlamos rotas específicas?
Então é aqui que temos que ir para cada um dos roteadores
e, em seguida, importar controles em rotas específicas.
Então, vamos começar com a rota dos pratos.
Então, para a rota dos pratos,
você lembrará que isso é controlado no arquivo dishRouter.js.
Então, indo para dishRouter.js,
vamos primeiro importar a autenticação aqui.
Então, vamos dizer, const authenticate
require../authenticate porque este
arquivo authenticator.js está na pasta de nível superior.
Então, lembre-se... autentique aqui.
Então, uma vez que você importar a autenticação,
para a rota do roteador prato para esta rota,
a operação get, eu vou permitir sem qualquer problema.
Então, isso está aberto.
Então eu não vou impor nenhuma restrição.
A partir do post, se quisermos aplicar vários middleware,
podemos simplesmente adicionar o principal dentro deste atrás do outro.
Agora, quando o post é chamado,
agora você está simplesmente executando esta função aqui.
Agora, pouco antes disso,
eu posso entrar e dizer, autenticate.VerifyUser, lá.
Então, o que isso faz?
Isso diz que se uma solicitação de post entrar,
eu primeiro executaria este middleware,
que eu exportei do arquivo authentic.js,
eu primeiro aplico isso, o
que é equivalente a dizer passaporte autenticar JWT e você está verificando o usuário.
Então, se isso for bem sucedido,
então eu vou seguir em frente para fazer o resto.
Se a autenticação falhar neste ponto, em
seguida, a autenticação do passaporte responderá de
volta ao cliente com a mensagem de erro apropriada.
Então isso já é tratado pelo passaporte autenticado,
então eu não tenho que me preocupar com nada além desse ponto.
Se eu cruzei este middleware e, em seguida, começar a
executar a próxima função que significa que a minha autenticação foi bem sucedida,
então eu sou capaz de prosseguir a partir deste ponto.
Então, isso está atuando como a barreira para este método post.
Agora usando o mesmo argumento,
eu posso simplesmente aplicar este middleware particular a todos os outros métodos.
Posso fazer isso com o posto.
Embora neste caso,
colocar não vai estar fazendo nada.
Mas, em qualquer caso,
eu vou simplesmente apenas por uma questão de uniformidade,
Vou aplicar o usuário de verificação para também colocar e, claro
, para excluir também, Vou aplicar colocar.
Da mesma forma, indo para baixo para o /DISHID,
eu vou permitir que para trabalhar sem qualquer problema.
Post, aplicarei o usuário de verificação.
Coloque também vou aplicar o usuário verificar e para excluir também mesmo.
Para o /dishid/comentários, eu vou deixar o get aberto,
está tudo bem para qualquer um para recuperar comentários sobre um prato específico.
Post, vou fechar isso, para
que apenas usuários verificados possam postar comentários.
Coloque também vou fechar isso e excluir também.
Você precisa ir um passo adiante e dizer:
“Somente os usuários que publicaram o comentário podem excluir suas próprias postagens.”
Mas faremos isso no próximo módulo.
No momento, eu vou dizer,
“Ok, um usuário verificado pode excluir qualquer comentário.”
Isso é claro que não é verdade,
podemos colocar um cheque adicional,
mas vamos fazer isso no próximo módulo deste curso.
Então, para excluir também eu aplicar o mesmo.
Mais uma vez, para o roteador prato comentários/comentários Id,
eu vou deixá-lo como aberto.
Post, vou deixá-lo fechado.
Coloque também fechá-lo e, em seguida, para excluir também vou fechar isso fora.
Excluir, claro, como eu disse,
a operação de exclusão deve ser permitido apenas um usuário que
criou o comentário deve ser solicitado
a excluir isso, mas você precisa configurar algumas coisas adicionais para que funcione corretamente,
o que faremos no próximo módulo.
No momento, estamos dizendo que um usuário verificado pode excluir um comentário específico, é isso.
Agora vamos aplicar o mesmo princípio ao roteador promocional e também ao roteador líder.
Então, indo para o roteador promocional,
deixe-me importar autenticar
e, em seguida, get está aberto,
então este é o roteador líder.
Então, ficar aberto.
Post, eu vou controlar isso,
colocar, controlar, excluir, controlar,
roteador líder, ID líder,
ficar tudo bem, postar,
controlado, colocar é controlado e excluir é controlado.
A mesma coisa com o roteador promocional.
Deixe-me, exigir a autenticação
e, em seguida, para a rota get é aberto,
POST é controlado, colocar é controlado,
excluir é controlado, mesma coisa para o promorouter/promoid.
Get é aberto, POST é controlado,
colocar e excluir também são controlados, é isso.
Vamos salvar todas as alterações.
Então, uma vez que concluímos todas as alterações,
vamos salvar as alterações.
Agora, nossa aplicação está pronta para ser testada.
Então, vamos reiniciar o nosso servidor,
ou se o servidor não estiver em execução,
vamos apenas iniciar o servidor.
Indo para o terminal,
meu servidor não está funcionando.
Então, deixe-me iniciar o servidor digitando npm start.
Curiosamente, ele acabou de lançar um erro aqui,
eu só queria ilustrar para vocês que até eu posso cometer erros,
então você verá que há um erro aqui que diz,
“Não é possível encontrar module.authenticate”, e então se eu olhar através do código,
eu acho que esse problema ocorreu no,
Onde isso ocorreu?
Então, eu apenas procuro aqui
e, em algum lugar aqui embaixo,
notei que esse problema ocorreu dentro do meu arquivo users.js.
Então, aqui mesmo, ele diz,
isso está no arquivo users.js.
Então, indo para o arquivo users.js, vamos corrigir isso.
Indo para
o arquivo users.js, bem no topo quando eu precisava autenticar, eu disse,
“.authenticate”, e como eu estava dizendo,
isso deve ser um ponto ponto porque ele está na pasta superior.
Este arquivo users.js na pasta Rotas
e autenticar está na pasta Rota de Projetos, portanto, deve ser autenticar ponto ponto ponto.
Então, se você cometer erros, lá vai você,
é assim que você vai ser lembrado do erro que você introduziu.
Então, vamos salvar as alterações e, em seguida, reiniciar nosso servidor.
Novamente, voltando para esse terminal,
deixe-me iniciar meu servidor e meu servidor agora está funcionando,
vamos para o Postman e depois testar nosso aplicativo.
Agora, no Postman, deixe-me primeiro tentar fazer
um GET no localhost: 3000/pratos e, em seguida, quando eu faço um GET,
ele é bem sucedido porque o ponto final GET não é controlado.
Então eu posso fazer um GET em pratos,
eu posso fazer um GET em promoções,
e tudo funciona muito bem.
Mas se eu tentar fazer um POST em pratos,
então deixe-me encontrar onde eu fiz um POST em pratos.
Aqui eu fiz um POST em pratos.
Então, quando eu tentei fazer um POST em pratos,
ele imediatamente diz não autorizado.
Então meu módulo Passport percebeu que eu não estou autorizado, então eu não tenho permissão para fazer isso,
então é isso que está me lembrando.
Deixe-me limpar os cookies de,
no caso de você encontrar um cookie em seu Postman basta remover o cookie
correspondente ao localhost porque
esse cookie não é mais necessário e não será necessário.
Então, mesmo se eu remover o cookie e depois POST,
ele ainda vai dizer não autorizado.
Então, eu não estou autorizado para fazer essas operações.
Então, eu tenho que fazer login.
Agora, se você tiver feito o exercício anterior,
você teria deixado o usuário que você se inscreveu anteriormente.
Então, por exemplo, você teria inscrito esse usuário específico no exercício anterior,
deixe-me tentar registrar o mesmo usuário novamente e
meu servidor deve reclamar dizendo UserExistsError para que isso signifique que o usuário existe,
então eu não preciso me inscrever novamente.
Se você excluiu o usuário do seu MongoDB,
basta se inscrever esse usuário mais uma vez e, em seguida, vamos fazer login.
Então, vamos enviar uma solicitação de login para esse ponto final.
Então, quando eu enviar a solicitação de login fazendo um POST para o usuário final,
observe o que é retornado pelo meu servidor.
Você imediatamente percebe que na mensagem de resposta
junto com o sinalizador de sucesso e a mensagem de status,
você também recebe um token aqui.
Agora, este token em particular,
eu preciso copiar este token,
porque em meus pedidos subsequentes,
eu precisarei incluir este token.
Então, deixe-me ir para a versão bruta deste e que eu vou copiar este token.
Este token não é nada além de uma longa corda lá,
então deixe-me copiar este token.
Então, agora, se você estiver curioso sobre o que está contido neste token,
o JSON Web Token pode ser examinado.
Há um site específico onde você pode entrar e digitar
seu JSON Web Token e, em seguida, realmente verificar o que está dentro do JSON Web Token.
Vamos fazer isso como o próximo passo.
Em uma janela do navegador,
basta digitar jwt.io e isso o levará a este site chamado JSON Web Token jwt.io.
Se você se lembra, na palestra,
eu tinha mostrado a estrutura do JSON Web Token
e tinha mostrado a você que o JSON Web Token contém três partes: o cabeçalho,
a carga útil e as informações lá.
Agora, neste caso,
a informação está aqui em cima então eu vou
colar meu JSON Web Token neste lado esquerdo,
então deixe-me selecionar isso e, em seguida, colar meu JSON Web Token
no lado esquerdo na parte codificada e, em seguida, no lado direito,
ele está mostrando exatamente o que é dentro do JSON Web Token que acabei de criar.
Então, ele diz que o cabeçalho contém esses dois pedaços de informação.
O aviso de carga que contém o ID
do usuário e, em seguida, a assinatura na parte inferior aqui.
Então, isso é o que está contido dentro do meu JSON Web Token.
Voltando para o Carteiro,
deixe-me tentar pegar os pratos.
Então, quando eu digo GET localhost: 3000/pratos,
ele ainda retornará uma string vazia,
array vazio aqui porque meu banco de dados não o contém.
Então, deixe-me POST um prato no meu banco de dados.
Então, eu vou escolher a operação POST e no corpo,
você vê que eu tenho o meu prato aqui.
No cabeçalho, eu vou adicionar no novo cabeçalho chamado
autorização e você lembra que anteriormente para autorização básica,
você disse básico e, em seguida, você tinha a base 64 cadeia codificada lá.
Se você quiser incluir seu JSON Web Token no cabeçalho de autorização,
porque em nosso código,
dissemos autorização como token portador.
Então, se você quiser incluir o token no cabeçalho de autorização,
na autorização vamos dizer portador e, em seguida, vamos colar
essa string token que acabamos de copiar de nossa solicitação de entrada.
Então, vamos colar a string token lá.
Então, isso é o que será contido
no cabeçalho de autorização da minha solicitação de saída aqui,
solicitação POST de saída aqui.
Então observe, o lado esquerdo diz portador e o lado direito é a string,
o token que eu acabei de copiar
do ponto onde eu fiz login e, em seguida, deixe-me enviar a mensagem POST
agora e meu POST agora é bem sucedido e isso é postado no meu banco de dados.
Agora, se você quiser ter certeza de que ele foi postado,
vamos fazer um GET e quando você fizer um GET,
você pode ver que de fato esse prato foi inserido no meu banco de dados como mostrado aqui.
Então, é assim que você estará fazendo uso de JSON Web Tokens em seu aplicativo.
Então, sempre que você precisar fazer uma
operação POST, PUT ou DELETE em qualquer um dos endpoints,
você estaria encerrando.
Então, deixe-me voltar para este pedido POST aqui.
No cabeçalho, você vai colocar
este campo de autorização e, em seguida, isso seria incluído na autorização,
você vai iniciá-lo com portador e, em seguida, a string token,
depois que o espaço portador,
um único espaço e, em seguida, a string token seguinte a isso.
Então, é assim que suas mensagens de solicitação
carregariam o JSON Web Token no cabeçalho da mensagem de solicitação de saída.
Você também pode incluir o token no corpo da mensagem de solicitação de saída.
Agora, para isso, você terá que configurar
seu servidor express especialmente o JWT extra no
arquivo authenticate.js para aceitá-lo
do corpo para que você lembre que lá vimos que
o JWT extra suporta muitas maneiras diferentes de extrair
o JSON Web Token da entrada solicitação.
Então, lá você precisa especificar,
se você vai ser incluí-lo no corpo,
você precisa especificar essa informação lá.
Agora, os detalhes de como fazer isso você pode consultar
a documentação do módulo Passport JWT para entender como isso é feito.
Neste curso, eu vou simplesmente usar isso no cabeçalho de autorização
como eu tenho mostrado aqui e isso funciona muito bem para a maioria dos casos.
Agora, se você estiver desenvolvendo um aplicativo Web,
um aplicativo Angular ou um aplicativo Ionic ou NativeScript,
você precisa ser capaz de configurar
esse aplicativo pelo qual o JSON Web Token será incluído no cabeçalho de autorização.
Na última lição deste curso,
mostrarei como integrar o cliente e o servidor,
o cliente que você desenvolveu nos cursos anteriores com
o servidor que desenvolvemos neste curso.
Com isso, completamos este exercício.
Neste exercício, vimos como
podemos configurar nosso aplicativo para usar JSON Web Tokens,
e vimos como lidamos com a autenticação do usuário usando o JSON Web Token,
usando o suporte do módulo Passport e do módulo Passport JWT,
e os módulos JSON Web Token Node.
Com isso, completamos este exercício.
Este é um bom momento para você fazer um Git Commit com a mensagem Passport JWT.