· 동기/비동기는 결과를 받는 방식, 블로킹/논블로킹은 실행 흐름이 묶이는지를 묻는 서로 다른 축이다.
· FastAPI(uvicorn)와 Node.js는 모두 단일 스레드 이벤트 루프로, I/O를 기다리는 동안 다른 요청을 처리한다.
·
async def는 이벤트 루프에서, def는 스레드풀에서 실행된다. await 없는 동기 호출은 어디서 실행되느냐가 중요하다.· 비동기는 응답 시간이 아니라 동시 처리량을 늘리는 방식이다.
이 글은 Sleuth 백엔드를 이루는 FastAPI의 비동기 구조를 기술적으로 정리한 부록이다. Part 1에서 Python/FastAPI를 선택한 이유 중 하나로 비동기 I/O를 짧게 언급했지만, 설계 결정을 기록하는 글이라 그 구조 자체를 설명하지는 못했다. 여기서는 요청 하나가 서버 안에서 처리되는 과정을 출발점으로, 동기/비동기와 블로킹/논블로킹의 차이, 이벤트 루프, FastAPI의 실행 구조, 그리고 코드에 적용할 때 알아둘 점을 순서대로 풀어본다.
1. 요청 한 건은 서버 안에서 무얼할까
유저가 용의자에게 질문을 보내면 서버는 다음 순서로 요청을 처리한다.
| 단계 | 하는 일 | 성격 | 코드에서의 형태 |
|---|---|---|---|
| 1. 인증 | Firebase ID Token 검증 (캐시 미스 시 외부 RPC) | 네트워크 I/O | SDK가 동기 함수만 제공하므로 스레드풀로 위임 |
| 2. DTO 검증 | 입력 500자, 대화 이력 20턴 제한 | CPU, 수 ms | FastAPI와 Pydantic이 자동 처리 |
| 3. 프롬프트 조립 | 3단계 시스템 지시문 구성 | CPU, 수 ms | 일반 함수 |
| 4. LLM 호출 | Google GenAI SDK의 비동기 클라이언트(client.aio) 호출 | 네트워크 대기, 2~5초 | await |
| 5. 응답 변환 | 응답 DTO로 변환 후 반환 | CPU, 수 ms | 일반 함수 |
각 단계의 구현은 Part 1에서, LLM 호출을 Vertex AI로 옮기며 만난 분당 요청 제한 문제는 Part 3에서 다뤘다.
서버가 직접 계산하는 구간은 수 ms 단위이고, 전체 시간의 대부분은 4단계에서 외부 API의 응답을 기다리는 시간이다. 이 대기 동안 서버가 실제로 하는 일은 없다. 그래서 서버 구조에서 중요한 질문은 하나로 모인다.
이 대기 시간 동안, 서버의 일꾼(스레드)이 다른 요청을 처리할 수 있을까?
2. 동기/비동기와 블로킹/논블로킹
두 용어는 자주 섞여 쓰이지만 묻는 대상이 다르다.
- 동기/비동기: 작업의 결과를 어떻게 받는가. 호출한 쪽이 끝날 때까지 기다려서 받으면 동기, 나중에 통지(콜백,
await의 재개)로 받으면 비동기다. - 블로킹/논블로킹: 호출하는 동안 내 실행 흐름(스레드)이 묶이는가. 묶이면 블로킹, 바로 돌아오면 논블로킹이다.
| 블로킹 | 논블로킹 | |
|---|---|---|
| 동기 | 요청을 보내고 응답이 올 때까지 스레드가 멈춘다.requests.post(...), time.sleep(2) | 바로 돌아오지만 결과는 호출한 쪽이 계속 확인해야 한다. (폴링) |
| 비동기 | 비동기 함수의 모양을 하고 있지만 내부에서 스레드를 묶는다.async def 안의 time.sleep(2) | 요청만 걸어두고 다른 일을 하다가, 결과가 오면 이어서 한다.await httpx.AsyncClient().post(...) |
서버 개발에서 얻고 싶은 것은 오른쪽 아래 칸(비동기 + 논블로킹)이다. 다만 async def라는 키워드는 함수의 형태를 정할 뿐이고, 그 안의 호출이 논블로킹인지는 호출하는 함수가 await 가능한 비동기 함수인지에 달려 있다.
일꾼이 한 명인 주방에 비유하면 이해하기 쉽다. 요리사가 주문을 받아 오븐에 넣고 10분 동안 오븐 앞에 서 있으면 블로킹이고, 오븐에 넣어두고 다른 주문의 재료를 손질하다 타이머가 울리면 돌아오는 것이 논블로킹이다. 오븐(외부 API)이 일하는 동안 요리사(스레드)는 자유롭다.
(a)는 A의 응답이 올 때까지 B와 C가 시작도 못 한다. (b)는 A가 기다리는 동안 B와 C의 처리를 시작한다. 각 요청이 기다리는 2초 자체는 줄어들지 않는다. 달라지는 것은 일꾼 한 명이 동시에 감당하는 요청 수다.
3. 이벤트 루프의 구조
FastAPI가 올라가는 uvicorn은 Python의 asyncio 이벤트 루프를 사용하고, Node.js는 libuv 기반의 이벤트 루프를 사용한다. 이름만 다를 뿐 구조는 같다. 이벤트 루프는 스레드 하나가 계속 도는 반복문이고, 개념적으로는 아래와 같다.
# 이벤트 루프를 단순화한 가상의 코드
while True:
task = ready_queue.pop() # 지금 실행할 수 있는 작업을 꺼낸다
task.run_until_await() # await를 만날 때까지만 실행한다
# await를 만나면 task는 I/O 대기 목록으로 옮겨지고, 루프는 다음 작업으로 간다
핵심은 코루틴이 await에서 스스로 제어권을 돌려주는 협력적 구조라는 점이다. 이벤트 루프는 실행 중인 코드를 강제로 중단시키지 못한다. 코루틴이 await를 만나 양보해야 다른 코루틴이 실행된다.
| 개념 | Python (FastAPI) | Node.js |
|---|---|---|
| 이벤트 루프 | asyncio (uvicorn) | libuv |
| 비동기 함수 | async def + await | async function + await |
| 비동기 결과 객체 | Coroutine, Future | Promise |
| 대표적인 블로킹 호출 | time.sleep, requests.get | fs.readFileSync, execSync |
| 블로킹을 피하는 방법 | asyncio.to_thread, 스레드풀 | worker_threads, libuv 스레드풀 |
두 런타임은 같은 모델을 쓴다. Node.js로 결제 서버를, FastAPI로 LLM 서빙 서버를 구성했지만 I/O 대기를 다루는 방식은 동일하다. 둘의 차이는 비동기 모델이 아니라 언어와 생태계에 있다. 결제 서버에서 이 모델이 동시 요청을 어떻게 다루는지는 인앱결제 Part 1에, 같은 유저의 동시 요청 경합을 검증한 과정은 인앱결제 Part 3에 정리했다.
코드로 따라가기: 요청 A, B가 동시에 들어오면
LLM 호출 단계를 비동기 클라이언트로 작성한 핸들러를 기준으로 이벤트 루프의 움직임을 따라가 본다.
@app.post("/chat")
async def chat(req: ChatRequest):
prompt = build_prompt(req) # (1) CPU 작업, 수 ms
resp = await client.aio.models.generate_content( # (2) 여기서 양보
model=MODEL, contents=prompt.contents, config=prompt.config
)
return parse(resp) # (3) 재개되어 마무리
- 이벤트 루프가
chat(A)를 실행한다. (1)을 수 ms 안에 끝낸다. - (2)의
await를 만난다. LLM 서버로 요청을 보내고, A는 I/O 대기 목록으로 들어간다. A는 일시 정지되고 제어권이 이벤트 루프에게 돌아온다. - 이벤트 루프가 B를 꺼낸다.
chat(B)도 (1)을 수행하고 (2)에서 같은 방식으로 양보한다. - 더 실행할 코루틴이 없으면 루프는 OS에 "준비된 소켓이 생기면 알려달라"고 맡기고 쉰다. (Linux의 epoll, macOS의 kqueue)
- 2초쯤 뒤 A의 응답이 도착하면 OS가 알려주고, A는 ready 큐로 들어간다.
- 이벤트 루프가 A를 꺼내 (3)부터 이어서 실행하고 응답을 반환한다. B도 같은 방식으로 이어진다.
스레드는 하나뿐인데 A와 B는 동시에 2초를 기다렸다. await를 요약하면 "현재 coroutine은 결과가 준비될 때까지 실행을 중단하고, Event Loop에게 실행권을 돌려준다."는 의미다. 같은 이벤트 루프 위에서 코루틴끼리 자원을 나눠 쓰는 사례로는 Part 2의 지연 적재(asyncio.Lock)가 있다.
"프로그램을 멈춘다"가 아니라 "이 작업의 실행을 잠시 양보한다"로 이해하면 코드가 정확하게 읽힌다.
4. FastAPI의 실행 구조
요청이 들어오면 uvicorn(ASGI 서버)이 받아 FastAPI에 넘기고, FastAPI는 라우팅과 Pydantic 검증, 의존성 주입(Depends)을 거쳐 엔드포인트를 호출한다. 이때 엔드포인트와 의존성 함수가 async def인지 def인지에 따라 실행되는 곳이 갈린다.
| 선언 | 실행되는 곳 | 적합한 경우 |
|---|---|---|
async def | 이벤트 루프 (스레드 1개) | 함수 안에서 await로 비동기 I/O를 호출할 때 |
def | 스레드풀 (AnyIO, 기본 40개) | 동기 라이브러리만 쓰는 함수일 때 |
def로 선언한 함수는 FastAPI가 알아서 스레드풀로 넘기기 때문에 이벤트 루프를 막지 않는다. 반대로 async def 안에서 await 없이 동기 함수를 호출하면 그 호출은 이벤트 루프 스레드에서 직접 실행된다.
이 구조는 Cloud Run의 인스턴스 모델과도 맞물린다. Cloud Run은 인스턴스 하나가 여러 요청을 동시에 처리하도록 설정할 수 있다(동시성 기본값 80). 비동기 서버는 이 동시 요청들의 대기 시간을 겹쳐서 처리하기 때문에, 인스턴스당 스레드나 워커를 요청 수만큼 늘리지 않아도 된다. 동기 서버였다면 같은 동시성을 위해 워커 수나 스레드 수를 요청 수에 가깝게 맞춰야 한다. Scale-to-zero와 콜드스타트 등 Cloud Run 위에서의 구성은 Part 2에서 다뤘다.
5. await가 없는 호출 다루기
비동기 서버에서 자주 마주치는 경우는 동기 함수만 제공하는 라이브러리를 호출해야 할 때다. 예를 들어 firebase_admin.auth.verify_id_token은 동기 함수이고, check_revoked=True일 때는 내부에서 외부 서버로 HTTP 요청을 보낸다. 이런 함수를 async def 안에서 그냥 호출하면 호출이 끝날 때까지 이벤트 루프가 다른 일을 하지 못한다.
이 차이를 간단한 실험으로 확인했다. 외부 호출을 200ms 대기로 흉내내고, 요청 10개를 동시에 보낸다. 각 요청은 이 호출 뒤에 LLM 대기(0.5초)를 한다. 별도 코루틴이 10ms마다 깨어나서 "깨어나야 할 시점보다 얼마나 늦었는지"를 재서 이벤트 루프의 지연을 측정했다.
AUTH_MS = 0.2 # 외부 호출 200ms 가정
N = 10 # 동시 요청 수
def call_blocking(): # 동기 함수 (스레드를 붙잡음)
time.sleep(AUTH_MS)
async def call_async(): # 비동기 함수 (논블로킹)
await asyncio.sleep(AUTH_MS)
async def request(mode):
if mode == "blocking":
call_blocking() # async def 안에서 그냥 호출
elif mode == "thread":
await asyncio.to_thread(call_blocking) # 스레드풀로 넘김
else:
await call_async()
await asyncio.sleep(0.5) # LLM 호출 대기 가정
| 방식 | 마지막 응답까지 | 첫 응답까지 | 이벤트 루프 최대 지연 |
|---|---|---|---|
async def + 동기 호출 | 2.54초 | 2.04초 | 2,025ms |
async def + to_thread | 0.72초 | 0.71초 | 1ms |
async def + 비동기 호출 | 0.70초 | 0.70초 | 2ms |
동기 호출은 200ms가 요청 10개에 대해 직렬로 실행되어 2초가 쌓이고, 그동안 이벤트 루프는 아무 일도 하지 못했다. 같은 200ms를 스레드풀이나 비동기 호출로 처리하면 10개 요청이 겹쳐서 진행되어 0.7초대에 끝난다.
time.sleep(0.2)로 흉내낸 로컬 시뮬레이션이다. 실제 Firebase 호출이나 Cloud Run 환경에서 측정한 값이 아니므로, 수치보다는 "동기 호출이 이벤트 루프를 직렬화시킨다"는 경향으로 읽어야 한다.
동기 함수를 다루는 방법은 세 가지다.
| 방법 | 설명 | 비고 |
|---|---|---|
def로 선언 | FastAPI가 스레드풀에서 실행한다. | 함수 안에 await가 필요 없을 때 |
asyncio.to_thread | async def를 유지하면서 동기 함수 호출만 스레드풀로 넘긴다. | 가장 적용 범위가 넓다 |
| 비동기 클라이언트로 교체 | httpx.AsyncClient 등 비동기 라이브러리를 사용한다. | 비동기 SDK가 있을 때 |
Sleuth 서버의 인증 의존성은 두 번째 방법을 쓴다. Firebase Admin SDK의 검증 함수를 to_thread로 감싸서 스레드풀에서 실행하고, 이벤트 루프는 그동안 다른 요청을 처리한다.
async def get_current_user(authorization: str = Header(...)) -> AuthenticatedUser:
...
# SDK가 동기 함수만 제공하므로 스레드풀에서 실행한다
decoded_token = await asyncio.to_thread(
auth.verify_id_token, token, check_revoked=True
)
...
Node.js에서도 같은 원리가 적용된다. await를 붙인 함수 안에서 fs.readFileSync나 무거운 반복문을 돌리면 이벤트 루프가 막힌다. 이는 언어의 특성이 아니라 단일 스레드 이벤트 루프 모델의 성질이다.
// Node.js: async 함수라도 내부가 동기 호출이면 이벤트 루프는 막힌다
async function handler() {
const a = fs.readFileSync("big.json"); // 블로킹
const b = await fs.promises.readFile("big.json"); // 논블로킹
}
6. 비동기가 해주지 않는 것
- 응답 시간(latency)은 그대로다. LLM이 2초 걸리면 유저는 2초를 기다린다. 늘어나는 것은 동시에 처리할 수 있는 요청 수(concurrency)다.
- CPU를 쓰는 작업에는 효과가 없다. 큰 JSON을 파싱하거나 수치 연산을 하는 동안에는
await가 없으므로 루프가 점유된다. 이런 작업은 프로세스를 분리하거나 별도 워커로 보내야 한다. - 스레드풀에도 한도가 있다.
to_thread와def의 동시 처리 수는 스레드 수(기본 40개)에 묶인다. - I/O 대기가 짧거나 없으면 이점이 작다. 비동기가 효과적인 곳은 LLM 호출, DB 조회처럼 기다리는 시간이 긴 I/O 작업이다.
Sleuth는 서버 처리 시간 대부분이 LLM 응답 대기인 서비스라 이 모델과 잘 맞는다. 다만 이 이점은 FastAPI만의 것이 아니라 이벤트 루프 기반 서버(Node.js 포함)가 공통으로 가진다. 런타임을 고를 때는 비동기 모델 자체보다 사용하려는 SDK와 라이브러리, 팀의 개발 환경이 더 큰 기준이 되었다.
7. 마치며
정리하면 다음과 같다.
- 동기/비동기와 블로킹/논블로킹은 서로 다른 질문이고, 서버에서 원하는 것은 비동기 + 논블로킹이다.
- 이벤트 루프는 코루틴이
await에서 양보할 때만 다른 요청을 처리할 수 있다. - FastAPI는
async def를 이벤트 루프에서,def를 스레드풀에서 실행하며, 동기 함수는to_thread같은 방법으로 루프 밖에서 실행한다. - 비동기는 응답 시간을 줄이는 기술이 아니라 같은 자원으로 더 많은 요청을 동시에 받는 기술이다.




