Eko Sudarmaji

Laravel Cache dengan Redis: Panduan Praktis untuk Pemula

Apa Itu Laravel Cache dengan Redis?

Laravel Cache dengan Redis adalah kombinasi yang banyak digunakan untuk menyimpan data sementara di memory sehingga aplikasi Laravel dapat mengakses data yang sering digunakan dengan lebih cepat.

Tanpa cache, aplikasi mungkin menjalankan query database berulang kali:

$products = Product::latest()->get();

Jika query tersebut dijalankan pada setiap request, database harus terus memproses permintaan yang sama.

Dengan Redis sebagai cache backend, kita dapat menyimpan hasil query:

$products = Cache::remember(
    'products:latest',
    600,
    fn () => Product::latest()->get()
);

Pada request pertama, Laravel mengambil data dari database dan menyimpannya ke Redis.

Request berikutnya dapat mengambil data dari Redis selama cache masih tersedia.

Secara sederhana:

Request
   ↓
Laravel
   ↓
Redis Cache
   │
   ├── Cache HIT → Return Data
   │
   └── Cache MISS
          ↓
      Database
          ↓
      Simpan ke Redis
          ↓
      Return Data

Pendekatan ini dapat membantu mengurangi beban database dan meningkatkan response time aplikasi.

Kenapa Menggunakan Redis untuk Laravel Cache?

Laravel mendukung beberapa cache store, seperti file, database, Redis, dan backend lainnya tergantung versi serta konfigurasi aplikasi.

Redis memiliki kelebihan karena data utamanya disimpan di memory.

Beberapa alasan Redis sering digunakan untuk cache Laravel:

  • Akses data sangat cepat
  • Cocok untuk data yang sering dibaca
  • Mendukung TTL atau expiration
  • Dapat digunakan untuk aplikasi dengan beberapa server
  • Dapat digunakan Laravel untuk kebutuhan lain seperti queue dan session
  • Cocok untuk aplikasi dengan traffic tinggi

Namun, Redis bukan solusi untuk semua masalah performa.

Jika query database lambat karena tidak memiliki index yang tepat, mengganti cache driver menjadi Redis tidak otomatis memperbaiki query tersebut.

Redis sebaiknya digunakan sebagai bagian dari strategi optimasi aplikasi.

Laravel Cache vs Redis

Ada satu konsep yang perlu dipahami sejak awal.

Laravel Cache adalah API atau abstraction yang digunakan aplikasi.

Sedangkan Redis adalah salah satu backend atau cache store yang dapat digunakan untuk menyimpan data tersebut.

Contohnya:

use Illuminate\Support\Facades\Cache;

$data = Cache::remember(
    'products',
    600,
    fn () => Product::latest()->get()
);

Kode tersebut menggunakan API Laravel Cache.

Jika konfigurasi cache Laravel diarahkan ke Redis, data cache tersebut akan disimpan menggunakan Redis.

Jadi aplikasi tidak harus berinteraksi langsung dengan Redis untuk kebutuhan cache sederhana.

Arsitektur Laravel Cache dengan Redis

Secara sederhana, arsitekturnya seperti ini:

                  ┌──────────────┐
                  │    Client    │
                  └──────┬───────┘
                         │
                         ↓
                  ┌──────────────┐
                  │    Laravel   │
                  └──────┬───────┘
                         │
                Cek Cache Redis
                         │
               ┌─────────┴─────────┐
               │                   │
            HIT│                   │MISS
               ↓                   ↓
         ┌───────────┐       ┌───────────┐
         │   Redis   │       │  Database │
         └─────┬─────┘       └─────┬─────┘
               │                   │
               │             Simpan ke Redis
               │                   │
               └─────────┬─────────┘
                         ↓
                      Response

Pada kondisi cache hit, aplikasi tidak perlu mengambil data dari database.

Pada cache miss, Laravel mengambil data dari database kemudian menyimpannya ke Redis.

Persiapan Sebelum Menggunakan Redis

Sebelum menghubungkan Laravel ke Redis, kita membutuhkan:

  • Aplikasi Laravel
  • PHP dan Composer
  • Redis Server
  • Extension atau client Redis yang sesuai
  • Akses terminal jika menggunakan Ubuntu VPS

Jika Laravel dijalankan di Ubuntu, Redis dapat dipasang melalui package manager.

Cara Install Redis di Ubuntu

Pada Ubuntu, update package terlebih dahulu:

sudo apt update

Kemudian install Redis:

sudo apt install redis-server

Setelah selesai, cek status Redis:

sudo systemctl status redis-server

Jika Redis berjalan, status service akan menunjukkan kondisi aktif.

Kita juga dapat menguji Redis menggunakan:

redis-cli ping

Jika Redis berjalan dengan baik, hasilnya:

PONG

Jika mendapatkan PONG, Redis sudah dapat menerima koneksi dari Redis CLI.

Mengecek Versi Redis

Untuk mengetahui versi Redis:

redis-server --version

Contoh output dapat terlihat seperti:

Redis server v=7.x.x

Versi yang ditampilkan tentu bergantung pada repository dan versi Ubuntu yang digunakan.

Memastikan Redis Berjalan Setelah Reboot

Pada server production, Redis sebaiknya dijalankan sebagai service.

Cek apakah Redis aktif saat boot:

sudo systemctl is-enabled redis-server

Jika diperlukan, aktifkan:

sudo systemctl enable redis-server

Kemudian jalankan:

sudo systemctl start redis-server

Jika Redis sudah aktif, tidak perlu menjalankan start berulang kali.

Menguji Redis Secara Manual

Sebelum menghubungkan Redis ke Laravel, kita dapat menguji Redis secara langsung.

Masuk ke Redis CLI:

redis-cli

Kemudian:

SET test "Hello Redis"

Ambil kembali nilainya:

GET test

Hasil:

"Hello Redis"

Untuk menghapus key:

DEL test

Keluar dari Redis CLI:

exit

Tes sederhana ini memastikan Redis Server dapat menyimpan dan mengambil data.

Konfigurasi Redis di Laravel

Setelah Redis berjalan, kita perlu mengatur Laravel agar menggunakan Redis sebagai cache store.

Pada .env, konfigurasi dapat menggunakan:

CACHE_STORE=redis

Namun, nama variable cache dapat berbeda berdasarkan versi Laravel.

Pada project Laravel tertentu, kamu mungkin menemukan:

CACHE_DRIVER=redis

Karena itu, sebelum mengubah .env, periksa:

config/cache.php

dan lihat environment variable yang digunakan oleh versi Laravel tersebut.

Konfigurasi Redis Host dan Port

Konfigurasi Redis Laravel biasanya membutuhkan informasi seperti:

REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

Port default Redis adalah:

6379

Jika Redis berjalan pada server yang sama dengan Laravel, 127.0.0.1 biasanya digunakan.

Jika Redis berada di server terpisah, gunakan hostname atau IP server Redis sesuai konfigurasi jaringan.

Jangan mengekspos port Redis ke internet tanpa konfigurasi keamanan yang tepat.

Redis sebaiknya hanya dapat diakses oleh server atau jaringan yang memang membutuhkannya.

Konfigurasi Redis Connection di Laravel

Laravel menyimpan konfigurasi Redis pada:

config/database.php

Secara umum terdapat konfigurasi seperti:

'redis' => [

    'client' => env('REDIS_CLIENT', 'phpredis'),

    'default' => [
        'host' => env('REDIS_HOST', '127.0.0.1'),
        'password' => env('REDIS_PASSWORD'),
        'port' => env('REDIS_PORT', 6379),
        'database' => env('REDIS_DB', 0),
    ],

],

Struktur konfigurasi dapat berbeda tergantung versi Laravel.

Untuk aplikasi baru, jangan menyalin konfigurasi secara membabi buta. Gunakan file konfigurasi bawaan project sebagai referensi.

PHPRedis vs Predis

Laravel dapat menggunakan Redis melalui beberapa client, salah satunya PHPRedis.

PHPRedis merupakan extension PHP yang menyediakan komunikasi dengan Redis.

Alternatif lainnya adalah Predis, yaitu client Redis berbasis PHP.

Jika menggunakan PHPRedis, pastikan extension tersedia:

php -m | grep redis

Jika muncul:

redis

berarti extension Redis untuk PHP terdeteksi.

Untuk mengetahui versi PHP:

php -v

Pastikan extension Redis terpasang untuk versi PHP yang benar-benar digunakan oleh Laravel.

Menginstal PHPRedis di Ubuntu

Nama package dapat berbeda tergantung versi PHP.

Contohnya:

sudo apt install php-redis

Setelah instalasi, restart PHP-FPM jika aplikasi menggunakan Nginx dan PHP-FPM.

Contoh:

sudo systemctl restart php8.3-fpm

Nama service harus disesuaikan dengan versi PHP yang digunakan.

Kemudian cek:

php -m | grep redis

Jika extension muncul, PHP sudah dapat menggunakan Redis.

Membersihkan Cache Konfigurasi Laravel

Setelah mengubah .env, Laravel mungkin masih menggunakan konfigurasi yang sudah di-cache.

Untuk membersihkan configuration cache:

php artisan config:clear

Jika ingin membersihkan berbagai cache framework:

php artisan optimize:clear

Setelah itu Laravel akan membaca kembali konfigurasi dari environment.

Test Laravel Terhubung ke Redis

Setelah Redis dikonfigurasi, kita dapat membuat route sederhana untuk menguji cache.

Contoh:

use Illuminate\Support\Facades\Cache;

Route::get('/test-cache', function () {
    Cache::put('test_key', 'Hello Redis', 60);

    return Cache::get('test_key');
});

Jika konfigurasi benar, halaman tersebut akan menampilkan:

Hello Redis

Tetapi kita belum benar-benar memastikan data tersimpan di Redis.

Untuk memeriksanya, gunakan Redis CLI:

redis-cli

Kemudian:

GET test_key

Jika hasilnya:

"Hello Redis"

berarti Laravel berhasil menyimpan data ke Redis.

Menggunakan Cache::remember()

Untuk penggunaan sehari-hari, Cache::remember() adalah salah satu method yang paling praktis.

Contohnya:

use Illuminate\Support\Facades\Cache;

$products = Cache::remember(
    'products:latest',
    600,
    fn () => Product::latest()->get()
);

Artinya:

  • products:latest adalah cache key
  • 600 adalah TTL dalam detik
  • Closure adalah sumber data jika cache belum tersedia

Alurnya:

Request pertama
      ↓
Cache MISS
      ↓
Query Database
      ↓
Simpan ke Redis
      ↓
Return data

Request berikutnya
      ↓
Cache HIT
      ↓
Ambil dari Redis
      ↓
Return data

Contoh Laravel Cache dengan Redis untuk Query Database

Misalnya halaman menampilkan 10 artikel terbaru:

$posts = Cache::remember(
    'posts:latest',
    600,
    fn () => Post::where('published', true)
        ->latest()
        ->take(10)
        ->get()
);

Tanpa cache, query tersebut dapat dijalankan pada setiap request.

Dengan cache:

Database → Request pertama
Redis    → Request berikutnya selama TTL

Jika artikel berubah, kita dapat menghapus cache:

Cache::forget('posts:latest');

Cache Key yang Baik

Gunakan cache key yang jelas dan konsisten.

Contoh:

posts:latest
posts:popular
products:latest
product:123
user:45:profile
settings:site

Hindari key yang terlalu umum seperti:

data
cache
list
item

Cache key yang baik akan mempermudah proses debugging dan invalidasi.

Cache Key dengan ID

Untuk data individual, gunakan ID sebagai bagian dari key.

Contoh:

$product = Cache::remember(
    "product:{$productId}",
    3600,
    fn () => Product::findOrFail($productId)
);

Jika ID adalah 15, key menjadi:

product:15

Produk lain memiliki key berbeda:

product:16
product:17
product:18

Menghapus Cache

Ketika data berubah, cache yang berkaitan perlu diperbarui atau dihapus.

Contohnya:

$product->update($data);

Cache::forget("product:{$product->id}");

Untuk cache daftar produk:

Cache::forget('products:latest');

Request berikutnya akan mengambil data terbaru dari database dan menyimpannya kembali ke Redis.

Cache Invalidation pada Laravel

Salah satu tantangan terbesar dalam caching adalah menentukan kapan cache harus dianggap tidak valid.

Misalnya:

Database:
Product A = Rp100.000

Redis:
Product A = Rp100.000

Kemudian harga di database berubah:

Database:
Product A = Rp120.000

Jika cache tidak dihapus, aplikasi masih dapat menampilkan:

Rp100.000

Karena itu, ketika data berubah:

$product->update([
    'price' => 120000,
]);

Cache::forget("product:{$product->id}");

Caching yang baik bukan hanya tentang menyimpan data, tetapi juga tentang mengelola kapan data tersebut harus dihapus atau diperbarui.

Menggunakan TTL pada Redis

TTL dapat digunakan untuk memastikan cache expired secara otomatis.

Contoh:

Cache::put(
    'site_settings',
    $settings,
    3600
);

Cache tersebut memiliki TTL satu jam.

Kita juga dapat melihat TTL key secara langsung melalui Redis CLI:

TTL site_settings

Redis akan mengembalikan sisa waktu dalam detik.

Contohnya:

3542

Artinya key tersebut masih memiliki sekitar 3.542 detik sebelum expired.

Melihat Key Redis

Untuk development atau debugging, kita dapat melihat key yang tersimpan.

Salah satu command yang sering dikenal adalah:

KEYS *

Tetapi hindari menggunakan KEYS * pada Redis production dengan jumlah key besar, karena command tersebut dapat membebani Redis.

Untuk environment production, pendekatan seperti SCAN lebih aman untuk iterasi key.

Contoh:

SCAN 0

Untuk debugging sederhana pada server development, KEYS * masih dapat digunakan dengan hati-hati.

Melihat Informasi Redis

Redis CLI menyediakan:

INFO

untuk melihat informasi Redis.

Kita juga dapat memeriksa statistik memory:

INFO memory

Hal ini berguna ketika Redis digunakan sebagai cache dan kita ingin mengetahui penggunaan memory.

Laravel Cache dengan Redis untuk Data API

Redis juga berguna untuk menyimpan response dari API eksternal.

Misalnya:

$data = Cache::remember(
    'weather:lampung',
    300,
    fn () => Http::get($url)->json()
);

Selama lima menit, aplikasi tidak perlu memanggil API eksternal pada setiap request.

Manfaatnya:

  • Mengurangi request eksternal
  • Mengurangi latency
  • Mengurangi kemungkinan rate limit
  • Membuat aplikasi lebih tahan terhadap API yang lambat

Tetap pertimbangkan TTL sesuai kebutuhan freshness data.

Redis untuk Cache Tidak Sama dengan Redis untuk Queue

Jika kamu sudah menggunakan Laravel Queue dengan Redis, perlu dibedakan antara:

Redis sebagai Cache

dan:

Redis sebagai Queue Backend

Keduanya dapat menggunakan server Redis yang sama, tetapi memiliki kebutuhan dan konfigurasi yang berbeda.

Contohnya:

Laravel
   │
   ├── Cache ──→ Redis
   │
   └── Queue ──→ Redis

Untuk aplikasi production dengan traffic besar, penggunaan Redis dapat dirancang lebih lanjut agar workload cache dan queue tidak saling mengganggu.

Redis Cache di Localhost vs Production

Pada development, konfigurasi sederhana biasanya cukup:

REDIS_HOST=127.0.0.1
REDIS_PORT=6379

Namun pada production, perhatikan:

  • Redis authentication
  • Firewall
  • Network isolation
  • Memory limit
  • Persistence sesuai kebutuhan
  • Monitoring
  • Backup jika memang ada data yang perlu dipertahankan
  • Pemisahan workload jika diperlukan

Yang paling penting, jangan membuka Redis ke public internet tanpa perlindungan.

Port 6379 bukan port yang seharusnya dibiarkan terbuka untuk semua alamat.

Troubleshooting Laravel Tidak Bisa Terhubung ke Redis

Jika Laravel mengalami error koneksi Redis, periksa beberapa hal berikut.

1. Pastikan Redis Berjalan

sudo systemctl status redis-server

Atau:

redis-cli ping

Pastikan mendapatkan:

PONG

2. Periksa Host dan Port

Periksa .env:

REDIS_HOST=127.0.0.1
REDIS_PORT=6379

Pastikan sesuai dengan konfigurasi Redis.

3. Periksa PHP Extension

php -m | grep redis

Jika menggunakan PHPRedis, extension harus tersedia pada PHP yang digunakan Laravel.

4. Bersihkan Configuration Cache

Setelah mengubah .env:

php artisan config:clear

Atau:

php artisan optimize:clear

5. Periksa Redis CLI

Coba:

redis-cli ping

Jika Redis CLI saja tidak dapat terhubung, masalah kemungkinan berada pada Redis Server atau konfigurasi jaringan, bukan Laravel.

6. Periksa Log Laravel

Jika masih gagal, lihat:

storage/logs/laravel.log

Cari pesan seperti:

Connection refused

atau:

RedisException

Pesan error tersebut biasanya memberikan petunjuk mengenai bagian konfigurasi yang bermasalah.

Kesalahan yang Sering Terjadi

1. Redis Belum Berjalan

Laravel tidak akan dapat terhubung jika Redis Server berhenti.

2. .env Sudah Diubah tetapi Config Masih Cached

Gunakan:

php artisan config:clear

3. PHPRedis Belum Terpasang

Jika menggunakan PHPRedis, pastikan extension tersedia.

4. Host Salah

127.0.0.1 hanya benar jika Redis memang berjalan pada server yang sama.

5. Redis Port Tidak Sesuai

Port default adalah 6379, tetapi dapat diubah melalui konfigurasi Redis.

6. Redis Terbuka ke Internet

Hindari mengekspos Redis secara langsung ke internet publik.

7. Cache Tidak Pernah Di-invalidasi

Data yang berubah dapat tetap menampilkan nilai lama jika cache tidak dihapus.

Best Practice Laravel Cache dengan Redis

Berikut beberapa praktik yang baik untuk pemula:

Gunakan Cache::remember()

Cache::remember(
    'products:latest',
    600,
    fn () => Product::latest()->get()
);

Buat Cache Key yang Konsisten

Contoh:

product:123
products:latest
products:popular
settings:site

Tentukan TTL Berdasarkan Karakteristik Data

Data yang sering berubah → TTL lebih pendek.

Data yang jarang berubah → TTL dapat lebih panjang.

Lakukan Invalidasi Ketika Data Berubah

Cache::forget("product:{$id}");

Jangan Cache Semua Query

Cache hanya bagian yang memang memberikan manfaat.

Monitor Redis

Perhatikan penggunaan memory, jumlah key, hit/miss, dan beban Redis.

Jangan Mengekspos Redis ke Public Internet

Batasi akses menggunakan firewall dan network policy yang sesuai.

Contoh Implementasi Lengkap

Misalnya kita memiliki halaman daftar produk.

Controller:

use Illuminate\Support\Facades\Cache;

public function index()
{
    $products = Cache::remember(
        'products:latest',
        600,
        fn () => Product::with('category')
            ->latest()
            ->take(20)
            ->get()
    );

    return view('products.index', compact('products'));
}

Pada contoh tersebut terdapat dua optimasi:

Eager Loading
     ↓
with('category')

Caching
     ↓
Cache::remember()

Jadi Laravel tidak hanya menghindari query relationship yang tidak perlu, tetapi juga dapat menghindari menjalankan query database yang sama pada setiap request selama cache masih valid.

Ketika produk berubah, cache dapat dihapus:

Cache::forget('products:latest');

Pola seperti ini cukup umum untuk aplikasi Laravel yang membutuhkan response cepat tetapi datanya tidak harus selalu real-time.

Apakah Redis Selalu Diperlukan?

Tidak.

Untuk aplikasi Laravel kecil, cache menggunakan file atau database mungkin sudah cukup.

Redis mulai menjadi semakin menarik ketika:

  • Traffic aplikasi meningkat
  • Cache sering digunakan
  • Aplikasi memiliki beberapa server
  • Response time menjadi perhatian
  • Laravel Queue juga menggunakan Redis
  • Aplikasi membutuhkan cache berbasis memory
  • Beban database mulai meningkat

Jadi jangan menggunakan Redis hanya karena dianggap lebih cepat.

Pilih Redis ketika kebutuhan aplikasi memang membutuhkannya.

Kesimpulan

Laravel Cache dengan Redis merupakan kombinasi yang sangat berguna untuk meningkatkan performa aplikasi.

Laravel menyediakan API Cache yang sederhana:

Cache::remember(
    'products:latest',
    600,
    fn () => Product::latest()->get()
);

Sementara Redis berfungsi sebagai backend yang menyimpan data cache.

Alur dasarnya:

Laravel
   ↓
Cek Redis
   ↓
Cache HIT ─────→ Return Data
   │
Cache MISS
   ↓
Database
   ↓
Simpan ke Redis
   ↓
Return Data

Untuk pemula, fokus terlebih dahulu pada beberapa konsep utama:

  1. Memahami cache hit dan cache miss.
  2. Menggunakan Cache::remember().
  3. Membuat cache key yang konsisten.
  4. Menentukan TTL.
  5. Menghapus cache ketika data berubah.
  6. Memastikan Redis berjalan dengan baik.
  7. Tidak membuka Redis ke internet publik.

Setelah memahami dasar tersebut, Redis dapat dikembangkan lebih jauh untuk kebutuhan Laravel lainnya seperti Queue, Session, dan Laravel Horizon.

Yang paling penting, gunakan caching berdasarkan bottleneck nyata pada aplikasi. Cache yang dirancang dengan baik dapat mengurangi beban database dan mempercepat response, tetapi cache yang terlalu banyak atau tidak memiliki strategi invalidasi justru dapat membuat aplikasi lebih sulit dipelihara.

Artikel Terkait