Ruby on Rails Rehberi: Nasıl Kullanılır

Noves Digital olarak, 10'den fazla projede Ruby on Rails'in gücünü ve esnekliğini doğrudan deneyimledik. Bu rehber, modern yazılım ajanslarında Rails ekosisteminin derinliklerine iniyor ve teknik kararların arkasındaki pratik mantığı açıklıyor. İster cross-platform mobil uygulama backend'i, ister ölçeklenebilir e-ticaret altyapısı tasarlıyor olun, bu yazı size uygulanabilir bilgiler sunacak.

1. Ruby on Rails Rehberi: Nedir ve Nasıl Kullanılır

Ruby on Rails, David Heinemeier Hansson tarafından 2004 yılında oluşturulan, Ruby dilinde yazılmış tam yığın (full-stack) bir web uygulama çerçevesidir. "Convention over Configuration" ve "Don't Repeat Yourself" (DRY) prensipleri üzerine kuruludur; bu, geliştiricinin her kararı açıkça belirtmesi yerine, makul varsayılanların otomatik olarak uygulanması anlamına gelir. Rails, startup'ların hızlı MVP çıkarmasından enterprise düzeyde SaaS ürünlerine kadar geniş bir yelpazede kullanılır.

Modern agile geliştirme süreçlerinde Rails, 2 haftalık sprintlerde hızlı iterasyon yapmayı mümkün kılar. Ekosisteminde 200.000'den fazla gem (kütüphane) bulunur; bu, neredeyse her işlev için hazır çözümler sunar. Test edilebilirlik, framework'ün DNA'sında vardır: RSpec ve Minitest ile davranış odaklı ve birim testleri kolayca yazılır. Rails 7 ve sonrası, Hotwire ve Turbo ile modern reactive UI'ları server-rendered yaklaşımla sunarak, karmaşık JavaScript framework'lerine olan bağımlılığı azaltır.

2. Temel Özellikler: MVC, Convention over Configuration, ActiveRecord

Rails'in üç temel direği, onu farklı kılan mimari kararlardır. MVC (Model-View-Controller), uygulamanın sorumluluklarını net bir şekilde ayırır. Convention over Configuration, tekrarlayan yapılandırma kodunu ortadan kaldırır. ActiveRecord, veritabanı işlemlerini Ruby nesnelerine dönüştürerek SQL yazma ihtiyacını minimize eder. Bu üçlü, geliştiricinin iş mantığına odaklanmasını sağlar.

Profesyonel ekiplerde bu prensipler, kod tekrarını azaltır ve yeni geliştiricinin projeye adapte olma süresini kısaltır. Ancak convention'ları bilmeyen bir geliştirici için "sihir" gibi görünebilir; bu yüzden Rails'in arkasındaki mantığı anlamak, sadece "nasıl" değil "neden" sorusuna cevap vermek gerekir. Framework'ün 20 yılı aşkın evrimi, bu prensiplerin pratikte nasıl şekillendiğini gösterir.

3. MVC Nedir ve Rails'te Nasıl Uygulanır

MVC (Model-View-Controller), kullanıcı arayüzü ile iş mantığını ayıran mimari bir desendir. Model, veri ve iş kurallarını temsil eder (örneğin User modeli, veritabanındaki users tablosunu soyutlar). View, kullanıcıya gösterilen arayüzdür (ERB şablonları). Controller, isteği alır, model ile etkileşime girer ve uygun view'i render eder. Bu ayrım, kodun test edilebilirliğini artırır ve bakımı kolaylaştırır.

Rails'te MVC uygulaması katıdır ama esnektir. Bir istek geldiğinde, router (config/routes.rb) isteği doğru controller'a yönlendirir. Controller, params'ı doğrular, model'i çağırır ve respond_to bloğuyla HTML, JSON veya Turbo Stream yanıtı üretir. View layer'da, layout'lar (app/views/layouts/application.html.erb) sayfa iskeletini, partial'lar (_header.html.erb) tekrar kullanılabilir parçaları sağlar. Bu yapı, hem server-rendered hem API-only uygulamalar için temeldir.

# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])
    respond_to do |format|
      format.html
      format.json { render json: @user }
    end
  end
end

4. Convention over Configuration Avantajları ve Örnekleri

"Convention over Configuration" (CoC), Rails'in en tanımlayıcı özelliğidir. Örneğin, UsersController sınıfı otomatik olarak app/views/users/ dizinindeki şablonları arar. User modeli otomatik olarak users tablosuna eşlenir. created_at ve updated_at kolonları otomatik olarak yönetilir. Bu convention'lar, onlarca satır yapılandırma kodunu ortadan kaldırır.

Avantajları somuttur: yeni bir geliştirici projeye katıldığında, app/models/user.rb'in users tablosunu temsil ettiğini tahmin eder. Bu, ekip içi bilgi transferini hızlandırır. Ancak convention'ları override etmek mümkündür: self.table_name = 'app_users' ile tablo adını değiştirebilir, to_param ile URL-friendly ID'ler üretebilirsiniz. CoC, "batteries included" felsefesinin bir uzantısıdır; yaygın senaryolar için en iyi pratik hazır gelir, özel senaryolar için kapılar açıktır.

# Convention override örneği
class User < ApplicationRecord
  self.table_name = 'app_users'
  self.primary_key = 'uuid'
  
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

5. ActiveRecord Nedir; Model İlişkileri ve Sorgu Örnekleri

ActiveRecord, Rails'in ORM (Object-Relational Mapping) katmanıdır. Tablolar Ruby sınıflarına, satırlar nesnelere, kolonlar özelliklere (attribute) dönüştürülür. User.find(1) bir SQL SELECT çalıştırır ve sonucu User nesnesine dönüştürür. Bu soyutlama, SQL bilmeden veritabanı işlemleri yapmayı mümkün kılar; ancak performans kritik noktalarda SQL'in nasıl oluşturulduğunu anlamak gerekir.

Model ilişkileri: has_many, belongs_to, has_one, has_and_belongs_to_many (HABTM) ve has_many :through. has_many :through, join model ile zengin ilişkiler sunar (örneğin User → Subscription → Magazine). Sorgu optimizasyonu için includes (eager loading, N+1 sorununu çözer), joins (inner join), preload (ayrı sorgular) kullanılır. Scope'lar, tekrar kullanılabilir sorgu parçalarıdır. Arel, ActiveRecord'un altındaki SQL AST yöneticisidir; karmaşık sorgular için kullanılır.

# Model ilişkileri ve sorgular
class Order < ApplicationRecord
  belongs_to :user
  has_many :order_items
  has_many :products, through: :order_items
  
  scope :recent, -> { where('created_at > ?', 1.week.ago) }
  scope :by_status, ->(status) { where(status: status) }
end

# Kullanım
Order.includes(:user, :products).recent.by_status('shipped')

6. Migrations ve Schema Yönetimi Teknik Detayları

Migrations, veritabanı şemasının versiyon kontrolü altında tutulmasını sağlar. rails generate migration AddEmailToUsers email:string komutu, yeni bir migration dosyası oluşturur. up ve down metodları (veya change), migration'ın ileri ve geri alınabilir olmasını sağlar. db:migrate şemayı günceller, db:rollback son migration'ı geri alır, db:seed başlangıç verisini yükler.

Production ortamlarda migration stratejisi kritiktir. Zero-downtime deployment için: 1) Yeni kolon/tablo ekle (backward-compatible), 2) Kodu yeni şemaya göre güncelle, 3) Eski kolon/tabloyu kaldır. strong_migrations gem'i, riskli migration'ları (örneğin büyük tabloda add_index without algorithm: :concurrently) engeller. Schema.rb veya structure.sql, veritabanı şemasının anlık görüntüsüdür; yeni geliştirici db:schema:load ile hızlıca kurulum yapar.

# Güvenli migration örneği
class AddIndexToOrdersStatus < ActiveRecord::Migration[7.1]
  disable_ddl_transaction!
  
  def change
    add_index :orders, :status, algorithm: :concurrently
  end
end

7. Görselleştirme ve Dokümantasyon: View, Asset Pipeline, YARD

Rails'te görselleştirme katmanı, sadece HTML üretmek değil, kullanıcı deneyiminin bütününü şekillendirir. View şablonları (ERB, Haml), asset pipeline (CSS/JS yönetimi) ve dokümantasyon araçları (YARD, RDoc), bu katmanın üç bileşenidir. Modern web uygulamalarında, server-rendered yaklaşım ile reactive UI arasında denge kurmak önemlidir.

Asset yönetimi, Rails'in evriminde önemli bir dönüm noktasıdır. Rails 6 öncesi Sprockets (Asset Pipeline) hakimdi; Rails 6 ile Webpacker geldi; Rails 7 ile jsbundling-rails ve cssbundling-rails, modern JavaScript bundler'ları (esbuild, rollup) entegre etti. Bu evrim, Rails'in modern frontend ekosistemiyle uyumlu kalmasını sağlar.

8. View Şablonları (ERB, Haml) Nasıl Kullanılır; Örnekler

ERB (Embedded Ruby), HTML içine <% %> (Ruby kodu çalıştır) ve <%= %> (Ruby kodu çalıştır ve sonucu yaz) tag'leri ekleyerek dinamik içerik üretir. Bu, PHP benzeri bir yaklaşımdır ama MVC ayrımı sayesinde daha düzenlidir. Haml, ERB'ye alternatif olarak daha az tekrarlı, daha okunabilir bir sözdizimi sunar; %div.class#id yerine .class#id yazmanız yeterlidir.

Modern Rails uygulamalarında, ViewComponent gem'i React benzeri component-based UI yaklaşımını sunar. Her component, kendi Ruby sınıfı ve şablonu ile encapsulate edilir. Bu, partial'lardan daha güçlü bir soyutlama sunar ve test edilebilirliği artırır. Stimulus (Hotwire ekosistemi), HTML'e data-controller attribute'ları ekleyerek JavaScript davranışları bağlar; bu, React/Vue karmaşıklığına girmeden interaktif UI'lar oluşturur.

<!-- ERB örneği -->
<div class="user-card">
  <h2><%= @user.name %></h2>
  <p><%= @user.bio.truncate(100) %></p>
  <%= link_to "Profili Gör", user_path(@user), class: "btn btn-primary" %>
</div>

<!-- ViewComponent örneği -->
<%= render(UserCardComponent.new(user: @user)) %>

9. Asset Pipeline ve Webpacker ile Ön Yüz Yönetimi

Asset Pipeline (Sprockets), CSS ve JavaScript dosyalarını birleştirir (concatenate), minify eder ve fingerprint ekler (application-abc123.css). Bu, HTTP istek sayısını azaltır ve cache busting sağlar. Rails 6'da Webpacker, modern JavaScript ekosistemini (npm, Babel, ES6 modules) Rails'e getirdi; app/javascript/packs/application.js entry point oldu.

Rails 7 ile yeni yaklaşım: jsbundling-rails (esbuild, rollup) ve cssbundling-rails (Tailwind, PostCSS) ile Rails Asset Pipeline (Propshaft) birlikte kullanılır. Bu, JavaScript'i npm ile yönetip, Rails'in app/assets/builds dizinine çıktı almayı sağlar. Tailwind CSS, utility-first yaklaşımıyla hızlı UI geliştirmeyi mümkün kılar; tailwindcss-rails gem'i ile entegrasyon tek komutla yapılır. Bu modern stack, performans optimizasyonu ve kullanıcı deneyimi açısından önemli avantajlar sunar.

// app/javascript/application.js (Rails 7)
import "@hotwired/turbo-rails"
import "./controllers"
import * as bootstrap from "bootstrap"

// Stimulus controller
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static targets = ["output"]
  
  greet() {
    this.outputTarget.textContent = "Merhaba, Rails!"
  }
}

10. YARD ve RDoc ile Proje Dokümantasyonu Nasıl Hazırlanır

YARD (Yet Another Ruby Documentation), Ruby kodunun dokümantasyonunu otomatik üreten araçtır. RDoc'tan daha gelişmiştir; @param, @return, @example tag'leri ile metodların imza ve kullanım örnekleri belgelenir. yard doc komutu, tüm proje kodunu tarar ve HTML dokümantasyonu üretir. Bu, büyük Rails projelerinde kod keşfi (code discovery) için kritiktir.

Dokümantasyon, sadece public API'ler için değil, karmaşık business logic'ler için de yazılmalıdır. README.md, kurulum ve mimari kararları açıklar. doc/ dizini, ADR (Architecture Decision Records) kayıtlarını tutar. API-only Rails uygulamalarında, Swagger/OpenAPI entegrasyonu (rswag gem'i) interaktif dokümantasyon sunar. Sektörde, iyi dokümante edilmiş projelerin bakım maliyeti %40 daha düşüktür; bu, teknik borcun önlenmesinde en etkili yöntemlerden biridir.

# YARD dokümantasyon örneği
# Kullanıcı siparişlerini belirli bir tarih aralığında getirir.
#
# @param start_date [Date] Başlangıç tarihi
# @param end_date [Date] Bitiş tarihi
# @return [ActiveRecord::Relation<Order>] Sipariş koleksiyonu
# @example
#   user.orders_between(Date.today - 7, Date.today)
def orders_between(start_date, end_date)
  orders.where(created_at: start_date..end_date)
end

11. Component-Based UI ve Partial Kullanımı Teknik İpuçları

Partial'lar (_form.html.erb), tekrar kullanılabilir view parçalarıdır. render partial: 'form', locals: { user: @user } ile çağrılır. Ancak partial'ların sınırları vardır: kendi durumu (state) yoktur, sadece parametre alırlar. ViewComponent, bu sınırlamayı aşar: her component kendi Ruby sınıfı, şablonu ve testi ile birimdir.

Component-based UI, Rails'te "modern frontend" yaklaşımını getirir. app/components/button_component.rb ve app/components/button_component.html.erb ile tanımlanır. Slot'lar, component içinde içerik alanları tanımlar. Preview'lar (test/components/previews), component'leri izole geliştirmeyi ve test etmeyi sağlar. Bu desen, e-ticaret ve SaaS uygulamalarında karmaşık UI'ların yönetimini kolaylaştırır; aynı component hem web'de hem mobil uygulama backend'inde kullanılabilir.

# app/components/button_component.rb
class ButtonComponent < ViewComponent::Base
  def initialize(variant: :primary, size: :md)
    @variant = variant
    @size = size
  end
  
  def css_classes
    "btn btn-#{@variant} btn-#{@size}"
  end
end

12. Yerleşim ve Dağıtım: Monolit, Mikroservis, Container Orkestrasyonu

Rails uygulamalarının dağıtım mimarisi, projenin evreline göre değişir. Başlangıçta monolitik yapı hız ve basitlik sunar. Büyüdükçe, belirli domain'ler ayrı servislere bölünebilir. Container teknolojileri (Docker, Kubernetes), bu geçişi standartlaştırır ve ölçeklenebilirlik sağlar.

Deployment stratejisi seçimi, ekibin operasyonel yetkinliğine bağlıdır. Heroku gibi PaaS çözümleri, küçük ekipler için idealdir; AWS/GCP üzerinde Kubernetes, enterprise düzeyde kontrol sunar. Rails'in "batteries included" yapısı, monolitik uygulamaların uzun süre ölçeklenmesini sağlar; mikroservis geçişi her zaman zorunlu değildir.

13. Monolit Rails Uygulaması Nasıl Yapılandırılır; Avantajları

Monolitik Rails uygulaması, tek bir kod tabanında tüm işlevleri barındırır. app/ dizini altında models, controllers, views, jobs, mailers bir aradadır. Bu yapı, geliştirme hızını maksimize eder: yeni bir özellik eklemek için birden fazla repo ve deployment süreci yönetmek gerekmez. Basecamp, GitHub ve Shopify gibi büyük platformlar, uzun süre monolitik Rails ile ölçeklenmiştir.

Monolit avantajları: transaction yönetimi basittir (tek veritabanı, ACID garantisi), test yazımı ve çalıştırması kolaydır (rails test tek komut), debugging basittir (tek stack trace). Modular monolith deseni, monolit içinde domain'leri app/domains/ veya packs/ (Packwerk gem'i) ile izole eder. Bu, mikroservis geçişine hazırlık olabilir ama monolitik yapının basitliğini korur. Profesyonel ekiplerde, monolitik yapı 100+ geliştiriciye kadar verimli şekilde ölçeklenir.

# config/application.rb - Monolit modülerleştirme
config.autoload_paths += %W(#{config.root}/app/domains/billing)
config.autoload_paths += %W(#{config.root}/app/domains/inventory)

14. Mikroservis Mimarisi Geçiş Örnekleri ve API Tasarımı

Mikroservis geçişi, "strangler fig" deseniyle yavaş yavaş yapılır. Önce en bağımsız domain'i (örneğin "bildirim servisi") ayrı bir Rails API-only uygulaması olarak çıkarılır. Ana monolit, bu servise HTTP veya message queue üzerinden olaylar gönderir. Sonra "ödeme servisi", "stok servisi" sırasıyla izler.

API tasarımı bu geçişte kritiktir. Servisler arası iletişim için REST API veya gRPC kullanılır. Event-driven mimari (Kafka, RabbitMQ), servisler arası loosely coupled iletişim sağlar. API Gateway (Kong, AWS API Gateway), istemciye tek bir entry point sunar ve cross-cutting concerns'ları (auth, rate limiting) merkezi yönetir. Her servis kendi veritabanını yönetir; bu, distributed transaction zorluğunu getirir. Saga pattern (orchestration veya choreography) bu sorunu çözer.

# Servis-servis iletişim örneği
class OrderService
  def create_order(params)
    order = Order.create!(params)
    
    # Async event gönderimi
    EventPublisher.publish('order.created', {
      order_id: order.id,
      user_id: order.user_id,
      total: order.total
    })
    
    order
  end
end

15. Docker ve Kubernetes ile Rails Dağıtımı Nasıl Yapılır

Docker, Rails uygulamasını containerize ederek "benim makinemde çalışıyor" sorununu ortadan kaldırır. Dockerfile, Ruby imajını, bağımlılıkları ve uygulama kodunu tanımlar. docker-compose.yml, geliştirme ortamında Rails, PostgreSQL ve Redis servislerini koordine eder. Multi-stage build, production imajının boyutunu minimize eder (build araçları dahil edilmez).

Kubernetes (K8s), container'ların orkestrasyonunu sağlar. Deployment, ReplicaSet ve Service objeleri, Rails pod'larının yönetimini tanımlar. ConfigMap ve Secret, environment değişkenlerini ve hassas verileri yönetir. Horizontal Pod Autoscaler (HPA), CPU/memory kullanımına göre pod sayısını otomatik ölçekler. Helm chart'ları, tekrar kullanılabilir deployment şablonları sunar. CI/CD pipeline'ında, docker build ve kubectl apply adımları otomatize edilir.

# Dockerfile (multi-stage)
FROM ruby:3.2-alpine AS builder
RUN apk add --no-cache build-base postgresql-dev
WORKDIR /app
COPY Gemfile* ./
RUN bundle config set --local deployment 'true' && \
    bundle config set --local without 'development test' && \
    bundle install

FROM ruby:3.2-alpine
RUN apk add --no-cache postgresql-client tzdata
WORKDIR /app
COPY --from=builder /usr/local/bundle /usr/local/bundle
COPY . .
CMD ["bundle", "exec", "puma", "-C", "config/puma.rb"]

16. Gelişmiş Özellikler: Metaprogramming, Concern, ActiveJob

Rails'in gücü, sadece convention'larda değil, Ruby'nin metaprogramming yeteneklerini kullanışlı abstraction'lara dönüştürmesindedir. Concern'ler, kod paylaşımını modüler hale getirir. ActiveJob, background işlemlerini standartlaştırır. Bu özellikler, framework'ün "sihirli" görünen kısımlarının arkasındaki teknik mantığı açıklar.

Bu bölüm, Rails'i sadece "kullanan" değil, "anlayan" geliştiriciye hitap eder. Metaprogramming, dikkatsiz kullanımda kodu okunamaz kılabilir; ama doğru kullanımda tekrarı azaltır ve DSL'ler (Domain Specific Languages) oluşturur.

17. Metaprogramming Nedir ve Rails'te Pratik Örnekleri

Metaprogramming, kodun kod yazmasını (code that writes code) ifade eder. Ruby'de define_method, method_missing, class_eval ve module_eval bu işlevi sağlar. Rails, bu özellikleri yoğun kullanır: has_many :orders bir metod çağrısıdır ama arkasında define_method ile dinamik metodlar oluşturulur. find_by_email_and_status gibi dinamik finder'lar, method_missing ile yakalanır.

Pratik kullanım: bir Auditable modülü, model değişikliklerini otomatik loglar. define_method ile her model için create_audit_log metodu dinamik olarak eklenir. class_attribute, sınıf düzeyinde özellik tanımlar. delegate, metod çağrılarını başka nesneye yönlendirir. Ancak metaprogramming, debugging'i zorlaştırabilir; source_location ve method(:foo).source ile kaynak kodu bulunabilir. Profesyonel ekiplerde, metaprogramming sadeleştirilmiş DSL'ler için kullanılır, business logic'te değil.

# Metaprogramming örneği: Dinamik scope'lar
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true
  
  def self.status_scopes(*statuses)
    statuses.each do |status|
      scope status, -> { where(status: status) }
      define_method "#{status}?" do
        self.status == status.to_s
      end
    end
  end
end

class Order < ApplicationRecord
  status_scopes :pending, :paid, :shipped, :cancelled
end

18. Concern ve Modül Bazlı Kod Paylaşımı Nasıl Uygulanır

Concern, Rails'e özgü bir modül desenidir. ActiveSupport::Concern ile included, class_methods ve prepended blokları tanımlanır. Bu, modülün model/controller'a nasıl entegre olacağını açıkça belirtir. app/models/concerns/ ve app/controllers/concerns/ dizinleri, paylaşılan kodları barındırır.

Örnek concern'ler: Tokenable (JWT token üretimi), Paginatable (sayfalama mantığı), SoftDeletable (silme yerine deleted_at güncelleme), Searchable (Ransack/Elasticsearch entegrasyonu). Concern'ler, mixins'in Rails versiyonudur; ama dependency resolution ve callback sıralaması daha öngörülebilirdir. Büyük projelerde, concern'lerin aşırı kullanımı "god object" anti-pattern'ine yol açabilir; bu yüzden single responsibility prensibine uygun tutulmalıdır.

# app/models/concerns/soft_deletable.rb
module SoftDeletable
  extend ActiveSupport::Concern
  
  included do
    scope :active, -> { where(deleted_at: nil) }
    scope :deleted, -> { where.not(deleted_at: nil) }
  end
  
  def soft_delete!
    update!(deleted_at: Time.current)
  end
  
  def restore!
    update!(deleted_at: nil)
  end
  
  def deleted?
    deleted_at.present?
  end
end

# Kullanım
class User < ApplicationRecord
  include SoftDeletable
end

19. Background Job Yönetimi: ActiveJob, Sidekiq Örnekleri

ActiveJob, Rails'in background job abstraction katmanıdır. perform metodu, asenkron çalışacak iş mantığını içerir. deliver_later, mailer'ları job queue'ya atar. set(wait: 1.hour), job'u gecikmeli çalıştırır. Queue adapter'ları: Sidekiq (Redis tabanlı, en popüler), Delayed Job (veritabanı tabanlı), Resque (Redis + Sinatra), Solid Queue (Rails 8'de default, veritabanı tabanlı).

Sidekiq, multi-threaded yapısıyla yüksek throughput sunar. Redis, job queue'su ve metadata deposu olarak kullanılır. Web UI, job durumunu, retry sayısını ve hata loglarını görselleştirir. Job'lar idempotent olmalıdır: aynı job iki kez çalışırsa (network hatası nedeniyle), sonuç değişmemelidir. Bu, "at least once" delivery garantisi altında veri tutarlılığını korur.

# app/jobs/order_confirmation_job.rb
class OrderConfirmationJob < ApplicationJob
  queue_as :mailers
  
  def perform(order_id)
    order = Order.find(order_id)
    return if order.confirmation_sent_at.present? # Idempotency check
    
    OrderMailer.confirmation(order).deliver_now
    order.update!(confirmation_sent_at: Time.current)
  end
end

# Kullanım
OrderConfirmationJob.perform_later(@order.id)

20. Job Retry, Scheduling ve Idempotency Teknik Detayları

Job retry mekanizması, geçici hatalar (database timeout, üçüncü taraf API hatası) karşısında otomatik yeniden deneme sağlar. Exponential backoff, her deneme arasındaki bekleme süresini katlar: 1sn, 2sn, 4sn, 8sn... Sidekiq'de sidekiq_retryable ve retry_on ile konfigüre edilir. Maksimum retry sayısı aşılırsa, job "dead queue"ya düşer; buradan manuel retry veya hata analizi yapılır.

Scheduling için whenever gem'i (cron syntax), sidekiq-cron veya solid_queue (Rails 8) kullanılır. Idempotency, job güvenliğinin temelidir: order.processed? kontrolü, unique constraint'ler (database seviyesinde), veya Redis distributed lock'ları (redlock) ile sağlanır. Job id'leri, aynı işlemin tekrarlanmasını engeller. E-ticaret senaryolarında, ödeme job'u idempotent olmazsa çift çekme oluşabilir; bu, finansal kayıplara yol açar.

# Retry ve idempotency konfigürasyonu
class PaymentProcessingJob < ApplicationJob
  queue_as :payments
  retry_on PaymentGatewayError, wait: :exponentially_longer, attempts: 5
  
  def perform(payment_id)
    payment = Payment.find(payment_id)
    
    # Distributed lock ile idempotency
    LockingService.with_lock("payment:#{payment_id}", ttl: 30) do
      return if payment.processed?
      
      result = PaymentGateway.charge(payment)
      payment.update!(processed: true, gateway_response: result)
    end
  end
end

21. Performans ve Ölçeklenebilirlik: Caching, DB Tuning, Web Server Seçimi

Rails uygulamalarının performansı, üç temel faktöre bağlıdır: önbellekleme stratejileri, veritabanı optimizasyonu ve web server konfigürasyonu. Bu üçlü, kullanıcı deneyiminin teknik temelini oluşturur. Bir e-ticaret sitesinde sayfa yüklenme süresi 3 saniyeyi geçerse, dönüşüm oranı %40 düşebilir; bu yüzden performans optimizasyonu sadece teknik değil, iş kritik bir konudur.

Ölçeklenebilirlik, hem vertical (daha güçlü sunucu) hem horizontal (daha fazla sunucu) olarak düşünülmelidir. Rails, thread-safe yapısıyla horizontal ölçeklemeyi destekler. Ancak önbellek tutarlılığı, session yönetimi ve veritabanı connection pool'u, dağıtık ortamda dikkat gerektirir.

22. Önbellekleme Stratejileri: Fragment, Action, HTTP Cache Örnekleri

Rails'te çok katmanlı önbellekleme vardır. Fragment caching, view parçalarını (<% cache @product do %>) önbellekler; Redis veya Memcached backend'i kullanır. Action caching, tüm controller action'ını önbellekler (Rails 5'ten itibaren actionpack-action_caching gem'iyle). Page caching, statik HTML dosyası üretir (en hızlı ama en kısıtlı).

HTTP caching, fresh_when ve stale? metodlarıyla ETag/Last-Modified header'larını yönetir. expires_in 1.hour, Cache-Control header'ını ayarlar. Russian Doll caching, iç içe fragment'ların cache key'lerini birleştirir; bir alt parça değişirse sadece o parça invalidate olur. Cache key'lerde touch: true ile parent model'ın updated_at'ı güncellenir; bu, ilişkili cache'lerin otomatik temizlenmesini sağlar.

<!-- Russian Doll Caching -->
<% cache @product do %>
  <div class="product">
    <h1><%= @product.name %></h1>
    <% cache @product.description do %>
      <p><%= @product.description %></p>
    <% end %>
    <% @product.reviews.each do |review| %>
      <% cache review do %>
        <%= render review %>
      <% end %>
    <% end %>
  </div>
<% end %>

23. Veritabanı Optimizasyonu ve İndeksleme Nasıl Yapılır

Veritabanı performansı, çoğu Rails uygulamasının darboğazıdır. explain ve analyze, sorgu planını görüntüler. includes (eager loading), N+1 sorununu çözer. pluck ve select, sadece gerekli kolonları çeker. find_each ve find_in_batches, büyük dataset'leri belleğe yüklemek yerine parça parça işler.

İndeksleme stratejisi: add_index :orders, :user_id (tek kolon), add_index :orders, [:status, :created_at] (composite), add_index :products, :name, using: :gin (full-text search PostgreSQL'de). Partial index'ler (where: { active: true }), sadece aktif kayıtları indeksler ve boyutu küçültür. pg_stat_statements (PostgreSQL), en yavaş sorguları tespit eder. bullet gem'i, development ortamında N+1 ve unused eager loading uyarıları verir.

# Veritabanı optimizasyonu örnekleri
class Order < ApplicationRecord
  # Eager loading ile N+1 önleme
  scope :with_details, -> { includes(:user, :products, :shipping_address) }
  
  # Sadece gerekli kolonlar
  scope :recent_ids, -> { where('created_at > ?', 1.week.ago).pluck(:id) }
  
  # Batch processing
  def self.archive_old_orders
    where('created_at < ?', 1.year.ago).find_each do |order|
      order.archive!
    end
  end
end

# Migration: Composite index
add_index :orders, [:user_id, :status, :created_at], 
          name: 'index_orders_on_user_status_created'

24. Puma, Unicorn, Passenger Karşılaştırması ve Ölçekleme Örnekleri

Web server seçimi, Rails uygulamasının concurrency modelini belirler. Puma (Rails 5+ default), multi-threaded yapıdadır; tek process içinde birden fazla thread çalıştırır. Bu, bellek verimliliği sağlar ama thread-safe olmayan gem'lerle uyumsuz olabilir. Unicorn, multi-process'tir; her worker ayrı process'tir. Bellek tüketimi yüksektir ama izolasyon güçlüdür. Passenger, Nginx/Apache modülü olarak çalışır; yönetimi kolaydır ama esnekliği azdır.

Puma konfigürasyonu: config/puma.rb'de workers (process sayısı) ve threads (thread sayısı) ayarlanır. preload_app!, application'u worker'lar fork edilmeden önce yükler; bu, bellek paylaşımı (copy-on-write) sağlar. nakayoshi_fork gem'i, GC'yi optimize ederek fork sonrası bellek kullanımını azaltır. Production'da, Puma + Nginx reverse proxy kombinasyonu en yaygın yapılandırmadır. Yük testi için wrk veya k6 kullanılır; bu, gerçekçi concurrency senaryoları sunar.

# config/puma.rb
workers Integer(ENV.fetch('WEB_CONCURRENCY', 2))
threads_count = Integer(ENV.fetch('RAILS_MAX_THREADS', 5))
threads threads_count, threads_count

preload_app!

on_worker_boot do
  ActiveRecord::Base.establish_connection
end

25. Uyumluluk ve Güvenlik: Gem Yönetimi, Auth, GDPR Uygulamaları

Rails ekosisteminin gücü, binlerce gem'in hazır çözümler sunmasıdır. Ancak bu, bağımlılık yönetimi ve güvenlik zorluklarını da beraberinde getirir. Kimlik doğrulama, yetkilendirme ve veri koruma, hem teknik hem hukuki zorunluluklardır. GDPR ve benzeri düzenlemeler, API tasarımını doğrudan etkiler.

Güvenlik, "sonradan eklenen" bir özellik değil, geliştirme sürecinin ayrılmaz parçasıdır. Rails, CSRF koruması, XSS escaping, SQL injection prevention gibi özellikleri default olarak sunar. Ancak configuration hataları veya güncel olmayan gem'ler, zafiyetlere yol açabilir.

26. Bundler ile Bağımlılık Yönetimi ve Sürüm Kilitleme Nasıl Yapılır

Bundler, Ruby bağımlılıklarını yöneten standart araçtır. Gemfile, projenin bağımlılıklarını tanımlar. Gemfile.lock, tam sürüm ve hash bilgilerini kilitleyerek, farklı ortamlarda aynı gem setinin kurulmasını garanti eder. bundle install, bağımlılıkları kurar. bundle update, belirtilen gem'i günceller.

Sürüm kilitleme stratejileri: gem 'rails', '~> 7.1.0' (patch güncellemelerine izin verir), gem 'devise', '>= 4.9' (minimum sürüm), gem 'puma', '6.4.0' (tam kilitleme). bundle audit (bundler-audit gem'i), bilinen CVE'leri tarar. dependabot veya renovate, otomatik güncelleme PR'ları oluşturur. CI/CD pipeline'ında, bundle audit her build'de çalıştırılır; kritik zafiyet tespit edilirse pipeline durur.

# Gemfile - Sürüm kilitleme stratejisi
source 'https://rubygems.org'

ruby '3.2.2'

gem 'rails', '~> 7.1.0'
gem 'pg', '~> 1.5'
gem 'puma', '~> 6.4'

group :development do
  gem 'bullet'          # N+1 tespiti
  gem 'bundler-audit'   # Güvenlik taraması
  gem 'brakeman'        # Static analysis
end

27. Devise, OAuth ve JWT ile Kimlik Doğrulama Örnekleri

Devise, Rails'in en popüler kimlik doğrulama çözümüdür. Modüler yapıdadır: database_authenticatable (email/şifre), registerable (kayıt), recoverable (şifre sıfırlama), rememberable (beni hatırla), trackable (giriş istatistikleri), validatable (doğrulama), confirmable (email onayı), lockable (hesap kilitleme). Her modül ihtiyaca göre eklenir.

OAuth entegrasyonu için omniauth ve provider-specific gem'ler (omniauth-google-oauth2, omniauth-github) kullanılır. JWT (JSON Web Token), API-only uygulamalar veya SPA'lar için stateless kimlik doğrulama sunar. jwt gem'i ile token üretimi ve doğrulama yapılır. Refresh token rotation, güvenliği artırır. Multi-tenant SaaS uygulamalarında, JWT payload'ına tenant_id eklenir; bu, her isteğin doğru tenant bağlamında işlenmesini sağlar.

# JWT implementation örneği
class JsonWebToken
  SECRET_KEY = Rails.application.credentials.secret_key_base
  
  def self.encode(payload, exp = 24.hours.from_now)
    payload[:exp] = exp.to_i
    JWT.encode(payload, SECRET_KEY)
  end
  
  def self.decode(token)
    decoded = JWT.decode(token, SECRET_KEY)[0]
    HashWithIndifferentAccess.new(decoded)
  rescue JWT::DecodeError
    nil
  end
end

28. Veri Koruma ve GDPR Uyumluluğu İçin Rails Pratikleri

GDPR uyumluluğu, Rails uygulamalarında teknik ve organizasyonel önlemler gerektirir. Veri minimizasyonu: fields parametresiyle API sadece gerekli veriyi döndürür. Pseudonymization, kişisel verilerin ayırt edilemez hale getirilmesidir; email yerine user_hash kullanılır. Encryption, attr_encrypted gem'i veya Rails 7+'ın Active Record Encryption özelliğiyle yapılır.

Veri silme hakkı (right to erasure), anonymize! metoduyla gerçekleştirilir: kayıt silinmez, kişisel veriler anonimleştirilir (email → deleted_user_123@example.com). Veri taşınabilirliği, to_json veya CSV export endpoint'leriyle sağlanır. Consent yönetimi, gdpr_consents tablosuyla izlenir; kullanıcı hangi amaçla hangi veriyi paylaştığını API üzerinden kontrol eder. Loglama ve audit, paper_trail gem'i ile veri değişiklikleri versiyonlanır. Profesyonel ekiplerde, GDPR compliance checklist'i her sprint'in definition of done'ına dahil edilir.

# GDPR anonymization örneği
class User < ApplicationRecord
  def anonymize!
    update!(
      email: "anonymized_#{id}@deleted.example",
      name: "Deleted User",
      phone: nil,
      encrypted_password: nil,
      anonymized_at: Time.current
    )
    orders.update_all(user_email: nil)
  end
end

29. Güvenlik Taramaları ve CVE Takibi İçin Otomasyon Adımları

Güvenlik, otomasyon olmadan sürdürülemez. Brakeman, Rails'e özgü static analysis aracıdır; SQL injection, mass assignment, XSS gibi zafiyetleri tespit eder. bundle-audit, Gemfile.lock'taki bilinen CVE'leri tarar. rack-attack, brute force ve DDoS saldırılarına karşı rate limiting uygular.

CI/CD entegrasyonu: Her pull request'te brakeman --run-checks ve bundle-audit çalıştırılır. SonarQube veya Snyk, daha kapsamlı güvenlik analizi sunar. OWASP ZAP, canlı uygulamaya dinamik tarama (DAST) yapar. Dependabot/Renovate, güvenlik güncellemelerini otomatik PR olarak sunar. CVE takibi için National Vulnerability Database (NVD) ve Ruby Security mailing list'i izlenir. Penetration test'ler, yılda en az bir kez üçüncü taraf firmalarla yapılır.

# GitHub Actions - Güvenlik taraması
- name: Security Audit
  run: |
    bundle exec brakeman -q -w2 -o brakeman.html
    bundle exec bundle-audit check --update
- name: Upload Brakeman Report
  uses: actions/upload-artifact@v3
  with:
    name: brakeman-report
    path: brakeman.html

30. Uygulama Senaryoları: Web Geliştirme, Responsive Tasarım, E-ticaret, SaaS, UI/UX

Rails, teoride güçlü bir framework; pratikte ise gerçek dünya senaryolarında şekillenir. Web geliştirme, responsive tasarım, e-ticaret, SaaS ve UI/UX odaklı geliştirme, farklı teknik gereksinimler doğurur. Bu bölümde, bu senaryolara özgü Rails pratiklerini ele alıyoruz.

Cross-platform mobil uygulama backend'leri, tek bir Rails API'nin iOS ve Android istemcilerine hizmet etmesini gerektirir. E-ticaret platformları, stok tutarlılığı ve ödeme güvenliği gibi özel zorluklar sunar. SaaS uygulamaları, multi-tenant mimari ve ölçeklenebilirlik gerektirir.

31. Rails ile Web Geliştirme Örnekleri ve API Entegrasyonu

Modern web geliştirmede Rails, hem server-rendered hem API-only modlarda kullanılır. Full-stack Rails 7 + Hotwire, HTML over the wire yaklaşımıyla reactive UI'lar sunar; bu, React/Vue gibi SPA framework'lerine olan bağımlılığı azaltır. Turbo Drive, sayfa geçişlerini AJAX'la hızlandırır. Turbo Frames, sayfa parçalarını bağımsız günceller. Turbo Streams, WebSocket üzerinden real-time güncellemeler sunar.

API entegrasyonu için Rails API-only modu (rails new app --api) kullanılır. jbuilder veya active_model_serializers, JSON yanıt formatını kontrol eder. fast_jsonapi (jsonapi-serializer), performanslı serialization sunar. Versionlama, Accept header'ı veya URL prefix'iyle yapılır. Cross-platform mobil uygulamalar (Flutter, React Native) ve SPA'lar (React, Vue), bu API'lere bağlanır. API dokümantasyonu için rswag (Swagger/OpenAPI) veya apipie kullanılır.

# API-only controller örneği
class Api::V1::ProductsController < ApplicationController
  def index
    @products = Product.active.includes(:category)
    render json: @products, each_serializer: ProductSerializer
  end
end

# Serializer
class ProductSerializer < ActiveModel::Serializer
  attributes :id, :name, :price, :stock_quantity
  belongs_to :category
end

32. Responsive Ön Yüzlerle Rails Backend Entegrasyonu Nasıl Yapılır

Responsive tasarım, mobil öncelikli (mobile-first) yaklaşımla Rails view katmanına entegre edilir. Tailwind CSS, tailwindcss-rails gem'i ile kolayca kurulur; utility class'ları (md:w-1/2, lg:w-1/3) responsive breakpoint'leri yönetir. Bootstrap, cssbundling-rails ile entegre edilir. Stimulus controller'ları, mobil cihazlarda touch event'leri ve gesture'ları yönetir.

Rails backend'i, responsive UI için optimize edilmiş API yanıtları sunmalıdır. fields parametresi (/api/products?fields=id,name,thumbnail), mobil cihazlarda daha az veri transferi sağlar. Görsel optimizasyonu için Active Storage variant'ları (product.image.variant(resize_to_limit: [400, 400])), farklı ekran boyutlarına uygun görseller üretir. Lazy loading, loading="lazy" attribute'u veya Turbo lazy frames ile implemente edilir. Kullanıcı deneyimi, algılanan performans (perceived performance) kadar gerçek performans kadar önemlidir; skeleton screens ve progress indicator'lar bu algıyı yönetir.

<!-- Responsive grid with Tailwind -->
<div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
  <% @products.each do |product| %>
    <div class="card">
      <%= image_tag product.thumbnail.variant(resize_to_limit: [400, 400]), 
                    loading: "lazy", class: "w-full h-48 object-cover" %>
      <h3 class="text-lg font-bold"><%= product.name %></h3>
      <p class="text-gray-600"><%= number_to_currency(product.price) %></p>
    </div>
  <% end %>
</div>

33. E-ticaret Platformu Örnekleri: Ödeme, Stok ve Sipariş Akışı

E-ticaret Rails uygulamaları, karmaşık iş akışları yönetir. Sipariş akışı: sepet (cart) → adres → ödeme → stok rezervasyonu → onay → kargolama. Her adım, farklı servislerin koordinasyonunu gerektirir. Stok tutarlılığı, optimistic locking (lock_version kolonu) veya pessimistic locking (with_lock) ile sağlanır.

Ödeme entegrasyonu (Stripe, iyzico), stripe-ruby veya iyzipay gem'leriyle yapılır. Webhook'lar, ödeme durumu değişikliklerini asenkron olarak işler. Idempotency key, çift çekmeyi önler. Sipariş durumu makinesi (state machine), aasm gem'i ile tanımlanır: pending → paid → processing → shipped → delivered. Geçersiz geçişler (örneğin shipped → cancelled) API seviyesinde engellenir. Admin paneli için ActiveAdmin veya RailsAdmin gem'leri, hızlı CRUD arayüzleri sunar.

# Sipariş state machine örneği
class Order < ApplicationRecord
  include AASM
  
  aasm column: 'status' do
    state :pending, initial: true
    state :paid, :processing, :shipped, :delivered, :cancelled
    
    event :pay do
      transitions from: :pending, to: :paid
    end
    
    event :ship do
      transitions from: :processing, to: :shipped
    end
    
    event :cancel do
      transitions from: [:pending, :paid], to: :cancelled
      after { release_stock! }
    end
  end
  
  def release_stock!
    order_items.each(&:release_stock!)
  end
end

34. SaaS Uygulamaları ve Multi-Tenant Mimari Örnekleri

Multi-tenant SaaS mimarisi, tek Rails uygulamasıyla birden fazla müşteriye (tenant) hizmet sunar. Veri izolasyonu stratejileri: scoped queries (default_scope { where(tenant_id: Tenant.current_id) }), row-level security (PostgreSQL RLS), veya ayrı schema/database. acts_as_tenant gem'i, tenant izolasyonunu otomatikleştirir.

Tenant bazlı özelleştirmeler: white-label (logo, renk), custom domain (CNAME kaydı), feature flags (plan bazlı özellik kısıtlama). Rate limiting, tenant bazlı olmalıdır; rack-attack konfigürasyonunda tenant_id dikkate alınır. Billing entegrasyonu (Stripe Billing, Paddle), subscription yönetimi ve usage-based pricing sunar. API rate limit'leri, plan tier'larına göre farklılık gösterir (Free: 100 req/saat, Pro: 10.000 req/saat). Profesyonel ekiplerde, tenant izolasyonu testleri (cross-tenant data leak prevention) her deployment öncesi çalıştırılır.

# Multi-tenant scope örneği
class ApplicationController < ActionController::Base
  set_current_tenant_through_filter
  
  before_action :set_tenant
  
  private
  
  def set_tenant
    current_account = Account.find_by!(subdomain: request.subdomain)
    set_current_tenant(current_account)
  end
end

class Product < ApplicationRecord
  acts_as_tenant(:account)
end

35. UI/UX Odaklı Performans: Hızlı Veri Yükleme ve Önbellek Stratejileri

UI/UX odaklı API tasarımı, "API-first UX" yaklaşımıyla Rails view katmanına entegre edilir. Turbo Frames, sayfa parçalarını bağımsız yükler; bu, tam sayfa refresh'i önler. StimulusReflex veya CableReady, WebSocket üzerinde server-triggered DOM güncellemeleri sunar. Bu, React/Vue karmaşıklığına girmeden real-time UI'lar oluşturur.

Hızlı veri yükleme için N+1 önleme, counter cache (counter_cache: true) ve materyalized view'lar kullanılır. ransack veya pg_search, arama performansını optimize eder. Infinite scroll, cursor pagination (UUID-based) ile implemente edilir; bu, offset-based pagination'dan daha verimlidir. Önbellek stratejileri: fragment caching (product cards), action caching (category pages), Russian Doll caching (nested components). Kullanıcı deneyimi metrikleri (Core Web Vitals: LCP, FID, CLS), Rails uygulamasının frontend performansını ölçer.

# Counter cache örneği
class OrderItem < ApplicationRecord
  belongs_to :order, counter_cache: true
  belongs_to :product, counter_cache: true
end

class Product < ApplicationRecord
  # orders_count kolonu otomatik güncellenir
  scope :popular, -> { order(orders_count: :desc) }
end

36. Geliştirme Araçları ve Test: RSpec, Minitest, CI/CD, Debugging

Test, Rails geliştirmenin ayrılmaz parçasıdır. "If it ain't tested, it's broken" felsefesi, framework'ün DNA'sında vardır. RSpec ve Minitest, iki ana test framework'üdür. CI/CD entegrasyonu, testlerin her commit'te otomatik çalışmasını sağlar. Debugging araçları, geliştirme verimliliğini artırır.

Agile geliştirme süreçlerinde, test yazımı story point'lerin bir parçasıdır. TDD (Test-Driven Development), red-green-refactor döngüsüyle kod kalitesini artırır. BDD (Behavior-Driven Development), iş gereksinimlerini test senaryolarına dönüştürür. Her iki yaklaşım da Rails ekosisteminde güçlü destek bulur.

37. RSpec ile Davranış Odaklı Test Yazma Örnekleri

RSpec, BDD yaklaşımıyla test yazmayı teşvik eder. describe, context, it blokları, testleri okunabilir hale getirir. let ve let!, lazy ve eager değişken tanımlar. before ve after hook'ları, setup ve teardown işlemlerini yönetir. expect syntax'ı, assertion'ları anlaşılır kılar.

FactoryBot (eski adıyla FactoryGirl), test verisi üretimini standartlaştırır. build_stubbed, veritabanına dokunmadan nesne oluşturur; bu, test hızını artırır. travel_to ve freeze_time, zaman bağımlı testleri kontrol eder. VCR, HTTP çağrılarını kaydeder ve replay eder; bu, üçüncü taraf API testlerini hızlandırır ve deterministik kılar. shoulda-matchers, common Rails validation ve association testlerini tek satıra indirir.

# RSpec örneği
RSpec.describe Order, type: :model do
  let(:user) { create(:user) }
  let(:product) { create(:product, price: 100) }
  
  describe '#total_price' do
    context 'with multiple items' do
      let(:order) { create(:order, user: user) }
      
      before do
        create(:order_item, order: order, product: product, quantity: 2)
        create(:order_item, order: order, product: product, quantity: 3)
      end
      
      it 'calculates the correct total' do
        expect(order.total_price).to eq(500)
      end
    end
  end
  
  it { is_expected.to belong_to(:user) }
  it { is_expected.to have_many(:order_items) }
  it { is_expected.to validate_presence_of(:status) }
end

38. Minitest ile Birim Testi ve Fixture Yönetimi Nasıl Yapılır

Minitest, Rails'in default test framework'üdür. Daha minimal ama tam özellikli bir yapı sunar. test "should do something" syntax'ı, basit ve anlaşılırdır. setup ve teardown metodları, test öncesi/sonrası işlemleri yönetir. assert, assert_equal, assert_nil, assert_raises gibi assertion metodları, test koşullarını doğrular.

Fixture'lar, test/fixtures/ dizinindeki YAML dosyalarıdır; test veritabanına yüklenir. users.yml, products.yml gibi dosyalar, test senaryoları için tutarlı başlangıç verisi sunar. fixtures :all, tüm fixture'ları yükler; fixtures :users, :products sadece belirtilenleri yükler. Fixture'ların dezavantajı: büyük projelerde yönetimi zorlaşabilir. Bu durumda FactoryBot'a geçiş yaygındır. Minitest, RSpec'e göre daha hızlı başlar ve daha az bağımlılık gerektirir; bu, küçük projelerde tercih sebebidir.

# Minitest örneği
require "test_helper"

class ProductTest < ActiveSupport::TestCase
  fixtures :products
  
  test "product should be valid with name and price" do
    product = products(:laptop)
    assert product.valid?
    assert_equal "MacBook Pro", product.name
  end
  
  test "product should require name" do
    product = Product.new(price: 100)
    assert_not product.valid?
    assert_includes product.errors[:name], "can't be blank"
  end
end

39. CI/CD Boru Hatlarında Test, Sürümleme ve Otomatik Dağıtım Örnekleri

CI/CD pipeline'ı, kod kalitesini ve deployment güvenliğini otomatize eder. GitHub Actions, GitLab CI, CircleCI ve Travis CI, Rails projelerinde yaygın kullanılan platformlardır. Pipeline aşamaları: 1) Checkout, 2) Dependency install (bundle, yarn), 3) Database setup, 4) Test (unit, integration, system), 5) Security audit (brakeman, bundle-audit), 6) Lint (rubocop), 7) Build Docker image, 8) Deploy.

Sürümleme, semantic versioning (SemVer) ve Git etiketleriyle yönetilir. auto-tag veya semantic-release, changelog ve versiyon numarasını otomatize eder. Deployment stratejileri: blue-green (anında geçiş), canary (kademeli trafik), rolling (pod by pod). Capistrano, geleneksel sunucu deployment aracıdır; Docker/Kubernetes ortamlarında kubectl apply veya Helm kullanılır. Database migration'lar, deployment öncesi (pre-deploy hook) veya sonrası koordine edilir; backward-compatible migration stratejisi (expand-contract) kullanılır.

# GitHub Actions - Rails CI/CD
name: Rails CI/CD

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: postgres
    steps:
      - uses: actions/checkout@v4
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: '3.2'
          bundler-cache: true
      - name: Setup Database
        run: |
          bundle exec rails db:create
          bundle exec rails db:schema:load
      - name: Run Tests
        run: bundle exec rspec
      - name: Security Audit
        run: |
          bundle exec brakeman -q
          bundle exec bundle-audit check
      - name: Deploy to Staging
        if: github.ref == 'refs/heads/main'
        run: |
          docker build -t rails-app:${{ github.sha }} .
          kubectl set image deployment/rails-app app=rails-app:${{ github.sha }}

40. Debugging ve Profiling: rack-mini-profiler, Bullet Kullanım Detayları

Development ortamında debugging araçları, verimliliği katlar. byebug, Ruby debugger'ıdır; breakpoint koyar, değişkenleri inspect eder, adım adım çalıştırır. pry-rails, IRB yerine Pry'i kullanır; syntax highlighting ve introspection sunar. better_errors ve binding_of_caller, hata sayfasında interaktif console sağlar.

rack-mini-profiler, her sayfanın altına performans profili ekler: SQL sorgu sayısı, render süresi, memory kullanımı. bullet gem'i, N+1 sorgularını ve unused eager loading'i tespit eder; development'ta pop-up uyarı verir. memory_profiler ve derailed_benchmarks, memory leak ve boot time analizi yapar. stackprof ve ruby-prof, CPU profiling için kullanılır. Production'da, Skylight, New Relic veya Datadog APM araçları, gerçek zamanlı performans izleme sunar.

# Gemfile - Development tools
group :development do
  gem 'pry-rails'
  gem 'better_errors'
  gem 'binding_of_caller'
  gem 'rack-mini-profiler'
  gem 'bullet'
  gem 'memory_profiler'
end

# config/environments/development.rb
config.after_initialize do
  Bullet.enable = true
  Bullet.alert = true
  Bullet.bullet_logger = true
  Bullet.console = true
end

41. Sonuç ve En İyi Uygulamalar: Kod Kalitesi, Ölçümler, Gelecek Trendler

Bu rehber boyunca Ruby on Rails ekosisteminin derinliklerine indik: temel prensiplerden mikroservis mimarisine, güvenlikten performans optimizasyonuna, CI/CD'den izlemeye. Rails, 20 yılı aşkın evrimine rağmen "developer happiness" ve "convention over configuration" prensiplerine sadık kaldı. Teknolojiler değişse de bu temel değerler, framework'ün sürdürülebilirliğini garanti eder.

Noves Digital olarak gözlemlediğimiz en başarılı Rails projeleri, framework'ü sadece teknik bir araç değil, ürün geliştirme felsefesinin bir parçası olarak gören ekipler tarafından inşa edilir. Kod kalitesi, test kapsamı ve dokümantasyon, teknik borcun önlenmesinde en etkili yöntemlerdir.

42. Rails Projelerinde Okunabilirlik ve Sürdürülebilirlik İlkeleri

Sürdürülebilirlik, "bugün çalışan kodun yarın da anlaşılabilir olması" anlamına gelir. Rails'te bu, convention'lara sadık kalmayı, fat model/skinny controller prensibini uygulamayı ve service object'leri (iş mantığını controller'dan ayıran PORO'lar) kullanmayı gerektirir. app/services/, app/queries/, app/policies/ gibi dizinler, kod organizasyonunu standartlaştırır.

RuboCop, Ruby Style Guide'a uygunluğu otomatize eder. rubocop-rails ve rubocop-rspec, Rails ve RSpec-specific kurallar ekler. Code review süreçlerinde, "makes sense" standardı uygulanır: kod, review eden geliştirici tarafından anlaşılabilir olmalıdır. Teknik borç, "TODO" ve "FIXME" yorumlarıyla işaretlenir ve sprint planlamasında adreslenir. Profesyonel ekiplerde, kod kalitesi metrikleri (code coverage, cyclomatic complexity, code smells) CI pipeline'ında otomatize edilir.

# Service object örneği
class OrderCreator
  def initialize(user, params)
    @user = user
    @params = params
  end
  
  def call
    Order.transaction do
      order = @user.orders.create!(@params)
      order.reserve_stock!
      order.calculate_total!
      OrderConfirmationJob.perform_later(order.id)
      order
    end
  rescue StandardError => e
    Rails.logger.error("Order creation failed: #{e.message}")
    raise
  end
end

43. Performans Metrikleri, SLA ve Hata İzleme Nasıl Uygulanır

API ve web uygulamalarının başarısı, teknik metriklerle ölçülür. SLA (Service Level Agreement), availability hedefini belirtir: %99.9 (yılda ~8 saat downtime), %99.99 (yılda ~52 dakika). Rails uygulamalarında latency percentilleri: p50 (medyan), p95 (%95'lik dilim), p99 (en yavaş %1). p95 < 200ms, p99 < 500ms hedefleri yaygındır.

Hata oranı (error rate), 5xx durum kodlarının toplam isteklere oranıdır; < 0.1% hedeflenir. Apdex score, kullanıcı memnuniyetini sayısal ifade eder. Sentry, Honeybadger veya Rollbar, exception tracking ve hata gruplama sunar. Rails log'ları, structured JSON formatında (lograge gem'i) tutulursa, ELK Stack veya Datadog ile analiz edilebilir. Health check endpoint'leri (/health), load balancer'ların instance durumunu kontrol etmesini sağlar. Synthetic monitoring (Pingdom, UptimeRobot), dışarıdan periyodik health check yapar.

# config/initializers/lograge.rb
Rails.application.configure do
  config.lograge.enabled = true
  config.lograge.formatter = Lograge::Formatters::Json.new
  config.lograge.custom_options = lambda do |event|
    {
      request_id: event.payload[:request_id],
      user_id: event.payload[:user_id],
      db_runtime: event.payload[:db_runtime],
      view_runtime: event.payload[:view_runtime]
    }
  end
end

44. Gelecek Trendler: Hotwire, Turbo ve Rails Ekosistemindeki Yenilikler

Rails 7 ve sonrası, frontend ekosisteminde devrimsel bir değişim getirdi. Hotwire (HTML over the wire), React/Vue gibi ağır JavaScript framework'lerine olan bağımlılığı azaltır. Turbo Drive, sayfa geçişlerini AJAX'la hızlandırır. Turbo Frames, sayfa parçalarını bağımsız günceller. Turbo Streams, WebSocket üzerinden real-time DOM güncellemeleri sunar. Stimulus, hafif JavaScript davranışları ekler. Bu üçlü, "modern SPA deneyimi, server-rendered basitliği" vaadini yerine getirir.

Solid Queue (Rails 8), Redis bağımlılığını ortadan kaldırarak background job'ları veritabanı tabanlı yönetir. Solid Cache, Active Record ile önbellekleme sunar. Solid Cable, Action Cable alternatifi olarak WebSocket bağlantılarını veritabanı üzerinden yönetir. Bu "solid" trio, Redis bağımlılığını azaltarak basitliği artırır. Propshaft, Sprockets'in yerini alan modern asset pipeline'dır; source map'ler ve modern CSS/JS özelliklerini native destekler. Rails'in geleceği, "batteries included" felsefesini korurken modern web standartlarıyla uyumlu kalmak üzerine kuruludur.

<!-- Turbo Stream örneği -->
<%= turbo_stream_from "orders" %>

<div id="orders">
  <%= render @orders %>
</div>

<!-- Controller'da broadcast -->
class Order < ApplicationRecord
  after_create_commit -> { 
    broadcast_append_to "orders", target: "orders" 
  }
end

45. Mevcut Projeyi Modernize Etme ve Göç Planı Adımları

Eski Rails projesini modernize etmek, büyük bir yeniden yazma değil, evrimsel bir süreçtir. Adım 1: Ruby ve Rails versiyonunu güncelleyin; her minor versiyon için ayrı upgrade yapın, test kapsamını artırın. Adım 2: Asset Pipeline'ı Propshaft + jsbundling-rails'e geçirin; Webpacker'ı emekli edin. Adım 3: Hotwire/Turbo entegrasyonu; sayfa parçalarını kademeli olarak Turbo Frames'e dönüştürün.

Adım 4: Test suite'i güçlendirin; RSpec/Minitest kapsamını %80+ hedefleyin. Adım 5: Security audit yapın; brakeman ve bundle-audit ile zafiyetleri tespit edin. Adım 6: Database optimizasyonu; eksik indeksleri ekleyin, N+1 sorunlarını çözün. Adım 7: Docker containerization; development ve production ortamlarını standartlaştırın. Adım 8: CI/CD pipeline'ı modernize edin; GitHub Actions veya GitLab CI ile otomatize edin. Her adımda, geriye dönük uyumluluğu koruyun ve kullanıcıları bilgilendirin. Modernizasyon, teknoloji değişimi değil, iş değerini artırma sürecidir.

# Upgrade compatibility check
# lib/tasks/upgrade.rake
namespace :upgrade do
  task check: :environment do
    # Deprecated API kullanımlarını tespit et
    Rails.application.routes.routes.each do |route|
      warn "Deprecated route: #{route.path.spec}" if route.path.to_s.include?('old_api')
    end
    
    # Eski gem'leri kontrol et
    deprecated_gems = %w[webpacker sprockets]
    deprecated_gems.each do |gem|
      puts "WARNING: #{gem} is deprecated, consider migrating" if Gem.loaded_specs[gem]
    end
  end
end

Bu rehber, Ruby on Rails geliştirmenin tüm yığınını ele aldı. Framework'ün 20 yılı aşkın evrimi, convention'ların ve best practice'lerin ne kadar derinleştiğini gösteriyor. Teknolojiler değişse de "developer happiness" ve "convention over configuration" prensipleri her zaman geçerli kalıyor. Projelerinizde bu prensipleri uygularken, ekip büyüklüğünüze, domain karmaşıklığınıza ve kullanıcı beklentilerinize göre pragmatik kararlar almayı unutmayın. İyi kodlamalar!