Uwierzytelnianie NodeJS Google za pomocą usługi Passport i Express

Jeśli kiedykolwiek używałeś swojego konta Google do logowania się do aplikacji, być może zauważyłeś, jakie to proste. Wystarczy kliknąć jeden przycisk i nie musisz wpisywać swojego adresu e-mail ani hasła. Choć wydaje się to proste, to, co dzieje się pod maską, jest dość złożone. Jednak narzędzia takie jak Passport ułatwiają.

W tym samouczku dowiesz się, jak zaimplementować uwierzytelnianie Google w Node za pomocą Passport i Express.

Co to jest paszport?

Paszport (lub Passport.js) to oprogramowanie pośredniczące do uwierzytelniania węzłów, które zapewnia ponad 500 strategii uwierzytelniania użytkowników, w tym uwierzytelnianie społecznościowe za pomocą platform takich jak Google i Twitter.

Wykorzystasz paszport-google-oauth2 strategia uwierzytelniania użytkowników w Google.

Tworzenie systemu uwierzytelniania Google w węźle

Oto przegląd systemu uwierzytelniania, który utworzysz:

• Gdy użytkownik kliknie przycisk logowania, zostanie przekierowany na stronę logowania Google, na której się zaloguje.
instagram viewer
• Google przekieruje użytkownika do Twojej aplikacji za pomocą tokena dostępu. Token dostępu daje uprawnienia dostępu do informacji o profilu tego użytkownika.
• Wyślij token dostępu do Google, aby uzyskać dane profilu.
• Utwórz nowego użytkownika lub pobierz istniejącego użytkownika z bazy danych.
• Użyj tokenów JWT do ochrony wrażliwych tras.

Jak skonfigurować uwierzytelnianie Google w NodeJS za pomocą paszportu?

Wykonaj poniższe czynności, aby autoryzować użytkowników z Google OAuth,

Krok 1: Utwórz identyfikator klienta Google i tajny klucz klienta

Zanim użyjesz Google do logowania użytkowników w swojej aplikacji, musisz zarejestrować swoją aplikację w Google, aby uzyskać identyfikator klienta i klucz klienta do użycia podczas konfigurowania usługi Passport.

Zaloguj się do Konsola Google Cloud i wykonaj następujące kroki, aby zarejestrować swoją aplikację.

Utwórz nowy projekt. Na pasku menu wybierz Referencje i z listy rozwijanej wybierz Identyfikator klienta OAuth.

Jako typ aplikacji wybierz Aplikacja internetowa. Dodaj preferowaną nazwę aplikacji w polu Nazwa.

Pod autoryzowanymi identyfikatorami URI przekierowania użyj http://localhost: 3000 oraz http://localhost: 3000/auth/google/callback dla autoryzowanych identyfikatorów URI przekierowania.

Kliknij Stwórz aby utworzyć klienta OAuth. Ponieważ poświadczenia aplikacji są poufne, musisz utworzyć .env i dodaj do niego identyfikator klienta i klucz tajny klienta.

KLIENT_ID = 
CLIENT_SECRET = 

Krok 2: Skonfiguruj serwer węzła

Utwórz folder, autoryzacja-użytkownika-google, i przejdź do niego.

mkdir user-google-auth
cd użytkownik-google-auth

Zainicjuj npm tworzyć pakiet.json.

npm początek -y

Ponieważ będziesz używać ekspresu do utwórz serwer, zainstaluj go, uruchamiając następujące polecenie.

npm zainstaluj ekspres

Otwórz folder w preferowanym edytorze tekstu i utwórz nowy plik app.js. Będzie służył jako punkt wejścia do Twojej aplikacji.

Utwórz serwer NodeJS w app.js.

const express = require("ekspres");
const aplikacja = express();
const PORT = 3000;
app.listen (PORT, () => {
 console.log(`Nasłuch na porcie ${PORT}`);
});

Krok 2: Skonfiguruj MongoDB

Będziesz przechowywać dane użytkownika otrzymane od Google w Baza danych MongoDB. Przed zapisaniem informacji o użytkowniku należy zdefiniować strukturę, w jakiej będą przechowywane dane. Mongoose jest do tego idealna. Zapewnia dość prosty sposób tworzenia modeli danych.

zainstalować mangusta.

npm zainstaluj mangusty

Utwórz nowy plik userModel.jsi utwórz schemat użytkownika.

const mangusta = require("mangusta");
const { Schemat } = mangusta.model;
const UserSchema = nowy schemat ({
 Google: {
 ID: {
 typ: ciąg,
 },
 imię: {
 typ: ciąg,
 },
 e-mail: {
 typ: ciąg,
 },
 },
});
const Użytkownik = mongoose.model("Użytkownik",Schemat Użytkownika);
module.exports = Użytkownik;

w userModel.js, zaimportowałeś mangustą i utworzyłeś nowy schemat.

Zauważ, że grupujesz informacje od Google. Jest to szczególnie przydatne, gdy używasz również innych metod uwierzytelniania, a użytkownik używa więcej niż jednej. Ułatwia to zapobieganie podwójnej rejestracji.

Następnie utwórz db.js.

const mangusta = require("mangusta");
mangusta. Obietnica = globalna. Obietnica;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mangusta.connection;
 db.on("błąd", () => {
 console.log("nie można się połączyć");
 });
 db.once("otwarty", () => {
 console.log("> Pomyślnie połączono z bazą danych");
 });
};
module.exports = { połącz };

Połącz się z bazą danych w app.js.

const express = require("ekspres");
const aplikacja = express();
const PORT = 3000;
const db = wymagaj("./db");
db.connect();
app.listen (PORT, () => {
 console.log(`Nasłuch na porcie ${PORT}`);
});

Krok 3: Skonfiguruj paszport

zainstalować paszport oraz paszport-google-oauth2.

npm i paszport paszport-google-oauth2

Utwórz nowy plik, paszportConfig.jsi zaimportuj strategię Google z paszport-google-oauth2 oraz userModel.js.

const GoogleStrategy = require("passport-google-oauth2").Strategy;
const Użytkownik = wymagaj("./userModel");

Użyj swoich danych logowania do aplikacji, aby skonfigurować paszport z Google OAuth.

module.exports = (paszport) => {
 paszport.use (nowa strategia Google({
 identyfikator klienta: process.env. IDENTYFIKATOR KLIENTA,
 ClientSecret: process.env. KLIENT_SECRET,
 callbackURL: " http://localhost: 3000/auth/google/callback",
 passReqToCallback: prawda
 },
 async (request, accessToken, refreshToken, profile, done) => {
 próbować {
 let existingUser = await User.findOne({ 'google.id': profile.id });
// jeśli użytkownik istnieje, zwróć użytkownika
 jeśli (istniejącyUżytkownik) {
 return done (null, existingUser);
 }
// jeśli użytkownik nie istnieje, utwórz nowego użytkownika
 console.log('Tworzenie nowego użytkownika...');
 const nowyUżytkownik = nowy Użytkownik({
 metoda: 'google',
 Google: {
 id: profil.id,
 nazwa: profil.displayName,
 email: profile.emails[0].value
 }
 });
 czekaj na nowegoUżytkownika.zapisz();
 return done (null, newUser);
 } złapać (błąd) {
 zwrot wykonany (błąd, fałsz)
 }
 }
 ));
}

Po otrzymaniu informacji o profilu od Google sprawdź, czy użytkownik istnieje w bazie danych. Jeśli tak, po prostu zwróć znalezionego użytkownika. Jeśli użytkownik jest nowy, utwórz nowy dokument w bazie danych i zwróć utworzonego użytkownika.

Zauważ, że pracujesz z zazdrościć zmienne, więc użyj npm pakiet dotenv aby uzyskać do nich dostęp w aplikacji.

zainstalować dotenv.

npm zainstaluj dotenv

Stosowanie dotenv w app.js.

wymagać("dotenv").config()

w app.js,podawać paszport do paszportConfig.js

const paszport = wymagaj("paszport");
wymagaj("./passportConfig")(paszport);

Krok 4: Utwórz trasy uwierzytelniania

Potrzebujesz trzech tras, aby:

• Przekieruj użytkownika na stronę logowania Google, aby uzyskać token dostępu.
• Pobierz dane użytkownika za pomocą otrzymanego tokena dostępu.
• Przekieruj użytkownika na stronę profilu po pomyślne uwierzytelnienie.

// Przekieruj użytkownika na stronę logowania Google
aplikacja.pobierz(
 "/autor/google",
 paszport.authenticate("google", { zakres: ["email", "profil"] })
);
// Pobierz dane użytkownika za pomocą otrzymanego tokena dostępu
aplikacja.pobierz(
 "/auth/google/callback",
 paszport.authenticate("google", { session: false }),
 (wymagane, odp.) => {
 res.redirect("/profil/");
 }
);
// profiluj trasę po pomyślnym zalogowaniu
app.get("/profile", (req, res) => {
 console.log (wymagane);
 res.send("Witamy");
});

Krok 5: Chroń prywatne trasy

Teraz, po zalogowaniu się jako użytkownik, w jaki sposób możesz ograniczyć niektóre części swojej aplikacji tylko do uwierzytelnionych użytkowników? Jednym ze sposobów na to jest użycie tokenów internetowych JSON (JWT). JWT oferują bezpieczny sposób przesyłania informacji. W celu autoryzuj użytkowników przy użyciu tokenów JWT aplikacja będzie:

• Wygeneruj token, korzystając z danych użytkownika.
• Przekaż token użytkownikowi (użytkownik odeśle token z żądaniami wymagającymi autoryzacji).
• Zweryfikuj odesłany token.
• Przyznaj dostęp użytkownikowi, jeśli przedstawiony token jest ważny.

zainstalować jsonwebtoken do pracy z tokenami JWT.

npm zainstaluj jsonwebtoken

w app.js, import jsonwebtoken.

const jwt = require("jsonwebtoken")

Zmodyfikuj adres URL wywołania zwrotnego Google, aby podpisać użytkownika i wygenerować token.

aplikacja.pobierz(
 "/auth/google/callback",
 paszport.authenticate("google", { session: false }),
 (wymagane, odp.) => {
 znak.jwt(
 { użytkownik: żądany użytkownik },
 "sekretny klucz",
 { wygasa za: "1h" },
 (błąd, token) => {
 jeśli (błąd) {
 return res.json({
 token: null,
 });
 }
 res.json({
 znak,
 });
 }
 );
 }
);

Jeśli się zalogujesz, otrzymasz token.

Następnie użyj paszport-jwt, strategia JWT dostarczona przez Passport w celu weryfikacji tokenu i autoryzacji użytkowników.

npm zainstaluj paszport-jwt

w paszportConfig.js, dodaj strategię JWT.

const JwtStrategy = require("paszport-jwt").Strategia;
const { ExtractJwt } = require("passport-jwt");
module.exports = (paszport) => {
 paszport.use (nowa strategia Google(
// Strategia Google
 );
 paszport.użycie(
 nowa strategia Jwt(
 {
 jwtFromRequest: ExtractJwt.fromHeader("autoryzacja"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, gotowe) => {
 próbować {
// Wyodrębnij użytkownika
 const user = jwtPayload.user;
 gotowe (null, użytkownik); 
 } złapać (błąd) {
 zrobione (błąd, fałsz);
 }
 }
 )
 );
}

Tutaj wyodrębniasz token z nagłówka autoryzacji, w którym jest przechowywany — co jest znacznie bezpieczniejsze niż przechowywanie go w treści żądania.

Po zweryfikowaniu tokenu obiekt użytkownika jest odsyłany do treści żądania. Aby autoryzować użytkowników, dodaj paszportowe oprogramowanie pośredniczące uwierzytelniania JWT do chronionych tras.

aplikacja.pobierz(
 "/profil",
 paszport.authenticate("jwt", { sesja: fałsz }),
 (req, res, next) => {
 res.send("Witamy");
 }
);

Teraz dostęp uzyskają tylko żądania, które zawierają prawidłowy token.

Następne kroki

W tym samouczku pokazano, jak używać usługi Passport do logowania użytkowników do aplikacji przy użyciu ich kont Google. Korzystanie z Paszportu jest znacznie prostsze niż inne formularze, a dzięki nim zaoszczędzisz dużo czasu.

Passport zapewnia również inne strategie uwierzytelniania, których można używać z innymi dostawcami tożsamości, takimi jak Twitter i Facebook. Warto więc sprawdzić również te.

Uwierzytelnianie użytkownika w NodeJS przy użyciu Passport i MongoDB

Czytaj dalej

O autorze