Pengesahan Berasaskan Peranan dalam Timbunan MERN: Panduan Lengkap

Pengesahan ialah aspek penting dalam aplikasi web, memastikan hanya pengguna yang dibenarkan boleh mengakses sumber tertentu. Pengesahan Berasaskan Peranan (RBAC) mengambil langkah ini lebih jauh dengan memberikan kebenaran yang berbeza kepada pengguna berdasarkan peranan mereka.

Dalam siaran ini, kami akan membincangkan:
✅ Apakah Pengesahan Berasaskan Peranan?
✅ Mengapa Menggunakan Pengesahan Berasaskan Peranan?
✅ Cara Melaksanakan RBAC dalam Aplikasi Tindanan MERN

Apakah Pengesahan Berasaskan Peranan?
Kawalan Akses Berasaskan Peranan (RBAC) ialah pendekatan keselamatan di mana pengguna diberikan peranan dan setiap peranan mempunyai kebenaran khusus.

Contohnya, dalam aplikasi e-dagang:

Pentadbir boleh menambah, mengedit atau memadamkan produk.
Penjual boleh menguruskan produk mereka sendiri.
Pelanggan hanya boleh melihat dan membeli produk.
Ini memastikan pengguna hanya boleh melakukan tindakan yang berkaitan dengan peranan mereka.

Mengapa Menggunakan Pengesahan Berasaskan Peranan?
✔ Keselamatan Dipertingkat – Menghalang akses tanpa kebenaran kepada operasi sensitif.
✔ Kebolehskalaan – Tambahkan peranan dan kebenaran baharu dengan mudah apabila sistem berkembang.
✔ Pengurusan Pengguna yang Lebih Baik – Berikan kebenaran tanpa mengubah suai kod.

Bagaimana untuk Melaksanakan RBAC dalam Aplikasi Tindanan MERN?
1️⃣ Menyediakan Model Pengguna (MongoDB Mongoose)
Dalam models/user.model.js anda:

javascript
Salin kod
const mongoose = memerlukan("mongoose");

Const UserSchema = mongoose.Schema baharu({
nama pengguna: { type: String, required: true, unique: true },
e-mel: { type: String, required: true, unique: true },
kata laluan: { type: String, required: true },
peranan: {
jenis: Rentetan,
enum: ["admin", "penjual", "pelanggan"],
lalai: "pelanggan"
}
});

module.exports = mongoose.model("Pengguna", UserSchema);
? Di sini, setiap pengguna mempunyai medan peranan, yang menentukan kebenaran mereka.

2️⃣ Menjana Token JWT untuk Pengesahan
Dalam pengawal/auth.controller.js anda:

javascript
Salin kod
const jwt = memerlukan("jsonwebtoken");
const Pengguna = memerlukan("../models/user.model");

log masuk const = tak segerak (req, res) => {
const { e-mel, kata laluan } = req.body;
pengguna const = tunggu User.findOne({ email });

jika (!pengguna || pengguna.kata laluan !== kata laluan) {
kembalikan res.status(401).json({ mesej: "Kelayakan tidak sah" });
}

token const = jwt.sign({ userId: user._id, role: user.role }, "SECRET_KEY", { expiresIn: "1j" });

res.json({ token, peranan: user.role });
};

module.exports = { log masuk };
? Fungsi ini menjana token JWT yang mengandungi peranan pengguna.

3️⃣ Mencipta Middleware untuk Mengehadkan Akses
Dalam middlewares/auth.middleware.js:

javascript
Salin kod
const jwt = memerlukan("jsonwebtoken");

const authenticate = (req, res, next) => {
token const = req.header("Kebenaran")?.split(" ")[1];

jika (!token) mengembalikan res.status(403).json({ mesej: "Akses ditolak" });

cuba {
const dinyahkod = jwt.verify(token, "SECRET_KEY");
req.user = dinyahkod;
seterusnya();
} tangkap (err) {
res.status(401).json({ mesej: "Token tidak sah" });
}
};

kebenaran berterusan = (peranan) => {
return (req, res, next) => {
jika (!roles.includes(req.user.role)) {
kembalikan res.status(403).json({ mesej: "Dilarang" });
}
seterusnya();
};
};

module.exports = { sahkan, benarkan };
? sahkan – Memastikan hanya pengguna yang log masuk boleh mengakses laluan.
? membenarkan – Mengehadkan akses berdasarkan peranan.

4️⃣ Melindungi Laluan Berdasarkan Peranan Pengguna
Dalam route/admin.routes.js:

javascript
Salin kod
const express = require("express");
const { authenticate, authorize } = require("../middlewares/auth.middleware");

penghala const = express.Router();

router.get("/admin-dashboard", sahkan, benarkan(["admin"]), (req, res) => {
res.json({ mesej: "Selamat Datang ke Papan Pemuka Pentadbir" });
});

modul.eksport = penghala;
? Hanya pengguna yang mempunyai peranan pentadbir boleh mengakses /admin-dashboard.

5️⃣ Melaksanakan UI Berasaskan Peranan dalam React
Dalam App.js (Frontend):

javascript
Salin kod
import { useState, useEffect } daripada "react";
import axios daripada "axios";

const App = () => {
const [peranan, setRole] = useState(null);

useEffect(() => {
token const = localStorage.getItem("token");
jika (token) {
const dinyahkod = JSON.parse(atob(token.split(".")[1]));
setRole(decoded.role);
}
}, []);

kembali (

Selamat datang ke Pengesahan Berasaskan Peranan MERN

{peranan === "admin" && Papan Pemuka Pentadbir}
{peranan === "penjual" && Papan Pemuka Penjual}
{peranan === "pelanggan" && Papan Pemuka Pelanggan}

);
};

eksport Apl lalai;
? UI memaparkan papan pemuka yang berbeza berdasarkan peranan pengguna.

Kesimpulan
Pengesahan Berasaskan Peranan ialah langkah keselamatan penting dalam aplikasi web moden. Dengan melaksanakan RBAC dalam MERN Stack, anda boleh mengawal kebenaran pengguna dengan cekap.

? Langkah Seterusnya:
? Tambahkan panel pengurusan peranan untuk pentadbir.
? Laksanakan penyulitan pangkalan data untuk kata laluan.
? Gunakan Token Segar Semula untuk keselamatan yang lebih baik.

Ingin mengetahui lebih lanjut? Letakkan soalan anda dalam komen! ?

Atas ialah kandungan terperinci Pengesahan Berasaskan Peranan dalam Timbunan MERN: Panduan Lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!