Användarautentisering är processen för att verifiera identiteten för en användare som försöker få åtkomst till din applikation. Det innebär att auktorisera och överföra autentiseringsuppgifter för att bekräfta en användares äkthet.
Du kan implementera en enkel användarautentiseringsmodell i Node.js med hjälp av Express, Bcrypt och MongoDB, med bara några få steg.
Steg 1: Konfigurera utvecklingsmiljö
Skapa först en projektmapp och CD in i det genom att köra:
mkdir användarautentisering
CD användarautentisering
Initiera sedan npm i din projektkatalog genom att köra:
npm init -y
De -y flagga initierar npm och skapar din package.json filen med alla dess standardinställningar.
Den här användarautentiseringsmodellen kräver några beroenden.
De inkluderar:
- Uttrycka: Express är ett Node.js-ramverk som ger en robust uppsättning funktioner för webb- och mobilapplikationer. Det gör det enklare att bygga backend-applikationer med Node.js.
- Bcrypt: bcrypt är ett npm-paket som implementerar funktionen bcrypt lösenords-hashning. Det låter dig skapa hash från vanliga lösenordssträngar.
- Mongoose: Mongoose är ett MongoDB-objektdatamodelleringsbibliotek. Det förenklar interaktionerna mellan din app och en MongoDB-databas.
- dotenv: dotenv är ett paket med nollberoende som laddar miljövariabler från en .env fil i process.env.
- Validator: validator är ett paket som innehåller olika strängvalideringsfunktioner.
- Body-parser: Body-parser-paketet analyserar förfrågningskroppar i en mellanprogram före dina hanterare.
Installera paketen genom att köra:
npm Installera express bcrypt mongoose dotenv validator kropp-parser
Skapa sedan en app.js fil i ditt projekts rotkatalog och lägg till kodblocket nedan för att skapa en grundläggande Express-server:
// app.js
konst uttrycka = behöva('uttrycka');
konst app = express();
konst bodyParser = behöva("body-parser");konst port = 3000;
app.använda sig av(bodyParser.json());
app.använda sig av(bodyParser.urlenkodad({ förlängt: Sann }));
app.listen (port, ()=>{
trösta.logga(`Appen lyssnar på hamn ${port}`);
});
Den här koden skapar en expressapplikationsinstans genom att anropa expressfunktionen. Den använder sedan body-parser mellanprogram för att analysera inkommande begäranden. Sedan börjar den lyssna efter trafik på port 3000 genom att anropa expressinstansens lyssningsmetod och skicka portvariabeln som ett argument.
Steg 2: Anslut din applikation till en databas
Skapa en i ditt projekts rotkatalog .env fil och lagra dina MongoDB-uppgifter i den. Detta undviker att exponera dina databasuppgifter i kod som kan ge skadliga användare tillgång till din databas.
Nästa, navigera till din app.js arkivera och importera mongoose:
konst mangust = behöva("mungo");
Ring sedan import dotenv och ring till config metod på det:
behöva("dotenv").config();
Ringer till config metod på dotenv laddar miljövariabler i process.env.
Aktivera slutligen anslutningsmetoden mungo och skicka din MongoDB URI som ett argument:
mongoose.connect (process.env. MONGODB_URI).then(() => {
console.log('Ansluten till databasen framgångsrikt')
})
Steg 3: Skapa användarmodell
I ditt projekts rotkatalog, skapa en "modeller" mapp; det är här du förvarar din mongoosemodell:
mkdir-modeller
Skapa sedan en "användarmodell”-filen och lägg till följande importer:
konst mangust = behöva('mungo')
konst { isEmail } = behöva('validator')
isEmail är en valideringsfunktion som returnerar Sann om en given sträng är ett e-postmeddelande. Du behöver den för att tillämpa mongoose-validering på din användarmodell.
Lägg sedan till följande kod till din användarmodell fil:
// modeller/användarmodell
konst userSchema = mongoose. Schema({
e-post: {
typ: Sträng,
krävs: [sant, 'E-post krävs'],
validera: {
validator: isEmail,
meddelande: rekvisita => `${props.value} är inte en giltig e-post`
}
},Lösenord: {
typ: Sträng,
krävs: [sant, 'lösenord krävs'],
validera: {
validator: fungera (värde) {
lämna tillbaka värde.längd >= 6
},
meddelande: () =>'Lösenordet måste vara minst sex tecken långt'
}
}
})
modul.export = mongoose.model('User', userSchema)
Koden ovan skapar en userSchema variabel som lagrar värdet på mungo. Schema metod. Mangusten. Schemametoden mappar egenskaper till en MongoDB-samling och definierar formen på dokumenten i den. Mongooseschemat har två egenskaper - en e-post och a Lösenord– vilket kommer att vara dina autentiseringskrav.
E-postegenskapen är en strängtyp och har nödvändig satt till sant. Det medföljande felmeddelandet "E-post krävs" kommer att visas om en förfrågan inte innehåller en e-post fast egendom. Slutligen, med hjälp av mongoose anpassad validering, den validator egendom referenes the isEmail fungera. Den funktionen returnerar sant eller falskt baserat på strängens giltighet som ett e-postmeddelande. Då tar meddelandeegenskapen e-postvärdet (rekvisita) och skapar ett meningsfullt felmeddelande.
Lösenordsegenskapen är en obligatorisk strängtyp med ett felmeddelande som lyder "Lösenord krävs". De validator funktion är en anonym funktion som returnerar sant om lösenordet är minst sex tecken långt.
Den sista raden skapar och exporterar en mangustmodell genom att anropa modell metod på mungo. Skicka modellnamnet (Användare) som det första argumentet och ett schema (userSchema) som det andra argumentet.
Steg 4: Implementera inloggnings- och registreringsrutter
Skapa en i ditt projekts rotkatalog rutter mapp:
mkdir rutter
Skapa en rutter i mappen rutter userRoutes.js fil och lägg till följande importer:
// routes/userRoutes.js
konst uttrycka = behöva("uttrycka");
konst Användare = behöva("../models/userModel");
konst bcrypt = behöva("bcrypt");
Skapa en Express Router-instans genom att anropa Router metod på uttrycka:
konst router = express. Router();
Skapa sedan din registreringsrutt genom att lägga till kodblocket nedan till din userRoute.js fil:
router.post("/sign-up", asynkron (req, res) => {
Prova {
// Extrahera e-post och lösenord från objektet req.body
konst { email, password } = req.body;// Kolla uppom eposten är redan ianvända sig av
låta userExists = vänta User.findOne({ email });if (userExists) {
res.status(401).json({ meddelande: "E-post är redan inne använda sig av." });
lämna tillbaka;
}// Definiera saltrundor
konst saltRounds = 10;// Hash lösenord
bcrypt.hash (lösenord, saltRounds, (fel, hash) => {
om (fela) kastanyFel("Intern server Fel");// Skapa a nyanvändare
låta användare = ny Användare({
e-post,
Lösenord: hash,
});
// Spara användare till databasen
user.save().then(() => {
res.json({ meddelande: "Användaren skapades", användare });
});
});
} fånga (fel) {
lämna tillbakares.status(401).skicka(fela.meddelande);
}
});
I kodblocket ovan avstrukturerade du först e-postadressen och lösenordet från req.body objekt. Kontrollera sedan om en användare redan använder e-postmeddelandet eftersom det ska vara unikt för varje användare. Om e-postmeddelandet redan har använts returnerar du och stoppar kodexekveringen med en 401-statuskod.
Att lagra vanliga lösenord i en databas är ett enormt säkerhetshot eftersom illvilliga hackare kan få tillgång till databasen. Du bör hasha lösenord innan du lägger dem i din databas, så även om en hackare upptäcker dem bör det inte finnas någon risk för användarna. Hashing är processen att omvandla en given "nyckel" till ett annat värde. Hashing är en enkelriktad funktion, vilket innebär att du inte kan hämta det ursprungliga värdet från det hasade, till skillnad från kryptering.
Med bcrypt hashade du ditt användarlösenord genom att anropa hashmetoden på bcrypt. Hashmetoden tar tre parametrar: strängen som ska hashas, saltrundor och en återuppringningsfunktion. Du skickar användarlösenordet, saltRounds-variabeln du skapade tidigare och en återuppringning.
Saltrundor hänvisar till den tid som behövs för att beräkna en enda bcrypt-hash. Ju högre saltrundor, desto fler hashingrundor.
Om hashmetoden ger ett fel, skickar du ett "internt serverfel." Annars ställer du in lösenordsegenskapen till den framgångsrika hashen och sparar den i din databas genom att anropa sparmetoden på Användare exempel.
Skapa sedan din inloggningsrutt genom att lägga till kodblocket nedan till din userRoute.js fil:
router.post("/sign-in", asynkron (req, res) => {
Prova {
// Extrahera e-post och lösenord från objektet req.body
konst { email, password } = req.body;// Kolla uppomanvändareexisteraridatabas
låta användare = vänta User.findOne({ email });if (!användare) {
return res.status (401).json({ meddelande: "Ogiltiga uppgifter" });
}// Jämför lösenord
bcrypt.compare (lösenord, användare.lösenord, (fel, resultat) => {
if (resultat) {
return res.status (200).json({ meddelande: "Användaren har loggat in" });
}trösta.log (fel);
return res.status (401).json({ meddelande: "Ogiltiga uppgifter" });
});
} fånga (fel) {
res.status(401).skicka(fela.meddelande);
}
});
modul.export = router;
I kodblocket ovan destrukturerar du först e-postadressen och lösenordet från req.body objekt. Sedan kontrollerar du om det finns en användare i din databas. Om användaren inte finns i din databas återkommer du med en 401-statuskod.
Använd sedan bcrypts jämförelsemetod och skicka in lösenordet som användaren angav och det hashade lösenordet du hämtade från din databas. Jämför de två för att bekräfta om de matchar. Om lösenorden matchar returnerar du en 200-statuskod och ett framgångsmeddelande. Annars returnerar du en 401-statuskod och ett felmeddelande.
Till sist, importera router in i din app.js fil och använd den som ett mellanprogram på programnivå.
Detta slutför din användarverifieringsmodell; nu kan användare säkert registrera sig och logga in på din applikation.
Vikten av användarautentisering
Användarautentisering säkerställer att endast legitima användare kan få åtkomst till din applikation. Om dina uppgifter på något sätt är personliga eller privata bör du vidta åtgärder för att förhindra oautentiserade användare från att få åtkomst.