A autenticação do usuário é o processo de verificação da identidade de um usuário que está tentando obter acesso ao seu aplicativo. Envolve autorizar e transferir credenciais para confirmar a autenticidade de um usuário.
Você pode implementar um modelo de autenticação de usuário simples no Node.js usando Express, Bcrypt e MongoDB em apenas algumas etapas.
Etapa 1: Configurando o ambiente de desenvolvimento
Primeiro, crie uma pasta de projeto e cd nele executando:
autenticação de usuário mkdir
cd autenticação de usuário
Em seguida, inicialize o npm no diretório do seu projeto executando:
npm init -y
o -y flag inicializa o npm e cria seu pacote.json arquivo com todos os seus padrões.
Este modelo de autenticação de usuário requer algumas dependências.
Eles incluem:
- Expressar: Express é uma estrutura Node.js que fornece um conjunto robusto de recursos para aplicativos da Web e móveis. Isso facilita a criação de aplicativos de back-end com o Node.js.
- Bcrypt: bcrypt é um pacote npm que implementa a função de hash de senha bcrypt. Ele permite que você crie hashes a partir de strings de senha simples.
- Mongoose: Mongoose é uma biblioteca de modelagem de dados de objetos MongoDB. Ele simplifica as interações entre seu aplicativo e um banco de dados MongoDB.
- dotenv: dotenv é um pacote de dependência zero que carrega variáveis de ambiente de um .env arquivo em processo.env.
- Validator: validator é um pacote que contém várias funções de validação de strings.
- Body-parser: O pacote body-parser analisa corpos de solicitação em um middleware antes de seus manipuladores.
Instale os pacotes executando:
npm instalar validador expresso bcrypt mangusto dotenv corpo-parser
A seguir, crie um app.js arquivo no diretório raiz do seu projeto e adicione o bloco de código abaixo para criar um servidor Express básico:
// app.js
const expresso = exigir('expressar');
const aplicativo = expresso();
const bodyParser = exigir("corpo-parser");const porta = 3000;
aplicativo.usar(bodyParser.json());
aplicativo.usar(bodyParser.urlencoded({ estendido: verdadeiro }));
app.listen (porta, ()=>{
console.registro(`App está escutando na porta ${porta}`);
});
Esse código cria uma instância de aplicativo expresso chamando a função express. Em seguida, usa o analisador de corpo middleware para analisar os corpos das solicitações recebidas. Em seguida, ele começa a ouvir o tráfego na porta 3000 chamando o método listen da instância expressa e passando a variável port como um argumento.
Etapa 2: conectando seu aplicativo a um banco de dados
No diretório raiz do seu projeto, crie um .env arquivo e armazene suas credenciais do MongoDB nele. Isso evita expor suas credenciais de banco de dados em código que pode dar acesso a usuários mal-intencionados ao seu banco de dados.
Em seguida, navegue até o seu app.js arquivo e importe o mangusto:
const mangusto = exigir("mangusto");
Em seguida, chame a importação dotenv e ligue para o configuração método nele:
exigir ("dotenv").config();
Chamando o configuração método em dotenv carrega variáveis ambientais no processo.env.
Por fim, chame o método connect em mangusto e passe seu URI do MongoDB como um argumento:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Conectado ao banco de dados com sucesso')
})
Etapa 3: criando o modelo de usuário
No diretório raiz do seu projeto, crie um “modelos" pasta; é aqui que você armazenará seu modelo de mangusto:
modelos mkdir
Em seguida, crie um “userModel” e adicione as seguintes importações:
const mangusto = exigir('mangusto')
const { isEmail } = exigir('validador')
isEmail é uma função de validação que retorna verdadeiro se uma determinada string for um email. Você precisará dele para aplicar a validação do mangusto ao seu modelo de usuário.
Em seguida, adicione o seguinte código ao seu userModel Arquivo:
//models/userModel
const userSchema = mangusto. Esquema({
o email: {
modelo: Corda,
obrigatório: [verdadeiro, 'O e-mail é obrigatório'],
validar: {
validador: isEmail,
mensagem: adereços => `${props.value} não é um email válido`
}
},senha: {
modelo: Corda,
obrigatório: [verdadeiro, 'Senha requerida'],
validar: {
validador: função (valor) {
Retorna valor.comprimento >= 6
},
mensagem: () =>'A senha deve ter pelo menos seis caracteres'
}
}
})
módulo.exportações = mongoose.model('Usuário', userSchema)
O código acima cria um userSchema variável que armazena o valor do mangusto. Esquema método. O mangusto. O método Schema mapeia propriedades para uma coleção do MongoDB e define a forma dos documentos dentro dela. O esquema do mangusto tem duas propriedades - uma o email e um senha— que serão seus requisitos de autenticação.
A propriedade email é do tipo string e tem requeridos definido como verdadeiro. A mensagem de erro que a acompanha, "Email is required", será exibida se o corpo da solicitação não contiver um o email propriedade. Finalmente, usando a validação personalizada do mangusto, o validador propriedade refere-se a isEmail função. Essa função retorna true ou false com base na validade da string como um email. Em seguida, a propriedade de mensagem recebe o valor de email (adereços) e constrói uma mensagem de erro significativa.
A propriedade password é um tipo de string obrigatório com uma mensagem de erro que diz “A senha é necessária”. o validador é uma função anônima que retorna true se a senha tiver pelo menos seis caracteres.
A linha final cria e exporta um modelo de mangusto chamando o método modelo método em mangusto. Passe o nome do modelo (Do utilizador) como o primeiro argumento e um esquema (userSchema) como o segundo argumento.
Etapa 4: implementar rotas de login e inscrição
No diretório raiz do seu projeto, crie um rotas pasta:
rotas mkdir
Na sua pasta de rotas, crie um userRoutes.js arquivo e adicione as seguintes importações:
// rotas/userRoutes.js
const expresso = exigir("expressar");
const usuário = exigir("../models/userModel");
const bcript = exigir("bcript");
Crie uma instância do Express Router chamando o Roteador método em expressar:
const roteador = expresso. Roteador();
Em seguida, crie sua rota de inscrição adicionando o bloco de código abaixo ao seu userRoute.js Arquivo:
roteador.post("/sign-up", assíncrono (req, res) => {
tentar {
// Extraia email e senha do objeto req.body
const { e-mail, senha } = req.body;// VerificarE se o e-mail é já dentrousar
deixar userExist = aguardam User.findOne({ e-mail });if (userExists) {
res.status(401).json({ mensagem: "O e-mail já está em usar.&citação; });
Retorna;
}// Definir rodadas de sal
const rodadas de sal = 10;//Senha de hash
bcrypt.hash (senha, saltRounds, (err, hash) => {
E se (errar) lançarnovoErro("Servidor Interno Erro");// Crio uma novodo utilizador
deixar usuário = novo Do utilizador({
o email,
senha: cerquilha,
});
// Salva o usuário no banco de dados
user.save().then(() => {
res.json({ mensagem: "Usuário criado com sucesso", do utilizador });
});
});
} truque (erro) {
Retornares.status(401).mandar(errar.mensagem);
}
});
No bloco de código acima, primeiro você desestruturou o e-mail e a senha do req.corpo objeto. Em seguida, verifique se um usuário já está usando o e-mail, pois ele deve ser exclusivo para cada usuário. Se o e-mail já foi usado, você retorna e interrompe a execução do código com um código de status 401.
Armazenar senhas simples em um banco de dados é uma enorme ameaça à segurança, pois hackers mal-intencionados podem obter acesso ao banco de dados. Você deve fazer o hash das senhas antes de colocá-las no banco de dados, portanto, mesmo que um hacker as descubra, não haverá risco para os usuários. Hashing é o processo de converter uma determinada “chave” em outro valor. O hash é uma função unidirecional, o que significa que você não pode recuperar o valor original do hased, ao contrário da criptografia.
Usando bcrypt, você fez hash sua senha de usuário chamando o método hash em bcrypt. O método hash usa três parâmetros: a string a ser hash, rodadas de sal e uma função de retorno de chamada. Você passa a senha do usuário, a variável saltRounds que você criou anteriormente e um retorno de chamada.
As rodadas de sal referem-se ao tempo necessário para calcular um único hash bcrypt. Quanto mais altas as rodadas de sal, mais rodadas de hash.
Se o método hash lançar um erro, você lançará um “erro interno do servidor”. Caso contrário, você define a propriedade de senha como o hash bem-sucedido e o salva em seu banco de dados chamando o método save no Do utilizador instância.
Em seguida, crie sua rota de login adicionando o bloco de código abaixo ao seu userRoute.js Arquivo:
roteador.post("/sign-in", assíncrono (req, res) => {
tentar {
// Extraia email e senha do objeto req.body
const { e-mail, senha } = req.body;// VerificarE sedo utilizadorexistedentrobase de dados
deixar usuário = aguardam User.findOne({ e-mail });if (!usuário) {
return res.status (401).json({ mensagem: "Credenciais inválidas" });
}// Comparar senhas
bcrypt.compare (senha, usuário.senha, (erro, resultado) => {
se (resultado) {
return res.status (200).json({ mensagem: "Usuário conectado com sucesso" });
}console.log (erro);
return res.status (401).json({ mensagem: "Credenciais inválidas" });
});
} truque (erro) {
res.status(401).mandar(errar.mensagem);
}
});
módulo.exportações = roteador;
No bloco de código acima, primeiro você desestrutura o e-mail e a senha do req.corpo objeto. Em seguida, você verifica se existe um usuário em seu banco de dados. Se o usuário não existir em seu banco de dados, você retornará com um código de status 401.
Em seguida, usando o método de comparação do bcrypt, passe a senha que o usuário forneceu e a senha com hash que você recuperou do seu banco de dados. Compare os dois para confirmar se eles combinam. Se as senhas corresponderem, você retornará um código de status 200 e uma mensagem de sucesso. Caso contrário, você retornará um código de status 401 e uma mensagem de erro.
Por fim, importe roteador dentro de voce app.js e use-o como um middleware de nível de aplicativo.
Isso completa seu modelo de autenticação de usuário; agora, os usuários podem se inscrever e fazer login com segurança em seu aplicativo.
A importância da autenticação do usuário
A autenticação do usuário garante que apenas usuários legítimos possam obter acesso ao seu aplicativo. Se seus dados forem de alguma forma pessoais ou privados, você deve tomar medidas para impedir que usuários não autenticados obtenham acesso.
