# Ruby on Rails 8: Nieuwe Functies en Migratiehandleiding 2026

> Rails 8 introduceert de Solid Trifecta, native authenticatie, Kamal 2 en Propshaft. Uitgebreide handleiding met codevoorbeelden en migratiestappen vanaf Rails 7.

- Published: 2026-04-17
- Updated: 2026-04-17
- Author: SharpSkill
- Tags: ruby-on-rails, rails-8, tutorial, migration, solid-queue, solid-cache, authentication
- Reading time: 9 min

---

Ruby on Rails 8 vormt het meest ingrijpende release sinds Rails 7 en vervangt externe afhankelijkheden die jarenlang de productie-architectuur van Rails-applicaties hebben bepaald. Redis, Sprockets en Capistrano worden optioneel dankzij ingebouwde alternatieven die rechtstreeks op de database draaien. Sinds de publicatie in november 2024 en de uitbreiding met Rails 8.1 in oktober 2025 biedt het framework een aanzienlijk vereenvoudigde infrastructuur. Voor ontwikkelteams in de Benelux en het bredere Nederlandstalige gebied betekent dit lagere operationele kosten, minder bewegende onderdelen in productie en een lagere instapdrempel voor middelgrote projecten.

> **Rails 8 in het kort**
>
> Rails 8 vervangt Redis door de Solid Trifecta (Solid Queue, Solid Cache, Solid Cable), bevat een native authenticatiegenerator, maakt Propshaft de standaard asset-pipeline en levert Kamal 2 voor zero-downtime deployments. Ruby 3.2 of hoger is vereist.

## De Solid Trifecta: infrastructuur op databaseniveau

Voor Rails 8 was vrijwel elke serieuze productieapplicatie afhankelijk van Redis voor drie kritieke functies: achtergrondtaken, caching en WebSocket pub/sub. De Solid Trifecta vervangt deze drie bouwstenen door adapters die compatibel zijn met PostgreSQL, MySQL en SQLite, aangestuurd door de bestaande relationele database.

Het operationele voordeel is direct merkbaar: geen aparte Redis-instantie meer om in te richten, te bewaken en te onderhouden. De afweging betreft ruwe prestaties. Redis blijft sneller in scenario's met extreem hoge doorvoer, maar voor het overgrote deel van de applicaties bieden de database-adapters ruim voldoende prestaties. Basecamp, de vlaggenschipapplicatie van 37signals, draait een Solid Cache van 10 TB in productie met een retentieperiode van 60 dagen.

### Solid Queue: achtergrondtaken zonder Redis

Solid Queue vervangt Sidekiq, Resque of Delayed Job als Active Job-backend op databaseniveau. Het maakt gebruik van `FOR UPDATE SKIP LOCKED` op PostgreSQL 9.5+ en MySQL 8.0+, met een terugvalmechanisme voor SQLite.

```ruby
# config/environments/production.rb
config.active_job.queue_adapter = :solid_queue

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

De Puma-plugin start Solid Queue samen met de webserver in de ontwikkelomgeving, waardoor een apart proces overbodig wordt:

```ruby
# config/puma.rb
plugin :solid_queue if ENV["SOLID_QUEUE_IN_PUMA"] || Rails.env.development?
```

Solid Queue ondersteunt terugkerende taken, concurrentiebeheer en geavanceerde functionaliteit zoals het pauzeren en hervatten per wachtrij. Voor applicaties die minder dan 10.000 taken per minuut verwerken, kan het de belasting probleemloos aan.

### Solid Cache en Solid Cable

Solid Cache slaat gecachte HTML-fragmenten op in de database in plaats van in Memcached of Redis. Opslag op schijf (SSD/NVMe) kost een fractie van de prijs van RAM, waardoor aanzienlijk grotere cachepools met langere retentie mogelijk zijn.

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

Solid Cable vervangt de Redis pub/sub-adapter van Action Cable. WebSocket-berichten worden naar een databasetabel geschreven en standaard elke 100 ms uitgelezen. Het resultaat is nagenoeg realtime communicatie voor de meeste toepassingen, met automatische opruiming van berichten na 24 uur.

```yaml
# config/cable.yml
production:
  adapter: solid_cable
  polling_interval: 0.1
  keep_messages_around_for: 1.day
```

## De native authenticatiegenerator

Rails 8 bevat een authenticatiegenerator die de benodigde scaffolding produceert voor inloggen, uitloggen en wachtwoordherstel op basis van sessies. Er zijn geen externe gems nodig voor standaard authenticatie.

```bash
# Generate the authentication scaffolding
bin/rails generate authentication
```

Dit commando maakt het User-model, het Session-model, de SessionsController, de PasswordsController en een Authentication-concern aan. De gegenereerde code gebruikt `has_secure_password` met bcrypt en bevat rate limiting (10 inlogpogingen per 3 minuten per IP-adres).

```ruby
# app/controllers/concerns/authentication.rb
module Authentication
  extend ActiveSupport::Concern

  included do
    before_action :require_authentication
    helper_method :authenticated?
  end

  private

  def require_authentication
    resume_session || request_authentication
  end

  def resume_session
    Current.session = find_session_by_cookie
  end

  def find_session_by_cookie
    Session.find_by(id: cookies.signed[:session_id]) if cookies.signed[:session_id]
  end

  def request_authentication
    session[:return_to_after_authenticating] = request.url
    redirect_to new_session_path
  end

  def authenticated?
    Current.session.present?
  end
end
```

Wachtwoordherstel maakt gebruik van ondertekende tokens met vervaldatum, gegenereerd door `has_secure_password`, in plaats van tokens die in de database worden opgeslagen. De generator omvat bewust geen gebruikersregistratie, e-mailverificatie of sociale login. De gegenereerde code dient als solide basis om uit te breiden, niet als volledige vervanging van Devise.

> **Reikwijdte van de generator**
>
> De native generator dekt inloggen, uitloggen en wachtwoordherstel. Gebruikersregistratie, e-mailverificatie, OAuth en multifactorauthenticatie moeten handmatig worden toegevoegd of via gems zoals Authentication Zero.

## Veiligere parameterverwerking met params.expect

Rails 8 introduceert `params.expect`, een strenger alternatief voor het traditionele `params.require.permit`-patroon. De nieuwe methode gooit een uitzondering wanneer sleutels ontbreken, in plaats van stilzwijgend `nil` terug te geven.

```ruby
# Before (Rails 7)
def user_params
  params.require(:user).permit(:name, :email, :role)
end

# After (Rails 8)
def user_params
  params.expect(user: [:name, :email, :role])
end
```

De `expect`-methode garandeert dat de `:user`-sleutel bestaat en uitsluitend de toegestane attributen bevat. Bij afwezigheid wordt onmiddellijk `ActionController::ParameterMissing` gegooid, wat stille fouten verderop in de uitvoeringsstroom voorkomt.

## Propshaft: de nieuwe standaard asset-pipeline

Propshaft vervangt Sprockets als standaard asset-pipeline. Waar Sprockets compilatie, minificatie en fingerprinting in een monolithisch systeem afhandelde, richt Propshaft zich uitsluitend op het serveren en fingerprinting van statische bestanden.

Voor JavaScript-bundeling delegeert Propshaft naar moderne tools: esbuild, Vite of Bun. CSS-verwerking verloopt via Tailwind CLI of dart-sass. Het resultaat is een snellere, voorspelbaardere asset-pipeline die aansluit bij het huidige frontend-ecosysteem.

```ruby
# Gemfile (Rails 8 default)
gem "propshaft"

# No configuration needed for basic usage
# Assets in app/assets are served and fingerprinted automatically
```

Bestaande applicaties die Sprockets gebruiken, kunnen dat zonder beperkingen blijven doen. Het migratiepad bestaat uit het verwijderen van Sprockets-specifieke directieven (`//= require`) en het overstappen op import maps of een JavaScript-bundler.

## Kamal 2 en Thruster: zero-downtime deployment

Rails 8 wordt standaard geleverd met Kamal 2, een deployment-tool waarmee een kale Linux-server met een enkel commando wordt omgezet in een productieserver. Kamal 2 vervangt Traefik door Kamal Proxy, een reverse proxy die specifiek voor dit doel is ontworpen.

```bash
# Deploy to a fresh server
kamal setup

# Subsequent deployments
kamal deploy
```

Thruster bevindt zich tussen Kamal Proxy en Puma. Het biedt X-Sendfile-versnelling voor bestandsdownloads, automatische assetcompressie (gzip/brotli) en HTTP/2-ondersteuning. Het door Rails 8 gegenereerde Dockerfile bevat Thruster standaard.

```dockerfile
# Excerpt from Rails 8 generated Dockerfile
RUN gem install thruster
CMD ["thrust", "./bin/rails", "server"]
```

Deze technologiestack (Kamal 2 + Kamal Proxy + Thruster + Puma) verzorgt SSL-terminatie, zero-downtime deployments en geleidelijke herstarts zonder externe diensten als Nginx of HAProxy.

## Verbeterde SQLite-ondersteuning voor productie

Rails 8 verbetert de ondersteuning van SQLite voor productiegebruik aanzienlijk. Connection pooling, WAL-modus en verbeterde concurrency maken SQLite een haalbare optie voor kleine en middelgrote applicaties. In combinatie met de Solid Trifecta kan een enkele server een volledige Rails 8-applicatie op SQLite draaien, zonder externe databaseserver.

```yaml
# config/database.yml (SQLite production setup)
production:
  primary:
    adapter: sqlite3
    database: storage/production.sqlite3
    pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  cache:
    adapter: sqlite3
    database: storage/production_cache.sqlite3
  queue:
    adapter: sqlite3
    database: storage/production_queue.sqlite3
  cable:
    adapter: sqlite3
    database: storage/production_cable.sqlite3
```

Deze configuratie draait de volledige applicatiestack op vier SQLite-bestanden. Kamal koppelt de opslagmap als persistent volume, waardoor gegevens containerherstarts overleven.

## Migratie van Rails 7 naar Rails 8

De migratie van Rails 7.2 naar Rails 8.0 verloopt soepel, mits de applicatie alle deprecation-waarschuwingen heeft opgelost. Applicaties op Rails 7.0 of 7.1 dienen stapsgewijs te upgraden: van 7.0 naar 7.1, vervolgens naar 7.2 en ten slotte naar 8.0.

> **Vereisten vooraf controleren**
>
> Rails 8 vereist Ruby 3.2 of hoger. Controleer de geinstalleerde Ruby-versie, zorg ervoor dat de testsuite slaagt onder Rails 7.2 en verifieer de compatibiliteit van gems via RailsBump voordat de upgrade wordt gestart.

### Stap 1: afhankelijkheden bijwerken

```ruby
# Gemfile
gem "rails", "~> 8.0"
```

```bash
bundle update rails
```

### Stap 2: de updatetaak uitvoeren

```bash
bin/rails app:update
```

Dit commando werkt de configuratiebestanden bij naar de standaardwaarden van Rails 8. Het is essentieel om elke wijziging zorgvuldig te beoordelen met `git diff`. Belangrijke wijzigingen omvatten de nieuwe standaardwaarde van `Regexp.timeout` (1 seconde), het gewijzigde gedrag van `db:migrate` (schemalade op lege databases) en de Propshaft-configuratie.

### Stap 3: schemaherschikking afhandelen

Rails 8 herschikt de kolommen in `schema.rb` zodat deze overeenkomen met de werkelijke kolomvolgorde in de database. Het verdient aanbeveling om de schemadump direct uit te voeren, zodat deze cosmetische wijziging gescheiden blijft van daadwerkelijke migratiewijzigingen:

```bash
bin/rails db:schema:dump
git add db/schema.rb
git commit -m "Reorder schema columns for Rails 8"
```

### Stap 4: nieuwe functies geleidelijk adopteren

De Solid Trifecta, Propshaft en de authenticatiegenerator zijn optioneel voor bestaande applicaties. Het is raadzaam deze afzonderlijk te adopteren nadat de hoofdupgrade is gestabiliseerd:

1. De taakadapter vervangen door Solid Queue
2. De cachestore overzetten naar Solid Cache
3. Action Cable migreren naar Solid Cable (indien van toepassing)
4. De migratie van de asset-pipeline naar Propshaft evalueren

### Stap 5: parameterverwerking moderniseren

Alle `params.require.permit`-aanroepen in de controllers vervangen door `params.expect`. Deze wijziging is optioneel maar sterk aanbevolen voor robuustere parametervalidatie.

## Rails 8.1: Continuable Jobs en ingebouwde CI

Rails 8.1, uitgebracht in oktober 2025, bouwt voort op de fundamenten van Rails 8 met twee opvallende functionaliteiten. Continuable Jobs (`ActiveJob::Continuable`) splitsen langlopende taken op in hervattbare stappen. Wanneer een server herstart tijdens een importtaak, wordt de taak exact hervat op het punt waar deze was gestopt in plaats van helemaal opnieuw te beginnen.

```ruby
# app/jobs/import_records_job.rb
class ImportRecordsJob < ApplicationJob
  include ActiveJob::Continuable

  def perform(cursor:)
    records = Record.where("id > ?", cursor.value || 0).limit(1000)

    records.each do |record|
      process(record)
      cursor.advance(record.id)
    end
  end
end
```

Rails 8.1 introduceert daarnaast een ingebouwde CI-configuratie en native Markdown-rendering, waardoor het aantal externe afhankelijkheden verder wordt teruggebracht.

## Conclusie

Rails 8 markeert een fundamentele verschuiving in de filosofie van het framework, waarbij operationele eenvoud centraal staat zonder concessies te doen aan functionaliteit. De belangrijkste punten op een rij:

- De Solid Trifecta (Queue, Cache, Cable) elimineert Redis als verplichte afhankelijkheid voor achtergrondtaken, caching en WebSockets
- De native authenticatiegenerator biedt een basis voor sessiegerichte authenticatie zonder externe gems
- `params.expect` vervangt `params.require.permit` met een striktere en veiligere parameterverwerking
- Propshaft vervangt Sprockets als standaard asset-pipeline en delegeert bundeling naar moderne tools
- Kamal 2 en Thruster maken zero-downtime deployments mogelijk zonder Nginx of Capistrano
- De migratie vanaf Rails 7.2 is incrementeel: afhankelijkheden bijwerken, `app:update` uitvoeren en nieuwe functies geleidelijk adopteren
- Rails 8.1 voegt Continuable Jobs en ingebouwde CI toe voor teams die het aantal externe tools willen reduceren

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/nl/blog/ruby-on-rails/ruby-on-rails-8-new-features-migration-guide