L'autenticazione dell'utente è il processo di verifica dell'identità di un utente che tenta di accedere all'applicazione. Implica l'autorizzazione e il trasferimento delle credenziali per confermare l'autenticità di un utente.
Puoi implementare un semplice modello di autenticazione utente in Node.js utilizzando Express, Bcrypt e MongoDB, in pochi passaggi.
Passaggio 1: impostazione dell'ambiente di sviluppo
Innanzitutto, crea una cartella di progetto e CD in esso eseguendo:
mkdir autenticazione utente
CD autenticazione utente
Quindi, inizializza npm nella directory del tuo progetto eseguendo:
npm init -y
Il -y flag inizializza npm e crea il tuo pacchetto.json file con tutte le sue impostazioni predefinite.
Questo modello di autenticazione utente richiede alcune dipendenze.
Loro includono:
- Esprimere: Express è un framework Node.js che fornisce un solido set di funzionalità per applicazioni Web e mobili. Semplifica la creazione di applicazioni back-end con Node.js.
- Bcrypt: bcrypt è un pacchetto npm che implementa la funzione di hashing della password bcrypt. Ti consente di creare hash da semplici stringhe di password.
- Mongoose: Mongoose è una libreria di modellazione di dati a oggetti MongoDB. Semplifica le interazioni tra la tua app e un database MongoDB.
- dotenv: dotenv è un pacchetto a dipendenza zero che carica le variabili di ambiente da a .env archiviare in processo.env.
- Validatore: validatore è un pacchetto che contiene varie funzioni di convalida delle stringhe.
- Body-parser: il pacchetto body-parser analizza i corpi delle richieste in un middleware prima dei gestori.
Installa i pacchetti eseguendo:
npm installare express bcrypt mongoose dotenv validatore corpo-analizzatore
Quindi, crea un app.js file nella directory principale del tuo progetto e aggiungi il blocco di codice di seguito per creare un server Express di base:
// app.js
cost espresso = richiedere('esprimere');
cost app = espresso();
cost analizzatore del corpo = richiedere("analizzatore del corpo");cost porto = 3000;
app.uso(bodyParser.json());
app.uso(bodyParser.urlencoded({ esteso: VERO }));
app.ascolta (porta, ()=>{
consolle.tronco d'albero(`L'app è in ascolto sulla porta ${porta}`);
});
Questo codice crea un'istanza dell'applicazione express chiamando la funzione express. Quindi utilizza il analizzatore di corpi middleware per analizzare i corpi delle richieste in entrata. Quindi inizia ad ascoltare il traffico sulla porta 3000 chiamando il metodo listen dell'istanza express e passando la variabile port come argomento.
Passaggio 2: collegare l'applicazione a un database
Nella directory principale del tuo progetto, crea a .env file e archivia le tue credenziali MongoDB al suo interno. Ciò evita di esporre le credenziali del database nel codice che può consentire a utenti malintenzionati di accedere al database.
Quindi, vai al tuo app.js file e importa la mangusta:
cost mangusta = richiedere("mangusta");
Quindi, chiama import dotenv e chiama il config metodo su di esso:
richiedere("dotenv".config();
Chiamando il config metodo attivo dotenv carica le variabili ambientali nel processo.env.
Infine, chiama il metodo di connessione su mangusta e passa il tuo URI MongoDB come argomento:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Connesso al database con successo')
})
Passaggio 3: creazione del modello utente
Nella directory principale del tuo progetto, crea un "Modelli" cartella; qui è dove conserverai il tuo modello di mangusta:
modelli mkdir
Quindi, crea un "userModel” e aggiungi le seguenti importazioni:
cost mangusta = richiedere('mangusta')
cost { isEmail } = richiedere("validatore")
èE-mail è una funzione di convalida che restituisce VERO se una determinata stringa è un'e-mail. Ti servirà per applicare la convalida della mangusta al tuo modello utente.
Quindi, aggiungi il seguente codice al tuo userModel file:
// modelli/utenteModel
cost userSchema = mangusta. Schema({
e-mail: {
genere: Corda,
richiesto: [vero, 'L'e-mail è richiesta'],
convalida: {
validatore: isEmail,
messaggio: oggetti di scena => `${props.value} non è un'e-mail valida`
}
},parola d'ordine: {
genere: Corda,
richiesto: [vero, 'E 'richiesta la password'],
convalida: {
validatore: funzione (valore) {
Restituzione valore.lunghezza >= 6
},
messaggio: () =>'La password deve contenere almeno sei caratteri'
}
}
})
modulo.esportazioni = mongoose.model('User', userSchema)
Il codice sopra crea un schema utente variabile che memorizza il valore di mangusta. Schema metodo. La mangusta. Il metodo Schema associa le proprietà a una raccolta MongoDB e definisce la forma dei documenti al suo interno. Lo schema mangusta ha due proprietà: an e-mail e un parola d'ordine—quali saranno i tuoi requisiti di autenticazione.
La proprietà email è di tipo stringa e ha necessario impostato su vero. Se il corpo della richiesta non contiene un messaggio di errore, viene visualizzato il messaggio di errore "E-mail richiesta". e-mail proprietà. Infine, utilizzando la convalida personalizzata di mongoose, il validatore proprietà fa riferimento il èE-mail funzione. Quella funzione restituisce true o false in base alla validità della stringa come e-mail. Quindi la proprietà del messaggio prende il valore dell'e-mail (oggetti di scena) e costruisce un messaggio di errore significativo.
La proprietà della password è un tipo di stringa obbligatorio con un messaggio di errore che dice "La password è richiesta". Il validatore è una funzione anonima che restituisce true se la password è lunga almeno sei caratteri.
La riga finale crea ed esporta un modello di mangusta chiamando il file modello metodo attivo mangusta. Passa il nome del modello (Utente) come primo argomento e uno schema (schema utente) come secondo argomento.
Passaggio 4: implementazione dei percorsi di accesso e registrazione
Nella directory principale del tuo progetto, crea a itinerari cartella:
percorsi mkdir
Nella cartella dei percorsi, crea un userRoutes.js file e aggiungi le seguenti importazioni:
// percorsi/userRoutes.js
cost espresso = richiedere("esprimere");
cost Utente = richiedere("../models/userModel");
cost bcrypt = richiedere("bcrypt");
Crea un'istanza Express Router chiamando il Router metodo attivo esprimere:
cost router = espresso. Router();
Quindi, crea il tuo percorso di iscrizione aggiungendo il blocco di codice qui sotto al tuo userRoute.js file:
router.post("/sign-up", asincrono (richiesto, res) => {
Tentativo {
// Estrai email e password dall'oggetto req.body
cost { email, password } = req.body;// Dai un'occhiataSe l'email è già inuso
permettere utente esiste = aspettare User.findOne({ email });se (utente esiste) {
stato res(401.json({ messaggio: "L'email è già in uso." });
Restituzione;
}// Definisci i round di sale
cost saltRounds = 10;// Password hash
bcrypt.hash (password, saltRounds, (err, hash) => {
Se (errare) gettarenuovoErrore("Server interno Errore");// Creare un nuovoutente
permettere utente = nuovo Utente({
e-mail,
parola d'ordine: hash,
});
// Salva l'utente nel database
user.save().then(() => {
res.json({ messaggio: "Utente creato correttamente", utente });
});
});
} presa (erro) {
Restituzioneris.stato(401).inviare(err.Messaggio);
}
});
Nel blocco di codice sopra, in primo luogo, hai destrutturato l'e-mail e la password dal corpo richiesto oggetto. Quindi, controlla se un utente sta già utilizzando l'e-mail perché dovrebbe essere univoca per ogni utente. Se l'e-mail è già stata utilizzata, restituisci e interrompi l'esecuzione del codice con un codice di stato 401.
La memorizzazione di password semplici in un database è un'enorme minaccia alla sicurezza poiché hacker malintenzionati potrebbero accedere al database. Dovresti eseguire l'hashing delle password prima di inserirle nel database, quindi anche se un hacker le scopre, non dovrebbero esserci rischi per gli utenti. L'hashing è il processo di conversione di una determinata "chiave" in un altro valore. L'hashing è una funzione unidirezionale, il che significa che non è possibile recuperare il valore originale da quello hased, a differenza della crittografia.
Usando bcrypt, hai eseguito l'hashing la tua password utente chiamando il metodo hash su bcrypt. Il metodo hash accetta tre parametri: la stringa da sottoporre a hash, salt round e una funzione di callback. Passi la password utente, la variabile saltRounds creata in precedenza e una richiamata.
I salt round si riferiscono al tempo necessario per calcolare un singolo hash bcrypt. Più alti sono i round di sale, maggiori sono i round di hashing.
Se il metodo hash genera un errore, viene generato un "errore interno del server". Altrimenti, imposti la proprietà della password sull'hash riuscito e lo salvi nel tuo database chiamando il metodo save su Utente esempio.
Quindi, crea il tuo percorso di accesso aggiungendo il blocco di codice qui sotto al tuo userRoute.js file:
router.post("/sign-in", asincrono (richiesto, res) => {
Tentativo {
// Estrai email e password dall'oggetto req.body
cost { email, password } = req.body;// Dai un'occhiataSeutenteesisteinBanca dati
permettere utente = aspettare User.findOne({ email });se (! utente) {
restituisce res.status (401).json({ messaggio: "Credenziali non valide" });
}// Confronta le password
bcrypt.compare (password, user.password, (err, risultato) => {
se (risultato) {
restituisce res.status (200).json({ messaggio: "Utente connesso con successo" });
}consolle.log (err);
restituisce res.status (401).json({ messaggio: "Credenziali non valide" });
});
} presa (errore) {
ris.stato(401).inviare(err.Messaggio);
}
});
modulo.esportazioni = router;
Nel blocco di codice sopra, per prima cosa, destruttura l'e-mail e la password dal corpo richiesto oggetto. Quindi, controlli se esiste un utente nel tuo database. Se l'utente non esiste nel tuo database, restituisci con un codice di stato 401.
Successivamente, utilizzando il metodo di confronto di bcrypt, passa la password fornita dall'utente e la password con hash che hai recuperato dal tuo database. Confronta i due per confermare se corrispondono. Se le password corrispondono, restituisci un codice di stato 200 e un messaggio di successo. Altrimenti restituisci un codice di stato 401 e un messaggio di errore.
Infine, importa router nel tuo app.js file e usarlo come middleware a livello di applicazione.
Questo completa il tuo modello di autenticazione utente; ora, gli utenti possono registrarsi in modo sicuro e accedere alla tua applicazione.
L'importanza dell'autenticazione dell'utente
L'autenticazione dell'utente garantisce che solo gli utenti legittimi possano accedere all'applicazione. Se i tuoi dati sono in qualche modo personali o privati, dovresti adottare misure per impedire l'accesso agli utenti non autenticati.
