🏢 네이버 기술 스택 분석

한국 최대 검색 포털에서 글로벌 기술 플랫폼으로 진화한 네이버의 기술 스택을 심층 분석합니다.
"기술 플랫폼의 경계를 넘어" - 검색부터 AI까지 모든 것을 아우르는 기술력

📊 회사 개요

서비스 규모

• 일일 활성 사용자: 3,000만+ 명
• 월간 검색: 20억+ 건
• 서비스: 50+ 개 (검색, 쇼핑, 페이, 웹툰, 클라우드 등)
• 데이터 저장량: 100PB+
• 분당 요청: 1,000만+ 건

엔지니어링 조직

• 개발자: 3,000명+ (전체 직원 4,500+)
• 문화: "기술이 미래를 만든다"
• R&D 센터: 춘천, 대전, 일본, 베트남
• 오픈소스: 200+ 프로젝트 공개

기술적 도전과제

1. 초대규모 검색: 수십억 웹 페이지 인덱싱
2. 실시간 처리: 뉴스, 실시간 검색어
3. AI/ML: 한국어 자연어 처리
4. 글로벌 확장: 일본, 동남아 서비스

🏗️ 아키텍처 Overview

시스템 다이어그램

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Search │────►│ Query │────►│ Index │ │ Frontend │ │ Processor │ │ Cluster │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ │ │ Cache │ │ Hadoop │ │ │ (Arcus) │ │ Cluster │ │ └───────────┘ └───────────┘ │ │ │ └────────────────────┤ │ ┌─────▼─────┐ ┌─────▼─────┐ │ API │ │ ML │ │ Gateway │ │ Platform │ └───────────┘ └───────────┘ 

핵심 설계 원칙

1. Scalability First: 무한 확장 가능
2. High Availability: 24/7 무중단
3. Data-Driven: 모든 결정은 데이터로
4. Open Innovation: 오픈소스 우선
5. Global Standard: 글로벌 수준 기술

기술 진화

• 1999-2005: 검색 엔진 개발
• 2006-2010: 플랫폼화, 오픈 API
• 2011-2015: 빅데이터, 클라우드
• 2016-2020: AI/ML, 글로벌 확장
• 2021-현재: 초거대 AI, 메타버스

🧩 기술 스택 상세

검색 엔진 기술

대규모 검색 시스템

// 네이버 검색 엔진 핵심 (Java) @Component public class NaverSearchEngine { private final IndexManager indexManager; private final QueryProcessor queryProcessor; private final RankingEngine rankingEngine; private final CacheManager cacheManager; @GetMapping("/search") public SearchResult search( @RequestParam String query, @RequestParam(defaultValue = "1") int page, @RequestParam(defaultValue = "unified") String collection) { // 1. 쿼리 정규화 및 분석 NormalizedQuery normalized = queryProcessor.normalize(query); // 캐시 확인 String cacheKey = generateCacheKey(normalized, page, collection); SearchResult cached = cacheManager.get(cacheKey); if (cached != null && !isRealTimeQuery(normalized)) { return cached; } // 2. 쿼리 분석 QueryAnalysis analysis = analyzeQuery(normalized); // 3. 컬렉션별 검색 List<CollectionResult> results = new ArrayList<>(); if (collection.equals("unified")) { // 통합검색 results = searchAllCollections(analysis); } else { // 특정 컬렉션 검색 results.add(searchCollection(collection, analysis)); } // 4. 랭킹 및 정렬 SearchResult finalResult = rankingEngine.rank(results, analysis); // 5. 캐시 저장 if (!isRealTimeQuery(normalized)) { cacheManager.put(cacheKey, finalResult, getTTL(collection)); } return finalResult; } private QueryAnalysis analyzeQuery(NormalizedQuery query) { QueryAnalysis analysis = new QueryAnalysis(); // 형태소 분석 List<Token> tokens = morphAnalyzer.analyze(query.getText()); analysis.setTokens(tokens); // 의도 분석 Intent intent = intentClassifier.classify(query, tokens); analysis.setIntent(intent); // 엔티티 추출 List<Entity> entities = entityExtractor.extract(tokens); analysis.setEntities(entities); // 쿼리 카테고리 분류 Category category = categoryClassifier.classify(query, entities); analysis.setCategory(category); return analysis; } private List<CollectionResult> searchAllCollections(QueryAnalysis analysis) { // 병렬 검색 실행 CompletableFuture<CollectionResult> webFuture = CompletableFuture.supplyAsync(() -> searchWeb(analysis)); CompletableFuture<CollectionResult> newsFuture = CompletableFuture.supplyAsync(() -> searchNews(analysis)); CompletableFuture<CollectionResult> blogFuture = CompletableFuture.supplyAsync(() -> searchBlog(analysis)); CompletableFuture<CollectionResult> shoppingFuture = CompletableFuture.supplyAsync(() -> searchShopping(analysis)); // 결과 수집 return Stream.of(webFuture, newsFuture, blogFuture, shoppingFuture) .map(CompletableFuture::join) .filter(result -> result.getCount() > 0) .collect(Collectors.toList()); } } // 분산 인덱싱 시스템 @Service public class DistributedIndexer { private final HBaseClient hbaseClient; private final ElasticsearchClient esClient; private final KafkaProducer<String, IndexDocument> producer; public void indexDocument(Document document) { // 1. 문서 전처리 ProcessedDocument processed = preprocessDocument(document); // 2. 분산 저장 // HBase에 원본 저장 hbaseClient.put( "documents", document.getId(), processed.toHBaseRow() ); // 3. 역인덱스 생성 InvertedIndex invertedIndex = createInvertedIndex(processed); // 4. Elasticsearch 인덱싱 esClient.index( "web_index", document.getId(), invertedIndex.toElasticsearchDocument() ); // 5. 실시간 업데이트 전파 producer.send(new ProducerRecord<>( "index-updates", document.getId(), new IndexDocument(document.getId(), processed, invertedIndex) )); } private InvertedIndex createInvertedIndex(ProcessedDocument doc) { InvertedIndex index = new InvertedIndex(); // 토큰화 및 위치 정보 저장 Map<String, List<Position>> tokenPositions = new HashMap<>(); List<Token> tokens = tokenizer.tokenize(doc.getContent()); for (int i = 0; i < tokens.size(); i++) { Token token = tokens.get(i); tokenPositions.computeIfAbsent(token.getValue(), k -> new ArrayList<>()) .add(new Position(i, token.getOffset(), token.getLength())); } // TF-IDF 계산 for (Map.Entry<String, List<Position>> entry : tokenPositions.entrySet()) { String term = entry.getKey(); List<Position> positions = entry.getValue(); double tf = (double) positions.size() / tokens.size(); double idf = Math.log(totalDocuments / getDocumentFrequency(term)); index.addTerm(term, positions, tf * idf); } return index; } } 

실시간 검색어 처리

// 실시간 급상승 검색어 시스템 @Component public class RealtimeSearchTrendAnalyzer { private final RedisTemplate<String, SearchQuery> redisTemplate; private final TimeSeriesDB tsdb; // 검색 쿼리 수집 @EventListener public void collectSearchQuery(SearchEvent event) { String query = event.getQuery(); long timestamp = event.getTimestamp(); // 시간대별 집계 String minuteKey = getMinuteKey(timestamp); redisTemplate.opsForZSet().incrementScore( minuteKey, query, 1.0 ); // 시계열 데이터 저장 tsdb.addPoint( "search.queries", timestamp, 1.0, Tags.of("query", query) ); } // 급상승 검색어 계산 @Scheduled(fixedDelay = 60000) // 1분마다 public void calculateTrends() { long now = System.currentTimeMillis(); // 최근 10분 vs 이전 10분 비교 Map<String, Double> recent = getQueryCounts(now - 10 * MINUTE, now); Map<String, Double> previous = getQueryCounts(now - 20 * MINUTE, now - 10 * MINUTE); List<TrendingQuery> trends = new ArrayList<>(); for (Map.Entry<String, Double> entry : recent.entrySet()) { String query = entry.getKey(); double recentCount = entry.getValue(); double previousCount = previous.getOrDefault(query, 1.0); // 증가율 계산 double growthRate = (recentCount - previousCount) / previousCount; // 급상승 조건: 200% 이상 증가 & 최소 검색수 100회 if (growthRate > 2.0 && recentCount > 100) { trends.add(new TrendingQuery( query, recentCount, growthRate, calculateHotScore(recentCount, growthRate, now) )); } } // 상위 20개 선정 trends.sort((a, b) -> Double.compare(b.getHotScore(), a.getHotScore())); List<TrendingQuery> top20 = trends.stream() .limit(20) .collect(Collectors.toList()); // 결과 저장 및 전파 publishTrends(top20); } private double calculateHotScore(double count, double growth, long timestamp) { // Newton's law of cooling 응용 long age = System.currentTimeMillis() - timestamp; double timeFactor = Math.exp(-age / (5.0 * MINUTE)); return count * growth * timeFactor; } } 

빅데이터 플랫폼

Hadoop 기반 데이터 처리

// 네이버 C3 (Cloud Computing Center) 플랫폼 public class NaverBigDataPlatform { // MapReduce Job for 로그 분석 public static class LogAnalysisMapper extends Mapper<LongWritable, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); @Override protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { // 로그 파싱 LogEntry entry = LogParser.parse(value.toString()); // 검색 쿼리 추출 if (entry.getType() == LogType.SEARCH) { String query = entry.getQuery(); // 형태소 분석 List<String> tokens = MorphAnalyzer.analyze(query); for (String token : tokens) { word.set(token); context.write(word, one); } } // 사용자 행동 분석 String userId = entry.getUserId(); String action = entry.getAction(); context.write(new Text(userId + ":" + action), one); } } public static class LogAnalysisReducer extends Reducer<Text, IntWritable, Text, IntWritable> { @Override protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } context.write(key, new IntWritable(sum)); } } // Spark Streaming for 실시간 분석 public void runRealtimeAnalysis() { SparkConf conf = new SparkConf() .setAppName("NaverRealtimeAnalysis") .set("spark.streaming.kafka.maxRatePerPartition", "10000"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(10)); // Kafka 스트림 생성 JavaPairInputDStream<String, String> messages = KafkaUtils.createDirectStream( jssc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topicsSet ); // 실시간 로그 처리 JavaDStream<LogEntry> logs = messages .map(tuple -> LogParser.parse(tuple._2())); // 윈도우 기반 집계 JavaPairDStream<String, Integer> searchCounts = logs .filter(log -> log.getType() == LogType.SEARCH) .mapToPair(log -> new Tuple2<>(log.getQuery(), 1)) .reduceByKeyAndWindow( (a, b) -> a + b, Durations.minutes(10), Durations.minutes(1) ); // HBase에 저장 searchCounts.foreachRDD(rdd -> { rdd.foreachPartition(partition -> { HBaseConnection conn = HBaseConnectionPool.getConnection(); Table table = conn.getTable(TableName.valueOf("search_trends")); partition.forEachRemaining(record -> { Put put = new Put(Bytes.toBytes(record._1())); put.addColumn( Bytes.toBytes("counts"), Bytes.toBytes("value"), Bytes.toBytes(record._2()) ); table.put(put); }); table.close(); }); }); jssc.start(); jssc.awaitTermination(); } } 

캐싱 시스템 (Arcus)

분산 캐시 구현

// 네이버가 개발한 Arcus (memcached 클러스터) @Component public class ArcusCache { private final ArcusClient arcusClient; @PostConstruct public void init() { // Arcus 클라이언트 초기화 ConnectionFactoryBuilder cfb = new ConnectionFactoryBuilder(); cfb.setProtocol(Protocol.TEXT); cfb.setFailureMode(FailureMode.Cancel); arcusClient = ArcusClient.createArcusClient( "naver-search-cache", new ZKConnectionFactory(zkAddress), cfb ); } public <T> T get(String key, Class<T> type) { try { Future<Object> future = arcusClient.asyncGet(key); Object value = future.get(100, TimeUnit.MILLISECONDS); if (value != null) { return objectMapper.convertValue(value, type); } } catch (TimeoutException e) { // 캐시 타임아웃 - 통과 log.debug("Cache timeout for key: {}", key); } catch (Exception e) { log.error("Cache error for key: {}", key, e); } return null; } public void set(String key, Object value, int ttl) { try { String json = objectMapper.writeValueAsString(value); arcusClient.set(key, ttl, json); } catch (Exception e) { log.error("Failed to set cache for key: {}", key, e); } } // Collection 타입 지원 public void addToList(String key, Object value) { CollectionAttributes attrs = new CollectionAttributes(); attrs.setMaxCount(1000); attrs.setExpireTime(3600); arcusClient.asyncLopInsert( key, -1, // tail insert objectMapper.writeValueAsString(value), attrs ); } public List<String> getList(String key, int count) { CollectionFuture<List<Object>> future = arcusClient.asyncLopGet(key, 0, count, false, false); try { List<Object> result = future.get(100, TimeUnit.MILLISECONDS); return result.stream() .map(Object::toString) .collect(Collectors.toList()); } catch (Exception e) { return Collections.emptyList(); } } } 

AI/ML 플랫폼

CLOVA AI 시스템

# 네이버 CLOVA 자연어 처리 import torch import torch.nn as nn from transformers import BertModel, BertTokenizer class ClovaNLPEngine: def __init__(self): # 한국어 특화 BERT 모델 self.tokenizer = BertTokenizer.from_pretrained('naver/kobert') self.model = KoBertForSequenceClassification.from_pretrained('naver/kobert') # GPU 사용 self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') self.model.to(self.device) def analyze_intent(self, query: str) -> IntentResult: # 토큰화 inputs = self.tokenizer( query, return_tensors='pt', padding=True, truncation=True, max_length=128 ) # 의도 분류 with torch.no_grad(): outputs = self.model(**inputs.to(self.device)) predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) # 상위 의도 추출 top_intents = [] for idx, prob in enumerate(predictions[0]): if prob > 0.1: # 10% 이상 확률 top_intents.append({ 'intent': self.intent_labels[idx], 'confidence': float(prob) }) return IntentResult( query=query, intents=sorted(top_intents, key=lambda x: x['confidence'], reverse=True) ) def extract_entities(self, text: str) -> List[Entity]: # NER (Named Entity Recognition) tokens = self.tokenizer.tokenize(text) inputs = self.tokenizer(text, return_tensors='pt') with torch.no_grad(): outputs = self.ner_model(**inputs.to(self.device)) predictions = torch.argmax(outputs.logits, dim=2) # BIO 태깅 디코딩 entities = [] current_entity = None for idx, (token, label_id) in enumerate(zip(tokens, predictions[0])): label = self.ner_labels[label_id] if label.startswith('B-'): if current_entity: entities.append(current_entity) current_entity = { 'text': token.replace('##', ''), 'type': label[2:], 'start': idx, 'end': idx } elif label.startswith('I-') and current_entity: current_entity['text'] += token.replace('##', '') current_entity['end'] = idx else: if current_entity: entities.append(current_entity) current_entity = None return entities # Papago 번역 엔진 class PapagoTranslator: def __init__(self): self.models = {} self.load_models() def translate(self, text: str, source: str, target: str) -> str: # 언어 쌍별 특화 모델 선택 model_key = f"{source}_{target}" if model_key not in self.models: model_key = "multilingual" model = self.models[model_key] # 전처리 preprocessed = self.preprocess(text, source) # 번역 translated = model.translate(preprocessed) # 후처리 postprocessed = self.postprocess(translated, target) return postprocessed def preprocess(self, text: str, lang: str) -> str: # 언어별 전처리 if lang == 'ko': # 한국어 특수 처리 text = self.normalize_korean(text) elif lang == 'ja': # 일본어 특수 처리 text = self.normalize_japanese(text) return text 

모니터링 시스템 (Pinpoint)

APM (Application Performance Management)

// 네이버가 개발한 Pinpoint APM @Aspect @Component public class PinpointTracer { private final TraceContext traceContext; @Around("@annotation(Traced)") public Object trace(ProceedingJoinPoint joinPoint) throws Throwable { // 트레이스 시작 Trace trace = traceContext.currentTraceObject(); if (trace == null) { trace = traceContext.newTraceObject(); } SpanEventRecorder recorder = trace.traceBlockBegin(); try { // 메서드 정보 기록 recorder.recordServiceType(ServiceType.SPRING); recorder.recordApi(getMethodDescriptor(joinPoint)); // 실행 Object result = joinPoint.proceed(); // 성공 기록 recorder.recordException(false); return result; } catch (Throwable t) { // 예외 기록 recorder.recordException(t); throw t; } finally { // 트레이스 종료 trace.traceBlockEnd(); // 성능 메트릭 수집 long elapsed = trace.getElapsedTime(); if (elapsed > SLOW_THRESHOLD) { recordSlowTrace(joinPoint, elapsed); } } } // 분산 트레이싱 @Component public class DistributedTracer { public void propagateTrace(HttpRequest request) { Trace trace = traceContext.currentTraceObject(); if (trace != null) { // 트레이스 ID 전파 request.addHeader("Pinpoint-TraceID", trace.getTraceId().toString()); request.addHeader("Pinpoint-SpanID", trace.getSpanId()); request.addHeader("Pinpoint-pSpanID", trace.getParentSpanId()); request.addHeader("Pinpoint-Sampled", String.valueOf(trace.canSampled())); request.addHeader("Pinpoint-Flags", String.valueOf(trace.getFlags())); } } public void continueTrace(HttpServletRequest request) { String traceId = request.getHeader("Pinpoint-TraceID"); if (traceId != null) { // 전파된 트레이스 계속 TraceId remoteTraceId = TraceId.parse(traceId); long parentSpanId = Long.parseLong(request.getHeader("Pinpoint-pSpanID")); Trace trace = traceContext.continueTraceObject(remoteTraceId, parentSpanId); trace.recordAcceptorHost(request.getRemoteAddr()); trace.recordRpc(request.getRequestURI()); } } } } 

기술 스택 요약:

• Backend: Java, Spring, Node.js
• 검색: Elasticsearch, Lucene, 자체 엔진
• 빅데이터: Hadoop, Spark, HBase
• 캐시: Arcus (자체 개발), Redis
• 데이터베이스: MySQL, MongoDB, Cassandra
• 인프라: 자체 데이터센터, NBP (Naver Business Platform)
• 모니터링: Pinpoint (자체 개발)
• AI/ML: TensorFlow, PyTorch, CLOVA

💡 핵심 기술 인사이트

1. 검색 기술의 정수

• 한국어 특화 형태소 분석
• 실시간 인덱싱
• 의도 기반 검색

2. 오픈소스 기여

• Pinpoint APM
• Arcus Cache Cluster
• nGrinder 성능 테스트

3. AI 기술 선도

• CLOVA AI 플랫폼
• Papago 번역
• 초거대 AI HyperCLOVA

📈 성과 & 지표

기술적 성과

• 검색 응답시간: < 50ms
• 시스템 가용성: 99.95%+
• 일일 처리 데이터: 10TB+
• 동시 접속자: 500만+ 명
• API 호출: 분당 1,000만+ 건

비즈니스 영향

• 국내 검색 점유율: 60%+
• 글로벌 진출: 일본 LINE, 동남아
• AI 서비스: 10+ 개 출시
• 개발자 생태계: 10만+ 개발자

🎓 네이버에서 배울 점

✅ 적용 가능한 패턴

1. 대규모 검색 시스템: 분산 인덱싱
2. 실시간 처리: 스트리밍 아키텍처
3. 캐싱 전략: 다층 캐시 구조
4. 오픈소스화: 핵심 기술 공개
5. AI 통합: 검색과 AI의 융합

❌ 주의사항

1. 운영 복잡도: 수많은 서비스 관리
2. 레거시 부담: 오래된 시스템 유지
3. 규모의 저주: 작은 변경도 큰 영향
4. 경쟁 압박: 글로벌 기업과 경쟁

📚 추천 리소스

• 네이버 D2
• DEVIEW 컨퍼런스
• 네이버 오픈소스
• 네이버 Engineering

🔮 미래 전망

현재 집중 분야

1. 초거대 AI: HyperCLOVA X
2. 로봇공학: 서비스 로봇
3. 디지털 트윈: 제2사옥 활용
4. 클라우드: NBP 글로벌 확장
5. 메타버스: 제페토, 아크버스

기술 투자 영역

• 양자 컴퓨팅: 미래 검색 기술
• 블록체인: LINE 블록체인
• 자율주행: 네이버랩스
• 5G/6G: 초연결 서비스
• 그린 IT: 친환경 데이터센터

"기술이 사람을 더 가깝게, 정보를 더 유용하게, 세상을 더 편리하게 만듭니다."

• 네이버 기술 조직

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