# Ruby on Rails 8: Przewodnik po Nowych Funkcjach i Migracji 2026

> Rails 8 wprowadza Solid Trifecta, natywne uwierzytelnianie, Kamal 2 oraz Propshaft. Kompleksowy przewodnik z przykładami kodu i krokami migracji z 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 stanowi punkt zwrotny w historii tego frameworka. Wydany w listopadzie 2024 roku i ugruntowany wraz z Rails 8.1 w październiku 2025, ten cykl wydań eliminuje zewnętrzne zależności, które od lat obciążały architektury produkcyjne. Redis, Sprockets, Capistrano - wszystkie te komponenty Rails 8 czyni opcjonalnymi dzięki wbudowanym alternatywom opartym na bazie danych. Dla zespołów programistycznych ta przebudowa znacząco upraszcza wdrożenia, redukuje koszty infrastruktury i obniża barierę wejścia dla projektów średniej wielkości.

> **Rails 8 w skrócie**
>
> Rails 8 zastępuje Redis przez Solid Trifecta (Solid Queue, Solid Cache, Solid Cable), integruje natywny generator uwierzytelniania, przyjmuje Propshaft jako domyślny pipeline zasobów i zawiera Kamal 2 do wdrożeń bez przestojów. Wymagany jest Ruby 3.2 lub nowszy.

## Solid Trifecta: infrastruktura oparta na bazie danych

Przed Rails 8 każda poważna aplikacja produkcyjna zależała od Redis dla trzech krytycznych funkcji: zadań w tle, cache oraz pub/sub WebSocket. Solid Trifecta zastępuje te trzy elementy adapterami kompatybilnymi z PostgreSQL, MySQL i SQLite, bezpośrednio zarządzanymi przez istniejącą relacyjną bazę danych.

Korzyść operacyjna jest natychmiastowa: nie trzeba już provisionować, monitorować i utrzymywać osobnej instancji Redis. Kompromis dotyczy surowej wydajności. Redis pozostaje szybszy w scenariuszach o bardzo wysokiej przepustowości, ale dla zdecydowanej większości aplikacji adaptery oparte na bazie danych oferują w pełni wystarczającą wydajność. Basecamp, flagowa aplikacja 37signals, obsługuje 10 TB Solid Cache w produkcji z 60-dniowym okresem retencji.

### Solid Queue: zadania w tle bez Redis

Solid Queue zastępuje Sidekiq, Resque lub Delayed Job jako backend Active Job oparty na bazie danych. Wykorzystuje `FOR UPDATE SKIP LOCKED` na PostgreSQL 9.5+ i MySQL 8.0+, z mechanizmem fallback dla 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
```

Plugin Puma uruchamia Solid Queue obok serwera web w środowisku deweloperskim, co eliminuje konieczność uruchamiania osobnego procesu:

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

Solid Queue obsługuje zadania cykliczne, kontrolę współbieżności oraz zaawansowane funkcje takie jak wstrzymywanie i wznawianie według kolejki. Dla aplikacji przetwarzających mniej niż 10 000 zadań na minutę, absorbuje obciążenie bez trudności.

### Solid Cache i Solid Cable

Solid Cache przechowuje fragmenty HTML w bazie danych zamiast w Memcached lub Redis. Przechowywanie na dysku (SSD/NVMe) kosztuje ułamek ceny RAM, co pozwala na znacznie większe pule cache z dłuższym okresem retencji.

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

Solid Cable zastępuje adapter pub/sub Redis w Action Cable. Wiadomości WebSocket są zapisywane w tabeli i odpytywane co 100 ms domyślnie. Rezultat: komunikacja niemal w czasie rzeczywistym dla większości przypadków użycia, z automatycznym czyszczeniem wiadomości po 24 godzinach.

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

## Natywny generator uwierzytelniania

Rails 8 integruje generator uwierzytelniania, który tworzy scaffolding niezbędny do logowania, wylogowywania i resetowania hasła. Żadna zewnętrzna gem nie jest wymagana do podstawowego uwierzytelniania.

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

To polecenie tworzy model User, model Session, SessionsController, PasswordsController oraz concern Authentication. Wygenerowany kod używa `has_secure_password` z bcrypt i zawiera limitowanie prób (10 prób logowania co 3 minuty na IP).

```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
```

Resetowanie hasła opiera się na podpisanych tokenach z wygaśnięciem, generowanych przez `has_secure_password`, a nie na tokenach przechowywanych w bazie. Generator celowo nie zawiera rejestracji, weryfikacji adresu e-mail ani uwierzytelniania społecznościowego. Wygenerowany kod stanowi solidną bazę do rozbudowy, nie pełne zastąpienie Devise.

> **Zakres generatora**
>
> Natywny generator obejmuje logowanie, wylogowywanie i resetowanie hasła. Rejestracja użytkownika, weryfikacja e-mail, OAuth i uwierzytelnianie wieloskładnikowe muszą być dodane ręcznie lub za pomocą gemów takich jak Authentication Zero.

## Bezpieczna obsługa parametrów z params.expect

Rails 8 wprowadza `params.expect`, bardziej rygorystyczną alternatywę dla tradycyjnego `params.require.permit`. Nowa metoda rzuca wyjątek gdy brakuje kluczy, zamiast zwracać `nil` po cichu.

```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
```

Metoda `expect` gwarantuje, że klucz `:user` istnieje i zawiera tylko dozwolone atrybuty. W przypadku braku natychmiast rzuca `ActionController::ParameterMissing`, co zapobiega cichym błędom w dalszym przepływie wykonania.

## Propshaft: nowy domyślny pipeline zasobów

Propshaft zastępuje Sprockets jako domyślny pipeline zasobów. Tam gdzie Sprockets obsługiwał kompilację, minifikację i fingerprinting w monolitycznym systemie, Propshaft koncentruje się wyłącznie na serwowaniu i fingerprintingu plików statycznych.

Do bundlowania JavaScript Propshaft deleguje do nowoczesnych narzędzi: esbuild, Vite lub Bun. Przetwarzanie CSS przechodzi przez Tailwind CLI lub dart-sass. Rezultatem jest szybszy, bardziej przewidywalny pipeline zasobów, dopasowany do obecnego ekosystemu frontend.

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

Istniejące aplikacje korzystające ze Sprockets mogą nadal to robić bez ograniczeń. Migracja polega na usunięciu dyrektyw specyficznych dla Sprockets (`//= require`) i przyjęciu import maps lub bundlera JavaScript.

## Kamal 2 i Thruster: wdrożenia bez przestojów

Rails 8 jest wstępnie skonfigurowany z Kamal 2, narzędziem do wdrożeń zdolnym przekształcić czysty serwer Linux w serwer produkcyjny jednym poleceniem. Kamal 2 zastępuje Traefik przez Kamal Proxy, reverse proxy zaprojektowany specjalnie do tego celu.

```bash
kamal setup
kamal deploy
```

Thruster znajduje się między Kamal Proxy a Puma. Zapewnia akcelerację X-Sendfile dla pobierania plików, automatyczną kompresję zasobów (gzip/brotli) oraz wsparcie HTTP/2. Dockerfile generowany przez Rails 8 zawiera Thruster domyślnie.

```dockerfile
RUN gem install thruster
CMD ["thrust", "./bin/rails", "server"]
```

Ten stack technologiczny (Kamal 2 + Kamal Proxy + Thruster + Puma) obsługuje terminację SSL, wdrożenia bez przestojów i stopniowe restarty bez korzystania z zewnętrznych serwisów jak Nginx czy HAProxy.

## Wzmocnione wsparcie SQLite dla produkcji

Rails 8 znacząco poprawia wsparcie SQLite w produkcji. Connection pooling, tryb WAL i ulepszona współbieżność czynią SQLite odpowiednim dla małych i średnich aplikacji. W połączeniu z Solid Trifecta, pojedynczy serwer może obsługiwać aplikację Rails 8 całkowicie na SQLite, bez żadnego zewnętrznego serwera bazy danych.

```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
```

Ta konfiguracja uruchamia cały stack aplikacji z czterech plików SQLite. Kamal montuje katalog storage jako persistent volume, gwarantując że dane przetrwają restarty kontenerów.

## Migracja z Rails 7 do Rails 8

Migracja z Rails 7.2 do Rails 8.0 przebiega płynnie, pod warunkiem że aplikacja wcześniej naprawiła ostrzeżenia o deprecjacji. Aplikacje na Rails 7.0 lub 7.1 muszą przechodzić etapami: z 7.0 do 7.1, potem z 7.1 do 7.2, a na końcu z 7.2 do 8.0.

> **Wymagania wstępne**
>
> Rails 8 wymaga Ruby 3.2 lub nowszego. Należy zweryfikować zainstalowaną wersję Ruby, upewnić się że testy przechodzą pod Rails 7.2 i sprawdzić kompatybilność gemów przez RailsBump przed rozpoczęciem aktualizacji.

### Krok 1: aktualizacja zależności

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

```bash
bundle update rails
```

### Krok 2: uruchomienie zadania aktualizacji

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

To polecenie aktualizuje pliki konfiguracyjne do domyślnych wartości Rails 8. Istotne jest przejrzenie każdej zmiany za pomocą `git diff`. Godne uwagi zmiany obejmują nową domyślną wartość `Regexp.timeout` (1 sekunda), zmienione zachowanie `db:migrate` (ładowanie schematu na pustych bazach) oraz konfigurację Propshaft.

### Krok 3: obsługa reorganizacji schematu

Rails 8 zmienia kolejność kolumn w `schema.rb` aby odzwierciedlić rzeczywistą kolejność kolumn w bazie. Zaleca się natychmiastowe wykonanie zrzutu schematu, aby wyizolować tę kosmetyczną zmianę od rzeczywistych zmian migracji:

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

### Krok 4: stopniowe przyjmowanie nowych funkcji

Solid Trifecta, Propshaft i generator uwierzytelniania pozostają opcjonalne dla istniejących aplikacji. Lepiej jest je przyjmować indywidualnie po ustabilizowaniu głównej aktualizacji:

1. Zamienić adapter zadań na Solid Queue
2. Przełączyć store cache na Solid Cache
3. Migrować Action Cable do Solid Cable (jeśli dotyczy)
4. Ocenić migrację pipeline zasobów do Propshaft

### Krok 5: modernizacja obsługi parametrów

Zamienić wywołania `params.require.permit` na `params.expect` we wszystkich kontrolerach. Ta zmiana jest opcjonalna, ale silnie zalecana dla bardziej solidnej walidacji parametrów.

## Rails 8.1: Continuable Jobs i wbudowane CI

Rails 8.1, wydany w październiku 2025, rozszerza fundamenty położone przez Rails 8 o dwie znaczące funkcje. Continuable Jobs (`ActiveJob::Continuable`) dzielą długotrwałe zadania na kroki, które są automatycznie wznawiane. Jeśli serwer restartuje się w środku importu, zadanie wznawia się dokładnie tam gdzie się zatrzymało, zamiast zaczynać od nowa.

```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 wprowadza również wbudowaną konfigurację CI oraz natywne renderowanie Markdown, jeszcze bardziej redukując zewnętrzne zależności.

## Podsumowanie

Rails 8 reprezentuje znaczący zwrot w filozofii frameworka, przedkładając prostotę operacyjną bez kompromisów w zakresie funkcjonalności. Kluczowe punkty do zapamiętania:

- Solid Trifecta (Queue, Cache, Cable) eliminuje Redis jako obowiązkową zależność dla zadań, cache i WebSocketów
- Natywny generator uwierzytelniania zapewnia bazę dla uwierzytelniania opartego na sesjach bez zewnętrznych gemów
- `params.expect` zastępuje `params.require.permit` bardziej rygorystyczną i bezpieczniejszą obsługą parametrów
- Propshaft zastępuje Sprockets jako domyślny pipeline zasobów, delegując bundlowanie do nowoczesnych narzędzi
- Kamal 2 i Thruster umożliwiają wdrożenia bez przestojów bez korzystania z Nginx czy Capistrano
- Migracja z Rails 7.2 jest inkrementalna: aktualizacja zależności, uruchomienie `app:update` i stopniowe przyjmowanie nowych funkcji
- Rails 8.1 dodaje Continuable Jobs i wbudowane CI dla zespołów chcących zredukować zewnętrzne narzędzia

---

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