Pengenalan Redis Cache Menggunakan Docker Container

Menggunakan solusi caching sangat penting ketika kita sedang mengembangkan aplikasi berkinerja tinggi. Caching menggunakan penyimpanan sementara untuk menyimpan data dengan waktu kedaluwarsa, dan bekerja untuk data yang tidak sering berubah.

Ada tiga jenis cache:

In Memory Cache: Ini digunakan ketika kita ingin mengimplementasikan cache dalam satu proses. Cache mati setelah proses.
Persistence Cache: Dalam hal ini, data yang di-cache disimpan di luar memori proses, seperti sistem file atau di database seperti "Litedb". Jadi, dengan data ini dapat dipertahankan selama periode tertentu dan akan tersedia setelah proses selesai.
Cache Terdistribusi: Cache terdistribusi digunakan saat cache perlu dibagi dengan beberapa proses atau server. Biasanya, cache disimpan sebagai layanan eksternal dan pihak lain dapat menggunakannya. Redis adalah contoh cache terdistribusi.

Di sini kita akan membahas lebih lanjut tentang cache Redis, dan cara mengimplementasikan cache Redis menggunakan .Net dan docker.

Apa itu Redis?

Sesuai dokumentasi resmi,

Redis adalah penyimpanan struktur data dalam memori open source yang digunakan sebagai database, cache, perantara pesan, dan mesin streaming. Redis menyediakan struktur data seperti string, hash, daftar, set, set yang diurutkan dengan kueri rentang, bitmap, hyperloglog, indeks geospasial, dan aliran. Redis memiliki replikasi bawaan, pembuatan skrip Lua, penggusuran LRU, transaksi, dan tingkat persistensi on-disk yang berbeda, dan menyediakan ketersediaan tinggi melalui Redis Sentinel dan partisi otomatis dengan Redis Cluster.

Bagaimana cara menjalankan Redis dalam docker container?

Untuk menjalankan Redis dalam docker container, harap ikuti langkah-langkah yang disebutkan di bawah ini.

Cara 1: Unduh gambar Redis

Ini adalah perintah docker untuk mengunduh dan menggunakan Redis di lingkungan lokal.

docker pull redis

Perintah di atas digunakan untuk menarik image Redis dari docker hub. Setelah operasi ini, informasi gambar yang diunduh dapat dilihat dengan mengeksekusi perintah docker yang disebutkan di bawah.

docker image ls

Cara 2: Jalankan kontainer Redis

Gunakan perintah docker di bawah ini untuk menjalankan Redis dalam container.

docker run -d -p 6379:6379 --name local-redis  redis

Ini akan mengekspos port 6379 di lingkungan lokal Anda. Perintah docker untuk menampilkan informasi container adalah:

docker ps

Penyiapan awal selesai, penampung Redis sekarang aktif dan berjalan. Selanjutnya, kita dapat membuat project baru yang akan menggunakan container ini untuk operasi caching.

Pengaturan Proyek

Di sini kita dapat menggunakan API web sederhana untuk mendemonstrasikan cache Redis.

Pertama, buka visual studio dan buat aplikasi ASP.NET Core Web API baru. Beri nama proyek dan simpan.

Cara 1: Instal package Nuget yang diperlukan

Instal versi terbaru package SackExchangeRedis ke aplikasi untuk menghubungkan cache Redis.

Install-Package Microsoft.Extensions.Caching.StackExchangeRedis

Cara 2: Tambahkan layanan Redis ke koleksi layanan

Tambahkan layanan Redis ke koleksi layanan seperti yang ditampilkan di bawah ini:

builder.Services.AddStackExchangeRedisCache(options => { options.Configuration = builder.Configuration["RedisCacheUrl"]; });

AddStackExchangeRedisCache : Konfigurasi ini digunakan untuk menambahkan layanan caching terdistribusi Redis ke IServiceCollection yang ditentukan.

Konfigurasi RedisCacheUrl berisi informasi tentang host dan nomor port. Misalnya:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "RedisCacheUrl": "127.0.0.1:6379"
}

Dalam demo ini, kita dapat mengonfigurasi host sebagai 127.0.0.1 dan port sebagai 6379.

Cara 3: Implementasi Redis Cache menggunakan interface IDistributedCache

Sebagai langkah selanjutnya, kita dapat membuat kelas baru bernama RedisCacheService.cs dengan tipe IRedisCache.cs (interface). Layanan ini dapat digunakan untuk menangani semua operasi terkait cache.

Silakan temukan implementasinya di sini:

public interface IRedisCache
    {
        Task<byte[]?> Get(string key);
        Task<bool> Add(string key, string value);
    }

public class RedisCacheService : IRedisCache
    {
        private readonly IDistributedCache _cache;

        public RedisCacheService(IDistributedCache cache)
        {
            _cache = cache;
        }
        public async Task<bool> Add(string key, string value)
        {
            // Setting up the cache options
            DistributedCacheEntryOptions options = new DistributedCacheEntryOptions()
                .SetAbsoluteExpiration(DateTime.Now.AddMinutes(5))
                .SetSlidingExpiration(TimeSpan.FromMinutes(3));
            var dataToCache = Encoding.UTF8.GetBytes(value);
            await _cache.SetAsync(key, dataToCache, options);
            return true;
        }

        public async Task<byte[]?> Get(string key)
        {
            return await _cache.GetAsync(key);
        }
    }

interface IRedisCache bertindak sebagai pembungkus interface IDistributedCache. Langkah selanjutnya adalah menambahkan layanan yang baru dibuat ke IServiceCollection.

builder.Services.AddSingleton IRedisCache, RedisCacheService();
builder.Services.AddStackExchangeRedisCache(options => { options.Configuration =

Penggunaan AbsoluteExpirationRelativeToNow dan SlidingExpiration dijelaskan di bawah ini.

AbsoluteExpirationRelativeToNow: Data yang di-cache akan tetap berada di memori untuk waktu yang ditentukan, setelah itu entri akan dihapus dari cache. Pada dasarnya, ini akan menunjukkan waktu kedaluwarsa.

SlidingExpiration : sesuai dokumentasi Microsoft, Mendapat atau menetapkan berapa lama entri cache dapat tidak aktif (misalnya tidak diakses) sebelum dihapus. Ini tidak akan memperpanjang masa masuk melebihi batas waktu mutlak (jika ditetapkan). Misalnya, jika kita menyetel kedaluwarsa geser sebagai 60 menit dan kedaluwarsa absolut sebagai 24 jam. Jika data yang di-cache tidak diakses dalam waktu 60 menit maka item tersebut akan dihapus dari cache.

Bagaimana Cara Menguji?

Silakan ikuti langkah-langkah di bawah ini untuk memvalidasi implementasi cache.

Cara 1: Periksa container Redis sudah aktif dan berjalan

Cara 2: Tambahkan pengontrol API baru untuk membaca dan memperbarui data yang di-cache. Seperti yang ditunjukkan di bawah ini.

[ApiController]
    [Route("[controller]")]
    public class RedisController : ControllerBase
    {
        private readonly ILogger<RedisController> _logger;
        private readonly IRedisCache _cache;

        public RedisController(ILogger<RedisController> logger, IRedisCache rcache)
        {
            _logger = logger;
            _cache = rcache;
        }

        [HttpGet(Name = "GetCache")]
        public async Task<string?> GetCache(string key)
        {
            try
            {
                var byteData = await _cache.Get(key);
                if (byteData != null)
                    return Encoding.UTF8.GetString(byteData);
                return default;
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }

        [HttpPost(Name = "AddToCache")]
        public async Task<bool> AddToCache(string key,string val)
        {
            try
            {
                return await _cache.Add(key, val);
            }
            catch
            {
                return false;
            }
        }
    }

Cara 3: Jalankan aplikasi, dan uji penerapan Anda seperti yang ditampilkan di bawah ini:

Kesimpulan

Pada Artikel ini, kami baru saja membahas implementasi dasar cache Redis menggunakan .Net dan Docker.

Silakan bagikan saran dan ide Anda di kotak komentar. Selamat membuat kode!