FDE ツールキット — 武器庫を整える

# app/models/demo.rb
class Demo < ApplicationRecord
  belongs_to :customer
  belongs_to :fde, class_name: "User"
  has_one :demo_environment, dependent: :destroy
 
  enum :status, {
    draft:      "draft",
    scheduled:  "scheduled",
    ready:      "ready",
    in_progress: "in_progress",
    completed:  "completed",
    archived:   "archived"
  }
 
  enum :demo_type, {
    live:        "live",
    sandbox:     "sandbox",
    video:       "video",
    interactive: "interactive"
  }
 
  validates :title, presence: true
  validates :scheduled_at, presence: true, if: :scheduled?
  validates :scenario, presence: true
 
  scope :upcoming, -> { where(status: %w[scheduled ready]).order(:scheduled_at) }
  scope :for_fde, ->(user) { where(fde: user) }
 
  def provision_environment!
    return unless sandbox?
    return if demo_environment&.running?
 
    DemoProvisioningJob.perform_later(id)
    update!(status: :scheduled)
  end
end

# app/models/demo_environment.rb
class DemoEnvironment < ApplicationRecord
  belongs_to :demo
 
  enum :status, {
    provisioning: "provisioning",
    running:      "running",
    stopped:      "stopped",
    failed:       "failed",
    terminated:   "terminated"
  }
 
  validates :cluster_arn, presence: true, if: :running?
 
  def expires_soon?
    expires_at.present? && expires_at < 2.hours.from_now
  end
 
  def uptime
    return 0 unless provisioned_at
 
    Time.current - provisioned_at
  end
 
  def cost_estimate
    hours = (uptime / 1.hour).ceil
    hours * BigDecimal("0.15") # Fargate vCPU/hour の概算
  end
end

# db/migrate/XXXXXX_create_demos.rb
class CreateDemos < ActiveRecord::Migration[7.2]
  def change
    create_table :demos do |t|
      t.references :customer, null: false, foreign_key: true
      t.references :fde, null: false, foreign_key: { to_table: :users }
      t.string :title, null: false
      t.text :scenario, null: false
      t.string :status, null: false, default: "draft"
      t.string :demo_type, null: false, default: "live"
      t.datetime :scheduled_at
      t.jsonb :metadata, default: {}
      t.timestamps
    end
 
    create_table :demo_environments do |t|
      t.references :demo, null: false, foreign_key: true
      t.string :status, null: false, default: "provisioning"
      t.string :cluster_arn
      t.string :task_arn
      t.string :access_url
      t.datetime :provisioned_at
      t.datetime :expires_at
      t.jsonb :resource_tags, default: {}
      t.timestamps
    end
 
    add_index :demos, %i[status scheduled_at]
    add_index :demos, %i[fde_id status]
  end
end

# app/jobs/demo_provisioning_job.rb
class DemoProvisioningJob < ApplicationJob
  queue_as :provisioning
  retry_on Aws::ECS::Errors::ServiceError, wait: 30.seconds, attempts: 3
 
  def perform(demo_id)
    demo = Demo.find(demo_id)
    env = demo.create_demo_environment!(status: :provisioning)
 
    begin
      result = provision_fargate_task(demo)
 
      env.update!(
        status:         :running,
        cluster_arn:    result[:cluster_arn],
        task_arn:       result[:task_arn],
        access_url:     result[:access_url],
        provisioned_at: Time.current,
        expires_at:     24.hours.from_now
      )
 
      demo.update!(status: :ready)
      DemoReadyNotifier.notify(demo)
    rescue StandardError => e
      env.update!(status: :failed)
      Rails.logger.error("[DemoProvisioning] Failed: #{e.message}")
      ErrorNotifier.report(e, context: { demo_id: demo.id })
      raise
    end
  end
 
  private
 
  def provision_fargate_task(demo)
    ecs = Aws::ECS::Client.new(region: "ap-northeast-1")
 
    response = ecs.run_task(
      cluster:          ENV.fetch("DEMO_ECS_CLUSTER"),
      task_definition:  task_definition_for(demo),
      launch_type:      "FARGATE",
      count:            1,
      network_configuration: {
        awsvpc_configuration: {
          subnets:          ENV.fetch("DEMO_SUBNETS").split(","),
          security_groups:  [ENV.fetch("DEMO_SECURITY_GROUP")],
          assign_public_ip: "ENABLED"
        }
      },
      overrides: {
        container_overrides: [{
          name: "demo-app",
          environment: [
            { name: "CUSTOMER_ID", value: demo.customer_id.to_s },
            { name: "DEMO_SCENARIO", value: demo.scenario },
            { name: "DEMO_EXPIRES_AT", value: 24.hours.from_now.iso8601 }
          ]
        }]
      },
      tags: [
        { key: "demo_id", value: demo.id.to_s },
        { key: "customer", value: demo.customer.name }
      ]
    )
 
    task = response.tasks.first
    task_arn = task.task_arn
 
    # ENI のパブリック IP を取得するまで待機
    ecs.wait_until(:tasks_running, cluster: ENV.fetch("DEMO_ECS_CLUSTER"), tasks: [task_arn])
 
    public_ip = fetch_public_ip(ecs, task)
 
    {
      cluster_arn: ENV.fetch("DEMO_ECS_CLUSTER"),
      task_arn:    task_arn,
      access_url:  "https://demo-#{demo.id}.arclight.ai"
    }
  end
 
  def task_definition_for(demo)
    case demo.demo_type
    when "sandbox"  then "arclight-demo-sandbox:latest"
    when "live"     then "arclight-demo-live:latest"
    else "arclight-demo-sandbox:latest"
    end
  end
 
  def fetch_public_ip(ecs, task)
    eni_id = task.attachments
      .find { |a| a.type == "ElasticNetworkInterface" }
      &.details&.find { |d| d.name == "networkInterfaceId" }
      &.value
 
    return unless eni_id
 
    ec2 = Aws::EC2::Client.new(region: "ap-northeast-1")
    resp = ec2.describe_network_interfaces(network_interface_ids: [eni_id])
    resp.network_interfaces.first&.association&.public_ip
  end
end

# app/controllers/api/v1/demos_controller.rb
module Api
  module V1
    class DemosController < ApplicationController
      before_action :authenticate_fde!
      before_action :set_demo, only: %i[show provision teardown]
 
      def index
        demos = Demo.for_fde(current_user)
                     .upcoming
                     .includes(:customer, :demo_environment)
 
        render json: demos, include: %i[customer demo_environment]
      end
 
      def create
        demo = Demo.new(demo_params.merge(fde: current_user))
 
        if demo.save
          render json: demo, status: :created
        else
          render json: { errors: demo.errors.full_messages },
                 status: :unprocessable_entity
        end
      end
 
      def provision
        if @demo.demo_environment&.running?
          render json: { error: "環境は既に起動中です" },
                 status: :conflict
          return
        end
 
        @demo.provision_environment!
        render json: { message: "プロビジョニングを開始しました", demo: @demo }
      end
 
      def teardown
        TeardownDemoJob.perform_later(@demo.id)
        render json: { message: "環境の停止を開始しました" }
      end
 
      private
 
      def set_demo
        @demo = Demo.for_fde(current_user).find(params[:id])
      end
 
      def demo_params
        params.require(:demo).permit(
          :title, :scenario, :demo_type,
          :scheduled_at, :customer_id, metadata: {}
        )
      end
    end
  end
end

# app/jobs/cleanup_expired_demos_job.rb
class CleanupExpiredDemosJob < ApplicationJob
  queue_as :maintenance
 
  def perform
    expired = DemoEnvironment.running.where("expires_at < ?", Time.current)
 
    expired.find_each do |env|
      Rails.logger.info("[Cleanup] Terminating expired demo: #{env.demo_id}")
      TeardownDemoJob.perform_later(env.demo_id)
    end
 
    Rails.logger.info("[Cleanup] Queued #{expired.count} environments for teardown")
  end
end

# config/recurring.yml (Solid Queue)
cleanup_expired_demos:
  class: CleanupExpiredDemosJob
  queue: maintenance
  schedule: every hour