Phase 3: 프로토콜

6.1 프로토콜 개요

Phase 3는 시스템 간 실시간 통신을 위한 프로토콜을 정의합니다. 메시지 형식, 전송 메커니즘, 인증, 그리고 신뢰성 보장 방법이 포함됩니다.

6.2 메시지 형식

6.2.1 표준 메시지 구조

{
  "version": "1.0",
  "type": "wia-art-001",
  "messageId": "msg_xK9mN3pQr5tV7wY",
  "timestamp": "2025-01-15T10:30:00.123Z",
  "payload": {
    // 메시지별 내용
  },
  "signature": "sha256:abc123...",
  "metadata": {
    "sender": "client_id",
    "correlationId": "correlation_id",
    "priority": "normal",
    "ttl": 300
  }
}

6.2.2 메시지 필드

6.2.3 메시지 타입

// 요청/응답 타입
artwork.create.request
artwork.create.response
artwork.read.request
artwork.read.response

// 이벤트 타입
event.artwork.created
event.artwork.updated
event.artwork.deleted

// 시스템 타입
system.heartbeat
system.ping
system.pong
system.ack
system.error

6.3 전송 메커니즘

6.3.1 HTTPS/REST

// 동기식 요청/응답
POST /api/v1/messages HTTP/1.1
Host: api.wia.org
Content-Type: application/json
Authorization: Bearer <token>

{
  "version": "1.0",
  "type": "artwork.create.request",
  ...
}

6.3.2 WebSocket

// 연결 설정
const ws = new WebSocket('wss://api.wia.org/art-001/v1/stream');

// 인증
ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'system.auth',
    payload: {
      token: 'Bearer wia_art_sk_...',
      subscriptions: ['artwork.*', 'event.*']
    }
  }));
};

// 메시지 수신
ws.onmessage = (event) => {
  const message = JSON.parse(event.data);
  
  switch (message.type) {
    case 'event.artwork.created':
      handleArtworkCreated(message.payload);
      break;
    case 'system.heartbeat':
      // 연결 유지
      break;
  }
};

// 메시지 전송
ws.send(JSON.stringify({
  type: 'artwork.create.request',
  messageId: generateId(),
  timestamp: new Date().toISOString(),
  payload: { ... }
}));

6.3.3 Server-Sent Events (SSE)

// 단방향 이벤트 스트리밍
const eventSource = new EventSource(
  'https://api.wia.org/art-001/v1/events?token=...'
);

eventSource.addEventListener('artwork.created', (event) => {
  const data = JSON.parse(event.data);
  console.log('새 작품:', data.artworkId);
});

eventSource.addEventListener('artwork.updated', (event) => {
  const data = JSON.parse(event.data);
  console.log('작품 수정:', data.artworkId);
});

6.4 신뢰성 보장

6.4.1 메시지 확인 (Acknowledgment)

// 클라이언트 → 서버
{
  "type": "artwork.create.request",
  "messageId": "msg_123",
  "requiresAck": true,
  ...
}

// 서버 → 클라이언트 (수신 확인)
{
  "type": "system.ack",
  "payload": {
    "messageId": "msg_123",
    "status": "received",
    "timestamp": "2025-01-15T10:30:00.050Z"
  }
}

6.4.2 재시도 전략

class RetryStrategy {
  constructor(config = {}) {
    this.maxRetries = config.maxRetries || 3;
    this.baseDelay = config.baseDelay || 1000;
    this.maxDelay = config.maxDelay || 30000;
  }
  
  async execute(operation) {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        return await operation();
      } catch (error) {
        if (!this.isRetryable(error)) throw error;
        
        const delay = Math.min(
          this.baseDelay * Math.pow(2, attempt),
          this.maxDelay
        );
        
        console.log(`재시도 ${attempt + 1}/${this.maxRetries}, ${delay}ms 후`);
        await this.sleep(delay);
      }
    }
  }
  
  isRetryable(error) {
    return [408, 429, 500, 502, 503, 504].includes(error.status);
  }
}

6.4.3 멱등성 (Idempotency)

{
  "type": "artwork.create.request",
  "messageId": "msg_123",
  "idempotencyKey": "create_user123_artwork42_20250115",
  "payload": { ... }
}

// 서버 동작:
// 1. 첫 요청: 처리 후 결과 저장
// 2. 재시도: 저장된 결과 반환 (재처리 안 함)
// 3. 키 만료: 24시간 후

6.5 스트리밍 프로토콜

6.5.1 청크 업로드

// 1단계: 업로드 초기화
{
  "type": "upload.init.request",
  "payload": {
    "filename": "artwork.tiff",
    "size": 157286400,
    "chunkSize": 5242880,
    "checksum": "sha256:abc123..."
  }
}

// 2단계: 업로드 세션 수신
{
  "type": "upload.init.response",
  "payload": {
    "uploadId": "up_xyz789",
    "totalChunks": 30,
    "chunkSize": 5242880,
    "uploadUrls": [...],
    "expiresAt": "2025-01-15T14:30:00Z"
  }
}

// 3단계: 청크 업로드 (병렬 가능)
PUT /up_xyz789/chunk/0
Content-Type: application/octet-stream
X-Chunk-Checksum: sha256:chunk0hash

// 4단계: 업로드 완료
{
  "type": "upload.complete.request",
  "payload": {
    "uploadId": "up_xyz789",
    "chunks": [
      { "index": 0, "checksum": "sha256:..." },
      { "index": 1, "checksum": "sha256:..." }
    ]
  }
}

6.5.2 실시간 이벤트 구독

// 구독 요청
{
  "type": "stream.subscribe.request",
  "payload": {
    "topics": [
      "artwork.created",
      "artwork.updated"
    ],
    "filters": {
      "creator": "artist_uuid"
    }
  }
}

// 이벤트 수신
{
  "type": "stream.event",
  "payload": {
    "topic": "artwork.created",
    "data": {
      "artworkId": "art_new123",
      "title": "새 작품"
    }
  }
}

6.6 보안

6.6.1 전송 보안

• TLS 1.3 필수
• 인증서 고정 권장 (모바일)
• HSTS 헤더 사용
• 완전 순방향 비밀성 (PFS) 암호 스위트

6.6.2 메시지 서명

// 서명 생성
const signaturePayload = JSON.stringify({
  messageId: message.messageId,
  timestamp: message.timestamp,
  type: message.type,
  payload: message.payload
});

const signature = crypto
  .createHmac('sha256', apiSecret)
  .update(signaturePayload)
  .digest('hex');

message.signature = `sha256:${signature}`;

// 서명 검증
function verifySignature(message, apiSecret) {
  const [algorithm, hash] = message.signature.split(':');
  
  const calculated = crypto
    .createHmac(algorithm, apiSecret)
    .update(signaturePayload)
    .digest('hex');
  
  return crypto.timingSafeEqual(
    Buffer.from(hash),
    Buffer.from(calculated)
  );
}

6.6.3 재생 공격 방지

// 타임스탬프 검증 (5분 오차 허용)
const MAX_CLOCK_SKEW = 300;

function validateTimestamp(timestamp) {
  const messageTime = new Date(timestamp).getTime();
  const currentTime = Date.now();
  const difference = Math.abs(currentTime - messageTime);
  
  if (difference > MAX_CLOCK_SKEW * 1000) {
    throw new Error('요청 타임스탬프가 유효하지 않습니다');
  }
}

한국 사례 및 실무 적용

한국 디지털 아트 산업에서 WIA-ART-001 표준이 어떻게 적용되고 있는지 실제 사례를 통해 살펴봅니다.

글로벌 시장 진출 사례

WIA 표준을 활용한 한국 디지털 아티스트의 해외 진출이 증가하고 있습니다:

• 북미 시장: WIA 호환 포트폴리오로 Artstation, Behance에서 채용 기회 3배 증가
• 일본 시장: 메타데이터 다국어 지원으로 Pixiv, NicoNico 진출 용이
• 유럽 시장: GDPR 준수 메타데이터로 EU 플랫폼 접근성 향상
• 동남아 시장: 표준화된 라이선스 정보로 저작권 보호 강화

실무 구현 가이드

프로덕션 환경에서 이 기능을 안전하고 효율적으로 구현하기 위한 실무 지침입니다.

성능 최적화 전략

대용량 파일 처리

// TypeScript 예제: 청크 업로드로 대용량 파일 처리
async function uploadLargeArtwork(file: File) {
  const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB chunks
  const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
  
  for (let i = 0; i < totalChunks; i++) {
    const start = i * CHUNK_SIZE;
    const end = Math.min(start + CHUNK_SIZE, file.size);
    const chunk = file.slice(start, end);
    
    await uploadChunk(chunk, i, totalChunks);
  }
  
  // 모든 청크 업로드 후 병합 요청
  await finalizeUpload(file.name);
}

캐싱 전략

// Redis를 활용한 메타데이터 캐싱
const cacheKey = `artwork:${artworkId}:metadata`;
const ttl = 3600; // 1시간

// 캐시에서 먼저 조회
let metadata = await redis.get(cacheKey);

if (!metadata) {
  // 캐시 미스 시 DB에서 조회
  metadata = await db.getArtworkMetadata(artworkId);
  
  // 캐시에 저장
  await redis.setex(cacheKey, ttl, JSON.stringify(metadata));
}

return JSON.parse(metadata);

보안 강화 방안

파일 검증 프로세스

// 안전한 파일 업로드 검증
function validateUpload(file: File, metadata: ArtworkMetadata): ValidationResult {
  const checks = [
    // 1. MIME 타입 검증
    validateMimeType(file.type, metadata.format),
    
    // 2. 파일 크기 제한
    validateFileSize(file.size, MAX_FILE_SIZE),
    
    // 3. 파일 내용 검사 (매직 넘버)
    validateFileContent(file),
    
    // 4. 바이러스 스캔
    await scanForVirus(file),
    
    // 5. 메타데이터 스키마 검증
    validateSchema(metadata, WIA_ART_SCHEMA)
  ];
  
  return {
    valid: checks.every(c => c.passed),
    errors: checks.filter(c => !c.passed).map(c => c.error)
  };
}

에러 처리 및 복구

프로덕션 환경에서 발생할 수 있는 다양한 오류 상황에 대한 처리 전략:

고급 주제 및 최신 트렌드

AI 생성 아트 지원

AI 도구로 생성된 작품을 위한 특별한 메타데이터 필드:

{
  "aiGeneration": {
    "model": "Stable Diffusion XL",
    "version": "1.0",
    "prompt": "a serene Korean landscape in the style of traditional ink painting",
    "negativePrompt": "modern buildings, cars, people",
    "seed": 42,
    "steps": 50,
    "cfg_scale": 7.5,
    "sampler": "DPM++ 2M Karras",
    "humanContribution": {
      "promptDesign": 100,
      "postProcessing": 80,
      "selection": 100
    },
    "trainingDataConsent": true,
    "ethicalConsiderations": "No copyrighted content used in training"
  }
}

블록체인 통합

NFT 및 분산 저장소와의 통합 예제:

// WIA-BLOCKCHAIN 표준과 연동
async function mintAsNFT(artwork: Artwork) {
  // 1. IPFS에 작품 업로드
  const ipfsHash = await ipfs.add(artwork.content.primary);
  
  // 2. WIA 메타데이터를 NFT 메타데이터로 변환
  const nftMetadata = {
    name: artwork.metadata.title,
    description: artwork.metadata.description,
    image: `ipfs://${ipfsHash}`,
    attributes: [
      { trait_type: "Artist", value: artwork.metadata.creator.name },
      { trait_type: "Creation Date", value: artwork.metadata.creationDate },
      { trait_type: "Medium", value: artwork.metadata.medium }
    ],
    wia_standard: "WIA-ART-001",
    wia_version: "1.0",
    wia_artwork_id: artwork.id
  };
  
  // 3. 스마트 계약으로 NFT 발행
  const nft = await contract.mint(metadata, { value: mintingFee });
  
  // 4. 출처 정보에 NFT 정보 추가
  await updateProvenance(artwork.id, {
    type: "nft_minting",
    blockchain: "Ethereum",
    contract: contract.address,
    tokenId: nft.tokenId,
    ipfsHash: ipfsHash
  });
}

웹3 통합 및 분산 저장

중앙화된 서버 없이 작품을 분산 저장하고 관리하는 방법:

• IPFS: 작품 원본을 불변 저장소에 보관
• Filecoin: 장기 보존을 위한 유료 스토리지
• Arweave: 영구 저장을 위한 블록위브 기술
• Ceramic Network: 분산 메타데이터 관리

6.7 장 요약

복습 문제

1. 표준 메시지의 필수 필드 5가지는?
2. WebSocket과 SSE의 차이점을 설명하세요.
3. 멱등성 키의 역할은 무엇인가요?
4. 재생 공격을 어떻게 방지하나요?