refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게 [공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류. 문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인). - Topic_Programming → Domain_Programming (내부 구조 보존) - Topic_Graphic → Domain_Design - Topic_Business → Domain_Product - Topic_General → Domain_General - _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning), Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing) - 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서) - 빈 폴더 정리 (memory/procedures) - 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,177 @@
+---
+id: wiki-2026-0508-scalability
+title: Scalability
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [Scalability, 확장성, scale-out, scale-up]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [architecture, distributed-systems, performance]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: yaml
+  framework: kubernetes
+---
+
+# Scalability
+
+## 매 한 줄
+> **"매 부하가 늘 때 매 graceful하게 capacity를 키울 수 있는 능력"**. Scalability는 매 단일 dimension(traffic, data, compute)이 아니라 매 multi-axis property. 2026년에는 매 K8s HPA + KEDA, 매 serverless auto-scale, 매 LLM token-throughput scaling이 매 일상.
+
+## 매 핵심
+
+### 매 두 축
+- **Vertical (scale-up)**: 매 큰 머신 — 매 limit 빨리.
+- **Horizontal (scale-out)**: 매 더 많은 머신 — 매 stateless 필요.
+
+### 매 차원
+- **Load**: req/sec.
+- **Data**: GB → PB.
+- **Geographic**: 매 region.
+- **User**: 매 동시 user.
+- **Functional**: 매 feature 추가가 매 system을 깨지 않음.
+
+### 매 응용
+1. 매 web tier — auto-scale group.
+2. 매 DB — sharding / read replica.
+3. 매 LLM serving — vLLM tensor parallel + KV cache 분산.
+4. 매 event pipeline — Kafka partition scale.
+
+## 💻 패턴
+
+### 매 K8s HPA (CPU 기반)
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata: { name: api-hpa }
+spec:
+  scaleTargetRef: { apiVersion: apps/v1, kind: Deployment, name: api }
+  minReplicas: 3
+  maxReplicas: 50
+  metrics:
+    - type: Resource
+      resource:
+        name: cpu
+        target: { type: Utilization, averageUtilization: 70 }
+```
+
+### 매 KEDA (event-driven scale)
+```yaml
+apiVersion: keda.sh/v1alpha1
+kind: ScaledObject
+metadata: { name: kafka-consumer }
+spec:
+  scaleTargetRef: { name: consumer }
+  minReplicaCount: 0
+  maxReplicaCount: 100
+  triggers:
+    - type: kafka
+      metadata:
+        bootstrapServers: kafka:9092
+        consumerGroup: orders
+        topic: order-events
+        lagThreshold: "100"
+```
+
+### 매 Stateless service (scale-out 가능)
+```typescript
+// 매 session 매 외부화 (Redis)
+import express from "express";
+import session from "express-session";
+import RedisStore from "connect-redis";
+import { createClient } from "redis";
+
+const redis = createClient({ url: "redis://redis:6379" });
+await redis.connect();
+
+const app = express();
+app.use(session({
+  store: new RedisStore({ client: redis }),
+  secret: process.env.SESSION_SECRET!,
+  resave: false, saveUninitialized: false,
+}));
+// 매 어느 instance든 매 동일 session.
+```
+
+### 매 DB sharding (hash-based)
+```typescript
+function shardFor(userId: string): string {
+  const hash = crc32(userId);
+  return `db-shard-${hash % 8}`;
+}
+async function getUser(id: string) {
+  const shard = shardFor(id);
+  return pool[shard].query("SELECT * FROM users WHERE id=$1", [id]);
+}
+```
+
+### 매 Read replica
+```typescript
+const writeDb = postgres({ host: "primary" });
+const readDb = postgres({ host: "replica.read" });
+
+async function placeOrder(o: Order) { return writeDb`INSERT INTO orders ...`; }
+async function listOrders(uid: string) { return readDb`SELECT * FROM orders WHERE uid=${uid}`; }
+```
+
+### 매 LLM tensor-parallel (vLLM 0.7+)
+```bash
+vllm serve meta-llama/Llama-3.3-70B-Instruct \
+  --tensor-parallel-size 4 \
+  --gpu-memory-utilization 0.92 \
+  --max-num-seqs 256
+```
+
+### 매 Cache layer (scale read)
+```typescript
+async function getProduct(id: string) {
+  const cached = await redis.get(`p:${id}`);
+  if (cached) return JSON.parse(cached);
+  const p = await db.query("SELECT * FROM products WHERE id=$1", [id]);
+  await redis.setex(`p:${id}`, 60, JSON.stringify(p));
+  return p;
+}
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| 매 traffic spike (예측 가능) | HPA + capacity planning. |
+| 매 burst (predicate X) | Serverless / KEDA scale-to-zero. |
+| 매 data > single node | Sharding. |
+| 매 read >> write | Replica. |
+| 매 global users | Multi-region + edge cache. |
+| 매 LLM serving | vLLM TP + KV-cache routing. |
+
+**기본값**: 매 stateless service + HPA + Redis cache + read replica.
+
+## 🔗 Graph
+- 부모: [[Distributed Systems]]
+- 응용: [[Microservices]] · [[Serverless_Architecture]] · [[Service Mesh]]
+- Adjacent: [[CAP Theorem & PACELC]] · [[Sharding]] · [[Load Balancer]]
+
+## 🤖 LLM 활용
+**언제**: 매 capacity 설계, 매 bottleneck 진단, 매 cost-perf trade-off.
+**언제 X**: 매 단일 user 매 internal tool (매 over-engineering).
+
+## ❌ 안티패턴
+- **매 premature sharding**: 매 single PG로 매 충분한데 매 split.
+- **매 stateful pod scale-out**: 매 session 매 일부 instance 만.
+- **매 cache stampede 무시**: 매 expiry 동시에.
+- **매 N+1 query에서 scale-out 으로 도망**: 매 query 먼저 고칠 것.
+- **매 monolith 만 scale-up**: 매 vertical 한계.
+
+## 🧪 검증 / 중복
+- Verified (Designing Data-Intensive Applications, K8s docs, vLLM docs).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — HPA/KEDA/sharding/vLLM patterns |