Kem Intensif Pembangunan Backend Node.js · Pelajaran

Kawalan Akses Berasaskan Peranan

Bangunkan perisian tengah untuk kebenaran, dengan mengehadkan akses kepada laluan API berdasarkan peranan dan keizinan pengguna.

Pelajaran 5 daripada 611 langkah

Kawalan Akses Berasaskan Peranan ialah pelajaran Kem Intensif Pembangunan Backend Node.js percuma di CoddyKit. Ini ialah pelajaran 5 daripada 6. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Backend Node.js, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 6 pelajaran.

Pengenalan kepada Kawalan Akses Berasaskan Peranan

Selamat datang! Dalam pelajaran ini, kita akan mendalami Kawalan Akses Berasaskan Peranan (RBAC). RBAC ialah kaedah untuk mengehadkan akses sistem berdasarkan peranan yang dimiliki oleh pengguna dalam sesebuah organisasi.

Bayangkan RBAC seperti satu set kunci: setiap kunci (peranan) memberikan akses kepada pintu tertentu (sumber atau tindakan). Daripada memberikan setiap orang kunci untuk semua pintu, anda memberikan mereka satu rangkaian kunci berdasarkan tugas mereka.

Kepentingan RBAC

RBAC penting untuk membina aplikasi yang selamat dan boleh diskalakan. RBAC menawarkan beberapa manfaat:

Keselamatan Dipertingkat: Pengguna hanya mengakses perkara yang diperlukan.
Pengurusan Dipermudah: Kebenaran lebih mudah diurus untuk kumpulan berbanding individu.
Pengurangan Ralat: Kemungkinan memberikan akses yang salah menjadi lebih rendah.
Pematuhan Dipertingkat: Membantu memenuhi keperluan peraturan untuk akses data.

Tanpa RBAC, pengurusan kebenaran dalam aplikasi yang berkembang menjadi sangat rumit!

Peranan & Kebenaran Ditakrifkan

Adalah penting untuk memahami perbezaan antara peranan dan kebenaran:

Peranan: Himpunan kebenaran. Contoh: Admin, Editor, Viewer, Guest.
Kebenaran: Tindakan khusus yang boleh dilakukan oleh pengguna. Contoh: read:post, write:post, delete:user.

Pengguna diberikan satu atau lebih peranan, dan setiap peranan mempunyai set kebenaran yang ditakrifkan. Struktur ini menjadikan kawalan akses lebih fleksibel.

Cara Menyimpan Peranan Pengguna

Apabila pengguna mendaftar atau log masuk, peranan yang diberikan kepada mereka perlu disimpan. Cara biasa untuk melakukannya termasuk:

Medan Pangkalan Data: Rentetan (contohnya, "admin", "user") atau tatasusunan rentetan (contohnya, ["admin", "editor"]) dalam dokumen/rekod pengguna.
Muatan JWT: Sertakan peranan secara langsung dalam Token Web JSON (JWT) semasa log masuk. Dengan cara ini, peranan mudah dicapai pada setiap permintaan.

Untuk contoh kita, kita akan menganggap bahawa peranan tersedia pada objek req.user, yang akan diisi oleh perisian tengah pengesahan terdahulu (seperti perisian tengah daripada pelajaran sebelumnya).

Aliran Perisian Tengah Kebenaran

Dalam Express.js, fungsi perisian tengah amat sesuai untuk kebenaran. Perisian tengah kebenaran berada antara permintaan dan pengendali laluan.

Beginilah cara ia berfungsi:

Permintaan masuk untuk laluan yang dilindungi.
Perisian tengah kebenaran kita dijalankan.
Perisian tengah menyemak sama ada pengguna yang disahkan mempunyai peranan yang diperlukan.
Jika ya, perisian tengah memanggil next() untuk menyerahkan kawalan kepada pengendali laluan.
Jika tidak, perisian tengah menghantar tindak balas ralat (contohnya, 403 Forbidden).

Mentakrifkan Perisian Tengah Semakan Peranan

Kita akan mencipta fungsi perisian tengah boleh guna semula yang menyemak sama ada pengguna yang disahkan mempunyai peranan tertentu. Fungsi ini menerima requiredRole sebagai argumen dan mengembalikan fungsi perisian tengah yang lain.

Aplikasi sebenar perlu mempunyai perisian tengah pengesahan yang mengisi req.user terlebih dahulu.

function authorizeRoles(requiredRole) {
  return (req, res, next) => {
    // Assume req.user is populated by auth middleware
    // e.g., req.user = { id: 'abc', roles: ['user', 'editor'] }
    if (!req.user || !req.user.roles || !req.user.roles.includes(requiredRole)) {
      console.log(`Access Denied: Missing role '${requiredRole}'`);
      return res.status(403).send('Forbidden: Insufficient role');
    }
    console.log(`Access Granted for role '${requiredRole}'`);
    next(); // User has the required role, proceed
  };
}

// To make it runnable for demonstration, let's wrap it in a mock Express-like setup
const mockReq = { user: { id: '123', roles: ['user', 'admin'] } };
const mockRes = {
  status: function(code) { this.statusCode = code; return this; },
  send: function(msg) { console.log(`Response Status: ${this.statusCode}, Message: ${msg}`); }
};
const mockNext = () => console.log('Next middleware/route handler called.');

console.log('--- Testing authorizeRoles("admin") ---');
const adminAuth = authorizeRoles('admin');
adminAuth(mockReq, mockRes, mockNext);

console.log('\n--- Testing authorizeRoles("guest") ---');
const guestAuth = authorizeRoles('guest');
guestAuth(mockReq, mockRes, mockNext);

Melindungi Laluan dengan RBAC

Sekarang, mari lihat cara menggunakan perisian tengah authorizeRoles untuk melindungi laluan tertentu dalam aplikasi Express.js.

Kita boleh menghantar fungsi perisian tengah secara langsung kepada takrifan laluan. Sebarang permintaan ke laluan itu akan melalui semakan kebenaran terlebih dahulu.

const express = require('express');
const app = express();

// Mock authentication middleware (from previous lessons)
app.use((req, res, next) => {
  // In a real app, this would verify a JWT and populate req.user
  req.user = { id: 'user123', roles: ['user', 'viewer'] };
  next();
});

// Our authorization middleware
function authorizeRoles(requiredRole) {
  return (req, res, next) => {
    if (!req.user || !req.user.roles.includes(requiredRole)) {
      return res.status(403).send('Forbidden: Insufficient role');
    }
    next();
  };
}

// Route accessible only by 'admin'
app.get('/admin-panel', authorizeRoles('admin'), (req, res) => {
  res.send('Welcome to the Admin Panel!');
});

// Route accessible by 'user' or 'viewer' (since req.user has 'user', 'viewer')
app.get('/my-profile', authorizeRoles('user'), (req, res) => {
  res.send(`Hello ${req.user.id}, this is your profile.`);
});

app.listen(3000, () => {
  console.log('Server running on port 3000. Try accessing /admin-panel or /my-profile');
});

Mengendalikan Berbilang Peranan yang Diperlukan

Kadangkala, sesuatu laluan boleh diakses oleh lebih daripada satu peranan (contohnya, Editor atau Admin). Kita boleh melanjutkan perisian tengah supaya menerima berbilang peranan yang diperlukan.

Pengguna hanya perlu mempunyai *sekurang-kurangnya satu* daripada peranan yang dinyatakan untuk mendapatkan akses.

const express = require('express');
const app = express();

// Mock authentication middleware
app.use((req, res, next) => {
  req.user = { id: 'editor456', roles: ['user', 'editor'] };
  next();
});

// Middleware to check for multiple roles
function authorizeAnyRole(requiredRoles) {
  return (req, res, next) => {
    if (!req.user || !req.user.roles) {
      return res.status(403).send('Forbidden: User roles not found');
    }
    const hasRequiredRole = req.user.roles.some(role =>
      requiredRoles.includes(role)
    );
    if (!hasRequiredRole) {
      return res.status(403).send('Forbidden: Insufficient role(s)');
    }
    next();
  };
}

// Route accessible by 'admin' OR 'editor'
app.get('/edit-content', authorizeAnyRole(['admin', 'editor']), (req, res) => {
  res.send('You can edit content!');
});

// Route accessible by 'admin' only
app.get('/delete-all', authorizeAnyRole(['admin']), (req, res) => {
  res.send('Danger Zone: All data deleted!');
});

app.listen(3000, () => {
  console.log('Server running on port 3000. Try /edit-content or /delete-all');
});

Melangkaui Peranan: Kebenaran Terperinci

Walaupun peranan amat berguna untuk mengumpulkan kebenaran, kadangkala anda memerlukan kawalan yang lebih terperinci. Di sinilah kebenaran khusus digunakan.

Daripada authorizeRoles('admin'), anda mungkin menggunakan authorizePermission('delete:user').
Objek pengguna anda kemudiannya akan menyimpan tatasusunan kebenaran khusus (contohnya, ['read:post', 'update:post', 'delete:comment']).

Pendekatan ini menawarkan fleksibiliti maksimum, tetapi boleh meningkatkan kerumitan dalam pengurusan kebenaran.

Uji Pemahaman Anda

Pertimbangkan persediaan laluan Express berikut:

// ... (assume authorizeRoles function is defined as in lesson)
app.use((req, res, next) => {
  req.user = { id: 'testUser', roles: ['user', 'moderator'] };
  next();
});

app.get('/moderate', authorizeRoles('moderator'), (req, res) => {
  res.send('Moderator access granted.');
});

app.get('/admin-only', authorizeRoles('admin'), (req, res) => {
  res.send('Admin access granted.');
});

Jawab dalam pelajaran interaktif

Ulang Kaji & Langkah Seterusnya

Syabas! Anda telah mempelajari cara melaksanakan Kawalan Akses Berasaskan Peranan dalam aplikasi Node.js menggunakan perisian tengah Express.js.

RBAC mengehadkan akses berdasarkan peranan pengguna.
Fungsi perisian tengah sesuai untuk menyemak peranan sebelum akses laluan.
Anda boleh menyemak satu peranan atau berbilang peranan.
Senario lanjutan mungkin melibatkan semakan kebenaran secara langsung.

Kebenaran yang betul ialah kunci untuk melindungi API anda. Teruskan berlatih untuk menguasai konsep ini!

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 92

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kawalan Akses Berasaskan Peranan” percuma?

Ya — teks penuh “Kawalan Akses Berasaskan Peranan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Kem Intensif Pembangunan Backend Node.js, tingkat taraf kepada CoddyKit PRO. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 6 pelajaran.

Apakah yang akan saya pelajari dalam “Kawalan Akses Berasaskan Peranan”?

Bangunkan perisian tengah untuk kebenaran, dengan mengehadkan akses kepada laluan API berdasarkan peranan dan keizinan pengguna. Anda berlatih Kem Intensif Pembangunan Backend Node.js menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Backend Node.js?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Backend Node.js di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 5 daripada 6.

Berapa lamakah pelajaran “Kawalan Akses Berasaskan Peranan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Backend Node.js ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Backend Node.js menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kem Intensif Pembangunan Backend Node.js