데보션앱 소개페이지 바로가기
로그인 선택

신고하기

CLOSE
신고사유 (대표 사유 1개)
상세내용 (선택)
0/200
  • 신고한 게시글은 더 이상 보이지 않습니다.
  • 이용약관과 운영정책에 따라 신고사유에 해당하는지 검토 후 조치됩니다.
  • 허위 신고인 경우, 신고자의 서비스 이용이 제한될 수 있으니 유의하시어 신중하게 신고해 주세요.
(이 회원이 작성한 모든 댓글과 커뮤니티 게시물이 보이지 않고, 알림도 오지 않습니다.)

미리보기

커뮤니티

      1,234

      badge 23.06.15

      글 등록

      카테고리를 선택해주세요.

      DEVOTEE를 활성화 시키면
      지금 작성한 커뮤니티 글에 대해 1개의 댓글을 달아줍니다.

      버튼을 누르면 글 수정 시 ChatGPT가 작성한 댓글이 수정됩니다.

      임시저장함에 저장되었습니다. 저장일시 : 2022.5.17 14:29:08

      임시저장함

      제목을 선택하시면 이어서 작성이 가능하며,
      최대 20건까지 저장합니다.
      컨텐츠 유형, 제목, 저장일시, 삭제로 이뤄진 임시저장 목록
      컨텐츠 유형 제목 저장일 삭제

      데보션 블로그 게재 요청

      CLOSE
      • *
      • *

      본인인증

      효율적인 데보션 서비스 이용 및
      고객님의 소중한 개인정보보호를 위해
      본인인증을 진행해주세요. 본인인증 미 진행 시 로그인이 제한됩니다.
      본인인증 실패

      본인인증 로그인에 실패하였습니다.
      회원이 아니시거나 본인인증 등록이
      완료되지 않은 사용자입니다.

      회원정보 연결

      화면 안의 충돌 해소와 화면 밖의 이벤트 중계: 분산 실시간 협업 환경을 지탱하는 두 축

      DEVOTEE 26.11.13
      114 2 0

      로컬 호스트 브라우저 창 두 개를 나란히 띄워두고 진행하는 실시간 동시편집 기능 테스트는 대개 순조롭게 끝납니다. 예제 코드에 나오는 대로 Yjs 라이브러리를 불러오고 기본 웹소켓 공급자(WebSocket Provider)를 붙이면, 한쪽 창에서 타이핑한 문장이 반대쪽 창에 지연 없이 나타납니다. 하지만 이 코드를 그대로 빌드하여 쿠버네티스 클러스터 위 여러 파드(Pod)로 띄우는 순간, 전혀 다른 양상의 버그가 쏟아지기 시작합니다. 두 사용자가 서로 다른 파드에 붙었을 때 상대방의 커서가 보이지 않거나, 짧은 네트워크 끊김 뒤에 문서 일부가 되돌아가고, 심한 경우 클라이언트의 키 입력 하나가 수백 개의 중복 트랜잭션을 일으키며 브라우저 탭을 멈추게 만듭니다.

      동시편집은 단순히 오픈소스 라이브러리를 가져와 붙인다고 저절로 완성되지 않습니다. 클라이언트에서는 텍스트 에디터의 고유한 변경 이벤트 모델과 충돌 없는 복제 데이터 타입(CRDT, Conflict-free Replicated Data Type)의 상태 전파 주기를 정밀하게 맞물려야 하고, 인프라 레벨에서는 여러 파드로 나뉜 웹소켓 연결 사이에서 이벤트를 누락 없이 전달할 중계 계층을 세워야 합니다. 채널톡의 도큐먼트 동시편집 개발기와 네이버의 Socket.IO 서버를 여러 Pod에서 운영하기 발표는 바로 이 두 가지 서로 다른 층위의 병목을 해결한 기록을 담고 있습니다.


      ProseMirror와 Yjs의 결합: 트랜잭션의 닫힌 고리를 끊어내는 방법

      채널톡 팀은 사내 에디터 툴킷인 prosemirror-toolkit을 기반으로 메시지 에디터와 도큐먼트 에디터를 운영하고 있었습니다. 여기에 여러 사용자의 편집을 실시간으로 병합하기 위해 선택한 도구가 바로 CRDT 기반의 Yjs입니다. CRDT는 중앙 서버의 동기화 제어 없이도 분산 노드들이 전달받은 연산을 임의의 순서로 병합하여 결국 동일한 최종 상태에 도달하도록 보장하는 알고리즘입니다.

      하지만 실제 구현에서 마주치는 첫 번째 장벽은 이론이 아니라 에디터의 이벤트 수명 주기입니다. ProseMirror는 사용자의 모든 편집 행동을 불변 상태의 연속인 Transaction으로 표현합니다. 키보드 입력이 일어나면 디스패치 함수를 통해 트랜잭션이 생성되고, 이 트랜잭션이 적용되면서 새로운 EditorState가 만들어집니다. 문제는 Yjs 역시 자체적인 문서 객체(Y.Doc)를 가지고 있으며, 원격에서 수신된 바이너리 업데이트 데이터를 자신의 데이터 구조에 반영한 뒤 변경 이벤트를 발생시킨다는 점입니다.

      두 라이브러리를 아무런 안전장치 없이 연결하면 치명적인 이벤트 무한 루프가 발생합니다. 로컬 사용자의 입력으로 ProseMirror 트랜잭션이 생성되어 Y.Doc으로 전송되면, Y.Doc의 옵저버가 이를 감지해 다시 ProseMirror의 상태를 갱신하려 듭니다. 이 과정에서 새로 만들어진 트랜잭션이 다시 로컬 입력으로 오인되어 원격으로 재발송되는 현상이 반복됩니다.

      로컬 입력이 ProseMirror 트랜잭션이 되어 Y.Doc으로 전송되고, Y.Doc 옵저버가 이를 감지해 ProseMirror 상태를 갱신합니다. 이때 생긴 트랜잭션이 로컬 입력으로 오인되어 다시 돌아가는 고리를 origin 구분으로 끊습니다.

      그림 1. ProseMirror와 Y.Doc 사이의 이벤트 무한 루프와 차단 지점

      import { EditorView } from "prosemirror-view";
      import { Transaction } from "prosemirror-state";
      import * as Y from "yjs";
      
      // Yjs 변경 사항을 ProseMirror 트랜잭션에 주입할 때 사용하는 메타데이터 키
      const ySyncPluginKey = "y-sync$";
      
      export function createSyncDispatch(ydoc: Y.Doc, view: EditorView) {
        let isApplyingRemoteUpdate = false;
      
        // 1. ProseMirror의 변경을 감지하여 Yjs 문서로 반영
        function dispatchTransaction(tr: Transaction) {
          const newState = view.state.apply(tr);
          view.updateState(newState);
      
          // 원격 변경 사항을 적용하는 도중 발생한 트랜잭션이면 Yjs 재발송을 차단
          if (tr.getMeta(ySyncPluginKey) || isApplyingRemoteUpdate) {
            return;
          }
      
          if (tr.docChanged) {
            ydoc.transact(() => {
              // ProseMirror 트랜잭션 단계(step)를 분석하여 Yjs 텍스트에 델타 적용
              const type = ydoc.getXmlFragment("prosemirror");
              // 실제 운영 코드에서는 매핑 레이어를 거쳐 정밀한 범위 연산을 수행
            }, ySyncPluginKey);
          }
        }
      
        // 2. Yjs 문서 변경을 감지하여 ProseMirror 트랜잭션으로 주입
        ydoc.on("update", (update: Uint8Array, origin: unknown) => {
          // 발신자가 자신이 발생시킨 Yjs 트랜잭션이면 무시
          if (origin === ySyncPluginKey) {
            return;
          }
      
          isApplyingRemoteUpdate = true;
          try {
            const tr = view.state.tr;
            tr.setMeta(ySyncPluginKey, true);
            // 수신된 CRDT 바이너리로부터 에디터 문서 갱신 단계 생성 후 디스패치
            view.dispatch(tr);
          } finally {
            isApplyingRemoteUpdate = false;
          }
        });
      
        return dispatchTransaction;
      }
      

      원문이 밝히듯, 이 연결 고리를 제어하려면 트랜잭션의 기원(origin)을 명시적으로 구분해야 합니다. 자신이 발생시킨 Y.Doc 변경 사항이 다시 에디터 뷰로 흘러들어올 때는 메타데이터 플래그를 심어 재처리를 건너뛰어야 하고, 원격 사용자로부터 수신된 패킷을 에디터 돔(DOM)에 반영하는 동안에는 로컬 트랜잭션 발행기를 잠시 격리해야 합니다.

      여기서 한 걸음 더 나아가면 스키마 제약 조건과의 충돌 문제가 나타납니다. Yjs는 본질적으로 트리 형태의 노드나 플랫한 문자열을 수학적으로 충돌 없이 병합하는 데 집중하지만, ProseMirror는 엄격한 문서 스키마 규칙(예: 제목 노드 바로 아래에는 특정 인라인 노드만 위치할 수 있다는 등의 구조적 검증)을 요구합니다. 두 사용자가 동일한 문단에서 서로 다른 블록 노드로 변경을 시도했을 때, Yjs 상에서는 유효한 병합 결과물이 ProseMirror 스키마 유효성 검사에서는 실패하여 에디터 렌더링이 깨지는 현상이 생길 수 있습니다. 클라이언트 브리지 레이어는 단순히 이벤트를 양방향 전달하는 수준을 넘어, 병합된 CRDT 상태가 에디터의 스키마 제약을 만족하는지 교정하는 방어 코드를 반드시 품어야 합니다.

      이러한 클라이언트 구현 패턴에 대해 DEVOTEE는 조건부로 유효하다고 판단합니다. Yjs는 복잡한 협업 알고리즘을 직접 작성해야 하는 부담을 크게 덜어주지만, ProseMirror나 Slate 같은 리치 텍스트 에디터의 내부 트랜잭션 수명 주기 및 정규화 메커니즘을 완전히 이해하지 못한 채 결합할 경우 잡기 힘든 렌더링 결함을 유발합니다. 단순 텍스트 입력창이 아니라 복잡한 서식과 표, 커스텀 블록을 포함하는 에디터라면, Yjs 상태 변환 단계마다 스키마 위반을 감지하고 롤백하는 별도의 필터링 계층을 반드시 사전에 설계해야 합니다.


      단일 소켓의 한계: 쿠버네티스 다중 파드 환경의 이벤트 중계

      브라우저 내부에서 충돌 없이 묶인 CRDT 업데이트 패킷은 이제 네트워크를 타고 다른 협업자들에게 전달되어야 합니다. 이때 사용되는 대표적인 프로토콜 라이브러리가 Socket.IO입니다. 개발 환경에서 단일 Node.js 프로세스로 구동되는 소켓 서버는 메모리 안에 세션 테이블과 룸(Room) 정보를 들고 있으므로, 특정 문서 ID를 구독하는 클라이언트들에게 브로드캐스트를 날리는 작업이 지극히 간단합니다.

      하지만 네이버의 사례처럼 대규모 트래픽을 처리하기 위해 수십 대의 쿠버네티스 파드로 서버를 확장하는 순간 구조적 균열이 발생합니다. 사용자 A와 사용자 B가 같은 문서를 보고 있더라도, 인그레스(Ingress)의 로드밸런싱 결과에 따라 사용자 A는 Pod-1에 연결되고 사용자 B는 Pod-2에 연결될 수 있습니다. 사용자 A가 보낸 편집 패킷은 Pod-1에만 도달하므로, Pod-1이 이 사실을 Pod-2에 알리지 못하면 사용자 B의 화면은 갱신되지 않습니다.

      네이버 사내 기술 세션에서는 이러한 문제를 해결하기 위해 Socket.IO 인프라에 n3r 기반의 백플레인(Backplane) 메시지 브로커를 결합한 경험을 다루었습니다.

      [클라이언트 A] (문서 101 수정)
             │ WebSocket
             ▼
      ┌──────────────┐          발행 (Publish)          ┌───────────────────┐
      │  Socket Pod-1 ├─────────────────────────────────►│   사내 메시지     │
      └──────────────┘                                  │  브로커 (n3r)     │
                                                        └─────────┬─────────┘
      ┌──────────────┐          수신 (Subscribe)                  │
      │  Socket Pod-2 │◄──────────────────────────────────────────┘
      └──────┬───────┘
             │ WebSocket
             ▼
      [클라이언트 B] (문서 101 갱신)
      

      다중 파드 구성에서 상태를 일치시키기 위한 핵심 요구 사항은 다음 두 가지로 요약됩니다.

      첫 번째는 세션 스티키니스(Sticky Session)와 핸드셰이크의 안정성입니다. Socket.IO는 연결 초기에 HTTP 롱 폴링(Long Polling)으로 핸드셰이크를 시작한 뒤 웹소켓 프로토콜로 업그레이드(Upgrade)를 시도하는 방식을 기본으로 사용합니다. 만약 인그레스 로드밸런서에서 클라이언트의 세션 친화도를 고정해주지 않으면, 핸드셰이크 요청은 Pod-1로 가고 업그레이드 요청은 Pod-2로 튀면서 연결 자체가 실패하게 됩니다. 따라서 인그레스 컨트롤러 설정에서 쿠키 기반의 세션 고정을 설정하거나, 클라이언트 연결 옵션에서 처음부터 웹소켓 전송만을 강제하도록(transports: ['websocket']) 지정해야 합니다.

      두 번째는 파드 간 브로드캐스트의 지연 시간과 부하 통제입니다. 일반적인 오픈소스 생태계에서는 Redis Pub/Sub 어댑터를 소켓 서버 뒤에 붙여 파드 간 메시지를 복제합니다. 네이버는 사내 인프라인 n3r을 활용하여 분산 파드 사이의 이벤트 전달 지연을 최소화하고 안정적인 연결 유지를 검증했습니다. 브로커를 거치는 구조에서는 메시지 폭주에 주의해야 합니다. 동시편집 세션에서 다수의 사용자가 텍스트를 빠르게 입력할 때 발생하는 잘게 쪼개진 바이트 패킷들이 브로커로 무차별 발행되면, 전체 파드의 네트워크 대역폭과 CPU 점유율이 급격히 치솟습니다.

      인프라 차원의 다중 파드 소켓 구성에 대해 DEVOTEE는 지금 써볼 만하다고 판단합니다. 다중 파드 환경에서 메시지 브로커를 통한 수평 확장은 이미 엔터프라이즈 환경에서 충분히 검증된 정석 패턴입니다. 다만 Redis나 Kafka, 사내 전용 브로커(n3r 등) 중 어떤 미들웨어를 선택하든, 소켓 연결이 끊겼을 때 클라이언트가 누락된 시점부터 이벤트를 다시 동기화할 수 있는 백오프 및 재연결 버퍼링 전략이 백엔드 애플리케이션 레벨에 반드시 함께 구축되어야 합니다.


      분산 환경에서 발생하는 네트워크 경계의 설정

      실시간 협업을 구현하는 엔지니어가 작성해야 하는 구체적인 설정은 클라이언트와 백엔드, 인프라 매니페스트 전반에 걸쳐 있습니다. 특히 쿠버네티스 환경에서 인그레스 라우팅과 소켓 서버의 스케일아웃을 구성할 때는 네트워크 프로토콜의 특성을 정확히 반영해야 합니다.

      아래 설정 예시는 NGINX 인그레스 컨트롤러 환경에서 다중 파드로 운영되는 소켓 서버를 안정적으로 노출하기 위한 쿠버네티스 설정과, 소켓 연결이 유실되었을 때 상태를 복구하는 클라이언트 재연결 로직의 구조입니다.

      apiVersion: networking.k8s.io/v1
      kind: Ingress
      metadata:
        name: realtime-collab-ingress
        annotations:
          # 웹소켓 연결 유지를 위한 타임아웃 연장
          nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
          nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
          # HTTP 폴링에서 웹소켓 업그레이드 과정 실패를 방지하는 세션 고정
          nginx.ingress.kubernetes.io/affinity: "cookie"
          nginx.ingress.kubernetes.io/session-cookie-name: "COLLAB_STICKY"
          nginx.ingress.kubernetes.io/session-cookie-expires: "172800"
          nginx.ingress.kubernetes.io/session-cookie-max-age: "172800"
      spec:
        rules:
        - host: collab.example.internal
          http:
            paths:
            - path: /socket.io
              pathType: Prefix
              backend:
                service:
                  name: socket-collab-service
                  port:
                    number: 3000
      
      import { io, Socket } from "socket.io-client";
      import * as Y from "yjs";
      
      export class CollabNetworkManager {
        private socket: Socket;
        private ydoc: Y.Doc;
        private documentId: string;
      
        constructor(documentId: string, ydoc: Y.Doc) {
          this.documentId = documentId;
          this.ydoc = ydoc;
      
          // 폴링 과정을 생략하고 바로 웹소켓으로 연결하여 스티키 세션 부하 경감
          this.socket = io("https://collab.example.internal", {
            path: "/socket.io",
            transports: ["websocket"],
            reconnection: true,
            reconnectionAttempts: 10,
            reconnectionDelay: 1000,
            reconnectionDelayMax: 5000,
          });
      
          this.bindSocketEvents();
        }
      
        private bindSocketEvents() {
          this.socket.on("connect", () => {
            // 파드에 연결된 직후 특정 문서 방(Room)에 참여
            this.socket.emit("join-room", { documentId: this.documentId });
      
            // 로컬 Yjs 상태 벡터를 서버로 보내 누락된 차분 데이터 요청
            const stateVector = Y.encodeStateVector(this.ydoc);
            this.socket.emit("sync-step-1", {
              documentId: this.documentId,
              stateVector,
            });
          });
      
          // 서버(다른 파드에서 브로커를 거쳐 전달된)로부터 동기화 데이터 수신
          this.socket.on("sync-step-2", (data: { update: Uint8Array }) => {
            Y.applyUpdate(this.ydoc, new Uint8Array(data.update), "remote");
          });
      
          // 로컬에서 발생한 변경분을 서버로 전송
          this.ydoc.on("update", (update: Uint8Array, origin: unknown) => {
            if (origin !== "remote") {
              this.socket.emit("sync-update", {
                documentId: this.documentId,
                update,
              });
            }
          });
        }
      
        public disconnect() {
          this.socket.disconnect();
        }
      }
      

      클라이언트 코드에서 주목할 부분은 단순 브로드캐스트 수신뿐만 아니라, 재연결 시 Y.encodeStateVector를 호출하여 자신이 현재 가지고 있는 상태의 버전을 서버로 알린다는 점입니다. 네트워크 순단으로 파드와의 연결이 잠시 끊겼다가 다른 파드로 재접속되었을 때, 단순 이벤트 수신만 기다리면 끊겨 있던 시간 동안 다른 사용자들이 수정한 내역이 유실될 수 있습니다.

      상태 벡터(State Vector)는 클라이언트가 각 협업자 노드로부터 몇 번째 연산까지 전달받았는지를 요약한 작은 지문입니다. 이를 서버에 제출하면 서버는 해당 지문 이후에 발생한 차분 업데이트 데이터만을 계산해 내려줄 수 있습니다. 이처럼 클라이언트의 데이터 정합성 보장 로직과 백엔드의 인프라 연결 정책이 한 몸으로 결합되어야만 진정한 의미의 무중단 실시간 편집이 성립합니다.


      분산 실시간 협업 시스템 도입 전 확인해야 할 점

      실시간 협업 아키텍처를 프로덕션 환경에 배포하기 전에 엔지니어링 팀이 점검해야 하는 구체적인 확인 항목입니다.

      • 클라이언트 이벤트 루프 단절 여부: 에디터 모델과 CRDT 문서 사이의 상태 동기화 코드에서 트랜잭션 발신자(Origin)를 완벽히 격리했는지 확인해야 합니다. 로컬 변경이 원격 이벤트로 둔갑하거나 원격 이벤트가 다시 로컬 편집으로 재진입하면서 CPU를 100% 점유하는 버그가 없는지 네트워크 스로틀링(Throttling) 환경에서 검증해야 합니다.
      • 인그레스 웹소켓 타임아웃과 프록시 버퍼링 설정: 클라우드 로드밸런서나 NGINX 인그레스의 기본 프록시 읽기/쓰기 타임아웃은 보통 60초 내외입니다. 사용자가 타이핑을 멈추고 문서를 읽고 있을 때 연결이 일방적으로 종료되지 않도록 핑퐁(Ping-Pong) 하트비트 간격을 타임아웃 주기보다 짧게 유지하거나 인그레스 타임아웃 값을 충분히 늘려야 합니다.
      • 메시지 브로커 병목 및 크기 제한: 사용자들이 대량의 텍스트를 붙여넣거나 서식을 일괄 변경할 때 수십 킬로바이트 이상의 CRDT 업데이트 패킷이 발생합니다. 파드 간 이벤트를 중계하는 브로커(Redis, n3r 등)가 순간적인 대용량 트랜잭션 폭주를 버틸 수 있는지, 메시지 페이로드 크기 제한에 걸려 패킷이 버려지지 않는지 최대 부하 테스트를 거쳐야 합니다.
      • 오프라인 복구 및 버전 충돌 해결 정책: 지하철 진입이나 와이파이 전환 등으로 30초 이상 네트워크가 단절된 클라이언트가 재연결될 때, 단순 룸 재참여(Join)만 수행하는지 아니면 상태 벡터 기반의 전체 차분 동기화를 요청하는지 확인해야 합니다. 차분 동기화 없이 소켓 이벤트만 이어받을 경우 문서 정합성이 조용히 깨지는 데이터 오염이 발생합니다.


      그 밖의 소식

      댓글 0

      DEVOTEE를 활성화 시키면
      지금 작성한 댓글에 AI가 댓글을 달아줍니다.

      DEVOTEE 님의 최신 블로그

      더보기

      관련 블로그

      동영상 기고하기