Lucee dan Redis: session, cache dan pub/sub

Lucee dan Redis: session, cache dan pub/sub

Redis ialah stor data dalam memori yang menyimpan pasangan kunci dan nilai. Ia bercakap melalui protokol RESP di atas TCP, bukan HTTP, jadi anda tidak boleh memanggilnya dengan cfhttp seolah-olah ia sebuah API REST. Dalam Lucee, Redis memainkan tiga peranan berbeza: storan session, backend cache objek, dan saluran pub/sub untuk pesanan antara pelayan. Artikel ini menerangkan ketiga-tiganya, bila setiap satu sesuai, dan cara menyambungkannya tanpa mencipta API yang sebenarnya tidak wujud.

Bila session dalam memori memadai

Storan session lalai Lucee ialah memory. Data session disimpan terus dalam timbunan JVM sepanjang hayatnya, tanpa serialization, tanpa sambungan rangkaian dan tanpa konfigurasi tambahan. Untuk aplikasi yang berjalan pada satu pelayan, ini pilihan terbaik: ia paling pantas dan paling mudah diselenggara. Selagi trafik anda boleh dihidangkan oleh satu contoh Lucee, anda tidak perlukan Redis untuk session sama sekali.

Menambah Redis pada seni bina satu pelayan sebenarnya menambah kos: setiap operasi session perlu disiri dan dihantar melalui rangkaian, dan anda kini menyelenggara satu lagi perkhidmatan. Peraturan mudahnya, mula dengan memory, dan hanya beralih apabila seni bina anda memaksanya. Asas cara session dikonfigurasikan dibincangkan dalam panduan pengurusan sesi dalam Lucee.

Bila session dalam memori gagal

Memory mula gagal dalam dua keadaan. Pertama, apabila aplikasi anda berjalan di belakang pengimbang beban dan permintaan pengguna yang sama boleh mendarat di pelayan berbeza. Pelayan kedua tidak mempunyai session itu dalam ingatannya, jadi pengguna tiba-tiba log keluar atau kehilangan keranjang belanja. Session melekit boleh menampal masalah ini, tetapi ia rapuh: kalau satu pelayan mati, semua session yang melekat padanya hilang.

Kedua, apabila anda mula semula Lucee atau menggunakan semula aplikasi. Session dalam memori musnah bersama proses JVM, jadi setiap deploy atau mula semula memaksa semua pengguna log masuk semula. Session juga memakan timbunan JVM, dan semakin banyak session aktif, semakin banyak memori yang diduduki dan semakin kerap kutipan sampah berjalan. Kalau timbunan anda sudah ketat, lihat panduan tala JVM untuk Lucee.

Dalam kedua-dua kes, jawapannya ialah memindahkan session keluar dari ingatan pelayan ke storan luar yang boleh dikongsi, dan Redis ialah pilihan yang paling biasa untuk itu.

Cara Lucee menyimpan session dalam Redis

Lucee tidak menyambung terus ke Redis. Anda mesti memasang sambungan Redis terlebih dahulu daripada kedai sambungan Lucee, dan ia hanya boleh dipasang dalam Server Admin, bukan Web Admin. Sambungan rasmi ini membundel pemacu kliennya sendiri: versi terdahulunya dibina atas Jedis, salah satu daripada dua pemacu Java Redis yang popular, manakala Lettuce ialah pemacu satu lagi yang lebih dikenali dalam ekosistem Spring. Anda tidak perlu memilih antara kedua-duanya secara manual kerana sambungan itu menghantar kliennya sendiri, tetapi penting untuk tahu bahawa sambungan rasmi menyokong satu pelayan Redis sahaja, bukan Redis Cluster.

Selepas dipasang, anda mencipta sambungan cache baharu dengan jenis Redis Cache dalam bahagian Services, Cache. Tetapan sambungan yang penting ialah host dan port (lalai localhost pada 6379), indeks pangkalan data untuk memisahkan data, kata laluan jika Redis anda dilindungi, dan nama ruang untuk mengelakkan kunci bertembung antara beberapa contoh cache. Satu kotak semak yang menentukan: Allow to use this cache as client/session storage. Tanpa kotak ini ditanda, cache tidak boleh digunakan sebagai storan session.

Menyimpan cache aplikasi dengan fungsi cache terbina

Untuk cache objek, anda tidak memerlukan sebarang pustaka klien Redis terus. Lucee menyediakan lapisan cache yang boleh ditukar ganti, dan kod anda bercakap kepadanya melalui fungsi terbina dalam seperti cachePut, cacheGet dan cacheRemove. Backend di belakang fungsi ini boleh jadi cache RAM terbina dalam atau Redis, dan kod anda tidak berubah apabila backend bertukar.

Pola yang paling biasa ialah cache-aside: baca dahulu, dan kalau tiada, muat semula lalu simpan:

function getSenaraiProduk() {
    var hasil = cacheGet("produk:senarai");
    if (isNull(hasil)) {
        hasil = muatSenaraiProduk();
        cachePut("produk:senarai", hasil, createTimeSpan(0, 0, 5, 0));
    }
    return hasil;
}

Apabila data berubah, anda buang entri itu supaya permintaan seterusnya memuatkan versi segar:

cacheRemove("produk:senarai");

Satu perkara yang patut ditegaskan: jangan cuba mencapai Redis melalui cfhttp. Redis tidak memahami HTTP atau REST, jadi memanggilnya dengan cfhttp akan gagal. Cara yang benar-benar wujud ialah fungsi cache terbina dalam dengan sambungan Redis yang didaftarkan, atau klien Java terus jika anda memerlukan ciri Redis yang tidak didedahkan oleh lapisan cache. Panduan penuh jenis cache dan cara membatalkannya ada dalam panduan caching dan prestasi.

Application.cfc yang sah

Beginilah rupa Application.cfc yang mendaftarkan dua sambungan Redis, satu untuk session dan satu untuk cache objek:

component {
    this.name = "kedaiRedis";
    this.sessionManagement = true;
    this.sessionTimeout = createTimeSpan(0, 0, 30, 0);

    this.cache.connections["redisSesi"] = {
        class: "org.lucee.redis.RedisCache",
        storage: true,
        custom: {
            host: "localhost",
            port: 6379,
            database: 0,
            password: ""
        }
    };

    this.cache.connections["redisObjek"] = {
        class: "org.lucee.redis.RedisCache",
        storage: true,
        custom: {
            host: "localhost",
            port: 6379,
            database: 1
        },
        default: "object"
    };

    this.sessionStorage = "redisSesi";
}

Kunci storage berpadanan dengan kotak semak dalam admin: nilai true membenarkan cache itu digunakan sebagai storan session. Kunci default menetapkan cache mana yang menjadi cache objek lalai, jadi cachePut dan cacheGet tanpa argumen cacheName menggunakannya secara automatik. Baris terakhir, this.sessionStorage, ialah tempat enjin diarahkan untuk menyimpan session dalam Redis dan bukannya dalam ingatan.

docker-compose untuk Redis

Untuk pembangunan tempatan, satu contoh Redis boleh dihidupkan dengan fail docker-compose ringkas:

services:
  redis:
    image: redis:8-alpine
    container_name: lucee-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis-data:/data

volumes:
  redis-data:

Flag appendonly menghidupkan kegigihan fail, supaya data cache dan session terselamat daripada mula semula bekas. Flag requirepass menetapkan kata laluan, dan anda memadankannya dengan kunci password dalam tetapan sambungan di Application.cfc. Dalam persekitaran pengeluaran, sambungkan Lucee dan Redis pada rangkaian Docker yang sama dan elakkan mendedahkan port 6379 kepada awam. Cara menghidupkan Lucee sendiri dalam bekas ada dalam panduan deploy Lucee dengan Docker.

Redis sebagai storan session di peringkat enjin

Apabila sessionStorage menunjuk kepada sambungan Redis, Lucee mengendalikan pemindahan data secara telus. Session disimpan dalam ingatan sehingga seminit ketika tidak aktif, kemudian dibuang dan dimuat semula daripada Redis mengikut keperluan. Tetapan this.sessionCluster mengawal arah kebenaran: dengan nilai false, ingatan tempatan ialah sumber utama dan Redis hanya dikemas kini apabila data berubah, yang menjimatkan operasi rangkaian. Dengan nilai true, Redis menjadi sumber kebenaran dan session disemak terhadap Redis pada setiap permintaan, yang menjamin konsistensi merentas pelayan dalam kluster.

Kerana data kini disiri setiap kali ia meninggalkan ingatan, elakkan menyimpan komponen atau objek besar dalam skop session. Simpan nilai ringkas sahaja, seperti id pengguna, bendera log masuk dan data kecil lain. Perbandingan backend cache lain, termasuk Ehcache dan Memcached, ada dalam panduan perbandingan Ehcache dan Memcached.

Jadual kes penggunaan

Baris pub/sub ialah tempat kebanyakan orang tersilap. Fungsi cache terbina dalam Lucee hanya menyimpan dan mengambil nilai, ia tidak menerbitkan atau melanggan saluran. Kalau aplikasi anda memerlukan pesanan masa nyata antara pelayan, anda perlu sama ada memuatkan klien Redis Java terus melalui createObject, atau menggunakan sambungan Ortus Redis yang mendedahkan pemesejan pub/sub dan storan dokumen sebagai tambahan kepada caching dan session.

Soalan Lazim (FAQ)

Bagaimana cara menyimpan session Lucee dalam Redis?

Pasang sambungan Redis dalam Server Admin, cipta sambungan cache dengan jenis Redis Cache dan tanda kotak Allow to use this cache as client/session storage, kemudian tetapkan this.sessionStorage kepada nama sambungan itu dalam Application.cfc.

Bolehkah saya mencapai Redis dengan cfhttp?

Tidak. Redis bercakap melalui protokol RESP di atas TCP, bukan HTTP atau REST. Gunakan fungsi cache terbina dalam Lucee dengan sambungan Redis yang didaftarkan, atau klien Java terus jika anda memerlukan ciri yang tidak didedahkan oleh lapisan cache.

Apa beza storage true dan false dalam definisi cache Redis?

storage true membolehkan cache itu digunakan sebagai storan session atau client. storage false bermakna cache hanya untuk objek dan tidak boleh digunakan oleh sessionStorage.

Adakah sambungan Redis Lucee menyokong Redis Cluster?

Tidak. Sambungan rasmi menyokong satu pelayan Redis sahaja. Untuk Redis Cluster, anda perlu laluan lain seperti sambungan Ortus atau klien Java tersendiri.

Bila saya patut kekal dengan session dalam memori?

Kekal dengan memory selagi aplikasi berjalan pada satu pelayan dan anda boleh menerima session hilang apabila Lucee dimulakan semula. Beralih kepada Redis hanya apabila anda perlu berkongsi session merentas pelayan atau menyimpannya merentas mula semula.

Sumber

• Redis Cache Extension, github.com/lucee/extension-redis
• Session Handling in Lucee, docs.lucee.org
• Getting Started with Caching, docs.lucee.org
• Redis Category, docs.lucee.org
• Redis Extension for Jakarta 4.0.0, Lucee Dev

Senarai semak

• Pasang sambungan Redis dalam Server Admin sebelum cuba mencipta sambungan cache.
• Tanda kotak Allow to use this cache as client/session storage untuk sambungan yang akan menyimpan session.
• Tetapkan this.sessionStorage kepada nama sambungan Redis, dan this.sessionCluster true untuk kluster.
• Gunakan cachePut, cacheGet dan cacheRemove untuk cache objek, bukan cfhttp.
• Simpan nilai ringkas dalam session, bukan komponen besar yang mahal untuk disiri.
• Lindungi Redis dengan kata laluan dan jangan dedahkan port 6379 kepada awam.