# Solid Queue und Solid Cache in Rails 8: Umfassender Leitfaden für technische Vorstellungsgespräche 2026

> Tiefgehende Analyse von Solid Queue und Solid Cache – den datenbankgestützten Standardkomponenten in Rails 8. Architektur, Konfiguration, Nebenläufigkeitssteuerung und prüfungsrelevantes Wissen für 2026.

- Published: 2026-05-13
- Updated: 2026-05-13
- Author: Anthony Fillion-Maillet
- Tags: ruby-on-rails, solid-queue, solid-cache, rails-8, background-jobs, caching, interview
- Reading time: 10 min

---

Solid Queue und Solid Cache markieren den bedeutendsten Infrastrukturwandel in der Geschichte von Rails. Beide Komponenten sind seit Rails 8 als Standardlösungen integriert und ersetzen Redis für Hintergrund-Jobs und Caching durch datenbankgestützte Alternativen, die eine ganze Schicht operativer Komplexität eliminieren.

> **Die Solid-Trias**
>
> Rails 8 setzt standardmäßig auf drei datenbankgestützte Komponenten: Solid Queue (Hintergrund-Jobs), Solid Cache (Cache-Speicher) und Solid Cable (WebSockets). Gemeinsam beseitigen sie die Redis-Abhängigkeit für die meisten Rails-Anwendungen. Dieses Thema taucht regelmäßig in technischen Interviews zu Rails 8 auf.

## Wie Solid Queue Redis-basierte Job-Backends ersetzt

Solid Queue ist ein datenbankgestütztes Active-Job-Backend, das Jobs direkt in PostgreSQL, MySQL oder SQLite speichert. Der zentrale Mechanismus ist `FOR UPDATE SKIP LOCKED` — ein SQL-Feature, das ab PostgreSQL 9.5+ und MySQL 8+ verfügbar ist und eine reguläre Datenbanktabelle in eine nebenläufige Job-Warteschlange verwandelt, ohne Blockierungen zu verursachen.

Die Architektur besteht aus drei Komponenten:

- **Workers** fragen `solid_queue_ready_executions` ab und beanspruchen Jobs mittels `SKIP LOCKED`
- **Dispatcher** verschieben geplante Jobs von `solid_queue_scheduled_executions` in die Ready-Tabelle, sobald deren Ausführungszeit erreicht ist
- **Scheduler** verwalten wiederkehrende Aufgaben gemäß der Konfiguration

```ruby
# config/solid_queue.yml
production:
  dispatchers:
    - polling_interval: 1
      batch_size: 500
  workers:
    - queues: "*"
      threads: 5
      polling_interval: 0.1
      processes: 2
```

Diese Konfiguration startet zwei Worker-Prozesse mit jeweils 5 Threads, die alle 100 ms abfragen. Der Dispatcher prüft geplante Jobs jede Sekunde in Stapeln von 500.

## Transaktionale Job-Einreihung in Rails 8

Eines der stärksten Argumente für Solid Queue gegenüber Redis-basierten Backends ist die transaktionale Einreihung. Wird ein Job innerhalb einer Datenbanktransaktion eingereiht, wird er erst nach dem Commit der Transaktion sichtbar. Redis-basierte Backends können diese Garantie nicht bieten — ein Job könnte ausgeführt werden, bevor die auslösende Transaktion abgeschlossen ist, und dabei auf Datensätze verweisen, die noch nicht existieren.

```ruby
# app/jobs/send_welcome_email_job.rb
class SendWelcomeEmailJob < ApplicationJob
  self.enqueue_after_transaction_commit = true

  queue_as :default

  def perform(user_id)
    user = User.find(user_id)
    UserMailer.welcome(user).deliver_now
  end
end

# app/models/user.rb
class User < ApplicationRecord
  after_create do
    SendWelcomeEmailJob.perform_later(id)
    # Job wird erst nach Commit der CREATE-Transaktion eingereiht
    # Kein Risiko, dass der Job vor dem Anlegen des User-Datensatzes läuft
  end
end
```

Mit aktiviertem `enqueue_after_transaction_commit` wird der Job bis zum erfolgreichen Abschluss der umgebenden Transaktion zurückgehalten. Wird die Transaktion zurückgerollt, wird der Job niemals eingereiht. Damit wird eine ganze Klasse von Race Conditions eliminiert, die Redis-gestützte Warteschlangen plagen.

## Nebenläufigkeitssteuerung und Prioritätswarteschlangen

Solid Queue bietet integrierte Nebenläufigkeitskontrollen, die Sidekiq nur in der kostenpflichtigen Enterprise-Version anbietet. Die Option `concurrency_limit` beschränkt, wie viele Jobs eines bestimmten Typs gleichzeitig ausgeführt werden können.

```ruby
# app/jobs/api_sync_job.rb
class ApiSyncJob < ApplicationJob
  limits_concurrency to: 3, key: ->(account_id) { "api_sync_#{account_id}" }

  def perform(account_id)
    account = Account.find(account_id)
    ExternalApi.sync(account)
  end
end
```

Dies stellt sicher, dass höchstens 3 API-Sync-Jobs gleichzeitig pro Account laufen und Ratenlimit-Überschreitungen ohne externe Koordination verhindert werden. Blockierte Jobs werden in `solid_queue_blocked_executions` gespeichert und automatisch freigegeben, sobald ein Platz frei wird.

Priorität funktioniert auf zwei Ebenen: numerische Priorität pro Job (niedrigere Zahl = höhere Priorität) und Warteschlangen-Reihenfolge in der Worker-Konfiguration. Beide Ebenen lassen sich für eine feingranulare Steuerung der Job-Ausführungsreihenfolge kombinieren.

> **Interview-Hinweis**
>
> Eine häufige Frage in Rails-8-Interviews betrifft die Abwägungen zwischen Solid Queue und Sidekiq. Der entscheidende Unterschied: Solid Queue bietet transaktionale Garantien und integrierte Nebenläufigkeitskontrollen ohne Zusatzkosten. Sidekiq punktet beim reinen Durchsatz für Hochlast-Szenarien (10.000+ Jobs/Minute), da Redis im Arbeitsspeicher arbeitet. Für 95 % aller Anwendungen liefert Solid Queue ausreichende Performance.

## Wiederkehrende Jobs ohne Cron

Solid Queue ersetzt cron-basierte Planung durch einen integrierten Scheduler. Wiederkehrende Aufgaben werden in einer YAML-Konfigurationsdatei definiert und vom Scheduler-Prozess verwaltet.

```ruby
# config/recurring.yml
production:
  cleanup_expired_sessions:
    class: CleanupExpiredSessionsJob
    schedule: every 6 hours
  daily_report:
    class: DailyReportJob
    schedule: every day at 6am
    queue: reports
  weekly_digest:
    class: WeeklyDigestJob
    schedule: every Monday at 9am
```

Der Scheduler-Prozess liest diese Datei und reiht die entsprechenden Jobs in den definierten Intervallen ein. Anders als Cron läuft er innerhalb desselben Prozess-Supervisors und teilt sich die gleiche Datenbankverbindung.

## Deployment mit Puma-Integration

Rails 8 mit [Kamal](https://kamal-deploy.org/) bietet eine konfigurationsfreie Bereitstellung für Solid Queue. Die Umgebungsvariable `SOLID_QUEUE_IN_PUMA=1` weist Puma an, Solid-Queue-Prozesse zusammen mit dem Webserver zu forken und zu überwachen.

```ruby
# config/puma.rb (Rails 8 Standard)
plugin :solid_queue if ENV["SOLID_QUEUE_IN_PUMA"]
```

Dieses Single-Process-Deployment-Modell vereinfacht die Container-Orchestrierung. Ein einziges Docker-Image betreibt sowohl den Webserver als auch die Job-Verarbeitung und reduziert den Betriebsaufwand für kleine bis mittlere Anwendungen.

## Solid Cache: Datenbankgestütztes Caching mit Skalierbarkeit

Solid Cache ist ein datenbankgestützter `ActiveSupport::Cache::Store`, der die Leistung moderner SSDs nutzt, um Redis und Memcached als Standard-Cache-Speicher zu ersetzen. Die Prämisse: SSDs sind bei Lesevorgängen nur geringfügig langsamer als RAM, bieten jedoch um Größenordnungen mehr Speicherkapazität zu einem Bruchteil der Kosten.

Solid Cache verwendet eine FIFO-Verdrängungsstrategie (First In, First Out) anstelle von LRU (Least Recently Used). Obwohl FIFO theoretisch weniger effizient ist, kompensiert die deutlich größere Speicherkapazität — Einträge bleiben viel länger im Cache, was die Cache-Fehlquote insgesamt senkt.

```ruby
# config/environments/production.rb
config.cache_store = :solid_cache_store

# config/solid_cache.yml
production:
  databases:
    - cache
  store_options:
    max_age: 604800        # 1 Woche in Sekunden
    max_size: 256           # Max. Eintragsgröße in KB
    namespace: "app_v1"
    expiry_batch_size: 100  # Einträge pro Aufräumzyklus
```

## Cache-Architektur und Verdrängungsmechanismus

Solid Cache verfolgt Schreibvorgänge über einen internen Zähler. Erreicht der Zähler 50 % der konfigurierten `expiry_batch_size`, wird eine Hintergrundaufgabe zur Bereinigung abgelaufener Einträge ausgelöst. Dieser amortisierte Ansatz vermeidet die Stop-the-World-Pausen, die bei LRU-Verdrängung in speicherbeschränkten Redis-Instanzen auftreten können.

Die Tabelle `solid_cache_entries` speichert alle zwischengespeicherten Daten:

```ruby
# db/cache_schema.rb (vom Installer generiert)
create_table :solid_cache_entries do |t|
  t.binary :key, null: false, limit: 1024
  t.binary :value, null: false, limit: 262144  # 256 KB Standard
  t.datetime :created_at, null: false
  t.index :key, unique: true
  t.index :created_at  # Für FIFO-Verdrängung
end
```

Lese- und Schreibvorgänge auf diese Tabelle verwenden standardmäßig denselben Connection Pool wie die restliche Anwendung. Für stark frequentierte Anwendungen verhindert eine separate Datenbank für Cache-Daten, dass Cache-Operationen die Performance der Hauptdatenbank beeinträchtigen.

## Separate Datenbankkonfiguration für den Cache

Die Isolation von Solid Cache auf einer dedizierten Datenbank ist unkompliziert und wird für Produktionsumgebungen mit signifikantem Cache-Verkehr empfohlen.

```yaml
# config/database.yml
production:
  primary:
    <<: *default
    database: myapp_production
  cache:
    <<: *default
    database: myapp_cache_production
    migrations_paths: db/cache_migrate
```

Diese Trennung stellt sicher, dass Millionen von Cache-Schreibvorgängen weder das WAL (Write-Ahead Log) der Hauptdatenbank aufblähen noch um Connection-Pool-Plätze mit Anwendungsabfragen konkurrieren.

> **Produktionshinweis**
>
> Ohne separate Datenbank nehmen Solid-Cache-Lese- und Schreibvorgänge an jeder umgebenden `ActiveRecord`-Transaktion teil. Das bedeutet, dass eine lang laufende Transaktion Cache-Einträge in einem nicht-commiteten Zustand hält. Für Produktionsanwendungen sollte stets eine dedizierte Cache-Datenbank konfiguriert werden.

## Sharding und Verschlüsselung

Solid Cache unterstützt das Sharding von Cache-Daten über mehrere Datenbanken zur Lastverteilung. Zusätzlich werden [verschlüsselte Attribute](https://guides.rubyonrails.org/active_record_encryption.html) unterstützt — zwischengespeicherte Daten bleiben im Ruhezustand verschlüsselt, eine Compliance-Anforderung für Anwendungen, die sensible Informationen verarbeiten.

```ruby
# config/solid_cache.yml
production:
  databases:
    - cache_shard_1
    - cache_shard_2
    - cache_shard_3
  store_options:
    max_age: 1209600  # 2 Wochen
```

Einträge werden mittels Consistent Hashing auf dem Cache-Schlüssel über die Shards verteilt. Das Hinzufügen oder Entfernen von Shards führt zu einem vorübergehenden Anstieg der Cache-Fehlquote, da Einträge neu verteilt werden, aber es gehen keine Daten verloren.

## Monitoring mit Mission Control Jobs

[Mission Control Jobs](https://github.com/rails/mission_control-jobs) bietet ein Web-Dashboard zur Inspektion und Verwaltung von Solid-Queue-Jobs. Es zeigt Worker, Warteschlangen und Job-Zustände (laufend, abgeschlossen, blockiert, fehlgeschlagen) über eine eingebundene Rails-Engine an.

```ruby
# config/routes.rb
Rails.application.routes.draw do
  mount MissionControl::Jobs::Engine, at: "/jobs"
end

# Gemfile
gem "mission_control-jobs", ">= 1.0.1"
```

Mission Control stellt auch eine Konsolen-API für Massenoperationen bei fehlgeschlagenen Jobs bereit:

```ruby
# Rails-Konsole
ActiveJob.jobs.failed.where(job_class: "ApiSyncJob").retry_all
ActiveJob.jobs.failed.where(job_class: "BrokenJob").discard_all
```

Dieser programmatische Zugriff ist unerlässlich für die Behandlung großflächiger Job-Fehler, ohne sich manuell durch ein Dashboard klicken zu müssen.

## Zentrale Fragen für technische Vorstellungsgespräche

In Interviews zu Rails 8 liegt der Fokus zunehmend auf dem Solid Stack. Die folgenden Fragen tauchen am häufigsten auf, zusammen mit der erwarteten Antworttiefe.

**F: Wie erreicht Solid Queue nebenläufige Job-Verarbeitung ohne Redis?**
Solid Queue verwendet `FOR UPDATE SKIP LOCKED`, eine SQL-Klausel, die mehreren Workern erlaubt, dieselbe Tabelle abzufragen, ohne sich gegenseitig zu blockieren. Jeder Worker sperrt einen Stapel von Zeilen, verarbeitet diese und löscht die Ausführungsdatensätze. Andere Worker überspringen bereits gesperrte Zeilen und beanspruchen andere Jobs.

**F: Welches Problem löst die transaktionale Einreihung?**
Sie verhindert, dass Jobs ausgeführt werden, bevor die Datenbanktransaktion, die sie ausgelöst hat, committed wurde. Ohne diese Garantie könnte ein Job auf einen Datensatz verweisen, der zurückgerollt wurde, was zu `ActiveRecord::RecordNotFound`-Fehlern führt.

**F: Warum verwendet Solid Cache FIFO statt LRU?**
FIFO ist in einer Datenbank einfacher zu implementieren und vermeidet die Schreibverstärkung durch das Aktualisieren von Zugriffszeitstempeln bei jedem Lesevorgang. Der Nachteil wird durch die SSD-Kapazität ausgeglichen — Einträge leben länger, sodass die Trefferquote trotz der weniger optimalen Verdrängungsstrategie hoch bleibt.

**F: Wann sollte eine Anwendung weiterhin Redis statt dem Solid Stack verwenden?**
Redis bleibt überlegen für Anwendungen, die mehr als 10.000 Jobs pro Minute verarbeiten, für Workloads, die Cache-Lesezeiten unter einer Millisekunde erfordern, oder für Anwendungen, die Redis bereits für andere Zwecke nutzen (Pub/Sub, Rate Limiting, Session-Speicherung). Der Solid Stack zielt auf Einfachheit, nicht auf maximalen Durchsatz.

Diese und weitere Fragen lassen sich auf [SharpSkills Modul zu ActiveJob und Hintergrund-Jobs](/technologies/ruby-on-rails/interview-questions/active-job-background-jobs) sowie dem [Modul zu Caching-Strategien](/technologies/ruby-on-rails/interview-questions/caching-strategies) üben.

## Fazit

- Solid Queue ersetzt Redis-gestützte Job-Warteschlangen durch eine datenbankgestützte Lösung mit `FOR UPDATE SKIP LOCKED` für nebenläufige Verarbeitung
- Transaktionale Einreihung eliminiert Race Conditions zwischen Datenbankschreibvorgängen und Job-Ausführung — eine Garantie, die Redis nicht bieten kann
- Integrierte Nebenläufigkeitskontrollen, wiederkehrende Jobs und Puma-Integration sind ohne Zusatzkosten in Solid Queue enthalten
- Solid Cache nutzt SSD-gestütztes FIFO-Caching mit optionalem Sharding und Verschlüsselung und entfernt Memcached sowie Redis aus dem Infrastruktur-Stack
- Eine separate Datenbankkonfiguration für Solid Cache verhindert, dass Cache-Operationen die Performance der Hauptdatenbank beeinträchtigen
- Mission Control Jobs bietet Produktionsmonitoring und Massen-Job-Verwaltung über ein Web-Dashboard und eine Konsolen-API
- Für die meisten Rails-8-Anwendungen im Jahr 2026 ist der Solid Stack die empfohlene Standardwahl — Redis bleibt nur für Hochdurchsatz-Grenzfälle mit über 10.000 Jobs pro Minute die bevorzugte Option

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/ruby-on-rails/solid-queue-solid-cache-rails-8-guide