Redis Streams와 SSE로 개선한 봇 실시간 데이터 전달 구조

백엔드2026년 10월 18일

들어가며

현재 운영 중인 가상화폐 자동매매 플랫폼에서는 사용자가 봇을 시작하면 백엔드가 해당 봇의 전략을 실제로 실행하는 컨테이너를 하나 띄우는데, 이를 엔진이라고 부른다. 엔진은 사용자가 노드로 구성한 전략에 따라 시세를 확인하고 주문을 넣으면서 봇의 상태, 거래 기록, 현재 실행 중인 노드, 포지션 정보 등의 데이터를 만들어내고, 이 데이터는 백엔드를 거쳐 사용자의 대시보드에 실시간으로 표시된다.

이 데이터가 전달되는 경로는 크게 두 구간으로 나눌 수 있다. 엔진에서 백엔드로 가는 구간과, 백엔드에서 클라이언트로 가는 구간이다.

기존에는 각각 REST 호출과 WebSocket으로 구현되어 있었는데, 운영하면서 두 방식 모두 불편한 점이 드러나 엔진과 백엔드 사이는 Redis Streams로, 백엔드와 클라이언트 사이는 SSE로 변경했다. 이번 글에서는 각각을 바꾼 이유와 구현 과정을 정리해보고자 한다.

기존 구조

먼저 엔진에서 백엔드로 데이터를 보내는 방식은 데이터의 종류에 따라 두 가지로 나뉘어 있었다. 봇의 상태나 거래 기록처럼 DB에 저장되어야 하는 데이터는 백엔드의 REST API를 호출하여 전달했고, 현재 실행 중인 노드나 포지션처럼 화면에 보여주기만 하면 되는 데이터는 Redis Pub/Sub으로 전달했다. 기존 엔진의 코드는 다음과 같다.

// 봇 상태 변경 (REST)
await http.patch(`${BACKEND_URL}/bots/${botId}/state`, { state }, { headers: internalAuthHeader });

// 거래 기록 전송 (REST)
await http.post(`${BACKEND_URL}/tradelogs`, { botId, log }, { headers: internalAuthHeader });

// 실행 중인 노드, 포지션 정보 (Redis Pub/Sub)
await redis.publish(`engine:${engineId}`, JSON.stringify({ kind: "position", data: position }));

백엔드에서 클라이언트로 데이터를 보내는 구간은 WebSocket으로 구현되어 있었다. 클라이언트가 WebSocket으로 연결한 뒤 특정 봇에 대한 구독 메시지를 보내면, 백엔드는 해당 봇의 Redis Pub/Sub 채널을 구독하여 들어오는 메시지를 클라이언트에 그대로 전달하는 방식이다.

server.on("upgrade", (req, socket, head) => {
    const user = authenticate(req); // 세션에서 사용자 확인
    if (!user) return reject(socket, 401);

    wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, user));
});

wss.on("connection", (ws, user) => {
    ws.on("message", async (message) => {
        const { action, botId } = JSON.parse(message);

        if (action === "subscribe") {
            await verifyOwnership(user, botId);
            subscribeEngineChannel(ws, botId); // 해당 엔진의 Pub/Sub 채널 구독
        }
    });
});

엔진과 백엔드 사이의 REST 호출

동작에는 문제가 없었지만, 엔진이 백엔드를 REST로 호출하는 방식에는 몇 가지 불편한 점이 있었다.

먼저 엔진이 백엔드의 주소를 알고 있어야 했다. 위 코드의 BACKEND_URL처럼 엔진은 백엔드가 어디에 떠 있는지를 알아야만 데이터를 보낼 수 있었다. 지금은 엔진과 백엔드가 같은 호스트에 있지만, 추후 봇이 다른 인스턴스에서 실행되는 경우까지 고려하면 엔진이 백엔드의 위치에 의존하는 구조는 부담이 될 수밖에 없었다.

다음으로 인증 문제가 있었다. 엔진이 호출하는 API는 일반 사용자가 호출해서는 안 되는 API이기 때문에, 엔진만 호출할 수 있도록 내부용 토큰을 검증하는 별도의 인증 과정을 두어야 했다. 엔진에서 백엔드로 보내는 데이터의 종류가 늘어날수록 이러한 내부용 API와 인증 로직도 함께 늘어나는 구조였다.

또한 HTTP 자체의 오버헤드도 있었다. 상태 변경이나 거래 기록은 크기가 작은 데이터인데도, 보낼 때마다 HTTP 연결을 맺고 요청을 보내야 했기 때문에, 데이터 크기에 비해 불필요한 비용이 계속 발생했다.

마지막으로 데이터가 나가는 경로가 나뉘어 있었다. 실행 중인 노드나 포지션 정보는 이미 Redis Pub/Sub으로 보내고 있었기 때문에, 같은 엔진에서 나가는 데이터가 종류에 따라 REST와 Redis 두 경로로 나뉘어 있었다. 그 결과 새로운 데이터를 추가할 때마다 어느 경로로 보낼지 정해야 했고, 백엔드에서도 두 곳에서 데이터를 받아 처리해야 했다.

Redis Streams 선택

이미 엔진과 백엔드가 모두 Redis에 연결되어 있었기 때문에, REST 호출을 Redis를 통한 전달로 바꾸면 위 문제들을 한 번에 해결할 수 있었다. 엔진은 백엔드의 주소를 알 필요 없이 Redis에만 데이터를 쓰면 되고, Redis는 내부 네트워크 안에만 있기 때문에 엔진만을 위한 별도의 인증 API도 필요가 없어진다.

다만 기존에 사용하던 Pub/Sub은 상태나 거래 기록을 전달하기에는 적합하지 않았다. Pub/Sub은 메시지를 보관하지 않기 때문에 백엔드가 재시작 중이거나 구독하고 있지 않은 순간에 발행된 메시지는 그대로 유실된다. 화면에 보여주기만 하는 데이터라면 문제가 없지만, 거래 기록은 한 건이라도 빠지면 안 되는 데이터이다. 그래서 메시지를 보관하는 Redis Streams를 사용하기로 했다.

항목RESTRedis Pub/SubRedis Streams
엔진이 백엔드 주소를 알아야 함OXX
별도 인증 필요OXX
수신자가 없을 때 메시지 보존X (요청 실패)XO
추가 인프라없음없음(Redis 사용 중)없음(Redis 사용 중)

메시지를 보관해야 한다는 점만 보면 Apache Kafka나 RabbitMQ도 선택지가 될 수 있다. 하지만 엔진에서 백엔드로 전달되는 데이터는 양이 많지 않았고, 필요한 기능도 수신자가 없을 때 메시지를 보관해두는 정도였다. 이를 위해 별도의 메시지 브로커를 새로 운영하는 것은 과하다고 판단했고, 이미 사용하고 있던 Redis 안에서 해결할 수 있는 Redis Streams를 선택했다.

엔진 구현

엔진에서는 기존의 REST 호출과 Pub/Sub 발행을 모두 XADD로 바꾸었다. 데이터의 종류마다 스트림을 하나씩 두어 bot:state, bot:tradelogs, bot:execution, bot:position 네 개의 스트림으로 나누었다.

// 봇 상태 변경
await redis.xadd("bot:state", "*", "botId", botId, "state", state);

// 거래 기록 전송
await redis.xadd("bot:tradelogs", "*", "botId", botId, "log", JSON.stringify(log));

// 포지션 정보
await redis.xadd("bot:position", "*", "botId", botId, "position", JSON.stringify(position));

백엔드 구현

백엔드에서는 스트림을 읽어 처리하는 로직을 worker_threads로 분리하여 메인 스레드와 별도로 실행했다. 워커는 XREAD BLOCK으로 네 개의 스트림을 동시에 기다리다가, 데이터가 들어오면 종류에 따라 처리한다.

const STREAMS = ["bot:state", "bot:tradelogs", "bot:execution", "bot:position"];

async function processStream() {
    try {
        const streams = await redis.xread("BLOCK", 0, "STREAMS", ...STREAMS, ...STREAMS.map(() => "0"));

        for (const [streamName, entries] of streams) {
            for (const [entryId, data] of entries) {
                const done = await handle(streamName, data); // 상태, 거래 기록은 DB 저장 성공 여부

                if (done) await redis.xdel(streamName, entryId);

                parentPort.postMessage({ streamName, data }); // 메인 스레드로 전달
            }
        }

        processStream();
    } catch (e) {
        setTimeout(processStream, 1000);
    }
}

여기서 중요한 점은 XDEL을 호출하는 시점이다. 상태나 거래 기록의 경우 DB 저장이 성공한 경우에만 스트림에서 해당 항목을 삭제한다. 따라서 DB 저장에 실패하거나 처리 도중 백엔드가 종료되더라도 항목은 스트림에 남아 있고, 다음 XREAD에서 다시 처리된다. 기존 REST 방식에서는 요청이 실패할 경우를 대비해 엔진이 재시도 로직을 직접 가지고 있어야 했는데, 이제는 엔진이 스트림에 데이터를 쓰기만 하면 되기 때문에 해당 로직도 제거할 수 있었다.

처리가 끝난 데이터는 parentPort.postMessage()를 통해 메인 스레드로 넘기고, 메인 스레드는 이를 클라이언트에 전달한다.

백엔드와 클라이언트 사이의 WebSocket

엔진 쪽을 바꾸면서 백엔드에서 클라이언트로 가는 구간도 다시 보게 되었다. 기존 WebSocket 구현을 살펴보면, 실제로 클라이언트가 서버로 보내는 메시지는 어떤 봇을 구독할지 알려주는 구독 메시지 하나뿐이었다. 그 이후로는 서버에서 클라이언트로 데이터를 보내기만 한다.

즉 양방향 통신이 필요하지 않은 상황에서 WebSocket을 사용하고 있었고, 그 때문에 연결 업그레이드 처리, 세션을 직접 파싱하는 인증 로직, 구독 메시지 프로토콜까지 별도로 구현해야 했다. 단방향 전송이라면 SSE로도 충분하다고 판단하여 SSE로 변경하기로 했다.

SSE는 일반적인 HTTP GET 요청 위에서 동작하기 때문에, 기존 REST API와 동일한 방식으로 라우트를 정의할 수 있다. 덕분에 기존에 사용하던 세션 인증 미들웨어도 그대로 적용되고, 구독 메시지 대신 URL의 봇 ID로 어떤 봇의 데이터를 받을지 정할 수 있다.

router.get("/bots/:id/events", requireSession, async (req, res) => {
    const bot = await findUserBot(req.user, req.params.id);
    if (!bot) return res.sendStatus(404);

    res.setHeader("Content-Type", "text/event-stream");
    res.setHeader("Cache-Control", "no-cache");
    res.setHeader("Connection", "keep-alive");

    addClient(bot.id, req.query.clientId, res);
    req.on("close", () => removeClient(bot.id, req.query.clientId));
});

연결된 클라이언트는 봇 ID별로 묶어서 관리한다. 이때 고려해야 했던 점은 같은 사용자가 같은 봇의 페이지를 여러 탭에서 열어두는 경우이다. 사용자 ID나 봇 ID만으로 연결을 구분하면, 탭 하나를 닫았을 때 같은 봇을 보고 있는 다른 탭의 연결까지 함께 정리되거나, 반대로 새 탭의 연결이 기존 연결을 덮어쓰게 된다.

따라서 클라이언트가 페이지에 진입할 때마다 UUID로 clientId를 새로 만들어 연결 요청에 함께 보내도록 하고, 백엔드에서는 봇 ID 아래에 clientId별로 연결을 한 번 더 나누어 저장했다. 연결이 끊어지면 해당 clientId의 연결만 제거하고, 그 봇을 보고 있는 클라이언트가 하나도 남지 않았을 때 봇 ID 항목 자체를 삭제한다.

const sseClients = new Map(); // botId -> Map<clientId, res>

function addClient(botId, clientId, res) {
    if (!sseClients.has(botId)) sseClients.set(botId, new Map());
    sseClients.get(botId).set(clientId, res);
}

function removeClient(botId, clientId) {
    const clients = sseClients.get(botId);
    if (!clients) return;

    clients.delete(clientId);
    if (!clients.size) sseClients.delete(botId);
}

앞서 스트림 워커가 메인 스레드로 데이터를 넘기면, 해당 봇을 보고 있는 클라이언트들에게만 이벤트를 전송한다. 이때 스트림 이름을 SSE의 이벤트 이름으로 그대로 사용하여, 클라이언트에서 데이터 종류별로 이벤트를 구분할 수 있도록 했다.

streamWorker.on("message", ({ streamName, data }) => {
    if (sseClients.has(data.botId)) {
        sseClients.get(data.botId).forEach((res) => {
            res.write(`event: ${streamName}\ndata: ${JSON.stringify(data)}\n\n`);
        });
    }
});

또한 클라이언트가 처음 연결되었을 때는 Redis에 저장해둔 현재 실행 중인 노드와 포지션 정보를 먼저 보내주도록 했다. 스트림은 변경이 있을 때만 데이터를 보내기 때문에, 이 처리가 없으면 다음 변경이 일어나기 전까지 화면이 비어 있게 된다.

클라이언트 구현

클라이언트에서는 브라우저에 내장된 EventSource를 사용하여 연결하고, 앞서 정의한 이벤트 이름별로 리스너를 등록한다.

const source = new EventSource(`/api/bots/${botId}/events?clientId=${clientId}`, { withCredentials: true });

source.addEventListener("bot:state", (event) => { ... });
source.addEventListener("bot:tradelogs", (event) => { ... });
source.addEventListener("bot:execution", (event) => { ... });
source.addEventListener("bot:position", (event) => { ... });

source.addEventListener("error", () => {
    source.close();
    setDisconnected(true);
});

연결이 끊어진 경우에는 연결을 닫고 사용자에게 알림을 띄워, 데이터가 실시간으로 갱신되지 않을 수 있다는 점을 알려주고 직접 재접속할 수 있도록 했다.

sse-disconnect.png

남아 있는 한계

엔진은 Redis에만 데이터를 쓰면 되기 때문에 어느 인스턴스에서 몇 개가 실행되든 상관없지만, 이를 읽어 처리하는 백엔드 쪽은 아직 하나의 인스턴스로 실행된다는 전제 위에 있다. 연결된 SSE 클라이언트 목록을 백엔드 프로세스의 메모리에 보관하고 있고, 스트림 역시 컨슈머 그룹 없이 처음부터 읽은 뒤 처리한 항목을 삭제하는 방식이기 때문이다. 백엔드를 여러 인스턴스로 늘리면 같은 항목을 여러 인스턴스가 중복으로 처리하게 되고, 클라이언트가 연결된 인스턴스와 데이터를 읽은 인스턴스가 다를 수도 있다. 이 부분은 백엔드를 확장해야 하는 시점에 컨슈머 그룹을 도입하는 방향으로 다시 고려해보기로 했다.

마무리

이번 글에서는 엔진에서 클라이언트까지 봇의 실시간 데이터가 전달되는 경로를 Redis Streams와 SSE로 바꾼 과정을 정리해보았다.

엔진과 백엔드 사이를 Redis Streams로 바꾸면서 엔진은 더 이상 백엔드의 주소나 인증 방식을 알 필요가 없어졌고, 흩어져 있던 REST 호출과 Pub/Sub 발행도 하나의 방식으로 통일되었다. 또한 DB 저장이 끝난 뒤에만 항목을 삭제하도록 하여, 백엔드가 잠시 내려가 있더라도 거래 기록이 유실되지 않는 구조를 만들 수 있었다.

백엔드와 클라이언트 사이는 SSE로 바꾸면서 WebSocket을 위해 따로 두었던 업그레이드 처리, 인증, 구독 프로토콜을 걷어내고 기존 REST API와 같은 방식으로 다룰 수 있게 되었다. 또한 라우트 하나만 추가하면 되는 구조가 되면서, 이후 폴링으로 구현되어 있던 백테스트 진행 상황도 같은 방식으로 쉽게 옮길 수 있었다. 두 변경 모두 새로운 인프라를 추가하지 않고 이미 사용하고 있던 Redis와 HTTP 위에서 해결했다는 점에서, 당시 프로젝트의 규모에 맞는 선택이었다고 생각한다.

댓글