Redis adalah : Panduan Pemula dan Caching dengan Node JS

Last Updated on March 24, 2022 by

Dalam beberapa tahun terakhir, Redis telah menjadi kejadian umum di tumpukan aplikasi Node.js. Meskipun kasus penggunaannya yang paling populer adalah caching, Redis merupakan kasus penggunaan lain di mana Anda dapat memanfaatkan database dalam memori yang sangat cepat.

Pada tutorial ini, kami akan memberi Anda pengantar singkat tentang Redis. Kami juga akan memperkenalkan redis adalah penggunaan yang membuat cache sederhana untuk aplikasi Node guna melihat bagaimana pengaruhnya terhadap kinerjanya.

Apa itu Redis?

Redis memiliki sumber terbuka, penyimpanan struktur data dalam memori yang digunakan sebagai database, cache, dan perantara pesan.

Anda dapat menganggapnya sebagai database tanpa SQL, yang menyimpan data sebagai pasangan nilai kunci di memori sistem. Redis juga mendukung penyimpanan data persisten disk, jika diperlukan.

Redis memiliki dukungan untuk menyimpan beberapa struktur data dan tipe data, termasuk string, daftar, hash, set, dan set yang diurutkan. Struktur data yang didukung memberi Redis fleksibilitas untuk banyak kasus penggunaan.

Redis paling baik dalam situasi yang membutuhkan data untuk diambil dan dikirim ke klien dalam waktu yang paling singkat.

Kasus penggunaan Redis

Redis untuk penyimpanan dalam cache

Salah satu kasus penggunaan paling popular Redis adalah penyimpanan cache.

Apa itu caching?

Caching adalah proses menyimpan salinan data dalam cache untuk memungkinkan aplikasi mengakses dan mengambil data lebih cepat. Tujuan dari caching adalah mempercepat operasi akses data lebih baik daripada database, atau server jarak jauh dapat mengizinkan terutama berlaku untuk operasi yang mahal (dalam waktu).

Sebagai pengembang back-end, tugas kita adalah menyelesaikan permintaan klien secepat mungkin. Terkadang, kueri memerlukan beberapa operasi seperti mengambil data dari database, melakukan penghitungan, mengambil data tambahan dari layanan lain dll.

Di sinilah keunggulan caching karena dapat memproses data sekali, menyimpannya di cache dan kemudian mengambilnya kembali langsung dari cache tanpa melakukan semua operasi yang mahal.

Caching & Redis

Karena Redis adalah database dalam memori, operasi akses datanya lebih cepat daripada yang dapat diberikan oleh database terikat disk lainnya. Itu menjadikan Redis adalah pilihan yang sempurna untuk penyimpanan dalam cache.

Dalam tutorial ini, kita akan melihat bagaimana melakukan caching dengan Redis dan Node.js.

Redis untuk analitik waktu nyata

Redis menjanjikan operasi pemrosesan data berdurasi sub-milidetik. Itu menjadikan Redis kandidat yang sempurna untuk aplikasi yang mengandalkan analisis data waktu nyata.

Misalnya, Anda dapat menggunakan Redis untuk menyimpan identitas pengguna dan detail transaksi mereka saat menerapkan layanan deteksi penipuan waktu nyata.

Redis bahkan menyediakan sistem penilaian transaksi lebih cepat yang didukung AI dan model statistik yang lebih cepat untuk melakukan kasus penggunaan ini dengan lebih baik.

Kasus penggunaan lain dalam analitik waktu nyata mencakup sistem manajemen inventaris waktu nyata dan papan peringkat game.

Redis untuk manajemen sesi

Jika aplikasi Anda menggunakan sesi untuk melacak pengguna yang diautentikasi dan mengelola data khusus pengguna, Redis sangat cocok untuk digunakan sebagai penyimpanan sesi.

Menggunakan Redis dapat secara signifikan meningkatkan kinerja sistem sekaligus membuatnya lebih mudah untuk memproses data pengguna, termasuk kredensial, aktivitas terkini, dan bahkan sistem seperti keranjang belanja.

Redis sebagai Antrian

Anda dapat menggunakan Redis untuk mengantre tugas aplikasi yang membutuhkan waktu lama untuk diselesaikan. Anda dapat mengimplementasikan antrian FIDO (first-in, first-out) atau membuat antrian tertunda untuk menunda implementasi tugas hingga waktu yang telah dijadwalkan sebelumnya.

Caching dengan Node dan Redis

Sekarang, mari kita mulai dengan fokus utama dari tutorial ini: menggunakan Redis adalah untuk caching dalam aplikasi NodeJS.

Proses caching dengan Redis cukup sederhana. Saat kami menerima permintaan pengguna ke rute yang cache-nya diaktifkan, pertama-tama kami memeriksa apakah data yang diminta sudah disimpan di cache. Jika ya, kami dapat dengan cepat mengambil data dari Redis dan mengirimkan tanggapan.

Namun, jika data tidak disimpan di cache, yang kita sebut cache miss, pertama-tama kita harus mengambil data dari database atau API eksternal dan mengirimkannya ke klien.

Kami juga memastikan untuk menyimpan data yang diambil dalam cache sehingga saat berikutnya permintaan yang sama diterima, kami dapat dengan mudah mengirim data cache ke pengguna lebih cepat.

Sekarang setelah Anda memiliki gagasan yang jelas tentang apa yang akan kita lakukan, mari kita mulai penerapannya.

Pasang Redis

Jika Anda belum melakukannya, Anda perlu menginstal Redis untuk tutorial ini.

Anda dapat mengunduh binari dan mengkompilasinya dengan mudah menggunakan perintah berikut.

wget https://download.redis.io/releases/redis-6.0.9.tar.gz
tar xzf redis-6.0.9.tar.gz
cd redis-6.0.9
make
make install

Untuk memastikan bahwa server Redis berjalan tanpa masalah, kirim ping ke server menggunakan redis-cli.

redis-cli ping

Jika Anda menerima ping sebagai tanggapan, server Redis berjalan dengan sukses.

Bangun aplikasi NodeJS

Pengaturan dasar

Siapkan boilerplate awal untuk aplikasi Node seperti ini.

const express = require("express");
const axios = require("axios");
const redis = require("redis");
const app = express();

app.listen(process.env.PORT || 3000, () => {
console.log(“Node server started”);
});

Perhatikan bagaimana tutorial ini menggunakan dua paket tambahan bernama axios dan redis. Redis adalah klien Redis standar untuk Node. Tutorial ini menggunakan axios untuk mengambil data dari API eksternal untuk tutorial ini.

Sebelum melanjutkan, pastikan untuk menginstal kedua paket tersebut menggunakan npm.

npm install axios redis –save

Ambil data dari API eksternal

Tutorial ini akan menggunakan GitHub Jobs API untuk mendapatkan data terkait pekerjaan pemrograman yang tersedia di berbagai lokasi di dunia.

Anda dapat meneruskan istilah pencarian yang terkait dengan pekerjaan yang Anda cari ke API dan mengambil larik pekerjaan yang tersedia dalam format json. Contoh permintaan ke API terlihat seperti ini.

https://jobs.github.com/positions.json?search=node.js

Dalam aplikasi Node ini, kami mendefinisikan rute bernama /jobs, yang mengambil data pekerjaan dari API di atas dan mengirimkannya kembali ke klien.

const express = require("express");
const axios = require("axios");
const redis = require("redis");
const app = express();
app.get("/jobs", async (req, res) => {
const searchTerm = req.query.search;
try {
const jobs = await axios.get(`https://jobs.github.com/positions.json?search=${searchTerm}`);
res.status(200).send({
jobs: jobs.data,
});
} catch(err) {
res.status(500).send({message: err.message});
}
});
app.listen(process.env.PORT || 3000, () => {
console.log("Node server started");
});

Di sini, tutorial ini menggunakan axios untuk mengirim permintaan GET ke GitHub Jobs API dengan istilah pencarian yang disediakan pengguna.

Mari kita lihat bagaimana rute bekerja sekarang menggunakan Postman.

Menyimpan hasil

Sekarang, mari kita lihat bagaimana kita dapat meningkatkan kinerja aplikasi dengan caching.

Pertama, kita perlu terhubung ke server Redis melalui aplikasi kita. Kami menggunakan paket redis yang diinstal untuk tugas ini.

const redisPort = 6379
const client = redis.createClient(redisPort);
//log error to the console if any occurs
client.on("error", (err) => {
console.log(err);
});

Server Redis adalah mendengarkan port 6379 secara default. Jadi, kami meneruskan nomor port untuk terhubung ke Redis dan membuat klien. Lalu buat logika untuk menyimpan dan mengambil data dari cache.

app.get("/jobs", (req, res) => {
const searchTerm = req.query.search;
try {
client.get(searchTerm, async (err, jobs) => {
if (err) throw err;
if (jobs) {
res.status(200).send({
jobs: JSON.parse(jobs),
message: "data retrieved from the cache"
});
} else {
const jobs = await axios.get(`https://jobs.github.com/positions.json?search=${searchTerm}`);
client.setex(searchTerm, 600, JSON.stringify(jobs.data));
res.status(200).send({
jobs: jobs.data,
message: "cache miss"
});
}
});
} catch(err) {
res.status(500).send({message: err.message});
}
});

Apa yang terjadi di sini?

Ketika kami menerima permintaan klien ke rute / pekerjaan, pertama, kami mendapatkan istilah pencarian dikirim dengan parameter kueri permintaan.

const searchTerm = req.query.search;

Kemudian, cobalah mengambil data yang diminta dari cache dengan meneruskan istilah pencarian, yang kami gunakan sebagai kunci saat menyimpan data di cache.  Paket Redis tidak memiliki dukungan asli untuk promise, jadi harus meneruskan callback untuk memproses data yang diambil.

client.get(searchTerm, async (err, jobs) => {
if (err) throw err;
});

Jika nilai yang dikembalikan dari Redis bukan null, itu berarti data terkait ada di cache, jadi mudah untuk mengembalikan data tersebut dalam respons. Pastikan Anda mengembalikan string ke JSON.

if (jobs) {
res.status(200).send({
jobs: JSON.parse(jobs),
message: "data retrieved from the cache"
});
}

Jika nilai yang dikembalikan adalah null, kita harus mengirim permintaan ke API eksternal untuk mengambil data yang relevan.

else {
const jobs = await axios.get(`https://jobs.github.com/positions.json?search=${searchTerm}`);
client.setex(searchTerm, 600, JSON.stringify(jobs.data));
res.status(200).send({
jobs: jobs.data,
message: "cache miss"
});
}

Ketika kami mendapatkan data dari API, sebelum mengirimnya kembali, kami menyimpannya di Redis sehingga saat permintaan yang sama dikirim ke server Node, ia dapat merespons dengan data yang disimpan di cache alih-alih memintanya dari API .

Perhatikan bagaimana kami menggunakan setex fungsi untuk menyimpan data di cache. Menggunakan setex fungsi secara khusus, alih-alih set fungsi reguler, kita dapat menyetel waktu kedaluwarsa ke pasangan nilai kunci yang disimpan. Karena kami menetapkan nilai untuk waktu kedaluwarsa, Redis akan secara otomatis menghapus pasangan nilai kunci itu dari cache saat waktu yang berlalu habis.

Kode sumber lengkap

const express = require("express");
const axios = require("axios");
const redis = require("redis");
const app = express();

const redisPort = 6379
const client = redis.createClient(redisPort);

client.on("error", (err) => {
console.log(err);
})

app.get("/jobs", (req, res) => {
const searchTerm = req.query.search;
try {
client.get(searchTerm, async (err, jobs) => {
if (err) throw err;
if (jobs) {
res.status(200).send({
jobs: JSON.parse(jobs),
message: "data retrieved from the cache"
});
}
else {
const jobs = await axios.get(`https://jobs.github.com/positions.json?search=${searchTerm}`);
client.setex(searchTerm, 600, JSON.stringify(jobs.data));
res.status(200).send({
jobs: jobs.data,
message: "cache miss"
});
}
});
} catch(err) {
res.status(500).send({message: err.message});
}
});
app.listen(process.env.PORT || 3000, () => {
console.log("Node server started");
});

Itu dia. Kami telah membuat cache sederhana untuk aplikasi kami. Itu tidak terlalu sulit, bukan?

Ringkasan

Dalam tutorial ini, kami memberi Anda pengenalan singkat tentang Redis dan membuat cache sederhana untuk aplikasi Node.js. Sekarang Anda dapat menggunakan Redis untuk menyimpan data yang sering ditanyakan di aplikasi Anda untuk mendapatkan peningkatan kinerja yang cukup besar.

Anda juga dapat melihat cara memanfaatkan fitur terbaik Redis dalam kasus penggunaan lain juga.

Terima kasih sudah membaca dan kunjungi terus situs Appkey.id dan nantikan informasi seputar IT setiap harinya!