Code Cook

[Spring] Elastic Cloud + Spring Boot 3.x 연동하기

Chef.Yeon — Fri, 23 Aug 2024 16:37:28 +0900

1. 의존성

build.gradle

implementation 'org.springframework.boot:spring-boot-starter-data-elasticsearch'

2. API Key 연동

ElasticSearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticSearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.api-key}")
    private String apiKey;

    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Authorization", "ApiKey " + apiKey);
        return ClientConfiguration.builder()
                .connectedTo(host)
                .usingSsl()
                .withDefaultHeaders(headers)
                .build();
    }
}

2-1. 호스트

host는 copy endpoint를 통해 복사한 내용을 사용한다.

이때, https:// 부분은 제외하고 맨 뒤에 ':443' 포트를 추가해야 한다.

예시) 0a6485cf(생략).us-central1.gcp.cloud.es.io:443

2-2. API 키 발급

API Key는 다음과 같이 발급 받을 수 있다.

1) 좌측 상단 메뉴 > Management > Stack Management

2) 좌측 메뉴 Security > API keys > Create API Key > 원하는 Name 입력

발급 받은 API Key는 잊어버리지 않도록 따로 저장해두자.

API Key를 환경 변수에 추가하고 애플리케이션을 실행하면 된다.

2. USERNAME-PASSWORD 연동

username과 password는 클라우드에서 deployment를 생성하고 발급 받은 것을 사용한다.

만약 비밀번호를 잊어버렸다면 다음과 같이 재발급 받을 수 있다.

username은 기본적으로 elastic이다.

ElasticSearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticsearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.username}")
    private String username;

    @Value("${spring.elasticsearch.password}")
    private String password;

    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo(host)
                .usingSsl()
                .withBasicAuth(username, password)
                .build();
    }
}

username과 password를 환경 변수로 등록해주면 된다.

3. Nori 분석기

만약 Nori 분석기를 사용한다면 다음과 같이 플러그인을 추가할 수 있다.

1) 우측 메뉴 Edit > Manage user settings and extensions

2) analysis-nori 선택

analysis-nori를 선택하고 Back 으로 빠져 나온 뒤, 가장 밑의 save를 클릭한다.

[TIL - 20240819] Elasticsearch8.x + Kibana, Docker-compose로 구성, Credential 설정

Chef.Yeon — Mon, 19 Aug 2024 04:39:23 +0900

문제점

공식 사이트를 참고했다.

1. Docker-Compose 파일 작성

.env

ELASTIC_PASSWORD=elastic
KIBANA_PASSWORD=kibana_system
STACK_VERSION=8.7.1
CLUSTER_NAME=docker-cluster
LICENSE=basic
ES_PORT=9200
KIBANA_PORT=5601

docker-compose.yml

version: "3.8"

volumes:
  certs:
    driver: local
  esdata01:
    driver: local
  kibanadata:
    driver: local

networks:
  default:
    name: elastic
    external: false

services:
  setup:
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    volumes:
      - certs:/usr/share/elasticsearch/config/certs
    user: "0"
    command: >
      bash -c '
        if [ x${ELASTIC_PASSWORD} == x ]; then
          echo "Set the ELASTIC_PASSWORD environment variable in the .env file";
          exit 1;
        elif [ x${KIBANA_PASSWORD} == x ]; then
          echo "Set the KIBANA_PASSWORD environment variable in the .env file";
          exit 1;
        fi;
        if [ ! -f config/certs/ca.zip ]; then
          echo "Creating CA";
          bin/elasticsearch-certutil ca --silent --pem -out config/certs/ca.zip;
          unzip config/certs/ca.zip -d config/certs;
        fi;
        if [ ! -f config/certs/certs.zip ]; then
          echo "Creating certs";
          echo -ne \
          "instances:\n"\
          "  - name: es01\n"\
          "    dns:\n"\
          "      - es01\n"\
          "      - localhost\n"\
          "    ip:\n"\
          "      - 127.0.0.1\n"\
          "  - name: kibana\n"\
          "    dns:\n"\
          "      - kibana\n"\
          "      - localhost\n"\
          "    ip:\n"\
          "      - 127.0.0.1\n"\
          > config/certs/instances.yml;
          bin/elasticsearch-certutil cert --silent --pem -out config/certs/certs.zip --in config/certs/instances.yml --ca-cert config/certs/ca/ca.crt --ca-key config/certs/ca/ca.key;
          unzip config/certs/certs.zip -d config/certs;
        fi;
        echo "Setting file permissions"
        chown -R root:root config/certs;
        find . -type d -exec chmod 750 \{\} \;;
        find . -type f -exec chmod 640 \{\} \;;
        echo "Waiting for Elasticsearch availability";
        until curl -s --cacert config/certs/ca/ca.crt https://es01:9200 | grep -q "missing authentication credentials"; do sleep 30; done;
        echo "Setting kibana_system password";
        until curl -s -X POST --cacert config/certs/ca/ca.crt -u "elastic:${ELASTIC_PASSWORD}" -H "Content-Type: application/json" https://es01:9200/_security/user/kibana_system/_password -d "{\"password\":\"${KIBANA_PASSWORD}\"}" | grep -q "^{}"; do sleep 10; done;
        echo "All done!";
      '
    healthcheck:
      test: ["CMD-SHELL", "[ -f config/certs/es01/es01.crt ]"]
      interval: 1s
      timeout: 5s
      retries: 120

  es01:
    depends_on:
      setup:
        condition: service_healthy
    image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
    labels:
      co.elastic.logs/module: elasticsearch
    volumes:
      - certs:/usr/share/elasticsearch/config/certs
      - esdata01:/usr/share/elasticsearch/data
    ports:
      - ${ES_PORT}:9200
    environment:
      - node.name=es01
      - cluster.name=${CLUSTER_NAME}
      - discovery.type=single-node
      - ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
      - bootstrap.memory_lock=true
      - xpack.security.enabled=true
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.http.ssl.enabled=true
      - xpack.security.http.ssl.key=certs/es01/es01.key
      - xpack.security.http.ssl.certificate=certs/es01/es01.crt
      - xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.enabled=true
      - xpack.security.transport.ssl.key=certs/es01/es01.key
      - xpack.security.transport.ssl.certificate=certs/es01/es01.crt
      - xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
      - xpack.security.transport.ssl.verification_mode=certificate
      - xpack.license.self_generated.type=${LICENSE}
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -s --cacert config/certs/ca/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'",
        ]
      interval: 10s
      timeout: 10s
      retries: 120

  kibana:
    depends_on:
      es01:
        condition: service_healthy
    image: docker.elastic.co/kibana/kibana:${STACK_VERSION}
    labels:
      co.elastic.logs/module: kibana
    volumes:
      - certs:/usr/share/kibana/config/certs
      - kibanadata:/usr/share/kibana/data
    ports:
      - ${KIBANA_PORT}:5601
    environment:
      - SERVERNAME=kibana
      - ELASTICSEARCH_HOSTS=https://es01:9200
      - ELASTICSEARCH_USERNAME=kibana_system
      - ELASTICSEARCH_PASSWORD=${KIBANA_PASSWORD}
      - ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES=config/certs/ca/ca.crt
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -s -I http://localhost:5601 | grep -q 'HTTP/1.1 302 Found'",
        ]
      interval: 10s
      timeout: 10s
      retries: 120

docker-compose up을 통해 컨테이너를 실행한다.

2. Nori 분석기 설치

# es container 확인
$ docker ps 

# es컨테이너 접속
$ docker exec -it {containerId} /bin/bash

$ cd /usr/share/elasticsearch/bin/

$ ./elasticsearch-plugin install analysis-nori

docker-compose stop > docker-compose up

3. Elasticsearch Config 설정

ElasticsearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticsearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.username}")
    private String username;

    @Value("${spring.elasticsearch.password}")
    private String password;

    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo(host)
                .usingSsl()
                .withBasicAuth(username, password)
                .build();
    }

    @Bean
    public ElasticsearchClient elasticsearchClient(RestClient restClient) {
        ObjectMapper objectMapper =
                new ObjectMapper()
                        .registerModule(new JavaTimeModule())
                        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        ElasticsearchTransport transport =
                new RestClientTransport(restClient, new JacksonJsonpMapper(objectMapper));
        return new ElasticsearchClient(transport);
    }
}

애플리케이션 실행 시, SSL 인증서 등록 관련 에러가 발생했다.

PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

시도

인증서 객체를 생성하여 키스토어에 등록

docker-compose.yml의 setup 서비스 command를 살펴보면, 컨테이너 내에서 SSL/TLS 인증서 및 보안 설정을 구성하여 Elasticsearch와 Kibana가 통신할 수 있도록 한다.

여기서 SSL/TLS 인증을 위한 CA를 생성하는 부분이 있다.

echo "Creating CA";
bin/elasticsearch-certutil ca --silent --pem -out config/certs/ca.zip;
unzip config/certs/ca.zip -d config/certs;

PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

이 오류는 SSL 인증서 검증 과정에서 발생하는 문제로, 애플리케이션이 Elasticsearch 서버의 인증서에 대해 신뢰할 수 있는 인증서 경로( PKIX path building failed)를 찾지 못했을 때 발생할 수 있다.

이를 해결하기 위해 클라이언트 측에서 해당 인증서를 신뢰하도록 설정해줘야 한다.

Java Keystore에 해당 인증서를 추가하자.

Stack Overflow에서 ca.crt를 디코딩하고 인증서 객체를 생성해 KeyStore에 저장 하는 방법을 찾았다.

https://stackoverflow.com/questions/75081596/how-to-configure-security-in-elasticsearch-8-5-3-using-starter-data-elasticsearc

How to configure security in elasticsearch 8.5.3 using Starter Data Elasticsearch 3.0.1 in maven java springboot

I was able to create an elasticsearch 8.5.3 server as a docker image, but with security completely disabled, and in my springboot application I am using ElasticsearchRepository to perform insert,up...

stackoverflow.com

elasticsearch 컨테이너의 /usr/share/elasticsearch/config/certs/ca/ca.crt를 열면 다음과 같은 내용이 있다.

-----BEGIN CERTIFICATE-----
MIIDSTCCAjGgAwIBAgIUR1gPSYQEiqCeWaI7ir1hQf9BZ9EwDQYJKoZIhvcNAQEL
(생략)
OL01woHZE+jHFz4i/31pARjL6Fvq8vsrjXJc2Uo=
-----END CERTIFICATE-----

첫 번째 줄(BEGIN)과 마지막 줄(END)를 제외하고 복사하여 application.yml에 추가한다.

나는 환경 변수를 만들어 추가했다.

spring:
  elasticsearch:
    host: ${ELASTIC_HOST}
    username: ${ELASTIC_USER}
    password: ${ELASTIC_PASSWORD}
    client:
      certificate: ${ELASTIC_CA}

다음과 같은 방식으로 해도 된다. 개행이 없어야 하기 때문에 '|' 을 추가하여 여러 줄의 텍스트를 하나의 문자열로 취급하도록 한다.

    client:
      certificate: |
        MIIDSTCCAjGgAwIBAgIUR1gPSYQEiqCeWaI7ir1hQf9BZ9EwDQYJKoZIhvcNAQEL
		(생략)
        OL01woHZE+jHFz4i/31pARjL6Fvq8vsrjXJc2Uo=

ElasticsearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticsearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.client.certificate}")
    private String certificateBase64;
    
    @Value("${spring.elasticsearch.username}")
    private String username;

    @Value("${spring.elasticsearch.password}")
    private String password;

    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        try {
            return ClientConfiguration.builder()
                    .connectedTo("localhost:9200")
                    .usingSsl(getSSLContext())
                    .withBasicAuth(username, password)
                    .build();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Bean
    public ElasticsearchClient elasticsearchClient(RestClient restClient) {
        ObjectMapper objectMapper =
                new ObjectMapper()
                        .registerModule(new JavaTimeModule())
                        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        ElasticsearchTransport transport =
                new RestClientTransport(restClient, new JacksonJsonpMapper(objectMapper));
        return new ElasticsearchClient(transport);
    }

    private SSLContext getSSLContext() throws Exception {
        byte[] decodedCertificate = Base64.getMimeDecoder().decode(certificateBase64);

        CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
        X509Certificate ca;
        try (InputStream certificateInputStream = new ByteArrayInputStream(decodedCertificate)) {
            ca = (X509Certificate) certificateFactory.generateCertificate(certificateInputStream);
        }

        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null); 
        keyStore.setCertificateEntry("ca", ca);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(keyStore);

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), new java.security.SecureRandom());
        return sslContext;
    }
}

해결

cmd로 인증서 등록

1. ca.crt 로컬에 복사

C드라이브 하위에 elasticsearch 폴더를 생성하고, cmd를 관리자 권한으로 실행했다.

(폴더를 생성하지 않고 C드라이브에 복사해도 된다)

$ docker ps

$ docker cp {es container id}:/usr/share/elasticsearch/config/certs/ca/ca.crt /elasticsearch

elasticsearch 폴더에 ca.crt 파일이 복사된 것을 확인할 수 있다.

2. 인증서 등록

자바가 설치된 경로의 lib 폴더로 이동해서 자바 인증서 저장소에 ca.crt를 등록해주자

$ cd {JAVA_HOME}\lib

$ keytool.exe -import -alias {별칭} -keystore "{JAVA_HOME}\lib\security\cacerts" -storepass changeit -file "인증서 경로"

예시: keytool.exe -import -alias es -keystore "{JAVA_HOME}\lib\security\cacerts" -storepass changeit -file "C:\elasticsearch\ca.crt"

등록한 인증서를 삭제하고 싶다면 다음 명령을 사용한다.

$ keytool -delete -alias es -keystore "{JAVA_HOME}\lib\security\cacerts" -storepass changeit

참고

https://ssow93.tistory.com/73

[에러] PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certificati

SSL 인증서 등록 관련 에러 발생 고객사 쪽의 API를 호출을 하고 있었는데, 이 사이트에 https를 적용하면서 정상적으로 호출이 되지 않고 아래와 같은 에러가 발생하였다. 이에 관련해서 조치

ssow93.tistory.com

[TIL - 20240817] Spring Boot 3.x + Elasticsearch 8.x jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type `java.time.LocalDateTime`

Chef.Yeon — Sat, 17 Aug 2024 01:44:16 +0900

문제점 - LocalDateTime 직렬화/역직렬화

Elasticsearch 검색을 수행하던 도중 오류가 발생했다.

http://localhost:8080/api/v1/posts/suggest?keyword=통밀빵

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type `java.time.LocalDateTime` not supported by default: add Module"com.fasterxml.jackson.datatype:jackson-datatype-jsr310" to enable handling

LocalDateTime의 직렬화/역직렬화 문제가 발생했다.

해결

ElasticsearchConfig에 ElasticsearchClient 빈을 생성하는 코드를 추가하고, JacksonJsonpMapper에 JavaTimeModule을 등록하여 LocalDateTime을 처리할 수 있도록 설정했다.

ElasticsearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticsearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.username}")
    private String username;

    @Value("${spring.elasticsearch.password}")
    private String password;

    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo(host)
                .build();
    }

    @Bean
    public ElasticsearchClient elasticsearchClient(RestClient restClient) {
        ObjectMapper objectMapper =
                new ObjectMapper()
                        .registerModule(new JavaTimeModule())
                        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        ElasticsearchTransport transport =
                new RestClientTransport(restClient, new JacksonJsonpMapper(objectMapper));
        return new ElasticsearchClient(transport);
    }
}

1. ObjectMapper 생성

Jackson 라이브러리의 ObjectMapper는 JSON 데이터를 Java 객체로 변환하거나, Java 객체를 JSON으로 변환하는 데 사용된다.

registerModule(new JavaTimeModule())
- JavaTimeModule을 등록하여 LocalDateTime과 같은 Java8 날짜/시간 타입을 처리할 수 있도록 한다.
disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
- 날짜/시간이 타임 스탬프가 아닌 ISO-8601 문자열 형식('yyyy-MM-dd'T'HH:mm:ss.SSSZ ')으로 직렬화 되도록 한다.

2. ElasticsearchTransport 생성

RestClientTransport는 Elasticsearch 서버와의 통신을 담당한다.

RestClientTransport를 생성할 때, JacksonJsonpMapper에 objectMapper를 전달하여 LocalDateTime을 지원하도록 설정한다.

3. ElasticsearchClient

설정한 ElasticsearchTransport를 사용하여 ElasticsearchClient를 생성하고 빈으로 등록한다.

[TIL-20240813-17] Elasticsearch 자동 완성 (2)

Chef.Yeon — Tue, 13 Aug 2024 01:56:18 +0900

https://yeon-dev.tistory.com/254

[TIL - 20240810] ElasticSearch 자동 완성 (1)

https://yeon-dev.tistory.com/253 [Spring] Spring Boot3.x Docker Compose로 ElasticSearch 8.x+Kibana 구성 (Local)프로젝트 루트 디렉토리에 docker-compose.yml을 생성한다. 1. Docker Compose 파일 작성docker-compose.ymlversion: '3.7'servi

yeon-dev.tistory.com

문제점1 - 검색 결과 우선 순위

PostMan으로 요청하면 응답이 다음과 같다.

http://localhost:8080/api/v1/posts/suggest?keyword=맛있는 통밀빵

[
    "통밀빵 정말 맛있는 카페",
    "맛있는 통밀빵 간식 만들기",
    "맛있는 비건 디저트 카페",
    "통밀빵 맛있게 먹는 방법",
    "통밀 식빵 맛있게 먹는 방법",
    "통밀빵 효능",
    "감성빵집 통밀빵",
    "통밀빵 샌드위치",
    "100% 통밀빵 토스트",
    "스완베이커리 통밀빵",
    "파리바게트 통밀빵 다이어트"
]

"맛있는 통밀빵 간식 만들기"가 검색어와 일치하는 구문이 있음에도 2번째로 위치한다.

또한, "맛있는 비건 디저트 카페"는 "통밀 식빵 맛있게 먹는 방법" 보다 우선 순위가 높다.

문제점1 시도

1. Kibana 콘솔

GET /posts/_search
{
  "size": 5,
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "title": {
              "query": "맛있는 통밀빵",
              "slop": 1, 
              "boost": 3.0
            }
          }
        },
        {
          "match": {
            "title.ngram": {
              "query": "맛있는 통밀빵",
              "operator": "and", 
              "boost": 2.0
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

1. Bool Query

여러 쿼리를 결합하는데 사용한다. 상위에 bool 쿼리를 사용하고, 그 안에 다른 쿼리를 넣어 사용할 수 있다.

must: 쿼리가 참인 문서 검색
must_not: 쿼리가 거짓인 문서 검색
should: 검색 결과 중 이 쿼리에 해당하는 문서의 점수를 높임
filter: 쿼리가 참인 문서를 검색하지만, 스코어를 계산하지 않음

위에서는 should를 사용하여 두 개의 조건을 정의하고 있다.

minimum_should_match: 1로 설정하여, 두 조건 중 하나라도 일치하면 문서를 반환한다.

2. should

2-1. match_phrase 쿼리

match_phrase 쿼리는 검색어의 단어가 모두 존재하고, 순서가 같은 문서를 반환한다.

slop: 1
- slop은 단어 사이에 허용되는 단어 개수를 의미한다.
- slop: 1을 통해 "맛있는 통밀빵"을 입력했을 때, 예를 들어 "맛있는 최고의 통밀빵"도 조건을 만족할 수 있다.
boost: 3.0
- boost는 조건의 중요도를 의미한다.
- match_phrase 조건에 높은 boost를 설정하여, 이 조건을 만족하면 가장 높은 우선 순위를 갖도록 했다.

2-2. match 쿼리

N-gram 분석기를 사용하는 titme.ngram 필드에서 검색을 수행한다.

operator: "and"
- 모든 단어가 문서에 포함되어야 결과에 포함된다.
boost: 2.0
- match_phrase 보다는 낮은 우선 순위를 갖는다.

2. 서비스, 레포지토리 코드

PostCustomElasticRepositoryImpl

@Repository
@RequiredArgsConstructor
public class PostCustomElasticRepositoryImpl implements PostCustomElasticRepository {
    private final ElasticsearchClient elasticsearchClient;
    private final String POST_INDEX = "posts";

    @Override
    public List<PostDocument> findAutoCompleteSuggestion(String keyword, int size) {
        try {
            SearchResponse<PostDocument> response = elasticsearchClient.search(s -> s
                    .index(POST_INDEX)
                    .size(size)
                    .query(q -> q
                            .bool(b -> b
                                    .should(sh -> sh
                                            .matchPhrase(mp -> mp
                                                    .field("title")
                                                    .query(keyword)
                                                    .slop(1)
                                                    .boost(3.0f)
                                            )
                                    )
                                    .should(sh -> sh
                                            .match(m -> m
                                                    .field("title.ngram")
                                                    .query(keyword)
                                                    .operator(Operator.And)
                                                    .boost(2.0f)
                                            )
                                    ).minimumShouldMatch("1")
                            )
                    ), PostDocument.class
            );

            return response.hits().hits().stream()
                    .map(Hit::source)
                    .toList();
        } catch (IOException e) {
            throw new ElasticsearchOperationException(ErrorCode.ES_OPERATION_FAILED);
        }
    }
}

PostQueryService

    public List<String> suggestByKeyword(String keyword, int size) {
        return postElasticRepository.findAutoCompleteSuggestion(keyword, size)
                .stream()
                .map(PostDocument::getTitle)
                .toList();
    }

ES 검색 도중 LocalDateTime 직렬화/역직렬화 문제가 있었다. 자세한 내용은 다음 링크에서 확인할 수 있다.

https://yeon-dev.tistory.com/256

[TIL - 20240817] Spring Boot 3.x + Elasticsearch 8.x jackson.databind.exc.InvalidDefinitionException: Java 8 date/time type `jav

문제점 - LocalDateTime 직렬화/역직렬화Elasticsearch 검색을 수행하던 도중 오류가 발생했다.http://localhost:8080/api/v1/posts/suggest?keyword=통밀빵 com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Java 8 d

yeon-dev.tistory.com

PostMan으로 요청을 보내보자.

size는 디폴트 값(=5)이 설정되어 있어서 요청 파라미터에 포함하지 않았다.

http://localhost:8080/api/v1/posts/suggest?keyword=맛있는 통밀빵

"맛있는 비건 디저트 카페"

두 가지 조건 모두 맞지 않아 결과에 포함되지 않는다.

우선 순위

검색어와 일치하는 구문이 있는 "맛있는 통밀빵 간식 만들기"가 가장 위에 위치한다. (조건1 충족)
"통밀빵"과 "맛있는"이 포함된 "통밀빵 정말 맛있는 카페"가 그 다음에 위치한다. (조건2 충족)

"통밀빵 맛있게 먹는 방법"은 결과에 포함되지 않는다. "맛있는"이 아닌 "맛있게"가 포함되어 있기 때문이다.

하지만 검색어와 유사하므로 결과에 포함될 필요가 있었다.

문제점1 해결

1. match 쿼리(Nori 분석기 사용) 추가

GET /posts/_search
{
  "size": 10, 
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "title": {
              "query": "맛있는 통밀빵",
              "slop": 1, 
              "boost": 3.0
            }
          }
        },
        {
          "match": {
            "title.nori": {
              "query": "맛있는 통밀빵",
              "operator": "and", 
              "boost": 2.0,
              "fuzziness": 1              
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

결과: 
[
    "맛있는 통밀빵 간식 만들기",
    "맛있는 최고의 통밀빵 레시피", 
    "통밀빵 정말 맛있는 카페", 
    "통밀빵 맛있게 먹는 방법", 
    "통밀 식빵 맛있게 먹는 방법"
]

1-1. match 쿼리

Nori 분석기를 사용하는 title.nori 필드에서 검색을 수행한다.

Nori 분석기의 nori_part_of_speech 필터를 사용해 "맛있는 통밀빵" 에서 '는'과 같은 조사를 제거하고 분석하기 위함이다.

fuzziness: 1
- fuzziness는 두 문자열 사이의 최소 편집 작업(삽입/제거/변경/인접한 두 문자 교체) 수를 의미한다.
  - 변경 (box → fox)
  - 제거 (black → lack)
  - 삽입 (sic → sick)
  - 인접한 두 문자 교체 (act → cat)
- fuzziness가 없을 때, 만약 검색어가 "멋있는 통밀빵"이라면 아무런 문서도 반환되지 않을 것이다.
  하지만 fuzziness: 1을 통해 한 글자의 오타를 허용하기 때문에, "멋있는 통밀빵" 이라고 검색해도 다음과 같은 결과를 반환한다.

[
	"통밀빵 정말 맛있는 카페",
    "맛있는 통밀빵 간식 만들기",
    "통밀빵 맛있게 먹는 방법",
    "맛있는 최고의 통밀빵 레시피",
    "통밀 식빵 맛있게 먹는 방법"
]

2. match 쿼리(N-gram 분석기 사용) 추가

GET /posts/_search
{
  "size": 10, 
  "query": {
    "bool": {
      "should": [
        {
          "match_phrase": {
            "title": {
              "query": "맛있는 통밀빵",
              "slop": 1, 
              "boost": 3.0
            }
          }
        },
        {
          "match": {
            "title.nori": {
              "query": "맛있는 통밀빵",
              "operator": "and", 
              "boost": 2.0,
              "fuzziness": 1
            }
          }
        },
        {
          "match": {
            "title.ngram": {
              "query": "맛있는 통밀빵"
            }
          }
        }
      ],
      "minimum_should_match": 1
    }
  }
}

결과: 
[
	"맛있는 통밀빵 간식 만들기", 
    "맛있는 최고의 통밀빵 레시피", 
    "통밀빵 정말 맛있는 카페", 
    "통밀빵 맛있게 먹는 방법",
    "통밀 식빵 맛있게 먹는 방법",
    "맛있는 비건 디저트 카페",
    "통밀빵 효능",
    "감성빵집 통밀빵",
    "통밀빵 샌드위치",
    "100% 통밀빵 토스트"
]

2-1. match 쿼리

N-gram 분석기가 적용된 title.ngram 필드에서 부분 문자열을 기반으로 유사한 문서를 찾는다.

이 쿼리문으로 인해 "맛있는 통밀빵"을 입력했을 때 "맛있는 비건 디저트 카페"나 "통밀빵 효능"과 같이 부분 문자열이 일치하는 경우도 결과에 포함된다.

때문에 관련이 적은 결과가 포함될 수 있어 앞선 2개의 조건 보다 낮은 우선 순위를 갖도록 했다. (디폴트 1.0)

3. 서비스, 레포지토리 코드

PostCustomElasticRepositoryImpl

@Repository
@RequiredArgsConstructor
public class PostCustomElasticRepositoryImpl implements PostCustomElasticRepository {
    private final ElasticsearchClient elasticsearchClient;
    private final String POST_INDEX = "posts";

    @Override
    public List<PostDocument> findAutoCompleteSuggestion(String keyword, int size) {
        try {
            SearchResponse<PostDocument> response = elasticsearchClient.search(s -> s
                    .index(POST_INDEX)
                    .size(size)
                    .query(q -> q
                            .bool(b -> b
                                    .should(sh -> sh
                                            .matchPhrase(mp -> mp
                                                    .field("title")
                                                    .query(keyword)
                                                    .slop(1)
                                                    .boost(3.0f)
                                            )
                                    )
                                    .should(sh -> sh
                                            .match(m -> m
                                                    .field("title.nori")
                                                    .query(keyword)
                                                    .operator(Operator.And)
                                                    .boost(2.0f)
                                                    .fuzziness("1")
                                            )
                                    )
                                    .should(sh -> sh
                                            .match(m -> m
                                                    .field("title.ngram")
                                                    .query(keyword)
                                            )
                                    ).minimumShouldMatch("1")
                            )
                    ), PostDocument.class
            );

            return response.hits().hits().stream().map(Hit::source).toList();
        } catch (IOException e) {
            throw new ElasticsearchOperationException(ErrorCode.ES_OPERATION_FAILED);
        }
    }
}

PostMan으로 요청해보았다.

http://localhost:8080/api/v1/posts/suggest?keyword=맛있는 통밀빵

1. match_phrase 쿼리만 사용된 결과

["맛있는 통밀빵 간식 만들기", "맛있는 최고의 통밀빵 레시피"]

2. match 쿼리(Nori 분석기 사용) 추가한 결과

["맛있는 통밀빵 간식 만들기", "맛있는 최고의 통밀빵 레시피",
"통밀빵 정말 맛있는 카페", "통밀빵 맛있게 먹는 방법", "통밀 식빵 맛있게 먹는 방법"]

3. match 쿼리(Ngram 분석기 사용) 추가한 결과

["맛있는 통밀빵 간식 만들기", "맛있는 최고의 통밀빵 레시피",
"통밀빵 정말 맛있는 카페", "통밀빵 맛있게 먹는 방법", "통밀 식빵 맛있게 먹는 방법",
"맛있는 비건 디저트 카페", "통밀빵 효능", "감성빵집 통밀빵", "통밀빵 샌드위치", "100% 통밀빵 토스트"]

문제점2 - 가독성

현재 findAutoCompleteSuggestion 메서드는 람다 표현식이 중첩되어 있어서 Spotless를 사용하여 코드 포맷팅을 하면 가독성이 매우 떨어진다.

    @Override
    public List<PostDocument> findAutoCompleteSuggestion(String keyword, int size) {
        try {
            SearchResponse<PostDocument> response =
                    elasticsearchClient.search(
                            s ->
                                    s.index(POST_INDEX)
                                            .size(size)
                                            .query(
                                                    q ->
                                                            q.bool(
                                                                    b ->
                                                                            b.should(
                                                                                            sh ->
                                                                                                    sh
                                                                                                            .matchPhrase(
                                                                                                                    mp ->
                                                                                                                            mp.field(
                                                                                                                                            "title")
                                                                                                                                    .query(
                                                                                                                                            keyword)
                                                                                                                                    .slop(
                                                                                                                                            1)
                                                                                                                                    .boost(
                                                                                                                                            3.0f)))
                                                                                    .should(
                                                                                            sh ->
                                                                                                    sh
                                                                                                            .match(
                                                                                                                    m ->
                                                                                                                            m.field(
                                                                                                                                            "title.nori")
                                                                                                                                    .query(
                                                                                                                                            keyword)
                                                                                                                                    .operator(
                                                                                                                                            Operator
                                                                                                                                                    .And)
                                                                                                                                    .boost(
                                                                                                                                            2.0f)
                                                                                                                                    .fuzziness(
                                                                                                                                            "1")))
                                                                                    .should(
                                                                                            sh ->
                                                                                                    sh
                                                                                                            .match(
                                                                                                                    m ->
                                                                                                                            m.field(
                                                                                                                                            "title.ngram")
                                                                                                                                    .query(
                                                                                                                                            keyword)))
                                                                                    .minimumShouldMatch(
                                                                                            "1"))),

            return response.hits().hits().stream().map(Hit::source).toList();
        } catch (IOException e) {
            throw new ElasticsearchOperationException(ErrorCode.ES_OPERATION_FAILED);
        }
    }

문제점2 해결

@Repository
@RequiredArgsConstructor
public class PostCustomElasticRepositoryImpl implements PostCustomElasticRepository {
    private final ElasticsearchClient elasticsearchClient;
    private final String POST_INDEX = "posts";

    @Override
    public List<PostDocument> findAutoCompleteSuggestion(String keyword, int size) {
        try {
            SearchResponse<PostDocument> response =
                    elasticsearchClient.search(
                            s -> autoCompleteSuggestionQuery(s, keyword, size), PostDocument.class);

            return response.hits().hits().stream().map(Hit::source).toList();
        } catch (IOException e) {
            throw new ElasticsearchOperationException(ErrorCode.ES_OPERATION_FAILED);
        }
    }

    private ObjectBuilder<SearchRequest> autoCompleteSuggestionQuery(
            SearchRequest.Builder builder, String keyword, int size) {
        Query matchPhraseQuery = MatchPhraseQuery.of(mp -> mp.field("title").query(keyword).slop(1).boost(3.0f))._toQuery();
        Query matchNoriQuery = MatchQuery.of(m -> m.field("title.nori").query(keyword).operator(Operator.And).boost(2.0f).fuzziness("1"))._toQuery();
        Query matchNgramQuery = MatchQuery.of(m -> m.field("title.ngram").query(keyword))._toQuery();
        Query boolQuery = BoolQuery.of(b -> b.should(matchPhraseQuery).should(matchNoriQuery).should(matchNgramQuery).minimumShouldMatch("1"))._toQuery();

        return builder.index(POST_INDEX).size(size).query(boolQuery);
    }
}

쿼리 작성 로직을 메서드로 분리하고, MatchPhraseQuery, MatchQuery, BoolQuery를 따로 작성했다.

이를 결합하여 최종 쿼리를 생성한다.

Spotless를 적용하면 다음과 같이 포맷팅된다. 이전과 비교했을 때 가독성이 더 좋아졌다.

    private ObjectBuilder<SearchRequest> autoCompleteSuggestionQuery(
            SearchRequest.Builder builder, String keyword, int size) {
        Query matchPhraseQuery =
                MatchPhraseQuery.of(mp -> mp.field("title").query(keyword).slop(1).boost(3.0f))
                        ._toQuery();
        Query matchNoriQuery =
                MatchQuery.of(
                                m ->
                                        m.field("title.nori")
                                                .query(keyword)
                                                .operator(Operator.And)
                                                .boost(2.0f)
                                                .fuzziness("1"))
                        ._toQuery();
        Query matchNgramQuery =
                MatchQuery.of(m -> m.field("title.ngram").query(keyword))._toQuery();
        Query boolQuery =
                BoolQuery.of(
                                b ->
                                        b.should(matchPhraseQuery)
                                                .should(matchNoriQuery)
                                                .should(matchNgramQuery)
                                                .minimumShouldMatch("1"))
                        ._toQuery();

        return builder.index(POST_INDEX).size(size).query(boolQuery);
    }

[TIL - 20240810~12] ElasticSearch 자동 완성 (1)

Chef.Yeon — Mon, 12 Aug 2024 23:54:46 +0900

https://yeon-dev.tistory.com/253

[Spring] Spring Boot3.x Docker Compose로 ElasticSearch 8.x+Kibana 구성 (Local)

프로젝트 루트 디렉토리에 docker-compose.yml을 생성한다. 1. Docker Compose 파일 작성docker-compose.ymlversion: '3.7'services: es: image: docker.elastic.co/elasticsearch/elasticsearch:8.7.1 container_name: es environment: - node.name=es-

yeon-dev.tistory.com

커뮤니티 검색 시, 자동 완성 기능을 ElasticSearch로 구현하고자 한다.

'통밀빵'이라는 검색어 입력 시, 다음과 같이 시작/중간/끝에 '통밀빵'이 포함된 자동 완성 목록이 떠야한다.

우선, ElasticSearch에 '통밀빵'이 접두사/중간/접미사에 사용되는 데이터를 2개씩 넣어주었다.

(bulk 연산 또는 PostMan 요청)

kibana dev tools에서 다음 명령어를 입력해 posts 인덱스의 모든 문서를 검색할 수 있다.

GET /posts/_search?q=*&pretty

1. N-gram 분석기

자동완성 기능은 사용자가 입력하는 대로 실시간으로 반응해야 한다. 때문에 단어의 일부분만을 가지고 결과를 제공하는 것이 중요하다고 판단하여, N-gram 분석기를 사용했다.

1-1. Nori 분석기 예시

Nori 분석기는 한글을 형태소 단위로 분석한다. 다음은 Nori 분석기로 "동해물과 백두산이 마르고 닳도록"을 분석한 결과다.

GET _analyze
{
  "tokenizer": {
    "type": "nori_tokenizer",
    "decompound_mode": "mixed"
  },
  "filter": ["lowercase", "stop", "trim", "nori_part_of_speech"],
  "text": ["동해물과 백두산이 마르고 닳도록"]
}

Nori 분석 결과: ["동해", "물", "백두산", "백두", "산", "마르", "닳"]

여기서 decompound_mode는 복합어를 분리하여 원본과 함께 저장하는 방식이다. mixed로 설정하여 "백두산"이라는 복합어를 "백두"+"산"으로 분해하면서도 "백두산"을 함께 인덱싱한다.

사용자가 '두산'이라는 단어를 입력했을 때 Nori 분석기는 다음과 같은 결과를 보여준다.

GET /posts/_search
{
  "query": {
    "match": {
      "title": "두산"
    }
  }
}

결과:
{
  "took": 1,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 0,
      "relation": "eq"
    },
    "max_score": null,
    "hits": []
  }
}

'백두산'이라는 단어에서 '두산' 이라는 일부분만 사용해서 검색했을 때, 원하는 결과를 얻을 수 없었다.

Nori 분석기는 '백두산'을 '백두'+'산'으로 분해하지만, '두산'을 별도로 인식하지 않는다.

1-2. N-gram 분석기 예시

반면에, N-gram 분석기는 텍스트를 일정한 길이의 부분 문자열로 나누어 인덱싱한다.

GET _analyze
{
  "tokenizer": {
    "type": "ngram",
    "min_gram": 2,
    "max_gram": 2,
    "token_chars": ["letter", "digit"]
  },
  "text": ["동해물과 백두산이 마르고 닳도록"]
}

2-gram 분석 결과: ["동해", "해물", "물과", "백두", "두산", "산이", "마르", "르고", "닳도", "도록"]

3-gram 분석 결과: ["동해물", "해물과", "백두산", "두산이", "마르고", "닳도록"]

N-gram 분석기를 사용하면, '백두산이'라는 문자열이 '백두', '두산', '산이'와 같은 부분 문자열로 나누어진다.

때문에 사용자가 '두산'이라는 단어를 검색하면, '백두산'이 포함된 문장을 결과로 얻을 수 있다.

GET /posts/_search
{
  "query": {
    "match": {
      "title.ngram": "두산"
    }
  }
}

결과:
{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1.5741749,
    "hits": [
      {
        "_index": "posts",
        "_id": "8",
        "_score": 1.5741749,
        "_source": {
          "id": 8,
          "title": "동해물과 백두산이 마르고 닳도록",
          "content": "내용8",
          "createdAt": "2024-08-12T21:04:31.777",
          "tags": [
            "#애국가"
          ]
        }
      }
    ]
  }
}

2. 인덱스 설정 및 매핑 구성

2-1. post-setting.json

{
  "analysis": {
    "tokenizer": {
      "my-nori-tokenizer": {
        "type": "nori_tokenizer",
        "decompound_mode": "mixed"
      },
      "my-ngram-tokenizer": {
        "type": "ngram",
        "min_gram": 2,
        "max_gram": 3,
        "token_chars": ["letter", "digit"]
      }
    },
    "analyzer": {
      "my-nori-analyzer": {
        "type": "custom",
        "tokenizer": "my-nori-tokenizer",
        "filter": [
          "lowercase",
          "stop",
          "trim",
          "nori_part_of_speech"
        ]
      },
      "my-ngram-analyzer": {
        "type": "custom",
        "tokenizer": "my-ngram-tokenizer",
        "filter": [
          "lowercase",
          "trim"
        ]
      }
    }
  }
}

2-2. post-mapping.json

{
  "properties": {
    "id": {
      "type": "long"
    },
    "title": {
      "type": "text",
      "fields": {
        "ngram": {
          "type": "text",
          "analyzer": "my-ngram-analyzer"
        },
        "nori": {
          "type": "text",
          "analyzer": "my-nori-analyzer"
        }
      }
    },
    "content": {
      "type": "text",
      "analyzer": "my-nori-analyzer"
    },
    "createdAt": {
      "type": "date",
      "format": "yyyy-MM-dd'T'HH:mm:ss.SSS||epoch_millis"
    },
    "imageUrl": {
      "type": "text"
    },
    "tags": {
      "type": "keyword"
    }
  }
}

이 설정에서는 title 필드에 n-gram과 nori 두 가지 분석기를 적용하여, 다양한 검색 시나리오에 대응할 수 있도록 멀티 필드를 정의했다.

3. 서비스 및 레포지토리 구현

3-1. 레포지토리 구현

PostCustomElasticRepository

public interface PostCustomElasticRepository {
    List<PostDocument> findByKeywordInField(String fieldName, String keyword);
}

PostCustomElasticRepositoryImpl

@Repository
@RequiredArgsConstructor
public class PostCustomElasticRepositoryImpl implements PostCustomElasticRepository {
    private final ElasticsearchOperations elasticsearchOperations;

    @Override
    public List<PostDocument> findByKeywordInField(String fieldName, String keyword) {

        Criteria criteria = new Criteria(fieldName).matches(keyword);
        CriteriaQuery query = new CriteriaQuery(criteria);

        return elasticsearchOperations
                .search(query, PostDocument.class)
                .map(SearchHit::getContent)
                .stream()
                .toList();
    }
}

PostElasticRepository

@Repository
public interface PostElasticRepository extends ElasticsearchRepository<PostDocument, Long>, PostCustomElasticRepository {
}

3-2. 서비스 구현

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostQueryService {
    private final PostElasticRepository postElasticRepository;
    
    public List<String> searchByKeyword(String keyword) {
        return postElasticRepository.findByKeywordInField("title.ngram", keyword)
                .stream().map(PostDocument::getTitle)
                .toList();
    }
}

4. API 요청

4-1. 통밀빵 검색 예시

http://localhost:8080/api/v1/posts/elastic?keyword=통밀빵

4-2. 오타가 포함된 검색 예시

http://localhost:8080/api/v1/posts/elastic?keyword=텅밀빵

오타가 포함되어도 부분 문자열이 일치하기 때문에 원하는 결과를 확인할 수 있다.

[Spring] Spring Boot3.x Docker Compose로 ElasticSearch 8.x+Kibana 구성 (Local)

Chef.Yeon — Sun, 11 Aug 2024 02:53:53 +0900

프로젝트 루트 디렉토리에 docker-compose.yml을 생성한다.

1. Docker Compose 파일 작성

docker-compose.yml

version: '3.7'

services:
  es:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.7.1
    container_name: es
    environment:
      - node.name=es-node
      - cluster.name=search-cluster
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
      - xpack.security.enabled=false
      - xpack.security.http.ssl.enabled=false
      - xpack.security.transport.ssl.enabled=false
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es-data:/usr/share/elasticsearch/data
    ports:
      - 9200:9200 # https
      - 9300:9300 #tcp
    networks:
      - es-bridge

  kibana:
    image: docker.elastic.co/kibana/kibana:8.7.1
    container_name: kibana
    environment:
      SERVER_NAME: kibana
      ELASTICSEARCH_HOSTS: http://es:9200
    ports:
      - 5601:5601
    depends_on:
      - es
    networks:
      - es-bridge

volumes:
  es-data:
    driver: local

networks:
  es-bridge:
    driver: bridge

version: Docker Compose 파일 버전 지정

services: Docker Compose에서 정의하는 개별 서비스

volumes: 컨테이너와 호스트 간 데이터 저장/공유를 위한 볼륨 정의

networks: 서비스들이 통신할 네트워크 정의

- ElasticSearch 서비스 (es)

discovery.type=single-node: Elasticsearch를 단일 노드 모드로 실행

bootstrap.memory_lock=true: 메모리 스왑 방지

ES_JAVA_OPTS=Xms1g -Xmx1g: JVM 최소 힙 메모리 크기와 최대 힙 메모리 크기를 1GB로 설정

로컬 개발 환경에서 실행하기 위해 다음과 같이 Xpack 보안 기능과 SSL 설정을 비활성화 했다.

xpack.security.enabled=false

xpack.security.http.ssl.enabled=false

xpack.security.transport.ssl.enabled=false

ulimits:memlock: 메모리 락 한도 설정 (-1은 무제한)

- Kinaba 서비스

ELASTICSEARCH_HOSTS: 연결한 Elasticsearch 호스트 지정

ElasticSearch 서비스를 es라고 정의해두었으므로 http://es:9200로 연결
만약 서비스 이름이 elasticsearch라면 http://elasticsearch:9200로 연결

depends on: Kibana 서비스가 es 서비스에 종속됨

es 서비스 시작된 후에 Kibana 시작

- 네트워크 정의

networks:es-bridge: 두 서비스 간의 통신을 위한 브리지 네트워크

터미널에서 docker-compose up 명령을 통해 실행하고, 정상적으로 실행되는지 확인해보자.

http://localhost:9200

http://localhost:5601

2. Nori 설치

Nori는 한글 형태소 분석기로 카카오에서 개발하여 Elasticsearch에서 공식 지원한다.

cmd를 열어 다음 명령어를 입력해주어 설치하자.

# es container 확인
$ docker ps 

# es컨테이너 접속
$ docker exec -it {containerId} /bin/bash

$ cd /usr/share/elasticsearch/bin/

$ ./elasticsearch-plugin install analysis-nori

docker compose down 후, 재실행한다.

3. ElasticSearch 설정 및 서비스 구현

build.gradle

implementation 'org.springframework.boot:spring-boot-starter-data-elasticsearch'

application.yml

spring:
  elasticsearch:
    host: localhost:9200

ElasticSearchConfig

@Configuration
@EnableElasticsearchRepositories
public class ElasticSearchConfig extends ElasticsearchConfiguration {
    @Value("${spring.elasticsearch.host}")
    private String host;

    @Override
    public ClientConfiguration clientConfiguration() {
        return ClientConfiguration.builder()
                .connectedTo(host)
                .build();
    }
}

@EnalbeElasticsearchRepositories: elastic 레포지토리 지원 활성화

Post

@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Post extends TimeStamped {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "post_id")
    private Long id;

    @Column(nullable = false)
    private String username;

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String content;

    @Builder
    public Post(String username, String title, String content) {
        this.username = username;
        this.title = title;
        this.content = content;
    }
}

PostDocument

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Document(indexName = "posts", writeTypeHint = WriteTypeHint.FALSE)
@Setting(settingPath = "elastic/post-setting.json")
@Mapping(mappingPath = "elastic/post-mapping.json")
public class PostDocument {
    @Id
    private Long id;
    private String username;
    private String title;
    private String content;

    @Builder
    public PostDocument(Long id, String username, String title, String content) {
        this.id = id;
        this.username = username;
        this.title = title;
        this.content = content;
    }

    public static PostDocument from(Post post) {
        return PostDocument.builder()
                .id(post.getId())
                .username(post.getUsername())
                .title(post.getTitle())
                .content(post.getContent())
                .build();
    }
}

@Document

Elasticsearch 인덱스를 지정하고, 해당 클래스가 Elasticsearch 도큐먼트로 매핑되도록 정의

indexName: Elasticsearch 인덱스 이름 지정 (필수)
writeTypeHint: 도큐먼트 타입 힌트작성 여부 (기본값: true)
- 기본적으로 Spring Data Elasticsearch는 도큐먼트에 '_class' 필드 생성한다.
createIndex: 인덱스 자동 생성 여부 (기본값: true)
- true로 설정된 경우, Spring Data Elasticsearch가 애플리케이션 시작시 @Document에 의해 생성된 인덱스가 있는지 확인하고 없으면 생성한다.
shards, replicas, refreshInterval, versionType

@Mapping

Elasticsearch 인덱스의 매핑을 정의하는 JSON 파일의 경로 지정

(런타임 필드로 인덱스 매핑을 정의하면, 클래스 경로에 해당 JSON 파일의 경로를 설정해야한다.)

post-mapping.json 파일은 resources/elastic 폴더 하위에 있다.

@Setting

Elasticsearch 인덱스의 설정을 정의하는 JSON 파일 경로 지정

post-setting.json 파일은 resources/elastic 폴더 하위에 있다.

post-setting.json

인덱스의 분석기, 토크나이저와 같은 설정을 포함할 수 있다.

{
  "analysis": {
    "analyzer": {
      "korean": {
        "type": "nori"
      }
    }
  }
}

post-mapping.json

필드의 데이터 타입(text, keyword 등), 분석기 설정, 필드 속성 등이 정의된다.

{
  "properties": {
    "id": {
      "type": "long"
    },
    "username": {
      "type": "text",
      "analyzer": "korean"
    },
    "title": {
      "type": "text",
      "analyzer": "korean"
    },
    "content": {
      "type": "text",
      "analyzer": "korean"
    }
  }
}

PostSearchController

@RestController
@RequestMapping("api/v1/posts")
@RequiredArgsConstructor
public class PostSearchController {
    private final PostSearchService postSearchService;

    @GetMapping("/search")
    ResponseEntity<List<PostDocument>> search(@RequestParam String keyword) {
        return ResponseEntity.ok(postSearchService.searchByKeyword(keyword));
    }
}

PostService

@Service
@RequiredArgsConstructor
public class PostService {
    private final PostElasticRepository postElasticRepository;

    public Post add(PostRequestDto request) {
        Post post = Post.builder()
                .username(request.getUsername())
                .title(request.getTitle())
                .content(request.getContent())
                .build();
        postRepository.save(post);
        postElasticRepository.save(PostDocument.from(post));
        return post;
    }
}

수정 기능은 postElasticRepository.save를 통해 PostDocument를 다시 저장해주면 해당 id이 document가 수정된다.

삭제 기능은 postElasticRepository.deleteById 또는 delete를 사용해 삭제할 수 있다.

PostSearchService

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class PostSearchService {
    private final PostElasticRepository postElasticRepository;

    public List<PostDocument> searchByKeyword(String keyword) {
        return postElasticRepository.findByTitle(keyword);
    }
}

PostElasticRepository

@Repository
public interface PostElasticRepository extends ElasticsearchRepository<PostDocument, Long> {
    List<PostDocument> findByTitle(String title);
}

ElasticsearchRepository는 Spring Data Elasticsearch에서 지원한다.

기본적인 CRUD가 지원되고, 메서드 이름을 기반으로 쿼리를 자동 생성할 수 있다. (Query mehtods)

findByTitle은 파라미터가 '제목'일 때 다음과 같은 elasticsearch query가 생성된다.

{
  "query": {
    "match": {
      "title": "제목"
    }
  }
}

4. API 테스트

Postman과 Kibana를 사용하여 Elasticsearch에 저장된 데이터를 확인하고, 데이터를 검색해보자.

우선애플리케이션을 실행하고, 데이터 확인을 위해 Analytics(Kibana이다) > Discover로 이동해 DataView를 만들어준다.

만약 date 필드가 있으면 Timestamp field를 설정해주자.

Postman을 사용해 요청을 보내보자.

DataView에서 Refresh 버튼을 클릭하면, 저장된 데이터를 확인할 수 있다.

PostMan으로 요청을 보내서 Elasticsearch 검색 기능 동작을 확인해보자.

[Spring] Spring Boot 프로젝트 이름 변경하기

Chef.Yeon — Thu, 8 Aug 2024 03:22:05 +0900

Spring Boot 프로젝트 이름을 변경해보자.

1. File > Project Structure > Name 변경

Name 부분을 변경할 프로젝트 이름으로 수정해준다.

2. settings.gradle

rootProject.name을 수정해준다.

3. 변경 사항 적용

변경 사항을 적용하기 위해 코끼리를 클릭한다.

만약 프로젝트가 있는 폴더도 이동한 경우 애플리케이션 실행 시 다음과 같은 문제가 생길 수 있다.

Two modules in a project cannot share the same content root.

프로젝트 폴더 안에 있는 .idea 폴더와 *.iml 파일을 삭제하고 IntelliJ를 다시 켜주면 된다.(자동 생성)

[TIL-20240805] ElasticSearch + Spring Boot 연동 오류 해결

Chef.Yeon — Mon, 5 Aug 2024 07:04:09 +0900

문제점1: CreatedAt 필드 타입

post-mappings.json

{
  "properties": {
    "id": {
      "type": "long"
    },
    "title": {
      "type": "text",
      "analyzer": "korean"
    },
    "content": {
      "type": "text",
      "analyzer": "korean"
    },
    "createdAt": {
      "type": "date",
      "format": "yyyy-MM-dd'T'HH:mm:ss.SSSSSS||epoch_millis"
    },
    "imageUrl": {
      "type": "text"
    },
    "tags": {
      "type": "keyword"
    }
  }
}

PostDocument

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Document(indexName = "posts")
@Setting(settingPath = "elastic/post-setting.json")
@Mapping(mappingPath = "elastic/post-mapping.json")
public class PostDocument {
    @Id
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdAt;
    private String imageUrl;
    private List<String> tags;

    @Builder
    public PostDocument(
            Long id,
            String title,
            String content,
            LocalDateTime createdAt,
            String imageUrl,
            List<String> tags) {
        this.id = id;
        this.title = title;
        this.content = content;
        this.createdAt = createdAt;
        this.imageUrl = imageUrl;
        this.tags = tags;
    }
}

PostElasticRepository

@Repository
public interface PostElasticRepository extends ElasticsearchRepository<PostDocument, Long> {
    List<PostDocument> findByTitleContaining(String title);
}

Elasticsearch를 사용한 데이터 검색이 정상 동작하는지 확인하기 위해 간단히 검색 api를 만들어 테스트했다.

'http://localhost:8080/api/v1/posts/elastic?keyword=오늘'로 요청을 보냈을 때, 다음과 같은 오류가 발생했다.

No converter found capable of converting from type [java.lang.Long] to type [java.time.LocalDateTime]

문제점1-해결

Kibana를 통해 생성된 posts 인덱스를 확인해보니, createdAt 필드 타입이 date 타입이 아닌 long 타입으로 생성되었다.

kibana > dev tools 를 통해 인덱스를 직접 생성해주었다.

PUT /posts
{
  "settings": {
    "analysis": {
      "analyzer": {
        "english": {
          "type": "whitespace"
        },
        "korean": {
          "type": "nori"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id": {
        "type": "long"
      },
      "title": {
        "type": "text",
        "analyzer": "korean"
      },
      "content": {
        "type": "text",
        "analyzer": "korean"
      },
      "createdAt": {
        "type": "date",
        "format": "yyyy-MM-dd'T'HH:mm:ss.SSS||epoch_millis"
      },
      "imageUrl": {
        "type": "text"
      },
      "tags": {
        "type": "keyword"
      }
    }
  }
}

문제점2: _class 필드 역직렬화

'http://localhost:8080/api/v1/posts/elastic?keyword=날씨' 로 요청을 보냈을 때, 다음과 같은 오류가 발생했다.

com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "_class" (class com....post.domain.document.PostDocument), not marked as ignorable (6 known properties: "imageUrl", "title", "content", "id", "tags", "createdAt"])

문제점2-해결

JSON 응답을 PostDocument로 역직렬화하는 과정에서 _class라는 인식되지 않은 필드가 존재하여 발생한 문제이다. Spring Data Elasticsearch는 기본적으로 엔터티 클래스의 _class 필드를 추가하여 인덱싱한다.

PostDocument

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Document(indexName = "posts", createIndex = false, writeTypeHint = WriteTypeHint.FALSE)
@Setting(settingPath = "elastic/post-setting.json")
@Mapping(mappingPath = "elastic/post-mapping.json")
public class PostDocument {
    @Id
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdAt;
    private String imageUrl;
    private List<String> tags;

    @Builder
    public PostDocument(
            Long id,
            String title,
            String content,
            LocalDateTime createdAt,
            String imageUrl,
            List<String> tags) {
        this.id = id;
        this.title = title;
        this.content = content;
        this.createdAt = createdAt;
        this.imageUrl = imageUrl;
        this.tags = tags;
    }
}

@Document 속성

indexName: ElasticSearch 인덱스 이름 지정
createIndex: 애플리케이션 시작 시 인덱스를 자동으로 생성할지 여부 지정
writeTypeHint: 도큐먼트에 타입 힌트를 쓸지 여부 지정
- 도큐먼트에 _class 필드를 추가하지 않도록 한다.

문제점3: LocalDateTime 필드 매핑

'http://localhost:8080/api/v1/posts/elastic?keyword=날씨' 로 요청을 보냈을 때, 다음과 같은 오류가 발생했다

Type LocalDateTime of property PostDocument.createdAt is a TemporalAccessor class but has neither a @Field annotation defining the date type nor a registered converter for reading! It cannot be mapped from a complex object in Elasticsearch!

문제점3-해결

LocalDateTime 필드를 Elasticsearch와 올바르게 매핑하기 위해 PostDocument의 createdAt 필드에 @Field 애노테이션을 추가했다.

    @Field(type = FieldType.Date, format = {}, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS||epoch_millis")
    private LocalDateTime createdAt;

기존 인덱스도 삭제하고 재생성해주었다.

DELETE /posts

post를 저장하고, 다음과 같이 kibana를 통해 확인할 수 있었다.

'http://localhost:8080/api/v1/posts/elastic?keyword=날씨' 로 요청을 보냈을 때 정상적으로 응답이 왔다.

Elasticsearch와 Spring Boot를 연동하여 데이터를 저장하고 검색하는 과정에서 다양한 문제가 발생했다.

요청 하나 보내기 정말 어렵다

[DevOps] 윈도우 ElasticSearch 8.x 다운로드 및 키바나 연동

Chef.Yeon — Sun, 28 Jul 2024 04:12:25 +0900

ElasticSearch 다운로드 및 실행

먼저, 다음 페이지에서 ElasticSearch와 Kibana를 다운 받아 압축을 풀어준다.

ElasticSearch 다운로드

Kibana 다운로드

ElasticSearch 압축을 풀고 bin 폴더 하위의 elasticsearch 배치 파일을 직접 또는 cmd 창을 열어서 실행한다.

C:\Users\...\elasticsearch-8.14.3>bin\elasticsearch

첫 실행 시 초기 비밀번호와 키바나 연결을 위한 토큰 값을 제공한다.

비밀번호 재설정

비밀번호 재설정은 필요한 경우에 수행하면 된다.

1) 새로운 비밀번호 랜덤 발급

cmd에서 다음을 입력하면 유저 elastic에 대한 새로운 비밀번호를 다시 발급받을 수 있다.

C:\Users\...\elasticsearch-8.14.3>bin\elasticsearch-reset-password -u elastic

Please confirm... [y/N] 에 y를 입력하면 된다.

2) 원하는 비밀번호 재설정

cmd에서 다음을 입력하면 유저 elastic에 대한 새로운 비밀번호를 직접 설정할 수 있다.

나는 이 방법을 사용해서 user와 password를 elastic으로 통일했다.

C:\Users\...\elasticsearch-8.14.3>bin\elasticsearch-reset-password -u elastic -i

실행 확인

ElasticSearch는 9200 포트를 사용한다. 또한, 7.x 버전과 달리 8.x 버전은 보안 기능이 있어 https를 사용해서 접속해야 한다.

https://localhost:9200 으로 접속해서 정상 실행되는지 확인해보자.

고급 버튼을 눌러 (안전하지 않음)으로 이동을 클릭한다.

user와 password를 입력해 로그인 하고, 현재 실행 중인 클러스터 정보를 볼 수 있다.

user는 기본적으로 elastic이다.

Kibana 연동

이제 Kibana와 연동해보자. bin 폴더 하위의 kibana 배치 파일을 실행한다.

Kibana는 5601 포트를 사용한다. http://localhost:5601 로 접속해자 (https 아님)

다음과 같은 창이 뜨면, elasticsearch를 실행할 때 받은 토큰 값을 입력해준다.

토큰 값을 입력한 후, Configure Elastic 버튼을 누르면 다음과 같이 인증 코드를 요구한다.

kibana-verification-code 배치 파일을 실행해서 코드를 얻을 수 있다.

C:\Users\...\kibana-8.14.3\bin>kibana-verification-code

Welcome to Elastic이라는 문구와 함께 username과 password를 요구하면, elasticsearch에서 사용한 user와 password를 사용하면 된다.

좌측 메뉴에서 Analytics 카테고리가 Kibana이다.

[TIL - 20240612] Swagger HTTPS 설정

Chef.Yeon — Wed, 12 Jun 2024 22:39:09 +0900

문제점

Spring REST Docs와 Swagger UI를 연동했다.

로컬에서 정상 동작하는 것을 확인하고 개발 서버로 배포해서 테스트했으나, 다음과 같은 오류가 발생했다.

개발 서버 도메인은 https를 사용한다.

하지만, Request URL을 보면 http를 사용하는 것을 볼 수 있다.

해결

Swagger가 기본적으로 http로 요청을 보내기 때문에 발생한 문제다.

SwaggerConfig에서 @OpenAPIDefinition 애노테이션의 servers 속성을 사용하여 API가 호스팅 되는 서버 목록을 정의해주었다.

SwaggerConfig

import io.swagger.v3.oas.annotations.OpenAPIDefinition;
import io.swagger.v3.oas.annotations.servers.Server;
// ...other import

@OpenAPIDefinition(
        servers = {
            @Server(url = "https://개발서버.com", description = "개발 서버"),
            @Server(url = "http://localhost:8080", description = "로컬 서버")
        })
@Configuration
public class SwaggerConfig {
    private final String AUTH_SCHEME_NAME = "JWT Access Token";
    private final String AUTH_SCHEME = "bearer";
    private final String BEARER_FORMAT = "JWT";

    @Bean
    public OpenAPI openAPI() {
        SecurityRequirement securityRequirement =
                new SecurityRequirement().addList(AUTH_SCHEME_NAME);
        Components components =
                new Components()
                        .addSecuritySchemes(
                                AUTH_SCHEME_NAME,
                                new SecurityScheme()
                                        .name(AUTH_SCHEME_NAME)
                                        .type(SecurityScheme.Type.HTTP)
                                        .description("bearer는 제외하고 입력해주세요.")
                                        .scheme(AUTH_SCHEME)
                                        .bearerFormat(BEARER_FORMAT));

        return new OpenAPI().components(components).addSecurityItem(securityRequirement);
    }
}

배포 후 다시 확인해 본 결과, https를 사용해서 정상적으로 API 호출이 된다.