🏢 Uber 기술 스택 분석

전 세계 10,000개 도시에서 매초 수천 건의 실시간 매칭을 처리하는 Uber의 기술 스택을 심층 분석합니다.
"Move the world, build the future" - 실시간 마켓플레이스의 기술적 도전

📊 회사 개요

서비스 규모

• 월간 활성 사용자: 1.3억 명
• 드라이버 & 배달원: 500만 명+
• 일일 트립: 2,500만 건
• 도시: 전 세계 10,000개+
• 서비스: Rides, Eats, Freight, Health

엔지니어링 조직

• 엔지니어: 3,000명+
• 기술 스택: 4,000+ 마이크로서비스
• 코드베이스: 수천만 줄
• 배포: 주당 4,000+ 배포

기술적 도전과제

1. 실시간 매칭: 수요-공급 최적화
2. 동적 가격: 서지 프라이싱 알고리즘
3. 글로벌 확장: 다양한 규제와 시장
4. 신뢰성: 24/7 가용성 필수

🏗️ 아키텍처 Overview

시스템 다이어그램

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Riders │────►│ Gateway │────►│ Dispatch │ │ App │ │ (Edge) │ │ System │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ │ │ DISCO │ │ Supply │ │ │ Matching │ │ Service │ │ └───────────┘ └───────────┘ │ │ │ ┌─────────────┐ ┌─────▼─────┐ ┌─────▼─────┐ │ Drivers │◄──────│ Kafka │◄──────│ Pricing │ │ App │ │ Streams │ │ Service │ └─────────────┘ └───────────┘ └───────────┘ 

핵심 설계 원칙

1. Domain-Oriented Architecture: 비즈니스 도메인별 분리
2. Layered Architecture: 플랫폼, 제품, 프레젠테이션 레이어
3. Event-Driven: 이벤트 기반 통신
4. Location-First: H3 기반 지리공간 인덱싱
5. Real-Time Priority: 저지연 최적화

기술 진화

• 2009-2012: PHP 모놀리스
• 2013-2015: Python/Node.js 마이크로서비스 전환
• 2016-2018: Go 도입, Schemaless 개발
• 2019-2021: gRPC 마이그레이션
• 2022-현재: 플랫폼 통합 (Rides + Eats)

🧩 기술 스택 상세

Backend 기술

Go 서비스 예시

// 지리공간 매칭 서비스 package dispatch import ( "context" "github.com/uber/h3-go" "github.com/uber/ringpop-go" ) type DispatchService struct { supplyIndex *H3Index demandQueue *PriorityQueue ringpop *ringpop.Ringpop priceEngine PricingClient } func (s *DispatchService) FindOptimalMatch(ctx context.Context, req *RideRequest) (*Match, error) { // H3 셀 기반 근처 드라이버 검색 h3Cell := h3.GeoToH3(req.Pickup.Lat, req.Pickup.Lng, 9) nearbyDrivers := s.supplyIndex.GetDriversInRadius(h3Cell, 2000) // 2km // 동적 가격 계산 surge, err := s.priceEngine.CalculateSurge(ctx, &SurgeRequest{ H3Cell: h3Cell, Timestamp: time.Now(), SupplyCount: len(nearbyDrivers), DemandCount: s.demandQueue.GetDemandCount(h3Cell), }) // 최적 매칭 알고리즘 matches := []Match{} for _, driver := range nearbyDrivers { score := s.calculateMatchScore(req, driver, surge) if score > MinMatchThreshold { matches = append(matches, Match{ Driver: driver, Rider: req.RiderID, Score: score, ETA: driver.ETA, Fare: s.calculateFare(req, surge), }) } } // 최고 점수 매치 반환 sort.Slice(matches, func(i, j int) bool { return matches[i].Score > matches[j].Score }) if len(matches) > 0 { return &matches[0], nil } return nil, ErrNoMatchFound } 

주요 백엔드 기술:

• 언어: Go (60%), Java (25%), Python (10%), Node.js (5%)
• RPC: gRPC, TChannel (레거시)
• API Gateway: Edge Gateway (자체 개발)
• 서비스 메시: Envoy Proxy
• 메시징: Apache Kafka, Celery

마이크로서비스 아키텍처

# 주요 도메인 서비스 services: # 핵심 비즈니스 - name: dispatch-service language: go dependencies: [supply, demand, pricing] - name: pricing-service language: java dependencies: [ml-platform, surge-engine] - name: payment-service language: java dependencies: [risk, fraud-detection] # 플랫폼 서비스 - name: user-platform language: java dependencies: [auth, profile, preferences] - name: geospatial-platform language: go dependencies: [h3-index, routing, maps] - name: ml-platform language: python dependencies: [feature-store, model-serving] 

Frontend 기술

모바일 앱 아키텍처

// iOS 라이더 앱 아키텍처 class RideRequestViewController: UIViewController { private let locationManager = LocationManager() private let networkClient = UberAPIClient() private let mapView = MapboxMapView() func requestRide() { // 실시간 위치 추적 locationManager.startUpdatingLocation { location in self.updatePickupLocation(location) } // 실시간 공급 상황 표시 networkClient.streamNearbyDrivers { drivers in self.mapView.updateDriverPositions(drivers) } // 요금 추정 networkClient.estimateFare( from: pickupLocation, to: destinationLocation ) { fare in self.showFareEstimate(fare) } } } 

플랫폼별 기술:

• iOS: Swift, RIBs 아키텍처
• Android: Kotlin, MVP/MVVM
• Web: React, TypeScript, GraphQL
• Driver App: React Native (일부), Native

RIBs 아키텍처

// Router-Interactor-Builder 패턴 protocol RideRequestRouting: ViewableRouting { func routeToLocationPicker() func routeToPaymentSelection() func routeToRideStatus() } class RideRequestInteractor: PresentableInteractor<RideRequestPresentable> { weak var router: RideRequestRouting? private let rideService: RideService func requestRide(pickup: Location, destination: Location) { rideService.createRideRequest(pickup: pickup, destination: destination) .subscribe(onNext: { [weak self] rideStatus in self?.router?.routeToRideStatus() }) .disposed(by: disposeBag) } } 

Data & Infrastructure

데이터 아키텍처

-- Schemaless 데이터 모델 (MySQL 기반) CREATE TABLE entities ( entity_type VARCHAR(50), entity_id BINARY(16), attribute_name VARCHAR(100), attribute_value JSON, version BIGINT, updated_at TIMESTAMP, PRIMARY KEY (entity_type, entity_id, attribute_name, version) ); -- 예시: 라이드 데이터 INSERT INTO entities VALUES ('ride', UUID_TO_BIN('...'), 'status', '{"value": "completed"}', 1, NOW()), ('ride', UUID_TO_BIN('...'), 'fare', '{"amount": 25.50, "currency": "USD"}', 1, NOW()), ('ride', UUID_TO_BIN('...'), 'route', '{"distance": 10.5, "duration": 900}', 1, NOW()); 

데이터 저장소:

• Schemaless: MySQL 기반 NoSQL (자체 개발)
• Docstore: 문서 저장소
• Apache Cassandra: 시계열 데이터
• HDFS: 데이터 레이크
• Redis: 캐싱, 세션

H3 지리공간 시스템

// Uber의 H3 육각형 그리드 시스템 type H3Index struct { resolution int index map[h3.H3Index]*Cell } type Cell struct { drivers []*Driver demand float64 surge float64 lastUpdate time.Time } func (idx *H3Index) UpdateSupply(lat, lng float64, driverID string) { cell := h3.GeoToH3(lat, lng, idx.resolution) idx.mu.Lock() defer idx.mu.Unlock() if idx.index[cell] == nil { idx.index[cell] = &Cell{} } idx.index[cell].drivers = append(idx.index[cell].drivers, &Driver{ ID: driverID, Location: geo.NewPoint(lat, lng), Status: "available", }) } 

ML & 데이터 사이언스

Michelangelo ML 플랫폼

# 수요 예측 모델 from michelangelo import Model, Feature, Pipeline class DemandForecastModel(Model): def __init__(self): self.features = [ Feature("h3_cell", type="categorical"), Feature("hour_of_day", type="numeric"), Feature("day_of_week", type="categorical"), Feature("weather", type="categorical"), Feature("events_nearby", type="numeric"), Feature("historical_demand", type="time_series"), ] def train(self, training_data): # XGBoost 모델 학습 self.model = XGBRegressor( n_estimators=1000, max_depth=8, learning_rate=0.01 ) X = self.prepare_features(training_data) y = training_data["demand_count"] self.model.fit(X, y) def predict(self, h3_cell, timestamp): features = self.extract_features(h3_cell, timestamp) return self.model.predict(features)[0] 

ML 사용 사례:

• 수요 예측: 15분 단위 예측
• 동적 가격: 실시간 서지 계산
• ETA 예측: 도착 시간 추정
• 사기 탐지: 실시간 위험 평가
• 경로 최적화: 최단 경로 계산

DevOps & Infrastructure

배포 파이프라인

# uDeploy 배포 설정 deployment: service: dispatch-service stages: - name: development clusters: [dev-us-west-2] canary_percentage: 0 - name: staging clusters: [staging-us-west-2] canary_percentage: 10 duration: 30m - name: production clusters: [prod-us-west-2, prod-eu-west-1, prod-ap-south-1] canary_percentage: 1 increment: 10 duration: 2h health_checks: - endpoint: /health interval: 10s threshold: 3 rollback: automatic: true error_rate_threshold: 0.1 latency_threshold_p99: 500ms 

DevOps 도구:

• uDeploy: 자체 배포 시스템
• Phabricator: 코드 리뷰 (현재 GitHub 이전 중)
• M3: 메트릭 시스템 (Prometheus 기반)
• Jaeger: 분산 트레이싱
• PagerDuty: 인시던트 관리

💡 핵심 기술 인사이트

1. DISCO (Dispatch Optimization)

# 실시간 매칭 최적화 class DISCOOptimizer: def optimize_batch(self, riders, drivers): # 이분 그래프 매칭 문제 graph = BipartiteGraph() for rider in riders: for driver in drivers: if self.is_matchable(rider, driver): weight = self.calculate_match_value(rider, driver) graph.add_edge(rider.id, driver.id, weight) # Hungarian 알고리즘으로 최적 매칭 matches = graph.maximum_weight_matching() return matches def calculate_match_value(self, rider, driver): # 다중 목표 최적화 pickup_time = self.estimate_pickup_time(rider, driver) driver_utilization = self.get_driver_utilization(driver) rider_wait_time = self.get_rider_wait_time(rider) # 가중치 조합 value = ( - 0.4 * pickup_time - 0.3 * rider_wait_time + 0.3 * driver_utilization ) return value 

2. 서지 프라이싱

// 동적 가격 책정 엔진 type SurgePricingEngine struct { mlModel MLModel constraints PricingConstraints } func (e *SurgePricingEngine) CalculateSurge(ctx context.Context, cell h3.H3Index) float64 { // 실시간 수요-공급 비율 supply := e.getSupplyCount(cell) demand := e.getDemandCount(cell) ratio := float64(demand) / float64(supply) // ML 모델 예측 features := e.extractFeatures(cell) predictedDemand := e.mlModel.Predict(features) // 서지 계산 var surge float64 if ratio > 1.5 { surge = min( 1.0 + (ratio-1.5)*0.5, e.constraints.MaxSurge, ) } // 규제 준수 surge = e.applyLocalRegulations(cell, surge) return surge } 

3. 글로벌 확장 플랫폼

// 다중 지역 구성 관리 @Component public class RegionalConfigService { private final Map<String, RegionalConfig> configs; @PostConstruct public void loadConfigs() { // 지역별 규제 및 기능 로드 configs = Map.of( "US", new RegionalConfig() .withTipping(true) .withUpfrontPricing(true) .withSurgeMultiplier(3.0), "EU", new RegionalConfig() .withGDPRCompliance(true) .withFixedPricing(true) .withSurgeMultiplier(2.0), "IN", new RegionalConfig() .withCashPayments(true) .withAutoRickshaw(true) .withSurgeMultiplier(2.5) ); } } 

📈 성과 & 지표

기술적 성과

• 매칭 시간: 평균 15초 이내
• 시스템 가용성: 99.99%
• API 응답시간: P50 < 100ms, P99 < 500ms
• 배포 빈도: 일일 1,000+ 배포
• 서비스 수: 4,000+ 마이크로서비스

규모 지표

• 일일 트립: 2,500만 건
• 피크 시간 RPS: 500,000+
• 데이터 처리: 일일 수 PB
• ML 예측: 초당 수백만 건

🎓 Uber에서 배울 점

✅ 적용 가능한 패턴

1. H3 지리공간 인덱싱: 효율적인 위치 기반 검색
2. Schemaless 설계: 유연한 데이터 모델
3. RIBs 아키텍처: 모바일 앱 구조화
4. 배치 매칭: 효율성 극대화
5. Circuit Breaker: 장애 격리

❌ 주의사항

1. 복잡성 관리: 4000+ 서비스는 관리 어려움
2. 기술 부채: 레거시 시스템 마이그레이션
3. 조직 사일로: 팀 간 협업 어려움
4. 비용: 대규모 인프라 운영비

📚 추천 리소스

• Uber Engineering Blog
• H3 Documentation
• RIBs Architecture
• Cadence Workflow

🔮 미래 전망

현재 집중 분야

1. 자율주행: ATG 기술 통합
2. 멀티모달: 다양한 이동 수단 통합
3. Uber Freight: B2B 물류 혁신
4. 금융 서비스: Uber Money
5. 슈퍼앱: 통합 플랫폼화

기술 투자 영역

• 실시간 ML: 더 정교한 예측
• 엣지 컴퓨팅: 저지연 처리
• 블록체인: 공급망 추적
• AR/VR: 향상된 사용자 경험

"우리는 단순히 차량을 호출하는 앱이 아닙니다. 우리는 도시의 OS를 만들고 있습니다."

• Uber Engineering

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