Trunk-based Development

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

                    Trunk-based Development 원리
                    
    [Single Trunk Branch (main/master)]
           │
           │ Daily commits
           ├─── [Developer 1] ─── Small changes ─→ CI/CD → Deploy
           │
           ├─── [Developer 2] ─── Small changes ─→ CI/CD → Deploy
           │
           └─── [Developer N] ─── Small changes ─→ CI/CD → Deploy

	
    Key Principles:
    1. Single Source of Truth (하나의 trunk)
    2. Frequent Integration (하루 여러번 통합)
    3. Small Commits (작은 변경 단위)
    4. Always Releasable (항상 배포 가능한 상태)
    5. Automated Testing (자동화된 테스트)
    6. Feature Flags (기능 토글)

1
2
3

   [개발자] → [직접 trunk 커밋] → [CI 실행] → [자동 배포]
          ↑                                        │
          └────────── 피드백 ─────────────────────┘

1
2
3
4
5
6
7

   [개발자] → [짧은 피처 브랜치] → [Pull Request] → [코드 리뷰]
                                                        │
                    ┌───────────────────────────────────┘
                    ↓
           [CI 테스트 통과] → [trunk 병합] → [자동 배포]
                    │                            │
                    └── 실패시 즉시 수정 ────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

┌──────────────────────────────────────────────────────────────┐
│               Trunk-based Development Architecture            │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌─────────────┐    ┌────────────────┐    ┌───────────────┐ │
│  │  Developers │    │ CI/CD Pipeline │    │  Production   │ │
│  │             │    │                │    │  Environment  │ │
│  └──────┬──────┘    └───────┬────────┘    └───────┬───────┘ │
│         │                   │                     │         │
│         ▼                   │                     │         │
│  ┌─────────────┐           │                     │         │
│  │ Short-lived │           │                     │         │
│  │  Branches   │─────┐     │                     │         │
│  └─────────────┘     │     │                     │         │
│                      ▼     ▼                     │         │
│                 ┌─────────────┐                  │         │
│                 │    TRUNK    │ ◄────────────────┘         │
│                 │  (main/master)  │                        │
│                 └──────┬──────┘                           │
│                        │                                   │
│         ┌──────────────┴──────────────┐                  │
│         ▼                             ▼                  │
│  ┌─────────────┐              ┌─────────────┐           │
│  │  Automated  │              │   Feature   │           │
│  │    Tests    │              │    Flags    │           │
│  └─────────────┘              └─────────────┘           │
│                                                          │
└──────────────────────────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 저장소 구조
fintech-pro/
├── .github/
│   └── workflows/
│       ├── ci.yml
│       ├── deploy.yml
│       └── release.yml
├── src/
│   ├── features/
│   ├── core/
│   └── shared/
├── tests/
├── config/
│   └── feature-flags.json
└── scripts/
    └── release.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// src/lib/feature-flags.js
class FeatureFlagService {
  constructor() {
    this.flags = {};
    this.userOverrides = {};
  }

  async loadFlags() {
    const response = await fetch('/api/feature-flags');
    this.flags = await response.json();
  }

  isEnabled(flagName, userId = null) {
    const flag = this.flags[flagName];
    if (!flag) return false;

    // 사용자별 오버라이드 확인
    if (userId && this.userOverrides[userId]?.[flagName] !== undefined) {
      return this.userOverrides[userId][flagName];
    }

    // 기본 활성화 상태 확인
    if (flag.enabled === false) return false;

    // 점진적 롤아웃 확인
    if (flag.rollout) {
      if (userId && flag.rollout.targetUsers?.includes(userId)) {
        return true;
      }
      
      if (flag.rollout.percentage > 0) {
        // 사용자 ID를 기반으로 일관된 해시 생성
        const hash = this.hashUserId(userId);
        return (hash % 100) < flag.rollout.percentage;
      }
    }

    return flag.enabled;
  }

  // A/B 테스팅을 위한 변형 선택
  getVariant(flagName, userId) {
    const flag = this.flags[flagName];
    if (!flag?.variants) return 'control';

    const hash = this.hashUserId(userId);
    const variantIndex = hash % flag.variants.length;
    return flag.variants[variantIndex];
  }

  private hashUserId(userId) {
    if (!userId) return Math.random() * 100;
    
    let hash = 0;
    for (let i = 0; i < userId.length; i++) {
      hash = ((hash << 5) - hash) + userId.charCodeAt(i);
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }
}

// 사용 예시
const featureFlags = new FeatureFlagService();

// React 컴포넌트에서 사용
function PaymentButton({ userId }) {
  const isNewCheckoutEnabled = featureFlags.isEnabled('newCheckout', userId);
  const checkoutVariant = featureFlags.getVariant('checkoutExperiment', userId);

  if (!isNewCheckoutEnabled) {
    return <LegacyCheckoutButton />;
  }

  switch (checkoutVariant) {
    case 'variantA':
      return <CheckoutButtonA />;
    case 'variantB':
      return <CheckoutButtonB />;
    default:
      return <DefaultCheckoutButton />;
  }
}

1
2
3
4
5
6
7

# 1.1 최신 main 브랜치 동기화
git checkout main
git pull origin main

# 1.2 작업 환경 확인
npm install
npm test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 2.1 기능 플래그 추가
cat > config/feature-flags.json << EOF
{
  "features": {
    "userProfile": {
      "enabled": false,
      "description": "New user profile page",
      "createdAt": "2024-03-15T10:00:00Z",
      "owner": "dev@company.com"
    }
  }
}
EOF

# 2.2 기능 플래그 커밋
git add config/feature-flags.json
git commit -m "feat: add feature flag for user profile"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 3.1 프로필 컴포넌트 생성
mkdir -p src/components/UserProfile
touch src/components/UserProfile/UserProfile.jsx

# 3.2 컴포넌트 코드 작성
cat > src/components/UserProfile/UserProfile.jsx << EOF
import { useFeatureFlag } from '@/hooks/useFeatureFlag';

export function UserProfile({ userId }) {
  const isEnabled = useFeatureFlag('userProfile');
  
  if (!isEnabled) {
    return <LegacyProfile userId={userId} />;
  }
  
  return (
    <div className="user-profile">
      <ProfileHeader userId={userId} />
      <ProfileContent userId={userId} />
    </div>
  );
}
EOF

# 3.3 구현 커밋
git add src/components/UserProfile/
git commit -m "feat: implement basic user profile component"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 4.1 테스트 파일 생성
touch src/components/UserProfile/UserProfile.test.jsx

# 4.2 테스트 코드 작성
cat > src/components/UserProfile/UserProfile.test.jsx << EOF
import { render, screen } from '@testing-library/react';
import { UserProfile } from './UserProfile';

jest.mock('@/hooks/useFeatureFlag', () => ({
  useFeatureFlag: jest.fn()
}));

describe('UserProfile', () => {
  it('shows legacy profile when feature is disabled', () => {
    useFeatureFlag.mockReturnValue(false);
    render(<UserProfile userId="123" />);
    expect(screen.getByTestId('legacy-profile')).toBeInTheDocument();
  });

  it('shows new profile when feature is enabled', () => {
    useFeatureFlag.mockReturnValue(true);
    render(<UserProfile userId="123" />);
    expect(screen.getByTestId('new-profile')).toBeInTheDocument();
  });
});
EOF

# 4.3 테스트 실행 및 커밋
npm test
git add src/components/UserProfile/UserProfile.test.jsx
git commit -m "test: add tests for user profile component"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 5.1 개발 환경에서 기능 활성화
cat > config/feature-flags.dev.json << EOF
{
  "features": {
    "userProfile": {
      "enabled": true
    }
  }
}
EOF

# 5.2 변경사항 커밋
git add config/feature-flags.dev.json
git commit -m "feat: enable user profile in dev environment"
git push origin main

1
2
3
4
5
6
7
8

# 1.1 최신 코드 동기화
git checkout main
git pull origin main

# 1.2 로그 확인 및 문제 재현
npm run logs:prod
# Error: Cannot read property 'amount' of undefined
# at PaymentService.processPayment (payment.service.js:45)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 2.1 문제가 있는 코드 확인
cat src/services/payment.service.js
# Line 45: const amount = transaction.amount;

# 2.2 버그 수정
cat > src/services/payment.service.js << EOF
export class PaymentService {
  async processPayment(transaction) {
    // 버그 수정: null 체크 추가
    if (!transaction || !transaction.amount) {
      throw new Error('Invalid transaction data');
    }
    
    const amount = transaction.amount;
    // … 나머지 코드
  }
}
EOF

# 2.3 수정사항 커밋
git add src/services/payment.service.js
git commit -m "fix: add null check for transaction in payment service"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 3.1 테스트 케이스 추가
cat >> src/services/payment.service.test.js << EOF

test('should throw error for null transaction', async () => {
  const service = new PaymentService();
  
  await expect(service.processPayment(null))
    .rejects.toThrow('Invalid transaction data');
});

test('should throw error for transaction without amount', async () => {
  const service = new PaymentService();
  
  await expect(service.processPayment({}))
    .rejects.toThrow('Invalid transaction data');
});
EOF

# 3.2 테스트 실행
npm test src/services/payment.service.test.js

# 3.3 테스트 커밋
git add src/services/payment.service.test.js
git commit -m "test: add tests for payment service null checks"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 4.1 변경사항 푸시
git push origin main

# 4.2 CI/CD 파이프라인 모니터링
# GitHub Actions에서 자동으로:
# - 테스트 실행
# - 빌드
# - 스테이징 배포
# - 프로덕션 배포

# 4.3 배포 확인
npm run health-check:prod

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 1.1 팀 미팅 후 기능 플래그 구조 설계
cat > config/feature-flags.json << EOF
{
  "features": {
    "newDashboard": {
      "enabled": false,
      "components": {
        "layout": false,
        "widgets": false,
        "analytics": false,
        "charts": false
      },
      "rollout": {
        "percentage": 0,
        "targetGroups": ["beta", "internal"],
        "excludeGroups": ["enterprise"]
      }
    }
  }
}
EOF

# 1.2 아키텍처 문서 작성
cat > docs/new-dashboard-architecture.md << EOF
# New Dashboard Architecture

## Components
1. Layout System
2. Widget Framework
3. Analytics Engine
4. Chart Library

## Implementation Phases
- Phase 1: Basic Layout (Developer A)
- Phase 2: Widget System (Developer B)
- Phase 3: Analytics (Developer C)
- Phase 4: Interactive Charts (Developer D)
EOF

git add config/feature-flags.json docs/
git commit -m "docs: add new dashboard architecture and feature flags"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 2.1 최신 변경사항 동기화
git pull origin main

# 2.2 레이아웃 컴포넌트 구현
mkdir -p src/components/Dashboard/Layout
cat > src/components/Dashboard/Layout/DashboardLayout.jsx << EOF
export function DashboardLayout({ children }) {
  const { isEnabled, getComponent } = useFeatureFlag('newDashboard');
  
  if (!isEnabled || !getComponent('layout')) {
    return <LegacyDashboard>{children}</LegacyDashboard>;
  }
  
  return (
    <div className="dashboard-layout">
      <Sidebar />
      <main className="dashboard-content">
        {children}
      </main>
    </div>
  );
}
EOF

# 2.3 테스트 작성
cat > src/components/Dashboard/Layout/DashboardLayout.test.jsx << EOF
describe('DashboardLayout', () => {
  it('renders legacy dashboard when feature is disabled', () => {
    // 테스트 코드
  });
  
  it('renders new layout when feature is enabled', () => {
    // 테스트 코드
  });
});
EOF

# 2.4 커밋 및 푸시
git add src/components/Dashboard/Layout/
git commit -m "feat: implement dashboard layout system"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 3.1 최신 변경사항 동기화
git pull origin main

# 3.2 위젯 프레임워크 구현
mkdir -p src/components/Dashboard/Widgets
cat > src/components/Dashboard/Widgets/WidgetContainer.jsx << EOF
export function WidgetContainer({ type, data }) {
  const { getComponent } = useFeatureFlag('newDashboard');
  
  if (!getComponent('widgets')) {
    return null;
  }
  
  const Widget = widgetRegistry[type];
  if (!Widget) {
    console.error(`Unknown widget type: ${type}`);
    return null;
  }
  
  return (
    <div className="widget-container">
      <Widget data={data} />
    </div>
  );
}
EOF

# 3.3 위젯 레지스트리 생성
cat > src/components/Dashboard/Widgets/registry.js << EOF
export const widgetRegistry = {
  'chart': ChartWidget,
  'stats': StatsWidget,
  'table': TableWidget,
  'timeline': TimelineWidget
};
EOF

# 3.4 커밋 및 푸시
git add src/components/Dashboard/Widgets/
git commit -m "feat: implement widget framework for dashboard"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 4.1 통합 테스트 작성
cat > src/components/Dashboard/Dashboard.integration.test.jsx << EOF
describe('Dashboard Integration', () => {
  beforeEach(() => {
    // 모든 기능 플래그 활성화
    mockFeatureFlags({
      newDashboard: {
        enabled: true,
        components: {
          layout: true,
          widgets: true,
          analytics: true,
          charts: true
        }
      }
    });
  });
  
  it('renders complete dashboard with all components', () => {
    render(<Dashboard />);
    
    expect(screen.getByTestId('dashboard-layout')).toBeInTheDocument();
    expect(screen.getByTestId('widget-container')).toBeInTheDocument();
    expect(screen.getByTestId('analytics-panel')).toBeInTheDocument();
  });
});
EOF

# 4.2 E2E 테스트 작성
cat > tests/e2e/dashboard.spec.js << EOF
describe('Dashboard E2E', () => {
  it('loads dashboard with feature flags', () => {
    cy.visit('/dashboard');
    cy.getCookie('featureFlags').should('exist');
    cy.get('[data-testid="dashboard-layout"]').should('be.visible');
  });
});
EOF

git add src/components/Dashboard/*.test.jsx tests/e2e/
git commit -m "test: add integration and e2e tests for dashboard"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 1.1 기능 플래그 구성
cat > config/feature-flags.json << EOF
{
  "features": {
    "newSearch": {
      "enabled": true,
      "rollout": {
        "percentage": 0,
        "stages": [
          { "percentage": 5, "date": "2024-03-15" },
          { "percentage": 25, "date": "2024-03-17" },
          { "percentage": 50, "date": "2024-03-19" },
          { "percentage": 100, "date": "2024-03-21" }
        ]
      },
      "monitoring": {
        "errorThreshold": 0.01,
        "latencyThreshold": 200
      }
    }
  }
}
EOF

git add config/feature-flags.json
git commit -m "feat: configure progressive rollout for new search"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# 2.1 모니터링 대시보드 구성
cat > monitoring/dashboards/search-rollout.json << EOF
{
  "dashboard": "Search Feature Rollout",
  "panels": [
    {
      "title": "Error Rate by Search Version",
      "metrics": [
        "search.errors.new",
        "search.errors.legacy"
      ]
    },
    {
      "title": "Search Latency",
      "metrics": [
        "search.latency.p95.new",
        "search.latency.p95.legacy"
      ]
    },
    {
      "title": "User Distribution",
      "metrics": [
        "search.users.new",
        "search.users.legacy"
      ]
    }
  ]
}
EOF

# 2.2 알림 규칙 설정
cat > monitoring/alerts/search-rollout.yaml << EOF
alerts:
  - name: high_error_rate
    condition: search.errors.new > 0.01
    duration: 5m
    action: rollback_feature
    
  - name: high_latency
    condition: search.latency.p95.new > 200ms
    duration: 10m
    action: notify_team
EOF

git add monitoring/
git commit -m "feat: add monitoring for search rollout"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

# 3.1 롤아웃 자동화 스크립트
cat > scripts/progressive-rollout.js << EOF
const { FeatureFlags } = require('../lib/feature-flags');
const { Monitoring } = require('../lib/monitoring');

async function progressiveRollout(featureName) {
  const flags = new FeatureFlags();
  const monitoring = new Monitoring();
  
  const feature = await flags.getFeature(featureName);
  const currentStage = getCurrentStage(feature.rollout.stages);
  
  if (!currentStage) {
    console.log('Rollout complete');
    return;
  }
  
  // 다음 단계로 진행
  await flags.updateRollout(featureName, {
    percentage: currentStage.percentage
  });
  
  // 30분 모니터링
  await monitorRollout(featureName, 30 * 60 * 1000);
  
  // 메트릭 확인
  const metrics = await monitoring.getFeatureMetrics(featureName);
  
  if (metrics.errorRate > feature.monitoring.errorThreshold) {
    console.error('Error threshold exceeded, rolling back');
    await flags.rollback(featureName);
    return;
  }
  
  console.log(`Successfully rolled out to ${currentStage.percentage}%`);
}

// 매일 실행되는 cron job
progressiveRollout('newSearch');
EOF

# 3.2 GitHub Actions 워크플로우
cat > .github/workflows/progressive-rollout.yml << EOF
name: Progressive Feature Rollout

on:
  schedule:
    - cron: '0 0 * * *'  # 매일 자정 실행
  workflow_dispatch:     # 수동 실행 가능

jobs:
  rollout:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        
      - name: Run rollout script
        run: node scripts/progressive-rollout.js
        env:
          FEATURE_FLAGS_API_KEY: ${{ secrets.FEATURE_FLAGS_API_KEY }}
      
      - name: Notify on failure
        if: failure()
        uses: slackapi/slack-github-action@v1.24.0
        with:
          payload: |
            {
              "text": "⚠️ Feature rollout failed",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "Progressive rollout failed for feature: newSearch"
                  }
                }
              ]
            }
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}
EOF

git add scripts/ .github/workflows/
git commit -m "feat: add progressive rollout automation"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# 4.1 피드백 수집 컴포넌트
cat > src/components/Feedback/FeatureFeedback.jsx << EOF
export function FeatureFeedback({ featureName }) {
  const [feedback, setFeedback] = useState('');
  const [rating, setRating] = useState(0);
  
  const submitFeedback = async () => {
    await api.post('/feedback', {
      feature: featureName,
      rating,
      comment: feedback,
      version: isFeatureEnabled(featureName) ? 'new' : 'legacy'
    });
  };
  
  return (
    <div className="feature-feedback">
      <h3>How's the new {featureName}?</h3>
      <RatingStars value={rating} onChange={setRating} />
      <textarea
        value={feedback}
        onChange={(e) => setFeedback(e.target.value)}
        placeholder="Your feedback…"
      />
      <button onClick={submitFeedback}>Submit</button>
    </div>
  );
}
EOF

# 4.2 피드백 분석 대시보드
cat > src/pages/admin/FeedbackDashboard.jsx << EOF
export function FeedbackDashboard() {
  const [feedbackData, setFeedbackData] = useState([]);
  
  useEffect(() => {
    fetchFeedbackData().then(setFeedbackData);
  }, []);
  
  const avgRatingNew = calculateAvgRating(feedbackData, 'new');
  const avgRatingLegacy = calculateAvgRating(feedbackData, 'legacy');
  
  return (
    <div className="feedback-dashboard">
      <h2>Feature Feedback Analysis</h2>
      
      <div className="rating-comparison">
        <div>New Version: {avgRatingNew.toFixed(2)} ⭐</div>
        <div>Legacy Version: {avgRatingLegacy.toFixed(2)} ⭐</div>
      </div>
      
      <SentimentAnalysis data={feedbackData} />
      <WordCloud data={feedbackData} />
    </div>
  );
}
EOF

git add src/components/Feedback/ src/pages/admin/
git commit -m "feat: add feature feedback collection system"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# 1.1 인증 인터페이스 정의
cat > src/auth/AuthProvider.interface.ts << EOF
export interface AuthProvider {
  login(credentials: Credentials): Promise<User>;
  logout(): Promise<void>;
  getCurrentUser(): Promise<User | null>;
  refreshToken(): Promise<string>;
}
EOF

# 1.2 추상화 구현
cat > src/auth/AuthService.ts << EOF
export class AuthService implements AuthProvider {
  constructor(private featureFlags: FeatureFlags) {}
  
  async login(credentials: Credentials): Promise<User> {
    if (this.featureFlags.isEnabled('newAuthSystem')) {
      return this.oauthLogin(credentials);
    }
    return this.legacyLogin(credentials);
  }
  
  private async legacyLogin(credentials: Credentials): Promise<User> {
    // 기존 인증 로직
    const response = await api.post('/auth/login', credentials);
    return response.data.user;
  }
  
  private async oauthLogin(credentials: Credentials): Promise<User> {
    // 새로운 OAuth 로직
    const token = await oauth.getToken(credentials);
    const user = await oauth.getUserInfo(token);
    return user;
  }
}
EOF

git add src/auth/
git commit -m "feat: create auth abstraction layer"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# 2.1 듀얼 라이트 설정
cat > src/auth/DualAuthService.ts << EOF
export class DualAuthService extends AuthService {
  async login(credentials: Credentials): Promise<User> {
    let user: User;
    
    try {
      // 먼저 레거시 시스템으로 로그인
      user = await this.legacyLogin(credentials);
      
      // 백그라운드에서 새 시스템 테스트
      if (this.featureFlags.isEnabled('testNewAuth')) {
        this.testNewAuthSystem(credentials).catch(error => {
          console.error('New auth system test failed:', error);
          this.metrics.increment('auth.dual_write.failure');
        });
      }
      
      return user;
    } catch (error) {
      // 레거시 실패 시 새 시스템으로 폴백
      if (this.featureFlags.isEnabled('authFallback')) {
        return this.oauthLogin(credentials);
      }
      throw error;
    }
  }
  
  private async testNewAuthSystem(credentials: Credentials): Promise<void> {
    const startTime = Date.now();
    try {
      const newUser = await this.oauthLogin(credentials);
      const duration = Date.now() - startTime;
      
      this.metrics.timing('auth.new_system.latency', duration);
      this.metrics.increment('auth.dual_write.success');
      
      // 결과 비교
      if (!this.compareUsers(user, newUser)) {
        this.metrics.increment('auth.dual_write.mismatch');
      }
    } catch (error) {
      this.metrics.increment('auth.new_system.error');
      throw error;
    }
  }
}
EOF

git add src/auth/DualAuthService.ts
git commit -m "feat: implement dual auth for testing new system"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

# 3.1 마이그레이션 스크립트
cat > scripts/migrate-auth.js << EOF
async function migrateUsers(batchSize = 1000) {
  const db = new Database();
  const flags = new FeatureFlags();
  
  let offset = 0;
  let migrated = 0;
  
  while (true) {
    // 마이그레이션 일시 중지 체크
    if (!flags.isEnabled('authMigration')) {
      console.log('Migration paused');
      await sleep(60000);
      continue;
    }
    
    // 사용자 배치 가져오기
    const users = await db.query(
      'SELECT * FROM users WHERE auth_version = 1 LIMIT ? OFFSET ?',
      [batchSize, offset]
    );
    
    if (users.length === 0) break;
    
    // 배치 마이그레이션
    for (const user of users) {
      try {
        await migrateUser(user);
        migrated++;
        
        if (migrated % 100 === 0) {
          console.log(`Migrated ${migrated} users`);
        }
      } catch (error) {
        console.error(`Failed to migrate user ${user.id}:`, error);
        await notifyError('auth_migration', user.id, error);
        
        // 에러율이 높으면 중단
        const errorRate = await getErrorRate('auth_migration');
        if (errorRate > 0.01) {
          await flags.disable('authMigration');
          break;
        }
      }
    }
    
    offset += batchSize;
  }
  
  console.log(`Migration completed. Total migrated: ${migrated}`);
}
EOF

# 3.2 마이그레이션 모니터링
cat > monitoring/auth-migration.js << EOF
class AuthMigrationMonitor {
  async checkMigrationHealth() {
    const metrics = await this.getMetrics();
    
    const dashboard = {
      totalUsers: metrics.totalUsers,
      migratedUsers: metrics.migratedUsers,
      progress: (metrics.migratedUsers / metrics.totalUsers) * 100,
      errorRate: metrics.errors / metrics.attempts,
      avgMigrationTime: metrics.totalTime / metrics.migratedUsers
    };
    
    // 대시보드 업데이트
    await this.updateDashboard(dashboard);
    
    // 알림 체크
    if (dashboard.errorRate > 0.01) {
      await this.alert('High error rate in auth migration');
    }
    
    return dashboard;
  }
}
EOF

git add scripts/migrate-auth.js monitoring/
git commit -m "feat: add auth migration scripts and monitoring"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# 4.1 컷오버 체크리스트
cat > docs/auth-cutover-checklist.md << EOF
# Auth System Cutover Checklist

## Pre-cutover
- [ ] All users migrated successfully
- [ ] Error rate < 0.1% for past 7 days
- [ ] Performance metrics acceptable
- [ ] Rollback plan tested
- [ ] Support team trained

## Cutover Steps
1. Enable read from new system (50% traffic)
2. Monitor for 24 hours
3. Enable read from new system (100% traffic)
4. Monitor for 48 hours
5. Disable writes to legacy system
6. Monitor for 7 days
7. Decommission legacy system

## Rollback Plan
1. Disable new system flag
2. Re-enable legacy system
3. Investigate issues
4. Fix and retry
EOF

# 4.2 컷오버 자동화 스크립트
cat > scripts/auth-cutover.js << EOF
async function executeAuthCutover(phase) {
  const flags = new FeatureFlags();
  const monitor = new AuthMigrationMonitor();
  
  switch (phase) {
    case 'phase1':
      // 50% 트래픽을 새 시스템으로
      await flags.update('newAuthSystem', {
        enabled: true,
        rollout: { percentage: 50 }
      });
      break;
      
    case 'phase2':
      // 100% 트래픽을 새 시스템으로
      await flags.update('newAuthSystem', {
        enabled: true,
        rollout: { percentage: 100 }
      });
      break;
      
    case 'phase3':
      // 레거시 시스템 비활성화
      await flags.update('legacyAuthWrites', {
        enabled: false
      });
      break;
      
    case 'rollback':
      // 롤백 실행
      await flags.update('newAuthSystem', {
        enabled: false
      });
      await flags.update('legacyAuthWrites', {
        enabled: true
      });
      break;
  }
  
  // 상태 모니터링
  const health = await monitor.checkMigrationHealth();
  console.log('System health:', health);
}
EOF

git add docs/auth-cutover-checklist.md scripts/auth-cutover.js
git commit -m "feat: add auth system cutover automation"
git push origin main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

# .github/workflows/ci.yml
name: Continuous Integration

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    
    - name: Install dependencies
      run: npm ci
    
    - name: Run linting
      run: npm run lint
    
    - name: Run type checking
      run: npm run type-check
    
    - name: Run unit tests
      run: npm run test:unit
    
    - name: Run integration tests
      run: npm run test:integration

  security-scan:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Run security audit
      run: npm audit
    
    - name: Run SAST scan
      uses: github/codeql-action/analyze@v2

  deploy-staging:
    needs: [test, security-scan]
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Deploy to staging
      run: |
        npm run build
        npm run deploy:staging
    
    - name: Run E2E tests
      run: npm run test:e2e
    
    - name: Health check
      run: |
        curl --fail https://staging.fintech-pro.com/health || exit 1

  deploy-production:
    needs: deploy-staging
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
    - uses: actions/checkout@v3
    
    - name: Deploy to production
      run: |
        npm run build:prod
        npm run deploy:prod
    
    - name: Smoke tests
      run: npm run test:smoke
    
    - name: Monitor deployment
      run: |
        # 배포 모니터링 스크립트
        npm run monitor:deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

Google의 대규모 TBD 구현 사례:

┌─────────────────────────────────────────────────────────────────┐
│                   Google Monorepo TBD Workflow                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  [35,000+ Developers Worldwide]                                │
│           │                                                     │
│           ▼                                                     │
│  ┌─────────────────┐                                           │
│  │  Local Changes  │ ── Pre-submit Tests ──┐                   │
│  └─────────────────┘                       │                   │
│                                            ▼                   │
│                               ┌──────────────────────┐        │
│                               │ Code Review System   │        │
│                               │ (Critique)           │        │
│                               └──────────┬───────────┘        │
│                                          │                    │
│                                          ▼                    │
│                               ┌──────────────────────┐        │
│         ┌─────────────────────│    Single Trunk      │        │
│         │                     │   (Google3 Repo)     │        │
│         │                     └──────────┬───────────┘        │
│         │                                │                    │
│         │                                ▼                    │
│         │                     ┌──────────────────────┐        │
│         │                     │  Post-submit Tests   │        │
│         │                     │  (TAP - Test         │        │
│         │                     │   Automation Platform)│        │
│         │                     └──────────┬───────────┘        │
│         │                                │                    │
│         │                                ▼                    │
│         │                     ┌──────────────────────┐        │
│         └─────── Rollback ────│  Global Deployment   │        │
│           (if issues found)   │  (Borg/Kubernetes)   │        │
│                               └──────────────────────┘        │
│                                                               │
│  특징:                                                        │
│  - 단일 모노레포 (수십억 줄의 코드)                          │
│  - 강력한 코드 검색 도구 (CodeSearch)                        │
│  - 자동화된 대규모 리팩토링 (Rosie)                          │
│  - 엄격한 pre-submit 테스트                                  │
│  - 즉각적인 롤백 메커니즘                                    │
│                                                               │
└─────────────────────────────────────────────────────────────────┘