NodeJS + Postgres DB + Passport JWT + Passport 로컬 로그인 및 인증

안녕,

간단한 [NodeJS 애플리케이션] 😎( https://www.npmjs.com/package/express )을 Postgres에 연결하고 인증 및 승인을 위해 PassportJS을 사용하는 방법에 대한 첫 번째 블로그 😇를 작성하고 있습니다.

따라서 기본 머신 설정은 다음과 같습니다.
Node JS - v12 or abovepgAdmin for DB Connectivitynpm for creating and installing the dependencies

Step 1:



애플리케이션을 만들려는 디렉터리에서 npm init를 사용하여 간단한 npm 모듈을 만들어 보겠습니다.
> npm init
구성에 대해 다음과 같은 질문을 합니다.



모든 질문에 대해 Enter 키를 누르거나 자신의 구성을 추가할 수 있습니다. 저는 기본 구성을 사용하고 있습니다.

Step 2:
Now we need the dependencies which needs to be installed for our application to use while we compile the code:



내 package.json은 다음과 같습니다.



종속성을 설치하기 위해 실행할 수 있는 명령은 다음과 같습니다.
npm i --save bcrypt-nodejs cors express jsonwebtoken nodemon passport passport-jwt passport-local pg pg-hstore sequelize
우리를 위해 모든 종속성과 해당 작업을 파악해 봅시다.
  • bcrypt-nodejs : 새 사용자를 만들 때 암호를 암호화하고 해독하는 데 도움이 됩니다.
  • cors : 원하거나 필요한 경우 CROSS ORIGIN REQUESTS 설치를 허용합니다.
  • express : 경로를 사용할 서버를 생성합니다.
  • jsonwebtoken : API 인증을 위한 JWT 토큰을 생성합니다.
  • passport : 사용자의 간편한 인증을 위해.
  • passport-jwt : JWT 인증용.
  • passport-local : 로그인 인증의 LocalStrategy용
  • pg pg-hstore sequelize : Postgres DB 액세스용

  • Step 3:



    프로젝트를 시작할 간단한 서버를 만들어 보겠습니다.

    index.js 파일에 있는 내용은 다음과 같습니다.

    // project/index.js 
    
    
    const express = require('express')
    const db = require('./models')
    var cors = require('cors')
    const app = express()
    const port = 3000
    app.use(express.json());
    app.use(cors())
    
    db.sequelize.sync().then(() => {
        console.log("Synced")
    }).catch(err => console.err(err))
    
    app.get('/', (req, res) => {
        res.send('Hello World!')
    })
    
    require('./routes/user.route')(app)
    
    app.listen(port, () => {
        console.log(`Example app listening on port ${port}`)
    })
    


    이 문이 하는 일은 다음과 같습니다.

    db.sequelize.sync().then(() => {
        console.log("Synced")
    }).catch(err => console.err(err))
    

    Postgres DB가 연결되었고 속편화 중인지 확인합니다.

    그런 다음 바로 다음 단계에서 생성할 경로입니다.

    그리고 서버 시작:

    이 줄을 주석 처리
    require('./routes/user.route')(app)npm run dev를 실행하고 응용 프로그램이 Synced이고 포트 3000에서 실행 중인지 확인합니다.

    아래에 표시되는 경우:



    야야야....!!! 이제 익스프레스 서버를 만들었습니다.

    Step 4:



    재미있는 부분은 여기에서 시작됩니다.
  • 경로를 생성해 보겠습니다.

  • // project/routes/user.route.js
    
    
    module.exports = app => {
    
        // Import of the controller
        const user = require('../controller/user.controller')
    
        // Creating the router instance
        const router = require('express').Router();
    
        // TO create the user
        router.post('/user', user.create)
    
        // To Login the user using Passport Local Strategy
        router.post('/user-passport-login', user.loginWithPassport)
    
        // Pass the router instance to the App.
        app.use('/api/v1', router)
    }
    


    각 경로에는 고유한 정의가 있습니다. 이제 첫 번째 컨트롤러를 만들어 보겠습니다.

    // project/controller/user.controller.js
    
    const db = require("../models");
    const User = db.user;
    const passportLocal = require('../config/passportLocal')
    
    // To create a new user in the DB
    
    function create(req, res) {
        const userdata = {
            username: req.body.username,
            password: req.body.password
        }
        User.create(userdata).then(data => {
            return res.send(data)
        }).catch(err => {
            console.warn(err)
        })
    }
    
    
    // To Login the user using Passport
    
    async function loginWithPassport(req, res) {
        return await passportLocal.authenticate('local', function (err, response) {
            if (response) {
                return res.send({
                    msg: "Login Success",
                })
            }
            if (!response) {
                return res.send({
                    msg: "Failed"
                })
            }
        })(req, res)
    }
    
    


    기다려 기다려...!!

    왜 이 라인:

        })(req, res)
    

    loginWithPassportreqres를 매개변수로 갖는 자체 호출 함수입니다. 계산된 응답을 컨트롤러에서 API로 반환해야 하기 때문에 요청 매개변수도 필요합니다.

    Step 5:



    이제 Models를 생성해 보겠습니다.

    // project/models/user.model.js
    
    var bcrypt = require('bcrypt-nodejs');
    
    module.exports = (sequelize, DataTypes) => {
    
        // To get the feasiblity of the Sequelize ORM
        const User = sequelize.define("user", {
            username: {
                type: DataTypes.STRING,
                primaryKey: true
            },
            password: {
                type: DataTypes.STRING
            },
        });
    
        // It will convert each password into the Hashed String for maintaining the security
        User.beforeSave((user) => {
            if (user.changed('password')) {
                user.password = bcrypt.hashSync(user.password, bcrypt.genSaltSync(10), null)
            }
        })
    
        // It will compare the password to the passed string using the bcrypt algo, and will return the result
        User.prototype.comparePassowrd = function (pass, cb) {
            bcrypt.compare(pass, this.password, function (err, isMatch) {
                if (err) {
                    return cb(err)
                }
                cb(null, isMatch)
            })
        }
        return User;
    };
    


    모델을 만들었지만 지금은 사용하지 않고 있습니다. 일종의 스키마일 뿐입니다. 이제 까다로운 부분을 수행해 보겠습니다. 아래 코드를 사용하여 pgAdmin에서 DB 테이블을 생성해 보겠습니다.

    // project/models/index.js
    
    const dbConfig = require('../db.config')
    const Sequelize = require('sequelize')
    
    const sequelize = new Sequelize(dbConfig.DB, dbConfig.USER, dbConfig.PASSWORD, {
        host: dbConfig.HOST,
        operatorAliases: false,
        dialect: dbConfig.dialect,
        pool: dbConfig.pool
    })
    
    const db = {}
    
    db.Sequelize = Sequelize
    db.sequelize = sequelize
    db.user = require('./user.model.js')(sequelize, Sequelize)
    
    module.exports = db;
    

    dbConfig.js
    // project/dbConfig.js
    
    module.exports = {
        HOST: "localhost",
        USER: "harishsoni",
        PASSWORD: "admin",
        DB: "testDB",
        dialect: "postgres",
        pool: {
            max: 5,
            min: 0,
            acquire: 30000,
            idle: 10000
        }
    }
    


    위의 Sequelization and Syncing the DB를 사용하는 index.js의 라인은 다음과 같습니다.

    const db = require('./models')
    


    Step 3:



    이제 마지막 파트에서는 ​​사용 인증을 확인하기 위한 주요 비즈니스 로직을 포함할 passportLocal.js 파일을 생성해 보겠습니다.

    // project/config/passportLocal.js
    
    const passport = require('passport')
    const LocalStratery = require('passport-local').Strategy
    const db = require('../models')
    
    // Creating the passport instance to be used from the controller.
    
    passport.use(new LocalStratery({
    
        // if you use any different name for the username field, you can pass the key here
        usernameField: 'username'
    }, async function (username, password, done) {
        // findByPk is a Sequelize function which returns the data if it finds the primary key with the value passed
        return await db.user.findByPk(username).then(async data => {
    
            // Check if the user is there in the DB:
            if (!data) {
                return done(null, null)
            }
    
            // If the user is correct, then let's see if he has entered the correct password.
            await data.comparePassowrd(password, (err, userData) => {
                return done(null, userData)
            })
        }).catch(err => { throw err })
    }))
    
    
    // For Storing the user id in the session {req.session.passport.user = {id: '..'}}
    passport.serializeUser(function (user, cb) {
        cb(null, user)
    })
    
    // For checking if the user has an active session.
    passport.deserializeUser(function (obj, cb) {
        cb(null, obj)
    })
    
    module.exports = passport
    


    다음은 사용자 로그인을 위한 여권 구성의 모습입니다.

    따라서 모든 것을 결합하면 다음과 같은 결과를 얻을 수 있습니다.

    project
    │   index.js
    │   db.config.js
    │   package.json
    │
    └───models
    │    user.model.js
    │    index.js
    │   
    └───config
    │    passportLocal.js
    │   
    └───controller
    │    user.controller.js
    │   
    └───routes
          user.route.js
    
    
    


    🥳🥳🥳 이제 설정을 마쳤습니다. 실행하고 코드가 작동하는지 확인할 시간입니다(작동하는 경우 신이 방법을 알고 그렇지 않은 경우 이유를 알아야 합니다 😂 😂 😂 😂 😂)

    🤞🤞 여기 우리 gooooooo.....!!!!



    🧐🧐🧐 성공했습니다::::::::::::

    지금 API를 확인해 보겠습니다.

    🤞🤞🤞🤞🤞🤞🤞🤞🤞🤞



    네, 효과가 있었어요: 😎😎😇😇

    Any suggestion are welcome:
    


    레포 링크: https://github.com/harish9312/passport-auth-node

    좋은 웹페이지 즐겨찾기