Connect to the Lindorm search engine using the Java Low Level REST Client - Lindorm

Le client Java Low Level REST envoie des requêtes HTTP brutes sans encoder ni décoder le corps de la requête ou de la réponse, ce qui vous offre un contrôle direct sur la gestion des requêtes. Utilisez-le lorsque vous devez vous connecter à LindormSearch (compatible avec Elasticsearch 7.10 et versions antérieures) et souhaitez gérer vous-même la sérialisation.

Prérequis

Avant de commencer, assurez-vous d'avoir :

JDK 1.8 ou version ultérieure installé
LindormSearch activé pour votre instance Lindorm. Consultez le Guide d'activation
L'adresse IP de votre client ajoutée à la liste d'autorisation de l'instance Lindorm. Consultez la rubrique Configurer une liste d'autorisation

Installer le client

Ajoutez les dépendances suivantes à la section dependencies de votre fichier pom.xml ou de votre fichier de build.

Maven :

<dependency>
  <groupId>org.elasticsearch.client</groupId>
  <artifactId>elasticsearch-rest-client</artifactId>
  <version>7.10.0</version>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.8.2</version>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-api</artifactId>
  <version>2.7</version>
</dependency>

Gradle :

dependencies {
  implementation 'org.elasticsearch.client:elasticsearch-rest-client:7.10.0'
  implementation 'org.apache.logging.log4j:log4j-core:2.8.2'
  implementation 'org.apache.logging.log4j:log4j-api:2.7'
}

Configurer la connexion

Créez un objet RestClient avec l'endpoint LindormSearch et les identifiants :

String search_url = "ld-t4n5668xk31ui****-proxy-search-public.lindorm.rds.aliyuncs.com";
int search_port = 30070;

// For demo purposes only. Do not hardcode credentials in production code.
String username = "user";
String password = "test";

final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));

RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(search_url, search_port));
restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
  @Override
  public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
  }
});

Paramètres :

Paramètre	Description
`search_url`	L'endpoint LindormSearch pour Elasticsearch. Pour obtenir l'endpoint, consultez la rubrique Afficher les endpoints. Utilisez l'endpoint VPC (Virtual Private Cloud) pour les applications s'exécutant sur une instance ECS, ou l'endpoint Internet pour les applications locales se connectant via le réseau public.
`search_port`	Le port de l'endpoint LindormSearch. Valeur fixe : `30070`.
`username`	Le nom d'utilisateur du moteur de recherche. Pour obtenir les identifiants par défaut, accédez à la console Lindorm, cliquez sur Database Connections dans le volet de navigation de gauche, puis cliquez sur l'onglet Search Engine.
`password`	Le mot de passe du moteur de recherche. Situé au même endroit que `username`.

Important

Utilisez une connexion VPC pour les applications déployées sur une instance ECS ; elle offre une latence plus faible et une meilleure sécurité qu'une connexion via le réseau public. Pour vous connecter via le réseau public, activez d'abord l'endpoint public : dans la console Lindorm, cliquez sur Database Connections dans le volet de navigation de gauche, cliquez sur l'onglet Search Engine, puis cliquez sur Enable Public Endpoint dans le coin supérieur droit.

Créer un index

try (RestClient restClient = restClientBuilder.build()) {
  String indexName = "lindorm_index";

  Request indexRequest = new Request("PUT", "/" + indexName);
  indexRequest.setJsonEntity("{" +
    "  \"settings\":{" +
    "    \"index.number_of_shards\": 1" +
    "  }," +
    "  \"mappings\":{" +
    "    \"properties\":{" +
    "      \"name\":{" +
    "        \"type\":\"text\"" +
    "      }" +
    "    }" +
    "  }" +
    "}");
  Response response = restClient.performRequest(indexRequest);
  String responseBody = EntityUtils.toString(response.getEntity());
  System.out.println("responseBody = " + responseBody);
}

Une réponse réussie se présente comme suit :

{"acknowledged":true,"shards_acknowledged":true,"index":"lindorm_index"}

Écrire des documents en bloc

Utilisez l'API Bulk pour écrire plusieurs documents dans une seule requête. L'exemple suivant écrit 5 000 documents dans lindorm_index :

Random random = new Random();
Request bulkRequest = new Request("POST", "/_bulk");
StringBuilder bulkJsonBuilder = new StringBuilder();
for (int i = 0; i < 5000; i++) {
  // Replace field names and values with those from your application.
  bulkJsonBuilder.append("{\"index\":{\"_index\":\"").append(indexName).append("\",\"_id\":\"").append(i).append("\"}}").append("\n");
  String value = random.nextInt() + "";
  bulkJsonBuilder.append("{\"field1\":\"").append(value).append("\",\"field2\":\"").append(value).append("\"}").append("\n");
}
bulkRequest.setJsonEntity(bulkJsonBuilder.toString());
response = restClient.performRequest(bulkRequest);

Après l'écriture en bloc, envoyez une requête de rafraîchissement pour rendre les documents visibles lors des recherches :

response = restClient.performRequest(new Request("POST", "/" + indexName + "/_refresh"));
responseBody = EntityUtils.toString(response.getEntity());
System.out.println("responseBody = " + responseBody);

Une réponse de rafraîchissement réussie se présente comme suit :

{"_shards":{"total":1,"successful":1,"failed":0}}

Interroger des documents

Interroger tous les documents de l'index (renvoie jusqu'à 10 résultats par défaut) :

response = restClient.performRequest(new Request("GET", "/" + indexName + "/_search"));
responseBody = EntityUtils.toString(response.getEntity());
System.out.println("responseBody = " + responseBody);

Interroger un document par ID :

response = restClient.performRequest(new Request("GET", "/" + indexName + "/_doc/0"));
responseBody = EntityUtils.toString(response.getEntity());
System.out.println("responseBody = " + responseBody);

Une réponse d'interrogation par ID réussie se présente comme suit :

{"_index":"lindorm_index","_id":"0","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"field1":"2127821774","field2":"2127821774"}}

Supprimer un index

response = restClient.performRequest(new Request("DELETE", "/" + indexName));
responseBody = EntityUtils.toString(response.getEntity());
System.out.println("responseBody = " + responseBody);

Une réponse de suppression réussie se présente comme suit :

{"acknowledged":true}

Exemple complet

Voici le programme d'exemple complet combinant toutes les opérations ci-dessus :

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

import java.util.Random;

public class RestLClientTest {
  public static void main(String[] args) {
    String search_url = "ld-t4n5668xk31ui****-proxy-search-public.lindorm.rds.aliyuncs.com";
    int search_port = 30070;

    // For demo purposes only. Do not hardcode credentials in production code.
    String username = "user";
    String password = "test";

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
    RestClientBuilder restClientBuilder = RestClient.builder(new HttpHost(search_url, search_port));
    restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
      @Override
      public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
        return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
      }
    });

    try (RestClient restClient = restClientBuilder.build()) {
      String indexName = "lindorm_index";

      // Create a search index.
      Request indexRequest = new Request("PUT", "/" + indexName);
      indexRequest.setJsonEntity("{" +
        "  \"settings\":{" +
        "    \"index.number_of_shards\": 1" +
        "  }," +
        "  \"mappings\":{" +
        "    \"properties\":{" +
        "      \"name\":{" +
        "        \"type\":\"text\"" +
        "      }" +
        "    }" +
        "  }" +
        "}");
      Response response = restClient.performRequest(indexRequest);
      String responseBody = EntityUtils.toString(response.getEntity());
      System.out.println("responseBody = " + responseBody);

      // Write 5,000 documents in a batch.
      Random random = new Random();
      Request bulkRequest = new Request("POST", "/_bulk");
      StringBuilder bulkJsonBuilder = new StringBuilder();
      for (int i = 0; i < 5000; i++) {
        // Replace field names and values with those from your application.
        bulkJsonBuilder.append("{\"index\":{\"_index\":\"").append(indexName).append("\",\"_id\":\"").append(i).append("\"}}").append("\n");
        String value = random.nextInt() + "";
        bulkJsonBuilder.append("{\"field1\":\"").append(value).append("\",\"field2\":\"").append(value).append("\"}").append("\n");
      }
      bulkRequest.setJsonEntity(bulkJsonBuilder.toString());
      response = restClient.performRequest(bulkRequest);

      // Refresh the index to make the written documents visible.
      response = restClient.performRequest(new Request("POST", "/" + indexName + "/_refresh"));
      responseBody = EntityUtils.toString(response.getEntity());
      System.out.println("responseBody = " + responseBody);

      // Query all documents in the index (returns up to 10 by default).
      response = restClient.performRequest(new Request("GET", "/" + indexName + "/_search"));
      responseBody = EntityUtils.toString(response.getEntity());
      System.out.println("responseBody = " + responseBody);

      // Query the document with ID 0.
      response = restClient.performRequest(new Request("GET", "/" + indexName + "/_doc/0"));
      responseBody = EntityUtils.toString(response.getEntity());
      System.out.println("responseBody = " + responseBody);

      // Delete the index.
      response = restClient.performRequest(new Request("DELETE", "/" + indexName));
      responseBody = EntityUtils.toString(response.getEntity());
      System.out.println("responseBody = " + responseBody);

    } catch (Exception e) {
      System.out.println("msg: " + e.getMessage());
    }
  }
}