NodeJS Google hitelesítés Passport és Express használatával

Ha valaha is használta Google-fiókját egy alkalmazásba való bejelentkezéshez, akkor valószínűleg észrevette, hogy ez milyen egyszerű. Csak egy gombra kell kattintania, és nem kell beírnia e-mail címét vagy jelszavát. Bár ez egyszerűnek tűnik, az, ami a motorháztető alatt történik, meglehetősen bonyolult. Az olyan eszközök azonban, mint a Passport, megkönnyítik.

Ebből az oktatóanyagból megtudhatja, hogyan valósíthatja meg a Google hitelesítést a Node-ban a Passport és az Express használatával.

Mi az az útlevél?

Útlevél (vagy Passport.js) egy csomópont-hitelesítési köztes szoftver, amely több mint 500 stratégiát biztosít a felhasználók hitelesítésére, beleértve a közösségi hitelesítést olyan platformokon, mint a Google és a Twitter.

Használni fogod pass-google-oauth2 stratégiát a felhasználók hitelesítésére a Google-on.

Google hitelesítési rendszer létrehozása a Node-ban

Ez a létrehozandó hitelesítési rendszer áttekintése:

• Amikor a felhasználó a bejelentkezés gombra kattint, a rendszer a Google bejelentkezési oldalára kerül, ahol bejelentkezik.
instagram viewer
• A Google egy hozzáférési tokennel átirányítja a felhasználót az alkalmazásához. A hozzáférési token engedélyt ad az adott felhasználó profilinformációinak elérésére.
• A profiladatok lekéréséhez küldje el a hozzáférési tokent a Google-nak.
• Hozzon létre egy új felhasználót, vagy kérje le a meglévő felhasználót az adatbázisból.
• Használjon JWT-ket az érzékeny útvonalak védelmére.

A Google hitelesítés beállítása a NodeJS-ben a Passport használatával

Kövesse az alábbi lépéseket a felhasználók Google OAuth használatával történő engedélyezéséhez,

1. lépés: Hozzon létre egy Google ügyfél-azonosítót és ügyféltitkot

Mielőtt a Google-lal bejelentkeztetné a felhasználókat az alkalmazásba, regisztrálnia kell alkalmazását a Google-nál, hogy megkapja az ügyfél-azonosítót és az ügyféltitkot a Passport konfigurálásakor.

Jelentkezzen be a Google Cloud konzol és kövesse az alábbi lépéseket az alkalmazás regisztrálásához.

Hozzon létre egy új projektet. A menüsorban válassza a lehetőséget Hitelesítő adatok és a legördülő listából válassza ki OAuth-ügyfélazonosító.

Az alkalmazás típusához válassza a lehetőséget webalkalmazás. Adja meg az alkalmazás kívánt nevét a Név mezőben.

Az engedélyezett átirányítási URI-k alatt használja a http://localhost: 3000 és http://localhost: 3000/auth/google/callback engedélyezett átirányítási URI-k esetén.

Kattintson teremt az OAuth-kliens létrehozásához. Mivel az alkalmazás hitelesítő adatai érzékenyek, létre kell hoznia a .env fájlt, és adja hozzá az ügyfélazonosítót és az ügyféltitkot.

CLIENT_ID = 
CLIENT_SECRET = 

2. lépés: Node Server beállítása

Hozzon létre egy mappát, user-google-auth, és navigáljon hozzá.

mkdir user-google-auth
cd user-google-auth

Inicializálja npm készíteni package.json.

npm init -y

Mivel expresszt fog használni hozza létre a szervert, telepítse a következő parancs futtatásával.

npm install express

Nyissa meg a mappát a kívánt szövegszerkesztővel, és hozzon létre egy új fájlt app.js. Ez lesz az alkalmazás belépési pontja.

Hozza létre a NodeJS szervert app.js.

const express = követelmény("expressz");
const app = express();
const PORT = 3000;
app.listen (PORT, () => {
 console.log(`Hangolás a ${PORT} porton`);
});

2. lépés: Állítsa be a MongoDB-t

A Google-tól kapott felhasználói adatokat a MongoDB adatbázis. A felhasználói információk mentése előtt meg kell határozni az adatok tárolásának struktúráját. A mongúz erre tökéletes. Ez egy meglehetősen egyszerű módszert kínál az adatmodellek létrehozására.

Telepítés indiai menyét.

npm install mongoose

Hozzon létre egy új fájlt userModel.js, és hozza létre a felhasználói sémát.

const mongoose = igény("mongúz");
const { Séma } = mongoose.model;
const UserSchema = new Schema({
 Google: {
 azonosító: {
 típus: húr,
 },
 név: {
 típus: húr,
 },
 email: {
 típus: húr,
 },
 },
});
const User = mongoose.model("Felhasználó", UserSchema);
module.exports = Felhasználó;

Ban ben userModel.js, importálta a mongoose-t, és létrehozott egy új sémát.

Figyelje meg, hogy a Google-tól származó információkat csoportosítja. Ez különösen akkor hasznos, ha más hitelesítési módszereket is használ, és egy felhasználó egynél többet használ. Ez megkönnyíti a kettős regisztráció elkerülését.

Ezután hozzon létre db.js.

const mongoose = igény("mongúz");
indiai menyét. Ígéret = globális. Ígéret;
const dbUrl = "mongodb://localhost/user";
const connect = async () => {
 mongoose.connect (dbUrl, { useNewUrlParser: true, useUnifiedTopology: true });
 const db = mongoose.connection;
 db.on("hiba", () => {
 console.log("nem sikerült csatlakozni");
 });
 db.once("nyitva", () => {
 console.log("> Sikeres csatlakozás az adatbázishoz");
 });
};
module.exports = {csatlakozás};

Csatlakozzon az adatbázishoz app.js.

const express = követelmény("expressz");
const app = express();
const PORT = 3000;
const db = megköveteli("./db");
db.connect();
app.listen (PORT, () => {
 console.log(`Hangolás a ${PORT} porton`);
});

3. lépés: Állítsa be a Passportot

Telepítés útlevél és pass-google-oauth2.

npm i passport passport-google-oauth2

Hozzon létre egy új fájlt, passportConfig.js, és importálja a Google stratégiát innen pass-google-oauth2 és userModel.js.

const GoogleStrategy = követelmény("passport-google-oauth2").Stratégia;
const Felhasználó = követelmény("./felhasználómodell");

A konfiguráláshoz használja az alkalmazás hitelesítő adatait útlevél a Google OAuth segítségével.

module.exports = (útlevél) => {
 passport.use (új GoogleStrategy({
 ügyfélazonosító: process.env. ÜGYFÉLAZONOSÍTÓ,
 clientSecret: process.env. CLIENT_SECRET,
 callbackURL: " http://localhost: 3000/auth/google/callback",
 passReqToCallback: igaz
 },
 async (request, accessToken, refreshToken, profile, done) => {
 próbálja meg {
 hagyja a meglévőUser = await User.findOne({ 'google.id': profile.id });
// ha a felhasználó létezik, adja vissza a felhasználót
 if (existingUser) {
 visszatérés kész (null, létezőUser);
 }
// ha a felhasználó nem létezik, hozzon létre egy új felhasználót
 console.log('Új felhasználó létrehozása...');
 const newUser = new User({
 módszer: 'google',
 Google: {
 azonosító: profile.id,
 név: profile.displayName,
 email: profile.emails[0].value
 }
 });
 await newUser.save();
 return kész (null, newUser);
 } fogás (hiba) {
 visszaküldés kész (hiba, hamis)
 }
 }
 ));
}

Miután megkapta a profiladatokat a Google-tól, ellenőrizze, hogy a felhasználó szerepel-e az adatbázisban. Ha igen, egyszerűen küldje vissza a megtalált felhasználót. Ha a felhasználó új, hozzon létre egy új dokumentumot az adatbázisban, és adja vissza a létrehozott felhasználót.

Vegye figyelembe, hogy dolgozik env változókat, ezért használja a npm csomag dotenv hogy elérje őket az alkalmazásban.

Telepítés dotenv.

npm install dotenv

Használat dotenv ban ben app.js.

request("dotenv").config()

Ban ben app.js,passz útlevél nak nek passportConfig.js

const passport = követelmény("útlevél");
igényel("./passportConfig")(útlevél);

4. lépés: Hozzon létre hitelesítési útvonalakat

Három útvonalra van szüksége:

• A hozzáférési token lekéréséhez irányítsa át a felhasználót a Google bejelentkezési oldalára.
• Felhasználói adatok lekérése a kapott hozzáférési token használatával.
• Ezután irányítsa át a felhasználót a profiloldalra sikeres hitelesítés.

// A felhasználó átirányítása a Google bejelentkezési oldalára
app.get(
 "/auth/google",
 passport.authenticate("google", { hatókör: ["e-mail", "profil"] })
);
// Felhasználói adatok lekérése a kapott hozzáférési token használatával
app.get(
 "/auth/google/callback",
 passport.authenticate("google", { session: false }),
 (req, res) => {
 res.redirect("/profil/");
 }
);
// profilútvonal sikeres bejelentkezés után
app.get("/profile", (req, res) => {
 console.log (req);
 res.send("Üdvözöljük");
});

5. lépés: Védje meg a privát útvonalakat

Most, hogy felhasználóként jelentkezett be, hogyan korlátozhatja az alkalmazás egyes részeit csak hitelesített felhasználókra? Ennek egyik módja a JSON Web Tokens (JWT) használata. A JWT-k biztonságos módot kínálnak az információtovábbításra. Nak nek engedélyezze a felhasználókat JWT-k használatával az alkalmazás:

• Hozzon létre egy tokent a felhasználói adatok felhasználásával.
• Adja át a tokent a felhasználónak (a felhasználó visszaküldi a tokent olyan kérésekkel, amelyekhez engedély szükséges).
• Ellenőrizze a visszaküldött tokent.
• Adjon hozzáférést a felhasználónak, ha a bemutatott token érvényes.

Telepítés jsonwebtoken JWT-kkel dolgozni.

npm install jsonwebtoken

Ban ben app.js, import jsonwebtoken.

const jwt = követelmény("jsonwebtoken")

Módosítsa a Google visszahívási URL-címét a felhasználó aláírásához, és generáljon tokent.

app.get(
 "/auth/google/callback",
 passport.authenticate("google", { session: false }),
 (req, res) => {
 jwt.sign(
 { user: req.user },
 "titkos kulcs",
 { expiresIn: "1h" },
 (hiba, token) => {
 if (err) {
 return res.json({
 token: null,
 });
 }
 res.json({
 jelképes,
 });
 }
 );
 }
);

Ha bejelentkezik, megkapja a tokent.

Következő, használja útlevél-jwt, a Passport által biztosított JWT stratégia a token ellenőrzésére és a felhasználók engedélyezésére.

npm install passport-jwt

Ban ben passportConfig.js, add hozzá a JWT stratégiát.

const JwtStrategy = követelmény("passport-jwt").Stratégia;
const { ExtractJwt } = követelmény("passport-jwt");
module.exports = (útlevél) => {
 passport.use (új GoogleStrategy(
// Google stratégia
 );
 passport.use(
 új JwtStrategy(
 {
 jwtFromRequest: ExtractJwt.fromHeader("engedély"),
 secretOrKey: "secretKey",
 },
 async (jwtPayload, kész) => {
 próbálja meg {
// Felhasználó kibontása
 const user = jwtPayload.user;
 kész (null, user); 
 } fogás (hiba) {
 kész (hiba, hamis);
 }
 }
 )
 );
}

Itt ki kell bontani a tokent az engedélyezési fejlécből, ahol tárolva van – ami sokkal biztonságosabb, mint a kérés törzsében való tárolása.

A token ellenőrzése után a felhasználói objektum visszaküldésre kerül a kérés törzsének. A felhasználók engedélyezéséhez adja hozzá a passport JWT hitelesítési köztes szoftvert a védett útvonalakhoz.

app.get(
 "/profil",
 passport.authenticate("jwt", { session: false }),
 (req, res, next) => {
 res.send("Üdvözöljük");
 }
);

Mostantól csak azok a kérések kapnak hozzáférést, amelyek érvényes tokent biztosítanak.

Következő lépések

Ez az oktatóanyag bemutatja, hogyan jelentkezhet be a Passport segítségével a felhasználók Google-fiókjuk segítségével az alkalmazásba. A Passport használata sokkal egyszerűbb, mint más űrlapok, és sok időt takaríthat meg használatával.

A Passport más hitelesítési stratégiákat is kínál, amelyeket más identitásszolgáltatókkal, például a Twitterrel és a Facebookkal is használhat. Szóval érdemes ezeket is megnézni.

Felhasználó hitelesítés a NodeJS-ben Passport és MongoDB használatával

Olvassa el a következőt

A szerzőről