Rails Ascent Logo Rails Ascent

Bienvenue dans l'ère "Solid" de Rails

Si vous débutez avec Rails ou si vous avez récemment entendu parler de Rails 8, vous avez probablement croisé ces trois noms mystérieux : Solid Cache, Solid Cable et Solid Queue. Ces trois gemmes forment ce qu'on appelle le "triumvirat Solid" (ou "Solid Trifecta" en anglais) et représentent l'une des évolutions les plus importantes de Rails depuis des années.


Mais pourquoi tant d'enthousiasme ? Parce que ces trois outils vous permettent de construire une application Rails complète et performante sans Redis ni aucune dépendance externe. Fini le casse-tête de la configuration de multiples services ! Tout tourne avec votre base de données.


Dans cette série d'article, nous allons explorer en profondeur chaque composant du triumvirat, comprendre comment ils fonctionnent, et surtout, apprendre à les utiliser avec des exemples concrets. Que vous soyez développeur junior ou simplement curieux, à la fin de cette lecture, vous maîtriserez ces trois outils essentiels de Rails 8.


On va également beaucoup parler de Redis donc si vous voulez apprendre ce que c'est ou vous rafraichir la mémoire, allez lire mon article ultra complet sur le sujet : Redis et Rails 8 : Le Guide Complet pour Développeurs Juniors


Pourquoi le Triumvirat Solid existe-t-il ?

Le problème traditionnel

Avant Rails 8, si vous vouliez construire une application Rails moderne avec des fonctionnalités avancées, votre stack ressemblait généralement à ceci :

  1. PostgreSQL ou MySQL : votre base de données principale
  2. Redis : pour le cache
  3. Redis ou Sidekiq : pour les tâches de fond (background jobs)
  4. Redis : pour Action Cable (fonctionnalités temps réel)


Vous voyez le pattern ? Redis partout ! Et bien que Redis soit excellent, il introduit plusieurs contraintes :

  1. Complexité de déploiement : un service de plus à gérer, monitorer et maintenir
  2. Coûts supplémentaires : sur des plateformes comme Heroku, chaque add-on a un prix
  3. Dépendance externe : si Redis tombe, plusieurs parties de votre app tombent aussi
  4. Courbe d'apprentissage : encore une technologie à apprendre pour les juniors



La philosophie "Solid"

L'équipe de Basecamp (les créateurs de Rails) a eu une réflexion simple mais puissante :

"Et si on utilisait notre base de données pour tout faire ?"

Avec les SSD modernes (notamment les NVMe), le stockage sur disque est devenu suffisamment rapide pour rivaliser avec la RAM dans beaucoup de cas d'usage. De plus, les bases de données modernes comme PostgreSQL et MySQL ont énormément progressé en performance.


Le résultat ? Un Rails plus simple, plus léger, et tout aussi performant pour 80% des applications.

Solid Cache : Le Cache Basé sur la Base de Données

Qu'est-ce que le cache, exactement ?

Avant de plonger dans Solid Cache, comprenons ce qu'est le cache. Imaginez que vous ayez un site e-commerce avec une page d'accueil qui affiche les produits les plus populaires. À chaque visite, le serveur doit :

  1. Interroger la base de données
  2. Calculer les statistiques
  3. Générer le HTML
  4. Envoyer la réponse

Si vous avez 1000 visiteurs par minute, vous répétez cette opération 1000 fois... pour afficher exactement le même contenu ! C'est du gaspillage de ressources.

Le cache résout ce problème en stockant le résultat de cette opération coûteuse en mémoire. La prochaine fois, au lieu de tout recalculer, on récupère simplement le résultat stocké. C'est comme garder votre tasse de café préférée sur votre bureau plutôt que dans le placard de la cuisine.

Solid Cache : Comment ça fonctionne ?

Solid Cache remplace les solutions traditionnelles (Redis, Memcached) par un système de cache basé sur votre base de données.


L'architecture

Solid Cache utilise une simple table dans votre base de données appelée solid_cache_entries. Voici sa structure :


# db/cache_schema.rb
create_table "solid_cache_entries", force: :cascade do |t|
t.binary "key", null: false # La clé du cache
t.binary "value", null: false # La valeur stockée
t.datetime "created_at", null: false
t.integer "key_hash", limit: 8, null: false # Hash de la clé pour les recherches rapides
t.integer "byte_size", limit: 4, null: false # Taille de l'entrée
end


Le principe :

  1. Quand vous mettez en cache une donnée, elle est stockée dans cette table
  2. Quand vous la récupérez, Rails fait une requête SQL ultra-rapide sur l'index key_hash
  3. Les entrées sont automatiquement nettoyées selon votre configuration


Pourquoi c'est rapide malgré le disque ?

Vous vous demandez sûrement : "Une base de données sur disque ne peut pas être aussi rapide que Redis en RAM, non ?"


Excellente question ! Voici pourquoi ça fonctionne :

  1. Les SSD modernes sont ultra-rapides : Les NVMe atteignent des vitesses de lecture/écriture impressionnantes
  2. Cache au niveau de la base de données : PostgreSQL et MySQL mettent en cache les données fréquemment accédées en RAM
  3. Stockage massif : Avec le disque, vous pouvez stocker 100x plus de données qu'avec Redis, ce qui signifie moins de cache misses
  4. Retention plus longue : Basecamp garde 10 To de cache pendant 60 jours !

Installation et Configuration

Sur Rails 8

Bonne nouvelle : Solid Cache est activé par défaut sur Rails 8 ! Rien à faire lors de la création d'une nouvelle app :


rails new mon_app
cd mon_app
rails db:migrate

C'est tout ! Solid Cache est déjà configuré en production.

Sur Rails 7.1+ (installation manuelle)

Si vous utilisez une version antérieure de Rails 8 :


# Ajouter la gemme
bundle add solid_cache
# Installer Solid Cache
bin/rails solid_cache:install
# Cela va créer :
# - config/cache.yml
# - db/cache_schema.rb


Ensuite, configurez votre config/database.yml :

production:
primary:
<<: *default
database: mon_app_production
cache:
<<: *default
database: mon_app_cache_production
migrations_paths: db/cache_migrate

Et dans config/environments/production.rb :


config.cache_store = :solid_cache_store

Configuration dans config/cache.yml

default: &default
store_options:
max_age: <%= 60.days.to_i %> # Durée maximale de conservation
max_size: <%= 256.megabytes %> # Taille maximale du cache
namespace: <%= Rails.env %>
production:
database: cache
<<: *default
development:
<<: *default

Exemples Pratiques

Exemple 1 : Cacher une requête coûteuse

# app/controllers/products_controller.rb
class ProductsController < ApplicationController
def index
# Sans cache : cette requête s'exécute à chaque visite
# @products = Product.includes(:category).where(published: true).order(views: :desc).limit(10)
# Avec cache : cette requête ne s'exécute que toutes les heures
@products = Rails.cache.fetch('popular_products', expires_in: 1.hour) do
Product.includes(:category)
.where(published: true)
.order(views: :desc)
.limit(10)
end
end
end


Comment ça marche :

  1. La première fois, Rails ne trouve rien dans le cache
  2. Le bloc s'exécute, la requête est faite
  3. Le résultat est stocké dans solid_cache_entries avec la clé "popular_products"
  4. Les visites suivantes récupèrent directement le résultat du cache
  5. Après 1 heure, l'entrée expire et le cycle recommence

Exemple 2 : Cacher un calcul complexe

# app/models/user.rb
class User < ApplicationRecord
def reputation_score
Rails.cache.fetch("user_#{id}_reputation", expires_in: 5.minutes) do
calculate_complex_reputation
end
end
private
def calculate_complex_reputation
# Calcul coûteux impliquant plusieurs tables
(posts.sum(:likes) * 2) +
(comments.sum(:upvotes) * 1.5) +
(achievements.count * 10) -
(posts.sum(:dislikes) * 0.5)
end
end

Exemple 3 : Cacher une vue partielle

Dans vos vues, vous pouvez utiliser le cache de fragments :

<!-- app/views/products/_product.html.erb -->
<% cache product do %>
<div class="product">
<h2><%= product.name %></h2>
<p><%= product.description %></p>
<span class="price"><%= number_to_currency(product.price) %></span>
</div>
<% end %>


Rails génère automatiquement une clé unique basée sur :

  1. Le modèle (Product)
  2. L'ID du produit
  3. La dernière mise à jour (updated_at)

Si le produit change, le cache est automatiquement invalidé !

Exemple 4 : Gérer le cache manuellement

# Écrire dans le cache
Rails.cache.write('ma_cle', 'ma_valeur', expires_in: 10.minutes)
# Lire depuis le cache
valeur = Rails.cache.read('ma_cle')
# Supprimer une entrée
Rails.cache.delete('ma_cle')
# Incrémenter un compteur
Rails.cache.increment('compteur_visiteurs')
# Décrémenter un compteur
Rails.cache.decrement('compteur_visiteurs')
# Vider tout le cache
Rails.cache.clear

Opérations de Maintenance

Activer le cache en développement

Par défaut, le cache est désactivé en développement. Pour l'activer :

rails dev:cache


Cette commande crée un fichier tmp/caching-dev.txt. Relancez-la pour désactiver le cache.

Monitoring du cache

# Console Rails
rails c
# Voir toutes les entrées
SolidCache::Entry.count
# Voir la taille totale du cache
SolidCache::Entry.sum(:byte_size) / 1.megabyte
# => 145.2 MB
# Voir les entrées les plus récentes
SolidCache::Entry.order(created_at: :desc).limit(10)

Solid Cache vs Redis : Quand utiliser quoi ?

Critère
Solid Cache
Redis
Vitesse
Rapide (disque + cache DB)
Très rapide (RAM pure)
Capacité
Massive (plusieurs TB)
Limitée (RAM coûteuse)
Persistance
Oui, sur disque
Optionnelle
Simplicité
Très simple (intégré Rails)
Configuration externe
Coût
Faible (utilise disque)
Plus élevé (RAM)
Cas d'usage
Apps petites/moyennes
Apps haute performance


Utilisez Solid Cache si :

  1. Vous démarrez un nouveau projet Rails 8
  2. Vous voulez simplifier votre infrastructure
  3. Vous n'avez pas besoin de performance extrême
  4. Vous voulez stocker beaucoup de données en cache


Gardez Redis si :

  1. Vous avez besoin de performance maximale
  2. Vous utilisez les fonctionnalités avancées de Redis (pub/sub, sorted sets). Vous ne savez pas ce que c'est ? Allez lire mon article sur le sujet : Redis et Rails 8 : Le Guide Complet pour Développeurs Juniors
  3. Vous avez déjà une infrastructure Redis bien rodée

Conclusion : Solid Cache, le super cache natif de Rails

Solid Cache, c’est le cache Rails repensé pour la simplicité et la performance. En s’appuyant sur Active Record et une base SQL, il élimine les frictions liées à Redis tout en offrant une API familière et puissante. Que ce soit pour optimiser les performances de vos vues, réduire les appels à des services externes ou accélérer vos requêtes, Solid Cache s’intègre naturellement dans votre stack Rails.

Avec Rails 8 qui l’adopte officiellement, il est temps de dire adieu aux configurations complexes et de profiter d’un cache robuste, lisible et facile à maintenir.


🚀 Moins de dépendances, plus de clarté. Solid Cache, c’est le cache Rails comme on l’a toujours rêvé.