검색 엔진(Search Engine)은 어떻게 설계하나요?

김상욱·2024년 12월 22일

검색 엔진(Search Engine)은 어떻게 설계하나요?

검색 엔진(Search Engine)은 인터넷 상의 방대한 정보를 효율적으로 수집, 저장, 검색하여 사용자에게 필요한 정보를 빠르게 제공하는 시스템입니다.

1. 크롤링(Crawling)

크롤러(Crawler) 또는 스파이더(Spider)는 웹 페이지를 자동으로 탐색하고 데이터를 수집하는 역할을 합니다. 크롤러는 시작 URL 목록에서부터 시작하여 링크를 따라가며 웹 페이지를 방문하고 콘텐츠를 수집합니다.

HTTP 요청 : Java에서는 HttpClient나 Jsoup과 같은 라이브러리를 사용하여 웹 페이지에 요청을 보낼 수 있습니다.
병렬 처리 : 대량의 웹 페이지를 효율적으로 크롤링하기 위해 멀티스레딩이나 비동기 처리를 고려해야 합니다. Spring에서는 @Async를 활용할 수 있습니다.
URL 관리 : 방문한 URL과 방문할 URL을 관리하기 위한 데이터 구조가 필요합니다. 예를 들어, Queue와 Set을 사용하여 중복 방문을 방지할 수 있습니다.

@Service
public class CrawlerService {
    
    private Set<String> visited = ConcurrentHashMap.newKeySet();
    private Queue<String> queue = new ConcurrentLinkedQueue<>();

    public void startCrawling(String startUrl) {
        queue.add(startUrl);
        while(!queue.isEmpty()) {
            String url = queue.poll();
            if (visited.contains(url)) continue;
            visited.add(url);
            // HTTP 요청 및 페이지 파싱 로직
            // 새로운 링크를 queue에 추가
        }
    }
}

2. 인덱싱(Indexing)

인덱싱은 수집된 웹 페이지의 콘텐츠를 분석하고 구조화하여 빠른 검색이 가능하도록 데이터베이스에 저장하는 과정입니다. 일반적으로 역인덱스(Inverted Index)를 사용하여 단어와 해당 단어가 포함된 문서 간의 매핑을 생성합니다.

구현 시 고려 사항

데이터 저장소 : 검색 성능을 높이기 위해 NoSQL 데이터베이스나 관계형 데이터베이스를 사용할 수 있습니다.
데이터 구조 : 역인덱스는 단어를 키로 하고, 해당 단어가 포함된 문서 ID 목록을 값으로 저장합니다.
토큰화 및 정규화 : 텍스트 데이터를 분석하여 단어 단위로 분리하고, 소문자 변환, 불용어 제거 등의 전처리를 수행합니다.

@Service
public class IndexingService {
    
    private Map<String, Set<Long>> invertedIndex = new ConcurrentHashMap<>();

    public void indexDocument(Long docId, String content) {
        String[] tokens = content.toLowerCase().split("\\W+");
        for(String token : tokens) {
            invertedIndex.computeIfAbsent(token, k -> ConcurrentHashMap.newKeySet()).add(docId);
        }
    }

    public Map<String, Set<Long>> getInvertedIndex() {
        return invertedIndex;
    }
}

3. 검색(Query Processing)

사용자가 검색어를 입력하면, 검색 엔진은 이를 처리하여 관련된 문서를 찾아 반환합니다. 이 과정에서는 사용자의 쿼리를 분석하고, 인덱스에서 관련 문서를 검색합니다.

구현 시 고려 사항

쿼리 파싱 : 사용자의 입력을 토큰화하고, 불용어 제거, 어간 추출 등의 전처리를 수행합니다.
검색 알고리즘 : 단순한 키워드 매칭부터 TF-IDF, BM25와 같은 고급 알고리즘을 사용할 수 있습니다.
결과 정렬 : 관련성에 따라 결과를 정렬합니다.

@Service
public class SearchService {
    
    @Autowired
    private IndexingService indexingService;

    public Set<Long> search(String query) {
        String[] tokens = query.toLowerCase().split("\\W+");
        Set<Long> result = new HashSet<>();
        for(String token : tokens) {
            Set<Long> docs = indexingService.getInvertedIndex().get(token);
            if(docs != null) {
                result.addAll(docs);
            }
        }
        return result;
    }
}

4. 랭킹(Ranking)

검색 결과를 단순히 관련 문서로 나열하는 것보다는, 사용자에게 가장 유용한 문서를 먼저 보여주는 것이 중요합니다. 이를 위해 문서의 중요도나 관련성을 평가하여 순위를 매깁니다.
구현 시 고려 사항

TF-IDF : 단어 빈도(TF)와 역문서 빈도(IDF)를 활용하여, 문서의 중요도를 계산합니다.
페이지랭크(PageRank) : 링크 구조를 분석하여 페이지의 권위성을 판단합니다.
사용자 행동 데이터 : 클릭률, 체류 시간 등 사용자 데이터를 활용할 수 있습니다.

@Service
public class RankingService {
    
    public double calculateTFIDF(String term, int termFreq, int docFreq, int totalDocs) {
        double tf = 1 + Math.log(termFreq);
        double idf = Math.log((double) totalDocs / (1 + docFreq));
        return tf * idf;
    }

    public List<Long> rankDocuments(Set<Long> docs, String query, int totalDocs) {
        Map<Long, Double> docScores = new HashMap<>();
        for(Long docId : docs) {
            // 각 문서에 대해 TF-IDF 점수 계산
            double score = 0.0;
            // 예: query의 각 단어에 대해 점수를 더함
            docScores.put(docId, score);
        }
        return docScores.entrySet().stream()
                        .sorted(Map.Entry.<Long, Double>comparingByValue().reversed())
                        .map(Map.Entry::getKey)
                        .collect(Collectors.toList());
    }
}

5. 인프라 및 확장성(Infrastructure & Scalability)

검색 엔진은 대량의 데이터를 처리하고, 빠른 응답 속도를 유지해야 합니다. 따라서 인프라 설계와 확장성이 중요합니다.

구현 시 고려 사항

분산 시스템 : 데이터를 여러 서버에 분산 저장하고, 병렬 처리를 통해 성능을 향상시킵니다. 예를 들어, Hadoop이나 Spark와 같은 분산 처리 프레임워크를 사용할 수 있습니다.
캐싱 : 자주 조회되는 데이터를 캐시에 저장하여 응답 속도를 높입니다. Spring에서는 Redis와 같은 인메모리 데이터베이스를 사용할 수 있습니다.
마이크로서비스 아키텍쳐 : 검색 엔진의 각 기능(크롤링, 인덱싱, 검색, 랭킹 등)을 독립된 서비스로 분리하여 관리합니다.

ex)

Spring Boot : 각 기능을 마이크로서비스로 구현하고, Spring Cloud를 활용하여 서비스 간 통신을 관리합니다.
데이터베이스 : Elasticsearch를 사용하여 인덱싱과 검색 기능을 강화할 수 있습니다.
캐시 : Redis를 이용하여 인덱스나 자주 검색되는 결과를 캐싱합니다.

추가 고려 사항

에러 처리 및 로그 관리 : 크롤링 중 발생하는 다양한 오류를 처리하고, 로그를 통해 문제를 모니터링합니다.
보안 : 크롤링 시 웹사이트의 robots.txt를 준수하고 데이터 저장 시 개인정보 보호를 고려합니다.
성능최적화 : 인덱스 구조, 데이터베이스 쿼리 최적화 등을 통해 검색 속도를 향상시킵니다.

신입 Java/Spring 백엔드 개발자로서 검색 엔진 설계에 대한 이해를 높이고, 포트폴리오에 추가할 만한 실습 프로젝트를 통해 실력을 향상시키는 것은 매우 좋은 접근 방식입니다. 아래에서는 단계별로 진행할 수 있는 실습 프로젝트 아이디어와 그에 따른 구현 방법을 제안드립니다. 각 프로젝트는 Java와 Spring을 중심으로 구성되었으며, 검색 엔진의 주요 구성 요소를 직접 구현해보며 학습할 수 있습니다.

1. 간단한 웹 크롤러(Web Crawler) 구현

목표:

웹 페이지를 자동으로 탐색하고 데이터를 수집하는 크롤러를 구현하여, 크롤링의 기본 개념과 HTTP 요청 처리 방법을 익힙니다.

구현 단계:

프로젝트 설정:
- Spring Boot 프로젝트 생성 (Spring Initializr 사용 권장).
- 필요한 의존성 추가: Spring Web, Jsoup (HTML 파싱 라이브러리).
기본 크롤링 로직 구현:
- Jsoup을 사용하여 웹 페이지에 HTTP 요청을 보내고 HTML을 파싱합니다.
- 특정 URL에서 시작하여 페이지 내의 모든 링크를 추출합니다.
크롤링 제어:
- 방문한 URL을 추적하기 위해 Set<String>을 사용하여 중복 방문을 방지합니다.
- 큐(Queue<String>)를 사용하여 크롤링할 URL 목록을 관리합니다.
멀티스레딩 도입:
- Spring의 @Async를 활용하여 비동기적으로 크롤링 작업을 수행합니다.
- Executor를 설정하여 스레드 풀을 관리합니다.

예시 코드:

// CrawlerService.java
@Service
public class CrawlerService {

    private Set<String> visited = ConcurrentHashMap.newKeySet();
    private Queue<String> queue = new ConcurrentLinkedQueue<>();

    @Async
    public void startCrawling(String startUrl) {
        queue.add(startUrl);
        while (!queue.isEmpty() && visited.size() < 100) { // 예: 최대 100 페이지 크롤링
            String url = queue.poll();
            if (url == null || visited.contains(url)) continue;
            visited.add(url);
            try {
                Document doc = Jsoup.connect(url).get();
                // 링크 추출
                Elements links = doc.select("a[href]");
                for (Element link : links) {
                    String nextUrl = link.absUrl("href");
                    if (!visited.contains(nextUrl)) {
                        queue.add(nextUrl);
                    }
                }
                // 페이지 내용 저장 또는 처리
                System.out.println("Crawled: " + url);
            } catch (IOException e) {
                System.err.println("Failed to crawl: " + url);
            }
        }
    }

    public Set<String> getVisitedUrls() {
        return visited;
    }
}

// CrawlerController.java
@RestController
@RequestMapping("/crawler")
public class CrawlerController {

    @Autowired
    private CrawlerService crawlerService;

    @PostMapping("/start")
    public ResponseEntity<String> startCrawling(@RequestParam String startUrl) {
        crawlerService.startCrawling(startUrl);
        return ResponseEntity.ok("Crawling started.");
    }

    @GetMapping("/visited")
    public ResponseEntity<Set<String>> getVisitedUrls() {
        return ResponseEntity.ok(crawlerService.getVisitedUrls());
    }
}

실습 팁:

robots.txt 준수: 실제 웹사이트를 크롤링할 때는 robots.txt 파일을 확인하여 크롤링 정책을 준수하세요.
에러 처리: 다양한 예외 상황(예: 네트워크 오류, 잘못된 URL)을 처리하는 로직을 추가하여 크롤러의 안정성을 높입니다.
크롤링 속도 조절: 서버에 과부하를 주지 않도록 요청 간에 딜레이를 추가하거나 스레드 수를 조절합니다.

2. 기본 인덱싱 시스템 구현

목표:

크롤링한 데이터를 효율적으로 검색할 수 있도록 인덱스를 생성하고 저장하는 시스템을 구현합니다.

구현 단계:

데이터 모델링:
- 문서(Document) 엔티티를 정의합니다 (예: id, url, content).
- 역인덱스(Inverted Index) 구조를 설계합니다 (Map<String, Set<Long>> 형태로 단어와 문서 ID 매핑).
인덱싱 로직 구현:
- 크롤러에서 수집한 콘텐츠를 토큰화하고, 각 단어를 인덱스에 추가합니다.
- 불용어 제거, 소문자 변환 등의 전처리 작업을 수행합니다.
데이터 저장:
- 간단하게는 메모리에 인덱스를 저장할 수 있지만, 더 나아가 데이터베이스 (예: H2, MongoDB)와 연동하여 지속성을 부여합니다.

예시 코드:

// Document.java
@Entity
public class Document {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String url;
    @Lob
    private String content;

    // getters and setters
}

// IndexingService.java
@Service
public class IndexingService {

    private Map<String, Set<Long>> invertedIndex = new ConcurrentHashMap<>();

    @Autowired
    private DocumentRepository documentRepository;

    public void indexDocument(Long docId, String content) {
        String[] tokens = content.toLowerCase().split("\\W+");
        for (String token : tokens) {
            if (token.isEmpty() || isStopWord(token)) continue;
            invertedIndex.computeIfAbsent(token, k -> ConcurrentHashMap.newKeySet()).add(docId);
        }
    }

    private boolean isStopWord(String word) {
        // 간단한 불용어 목록
        List<String> stopWords = Arrays.asList("the", "is", "at", "which", "on", "and");
        return stopWords.contains(word);
    }

    public Set<Long> search(String term) {
        return invertedIndex.getOrDefault(term.toLowerCase(), Collections.emptySet());
    }
}

// DocumentRepository.java
public interface DocumentRepository extends JpaRepository<Document, Long> {
}

실습 팁:

전처리 강화: 어간 추출(stemming)이나 표제어 추출(lemmatization)을 추가하여 검색 정확도를 높일 수 있습니다.
데이터베이스 연동: 인덱스를 데이터베이스에 저장하면 시스템 재시작 시에도 인덱스를 유지할 수 있습니다.
성능 최적화: 대규모 데이터에서는 메모리 사용량과 검색 속도를 고려하여 인덱스 구조를 최적화합니다.

3. 간단한 검색 API 구현

목표:

사용자가 검색어를 입력하면 관련 문서를 반환하는 RESTful API를 구현하여 검색 기능을 체험합니다.

구현 단계:

검색 API 엔드포인트 설계:
- GET /search?query=검색어와 같은 엔드포인트를 설계합니다.
검색 로직 구현:
- 입력된 쿼리를 토큰화하고, 인덱스를 이용해 관련 문서 ID를 찾습니다.
- 해당 문서 ID를 기반으로 문서 내용을 반환합니다.
결과 정렬 및 페이징:
- 단순히 관련 문서를 반환하는 것 외에, 페이징 처리를 통해 대량의 결과를 관리합니다.

예시 코드:

// SearchController.java
@RestController
@RequestMapping("/search")
public class SearchController {

    @Autowired
    private IndexingService indexingService;

    @Autowired
    private DocumentRepository documentRepository;

    @GetMapping
    public ResponseEntity<List<Document>> search(@RequestParam String query) {
        String[] terms = query.toLowerCase().split("\\W+");
        Set<Long> resultIds = new HashSet<>();
        for (String term : terms) {
            resultIds.addAll(indexingService.search(term));
        }
        List<Document> results = documentRepository.findAllById(resultIds);
        return ResponseEntity.ok(results);
    }
}

실습 팁:

쿼리 최적화: AND, OR 연산자를 지원하여 복잡한 쿼리도 처리할 수 있도록 확장해보세요.
결과 정렬: 관련도에 따라 결과를 정렬하는 로직을 추가합니다 (예: 단어 빈도 기반 정렬).
에러 핸들링: 잘못된 입력이나 검색어가 없을 때의 예외 상황을 처리합니다.

4. 문서 랭킹(Ranking) 추가 구현

목표:

검색 결과의 관련성을 높이기 위해 TF-IDF와 같은 랭킹 알고리즘을 적용하여 결과를 정렬합니다.

구현 단계:

TF-IDF 계산 로직 구현:
- 각 문서에서 단어의 빈도(TF)와 역문서 빈도(IDF)를 계산하여 단어의 중요도를 평가합니다.
랭킹 서비스 구현:
- 검색된 문서에 대해 TF-IDF 점수를 계산하고, 이를 기반으로 문서를 정렬합니다.
검색 결과에 랭킹 적용:
- 랭킹 점수가 높은 문서부터 사용자에게 반환합니다.

예시 코드:

// RankingService.java
@Service
public class RankingService {

    @Autowired
    private DocumentRepository documentRepository;

    @Autowired
    private IndexingService indexingService;

    public List<Document> rankDocuments(String query, Set<Long> docIds) {
        String[] terms = query.toLowerCase().split("\\W+");
        int totalDocs = documentRepository.count();
        Map<Long, Double> docScores = new HashMap<>();

        for (Long docId : docIds) {
            double score = 0.0;
            Document doc = documentRepository.findById(docId).orElse(null);
            if (doc == null) continue;
            String content = doc.getContent().toLowerCase();
            for (String term : terms) {
                int tf = countTermFrequency(content, term);
                int df = indexingService.getDocumentFrequency(term);
                double idf = Math.log((double) totalDocs / (1 + df));
                score += (1 + Math.log(tf)) * idf;
            }
            docScores.put(docId, score);
        }

        return docScores.entrySet().stream()
                .sorted(Map.Entry.<Long, Double>comparingByValue().reversed())
                .map(entry -> documentRepository.findById(entry.getKey()).get())
                .collect(Collectors.toList());
    }

    private int countTermFrequency(String content, String term) {
        return (int) Arrays.stream(content.split("\\W+"))
                .filter(word -> word.equals(term))
                .count();
    }
}

// Updated SearchController.java
@RestController
@RequestMapping("/search")
public class SearchController {

    @Autowired
    private IndexingService indexingService;

    @Autowired
    private DocumentRepository documentRepository;

    @Autowired
    private RankingService rankingService;

    @GetMapping
    public ResponseEntity<List<Document>> search(@RequestParam String query) {
        String[] terms = query.toLowerCase().split("\\W+");
        Set<Long> resultIds = new HashSet<>();
        for (String term : terms) {
            resultIds.addAll(indexingService.search(term));
        }
        List<Document> rankedResults = rankingService.rankDocuments(query, resultIds);
        return ResponseEntity.ok(rankedResults);
    }
}

실습 팁:

랭킹 알고리즘 확장: BM25와 같은 더 정교한 랭킹 알고리즘을 연구하고 구현해보세요.
성능 최적화: TF-IDF 계산이 많은 문서에서 성능 이슈가 발생할 수 있으므로, 캐싱이나 사전 계산을 고려합니다.
테스트 데이터: 다양한 문서를 수집하여 랭킹 알고리즘의 효과를 시각적으로 확인해보세요.

5. Elasticsearch 통합 프로젝트

목표:

강력한 검색 기능을 제공하는 오픈소스 검색 엔진인 Elasticsearch를 Spring 애플리케이션에 통합하여, 실제 검색 엔진의 성능과 기능을 체험합니다.

구현 단계:

Elasticsearch 설치 및 설정:
- 로컬 또는 클라우드 환경에 Elasticsearch를 설치합니다.
- 기본 설정을 확인하고, 필요한 인덱스를 생성합니다.
Spring Data Elasticsearch 연동:
- spring-boot-starter-data-elasticsearch 의존성을 추가합니다.
- Elasticsearch와의 연결 설정을 application.properties 또는 application.yml 파일에 추가합니다.
데이터 인덱싱:
- 크롤러에서 수집한 문서를 Elasticsearch에 인덱싱합니다.
- Spring Data Elasticsearch의 리포지토리를 활용하여 문서를 저장하고 검색할 수 있습니다.
검색 API 구현:
- Elasticsearch의 검색 기능을 활용하여 고급 검색 API를 구현합니다 (예: 필터링, 페이징, 정렬).

예시 코드:

<!-- pom.xml -->
<dependencies>
    <!-- Other dependencies -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
</dependencies>

# application.yml
spring:
  elasticsearch:
    client:
      rest:
        uris: http://localhost:9200
    index:
      name: documents

// ElasticsearchDocument.java
@Document(indexName = "documents")
public class ElasticsearchDocument {
    @Id
    private String id;
    private String url;
    private String content;

    // getters and setters
}

// ElasticsearchRepository.java
public interface ElasticsearchRepository extends ElasticsearchRepository<ElasticsearchDocument, String> {
    List<ElasticsearchDocument> findByContentContaining(String content);
}

// SearchController.java
@RestController
@RequestMapping("/search")
public class SearchController {

    @Autowired
    private ElasticsearchRepository elasticsearchRepository;

    @GetMapping
    public ResponseEntity<List<ElasticsearchDocument>> search(@RequestParam String query) {
        List<ElasticsearchDocument> results = elasticsearchRepository.findByContentContaining(query);
        return ResponseEntity.ok(results);
    }
}

실습 팁:

Elasticsearch 쿼리 DSL 학습: Elasticsearch의 강력한 쿼리 DSL을 활용하여 다양한 검색 조건을 구현해보세요.
인덱스 매핑 최적화: 문서의 필드 매핑을 최적화하여 검색 성능과 정확도를 향상시킵니다.
모니터링: Elasticsearch의 모니터링 도구를 사용하여 클러스터 상태와 성능을 관리합니다.

6. 전체 검색 엔진 프로젝트: 종합 실습

목표:

앞서 구현한 각 구성 요소(크롤링, 인덱싱, 검색, 랭킹)를 통합하여 간단한 검색 엔진을 완성합니다. 이 프로젝트는 포트폴리오에 추가할 수 있는 완성도 높은 프로젝트로, 다양한 기술을 체험할 수 있습니다.

구현 단계:

프로젝트 구조 설계:
- 마이크로서비스 아키텍처를 고려하여 각 기능을 독립된 서비스로 분리할지 결정합니다.
- 단일 모놀리식 애플리케이션으로 시작하여 점차 확장해 나가는 것도 좋은 방법입니다.
크롤러와 인덱서 통합:
- 크롤러가 수집한 데이터를 인덱서가 받아 인덱스를 생성하도록 연동합니다.
- 실시간 또는 배치 방식으로 데이터를 처리할 수 있도록 설계합니다.
검색 API 확장:
- 사용자에게 검색어 입력 인터페이스를 제공하고, 검색 결과를 반환하는 RESTful API를 구현합니다.
- 프론트엔드와 연동하여 간단한 웹 인터페이스를 추가할 수도 있습니다.
추가 기능 구현:
- 페이징, 필터링, 고급 검색 기능 (예: 날짜 범위, 카테고리 등)을 추가합니다.
- 사용자 인증 및 권한 관리 기능을 도입하여 보안을 강화합니다.
배포 및 운영:
- 애플리케이션을 클라우드 서비스 (예: AWS, Azure, GCP)에 배포합니다.
- CI/CD 파이프라인을 구축하여 지속적인 배포와 통합을 자동화합니다.

실습 팁:

문서화: 프로젝트의 구조와 각 구성 요소의 역할을 문서화하여 이해도를 높이고, 포트폴리오에 추가할 때 유용하게 활용합니다.
버전 관리: Git을 사용하여 프로젝트의 버전을 관리하고, GitHub와 같은 플랫폼에 코드를 공개하여 포트폴리오로 활용합니다.
테스트 작성: 단위 테스트와 통합 테스트를 작성하여 코드의 안정성과 신뢰성을 높입니다.

추가 학습 자료 및 리소스

Java & Spring:
- Spring 공식 문서
- Baeldung의 Spring 튜토리얼
웹 크롤링:
- Jsoup 공식 문서
- Web Crawling with Java
검색 엔진 이론:
- Introduction to Information Retrieval - Stanford University
- Lucene in Action
Elasticsearch:
- Elasticsearch 공식 문서
- Spring Data Elasticsearch

결론

검색 엔진 설계와 구현은 다양한 백엔드 기술과 알고리즘을 체험할 수 있는 훌륭한 실습 주제입니다. 위에서 제안한 프로젝트를 통해 크롤링, 인덱싱, 검색, 랭킹 등 검색 엔진의 주요 구성 요소를 직접 구현해보며, Java와 Spring을 활용한 백엔드 개발 능력을 향상시킬 수 있습니다. 각 단계에서 발생하는 문제를 해결하고, 기능을 확장해 나가면서 실력을 키우는 동시에, 포트폴리오에 추가할 수 있는 의미 있는 프로젝트를 완성해보세요. 성공적인 취업 준비를 응원합니다!

김상욱

이전 포스트

세션 관리(Session Management)는 어떻게 이루어지나요?

다음 포스트

검색 엔진(Search Engine)은 어떻게 설계하나요?