Antigravity Agent
215 lines
7.3 KiB
Markdown
215 lines
7.3 KiB
Markdown
---
|
|
id: wiki-2026-0508-엔터프라이즈-애플리케이션-및-점진적-리팩토링
|
|
title: 엔터프라이즈 애플리케이션 및 점진적 리팩토링
|
|
category: 10_Wiki/Topics
|
|
status: verified
|
|
canonical_id: self
|
|
aliases: [Incremental Refactoring, Strangler Fig, Brownfield Refactor]
|
|
duplicate_of: none
|
|
source_trust_level: A
|
|
confidence_score: 0.9
|
|
verification_status: applied
|
|
tags: [refactoring, enterprise, legacy, strangler-fig]
|
|
raw_sources: []
|
|
last_reinforced: 2026-05-10
|
|
github_commit: pending
|
|
tech_stack:
|
|
language: typescript
|
|
framework: nestjs-nginx
|
|
---
|
|
|
|
# 엔터프라이즈 애플리케이션 및 점진적 리팩토링
|
|
|
|
## 매 한 줄
|
|
> **"매 big rewrite는 실패한다 — strangle 하라"**. 수년간 누적된 enterprise codebase는 한 번에 다시 쓸 수 없다. Martin Fowler의 *Strangler Fig*, *branch by abstraction*, *parallel run* 같은 점진 패턴으로 운영 중인 시스템 옆에 새 모듈을 자라게 하고, 기존을 천천히 제거.
|
|
|
|
## 매 핵심
|
|
|
|
### 매 점진적 vs Big Bang
|
|
- **Big bang rewrite**: 6-24개월 dark, 새 기능 동결, 비즈니스 중단. 80% 실패 (Joel Spolsky의 "things you should never do").
|
|
- **점진적**: 매 PR 단위 가치 전달, rollback 가능, business risk 최소.
|
|
|
|
### 매 4 핵심 패턴
|
|
- **Strangler Fig**: 기존 시스템 앞에 facade(예: API gateway, reverse proxy), traffic을 점차 새 구현으로 routing.
|
|
- **Branch by Abstraction**: 코드 내부 abstraction 추가 → 두 구현 병존 → old 제거.
|
|
- **Parallel Run**: 신·구 동시 실행, 결과 비교, 차이 발견 시 alert. 신뢰 확보 후 cutover.
|
|
- **Anti-Corruption Layer (DDD)**: legacy 모델이 새 도메인을 오염하지 않도록 translator layer.
|
|
|
|
### 매 응용
|
|
1. **Monolith → Microservice**: route 별 strangler.
|
|
2. **DB migration**: dual write + parallel read + cutover.
|
|
3. **Framework upgrade** (e.g., Angular 1→latest): branch by abstraction per route.
|
|
4. **Algorithm replacement** (legacy pricing → ML pricing): parallel run.
|
|
|
|
## 💻 패턴
|
|
|
|
### Strangler Fig — Nginx routing
|
|
```nginx
|
|
# 1단계: 100% legacy
|
|
location /api/orders { proxy_pass http://legacy-monolith; }
|
|
|
|
# 2단계: new endpoint만 신규로
|
|
location /api/orders/v2 { proxy_pass http://order-service; }
|
|
|
|
# 3단계: feature flag로 점진 cutover
|
|
location /api/orders {
|
|
set $backend "legacy-monolith";
|
|
if ($cookie_canary = "v2") { set $backend "order-service"; }
|
|
proxy_pass http://$backend;
|
|
}
|
|
|
|
# 4단계: 100% 신규 → legacy 제거
|
|
location /api/orders { proxy_pass http://order-service; }
|
|
```
|
|
|
|
### Branch by Abstraction (코드 내부)
|
|
```typescript
|
|
// 1단계: 추상화 추출
|
|
export interface PricingEngine {
|
|
price(cart: Cart): Promise<Money>;
|
|
}
|
|
|
|
// 2단계: 기존 구현을 interface 뒤로
|
|
export class LegacyPricing implements PricingEngine {
|
|
async price(cart: Cart) { /* 10년 묵은 코드 */ }
|
|
}
|
|
|
|
// 3단계: 신규 구현 추가, feature flag로 선택
|
|
export class NewPricing implements PricingEngine {
|
|
async price(cart: Cart) { /* 새 도메인 모델 */ }
|
|
}
|
|
|
|
@Injectable()
|
|
export class PricingFactory {
|
|
constructor(private readonly flags: FeatureFlags) {}
|
|
get(userId: string): PricingEngine {
|
|
return this.flags.isOn('new-pricing', userId)
|
|
? new NewPricing()
|
|
: new LegacyPricing();
|
|
}
|
|
}
|
|
```
|
|
|
|
### Parallel Run + diff alarm
|
|
```typescript
|
|
@Injectable()
|
|
export class PricingShadow implements PricingEngine {
|
|
constructor(
|
|
private readonly legacy: LegacyPricing,
|
|
private readonly fresh: NewPricing,
|
|
private readonly metrics: Metrics,
|
|
) {}
|
|
|
|
async price(cart: Cart): Promise<Money> {
|
|
const [oldP, newP] = await Promise.allSettled([
|
|
this.legacy.price(cart),
|
|
this.fresh.price(cart),
|
|
]);
|
|
|
|
if (oldP.status === 'fulfilled' && newP.status === 'fulfilled'
|
|
&& !oldP.value.equals(newP.value)) {
|
|
this.metrics.inc('pricing.diff', { sku: cart.skus.join(',') });
|
|
log.warn({ legacy: oldP.value, fresh: newP.value }, 'pricing diff');
|
|
}
|
|
|
|
return oldP.status === 'fulfilled' ? oldP.value : (newP as any).value;
|
|
}
|
|
}
|
|
```
|
|
|
|
### DB migration: dual write + verify + cutover
|
|
```typescript
|
|
// Phase A: dual write (legacy = source of truth)
|
|
async function saveOrder(o: Order) {
|
|
await legacyDb.orders.insert(toLegacy(o));
|
|
try { await newDb.orders.insert(toNew(o)); }
|
|
catch (e) { metrics.inc('dual-write.new.fail'); /* not fatal yet */ }
|
|
}
|
|
|
|
// Phase B: read from new + verify against legacy (shadow read)
|
|
async function getOrder(id: string): Promise<Order> {
|
|
const [legacy, fresh] = await Promise.all([
|
|
legacyDb.orders.find(id), newDb.orders.find(id),
|
|
]);
|
|
if (legacy && fresh && !equal(legacy, fresh)) {
|
|
metrics.inc('dual-read.diff');
|
|
}
|
|
return fromLegacy(legacy); // 아직 legacy가 truth
|
|
}
|
|
|
|
// Phase C: cutover — new = source of truth, legacy = read shadow
|
|
// Phase D: legacy stop
|
|
```
|
|
|
|
### Anti-Corruption Layer
|
|
```typescript
|
|
// legacy/order-record.ts — 외부 모델 (변경 불가)
|
|
interface LegacyOrderRecord {
|
|
ord_id: string;
|
|
cust_no: number;
|
|
itm_lst: string; // pipe-delimited!
|
|
amt_krw: number;
|
|
}
|
|
|
|
// domain/order.ts — 새 도메인 모델
|
|
export class Order { /* clean */ }
|
|
|
|
// acl/order-acl.ts — translator
|
|
export function fromLegacy(r: LegacyOrderRecord): Order {
|
|
return new Order({
|
|
id: r.ord_id,
|
|
customerId: `legacy-${r.cust_no}`,
|
|
items: r.itm_lst.split('|').map(parseItem),
|
|
total: Money.krw(r.amt_krw),
|
|
});
|
|
}
|
|
```
|
|
|
|
### Test characterization (Working Effectively with Legacy Code)
|
|
```typescript
|
|
// Refactor 전: 기존 동작을 test로 pin
|
|
test('legacy pricing — golden', async () => {
|
|
for (const fixture of loadFixtures('pricing/*.json')) {
|
|
expect(await legacy.price(fixture.cart)).toEqual(fixture.expected);
|
|
}
|
|
});
|
|
// 이후 refactor가 동작을 깨면 즉시 감지
|
|
```
|
|
|
|
## 매 결정 기준
|
|
| 상황 | Approach |
|
|
|---|---|
|
|
| 모놀리스 → 서비스 분리 | Strangler Fig (proxy level) |
|
|
| 동일 process 내부 모듈 교체 | Branch by Abstraction |
|
|
| 위험한 알고리즘 교체 | Parallel Run |
|
|
| Legacy 모델 격리 | Anti-Corruption Layer |
|
|
| DB 교체 | Dual write → shadow read → cutover |
|
|
|
|
**기본값**: 매 refactor는 매 PR 단위 deploy 가능해야 함 — 며칠 이상 머지 안 되는 long-lived branch 금지.
|
|
|
|
## 🔗 Graph
|
|
- 부모: [[Refactoring]] · [[Legacy Code]]
|
|
- 변형: [[Strangler Fig]] · [[Branch by Abstraction]] · [[Parallel Run]]
|
|
- 응용: [[Monolith to Microservices]] · [[Database Migration]]
|
|
- Adjacent: [[Feature Flags]] · [[Anti-Corruption Layer]] · [[Domain-Driven Design]]
|
|
|
|
## 🤖 LLM 활용
|
|
**언제**: 대규모 legacy 시스템 refactor 계획, 마이그레이션 step decomposition.
|
|
**언제 X**: 파일 < 1000줄, 작은 internal tool — 그냥 다시 쓰는 게 빠름.
|
|
|
|
## ❌ 안티패턴
|
|
- **Big bang rewrite**: 동결 기간 동안 비즈니스 정체 + cutover 시 폭발.
|
|
- **Long-lived feature branch**: refactor 가지가 main에서 분기되어 영원히 conflict.
|
|
- **Test 없이 refactor**: 회귀 감지 불가 → 결국 rollback.
|
|
- **Strangler 도중 멈춤**: 신·구 system 영구 공존 → 복잡도 2배.
|
|
|
|
## 🧪 검증 / 중복
|
|
- Verified (Martin Fowler, "StranglerFigApplication"; Michael Feathers, *Working Effectively with Legacy Code*, 2004).
|
|
- 신뢰도 A.
|
|
|
|
## 🕓 Changelog
|
|
| 날짜 | 변경 |
|
|
|---|---|
|
|
| 2026-05-08 | Phase 1 |
|
|
| 2026-05-10 | Manual cleanup — strangler·BBA·parallel run·ACL 패턴 |
|