A autenticação, ou confirmação da identidade de um usuário em um aplicativo, é fundamental para implementação em aplicativos da web. A autenticação cria um sistema para verificar as credenciais do usuário por meio de nomes de usuário, senhas, tokens, impressões digitais, reconhecimento facial ou perguntas de segurança.
Os desenvolvedores geralmente ficam divididos entre construir seu próprio sistema de autenticação ou usar um serviço de terceiros. Neste artigo, veremos como implementar a autenticação em aplicativos Next.js usando Auth0 .
O que é Auth0?
De acordo com seus documentos, “ Auth0 é uma solução flexível e drop-in para adicionar serviços de autenticação e autorização ao seu formulários”. Basicamente, o Auth0 permite adicionar segurança aos seus aplicativos usando qualquer linguagem ou pilha. Alguns de seus recursos incluem:
Autenticação multifator: requer duas ou mais credenciais para acesso (ou seja, autenticação de dois fatores)
Login social : permite que você se inscreva e faça login em seu aplicativo usando suas redes sociais
Logon único: armazena credenciais, para que você não precise inseri-las a cada login
Analytics: ferramentas analíticas e de relatório
O Auth0 também vem com frameworks e SDKs para várias bibliotecas de front-end prontos para uso. Um deles é o SDK do Auth0 Next.js , que permite adicionar autenticação aos aplicativos Next.js usando Auth0.
SDK do Auth0 Next.js
Primeiro, vamos instalar o pacote Auth0 Next.js SDK do npm. Vamos configurar o Auth0 com base em nossas necessidades exclusivas de projeto e, em seguida, estaremos prontos para implementá-lo!
Com o SDK Auth0 Next.js, podemos adicionar autenticação aos nossos aplicativos usando métodos do lado do cliente e do lado do servidor. No back-end, usaremos rotas de API. No front-end, usaremos a API React Context .
Instalando Auth0
Primeiro, crie uma conta Auth0 . Navegue até o seu Painel Auth0 e clique nos aplicativos. Criar uma nova aplicação; usaremos um aplicativo da web normal.
Você verá um pop-up perguntando qual estrutura ou pilha você está usando. Escolha Next.js.
Clique na guia Aplicativos e selecione o aplicativo criado recentemente. Na guia Configurações , role até a subseção URIs do aplicativo e atualize os seguintes detalhes:
URLs de retorno de chamada permitidos: adicione http://localhost: 3000/api/auth/callback
URLs de logout permitidos: adicione http://localhost: 3000/
Nos snippets de código acima, adicionamos um URL de retorno de chamada para redirecionar os usuários depois que eles registram em nosso aplicativo e um URL de logout para redirecionar os usuários depois que eles se desconectam.
Em nosso painel Auth0, podemos configurar o tipo de autenticação que desejamos para nossos usuários, adicionar páginas de login e inscrição, adicionar registros de usuários e até mesmo adicionar um banco de dados para usuários. Agora, estamos prontos para criar nosso aplicativo Next.js!
Criação de um aplicativo Next.js
Para inicializar um aplicativo Next.js, recomendo usar Criar próximo aplicativo . Esta ferramenta CLI configura automaticamente tudo que você precisa para seu aplicativo. Execute o comando abaixo para criar um novo projeto:
npx create-next-app {nome do projeto}
Como alternativa, você pode usar o Yarn:
yarn create-next-app {nome do projeto}
Em seguida, vá para o diretório do projeto e inicie o servidor de desenvolvimento usando o comando abaixo:
cd {nome do projeto} && yarn run dev
Configurando Auth0 para Next.js
Agora, instalaremos a dependência @ auth0/next.js-auth0 em nosso aplicativo:
npm install @ auth0/nextjs-auth0
Usando o Yarn:
yarn add @ auth/nextjs-auth0
A seguir, vamos instalar o pacote dotenv, que usaremos para armazenar nossas variáveis de ambiente. Também adicionamos componentes estilizados, que usaremos para estilizar nosso aplicativo:
npm install dotenv styled-components
Usando o Yarn:
fios adicionar componentes estilizados dotenv
Crie um novo arquivo chamado.env no diretório raiz do seu projeto e adicione as seguintes credenciais, fornecidas pelo Auth0:
AUTH0_SECRET=”seu segredo de autenticação vai aqui”
AUTH0_BASE_URL=”http://localhost: 3000″
AUTH0_ISSUER_BASE_URL=”seu URL base de auth0″
AUTH0_CLIENT_ID=”seu ID exclusivo vai aqui”
AUTH0_CLIENT_SECRET=”seu segredo auth0 vai aqui”
O AUTH0_SECRET é um segredo de 32 caracteres usado para criptografar cookies e o AUTH0_CLIENT_SECRET pode ser encontrado no painel do Auth0 na guia Configurações.
Você pode ler mais sobre as configurações do Auth0 nos documentos.
Criação de rotas e componentes de aplicativos
Crie uma nova pasta chamada componentes dentro do diretório src em nosso aplicativo Next.js. Dentro da pasta de componentes, crie uma nova pasta chamada Navbar. Dentro do Navbar, crie um arquivo chamado Navbar.jsx.
Vamos criar um componente funcional chamado Navbar com dois links dinâmicos, um para fazer o login de um usuário e outro para desconectar um usuário:
//componentes/Navbar/Navbar.jsx importar {useUser} de”@ auth0/nextjs-auth0″;
importar estilizado de”componentes estilizados”; const Navbar=()=> { const {usuário}=useUser (); Retorna (
My Nextjs Note App
{!do utilizador ? ( Faça login ): ( Sair )} );
};
No código acima, criamos um componente funcional chamado Navbar. Dentro dele, inicializamos uma tag nav e adicionamos um h1 com o título de nosso aplicativo. Em seguida, verificamos se o usuário está logado. Se estiver, exibimos o botão Sair. Se eles não estiverem logados, renderizamos um botão Sign in.
A seguir, adicionaremos estilos ao nosso arquivo Navbar:
const Nav=styled.nav` display: flex; alinhar-itens: centro; justify-content: espaço entre; largura: 90%; margem: 0 automático; h1 { tamanho da fonte: 1,4 rem; estilo da fonte: oblíquo; } &> div { display: flex; uma { margem esquerda: 1rem; } } uma { display: bloquear! importante; fronteira: nenhum; esboço: nenhum; plano de fundo: # 5b6d5b; cor: #fff; tamanho da fonte: 1rem; preenchimento: 0,8 rem 2,5 rem; raio da borda: 5px; transição: opacidade 0,7s; decoração de texto: nenhum; &:flutuar { opacidade: 0,8; } }
`;
exportar Navbar padrão;
Nosso componente Navbar deve ser semelhante à imagem abaixo:
Construindo um componente de formulário
Nesta seção, construiremos um formulário para os usuários adicionarem notas a seus aplicativos. Construiremos um campo de entrada, um botão de envio e uma função para enviar nossa nota no componente de formulário.
Usaremos localStorage como banco de dados para armazenar nossas notas:
import {useState} de”react”;
importar estilizado de”componentes estilizados”;
importar {addNote} de”../../utils/utils”; Const Form=({hideForm, setRefresh})=> { const [título, setTitle]=useState (“”); const [content, setContent]=useState (“”); const SubmitHandler=(e)=> { e.preventDefault (); título && conteúdo && addNote (título, conteúdo); setTitle (“”); setContent (“”); hideForm (false); setRefresh (); };
No bloco de código acima, importamos o gancho useState do React e um objeto addNote do diretório de utilitários. Em seguida, criamos um componente de formulário que inclui um hideForm e uma propriedade setRefresh.
A seguir, adicionamos a função SubmitHandler para lidar com o envio de nossas notas. Para que uma nota seja enviada, ela deve conter um título e conteúdo.
Agora, vamos construir um componente e botões para enviar nossas notas usando a função acima:
Retorna (
);
};
No bloco de código acima, criamos dois campos de entrada, um para adicionar o título da nota e outro para os usuários inserirem seu conteúdo. Por fim, adicionamos um botão de envio.
Para completar nosso diretório de componentes, precisamos construir um componente para uma nota.
Construindo o componente de notas
Agora, escreveremos uma função que atuará como um backbone para adicionar notas ao nosso aplicativo. Inicializaremos funções para editar e excluir uma nota depois que ela for adicionada por um usuário. O componente obterá um ID para nossas notas e o definirá como o estado de nosso aplicativo:
import {useState} de”react”;
importar estilizado de”componentes estilizados”;
import {editNote, deleteNote} de”../../utils/utils”; const Note=({title, id, content, setRefresh})=> { const [editar, setEdit]=useState (false); const [newTitle, setNewTitle]=useState (título); const [newContent, setNewContent]=useState (conteúdo); const submitHandler=(e)=> { e.preventDefault (); newTitle && newContent && editNote (id, newTitle, newContent); setEdit (false); setRefresh (); }; const deleteHandler=()=> { const ok=window.confirm (“Tem certeza que deseja excluir?”); if (ok) { deleteNote (id); setRefresh (); } };
No código acima, inicializamos uma função Note, que leva título, id, conteúdo e setRefresh como adereços. Usando os ganchos useState, adicionamos o estado ao título, edição e newContent. Como fizemos com nosso componente de formulário, criamos uma função submitHandler para os usuários.
Para lidar com a exclusão de uma nota pelo usuário, criamos outra função chamada deleteHandler, que pede um alerta de confirmação antes de tentar excluir uma nota com base no ID da nota.
A seguir, criaremos um botão Editar para editar nossas notas e adicionaremos um botão Excluir para excluir postagens usando uma instrução condicional.
Retorna (
): ( <> {conteúdo} > )} Editar nota
{title}
};
No bloco de código acima, adicionamos campos de entrada para os usuários adicionarem notas. Também adicionamos os botões Editar e Excluir. Para editar uma entrada, atualizamos as notas do usuário usando o ID da entrada.
Observe os erros na tela que indicam que utils não está declarado. Criaremos uma nova pasta dentro de nosso src chamada utils que conterá a lógica para armazenar as notas do usuário no armazenamento local de seus dispositivos.
Armazenamento e edição de notas
Vamos escrever a lógica para esta tarefa no diretório utils.
Adicionando notas do usuário ao armazenamento local:
/** * Adiciona nota à lista de notas em localStorage * @param {*} título da nota do título * @param {*} corpo do conteúdo da nota */
export const addNote=(título, conteúdo)=> { let notesArr=JSON.parse (localStorage.getItem (“next: note-app”)); if (notesArr?.length) { const newNote={ id: new Date (). getTime (), título, contente, }; const newNotesArr=[… notesArr, newNote]; localStorage.setItem (“next: note-app”, JSON.stringify (newNotesArr)); } senão { const newNote={ id: new Date (). getTime (), título, contente, }; const newNotesArr=[newNote]; localStorage.setItem (“next: note-app”, JSON.stringify (newNotesArr)); }
};
No código acima, exportamos o objeto addNote que contém um título e conteúdo. Em seguida, inicializamos o objeto e o passamos como JSON para o armazenamento local. Para garantir que os usuários não adicionem notas vazias, adicionamos um método que monitora o comprimento da matriz da nota do usuário e a armazena como strings JSON no armazenamento local.
Nosso componente deve ser semelhante à imagem abaixo:
Editando uma nota
Nesta seção, criaremos uma função para editar uma nota depois que ela for adicionada ao armazenamento local do usuário:
** * Editar Nota Func * @param {*} id note id * @param {*} title novo título * @param {*} content novo conteúdo */
export const editNote=(id, título, conteúdo)=> { let notesArr=JSON.parse (localStorage.getItem (“next: note-app”)); let noteIndex=notesArr.findIndex ((note)=> note.id===id); const selectedNote=notesArr [noteIndex]; const updatedNote={ id: selectedNote.id, título, contente, }; notesArr.splice (noteIndex, 1, updatedNote); localStorage.setItem (“next: note-app”, JSON.stringify (notesArr));
};
No bloco de código acima, analisamos uma nota para nosso armazenamento local como um arquivo JSON. Em seguida, recuperamos a nota que queremos editar, passando o ID da nota. Usando o método nativo JavaScript Splice , atualizamos o conteúdo de a nota, substituindo ou adicionando novos conteúdos a uma nota.
Nossa página de edição deve ser semelhante à imagem abaixo:
Renderizando nosso aplicativo
Vamos navegar até nosso diretório api dentro de nossa pasta src. Dentro dele, vamos atualizar o index.js para renderizar todo o nosso aplicativo:
importar Cabeçalho de”próximo/cabeça”;
import {useState, useEffect} de”react”;
importar {useUser} de”@ auth0/nextjs-auth0″;
importar estilizado de”componentes estilizados”;
importar formulário de”../components/Form/Form”;
importar Navbar de”../components/Navbar/Navbar”;
import Note from”../components/Note/Note”; const App=()=> { const [showForm, setShowForm]=useState (false); const [notas, setNotes]=useState ([]); const [atualizar, setRefresh]=useState (false); const {usuário, isLoading, erro}=useUser (); useEffect (()=> { //Nossas notas do LocalStorage (nosso banco de dados) const store=JSON.parse (localStorage.getItem (“next: note-app”)); setNotes (armazenar); }, [atualizar]); Retorna ( <>
Carregando…
): erro? (
{erro?.mensagem}
): do utilizador ? ( <> {showForm? (
): (
)} {! notas?.comprimento? (
Nenhuma nota disponível, clique no botão acima para adicionar
): (
)} > ): (
Bem-vindo ao meu app de notas next.js, faça login para começar
)}
};
No bloco de código acima, estamos usando o gancho useEffect para obter notas de nosso armazenamento local, que atua como nosso banco de dados, e renderizando-as como nossas notas padrão.
Também adicionamos um título para nosso aplicativo. Usando Auth0, adicionamos recursos de login para que os usuários façam login em seus aplicativos de notas personalizadas. Também criamos um botão para adicionar uma nota. Para renderizar todas as nossas notas, usamos o objeto nativo mapa JavaScript .
Para completar nosso aplicativo, vamos adicionar alguns estilos:
const Wrapper=styled.section` margem: 1rem 0; largura máxima: 100%; overflow-x: oculto; altura: 100%; .form-wrapper { largura máxima: 60%; margem: 1,5 rem auto 0; display: flex; direção flexível: coluna; alinhar-itens: centro; justificar o conteúdo: centro; botão { fronteira: nenhum; esboço: nenhum; plano de fundo: # 5b6d5b; cor: #fff; tamanho da fonte: 1rem; altura: 2,6 rem; largura: 10rem; raio da borda: 5px; transição: opacidade 0,7s; &:flutuar { opacidade: 0,8; } } } .notes-wrapper { largura máxima: 95%; margem: 4rem automático; display: grade; colunas de modelo de grade: repetir (3, 1fr); grade-gap: 2rem; } .nodata-indicator { margem superior: 4rem; alinhamento de texto: centro; } .non-auth-text { margem superior: 4rem; alinhamento de texto: centro; tamanho da fonte: 1,5 rem; }
`;
exportar aplicativo padrão;
Nosso aplicativo deve ser semelhante à imagem abaixo:
Conclusão
Neste artigo, aprendemos como configurar o Auth0 para autenticação em aplicativos Next.js.
Construímos um aplicativo Notes usando Next.js e o SDK Auth0 Next.js. Em seguida, adicionamos a autenticação com recursos como login, logout e verificação de e-mail, prontos para uso com o Auth0.
Auth0 é uma ótima ferramenta se você está procurando uma maneira fácil de adicionar autenticação ao seu projeto. Neste artigo, abordamos apenas a superfície dos diferentes métodos de verificação. Em última análise, a melhor solução para você dependerá das necessidades do seu projeto.
Uma versão funcional do código neste artigo pode ser encontrada em Código S andbox.
A postagem Autentique seu aplicativo Next.js usando Auth0 apareceu primeiro em LogRocket Blog .