# 2026'da Rails API Modu: RESTful API, Serializasyon ve Mulakat Sorulari

> Rails API-only modu ile production-ready RESTful API gelistirme: Alba ve jsonapi-serializer ile JSON serializasyonu, JWT authentication, hata yonetimi ve RSpec testleri.

- Published: 2026-06-12
- Updated: 2026-06-12
- Author: SharpSkill
- Tags: Ruby on Rails, API, REST, Serialization, Interview
- Reading time: 8 min

---

Rails API modu, 2026 yilinda modern web ve mobil uygulamalarin backend katmanini olusturmak icin en yaygin tercih edilen yaklasimlardan biri olmaya devam ediyor. React, Vue veya mobil istemciler icin RESTful endpoint'ler gelistirildiginde, Rails'in API-only modu gereksiz gorunum katmanini, session middleware'lerini ve asset pipeline'i kaldirarak hem performans hem de kod netligi saglar. Bu rehber, Rails 8 ile production-grade API gelistirme surecini, serializasyon stratejilerini, JWT authentication desenlerini, hata yonetimini ve teknik mulakatlarda sikca karsilasilan konulari ayrintili olarak ele alir.

> **Hizli Ozet**
>
> Rails API modu, oturum yonetimi, cookie'ler, gorunum katmani ve asset pipeline middleware'lerini kaldirarak hafif bir yapi sunar. Sonuc olarak JSON yanitlari icin optimize edilmis, mobil backend'ler, mikro hizmetler ve ayristirilmis SPA mimarileri icin ideal bir stack elde edilir.

## Rails 8 API-Only Uygulama Kurulumu

Rails 8 ile API-only bir proje olusturmak, gereksiz middleware ve gorunum bilesenlerini kaldirarak optimize edilmis bir yapi sunar. `--api` bayragi, `ApplicationController` sinifini `ActionController::Base` yerine `ActionController::API` uzerinden yapilandirir ve tarayiciya ozgu 15'ten fazla middleware katmanini devre disi birakir.

```ruby
# Terminal command
rails new order_service --api --database=postgresql
```

Bu komut, view template'leri, asset derleme veya session cookie'leri olmayan bir proje olusturur. Olusturulan `application.rb` dosyasinda `config.api_only = true` ayari bulunur ve middleware yigini minimal seviyede tutulur.

Mevcut tam donanımli Rails uygulamalarina API namespace'i eklemek icin farkli bir yaklasim izlenir. `ActionController::API`'den tureyen bir base API controller olusturulur ve API route'lari versiyonlanmis bir namespace altinda tanimlanir.

```ruby
# app/controllers/api/v1/base_controller.rb
module Api
  module V1
    class BaseController < ActionController::API
      before_action :authenticate_request

      private

      def authenticate_request
        # Token validation logic
      end
    end
  end
end
```

Bu desen, mevcut tam donanımli uygulamayi korurken ayri bir API katmani eklenmesini saglar. Tum API controller'lari bu base class'tan turetilerek ortaklastirilmis authentication ve hata yonetimi davranislari miras alinir.

## RESTful Route Tasarimi ve Versiyonlama

Temiz RESTful route tasarimi, API'nin kullanilabilirligini ve surdurulebilirligini dogrudan etkiler. Rails routing DSL, kaynak hiyerarsilerini ifade etmeyi kolaylastirir; ancak bazi konvansiyonlara uyum, saglam API'leri kirilgan olanlardan ayirir.

```ruby
# config/routes.rb
Rails.application.routes.draw do
  namespace :api do
    namespace :v1 do
      resources :users, only: [:index, :show, :create, :update] do
        resources :orders, only: [:index, :show, :create]
      end

      resources :products, only: [:index, :show] do
        collection do
          get :search
        end
      end

      resource :session, only: [:create, :destroy]
    end
  end
end
```

Temel konvansiyonlar asagidaki gibidir:

- **Namespace versiyonlama** (`/api/v1/`): Header tabanli versiyonlamaya gore daha basit ve cache dostu bir yaklasimdir
- **Sig ic ice gecme**: Tek seviyeyle sinirli tutulmalidir. `/users/:user_id/orders` uygun bir yapidir ancak `/users/:user_id/orders/:order_id/items` yerine `/orders/:order_id/items` tercih edilmelidir
- **Tekil kaynaklar**: Mevcut kullanicinin oturumunu veya profilini temsil eden endpoint'ler icin `resource` (cogul degil) kullanilir

> **Versiyon Kullanimdan Kaldirma**
>
> Bir API versiyonunu kullanimdan kaldirirken, istemcileri sessizce kirmak yerine HTTP 410 Gone yaniti ile birlikte yeni versiyona yonlendiren bir JSON govdesi dondurulmesi onerilen yaklasimdir.

## JSON Serializasyonu: Alba ve jsonapi-serializer

Serializasyon, ActiveRecord nesnelerinin JSON yanitlarina nasil donusturulecegini belirler. Serializer secimi yanit surelerini, payload yapisini ve API sozlesme esnekligini dogrudan etkiler. 2026 yilinda Rails ekosisteminde iki kutuphane one cikar: hiz ve basitlik icin Alba, JSON:API spec uyumlulugu icin jsonapi-serializer.

### Alba: Bagimliliksiz Yuksek Performans

Alba, Ruby nesnelerini eski alternatiflere gore 10 kata kadar daha hizli serialize eder. Sifir bagimliliga sahiptir ve hafif API servisleri icin ideal bir secimdir.

```ruby
# app/resources/user_resource.rb
class UserResource
  include Alba::Resource

  root_key :user, :users

  attributes :id, :email, :name, :created_at

  attribute :full_name do |user|
    "#{user.first_name} #{user.last_name}"
  end

  many :orders, resource: OrderResource

  # Conditional attributes based on context
  attribute :admin_notes, if: proc { |user, params|
    params[:current_user]&.admin?
  }
end
```

Alba resource dosyalari controller icerisinde dogrudan kullanilir. Asagidaki ornekte `UserResource` sinifinin hem tekil hem de koleksiyon yanitlarinda nasil kullanildigi gorulmektedir.

```ruby
# app/controllers/api/v1/users_controller.rb
class Api::V1::UsersController < Api::V1::BaseController
  def show
    user = User.includes(:orders).find(params[:id])
    render json: UserResource.new(user, params: { current_user: current_user })
  end

  def index
    users = User.where(active: true).page(params[:page])
    render json: UserResource.new(users)
  end
end
```

### jsonapi-serializer: Kati Spec Uyumlulugu

API tuketicileri `data`, `type`, `attributes` ve `relationships` anahtarlariyla JSON:API formatinda yanitlar beklediginde, `jsonapi-serializer` (Netflix'in fast_jsonapi kutuphanesinin surdurulen fork'u) bu formatlama islemini otomatik olarak gerceklestirir.

```ruby
# app/serializers/user_serializer.rb
class UserSerializer
  include JSONAPI::Serializer

  set_type :user
  set_id :id

  attributes :email, :name, :created_at

  has_many :orders, serializer: OrderSerializer

  # Cache at the serializer level for high-traffic endpoints
  cache_options store: Rails.cache, namespace: "jsonapi", expires_in: 1.hour
end
```

Secim projenin gereksinimlerine baglidir. Dahili API'ler, mikro hizmetler ve payload esnekliginin onemli oldugu mobil backend'ler icin Alba tercih edilir. Standart sozlesmelerin entegrasyon surtunmesini azalttigi genel API'ler icin jsonapi-serializer daha uygun bir secimdir.

## Rails API'leri icin Kimlik Dogrulama Desenleri

Rails 8, session tabanli authentication'i iskeletleyen yerlesik bir kimlik dogrulama olusturucusu sunmustur. Bunu API-only moda uyarlamak, cookie oturumlarini token tabanli kimlik dogrulama ile degistirmeyi gerektirir. Iki yaygin desen bulunur: stateless mimariler icin JWT ve daha basit iptal mekanizmasi icin opaque bearer token'lar.

### Kisa Omurlu JWT Token'lar

JWT, stateless authentication icin yaygin bir standarttir. Asagidaki servis sinifi, token olusturma ve cozumleme islemlerini kapsullemektedir.

```ruby
# app/services/jwt_service.rb
class JwtService
  SECRET = Rails.application.credentials.jwt_secret_key
  ALGORITHM = "HS256"

  def self.encode(payload, exp: 15.minutes.from_now)
    payload[:exp] = exp.to_i
    JWT.encode(payload, SECRET, ALGORITHM)
  end

  def self.decode(token)
    body = JWT.decode(token, SECRET, true, algorithm: ALGORITHM).first
    HashWithIndifferentAccess.new(body)
  rescue JWT::ExpiredSignature, JWT::DecodeError => e
    nil
  end
end
```

JWT servisi bir concern icerisinde kullanilarak tum API controller'larina uygulanir. Asagidaki concern, her istekte Authorization header'indan token'i cikarir ve dogrular.

```ruby
# app/controllers/concerns/jwt_authenticatable.rb
module JwtAuthenticatable
  extend ActiveSupport::Concern

  included do
    before_action :authenticate_request
  end

  private

  def authenticate_request
    token = request.headers["Authorization"]&.split(" ")&.last
    decoded = JwtService.decode(token)

    if decoded
      @current_user = User.find_by(id: decoded[:user_id])
    end

    render json: { error: "Unauthorized" }, status: :unauthorized unless @current_user
  end

  def current_user
    @current_user
  end
end
```

Kisa omurlu erisim token'lari (15 dakika) ile refresh token rotasyonu guvenli bir denge saglar. Erisim token'i stateless kalirken, veritabaninda saklanan refresh token'lar sifre degisikligi veya cikis isleminde iptal edilebilir.

### Opaque Bearer Token'lar

Her istekte veritabani sorgusu kabul edilebilir olan daha basit API'ler icin `has_secure_token` dogrudan bir yaklasim sunar.

```ruby
# app/models/user.rb
class User < ApplicationRecord
  has_secure_password
  has_secure_token :api_token

  def regenerate_api_token!
    regenerate_api_token
  end
end
```

Opaque token'lar iptali basitlestirir (token silinir veya yeniden olusturulur) ancak her kimlik dogrulamali istekte veritabani sorgusu gerektirir. Dusuk trafik hacmine sahip dahili API'ler icin bu trade-off kabul edilebilir duzeydedir.

> **Token Auth icin CSRF'yi Devre Disi Birakin**
>
> Token tabanli kimlik dogrulama kullanan API controller'lari CSRF dogrulamasini atlamalidir. `skip_before_action :verify_authenticity_token` ekleyin veya varsayilan olarak CSRF middleware icermeyen `ActionController::API`'den turetin.

## API Genelinde Yapilandirilmis Hata Yonetimi

Tutarli hata yanitlari, profesyonel API'leri prototiplerden ayiran temel unsurlardan biridir. Merkezi bir hata yoneticisi, Rails'in varsayilan HTML hata sayfalarini dondurmesini engeller ve her basarisizligin yapilandirilmis JSON dondurmesini garantiler.

```ruby
# app/controllers/concerns/error_handler.rb
module ErrorHandler
  extend ActiveSupport::Concern

  included do
    rescue_from ActiveRecord::RecordNotFound, with: :not_found
    rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
    rescue_from ActionController::ParameterMissing, with: :bad_request
  end

  private

  def not_found(exception)
    render json: {
      error: "not_found",
      message: "Resource not found",
      details: exception.message
    }, status: :not_found
  end

  def unprocessable_entity(exception)
    render json: {
      error: "validation_failed",
      message: "Validation failed",
      details: exception.record.errors.full_messages
    }, status: :unprocessable_entity
  end

  def bad_request(exception)
    render json: {
      error: "bad_request",
      message: "Missing required parameter",
      details: exception.message
    }, status: :bad_request
  end
end
```

Bu concern, base API controller'a dahil edilir. Boylece her endpoint uygun HTTP durum kodlari, makine tarafindan okunabilir hata tipleri ve insan tarafindan okunabilir mesajlarla ongorulebilir JSON hatalari dondurur. Production ortaminda bu yaklasim, API tuketicilerinin hata durumlarini programatik olarak islemesini kolaylastirir.

## Sayfalama ve Yanit Optimizasyonu

Sinirsiz sorgular, performans dususunun en hizli yoludur. Her liste endpoint'i sonuclari sayfalamalı ve sayfalama meta verilerini acikca iletmelidir.

```ruby
# app/controllers/api/v1/products_controller.rb
class Api::V1::ProductsController < Api::V1::BaseController
  def index
    products = Product
      .where(active: true)
      .order(created_at: :desc)
      .page(params[:page])
      .per(params[:per_page] || 25)

    render json: {
      data: ProductResource.new(products).serializable_hash,
      meta: {
        current_page: products.current_page,
        total_pages: products.total_pages,
        total_count: products.total_count
      }
    }
  end
end
```

Sayfalama otesinde, API yanit surelerinde olculebilir fark yaratan uc temel optimizasyon bulunur:

- **Eager loading**: `includes` veya `preload` ile veritabani round-trip'lerini coglaltan N+1 sorgulari ortadan kaldirilir
- **Sadece gerekli sutunlar**: Serializer'lar model ozniteliklerinin bir alt kumesini kullandiginda `.select(:id, :name, :price)` ile sorgu optimize edilir
- **HTTP cache header'lari**: `stale?` ve `fresh_when` araclariyla istemciler ve CDN'ler ozel mantik olmadan yanitlari cache'leyebilir

## Rails API Endpoint'lerini RSpec ile Test Etme

API testleri durum kodlarini, yanit yapisini ve kimlik dogrulama kapilarini dogrulamalidir. RSpec'teki request spec'leri tam middleware yiginini test eder ve gercek API davranisinin en yakin temsilidir.

```ruby
# spec/requests/api/v1/users_spec.rb
RSpec.describe "Api::V1::Users", type: :request do
  let(:user) { create(:user) }
  let(:token) { JwtService.encode(user_id: user.id) }
  let(:headers) { { "Authorization" => "Bearer #{token}" } }

  describe "GET /api/v1/users/:id" do
    it "returns the user with correct structure" do
      get "/api/v1/users/#{user.id}", headers: headers

      expect(response).to have_http_status(:ok)
      json = JSON.parse(response.body)
      expect(json["user"]).to include(
        "id" => user.id,
        "email" => user.email,
        "name" => user.name
      )
    end

    it "returns 401 without authentication" do
      get "/api/v1/users/#{user.id}"

      expect(response).to have_http_status(:unauthorized)
    end

    it "returns 404 for non-existent user" do
      get "/api/v1/users/0", headers: headers

      expect(response).to have_http_status(:not_found)
      json = JSON.parse(response.body)
      expect(json["error"]).to eq("not_found")
    end
  end
end
```

Bu testler, her API endpoint'inin ele almasi gereken uc temel senaryoyu kapsar: basarili yanit yapisi, kimlik dogrulama zorunlulugu ve hata yanit formati. Request spec'leri, controller spec'lerinin aksine routing, middleware ve serialization katmanlarini da icerir.

## Rails 8.1 API Ozellikleri

Rails 8.1 (Ekim 2025'te yayinlanan), API gelistirmeyle dogrudan ilgili onemli yetenekler ekledi:

- **Continuable Jobs**: Uzun suren arka plan gorevlerinin (veri ice aktarma, toplu isleme) dagitimlar veya yeniden baslatmalar sonrasinda son kontrol noktasindan devam etmesini saglar
- **Structured Event Logging**: `Rails.event.notify(...)` araciyla ozel enstrumantasyon kodu olmadan APM platformlari (Datadog, New Relic) tarafindan tuketilebilir olaylar yayinlar
- **Deprecated Associations**: `:warn`, `:raise` veya `:notify` modlariyla isaretlenebilir, ekiplerin buyuk API kod tabanlarinda eski iliskileri asamali olarak kaldirmasina yardimci olur

Bu ozellikler API projelerinde sablon kodu azaltir ve gozlemlenebilirligi artirir.

## Sonuc

Rails API modu ile production-ready backend servisleri gelistirmek icin asagidaki temel ilkeler goz onunde bulundurulmalidir:

- **`--api` modunu kullanin**: Ayristirilmis API servisleri icin gereksiz middleware'i ortadan kaldirarak yanit gecikmesini azaltin
- **Sozlesmeye uygun bir serializer secin**: Hiz ve esneklik icin Alba, kati JSON:API uyumlulugu icin jsonapi-serializer
- **Token kimlik dogrulamasi uygulayin**: Kisa omurlu JWT'ler ve refresh rotasyonu veya daha basit iptal ihtiyaclari icin opaque bearer token'lar
- **Hata yonetimini merkezilestirin**: Paylasilan bir concern'de her endpoint'in tutarli hata tipleriyle yapilandirilmis JSON dondurmesini saglayin
- **Her liste endpoint'ini sayfalayin** ve N+1 sorgularini production'a ulasmadan eager loading ile ortadan kaldirin
- **Request spec'lerle test edin**: Uc temel senaryoya karsi dogrulama yapin: basari yapisi, auth zorunlulugu ve hata formati
- **Rails 8.1 ozelliklerini benimseyin**: Continuable jobs ve structured events ile API servislerinde guvenilirlik ve gozlemlenebilirligi artirin

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/ruby-on-rails/rails-api-mode-restful-serialization-best-practices