Cari tahu bagaimana menggabungkan teknologi ini dengan demonstrasi praktis.
Kontrol akses berbasis peran adalah mekanisme otentikasi yang aman. Anda dapat menggunakannya untuk membatasi akses ke sumber daya tertentu untuk pengguna yang memiliki peran tertentu.
Jenis autentikasi ini membantu administrator sistem mengontrol izin sesuai dengan peran yang ditentukan pengguna. Tingkat kontrol terperinci ini menambah lapisan keamanan, memungkinkan aplikasi mencegah akses tidak sah.
Menerapkan Mekanisme Kontrol Akses Berbasis Peran Menggunakan Passport.js dan JWTs
Kontrol akses berbasis peran (RBAC) adalah mekanisme populer yang digunakan untuk memberlakukan pembatasan akses dalam aplikasi berdasarkan peran dan izin pengguna. Ada berbagai metode yang tersedia untuk mengimplementasikan mekanisme RBAC.
Dua pendekatan populer termasuk menggunakan perpustakaan RBAC khusus seperti AccessControl atau memanfaatkan perpustakaan autentikasi yang ada untuk mengimplementasikan mekanisme.
Dalam hal ini, Token Web JSON (JWT) menyediakan cara yang aman untuk mengirimkan kredensial autentikasi, sementara Passport.js menyederhanakan proses autentikasi dengan menyediakan autentikasi yang fleksibel middleware.
Dengan menggunakan pendekatan ini, Anda dapat menetapkan peran kepada pengguna dan menyandikannya di JWT saat diautentikasi. Anda kemudian dapat menggunakan JWT untuk memverifikasi identitas dan peran pengguna dalam permintaan berikutnya, memungkinkan otorisasi berbasis peran dan kontrol akses.
Kedua pendekatan tersebut memiliki kelebihan dan dapat efektif dalam mengimplementasikan RBAC. Pilihan antara metode mana yang akan diterapkan akan bergantung pada persyaratan khusus proyek Anda.
Anda dapat mengunduh kode proyek ini dari file repositori GitHub.
Menyiapkan Proyek Express.js
Untuk memulai, menyiapkan proyek Express.js secara lokal. Setelah Anda mengatur proyek, lanjutkan, dan instal paket-paket ini:
npm install cors dotenv mongoose cookie-parser jsonwebtoken mongodb \
paspor paspor-lokalBerikutnya, membuat database MongoDB atau menyiapkan klaster di MongoDB Atlas. Salin URI koneksi database dan tambahkan ke a .env file di direktori root proyek Anda dari proyek Anda:
CONNECTION_URI="koneksi URI"Konfigurasi Koneksi Database
Di direktori root, buat yang baru utils/db.js file, dan tambahkan kode di bawah ini untuk membuat koneksi ke klaster MongoDB yang berjalan di Atlas menggunakan Mongoose.
const luwak = memerlukan('luwak');const connectDB = asinkron () => {
mencoba {
menunggu mongoose.connect (process.env. CONNECTION_URI);
menghibur.catatan("Terhubung ke MongoDB!");
} menangkap (kesalahan) {
menghibur.kesalahan("Kesalahan menghubungkan ke MongoDB:", kesalahan);
}
};
modul.ekspor = connectDB;
Tentukan Model Data
Di direktori root, buat yang baru model/pengguna.model.js file, dan tambahkan kode berikut untuk menentukan model data untuk data pengguna menggunakan Mongoose.
const luwak = memerlukan('luwak');const userSchema = baru luwak. Skema({
nama belakang: Rangkaian,
kata sandi: Rangkaian,
peran: Rangkaian
});
modul.ekspor = luwak.model('Pengguna', skema pengguna);
Buat Pengontrol untuk Titik Akhir API
Buat yang baru controllers/user.controller.js file di direktori root dan tambahkan kode di bawah ini.
Pertama, buat impor ini:
const Pengguna = memerlukan('../model/pengguna.model');
const paspor = memerlukan('paspor');
const { generateToken } = memerlukan('../middleware/auth');
memerlukan('../middleware/paspor')(paspor);Selanjutnya, tentukan logika untuk mengelola pendaftaran pengguna dan fungsi login:
ekspor.registerUser = asinkron (req, res) => {
const { nama pengguna, kata sandi, peran } = req.body;mencoba {
menunggu Pengguna.buat({ nama pengguna, kata sandi, peran });
res.status(201).json({ pesan: 'Pengguna berhasil terdaftar' });
} menangkap (kesalahan) {
menghibur.log (kesalahan);
res.status(500).json({ pesan: 'Terjadi kesalahan!' });
}
};export.loginUser = (req, res, selanjutnya) => {
paspor.otentikasi('lokal', { sidang: PALSU }, (err, pengguna, info) => {
jika (salah) {
menghibur.log (salah);kembali res.status(500).json({
pesan: 'Terjadi kesalahan saat masuk'
});
}jika (!pengguna) {
kembali res.status(401).json({
pesan: 'Kredensial masuk tidak valid'
});
}req.login (pengguna, { sidang: PALSU }, (salah) => {
jika (salah) {
menghibur.log (salah);kembali res.status(500).json({
pesan: 'Terjadi kesalahan saat masuk'
});
}
const { _id, nama pengguna, peran } = pengguna;
const muatan = { identitas pengguna: _id, nama pengguna, peran };
const token = generateToken (muatan);
res.cookie('token', token, { httpOnly: BENAR });
kembali res.status(200).json({ pesan: 'Login berhasil' });
});
})(req, res, selanjutnya);
};
Itu registerUser function menangani pendaftaran pengguna baru dengan mengekstrak nama pengguna, kata sandi, dan peran dari badan permintaan. Itu kemudian membuat entri pengguna baru di database dan merespons dengan pesan sukses atau kesalahan jika ada yang terjadi selama proses.
Di sisi lain, loginUser fungsi memfasilitasi login pengguna dengan memanfaatkan strategi otentikasi lokal yang disediakan oleh Passport.js. Ini mengotentikasi kredensial pengguna dan mengembalikan token setelah login berhasil yang kemudian disimpan dalam cookie untuk permintaan selanjutnya yang diautentikasi. Jika ada kesalahan yang terjadi selama proses login, itu akan mengembalikan pesan yang sesuai.
Terakhir, tambahkan kode yang mengimplementasikan logika pengambilan semua data pengguna dari database. Kami akan menggunakan titik akhir ini sebagai rute terbatas untuk memastikan bahwa hanya pengguna resmi dengan peran admin dapat mengakses titik akhir ini.
ekspor.getUsers = asinkron (req, res) => {
mencoba {
const pengguna = menunggu Pengguna.temukan({});
res.json (pengguna);
} menangkap (kesalahan) {
menghibur.log (kesalahan);
res.status(500).json({ pesan: 'Terjadi kesalahan!' });
}
};Siapkan Strategi Otentikasi Lokal Passport.js
Untuk mengautentikasi pengguna setelah mereka memberikan kredensial login, Anda perlu menyiapkan strategi autentikasi lokal.
Buat yang baru middleware/passport.js file di direktori root dan tambahkan kode berikut.
const Strategi Lokal = memerlukan('paspor-lokal').Strategi;
const Pengguna = memerlukan('../model/pengguna.model');modul.ekspor = (paspor) => {
penggunaan paspor(
baru Strategi Lokal(asinkron (nama pengguna, kata sandi, selesai) => {
mencoba {
const pengguna = menunggu Pengguna.findOne({ nama pengguna });jika (!pengguna) {
kembali Selesai(batal, PALSU);
}jika (pengguna.kata sandi !== kata sandi) {
kembali Selesai(batal, PALSU);
}
kembali Selesai(batal, pengguna);
} menangkap (kesalahan) {
kembali selesai (kesalahan);
}
})
);
};
Kode ini mendefinisikan strategi passport.js lokal untuk mengautentikasi pengguna berdasarkan nama pengguna dan kata sandi yang diberikan.
Pada awalnya, ia menanyakan database untuk menemukan pengguna dengan nama pengguna yang cocok dan kemudian melanjutkan untuk memvalidasi kata sandi mereka. Akibatnya, ia mengembalikan objek pengguna yang diautentikasi jika proses login berhasil.
Buat Middleware Verifikasi JWT
Di dalam middleware direktori, buat file auth.js baru, dan tambahkan kode berikut untuk menentukan middleware yang menghasilkan dan memverifikasi JWT.
const jwt = memerlukan('jsonwebtoken');
const secretKey = process.env. KUNCI RAHASIA;const generateToken = (muatan) => {
const token = jwt.tanda (muatan, secretKey, { kadaluarsa dalam: '1 jam' });
kembali token;
};const verifikasiToken = (peran yang dibutuhkan) =>(req, res, selanjutnya) => {
const token = req.cookies.token;jika (!token) {
kembali res.status(401).json({ pesan: 'Tidak ada token yang disediakan' });
}jwt.verify (token, secretKey, (err, decode) => {
jika (salah) {
kembali res.status(401).json({ pesan: 'Token tidak valid' });
}req.userId = decode.userId;
jika (decoded.role !== requiredRole) {
kembali res.status(403).json({
pesan: 'Anda tidak memiliki otorisasi dan izin untuk mengakses sumber daya ini.'
});
}Berikutnya();
});
};
modul.ekspor = { generateToken, verifikasiToken };
Itu generateToken fungsi membuat JWT dengan waktu kedaluwarsa yang ditentukan, sedangkan verifikasiToken fungsi memeriksa apakah token ada dan valid. Selain itu, ini juga memverifikasi bahwa token yang didekode berisi peran yang diperlukan, pada dasarnya, memastikan bahwa hanya pengguna dengan peran dan izin resmi yang memiliki akses.
Untuk menandatangani JWT secara unik, Anda perlu membuat kunci rahasia unik dan menambahkannya ke .env berkas seperti yang ditunjukkan di bawah ini.
SECRET_KEY="Ini adalah contoh kunci rahasia."Tentukan Rute API
Di direktori root, buat folder baru dan beri nama rute. Di dalam folder ini, buat yang baru userRoutes.js, dan tambahkan kode berikut.
const mengungkapkan = memerlukan('cepat');
const router = ekspres. Perute();
const userController = memerlukan('../controllers/userController');
const {verifikasiToken} = memerlukan('../middleware/auth');router.post('/api/daftar', userControllers.registerUser);
router.post('/api/masuk', userControllers.loginUser);router.dapatkan('/api/pengguna', verifikasiToken('admin'), userControllers.getUsers);
modul.ekspor = perute;
Kode ini menentukan rute HTTP untuk REST API. Itu pengguna rute khusus, server sebagai rute yang dilindungi. Dengan membatasi akses ke pengguna dengan admin peran, Anda secara efektif menerapkan kontrol akses berbasis peran.
Perbarui File Server Utama
Bukalah server.js file dan perbarui sebagai berikut:
const mengungkapkan = memerlukan('cepat');
const kor = memerlukan('kor');
const cookieParser = memerlukan('pengurai kue');
const aplikasi = ekspres();
const pelabuhan = 5000;
memerlukan('dotenv'.config();
const connectDB = memerlukan('./utils/db');
const paspor = memerlukan('paspor');
memerlukan('./middleware/paspor')(paspor);connectDB();
app.use (express.json());
app.use (express.urlencoded({ diperpanjang: BENAR }));
app.use (cors());
app.use (cookieParser());
app.use (passport.initialize());const rute pengguna = memerlukan('./routes/userRoutes');
aplikasi.penggunaan('/', rute pengguna);
app.listen (port, () => {
menghibur.catatan(`Server berjalan di port ${port}`);
});
Terakhir, mulai server pengembangan untuk menjalankan aplikasi.
simpul server.jsManfaatkan Mekanisme RBAC untuk Meningkatkan Sistem Otentikasi Anda
Menerapkan kontrol akses berbasis peran adalah cara yang efektif untuk meningkatkan keamanan aplikasi Anda.
Sementara menggabungkan perpustakaan autentikasi yang ada untuk membuat sistem RBAC yang efisien adalah pendekatan yang bagus, memanfaatkan perpustakaan RBAC untuk secara eksplisit menentukan peran pengguna dan memberikan izin memberikan solusi yang lebih kuat, pada akhirnya, meningkatkan keamanan Anda secara keseluruhan aplikasi.
