AI 기반 시각화 전문지식 서비스

프로그램개발 · 분야 선택22개 분야

Ver3.0 전체 열람

Ver3.0 🔍 PHP와 Elasticsearch로 만드는 강력한 전문 검색 시스템 완벽 가이드

2025.10.07

재능넷

댓글 0 전체 61 페이지

🔍 PHP와 Elasticsearch로 만드는 강력한 전문 검색 시스템 완벽 가이드

검색 기능을 한 단계 업그레이드하고 싶다면? 지금 바로 시작해보자!

🎯 왜 Elasticsearch인가?

웹사이트나 애플리케이션을 만들다 보면 검색 기능은 필수야. 그런데 MySQL의 LIKE 쿼리로는 한계가 명확하지. 사용자가 늘어나고 데이터가 쌓이면 검색 속도가 느려지고, 오타를 입력하면 결과가 안 나오고, 관련성 높은 결과를 우선적으로 보여주기도 어렵지. 😓

이럴 때 등장하는 게 바로 Elasticsearch야! 이건 단순한 데이터베이스가 아니라 검색에 특화된 엔진이거든. 실시간으로 빠르게 검색하고, 자연어 처리도 가능하고, 심지어 오타도 어느 정도 커버해줘. 네이버, 구글 같은 대형 포털부터 작은 스타트업까지 많이 사용하는 이유가 다 있어.

💡 재능넷 같은 플랫폼에서도 활용 가능!

재능넷처럼 다양한 재능과 서비스를 연결하는 플랫폼에서는 사용자가 원하는 재능을 빠르고 정확하게 찾는 게 핵심이야. Elasticsearch를 활용하면 "디자인", "디자이너", "디자인 작업" 같은 유사 검색어도 똑똑하게 처리할 수 있지!

🏗️ Elasticsearch 기본 개념 이해하기

본격적으로 코드를 작성하기 전에 Elasticsearch의 기본 개념을 알아야 해. 데이터베이스와 비슷하지만 용어가 좀 달라서 처음엔 헷갈릴 수 있거든.

📦 Index (인덱스)

MySQL의 데이터베이스와 비슷한 개념이야. 관련된 문서들을 모아놓은 컬렉션이지. 예를 들어 'products', 'users', 'posts' 같은 인덱스를 만들 수 있어.

📄 Document (문서)

MySQL의 row와 같은 개념. JSON 형태로 저장되며, 실제 검색 대상이 되는 데이터야. 각 문서는 고유한 ID를 가지고 있지.

🏷️ Field (필드)

MySQL의 column과 같아. 문서 내의 각 속성을 의미해. 'title', 'content', 'price' 같은 필드들이 있을 수 있지.

🔍 Mapping (매핑)

MySQL의 스키마와 비슷해. 각 필드의 데이터 타입과 분석 방법을 정의하는 거야. 검색 품질에 큰 영향을 미치는 중요한 부분이지.

🎓 역색인(Inverted Index)이란?

Elasticsearch가 빠른 이유는 역색인 구조 덕분이야. 일반적인 데이터베이스는 "문서 → 단어" 방향으로 저장하지만, Elasticsearch는 "단어 → 문서" 방향으로 저장해.

예를 들어볼게:

문서 1: "PHP는 웹 개발에 좋은 언어입니다"
문서 2: "PHP와 Elasticsearch를 함께 사용하면 좋습니다"

역색인 구조:

• PHP → [문서1, 문서2]
• 웹 → [문서1]
• 개발 → [문서1]
• Elasticsearch → [문서2]
• 좋은, 좋습니다 → [문서1, 문서2]

이렇게 저장하면 "PHP"를 검색할 때 모든 문서를 뒤질 필요 없이 바로 관련 문서를 찾을 수 있어! 🚀

⚙️ 환경 설정: PHP와 Elasticsearch 연결하기

자, 이제 실전으로 들어가보자! PHP에서 Elasticsearch를 사용하려면 공식 클라이언트 라이브러리를 설치해야 해.

Step 1: Elasticsearch 설치

먼저 Elasticsearch를 설치해야 해. Docker를 사용하면 정말 간단해:

docker pull docker.elastic.co/elasticsearch/elasticsearch:8.11.0

docker run -d --name elasticsearch \
  -p 9200:9200 -p 9300:9300 \
  -e "discovery.type=single-node" \
  -e "xpack.security.enabled=false" \
  docker.elastic.co/elasticsearch/elasticsearch:8.11.0

설치가 완료되면 브라우저에서 http://localhost:9200에 접속해봐. JSON 형태의 응답이 나오면 성공이야! 🎉

Step 2: PHP Elasticsearch 클라이언트 설치

Composer를 사용해서 공식 클라이언트를 설치하자:

composer require elasticsearch/elasticsearch

설치가 완료되면 PHP 코드에서 바로 사용할 수 있어!

Step 3: 기본 연결 테스트

제대로 연결되는지 확인해보자:

<?php
require 'vendor/autoload.php';

use Elastic\Elasticsearch\ClientBuilder;

// Elasticsearch 클라이언트 생성
$client = ClientBuilder::create()
    ->setHosts(['localhost:9200'])
    ->build();

// 연결 테스트
try {
    $response = $client->info();
    echo "연결 성공!\n";
    print_r($response->asArray());
} catch (Exception $e) {
    echo "연결 실패: " . $e->getMessage();
}

⚠️ 주의사항

Elasticsearch 8.x 버전부터는 기본적으로 보안 기능이 활성화되어 있어. 개발 환경에서는 xpack.security.enabled=false로 비활성화할 수 있지만, 프로덕션 환경에서는 반드시 인증을 설정해야 해!

📝 인덱스 생성과 매핑 설정

이제 실제로 데이터를 저장할 인덱스를 만들어보자. 예를 들어 상품 검색 시스템을 만든다고 가정해볼게.

🎨 매핑 설계의 중요성

매핑은 검색 품질을 결정하는 핵심이야. 각 필드를 어떻게 분석할지, 어떤 타입으로 저장할지 정의하는 거거든. 한 번 설정하면 변경이 어려우니까 처음부터 신중하게 설계해야 해!

<?php
require 'vendor/autoload.php';

use Elastic\Elasticsearch\ClientBuilder;

$client = ClientBuilder::create()
    ->setHosts(['localhost:9200'])
    ->build();

// 인덱스 생성 및 매핑 설정
$params = [
    'index' => 'products',
    'body' => [
        'settings' => [
            'number_of_shards' => 1,
            'number_of_replicas' => 0,
            'analysis' => [
                'analyzer' => [
                    'korean' => [
                        'type' => 'custom',
                        'tokenizer' => 'nori_tokenizer',
                        'filter' => ['lowercase', 'nori_part_of_speech']
                    ]
                ]
            ]
        ],
        'mappings' => [
            'properties' => [
                'id' => [
                    'type' => 'integer'
                ],
                'name' => [
                    'type' => 'text',
                    'analyzer' => 'korean',
                    'fields' => [
                        'keyword' => [
                            'type' => 'keyword'
                        ]
                    ]
                ],
                'description' => [
                    'type' => 'text',
                    'analyzer' => 'korean'
                ],
                'category' => [
                    'type' => 'keyword'
                ],
                'price' => [
                    'type' => 'integer'
                ],
                'tags' => [
                    'type' => 'keyword'
                ],
                'created_at' => [
                    'type' => 'date',
                    'format' => 'yyyy-MM-dd HH:mm:ss'
                ],
                'rating' => [
                    'type' => 'float'
                ],
                'stock' => [
                    'type' => 'integer'
                ]
            ]
        ]
    ]
];

try {
    // 기존 인덱스가 있으면 삭제
    if ($client->indices()->exists(['index' => 'products'])->asBool()) {
        $client->indices()->delete(['index' => 'products']);
    }
    
    // 새 인덱스 생성
    $response = $client->indices()->create($params);
    echo "인덱스 생성 완료!\n";
} catch (Exception $e) {
    echo "에러 발생: " . $e->getMessage();
}

🔑 매핑 설정 해설

1. text vs keyword

• text: 전문 검색용. 형태소 분석을 거쳐 토큰으로 나뉘어 저장돼. "스마트폰 케이스"는 "스마트폰", "케이스"로 분리되지.
• keyword: 정확한 매칭용. 분석 없이 원본 그대로 저장돼. 카테고리, 태그, 상태값 같은 곳에 사용해.

2. multi-field (fields)

name 필드를 보면 text와 keyword 두 가지로 저장하고 있어. 이렇게 하면 전문 검색도 하고, 정렬이나 집계도 할 수 있지!

3. analyzer

한국어 검색을 위해 nori 분석기를 사용했어. 이건 Elasticsearch에 기본 포함된 한국어 형태소 분석기야. "먹었습니다"를 "먹다"로 정규화해주는 똑똑한 녀석이지! 🧠

💾 문서 색인하기 (Indexing)

인덱스를 만들었으니 이제 실제 데이터를 넣어보자! 문서를 추가하는 방법은 여러 가지가 있어.

단일 문서 색인

<?php
// 단일 상품 추가
$params = [
    'index' => 'products',
    'id' => 1,
    'body' => [
        'id' => 1,
        'name' => '무선 블루투스 이어폰',
        'description' => '고음질 무선 이어폰으로 최대 24시간 재생 가능합니다. 노이즈 캔슬링 기능 지원',
        'category' => '전자제품',
        'price' => 89000,
        'tags' => ['이어폰', '블루투스', '무선', '노이즈캔슬링'],
        'created_at' => date('Y-m-d H:i:s'),
        'rating' => 4.5,
        'stock' => 150
    ]
];

try {
    $response = $client->index($params);
    echo "문서 추가 완료! ID: " . $response['_id'] . "\n";
} catch (Exception $e) {
    echo "에러: " . $e->getMessage();
}

대량 문서 색인 (Bulk API)

여러 문서를 한 번에 추가할 때는 Bulk API를 사용하면 훨씬 빨라! 네트워크 왕복 횟수가 줄어들거든.

<?php
// 여러 상품 한 번에 추가
$products = [
    [
        'id' => 2,
        'name' => '스마트워치 프로',
        'description' => '건강 관리와 운동 추적이 가능한 스마트워치',
        'category' => '전자제품',
        'price' => 350000,
        'tags' => ['스마트워치', '헬스케어', '운동'],
        'created_at' => date('Y-m-d H:i:s'),
        'rating' => 4.7,
        'stock' => 80
    ],
    [
        'id' => 3,
        'name' => '게이밍 키보드',
        'description' => '기계식 스위치를 사용한 RGB 게이밍 키보드',
        'category' => '컴퓨터주변기기',
        'price' => 129000,
        'tags' => ['키보드', '게이밍', '기계식', 'RGB'],
        'created_at' => date('Y-m-d H:i:s'),
        'rating' => 4.3,
        'stock' => 200
    ],
    [
        'id' => 4,
        'name' => '무선 마우스',
        'description' => '인체공학적 디자인의 무선 마우스',
        'category' => '컴퓨터주변기기',
        'price' => 45000,
        'tags' => ['마우스', '무선', '인체공학'],
        'created_at' => date('Y-m-d H:i:s'),
        'rating' => 4.1,
        'stock' => 300
    ]
];

$params = ['body' => []];

foreach ($products as $product) {
    $params['body'][] = [
        'index' => [
            '_index' => 'products',
            '_id' => $product['id']
        ]
    ];
    $params['body'][] = $product;
}

try {
    $response = $client->bulk($params);
    
    if ($response['errors']) {
        echo "일부 문서 추가 실패\n";
    } else {
        echo "모든 문서 추가 완료!\n";
    }
} catch (Exception $e) {
    echo "에러: " . $e->getMessage();
}

🚀 성능 최적화 팁

• Bulk API 사용 시 한 번에 1000~5000개 정도가 적당해
• 너무 많으면 메모리 문제가 생길 수 있고, 너무 적으면 효율이 떨어져
• 실시간 반영이 필요하면 refresh=true 옵션을 사용하되, 성능에 영향을 줄 수 있으니 주의해야 해

MySQL 데이터를 Elasticsearch로 마이그레이션

기존 MySQL 데이터를 Elasticsearch로 옮기는 실전 예제야:

<?php
// MySQL 연결
$pdo = new PDO('mysql:host=localhost;dbname=myshop', 'username', 'password');

// 상품 데이터 가져오기
$stmt = $pdo->query("SELECT * FROM products");
$products = $stmt->fetchAll(PDO::FETCH_ASSOC);

$params = ['body' => []];
$count = 0;

foreach ($products as $product) {
    $params['body'][] = [
        'index' => [
            '_index' => 'products',
            '_id' => $product['id']
        ]
    ];
    
    $params['body'][] = [
        'id' => (int)$product['id'],
        'name' => $product['name'],
        'description' => $product['description'],
        'category' => $product['category'],
        'price' => (int)$product['price'],
        'tags' => explode(',', $product['tags']),
        'created_at' => $product['created_at'],
        'rating' => (float)$product['rating'],
        'stock' => (int)$product['stock']
    ];
    
    $count++;
    
    // 1000개씩 묶어서 전송
    if ($count % 1000 == 0) {
        $client->bulk($params);
        $params = ['body' => []];
        echo "$count 개 처리 완료...\n";
    }
}

// 남은 데이터 처리
if (!empty($params['body'])) {
    $client->bulk($params);
}

echo "총 $count 개 마이그레이션 완료!\n";

🔎 검색 쿼리 작성하기

드디어 검색의 핵심 부분이야! Elasticsearch는 정말 다양한 검색 방법을 제공해. 하나씩 살펴보자.

1️⃣ 기본 매치 쿼리 (Match Query)

가장 기본적인 전문 검색이야. 입력한 텍스트를 분석해서 관련 문서를 찾아줘.

<?php
// "블루투스 이어폰" 검색
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'match' => [
                'name' => '블루투스 이어폰'
            ]
        ]
    ]
];

$response = $client->search($params);

foreach ($response['hits']['hits'] as $hit) {
    echo "상품명: " . $hit['_source']['name'] . "\n";
    echo "점수: " . $hit['_score'] . "\n";
    echo "---\n";
}

"블루투스 이어폰"을 검색하면 "블루투스"나 "이어폰" 중 하나라도 포함된 문서를 찾아줘. 둘 다 포함된 문서가 더 높은 점수를 받지!

2️⃣ 멀티 매치 쿼리 (Multi Match Query)

여러 필드를 동시에 검색할 때 사용해. 제목과 설명을 함께 검색하는 경우가 많잖아?

<?php
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'multi_match' => [
                'query' => '무선 게이밍',
                'fields' => ['name^2', 'description'],  // name 필드에 2배 가중치
                'type' => 'best_fields'
            ]
        ]
    ]
];

$response = $client->search($params);

^2는 가중치야. name 필드에서 매칭되면 점수를 2배로 올려줘. 제목이 설명보다 중요하니까!

3️⃣ 불 쿼리 (Bool Query)

여러 조건을 조합할 때 사용해. must(AND), should(OR), must_not(NOT), filter 같은 조건을 섞을 수 있어.

<?php
// "전자제품" 카테고리에서 "무선"이 포함되고, 
// 가격이 100,000원 이하인 상품 검색
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'bool' => [
                'must' => [
                    ['match' => ['description' => '무선']]
                ],
                'filter' => [
                    ['term' => ['category' => '전자제품']],
                    ['range' => ['price' => ['lte' => 100000]]]
                ],
                'should' => [
                    ['match' => ['tags' => '블루투스']]
                ],
                'minimum_should_match' => 0
            ]
        ],
        'sort' => [
            ['rating' => ['order' => 'desc']],
            ['_score' => ['order' => 'desc']]
        ]
    ]
];

$response = $client->search($params);

📌 must vs filter 차이점

• must: 스코어 계산에 영향을 줘. 관련성이 높을수록 점수가 올라가
• filter: 스코어 계산 안 해. 단순히 조건 만족 여부만 체크해. 캐싱되어서 더 빨라!

카테고리나 가격 같은 정확한 조건은 filter로, 텍스트 검색은 must로 처리하는 게 좋아.

4️⃣ 퍼지 쿼리 (Fuzzy Query)

오타를 처리해주는 똑똑한 검색이야! 사용자가 "블투투스"라고 잘못 입력해도 "블루투스"를 찾아줘.

<?php
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'match' => [
                'name' => [
                    'query' => '블투투스',
                    'fuzziness' => 'AUTO'  // 자동으로 편집 거리 계산
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

fuzziness는 얼마나 다른 글자를 허용할지 정해. 'AUTO'로 설정하면 단어 길이에 따라 자동으로 조절돼!

5️⃣ 구문 검색 (Phrase Query)

정확한 구문을 찾을 때 사용해. "무선 이어폰"이라는 순서 그대로 나오는 문서만 찾아줘.

<?php
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'match_phrase' => [
                'description' => [
                    'query' => '노이즈 캔슬링',
                    'slop' => 1  // 단어 사이에 1개까지 다른 단어 허용
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

🎨 검색 결과 하이라이팅

검색 결과에서 검색어를 강조 표시하면 사용자 경험이 훨씬 좋아져. 네이버나 구글에서 검색어가 굵게 표시되는 것처럼 말이야!

<?php
$params = [
    'index' => 'products',
    'body' => [
        'query' => [
            'multi_match' => [
                'query' => '무선 블루투스',
                'fields' => ['name', 'description']
            ]
        ],
        'highlight' => [
            'fields' => [
                'name' => [
                    'pre_tags' => ['<strong class="highlight">'],
                    'post_tags' => ['</strong>']
                ],
                'description' => [
                    'pre_tags' => ['<strong class="highlight">'],
                    'post_tags' => ['</strong>'],
                    'fragment_size' => 150,  // 표시할 문자 수
                    'number_of_fragments' => 3  // 최대 조각 수
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

foreach ($response['hits']['hits'] as $hit) {
    echo "상품명: ";
    if (isset($hit['highlight']['name'])) {
        echo $hit['highlight']['name'][0];  // 하이라이트된 제목
    } else {
        echo $hit['_source']['name'];
    }
    echo "\n";
    
    if (isset($hit['highlight']['description'])) {
        echo "설명: " . implode(' ... ', $hit['highlight']['description']) . "\n";
    }
    echo "---\n";
}

✨ 하이라이팅 결과 예시

상품명: 무선 블루투스 이어폰
설명: 고음질 무선 이어폰으로 최대 24시간 재생 가능합니다 ... 블루투스 5.0을 지원하여 안정적인 연결이 가능합니다

📊 집계(Aggregation)로 통계 내기

Elasticsearch의 강력한 기능 중 하나가 바로 집계야! 검색 결과를 분석하고 통계를 낼 수 있어. 쇼핑몰의 필터 기능 같은 거 생각하면 돼.

카테고리별 상품 수 집계

<?php
$params = [
    'index' => 'products',
    'body' => [
        'size' => 0,  // 문서는 가져오지 않고 집계만
        'aggs' => [
            'categories' => [
                'terms' => [
                    'field' => 'category',
                    'size' => 10
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

echo "카테고리별 상품 수:\n";
foreach ($response['aggregations']['categories']['buckets'] as $bucket) {
    echo $bucket['key'] . ": " . $bucket['doc_count'] . "개\n";
}

가격대별 분포 집계

<?php
$params = [
    'index' => 'products',
    'body' => [
        'size' => 0,
        'aggs' => [
            'price_ranges' => [
                'range' => [
                    'field' => 'price',
                    'ranges' => [
                        ['to' => 50000],
                        ['from' => 50000, 'to' => 100000],
                        ['from' => 100000, 'to' => 200000],
                        ['from' => 200000]
                    ]
                ]
            ],
            'avg_price' => [
                'avg' => [
                    'field' => 'price'
                ]
            ],
            'max_price' => [
                'max' => [
                    'field' => 'price'
                ]
            ],
            'min_price' => [
                'min' => [
                    'field' => 'price'
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

echo "가격대별 상품 수:\n";
foreach ($response['aggregations']['price_ranges']['buckets'] as $bucket) {
    $from = $bucket['from'] ?? 0;
    $to = $bucket['to'] ?? '이상';
    echo number_format($from) . "원 ~ " . (is_numeric($to) ? number_format($to) . "원" : $to) . ": ";
    echo $bucket['doc_count'] . "개\n";
}

echo "\n통계:\n";
echo "평균 가격: " . number_format($response['aggregations']['avg_price']['value']) . "원\n";
echo "최고 가격: " . number_format($response['aggregations']['max_price']['value']) . "원\n";
echo "최저 가격: " . number_format($response['aggregations']['min_price']['value']) . "원\n";

중첩 집계: 카테고리별 평균 가격

<?php
$params = [
    'index' => 'products',
    'body' => [
        'size' => 0,
        'aggs' => [
            'categories' => [
                'terms' => [
                    'field' => 'category'
                ],
                'aggs' => [
                    'avg_price' => [
                        'avg' => [
                            'field' => 'price'
                        ]
                    ],
                    'avg_rating' => [
                        'avg' => [
                            'field' => 'rating'
                        ]
                    ]
                ]
            ]
        ]
    ]
];

$response = $client->search($params);

echo "카테고리별 통계:\n";
foreach ($response['aggregations']['categories']['buckets'] as $bucket) {
    echo "\n" . $bucket['key'] . ":\n";
    echo "  상품 수: " . $bucket['doc_count'] . "개\n";
    echo "  평균 가격: " . number_format($bucket['avg_price']['value']) . "원\n";
    echo "  평균 평점: " . round($bucket['avg_rating']['value'], 2) . "점\n";
}

🎯 집계 활용 아이디어

• 쇼핑몰 필터: 카테고리, 브랜드, 가격대별 상품 수 표시
• 대시보드: 일별/월별 통계, 인기 검색어 순위
• 추천 시스템: 비슷한 가격대/카테고리 상품 추천
• 트렌드 분석: 시간대별 검색 패턴 분석

🔧 실전 검색 시스템 구축하기

이제 배운 내용을 종합해서 실제로 사용할 수 있는 검색 시스템을 만들어보자! 재능넷 같은 플랫폼에서도 바로 적용할 수 있는 수준이야.

검색 클래스 만들기

<?php
class ProductSearch {
    private $client;
    private $index = 'products';
    
    public function __construct($hosts = ['localhost:9200']) {
        $this->client = ClientBuilder::create()
            ->setHosts($hosts)
            ->build();
    }
    
    /**
     * 통합 검색 메서드
     */
    public function search($keyword, $filters = [], $options = []) {
        $query = $this->buildQuery($keyword, $filters);
        
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => $query,
                'from' => $options['from'] ?? 0,
                'size' => $options['size'] ?? 20,
                'sort' => $this->buildSort($options['sort'] ?? 'relevance'),
                'highlight' => [
                    'fields' => [
                        'name' => new \stdClass(),
                        'description' => [
                            'fragment_size' => 150,
                            'number_of_fragments' => 2
                        ]
                    ]
                ]
            ]
        ];
        
        // 집계 추가
        if (!empty($options['aggregations'])) {
            $params['body']['aggs'] = $this->buildAggregations();
        }
        
        return $this->client->search($params);
    }
    
    /**
     * 쿼리 빌더
     */
    private function buildQuery($keyword, $filters) {
        $must = [];
        $filter = [];
        
        // 키워드 검색
        if (!empty($keyword)) {
            $must[] = [
                'multi_match' => [
                    'query' => $keyword,
                    'fields' => ['name^3', 'description', 'tags^2'],
                    'type' => 'best_fields',
                    'fuzziness' => 'AUTO'
                ]
            ];
        }
        
        // 카테고리 필터
        if (!empty($filters['category'])) {
            $filter[] = ['term' => ['category' => $filters['category']]];
        }
        
        // 가격 범위 필터
        if (!empty($filters['price_min']) || !empty($filters['price_max'])) {
            $range = [];
            if (!empty($filters['price_min'])) {
                $range['gte'] = $filters['price_min'];
            }
            if (!empty($filters['price_max'])) {
                $range['lte'] = $filters['price_max'];
            }
            $filter[] = ['range' => ['price' => $range]];
        }
        
        // 평점 필터
        if (!empty($filters['rating_min'])) {
            $filter[] = ['range' => ['rating' => ['gte' => $filters['rating_min']]]];
        }
        
        // 재고 있는 상품만
        if (!empty($filters['in_stock'])) {
            $filter[] = ['range' => ['stock' => ['gt' => 0]]];
        }
        
        // Bool 쿼리 구성
        $bool = [];
        if (!empty($must)) {
            $bool['must'] = $must;
        }
        if (!empty($filter)) {
            $bool['filter'] = $filter;
        }
        
        // 키워드가 없으면 전체 검색
        if (empty($bool)) {
            return ['match_all' => new \stdClass()];
        }
        
        return ['bool' => $bool];
    }
    
    /**
     * 정렬 옵션 빌더
     */
    private function buildSort($sortType) {
        switch ($sortType) {
            case 'price_asc':
                return [['price' => ['order' => 'asc']]];
            case 'price_desc':
                return [['price' => ['order' => 'desc']]];
            case 'rating':
                return [['rating' => ['order' => 'desc']], ['_score' => ['order' => 'desc']]];
            case 'newest':
                return [['created_at' => ['order' => 'desc']]];
            case 'relevance':
            default:
                return [['_score' => ['order' => 'desc']]];
        }
    }
    
    /**
     * 집계 빌더
     */
    private function buildAggregations() {
        return [
            'categories' => [
                'terms' => ['field' => 'category', 'size' => 20]
            ],
            'price_ranges' => [
                'range' => [
                    'field' => 'price',
                    'ranges' => [
                        ['key' => '5만원 미만', 'to' => 50000],
                        ['key' => '5만원~10만원', 'from' => 50000, 'to' => 100000],
                        ['key' => '10만원~20만원', 'from' => 100000, 'to' => 200000],
                        ['key' => '20만원 이상', 'from' => 200000]
                    ]
                ]
            ],
            'avg_price' => [
                'avg' => ['field' => 'price']
            ]
        ];
    }
    
    /**
     * 자동완성 제안
     */
    public function suggest($prefix) {
        $params = [
            'index' => $this->index,
            'body' => [
                'suggest' => [
                    'product-suggest' => [
                        'prefix' => $prefix,
                        'completion' => [
                            'field' => 'name.suggest',
                            'size' => 10,
                            'fuzzy' => [
                                'fuzziness' => 'AUTO'
                            ]
                        ]
                    ]
                ]
            ]
        ];
        
        return $this->client->search($params);
    }
}

검색 API 엔드포인트 만들기

<?php
// search_api.php
require 'vendor/autoload.php';
require 'ProductSearch.php';

header('Content-Type: application/json; charset=utf-8');

$search = new ProductSearch();

// GET 파라미터 받기
$keyword = $_GET['q'] ?? '';
$page = max(1, intval($_GET['page'] ?? 1));
$perPage = min(100, max(1, intval($_GET['per_page'] ?? 20)));
$sort = $_GET['sort'] ?? 'relevance';

// 필터 설정
$filters = [];
if (!empty($_GET['category'])) {
    $filters['category'] = $_GET['category'];
}
if (!empty($_GET['price_min'])) {
    $filters['price_min'] = intval($_GET['price_min']);
}
if (!empty($_GET['price_max'])) {
    $filters['price_max'] = intval($_GET['price_max']);
}
if (!empty($_GET['rating_min'])) {
    $filters['rating_min'] = floatval($_GET['rating_min']);
}
if (!empty($_GET['in_stock'])) {
    $filters['in_stock'] = true;
}

// 검색 옵션
$options = [
    'from' => ($page - 1) * $perPage,
    'size' => $perPage,
    'sort' => $sort,
    'aggregations' => true
];

try {
    $response = $search->search($keyword, $filters, $options);
    
    // 결과 포맷팅
    $result = [
        'success' => true,
        'total' => $response['hits']['total']['value'],
        'took' => $response['took'],
        'page' => $page,
        'per_page' => $perPage,
        'items' => [],
        'aggregations' => []
    ];
    
    // 검색 결과
    foreach ($response['hits']['hits'] as $hit) {
        $item = $hit['_source'];
        $item['score'] = $hit['_score'];
        
        // 하이라이트 적용
        if (isset($hit['highlight'])) {
            if (isset($hit['highlight']['name'])) {
                $item['name_highlighted'] = $hit['highlight']['name'][0];
            }
            if (isset($hit['highlight']['description'])) {
                $item['description_highlighted'] = implode(' ... ', $hit['highlight']['description']);
            }
        }
        
        $result['items'][] = $item;
    }
    
    // 집계 결과
    if (isset($response['aggregations'])) {
        $result['aggregations'] = [
            'categories' => $response['aggregations']['categories']['buckets'],
            'price_ranges' => $response['aggregations']['price_ranges']['buckets'],
            'avg_price' => $response['aggregations']['avg_price']['value']
        ];
    }
    
    echo json_encode($result, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
    
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode([
        'success' => false,
        'error' => $e->getMessage()
    ], JSON_UNESCAPED_UNICODE);
}

프론트엔드 연동 예제

<!DOCTYPE html>
<html>
<head>
    <title>상품 검색</title>
    <style>
        .search-box { margin: 20px; }
        .filters { margin: 20px; }
        .results { margin: 20px; }
        .product-item { 
            border: 1px solid #ddd; 
            padding: 15px; 
            margin: 10px 0;
            border-radius: 8px;
        }
        .highlight { 
            background: #fff9c4; 
            font-weight: bold; 
        }
    </style>
</head>
<body>
    <div class="search-box">
        <input type="text" id="searchInput" placeholder="상품 검색..." style="width: 400px; padding: 10px;">
        <button onclick="search()">검색</button>
    </div>
    
    <div class="filters">
        <select id="categoryFilter">
            <option value="">전체 카테고리</option>
        </select>
        
        <select id="sortFilter">
            <option value="relevance">관련도순</option>
            <option value="price_asc">가격 낮은순</option>
            <option value="price_desc">가격 높은순</option>
            <option value="rating">평점순</option>
            <option value="newest">최신순</option>
        </select>
        
        <label>
            <input type="checkbox" id="inStockFilter"> 재고 있는 상품만
        </label>
    </div>
    
    <div class="results" id="results"></div>
    
    <script>
    async function search() {
        const keyword = document.getElementById('searchInput').value;
        const category = document.getElementById('categoryFilter').value;
        const sort = document.getElementById('sortFilter').value;
        const inStock = document.getElementById('inStockFilter').checked;
        
        const params = new URLSearchParams({
            q: keyword,
            sort: sort,
            per_page: 20
        });
        
        if (category) params.append('category', category);
        if (inStock) params.append('in_stock', '1');
        
        try {
            const response = await fetch(`search_api.php?${params}`);
            const data = await response.json();
            
            displayResults(data);
            updateFilters(data.aggregations);
        } catch (error) {
            console.error('검색 오류:', error);
        }
    }
    
    function displayResults(data) {
        const resultsDiv = document.getElementById('results');
        
        if (data.total === 0) {
            resultsDiv.innerHTML = '<p>검색 결과가 없습니다.</p>';
            return;
        }
        
        let html = `<p>총 ${data.total}개의 상품 (${data.took}ms)</p>`;
        
        data.items.forEach(item => {
            const name = item.name_highlighted || item.name;
            const desc = item.description_highlighted || item.description.substring(0, 150);
            
            html += `
                <div class="product-item">
                    <h3>${name}</h3>
                    <p>${desc}</p>
                    <p>
                        <strong>가격:</strong> ${item.price.toLocaleString()}원 | 
                        <strong>평점:</strong> ${item.rating}점 | 
                        <strong>재고:</strong> ${item.stock}개
                    </p>
                    <p><small>카테고리: ${item.category} | 태그: ${item.tags.join(', ')}</small></p>
                </div>
            `;
        });
        
        resultsDiv.innerHTML = html;
    }
    
    function updateFilters(aggregations) {
        if (!aggregations) return;
        
        // 카테고리 필터 업데이트
        const categoryFilter = document.getElementById('categoryFilter');
        const currentCategory = categoryFilter.value;
        
        categoryFilter.innerHTML = '<option value="">전체 카테고리</option>';
        
        aggregations.categories.forEach(bucket => {
            const option = document.createElement('option');
            option.value = bucket.key;
            option.textContent = `${bucket.key} (${bucket.doc_count})`;
            if (bucket.key === currentCategory) {
                option.selected = true;
            }
            categoryFilter.appendChild(option);
        });
    }
    
    // 엔터키로 검색
    document.getElementById('searchInput').addEventListener('keypress', function(e) {
        if (e.key === 'Enter') {
            search();
        }
    });
    
    // 필터 변경 시 자동 검색
    document.getElementById('categoryFilter').addEventListener('change', search);
    document.getElementById('sortFilter').addEventListener('change', search);
    document.getElementById('inStockFilter').addEventListener('change', search);
    </script>
</body>
</html>

⚡ 성능 최적화 전략

검색 시스템이 느려지면 사용자들이 떠나가. 빠르고 효율적인 검색을 위한 최적화 방법들을 알아보자!

🎯 인덱싱 최적화

Bulk API 활용
한 번에 여러 문서를 색인하면 네트워크 오버헤드가 줄어들어. 1000~5000개씩 묶어서 처리하는 게 좋아.

Refresh 간격 조정
실시간 검색이 필요 없다면 refresh_interval을 늘려서 성능을 높일 수 있어.

PUT /products/_settings
{
  "index": {
    "refresh_interval": "30s"
  }
}

💾 쿼리 캐싱

Filter Context 사용
filter는 캐싱되기 때문에 반복적인 쿼리가 빨라져. 카테고리, 가격 범위 같은 건 filter로 처리해.

Request Cache
size=0인 집계 쿼리는 자동으로 캐싱돼. 통계 데이터를 빠르게 가져올 수 있지.

🔍 검색 쿼리 최적화

필요한 필드만 가져오기
_source 필터링으로 필요한 필드만 가져오면 네트워크 전송량이 줄어들어.

"_source": ["name", "price", "rating"]

from + size 제한
깊은 페이지네이션은 느려. search_after나 scroll API를 사용하는 게 좋아.

📊 샤드 설정

적절한 샤드 수
너무 많으면 오버헤드가 크고, 너무 적으면 확장성이 떨어져. 샤드당 20~50GB가 적당해.

레플리카 활용
읽기 성능을 높이려면 레플리카를 늘려. 검색 요청이 여러 노드에 분산돼.

⚠️ 피해야 할 안티패턴

1. Wildcard 쿼리 남용
*검색어* 같은 패턴은 매우 느려. 가능하면 n-gram이나 edge n-gram을 사용해.

2. 너무 많은 필드 검색
multi_match에서 수십 개 필드를 검색하면 느려져. 중요한 필드 3~5개만 선택해.

3. 깊은 페이지네이션
from=10000 같은 건 피해. 10,000개 문서를 모두 정렬해야 하거든.

4. 실시간 refresh
매번 refresh=true를 사용하면 성능이 크게 떨어져. 꼭 필요한 경우만 사용해.

✅ 성능 모니터링

<?php
// 느린 쿼리 로깅
$params = [
    'index' => 'products',
    'body' => [
        'profile' => true,  // 쿼리 프로파일링 활성화
        'query' => [
            'match' => ['name' => '검색어']
        ]
    ]
];

$response = $client->search($params);

// 프로파일 정보 확인
if (isset($response['profile'])) {
    $profile = $response['profile'];
    // 각 샤드별 실행 시간 분석
    foreach ($profile['shards'] as $shard) {
        foreach ($shard['searches'] as $search) {
            echo "쿼리 시간: " . $search['query'][0]['time_in_nanos'] / 1000000 . "ms\n";
        }
    }
}

🛡️ 보안과 운영 관리

프로덕션 환경에서는 보안이 정말 중요해! 기본 설정으로 운영하면 큰일 나.

🔐 필수 보안 설정

1. X-Pack Security 활성화

# elasticsearch.yml
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.http.ssl.enabled: true

2. 사용자 인증 설정

<?php
$client = ClientBuilder::create()
    ->setHosts(['https://localhost:9200'])
    ->setBasicAuthentication('username', 'password')
    ->setSSLVerification(false)  // 개발 환경에서만
    ->build();

3. 역할 기반 접근 제어
읽기 전용 사용자, 쓰기 권한 사용자를 분리해서 관리해. 애플리케이션에서는 최소 권한만 부여하는 게 원칙이야.

📈 모니터링과 로깅

클러스터 상태 확인

<?php
// 클러스터 헬스 체크
$health = $client->cluster()->health();

if ($health['status'] === 'red') {
    // 알림 발송
    error_log('Elasticsearch cluster is RED!');
}

// 노드 통계
$stats = $client->nodes()->stats();
foreach ($stats['nodes'] as $node) {
    $jvmHeapPercent = $node['jvm']['mem']['heap_used_percent'];
    if ($jvmHeapPercent > 85) {
        error_log("Node {$node['name']} heap usage: {$jvmHeapPercent}%");
    }
}

인덱스 관리

<?php
// 오래된 인덱스 삭제 (로그 데이터 등)
$indices = $client->cat()->indices(['format' => 'json']);

foreach ($indices as $index) {
    $indexName = $index['index'];
    
    // logs-2024-01-01 형식의 인덱스에서 날짜 추출
    if (preg_match('/logs-(\d{4}-\d{2}-\d{2})/', $indexName, $matches)) {
        $date = new DateTime($matches[1]);
        $now = new DateTime();
        $diff = $now->diff($date)->days;
        
        // 30일 이상 된 인덱스 삭제
        if ($diff > 30) {
            $client->indices()->delete(['index' => $indexName]);
            echo "Deleted old index: $indexName\n";
        }
    }
}

💡 백업과 복구

스냅샷 생성

<?php
// 스냅샷 리포지토리 등록
$client->snapshot()->createRepository([
    'repository' => 'my_backup',
    'body' => [
        'type' => 'fs',
        'settings' => [
            'location' => '/mount/backups/elasticsearch'
        ]
    ]
]);

// 스냅샷 생성
$client->snapshot()->create([
    'repository' => 'my_backup',
    'snapshot' => 'snapshot_' . date('Y-m-d'),
    'body' => [
        'indices' => 'products',
        'ignore_unavailable' => true,
        'include_global_state' => false
    ]
]);

정기적으로 스냅샷을 생성해서 데이터 손실에 대비해야 해. cron으로 자동화하는 게 좋아!

🚀 고급 기능 활용하기

기본 검색을 넘어서 더 똑똑한 기능들을 추가해보자!

🤖 자동완성 (Autocomplete)

사용자가 타이핑하는 동안 실시간으로 제안을 보여주는 기능이야. 검색 경험을 크게 향상시켜줘!

<?php
// 인덱스 생성 시 suggest 필드 추가
$params = [
    'index' => 'products',
    'body' => [
        'mappings' => [
            'properties' => [
                'name' => [
                    'type' => 'text',
                    'fields' => [
                        'suggest' => [
                            'type' => 'completion'
                        ]
                    ]
                ]
            ]
        ]
    ]
];

// 자동완성 검색
function autocomplete($client, $prefix) {
    $params = [
        'index' => 'products',
        'body' => [
            'suggest' => [
                'product-suggest' => [
                    'prefix' => $prefix,
                    'completion' => [
                        'field' => 'name.suggest',
                        'size' => 10,
                        'skip_duplicates' => true,
                        'fuzzy' => [
                            'fuzziness' => 1
                        ]
                    ]
                ]
            ]
        ]
    ];
    
    $response = $client->search($params);
    $suggestions = [];
    
    foreach ($response['suggest']['product-suggest'][0]['options'] as $option) {
        $suggestions[] = $option['text'];
    }
    
    return $suggestions;
}

// 사용 예시
$suggestions = autocomplete($client, '블루');
// 결과: ['블루투스 이어폰', '블루투스 스피커', '블루투스 키보드']

🎯 개인화 검색

사용자의 과거 행동을 기반으로 검색 결과를 조정할 수 있어. 더 관련성 높은 결과를 보여주는 거지!

<?php
function personalizedSearch($client, $keyword, $userId) {
    // 사용자의 과거 구매/조회 카테고리 가져오기
    $userPreferences = getUserPreferences($userId);
    
    $params = [
        'index' => 'products',
        'body' => [
            'query' => [
                'bool' => [
                    'must' => [
                        ['multi_match' => [
                            'query' => $keyword,
                            'fields' => ['name^3', 'description']
                        ]]
                    ],
                    'should' => [
                        // 사용자가 선호하는 카테고리에 가중치
                        ['terms' => [
                            'category' => $userPreferences['categories'],
                            'boost' => 2.0
                        ]],
                        // 사용자의 가격대에 맞는 상품
                        ['range' => [
                            'price' => [
                                'gte' => $userPreferences['price_min'],
                                'lte' => $userPreferences['price_max'],
                                'boost' => 1.5
                            ]
                        ]]
                    ]
                ]
            ]
        ]
    ];
    
    return $client->search($params);
}

function getUserPreferences($userId) {
    // 실제로는 데이터베이스에서 가져와야 함
    return [
        'categories' => ['전자제품', '컴퓨터주변기기'],
        'price_min' => 50000,
        'price_max' => 200000
    ];
}

📊 검색 분석 (Search Analytics)

어떤 검색어가 많이 사용되는지, 결과가 없는 검색은 무엇인지 분석하면 서비스 개선에 도움이 돼!

<?php
class SearchAnalytics {
    private $pdo;
    
    public function logSearch($keyword, $resultCount, $userId = null) {
        $stmt = $this->pdo->prepare("
            INSERT INTO search_logs 
            (keyword, result_count, user_id, created_at) 
            VALUES (?, ?, ?, NOW())
        ");
        $stmt->execute([$keyword, $resultCount, $userId]);
    }
    
    public function getPopularSearches($limit = 10) {
        $stmt = $this->pdo->prepare("
            SELECT keyword, COUNT(*) as count 
            FROM search_logs 
            WHERE created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
            GROUP BY keyword 
            ORDER BY count DESC 
            LIMIT ?
        ");
        $stmt->execute([$limit]);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }
    
    public function getZeroResultSearches($limit = 10) {
        $stmt = $this->pdo->prepare("
            SELECT keyword, COUNT(*) as count 
            FROM search_logs 
            WHERE result_count = 0 
            AND created_at >= DATE_SUB(NOW(), INTERVAL 7 DAY)
            GROUP BY keyword 
            ORDER BY count DESC 
            LIMIT ?
        ");
        $stmt->execute([$limit]);
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }
}

// 사용 예시
$analytics = new SearchAnalytics($pdo);

// 검색 시 로깅
$response = $client->search($params);
$analytics->logSearch(
    $keyword, 
    $response['hits']['total']['value'],
    $currentUserId
);

// 인기 검색어 확인
$popular = $analytics->getPopularSearches();
foreach ($popular as $item) {
    echo "{$item['keyword']}: {$item['count']}회\n";
}

// 결과 없는 검색어 확인 (상품 추가 필요)
$zeroResults = $analytics->getZeroResultSearches();
foreach ($zeroResults as $item) {
    echo "{$item['keyword']}: {$item['count']}회 검색됨\n";
}

🔄 동의어 처리 (Synonyms)

"노트북"을 검색해도 "랩탑"이 나오게 하려면 동의어 설정이 필요해!

<?php
// 동의어가 포함된 인덱스 생성
$params = [
    'index' => 'products',
    'body' => [
        'settings' => [
            'analysis' => [
                'filter' => [
                    'synonym_filter' => [
                        'type' => 'synonym',
                        'synonyms' => [
                            '노트북, 랩탑, 노트북컴퓨터',
                            '스마트폰, 휴대폰, 핸드폰',
                            '이어폰, 이어버드, 이어셋',
                            '무선, 와이어리스',
                            '블루투스, BT'
                        ]
                    ]
                ],
                'analyzer' => [
                    'synonym_analyzer' => [
                        'type' => 'custom',
                        'tokenizer' => 'standard',
                        'filter' => ['lowercase', 'synonym_filter']
                    ]
                ]
            ]
        ],
        'mappings' => [
            'properties' => [
                'name' => [
                    'type' => 'text',
                    'analyzer' => 'synonym_analyzer'
                ]
            ]
        ]
    ]
];

$client->indices()->create($params);

이제 "랩탑"을 검색해도 "노트북"이 포함된 상품이 나와! 사용자 경험이 훨씬 좋아지지? 😊

🎓 실전 프로젝트: 재능 검색 시스템

지금까지 배운 내용을 종합해서 재능넷 같은 플랫폼에서 사용할 수 있는 재능 검색 시스템을 만들어보자!

Step 1: 재능 인덱스 설계

<?php
$params = [
    'index' => 'talents',
    'body' => [
        'settings' => [
            'number_of_shards' => 2,
            'number_of_replicas' => 1,
            'analysis' => [
                'analyzer' => [
                    'korean' => [
                        'type' => 'custom',
                        'tokenizer' => 'nori_tokenizer',
                        'filter' => ['lowercase', 'nori_part_of_speech']
                    ]
                ]
            ]
        ],
        'mappings' => [
            'properties' => [
                'id' => ['type' => 'integer'],
                'title' => [
                    'type' => 'text',
                    'analyzer' => 'korean',
                    'fields' => [
                        'keyword' => ['type' => 'keyword'],
                        'suggest' => ['type' => 'completion']
                    ]
                ],
                'description' => [
                    'type' => 'text',
                    'analyzer' => 'korean'
                ],
                'category' => ['type' => 'keyword'],
                'subcategory' => ['type' => 'keyword'],
                'tags' => ['type' => 'keyword'],
                'seller_id' => ['type' => 'integer'],
                'seller_name' => [
                    'type' => 'text',
                    'fields' => ['keyword' => ['type' => 'keyword']]
                ],
                'price' => ['type' => 'integer'],
                'rating' => ['type' => 'float'],
                'review_count' => ['type' => 'integer'],
                'order_count' => ['type' => 'integer'],
                'delivery_days' => ['type' => 'integer'],
                'location' => ['type' => 'geo_point'],
                'is_online' => ['type' => 'boolean'],
                'is_express' => ['type' => 'boolean'],
                'created_at' => ['type' => 'date'],
                'updated_at' => ['type' => 'date']
            ]
        ]
    ]
];

$client->indices()->create($params);

Step 2: 재능 검색 클래스

<?php
class TalentSearch {
    private $client;
    private $index = 'talents';
    
    public function __construct($client) {
        $this->client = $client;
    }
    
    /**
     * 재능 검색
     */
    public function search($options = []) {
        $keyword = $options['keyword'] ?? '';
        $category = $options['category'] ?? '';
        $priceMin = $options['price_min'] ?? null;
        $priceMax = $options['price_max'] ?? null;
        $ratingMin = $options['rating_min'] ?? null;
        $isOnline = $options['is_online'] ?? null;
        $isExpress = $options['is_express'] ?? null;
        $location = $options['location'] ?? null;
        $distance = $options['distance'] ?? 10; // km
        $sort = $options['sort'] ?? 'relevance';
        $page = max(1, $options['page'] ?? 1);
        $perPage = min(100, max(1, $options['per_page'] ?? 20));
        
        // 쿼리 구성
        $must = [];
        $filter = [];
        $should = [];
        
        // 키워드 검색
        if (!empty($keyword)) {
            $must[] = [
                'multi_match' => [
                    'query' => $keyword,
                    'fields' => [
                        'title^3',
                        'description^2',
                        'tags^2',
                        'seller_name',
                        'category'
                    ],
                    'type' => 'best_fields',
                    'fuzziness' => 'AUTO'
                ]
            ];
        }
        
        // 카테고리 필터
        if (!empty($category)) {
            $filter[] = ['term' => ['category' => $category]];
        }
        
        // 가격 범위
        if ($priceMin !== null || $priceMax !== null) {
            $range = [];
            if ($priceMin !== null) $range['gte'] = $priceMin;
            if ($priceMax !== null) $range['lte'] = $priceMax;
            $filter[] = ['range' => ['price' => $range]];
        }
        
        // 평점 필터
        if ($ratingMin !== null) {
            $filter[] = ['range' => ['rating' => ['gte' => $ratingMin]]];
        }
        
        // 온라인/오프라인
        if ($isOnline !== null) {
            $filter[] = ['term' => ['is_online' => $isOnline]];
        }
        
        // 빠른 배송
        if ($isExpress) {
            $filter[] = ['term' => ['is_express' => true]];
        }
        
        // 위치 기반 검색
        if ($location && !empty($location['lat']) && !empty($location['lon'])) {
            $filter[] = [
                'geo_distance' => [
                    'distance' => $distance . 'km',
                    'location' => [
                        'lat' => $location['lat'],
                        'lon' => $location['lon']
                    ]
                ]
            ];
        }
        
        // 인기 판매자 부스트
        $should[] = [
            'range' => [
                'order_count' => [
                    'gte' => 100,
                    'boost' => 1.5
                ]
            ]
        ];
        
        // 높은 평점 부스트
        $should[] = [
            'range' => [
                'rating' => [
                    'gte' => 4.5,
                    'boost' => 1.3
                ]
            ]
        ];
        
        // Bool 쿼리
        $query = ['bool' => []];
        if (!empty($must)) $query['bool']['must'] = $must;
        if (!empty($filter)) $query['bool']['filter'] = $filter;
        if (!empty($should)) {
            $query['bool']['should'] = $should;
            $query['bool']['minimum_should_match'] = 0;
        }
        
        // 전체 검색
        if (empty($must) && empty($filter)) {
            $query = ['match_all' => new \stdClass()];
        }
        
        // 정렬
        $sortOptions = $this->buildSort($sort, $location);
        
        // 검색 실행
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => $query,
                'from' => ($page - 1) * $perPage,
                'size' => $perPage,
                'sort' => $sortOptions,
                'highlight' => [
                    'fields' => [
                        'title' => new \stdClass(),
                        'description' => [
                            'fragment_size' => 150,
                            'number_of_fragments' => 2
                        ]
                    ]
                ],
                'aggs' => [
                    'categories' => [
                        'terms' => ['field' => 'category', 'size' => 20]
                    ],
                    'price_ranges' => [
                        'range' => [
                            'field' => 'price',
                            'ranges' => [
                                ['key' => '1만원 미만', 'to' => 10000],
                                ['key' => '1만원~5만원', 'from' => 10000, 'to' => 50000],
                                ['key' => '5만원~10만원', 'from' => 50000, 'to' => 100000],
                                ['key' => '10만원 이상', 'from' => 100000]
                            ]
                        ]
                    ],
                    'avg_price' => ['avg' => ['field' => 'price']],
                    'avg_rating' => ['avg' => ['field' => 'rating']]
                ]
            ]
        ];
        
        return $this->client->search($params);
    }
    
    /**
     * 정렬 옵션
     */
    private function buildSort($sort, $location = null) {
        switch ($sort) {
            case 'price_asc':
                return [['price' => ['order' => 'asc']]];
            case 'price_desc':
                return [['price' => ['order' => 'desc']]];
            case 'rating':
                return [
                    ['rating' => ['order' => 'desc']],
                    ['review_count' => ['order' => 'desc']]
                ];
            case 'popular':
                return [['order_count' => ['order' => 'desc']]];
            case 'newest':
                return [['created_at' => ['order' => 'desc']]];
            case 'distance':
                if ($location && !empty($location['lat']) && !empty($location['lon'])) {
                    return [[
                        '_geo_distance' => [
                            'location' => [
                                'lat' => $location['lat'],
                                'lon' => $location['lon']
                            ],
                            'order' => 'asc',
                            'unit' => 'km'
                        ]
                    ]];
                }
                // fallthrough
            case 'relevance':
            default:
                return [['_score' => ['order' => 'desc']]];
        }
    }
    
    /**
     * 자동완성
     */
    public function autocomplete($prefix) {
        $params = [
            'index' => $this->index,
            'body' => [
                'suggest' => [
                    'talent-suggest' => [
                        'prefix' => $prefix,
                        'completion' => [
                            'field' => 'title.suggest',
                            'size' => 10,
                            'skip_duplicates' => true,
                            'fuzzy' => ['fuzziness' => 1]
                        ]
                    ]
                ]
            ]
        ];
        
        $response = $this->client->search($params);
        $suggestions = [];
        
        foreach ($response['suggest']['talent-suggest'][0]['options'] as $option) {
            $suggestions[] = [
                'text' => $option['text'],
                'score' => $option['_score']
            ];
        }
        
        return $suggestions;
    }
    
    /**
     * 유사 재능 추천
     */
    public function moreLikeThis($talentId) {
        $params = [
            'index' => $this->index,
            'body' => [
                'query' => [
                    'more_like_this' => [
                        'fields' => ['title', 'description', 'tags'],
                        'like' => [
                            [
                                '_index' => $this->index,
                                '_id' => $talentId
                            ]
                        ],
                        'min_term_freq' => 1,
                        'max_query_terms' => 12
                    ]
                ],
                'size' => 10
            ]
        ];
        
        return $this->client->search($params);
    }
}

Step 3: API 엔드포인트

<?php
// talent_search_api.php
require 'vendor/autoload.php';
require 'TalentSearch.php';

header('Content-Type: application/json; charset=utf-8');

$client = ClientBuilder::create()
    ->setHosts(['localhost:9200'])
    ->build();

$search = new TalentSearch($client);

$action = $_GET['action'] ?? 'search';

try {
    switch ($action) {
        case 'search':
            $options = [
                'keyword' => $_GET['q'] ?? '',
                'category' => $_GET['category'] ?? '',
                'price_min' => isset($_GET['price_min']) ? intval($_GET['price_min']) : null,
                'price_max' => isset($_GET['price_max']) ? intval($_GET['price_max']) : null,
                'rating_min' => isset($_GET['rating_min']) ? floatval($_GET['rating_min']) : null,
                'is_online' => isset($_GET['is_online']) ? ($_GET['is_online'] === '1') : null,
                'is_express' => isset($_GET['is_express']) ? ($_GET['is_express'] === '1') : null,
                'sort' => $_GET['sort'] ?? 'relevance',
                'page' => intval($_GET['page'] ?? 1),
                'per_page' => intval($_GET['per_page'] ?? 20)
            ];
            
            // 위치 정보
            if (!empty($_GET['lat']) && !empty($_GET['lon'])) {
                $options['location'] = [
                    'lat' => floatval($_GET['lat']),
                    'lon' => floatval($_GET['lon'])
                ];
                $options['distance'] = intval($_GET['distance'] ?? 10);
            }
            
            $response = $search->search($options);
            
            $result = [
                'success' => true,
                'total' => $response['hits']['total']['value'],
                'took' => $response['took'],
                'items' => [],
                'aggregations' => $response['aggregations'] ?? []
            ];
            
            foreach ($response['hits']['hits'] as $hit) {
                $item = $hit['_source'];
                $item['score'] = $hit['_score'];
                
                if (isset($hit['highlight'])) {
                    $item['highlight'] = $hit['highlight'];
                }
                
                if (isset($hit['sort'])) {
                    $item['distance'] = $hit['sort'][0] ?? null;
                }
                
                $result['items'][] = $item;
            }
            
            echo json_encode($result, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT);
            break;
            
        case 'autocomplete':
            $prefix = $_GET['q'] ?? '';
            $suggestions = $search->autocomplete($prefix);
            
            echo json_encode([
                'success' => true,
                'suggestions' => $suggestions
            ], JSON_UNESCAPED_UNICODE);
            break;
            
        case 'similar':
            $talentId = $_GET['id'] ?? '';
            $response = $search->moreLikeThis($talentId);
            
            $items = [];
            foreach ($response['hits']['hits'] as $hit) {
                $items[] = $hit['_source'];
            }
            
            echo json_encode([
                'success' => true,
                'items' => $items
            ], JSON_UNESCAPED_UNICODE);
            break;
            
        default:
            throw new Exception('Invalid action');
    }
    
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode([
        'success' => false,
        'error' => $e->getMessage()
    ], JSON_UNESCAPED_UNICODE);
}

💭 마무리하며

와! 여기까지 정말 긴 여정이었어. PHP와 Elasticsearch를 활용한 전문 검색 시스템 구축에 대해 알아봤는데, 어때? 생각보다 복잡하지만 막상 해보면 재미있지? 😊

🎯 핵심 요약

1. Elasticsearch의 강점
• 빠른 검색 속도 (역색인 구조)
• 오타 허용 (퍼지 검색)
• 관련성 기반 정렬 (스코어링)
• 강력한 집계 기능
• 확장성 (샤딩, 레플리카)

2. 검색 품질 향상 방법
• 적절한 매핑 설계
• 한국어 형태소 분석기 활용
• 동의어 처리
• 개인화 검색
• 하이라이팅

3. 성능 최적화
• Bulk API 사용
• Filter context 활용
• 적절한 샤드 설정
• 쿼리 캐싱
• 모니터링

4. 보안과 운영
• 인증 설정
• 역할 기반 접근 제어
• 정기 백업
• 로그 분석

🚀 다음 단계로

이제 기본은 마스터했으니 더 나아가보자!

학습 추천:
• Logstash로 데이터 파이프라인 구축
• Kibana로 시각화 대시보드 만들기
• 머신러닝 기능 활용 (이상 탐지, 추천)
• 클러스터 구성과 샤드 관리
• 성능 튜닝 심화

실전 프로젝트 아이디어:
• 이커머스 상품 검색
• 채용 공고 검색
• 부동산 매물 검색
• 블로그/뉴스 검색
• 재능 마켓플레이스 (재능넷처럼!)

✨ 마지막 조언

검색은 사용자 경험의 핵심이야. 빠르고 정확한 검색은 사용자를 만족시키고, 비즈니스 성과로 이어져. Elasticsearch는 강력한 도구지만, 제대로 활용하려면 지속적인 학습과 최적화가 필요해.

처음엔 어렵게 느껴질 수 있지만, 하나씩 차근차근 적용해보면 금방 익숙해질 거야. 작은 프로젝트부터 시작해서 점점 확장해나가는 걸 추천해!

재능넷 같은 플랫폼을 만들고 싶다면, 이 글에서 배운 내용이 큰 도움이 될 거야. 사용자들이 원하는 재능을 빠르고 정확하게 찾을 수 있게 해주는 검색 시스템, 정말 멋지지 않아? 🎨

궁금한 점이 있거나 막히는 부분이 있다면 Elasticsearch 공식 문서와 커뮤니티를 활용해봐. 많은 개발자들이 비슷한 문제를 겪고 해결책을 공유하고 있거든!

자, 이제 당신의 프로젝트에 강력한 검색 기능을 추가해볼 시간이야. 화이팅! 💪

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

사용 제한: 재능넷의 명시적 서면 동의 없이 본 컨텐츠를 복제, 수정, 배포, 또는 상업적으로 활용하는 행위는 엄격히 금지됩니다.
데이터 수집 금지: 본 컨텐츠에 대한 무단 스크래핑, 크롤링, 및 자동화된 데이터 수집은 법적 제재의 대상이 됩니다.
AI 학습 제한: 재능넷의 AI 생성 컨텐츠를 타 AI 모델 학습에 무단 사용하는 행위는 금지되며, 이는 지적 재산권 침해로 간주됩니다.

재능인 5급 인증

6.9K

업무용/홍보/마케팅/정보수집/CRM/ERP 등등 개발 해 드립니다.

AS규정 기본적으로 A/S 는 평생 가능합니다. *. 구매자의 요청으로 수정 및 보완이 필요한 경우 일정 금액의 수고비를 상호 협의하에 요청 할수 있습니다. 환불규정 프로그램 특성상 납품이 완료된 후에는 환불이 불가능합니다. 완료된 제품은 이메일 또는 메신져 로 (셋업형식) 납품합니다. 각종 홍보 및 마케팅 / 오토 등록 / 정보 수집 등 업무에 필요한 어

5,000원~

3.5K

JAVA / JSP / PHP / PYTHON / RPA / ETL 저렴한 금액으로 프로그램해드립니다.

저렴하고 빠르고 추후 유지 관리 비용 등을 고려 하여 최대한 부담없는 프로그램을 만들어 드리겠습니다. 프로그램 제작에 관련된 어떤한 문의도 받습니다. [경력및이력] 경력: 15년 [제작유형] 현재는 간단한 JAVA / PYTHON / JSP / PHP 프로그램만 제작하고 있습니다. [제작환경] 개발언어 : JAVA , JSP, PHP , JQUERY [진행

5,000원~

재능인 4급 인증

11.1K

엑셀 자동화 작업과 VBA, 매크로 프로그램 작업 도와드려요!

안녕하세요!!! 고객님이 상상하시는 작업물 그 이상을 작업해 드리려 노력합니다. 저는 작업물을 완성하여 고객님에게 보내드리는 것으로 거래 완료라고 생각하지 않습니다. 프로그램을 사용하시면서 예상치 못한 문제 발생시 빠른 응답과 완벽한 무료 AS로 저와 거래하신 많은 고객분들과 오랫동안 인연을 이어가고 있습니다. 고객님이 예상하시는 것보다 더 좋은 결과로 보

5,000원~

4.7K

기업관리 프로그램(일반관리/공장관리/MES/ERP)을 제작해드립니다.

>>>서비스 설명<<< 저렴한 가격, 합리적인 가격, 최적의 공수로 윈도우 프로그램을 제작해 드립니다 고객이 원하는 프로그램, 꼭 맞는 프로그램을 제작하기 위해 최선을 다합니다. 기업과 공장을 운영하기 위한 모든 모듈이 준비되어 있습니다. 웹 ERP / 윈도우 프로그램 모두 제작 가능하며 크로스플랫폼 제작도 가능합니다. Java, C#, MSSQL 등 최신

99,000원~

재능인 3급 인증

28.6K

엑셀을 이용한 자동화 양식 작성과 분석 및 프로그래밍

30년간 직장 생활을 하고 정년 퇴직을 하였습니다. 퇴직 후 재능넷 수행 내용은 쇼핑몰/학원/판매점 등 관리 프로그램 및 데이터 분석, 의료기관/결혼정보/부동산 등 고객관리 및 고객분석과 예산관리, 번역문서 한글 추출 프로그래밍 등 - 주문데이터 변환 및 재고관리와 판매분석 - 판매데이터 등록 및 이력관리와 판매분석 - 주문과 생산/출하 등 주문 및 재고

50,000원~

알바 출퇴근 기록 엑셀 → 한 달 급여 정산표 자동 계산 프로그램 (주휴·야간·연장)

매달 출근부를 보며 알바마다 근무시간을 더하고, 주휴수당 받을 주인지 하나씩 따지고 계신가요? 출퇴근 기록 엑셀(종이 출근부를 옮긴 것·출퇴근 앱에서 내려받은 것)을 폴더에 넣고 한 번 실행하면, 직원마다 근무시간·연장·야간·주휴수당·공휴일 수당·세전 합계를 한 엑셀로 정리하는 프로그램을 만들어 드립니다. 진행 1. 출퇴근 기록 엑셀 견본과 직원 목록(이름

50,000원~ 후기 0개

456

엑셀기초에서 VBA, 크롤링 고급기능까지 강의 드립니다.

서비스 설명 서비스 설명 #간단한 엑셀 함수부터 고급 기능인 크롤링, 폼 이용까지 강의드립니다. IT 업무에 종사하면서, 개발 경력을 바탕으로실무에서 다양한 작업을 코딩하여 사용하고 있습니다. 엑셀 및 pyhotn 기초기능 사용에 어려움을 느끼시는 분들께 최선의 도움을 드릴 것을 약속합니다^^ [강의이력] 2011.11 ~ 2012.12 - 컴퓨터학원 컴ㅇ

40,000원~ 후기 0개

Unity에서 센서·CSV 기록 데이터를 시각화해 드립니다

숫자로 남은 이동·센서 기록을 Unity에서 다시 보기 시간이 적힌 위치 기록이나 센서 수치를 Unity 화면에서 재생하는 데모를 만듭니다. 실제 장비를 계속 가동하지 않아도 저장된 자료가 어떤 순서로 변했는지 살펴보려는 시연·확인 용도에 맞는 작업입니다. 35,000원 · 작업기간 5일 데이터가 어떻게 생겼는지부터 알려 주세요 예를 들어 CSV에 시간·X

35,000원~ 후기 0개

프로그램개발 · 분야 선택22개 분야

🔍 PHP와 Elasticsearch로 만드는 강력한 전문 검색 시스템 완벽 가이드

🎯 왜 Elasticsearch인가?

🏗️ Elasticsearch 기본 개념 이해하기

📦 Index (인덱스)

📄 Document (문서)

🏷️ Field (필드)

🔍 Mapping (매핑)

🎓 역색인(Inverted Index)이란?

⚙️ 환경 설정: PHP와 Elasticsearch 연결하기

Step 1: Elasticsearch 설치

Step 2: PHP Elasticsearch 클라이언트 설치

Step 3: 기본 연결 테스트

📝 인덱스 생성과 매핑 설정

🎨 매핑 설계의 중요성

🔑 매핑 설정 해설

💾 문서 색인하기 (Indexing)

단일 문서 색인

대량 문서 색인 (Bulk API)

MySQL 데이터를 Elasticsearch로 마이그레이션

🔎 검색 쿼리 작성하기

1️⃣ 기본 매치 쿼리 (Match Query)

2️⃣ 멀티 매치 쿼리 (Multi Match Query)

3️⃣ 불 쿼리 (Bool Query)

4️⃣ 퍼지 쿼리 (Fuzzy Query)

5️⃣ 구문 검색 (Phrase Query)

🎨 검색 결과 하이라이팅

📊 집계(Aggregation)로 통계 내기

카테고리별 상품 수 집계

가격대별 분포 집계

중첩 집계: 카테고리별 평균 가격

🔧 실전 검색 시스템 구축하기

검색 클래스 만들기

검색 API 엔드포인트 만들기

프론트엔드 연동 예제

⚡ 성능 최적화 전략

🎯 인덱싱 최적화

💾 쿼리 캐싱

🔍 검색 쿼리 최적화

📊 샤드 설정

⚠️ 피해야 할 안티패턴

✅ 성능 모니터링

🛡️ 보안과 운영 관리

🔐 필수 보안 설정

📈 모니터링과 로깅

💡 백업과 복구

🚀 고급 기능 활용하기

🤖 자동완성 (Autocomplete)

🎯 개인화 검색

📊 검색 분석 (Search Analytics)

🔄 동의어 처리 (Synonyms)

🎓 실전 프로젝트: 재능 검색 시스템

Step 1: 재능 인덱스 설계

Step 2: 재능 검색 클래스

Step 3: API 엔드포인트

💭 마무리하며

🎯 핵심 요약

🚀 다음 단계로

관련 키워드

댓글 작성

로그인이 필요합니다

댓글 0

지식인의 숲 - 지적 재산권 보호 고지

지적 재산권 보호 고지

해당 지식과 관련있는 인기재능