Uwierzytelnianie użytkownika to proces weryfikacji tożsamości użytkownika próbującego uzyskać dostęp do Twojej aplikacji. Obejmuje autoryzację i przesyłanie poświadczeń w celu potwierdzenia autentyczności użytkownika.
Możesz zaimplementować prosty model uwierzytelniania użytkowników w Node.js przy użyciu Express, Bcrypt i MongoDB w zaledwie kilku krokach.
Krok 1: Konfiguracja środowiska programistycznego
Najpierw utwórz folder projektu i płyta CD do niego, uruchamiając:
Uwierzytelnianie użytkownika mkdir
płyta CD uwierzytelnianie użytkownika
Następnie zainicjuj npm w katalogu projektu, uruchamiając:
npm początek -y
The -y flaga inicjuje npm i tworzy twój pakiet.json plik ze wszystkimi jego wartościami domyślnymi.
Ten model uwierzytelniania użytkownika wymaga kilku zależności.
Zawierają:
- Wyrazić: Express to framework Node.js który zapewnia solidny zestaw funkcji dla aplikacji internetowych i mobilnych. Ułatwia budowanie aplikacji backendowych za pomocą Node.js.
- Bcrypt: bcrypt to pakiet npm, który implementuje funkcję haszowania hasła bcrypt. Umożliwia tworzenie skrótów ze zwykłych ciągów haseł.
- Mongoose: Mongoose to biblioteka modelowania danych obiektowych MongoDB. Upraszcza interakcje między Twoją aplikacją a bazą danych MongoDB.
- dotenv: dotenv to pakiet o zerowej zależności, który ładuje zmienne środowiskowe z .env zapisz do proces.env.
- Validator: walidator to pakiet, który zawiera różne funkcje walidacji napisów.
- Body-parser: pakiet body-parser analizuje treść żądań w oprogramowaniu pośredniczącym przed programami obsługi.
Zainstaluj pakiety, uruchamiając:
npm zainstalować express bcrypt mangusta dotenv walidator ciało-parser
Następnie utwórz app.js w katalogu głównym projektu i dodaj poniższy blok kodu, aby utworzyć podstawowy serwer Express:
// app.js
stały ekspres = wymagać('wyrazić');
stały aplikacja = ekspres();
stały bodyParser = wymagać("parser ciała");stały port = 3000;
aplikacja.posługiwać się(bodyParser.json());
aplikacja.posługiwać się(bodyParser.urlencoded({ rozszerzony: PRAWDA }));
app.listen (port, ()=>{
konsola.dziennik(`Aplikacja nasłuchuje na porcie ${port}`);
});
Ten kod tworzy wystąpienie aplikacji ekspresowej, wywołując funkcję ekspresową. Następnie używa parser ciała oprogramowanie pośredniczące do analizowania treści żądań przychodzących. Następnie rozpoczyna nasłuchiwanie ruchu na porcie 3000, wywołując metodę nasłuchiwania instancji ekspresowej i przekazując zmienną portu jako argument.
Krok 2: Łączenie aplikacji z bazą danych
W katalogu głównym projektu utwórz a .env pliku i przechowuj w nim swoje dane logowania MongoDB. Pozwala to uniknąć ujawnienia poświadczeń bazy danych w kodzie, co może dać złośliwym użytkownikom dostęp do bazy danych.
Następnie przejdź do swojego app.js pliku i importu mangusty:
stały mangusta = wymagać("mangusta");
Następnie zadzwoń do importu dotenv i zadzwoń do konfiguracja metoda na nim:
wymagać("dotenv").config();
Dzwonię do konfiguracja metoda włączona dotenv ładuje zmienne środowiskowe do proces.env.
Na koniec wywołaj metodę connect on mangusta i przekaż swój URI MongoDB jako argument:
mongoose.connect (process.env. MONGODB_URI).następnie(() => {
konsola.log('Pomyślnie połączono z bazą danych')
})
Krok 3: Tworzenie modelu użytkownika
W katalogu głównym projektu utwórz „modele" teczka; tutaj przechowasz swój model mangusty:
modele mkdir
Następnie utwórz „userModel” i dodaj następujące importy:
stały mangusta = wymagać('mangusta')
stały { isEmail } = wymagać(„walidator”)
isEmail to funkcja walidacji, która zwraca PRAWDA jeśli dany ciąg jest e-mailem. Będziesz go potrzebować, aby zastosować walidację mangusty do swojego modelu użytkownika.
Następnie dodaj następujący kod do swojego userModel plik:
// modele/userModel
stały userSchema = mangusta. Schemat({
e-mail: {
rodzaj: Strunowy,
wymagane: [prawda, 'email jest wymagany'],
zatwierdź: {
walidator: isEmail,
wiadomość: rekwizyty => `${props.value} nie jest prawidłowym adresem e-mail`
}
},hasło: {
rodzaj: Strunowy,
wymagane: [prawda, 'Wymagane jest hasło'],
zatwierdź: {
walidator: funkcjonować (wartość) {
zwrócić wartość.długość >= 6
},
wiadomość: () =>'Hasło musi mieć co najmniej sześć znaków'
}
}
})
moduł.eksport = mongoose.model('Użytkownik', userSchema)
Powyższy kod tworzy schemat użytkownika zmienna przechowująca wartość mangusta. Schemat metoda. Mangusta. Metoda schematu mapuje właściwości do kolekcji MongoDB i definiuje kształt zawartych w niej dokumentów. Schemat mangusty ma dwie właściwości — an e-mail i hasło— które będą Twoimi wymaganiami dotyczącymi uwierzytelniania.
Właściwość e-mail jest typu string i ma wymagany ustawione na prawda. Towarzyszący komunikat o błędzie „Wymagany jest e-mail” zostanie wyświetlony, jeśli treść żądania nie zawiera e-mail własność. Wreszcie, przy użyciu niestandardowej walidacji mangusty, walidator referencje własności isEmail funkcjonować. Ta funkcja zwraca prawdę lub fałsz na podstawie ważności ciągu jako wiadomości e-mail. Następnie właściwość message przyjmuje wartość e-mail (rekwizyty) i konstruuje zrozumiały komunikat o błędzie.
Właściwość hasła jest wymaganym typem ciągu z komunikatem o błędzie o treści „Wymagane jest hasło”. The walidator funkcja jest anonimowa, która zwraca prawdę, jeśli hasło ma co najmniej sześć znaków.
Ostatnia linia tworzy i eksportuje model mangusty, wywołując Model metoda włączona mangusta. Podaj nazwę modelu (Użytkownik) jako pierwszy argument i schemat (schemat użytkownika) jako drugi argument.
Krok 4: Wdrażanie tras logowania i rejestracji
W katalogu głównym projektu utwórz a trasy teczka:
trasy mkdir
W folderze tras utwórz userRoutes.js plik i dodaj następujące importy:
// trasy/userRoutes.js
stały ekspres = wymagać("wyrazić");
stały Użytkownik = wymagać(../modele/model_użytkownika");
stały bcrypt = wymagać("bkrypt");
Utwórz instancję Express Router, wywołując Router metoda włączona wyrazić:
stały router = ekspres. Router();
Następnie utwórz trasę rejestracji, dodając poniższy blok kodu do swojego userRoute.js plik:
router.post("/sign-up", asynchroniczny (wymagany, odp.) => {
próbować {
// Wyodrębnij e-mail i hasło z obiektu req.body
stały { e-mail, hasło } = zam.body;// Sprawdzaćjeśli e-mail jest już wposługiwać się
wynajmować użytkownikIstnieje = czekać na User.findOne({ e-mail });jeśli (użytkownik istnieje) {
stan.odn.(401).json({ message: "E-mail jest już w posługiwać się.&cytuję; });
zwrócić;
}// Zdefiniuj rundy soli
stały sólRounds = 10;// Hasło skrótu
bcrypt.hash (hasło, saltRounds, (błąd, hash) => {
jeśli (błądzić) rzucićNowyBłąd(„Serwer wewnętrzny Błąd");// Tworzyć a Nowyużytkownik
wynajmować użytkownik = Nowy Użytkownik({
e-mail,
hasło: haszysz,
});
// Zapisz użytkownika w bazie danych
user.save().then(() => {
res.json ({ wiadomość: "Pomyślnie utworzono użytkownika", użytkownik });
});
});
} złapać (błąd) {
zwrócićres.status(401).wysłać(błądzić.wiadomość);
}
});
W powyższym bloku kodu najpierw zdestrukturyzowałeś e-mail i hasło z wymagane ciało obiekt. Następnie sprawdź, czy użytkownik już korzysta z adresu e-mail, ponieważ powinien on być unikalny dla każdego użytkownika. Jeśli wiadomość e-mail była już używana, zwracasz i zatrzymujesz wykonywanie kodu z kodem stanu 401.
Przechowywanie zwykłych haseł w bazie danych stanowi ogromne zagrożenie bezpieczeństwa, ponieważ złośliwi hakerzy mogą uzyskać dostęp do bazy danych. Hasła należy haszować przed zapisaniem ich w bazie danych, więc nawet jeśli haker je odkryje, nie powinno być zagrożenia dla użytkowników. Haszowanie to proces konwersji danego „klucza” na inną wartość. Haszowanie jest funkcją jednokierunkową, co oznacza, że w przeciwieństwie do szyfrowania, nie można pobrać oryginalnej wartości z zaszyfrowanej.
Używając bcrypt, haszujesz swoje hasło użytkownika, wywołując metodę skrótu na bcrypt. Metoda haszująca przyjmuje trzy parametry: ciąg do zaszyfrowania, rundy soli i funkcję zwrotną. Przekazujesz hasło użytkownika, utworzoną wcześniej zmienną saltRounds i wywołanie zwrotne.
Solne rundy odnoszą się do czasu potrzebnego do obliczenia pojedynczego skrótu bcrypt. Im wyższe rundy soli, tym więcej rund mieszania.
Jeśli metoda mieszająca zgłosi błąd, zgłaszasz „wewnętrzny błąd serwera”. W przeciwnym razie ustawiasz właściwość hasła na pomyślny skrót i zapisujesz go w swojej bazie danych, wywołując metodę save na Użytkownik instancja.
Następnie utwórz trasę logowania, dodając poniższy blok kodu do swojego userRoute.js plik:
router.post("/sign-in", asynchroniczny (wymagany, odp.) => {
próbować {
// Wyodrębnij e-mail i hasło z obiektu req.body
stały { e-mail, hasło } = zam.body;// SprawdzaćjeśliużytkownikistniejewBaza danych
wynajmować użytkownik = czekać na User.findOne({ e-mail });jeśli (!użytkownik) {
return res.status (401).json ({ wiadomość: "Nieprawidłowe poświadczenia" });
}// Porównaj hasła
bcrypt.compare (hasło, user.password, (błąd, wynik) => {
jeśli (wynik) {
return res.status (200).json ({ wiadomość: "Użytkownik zalogował się pomyślnie" });
}konsola.log (błąd);
return res.status (401).json ({ wiadomość: "Nieprawidłowe poświadczenia" });
});
} złapać (błąd) {
res.status(401).wysłać(błądzić.wiadomość);
}
});
moduł.eksport = router;
W powyższym bloku kodu, najpierw zdestrukturyzuj e-mail i hasło z wymagane ciało obiekt. Następnie sprawdzasz, czy użytkownik istnieje w Twojej bazie danych. Jeśli użytkownik nie istnieje w Twojej bazie danych, wracasz z kodem statusu 401.
Następnie, korzystając z metody porównywania bcrypt, przekaż hasło podane przez użytkownika i zaszyfrowane hasło pobrane z bazy danych. Porównaj te dwa, aby potwierdzić, czy pasują. Jeśli hasła są zgodne, zwracasz kod stanu 200 i komunikat o powodzeniu. W przeciwnym razie zwracasz kod stanu 401 i komunikat o błędzie.
Wreszcie, importuj router do twojego app.js plik i używać go jako oprogramowania pośredniczącego na poziomie aplikacji.
To kończy model uwierzytelniania użytkownika; teraz użytkownicy mogą bezpiecznie zarejestrować się i zalogować do Twojej aplikacji.
Znaczenie uwierzytelniania użytkownika
Uwierzytelnianie użytkownika zapewnia, że tylko legalni użytkownicy mogą uzyskać dostęp do Twojej aplikacji. Jeśli Twoje dane są w jakikolwiek sposób osobiste lub prywatne, powinieneś podjąć kroki, aby uniemożliwić dostęp nieuwierzytelnionym użytkownikom.
