[태그:] Error Handling

목차

• Introduction: AI 워크플로에서의 비동기 처리의 중요성
• 1. Async Request Pattern의 핵심 개념 및 아키텍처
• 2. 실제 구현: Request Handler와 Worker Pool 설계
• 3. 복원력 있는 시스템: Resilience Patterns의 적용
• 4. 모니터링과 관찰성: Production 환경에서의 실전 전략
• 결론: 신뢰도 높은 AI 워크플로 구축하기

Introduction: AI 워크플로에서의 비동기 처리의 중요성

AI 워크플로 설계에서 가장 중요한 과제 중 하나는 불확실성과 지연시간(Latency)을 효과적으로 관리하는 것입니다. 특히 LLM 기반의 에이전트 시스템에서는 단일 요청의 처리 시간이 몇 초에서 수십 초에 이를 수 있고, 외부 API 호출이나 데이터베이스 작업도 예측 불가능한 지연을 발생시킵니다.

전통적인 동기식 요청-응답 패턴(Synchronous Request-Response Pattern)은 이러한 환경에서 심각한 병목 현상을 초래합니다. 예를 들어, 한 번에 100개의 요청을 처리해야 하는 상황에서 동기식으로 처리하면 첫 번째 요청부터 마지막 요청까지의 총 처리 시간은 선형적으로 증가하게 됩니다. 이는 사용자 경험의 악화, 시스템 리소스의 낭비, 그리고 장애에 대한 취약성으로 이어집니다.

따라서 Asynchronous Request Pattern(비동기 요청 패턴)은 현대 AI 워크플로에서 선택이 아닌 필수입니다. 이 패턴을 올바르게 구현하면 처리 능력(Throughput)을 극대화하고, 시스템의 복원력(Resilience)을 강화하며, 장애 상황에서도 우아하게 성능을 저하시킬 수 있습니다.

1. Async Request Pattern의 핵심 개념 및 아키텍처

1.1 기본 원리: Decoupling through Message Queue

비동기 요청 패턴의 핵심은 요청 제출과 결과 수신을 시간적으로 분리하는 것입니다. 이를 위해 메시지 큐(Message Queue)를 중앙에 배치하여 요청자(Requester)와 처리자(Worker) 간의 느슨한 결합(Loose Coupling)을 달성합니다.

구체적인 흐름은 다음과 같습니다:

1. Request Handler: 클라이언트로부터 요청을 수신하고, 입력값을 검증한 후, 메시지 큐에 메시지를 쌓습니다. 즉시 클라이언트에게 Promise 또는 요청 ID를 반환합니다.
2. Message Queue: 분산 메시지 큐(예: Redis, RabbitMQ, AWS SQS)를 통해 요청을 임시 저장합니다. 이는 피크 트래픽을 흡수하고, 워커가 처리할 준비가 될 때까지 요청을 버퍼링합니다.
3. Worker Pool: 메시지 큐에서 요청을 하나씩 꺼내(Dequeue) 처리합니다. 워커의 개수는 동적으로 조절될 수 있으며, 처리 실패 시 Retry 로직이 적용됩니다.
4. Result Store: 처리된 결과를 캐시 또는 데이터베이스에 저장합니다. 클라이언트는 요청 ID를 이용해 결과를 나중에 조회할 수 있습니다.

1.2 Request Handler의 설계 원칙

Request Handler는 빠르고 가벼워야 합니다. 이 계층에서는 다음과 같은 작업만 수행해야 합니다:

• 입력 검증(Input Validation): 필수 필드, 데이터 타입, 범위 등을 확인합니다. 유효하지 않은 요청은 즉시 거절해야 합니다.
• 인증(Authentication): API 키, JWT 토큰 등을 검증하여 권한이 있는 요청인지 확인합니다.
• 메시지 큐 전송: 검증을 통과한 요청을 메시지 큐에 put합니다. 이 작업은 일반적으로 매우 빠릅니다(밀리초 단위).
• Promise 반환: 클라이언트에게 요청 ID와 함께 202 Accepted 응답을 반환합니다.

Handler 계층에서 무거운 작업(예: LLM 호출, 데이터 변환)을 수행하면 안 됩니다. 이러한 작업은 모두 Worker에게 위임해야 합니다.

1.3 Queue 선택 기준

메시지 큐 선택은 워크플로 요구사항에 따라 달라집니다:

2. 실제 구현: Request Handler와 Worker Pool 설계

2.1 Request Handler 구현 예제

다음은 Python 기반의 간단한 Request Handler 구현입니다:

from fastapi import FastAPI, HTTPException
from datetime import datetime
import uuid
import redis

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.post("/api/process")
async def submit_request(payload: dict):
    # 1단계: 입력 검증
    if not payload.get("text"):
        raise HTTPException(status_code=400, detail="'text' field required")

    if len(payload["text"]) > 50000:
        raise HTTPException(status_code=400, detail="Text too long")

    # 2단계: 요청 ID 생성
    request_id = str(uuid.uuid4())

    # 3단계: 메시지 큐에 전송
    message = {
        "request_id": request_id,
        "payload": payload,
        "timestamp": datetime.utcnow().isoformat(),
        "retry_count": 0
    }

    redis_client.rpush("processing_queue", json.dumps(message))

    # 4단계: 202 응답 반환
    return {
        "status": "accepted",
        "request_id": request_id,
        "status_url": f"/api/status/{request_id}"
    }

@app.get("/api/status/{request_id}")
async def get_status(request_id: str):
    # 결과 저장소에서 조회
    result = redis_client.get(f"result:{request_id}")

    if result is None:
        return {"status": "processing", "request_id": request_id}

    return {
        "status": "completed",
        "request_id": request_id,
        "result": json.loads(result)
    }

2.2 Worker Pool 구현 패턴

Worker는 메시지 큐에서 계속해서 새로운 작업을 꺼내 처리합니다. 중요한 설계 원칙은 다음과 같습니다:

• Poll 기반 처리: Worker는 주기적으로 메시지 큐를 폴링(Polling)하여 새로운 작업을 확인합니다.
• Idempotency 보장: 같은 요청이 중복으로 처리되어도 결과가 같아야 합니다(멱등성).
• 타임아웃 관리: 처리 중인 작업이 너무 오래 걸리면 자동으로 중단하고 재시도합니다.
• Dead Letter Queue: 최대 재시도 횟수를 초과한 작업은 별도의 DLQ로 이동하여 나중에 검토합니다.

구체적인 Worker 구현은 다음과 같습니다:

import asyncio
from typing import Optional

class AIWorkflowWorker:
    def __init__(self, queue_client, result_store, max_retries=5):
        self.queue_client = queue_client
        self.result_store = result_store
        self.max_retries = max_retries

    async def process_queue(self):
        while True:
            try:
                # Step 1: Dequeue message
                message = self.queue_client.lpop("processing_queue", timeout=5)

                if message is None:
                    await asyncio.sleep(1)  # Queue empty, wait
                    continue

                request = json.loads(message)
                request_id = request["request_id"]

                # Step 2: Process with timeout
                try:
                    result = await asyncio.wait_for(
                        self.process_ai_task(request),
                        timeout=60  # 60초 타임아웃
                    )

                    # Step 3: Store result
                    self.result_store.set(
                        f"result:{request_id}",
                        json.dumps(result),
                        ex=3600  # 1시간 TTL
                    )

                except asyncio.TimeoutError:
                    # Timeout 발생 시 재시도
                    self.retry_request(request)

            except Exception as e:
                logger.error(f"Worker error: {str(e)}")
                await asyncio.sleep(5)

    async def process_ai_task(self, request):
        # 실제 AI 처리 로직
        text = request["payload"]["text"]

        # LLM API 호출 (예시)
        response = await call_llm(text)

        return {
            "request_id": request["request_id"],
            "result": response,
            "processed_at": datetime.utcnow().isoformat()
        }

    def retry_request(self, request):
        retry_count = request.get("retry_count", 0)

        if retry_count >= self.max_retries:
            # Dead Letter Queue로 이동
            self.queue_client.rpush("dlq", json.dumps(request))
        else:
            # 지수 백오프(Exponential Backoff)를 이용한 재시도
            delay = 2 ** retry_count  # 1s, 2s, 4s, 8s, 16s
            request["retry_count"] = retry_count + 1

            # 지연 후 다시 큐에 추가
            self.queue_client.rpush("processing_queue", json.dumps(request))

3. 복원력 있는 시스템: Resilience Patterns의 적용

3.1 Retry Strategy: 지수 백오프(Exponential Backoff)

일시적 오류(Transient Failure)를 처리하는 가장 기본적인 방법은 재시도(Retry)입니다. 다만, 즉시 재시도하면 원인을 해결할 시간이 없으므로 재시도 사이에 대기 시간을 두어야 합니다. 이것이 Exponential Backoff 패턴입니다.

• 초기 대기 시간: 보통 100ms ~ 1s 사이
• 재시도 횟수: 보통 3 ~ 5회
• 백오프 배수(Multiplier): 보통 2.0 (각 재시도마다 대기 시간을 2배로)
• 최대 대기 시간(Max Backoff): 예를 들어 32초 이상으로 증가하지 않도록 제한

지수 백오프 공식: delay = min(initial_delay * (multiplier ^ attempt), max_delay)

예시:

• 1차 재시도: 100ms 대기 후 시도
• 2차 재시도: 200ms 대기 후 시도
• 3차 재시도: 400ms 대기 후 시도
• 4차 재시도: 800ms 대기 후 시도
• 5차 재시도: 1,600ms 대기 후 시도

또한 동시에 여러 클라이언트가 같은 시간에 재시도하는 ‘Thundering Herd’ 문제를 피하기 위해 재시도 시간에 작은 랜덤 값을 더합니다(Jitter):

import random
import time

def retry_with_backoff(func, max_retries=5, initial_delay=0.1):
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt == max_retries - 1:
                raise

            delay = initial_delay * (2 ** attempt)
            jitter = random.uniform(0, delay * 0.1)
            time.sleep(delay + jitter)

3.2 Circuit Breaker: 장애 격리

재시도만으로는 부족합니다. 예를 들어, 외부 API가 완전히 다운된 상황에서 계속 재시도하면 그냥 시간과 리소스만 낭비합니다. 이런 상황에서는 더 이상 시도하지 않고, 대신 사용자에게 빠르게 실패를 알려야 합니다.

Circuit Breaker 패턴은 이를 구현합니다. 전기 회로 차단기처럼 작동하며 3가지 상태를 가집니다:

1. CLOSED: 정상 상태. 모든 요청이 통과합니다.
2. OPEN: 오류가 임계값을 초과했을 때. 요청을 즉시 거절합니다(Fail Fast).
3. HALF-OPEN: 복구 대기 상태. 일부 요청을 통과시켜 서비스가 복구되었는지 확인합니다.

3.3 Fallback & Graceful Degradation

모든 장애를 완벽하게 해결할 수는 없습니다. 따라서 우아하게 실패하는(Gracefully Fail) 전략이 필요합니다. Fallback 패턴은 주요 처리 경로가 실패했을 때 대체 경로를 제공합니다:

1. Primary Service: 가장 선호하는 처리 방법. 예: 최신 AI 모델 호출
2. Cached Results: 이전에 처리한 결과를 재사용. 예: Redis 캐시
3. Default Response: 기본값 또는 간단한 응답. 예: 템플릿 기반 응답

이렇게 계층적 Fallback을 구현하면, Primary 서비스가 실패해도 사용자에게 최소한의 응답을 제공할 수 있습니다.

4. 모니터링과 관찰성: Production 환경에서의 실전 전략

4.1 핵심 메트릭(Key Metrics)

Async 워크플로의 건강도를 평가하려면 다음 메트릭들을 모니터링해야 합니다:

• Queue Depth: 현재 처리 대기 중인 요청의 개수. 너무 커지면 시스템이 과부하 상태입니다.
• Worker Utilization: 워커의 평균 활용도. 너무 낮으면 리소스 낭비, 너무 높으면 병목입니다.
• Error Rate: 시간대별 오류 비율. 유형별(timeout, rate-limit, application error)로 분류해야 합니다.
• Latency Percentiles: P50(중간값), P95(95%), P99(99%)를 추적하여 사용자 경험을 평가합니다.
• Retry Count Distribution: 몇 번째 시도에서 성공했는지 파악하여 재시도 정책을 최적화합니다.
• Dead Letter Queue Size: 처리 불가능한 메시지의 누적. 빠르게 증가하면 심각한 문제입니다.
• Circuit Breaker State: 각 외부 의존성의 CB 상태 전이(transition)를 추적합니다.
• Cache Hit Ratio: Fallback 전략의 효율성을 평가합니다.

4.2 분산 추적(Distributed Tracing)

비동기 시스템에서는 단일 요청이 여러 컴포넌트를 거치므로, 전체 흐름을 추적하기가 어렵습니다. 이때 Distributed Tracing이 필수입니다.

각 요청은 Trace ID를 부여받고, 이 ID를 따라가면서 각 단계에서의 시간 소비를 기록합니다. 이를 통해:

• 병목 지점을 정확히 파악할 수 있습니다.
• 특정 외부 API 호출이 느린지, 아니면 처리 로직이 느린지 구분할 수 있습니다.
• 특정 사용자 또는 요청의 전체 여정을 재구성할 수 있습니다.

인기 있는 Distributed Tracing 솔루션:

• Jaeger: 오픈소스, CNCF 프로젝트
• Zipkin: 오픈소스, Twitter가 개발
• AWS X-Ray: AWS 완전 관리형
• Datadog APM: 상용 서비스, 높은 통합성

4.3 알림과 SLA

메트릭을 수집했다고 해서 충분하지 않습니다. 문제가 발생했을 때 신속하게 알려야 합니다:

• Queue Depth > 임계값: 자동으로 워커를 추가하고, 엔지니어에게 알립니다.
• Error Rate > 5%: 심각도에 따라 즉시 또는 15분 후 알립니다.
• P99 Latency > 30s: 사용자 경험이 악화되었으므로 즉시 조사합니다.
• Circuit Breaker OPEN: 외부 의존성 장애 상황이므로 팀에 공유합니다.
• DLQ Size > 임계값: 처리 불가능한 요청이 쌓이고 있으므로 긴급 대응합니다.

결론: 신뢰도 높은 AI 워크플로 구축하기

Async Request Pattern은 단순한 아키텍처 선택이 아닙니다. 이는 신뢰도(Reliability), 확장성(Scalability), 관찰성(Observability)을 동시에 달성하는 핵심 전략입니다.

이 글에서 다룬 내용을 정리하면:

1. 아키텍처 설계: Request Handler → Message Queue → Worker Pool → Result Store의 명확한 역할 분리
2. Resilience 패턴: Exponential Backoff, Circuit Breaker, Fallback을 조합하여 장애 상황 대응
3. 운영 전략: 메트릭 수집, 분산 추적, 자동 알림을 통해 Production 환경 안정화

AI 워크플로는 계속 복잡해지고 있습니다. 하지만 올바른 패턴과 도구를 사용한다면, 높은 신뢰도와 성능을 동시에 달성할 수 있습니다. 지금부터 Async Request Pattern을 도입하고, 단계적으로 resilience 메커니즘을 추가해 보세요.

Tags: Async Request Pattern,AI 워크플로,Resilience,Circuit Breaker,Message Queue,Error Handling,Exponential Backoff,Distributed Tracing,Monitoring,Production Engineering