Brukerautentisering er prosessen med å bekrefte identiteten til en bruker som prøver å få tilgang til applikasjonen din. Det innebærer godkjenning og overføring av legitimasjon for å bekrefte en brukers autentisitet.
Du kan implementere en enkel brukerautentiseringsmodell i Node.js ved å bruke Express, Bcrypt og MongoDB, med bare noen få trinn.
Trinn 1: Sette opp utviklingsmiljø
Først oppretter du en prosjektmappe og cd inn i den ved å kjøre:
mkdir brukerautentisering
cd bruker autentisering
Deretter initialiser npm i prosjektkatalogen din ved å kjøre:
npm init -y
De -y flagget initialiserer npm og oppretter din package.json fil med alle standardinnstillingene.
Denne brukerautentiseringsmodellen krever noen få avhengigheter.
De inkluderer:
- Uttrykke: Express er et Node.js-rammeverk som gir et robust sett med funksjoner for nett- og mobilapplikasjoner. Det gjør det enklere å bygge backend-applikasjoner med Node.js.
- Bcrypt: bcrypt er en npm-pakke som implementerer bcrypt-passordhashing-funksjonen. Den lar deg lage hashes fra vanlige passordstrenger.
- Mongoose: Mongoose er et MongoDB-objektdatamodelleringsbibliotek. Det forenkler interaksjonene mellom appen din og en MongoDB-database.
- dotenv: dotenv er en nullavhengighetspakke som laster inn miljøvariabler fra en .env fil inn process.env.
- Validator: validator er en pakke som inneholder forskjellige strengvalideringsfunksjoner.
- Body-parser: Body-parser-pakken analyserer forespørselskropper i en mellomvare før behandlerne dine.
Installer pakkene ved å kjøre:
npm installere express bcrypt mongoose dotenv validator kropp-parser
Deretter oppretter du en app.js fil i prosjektets rotkatalog og legg til kodeblokken nedenfor for å lage en grunnleggende Express-server:
// app.js
konst uttrykke = krever('uttrykke');
konst app = express();
konst bodyParser = krever("body-parser");konst port = 3000;
app.bruk(bodyParser.json());
app.bruk(bodyParser.urlencoded({ forlenget: sant }));
app.listen (port, ()=>{
konsoll.Logg(`Appen lytter på port ${port}`);
});
Denne koden oppretter en ekspressapplikasjonsforekomst ved å kalle opp ekspressfunksjonen. Den bruker da body-parser mellomvare for å analysere innkommende forespørselskropper. Deretter begynner den å lytte etter trafikk på port 3000 ved å kalle ekspressforekomstens lyttemetode og sende portvariabelen som et argument.
Trinn 2: Koble applikasjonen din til en database
I prosjektets rotkatalog oppretter du en .env fil og lagre MongoDB-legitimasjonen din i den. Dette unngår å eksponere databaselegitimasjonen din i kode som kan gi ondsinnede brukere tilgang til databasen.
Deretter navigerer du til din app.js fil og importer mongoose:
konst mangust = krever("mangus");
Ring deretter import dotenv og ring konfig metode på det:
krever("dotenv").config();
Ringer til konfig metode på dotenv laster inn miljøvariabler i process.env.
Til slutt kaller du på tilkoblingsmetoden mangust og send MongoDB URI som et argument:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Koblet til databasen')
})
Trinn 3: Opprette brukermodell
I prosjektets rotkatalog oppretter du en "modeller" mappe; her vil du lagre mongoosemodellen din:
mkdir-modeller
Deretter oppretter du en "brukermodell"-filen og legg til følgende importer:
konst mangust = krever('mangus')
konst { isEmail } = krever('validator')
erE-post er en valideringsfunksjon som returnerer ekte hvis en gitt streng er en e-post. Du trenger den for å bruke mongoose-validering på brukermodellen din.
Deretter legger du til følgende kode til din brukermodell fil:
// modeller/brukermodell
konst userSchema = mongoose. Skjema({
e-post: {
type: String,
påkrevd: [true, 'E-post er påkrevd'],
validere: {
validator: isEmail,
melding: rekvisitter => `${props.value} er ikke en gyldig e-post`
}
},passord: {
type: String,
påkrevd: [true, 'Passord er påkrevd'],
validere: {
validator: funksjon (verdi) {
komme tilbake verdi.lengde >= 6
},
melding: () =>'Passordet må være minst seks tegn langt'
}
}
})
modul.eksport = mongoose.model('Bruker', brukerskjema)
Koden ovenfor oppretter en brukerskjema variabel som lagrer verdien av mangust. Skjema metode. Mangusten. Skjemametoden kartlegger egenskaper til en MongoDB-samling og definerer formen på dokumentene i den. Mongoose-skjemaet har to egenskaper - en e-post og a passord– som vil være autentiseringskravene dine.
E-postegenskapen er en strengtype og har nødvendig satt til sann. Den medfølgende feilmeldingen "E-post er påkrevd" vil vises hvis en forespørselstekst ikke inneholder en e-post eiendom. Til slutt, ved å bruke mongoose tilpasset validering, validator eiendom refererer til erE-post funksjon. Denne funksjonen returnerer sant eller usant basert på gyldigheten til strengen som en e-post. Deretter tar meldingsegenskapen e-postverdien (Rekvisitter) og konstruerer en meningsfull feilmelding.
Passordegenskapen er en obligatorisk strengtype med en feilmelding som lyder "Passord kreves". De validator funksjonen er en anonym funksjon som returnerer true hvis passordet er minst seks tegn langt.
Den siste linjen oppretter og eksporterer en mangustmodell ved å kalle modell metode på mangust. Send modellnavnet (Bruker) som det første argumentet og et skjema (brukerskjema) som det andre argumentet.
Trinn 4: Implementering av påloggings- og påmeldingsruter
I prosjektets rotkatalog oppretter du en ruter mappe:
mkdir ruter
Opprett en i rutemappen din userRoutes.js fil og legg til følgende importer:
// routes/userRoutes.js
konst uttrykke = krever("uttrykke");
konst Bruker = krever("../models/userModel");
konst bcrypt = krever("bcrypt");
Opprett en Express Router-forekomst ved å ringe Ruter metode på uttrykke:
konst ruter = ekspress. Ruter();
Deretter oppretter du registreringsruten ved å legge til kodeblokken nedenfor til din userRoute.js fil:
router.post("/sign-up", asynkron (req, res) => {
prøve {
// Trekk ut e-post og passord fra req.body-objektet
konst { e-post, passord } = req.body;// Kryss avhvis eposten er allerede ibruk
la brukereksisterer = avvente User.findOne({ email });if (brukereksisterer) {
res.status(401).json({ melding: "E-post er allerede inne bruk." });
komme tilbake;
}// Definer saltrunder
konst saltRounds = 10;// Hash passord
bcrypt.hash (passord, saltRounds, (feil, hash) => {
hvis (feil) kastenyFeil("Intern server Feil");// Skape en nybruker
la bruker = ny Bruker({
e-post,
passord: hasj,
});
// Lagre bruker til database
user.save().then(() => {
res.json({ melding: "Bruker opprettet", bruker });
});
});
} å fange (feil) {
komme tilbakeres.status(401).sende(feil.beskjed);
}
});
I kodeblokken ovenfor destrukturerte du først e-posten og passordet fra req.body gjenstand. Sjekk deretter om en bruker allerede bruker e-posten fordi den skal være unik for hver bruker. Hvis e-posten allerede er brukt, returnerer du og stopper kjøring av kode med en 401-statuskode.
Lagring av vanlige passord i en database er en stor sikkerhetstrussel ettersom ondsinnede hackere kan få tilgang til databasen. Du bør hash passord før du legger dem i databasen din, så selv om en hacker oppdager dem, bør det ikke være noen risiko for brukerne. Hashing er prosessen med å konvertere en gitt "nøkkel" til en annen verdi. Hashing er en enveisfunksjon, som betyr at du ikke kan hente den opprinnelige verdien fra den hashing, i motsetning til kryptering.
Ved å bruke bcrypt, hashhadde du brukerpassordet ditt ved å kalle hash-metoden på bcrypt. Hash-metoden tar tre parametere: strengen som skal hashes, saltrunder og en tilbakeringingsfunksjon. Du sender brukerpassordet, saltRounds-variabelen du opprettet tidligere, og en tilbakeringing.
Saltrunder refererer til tiden som trengs for å beregne en enkelt bcrypt-hash. Jo høyere saltrunder, desto flere hash-runder.
Hvis hash-metoden gir en feil, kaster du en "intern serverfeil." Ellers setter du passordegenskapen til den vellykkede hashen og lagrer den i databasen din ved å ringe lagringsmetoden på Bruker forekomst.
Deretter oppretter du påloggingsruten ved å legge til kodeblokken nedenfor til din userRoute.js fil:
router.post("/sign-in", asynkron (req, res) => {
prøve {
// Trekk ut e-post og passord fra req.body-objektet
konst { e-post, passord } = req.body;// Kryss avhvisbrukerfinnesidatabase
la bruker = avvente User.findOne({ email });if (!bruker) {
return res.status (401).json({ melding: "Ugyldige legitimasjon" });
}// Sammenlign passord
bcrypt.compare (passord, bruker.passord, (feil, resultat) => {
if (resultat) {
return res.status (200).json({ melding: "Bruker logget på" });
}konsoll.log (feil);
return res.status (401).json({ melding: "Ugyldige legitimasjon" });
});
} å fange (feil) {
res.status(401).sende(feil.beskjed);
}
});
modul.eksport = ruter;
I kodeblokken ovenfor destrukturerer du først e-posten og passordet fra req.body gjenstand. Deretter sjekker du om det finnes en bruker i databasen din. Hvis brukeren ikke finnes i databasen din, returnerer du med en 401-statuskode.
Deretter, bruk bcrypts sammenligningsmetode, send inn passordet brukeren oppga og det hashed-passordet du hentet fra databasen din. Sammenlign de to for å bekrefte om de stemmer overens. Hvis passordene samsvarer, returnerer du en 200-statuskode og en suksessmelding. Ellers returnerer du en 401-statuskode og en feilmelding.
Til slutt, import ruter inn i din app.js fil og bruk den som en mellomvare på programnivå.
Dette fullfører brukerautentiseringsmodellen din; nå kan brukere trygt registrere seg og logge på applikasjonen din.
Viktigheten av brukerautentisering
Brukerautentisering sikrer at bare legitime brukere kan få tilgang til applikasjonen din. Hvis dataene dine på noen måte er personlige eller private, bør du ta skritt for å forhindre at uautentiserte brukere får tilgang.