Open Authorization, também conhecido como OAuth, é um protocolo usado para autorizar um usuário em seu site usando algum serviço de terceiros como Google, Github, Facebook, etc. O serviço de terceiros compartilha alguns dados (nome, email, foto de perfil, etc.) com seu site e depois autoriza o usuário em seu nome sem gerenciar as senhas e nomes de usuário do seu site, e salvar os usuários com muitos problemas extras.

Como funciona o OAuth

Quando um usuário clica em "Login com o Google", leva o usuário à página de consentimento do Google OAuth. Quando o usuário concorda com o consentimento e autentica sua identidade no Google, o Google entrará em contato com seu site como serviço de terceiros e autorizará o usuário em seu nome e compartilhará alguns dados com seu site. Dessa forma, o usuário pode ser autorizado sem gerenciar as credenciais do seu site separadamente.

Implementando o Google OAuth usando o nó.JS

Quase todas as linguagens de programação fornecem bibliotecas diferentes para implementar o Google OAuth para autorizar os usuários. Nó.JS fornece bibliotecas 'passaporte' e 'passaporte-google-outh20' para implementar o Google OAuth. Neste artigo, implementaremos um protocolo OAuth para autorizar os usuários a usar o Node.JS.

Crie um projeto no Google

O primeiro passo para implementar o Google OAuth é criar um projeto no Google Developer Console para o seu site. Este projeto é usado para obter as teclas da API usadas para fazer solicitações ao Google para obter autenticação aberta. GOTO O link a seguir e criar seu projeto:

https: // console.desenvolvedores.Google.com

.

Configurando o Projeto Google

Depois de criar o projeto, vá para o projeto e selecione “Tela de consentimento OAuth” no menu do lado esquerdo.

Clique no botão 'Criar' e forneça todos os detalhes do seu projeto. Clique em "Salvar e continuar" para seguir em frente.

Agora forneça o escopo do seu projeto. Escopos são os tipos de permissões para acessar os dados do usuário de uma conta do Google. Você precisa configurar as permissões para obter dados específicos do usuário da sua conta do Google. Clique em “Salvar e continuar.”

Agora adicione os usuários do teste ao projeto, se quiser. Os usuários de teste são os únicos usuários permitidos que podem acessar seu aplicativo da web no modo de teste. Por enquanto, não entraremos em nenhum usuário do teste e clicaremos em "Salvar e continuar" para seguir para a página de resumo do projeto.

Revise seu projeto na página de resumo e salve a configuração. Agora vamos gerar credenciais para o nosso projeto. Selecione a guia 'Credenciais' no menu do lado esquerdo e clique no botão 'Criar credenciais' na parte superior para gerar oauth 2.0 IDs de cliente.

No menu suspenso, selecione 'OAuth Client ID' e especifique o tipo de aplicativo como 'aplicativo da web' e o nome do seu aplicativo.

Na mesma página, temos que fornecer dois Uris, as 'origens autorizadas de JavaScript' e 'Uris de redirecionamento autorizado'. O 'JavaScript Origins autorizado' é a origem http do seu aplicativo da web, e não pode ter nenhum caminho. O 'URIs de redirecionamento autorizado' é o URI exato com um caminho em que o usuário será redirecionado após a autenticação do Google.

Depois de inserir todas as entradas necessárias, clique em 'Criar' para criar credenciais do OAuth.

Iniciando o nó.Projeto JS

Até agora, criamos um projeto do Google para autorizar os usuários para o nosso aplicativo usando o Google. Agora vamos iniciar o nó.Projeto JS para implementar o OAuth. Crie um diretório chamado 'Auth' e inicie o projeto Express.

ubuntu@ubuntu: ~ $ mkdir auth
ubuntu@ubuntu: ~ $ CD Auth
ubuntu@ubuntu: ~ $ npm init -y

Instalando os pacotes NPM necessários

Para implementar o Google OAuth usando o nó.JS, precisamos instalar alguns pacotes NPM. Usaremos 'passaporte', 'expresso', 'caminho' e 'passaporte-google-outh20'. Instale esses pacotes usando NPM.

ubuntu@ubuntu: ~ $ npm Install Express passaporte passaporte-google-outh20 caminho

Nó de escrita.Código JS

Primeiro de tudo, escreveremos duas páginas da web html simples, a que com um botão e autorizaremos o usuário quando clicar no botão. A segunda página será autorizada e o usuário será redirecionado para a página autorizada após a autorização. Crie um arquivo 'público/índice.html '.

Agora crie um arquivo 'público/sucesso.html 'com o seguinte conteúdo.

Autorizado

Depois de criar páginas da web, agora escreveremos código para autorizar os usuários a usar o Google OAuth. Crie um arquivo 'Índice.js '.

// Importando pacotes necessários
const express = requer ('express');
const passaporte = requer ('passaporte');
const caminho = requer ('caminho');
const googleSrategy = requer ('passaporte-google-outh20').Estratégia;
const app = express ();
// Definindo parâmetros
// ID do cliente é o parâmetro que obteremos do Google Developer Console
Client_id = "xxxxxxx";
// O segredo do cliente também será retirado do console do Google Developer
Client_secret = "xxxxx";
// O usuário será redirecionado para o callback_url após a autorização
Callback_url = ”http: // localhost: 8000/autorizado”;
// O número da porta deve ser o mesmo definido no console do desenvolvedor
Porta = 8000;
// Configurando o middleware do passaporte
aplicativo.Use (passaporte.inicializar());
aplicativo.Use (passaporte.sessão());
Passaporte.SerializeUser (função (id, feito)
feito (nulo, id);
);
Passaporte.DeserializeUser (função (id, feito)
feito (nulo, id);
);
// O middleware a seguir será executado sempre que o passaporte. O método de autenticação é chamado e retorna diferentes parâmetros definidos no escopo.
Passaporte.Use (New GoogleStrategy (
ClientID: client_id,
ClientSecret: client_secret,
Callbackurl: callback_url
,
Função assíncrona (AccessToken, RefreshToken, perfil, email, CB)
Retornar CB (nulo, e -mail.eu ia);

));
// Servindo página inicial para o aplicativo
aplicativo.get ('/', (req, res) =>

res.Sendfile (caminho.Junte -se (__ Dirname + '/Public/Index.html '));
);
// Página de sucesso Servindo para o aplicativo
aplicativo.get ('/sucesso', (req, res) =>

res.Sendfile (caminho.Junte -se (__ Dirname + '/Public/Success.html '));
);
// O usuário será redirecionado para a página de autenticação do Google sempre que chegar à rota '/google/auth'.
aplicativo.Get ('/Google/Auth',
Passaporte.autenticate ('google', scope: ['perfil', 'email'])
);
// O redirecionamento de falha de autenticação é definido na rota seguinte
aplicativo.Get ('/Autorizado',
Passaporte.Authenticate ('Google', FailureRedirect: '/'),
(req, res) =>

res.redirecionar ('/sucesso');

);
// em execução servidor
aplicativo.Ouça (Port, () =>

console.Log ("Servidor está em execução na porta" + porta)
)

Testando o Google OAuth

Agora nosso aplicativo está pronto e podemos testar se ele autoriza os usuários usando o Google OAuth. Vá para o diretório raiz e execute o aplicativo.

ubuntu@ubuntu: ~ ~ Índice de Nó.JS

Agora insira o URL do seu aplicativo no navegador.

http: // localhost: 8000

Ele mostra a página inicial com uma tag de âncora.

Quando clicamos no 'Autorizar aqui', ele será redirecionado para a página do Google Oauth.

O nome do seu aplicativo 'teste' é exibido na página de autenticação do Google. Ao autorizar sua conta, ela o levará à página autorizada.

Conclusão

Gerenciar nomes de usuário e senhas para diferentes aplicativos da Web não é uma tarefa feliz para os usuários. Muitos usuários deixam seu aplicativo da web sem registrar sua conta apenas porque não querem gerenciar credenciais. O processo de autorização em seu aplicativo ou site da Web pode ser simplificado usando serviços de terceiros como Google, Facebook, etc. Esses serviços autorizam os usuários em seu nome, e o usuário não precisa gerenciar credenciais separadamente. Neste artigo, implementamos o protocolo do Google OAuth para autorizar os usuários a usar o Node.JS.