Rails Active Storage 2026: Upload File, Tich Hop S3 va Cau Hoi Phong Van

# Generate Active Storage tables
rails active_storage:install
rails db:migrate

# app/models/user.rb
class User < ApplicationRecord
  has_one_attached :avatar
  has_many_attached :documents

  validates :avatar, content_type: ['image/png', 'image/jpeg'],
                     size: { less_than: 5.megabytes }
end

# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      redirect_to @user, notice: 'User created successfully'
    else
      render :new, status: :unprocessable_entity
    end
  end

  def update
    @user = User.find(params[:id])
    if @user.update(user_params)
      redirect_to @user, notice: 'User updated successfully'
    else
      render :edit, status: :unprocessable_entity
    end
  end

  private

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

<%# app/views/users/_form.html.erb %>
<%= form_with model: @user do |form| %>
  <div class="field">
    <%= form.label :avatar %>
    <%= form.file_field :avatar, accept: 'image/png,image/jpeg',
        direct_upload: true %>
  </div>

  <div class="field">
    <%= form.label :documents %>
    <%= form.file_field :documents, multiple: true,
        direct_upload: true %>
  </div>

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

# config/storage.yml
amazon:
  service: S3
  access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
  secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
  region: ap-southeast-1
  bucket: myapp-production-uploads
  public: false

# config/environments/production.rb
Rails.application.configure do
  config.active_storage.service = :amazon
end

# Gemfile
gem 'aws-sdk-s3', require: false
gem 'image_processing', '~> 1.2'

# Generating image variants
@user.avatar.variant(resize_to_limit: [200, 200]).processed

# Pre-defined variants in model
class User < ApplicationRecord
  has_one_attached :avatar do |attachable|
    attachable.variant :thumb, resize_to_limit: [100, 100]
    attachable.variant :medium, resize_to_limit: [300, 300]
    attachable.variant :large, resize_to_limit: [800, 800]
  end
end

<%# Display avatar with variant %>
<%= image_tag @user.avatar.variant(:thumb) if @user.avatar.attached? %>

<%# Link to download document %>
<% @user.documents.each do |document| %>
  <%= link_to document.filename, rails_blob_path(document, disposition: 'attachment') %>
<% end %>

<%# Display image with fallback %>
<%= image_tag(@user.avatar.attached? ? @user.avatar.variant(:medium) : 'default-avatar.png') %>

import { DirectUpload } from "@rails/activestorage"

class DirectUploadController {
  constructor(file, url) {
    this.directUpload = new DirectUpload(file, url, this)
  }

  upload() {
    return new Promise((resolve, reject) => {
      this.directUpload.create((error, blob) => {
        if (error) {
          reject(error)
        } else {
          resolve(blob.signed_id)
        }
      })
    })
  }

  directUploadWillStoreFileWithXHR(request) {
    request.upload.addEventListener("progress", event => {
      const progress = (event.loaded / event.total) * 100
      console.log(`Upload progress: ${progress.toFixed(2)}%`)
    })
  }
}

export { DirectUploadController }

# app/validators/file_size_validator.rb
class FileSizeValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    return unless value.attached?

    if value.is_a?(ActiveStorage::Attached::Many)
      value.each do |attachment|
        validate_attachment(record, attribute, attachment)
      end
    else
      validate_attachment(record, attribute, value)
    end
  end

  private

  def validate_attachment(record, attribute, attachment)
    max_size = options[:max] || 10.megabytes
    if attachment.blob.byte_size > max_size
      record.errors.add(attribute, "is too large (max: #{max_size / 1.megabyte}MB)")
    end
  end
end

# app/jobs/process_video_job.rb
class ProcessVideoJob < ApplicationJob
  queue_as :default

  def perform(video_id)
    video = Video.find(video_id)
    return unless video.file.attached?

    video.file.analyze
    # Additional processing logic
  end
end

# Trigger job after upload
class Video < ApplicationRecord
  has_one_attached :file

  after_commit :process_video, on: [:create, :update]

  private

  def process_video
    ProcessVideoJob.perform_later(id) if file.attached?
  end
end

# test/models/user_test.rb
require 'test_helper'

class UserTest < ActiveSupport::TestCase
  test 'should attach avatar' do
    user = users(:john)
    user.avatar.attach(
      io: File.open(Rails.root.join('test/fixtures/files/avatar.png')),
      filename: 'avatar.png',
      content_type: 'image/png'
    )

    assert user.avatar.attached?
    assert_equal 'avatar.png', user.avatar.filename.to_s
  end

  test 'should validate avatar content type' do
    user = users(:john)
    user.avatar.attach(
      io: File.open(Rails.root.join('test/fixtures/files/document.pdf')),
      filename: 'document.pdf',
      content_type: 'application/pdf'
    )

    assert_not user.valid?
    assert_includes user.errors[:avatar], 'has an invalid content type'
  end
end

# Manual purge
ActiveStorage::Blob.unattached.where('created_at < ?', 1.day.ago).find_each(&:purge_later)