Elasticsearch란 무엇인가 – 개념부터 동작 원리, 실전 활용법까지 완벽 정리

-- RDB의 LIKE 검색 – 인덱스를 타지 못해 전체 테이블 스캔 발생
SELECT * FROM products
WHERE name LIKE '%무선 블루투스 이어폰%';

// 상품 도큐먼트 예시
{
  "_index": "products",
  "_id": "1001",
  "_source": {
    "name": "소니 WH-1000XM5 무선 블루투스 헤드폰",
    "brand": "Sony",
    "category": "헤드폰",
    "price": 389000,
    "rating": 4.8,
    "tags": ["노이즈캔슬링", "무선", "블루투스", "프리미엄"],
    "description": "업계 최고 수준의 노이즈 캔슬링과 30시간 배터리 지속 시간",
    "inStock": true,
    "createdAt": "2024-03-15T09:00:00Z"
  }
}

[문서 원문]
Doc 1: "무선 블루투스 이어폰 추천"
Doc 2: "블루투스 헤드폰 노이즈캔슬링"
Doc 3: "무선 헤드폰 충전 방법"

[역색인 구조]
토큰(단어)      →  문서 ID 목록
─────────────────────────────
"무선"          →  [Doc 1, Doc 3]
"블루투스"      →  [Doc 1, Doc 2]
"이어폰"        →  [Doc 1]
"추천"          →  [Doc 1]
"헤드폰"        →  [Doc 2, Doc 3]
"노이즈캔슬링"  →  [Doc 2]
"충전"          →  [Doc 3]
"방법"          →  [Doc 3]

애널라이저 처리 흐름:
원문 텍스트
    ↓
[Character Filter]    불필요한 문자 제거 (HTML 태그, 특수문자 등)
    ↓
[Tokenizer]           텍스트를 토큰으로 분리 (공백, 형태소 기준 등)
    ↓
[Token Filter]        토큰 정규화 (소문자 변환, 동의어 처리, 불용어 제거 등)
    ↓
역색인에 저장

┌──────────────────────────────────────────────┐
│              Cluster (my-cluster)            │
│                                              │
│  ┌─────────────┐     ┌─────────────┐         │
│  │   Node 1    │     │   Node 2    │  ...    │
│  │  (Master)   │     │  (Data)     │         │
│  │             │     │             │         │
│  │ ┌─────────┐ │     │ ┌─────────┐ │         │
│  │ │Shard P0 │ │     │ │Shard R0 │ │         │
│  │ │(Primary)│ │     │ │(Replica)│ │         │
│  │ └─────────┘ │     │ └─────────┘ │         │
│  │ ┌─────────┐ │     │ ┌─────────┐ │         │
│  │ │Shard R1 │ │     │ │Shard P1 │ │         │
│  │ │(Replica)│ │     │ │(Primary)│ │         │
│  │ └─────────┘ │     │ └─────────┘ │         │
│  └─────────────┘     └─────────────┘         │
└──────────────────────────────────────────────┘

// 샤드 설정 예시: 프라이머리 3개, 레플리카 1세트
PUT /products
{
  "settings": {
    "number_of_shards": 3,    // 프라이머리 샤드 3개로 데이터 분산
    "number_of_replicas": 1   // 각 프라이머리마다 레플리카 1개
  }
}
// 총 샤드 수: 3 (Primary) + 3 (Replica) = 6개

[실무 권장 아키텍처]

사용자 요청
    │
    ├─── 쓰기(주문, 결제) ──→ RDB (MySQL) ──→ CDC / 메시지큐 ──→ Elasticsearch 동기화
    │
    └─── 검색(상품 조회) ──→ Elasticsearch

// 잘못 설계된 매핑을 변경하려면 재색인 필요
POST /_reindex
{
  "source": { "index": "products_v1" },
  "dest":   { "index": "products_v2" }
}
// 이후 products_v2를 products 별칭(alias)으로 전환

# jvm.options 설정 예시
-Xms16g   # 최소 힙
-Xmx16g   # 최대 힙 (min = max로 설정 권장 – GC 오버헤드 최소화)

# docker-compose.yml
version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.13.0
    container_name: elasticsearch
    environment:
      - discovery.type=single-node          # 단일 노드 개발 모드
      - xpack.security.enabled=false        # 개발 환경 보안 비활성화
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    ports:
      - "9200:9200"
    volumes:
      - es-data:/usr/share/elasticsearch/data

  kibana:
    image: docker.elastic.co/kibana/kibana:8.13.0
    container_name: kibana
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      - elasticsearch

volumes:
  es-data:

docker-compose up -d
# Elasticsearch: http://localhost:9200
# Kibana:        http://localhost:5601

PUT /products
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 0,
    "analysis": {
      "analyzer": {
        "korean_analyzer": {
          "type": "custom",
          "tokenizer": "nori_tokenizer",
          "filter": ["lowercase", "nori_part_of_speech"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "korean_analyzer",
        "fields": {
          "keyword": { "type": "keyword" }  // 정렬·집계용 keyword 서브필드
        }
      },
      "brand":    { "type": "keyword" },    // 정확 일치 검색
      "category": { "type": "keyword" },
      "price":    { "type": "double" },
      "rating":   { "type": "float" },
      "tags":     { "type": "keyword" },
      "description": {
        "type": "text",
        "analyzer": "korean_analyzer"
      },
      "inStock":    { "type": "boolean" },
      "createdAt":  { "type": "date" }
    }
  }
}

// 단일 도큐먼트 색인
POST /products/_doc/1001
{
  "name": "소니 WH-1000XM5 무선 블루투스 헤드폰",
  "brand": "Sony",
  "category": "헤드폰",
  "price": 389000,
  "rating": 4.8,
  "tags": ["노이즈캔슬링", "무선", "블루투스", "프리미엄"],
  "description": "업계 최고 수준의 노이즈 캔슬링과 30시간 배터리 지속 시간",
  "inStock": true,
  "createdAt": "2024-03-15T09:00:00Z"
}

// 벌크 색인 – 대량 데이터 적재 시 사용 (권장)
POST /products/_bulk
{ "index": { "_id": "1002" } }
{ "name": "애플 AirPods Pro 2세대", "brand": "Apple", "category": "이어폰", "price": 359000, "rating": 4.7, "tags": ["노이즈캔슬링", "무선", "애플"], "inStock": true, "createdAt": "2024-01-10T09:00:00Z" }
{ "index": { "_id": "1003" } }
{ "name": "삼성 갤럭시 버즈2 프로", "brand": "Samsung", "category": "이어폰", "price": 199000, "rating": 4.5, "tags": ["노이즈캔슬링", "무선", "삼성"], "inStock": true, "createdAt": "2024-02-20T09:00:00Z" }

GET /products/_search
{
  "query": {
    "match": {
      "name": "블루투스 헤드폰"  // 형태소 분석 후 검색
    }
  }
}

GET /products/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "name": "헤드폰" } }         // 반드시 포함 (점수 영향)
      ],
      "filter": [
        { "term":  { "inStock": true } },          // 재고 있는 상품만 (점수 무관)
        { "range": { "price": { "lte": 400000 } } } // 40만원 이하
      ],
      "should": [
        { "term": { "tags": "노이즈캔슬링" } }     // 있으면 점수 가산
      ],
      "must_not": [
        { "term": { "brand": "Unknown" } }         // 제외할 조건
      ]
    }
  },
  "sort": [
    { "_score": { "order": "desc" } },   // 관련도 점수 내림차순
    { "rating": { "order": "desc" } }    // 평점 내림차순 (2차 정렬)
  ],
  "from": 0,   // 페이지네이션 시작 오프셋
  "size": 10   // 반환할 도큐먼트 수
}

GET /products/_search
{
  "query": {
    "match_phrase_prefix": {
      "name": "블루투"   // "블루투스", "블루투스 헤드폰" 등 자동완성
    }
  }
}

GET /products/_search
{
  "size": 0,  // 도큐먼트는 필요 없고 집계 결과만 반환
  "aggs": {
    "by_category": {
      "terms": { "field": "category" },           // 카테고리별 그룹핑
      "aggs": {
        "avg_price": { "avg": { "field": "price" } },   // 평균 가격
        "max_rating": { "max": { "field": "rating" } }  // 최고 평점
      }
    }
  }
}

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

# application.yml
spring:
  elasticsearch:
    uris: http://localhost:9200
    connection-timeout: 5s
    socket-timeout: 30s

// 도큐먼트 엔티티 정의
@Document(indexName = "products")
@Setting(settingPath = "elasticsearch/settings.json")
public class ProductDocument {

    @Id
    private String id;

    @Field(type = FieldType.Text, analyzer = "korean_analyzer")
    private String name;

    @Field(type = FieldType.Keyword)
    private String brand;

    @Field(type = FieldType.Keyword)
    private String category;

    @Field(type = FieldType.Double)
    private double price;

    @Field(type = FieldType.Float)
    private float rating;

    @Field(type = FieldType.Boolean)
    private boolean inStock;

    @Field(type = FieldType.Date, format = DateFormat.date_time)
    private LocalDateTime createdAt;

    // getter, setter, builder...
}

// Repository 정의
public interface ProductSearchRepository
        extends ElasticsearchRepository<ProductDocument, String> {

    // 메서드 이름으로 쿼리 자동 생성
    List<ProductDocument> findByBrandAndInStockTrue(String brand);
    List<ProductDocument> findByPriceBetween(double min, double max);
}

// 서비스 레이어 – NativeQuery로 복잡한 쿼리 처리
@Service
public class ProductSearchService {

    private final ElasticsearchOperations operations;

    public ProductSearchService(ElasticsearchOperations operations) {
        this.operations = operations;
    }

    public SearchHits<ProductDocument> searchProducts(String keyword,
                                                       double maxPrice,
                                                       String category) {
        Query query = NativeQuery.builder()
            .withQuery(q -> q
                .bool(b -> b
                    .must(m -> m.match(mt -> mt.field("name").query(keyword)))
                    .filter(f -> f.range(r -> r.field("price").lte(JsonData.of(maxPrice))))
                    .filter(f -> f.term(t -> t.field("category").value(category)))
                    .filter(f -> f.term(t -> t.field("inStock").value(true)))
                )
            )
            .withSort(Sort.by(Sort.Direction.DESC, "_score"))
            .withPageable(PageRequest.of(0, 10))
            .build();

        return operations.search(query, ProductDocument.class);
    }
}

[데이터 흐름]

애플리케이션 로그
서버 메트릭       →  Logstash / Beats  →  Elasticsearch  →  Kibana (시각화)
보안 이벤트                (수집·변환)        (저장·검색)      (대시보드·알림)