🏢 Discord 기술 스택 분석

게이머를 위해 시작했지만 전 세계 커뮤니티의 홈이 된 Discord의 기술 스택을 심층 분석합니다.
"Imagine a place..." - 실시간 커뮤니케이션의 미래를 만드는 기술

📊 회사 개요

서비스 규모

• 월간 활성 사용자: 1.5억 명+
• 일일 메시지: 40억+ 건
• 음성 통화: 월 40억+ 분
• 서버(커뮤니티): 1,900만+ 활성 서버
• 동시 접속자: 피크 1,500만+

엔지니어링 조직

• 엔지니어: 300명+ (전체 직원 700+)
• 문화: "Build Belonging"
• 원격 우선: 전 세계 분산 팀
• 기술 다양성: Elixir, Rust, Python, Go

기술적 도전과제

1. 초저지연: 전 세계 실시간 음성/비디오
2. 대규모 동시성: 수백만 동시 연결
3. 안정성: 게임 중 끊김 없는 통신
4. 확장성: 급격한 성장 대응

🏗️ 아키텍처 Overview

시스템 다이어그램

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Clients │────►│ Gateway │────►│ Guilds │ │(Desktop/Web)│ │ (Elixir) │ │ (Elixir) │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ │ │WebRTC SFU │ │ Message │ │ │ (Rust) │ │ Store │ │ └───────────┘ └───────────┘ │ │ │ └────────────────────┤ │ ┌─────▼─────┐ ┌─────▼─────┐ │ Media │ │ ScyllaDB │ │ Server │ │(Cassandra)│ └───────────┘ └───────────┘ 

핵심 설계 원칙

1. Erlang/OTP: 고가용성과 fault tolerance
2. Actor Model: 수백만 개의 경량 프로세스
3. Event Sourcing: 모든 상태 변경 추적
4. Microservices: 서비스별 최적 언어 선택
5. Edge Computing: 글로벌 엣지 네트워크

기술 진화

• 2015: Python 모놀리스로 시작
• 2016: Elixir/Erlang 마이그레이션
• 2017: Rust로 성능 최적화
• 2019: Go 서비스 추가
• 2021: 대규모 인프라 재설계
• 2023: AI 기능 통합

🧩 기술 스택 상세

Backend 기술

Elixir/Erlang 코어

# Discord의 Guild (서버) GenServer defmodule Discord.Guild do use GenServer defstruct [:id, :name, :owner_id, :channels, :members, :roles] # Guild 시작 def start_link(guild_id) do GenServer.start_link(__MODULE__, guild_id, name: {:via, Registry, {Discord.GuildRegistry, guild_id}}) end # 메시지 처리 def handle_cast({:message, %{channel_id: channel_id, content: content} = message}, state) do # 권한 확인 if authorized?(message.author_id, channel_id, state) do # 메시지 저장 MessageStore.save(message) # 온라인 멤버에게 브로드캐스트 state.members |> Enum.filter(&Member.online?/1) |> Enum.each(fn member -> Gateway.push(member.session_id, {:message, message}) end) # Presence 업데이트 Presence.track(self(), "guild:#{state.id}", message.author_id, %{ status: "online", typing: false }) end {:noreply, state} end # 음성 채널 참가 def handle_call({:join_voice, channel_id, user_id}, _from, state) do case VoiceServer.allocate(state.region) do {:ok, server} -> # WebRTC 연결 정보 생성 credentials = generate_webrtc_credentials(user_id) # 음성 상태 업데이트 new_state = update_voice_state(state, user_id, channel_id, server) {:reply, {:ok, %{server: server, credentials: credentials}}, new_state} {:error, reason} -> {:reply, {:error, reason}, state} end end # 대규모 Guild 최적화 defp maybe_lazy_load_members(state) do if length(state.members) > 1000 do # 대규모 서버는 멤버 지연 로딩 %{state | members: :lazy} else state end end end 

Rust 고성능 서비스

// Discord의 음성 서버 (Rust) use tokio::net::UdpSocket; use webrtc::peer_connection::RTCPeerConnection; use std::sync::Arc; use dashmap::DashMap; pub struct VoiceServer { connections: Arc<DashMap<u64, VoiceConnection>>, mixer: Arc<AudioMixer>, config: ServerConfig, } struct VoiceConnection { user_id: u64, peer_connection: RTCPeerConnection, audio_track: Arc<dyn MediaStreamTrack>, opus_encoder: OpusEncoder, jitter_buffer: JitterBuffer, } impl VoiceServer { pub async fn new(config: ServerConfig) -> Result<Self> { let socket = UdpSocket::bind(&config.bind_address).await?; Ok(Self { connections: Arc::new(DashMap::new()), mixer: Arc::new(AudioMixer::new(config.sample_rate)), config, }) } pub async fn handle_audio_packet(&self, packet: AudioPacket) -> Result<()> { // Opus 디코딩 let pcm_data = self.decode_opus(packet.data)?; // Jitter buffer에 추가 if let Some(mut conn) = self.connections.get_mut(&packet.user_id) { conn.jitter_buffer.push(pcm_data, packet.timestamp); // 믹싱을 위한 오디오 준비 if let Some(frame) = conn.jitter_buffer.pop() { self.mixer.add_source(packet.user_id, frame); } } // 다른 참가자에게 전송 self.broadcast_mixed_audio(packet.channel_id).await?; Ok(()) } async fn broadcast_mixed_audio(&self, channel_id: u64) -> Result<()> { let participants = self.get_channel_participants(channel_id); for user_id in participants { // 각 사용자별 맞춤 믹스 (자신 제외) let mixed = self.mixer.mix_excluding(user_id); // Opus 인코딩 let encoded = self.encode_opus(mixed)?; // WebRTC DataChannel로 전송 if let Some(conn) = self.connections.get(&user_id) { conn.peer_connection .send_audio(encoded) .await?; } } Ok(()) } } // 저지연 오디오 믹서 struct AudioMixer { sources: Arc<DashMap<u64, AudioSource>>, sample_rate: u32, } impl AudioMixer { fn mix_excluding(&self, exclude_user_id: u64) -> Vec<i16> { let mut output = vec![0i32; 960]; // 20ms @ 48kHz self.sources.iter() .filter(|entry| *entry.key() != exclude_user_id) .for_each(|entry| { let source = entry.value(); for (i, &sample) in source.samples.iter().enumerate() { output[i] = output[i].saturating_add(sample as i32); } }); // 클리핑 방지 output.iter() .map(|&s| (s.max(-32768).min(32767)) as i16) .collect() } } 

Backend 기술 스택:

• 언어: Elixir (50%), Rust (20%), Python (15%), Go (15%)
• 프레임워크: Phoenix (Elixir), Actix (Rust), FastAPI
• 실시간: WebSocket, WebRTC
• 메시징: NATS, RabbitMQ
• RPC: gRPC, Protobuf

Frontend 기술

React Desktop App

// Discord Desktop App (Electron + React) import { useEffect, useState } from "react"; import { Gateway } from "@discord/gateway"; import { VoiceConnection } from "@discord/voice"; interface ChannelViewProps { channelId: string; guildId: string; } export function ChannelView({ channelId, guildId }: ChannelViewProps) { const [messages, setMessages] = useState<Message[]>([]); const [voiceState, setVoiceState] = useState<VoiceState | null>(null); const gateway = useGateway(); useEffect(() => { // 실시간 메시지 구독 const unsubscribe = gateway.subscribe(`channel:${channelId}`, (event) => { switch (event.type) { case "MESSAGE_CREATE": setMessages((prev) => [...prev, event.message]); break; case "MESSAGE_UPDATE": setMessages((prev) => prev.map((msg) => msg.id === event.message.id ? event.message : msg ) ); break; case "TYPING_START": showTypingIndicator(event.userId); break; } }); return unsubscribe; }, [channelId]); // 음성 채널 연결 const joinVoiceChannel = async () => { const connection = new VoiceConnection({ guildId, channelId, selfDeaf: false, selfMute: false, }); // WebRTC 연결 설정 await connection.connect(); // 로컬 오디오 스트림 const stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, }, }); connection.setInputStream(stream); setVoiceState(connection); }; return ( <div className="channel-view"> <MessageList messages={messages} /> <MessageInput channelId={channelId} /> <VoiceControls connected={!!voiceState} onJoin={joinVoiceChannel} onLeave={() => voiceState?.disconnect()} /> </div> ); } // 최적화된 메시지 렌더링 const MessageList = React.memo(({ messages }: { messages: Message[] }) => { const virtualizer = useVirtualizer({ count: messages.length, getScrollElement: () => scrollRef.current, estimateSize: () => 50, overscan: 5, }); return ( <div ref={scrollRef} className="message-list"> {virtualizer.getVirtualItems().map((virtualItem) => ( <MessageItem key={messages[virtualItem.index].id} message={messages[virtualItem.index]} style={{ height: `${virtualItem.size}px`, transform: `translateY(${virtualItem.start}px)`, }} /> ))} </div> ); }); 

Frontend 기술:

• Desktop: Electron + React
• Web: React + TypeScript
• Mobile: React Native
• 상태관리: MobX, Zustand
• UI: 자체 디자인 시스템

Data Infrastructure

메시지 저장소

# Discord의 메시지 저장 시스템 from cassandra.cluster import Cluster from cassandra.policies import DCAwareRoundRobinPolicy import msgpack import zstd class MessageStore: def __init__(self): self.cluster = Cluster( contact_points=['scylla-1', 'scylla-2', 'scylla-3'], load_balancing_policy=DCAwareRoundRobinPolicy(local_dc='us-west') ) self.session = self.cluster.connect('discord') async def save_message(self, message): # 메시지 압축 compressed = zstd.compress( msgpack.packb({ 'content': message.content, 'embeds': message.embeds, 'attachments': message.attachments, }), level=3 ) # ScyllaDB에 저장 query = """ INSERT INTO messages ( channel_id, message_id, author_id, content, timestamp, edited_timestamp ) VALUES (?, ?, ?, ?, ?, ?) USING TTL ? """ # 메시지 보관 정책에 따른 TTL ttl = self.get_message_ttl(message.channel_id) await self.session.execute_async( query, ( message.channel_id, message.id, message.author_id, compressed, message.timestamp, message.edited_timestamp, ttl ) ) # 검색 인덱스 업데이트 await self.update_search_index(message) async def get_messages(self, channel_id, before=None, limit=50): query = """ SELECT * FROM messages WHERE channel_id = ? AND message_id < ? ORDER BY message_id DESC LIMIT ? """ rows = await self.session.execute_async( query, (channel_id, before or MAX_ID, limit) ) messages = [] for row in rows: # 압축 해제 data = msgpack.unpackb( zstd.decompress(row.content) ) messages.append(Message.from_db(row, data)) return messages 

데이터 인프라:

• 주 데이터베이스: ScyllaDB (Cassandra 호환)
• 캐시: Redis Cluster
• 검색: Elasticsearch
• 분석: Google BigQuery
• 메시지 큐: NATS, Kafka

Infrastructure & DevOps

글로벌 인프라

# Kubernetes 배포 설정 apiVersion: apps/v1 kind: StatefulSet metadata: name: discord-guild-service namespace: discord-prod spec: serviceName: guild-service replicas: 100 podManagementPolicy: Parallel selector: matchLabels: app: guild-service template: metadata: labels: app: guild-service spec: affinity: podAntiAffinity: requiredDuringSchedulingIgnoredDuringExecution: - labelSelector: matchExpressions: - key: app operator: In values: - guild-service topologyKey: kubernetes.io/hostname containers: - name: guild image: discord/guild-service:v2.3.0 resources: requests: memory: "4Gi" cpu: "2" limits: memory: "8Gi" cpu: "4" env: - name: BEAM_SCHEDULER_COUNT value: "8" - name: ERL_MAX_PORTS value: "1048576" livenessProbe: httpGet: path: /health port: 4000 initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /ready port: 4000 initialDelaySeconds: 5 periodSeconds: 5 

인프라 기술:

• 클라우드: Google Cloud Platform + 자체 데이터센터
• CDN: Cloudflare (글로벌 엣지)
• 컨테이너: Kubernetes
• 모니터링: Prometheus, Grafana, Datadog
• CI/CD: GitLab CI, ArgoCD

💡 핵심 기술 인사이트

1. Elixir/Erlang의 힘

# Discord의 분산 시스템 설계 defmodule Discord.Presence do use Phoenix.Presence, otp_app: :discord, pubsub_server: Discord.PubSub # 수백만 사용자의 presence 추적 def track_user(guild_id, user_id, meta) do track(self(), "guild:#{guild_id}", user_id, meta) end # CRDT 기반 동기화 def handle_diff(diff, state) do # Conflict-free 상태 병합 for {user_id, %{metas: [meta | _]}} <- diff.joins do # 사용자 온라인 이벤트 broadcast_user_presence(user_id, :online, meta) end for {user_id, _} <- diff.leaves do # 사용자 오프라인 이벤트 broadcast_user_presence(user_id, :offline, %{}) end {:ok, state} end end 

2. WebRTC 최적화

// 커스텀 WebRTC SFU (Selective Forwarding Unit) pub struct DiscordSFU { router: MediaRouter, bandwidth_estimator: BandwidthEstimator, quality_controller: QualityController, } impl DiscordSFU { pub async fn handle_rtp_packet(&self, packet: RtpPacket) -> Result<()> { // 1. 대역폭 추정 self.bandwidth_estimator.update(&packet); // 2. 품질 제어 (시뮬캐스트/SVC) let target_quality = self.quality_controller.decide_quality( packet.ssrc, self.bandwidth_estimator.get_estimate() ); // 3. 선택적 포워딩 let recipients = self.router.get_recipients(packet.ssrc); for recipient in recipients { // 수신자별 최적화 let adapted_packet = match recipient.connection_quality { Quality::High => packet.clone(), Quality::Medium => self.downscale_packet(&packet, 720), Quality::Low => self.downscale_packet(&packet, 480), }; // NACK, FEC 처리 recipient.send_with_redundancy(adapted_packet).await?; } Ok(()) } } 

3. 대규모 실시간 동기화

// Go로 작성된 Presence 서비스 type PresenceService struct { shards map[uint64]*PresenceShard ring *consistent.Ring redisCli *redis.ClusterClient } type PresenceShard struct { mu sync.RWMutex users map[uint64]*UserPresence lastSync time.Time } func (ps *PresenceService) UpdatePresence(userID uint64, status Status) error { // Consistent hashing으로 샤드 결정 shardID := ps.ring.Get(fmt.Sprintf("user:%d", userID)) shard := ps.shards[shardID] shard.mu.Lock() defer shard.mu.Unlock() // 로컬 업데이트 presence := &UserPresence{ UserID: userID, Status: status, UpdatedAt: time.Now(), } shard.users[userID] = presence // Redis에 비동기 동기화 go ps.syncToRedis(userID, presence) // 구독자에게 브로드캐스트 ps.broadcastUpdate(userID, presence) return nil } // 효율적인 bulk 동기화 func (ps *PresenceService) BulkSync() { ticker := time.NewTicker(5 * time.Second) defer ticker.Stop() for range ticker.C { for _, shard := range ps.shards { shard.mu.RLock() updates := make([]*UserPresence, 0, len(shard.users)) for _, presence := range shard.users { if presence.UpdatedAt.After(shard.lastSync) { updates = append(updates, presence) } } shard.mu.RUnlock() if len(updates) > 0 { ps.bulkSyncToRedis(updates) shard.lastSync = time.Now() } } } } 

📈 성과 & 지표

기술적 성과

• 메시지 지연: < 100ms (글로벌 평균)
• 음성 지연: < 60ms (동일 지역)
• 가용성: 99.95%+
• 동시 음성 채널: 수백만 개
• 메시지 처리량: 초당 수백만 건

확장성 성과

• 서버당 사용자: 최대 80만 명 (Midjourney)
• 최대 음성 참가자: 10,000명 (Stage Channels)
• 파일 업로드: 500MB (Nitro)
• 화면 공유: 4K 60fps 지원

🎓 Discord에서 배울 점

✅ 적용 가능한 패턴

1. Actor Model: Erlang/OTP의 강력함
2. 언어별 최적화: 적재적소에 최적 언어 사용
3. WebRTC SFU: 대규모 실시간 통신
4. Consistent Hashing: 분산 시스템 샤딩
5. Event Sourcing: 상태 관리와 히스토리

❌ 주의사항

1. Elixir 학습곡선: 함수형 + Actor 모델
2. 다중 언어 복잡성: 운영 오버헤드
3. 실시간 요구사항: 네트워크 품질 의존
4. 스케일 도전: 대규모 서버 관리

📚 추천 리소스

• Discord Engineering Blog
• How Discord Stores Billions of Messages
• Discord's Architecture
• Elixir in Production

🔮 미래 전망

현재 집중 분야

1. AI 통합: 대화 요약, 번역, 모더레이션
2. Forum Channels: 구조화된 대화
3. Activities: 앱 내 미니게임/활동
4. 크리에이터 수익화: 서버 구독, 티켓팅
5. 엔터프라이즈: Slack 대체 시장

기술 투자 영역

• Rust 확대: 더 많은 핵심 서비스
• AI/ML: 콘텐츠 모더레이션, 추천
• 엣지 컴퓨팅: 더 낮은 지연시간
• 블록체인: Web3 커뮤니티 지원
• AR/VR: 메타버스 통합

"우리는 단순한 채팅 앱이 아닌, 전 세계 커뮤니티가 모이는 디지털 공간을 만들고 있습니다."

• Discord Engineering

마지막 업데이트: 2025-01-28