Brugergodkendelse er processen med at bekræfte identiteten af en bruger, der forsøger at få adgang til din applikation. Det involverer godkendelse og overførsel af legitimationsoplysninger for at bekræfte en brugers ægthed.
Du kan implementere en simpel brugergodkendelsesmodel i Node.js ved hjælp af Express, Bcrypt og MongoDB i blot et par trin.
Trin 1: Opsætning af udviklingsmiljø
Først skal du oprette en projektmappe og cd ind i det ved at køre:
mkdir brugergodkendelse
cd brugergodkendelse
Start derefter npm i din projektmappe ved at køre:
npm init -y
Det -y flag initialiserer npm og opretter din package.json fil med alle dens standardindstillinger.
Denne brugergodkendelsesmodel kræver nogle få afhængigheder.
De omfatter:
- Express: Express er en Node.js-ramme der giver et robust sæt funktioner til web- og mobilapplikationer. Det gør det nemmere at bygge backend-applikationer med Node.js.
- Bcrypt: bcrypt er en npm-pakke, der implementerer bcrypt password hashing-funktionen. Det giver dig mulighed for at oprette hashes fra almindelige adgangskodestrenge.
- Mongoose: Mongoose er et MongoDB-objektdatamodelleringsbibliotek. Det forenkler interaktionerne mellem din app og en MongoDB-database.
- dotenv: dotenv er en nulafhængighedspakke, der indlæser miljøvariabler fra en .env fil ind proces.env.
- Validator: validator er en pakke, der indeholder forskellige strengvalideringsfunktioner.
- Body-parser: Body-parser-pakken analyserer anmodningstekster i en middleware før dine behandlere.
Installer pakkerne ved at køre:
npm installere express bcrypt mongoose dotenv validator legeme-parser
Opret derefter en app.js fil i dit projekts rodmappe, og tilføj kodeblokken nedenfor for at oprette en grundlæggende Express-server:
// app.js
konst udtrykke = kræve('udtryk');
konst app = express();
konst bodyParser = kræve("body-parser");konst port = 3000;
app.brug(bodyParser.json());
app.brug(bodyParser.urlencoded({ udvidet: rigtigt }));
app.listen (port, ()=>{
konsol.log(`App lytter på port ${port}`);
});
Denne kode opretter en ekspresapplikationsforekomst ved at kalde ekspresfunktionen. Den bruger så krop-parser middleware til at analysere indgående anmodningskroppe. Derefter begynder den at lytte efter trafik på port 3000 ved at kalde ekspresforekomstens lyttemetode og sende portvariablen som et argument.
Trin 2: Tilslutning af din applikation til en database
I dit projekts rodmappe skal du oprette en .env fil og gem dine MongoDB-legitimationsoplysninger i den. Dette undgår at afsløre dine databaselegitimationsoplysninger i kode, som kan give ondsindede brugere adgang til din database.
Derefter skal du navigere til din app.js fil og importer mongoose:
konst mangust = kræve("mangust");
Ring derefter til import dotenv og ring til config metode på det:
kræve("dotenv").config();
Ringer til config metode på dotenv indlæser miljøvariabler i proces.env.
Til sidst skal du aktivere forbindelsesmetoden mangust og send din MongoDB URI som et argument:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Forbundet til databasen lykkedes')
})
Trin 3: Oprettelse af brugermodel
I dit projekts rodmappe skal du oprette en "modeller" mappe; det er her du gemmer din mongoose model:
mkdir modeller
Opret derefter en "brugermodel" fil og tilføj følgende importer:
konst mangust = kræve('mangus')
konst { isEmail } = kræve('validator')
erE-mail er en valideringsfunktion, der returnerer rigtigt hvis en given streng er en e-mail. Du skal bruge den for at anvende mongoose-validering på din brugermodel.
Tilføj derefter følgende kode til din brugermodel fil:
// modeller/brugermodel
konst userSchema = mangust. Skema({
e-mail: {
type: Snor,
påkrævet: [sandt, 'E-mail er påkrævet'],
valider: {
validator: isEmail,
besked: rekvisitter => `${props.value} er ikke en gyldig e-mail`
}
},adgangskode: {
type: Snor,
påkrævet: [sandt, 'adgangskode er påkrævet'],
valider: {
validator: fungere (værdi) {
Vend tilbage værdi.længde >= 6
},
besked: () =>'Adgangskoden skal være mindst seks tegn lang'
}
}
})
modul.eksport = mongoose.model('Bruger', brugerskema)
Koden ovenfor opretter en brugerSchema variabel, der gemmer værdien af mangust. Skema metode. Mangusten. Skemametoden kortlægger egenskaber til en MongoDB-samling og definerer formen på dokumenterne i den. Mongoose-skemaet har to egenskaber - en e-mail og en adgangskode- hvilket vil være dine autentificeringskrav.
E-mail-egenskaben er en strengtype og har påkrævet sat til sand. Den medfølgende fejlmeddelelse, "E-mail er påkrævet," vises, hvis en anmodningstekst ikke indeholder en e-mail ejendom. Endelig, ved hjælp af mongoose tilpasset validering validator ejendom referenes den erE-mail fungere. Denne funktion returnerer sand eller falsk baseret på gyldigheden af strengen som en e-mail. Derefter tager meddelelsesegenskaben e-mail-værdien (rekvisitter) og konstruerer en meningsfuld fejlmeddelelse.
Adgangskodeegenskaben er en påkrævet strengtype med en fejlmeddelelse, der lyder "Adgangskode er påkrævet". Det validator funktion er en anonym, der returnerer sand, hvis adgangskoden er mindst seks tegn lang.
Den sidste linje opretter og eksporterer en mangustmodel ved at kalde model metode på mangust. Send modelnavnet (Bruger) som det første argument og et skema (brugerSchema) som det andet argument.
Trin 4: Implementering af tilmeldings- og tilmeldingsruter
I dit projekts rodmappe skal du oprette en ruter folder:
mkdir ruter
I din rutemappe skal du oprette en userRoutes.js fil og tilføj følgende importer:
// routes/userRoutes.js
konst udtrykke = kræve("udtryk");
konst Bruger = kræve("../models/userModel");
konst bcrypt = kræve("bcrypt");
Opret en Express Router-instans ved at kalde Router metode på udtrykke:
konst router = ekspres. Router();
Opret derefter din tilmeldingsrute ved at tilføje kodeblokken nedenfor til din userRoute.js fil:
router.post("/sign-up", asynkron (req, res) => {
prøve {
// Uddrag e-mail og adgangskode fra objektet req.body
konst { email, password } = req.body;// Kontrollerehvis e-mailen er allerede ibrug
lade brugereksisterer = vente User.findOne({ email });if (brugereksisterer) {
res.status(401).json({ besked: "E-mail er allerede i brug." });
Vend tilbage;
}// Definer salt runder
konst saltRunder = 10;// Hash adgangskode
bcrypt.hash (adgangskode, saltRounds, (fejl, hash) => {
hvis (fejl) kastenyFejl("Intern server Fejl");// skab -en nybruger
lade bruger = ny Bruger({
e-mail,
adgangskode: hash,
});
// Gem bruger i databasen
user.save().then(() => {
res.json({ besked: "Bruger oprettet", bruger });
});
});
} fangst (fejl) {
Vend tilbageres.status(401).sende(fejl.besked);
}
});
I kodeblokken ovenfor destrukturerede du først e-mailen og adgangskoden fra req.body objekt. Kontroller derefter, om en bruger allerede bruger e-mailen, fordi den skal være unik for hver bruger. Hvis e-mailen allerede er brugt, returnerer og stopper du kodeudførelse med en 401-statuskode.
Lagring af almindelige adgangskoder i en database er en enorm sikkerhedstrussel, da ondsindede hackere kan få adgang til databasen. Du bør hash-kodeord, før du sætter dem i din database, så selvom en hacker opdager dem, burde der ikke være nogen risiko for brugerne. Hashing er processen med at konvertere en given "nøgle" til en anden værdi. Hashing er en envejsfunktion, hvilket betyder, at du ikke kan hente den oprindelige værdi fra den hashed, i modsætning til kryptering.
Ved at bruge bcrypt, hasherede du din brugeradgangskode ved at kalde hash-metoden på bcrypt. Hash-metoden tager tre parametre: strengen, der skal hash, saltrunder og en tilbagekaldsfunktion. Du sender brugeradgangskoden, saltRounds-variablen, du oprettede tidligere, og et tilbagekald.
Saltrunder refererer til den tid, der er nødvendig for at beregne en enkelt bcrypt-hash. Jo højere salt-runder, jo flere hashing-runder.
Hvis hash-metoden kaster en fejl, kaster du en "intern serverfejl." Ellers indstiller du adgangskodeegenskaben til den vellykkede hash og gemmer den i din database ved at kalde gem-metoden på Bruger eksempel.
Opret derefter din login-rute ved at tilføje kodeblokken nedenfor til din userRoute.js fil:
router.post("/sign-in", asynkron (req, res) => {
prøve {
// Uddrag e-mail og adgangskode fra objektet req.body
konst { email, password } = req.body;// Kontrollerehvisbrugereksistereridatabase
lade bruger = vente User.findOne({ email });if (!bruger) {
returner res.status (401).json({ besked: "Ugyldige legitimationsoplysninger" });
}// Sammenlign adgangskoder
bcrypt.compare (adgangskode, bruger.adgangskode, (fejl, resultat) => {
if (resultat) {
returner res.status (200).json({ besked: "Bruger logget ind" });
}konsol.log (fejl);
returner res.status (401).json({ besked: "Ugyldige legitimationsoplysninger" });
});
} fangst (fejl) {
res.status(401).sende(fejl.besked);
}
});
modul.eksport = router;
I kodeblokken ovenfor destrukturerer du først e-mailen og adgangskoden fra req.body objekt. Derefter tjekker du, om der findes en bruger i din database. Hvis brugeren ikke findes i din database, vender du tilbage med en 401-statuskode.
Brug derefter bcrypts sammenligningsmetode til at indtaste den adgangskode, som brugeren har angivet, og den hash-kodede adgangskode, du hentede fra din database. Sammenlign de to for at bekræfte, om de matcher. Hvis adgangskoderne matcher, returnerer du en 200-statuskode og en succesmeddelelse. Ellers returnerer du en 401-statuskode og en fejlmeddelelse.
Til sidst importerer router ind i din app.js fil og brug den som middleware på applikationsniveau.
Dette fuldender din brugergodkendelsesmodel; nu kan brugere sikkert tilmelde sig og logge ind på din applikation.
Vigtigheden af brugergodkendelse
Brugergodkendelse sikrer, at kun legitime brugere kan få adgang til din applikation. Hvis dine data på nogen måde er personlige eller private, bør du tage skridt til at forhindre uautoriserede brugere i at få adgang.
