नेक्स्ट.जेएस रूट्स और अपस्टैश रेडिस का उपयोग करके एक सुरक्षित, तेज़ प्रमाणित एपीआई बनाएं

आवश्यकताएँ

• एक अपस्टैश खाता - यहां निःशुल्क खाते के लिए साइन अप करें
• रेडिस का बुनियादी ज्ञान
• नेक्स्ट.जेएस एपीआई रूट्स का बुनियादी ज्ञान
• प्रमाणीकरण और प्राधिकरण वर्कफ़्लो का बुनियादी ज्ञान
• HTTP अनुरोध करने के लिए आपकी पसंद का एक उपकरण

अपस्टैश रेडिस क्या है

हम क्या बनाएंगे

रिपॉजिटरी और डेमो

रेडिस डेटाबेस की स्थापना

 hmset movie:’Dr. Strangelove’ director ‘Stanley Kubrick’ year 1964
 hmset movie:’2001: A Space Odyssey’ director ‘Stanley Kubrick’ year 1968
 hmset movie:’Pulp Fiction’ director ‘Quentin Tarantino’ year 1994
 hmset movie:’Django Unchained’ director ‘Quentin Tarantino’ year 2012

 hmset user:’me@home.org’ password $2b$10$zctxUVDyy3jzvSp68oKpMOnkyra4R.NzOFVh9aii3Y43X7XtetoyK level 0

प्राधिकरण वर्कफ़्लो

• उपयोगकर्ता साइन-इन एंडपॉइंट, उपयोगकर्ता नाम और पासवर्ड पोस्ट करने का अनुरोध करता है
• सर्वर उपयोगकर्ता को प्रमाणित करने का प्रयास करता है, यदि उपयोगकर्ता वैध है तो सर्वर एक JWT (JSON वेब टोकन) और एक रिफ्रेश टोकन बनाता है और वापस भेजता है, रिफ्रेश टोकन हमारे अपस्टैश रेडिस इंस्टेंस पर भी संग्रहीत होता है
• ग्राहक टोकन वापस प्राप्त करता है और उन्हें कहीं संग्रहीत करता है (यह ग्राहक की जिम्मेदारी है कि उन्हें कैसे/कहां संग्रहीत करना है)
• क्लाइंट हेडर में JWT भेजकर एक संरक्षित समापन बिंदु का अनुरोध करता है
• सर्वर JWT प्राप्त करता है, इसे सत्यापित करता है, और यदि यह सत्यापित है तो क्लाइंट द्वारा अनुरोधित डेटा वापस भेजता है
• एक बार जब JWT समाप्त हो जाता है या समाप्त होने के करीब होता है, तो ग्राहक एक विशिष्ट समापन बिंदु पर रिफ्रेश टोकन भेजकर, दोबारा लॉगिन किए बिना नए JWT का अनुरोध कर सकता है।
• सर्वर को रिफ्रेश टोकन प्राप्त होता है, इसे सत्यापित करें, और यदि सत्यापन सकारात्मक है तो एक नया JWT और रिफ्रेश टोकन जारी करें, उन्हें क्लाइंट को वापस भेजें, और नए रिफ्रेश टोकन को फिर से संग्रहीत करें

प्रोजेक्ट की स्थापना

 npx create-next-app upstash-jwt

 npm i bcrypt jsonwebtoken @upstash/redis

 SECRET_TOKEN=
 SECRET_RTOKEN=
 UPSTASH_REDIS_REST_URL=
 UPSTASH_REDIS_REST_TOKEN=

एपीआई मार्गों के लिए कोड

import bcrypt from "bcrypt";
 
import {
 addToList,
 generateAccessToken,
 generateRefreshToken,
 redis,
} from "../../../utils";
 
export default async (req, res) => {
 if (req.method === "GET") {
 res.status(405).send("Not Allowed");
 } else {
 console.log(req.body.user);
 try {
 const user = await redis.hgetall(`user:${req.body.user}`);
 if (user) {
 const validPassword = bcrypt.compare(req.body.password, user.password);
 if (validPassword) {
 const token = generateAccessToken(req.body.user, user.level);
 const refreshToken = generateRefreshToken(req.body.user, user.level);
 const refresh = await addToList(req.body.user, refreshToken);
 const content = {
 user: req.body.user,
 level: user.level,
 };
 res.status(200).json({
 message: "Logged in",
 content: content,
 JWT: token,
 refresh: refreshToken,
 });
 } else {
 res.status(400).json({ error: "Invalid Password" });
 }
 } else {
 res.status(401).json({ error: "User not found" });
 }
 } catch (error) {
 res.status(500).send("Internal Server Error");
 }
 }
};

 const user = await redis.hgetall(`user:${req.body.user}`);

 const validPassword = bcrypt.compare(req.body.password, user.password);

import { Redis } from "@upstash/redis";
import jwt from "jsonwebtoken";
 
export const redis = new Redis({
 url: process.env.UPSTASH_REDIS_REST_URL,
 token: process.env.UPSTASH_REDIS_REST_TOKEN,
});
export function generateAccessToken(username, email, level) {
 return jwt.sign(
 { user: username, email: email, level: level },
 process.env.SECRET_TOKEN,
 {
 expiresIn: "1h",
 },
 );
}
 
export function generateRefreshToken(username, email, level) {
 return jwt.sign(
 { user: username, email: email, level: level },
 process.env.SECRET_RTOKEN,
 {
 expiresIn: "30d",
 },
 );
}
 
export async function addToList(user, refresher) {
 try {
 await redis.hset("refresh:" + user, { refresh: refresher });
 } catch (error) {
 console.log(error);
 }
}
 
export async function tokenRefresh(refreshtoken, res) {
 var decoded = "";
 try {
 decoded = jwt.verify(refreshtoken, process.env.SECRET_RTOKEN);
 } catch (error) {
 return res.status(401).send("Can't refresh. Invalid Token");
 }
 if (decoded) {
 try {
 const rtoken = await redis.hget("refresh:" + decoded.user, "refresh");
 console.log(rtoken);
 if (rtoken !== refreshtoken) {
 return res.status(401).send("Can't refresh. Invalid Token");
 } else {
 const user = await redis.hgetall(`user:${decoded.user}`);
 console.log(user);
 const token = generateAccessToken(decoded.user, user.level);
 const refreshToken = generateRefreshToken(decoded.user, user.level);
 
 const refresh = await addToList(decoded.user, refreshToken);
 
 const content = {
 user: decoded.user,
 level: user.level,
 };
 return {
 message: "Token Refreshed",
 content: content,
 JWT: token,
 refresh: refreshToken,
 };
 }
 } catch (error) {
 console.log(error);
 }
 }
}
 
export async function verifyToken(token, res) {
 try {
 const decoded = jwt.verify(token, process.env.SECRET_TOKEN);
 return decoded;
 } catch (err) {
 return res.status(405).send("Token is invalid");
 }
}

import { redis, tokenRefresh } from "../../../utils";
 
export default async (req, res) => {
 if (req.method === "GET") {
 res.status(405).send("Not Allowed");
 } else {
 console.log(req.body.refresh);
 const refresp = await tokenRefresh(req.body.refresh, res);
 res.status(200).json(refresp);
 }
};

import { redis, verifyToken } from "../../../utils";
 
export default async (req, res) => {
 var id;
 console.log(req.query);
 if (req.query.id) {
 id = req.query.id[0];
 }
 
 var decoded = "";
 const authHeader = req.headers["authorization"];
 const token = authHeader && authHeader.split(" ")[1];
 if (!token) {
 return res.status(403).send("A token is required for authentication");
 } else {
 decoded = await verifyToken(token, res);
 }
 if (decoded) {
 if (id) {
 try {
 const result = await redis.hgetall(id);
 console.log(result);
 return res.status(200).json(result);
 } catch (error) {
 return res.status(500).send("Internal Server Error");
 }
 } else {
 try {
 const result = await redis.scan(0, { match: "movie:*" });
 return res.status(200).json(result);
 } catch (error) {
 return res.status(500).send("Internal Server Error");
 }
 }
 }
};

 const result = await redis.scan(0, { match: ‘movie:*’ });

const result = await redis.hgetall(id);

ग्राहक परिप्रेक्ष्य

आगे क्या