Otentikasi pengguna adalah proses verifikasi identitas pengguna yang mencoba mendapatkan akses ke aplikasi Anda. Ini melibatkan otorisasi dan transfer kredensial untuk mengonfirmasi keaslian pengguna.
Anda dapat menerapkan model otentikasi pengguna sederhana di Node.js menggunakan Express, Bcrypt, dan MongoDB, hanya dalam beberapa langkah.
Langkah 1: Menyiapkan Lingkungan Pengembangan
Pertama, buat folder proyek dan CD ke dalamnya dengan menjalankan:
mkdir otentikasi pengguna
CD otentikasi pengguna
Selanjutnya, inisialisasi npm di direktori proyek Anda dengan menjalankan:
npm init -y
Itu -y flag menginisialisasi npm dan membuat Anda package.json file dengan semua default-nya.
Model otentikasi pengguna ini memerlukan beberapa dependensi.
Mereka termasuk:
- Cepat: Express adalah kerangka kerja Node.js yang menyediakan serangkaian fitur tangguh untuk aplikasi web dan seluler. Itu membuatnya lebih mudah untuk membangun aplikasi backend dengan Node.js.
- Bcrypt: bcrypt adalah paket npm yang mengimplementasikan fungsi hashing kata sandi bcrypt. Ini memungkinkan Anda untuk membuat hash dari string kata sandi biasa.
- Mongoose: Mongoose adalah perpustakaan pemodelan data objek MongoDB. Ini menyederhanakan interaksi antara aplikasi Anda dan database MongoDB.
- dotenv: dotenv adalah paket tanpa ketergantungan yang memuat variabel lingkungan dari a .env file ke dalam proses.env.
- Validator: validator adalah paket yang berisi berbagai fungsi validasi string.
- Body-parser: Paket body-parser mem-parsing badan permintaan di middleware sebelum penangan Anda.
Instal paket dengan menjalankan:
npm Install express bcrypt luwak dotenv validator tubuh-pengurai
Selanjutnya, buat app.js file di direktori root proyek Anda dan tambahkan blok kode di bawah ini untuk membuat server Express dasar:
// aplikasi.js
konstan ekspres = memerlukan('cepat');
konstan aplikasi = ekspres();
konstan bodyParser = memerlukan("pengurai-tubuh");konstan pelabuhan = 3000;
aplikasi.menggunakan(bodyParser.json());
aplikasi.menggunakan(bodyParser.urlencoded({ diperpanjang: BENAR }));
app.listen (port, ()=>{
menghibur.catatan(`Aplikasi mendengarkan di port ${pelabuhan}`);
});
Kode ini membuat instance aplikasi ekspres dengan memanggil fungsi ekspres. Ia kemudian menggunakan body-parser middleware untuk mengurai badan permintaan yang masuk. Kemudian mulai mendengarkan lalu lintas pada port 3000 dengan memanggil metode mendengarkan instance ekspres dan meneruskan variabel port sebagai argumen.
Langkah 2: Menghubungkan Aplikasi Anda ke Database
Di direktori root proyek Anda, buat .env file dan simpan kredensial MongoDB Anda di dalamnya. Ini menghindari mengekspos kredensial basis data Anda dalam kode yang dapat memberi pengguna jahat akses ke basis data Anda.
Selanjutnya, navigasikan ke app.js file dan impor luwak:
konstan luwak = memerlukan("luwak");
Kemudian, panggil impor dotenv dan panggil konfigurasi metode di atasnya:
memerlukan("dotenv").konfigurasi();
Memanggil konfigurasi metode aktif dotenv memuat variabel lingkungan ke dalam proses.env.
Terakhir, panggil metode connect on luwak dan berikan URI MongoDB Anda sebagai argumen:
luwak.connect (process.env. MONGODB_URI).lalu(() => {
konsol.log('Terhubung ke Basis Data Berhasil')
})
Langkah 3: Membuat Model Pengguna
Di direktori root proyek Anda, buat "modelfolder ”; di sinilah Anda akan menyimpan model luwak Anda:
model mkdir
Selanjutnya, buat “model pengguna” dan tambahkan impor berikut:
konstan luwak = memerlukan('luwak')
konstan { isEmail } = memerlukan('validator')
adalahEmail adalah fungsi validasi yang mengembalikan BENAR jika string yang diberikan adalah email. Anda akan membutuhkannya untuk menerapkan validasi luwak ke model pengguna Anda.
Selanjutnya, tambahkan kode berikut ke Anda model pengguna mengajukan:
// model/model pengguna
konstan userSchema = luwak. Skema({
surel: {
Tipe: Rangkaian,
diperlukan: [benar, 'Email diperlukan'],
memvalidasi: {
validator: isEmail,
pesan: alat peraga => `${props.value} bukan email yang valid`
}
},kata sandi: {
Tipe: Rangkaian,
diperlukan: [benar, 'katakunci dibutuhkan'],
memvalidasi: {
validator: fungsi (nilai) {
kembali nilai.panjang >= 6
},
pesan: () =>'Kata sandi harus setidaknya enam karakter'
}
}
})
modul.ekspor = luwak.model('Pengguna', skema pengguna)
Kode di atas membuat skema pengguna variabel yang menyimpan nilai luwak. Skema metode. luwak. Metode skema memetakan properti ke koleksi MongoDB dan mendefinisikan bentuk dokumen di dalamnya. Skema luwak memiliki dua sifat—dan surel dan kata sandi—yang akan menjadi persyaratan otentikasi Anda.
Properti email adalah tipe string dan memiliki yg dibutuhkan disetel ke benar. Pesan kesalahan yang menyertai, "Email diperlukan," akan ditampilkan jika badan permintaan tidak berisi surel Properti. Akhirnya, menggunakan validasi kustom luwak, validator referensi properti adalahEmail fungsi. Fungsi itu mengembalikan benar atau salah berdasarkan validitas string sebagai email. Kemudian properti pesan mengambil nilai email (Atribut) dan membuat pesan kesalahan yang berarti.
Properti kata sandi adalah tipe string yang diperlukan dengan pesan kesalahan yang berbunyi "Kata sandi diperlukan". Itu validator fungsi adalah salah satu anonim yang mengembalikan true jika kata sandi setidaknya enam karakter.
Baris terakhir membuat dan mengekspor model luwak dengan memanggil model metode aktif luwak. Lewati nama model (Pengguna) sebagai argumen pertama dan skema (skema pengguna) sebagai argumen kedua.
Langkah 4: Menerapkan Rute Masuk dan Pendaftaran
Di direktori root proyek Anda, buat rute map:
rute mkdir
Di folder rute Anda, buat penggunaRoutes.js file dan tambahkan impor berikut:
// route/userRoutes.js
konstan ekspres = memerlukan("cepat");
konstan Pengguna = memerlukan("../models/userModel");
konstan bcrypt = memerlukan("bcrypt");
Buat instance Express Router dengan memanggil Router metode aktif cepat:
konstan router = ekspres. Router();
Selanjutnya, buat rute pendaftaran Anda dengan menambahkan blok kode di bawah ini ke userRoute.js mengajukan:
router.post("/sign-up", asinkron (permintaan, res) => {
mencoba {
// Ekstrak email dan kata sandi dari objek req.body
konstan { email, kata sandi } = req.body;// Memeriksajika email adalah sudah dimenggunakan
membiarkan penggunaAda = menunggu Pengguna.temukanSatu({ email });jika (penggunaAda) {
res.status(401).json({ pesan: "Email sudah masuk menggunakan.&kutipan; });
kembali;
}// Tentukan putaran garam
konstan garam Putaran = 10;// hash kata sandi
bcrypt.hash (kata sandi, saltRounds, (err, hash) => {
jika (berbuat salah) melemparkanbaruKesalahan("Server Internal Kesalahan");// Membuat sebuah barupengguna
membiarkan pengguna = baru Pengguna({
surel,
kata sandi: hash,
});
// Simpan pengguna ke database
pengguna.simpan().lalu(() => {
res.json({ pesan: "Pengguna berhasil dibuat", pengguna });
});
});
} menangkap (salah) {
kembalires.status(401).Kirim(berbuat salah.pesan);
}
});
Di blok kode di atas, pertama-tama Anda de-struktur email dan kata sandi dari req.body obyek. Kemudian, periksa apakah pengguna sudah menggunakan email karena harus unik untuk setiap pengguna. Jika email telah digunakan, Anda kembali dan menghentikan eksekusi kode dengan kode status 401.
Menyimpan kata sandi biasa dalam database adalah ancaman keamanan yang sangat besar karena peretas jahat mungkin mendapatkan akses ke database. Anda harus meng-hash kata sandi sebelum menyortirnya di database Anda, jadi bahkan jika peretas menemukannya, tidak akan ada risiko bagi pengguna. Hashing adalah proses mengubah "kunci" yang diberikan menjadi nilai lain. Hashing adalah fungsi satu arah, yang berarti Anda tidak dapat mengambil nilai asli dari yang di-hash, tidak seperti enkripsi.
Menggunakan bcrypt, Anda melakukan hash kata sandi pengguna Anda dengan memanggil metode hash di bcrypt. Metode hash membutuhkan tiga parameter: string yang akan di-hash, salt round, dan fungsi callback. Anda melewati kata sandi pengguna, variabel saltRounds yang Anda buat sebelumnya, dan panggilan balik.
Putaran garam mengacu pada waktu yang dibutuhkan untuk menghitung hash bcrypt tunggal. Semakin tinggi putaran garam, semakin banyak putaran hashing.
Jika metode hash memunculkan kesalahan, Anda melempar "kesalahan server internal." Jika tidak, Anda mengatur properti kata sandi ke hash yang berhasil dan menyimpannya ke database Anda dengan memanggil metode simpan di Pengguna contoh.
Selanjutnya, buat rute masuk Anda dengan menambahkan blok kode di bawah ini ke userRoute.js mengajukan:
router.post("/sign-in", asinkron (permintaan, res) => {
mencoba {
// Ekstrak email dan kata sandi dari objek req.body
konstan { email, kata sandi } = req.body;// Memeriksajikapenggunaadadibasis data
membiarkan pengguna = menunggu Pengguna.temukanSatu({ email });jika (!pengguna) {
kembali res.status (401).json({ pesan: "Kredensial tidak valid" });
}// Bandingkan kata sandi
bcrypt.compare (password, user.password, (err, result) => {
jika (hasil) {
kembali res.status (200).json({ pesan: "Pengguna Berhasil Masuk" });
}menghibur.log (err);
kembali res.status (401).json({ pesan: "Kredensial tidak valid" });
});
} menangkap (kesalahan) {
res.status(401).Kirim(berbuat salah.pesan);
}
});
modul.ekspor = ruter;
Di blok kode di atas, pertama-tama, Anda de-struktur email dan kata sandi dari req.body obyek. Kemudian, Anda memeriksa apakah ada pengguna di database Anda. Jika pengguna tidak ada di database Anda, Anda kembali dengan kode status 401.
Selanjutnya, menggunakan metode perbandingan bcrypt, berikan kata sandi yang diberikan pengguna dan kata sandi hash yang Anda ambil dari database Anda. Bandingkan keduanya untuk mengonfirmasi apakah keduanya cocok. Jika kata sandi cocok, Anda mengembalikan kode status 200 dan pesan sukses. Jika tidak, Anda mengembalikan kode status 401 dan pesan kesalahan.
Akhirnya, impor router ke dalam kamu app.js file dan menggunakannya sebagai middleware tingkat aplikasi.
Ini melengkapi model otentikasi pengguna Anda; sekarang, pengguna dapat mendaftar dan masuk ke aplikasi Anda dengan aman.
Pentingnya Otentikasi Pengguna
Otentikasi pengguna memastikan bahwa hanya pengguna yang sah yang dapat memperoleh akses ke aplikasi Anda. Jika data Anda bersifat pribadi atau pribadi, Anda harus mengambil langkah-langkah untuk mencegah pengguna yang tidak diautentikasi mendapatkan akses.
