김신건의 로그 - 위키 / rails

[Rails] ActiveRecord Callbacks: 장점과 단점

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

ActiveRecord Callbacks = 모델의 라이프사이클 이벤트 (생성, 갱신, 삭제) 에 훅 을 거는 메커니즘. DRY + 자동화 가 매력이지만 암묵적 부수효과 의 함정이 큼.

[!IMPORTANT] Rails 의 철학적 선물 + 저주. 2026 시점 큰 코드베이스에서 callback 줄이고 Service object 로 옮기는 추세.

콜백 순서 (Create 시)

flowchart TB
    Init["new / build"] --> BV["before_validation"]
    BV --> Valid{"validate"}
    Valid -->|fail| AV_F["after_validation (실패)"]
    Valid -->|pass| AV_OK["after_validation (성공)"]
    AV_OK --> BS_R["before_save"]
    BS_R --> BC["before_create"]
    BC --> SQL[("INSERT SQL")]
    SQL --> AC["after_create"]
    AC --> AS_R["after_save"]
    AS_R --> AC_C["after_commit (트랜잭션 commit 후)"]
    SQL -.실패.-> AR["after_rollback"]

콜백 종류

단계	callback
Validation	`before_validation`, `after_validation`
Save (create + update 공통)	`before_save`, `around_save`, `after_save`
Create only	`before_create`, `around_create`, `after_create`
Update only	`before_update`, `around_update`, `after_update`
Destroy	`before_destroy`, `around_destroy`, `after_destroy`
Transaction	`after_commit`, `after_rollback`, `after_save_commit`, `after_create_commit`, `after_update_commit`, `after_destroy_commit`
Initialization	`after_initialize`, `after_find`
Touch	`after_touch`

사용

class Order < ApplicationRecord
  # 정규화
  before_validation :normalize_email

  # 비즈니스 로직
  before_create :generate_order_number

  # 외부 호출 (after_commit 만!)
  after_commit :send_confirmation_email, on: :create
  after_commit :enqueue_analytics, on: :create

  # 갱신 시 cascade
  after_save :update_total

  private

  def normalize_email
    self.email = email&.downcase&.strip
  end

  def generate_order_number
    self.order_number = "ORD-#{SecureRandom.hex(6).upcase}"
  end

  def send_confirmation_email
    OrderMailer.confirmation(self).deliver_later
  end

  def update_total
    total = items.sum(&:price)
    update_column(:total, total)   # callback 회피
  end
end

장점

flowchart TB
    Pro[Callback 장점]
    Pro --> DRY["DRY (한 곳에서 처리)"]
    Pro --> Auto["자동 (개발자가 못 빠뜨림)"]
    Pro --> Norm["자료 정규화 자연스러움"]
    Pro --> Inv["불변량 보장"]

1. DRY

# Without callback
class OrdersController
  def create
    order = Order.new(params)
    order.normalize_email   # 잊기 쉬움
    order.generate_order_number
    if order.save
      OrderMailer.confirmation(order).deliver_later
      AnalyticsJob.perform_later(order)
    end
  end
end

# Controller 5개 다 똑같이 반복...

# With callback
class OrdersController
  def create
    Order.create(params)
    # 자동으로 정규화 + 번호 + 메일 + 분석
  end
end

2. 깜빡임 방지

새 개발자가 Order.create 만 호출해도 모든 부수효과 자동. 비즈니스 룰 누락 X.

단점

flowchart TB
    Con[Callback 단점]
    Con --> Hidden["숨은 부수효과 (debugging 지옥)"]
    Con --> Tight["Coupling (Order 가 외부 시스템 알아야)"]
    Con --> Test["테스트 어려움 (Mock 폭증)"]
    Con --> Order["순서 의존 (callback 끼리)"]
    Con --> Skip["skip 어려움 (update_column 등 trick)"]

1. 숨은 부수효과

order.update(status: 'paid')
# 무슨 일이?
# - before_validation
# - after_validation
# - before_save
# - before_update
# - SQL UPDATE
# - after_update
# - after_save
# - after_commit
#   - send_confirmation_email → SMTP 호출 (느림, 실패 가능)
#   - update_inventory → 재고 system 호출
#   - notify_admin → Slack webhook
#   - enqueue_loyalty_points → Sidekiq job
#   - ...

# 디버깅: order.update 한 줄이 뭘 하는지 *몰라*. 코드 trace 필요.

2. 테스트 어려움

# 단위 테스트
it "updates total" do
  order.update(items: [...])
  expect(order.total).to eq(100)
end

# 실패: SMTP 가 stub 안 되어서 에러
# → 매번 callback mock 해야 함
allow(OrderMailer).to receive_message_chain(:confirmation, :deliver_later)
allow(AnalyticsJob).to receive(:perform_later)
# ... 5개 더

3. 순서 의존성

class Order
  after_create :send_email    # 1
  after_create :charge_card   # 2

  # 정의 순서대로 실행. send_email 이 먼저!
  # 결제 실패해도 이메일 발송됨
end

4. Cascade 폭발

class Order
  after_save :update_user_stats
end

class User
  after_save :recalculate_loyalty
end

class Loyalty
  after_save :send_tier_change_email
end

# Order.update → User.save → Loyalty.save → Email!
# 의도치 않은 chain reaction

안전 가이드

`after_commit` 만 외부 호출

# ❌ 트랜잭션 중에 외부 호출
after_save :send_email   # 트랜잭션 rollback 시 이메일 이미 갔음

# ✓ 커밋 후
after_commit :send_email, on: :create

동기 vs 비동기

# ❌ 콜백에서 동기 호출
after_commit :fetch_from_external_api   # 외부 API 다운 → save 실패

# ✓ 비동기 Job 으로 위임
after_commit :enqueue_external_fetch
def enqueue_external_fetch
  ExternalFetchJob.perform_later(self.id)
end

패턴: Service Object 권장

# ❌ Fat callbacks
class Order
  after_create :send_email
  after_create :update_inventory
  after_create :charge_card
  after_create :notify_admin
  # 비즈니스 로직이 모델 안
end

# ✓ Service object
class OrdersController
  def create
    result = OrderCreationService.call(order_params)
    if result.success?
      render json: result.order
    else
      render json: result.errors, status: 422
    end
  end
end

class OrderCreationService
  def self.call(params)
    ActiveRecord::Base.transaction do
      order = Order.create!(params)
      InventoryUpdateService.call(order)
      PaymentService.call(order)
    end
    EmailService.send_confirmation(order)   # 트랜잭션 밖
    AdminNotificationService.call(order)
    Result.success(order)
  rescue => e
    Result.failure(e.message)
  end
end

Callbacks 우회

order.update_column(:status, 'paid')           # callback skip!
order.update_columns(status: 'paid', total: 100)
Order.update_all(status: 'archived')           # callback skip!
order.touch(:viewed_at)                          # after_touch 만 (다른 callback skip)

[!CAUTION] callback skip = 의도적이지만 위험. callback 의존하는 로직이 안 돌아감. 데이터 무결성 깨질 수 있음.

결정 가이드

flowchart TD
    Q{언제 callback?}
    Q -->|항상 따라야 하는 *데이터 정규화*| OK1["✓ before_validation"]
    Q -->|"자동 생성 (UUID, slug)"| OK2["✓ before_create"]
    Q -->|"외부 호출 (mail, api)"| Service["✗ Service object + Job"]
    Q -->|복잡한 cascade| Service2["✗ 명시적 흐름"]
    Q -->|"불변량 보장 (calculated field)"| OK3["✓ before_save"]

흔한 함정

[!WARNING]

after_save 에 외부 호출 = 트랜잭션 rollback 시 이미 호출됨. after_commit 으로.

Cascade callback = 한 save 가 수십 callback chain. 디버깅 지옥.

update_column 으로 callback skip 의존 = 다른 곳에서 일반 update 사용 → callback 발동 → 다른 결과.

Polymorphic + callback = delegate :save, to: :parent 같이 우회 시 callback 빠짐.

[Rails] 쿼리 최적화: preload, eager_load, includes, references

koa (김신건) — Tue, 23 Jun 2026 00:00:00 GMT

정의

Active Record 는 연관 (has_many, belongs_to) 을 lazy 로딩한다. 부모 객체를 받아온 뒤 자식을 순회하면 자식마다 SELECT 가 1번씩 추가로 발생 = N+1 문제.

Rails 의 해결 도구는 세 가지 메서드 + 보조 메서드 1 개:

메서드	동작	조건 사용 시
`preload(:assoc)`	항상 2개의 분리된 쿼리 (parent 한 번 + child IN 한 번)	연관 테이블 조건 불가
`eager_load(:assoc)`	항상 1개의 LEFT OUTER JOIN 쿼리	연관 테이블 조건 가능
`includes(:assoc)`	상황에 따라 preload 또는 eager_load 자동 선택	조건 추가 시 자동 eager_load
`references(:assoc)`	`includes` 와 조합, 강제 eager_load	보조

N+1 시나리오

class School < ApplicationRecord
  has_many :teachers
end

class Teacher < ApplicationRecord
  belongs_to :school
end

School.all.each do |school|
  school.teachers.each do |teacher|
    puts "#{school.name} : #{teacher.name}"
  end
end

발생 SQL:

SELECT * FROM schools;                                          -- 1번
SELECT * FROM teachers WHERE school_id = 1;                     -- N번
SELECT * FROM teachers WHERE school_id = 2;
...

school 5개면 6 쿼리, 100개면 101 쿼리. 트랜잭션 응답시간 폭발.

preload: 별도 2 쿼리

School.preload(:teachers)

SELECT * FROM schools;
SELECT * FROM teachers WHERE school_id IN (1, 2, 3, 4, 5);

항상 2 개의 쿼리. 부모 한 번, 자식 IN 한 번. row 가 부모 수와 동일 (중복 없음).

제약: 연관 테이블의 컬럼을 조건절에 사용 불가.

# ❌ Error: column teachers.name does not exist
School.preload(:teachers).where('teachers.name = ?', '홍길동')

자기 자신 (선행 모델) 조건은 OK:

School.preload(:teachers).where(name: '루비 고등학교')

preload 가 적합:

자식 데이터 양이 많을 때 (JOIN 시 부모 row 복제로 메모리 폭발 방지)
자식 컬럼 검색 필요 없을 때
카르테시안 곱 회피

eager_load: LEFT OUTER JOIN 단일 쿼리

School.eager_load(:teachers).where('teachers.name = ?', '홍길동').to_a

SELECT "schools"."id" AS t0_r0, "schools"."name" AS t0_r1,
       "teachers"."id" AS t1_r0, "teachers"."name" AS t1_r1, "teachers"."school_id" AS t1_r2
FROM "schools"
LEFT OUTER JOIN "teachers" ON "teachers"."school_id" = "schools"."id"
WHERE "teachers"."name" = '홍길동';

1 개의 LEFT OUTER JOIN 쿼리. 연관 테이블 조건 가능.

제약: 부모 row 가 자식 수만큼 곱해진다. school 5 개에 teacher 평균 20 명이면 100 row 반환 → Active Record 가 메모리에서 dedup. 큰 데이터에선 메모리 부담.

eager_load 가 적합:

연관 테이블 조건 필요
자식 수가 적을 때
JOIN 으로 한 번에 모든 데이터 가져오는 게 효율적인 경우

includes: 자동 선택

School.includes(:teachers)

조건절 없으면 preload 처럼 동작 (2 쿼리):

SELECT * FROM schools;
SELECT * FROM teachers WHERE school_id IN (1, 2, 3, 4, 5);

조건절 추가하면 자동으로 eager_load 처럼 동작 (JOIN):

School.includes(:teachers).where('teachers.name = ?', '홍길동')

SELECT "schools"."id" AS t0_r0, ..., "teachers"."name" AS t1_r1
FROM "schools" LEFT OUTER JOIN "teachers" ON ...
WHERE "teachers"."name" = '홍길동';

includes 가 가장 권장. Rails 가 자동으로 최적 선택.

references: 강제 eager_load

조건이 string 이 아닌 hash 라 includes 가 detect 못 할 때 강제:

School.includes(:teachers).where(teachers: { name: '홍길동' })
# → Rails 4+ 자동 detect, JOIN 사용

명시적으로 강제:

School.includes(:teachers).references(:teachers)
# → 조건 없어도 JOIN 사용

복잡한 동적 query 빌딩에서 안전망.

다중 / 중첩 연관

# 다중
Post.includes(:author, :comments)

# 중첩 (post → comments → user)
Post.includes(comments: :user)

# 깊은 중첩
Post.includes(author: { posts: :comments }, comments: :user)

preload, eager_load 도 동일 문법.

중첩 깊을수록 JOIN 폭발 위험. 깊은 nested 는 preload 로 단계 분리가 안전.

bullet gem 으로 자동 감지

# Gemfile
group :development do
  gem 'bullet'
end

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

N+1 발생 시 자동 로그 + UI footer 표시. CI 에서 Bullet.raise = true 로 실패시킬 수도.

strict_loading (Rails 6.1+)

class School < ApplicationRecord
  has_many :teachers, strict_loading: true
end

school = School.find(1)
school.teachers.to_a   # ❌ ActiveRecord::StrictLoadingViolationError

연관 lazy 접근을 컴파일 타임처럼 차단. preload / includes 없으면 즉시 에러. 의도하지 않은 N+1 방지.

School.strict_loading.find(1)             # 인스턴스별
config.active_record.strict_loading_by_default = true   # 전역 (개발 / 테스트)

counter_cache: count 의 N+1

# ❌ 매 school 마다 COUNT 쿼리
School.all.each { |s| puts s.teachers.count }

counter_cache 로 부모에 카운트 컬럼:

class Teacher < ApplicationRecord
  belongs_to :school, counter_cache: true
end

# 마이그레이션
add_column :schools, :teachers_count, :integer, default: 0
# 기존 데이터 재계산
School.reset_counters(school.id, :teachers)

school.teachers.count → school.teachers_count 컬럼 직접 read. 자식 create / destroy 시 자동 갱신.

대규모 동시 INSERT 시 row lock 경합 주의. 절대값 정확성 critical 아니면 counter_cache: true 권장.

자주 보는 함정

1. find vs find_by + includes

# ❌ find_by 가 includes 무시
School.includes(:teachers).find_by(id: 1)

# ✓
School.includes(:teachers).where(id: 1).first

(Rails 7+ 에서 일부 개선됐지만 안전한 패턴 권장)

2. uniq / distinct 후 includes

# JOIN 결과의 row 중복 제거하면서 preload 가 깨질 수 있음
School.includes(:teachers).distinct

Rails 가 알아서 처리하지만 가끔 의도와 다른 row count. 명시적으로 분리:

school_ids = School.joins(:teachers).distinct.pluck(:id)
School.where(id: school_ids).includes(:teachers)

3. select 와 함께

select 로 부분 컬럼만 가져올 때 연관 FK 누락 주의:

# ❌ school_id 가 select 에 없으면 teachers 매칭 불가
Teacher.select(:name).includes(:school)   # error

4. polymorphic + includes

class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

# polymorphic 은 type 마다 다른 테이블 → JOIN 불가
Comment.includes(:commentable)   # preload 강제됨

자동으로 preload 만 사용 (JOIN 불가). 의도 그대로.

5. scope 와 조합

class Post < ApplicationRecord
  scope :published, -> { where(published: true) }
end

# scope 가 includes / preload 안에 작동
User.includes(:posts).merge(Post.published)

merge 로 scope 결합.

성능 측정

# 쿼리 수 측정
expect do
  User.includes(:posts).each { |u| u.posts.size }
end.to make_database_queries(count: 2)   # rspec-rails-shoulda matchers

# 로그
ActiveRecord::Base.logger = Logger.new(STDOUT)
# 또는 .logger.level = Logger::DEBUG

베스트 프랙티스

기본은 includes: Rails 가 알아서 최적 선택
조건 없으면 의도 명확히 preload: 부모 row 중복 회피
연관 테이블 조건 + 작은 결과면 eager_load 또는 includes + references
bullet gem 개발 환경에 필수
Rails 6.1+ 면 strict_loading 적극 활용: 의도 안 한 lazy 차단
count 가 자주 발생하면 counter_cache
체이닝 길어지면 별도 query 로 분리: 가독성 + 성능 모두 개선
EXPLAIN ANALYZE 로 실제 plan 확인 (.explain)

[Rails] Action Cable & Solid Cable: WebSocket

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Action Cable은 Rails의 WebSocket 통합. 채널(channel) 기반 발행/구독 모델. Rails 8부터 Solid Cable (DB 기반 어댑터)이 기본. 이전엔 Redis 필요. Turbo Streams의 broadcast가 이 위에 구축됨.

채널 생성

bin/rails g channel Chat

# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_room_#{params[:room]}"
  end

  def unsubscribed
    # cleanup
  end

  def receive(data)
    # 클라이언트가 보낸 메시지 처리
    ActionCable.server.broadcast("chat_room_#{params[:room]}", data)
  end

  def send_message(data)
    # 클라이언트 perform("send_message", {...}) 호출 처리
    Message.create!(content: data["message"], room: params[:room])
  end
end

// app/javascript/channels/chat_channel.js
import consumer from "./consumer"

consumer.subscriptions.create({ channel: "ChatChannel", room: "lobby" }, {
    received(data) {
        console.log(data)
    },

    send_message(message) {
        this.perform("send_message", { message })
    },
})

broadcast

ActionCable.server.broadcast("chat_room_lobby", {
  user: "Alice",
  message: "Hello!",
})

모든 구독자에게 메시지 전송.

Channel 인스턴스에서:

ChatChannel.broadcast_to(@room, message: "...")

인증

# app/channels/application_cable/connection.rb
module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
    end

    private

    def find_verified_user
      if verified_user = env["warden"]&.user
        verified_user
      else
        reject_unauthorized_connection
      end
    end
  end
end

세션/cookie 기반 인증. 또는 token:

def find_verified_user
  token = request.params[:token]
  User.find_by(api_token: token) || reject_unauthorized_connection
end

stream_for (자동 channel 이름)

class RoomChannel < ApplicationCable::Channel
  def subscribed
    room = Room.find(params[:id])
    stream_for room
  end
end

# broadcast
RoomChannel.broadcast_to(@room, ...)

broadcasting_for(@room)이 자동 채널 이름.

Solid Cable (8.0+)

# Gemfile (Rails 8 자동)
gem "solid_cable"

# config/cable.yml
production:
  adapter: solid_cable
  connects_to:
    database:
      writing: cable

전용 DB 또는 기본 DB 사용 가능. Redis 의존 제거.

Redis 어댑터 (전통)

production:
  adapter: redis
  url: <%= ENV["REDIS_URL"] %>

Turbo Streams broadcast (위에 구축)

class Post < ApplicationRecord
  broadcasts_to ->(post) { "posts" }
  # post.created → posts 채널에 turbo_stream 전송
  # post.updated, post.destroyed 자동
end

# 또는 명시
class Post < ApplicationRecord
  after_create_commit -> { broadcast_append_to "posts" }
  after_update_commit -> { broadcast_replace_to "posts" }
  after_destroy_commit -> { broadcast_remove_to "posts" }
end

<%# views/posts/index.html.erb %>
<%= turbo_stream_from "posts" %>

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

다른 사용자가 글 작성/수정 → 모든 클라이언트에 자동 반영.

Channel에 인자 전달

consumer.subscriptions.create({
    channel: "ChatChannel",
    room: "lobby",
    user_id: 42
}, {...})

class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room]}"
    Rails.logger.info "user #{params[:user_id]} joined"
  end
end

reject

def subscribed
  if user_can_access?(params[:room])
    stream_from "..."
  else
    reject
  end
end

권한 없음.

클라이언트 메서드 호출

const sub = consumer.subscriptions.create({...}, {
    received(data) {...}
})

sub.perform("send_message", {body: "Hello"})    // channel의 send_message 호출

서버:

class ChatChannel < ApplicationCable::Channel
  def send_message(data)
    # data["body"]
    Message.create!(...)
  end
end

자주 보는 패턴

실시간 알림

class NotificationsChannel < ApplicationCable::Channel
  def subscribed
    stream_for current_user
  end
end

# 알림 발송
NotificationsChannel.broadcast_to(user, message: "새 댓글")

consumer.subscriptions.create("NotificationsChannel", {
    received(data) {
        showToast(data.message)
    }
})

Presence (온라인 사용자)

class PresenceChannel < ApplicationCable::Channel
  def subscribed
    Redis.current.sadd("online_users", current_user.id)
    broadcast_presence
    stream_from "presence"
  end

  def unsubscribed
    Redis.current.srem("online_users", current_user.id)
    broadcast_presence
  end

  private

  def broadcast_presence
    ActionCable.server.broadcast("presence", users: Redis.current.smembers("online_users"))
  end
end

실시간 협업 에디터

각 키 입력을 broadcast → 다른 클라이언트 즉시 반영. Operational Transform 또는 CRDT 라이브러리 필요.

배포 시 고려

WebSocket은 long-lived 연결 → 워커 메모리/CPU

Nginx 프록시 설정:

location /cable {
    proxy_pass http://rails;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
}

Puma 워커는 thread-safe 필수
큰 메시지는 별도 storage + ID broadcast

함정

1. broadcast에 큰 객체

ActionCable.server.broadcast("ch", post: @post)    # AR 인스턴스 직렬화

primitive로 변환:

broadcast("ch", post: @post.as_json)

2. broadcast가 트랜잭션 내부

ActiveRecord::Base.transaction do
  post.save!
  ActionCable.server.broadcast("ch", post: post.as_json)
  # 트랜잭션 rollback 시 broadcast는 이미 발송됨
end

after_commit 안에서.

3. 권한 검사

stream_from은 채널 이름만 검사. 권한 없는 사용자가 다른 사람 채널 구독 시도 가능.

def subscribed
  if @room.member?(current_user)
    stream_for @room
  else
    reject
  end
end

4. JSON 인코딩

서버는 hash 그대로 broadcast. 클라이언트가 JSON 받음. 객체 inspect 등 직렬화 안 됨.

5. 동시성

채널 핸들러는 Puma thread pool에서 실행. CPU 작업은 별도 job으로.

대안

솔루션	적합
Action Cable	Rails 표준
Solid Cable	DB 단순화
Pusher	호스팅 (외부 의존)
AnyCable	Action Cable 성능 향상 (Go 워커)
Mercure	SSE 대안

대용량 동시 연결은 AnyCable 검토.

[Rails] Action Mailer: 이메일 발송

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Action Mailer는 Rails의 이메일 처리 프레임워크. 컨트롤러처럼 구조화된 mailer 클래스 + ERB 템플릿 + Active Job 통합. SMTP, Sendmail, SES, SendGrid 등 다양한 백엔드.

생성

bin/rails generate mailer UserMailer welcome reset_password

생성:

app/mailers/user_mailer.rb
app/mailers/application_mailer.rb
app/views/user_mailer/welcome.html.erb, .text.erb
app/views/layouts/mailer.html.erb, .text.erb
test/mailers/user_mailer_test.rb

Mailer 클래스

# app/mailers/application_mailer.rb
class ApplicationMailer < ActionMailer::Base
  default from: "noreply@example.com"
  layout "mailer"
end

# app/mailers/user_mailer.rb
class UserMailer < ApplicationMailer
  def welcome(user)
    @user = user
    @url = root_url
    mail(to: user.email, subject: "환영합니다")
  end

  def reset_password(user, token)
    @user = user
    @reset_url = edit_password_reset_url(token)
    mail(
      to: user.email,
      subject: "비밀번호 재설정",
      cc: ["audit@example.com"],
      reply_to: "support@example.com",
    )
  end
end

템플릿

<%# app/views/user_mailer/welcome.html.erb %>
<!DOCTYPE html>
<html>
<body>
  <h1><%= @user.name %>님 환영합니다!</h1>
  <p>가입을 완료하려면 <%= link_to "여기", @url %>를 클릭하세요.</p>
</body>
</html>

<%# app/views/user_mailer/welcome.text.erb %>
<%= @user.name %>님 환영합니다!

가입 완료: <%= @url %>

HTML + text 둘 다 자동으로 multipart 메일에 포함. 클라이언트가 선택.

전송

# 즉시
UserMailer.welcome(user).deliver_now

# 비동기 (Active Job)
UserMailer.welcome(user).deliver_later

# 옵션
UserMailer.welcome(user).deliver_later(
  wait: 5.minutes,
  wait_until: Date.tomorrow.noon,
  queue: "mailers",
  priority: 10,
)

기본 큐 이름: mailers. Sidekiq/Solid Queue 워커가 처리.

설정

# config/environments/production.rb
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
  address: ENV["SMTP_HOST"],
  port: 587,
  domain: "example.com",
  user_name: ENV["SMTP_USER"],
  password: ENV["SMTP_PASS"],
  authentication: "plain",
  enable_starttls_auto: true,
}
config.action_mailer.default_url_options = { host: "example.com" }
config.action_mailer.raise_delivery_errors = true
config.action_mailer.perform_deliveries = true

다른 백엔드

Backend	용도
`:smtp`	표준 SMTP
`:sendmail`	시스템 sendmail
`:file`	파일에 저장 (개발)
`:test`	메모리 (`ActionMailer::Base.deliveries`)
`:async_job`	큐

# 개발
config.action_mailer.delivery_method = :letter_opener    # gem
# 브라우저에서 자동 열림

URL helpers in mailer

Mailer는 별도 컨텍스트라 host 명시 필요.

# config/environments/production.rb
config.action_mailer.default_url_options = { host: "example.com", protocol: "https" }

# config/environments/development.rb
config.action_mailer.default_url_options = { host: "localhost", port: 3000 }

<%= link_to "프로필", profile_url(@user) %>    <%# url 헬퍼 (path 아님) %>

*_url 사용 (*_path는 mailer에서 사용 X).

첨부

def invoice(invoice)
  @invoice = invoice
  attachments["invoice.pdf"] = File.read(invoice.pdf_path)
  # 또는 ActiveStorage
  attachments["invoice.pdf"] = invoice.pdf_blob.download
  mail(to: invoice.user.email, subject: "청구서")
end

inline 이미지:

attachments.inline["logo.png"] = File.read("app/assets/images/logo.png")

<%= image_tag attachments["logo.png"].url %>

Preview

bin/rails generate mailer가 자동 생성.

# test/mailers/previews/user_mailer_preview.rb
class UserMailerPreview < ActionMailer::Preview
  def welcome
    user = User.first
    UserMailer.welcome(user)
  end

  def reset_password
    user = User.first
    UserMailer.reset_password(user, "test-token")
  end
end

브라우저: http://localhost:3000/rails/mailers

각 메일을 HTML/text로 미리 보기. 디자인 작업에 유용.

테스트

class UserMailerTest < ActionMailer::TestCase
  test "welcome" do
    user = users(:alice)
    mail = UserMailer.welcome(user)

    assert_equal "환영합니다", mail.subject
    assert_equal [user.email], mail.to
    assert_equal ["noreply@example.com"], mail.from
    assert_match user.name, mail.body.encoded
  end
end

RSpec:

RSpec.describe UserMailer, type: :mailer do
  let(:user) { create(:user) }
  let(:mail) { UserMailer.welcome(user) }

  it "renders" do
    expect(mail.subject).to eq("환영합니다")
    expect(mail.to).to eq([user.email])
    expect(mail.body.encoded).to match(user.name)
  end
end

전송 카운트:

assert_emails 1 do
  UserMailer.welcome(user).deliver_now
end

Action Mailbox (수신)

이메일 수신 처리.

class InboundMailbox < ApplicationMailbox
  def process
    parent = User.find_by(email: mail.from)
    return unless parent

    Comment.create!(author: parent, body: mail.body.decoded)
  end
end

라우팅:

# app/mailboxes/application_mailbox.rb
class ApplicationMailbox < ActionMailbox::Base
  routing /^reply-/i => :inbound
  routing "support@example.com" => :support
end

수신 게이트웨이: SendGrid Inbound, Mailgun, Postfix 등.

자주 보는 패턴

사용자 알림

class NotificationMailer < ApplicationMailer
  def comment_added(comment)
    @comment = comment
    @post = comment.post
    mail(to: @post.author.email, subject: "새 댓글")
  end
end

# Comment 모델
after_create_commit -> { NotificationMailer.comment_added(self).deliver_later }

다국어

def welcome(user)
  I18n.with_locale(user.locale) do
    mail(to: user.email, subject: I18n.t("mailer.welcome.subject"))
  end
end

<h1><%= t("mailer.welcome.title", name: @user.name) %></h1>

발송 실패 처리

class UserMailer < ApplicationMailer
  rescue_from Net::SMTPAuthenticationError do |e|
    Rails.logger.error("SMTP auth failed: #{e.message}")
    SentryService.notify(e)
  end
end

대량 발송 (rate limit)

users.find_each do |user|
  UserMailer.newsletter(user).deliver_later(wait: rand(0..3600).seconds)
end

랜덤 분산으로 SMTP rate limit 회피.

함정

1. deliver_now in controller

def signup
  user.save
  UserMailer.welcome(user).deliver_now    # 1-3초 응답 지연
  redirect_to root_path
end

→ deliver_later.

2. 트랜잭션과 deliver_later

User.transaction do
  user = User.create!(...)
  UserMailer.welcome(user).deliver_later
end
# 트랜잭션 rollback 시 메일은 이미 enqueue → 워커가 user 못 찾음

해결: Solid Queue (같은 DB라 안전) 또는 after_commit.

3. 큰 첨부

이미지 5MB+ → SMTP 거부. 큰 파일은 다운로드 URL로.

4. SPF/DKIM 미설정

from: noreply@example.com 보내려면 도메인에 SPF/DKIM. 안 그러면 스팸. SES/SendGrid 같은 서비스는 자체 도메인 사용.

5. 개발에서 실제 발송

# config/environments/development.rb
config.action_mailer.delivery_method = :test    # 또는 :letter_opener

:smtp로 두면 개발 중 실제 발송 위험.

외부 서비스 통합

서비스	gem
SendGrid	`sendgrid-ruby` 또는 SMTP
Mailgun	`mailgun-ruby` 또는 SMTP
AWS SES	`aws-sdk-rails`
Postmark	`postmark-rails`

SMTP가 가장 간단하나 API 사용이 더 강력 (tags, metadata, webhook).

[Rails] Action Text & Active Storage 통합

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Action Text (Rails 6+)는 Trix 에디터 + Active Storage 통합 + 안전한 HTML 저장으로 rich text 콘텐츠 처리. 댓글, 게시글, 메모 등에 WYSIWYG 에디터 즉시 추가 가능.

설치

bin/rails action_text:install
bin/rails db:migrate

생성:

app/assets/stylesheets/actiontext.css
action_text_rich_texts, action_text_embeds 테이블
Trix 에디터 자산

importmap.rb 또는 package.json에 trix 자동 추가.

모델

class Post < ApplicationRecord
  has_rich_text :body
end

마이그레이션 없음 (polymorphic 별도 테이블). post.body로 rich text 접근.

폼

<%= form_with model: @post do |form| %>
  <%= form.label :title %>
  <%= form.text_field :title %>

  <%= form.label :body %>
  <%= form.rich_text_area :body %>

  <%= form.submit %>
<% end %>

자동으로 Trix 에디터 렌더링 (toolbar, 굵게, 기울임, 링크, 첨부 등).

출력

<article>
  <h1><%= @post.title %></h1>
  <%= @post.body %>
</article>

자동으로 HTML 출력 + Active Storage 첨부 변환 + sanitization.

첨부 (drag & drop)

Trix 에디터에 이미지 드래그하면 자동으로 Active Storage에 업로드 + HTML에 embed.

Variant

<%= @post.body.body.attachables.each do |attachable| %>
  <%= image_tag attachable.variant(resize_to_limit: [800, 800]) %>
<% end %>

또는 글로벌 설정:

# config/initializers/action_text.rb
ActiveSupport.on_load(:action_text_content) do
  attr_writer :default_attachment_variant
end

Sanitization

Action Text는 기본적으로 XSS 방지. 허용 태그·속성만 통과.

# config/initializers/action_text.rb
ActionText::ContentHelper.allowed_tags = %w[h1 h2 h3 p ul ol li b i strong em a img blockquote code pre]
ActionText::ContentHelper.allowed_attributes = %w[href src alt class]

기본값으로도 안전. 필요한 태그만 추가.

Plain text 추출

post.body.to_plain_text    # HTML 제거
post.body.body.to_s        # raw HTML

검색 인덱싱, 미리보기, 이메일 텍스트 버전에 활용.

검색

class Post < ApplicationRecord
  has_rich_text :body

  scope :search, ->(q) {
    joins(:rich_text_body)
      .where("action_text_rich_texts.body LIKE ?", "%#{q}%")
  }
end

Post.search("Rails")

본격 검색은 Elasticsearch / Meilisearch / pg_trgm.

자주 보는 패턴

Comment with rich text

class Comment < ApplicationRecord
  belongs_to :post
  has_rich_text :content
end

# form
<%= form.rich_text_area :content, placeholder: "댓글..." %>

<%= form.rich_text_area :body, data: { trix: '{"toolbar": "minimal"}' } %>

또는 JS로 Trix 설정.

다른 첨부 가능 객체

class Post < ApplicationRecord
  has_rich_text :body
end

# Custom attachable
class Hashtag
  include ActiveModel::Model
  include ActionText::Attachable

  def to_trix_content_attachment_partial_path
    "hashtags/attachment"
  end
end

#tag 같은 커스텀 임베드 가능.

Markdown 대체

Markdown 편집기 원하면 redcarpet + easymde/stackedit 같은 별도 솔루션. Action Text는 WYSIWYG 우선.

함정

1. n+1

<% @posts.each do |post| %>
  <%= post.body %>    <%# 매번 SQL #}
<% end %>

@posts = Post.with_rich_text_body.includes(rich_text_body: { embeds_attachments: :blob })

2. body가 nil

post.body.to_plain_text    # post.body 가 ActionText::RichText 객체, body 안에 또 body
post.body.body.to_s         # raw HTML

이름 헷갈림. has_rich_text :content로 명명 변경하면 post.content.to_plain_text.

3. 마이그레이션 누락

bin/rails action_text:install 안 하면 polymorphic 테이블 없어 저장 실패.

4. CSP 충돌

Trix가 inline style 사용. CSP 엄격하면 'unsafe-inline' 또는 hash/nonce 허용.

5. 큰 콘텐츠

거대 HTML 저장 시 DB 부담. text 컬럼 (~ TEXT). 이미지는 첨부로 분리되어 OK.

대안

솔루션	특징
Action Text	Rails 표준, 통합
Trix 직접	더 가벼움
TinyMCE	풍부, 무거움
CKEditor	엔터프라이즈
Tiptap	모던 (Vue/React)
ProseMirror	저수준
EditorJS	블록 기반
MDX (Markdown + React)	개발자 친화

[Rails] Active Job 고급: retry, schedule, callback

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Active Job 기본 사용은 별도 페이지. 이 문서는 재시도 전략, 콜백, 시리얼라이즈, 멱등성, 우선순위 등 고급 패턴을 다룬다.

Retry / Discard

class MyJob < ApplicationJob
  retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 5
  retry_on ActiveRecord::Deadlocked, wait: :polynomially_longer, attempts: 3
  retry_on StandardError, wait: 10.seconds, attempts: 2

  discard_on ActiveJob::DeserializationError    # 영구 실패 (재시도 X)
  discard_on ActiveRecord::RecordNotFound

  def perform(record_id)
    record = Record.find(record_id)
    process(record)
  end
end

Wait 전략

retry_on Net::OpenTimeout,
  wait: :exponentially_longer,    # 5, 25, 125, ...초
  attempts: 5

retry_on RetryableError,
  wait: :polynomially_longer,      # 3, 18, 83, 258, 625초
  attempts: 5

retry_on FlakyError, wait: 30.seconds, attempts: 3

# 커스텀
retry_on MyError, wait: ->(executions) { 2.seconds * executions ** 2 }

무한 재시도 X

discard_on PermanentError

영구 에러는 DLQ 또는 알림. 무한 재시도는 자원 낭비.

Callbacks

class MyJob < ApplicationJob
  before_enqueue :log_enqueue
  after_enqueue :metrics_enqueue
  around_perform :timing

  before_perform :setup
  after_perform :cleanup

  def perform(*args)
    ...
  end

  private

  def log_enqueue
    Rails.logger.info("Enqueueing #{self.class}")
  end

  def timing
    start = Time.current
    yield
    elapsed = Time.current - start
    Metrics.record("job.duration", elapsed, job: self.class.name)
  end
end

Job arguments serialization

MyJob.perform_later(user)    # GlobalID 자동
MyJob.perform_later(user.id)    # primitive 권장

GlobalID로 ActiveRecord 자동 직렬화/역직렬화. 단 워커가 처리할 시점에 record가 존재해야:

class MyJob < ApplicationJob
  discard_on ActiveJob::DeserializationError
end

또는 ID 사용 + 명시적 처리:

def perform(user_id)
  user = User.find_by(id: user_id)
  return if user.nil?    # silently skip
  process(user)
end

멱등성 (Idempotency)

같은 job이 두 번 실행되어도 안전하게.

class SendInvoiceJob < ApplicationJob
  def perform(order_id)
    order = Order.find(order_id)
    return if order.invoice_sent_at.present?    # 이미 처리됨

    Order.transaction do
      InvoiceMailer.send_invoice(order).deliver_now
      order.update!(invoice_sent_at: Time.current)
    end
  end
end

Lock 기반

class CriticalJob < ApplicationJob
  def perform(resource_id)
    key = "lock:#{self.class.name}:#{resource_id}"

    if Redis.current.set(key, "1", nx: true, ex: 5.minutes.to_i)
      begin
        do_work(resource_id)
      ensure
        Redis.current.del(key)
      end
    else
      raise "Already processing"
    end
  end
end

또는 acidic_job gem.

큐 우선순위

class HighPriorityJob < ApplicationJob
  queue_as :high
end

class LowPriorityJob < ApplicationJob
  queue_as :low
end

# Sidekiq config/sidekiq.yml
:queues:
  - [high, 5]
  - [default, 3]
  - [low, 1]

가중치로 처리 비율.

Solid Queue:

production:
  workers:
    - queues: high
      threads: 5
      processes: 2
      polling_interval: 0.1
    - queues: default
      threads: 5
      processes: 1
      polling_interval: 0.5
    - queues: low
      threads: 2
      processes: 1
      polling_interval: 1

스케줄링

# 즉시
MyJob.perform_later(arg)

# 5분 후
MyJob.set(wait: 5.minutes).perform_later(arg)

# 특정 시간에
MyJob.set(wait_until: Time.current.tomorrow.noon).perform_later(arg)

# 우선순위 (Sidekiq Pro 등)
MyJob.set(priority: 10).perform_later(arg)

정기 작업 (cron)

Sidekiq + sidekiq-cron

# config/sidekiq.yml
:schedule:
  daily_report:
    cron: "0 9 * * *"    # 매일 09:00
    class: DailyReportJob

Solid Queue + recurring

# config/recurring.yml
production:
  daily_report:
    class: DailyReportJob
    schedule: every day at 9am
  cleanup:
    class: CleanupJob
    schedule: every 1 hour

3.4+ Sidekiq cron 빌트인. 활용 권장.

Bulk enqueue (8.0+)

ActiveJob.perform_all_later(
  posts.map { |p| IndexPostJob.new(p.id) }
)

100 jobs를 한 번에 enqueue → 워커 RTT 감소.

Worker 모니터링

Mission Control (Rails 8 권장)

gem "mission_control-jobs"
mount MissionControl::Jobs::Engine, at: "/jobs"

웹 UI에서 job 큐, 실패, 재시도 관리.

Sidekiq Web

require "sidekiq/web"
authenticate :user, ->(u) { u.admin? } do
  mount Sidekiq::Web => "/sidekiq"
end

트랜잭션 안전

ActiveRecord::Base.transaction do
  user = User.create!(...)
  WelcomeEmailJob.perform_later(user.id)
end
# 트랜잭션 rollback 시 job은 이미 enqueue → 워커가 user 못 찾음 → 재시도 무한

해결:

after_commit

class User < ApplicationRecord
  after_create_commit -> { WelcomeEmailJob.perform_later(id) }
end

commit 후에만 enqueue.

Solid Queue (DB 트랜잭션 안전)

같은 DB라 트랜잭션 안에서 enqueue OK. rollback 시 job도 사라짐.

Exception 처리

class MyJob < ApplicationJob
  rescue_from(StandardError) do |exception|
    Sentry.capture_exception(exception)
    raise    # 재발생 → retry/discard 규칙 적용
  end

  def perform(*args)
    ...
  end
end

Sentry, Rollbar 등 자동 캡처.

자주 보는 패턴

Webhook 처리

class WebhookProcessJob < ApplicationJob
  queue_as :webhooks

  retry_on StandardError, wait: 30.seconds, attempts: 5

  def perform(event_id)
    event = WebhookEvent.find(event_id)
    return if event.processed?

    WebhookEvent.transaction do
      ExternalAPI.confirm(event.external_id)
      event.update!(processed: true, processed_at: Time.current)
    end
  end
end

Image processing

class ImageProcessJob < ApplicationJob
  queue_as :media

  def perform(image_id)
    image = Image.find(image_id)
    image.variants.each do |size|
      image.process(size)
    end
    image.update!(processed: true)
  end
end

Email digest

class DailyDigestJob < ApplicationJob
  def perform
    User.where(daily_digest: true).find_each(batch_size: 100) do |user|
      DigestMailer.daily(user).deliver_later(queue: :emails)
    end
  end
end

# cron으로 매일 호출

작업 단위를 더 작게 분리 → 워커 효율.

Batch with progress

class ImportJob < ApplicationJob
  def perform(import_id)
    import = Import.find(import_id)

    rows = CSV.read(import.file_path)
    rows.each_with_index do |row, i|
      Record.create!(...)
      if i % 100 == 0
        import.update!(progress: (i.to_f / rows.size * 100).round)
        ActionCable.server.broadcast("import_#{import.id}", progress: import.progress)
      end
    end

    import.update!(completed_at: Time.current)
  end
end

긴 작업 + 실시간 진행률.

함정

1. 큰 인자

MyJob.perform_later(huge_array)    # serialize 비용 + queue 메모리

ID 전달.

2. perform vs perform_now vs perform_later

MyJob.perform(args)         # 클래스 메서드 호출 (NoMethodError)
MyJob.new.perform(args)     # 인스턴스 직접 호출 (이상함)
MyJob.perform_now(args)     # 동기 실행 (테스트, 디버그)
MyJob.perform_later(args)   # 백그라운드

표준은 perform_later.

3. session/request context 누락

class MyJob < ApplicationJob
  def perform(user_id)
    user = User.find(user_id)
    # request.host, current_user 등 없음 (다른 프로세스)
  end
end

URL helper 사용 시 Rails.application.routes.default_url_options[:host] 설정.

4. 비결정적 처리

def perform(date_string)
  date = Date.parse(date_string)
  process(date)
end

문자열 vs Date 객체. 직렬화는 문자열이 안전.

5. 디버깅 어려움

별도 프로세스 → log 의존. perform_now 동기 실행으로 디버거 진입.

Rails.logger.info("Starting #{self.class} with #{arguments.inspect}")

각 단계 로깅.

[Rails] Active Job: 백그라운드 워커

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Active Job은 백엔드(Sidekiq, Resque, Solid Queue 등) 추상화 계층. 같은 코드로 다른 queue adapter 교체 가능. Rails 8부터 Solid Queue(DB 기반)가 기본.

기본

bin/rails g job SendWelcomeEmail

# app/jobs/send_welcome_email_job.rb
class SendWelcomeEmailJob < ApplicationJob
  queue_as :default
  retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 5
  discard_on ActiveJob::DeserializationError

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

호출:

SendWelcomeEmailJob.perform_later(user.id)            # 백그라운드
SendWelcomeEmailJob.perform_now(user.id)              # 동기 (테스트)
SendWelcomeEmailJob.set(wait: 1.hour).perform_later(user.id)
SendWelcomeEmailJob.set(wait_until: Time.tomorrow.noon).perform_later(user.id)
SendWelcomeEmailJob.set(priority: 10, queue: :emails).perform_later(user.id)

queue adapter

# config/application.rb 또는 environments/production.rb
config.active_job.queue_adapter = :solid_queue
# 또는 :sidekiq, :resque, :good_job, :delayed_job, :async (개발)

Adapter	백엔드	특징
`:solid_queue`	DB	8.0+ 기본. Redis 불필요
`:sidekiq`	Redis	성능, 생태계
`:good_job`	DB (PG)	Active Job 친화
`:resque`	Redis	옛 표준
`:async`	인메모리	개발/테스트만

Sidekiq

# Gemfile
gem "sidekiq"

# config/sidekiq.yml
:concurrency: 10
:queues:
  - [critical, 5]
  - [default, 3]
  - [low, 1]

bundle exec sidekiq

Web UI:

# config/routes.rb
require "sidekiq/web"
mount Sidekiq::Web => "/sidekiq"

Solid Queue (Rails 8 기본)

# Gemfile (Rails 8 자동)
gem "solid_queue"

bin/rails db:migrate    # solid_queue 테이블 생성
bin/jobs                 # 워커 실행

config/queue.yml로 설정.

장점:

Redis 불필요 (PG/MySQL/SQLite)
인프라 1개 줄임
트랜잭션 안에서 enqueue → DB 일관성

재시도

class MyJob < ApplicationJob
  retry_on Net::OpenTimeout, attempts: 5, wait: :exponentially_longer
  retry_on Net::ReadTimeout, attempts: 3, wait: 30.seconds
  discard_on ActiveJob::DeserializationError    # 영구 실패 (재시도 X)
  discard_on ActiveRecord::RecordNotFound

  def perform(record_id)
    record = Record.find(record_id)
    ...
  end
end

wait: :exponentially_longer는 지수 backoff. wait: ->(executions) { ... }로 커스텀.

트랜잭션과 안전성

ActiveRecord::Base.transaction do
  user = User.create!(...)
  SendWelcomeEmailJob.perform_later(user.id)
end
# 트랜잭션 rollback 시 job은 이미 큐에 → user 못 찾음 + 재시도 무한

해결:

after_commit에서 enqueue
Solid Queue는 같은 DB라 트랜잭션 안에서 안전

ActiveRecord::Base.transaction do
  user = User.create!(...)
  user.send_welcome_email!    # after_commit 콜백
end

또는 Concurrent.with_executor 패턴, Solid Queue 활용.

perform_later 인자 직렬화

GlobalID로 ActiveRecord 자동 직렬화/역직렬화.

MyJob.perform_later(user)    # GlobalID "gid://app/User/1"

워커 시작 시 다시 User.find(1). 그 시점에 데이터 없으면 DeserializationError.

직렬화 가능: 기본 타입(String, Integer, Float, Bool, Hash, Array, nil), GlobalID 객체.

직렬화 불가: 일반 객체, Proc, IO.

MyJob.perform_later(user.id, options.to_h)    # primitive로 변환

큐 분리

class CriticalJob < ApplicationJob
  queue_as :critical
end

class LowJob < ApplicationJob
  queue_as :low
end

Sidekiq/Solid Queue 모두 큐별 동시성/우선순위 설정 가능. critical 워커 따로 띄우는 등.

자주 보는 패턴

이메일 발송

WelcomeMailer.welcome(user).deliver_later
# 내부적으로 ActionMailer::DeliveryJob 사용

Cron 작업

# Sidekiq + sidekiq-cron 또는 Solid Queue recurring

# Solid Queue config/recurring.yml
production:
  daily_report:
    class: DailyReportJob
    schedule: every day at 9am

Idempotency

같은 job이 두 번 실행되어도 안전하게.

class SendInvoiceJob < ApplicationJob
  def perform(order_id)
    order = Order.find(order_id)
    return if order.invoice_sent_at.present?

    InvoiceMailer.send_invoice(order).deliver_now
    order.update!(invoice_sent_at: Time.current)
  end
end

네트워크 끊김, 중복 enqueue로 두 번 실행될 수 있음. DB 트랜잭션 + 상태 체크.

Bulk enqueue (8.0+)

ActiveJob.perform_all_later(
  [Job1.new(arg1), Job2.new(arg2), Job3.new(arg3)]
)

한 번에 다수 enqueue (Sidekiq의 push_bulk와 유사).

결과를 클라이언트로

긴 작업 → 진행 상황을 Turbo Stream / WebSocket으로 push.

class GenerateReportJob < ApplicationJob
  def perform(user_id)
    user = User.find(user_id)
    100.times do |i|
      # 작업
      Turbo::StreamsChannel.broadcast_update_to(
        "user_#{user_id}",
        target: "progress",
        html: "<span>#{i}%</span>",
      )
    end
  end
end

모니터링

Sidekiq Web UI
Solid Queue dashboard (mission_control-jobs gem)
Sentry/Honeybadger Active Job integration
Mission Control jobs (Rails 8+ 권장)

gem "mission_control-jobs"
mount MissionControl::Jobs::Engine, at: "/jobs"

함정

1. perform vs perform_later

MyJob.perform(args)           # 즉시 동기 실행 (테스트용)
MyJob.perform_later(args)     # 큐에 넣고 워커가 처리

perform_later가 백그라운드. 혼동 주의.

2. job 내부에서 트랜잭션 외부 영향

job 안에서 DB 쓰기 → 트랜잭션 커밋 → 외부 API → 실패 → 재시도 시 DB 변경은 이미 반영. 멱등성 고려.

3. job 내부 큰 데이터 전달

MyJob.perform_later(huge_array)    # serialize 느림, Redis 메모리

ID 전달 + 워커가 DB 조회.

4. 시간대

MyJob.set(wait_until: Date.tomorrow.beginning_of_day).perform_later

Date.tomorrow가 어느 시간대? Time.current 사용.

config.active_record.default_timezone = :utc
config.time_zone = "Asia/Seoul"

5. 디버깅 어려움

워커가 별도 프로세스 → print 안 보임. 로깅으로.

class MyJob < ApplicationJob
  def perform(id)
    Rails.logger.info("starting #{id}")
    ...
    Rails.logger.info("done")
  end
end

perform_now로 동기 실행하면서 디버거 사용.

테스트

# test/jobs/welcome_email_job_test.rb
class WelcomeEmailJobTest < ActiveJob::TestCase
  test "perform" do
    user = users(:alice)
    perform_enqueued_jobs do
      WelcomeEmailJob.perform_later(user.id)
    end
    # 이메일 발송 확인
  end

  test "enqueue" do
    assert_enqueued_with(job: WelcomeEmailJob, args: [1]) do
      WelcomeEmailJob.perform_later(1)
    end
  end
end

ActiveJob::TestHelper 자동 포함.

Sidekiq vs Solid Queue vs GoodJob

	Sidekiq	Solid Queue	GoodJob
백엔드	Redis	DB	PostgreSQL
Rails 8 기본	X	O	X
성능	매우 빠름	중상	중상
인프라	Redis 별도	DB 공유	DB 공유
Pro 기능	유료	무료	무료

소규모 → Solid Queue 또는 GoodJob (인프라 단순). 대규모/Sidekiq 익숙 → Sidekiq.

[Rails] Active Record Encryption

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Active Record Encryption (Rails 7.0+)은 모델 attribute 자동 암호화. 키 관리, 검색(deterministic), 마이그레이션 등 내장. 비밀번호는 has_secure_password (bcrypt), 일반 민감 데이터는 encrypts.

초기 설정

bin/rails db:encryption:init

출력된 키를 credentials에 저장:

# config/credentials.yml.enc (bin/rails credentials:edit)
active_record_encryption:
  primary_key: ...
  deterministic_key: ...
  key_derivation_salt: ...

또는 환경변수:

config.active_record.encryption.primary_key = ENV["AR_PRIMARY_KEY"]
config.active_record.encryption.deterministic_key = ENV["AR_DETERMINISTIC_KEY"]
config.active_record.encryption.key_derivation_salt = ENV["AR_SALT"]

사용

class User < ApplicationRecord
  encrypts :ssn
  encrypts :api_key
  encrypts :credit_card, deterministic: true    # 검색 가능
end

user = User.create(ssn: "123-45-6789")
user.ssn    # "123-45-6789" (자동 복호화)
User.where(ssn: "123-45-6789")    # ERROR (non-deterministic)
User.where(credit_card: "...")     # OK (deterministic)

DB에는 암호화된 값 저장.

Deterministic vs Non-deterministic

옵션	검색 가능	보안
Default (random IV)	X	강함 (같은 평문도 다른 ciphertext)
`deterministic: true`	O	약함 (같은 평문 → 같은 ciphertext)

가능하면 non-deterministic. 검색이 필수일 때만 deterministic.

Downcase

encrypts :email, deterministic: true, downcase: true

검색 시 case-insensitive. User.where(email: "Alice@Example.com") 도 매치.

previous 키 (회전)

키 회전 시 옛 키로 복호화 가능:

class User < ApplicationRecord
  encrypts :ssn, previous: [
    { key: ENV["AR_OLD_PRIMARY_KEY"] },
  ]
end

새 키로 저장, 옛 키도 읽기. 데이터를 점진적으로 새 키로 마이그레이션:

bin/rails db:encryption:rotate

검증

class User < ApplicationRecord
  encrypts :ssn
  validates :ssn, presence: true, format: { with: /\A\d{3}-\d{2}-\d{4}\z/ }
end

검증은 평문에 대해 작동.

인덱스

add_index :users, :credit_card    # deterministic 컬럼만 의미 있음

non-deterministic은 인덱스 무용 (매번 다른 값).

자주 보는 패턴

개인정보

class Customer < ApplicationRecord
  encrypts :ssn
  encrypts :birthday
  encrypts :phone, deterministic: true    # 검색 필요
end

API 키

class Integration < ApplicationRecord
  encrypts :api_key
  encrypts :api_secret
end

외부 토큰

class User < ApplicationRecord
  encrypts :oauth_access_token
  encrypts :oauth_refresh_token
end

마이그레이션 (기존 데이터)

# 마이그레이션
class EncryptUserSsn < ActiveRecord::Migration[7.0]
  def up
    User.find_each do |user|
      user.ssn = user.read_attribute(:ssn)    # 평문 읽기
      user.save!    # 암호화 저장
    end
  end
end

또는 별도 작업으로 점진적 변환.

함정

1. 인덱스 컬럼 길이

encrypts :name    # 암호화 후 더 김

암호화된 값은 평문보다 큼 (base64). VARCHAR(255) → 부족할 수 있음. TEXT 권장 또는 확인.

2. 비교

user.ssn == "123-..."         # OK (메모리에서 복호화)
User.where(ssn: "123-...")    # deterministic만 가능

3. 검색 + 정렬

deterministic이라도 LIKE 검색은 의미 없음 (암호화된 substring 매치 X).

User.where("ssn LIKE ?", "123%")    # 동작 안 함

검색 + 암호화는 별도 검색 인덱스 (Searchable encryption) 또는 별 필드.

4. Rails 콘솔에서 평문 노출

User.first.ssn    # 평문 출력!

inspect도. 필요 시 attr_redact (커스텀 helper).

5. key 노출

config/credentials.yml.enc는 git OK (암호화). master.key는 절대 X. 노출 시 즉시 회전.

비밀번호는 다름

class User < ApplicationRecord
  has_secure_password    # bcrypt, irreversible
end

비밀번호는 hash (해시) - 복호화 못 함. encrypts는 복호화 가능. 비밀번호엔 has_secure_password, 일반 민감 데이터엔 encrypts.

Audit / 로그 보호

# config/initializers/filter_parameter_logging.rb
Rails.application.config.filter_parameters += [
  :ssn, :credit_card, :api_key,
]

로그에 [FILTERED] 표시. 암호화 + 로그 필터 둘 다.

외부 KMS

config.active_record.encryption.key_provider = MyKmsKeyProvider.new

AWS KMS, Vault 등 통합. 키 회전, 권한 관리 위임.

대안

솔루션	특징
Active Record Encryption	Rails 표준 (7.0+)
attr_encrypted	옛 표준 (gem)
lockbox	활발 (gem)
PG pgcrypto	DB 레벨
어플리케이션 레벨 (Vault, KMS)	강력

Rails 7+ 신규 프로젝트는 내장 Encryption.

보안 모범

가능한 한 적게 암호화 (성능 + 복잡도)
필드 단위 권한 (admin만 복호화)
키 회전 정기
백업도 암호화
로그/응답에 비밀 X

[Rails] Active Storage: 파일 업로드와 attachment

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Active Storage는 Rails 5.2+ 표준 파일 업로드 솔루션. S3, GCS, Azure, 로컬 디스크를 균일한 API로. 이미지 variant(크기 변환), 파일 검증, 미리보기, direct upload(클라이언트 → S3) 지원.

설치

bin/rails active_storage:install
bin/rails db:migrate
# active_storage_blobs, active_storage_attachments, active_storage_variant_records 생성

config/storage.yml:

local:
  service: Disk
  root: <%= Rails.root.join("storage") %>

amazon:
  service: S3
  access_key_id: <%= ENV["AWS_ACCESS_KEY_ID"] %>
  secret_access_key: <%= ENV["AWS_SECRET_ACCESS_KEY"] %>
  region: ap-northeast-2
  bucket: my-bucket

google:
  service: GCS
  project: my-project
  credentials: <%= Rails.root.join("config/gcs.json") %>
  bucket: my-bucket

azure:
  service: AzureStorage
  ...

# config/environments/production.rb
config.active_storage.service = :amazon

모델 연결

class User < ApplicationRecord
  has_one_attached :avatar
  has_many_attached :photos
end

class Post < ApplicationRecord
  has_many_attached :images
  has_one_attached :pdf
end

마이그레이션 불필요. 별도 테이블에 polymorphic 저장.

첨부

# 직접
user.avatar.attach(io: File.open("avatar.png"), filename: "avatar.png", content_type: "image/png")

# Form에서
user.avatar.attach(params[:avatar])    # ActionDispatch::Http::UploadedFile
user.photos.attach(params[:photos])    # array

폼

<%= form_with model: @user do |form| %>
  <%= form.file_field :avatar %>
  <%= form.file_field :photos, multiple: true %>
  <%= form.submit %>
<% end %>

def user_params
  params.require(:user).permit(:name, :avatar, photos: [])
end

avatar (single), photos: [] (multiple).

조회

user.avatar.attached?
user.avatar.filename
user.avatar.byte_size
user.avatar.content_type
user.avatar.download    # 바이트 전체 (큰 파일 위험)
user.avatar.open { |file| ... }    # tmp file
user.avatar.purge      # 첨부 삭제
user.avatar.purge_later    # background로 삭제

표시

<%= image_tag @user.avatar %>
<%= image_tag @user.avatar.variant(resize_to_limit: [200, 200]) %>

<%= link_to "다운로드", rails_blob_url(@user.avatar) %>
<%= url_for(@user.avatar) %>

<% @post.images.each do |image| %>
  <%= image_tag image.variant(resize_to_fill: [400, 400]) %>
<% end %>

rails_blob_url은 Rails가 프록시. CDN URL은 direct service URL.

Variants (이미지 변환)

user.avatar.variant(resize_to_limit: [200, 200])
user.avatar.variant(resize_to_fill: [400, 400])
user.avatar.variant(resize_to_fit: [800, 600])
user.avatar.variant(format: :webp, quality: 80)
user.avatar.variant(resize_and_pad: [400, 400, gravity: "center"])

요구사항:

brew install vips    # 또는 imagemagick

# config/application.rb
config.active_storage.variant_processor = :vips    # 또는 :mini_magick

variant는 첫 호출 시 생성 → 저장. 이후 캐시.

사전 정의 variants (6.1+)

class User < ApplicationRecord
  has_one_attached :avatar do |attachable|
    attachable.variant :thumb, resize_to_limit: [100, 100]
    attachable.variant :medium, resize_to_fill: [400, 400]
  end
end

<%= image_tag @user.avatar.variant(:thumb) %>
<%= image_tag @user.avatar.variant(:medium) %>

Preview (PDF, video)

@post.pdf.preview(resize_to_limit: [800, 800])    # 첫 페이지 이미지
@video.preview(resize_to_limit: [800, 800])

requirements: mutool (PDF), ffmpeg (video).

Direct Upload (브라우저 → S3)

큰 파일을 서버 거치지 않고 직접.

<%= form.file_field :avatar, direct_upload: true %>

// app/javascript/application.js
import * as ActiveStorage from "@rails/activestorage"
ActiveStorage.start()

JS가 자동으로 presigned URL 받아 S3에 PUT.

# CORS 설정 (S3 측)
[{
  "AllowedHeaders": ["*"],
  "AllowedMethods": ["PUT", "POST"],
  "AllowedOrigins": ["https://example.com"],
  "ExposeHeaders": ["Origin", "Content-Type", "Content-MD5", "Content-Disposition"],
  "MaxAgeSeconds": 3600
}]

검증 (active_storage_validations gem)

표준 라이브러리엔 검증 미포함. gem 사용:

gem "active_storage_validations"

class User < ApplicationRecord
  has_one_attached :avatar
  validates :avatar, content_type: ["image/png", "image/jpeg"], size: { less_than: 5.megabytes }
end

또는 수동:

validate :avatar_format

def avatar_format
  return unless avatar.attached?
  unless avatar.blob.content_type.start_with?("image/")
    errors.add(:avatar, "이미지만")
  end
  if avatar.blob.byte_size > 5.megabytes
    errors.add(:avatar, "5MB 이하")
  end
end

URL 유효 기간

url_for(@user.avatar)             # 5분 (기본)
rails_blob_url(@user.avatar, disposition: "attachment")

S3 presigned URL은 만료 시간 짧음. 영구 공개 URL은 public: true service 설정.

amazon_public:
  service: S3
  ...
  public: true

또는 CloudFront/CDN 앞단.

메타데이터

user.avatar.metadata       # { width: 200, height: 200, identified: true }
user.avatar.analyzed?      # 메타데이터 추출 완료?
user.avatar.analyze        # 강제

이미지 dimensions, audio length 등 자동 추출 (analyze job).

함정

1. n+1 attachment

@users.each { |u| u.avatar.variant(:thumb) }    # N+1 SQL + N+1 storage call

User.with_attached_avatar.each { ... }

2. variant 생성 비용

첫 호출 시 이미지 처리 → 큰 이미지면 응답 지연. preprocessed variant (사전 생성) 또는 background job.

3. 큰 파일 download

@user.avatar.download    # 전체 메모리 로드, OOM 위험

@user.avatar.open { |file| process(file) }    # tmp 파일
# 또는 stream

4. 첨부 삭제

user.destroy    # avatar도 함께 삭제 (purge_later 자동)
user.avatar.purge_later

cloud storage의 파일도 함께 삭제. 모르고 purge하면 복구 어려움.

5. service URL vs proxy URL

rails_blob_url(blob)              # Rails 통해 proxy (인증 가능)
rails_blob_path(blob)
blob.service_url                   # S3 직접 URL (만료 있음)

용도에 따라 선택.

대안

솔루션	특징
Active Storage	Rails 표준, 통합
CarrierWave	옛 표준, 강력
Shrine	모듈식, 유연
Paperclip	Deprecated

새 프로젝트는 Active Storage. 복잡한 처리는 Shrine.

보안

업로드 파일 MIME 검증 (확장자만 X)
파일명 sanitize (path traversal)
실행 권한 분리 storage
인증된 사용자만 첨부
size 제한
악성 SVG (XSS), exif 데이터 (privacy)

[Rails] Active Support: Ruby 확장

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Active Support는 Ruby 표준 라이브러리에 Rails가 추가하는 유틸리티 + 코어 확장. 1.day.ago, "hello".pluralize, blank? 등 모든 Rails 코드에서 사용. Rails 없는 Ruby 프로젝트도 require "active_support/all"로 사용 가능.

Time / Date

1.day.ago               # 1일 전
3.hours.from_now        # 3시간 후
1.month.from_now
2.weeks.ago.beginning_of_week
Date.today.end_of_month
Time.current            # 현재 (시간대 인식)
Date.tomorrow
Time.zone.parse("2026-06-20 14:00")

# Duration
1.day + 3.hours         # 27시간
2.days.in_seconds       # 172800
1.year.in_days          # 365.25

# 비교
1.day.ago < Time.current    # true

# 포맷
Time.current.to_s(:db)       # "2026-06-20 14:30:00"
Time.current.to_fs(:long)    # "June 20, 2026 14:30"

문자열 확장

"hello".pluralize          # "hellos"
"hellos".singularize       # "hello"
"helloWorld".underscore    # "hello_world"
"hello_world".camelize     # "HelloWorld"
"hello world".titleize     # "Hello World"
"hello world".parameterize # "hello-world"
"hello".starts_with?("he") # true (Ruby 2.5+ 표준)
"hello".ends_with?("lo")

# 잘라내기
"hello world".truncate(8)         # "hello..."
"hello world".truncate(8, omission: "…")
"hello world".truncate_words(2)   # "hello world..."

# 코드 변환
"some_class_name".classify     # "SomeClassName"
"SomeClass".tableize           # "some_classes"
"SomeClass".foreign_key        # "some_class_id"
"posts/comment".singularize    # "posts/comment"

# 변환
"5".to_i; "5.0".to_f; "true".to_b    # to_b는 ActiveModel
"<p>Hello</p>".html_safe?      # false (자동 escape)
ActionController::Base.helpers.strip_tags("<p>Hi</p>")    # "Hi"

Object 메서드

blank? / present?

nil.blank?         # true
"".blank?          # true
"  ".blank?        # true
[].blank?          # true
{}.blank?          # true
0.blank?           # false

"hello".present?   # true
"".present?        # false
"  ".present?      # false

present? = !blank?. nil-safe로 사용.

presence

""    || "default"      # "" (빈 문자열이지만 truthy)
"".presence || "default"    # "default" (blank면 nil)

name = params[:name].presence || "anonymous"

try

user.try(:name)              # user가 nil이면 nil, 아니면 user.name
user&.name                   # Ruby 2.3+ safe navigation (더 명시적)

user.try(:profile).try(:bio)
user&.profile&.bio

try는 정의되지 않은 메서드도 안전. &.는 NoMethodError.

Hash 확장

{a: 1, b: 2}.symbolize_keys      # {a: 1, b: 2}
{"a" => 1, "b" => 2}.symbolize_keys  # {a: 1, b: 2}
{a: 1, b: 2}.stringify_keys      # {"a" => 1, "b" => 2}

{a: 1, b: 2}.except(:a)          # {b: 2}
{a: 1, b: 2}.slice(:a)            # {a: 1}

{a: 1, b: 2}.deep_merge(b: 3, c: 4)    # {a: 1, b: 3, c: 4}
# 중첩 hash 재귀 merge

{a: 1, b: 2}.deep_transform_keys(&:to_s)
{a: 1, b: nil}.compact     # {a: 1}

# 기본값
hash.fetch(:key, "default")
hash.dig(:a, :b, :c)       # nested 안전 접근

HashWithIndifferentAccess

h = ActiveSupport::HashWithIndifferentAccess.new(a: 1)
h[:a]      # 1
h["a"]     # 1 (string/symbol 동일)

# Rails params도 같은 동작
params[:user][:name]
params["user"]["name"]

Array 확장

[1, 2, 3].in_groups_of(2)               # [[1, 2], [3, nil]]
[1, 2, 3, 4, 5].in_groups(2)            # [[1, 2, 3], [4, 5, nil]]
[1, 2, 3].split(2)                       # [[1], [3]]
[1, 2, 3, 4].second                      # 2
[1, 2, 3, 4].third
[1, 2, 3, 4].fourth ... fifth, forty_two   # 농담? 진짜 있음
[1, 2, 3].to_sentence                    # "1, 2, and 3"
%w[apple banana].to_sentence(words_connector: ", ", two_words_connector: " 또는 ")

# Pluck (배열 of hash)
[{a: 1}, {a: 2}].pluck(:a)   # [1, 2]

Concern

extend ActiveSupport::Concern. rails-concerns 참고.

Configurable

class MyClass
  include ActiveSupport::Configurable

  config_accessor :api_key, :timeout
  config.timeout = 30
end

MyClass.config.api_key = "..."
MyClass.config.api_key

class-level 설정.

Notifications (Instrumentation)

Rails 내부도 사용. 임의 이벤트 publish/subscribe.

# 구독
ActiveSupport::Notifications.subscribe("user.signup") do |name, started, finished, unique_id, payload|
  Rails.logger.info("User signed up: #{payload[:user_id]}")
end

# 발행
ActiveSupport::Notifications.instrument("user.signup", user_id: user.id) do
  send_welcome_email(user)
end

Rails 자체 이벤트:

sql.active_record (모든 SQL)
process_action.action_controller
render_template.action_view
start_processing.action_controller

APM 도구가 자동 구독.

ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
  event = ActiveSupport::Notifications::Event.new(*args)
  Rails.logger.debug("SQL: #{event.payload[:sql]} took #{event.duration}ms")
end

Numeric 확장

50.bytes        # 50
1.kilobyte      # 1024
2.megabytes     # 2097152
3.gigabytes
4.terabytes

1.day           # ActiveSupport::Duration 60*60*24
1.hour
60.minutes
1.second.in_milliseconds  # 1000

# Numeric 메서드
50.percent_of(100)   # 50.0
50.percentage_of(100)

Callback

class MyClass
  include ActiveSupport::Callbacks
  define_callbacks :process

  set_callback :process, :before, :prepare
  set_callback :process, :after, :cleanup

  def process
    run_callbacks(:process) do
      # 실제 작업
    end
  end

  private

  def prepare; end
  def cleanup; end
end

Rails의 model callbacks, controller filters 모두 이 위에.

Cache (Rails.cache 외)

cache = ActiveSupport::Cache::MemoryStore.new
cache.write("key", value, expires_in: 1.hour)
cache.read("key")
cache.fetch("key") { expensive }

MemoryStore, FileStore, MemCacheStore, RedisCacheStore 등.

Logger

logger = ActiveSupport::Logger.new(STDOUT)
logger = ActiveSupport::TaggedLogging.new(logger)
logger.tagged("request_id=#{id}") do
  logger.info("Processing")
end
# 출력: [request_id=abc] Processing

OrderedOptions

config = ActiveSupport::OrderedOptions.new
config.api_key = "..."
config[:api_key]    # "..." (dot 또는 hash)

옵션 객체.

함정

1. blank?의 의외 동작

0.blank?         # false (0은 truthy)
false.blank?     # true
[nil].blank?     # false (요소 있음)
[nil].compact.blank?    # true

2. try의 silent failure

user.try(:invalid_method)    # nil (예외 안 던짐, 디버깅 어려움)

try 남용은 버그 숨김. 가능하면 &. (NoMethodError는 던짐).

3. require “active_support”

require "active_support"            # 기본만
require "active_support/all"        # 전부 (무거움)
require "active_support/core_ext/object/blank"    # 일부만

Rails 없이 Ruby 프로젝트에서 사용 시.

4. duration 비교

1.day == 86400.seconds    # true (둘 다 Duration)
1.day == 86400             # false (Numeric 비교)
1.day.to_i == 86400        # true

5. tableize / pluralize 오류

"deer".pluralize    # "deers" (실제 영어로 "deer")
"sheep".pluralize   # "sheep"
"person".pluralize  # "people"

영어 불규칙. 커스텀 inflection 등록 가능:

ActiveSupport::Inflector.inflections do |inflect|
  inflect.irregular "person", "people"
  inflect.uncountable %w[equipment]
end

[Rails] ActiveRecord 기초: Model, Migration, CRUD

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

ActiveRecord는 Rails의 ORM. 클래스 ↔ 테이블 1:1 매핑(관례), 인스턴스 = 행. Active Record 패턴 그대로(데이터 + 행동). 마이그레이션으로 스키마 버전 관리, 풍부한 Query DSL, 콜백·검증·관계 내장.

모델 생성

rails generate model Post title:string body:text published:boolean

# 만들어지는 것:
# - app/models/post.rb
# - db/migrate/20260620_create_posts.rb
# - test/models/post_test.rb
# - test/fixtures/posts.yml

# app/models/post.rb
class Post < ApplicationRecord
end

# db/migrate/20260620120000_create_posts.rb
class CreatePosts < ActiveRecord::Migration[7.2]
  def change
    create_table :posts do |t|
      t.string :title, null: false
      t.text :body
      t.boolean :published, default: false
      t.timestamps    # created_at, updated_at 자동
    end
  end
end

마이그레이션 실행

rails db:migrate                # 적용
rails db:rollback               # 마지막 1개 되돌리기
rails db:rollback STEP=3
rails db:migrate:status         # 현재 상태
rails db:reset                  # drop + create + migrate + seed
rails db:seed

CRUD

# Create
post = Post.new(title: "Hello")
post.body = "..."
post.save                       # bool 반환 (검증 실패면 false)
post.save!                      # 실패 시 예외

post = Post.create(title: "Hello", body: "...")   # new + save 한 번에
post = Post.create!(...)        # 예외

# Read
Post.find(1)                    # PK, 없으면 RecordNotFound
Post.find_by(slug: "hello")     # 단일, 없으면 nil
Post.find_by!(slug: "hello")    # 예외
Post.where(published: true)
Post.first
Post.last
Post.all                        # 보통 안 씀 (큰 테이블 위험)

# Update
post.title = "New"
post.save
post.update(title: "New", body: "...")    # 한 번에
post.update!(title: "New")

# 일괄
Post.where(published: false).update_all(featured: false)    # 검증·콜백 우회 (빠름)

# Delete
post.destroy                    # 콜백 실행
post.destroy!
Post.destroy_all                # 모든 행 (콜백 실행, 느림)
Post.delete_all                 # SQL DELETE (콜백 우회)
post.delete                     # 단일, 콜백 우회

마이그레이션 자주 쓰는 메서드

class Example < ActiveRecord::Migration[7.2]
  def change
    create_table :posts do |t|
      t.string :title, null: false, limit: 200
      t.text :body
      t.references :author, null: false, foreign_key: true   # FK
      t.references :category, foreign_key: true
      t.boolean :published, default: false, null: false
      t.integer :views, default: 0
      t.decimal :price, precision: 10, scale: 2
      t.datetime :published_at
      t.timestamps

      t.index :slug, unique: true
      t.index [:author_id, :created_at]
    end
  end
end

# 컬럼 추가
add_column :posts, :slug, :string
add_index :posts, :slug, unique: true

# 변경
change_column :posts, :title, :string, limit: 500
change_column_null :posts, :title, false
change_column_default :posts, :published, from: nil, to: false

# 삭제
remove_column :posts, :slug
remove_index :posts, :slug

# 이름 변경
rename_column :posts, :body, :content
rename_table :posts, :articles

# 참조
add_reference :posts, :author, foreign_key: true
remove_reference :posts, :author, foreign_key: true

마이그레이션 generator

rails g migration AddSlugToPosts slug:string:uniq
rails g migration AddAuthorRefToPosts author:references
rails g migration CreateJoinTableAuthorsPosts authors posts

이름 규칙으로 자동 생성.

strong migrations / safe migrations

큰 테이블에 락 거는 마이그레이션은 위험. strong_migrations gem이 dangerous한 작업 차단.

# Gemfile
gem "strong_migrations"

NULL not null 추가, default with backfill 등이 자동 감지.

트랜잭션

ActiveRecord::Base.transaction do
  user.update!(balance: user.balance - amount)
  recipient.update!(balance: recipient.balance + amount)
end
# 예외 시 rollback

# 중첩 (savepoint)
ActiveRecord::Base.transaction do
  ...
  ActiveRecord::Base.transaction(requires_new: true) do
    ...    # 이 내부 실패는 outer는 안 깨짐
  end
end

더티 추적

post.title = "New"
post.title_changed?          # true
post.title_was               # 이전 값
post.changes                 # {"title" => ["old", "new"]}
post.changed                 # ["title"]
post.changed_attributes      # {"title" => "old"}

# 저장 후
post.saved_change_to_title?
post.saved_change_to_title   # ["old", "new"]

콜백/검증에서 활용.

직렬화 / JSON

post.as_json
post.to_json
post.attributes

API에는 ActiveModel::Serializer, Jbuilder, Alba, Blueprinter 같은 라이브러리.

한 번에 가져오기 / 청크

Post.find_each(batch_size: 1000) do |p|
  process(p)
end

Post.in_batches(of: 1000) do |batch|
  batch.update_all(processed: true)
end

큰 테이블 순회. each는 모두 메모리에 로드 → 위험.

reload, refresh

post.reload          # DB 다시 읽기 (변경사항 버림)

콜백/외부에서 DB 변경 후 동기화.

자주 보는 패턴

counter cache

class Comment < ApplicationRecord
  belongs_to :post, counter_cache: true
end

# Post에 comments_count 컬럼 자동 갱신
post.comments_count    # SQL 안 함

touch

class Comment < ApplicationRecord
  belongs_to :post, touch: true
end

# Comment 변경 시 post.updated_at 갱신

캐시 무효화에 유용.

enum (7.0+)

class Post < ApplicationRecord
  enum :status, { draft: 0, published: 1, archived: 2 }
end

post.draft?
post.published!
Post.published     # 스코프 자동

가상 컬럼

class User < ApplicationRecord
  attribute :full_name, :string, default: -> { "#{first_name} #{last_name}" }
end

# 또는 DB store
class User < ApplicationRecord
  store :preferences, accessors: [:theme, :language]
end

user.theme = "dark"
user.save

함정

1. find vs find_by

Post.find(1)              # 1 없으면 ActiveRecord::RecordNotFound (404 자동)
Post.find_by(id: 1)       # 없으면 nil
Post.find_by!(id: 1)      # 없으면 예외

view에서 자동 404 원하면 find.

2. N+1

Post.all.each { |p| puts p.author.name }    # N+1
Post.includes(:author).each { ... }          # 해결 (eager load)

3. update_all은 콜백 우회

Post.update_all(published: true)    # before_save 등 미실행

검증·콜백 필요하면 루프 + save.

4. save 없이 변경

post.title = "New"
# save 호출 안 함 → 변경 영원히 안 됨

update가 더 명확.

5. 마이그레이션 순서

여러 개발자가 같은 base에서 다른 마이그레이션 만들면 timestamp 순서로 적용. 충돌 시 명시적 해결.

[Rails] AR Associations: belongs_to, has_many, polymorphic

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

ActiveRecord associations로 테이블 간 관계를 객체 그래프로 표현. 6가지 매크로(belongs_to, has_one, has_many, has_many :through, has_one :through, has_and_belongs_to_many)와 polymorphic, STI 같은 고급 패턴.

belongs_to

# Post가 author(User)에 속한다
class Post < ApplicationRecord
  belongs_to :author, class_name: "User", foreign_key: "author_id"
end

마이그레이션:

add_reference :posts, :author, foreign_key: { to_table: :users }

기본 동작:

post.author → User 조회
post.author = user → author_id 설정
5.0+ belongs_to는 기본 optional: false (NOT NULL)

belongs_to :author, optional: true    # NULL 허용

has_many

class User < ApplicationRecord
  has_many :posts, foreign_key: "author_id", dependent: :destroy
end

user.posts                  # SELECT * FROM posts WHERE author_id = ?
user.posts.count
user.posts.create(title: "X")
user.posts << post
user.posts.destroy(post)
user.posts.delete_all

dependent:

:destroy (콜백 실행)
:delete_all (SQL DELETE, 빠름)
:nullify (FK NULL로)
:restrict_with_exception (자식 있으면 예외)
:restrict_with_error (검증 에러)

has_one

class User < ApplicationRecord
  has_one :profile, dependent: :destroy
end

class Profile < ApplicationRecord
  belongs_to :user
end

has_many :through

조인 테이블이 자체 모델인 M:N.

class Doctor < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

class Appointment < ApplicationRecord
  belongs_to :doctor
  belongs_to :patient
end

class Patient < ApplicationRecord
  has_many :appointments
  has_many :doctors, through: :appointments
end

doctor.patients              # 그를 만난 환자들
appointment = doctor.appointments.create(patient: patient, scheduled_at: ...)

through 모델에 추가 컬럼 가질 수 있어 가장 유연.

has_and_belongs_to_many

조인 테이블에 모델 없는 M:N. 거의 안 쓴다. through 권장.

class Post < ApplicationRecord
  has_and_belongs_to_many :tags
end

# 마이그레이션
create_join_table :posts, :tags

조인 테이블에 추가 컬럼 못 둠.

has_one :through

class Supplier < ApplicationRecord
  has_one :account
  has_one :account_history, through: :account
end

class Account < ApplicationRecord
  belongs_to :supplier
  has_one :account_history
end

class AccountHistory < ApplicationRecord
  belongs_to :account
end

supplier.account_history    # JOIN account → account_history

Polymorphic Associations

여러 종류 부모를 하나의 자식이 가질 수 있게.

class Comment < ApplicationRecord
  belongs_to :commentable, polymorphic: true
end

class Post < ApplicationRecord
  has_many :comments, as: :commentable
end

class Photo < ApplicationRecord
  has_many :comments, as: :commentable
end

# 마이그레이션
create_table :comments do |t|
  t.references :commentable, polymorphic: true, null: false
  t.text :body
  t.timestamps
end
# commentable_type (string), commentable_id (integer)

comments.commentable → Post 또는 Photo. type 컬럼으로 클래스명 저장.

함정: FK 제약 못 검. 데이터 무결성은 애플리케이션 책임.

self-join

class Employee < ApplicationRecord
  belongs_to :manager, class_name: "Employee", optional: true
  has_many :subordinates, class_name: "Employee", foreign_key: "manager_id"
end

조직도, 트리 구조.

STI (Single Table Inheritance)

여러 클래스가 한 테이블 공유.

class Vehicle < ApplicationRecord
end

class Car < Vehicle
end

class Truck < Vehicle
end

# 마이그레이션
create_table :vehicles do |t|
  t.string :type    # 클래스명 저장
  t.string :name
end

Car.create(name: "Tesla")     # type = "Car"
Vehicle.where(type: "Car")     # Car만
Car.all                        # type = "Car" 자동

타입이 적고 비슷할 때. 컬럼 많아지면 비효율.

Delegated Type (6.1+)

STI의 강력한 대안.

class Entry < ApplicationRecord
  delegated_type :entryable, types: %w[Message Comment]
end

class Message < ApplicationRecord
  include Entry::Entryable
end

class Comment < ApplicationRecord
  include Entry::Entryable
end

조회는 Entry로 통합, 각자 자기 테이블.

eager loading

# N+1
posts = Post.all
posts.each { |p| puts p.author.name }    # N+1

# includes (자동 선택: preload or eager_load)
Post.includes(:author).each { |p| puts p.author.name }

# preload: 별도 쿼리 (WHERE author 사용 불가)
Post.preload(:author)

# eager_load: LEFT OUTER JOIN
Post.eager_load(:author)

# joins: INNER JOIN (eager X)
Post.joins(:author).where(authors: { active: true })

# 여러 관계
Post.includes(:author, :comments, tags: :category)

extension

class User < ApplicationRecord
  has_many :posts do
    def published
      where(published: true)
    end

    def recent
      order(created_at: :desc).limit(5)
    end
  end
end

user.posts.published
user.posts.recent.published

counter_cache

class Comment < ApplicationRecord
  belongs_to :post, counter_cache: true
end

# Post에 comments_count 컬럼 필요
post.comments_count    # SQL 없음

자동 +1/-1. M+1 회피.

# 명시 컬럼명
belongs_to :post, counter_cache: :total_comments

inverse_of

class Post < ApplicationRecord
  has_many :comments, inverse_of: :post
end

class Comment < ApplicationRecord
  belongs_to :post, inverse_of: :comments
end

post = Post.find(1)
comment = post.comments.first
comment.post.equal?(post)    # true (같은 객체 메모리 공유)

자동 추론되는 경우도 있지만 명시가 안전. 메모리 절약 + 검증 일관.

has_many association 옵션

has_many :posts,
  -> { where(published: true).order(created_at: :desc) },    # 기본 scope
  class_name: "Article",
  foreign_key: "author_id",
  primary_key: "uuid",
  dependent: :destroy,
  inverse_of: :author,
  autosave: true,        # 부모 저장 시 자동 자식 저장
  validate: true,
  counter_cache: :article_count

자주 보는 패턴

Through with extra data

class Membership < ApplicationRecord
  belongs_to :user
  belongs_to :group
  # 가입일, 권한 등 추가 컬럼
end

class User < ApplicationRecord
  has_many :memberships
  has_many :groups, through: :memberships
end

Polymorphic + Comment

class Post; has_many :comments, as: :commentable; end
class Video; has_many :comments, as: :commentable; end

Comment.where(commentable: post).count
Comment.where(commentable_type: "Post").count

Soft delete (paranoid)

gem "paranoia"

class Post < ApplicationRecord
  acts_as_paranoid
end

post.destroy           # deleted_at 설정만
Post.all               # deleted 제외
Post.with_deleted
post.restore

대안: discard gem (더 단순).

함정

1. dependent 빠뜨림

has_many :comments    # 부모 삭제해도 자식 남음 → orphan
has_many :comments, dependent: :destroy

DB FK가 있으면 ON DELETE 동작은 별도.

2. 큰 has_many에 destroy

post.destroy    # comments 모두 콜백 실행 → 매우 느림

대안: dependent: :delete_all (콜백 X) 또는 background job.

3. through + has_many 메모리

Post.includes(:tags).each { |p| p.tags.each {} }
# tags가 100개 × posts 100개 = 10000 객체

through 깊이 주의.

4. polymorphic FK 제약 X

DB가 commentable_id가 진짜 존재하는 행 가리키는지 모름. 직접 검증 또는 callback.

5. inverse 추론 실패

class Post; has_many :tags; end
class Tag; belongs_to :post; end    # inverse 자동 추론

class Post; has_many :tags, class_name: "TagModel"; end
class TagModel; belongs_to :post; end    # 추론 실패, inverse_of 필요

[Rails] AR Validations와 Callbacks

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

ActiveRecord는 save 전 검증과 다양한 라이프사이클 콜백을 제공한다. 검증은 DB 제약과 별도(애플리케이션 레벨). 콜백은 신중히, 비즈니스 로직은 service object로 분리하는 게 일반.

검증

class User < ApplicationRecord
  validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
  validates :age, numericality: { greater_than_or_equal_to: 0, less_than: 150 }
  validates :password, length: { minimum: 8 }, on: :create
  validates :role, inclusion: { in: %w[admin user guest] }
  validates :bio, length: { maximum: 500 }
end

user = User.new(email: "")
user.valid?           # false
user.errors           # ActiveModel::Errors
user.errors.full_messages   # ["Email can't be blank", ...]
user.save             # false (검증 실패)
user.save!            # ActiveRecord::RecordInvalid 예외

빌트인 검증

validator	옵션
`presence`	`true`, allow_nil: false
`uniqueness`	`true`, scope, case_sensitive, conditions
`length`	minimum, maximum, in: 1..100
`format`	with: regex
`inclusion`	in: […]
`exclusion`	in: […]
`numericality`	greater_than, less_than, only_integer
`acceptance`	(체크박스, 약관)
`confirmation`	(password_confirmation)
`comparison`	greater_than: :other_field (7.0+)

여러 attribute 동시:

validates :title, :body, presence: true

조건부 검증

validates :password, length: { minimum: 8 }, if: :new_record?
validates :credit_card, presence: true, if: -> { paid? }
validates :age, numericality: true, unless: :guest?

커스텀 검증

class User < ApplicationRecord
  validate :email_must_be_company_domain

  private

  def email_must_be_company_domain
    return if email.blank?
    errors.add(:email, "must be a company email") unless email.ends_with?("@example.com")
  end
end

또는 클래스로:

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    unless value =~ URI::MailTo::EMAIL_REGEXP
      record.errors.add(attribute, "is not a valid email")
    end
  end
end

class User < ApplicationRecord
  validates :email, email: true
end

errors

user.errors[:email]                  # ["can't be blank", ...]
user.errors.add(:base, "something")  # 모델 전체 에러
user.errors.full_messages
user.errors.full_messages_for(:email)
user.errors.delete(:email)
user.errors.size
user.errors.any?

폼 표시:

<% if @user.errors.any? %>
  <ul>
    <% @user.errors.full_messages.each do |msg| %>
      <li><%= msg %></li>
    <% end %>
  </ul>
<% end %>

Strong Migration / DB 제약과 함께

검증은 race condition 회피 못 함.

validates :email, uniqueness: true

두 요청이 동시에 같은 email로 가입 → 둘 다 검증 통과 → DB INSERT 시 unique 제약 위반.

해결: DB 레벨 unique index 필수.

add_index :users, :email, unique: true

검증은 사용자에 친절한 에러 메시지, DB는 무결성 보장.

Callbacks

라이프사이클 hook.

Callback	시점
`before_validation`	검증 전
`after_validation`	검증 후
`before_save`	save 전 (create + update)
`around_save`	save 둘러쌈
`after_save`	save 후
`before_create` / `after_create`	create 전후
`before_update` / `after_update`	update 전후
`before_destroy` / `after_destroy`	destroy 전후
`after_commit`	트랜잭션 commit 후
`after_rollback`	rollback 후
`after_initialize`	new 호출 직후
`after_find`	DB에서 로드 직후
`after_touch`	touch 후

순서: before_validation → validate → after_validation → before_save → before_create/update → save → after_create/update → after_save → after_commit.

사용 예

class Post < ApplicationRecord
  before_validation :generate_slug
  before_save :normalize_title
  after_create :notify_subscribers
  after_destroy :clear_cache

  private

  def generate_slug
    self.slug ||= title.parameterize
  end

  def normalize_title
    self.title = title.strip.squeeze(" ")
  end

  def notify_subscribers
    NotifySubscribersJob.perform_later(id)
  end

  def clear_cache
    Rails.cache.delete_matched("post:#{id}:*")
  end
end

after_commit

비동기 작업 트리거에 표준.

after_commit :enqueue_index, on: [:create, :update]
after_commit :remove_index, on: :destroy

def enqueue_index
  IndexJob.perform_later(id)
end

트랜잭션 commit 후 호출 → 워커가 진짜 commit된 데이터 볼 수 있음.

after_create_commit, after_update_commit, after_destroy_commit도 있음.

조건부 callback

before_save :downcase_email, if: :email_changed?
after_create :send_welcome, unless: :guest?

abort 콜백 (5.0+)

before_destroy :prevent_if_admin

def prevent_if_admin
  throw :abort if admin?
end

return false는 deprecated. throw :abort.

함정과 안티패턴

1. 콜백 과다 사용

class Post < ApplicationRecord
  after_save :update_search_index
  after_save :notify_subscribers
  after_save :clear_caches
  after_save :send_to_analytics
  after_save :update_user_stats
  ...

테스트 어렵고 디버깅 지옥. service object 패턴 권장.

class CreatePost
  def call(params)
    post = Post.new(params)
    return post unless post.save

    SearchIndex.add(post)
    NotifySubscribers.call(post)
    CacheInvalidator.call(post)
    post
  end
end

2. callback에서 무한 루프

after_save :update_views

def update_views
  self.views_summary = ...
  save    # 또 after_save → 무한 루프
end

해결:

update_columns (콜백 우회)
update_column
플래그

def update_views
  update_columns(views_summary: ...)
end

3. callback과 update_all

Post.where(...).update_all(views: 0)    # 콜백 미실행

콜백 의존 로직 깨짐. 명시적으로 알고 사용.

4. uniqueness 검증의 race

위에서 설명. DB index 필수.

5. validation 의존 외부 호출

validate :api_check

def api_check
  errors.add(:base, "external") if ExternalApi.invalid?(self)
end

매 save마다 외부 호출 → 느림. 캐싱 또는 별도 시점 검증.

검증 skip

post.save(validate: false)
post.update_columns(title: "...")    # 검증 + 콜백 우회

신중히. 주로 데이터 마이그레이션.

자주 보는 패턴

normalizes (7.1+)

class User < ApplicationRecord
  normalizes :email, with: ->(email) { email.strip.downcase }
end

user = User.new(email: "  Alice@Example.com  ")
user.email    # "alice@example.com"

before_validation을 깔끔하게.

encrypts (7.0+)

class User < ApplicationRecord
  encrypts :ssn, deterministic: true
end

user.ssn = "..."    # 자동 암호화 저장
user.ssn            # 복호화 반환

자세한 건 rails-active-record-encryption.

tokens

class User < ApplicationRecord
  has_secure_token :api_key
end

user = User.create
user.api_key    # 자동 생성된 토큰
user.regenerate_api_key

[Rails] Caching: fragment, action, low-level, Russian Doll

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails 캐싱은 fragment, action, page, HTTP, low-level (Rails.cache) 5단계. 모델·뷰 단위로 자동 무효화 (Russian Doll Caching)가 핵심. Rails 8부터 Solid Cache (DB 백엔드) 기본.

백엔드

# config/environments/production.rb
config.cache_store = :solid_cache_store
# 또는
config.cache_store = :redis_cache_store, { url: ENV["REDIS_URL"] }
config.cache_store = :memory_store, { size: 64.megabytes }
config.cache_store = :file_store, "/tmp/rails-cache"
config.cache_store = :null_store    # 비활성

옵션	특징
`:solid_cache_store` (8.0+)	DB, Redis 불필요
`:redis_cache_store`	Redis (빠름, 분산)
`:memcache_store`	Memcached
`:mem_cache_store`	동일
`:memory_store`	프로세스 메모리 (개발)
`:file_store`	파일

캐시 활성화 (development)

기본은 dev에서 캐싱 OFF:

bin/rails dev:cache    # tmp/caching-dev.txt 토글
# 다시 끄려면 같은 명령

low-level: Rails.cache

Rails.cache.write("key", value, expires_in: 1.hour)
Rails.cache.read("key")
Rails.cache.fetch("key", expires_in: 1.hour) { expensive_computation }
Rails.cache.delete("key")
Rails.cache.delete_matched("prefix:*")    # 와일드카드
Rails.cache.exist?("key")
Rails.cache.clear    # 위험 (전체 비움)

# 다중
Rails.cache.write_multi({ "a" => 1, "b" => 2 })
Rails.cache.read_multi("a", "b")

# 증감
Rails.cache.increment("counter", 1)
Rails.cache.decrement("counter")

fetch 패턴

def top_posts
  Rails.cache.fetch("top_posts", expires_in: 5.minutes) do
    Post.order(views: :desc).limit(10).to_a
  end
end

캐시 hit → 즉시 반환. miss → 블록 실행 + 저장.

fragment cache

<% cache @post do %>
  <h1><%= @post.title %></h1>
  <p><%= @post.body %></p>
<% end %>

<% cache [@post, "v2"] do %>
  <%# 버전 추가 - 코드 변경 시 캐시 무효화 #}
<% end %>

<% cache_if condition, @post do %>
  ...
<% end %>

키 자동 생성: views/posts/123-20260620143000. 모델의 cache_key_with_version.

컬렉션

<%= render partial: "post", collection: @posts, cached: true %>

각 post에 대해 fragment cache. 첫 요청 후 hit 비율 매우 높음.

Russian Doll Caching

부모 + 자식 nested 캐시. 자식 변경 시 부모도 자동 무효화 (updated_at 변경).

<% cache @post do %>
  <h1><%= @post.title %></h1>

  <% @post.comments.each do |comment| %>
    <% cache comment do %>
      <%= render comment %>
    <% end %>
  <% end %>
<% end %>

class Comment < ApplicationRecord
  belongs_to :post, touch: true    # 댓글 저장 시 post.updated_at 갱신
end

touch: true로 부모 cache_key 자동 갱신 → fragment 무효화. 매우 효율적.

HTTP 캐싱

Conditional GET

def show
  @post = Post.find(params[:id])
  if stale?(@post)    # ETag/Last-Modified 자동
    render
  end
end

# 또는
def show
  @post = Post.find(params[:id])
  fresh_when(@post)    # stale 시 render, fresh 시 304
end

브라우저가 If-None-Match 헤더로 다시 요청 → 변경 없으면 304 Not Modified.

Cache-Control

def index
  @posts = Post.featured
  expires_in 5.minutes, public: true
  render
end

Cache-Control: public, max-age=300 응답.

Cache key

post.cache_key                  # "posts/123"
post.cache_key_with_version     # "posts/123-20260620143000"
post.cache_version              # "20260620143000"

# 커스텀
class Post < ApplicationRecord
  def cache_key
    "post/#{id}/#{updated_at.to_i}"
  end
end

cache_key + cache_version 자동 결합.

자주 보는 패턴

비싼 쿼리

def expensive_stats
  Rails.cache.fetch("stats", expires_in: 1.hour) do
    {
      users: User.count,
      posts: Post.count,
      active: User.active.count,
    }
  end
end

외부 API 결과

def github_user(username)
  Rails.cache.fetch("github:#{username}", expires_in: 1.day) do
    Net::HTTP.get(URI("https://api.github.com/users/#{username}"))
  end
end

API rate limit + 응답 속도 둘 다 향상.

컬렉션 페이지네이션

<% cache [@posts, params[:page]] do %>
  <%= render @posts %>
<% end %>

페이지별 캐시. 페이지 안의 post 변경 시 자동 무효화.

사용자별

<% cache [@post, current_user] do %>
  <%# 사용자별 다른 내용 (좋아요 여부 등) %>
<% end %>

각 사용자마다 별도 키.

Solid Cache (Rails 8)

# Gemfile (8.0+ 자동)
gem "solid_cache"

# config/cache.yml
production:
  database: cache
  store_options:
    max_age: 14.days
    max_size: 256.megabytes

DB 기반 → Redis 불필요. LRU eviction. SQL 인덱스로 빠름.

함정

1. 캐시 무효화

“There are only two hard things in CS: cache invalidation and naming things.”

touch: true로 자동 무효화 권장. 수동 Rails.cache.delete는 누락 위험.

2. fetch 블록 안 예외

Rails.cache.fetch("key") do
  raise "fail"
end
# 다음 호출도 매번 fail (캐시 안 됨)

블록은 정상 반환해야 캐시. nil 반환은 캐시되지 않음 (skip_nil 옵션 X).

3. cache stampede

만료 직후 동시 다수 요청 → 모두 DB. 해결:

race_condition_ttl로 약간의 grace
미리 갱신 (TTL 도달 전)
lock-based 갱신

Rails.cache.fetch("key", expires_in: 5.minutes, race_condition_ttl: 30.seconds) do
  ...
end

4. Cache.clear in production

Rails.cache.clear 전체 비움. 다른 앱이 같은 store 공유 시 영향. namespace 사용:

config.cache_store = :redis_cache_store, { namespace: "myapp:" }

5. 키 너무 길거나 dict 직렬화

Rails.cache.fetch([@user, @post, params])    # params hash → 직렬화 비싼

명시 키 권장.

모니터링

캐시 hit/miss ratio
메모리 사용량
key 분포 (redis-cli --bigkeys)

Skylight, NewRelic, AppSignal 같은 APM이 자동 측정.

캐시 vs 다른 최적화

DB 인덱스 추가가 보통 첫 번째
N+1 해결
그 다음 캐시

캐시는 정합성 비용 + 디버깅 복잡. 진짜 필요할 때만.

[Rails] Concerns, Engines, Generators

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Concern은 모듈에 클래스 메서드와 콜백을 한 곳에 모으는 패턴. Engine은 별도 gem으로 분리 가능한 미니 Rails 앱. Generator는 코드 자동 생성 (모델, 컨트롤러, 마이그레이션 등). 셋 다 코드 재사용·모듈화 도구.

ActiveSupport::Concern

# app/models/concerns/trashable.rb
module Trashable
  extend ActiveSupport::Concern

  included do
    scope :trashed, -> { where.not(trashed_at: nil) }
    scope :not_trashed, -> { where(trashed_at: nil) }

    before_destroy :prevent_if_trashed
  end

  class_methods do
    def trash_count
      trashed.count
    end
  end

  # 인스턴스 메서드
  def trash!
    update!(trashed_at: Time.current)
  end

  def restore!
    update!(trashed_at: nil)
  end

  private

  def prevent_if_trashed
    throw :abort if trashed_at.present?
  end
end

class Post < ApplicationRecord
  include Trashable
end

class Comment < ApplicationRecord
  include Trashable
end

post.trash!
Post.trashed
Post.trash_count

included do ... end 블록 안의 모든 코드는 include하는 클래스 컨텍스트에서 실행 → scope, validation, callback 추가.

일반 module과 비교

# 일반 module
module Trashable
  def self.included(base)
    base.scope :trashed, -> { where.not(trashed_at: nil) }
    base.before_destroy :prevent_if_trashed
  end

  module ClassMethods
    def trash_count
      ...
    end
  end
end

class Post < ApplicationRecord
  include Trashable
  extend Trashable::ClassMethods
end

ActiveSupport::Concern이 boilerplate 제거.

의존성 해결

module A
  extend ActiveSupport::Concern
end

module B
  extend ActiveSupport::Concern
  include A    # A가 먼저 included됨
end

class Post
  include B    # B만 include하면 A도 자동
end

순서 자동 해결.

Controller Concern

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

  included do
    before_action :authenticate_user!
    helper_method :current_user
  end

  private

  def current_user
    @current_user ||= User.find_by(id: session[:user_id])
  end

  def authenticate_user!
    redirect_to login_path unless current_user
  end
end

class ApplicationController < ActionController::Base
  include Authentication
end

Rails Engine

Mini Rails app을 gem으로.

rails plugin new my_engine --mountable

my_engine/
├── app/
│   ├── controllers/my_engine/
│   ├── models/my_engine/
│   └── views/my_engine/
├── config/routes.rb
├── lib/my_engine/engine.rb
└── my_engine.gemspec

engine.rb:

module MyEngine
  class Engine < ::Rails::Engine
    isolate_namespace MyEngine
  end
end

호스트 앱에서:

# Gemfile
gem "my_engine", path: "../my_engine"
# 또는 git/path 등

# config/routes.rb
mount MyEngine::Engine => "/my_engine"

URL: /my_engine/posts/...

자주 보는 Engine

Devise (인증)
Sidekiq Web UI (mount Sidekiq::Web => "/sidekiq")
Mission Control (mount MissionControl::Jobs::Engine => "/jobs")
Rails admin / ActiveAdmin (관리자 UI)
Wagtail Ruby 버전: NO (Wagtail은 Django)

대규모 앱을 여러 모듈로 분리하는 데도 사용.

Generator

빌트인

bin/rails g model Post title:string body:text
bin/rails g controller Posts index show
bin/rails g migration AddSlugToPosts slug:string:uniq
bin/rails g scaffold Post title:string body:text
bin/rails g mailer UserMailer welcome
bin/rails g job CleanupJob
bin/rails g channel Chat
bin/rails g system_test posts

커스텀 Generator

bin/rails g generator service

# lib/generators/service/service_generator.rb
class ServiceGenerator < Rails::Generators::NamedBase
  source_root File.expand_path("templates", __dir__)

  def create_service_file
    template "service.rb.tt", "app/services/#{file_name}_service.rb"
  end

  def create_test_file
    template "service_test.rb.tt", "test/services/#{file_name}_service_test.rb"
  end
end

# lib/generators/service/templates/service.rb.tt
class <%= class_name %>Service
  def call
    # TODO
  end
end

사용:

bin/rails g service CreatePost
# app/services/create_post_service.rb 생성
# test/services/create_post_service_test.rb 생성

Generator 옵션

bin/rails g model Post --skip-migration --skip-test --skip-fixture

config/application.rb로 기본 옵션:

config.generators do |g|
  g.test_framework :rspec, fixture: false
  g.factory_bot dir: "spec/factories"
  g.skip_routes true
end

새 generator 호출 시 자동 적용.

자주 보는 Concern 패턴

Sluggable

module Sluggable
  extend ActiveSupport::Concern

  included do
    before_validation :generate_slug, on: :create
    validates :slug, presence: true, uniqueness: true
  end

  def to_param
    slug
  end

  private

  def generate_slug
    self.slug ||= title.parameterize
  end
end

Notifiable

module Notifiable
  extend ActiveSupport::Concern

  included do
    has_many :notifications, as: :notifiable, dependent: :destroy

    after_create_commit :notify_subscribers
  end

  private

  def notify_subscribers
    subscribers.each do |user|
      Notification.create!(user: user, notifiable: self)
    end
  end
end

Searchable

module Searchable
  extend ActiveSupport::Concern

  class_methods do
    def search(query)
      where("title ILIKE :q OR body ILIKE :q", q: "%#{query}%")
    end
  end
end

Concern 안티패턴

1. Concern으로 god module

module Post::Behaviors
  extend ActiveSupport::Concern
  # 300줄
end

작은 concern으로 분리.

2. concern 의존성

module A
  def call
    do_b   # B의 메서드 필요
  end
end

module B
  def do_b; ... end
end

class C
  include A    # B 빠뜨림 → 런타임 NoMethodError
  include B
end

명시적 include 의존 위험. 서비스 객체로 분리가 더 안전.

3. service object 대체

# 컨트롤러 concern으로 비즈니스 로직
module CreatePost
  def create_post(params)
    Post.transaction do
      post = Post.create!(params)
      Notification.create!(...)
      post
    end
  end
end

→ Service object 클래스가 더 명확:

class CreatePostService
  def call(params)
    Post.transaction do
      post = Post.create!(params)
      Notification.create!(...)
      post
    end
  end
end

Engine 함정

1. 호스트 앱과 라우트 충돌

mount MyEngine::Engine => "/"    # 충돌 가능
mount MyEngine::Engine => "/admin"    # 안전

2. asset compile

Engine asset도 host에서 collectstatic / asset compile 필요.

3. 의존성 관리

Engine의 gem 의존성이 host와 충돌. gemspec에서 정확한 버전.

[Rails] Controller: params, strong params, filters

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails Controller는 라우터가 전달한 요청을 받아 Model 조작 + View 렌더링을 조율한다. RESTful 7 action(index, show, new, create, edit, update, destroy) 패턴이 표준. ApplicationController가 모든 컨트롤러의 부모.

기본

rails g controller Posts index show new create

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def index
    @posts = Post.published.order(created_at: :desc)
  end

  def show
    @post = Post.find(params[:id])
  end

  def new
    @post = Post.new
  end

  def create
    @post = Post.new(post_params)
    if @post.save
      redirect_to @post, notice: "글이 작성되었습니다"
    else
      render :new, status: :unprocessable_entity
    end
  end

  def edit
    @post = Post.find(params[:id])
  end

  def update
    @post = Post.find(params[:id])
    if @post.update(post_params)
      redirect_to @post
    else
      render :edit, status: :unprocessable_entity
    end
  end

  def destroy
    Post.find(params[:id]).destroy
    redirect_to posts_path, notice: "삭제됨"
  end

  private

  def post_params
    params.require(:post).permit(:title, :body, tag_ids: [])
  end
end

Strong Parameters

mass assignment 보호. permit된 키만 통과.

params.require(:post).permit(:title, :body)
params.require(:post).permit(:title, :body, tag_ids: [])    # 배열
params.require(:post).permit(:title, address: [:street, :city])    # 중첩

# 모두 허용 (위험!)
params.permit!

require는 키 강제, permit는 허용 목록.

예시

# request body
{
  "post": {
    "title": "Hello",
    "body": "...",
    "admin": true,        # 악성 입력
    "tags": [1, 2]
  }
}

params.require(:post).permit(:title, :body, tags: [])
# => {title: "Hello", body: "...", tags: [1, 2]}
# admin은 자동 제외

params 접근

params[:id]                    # URL 또는 form
params[:post][:title]
params.dig(:post, :tags, 0)
params.permit(:q).fetch(:q, "default")

# 쿼리스트링 (?key=value)
params[:q]

# JSON body
params[:user][:name]    # JSON 자동 파싱

# 파일
params[:avatar]    # ActionDispatch::Http::UploadedFile

render와 redirect

# View 렌더링
render :show                              # views/posts/show.html.erb
render "other/template"
render plain: "Hello"
render json: @post
render xml: @post
render html: "<h1>Hi</h1>".html_safe
render status: :not_found                  # 또는 404
render layout: "admin"
render partial: "post", locals: { post: @post }
render template: "posts/index"

# 리다이렉트
redirect_to @post                          # post_path(@post)
redirect_to posts_path
redirect_to root_path, status: :see_other  # 303 (POST 후)
redirect_to "/external", allow_other_host: true
redirect_back fallback_location: root_path
redirect_back_or_to root_path              # 7.0+

render와 redirect_to는 한 action에 한 번만. 두 번 호출 시 DoubleRenderError.

flash

세션 1회용 메시지.

# Controller
redirect_to @post, notice: "저장됨"
redirect_to @post, alert: "실패"
flash[:custom] = "내용"
flash.now[:warning] = "view에서만 표시 (redirect 안 함)"

<%# View %>
<% flash.each do |key, message| %>
  <div class="<%= key %>"><%= message %></div>
<% end %>

<% if notice %>
  <div class="notice"><%= notice %></div>
<% end %>

flash.now는 redirect 안 하고 같은 request에서 표시.

Filter (before/after/around)

class PostsController < ApplicationController
  before_action :require_login, except: [:index, :show]
  before_action :load_post, only: [:show, :edit, :update, :destroy]
  before_action :require_owner, only: [:edit, :update, :destroy]
  after_action :track_view, only: :show
  around_action :log_timing

  private

  def require_login
    redirect_to login_path unless current_user
  end

  def load_post
    @post = Post.find(params[:id])
  end

  def require_owner
    redirect_to root_path unless @post.author == current_user
  end

  def track_view
    @post&.increment!(:views)
  end

  def log_timing
    start = Time.current
    yield
    Rails.logger.info("took #{Time.current - start}")
  end
end

only: / except:로 적용 액션 제한.

skip_before_action

상속받았는데 일부 액션엔 적용 안 하고 싶을 때.

class ApplicationController < ActionController::Base
  before_action :authenticate
end

class PublicController < ApplicationController
  skip_before_action :authenticate, only: [:landing]
end

respond_to / format

def show
  @post = Post.find(params[:id])
  respond_to do |format|
    format.html              # show.html.erb
    format.json { render json: @post }
    format.xml { render xml: @post }
    format.csv { send_data @post.to_csv, filename: "post.csv" }
  end
end

요청의 Accept 헤더 또는 URL 확장자(.json, .xml) 기반 분기.

API 컨트롤러

class Api::V1::PostsController < ApplicationController
  skip_forgery_protection    # CSRF 제외 (JWT 등)

  def index
    posts = Post.published.limit(20)
    render json: posts
  end

  def create
    post = Post.new(post_params.merge(author: current_user))
    if post.save
      render json: post, status: :created
    else
      render json: { errors: post.errors }, status: :unprocessable_entity
    end
  end
end

또는 ActionController::API 베이스 (HTML 미들웨어 제외, 가벼움):

class Api::ApplicationController < ActionController::API
end

예외 처리

class ApplicationController < ActionController::Base
  rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
  rescue_from ActionController::ParameterMissing, with: :bad_request

  private

  def record_not_found(e)
    render plain: "404", status: :not_found
  end

  def bad_request(e)
    render json: { error: e.message }, status: :bad_request
  end
end

helper_method

view에서 사용 가능하게.

class ApplicationController < ActionController::Base
  helper_method :current_user

  def current_user
    @current_user ||= User.find_by(id: session[:user_id])
  end
end

view에서 <%= current_user.name %>.

Concerns

여러 controller 공통 로직.

# app/controllers/concerns/pagination.rb
module Pagination
  extend ActiveSupport::Concern

  def paginate(scope)
    page = params[:page] || 1
    scope.page(page).per(20)
  end
end

class PostsController < ApplicationController
  include Pagination
end

세션과 쿠키

# 세션
session[:user_id] = user.id
session[:cart] = [1, 2, 3]
reset_session

# 쿠키
cookies[:remember] = "value"
cookies[:remember] = { value: "...", expires: 1.year.from_now, httponly: true }
cookies.signed[:user_id] = user.id      # 서명 (조작 감지)
cookies.encrypted[:secret] = "..."      # 암호화
cookies.delete(:remember)

세션 저장: cookie store (기본, 작은 데이터), DB, Redis, Memcached.

자주 보는 패턴

before_action으로 @resource 설정

class PostsController < ApplicationController
  before_action :set_post, only: %i[show edit update destroy]

  def show; end
  def edit; end
  def update
    if @post.update(post_params)
      ...
    end
  end

  private

  def set_post
    @post = Post.find(params[:id])
  end
end

scaffold가 생성하는 패턴.

Pundit/CanCanCan 인가

def update
  @post = Post.find(params[:id])
  authorize @post    # Pundit policy 검사
  @post.update(post_params)
end

자세한 건 별도 페이지.

Pagy / Kaminari

def index
  @pagy, @posts = pagy(Post.all)    # pagy gem
  # 또는
  @posts = Post.page(params[:page]).per(20)    # kaminari
end

함정

1. permit 누락

params.require(:post).permit(:title)
# :body, :tag_ids 등은 무시됨

새 필드 추가 시 permit도 업데이트.

2. params.require가 nil 이면 ParameterMissing

params.require(:post)    # post 키 없으면 예외

rescue_from으로 처리 또는 params[:post]&.permit(...).

3. instance variable 안 설정

def show
  post = Post.find(params[:id])    # 로컬 변수
end

view에서 @post로 접근 안 됨.

4. authenticity_token

POST 폼은 CSRF 토큰 필요. form_with 헬퍼가 자동 포함. 직접 폼 작성 시:

<form method="post">
  <%= hidden_field_tag :authenticity_token, form_authenticity_token %>
  ...
</form>

5. redirect status

POST 후 GET 리다이렉트는 303 see_other. 7.0+에서 기본 동작 변경.

[Rails] Encrypted Credentials과 환경변수

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails 5.2+ encrypted credentials는 비밀 정보를 암호화해 git에 안전하게 커밋. Rails 6+ 환경별 (development.yml.enc, production.yml.enc) 가능. .env 파일 + dotenv-rails는 대안.

기본 사용

bin/rails credentials:edit
# EDITOR 환경변수의 에디터로 plain YAML 열림
# 저장 시 자동 암호화

# credentials.yml.enc (편집 시 plain text)
secret_key_base: ...

aws:
  access_key_id: ...
  secret_access_key: ...

stripe:
  publishable_key: pk_...
  secret_key: sk_...
  webhook_secret: whsec_...

sendgrid:
  api_key: SG.xxx

Rails.application.credentials.aws[:access_key_id]
Rails.application.credentials.dig(:aws, :access_key_id)    # 안전한 nested
Rails.application.credentials.stripe![:secret_key]    # 누락 시 raise

파일 구조

config/
├── master.key              # .gitignore (커밋 X)
└── credentials.yml.enc     # 암호화 (커밋 O)

master.key 노출 → 모든 비밀 노출. 절대 git에 커밋 X.

환경별

bin/rails credentials:edit -e production
# config/credentials/production.yml.enc + production.key
bin/rails credentials:edit -e staging

Rails.env에 따라 자동 선택. 각 환경 다른 키.

config/
├── master.key                       # 기본 (development/test)
├── credentials.yml.enc              # 공통
└── credentials/
    ├── production.yml.enc
    ├── production.key               # .gitignore
    ├── staging.yml.enc
    └── staging.key

환경변수로 키

RAILS_MASTER_KEY=xxx bin/rails server

CI/CD, Docker, k8s에서 master.key 파일 대신 RAILS_MASTER_KEY 환경변수.

코드에서

# config/initializers/stripe.rb
Stripe.api_key = Rails.application.credentials.stripe[:secret_key]

# config/database.yml
production:
  password: <%= Rails.application.credentials.db[:password] %>

# Action Mailer
config.action_mailer.smtp_settings = {
  user_name: Rails.application.credentials.smtp[:user],
  password: Rails.application.credentials.smtp[:password],
}

.env (dotenv-rails)

# Gemfile
gem "dotenv-rails", groups: [:development, :test]

# .env (.gitignore)
DATABASE_URL=postgres://localhost/myapp_dev
STRIPE_SECRET=sk_test_...
SENDGRID_API_KEY=SG.xxx

# .env.example (git 커밋)
DATABASE_URL=
STRIPE_SECRET=
SENDGRID_API_KEY=

ENV["STRIPE_SECRET"]
ENV.fetch("STRIPE_SECRET")    # 누락 시 raise
ENV.fetch("PORT", "3000")    # 기본값

.env는 개발 편의. 프로덕션은 OS 환경변수 또는 secrets manager.

Credentials vs .env

항목	Credentials	.env
암호화	O	X (git 커밋 X)
git에 안전	O	X
편집	`credentials:edit`	텍스트
키 관리	master.key	없음
동적 로드	restart 필요	restart 필요

Rails 5.2+ 신규는 credentials. legacy는 .env 그대로.

Vault / AWS Secrets Manager

대규모는 외부 KMS:

# config/initializers/secrets.rb
require "aws-sdk-secretsmanager"

client = Aws::SecretsManager::Client.new(region: "ap-northeast-2")
secrets = JSON.parse(client.get_secret_value(secret_id: "myapp/prod").secret_string)

Rails.application.config.x.stripe_key = secrets["stripe_key"]

키 회전, 권한, 감사 로그가 KMS 우위.

환경 분리 예시

# config/initializers/stripe.rb
api_key = if Rails.env.production?
  Rails.application.credentials.dig(:stripe, :live_secret_key)
elsif Rails.env.staging?
  Rails.application.credentials.dig(:stripe, :test_secret_key)
else
  ENV["STRIPE_TEST_KEY"] || "sk_test_default"
end

Stripe.api_key = api_key

자주 보는 패턴

모든 secret 한 곳에

# config/initializers/00_secrets.rb (먼저 로드)
module AppSecrets
  module_function

  def stripe_key
    Rails.application.credentials.dig(:stripe, :secret_key) || raise("Missing stripe key")
  end

  def aws_access
    Rails.application.credentials.dig(:aws, :access_key_id) || raise("Missing AWS access")
  end
end

# 사용
Stripe.api_key = AppSecrets.stripe_key

타입 안전 + 누락 명확.

Health check + 시작 시 검증

# config/initializers/validate_secrets.rb
required = [
  [:stripe, :secret_key],
  [:aws, :access_key_id],
  [:sendgrid, :api_key],
]

missing = required.reject { |path| Rails.application.credentials.dig(*path).present? }
if missing.any?
  raise "Missing credentials: #{missing.inspect}"
end

서버 시작 시 누락 즉시 발견.

12-factor 환경변수 우선

def secret(key, path:)
  ENV[key] || Rails.application.credentials.dig(*path)
end

Stripe.api_key = secret("STRIPE_KEY", path: [:stripe, :secret_key])

ENV가 있으면 ENV, 없으면 credentials. 환경별 유연성.

함정

1. master.key 노출

git에 커밋, slack에 공유, CI 로그 출력 등. 노출 시:

즉시 새 키 생성
credentials 재암호화
모든 환경에 새 키 배포
노출된 비밀 (API key, password) 모두 회전

2. credentials 충돌

여러 개발자가 동시 편집 → merge conflict. credentials.yml.enc는 사실상 바이너리 → 수동 병합 불가.

해결: 한 명만 편집 + share / lock 프로세스.

3. Heroku / 클라우드 master.key

RAILS_MASTER_KEY 환경변수 설정.

heroku config:set RAILS_MASTER_KEY=$(cat config/master.key)

4. CI/CD

# GitHub Actions
- name: Test
  env:
    RAILS_MASTER_KEY: ${{ secrets.RAILS_MASTER_KEY }}
  run: bundle exec rspec

master.key를 CI secret으로.

5. test 환경

테스트는 실제 비밀 X. 더미 credentials:

# config/credentials/test.yml.enc
stripe:
  secret_key: sk_test_fake

또는 test에서 ENV / mock.

보안 모범

master.key는 별도 안전한 저장소
키 회전 정기 (분기 1회 등)
누가 언제 변경했는지 audit log
환경 분리 (dev/staging/prod 다른 키)
코드에 비밀 하드코딩 X
로그 / 에러 / 응답에 비밀 X

[Rails] Form Object, Service Object, Query Object

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Fat Model / Skinny Controller가 한계에 달하면 **POROs (Plain Old Ruby Objects)**로 책임 분리. Form Object (다중 모델 입력), Service Object (비즈니스 로직), Query Object (복잡한 쿼리), Decorator (표현 로직) 등.

Form Object

여러 모델을 한 폼에서 처리 (signup with profile, order with items).

# app/forms/signup_form.rb
class SignupForm
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :email, :string
  attribute :name, :string
  attribute :password, :string
  attribute :company_name, :string
  attribute :company_size, :integer

  validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
  validates :name, presence: true
  validates :password, length: { minimum: 8 }
  validates :company_name, presence: true

  attr_reader :user, :company

  def save
    return false unless valid?

    ActiveRecord::Base.transaction do
      @company = Company.create!(name: company_name, size: company_size)
      @user = User.create!(email: email, name: name, password: password, company: @company)
      true
    end
  rescue ActiveRecord::RecordInvalid => e
    errors.add(:base, e.message)
    false
  end
end

# Controller
class SignupController < ApplicationController
  def new
    @form = SignupForm.new
  end

  def create
    @form = SignupForm.new(signup_params)
    if @form.save
      session[:user_id] = @form.user.id
      redirect_to root_path
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def signup_params
    params.require(:signup_form).permit(:email, :name, :password, :company_name, :company_size)
  end
end

<%# View %>
<%= form_with model: @form, url: signup_path do |f| %>
  <%= f.text_field :email %>
  <%= f.text_field :name %>
  <%= f.password_field :password %>
  <%= f.text_field :company_name %>
  <%= f.number_field :company_size %>
  <%= f.submit "가입" %>
<% end %>

ActiveModel::Model로 form_with 호환 + validation.

Service Object

복잡한 비즈니스 로직 캡슐화.

# app/services/orders/create_order.rb
module Orders
  class CreateOrder
    Result = Struct.new(:success?, :order, :errors, keyword_init: true)

    def initialize(user:, items:, address:)
      @user = user
      @items = items
      @address = address
    end

    def call
      validate!
      order = create_order
      send_confirmation(order)
      Result.new(success?: true, order: order, errors: [])
    rescue ValidationError => e
      Result.new(success?: false, errors: e.errors)
    end

    private

    attr_reader :user, :items, :address

    def validate!
      raise ValidationError, ["No items"] if items.empty?
      ...
    end

    def create_order
      Order.transaction do
        order = Order.create!(user: user, address: address)
        items.each do |item|
          order.line_items.create!(product: item.product, quantity: item.quantity)
        end
        order.calculate_total!
        order
      end
    end

    def send_confirmation(order)
      OrderConfirmationJob.perform_later(order.id)
    end

    class ValidationError < StandardError
      attr_reader :errors
      def initialize(errors)
        @errors = errors
        super(errors.join(", "))
      end
    end
  end
end

# Controller
def create
  result = Orders::CreateOrder.new(
    user: current_user,
    items: cart_items,
    address: shipping_address,
  ).call

  if result.success?
    redirect_to result.order
  else
    flash[:error] = result.errors.join(", ")
    render :new, status: :unprocessable_entity
  end
end

표준 인터페이스

class ApplicationService
  def self.call(...)
    new(...).call
  end
end

class CreateOrder < ApplicationService
  def initialize(user:, items:)
    @user = user
    @items = items
  end

  def call
    ...
  end
end

# 사용
Orders::CreateOrder.call(user: current_user, items: items)

Query Object

복잡한 ActiveRecord 쿼리 분리.

# app/queries/posts/featured_posts_query.rb
module Posts
  class FeaturedPostsQuery
    def initialize(relation = Post.all)
      @relation = relation
    end

    def call
      @relation
        .joins(:author, :tags)
        .where(is_published: true)
        .where("views > ?", 1000)
        .where(authors: { active: true })
        .where(tags: { name: ["featured", "trending"] })
        .group(:id)
        .having("COUNT(tags.id) >= ?", 2)
        .order(views: :desc)
        .limit(10)
    end
  end
end

# 사용
posts = Posts::FeaturedPostsQuery.new.call
posts = Posts::FeaturedPostsQuery.new(current_user.posts).call    # scope 가능

Model에서 분리해 단일 책임 + 테스트 용이.

Decorator (Presenter)

표현 로직 (formatting, display)을 모델에서 분리.

draper gem

gem "draper"

# app/decorators/post_decorator.rb
class PostDecorator < Draper::Decorator
  delegate_all

  def published_at
    object.published_at&.strftime("%Y년 %-m월 %-d일") || "발행 안 됨"
  end

  def excerpt
    h.truncate(h.strip_tags(object.body), length: 200)
  end

  def status_badge
    h.content_tag(:span, status_label, class: "badge bg-#{status_color}")
  end

  private

  def status_label
    { draft: "초안", published: "발행" }[object.status.to_sym]
  end

  def status_color
    object.published? ? "green" : "gray"
  end
end

# Controller
@post = Post.find(params[:id]).decorate
@posts = Post.all.decorate

<%= @post.published_at %>    <%# "2026년 6월 20일" %>
<%= @post.excerpt %>
<%= @post.status_badge %>

h = helpers. 데코레이터에서 view 헬퍼 사용.

POROs

draper 없이 단순 PORO:

class PostPresenter
  def initialize(post, view_context)
    @post = post
    @h = view_context
  end

  def title
    @h.content_tag(:h1, @post.title)
  end

  def published_at
    @post.published_at&.strftime("%Y-%m-%d")
  end
end

# Controller
@post = PostPresenter.new(Post.find(params[:id]), view_context)

Policy Object (Pundit)

class PostPolicy < ApplicationPolicy
  def update?
    user.admin? || record.author == user
  end

  def destroy?
    user.admin?
  end

  class Scope < Scope
    def resolve
      if user.admin?
        scope.all
      else
        scope.where(author: user)
      end
    end
  end
end

자주 보는 패턴

모델은 단순화

class Post < ApplicationRecord
  belongs_to :author
  has_many :comments

  validates :title, presence: true

  scope :published, -> { where(is_published: true) }
  # 복잡한 쿼리는 Query Object로
  # 복잡한 비즈니스 로직은 Service로
  # 표현은 Decorator로
end

Controller도 단순화

def create
  result = Posts::CreatePost.call(user: current_user, params: post_params)
  if result.success?
    redirect_to result.post.decorate
  else
    @form = result.form
    render :new
  end
end

테스트

# Form Object
describe SignupForm do
  it "creates user and company" do
    form = SignupForm.new(email: "a@x.com", name: "Alice", password: "secret123", company_name: "Acme")
    expect(form.save).to be true
    expect(User.last.email).to eq("a@x.com")
    expect(Company.last.name).to eq("Acme")
  end
end

# Service
describe Orders::CreateOrder do
  it "creates order with items" do
    result = described_class.new(user: user, items: items, address: address).call
    expect(result).to be_success
    expect(result.order.line_items.count).to eq(items.size)
  end
end

# Query
describe Posts::FeaturedPostsQuery do
  it "returns top featured posts" do
    create_list(:post, 5, views: 2000, is_published: true)
    posts = described_class.new.call
    expect(posts.size).to eq(5)
  end
end

각 PORO를 독립 단위로 테스트. 빠르고 명확.

DHH의 반대 의견

DHH는 “Service Object 패턴”에 반대. Concern과 모델 자체로 충분하다는 입장. 트레이드오프:

모델에 모두: 응집, 단순. 그러나 거대화.
Service Object: 분리, 테스트 쉬움. 그러나 클래스 폭발.

소규모 프로젝트는 모델로 충분. 복잡해지면 분리 검토.

함정

1. 너무 많은 service object

app/services/
  create_user.rb
  update_user.rb
  delete_user.rb
  send_user_email.rb
  ...

CRUD 단순 작업까지 service면 boilerplate. 진짜 복잡한 것만.

2. service에 너무 많은 의존성

class CreateOrder
  def initialize(user:, items:, payment:, shipping:, tax:, discount:, ...)
    ...
  end
end

너무 많으면 책임이 큼. 더 작은 단위로 분리.

3. Form object와 모델 검증 중복

같은 규칙을 둘 다 정의 → 동기화 비용. Form은 폼 특화, 모델은 데이터 무결성.

4. Query object 남용

class PostByIdQuery
  def call(id)
    Post.find(id)
  end
end

단순 lookup은 그냥 Post.find(id).

5. Decorator의 view 의존

Decorator가 view helper에 강결합 → 단위 테스트 어려움. helper 의존을 최소화.

[Rails] Hotwire: Turbo Drive, Frames, Streams, Stimulus

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Hotwire는 Rails 7부터 기본인 “SPA 없이 SPA 같은 UX”를 위한 프론트엔드 접근. Turbo Drive(전체 페이지 전환을 fetch + DOM swap), Turbo Frames(부분 페이지 업데이트), Turbo Streams(서버 → 클라이언트 DOM 갱신), Stimulus(가벼운 JS 컴포넌트)로 구성. Basecamp/37signals가 만들고 사용 중.

Turbo Drive

기본 활성. 모든 링크/폼이 fetch로 가로채져 body만 교체.

// app/javascript/application.js
import "@hotwired/turbo-rails"
// 또는
import { Turbo } from "@hotwired/turbo-rails"

페이지 transition이 부드럽고 빠름. 전체 페이지 reload 없음.

일부 페이지 제외

<a href="/external" data-turbo="false">외부 사이트</a>
<form data-turbo="false">...</form>

Turbo Drive 옵션

<meta name="turbo-cache-control" content="no-cache">
<meta name="turbo-cache-control" content="no-preview">    <%# 미리 보기 미사용 %>

메서드와 confirm

<%= link_to "Delete", post,
            data: { turbo_method: :delete, turbo_confirm: "삭제하시겠습니까?" } %>

<a> 태그가 DELETE 요청 가능 (form 자동 생성).

Turbo Frames

<turbo-frame> 안의 링크/폼 결과를 그 frame만 교체.

<%# views/posts/show.html.erb %>
<%= turbo_frame_tag "post_#{@post.id}" do %>
  <h1><%= @post.title %></h1>
  <p><%= @post.body %></p>
  <%= link_to "수정", edit_post_path(@post) %>
<% end %>

<%# views/posts/edit.html.erb %>
<%= turbo_frame_tag "post_#{@post.id}" do %>
  <%= render "form", post: @post %>
<% end %>

수정 클릭 → edit 페이지 fetch → 같은 ID의 frame만 교체. 나머지 페이지(header, sidebar 등) 그대로.

lazy load

<%= turbo_frame_tag "comments", src: post_comments_path(@post), loading: "lazy" do %>
  로딩 중...
<% end %>

frame이 화면에 들어오면 src에서 가져옴. 무거운 댓글 등 지연 로드.

Frame을 따라가지 않는 링크

<%= link_to "전체보기", post_path(@post), data: { turbo_frame: "_top" } %>

_top은 frame 무시하고 전체 페이지 전환.

Turbo Streams

서버가 클라이언트의 DOM을 부분 갱신.

7가지 액션:

append / prepend
replace
update
remove
before / after

Response로 stream

<%# views/comments/create.turbo_stream.erb %>
<%= turbo_stream.append "comments" do %>
  <%= render @comment %>
<% end %>

<%= turbo_stream.replace "comment_count" do %>
  <%= @post.comments.count %>
<% end %>

<%= turbo_stream.update "new_comment_form" do %>
  <%= render "form", comment: Comment.new %>
<% end %>

# controller
def create
  @comment = @post.comments.create(comment_params)
  respond_to do |format|
    format.turbo_stream
    format.html { redirect_to @post }
  end
end

클라이언트가 Accept: text/vnd.turbo-stream.html로 요청하면 stream 응답. form 제출 후 페이지 재로드 없이 댓글 추가.

Broadcast (Action Cable 위)

class Post < ApplicationRecord
  broadcasts_to ->(post) { "posts:#{post.id}" }
end

모델 저장/삭제 시 모든 구독자에게 turbo stream 전송. 다중 사용자 실시간 협업.

<%# views/posts/show.html.erb %>
<%= turbo_stream_from "posts:#{@post.id}" %>

<%= turbo_frame_tag dom_id(@post) do %>
  <%# 다른 사용자가 글을 업데이트하면 자동 반영 %>
<% end %>

Stream 헬퍼

# 컨트롤러에서 직접
def update
  @post.update(post_params)
  render turbo_stream: turbo_stream.replace(@post)
end

# 여러 액션
render turbo_stream: [
  turbo_stream.replace(@post),
  turbo_stream.update("count", @posts.count),
]

Stimulus

가벼운 JS 컨트롤러. 작은 인터랙션에 적합.

bin/rails g stimulus hello

// app/javascript/controllers/hello_controller.js
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
    static targets = ["name", "output"]
    static values = { url: String }

    greet() {
        this.outputTarget.textContent = `Hello, ${this.nameTarget.value}!`
    }
}

<div data-controller="hello" data-hello-url-value="/api/users">
  <input data-hello-target="name" type="text">
  <button data-action="click->hello#greet">Greet</button>
  <p data-hello-target="output"></p>
</div>

data-controller: 어떤 컨트롤러 사용
data-action: event → method 매핑
data-<controller>-target: 요소 참조
data-<controller>-<name>-value: 값 전달

React/Vue처럼 무거운 SPA 없이 작은 UI 인터랙션.

자주 보는 패턴

무한 스크롤

<%# index.html.erb %>
<div id="posts">
  <%= render @posts %>
</div>

<% if @posts.next_page %>
  <%= turbo_frame_tag "load_more",
                       src: posts_path(page: @posts.next_page),
                       loading: "lazy" do %>
    로딩 중...
  <% end %>
<% end %>

<%# views/posts/_page.html.erb %>
<%= turbo_stream.append "posts" do %>
  <%= render @posts %>
<% end %>

<% if @posts.next_page %>
  <%= turbo_stream.replace "load_more" do %>
    <%= turbo_frame_tag "load_more", src: posts_path(page: @posts.next_page), loading: "lazy" %>
  <% end %>
<% end %>

인라인 편집

<%= turbo_frame_tag dom_id(post, :title) do %>
  <h1><%= post.title %></h1>
  <%= link_to "수정", edit_post_path(post) %>
<% end %>

수정 → 같은 frame에 form → 저장 → 새 제목으로 frame 교체.

라이브 검색

<%= form_with url: search_path, method: :get, data: { turbo_frame: "results" } do |f| %>
  <%= f.text_field :q, data: { action: "input->search#submit" } %>
<% end %>

<%= turbo_frame_tag "results" %>

// app/javascript/controllers/search_controller.js
import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
    submit() {
        clearTimeout(this.timeout)
        this.timeout = setTimeout(() => {
            this.element.requestSubmit()
        }, 200)
    }
}

debounce + 자동 제출 + frame 결과만 갱신.

알림 (toast)

<%# layouts에 %>
<%= turbo_stream_from "user_#{current_user.id}_notifications" %>
<div id="toasts"></div>

# 어디서나
Turbo::StreamsChannel.broadcast_append_to(
    "user_#{user.id}_notifications",
    target: "toasts",
    partial: "shared/toast",
    locals: { message: "저장됨" },
)

함정

1. JS 초기화 시점

Turbo Drive는 페이지 교체 시 DOMContentLoaded 발생 X.

document.addEventListener("turbo:load", () => {
    // 새 페이지 로드 시
})

Stimulus 컨트롤러는 자동 connect/disconnect라 신경 안 써도 됨.

2. form 응답이 200 OK + HTML

폼 제출 → 422 (검증 실패) 또는 200 OK + redirect 응답이 Turbo의 표준. 잘못 응답하면 turbo가 무시.

def create
  if @post.save
    redirect_to @post    # OK
  else
    render :new, status: :unprocessable_entity    # 422 필수
  end
end

3. frame ID 중복

<%= turbo_frame_tag "post" do %>
  ...
<% end %>

여러 post 있으면 ID 충돌. dom_id(post) 사용 → post_42.

4. broadcast 권한

broadcasts_to는 모든 구독자에게. 비공개 글이라면 직접 스트림에 권한 체크.

5. cache 무효화

페이지 캐시되어 있으면 turbo가 cached 페이지를 가져옴. Cache-Control 헤더 관리.

SPA와 비교

	Hotwire	React/Vue SPA
학습 곡선	낮	높
JS 양	적음	많음
SEO	자연스러움	SSR 필요
모바일	turbo-native (iOS/Android 공유)	RN 별도
복잡한 클라이언트 상태	약	강
인터랙티브성	중	매우 강

대다수 CRUD 앱엔 Hotwire가 충분 + 빠른 개발. 무거운 클라이언트 상태(에디터 등)는 SPA.

[Rails] I18n: 다국어와 지역화

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails I18n은 로케일별 번역, 숫자/날짜 포맷, 시간대, 복수형, 통화 등을 통합 처리. config/locales/*.yml에 번역 저장, I18n.t로 조회. View, controller, model 어디서나 사용 가능.

기본 설정

# config/application.rb
config.i18n.default_locale = :ko
config.i18n.available_locales = [:ko, :en, :ja]
config.i18n.fallbacks = true    # 미번역 시 default_locale 사용
config.i18n.load_path += Dir[Rails.root.join("config/locales/**/*.{rb,yml}")]

# Gemfile
gem "rails-i18n"    # ko, en, ja 등 70+ 언어의 Rails 기본 번역

로케일 파일

# config/locales/ko.yml
ko:
  welcome: "환영합니다"
  hello: "%{name}님, 안녕하세요"
  posts:
    title: "포스트"
    new: "새 포스트"
    edit: "수정"
    deleted: "%{count}개 삭제됨"
  errors:
    blank: "필수 항목입니다"

# config/locales/en.yml
en:
  welcome: "Welcome"
  hello: "Hello, %{name}"
  posts:
    title: "Posts"
    new: "New post"
    edit: "Edit"
    deleted: "%{count} deleted"

사용

<%# 뷰 %>
<h1><%= t("welcome") %></h1>
<p><%= t("hello", name: current_user.name) %></p>
<h2><%= t("posts.title") %></h2>

<%# 컨트롤러 %>
flash[:notice] = t("posts.created")

<%# 모델 %>
class Post < ApplicationRecord
  validates :title, presence: { message: I18n.t("errors.blank") }
end

로케일 전환

# 미들웨어/before_action으로 자동 감지
class ApplicationController < ActionController::Base
  around_action :switch_locale

  private

  def switch_locale(&action)
    locale = extract_locale || I18n.default_locale
    I18n.with_locale(locale, &action)
  end

  def extract_locale
    params[:locale] ||
      session[:locale] ||
      cookies[:locale] ||
      browser_locale ||
      current_user&.locale
  end

  def browser_locale
    request.env["HTTP_ACCEPT_LANGUAGE"]&.scan(/^[a-z]{2}/)&.first
  end
end

URL prefix

# config/routes.rb
scope "(:locale)", locale: /en|ko|ja/ do
  resources :posts
  resources :users
  root "home#index"
end

URL: /posts, /en/posts, /ko/posts.

url_for(locale: I18n.locale) 자동 추가.

복수형 (pluralization)

ko:
  items:
    one: "%{count}개의 항목"
    other: "%{count}개의 항목들"

en:
  items:
    zero: "no items"
    one: "1 item"
    other: "%{count} items"

<%= t("items", count: 0) %>    # "no items"
<%= t("items", count: 1) %>    # "1 item"
<%= t("items", count: 5) %>    # "5 items"

언어별 복수형 규칙 (영어 1/many, 슬라브어 1/2-4/5+ 등) 자동.

날짜 / 시간

<%= l(Date.today) %>                        # "2026. 06. 20."
<%= l(Date.today, format: :long) %>          # "2026년 6월 20일"
<%= l(Time.current, format: :short) %>       # "06. 20. 14:30"

ko:
  date:
    formats:
      default: "%Y. %m. %d."
      long: "%Y년 %-m월 %-d일"
      short: "%m. %d."
  time:
    formats:
      default: "%Y년 %-m월 %-d일 %H:%M"
      short: "%m. %d. %H:%M"

rails-i18n gem이 기본 제공.

숫자 / 통화

<%= number_to_currency(1234567) %>           # "₩1,234,567" (ko) / "$1,234,567" (en)
<%= number_with_delimiter(1234567) %>         # "1,234,567"
<%= number_to_percentage(0.1234) %>           # "12.34%"
<%= number_to_human_size(1024 * 1024) %>      # "1 MB"
<%= number_to_human(1500) %>                  # "1.5 천" / "1.5 Thousand"

설정:

ko:
  number:
    currency:
      format:
        unit: "₩"
        precision: 0
        delimiter: ","
        format: "%u%n"

모델 / Attribute 번역

ko:
  activerecord:
    models:
      post: "포스트"
      user:
        one: "사용자"
        other: "사용자들"
    attributes:
      post:
        title: "제목"
        body: "본문"
        author: "작성자"
    errors:
      models:
        post:
          attributes:
            title:
              blank: "제목을 입력해주세요"

Post.model_name.human → “포스트” Post.human_attribute_name(:title) → “제목”

폼 라벨, 에러 메시지가 자동 한글화.

View helpers

<%= form_with model: @post do |form| %>
  <%# label은 자동으로 t("activerecord.attributes.post.title") 사용 %>
  <%= form.label :title %>
  <%= form.text_field :title %>

  <%# button.create / button.update %>
  <%= form.submit %>
<% end %>

ko:
  helpers:
    submit:
      create: "%{model} 만들기"
      update: "%{model} 수정"
    label:
      post:
        title: "제목"

메일러 다국어

class UserMailer < ApplicationMailer
  def welcome(user)
    I18n.with_locale(user.locale) do
      mail(to: user.email, subject: t("mailer.welcome.subject"))
    end
  end
end

뷰도 welcome.ko.html.erb, welcome.en.html.erb로 자동 선택.

시간대

# config/application.rb
config.time_zone = "Asia/Seoul"
config.active_record.default_timezone = :utc    # DB는 UTC

Time.current               # Asia/Seoul (활성 TZ)
Time.zone.now              # 동일
Time.zone.parse("2026-06-20")
1.day.from_now             # TZ aware

# 사용자별
Time.use_zone(user.timezone) do
  ...
end

자주 보는 패턴

Lazy lookup

<%# views/posts/index.html.erb %>
<h1><%= t(".title") %></h1>    # 자동으로 "posts.index.title"

ko:
  posts:
    index:
      title: "포스트 목록"

누락 번역 확인

# config/environments/test.rb
config.i18n.raise_on_missing_translations = true

또는 i18n-tasks gem:

gem install i18n-tasks
i18n-tasks missing
i18n-tasks unused
i18n-tasks normalize

CI 단계에 추가하면 누락 즉시 감지.

모델 enum 번역

class Post < ApplicationRecord
  enum :status, { draft: 0, published: 1, archived: 2 }
end

ko:
  activerecord:
    attributes:
      post:
        statuses:
          draft: "임시저장"
          published: "발행됨"
          archived: "보관됨"

<%= t("activerecord.attributes.post.statuses.#{post.status}") %>

또는 enum_help gem.

함정

1. fallbacks 미설정

번역 누락 시 translation missing: ... 표시. fallbacks 켜면 default_locale로 자동.

2. yaml 들여쓰기

ko:
  posts:
   title: "..."     # 들여쓰기 1칸 → 적용 안 될 수 있음

들여쓰기 일관. 2칸 권장.

3. 변수 보간

hello: "Hello, %{name}"

<%= t("hello", name: "Alice") %>    # ":name => "Alice""도 가능

name: 대신 :name도. 누락 시 raises (default_value 제공 가능).

4. 시간대 혼동

Time.now       # 시스템 TZ (서버 TZ)
Time.current   # Rails config.time_zone
Time.zone.now  # 동일

Time.current 일관 사용.

5. 키 충돌

ko:
  posts:
    new: "새 포스트"

# 다른 파일
ko:
  posts:
    new: "신규"   # 덮어쓰기

i18n-tasks로 detect.

외부 도구

i18n-tasks: 누락/미사용/normalize
Lokalise, POEditor, Crowdin: 번역가 협업 SaaS
tolk: 셀프호스팅 번역 UI
globalize: 모델 다국어 (제목/내용을 언어별 row로)
mobility: Globalize 대안, 더 유연

[Rails] Rails 8: Solid Queue/Cache/Cable, Kamal, Propshaft

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

**Rails 8 (2024 11월)**의 표어는 “No PaaS”다. Solid 시리즈로 Redis/외부 큐 의존을 제거하고, Kamal로 Docker 기반 자체 호스팅을 간단하게. 기존 Rails 7 앱은 점진 마이그레이션 가능.

Solid Trifecta

컴포넌트	역할	백엔드
Solid Queue	백그라운드 잡	DB
Solid Cache	Rails.cache	DB
Solid Cable	Action Cable	DB

세 가지 모두 DB 사용 → Redis 불필요. 비용·운영 단순화.

Solid Queue

rails-active-job에 표준 어댑터. Rails 8 새 앱 기본.

bin/rails solid_queue:install

# config/application.rb
config.active_job.queue_adapter = :solid_queue

설정:

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

워커:

bin/jobs
# 또는
bundle exec rake solid_queue:start

cron 같은 recurring:

# config/recurring.yml
production:
  daily_report:
    class: DailyReportJob
    schedule: every day at 9am
  cleanup:
    class: CleanupJob
    schedule: every 1 hour

특징:

트랜잭션 안전 (같은 DB)
delayed/recurring 지원
queue prioritization
Sidekiq 만큼은 아니나 충분히 빠름

Solid Cache

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

DB에 저장 → Redis 없이 캐시. 부분적 LRU 처리.

Rails.cache.write("key", "value", expires_in: 1.hour)
Rails.cache.read("key")
Rails.cache.fetch("key") { expensive_computation }

기존 Rails.cache API와 호환.

대규모 → Redis가 여전히 빠름. 작은 ~ 중규모는 충분.

Solid Cable

# config/cable.yml
production:
  adapter: solid_cable

Action Cable이 DB 통해 pub/sub. Redis 불필요.

3분 polling 기본 (config polling_interval).

Kamal 2

Docker 기반 단일 명령 배포.

bin/kamal init
# config/deploy.yml 생성

bin/kamal setup        # 첫 배포 (서버 setup + Docker 이미지 + 컨테이너)
bin/kamal deploy       # 이후 배포
bin/kamal app logs
bin/kamal console
bin/kamal shell
bin/kamal rollback

config/deploy.yml:

service: myapp
image: myorg/myapp

servers:
  web:
    hosts:
      - 192.168.0.1
      - 192.168.0.2
  job:
    hosts:
      - 192.168.0.3
    cmd: bin/jobs

proxy:
  ssl: true
  host: example.com

registry:
  server: ghcr.io
  username: myorg
  password:
    - KAMAL_REGISTRY_PASSWORD

env:
  clear:
    RAILS_LOG_TO_STDOUT: "1"
    DATABASE_URL: "postgres://..."
  secret:
    - RAILS_MASTER_KEY
    - SECRET_KEY_BASE

builder:
  arch: amd64
  cache:
    type: gha

accessories:
  db:
    image: postgres:16
    host: 192.168.0.4
    env:
      secret: [POSTGRES_PASSWORD]
    directories:
      - data:/var/lib/postgresql/data

bin/kamal deploy로 빌드 + 푸시 + 무중단 롤링 업데이트.

특징:

zero-downtime (Traefik 대신 자체 proxy로 8.0+)
다중 서버
accessories (DB, Redis 등 별도 컨테이너)
자체 호스팅에 PaaS 같은 UX

Propshaft

Sprockets 후속 (Rails 7.x에서 도입). 더 단순한 asset pipeline.

gem "propshaft"

app/assets/ → 그냥 정적 파일로. 처리 없이 fingerprinting만.

JS는 importmap 또는 esbuild/jsbundling-rails.

importmap-rails (default)

Bundler 없이 ES modules.

# config/importmap.rb
pin "application"
pin "@hotwired/turbo-rails", to: "turbo.min.js"
pin "@hotwired/stimulus", to: "stimulus.min.js"

bin/importmap pin react react-dom

<%= javascript_importmap_tags %>

빌드 단계 없음. 브라우저가 직접 ES module 로드. HTTP/2 + cache로 충분.

Async query (8.0+ 강화)

load_async_query = Post.where(...).load_async
# 다른 작업 진행
posts = load_async_query.to_a

여러 쿼리를 병렬 실행.

새 generators 옵션

rails new myapp --skip-jbuilder --skip-system-test    # 옵션 정리
rails new myapp --solid                                # solid 세 가지 모두
rails new myapp --javascript=esbuild

그 외

MySQL 인증 native_password 자동
Active Record encrypt 기본 더 강함
Authentication generator (bin/rails g authentication)
Composite primary key 정식 지원
migration generator의 reference에 type 지정

Authentication generator

bin/rails g authentication

기본적인 로그인/가입/로그아웃 컨트롤러와 모델 생성. Devise만큼 풍부하진 않지만 시작점.

class User < ApplicationRecord
  has_secure_password
  ...
end

호환성과 마이그레이션

기존 Rails 7 앱:

Solid Queue로 Sidekiq 대체 가능 (양립 가능)
Solid Cache로 Redis 대체 점진
Solid Cable은 Redis 대체
Kamal은 신규/기존 모두

# 7 → 8 업그레이드
bin/rails app:update
bundle update rails

deprecation warning 처리.

함정

1. Solid Queue 처리량 한계

수만 jobs/min은 Sidekiq Pro. 일반 앱(수천)은 충분.

2. Solid Cache의 cache stampede

여러 워커가 동시 만료 시 thundering herd. lock-based 패턴 필요.

3. Kamal과 다중 데이터센터

지역 분산은 자체. Kamal은 단일 cluster 도구.

4. Solid Cable polling

WebSocket 자체 latency는 좋지만 broadcast → DB → polling → 클라이언트로 1-3초 지연 가능.

5. CI/CD와 Docker 캐시

Kamal builder에 cache 설정 안 하면 빌드 매우 느림.

builder:
  cache:
    type: gha          # GitHub Actions
    type: registry     # Docker Registry

Rails 8 + AI

Active Record + pgvector (외부 gem) + 위에서 추출한 embedding으로 RAG 패턴 쉽게.

# pgvector
class Document < ApplicationRecord
  has_neighbors :embedding, dimensions: 1536
end

Document.nearest_neighbors(:embedding, query_vector, distance: "cosine").first(5)

표준은 아니나 Rails 생태계가 빠르게 따라잡는 중.

자주 보는 패턴

미니멀 자체 호스팅

1 VPS:
  Postgres (Docker compose)
  Rails app (Kamal)
  Solid Queue (worker container)
  Caddy / Kamal proxy (TLS)

월 $5~20에 충분한 작은 사이트 + zero downtime.

Hetzner/DigitalOcean + Kamal

Hetzner는 가성비 최고. 4코어 16GB가 월 ~€10.

bin/kamal setup
# 30분 안에 완전 배포 + HTTPS

[Rails] Routes: resources, nested, scope, constraints

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails 라우팅은 URL을 controller#action으로 매핑. RESTful resources 매크로가 7개 표준 액션을 한 줄로 생성. config/routes.rb에 정의. rails routes로 전체 확인.

resources

# config/routes.rb
Rails.application.routes.draw do
  resources :posts
end

생성된 7개 라우트:

HTTP	URL	Controller#Action	헬퍼
GET	/posts	posts#index	posts_path
GET	/posts/new	posts#new	new_post_path
POST	/posts	posts#create	posts_path
GET	/posts/:id	posts#show	post_path(p)
GET	/posts/:id/edit	posts#edit	edit_post_path(p)
PATCH/PUT	/posts/:id	posts#update	post_path(p)
DELETE	/posts/:id	posts#destroy	post_path(p)

rails routes -c posts로 확인.

일부만 / 제외

resources :posts, only: [:index, :show]
resources :posts, except: [:destroy]

resource (단수, singleton)

resource :profile    # 단수 (현재 사용자 1개)

HTTP	URL	Action
GET	/profile/new	new
POST	/profile	create
GET	/profile	show
GET	/profile/edit	edit
PATCH	/profile	update
DELETE	/profile	destroy

index 없음. URL에 :id 없음.

Nested resources

resources :posts do
  resources :comments
end

/posts/:post_id/comments       # comments#index
/posts/:post_id/comments/:id   # comments#show

깊이 1단계 권장. 2단계 이상은 별도 라우트.

shallow

resources :posts do
  resources :comments, shallow: true
end

GET    /posts/:post_id/comments       # index
POST   /posts/:post_id/comments       # create
GET    /posts/:post_id/comments/new   # new
GET    /comments/:id                  # show
GET    /comments/:id/edit             # edit
PATCH  /comments/:id                  # update
DELETE /comments/:id                  # destroy

collection은 nested, member는 평탄. URL 단순 + 부모 컨텍스트 보존.

namespace, scope, module

# namespace: URL prefix + controller module + 라우트 이름 prefix
namespace :admin do
  resources :posts    # /admin/posts → Admin::PostsController, admin_posts_path
end

# scope: URL prefix만
scope "/v1" do
  resources :posts    # /v1/posts → PostsController, posts_path
end

# scope module: controller module만
scope module: :admin do
  resources :posts    # /posts → Admin::PostsController
end

# scope path: URL prefix만
scope "/api" do
  scope module: :api do
    resources :posts
  end
end

API versioning

namespace :api do
  namespace :v1 do
    resources :posts
    resources :users
  end
  namespace :v2 do
    resources :posts
  end
end

/api/v1/posts, Api::V1::PostsController.

constraints

# 정규식
get "/posts/:id", to: "posts#show", constraints: { id: /\d+/ }

# subdomain
constraints subdomain: "api" do
  resources :posts
end

# 메서드 객체
class AdminConstraint
  def matches?(request)
    User.find_by(id: request.session[:user_id])&.admin?
  end
end

constraints AdminConstraint.new do
  mount Sidekiq::Web => "/admin/sidekiq"
end

추가 액션: member, collection

resources :posts do
  member do
    post :publish        # /posts/:id/publish
    delete :archive
  end

  collection do
    get :featured        # /posts/featured
    get :search
  end
end

get on: :member 단축형:

resources :posts do
  get :publish, on: :member
end

기본 라우트

# 루트
root "posts#index"        # GET / → PostsController#index

# 정적
get "/about", to: "pages#about"
get "/contact", to: "pages#contact", as: :contact    # 헬퍼 이름 명시

# match (여러 HTTP 메서드)
match "/search", to: "search#query", via: [:get, :post]

URL 헬퍼

posts_path              # "/posts"
post_path(post)         # "/posts/123"
new_post_path           # "/posts/new"
edit_post_path(post)
post_url(post)          # "http://example.com/posts/123" (호스트 포함)

# 옵션
posts_path(format: :json)        # "/posts.json"
posts_path(page: 2)               # "/posts?page=2"
post_path(post, anchor: "comments")  # "/posts/123#comments"

view, controller, mailer에서 모두 사용.

redirect, mount

# 다른 URL로 리다이렉트
get "/old-blog/:id", to: redirect("/posts/%{id}")
get "/old", to: redirect("https://example.com")

# Rack 앱 마운트
mount Sidekiq::Web => "/sidekiq"
mount Lookbook::Engine, at: "/lookbook" if Rails.env.development?

concern (라우트 공유)

concern :commentable do
  resources :comments
end

resources :posts, concerns: :commentable
resources :photos, concerns: :commentable

DRY.

direct, resolve

특정 URL 생성 규칙.

direct(:homepage) { "https://example.com" }
homepage_url    # "https://example.com"

resolve("Post") { |post| post_path(post) }
# url_for(@post) → /posts/:id

globbing

get "/docs/*path", to: "docs#show"    # /docs/a/b/c → params[:path] = "a/b/c"

format 제한

resources :posts, defaults: { format: :json }
get "/api/posts", to: "api/posts#index", constraints: { format: :json }

동적 segment

get ":controller/:action/:id"    # legacy, 권장 안 함

7-action 외 액션 추가

resources :posts do
  resources :likes, only: [:create, :destroy]
  collection { get :search }
  member { post :duplicate }
end

라우트 디버깅

rails routes                          # 전부
rails routes -c posts                  # 특정 controller
rails routes -g admin                  # 패턴 검색
rails routes --expanded                # 상세

브라우저 /rails/info/routes (dev mode).

API only 라우팅

namespace :api, defaults: { format: :json } do
  namespace :v1 do
    resources :posts, only: [:index, :show, :create, :update, :destroy]
    resources :users, only: [:show]
  end
end

자주 보는 패턴

Catch-all (404)

# 가장 마지막
match "*path", to: "errors#not_found", via: :all

다국어

scope "(:locale)", locale: /en|ko/ do
  resources :posts
end
# /posts /ko/posts /en/posts

인증 분기

authenticate :user, ->(u) { u.admin? } do
  mount Sidekiq::Web => "/sidekiq"
end

devise가 제공하는 헬퍼.

Engine 마운트

mount MyEngine::Engine => "/my"

함정

1. 깊은 nesting

resources :a do
  resources :b do
    resources :c    # /a/:a_id/b/:b_id/c/:id (URL 깊고 헬퍼 복잡)
  end
end

shallow 또는 평탄화.

2. 라우트 순서

get "/posts/featured", to: "posts#featured"
resources :posts    # /posts/:id가 /posts/featured를 가로챌 수도

# 더 구체적 라우트 먼저

3. PATCH vs PUT

기본 update는 PATCH + PUT 둘 다 수락. REST 엄격하면 PATCH만:

resources :posts, only: [:update], via: :patch

4. 헬퍼 이름 변경

resources :posts, as: :articles    # post_path → article_path

URL은 그대로, 헬퍼만.

5. params에 ?[] (Rails 5+ deprecated)

?tags[]=1&tags[]=2

Rails는 자동 배열 변환. 다른 백엔드와 호환성 확인.

[Rails] Views: ERB, helpers, partials, layouts

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails View는 ERB(Embedded Ruby) 템플릿 + helper + partial + layout 조합. controller가 @instance_variables를 view로 전달. 뷰 로직은 helper나 ViewComponent로 추출하는 게 일반.

ERB 기본

<%# 주석 (출력 X) %>
<%= expr %>          <%# 출력 (HTML escape) %>
<%== expr %>          <%# raw 출력 (위험) %>
<%= raw expr %>       <%# 위와 동등 %>
<% statement %>       <%# 실행만 (출력 X) %>
<%- -%>               <%# 좌우 공백 제거 %>

<h1><%= @post.title %></h1>

<% @posts.each do |post| %>
  <article>
    <h2><%= link_to post.title, post %></h2>
    <p><%= truncate(post.body, length: 200) %></p>
  </article>
<% end %>

<% if user_signed_in? %>
  Hello, <%= current_user.name %>
<% end %>

XSS 자동 방어

<%= %>는 자동 HTML escape. <script>가 <script>로.

<%= "<b>bold</b>" %>          <%# &lt;b&gt;bold&lt;/b&gt; %>
<%= raw "<b>bold</b>" %>      <%# <b>bold</b> (신뢰할 수 있는 HTML만) %>
<%= "<b>bold</b>".html_safe %>

자주 쓰는 헬퍼

URL 헬퍼

<%= link_to "Read", post_path(post) %>
<%= link_to "Edit", edit_post_path(post), class: "btn" %>
<%= link_to "Delete", post, data: { turbo_method: :delete, turbo_confirm: "확실?" } %>
<%= button_to "발행", publish_post_path(post), method: :post %>

폼

<%= form_with model: @post do |form| %>
  <%= form.label :title %>
  <%= form.text_field :title %>

  <%= form.label :body %>
  <%= form.text_area :body, rows: 10 %>

  <%= form.collection_select :category_id, Category.all, :id, :name, prompt: "선택" %>
  <%= form.collection_check_boxes :tag_ids, Tag.all, :id, :name %>
  <%= form.file_field :image %>
  <%= form.hidden_field :slug %>

  <%= form.submit %>
<% end %>

form_with는 model 인스턴스에서 URL/메서드(POST 또는 PATCH) 자동 결정. CSRF 토큰 자동 포함. Rails 7+는 기본 turbo 활성.

<%# Model 없이 일반 폼 %>
<%= form_with url: search_path, method: :get do |form| %>
  <%= form.text_field :q %>
  <%= form.submit "검색" %>
<% end %>

출력/포맷팅

<%= number_to_currency(1234.56) %>           <%# $1,234.56 %>
<%= number_with_delimiter(1234567) %>         <%# 1,234,567 %>
<%= number_with_precision(3.14159, precision: 2) %>
<%= number_to_human_size(1024 * 1024) %>      <%# 1 MB %>
<%= number_to_percentage(50, precision: 1) %> <%# 50.0% %>

<%= time_ago_in_words(post.created_at) %>     <%# 3시간 %>
<%= l(post.created_at, format: :short) %>     <%# 06/20 14:30 %>
<%= I18n.l(post.created_at) %>

<%= truncate(text, length: 100) %>
<%= simple_format(post.body) %>                <%# 줄바꿈 → <p>/<br> %>
<%= pluralize(@posts.count, "post") %>         <%# 1 post / 2 posts %>
<%= sanitize(html, tags: %w[p br a], attributes: %w[href]) %>
<%= strip_tags(html) %>
<%= excerpt(text, "keyword", radius: 50) %>

자산

<%= image_tag "logo.png", alt: "Logo", class: "logo" %>
<%= image_tag post.image %>                    <%# Active Storage %>
<%= stylesheet_link_tag "application", "data-turbo-track": "reload" %>
<%= javascript_include_tag "application", defer: true %>
<%= asset_path "icons/star.svg" %>
<%= image_tag asset_path("logo.png") %>

Partial

DRY를 위한 부분 템플릿. _ 접두 파일명.

<%# views/posts/_post.html.erb %>
<article class="post">
  <h2><%= post.title %></h2>
  <p><%= truncate(post.body, length: 200) %></p>
</article>

<%# views/posts/index.html.erb %>
<%= render "post", post: @post %>
<%= render @post %>                            <%# 모델 추론 %>
<%= render @posts %>                            <%# 컬렉션 (각 element에 partial) %>
<%= render partial: "post", collection: @posts, as: :post, spacer_template: "spacer" %>

<%# 다른 디렉터리 %>
<%= render "shared/header" %>
<%= render partial: "comments/comment", locals: { comment: c } %>

Layout

<%# app/views/layouts/application.html.erb %>
<!DOCTYPE html>
<html>
<head>
  <title><%= content_for(:title) || "My App" %></title>
  <%= csrf_meta_tags %>
  <%= csp_meta_tag %>
  <%= stylesheet_link_tag "application" %>
  <%= javascript_include_tag "application" %>
  <%= yield :head %>
</head>
<body>
  <%= render "shared/header" %>
  <main>
    <%= render "shared/flash" %>
    <%= yield %>
  </main>
  <%= render "shared/footer" %>
</body>
</html>

yield는 view 내용 삽입 위치. yield :name은 content_for(:name)과 매칭.

<%# views/posts/show.html.erb %>
<% content_for(:title, @post.title) %>
<% content_for(:head) do %>
  <meta property="og:title" content="<%= @post.title %>">
<% end %>

<article>...</article>

Layout 변경

class AdminController < ApplicationController
  layout "admin"
end

# Action 별
class PostsController < ApplicationController
  def print
    render layout: "print"
  end

  def show
    render layout: false    # layout 없이
  end
end

Helper

app/helpers/에 module로 정의. 모든 view에서 자동 사용 가능.

# app/helpers/posts_helper.rb
module PostsHelper
  def post_status_badge(post)
    color = post.published? ? "green" : "gray"
    text = post.published? ? "발행" : "임시저장"
    content_tag(:span, text, class: "badge bg-#{color}")
  end

  def reading_time(text)
    minutes = (text.split.size / 200.0).ceil
    "#{minutes}분"
  end
end

<%= post_status_badge(@post) %>
<small><%= reading_time(@post.body) %></small>

content_tag, tag

HTML 안전 생성.

<%= content_tag(:div, "Hello", class: "greeting") %>
<%# <div class="greeting">Hello</div> %>

<%= tag.div "Hello", class: "greeting" %>
<%= tag.span class: "icon" do %>
  ★
<% end %>

직접 문자열로 HTML 만드는 것보다 안전 + 가독성.

ViewComponent

복잡한 컴포넌트를 OOP로.

bin/rails g component PostCard post

# app/components/post_card_component.rb
class PostCardComponent < ViewComponent::Base
  def initialize(post:)
    @post = post
  end

  def status_color
    @post.published? ? "green" : "gray"
  end
end

<%# app/components/post_card_component.html.erb %>
<article class="post-card">
  <h2><%= @post.title %></h2>
  <span class="badge bg-<%= status_color %>"><%= @post.status %></span>
</article>

사용:

<%= render PostCardComponent.new(post: @post) %>
<%= render PostCardComponent.with_collection(@posts) %>

테스트 가능, 캡슐화. 대규모 앱에 권장.

캐싱

<% cache @post do %>
  <%# 비싼 렌더링 %>
<% end %>

<% cache [@post, "v2"] do %>
  <%# 버전 추가 %>
<% end %>

<% cache_if condition, @post do %>
<% end %>

<% @posts.each do |post| %>
  <% cache post do %>
    <%= render post %>
  <% end %>
<% end %>

Russian Doll Caching: 부모 cache 안에 자식 cache 중첩 → 자식 변경 시 부모도 자동 무효화 (updated_at).

i18n

<%= t("welcome.message") %>
<%= t("hello", name: user.name) %>
<%= l(post.created_at, format: :short) %>

# config/locales/ko.yml
ko:
  welcome:
    message: "환영합니다"
  hello: "%{name}님, 안녕"

Streaming

큰 페이지의 응답을 청크로.

def index
  @posts = Post.all
  render stream: true
end

기본 layout 먼저 보내고, 본문 점진. UX 빠르나 미들웨어 호환 주의.

함정

1. 인스턴스 변수 vs 로컬

def show
  @post = Post.find(params[:id])   # view에서 @post
  post = Post.find(...)              # view에서 NoMethodError
end

view는 controller의 @만 접근.

2. render와 redirect 둘 다 호출

def create
  render :new
  redirect_to root_path    # DoubleRenderError
end

# 명시적 분기
def create
  if @post.save
    redirect_to @post
  else
    render :new
  end
end

3. html_safe 남용

<%= user_input.html_safe %>    <%# XSS! %>

신뢰할 수 있는 출처만.

4. partial 데이터 전달

<%= render "post" %>             <%# post 변수 없으면 nil %>
<%= render "post", post: @post %>  <%# 명시적 전달 %>
<%= render @post %>               <%# 모델명 추론 → post 변수 자동 %>

5. ERB와 dotenv

<%= "#{Time.current.year}년" %>   <%# 문자열 보간 %>
<% expensive_computation %>         <%# 매 요청마다 실행 %>

비싼 계산은 controller 또는 helper로.

대안

HAML: 들여쓰기 기반, 짧음
Slim: 더 짧음
ViewComponent: 컴포넌트 OOP
Phlex: Ruby로만 view (gem)

ERB가 표준. ViewComponent로 점진적 마이그레이션.

[Rails] 배포: Kamal, Capistrano, Heroku

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails 배포 옵션:

Kamal (Rails 8 기본): Docker + zero-downtime, 자체 호스팅
Capistrano: SSH 기반 (전통)
Heroku / Render / Fly.io: PaaS
AWS Elastic Beanstalk, ECS, EKS: AWS 매니지드
Docker Compose / Kubernetes: 자체 컨테이너

Puma (앱 서버)

기본. config/puma.rb:

max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count }
threads min_threads_count, max_threads_count

worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development"

port ENV.fetch("PORT") { 3000 }

environment ENV.fetch("RAILS_ENV") { "development" }

pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }

if ENV["WEB_CONCURRENCY"]
  workers ENV.fetch("WEB_CONCURRENCY") { 2 }
  preload_app!
end

plugin :tmp_restart
plugin :solid_queue if ENV["SOLID_QUEUE_IN_PUMA"]

workers: 멀티 프로세스 (CPU 코어 수)
threads: 워커당 스레드 (5-10)
메모리 = workers × per_worker_memory

Kamal 2 (Rails 8 기본)

bin/kamal init
# config/deploy.yml 생성

config/deploy.yml:

service: myapp
image: myorg/myapp

servers:
  web:
    - 192.168.0.1
    - 192.168.0.2
  worker:
    hosts:
      - 192.168.0.3
    cmd: bin/jobs

proxy:
  ssl: true
  host: example.com
  app_port: 3000
  healthcheck:
    path: /up
    interval: 3
    timeout: 30

registry:
  server: ghcr.io
  username: myorg
  password:
    - KAMAL_REGISTRY_PASSWORD

env:
  clear:
    RAILS_LOG_TO_STDOUT: "1"
    RAILS_SERVE_STATIC_FILES: "true"
  secret:
    - RAILS_MASTER_KEY
    - SECRET_KEY_BASE
    - DATABASE_URL

builder:
  arch: amd64
  cache:
    type: gha    # GitHub Actions
    # 또는 type: registry
  context: .

accessories:
  db:
    image: postgres:16
    host: 192.168.0.4
    env:
      secret: [POSTGRES_PASSWORD]
    directories:
      - data:/var/lib/postgresql/data
    files:
      - config/postgres/postgresql.conf:/etc/postgresql/postgresql.conf

  redis:
    image: redis:7-alpine
    host: 192.168.0.4
    directories:
      - data:/data

명령

bin/kamal setup           # 첫 배포 (서버 setup + Docker 설치 + 첫 컨테이너)
bin/kamal deploy           # 이후 배포
bin/kamal redeploy         # 재시작 없이 재배포
bin/kamal rollback v123

bin/kamal app logs --follow
bin/kamal app exec "bin/rails db:migrate"
bin/kamal console          # rails c
bin/kamal shell            # bash
bin/kamal db console        # psql

bin/kamal accessory boot db
bin/kamal accessory logs db

Zero-downtime

Kamal proxy (Traefik 대체, 8.0+)가 무중단 롤링 업데이트:

새 컨테이너 시작
healthcheck 통과 대기
트래픽 전환
옛 컨테이너 종료

up 엔드포인트:

# config/routes.rb
get "up" => "rails/health#show", as: :rails_health_check

기본 Rails health check.

CI/CD

# .github/workflows/deploy.yml
- uses: actions/checkout@v4
- uses: docker/setup-buildx-action@v3
- run: |
    bundle exec kamal deploy
  env:
    KAMAL_REGISTRY_PASSWORD: ${{ secrets.KAMAL_REGISTRY_PASSWORD }}
    SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}

Capistrano (전통)

cap install

config/deploy.rb:

set :application, "myapp"
set :repo_url, "git@github.com:org/myapp.git"
set :deploy_to, "/var/www/myapp"
set :branch, "main"

set :linked_files, %w{config/master.key .env.production}
set :linked_dirs, %w{log tmp/pids tmp/cache tmp/sockets storage public/uploads}

set :rbenv_ruby, "3.3.0"
set :passenger_restart_with_touch, true

cap production deploy
cap production deploy:rollback

전통적인 ssh + git pull 방식. Kamal보다 복잡.

Heroku

heroku create myapp
git push heroku main
heroku run rails db:migrate
heroku logs --tail
heroku ps:scale web=2 worker=1
heroku config:set RAILS_MASTER_KEY=...

빠른 prototype에 적합. 비싸짐. Render/Fly.io가 대안.

# Procfile
web: bin/rails server -p $PORT -e $RAILS_ENV
worker: bundle exec sidekiq
release: bin/rails db:migrate

Render / Fly.io

비슷한 PaaS. 더 가성비. Render는 GitHub auto-deploy 깔끔.

render.yaml:

services:
  - type: web
    name: myapp
    runtime: ruby
    buildCommand: "bundle install && bin/rails assets:precompile"
    startCommand: "bundle exec puma -C config/puma.rb"
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: myapp-db
          property: connectionString

databases:
  - name: myapp-db
    plan: starter

Docker (수동)

FROM ruby:3.3-alpine

RUN apk add --no-cache build-base postgresql-dev nodejs yarn tzdata git

WORKDIR /app

COPY Gemfile* ./
RUN bundle install --jobs 4 --retry 3

COPY package.json yarn.lock ./
RUN yarn install --frozen-lockfile

COPY . .

RUN SECRET_KEY_BASE=$(bin/rails secret) bin/rails assets:precompile

EXPOSE 3000

CMD ["bin/rails", "server", "-b", "0.0.0.0"]

docker-compose

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pg_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

  web:
    build: .
    depends_on: [db, redis]
    environment:
      DATABASE_URL: postgres://app:${DB_PASSWORD}@db:5432/myapp
      REDIS_URL: redis://redis:6379/0
      RAILS_MASTER_KEY: ${RAILS_MASTER_KEY}
    ports: ["3000:3000"]
    command: bin/rails server -b 0.0.0.0

  worker:
    build: .
    depends_on: [db, redis]
    command: bundle exec sidekiq

volumes:
  pg_data:

Asset precompile

RAILS_ENV=production bin/rails assets:precompile

public/assets/에 결과. nginx/CDN이 서빙.

Rails 8 + Propshaft + importmap → 빌드 거의 없음. esbuild/dartsass-rails 사용 시 별도 빌드.

DB migration

# Kamal
bin/kamal app exec "bin/rails db:migrate"

# Heroku
heroku run rails db:migrate

# 일반 ssh
ssh server "cd /app && bin/rails db:migrate"

배포 워크플로에 자동화. 다운타임 없는 마이그레이션 = 별 페이지 참고.

환경변수

# 로컬
EDITOR=vim bin/rails credentials:edit

# Kamal
bin/kamal env push    # local .env → 서버
# 또는 secret env로 명시

.env 파일 git 커밋 X. .env.example만.

모니터링

에러: Sentry, Honeybadger, Rollbar
APM: Skylight, NewRelic, AppSignal, Scout
로그: Papertrail, Datadog, ELK
메트릭: Prometheus + Grafana
uptime: Pingdom, UptimeRobot

# Gemfile
gem "sentry-ruby"
gem "sentry-rails"

# config/initializers/sentry.rb
Sentry.init do |config|
  config.dsn = ENV["SENTRY_DSN"]
  config.traces_sample_rate = 0.1
end

함정

1. master.key git 커밋

.gitignore에 config/master.key. 절대 커밋 X. 노출 시 즉시 회전.

2. asset 변경 후 재배포

CDN 캐싱 1년 → 새 자산 안 보임. bin/rails assets:precompile이 hash 추가하므로 자동 새 URL.

3. DB connection pool

# database.yml
production:
  pool: <%= ENV.fetch("DB_POOL") { ENV.fetch("RAILS_MAX_THREADS") { 5 } } %>

워커 × 스레드 ≤ DB max_connections. 부족하면 timeout.

4. tmp/ 영속성

Rails.root.join("tmp", "uploads", filename).write(...)

컨테이너 재시작 시 사라짐. Active Storage + S3로.

5. healthcheck 인증

get "up" => "rails/health#show"    # public OK?

내부 IP만 또는 token 검사. 외부 노출은 정보 누출 가능.

보안 체크리스트

[Rails] 보안: CSRF, XSS, SQL injection, encrypted credentials

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails는 OWASP Top 10 대부분을 기본 방어한다. 그러나 설정 누락, html_safe 남용, raw SQL 등이 흔한 함정. 보안은 기본 활성이고 명시적으로 우회해야 비활성.

CSRF (Cross-Site Request Forgery)

기본 활성. ApplicationController에 자동 포함:

class ApplicationController < ActionController::Base
  protect_from_forgery with: :exception    # 5.0+ 기본
end

form_with가 자동 토큰 포함. CSRF 누락 → ActionController::InvalidAuthenticityToken.

AJAX

// 기본 application.js에 포함됨
const csrfToken = document.querySelector("meta[name='csrf-token']").content;

fetch("/api/posts", {
    method: "POST",
    headers: {
        "X-CSRF-Token": csrfToken,
        "Content-Type": "application/json",
    },
    body: JSON.stringify(data),
});

API only

class Api::BaseController < ActionController::API    # CSRF 없음 (API 베이스)
end

# 또는 특정 액션 skip
class WebhooksController < ApplicationController
  skip_forgery_protection only: :stripe
end

세션 인증 + skip은 위험. JWT 등 별도 인증 시만.

XSS

ERB 자동 escape:

<%= user_input %>     <%# 자동 escape #}
<%== user_input %>    <%# raw (위험) %>
<%= raw user_input %>  <%# raw %>
<%= user_input.html_safe %>  <%# raw %>

안전한 HTML 출력

# helper에서
def my_html
  content_tag(:b, user_input)    # 안전
end

def my_html
  "<b>#{user_input}</b>".html_safe   # 위험 (escape 안 함)
end

def my_html
  format_html("<b>{}</b>", user_input)   # 안전 (인자만 escape)
end

sanitize 헬퍼

<%= sanitize(user_html, tags: %w[p br a], attributes: %w[href]) %>

화이트리스트만 허용. 나머지 태그/속성 제거.

SQL Injection

ActiveRecord는 기본적으로 placeholder 사용 → 자동 방어.

# 안전
User.where(email: params[:email])
User.where("email = ?", params[:email])
User.where("email = :email", email: params[:email])

# 위험
User.where("email = '#{params[:email]}'")
User.find_by_sql("SELECT * FROM users WHERE email = '#{params[:email]}'")

문자열 interpolation 금지. placeholder 또는 hash 인자.

order, where with raw

# 위험: column 명을 사용자 입력으로
User.order(params[:sort])    # SQL 인젝션 가능 (5.x)

# 안전: 화이트리스트
allowed = %w[name email created_at]
sort_col = allowed.include?(params[:sort]) ? params[:sort] : "id"
User.order(sort_col)

# 6.0+ Arel
User.order(Arel.sql(sort_col))

Strong Parameters

mass assignment 방어:

def user_params
  params.require(:user).permit(:name, :email, address: [:street, :city])
end

# 위험
User.create(params[:user])    # admin: true 같은 악성 입력 통과

permit된 키만 통과. 컨트롤러마다 명시.

비밀 정보 관리

encrypted credentials (5.2+)

bin/rails credentials:edit
bin/rails credentials:edit --environment production

config/credentials.yml.enc (암호화) + config/master.key (서명 키).

# credentials.yml.enc (편집 시 plain)
secret_key_base: ...
stripe:
  api_key: sk_test_...
  webhook_secret: whsec_...
aws:
  access_key_id: ...
  secret_access_key: ...

Rails.application.credentials.stripe[:api_key]
Rails.application.credentials.dig(:stripe, :api_key)

master.key는 .gitignore. credentials.yml.enc는 git 커밋 OK.

환경별

bin/rails credentials:edit -e production
# config/credentials/production.yml.enc + production.key

각 환경 다른 키로 분리.

ENV variable

ENV["STRIPE_KEY"]
ENV.fetch("STRIPE_KEY")    # 누락 시 raise

Docker, k8s, CI/CD에서 자연스러움.

HTTPS 강제

# config/environments/production.rb
config.force_ssl = true
config.ssl_options = {
  hsts: { expires: 1.year, subdomains: true, preload: true },
  redirect: { exclude: ->(request) { request.path =~ /healthcheck/ } },
}

자동 HTTPS 리다이렉트 + HSTS 헤더.

헤더 보안

# config/initializers/secure_headers.rb (gem)
SecureHeaders::Configuration.default do |config|
  config.csp = {
    default_src: %w['self'],
    script_src: %w['self' https://cdn.example.com],
    style_src: %w['self' 'unsafe-inline'],
    img_src: %w['self' data: https:],
  }
  config.x_frame_options = "DENY"
  config.x_content_type_options = "nosniff"
  config.referrer_policy = "strict-origin-when-cross-origin"
end

또는 Rails 기본 default_headers:

config.action_dispatch.default_headers = {
  "X-Frame-Options" => "SAMEORIGIN",
  "X-Content-Type-Options" => "nosniff",
  "Referrer-Policy" => "strict-origin-when-cross-origin",
}

Active Record Encryption (7.0+)

class User < ApplicationRecord
  encrypts :ssn, deterministic: true    # 검색 가능
  encrypts :api_key                      # 비결정 (검색 X)
  encrypts :credit_card, downcase: true
end

user.ssn = "..."
user.save
# DB에는 암호화된 값
user.ssn    # 자동 복호화

bin/rails db:encryption:init으로 키 생성.

쿼리:

User.where(ssn: "...")    # deterministic만 가능

비밀번호 (has_secure_password)

class User < ApplicationRecord
  has_secure_password    # password_digest 필드 필요
end

user = User.create(email: "...", password: "secret", password_confirmation: "secret")
user.authenticate("secret")    # User 또는 false

bcrypt 자동. password는 메모리만, DB엔 password_digest만.

인증 (Rails 8 generator)

bin/rails generate authentication

기본적인 로그인/가입/세션 컨트롤러 자동 생성. Devise/Sorcery 같은 풀스택 라이브러리 대안.

자주 보는 패턴

Rate limit

# Rails 8+ 내장
class LoginsController < ApplicationController
  rate_limit to: 5, within: 1.minute, only: :create
end

# 또는 rack-attack gem
Rack::Attack.throttle("logins/ip", limit: 5, period: 60) do |req|
  req.ip if req.path == "/login" && req.post?
end

Audit log

gem "audited"

class Post < ApplicationRecord
  audited
end

post.audits    # 모든 변경 이력

권한 (Pundit)

class PostPolicy < ApplicationPolicy
  def update?
    record.author == user || user.admin?
  end
end

class PostsController < ApplicationController
  def update
    authorize @post
    ...
  end
end

함정

1. RAILS_MASTER_KEY 노출

.env 파일 git 커밋, README에 키 적기 등. 노출 시 즉시 회전:

bin/rails credentials:edit    # 새 키로 재암호화

2. parameter logging 비밀

# config/initializers/filter_parameter_logging.rb
Rails.application.config.filter_parameters += [
  :password, :secret, :token, :api_key, :credit_card,
]

[FILTERED]로 표시. 신규 민감 필드는 직접 추가.

3. CORS 잘못

# Gemfile
gem "rack-cors"

Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
    origins "*"    # 위험!
    resource "*", methods: [:get, :post, :put, :delete]
  end
end

명시 origin:

origins "https://app.example.com"

4. open redirect

redirect_to params[:redirect_to]    # 위험: //evil.com 가능
redirect_to params[:redirect_to], allow_other_host: false    # 7.0+

5. timing attack

user.api_token == params[:token]    # timing attack 가능
ActiveSupport::SecurityUtils.secure_compare(user.api_token, params[:token])

상수 시간 비교.

보안 도구

Brakeman: 정적 분석 (CVE, 코드 패턴)
```
gem install brakeman
brakeman
```
bundler-audit: gem CVE 검사
dependabot: GitHub의 의존성 업데이트

CI에 포함.

[Rails] 성능: N+1, bullet, rack-mini-profiler

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails 성능 최적화는 보통 DB 쿼리 (N+1 회피, 인덱스), 캐싱, view 렌더링, Ruby 코드 효율 순서로 접근. 측정 도구 (bullet, rack-mini-profiler, APM)로 hotspot 식별 후 개선.

N+1 회피

# 나쁨
Post.all.each { |p| puts p.author.name }    # 1 + N

# select_related 같은 효과
Post.includes(:author).each { |p| puts p.author.name }
# 또는
Post.preload(:author)
Post.eager_load(:author)

includes: 자동 선택 (preload 또는 eager_load)
preload: 별도 쿼리 (WHERE on join 불가)
eager_load: LEFT OUTER JOIN

# JOIN 후 join 컬럼 검색
Post.includes(:author).where(authors: { active: true })    # eager_load 자동 사용
Post.eager_load(:author).where(authors: { active: true })

깊은 nesting

Post.includes(comments: { author: :profile }, tags: :category)

bullet gem (개발 N+1 자동 감지)

# Gemfile
group :development do
  gem "bullet"
end

# config/environments/development.rb
config.after_initialize do
  Bullet.enable = true
  Bullet.alert = true                  # JS alert
  Bullet.bullet_logger = true          # log/bullet.log
  Bullet.console = true                # browser console
  Bullet.rails_logger = true
  Bullet.add_footer = true             # 페이지 하단 표시
end

N+1 발견 시 즉시 알림. 개발 단계에 켜두면 회귀 방지.

rack-mini-profiler

gem "rack-mini-profiler"
gem "memory_profiler"
gem "stackprof"
gem "flamegraph"

페이지 좌측 상단에 응답 시간 + SQL 쿼리 수 표시. 클릭하면 상세 (각 쿼리, 시간, 콜 스택).

?pp=help      옵션 보기
?pp=profile-memory  메모리
?pp=flamegraph

APM (프로덕션)

도구	특징
Skylight	Rails 특화, 한국에 서버 X
New Relic	종합
AppSignal	Ruby 친화, 가격 합리적
Scout APM	Rails 친화
Datadog APM	종합, 비쌈
Honeybadger	에러 + APM

수집:

평균 응답 시간 / p95 / p99
DB 쿼리 시간
외부 API 호출
background job 처리 시간
에러율

DB 인덱스

# 마이그레이션
add_index :posts, :slug, unique: true
add_index :posts, [:author_id, :created_at]
add_index :posts, :title, length: 100      # MySQL
add_index :posts, :body, using: :gin       # PG full-text

EXPLAIN으로 쿼리 plan 확인:

Post.where(author_id: 1).explain

자주 검색하는 컬럼 + JOIN 컬럼 인덱스 추가.

lol_dba / strong_migrations

gem "lol_dba"
rake lol_dba:db_indexes    # 누락 인덱스 후보

gem "strong_migrations"    # 위험 마이그레이션 차단

쿼리 최적화

count vs size vs length

posts = Post.all
posts.count    # 항상 SQL COUNT
posts.length   # 모두 로드 후 count (위험)
posts.size     # 로드됐으면 length, 아니면 count

exists?

Post.where(...).any?     # 모두 로드 후 length > 0 (느릴 수 있음)
Post.where(...).exists?  # SQL EXISTS (1 LIMIT) - 권장

find_each

Post.all.each {}    # 모두 메모리에 로드

Post.find_each(batch_size: 1000) {}   # 청크 단위
Post.in_batches(of: 1000) { |batch| batch.update_all(...) }

큰 테이블 순회 시 메모리 절약.

pluck

emails = User.all.map(&:email)        # User 객체 모두 인스턴스화
emails = User.pluck(:email)            # SELECT email만
emails = User.pluck(:id, :email)       # 다중

객체 인스턴스화 비용 회피.

update_all / delete_all

Post.where(views: 0).update_all(featured: false)   # 콜백 X, 빠름
Post.where(...).delete_all                          # 콜백 X, 빠름

# vs
Post.where(...).destroy_all   # 콜백 O, 매우 느림

대량 작업은 update_all/delete_all. 단 콜백/검증 우회.

View 캐싱

rails-caching 페이지 참고. Russian Doll Caching이 view 렌더링 hotspot 해결.

메모리 관리

# 메모리 사용량 모니터링
ObjectSpace.memsize_of(obj)
GC.stat

derailed_benchmarks gem으로 메모리 leak detect:

gem "derailed_benchmarks"
bundle exec derailed bundle:mem
bundle exec derailed exec perf:mem

Background job 활용

긴 작업 (이메일, 이미지 처리, 외부 API)은 view에서 수행 X.

# Bad
def create
  user = User.create(...)
  send_welcome_email(user)        # 1-3초
  upload_avatar_to_s3(user)        # 5초
  redirect_to user_path(user)
end

# Good
def create
  user = User.create(...)
  UserWelcomeJob.perform_later(user.id)
  AvatarUploadJob.perform_later(user.id, avatar_data)
  redirect_to user_path(user)
end

Asset / Frontend

Propshaft + importmap-rails (Rails 8 기본): 빌드 단계 거의 없음
bun 또는 esbuild-bundler: JS 번들링 필요 시
이미지 최적화 (WebP, AVIF, Active Storage variants)
CDN (CloudFlare, CloudFront)

Ruby 코드 효율

Lazy enumerator

[1, 2, 3, 4, 5].lazy.map { ... }.select { ... }.first(2)    # 필요한 만큼만

큰 컬렉션에 유용.

Frozen string literals

# frozen_string_literal: true

각 파일 상단. 매 호출마다 새 문자열 생성 안 함.

Symbol vs string

"key".to_sym    # 매번 변환
:key            # 한 번

Hash 키는 symbol.

자주 보는 패턴

Bulk insert

posts = (1..1000).map { |i| { title: "Post #{i}", body: "..." } }
Post.insert_all(posts)             # 콜백 X, 매우 빠름
Post.upsert_all(posts, unique_by: :slug)

Pagination

# kaminari
gem "kaminari"
@posts = Post.page(params[:page]).per(20)

# pagy (가장 빠름)
gem "pagy"
@pagy, @posts = pagy(Post.all)

pagy가 메모리/속도에서 최고. kaminari는 더 기능 풍부.

Counter cache

class Comment < ApplicationRecord
  belongs_to :post, counter_cache: true    # comments_count 컬럼 자동
end

post.comments_count    # SQL 없음

post.comments.count 대신.

시간대 인덱스

add_index :events, "start_at::date"    # 함수 인덱스 (PG)

Event.where("start_at::date = ?", today) 빠름.

함정

1. 측정 없이 최적화

“Premature optimization is the root of all evil”

먼저 측정 (bullet, mini-profiler, APM), hotspot 식별, 그 다음 최적화.

2. 캐시가 만능

캐시 추가 = 정합성 문제. 인덱스, 쿼리 최적화가 우선.

3. eager_load 남용

Post.eager_load(:comments).limit(10)
# JOIN 후 limit → comments 많으면 결과 행 폭발

이런 경우 preload 또는 별도 쿼리.

4. 메모리 누수

장시간 실행 Puma/Sidekiq 메모리 증가. puma_worker_killer, max_requests 옵션.

5. before_action에 비싼 쿼리

before_action :set_user

def set_user
  @user = User.includes(:posts, :comments, :followers).find(params[:id])
  # 모든 액션에서 무거운 쿼리
end

액션별 필요한 것만 fetch.

[Rails] 테스트: Minitest, RSpec, FactoryBot, Capybara

koa (김신건) — Sat, 20 Jun 2026 00:00:00 GMT

정의

Rails는 Minitest 기반 테스트를 기본 제공한다. 커뮤니티는 RSpec도 광범위 사용. FactoryBot(객체 생성), Capybara(브라우저 시뮬레이션), Rails System Test(통합)이 표준 도구. fixture와 factory 둘 다 사용 가능.

디렉터리 구조

test/                       # Minitest (Rails 기본)
    models/
    controllers/
    system/                 # E2E
    fixtures/
    test_helper.rb

spec/                       # RSpec
    models/
    controllers/
    requests/
    system/
    factories/
    rails_helper.rb

Minitest

# test/models/post_test.rb
require "test_helper"

class PostTest < ActiveSupport::TestCase
  test "presence of title" do
    post = Post.new(body: "...")
    assert_not post.valid?
    assert_includes post.errors[:title], "can't be blank"
  end

  test "creates a post" do
    assert_difference "Post.count", 1 do
      Post.create!(title: "Hi", body: "...")
    end
  end
end

bin/rails test                   # 전체
bin/rails test test/models       # 디렉터리
bin/rails test test/models/post_test.rb
bin/rails test test/models/post_test.rb:42    # 특정 라인

fixtures

# test/fixtures/posts.yml
hello:
  title: Hello
  body: World
  author: alice    # users.yml의 alice 참조
  created_at: <%= 1.day.ago %>

ruby_post:
  title: Ruby
  body: "..."

def setup
  @post = posts(:hello)
end

자동 로드. 빠르지만 데이터 변경 시 모든 테스트 영향.

FactoryBot

# Gemfile
gem "factory_bot_rails"

# spec/factories/posts.rb
FactoryBot.define do
  factory :post do
    title { "Test" }
    body { "Body" }
    association :author, factory: :user

    trait :published do
      published { true }
      published_at { Time.current }
    end

    trait :with_comments do
      after(:create) do |post|
        create_list(:comment, 3, post: post)
      end
    end
  end
end

사용:

post = create(:post)
posts = create_list(:post, 5)
published = create(:post, :published)
with_tags = build(:post, tags: [tag1, tag2])     # save X
attrs = attributes_for(:post)                     # hash

fixture보다 명시적·유연.

RSpec

gem "rspec-rails", group: [:development, :test]
bin/rails g rspec:install

# spec/models/post_spec.rb
require "rails_helper"

RSpec.describe Post, type: :model do
  describe "validations" do
    it { is_expected.to validate_presence_of(:title) }
    it { is_expected.to belong_to(:author) }
  end

  describe "#publish!" do
    let(:post) { create(:post) }

    it "marks as published" do
      post.publish!
      expect(post.published).to be true
      expect(post.published_at).to be_present
    end

    context "when already published" do
      let(:post) { create(:post, :published) }

      it "raises" do
        expect { post.publish! }.to raise_error(StandardError)
      end
    end
  end
end

bundle exec rspec
bundle exec rspec spec/models
bundle exec rspec spec/models/post_spec.rb:30

Controller / Request specs

# spec/requests/posts_spec.rb
RSpec.describe "Posts", type: :request do
  describe "GET /posts" do
    it "returns success" do
      get posts_path
      expect(response).to have_http_status(:ok)
    end
  end

  describe "POST /posts" do
    let(:user) { create(:user) }
    before { sign_in user }

    it "creates a post" do
      expect {
        post posts_path, params: { post: { title: "T", body: "B" } }
      }.to change(Post, :count).by(1)
      expect(response).to redirect_to(Post.last)
    end

    context "with invalid params" do
      it "renders new" do
        post posts_path, params: { post: { title: "" } }
        expect(response).to have_http_status(:unprocessable_entity)
      end
    end
  end
end

type: :request는 통합 테스트. controller spec(type: :controller)은 deprecated 방향.

System tests (browser)

# test/system/posts_test.rb
require "application_system_test_case"

class PostsTest < ApplicationSystemTestCase
  test "creating a post" do
    sign_in users(:alice)
    visit posts_path
    click_on "New post"
    fill_in "Title", with: "Hello"
    fill_in "Body", with: "World"
    click_on "Create Post"
    assert_text "Hello"
  end
end

Capybara 사용. Selenium/Cuprite 드라이버.

# test/application_system_test_case.rb
class ApplicationSystemTestCase < ActionDispatch::SystemTestCase
  driven_by :selenium, using: :headless_chrome, screen_size: [1400, 1400]
end

또는 RSpec:

RSpec.describe "Posts", type: :system, js: true do
  before { driven_by :selenium, using: :headless_chrome }

  it "creates a post" do
    visit posts_path
    fill_in "Title", with: "Hi"
    click_button "Create"
    expect(page).to have_content "Hi"
  end
end

Mailer test

# spec/mailers/welcome_mailer_spec.rb
RSpec.describe WelcomeMailer, type: :mailer do
  describe "#welcome" do
    let(:user) { create(:user, email: "a@x.com") }
    let(:mail) { WelcomeMailer.welcome(user) }

    it "renders" do
      expect(mail.subject).to eq("환영합니다")
      expect(mail.to).to eq([user.email])
      expect(mail.body.encoded).to match("Hello")
    end
  end
end

테스트 환경 EMAIL: ActionMailer::Base.delivery_method = :test. ActionMailer::Base.deliveries에 mail 누적.

Job test

RSpec.describe SendWelcomeEmailJob, type: :job do
  let(:user) { create(:user) }

  it "enqueues" do
    expect {
      SendWelcomeEmailJob.perform_later(user.id)
    }.to have_enqueued_job(SendWelcomeEmailJob).with(user.id)
  end

  it "sends email" do
    expect {
      perform_enqueued_jobs do
        SendWelcomeEmailJob.perform_later(user.id)
      end
    }.to change { ActionMailer::Base.deliveries.size }.by(1)
  end
end

VCR (외부 API mock)

gem "vcr", group: :test

# spec/spec_helper.rb
VCR.configure do |c|
  c.cassette_library_dir = "spec/vcr_cassettes"
  c.hook_into :webmock
end

# 사용
RSpec.describe "API", :vcr do
  it "fetches data" do
    response = ApiClient.fetch_user(1)
    expect(response.name).to eq "Alice"
  end
end

첫 실행 시 실제 API 호출 → cassette 저장. 이후엔 cassette 재생.

DatabaseCleaner / 트랜잭션

RSpec은 기본 트랜잭션 wrapping (rollback). JS system test는 별도 thread → 트랜잭션 안 됨.

# spec/rails_helper.rb
RSpec.configure do |config|
  config.use_transactional_fixtures = true
  # JS 테스트엔 DatabaseCleaner truncation
end

shoulda-matchers

gem "shoulda-matchers"

RSpec.describe Post, type: :model do
  it { should validate_presence_of(:title) }
  it { should validate_uniqueness_of(:slug) }
  it { should belong_to(:author).class_name("User") }
  it { should have_many(:comments).dependent(:destroy) }
  it { should have_many(:tags).through(:post_tags) }
end

검증/관계를 한 줄로 테스트.

Mock / Stub

allow(User).to receive(:find).and_return(user)
expect(NotifyJob).to receive(:perform_later).with(user.id)

# instance
allow_any_instance_of(Post).to receive(:publish).and_return(true)

자주 보는 패턴

Request spec 표준

describe "PostsController" do
  describe "GET /posts" do
    let!(:posts) { create_list(:post, 3) }

    it "lists" do
      get posts_path
      expect(response).to be_successful
      expect(response.body).to include(posts.first.title)
    end
  end
end

Pundit policy spec

RSpec.describe PostPolicy do
  subject { described_class }

  permissions :update? do
    let(:user) { create(:user) }
    let(:post) { create(:post, author: user) }

    it "allows author" do
      expect(subject).to permit(user, post)
    end

    it "denies other" do
      other = create(:user)
      expect(subject).not_to permit(other, post)
    end
  end
end

Time travel

travel_to Time.zone.local(2026, 1, 1) do
  expect(Date.current).to eq(Date.new(2026, 1, 1))
end

# 또는 timecop
Timecop.freeze("2026-01-01")

함정

1. 트랜잭션과 background job

perform_enqueued_jobs 또는 inline adapter로 테스트 시 동기 실행.

2. system test flaky

비동기 처리, animation → 시간 대기 필요.

expect(page).to have_content("Saved", wait: 5)
# wait는 기본 2초

3. fixtures 순서

fixture 로드 순서가 보장 안 됨. ID 의존 코드 위험.

4. 너무 많은 stub

allow(...).to receive(...)
allow(...).to receive(...)
...

비즈니스 로직 결합 테스트가 됨. 통합 테스트가 가치 큼.

5. CI 느림

병렬 실행 (parallel_tests), --fail-fast, mock 줄이기.

Ruby on Rails

koa (김신건) — Mon, 15 Jun 2026 00:00:00 GMT

정의

Ruby on Rails (또는 Rails)는 Ruby 언어 기반의 풀스택 웹 프레임워크다. David Heinemeier Hansson (DHH)이 2004년 Basecamp 개발 중 추출했으며, “Convention over Configuration”을 핵심 철학으로 빠른 개발과 생산성을 강조한다.

[[Django]]와 함께 대표적인 “batteries-included” 철학의 웹 프레임워크로, ORM, 라우팅, 템플릿, 마이그레이션, 테스트 등 웹 개발에 필요한 모든 요소를 제공한다.

핵심 철학

Convention over Configuration (CoC): 설정보다 관습. 디렉토리 구조, 파일명 규칙을 따르면 설정 파일 작성을 최소화할 수 있다.
DRY (Don’t Repeat Yourself): 중복 제거. 같은 로직을 여러 곳에 반복하지 않는다.
Omakase (お任せ): “주방장에게 맡기기”. DHH가 선택한 도구와 패턴을 그대로 받아들이는 것을 권장한다.

MVC 구조

Rails는 Model-View-Controller 패턴을 따른다.

Browser Request
    ↓
Router (config/routes.rb)
    ↓
Controller (app/controllers/)
    ↓
Model (app/models/) ↔ Database (ActiveRecord)
    ↓
View (app/views/) ← ERB, ViewComponent
    ↓
Response (HTML, JSON, etc.)

계층	역할	주요 클래스
Model	비즈니스 로직, 데이터베이스 접근	ActiveRecord::Base
View	HTML, JSON 렌더링	ERB, Slim, Haml, ViewComponent
Controller	요청 처리, 흐름 제어	ActionController::Base

주요 구성 요소

ActiveRecord (ORM)

데이터베이스 테이블과 Ruby 클래스를 1:1 매핑. users 테이블은 User 모델로, created_at은 자동 timestamp.

class User < ApplicationRecord
  has_many :posts
  validates :email, presence: true, uniqueness: true
end

User.where(active: true).order(:created_at).limit(10)

ActionPack (라우팅, 컨트롤러)

RESTful 라우팅을 기본 제공.

# config/routes.rb
resources :posts  # 7개 RESTful route 자동 생성 (index, show, new, create, edit, update, destroy)

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def index
    @posts = Post.all
  end
end

ActionView (템플릿)

ERB (Embedded Ruby) 또는 ViewComponent를 사용. 레이아웃, 파셜, 헬퍼로 중복 제거.

ActiveJob (백그라운드 작업)

비동기 작업 처리. Sidekiq, Resque, DelayedJob 등 백엔드와 연동.

ActionCable (WebSocket)

실시간 양방향 통신. 채팅, 알림 등에 사용.

ActionMailer (이메일)

이메일 발송. 템플릿과 컨트롤러처럼 작성.

마이그레이션

데이터베이스 스키마를 버전 관리한다. db/migrate/ 아래 타임스탬프 파일로 순차 실행.

# db/migrate/20260615123456_create_users.rb
class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      t.string :email, null: false
      t.timestamps
    end
    add_index :users, :email, unique: true
  end
end

rails db:migrate 실행 시 schema_migrations 테이블에 기록, 롤백은 rails db:rollback.

Hotwire (Turbo + Stimulus)

SPA (Single Page Application) 없이 반응성을 확보하는 Rails 7 기본 스택.

Turbo: 페이지 전환 시 <body>만 교체 (Turbo Drive), 부분 렌더링 (Turbo Frames), WebSocket 스트리밍 (Turbo Streams)
Stimulus: 최소한의 JavaScript 컨트롤러로 DOM 이벤트 처리

에코시스템

도구	역할
Bundler	gem 의존성 관리
RSpec	테스트 프레임워크 (minitest는 기본 포함)
FactoryBot	테스트 fixture 생성
Devise	인증 (로그인, 회원가입)
Sidekiq	백그라운드 작업 (Redis 기반)
Puma	웹 서버 (Rails 기본)
Capistrano	배포 자동화

약점과 주의점

메모리 사용량: Ruby 프로세스당 50~200MB 이상. 멀티 프로세스 (Puma worker) 사용 시 메모리 부담 큼.
CPU 집약 작업: GIL (Global Interpreter Lock)로 인해 멀티코어 활용 제한. CPU 집약 작업은 별도 서비스 (Go, Rust)로 분리 권장.
N+1 쿼리: ActiveRecord의 편리함 뒤에 숨은 성능 문제. includes, joins 로 eager loading 필수.
Scaling: Monolith 구조로 시작하기 쉽지만, 트래픽 증가 시 수평 확장 (horizontal scaling) 전략 필요. 세션 관리는 Redis 등 외부 저장소 권장 ([[Sticky Session]] 회피).
Monolith vs Microservice: Rails는 monolith에 강점. 마이크로서비스로 전환 시 API 모드 (rails new —api) 사용 가능하지만, Rails의 장점 (CoC, 생산성)이 반감될 수 있음.

사용 사례

GitHub: 초기 Rails로 구축, 현재도 일부 코어 로직 유지
Shopify: Rails monolith + modular monolith 전략
Basecamp: DHH의 회사, Rails 탄생지
Airbnb: 초기 Rails로 성장, 이후 일부 서비스 분리

김신건의 로그 - 위키 / rails

[Rails] ActiveRecord Callbacks: 장점과 단점

정의

콜백 순서 (Create 시)

콜백 종류

사용

장점

1. DRY

2. 깜빡임 방지

단점

1. 숨은 부수효과

2. 테스트 어려움

3. 순서 의존성

4. Cascade 폭발

안전 가이드

after_commit 만 외부 호출

동기 vs 비동기

패턴: Service Object 권장

Callbacks 우회

결정 가이드

흔한 함정

관련 위키

[Rails] 쿼리 최적화: preload, eager_load, includes, references

정의

N+1 시나리오

preload: 별도 2 쿼리

eager_load: LEFT OUTER JOIN 단일 쿼리

includes: 자동 선택

references: 강제 eager_load

다중 / 중첩 연관

bullet gem 으로 자동 감지

strict_loading (Rails 6.1+)

counter_cache: count 의 N+1

자주 보는 함정

1. find vs find_by + includes

2. uniq / distinct 후 includes

3. select 와 함께

4. polymorphic + includes

5. scope 와 조합

성능 측정

베스트 프랙티스

관련 위키

[Rails] Action Cable & Solid Cable: WebSocket

정의

채널 생성

broadcast

인증

stream_for (자동 channel 이름)

Solid Cable (8.0+)

Redis 어댑터 (전통)

Turbo Streams broadcast (위에 구축)

Channel에 인자 전달

reject

클라이언트 메서드 호출

자주 보는 패턴

실시간 알림

Presence (온라인 사용자)

실시간 협업 에디터

배포 시 고려

함정

1. broadcast에 큰 객체

2. broadcast가 트랜잭션 내부

3. 권한 검사

4. JSON 인코딩

5. 동시성

대안

[Rails] Action Mailer: 이메일 발송

정의

생성

Mailer 클래스

템플릿

전송

설정

다른 백엔드

URL helpers in mailer

첨부

Preview

테스트

Action Mailbox (수신)

자주 보는 패턴

`after_commit` 만 외부 호출