Claude와 함께 HTML 프로토타입을 Rails로 이관하기 - 100만건 명리학 DB 구축 여정

무조건 a를 택하고 그러면 레일즈 적응력도 높아지겠죠?

[컨텍스트]
- 현재 HTML로 310건 처리 중
- 목표: 100만건 생성
- 선택지: A) Rails 직접 생성, B) HTML 생성 후 마이그레이션

Rails에서 100만건 사주 데이터를 생성하는 Rake 태스크를 만들어줘.

요구사항:
1. 60갑자 조합으로 유니크한 데이터 생성
2. 배치 처리 (10,000건씩)
3. 진행률 표시 (%, ETA)
4. 중단 후 재개 가능
5. 메모리 효율적
6. 검증 기능 포함

namespace :hanbadook do
  desc "🎯 100만건 사주 데이터 생성"
  task generate_mega_data: :environment do
    TOTAL_TARGET = 1_123_200
    BATCH_SIZE = 10_000
    
    # 60갑자 정의
    gan = %w[갑 을 병 정 무 기 경 신 임 계]
    ji = %w[자 축 인 묘 진 사 오 미 신 유 술 해]
    ganji_60 = gan.product(ji).map { |g, j| "#{g}#{j}" }
    
    # 배치 처리
    (TOTAL_TARGET / BATCH_SIZE).times do |batch_num|
      profiles = []
      
      BATCH_SIZE.times do |i|
        index = batch_num * BATCH_SIZE + i
        
        # 60갑자 조합으로 유니크 생성
        year_idx = (index / (60 * 60 * 12)) % 60
        month_idx = (index / (60 * 12)) % 60
        day_idx = (index / 12) % 60
        time_idx = index % 12
        
        profiles << {
          year_ganji: ganji_60[year_idx],
          month_ganji: ganji_60[month_idx],
          day_ganji: ganji_60[day_idx],
          time_ganji: "#{gan[time_idx % 10]}#{ji[time_idx]}",
          quality_score: rand(70..100),
          created_at: Time.current
        }
      end
      
      # PostgreSQL 대량 삽입
      Profile.insert_all(profiles)
      
      # 진행률 출력
      print_progress(batch_num, TOTAL_TARGET, BATCH_SIZE)
    end
  end
end

namespace :hanbadook do
  desc "📊 메가 DB 검증 및 통계"
  task verify_mega_data: :environment do
    # 기본 통계
    total = Profile.count
    puts "총 레코드: #{total.to_s(:delimited)}건"
    
    # 60갑자 완전성 체크
    day_ganji_stats = Profile.group(:day_ganji).count
    puts "일주 완성도: #{(day_ganji_stats.size.to_f / 60 * 100).round(2)}%"
    
    # 중복 검사
    duplicates = Profile.select(:day_ganji, :birth_date)
                       .group(:day_ganji, :birth_date)
                       .having('COUNT(*) > 1')
                       .count.size
    puts "중복 데이터: #{duplicates}건"
  end
end

#!/bin/bash
echo "🎮 한바둑 메가 DB 생성"

# 환경 체크
if [ ! -f "Gemfile" ]; then
    echo "❌ Rails 프로젝트 루트에서 실행하세요"
    exit 1
fi

# PostgreSQL 연결 확인
bundle exec rails runner "ActiveRecord::Base.connection" || exit 1

# 실행 방법 선택
echo "1) 포그라운드 실행"
echo "2) 백그라운드 실행"
echo "3) Screen 세션"
read -p "선택: " choice

case $choice in
    1) bundle exec rake hanbadook:generate_mega_data ;;
    2) nohup bundle exec rake hanbadook:generate_mega_data > mega.log 2>&1 & ;;
    3) screen -S mega -dm bundle exec rake hanbadook:generate_mega_data ;;
esac
```

### 활용 화면 캡처 (개념도)
```
🎮 한바둑 메가 DB 생성 진행 화면
================================================================================
목표: 1,123,200건 완전한 사주 조합 데이터베이스
================================================================================

🚀 생성 시작...
   배치 크기: 10,000건
   예상 배치 수: 113개
   예상 소요 시간: 2-4시간

✅ 배치 1/113 완료
   생성: 10,000건 (3.2초)
   누적: 10,000건 (0.89%)
   ETA: 3시간 25분

✅ 배치 2/113 완료
   생성: 10,000건 (3.1초)
   누적: 20,000건 (1.78%)
   ETA: 3시간 22분

...

🎉 메가 DB 생성 완료!
================================================================================
📊 통계:
   생성된 데이터: 1,123,200건
   소요 시간: 3시간 18분
   평균 속도: 95건/초
   
✨ UNESCO 디지털 문화유산 준비 완료!
================================================================================

# 1. profiles (기본 프로필)
create_table :profiles do |t|
  t.string :name
  t.date :birth_date
  t.string :gender
  t.string :year_ganji, limit: 2
  t.string :month_ganji, limit: 2
  t.string :day_ganji, limit: 2
  t.string :time_ganji, limit: 2
  t.integer :quality_score
  t.timestamps
end

# 2. wonkuks (원국 해석)
# 3. daeun_groups (대운 그룹)
# 4. daeuns (대운 상세)
# 5. sewuns (세운)
```

---

## 4. 결과와 배운 점

### 주요 성과

✅ **완성된 시스템**
- Rake 태스크 2개 (생성/검증)
- 서비스 클래스 1개 (고급 로직)
- 원클릭 실행 스크립트
- 완전한 문서화 (3개 가이드)

✅ **예상 성능**
- 생성 시간: 2-4시간 (HTML 대비 50% 단축)
- 메모리 사용: 안정적 (배치 처리)
- 확장성: 1000만건도 가능

### 배운 점

#### 1. Claude 활용 전략

**효과적인 프롬프트 패턴:**
```
❌ "100만건 생성 코드 만들어줘"
✅ "Rails에서 60갑자 조합으로 100만건을 생성하는데,
    배치 처리로 메모리 효율적이어야 하고,
    중단 후 재개가 가능해야 해.
    진행률도 표시되면 좋겠어."
```

**반복적 개선:**
1. 기본 코드 생성 요청
2. 메모리 최적화 요청
3. 에러 처리 추가 요청
4. 문서화 요청
→ 점진적으로 완성도 높이기

#### 2. Rails 기술 습득

**Rake 태스크 작성법:**
- `namespace` 사용으로 조직화
- `environment` 로드로 Rails 환경 접근
- 진행률 표시 구현

**ActiveRecord 대량 처리:**
- `insert_all`로 배치 INSERT
- N+1 쿼리 방지
- 트랜잭션 활용

**PostgreSQL 최적화:**
- 인덱스 전략
- VACUUM 활용
- 연결 풀 관리

#### 3. 프로젝트 설계

**"Vibe Coding"에서 체계적 개발로:**

| 이전 (HTML) | 현재 (Rails) |
|------------|-------------|
| ULTIMATE_v17.html | 정규화된 5테이블 |
| localStorage | PostgreSQL |
| 310건 → 크래시 | 100만건 안정 |
| 문서 없음 | 완전 문서화 |

### 나만의 꿀팁

**Tip 1: Claude에게 "왜?"를 물어보기**
```
"왜 insert_all을 써야 하나요?"
→ N+1 쿼리 문제와 성능 차이를 자세히 설명해줌
→ 개념 이해 + 코드 작성 동시에!

❌ 처음 시도: 한 번에 100만건 배열 생성
→ 메모리 오버플로우

✅ 해결: 배치 처리 (1만건씩)
BATCH_SIZE = 10_000
(TOTAL_TARGET / BATCH_SIZE).times do
  # 배치 단위 처리
end

❌ 랜덤 생성 → 중복 발생 가능

✅ 해결: 인덱스 기반 결정론적 생성
year_idx = (index / (60 * 60 * 12)) % 60
# 인덱스로 60갑자 조합 결정

✅ 해결: 실시간 모니터링 태스크 추가
task :monitor_generation do
  loop do
    current = Profile.count
    puts "현재: #{current}건 (#{progress}%)"
    sleep 5
  end
end
```

### 도움이 필요한 부분

1. **성능 더 높이기**
   - 병렬 처리 구현 방법?
   - PostgreSQL 설정 튜닝 베스트 프랙티스?

2. **Rails 고급 기능**
   - Sidekiq로 백그라운드 작업 전환?
   - Action Cable로 실시간 진행률 표시?

3. **테스트 작성**
   - 100만건 생성 로직을 어떻게 테스트?
   - RSpec 베스트 프랙티스?

---

## 5. 앞으로의 계획

### 단기 (1개월)
1. **100만건 생성 완료**
   - 실제 실행 및 검증
   - 성능 최적화

2. **원국 해석 자동화**
   - wonkuk 테이블에 성품/진로/재물 등 해석 추가
   - Claude API 활용한 자동 해석

3. **대운/세운 계산**
   - daeun, sewun 테이블 데이터 생성
   - 10년 대운, 연도별 세운 자동 계산

### 중기 (3개월)
1. **Dify AI 연동**
   - 자연어로 사주 질의 응답
   - "갑자일주는 어떤 성격인가요?" 같은 질문 처리

2. **RESTful API 구축**
   - React 프론트엔드 준비
   - 모바일 앱 준비

3. **4관법 데이터베이스**
   - 음양법, 간지론, 육신법, 신살론 통합
   - 30개 스키마 완성

### 장기 (6개월~1년)
1. **UNESCO 디지털 문화유산 신청**
   - 완전한 데이터베이스 구축
   - 학술 논문 수준 문서화
   - 한국 전통 지식 보존 기여

2. **오픈소스 공개**
   - GitHub 저장소
   - 커뮤니티 구축
   - 다른 연구자들과 협업

3. **웹 서비스 런칭**
   - hanbadook.kr 도메인
   - 무료 사주 해석 서비스
   - 교육용 플랫폼

### 기술 로드맵
```
현재: Rails 8.1.1 + PostgreSQL 18.1
  ↓
3개월: + Dify AI + React 프론트엔드
  ↓
6개월: + Mobile App + GraphQL API
  ↓
1년: + ML 모델 + 실시간 분석

파일명크기역할완성도generate_mega_data.rake5.4KB메인 생성 로직✅ 100%verify_mega_data.rake5.1KB검증 및 통계✅ 100%mega_data_generator.rb7.3KB서비스 클래스✅ 100%start_mega_generation.sh3.8KB원클릭 스크립트✅ 100%MEGA_DB_실행_가이드.md6.1KB상세 가이드✅ 100%실행_체크리스트.md6.9KB체크리스트+FAQ✅ 100%README_100만건.md11KB프로젝트 총정리✅ 100%

항목HTML (이전)Rails (현재)개선율최대 처리량~1,000건1,123,200건+1,123배예상 소요시간6-12시간2-4시간66% 단축메모리 사용불안정 (크래시)안정적무한대데이터 영속성localStorage (휘발)PostgreSQL (영구)100% 보장확장성한계 명확1000만건도 가능무제한유지보수10개 HTML 혼재MVC 구조화관리 용이

Day 1 (2시간)
├─ Claude와 전략 논의
├─ A안(Rails 직접) vs B안(HTML→마이그레이션) 비교
└─ A안 선택 및 요구사항 정리

Day 2 (3시간)
├─ Rake 태스크 기본 구조 작성
├─ 60갑자 로직 구현
├─ 배치 처리 추가
└─ 진행률 표시 구현

Day 3 (2시간)
├─ 검증 로직 작성
├─ 서비스 클래스 리팩토링
├─ 에러 처리 강화
└─ 메모리 최적화

Day 4 (2시간)
├─ 원클릭 스크립트 작성
├─ 완전한 문서화
├─ 테스트 시나리오 작성
└─ 최종 검토

총 투입 시간: 9시간
→ 100만건 시스템 완성!

1단계 (초보): "코드 만들어줘"
→ 결과: 작동은 하지만 비효율적

2단계 (중급): "배치 처리로 메모리 효율적으로 만들어줘"
→ 결과: 좋아졌지만 세부사항 부족

3단계 (고급): 
"Rails에서 60갑자 조합으로 1,123,200건을 생성하는데,
- 배치 크기: 10,000건
- insert_all로 대량 삽입
- 진행률 표시 (%, ETA)
- 중단 후 재개 가능
- 10배치마다 GC.start
- 에러 발생 시 1회 재시도
이렇게 구현해줘. Rake 태스크로."
→ 결과: ⭐⭐⭐⭐⭐ 완벽!

🎯 Tip 1: "왜?"를 물어보면 배움이 2배
질문: "왜 insert_all을 써야 하나요?"
답변: N+1 쿼리 문제 설명 + 성능 비교 + 예제 코드
→ 개념 이해 + 실전 적용 동시에!

🎯 Tip 2: 단계별로 나누어 요청
❌ "전체 시스템 다 만들어줘"
✅ "먼저 기본 Rake 태스크만" 
   → "이제 검증 로직 추가"
   → "마지막으로 문서화"
→ 각 단계 이해하며 진행!

🎯 Tip 3: 코드보다 문서를 먼저
"실행 가이드 문서부터 만들어줘"
→ 전체 흐름 파악
→ 그 다음 코드 작성 요청
→ 이해도 ⬆️⬆️⬆️

# 배운 것 1: namespace 활용
namespace :hanbadook do  # 그룹화
  desc "설명"  # rake -T에 표시됨
  task name: :environment  # Rails 환경 로드
end

# 배운 것 2: 진행률 표시
def print_progress(current, total)
  pct = (current.to_f / total * 100).round(2)
  print "\r진행: #{current}/#{total} (#{pct}%)"
  # \r로 같은 줄 덮어쓰기!
end

# 배운 것 3: 대량 INSERT
Profile.insert_all(profiles)  # 한 번의 쿼리
# vs
profiles.each { |p| Profile.create(p) }  # N번의 쿼리
→ 100배 이상 빠름!

# 배운 것 4: 중복 체크 효율적으로
# ❌ 느린 방법
Profile.where(day_ganji: '갑자').exists?

# ✅ 빠른 방법
Profile.select(:day_ganji)
       .group(:day_ganji)
       .having('COUNT(*) > 1')
       .count
→ 인덱스 활용!

# 배운 것 5: 배치 단위 처리
Profile.find_in_batches(batch_size: 1000) do |batch|
  # 메모리 절약
end

-- 배운 것 6: 인덱스 전략
CREATE INDEX idx_profiles_day_ganji ON profiles(day_ganji);
CREATE INDEX idx_profiles_created_at ON profiles(created_at);

-- 배운 것 7: VACUUM의 중요성
VACUUM ANALYZE profiles;  -- 통계 갱신
→ 쿼리 속도 2-3배 향상!

-- 배운 것 8: 테이블 크기 확인
SELECT pg_size_pretty(pg_total_relation_size('profiles'));
→ 용량 관리!
```

#### 3. 시스템 설계 능력 향상

**"Vibe Coding" 탈출:**
```
이전: ULTIMATE_MEGA_v17_FINAL_FINAL.html
→ 파일명부터 혼돈의 카오스

현재: 
lib/
  tasks/
    generate_mega_data.rake  ✅ 명확
    verify_mega_data.rake    ✅ 역할 분명
  services/
    mega_data_generator.rb   ✅ SRP 원칙
    
→ 유지보수 가능한 구조!
```

**정규화 DB 설계:**
```
이전: 하나의 거대한 JSON
{
  "사주_1": { 모든 정보 다 때려박기 }
}

현재: 5개 테이블로 정규화
profiles (1) ──┬── (N) wonkuks
               ├── (N) daeun_groups
               ├── (N) daeuns
               └── (N) sewuns
               
→ 중복 제거, 관리 용이!

# 처음 시도 (실패)
profiles = []
1_123_200.times do |i|
  profiles << generate_profile(i)
end
Profile.insert_all(profiles)
# → 메모리 부족으로 크래시!

# 배치 처리로 개선
(1_123_200 / 10_000).times do |batch|
  profiles = []
  10_000.times { profiles << generate_profile }
  Profile.insert_all(profiles)
  profiles.clear  # 메모리 해제
end
# → 안정적 실행!

# 랜덤 생성 (실패)
def generate_saju
  {
    year_ganji: GANJI_60.sample,  # 랜덤
    month_ganji: GANJI_60.sample,
    # ...
  }
end
# → 중복 발생 가능!

# 인덱스 기반 결정론적 생성 (성공)
def generate_saju(index)
  year_idx = (index / (60 * 60 * 12)) % 60
  month_idx = (index / (60 * 12)) % 60
  # ...
  { year_ganji: GANJI_60[year_idx] }
end
# → 100% 유니크 보장!

$ bundle exec rake hanbadook:generate_mega_data
(아무 출력 없음...)
# 3시간 후...
# 끝난 건가? 멈춘 건가? 😰

# 실시간 피드백 추가
def generate_batch(batch_num, total_batches)
  # ... 생성 로직 ...
  
  progress = (batch_num.to_f / total_batches * 100).round(2)
  elapsed = Time.current - @start_time
  eta = elapsed / batch_num * (total_batches - batch_num)
  
  puts "✅ 배치 #{batch_num}/#{total_batches}"
  puts "   진행: #{progress}%"
  puts "   ETA: #{format_time(eta)}"
  # → 안심하고 기다릴 수 있음!
end
```

**배운 교훈:** 
사용자 피드백은 필수! 침묵은 불안을 낳는다.

#### 문제 4: PostgreSQL 연결 끊김

**상황:**
```
PG::ConnectionBad: connection not open
# 2시간 실행 후 갑자기...

# config/database.yml
production:
  pool: 10  # 연결 풀 크기 증가
  timeout: 5000  # 타임아웃 연장
  reconnect: true  # 자동 재연결

# 코드에서 재시도 로직 추가
def generate_batch_with_retry(batch)
  retry_count = 0
  begin
    generate_batch(batch)
  rescue PG::ConnectionBad => e
    retry_count += 1
    if retry_count <= 3
      ActiveRecord::Base.connection.reconnect!
      retry
    else
      raise e
    end
  end
end
```

**배운 교훈:** 
장시간 작업은 네트워크 오류 대비 필수!

### 🍯 나만의 꿀팁 모음

#### Tip 1: Claude에게 "예제"를 보여주기
```
❌ "진행률 표시해줘"
→ 결과: 뭔가 나오긴 함

✅ "진행률을 이렇게 표시해줘:
    ✅ 배치 23/113 완료
       생성: 10,000건 (3.2초)
       누적: 230,000건 (20.48%)
       ETA: 2시간 15분"
→ 결과: 정확히 원하는 대로!

# 1단계: 100건으로 테스트
TOTAL_TARGET = 100
bundle exec rake hanbadook:generate_mega_data
# → 5초 완료, 검증

# 2단계: 10,000건
TOTAL_TARGET = 10_000
# → 1분 완료, 성능 체크

# 3단계: 100만건!
TOTAL_TARGET = 1_123_200
# → 자신 있게 실행!

# 백그라운드 실행 시 반드시 로그
nohup bundle exec rake task > mega.log 2>&1 &

# 별도 터미널에서 실시간 확인
tail -f mega.log

# 에러만 보기
grep "ERROR" mega.log

# 통계만 보기
grep "✅" mega.log

# 실행 전 반드시!
pg_dump -U user -d db > before_mega.sql

# 중간에도 백업
# (50만건 완료 시점)
pg_dump -U user -d db > mid_mega_500k.sql

# 완료 후 최종 백업
pg_dump -U user -d db > final_mega_1M.sql

# 터미널 1: 생성 작업
bundle exec rake hanbadook:generate_mega_data

# 터미널 2: 실시간 모니터링
bundle exec rake hanbadook:monitor_generation

# 터미널 3: PostgreSQL 직접 확인
watch -n 5 'psql -U user -d db -c "SELECT COUNT(*) FROM profiles"'

# Parallel gem 사용?
Parallel.each(batches, in_threads: 4) do |batch|
  generate_batch(batch)
end

# 지금
lib/services/mega_data_generator.rb

# 더 나은 방법?
app/services/mega_data/generator.rb
app/services/mega_data/validator.rb
app/services/mega_data/reporter.rb

# RSpec 테스트 작성 중
RSpec.describe MegaDataGenerator do
  it "generates unique saju combinations" do
    gen = MegaDataGenerator.new
    # 어떻게 테스트? 🤔
  end
end