Split View: Elasticsearch 완전 가이드 2025: 검색 엔진부터 로그 분석, 벡터 검색까지

ES 1.x (2014) - 초기 안정화
ES 2.x (2015) - Pipeline Aggregation 도입
ES 5.x (2016) - Lucene 6, Painless 스크립팅
ES 6.x (2017) - 인덱스당 단일 타입
ES 7.x (2019) - 타입 제거, 적응형 레플리카 선택
ES 8.x (2022) - 보안 기본 활성화, kNN 벡터 검색, NLP 통합

Doc 1: "The quick brown fox"
Doc 2: "The quick brown dog"
Doc 3: "The lazy brown fox"

Term      | Document IDs
----------|-------------
the       | [1, 2, 3]
quick     | [1, 2]
brown     | [1, 2, 3]
fox       | [1, 3]
dog       | [2]
lazy      | [3]

Index
  └── Shard (Lucene Index)
        ├── Segment 0 (immutable)
        │     ├── Inverted Index
        │     ├── Stored Fields
        │     ├── Doc Values
        │     └── Term Vectors
        ├── Segment 1 (immutable)
        ├── Segment 2 (immutable)
        └── Commit Point (segments_N)

역색인 (검색용): Term → Document IDs
Doc Values (집계/정렬용): Document ID → Values

// Doc Values 예시
{
  "doc_1": { "price": 100, "category": "electronics" },
  "doc_2": { "price": 200, "category": "books" },
  "doc_3": { "price": 150, "category": "electronics" }
}

PUT /products
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "standard",
        "fields": {
          "keyword": {
            "type": "keyword"
          }
        }
      },
      "price": {
        "type": "float"
      },
      "category": {
        "type": "keyword"
      },
      "description": {
        "type": "text",
        "analyzer": "korean_analyzer"
      },
      "created_at": {
        "type": "date",
        "format": "yyyy-MM-dd HH:mm:ss||epoch_millis"
      },
      "location": {
        "type": "geo_point"
      },
      "tags": {
        "type": "keyword"
      },
      "metadata": {
        "type": "object"
      },
      "reviews": {
        "type": "nested",
        "properties": {
          "author": { "type": "keyword" },
          "rating": { "type": "integer" },
          "comment": { "type": "text" }
        }
      }
    }
  }
}

텍스트 입력
  │
  ▼
Character Filter (문자 필터)
  │  - html_strip: HTML 태그 제거
  │  - mapping: 문자 치환
  │  - pattern_replace: 정규식 치환
  ▼
Tokenizer (토크나이저)
  │  - standard: 유니코드 단어 경계 기반
  │  - whitespace: 공백 기준 분리
  │  - ngram: N-gram 토큰 생성
  │  - edge_ngram: 접두사 기반 토큰
  │  - nori_tokenizer: 한국어 형태소 분석
  ▼
Token Filter (토큰 필터)
  │  - lowercase: 소문자 변환
  │  - stop: 불용어 제거
  │  - synonym: 동의어 처리
  │  - stemmer: 어간 추출
  │  - nori_part_of_speech: 한국어 품사 필터
  ▼
토큰 스트림 (Term)

PUT /korean_index
{
  "settings": {
    "analysis": {
      "tokenizer": {
        "nori_custom": {
          "type": "nori_tokenizer",
          "decompound_mode": "mixed",
          "discard_punctuation": true,
          "user_dictionary_rules": [
            "삼성전자",
            "엘라스틱서치"
          ]
        }
      },
      "filter": {
        "nori_pos_filter": {
          "type": "nori_part_of_speech",
          "stoptags": [
            "E", "IC", "J", "MAG", "MAJ",
            "MM", "SP", "SSC", "SSO", "SC",
            "SE", "XPN", "XSA", "XSN", "XSV",
            "UNA", "NA", "VSV"
          ]
        }
      },
      "analyzer": {
        "korean_analyzer": {
          "type": "custom",
          "tokenizer": "nori_custom",
          "filter": [
            "nori_readingform",
            "nori_pos_filter",
            "lowercase"
          ]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "title": {
        "type": "text",
        "analyzer": "korean_analyzer"
      }
    }
  }
}

POST /korean_index/_analyze
{
  "analyzer": "korean_analyzer",
  "text": "엘라스틱서치는 강력한 검색 엔진입니다"
}

// 결과
{
  "tokens": [
    { "token": "엘라스틱서치", "position": 0 },
    { "token": "강력", "position": 2 },
    { "token": "검색", "position": 4 },
    { "token": "엔진", "position": 5 }
  ]
}

// 기본 match - 분석기를 통해 토큰화 후 검색
GET /products/_search
{
  "query": {
    "match": {
      "description": "강력한 검색 엔진"
    }
  }
}

// match_phrase - 단어 순서까지 일치
GET /products/_search
{
  "query": {
    "match_phrase": {
      "description": {
        "query": "검색 엔진",
        "slop": 1
      }
    }
  }
}

// multi_match - 여러 필드에서 검색
GET /products/_search
{
  "query": {
    "multi_match": {
      "query": "엘라스틱서치 가이드",
      "fields": ["title^3", "description", "tags^2"],
      "type": "best_fields"
    }
  }
}

// term - keyword 필드의 정확한 일치
GET /products/_search
{
  "query": {
    "term": {
      "category": "electronics"
    }
  }
}

// terms - 여러 값 중 하나와 일치
GET /products/_search
{
  "query": {
    "terms": {
      "status": ["published", "pending"]
    }
  }
}

// range - 범위 검색
GET /products/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 500
      }
    }
  }
}

// exists - 필드 존재 여부
GET /products/_search
{
  "query": {
    "exists": {
      "field": "discount"
    }
  }
}

GET /products/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "description": "검색 엔진" } }
      ],
      "must_not": [
        { "term": { "status": "deleted" } }
      ],
      "should": [
        { "term": { "featured": true } },
        { "range": { "rating": { "gte": 4.5 } } }
      ],
      "filter": [
        { "term": { "category": "software" } },
        { "range": { "price": { "lte": 1000 } } }
      ],
      "minimum_should_match": 1
    }
  }
}

// 중첩 객체 검색 - 독립적인 문서로 저장됨
GET /products/_search
{
  "query": {
    "nested": {
      "path": "reviews",
      "query": {
        "bool": {
          "must": [
            { "term": { "reviews.author": "john" } },
            { "range": { "reviews.rating": { "gte": 4 } } }
          ]
        }
      },
      "inner_hits": {
        "size": 3,
        "highlight": {
          "fields": {
            "reviews.comment": {}
          }
        }
      }
    }
  }
}

GET /products/_search
{
  "query": {
    "function_score": {
      "query": { "match": { "title": "엘라스틱서치" } },
      "functions": [
        {
          "field_value_factor": {
            "field": "popularity",
            "modifier": "log1p",
            "factor": 2
          }
        },
        {
          "gauss": {
            "created_at": {
              "origin": "now",
              "scale": "30d",
              "decay": 0.5
            }
          }
        },
        {
          "filter": { "term": { "featured": true } },
          "weight": 5
        }
      ],
      "score_mode": "sum",
      "boost_mode": "multiply"
    }
  }
}

GET /products/_search
{
  "query": {
    "match": { "description": "검색 엔진" }
  },
  "highlight": {
    "pre_tags": ["<strong>"],
    "post_tags": ["</strong>"],
    "fields": {
      "description": {
        "fragment_size": 150,
        "number_of_fragments": 3
      }
    }
  }
}

// terms 집계 - 카테고리별 문서 수
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_category": {
      "terms": {
        "field": "category",
        "size": 20,
        "order": { "_count": "desc" }
      }
    }
  }
}

// date_histogram - 시간대별 집계
GET /logs/_search
{
  "size": 0,
  "aggs": {
    "logs_per_hour": {
      "date_histogram": {
        "field": "timestamp",
        "calendar_interval": "1h",
        "time_zone": "Asia/Seoul",
        "min_doc_count": 0
      }
    }
  }
}

// range 집계 - 가격대별
GET /products/_search
{
  "size": 0,
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          { "to": 100 },
          { "from": 100, "to": 500 },
          { "from": 500 }
        ]
      }
    }
  }
}

// 중첩 집계 - 카테고리별 평균 가격
GET /products/_search
{
  "size": 0,
  "aggs": {
    "by_category": {
      "terms": { "field": "category" },
      "aggs": {
        "avg_price": {
          "avg": { "field": "price" }
        },
        "price_stats": {
          "stats": { "field": "price" }
        }
      }
    }
  }
}

GET /products/_search
{
  "size": 0,
  "aggs": {
    "avg_price": { "avg": { "field": "price" } },
    "max_price": { "max": { "field": "price" } },
    "min_price": { "min": { "field": "price" } },
    "total_sales": { "sum": { "field": "sales_count" } },
    "unique_brands": { "cardinality": { "field": "brand" } },
    "price_percentiles": {
      "percentiles": {
        "field": "price",
        "percents": [25, 50, 75, 90, 99]
      }
    }
  }
}

GET /sales/_search
{
  "size": 0,
  "aggs": {
    "monthly_sales": {
      "date_histogram": {
        "field": "date",
        "calendar_interval": "month"
      },
      "aggs": {
        "total_revenue": {
          "sum": { "field": "revenue" }
        }
      }
    },
    "avg_monthly_revenue": {
      "avg_bucket": {
        "buckets_path": "monthly_sales>total_revenue"
      }
    },
    "max_monthly_revenue": {
      "max_bucket": {
        "buckets_path": "monthly_sales>total_revenue"
      }
    },
    "revenue_derivative": {
      "derivative": {
        "buckets_path": "monthly_sales>total_revenue"
      }
    },
    "moving_avg_revenue": {
      "moving_fn": {
        "buckets_path": "monthly_sales>total_revenue",
        "window": 3,
        "script": "MovingFunctions.unweightedAvg(values)"
      }
    }
  }
}

데이터 소스                  수집               처리/변환            저장              시각화
┌──────────┐          ┌──────────┐      ┌──────────┐      ┌──────────┐      ┌──────────┐
│  App Log │──────────│ Filebeat │──────│ Logstash │──────│  Elastic │──────│  Kibana  │
│  Server  │          │ Metricbt │      │ Pipeline │      │  search  │      │Dashboard │
│  Docker  │          │ Heartbt  │      │ (Filter) │      │ Cluster  │      │ Lens/Map │
│  K8s     │          │ Packetbt │      │          │      │          │      │ Alerting │
└──────────┘          └──────────┘      └──────────┘      └──────────┘      └──────────┘

# /etc/logstash/conf.d/main.conf
input {
  beats {
    port => 5044
  }
  kafka {
    bootstrap_servers => "kafka:9092"
    topics => ["app-logs"]
    codec => json
  }
}

filter {
  # Grok 패턴으로 비정형 로그 파싱
  grok {
    match => {
      "message" => "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:msg}"
    }
  }

  # 날짜 파싱
  date {
    match => ["timestamp", "ISO8601"]
    target => "@timestamp"
  }

  # GeoIP 변환
  geoip {
    source => "client_ip"
    target => "geo"
  }

  # 조건부 처리
  if [level] == "ERROR" {
    mutate {
      add_tag => ["alert"]
      add_field => { "severity" => "high" }
    }
  }

  # 불필요한 필드 제거
  mutate {
    remove_field => ["agent", "ecs", "host"]
  }
}

output {
  elasticsearch {
    hosts => ["http://elasticsearch:9200"]
    index => "logs-%{+YYYY.MM.dd}"
    user => "elastic"
    password => "changeme"
  }

  # 에러 로그는 별도 인덱스로
  if "alert" in [tags] {
    elasticsearch {
      hosts => ["http://elasticsearch:9200"]
      index => "alerts-%{+YYYY.MM.dd}"
    }
  }
}

# /etc/filebeat/filebeat.yml
filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/app/*.log
    multiline:
      pattern: '^\d{4}-\d{2}-\d{2}'
      negate: true
      match: after

  - type: container
    paths:
      - /var/lib/docker/containers/*/*.log
    processors:
      - add_docker_metadata: ~

output.logstash:
  hosts: ["logstash:5044"]

# 또는 직접 Elasticsearch로
# output.elasticsearch:
#   hosts: ["http://elasticsearch:9200"]
#   index: "filebeat-%{+yyyy.MM.dd}"

"자동차" → [0.12, -0.34, 0.56, ..., 0.89]  (768차원)
"차량"   → [0.13, -0.32, 0.55, ..., 0.88]  (유사한 벡터)
"과일"   → [-0.45, 0.67, -0.12, ..., 0.23] (다른 벡터)

PUT /semantic-search
{
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "content": { "type": "text" },
      "content_vector": {
        "type": "dense_vector",
        "dims": 768,
        "index": true,
        "similarity": "cosine",
        "index_options": {
          "type": "hnsw",
          "m": 16,
          "ef_construction": 200
        }
      }
    }
  }
}

// 순수 kNN 검색
GET /semantic-search/_search
{
  "knn": {
    "field": "content_vector",
    "query_vector": [0.12, -0.34, 0.56, ...],
    "k": 10,
    "num_candidates": 100
  }
}

// 하이브리드 검색 (키워드 + kNN)
GET /semantic-search/_search
{
  "query": {
    "match": {
      "content": "자동차 추천"
    }
  },
  "knn": {
    "field": "content_vector",
    "query_vector": [0.12, -0.34, 0.56, ...],
    "k": 10,
    "num_candidates": 100,
    "boost": 0.5
  },
  "size": 10
}

Layer 2 (sparse):  A ──── B
                   │
Layer 1 (medium):  A ── C ── B ── D
                   │    │    │    │
Layer 0 (dense):   A-E-C-F-B-G-D-H

// ELSER v2 모델 배포
PUT /_ml/trained_models/.elser_model_2
{
  "input": {
    "field_names": ["text_field"]
  }
}

// Ingest Pipeline으로 자동 벡터화
PUT /_ingest/pipeline/elser-pipeline
{
  "processors": [
    {
      "inference": {
        "model_id": ".elser_model_2",
        "input_output": [
          {
            "input_field": "content",
            "output_field": "content_embedding"
          }
        ]
      }
    }
  ]
}

┌─────────────────────────────────────────────────┐
│                  Elasticsearch Cluster            │
│                                                   │
│  ┌─────────────┐  ┌─────────────┐  ┌────────────┐│
│  │ Master Node │  │ Master Node │  │Master Node ││
│  │  (Elected)  │  │ (Eligible)  │  │(Eligible)  ││
│  └─────────────┘  └─────────────┘  └────────────┘│
│                                                   │
│  ┌─────────────┐  ┌─────────────┐  ┌────────────┐│
│  │  Data Node  │  │  Data Node  │  │ Data Node  ││
│  │ (Hot Tier)  │  │ (Hot Tier)  │  │(Warm Tier) ││
│  │  SSD 1TB    │  │  SSD 1TB    │  │ HDD 4TB    ││
│  └─────────────┘  └─────────────┘  └────────────┘│
│                                                   │
│  ┌─────────────┐  ┌─────────────┐                │
│  │ Ingest Node │  │ Coord Node  │                │
│  │ (Pipeline)  │  │ (Routing)   │                │
│  └─────────────┘  └─────────────┘                │
└─────────────────────────────────────────────────┘

// 인덱스 생성 시 샤드 수 지정
PUT /logs-2025.03
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1,
    "routing.allocation.require.data": "hot"
  }
}

PUT /_ilm/policy/logs-policy
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "1d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "warm": {
        "min_age": "7d",
        "actions": {
          "shrink": {
            "number_of_shards": 1
          },
          "forcemerge": {
            "max_num_segments": 1
          },
          "allocate": {
            "require": {
              "data": "warm"
            }
          },
          "set_priority": {
            "priority": 50
          }
        }
      },
      "cold": {
        "min_age": "30d",
        "actions": {
          "allocate": {
            "require": {
              "data": "cold"
            }
          },
          "freeze": {}
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}

// ILM 정책을 인덱스 템플릿에 적용
PUT /_index_template/logs-template
{
  "index_patterns": ["logs-*"],
  "template": {
    "settings": {
      "index.lifecycle.name": "logs-policy",
      "index.lifecycle.rollover_alias": "logs"
    }
  }
}

# 클러스터 상태
GET /_cluster/health

# 노드 정보
GET /_nodes/stats

# 인덱스 상태
GET /_cat/indices?v&s=store.size:desc

# 샤드 할당 상태
GET /_cat/shards?v&s=store:desc

# 할당 실패 원인
GET /_cluster/allocation/explain

# Hot Threads (CPU 사용 분석)
GET /_nodes/hot_threads

# Pending Tasks
GET /_cluster/pending_tasks

// Bulk API 사용 (단건 요청 대비 10x 이상 빠름)
POST /_bulk
{"index": {"_index": "products", "_id": "1"}}
{"name": "Product 1", "price": 100}
{"index": {"_index": "products", "_id": "2"}}
{"name": "Product 2", "price": 200}
{"update": {"_index": "products", "_id": "1"}}
{"doc": {"price": 150}}
{"delete": {"_index": "products", "_id": "3"}}

// 1. Filter Context 활용 (캐싱됨)
GET /products/_search
{
  "query": {
    "bool": {
      "filter": [
        { "term": { "category": "electronics" } },
        { "range": { "price": { "gte": 100, "lte": 500 } } }
      ],
      "must": [
        { "match": { "description": "wireless" } }
      ]
    }
  }
}

// 2. Source Filtering (필요한 필드만)
GET /products/_search
{
  "_source": ["name", "price", "category"],
  "query": { "match_all": {} }
}

// 3. Search After (Deep Pagination 대안)
GET /products/_search
{
  "size": 20,
  "sort": [
    { "created_at": "desc" },
    { "_id": "asc" }
  ],
  "search_after": ["2025-03-01T00:00:00", "abc123"]
}

Elasticsearch 캐시 계층:

1. Node Query Cache (Filter Cache)
   - filter context의 결과 캐싱
   - 노드 레벨, 힙의 10% (기본)
   - LRU 방식 제거

2. Shard Request Cache
   - 집계 결과 캐싱
   - 샤드 레벨, 힙의 1% (기본)
   - 인덱스 refresh 시 무효화

3. Field Data Cache
   - text 필드의 정렬/집계 데이터
   - 힙 메모리 사용 (주의 필요)

4. OS Page Cache
   - Lucene 세그먼트 파일 캐싱
   - 힙 외 메모리 활용
   - 가장 중요한 캐시!

// Force Merge (읽기 전용 인덱스에 적용)
POST /logs-2025.01/_forcemerge?max_num_segments=1

// 병합 정책 설정
PUT /products/_settings
{
  "index": {
    "merge": {
      "policy": {
        "max_merged_segment": "5gb",
        "segments_per_tier": 10,
        "floor_segment": "2mb"
      }
    }
  }
}

# jvm.options
-Xms16g
-Xmx16g
# 힙은 물리 메모리의 50% 이하, 최대 30.5GB (Compressed OOPs)

# elasticsearch.yml
bootstrap.memory_lock: true  # 스왑 비활성화

# OS 레벨 설정
# /etc/sysctl.conf
vm.max_map_count=262144
vm.swappiness=1

# /etc/security/limits.conf
elasticsearch soft nofile 65536
elasticsearch hard nofile 65536
elasticsearch soft nproc 4096
elasticsearch hard nproc 4096

// Component Template (재사용 가능한 블록)
PUT /_component_template/base-settings
{
  "template": {
    "settings": {
      "number_of_shards": 3,
      "number_of_replicas": 1,
      "index.lifecycle.name": "logs-policy"
    }
  }
}

PUT /_component_template/log-mappings
{
  "template": {
    "mappings": {
      "properties": {
        "@timestamp": { "type": "date" },
        "message": { "type": "text" },
        "level": { "type": "keyword" },
        "service": { "type": "keyword" },
        "trace_id": { "type": "keyword" }
      }
    }
  }
}

// Index Template (Component Template 조합)
PUT /_index_template/logs
{
  "index_patterns": ["logs-*"],
  "composed_of": ["base-settings", "log-mappings"],
  "priority": 200
}

// Alias 설정 (무중단 인덱스 교체)
POST /_aliases
{
  "actions": [
    { "remove": { "index": "products-v1", "alias": "products" } },
    { "add": { "index": "products-v2", "alias": "products" } }
  ]
}

// Reindex (인덱스 마이그레이션)
POST /_reindex
{
  "source": {
    "index": "old-index",
    "query": {
      "range": {
        "@timestamp": { "gte": "2025-01-01" }
      }
    }
  },
  "dest": {
    "index": "new-index",
    "pipeline": "enrichment-pipeline"
  }
}

// 리포지토리 등록 (S3)
PUT /_snapshot/s3-backup
{
  "type": "s3",
  "settings": {
    "bucket": "my-es-backups",
    "region": "ap-northeast-2",
    "base_path": "elasticsearch"
  }
}

// 스냅샷 생성
PUT /_snapshot/s3-backup/snapshot-2025-03-24
{
  "indices": "logs-*,products",
  "ignore_unavailable": true,
  "include_global_state": false
}

// 복원
POST /_snapshot/s3-backup/snapshot-2025-03-24/_restore
{
  "indices": "products",
  "rename_pattern": "(.+)",
  "rename_replacement": "restored-$1"
}