Introdução ao ElasticSearch (tutorial para babá)

Este capítulo apresentará: a função do ElasticSearch, criará o ambiente elasticsearch (Windows/Linux), criará o cluster ElasticSearch, instalará e usará o plug-in do cliente visual elasticsearch-head, instalará e usará o tokenizador IK; a operação ElasticSearch apresentada em este capítulo é baseado no formulário Restful (usando o formulário de solicitação http), consulte a próxima parte para a operação do código java

@

1. Introdução à Pesquisa Elástica

Elaticsearch, conhecido como es para abreviar, es é um mecanismo de pesquisa de texto completo distribuído altamente escalável de código aberto, que pode armazenar e recuperar dados quase em tempo real;
tem dados de nível . es também é desenvolvido em Java e usa o Lucene como núcleo para implementar
todas as funções de indexação e pesquisa, mas seu objetivo é ocultar a complexidade do Lucene por meio de uma API RESTful simples, facilitando a pesquisa de texto completo
.

1.1 Casos de uso do ElasticSearch

• No início de 2013, o GitHub abandonou o Solr e adotou o ElasticSearch para pesquisa em nível de PB. "O GitHub usa o ElasticSearch para pesquisar 20 TB
  de dados, incluindo 1,3 bilhão de arquivos e 130 bilhões de linhas de código"
• Wikipedia: Inicie a arquitetura de pesquisa principal baseada em elasticsearch
• SoundCloud: "O SoundCloud usa o ElasticSearch para fornecer serviços de pesquisa de música instantâneos e precisos para 180 milhões de usuários"
• Baidu: Atualmente, o Baidu usa amplamente o ElasticSearch para análise de dados de texto, coleta vários dados de índice e dados definidos pelo usuário em todos os servidores Baidu e realiza análises multidimensionais e exibição de vários dados para auxiliar na localização e análise de exceções de instância ou exceções de nível de negócios . Atualmente cobrindo mais de 20 linhas de negócios no Baidu (incluindo casio, análise de nuvem, aliança de rede, previsão, biblioteca, número direto, carteira, controle de risco etc.), um único cluster tem no máximo 100 máquinas, 200 nós ES e importa mais de 30 TB de dados todos os dias
• Sina usa ES para analisar e processar 3,2 bilhões de logs em tempo real
• Ali usa ES para construir o próprio sistema de coleta e análise de logs da Wacai

1.2 Comparação entre ElasticSearch e solr

• O Solr usa o Zookeeper para gerenciamento distribuído, enquanto o próprio Elasticsearch possui uma função de gerenciamento de coordenação distribuída;
• O Solr oferece suporte a dados em mais formatos, enquanto o Elasticsearch oferece suporte apenas ao formato de arquivo json;
• O Solr fornece oficialmente mais funções, enquanto o próprio Elasticsearch se concentra mais nas funções principais, e as funções mais avançadas são fornecidas por plug-ins de terceiros;
• O Solr tem desempenho melhor que o Elasticsearch em aplicativos de pesquisa tradicionais, mas é significativamente menos eficiente que o Elasticsearch em aplicativos de pesquisa em tempo real

2. Instalação do ElasticSearch (janelas)

Baixe o pacote compactado:

ElasticSearch:  Elasticsearch: O mecanismo distribuído oficial de pesquisa e análise | Elástico

2.1 instalação

Nota: es é desenvolvido usando java, usando lucene como núcleo, e o ambiente java precisa ser configurado! (jdk1.8 e superior)

Semelhante ao tomcat, basta descompactá-lo diretamente. Sua estrutura de diretórios é a seguinte:

2.2 Modifique o arquivo de configuração

• Modifique o arquivo conf\jvm.option

将#-Xms2g                                  
  #-Xmx2g修改成为：
-Xms340m
-Xmx340m
否则因为虚拟机内存不够无法启动

• Modifique o arquivo conf\elasticsearch.yml

elasticsearch-5.6.8\config\elasticsearch.yml中末尾加入：
http.cors.enabled: true
http.cors.allow-origin: "*"
network.host: 127.0.0.1
目的是使ES支持跨域请求

2.3 início

Clique em elasticsearch.bat no diretório bin em ElasticSearch para iniciar, e as informações de log exibidas no console são as seguintes:

Observação: 9300 é a porta de comunicação tcp, os clusters es usam tcp para comunicação e 9200 é a porta do protocolo http.

Podemos acessar no navegador:

2.4 Instale o plug-in gráfico

Pelo exposto, pode-se descobrir que o ElasticSearch é diferente da própria interface gráfica do Solr. Podemos completar o efeito da interface gráfica e visualizar os dados do índice instalando o plug-in principal do ElasticSearch. Existem duas maneiras de instalar plug-ins, instalação online e instalação local. Este documento usa o método de instalação local para instalar o plug-in de cabeçote. As versões Elasticsearch-5-* e superiores precisam instalar o node e o grunt para instalar o head.

• Baixe o plugin head: https://github.com/mobz/elasticsearch-head

Após baixar o pacote compactado, descompacte-o.

• Baixar node.js: Baixar | Node.js

Clique duas vezes para instalar e digite node -v a cmd para visualizar o número da versão

• Instale grunt como um comando global, Grunt é uma ferramenta de construção de projetos baseada em Node.js

Digite no cmd:

npm install ‐g grunt‐cli

Como você está acessando um servidor estrangeiro, se a velocidade de download for lenta, você pode alternar para o espelho Taobao

npm install -g cnpm –registry=https://registry.npm.taobao.org

Para uso posterior, basta substituir npm xxx por cnpm xxx

Verifique se a instalação foi bem-sucedida

npm config get registry 

Observação: o uso subsequente precisa ser npmsubstituído por cnpm.

• comece a cabeça

Entre no diretório principal do plugin, abra o cmd e digite:

>npm install
>grunt server

Abra o navegador e digite http://localhost:9100

3. Conceitos relacionados a ES

3.1 Visão geral (importante)

O Elasticsearch é orientado a documentos, o que significa que pode armazenar objetos ou documentos inteiros. No entanto, ele não
apenas armazena, mas também indexa (indexa) o conteúdo de cada documento para que possa ser pesquisado. No Elasticsearch, você pode indexar, pesquisar, classificar e filtrar documentos (em vez de linhas e colunas de dados). Comparado com bancos de dados relacionais tradicionais, o Elasticsearch é o seguinte:

Banco de dados relacional ‐> Bancos de dados ‐> Tabelas ‐> Linhas ‐> Colunas
Elasticsearch ‐> Índices ‐> Tipos ‐> Documentos ‐> Campos

3.2 Conceitos Fundamentais

1) índice índice -

Um índice é uma coleção de documentos com características um tanto semelhantes. Por exemplo, você pode ter um índice para dados de clientes, outro índice para catálogos de produtos e outro índice para dados de pedidos. Um índice é identificado por um nome (deve ser todo em letras minúsculas), e quando quisermos indexar, pesquisar, atualizar e deletar documentos correspondentes a esse índice, usaremos esse nome. Em um cluster, qualquer número de índices pode ser definido. Pode ser comparado ao banco de dados no mysql

2) tipo tipo

Em um índice, você pode definir um ou mais tipos. Um tipo é uma classificação/partição lógica do seu índice, cuja semântica depende inteiramente de você. Normalmente, um tipo é definido para documentos com um conjunto comum de campos. Por exemplo, digamos que você execute uma plataforma de blog e armazene todos os seus dados em um índice. Nesse índice, você pode definir um tipo de dados de usuário, outro tipo de dados de blog e, claro, outro tipo de dados de comentários. Pode ser comparado a tabelas no mysql

3) Campo arquivado

Equivale ao campo da tabela de dados, que classifica e identifica os dados do documento segundo diferentes atributos.

4) Mapeamento de mapeamento

O mapeamento consiste em fazer algumas restrições na forma de processamento de dados e regras, como o tipo de dados de um determinado campo, valor padrão, analisador, se está indexado etc. Essas são todas as configurações que podem ser definidas no mapeamento e outros são para processamento de dados em es O uso de configurações de regras também é chamado de mapeamento. O processamento de dados de acordo com as regras ideais pode melhorar muito o desempenho, por isso é necessário estabelecer o mapeamento e é necessário pensar em como estabelecer o mapeamento para melhorar o desempenho . Equivale ao processo de criação de uma tabela no mysql, configuração da chave primária e chave estrangeira, etc.

5) documento documento

Um documento é uma unidade básica de informação que pode ser indexada. Por exemplo, você pode ter um documento para um determinado cliente, um documento para um determinado produto e, claro, um documento para um determinado pedido. Os documentos são expressos no formato JSON (Javascript Object Notation), e JSON é um formato onipresente de interação de dados da Internet. Em um índice/tipo, você pode armazenar quantos documentos quiser. Observe que, embora um documento exista fisicamente em um índice, o documento deve ser indexado/atribuído a um tipo de índice. Insira a biblioteca de índices em unidades de documentos, análoga a uma linha de dados no banco de dados

6) cluster cluster

Um cluster é organizado por um ou mais nós, que juntos armazenam todos os dados e fornecem funções de indexação e pesquisa. Um cluster é identificado por um nome exclusivo, que por padrão é "elasticsearch". Esse nome é importante porque um nó só pode ingressar em um cluster especificando seu nome.

7) nó nó

Um nó é um servidor no cluster que, como parte do cluster, armazena dados e participa das funções de indexação e pesquisa do cluster. Semelhante aos clusters, um nó também é identificado por um nome. Por padrão, esse nome é o nome de um personagem aleatório da Marvel Comics atribuído ao nó na inicialização. Esse nome é muito importante para o trabalho de gerenciamento, pois nesse processo de gerenciamento você determinará quais servidores da rede correspondem a quais nós no cluster Elasticsearch.

Um nó pode ingressar em um cluster especificado configurando o nome do cluster. Por padrão, cada nó é programado para ingressar em um cluster chamado "elasticsearch", o que significa que, se você iniciar vários nós em sua rede e assumir que eles podem se descobrir, eles formarão e ingressarão automaticamente em um cluster chamado "elasticsearch".

Em um cluster, você pode ter quantos nós quiser. Além disso, se você não tiver atualmente nenhum nó Elasticsearch em execução em sua rede, iniciar um nó neste momento criará e ingressará em um cluster chamado "elasticsearch" por padrão.

8) fragmentos e réplicas de fragmentação e replicação

Um índice pode armazenar grandes quantidades de dados além das limitações de hardware de um único nó. Por exemplo, um índice com 1 bilhão de documentos ocupa 1 TB de espaço em disco e nenhum nó possui um espaço em disco tão grande; ou um único nó processa solicitações de pesquisa e a resposta é muito lenta. Para resolver esse problema, o Elasticsearch fornece a capacidade de dividir o índice em várias partes, essas partes são chamadas de shards. Ao criar um índice, você pode especificar o número de estilhaços que deseja. Cada fragmento é um "índice" totalmente funcional e independente que pode ser colocado em qualquer nó do cluster. A fragmentação é importante por dois motivos principais: 1) Permite que você divida/dimensione horizontalmente sua capacidade de conteúdo. 2) Permite executar operações paralelas distribuídas em estilhaços (potencialmente, em vários nós), melhorando o desempenho/taxa de transferência.

Quanto a como um shard é distribuído e como seus documentos são agregados de volta às solicitações de pesquisa, ele é totalmente gerenciado pelo Elasticsearch, que é transparente para você como usuário.

Em um ambiente de rede/nuvem onde falhas podem acontecer a qualquer momento, onde um fragmento/nó de alguma forma fica offline ou desaparece por qualquer motivo, é muito útil ter um mecanismo de failover e é altamente recomendado. Para isso, o Elasticsearch permite criar uma ou mais cópias de um shard, essas cópias são chamadas de shards replicados, ou simplesmente réplicas.

A replicação é importante por dois motivos principais: Fornece alta disponibilidade em caso de falha de estilhaço/nó. Por esse motivo, é muito importante observar que os fragmentos replicados nunca são colocados no mesmo nó que o fragmento original/primário. Dimensione seu volume/taxa de transferência de pesquisa, pois as pesquisas podem ser executadas em todas as réplicas em paralelo. Resumindo, cada índice pode ser dividido em vários shards. Um índice também pode ser replicado 0 vezes (ou seja, sem replicação) ou várias vezes. Uma vez replicado, cada índice tem um estilhaço primário (o estilhaço original do qual foi copiado) e um estilhaço replicado (uma cópia do estilhaço primário). O número de estilhaços e réplicas pode ser especificado no momento da criação do índice. Você pode alterar dinamicamente o número de réplicas a qualquer momento após a criação do índice, mas não pode alterar o número de estilhaços posteriormente.

Por padrão, cada índice no Elasticsearch é sharded com 5 shards primários e 1 réplica, ou seja, se você tiver pelo menos dois nós em seu cluster, seu índice terá 5 shards primários e outros 5 shards replicados (1 cópia completa), para um total de 10 estilhaços por índice.

4. Operação do cliente ElasticSearch

A parte acima é uma parte teórica. No desenvolvimento real, existem basicamente três maneiras de servir como cliente do serviço es:

• Use o plug-in elasticsearch-head
• Use a interface Restful fornecida pelo elasticsearch para acessar diretamente
• Use a API fornecida pelo elasticsearch para acessar

4.1 Acesso direto usando a interface Restful

Precisamos usar solicitações http e introduzir duas ferramentas de teste de interface: carteiro e testador de API Talend.

• Instalação do testador de API do Talend:

Este é um plug-in do Chrome, sem necessidade de download;

• Instalação do carteiro:

Site oficial do carteiro: https://www.getpostman.com

4.2 Use o testador Talend API para executar operações do cliente es.

1) Sintaxe da interface do Elasticsearch

curl ‐X<VERB> '<PROTOCOL>://<HOST>:<PORT>/<PATH>?<QUERY_STRING>' ‐d '<BODY>'

em:

2) Crie um índice de biblioteca de índices e adicione mapeamento------PUT

PUT 

Corpo da solicitação:

artigo: tipo tipo; é equivalente à definição de campos nesta tabela nesta biblioteca de índice chamada artigo definido abaixo,

Os campos não são indexados por padrão;

analisador: o tokenizer usa o tokenizer padrão

{
    "mappings": {
        "article": {
            "properties": {
                "id": {
                    "type": "long",
                    "store": true,
                    "index": "not_analyzed"
                },
                "title": {
                    "type": "text",
                    "store": true,
                    "index": "analyzed",
                    "analyzer": "standard"
                },
                "content": {
                    "type": "text",
                    "store": true,
                    "index": "analyzed",
                    "analyzer": "standard"
                }
            }
        }
    }
}

Veja na ferramenta de visualização elasticsearch-head:

3) Primeiro crie o índice index, depois adicione o mapeamento ----PUT

Podemos definir as informações de mapeamento ao criar o índice, é claro, também podemos criar o índice primeiro e depois definir o mapeamento.
Na etapa anterior, sem definir as informações de mapeamento, use diretamente o método put para criar um índice e, em seguida, defina as informações de mapeamento.
URL solicitado:

PUT   http://127.0.0.1:9200/hello2/article/_mapping

Corpo da solicitação:

{
     "article": {
            "properties": {
                "id": {
                    "type": "long",
                    "store": true,
                    "index": "not_analyzed"
                },
                "title": {
                    "type": "text",
                    "store": true,
                    "index": "analyzed",
                    "analyzer": "standard"
                },
                "content": {
                    "type": "text",
                    "store": true,
                    "index": "analyzed",
                    "analyzer": "standard"
                }
            }
        }
}

4) Excluir índice de índice ----DELETE

Solicitar URL:

DELETE  http://127.0.0.1:9200/hello2

5) Crie um documento de documento (adicione conteúdo à biblioteca de índice) --- POST

Solicitar URL:

POST  http://127.0.0.1:9200/hello/article/1

Corpo da solicitação:

{
    "id": 1,
    "title": "ElasticSearch是一个基于Lucene的搜索服务器",
    "content": "它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
}

Ver no elasticsearch-head:

Observe que geralmente atribuímos o mesmo valor a _id e id.

6) Modifique o conteúdo do documento ---- POST

Solicitar URL:

POST http://127.0.0.1:9200/hello/article/1

Ver no elasticsearch-head:

7) Excluir documento documento --- EXCLUIR

Solicitar URL:

DELETE http://127.0.0.1:9200/hello/article/2

8) Documento de consulta documento-----GET

Existem três maneiras de consultar documentos:

• Consulta por id;
• Consulta por palavra-chave
• De acordo com o conteúdo de entrada, segmentação de palavras primeiro e depois consulta

i. Consulta por id

Solicitar URL:

GET http://127.0.0.1:9200/hello/article/1

ii. Consulta baseada em palavras-chave - consulta de termo

Solicitar URL:

POST http://127.0.0.1:9200/hello/article/_search

Corpo da solicitação:

{
    "query": {
        "term": {
            "title": "搜"
        }
    }
}

iii. Documento de consulta - consulta querystring

Solicitar URL:

POST   http://127.0.0.1:9200/hello/article/_search

Corpo da solicitação:

{
    "query": {
        "query_string": {
            "default_field": "title",
            "query": "搜索服务器"
        }
    }
}

Especifique:
qual campo consultar,
qual o conteúdo a ser consultado;

Ele segmentará o conteúdo da consulta primeiro e, em seguida, consultará

4.3 Use elasticsearch-head para operação do cliente es

A ferramenta de solicitação http está integrada no elasticsearch-head, que pode fornecer consulta de revisão:

5. Uso integrado de IK tokenizer e Elasticsearch

O tokenizer acima usa um tokenizer padrão, que não é muito amigável para a segmentação de palavras chinesas. Por exemplo, se eu for um programador, obtenho:

GET http://127.0.0.1:9200/_analyze?analyzer=standard&pretty=true&text=我是程序员

"tokens":[
{
    
    "token": "我", "start_offset": 0, "end_offset": 1, "type": "<IDEOGRAPHIC>",…},
{
    
    "token": "是", "start_offset": 1, "end_offset": 2, "type": "<IDEOGRAPHIC>",…},
{
    
    "token": "程", "start_offset": 2, "end_offset": 3, "type": "<IDEOGRAPHIC>",…},
{
    
    "token": "序", "start_offset": 3, "end_offset": 4, "type": "<IDEOGRAPHIC>",…},
{
    
    "token": "员", "start_offset": 4, "end_offset": 5, "type": "<IDEOGRAPHIC>",…}
]

O particípio que esperamos alcançar é: eu, é, programa, programador.

Existem muitos separadores de palavras que suportam chinês, separador de palavras, Paoding Jieniu, separador de palavras Ansj, observe a seguir o uso do separador de palavras IK.

5.1 Instalação do tokenizador IK

1) Endereço de download: https://github.com/medcl/elasticsearch-analysis-ik/releases

2) Descompacte, copie a pasta elasticsearch descompactada para elasticsearch-5.6.8\plugins e renomeie a pasta para analysis-ik (outros nomes também estão disponíveis, o objetivo não é renomear)

3) Reinicie o ElasticSearch para carregar o tokenizer IK

5.2 Teste do tokenizador IK

IK fornece segmentação de duas palavras ik_smart e ik_max_word

Entre eles, ik_smart é a menor segmentação e ik_max_word é a divisão mais refinada.

Vamos testá-lo:

• Segmentação mínima: insira o endereço no navegador:

GET   http://127.0.0.1:9200/_analyze?analyzer=ik_smart&pretty=true&text=我是程序员

resultado de retorno:

"tokens":[
{
    
    "token": "我", "start_offset": 0, "end_offset": 1, "type": "CN_CHAR",…},
{
    
    "token": "是", "start_offset": 1, "end_offset": 2, "type": "CN_CHAR",…},
{
    
    "token": "程序员", "start_offset": 2, "end_offset": 5, "type": "CN_WORD",…}
]

• A última segmentação: insira o endereço no navegador:

GET   http://127.0.0.1:9200/_analyze?analyzer=ik_max_word&pretty=true&text=我是程序员

resultado de retorno:

"tokens":[
{
    
    "token": "我", "start_offset": 0, "end_offset": 1, "type": "CN_CHAR",…},
{
    
    "token": "是", "start_offset": 1, "end_offset": 2, "type": "CN_CHAR",…},
{
    
    "token": "程序员", "start_offset": 2, "end_offset": 5, "type": "CN_WORD",…},
{
    
    "token": "程序", "start_offset": 2, "end_offset": 4, "type": "CN_WORD",…},
{
    
    "token": "员", "start_offset": 4, "end_offset": 5, "type": "CN_CHAR",…}
]

6. Grupo ElasticSearch

O cluster ES é um sistema distribuído do tipo P2P (usando o protocolo gossip). Exceto pelo gerenciamento de estado do cluster, todas as outras solicitações podem ser enviadas para qualquer nó do cluster. Este nó pode descobrir para quais nós precisam ser encaminhados e se comunicar diretamente com esses nós. Portanto, do ponto de vista da arquitetura de rede e configuração de serviço, a configuração necessária para construir um cluster é extremamente simples. Antes do Elasticsearch 2.0, em uma rede desimpedida, todos os nós configurados com o mesmo cluster.name pertenciam automaticamente a um cluster. Após a versão 2.0, com base em considerações de segurança, para evitar problemas causados ​​pelo ambiente de desenvolvimento muito casual, a partir da versão 2.0, o método de descoberta automática padrão é alterado para o método unicast (unicast). Os endereços de vários nós são fornecidos na configuração e o ES os considera como roteadores de fofoca para concluir a descoberta do cluster. Como esta é apenas uma pequena função no ES, o papel do roteador gossip não precisa ser configurado separadamente, e cada nó ES pode assumi-lo. Portanto, em um cluster usando o modo unicast, cada nó pode ser configurado com a mesma lista de vários nós como um roteador.

Não há limite para o número de nós em um cluster, geralmente dois ou mais nós podem ser considerados como um cluster. Geralmente em termos de alto desempenho e alta disponibilidade

Considere que o número de nós em um cluster geral é 3 ou mais.

6.1 Construção do cluster (janelas)

1) Prepare três servidores elasticsearch:

2) Modifique a configuração de cada servidor

Modifique o arquivo de configuração \comf\elasticsearch.yml:

#Node节点1：

http.cors.enabled: true
http.cors.allow-origin: "*"
#节点1的配置信息：
#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-1
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9201
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9301
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

#Node节点2：

http.cors.enabled: true
http.cors.allow-origin: "*"
#节点1的配置信息：
#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-2
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9202
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9302
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

#Node节点3：

http.cors.enabled: true
http.cors.allow-origin: "*"
#节点1的配置信息：
#集群名称，保证唯一
cluster.name: my-elasticsearch
#节点名称，必须不一样
node.name: node-3
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9203
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9303
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

3. Inicie cada servidor de nó

Você pode iniciar o elasticsearch.bat em cada servidor separadamente. Aqui eu uso o arquivo em lote no windows:

Crie um novo arquivo elasticsearch_cluster_start.bat e adicione o seguinte conteúdo:

O formato é: start "o nome do arquivo a ser iniciado" "o caminho do arquivo" e significa continuar a execução após iniciar A.

start "elasticsearch.bat" "F:\Soft\ES-cluster\cluster01\bin\elasticsearch.bat" &
start "elasticsearch.bat" "F:\Soft\ES-cluster\cluster02\bin\elasticsearch.bat" &
start "elasticsearch.bat" "F:\Soft\ES-cluster\cluster03\bin\elasticsearch.bat" 

O processamento em lote no Windows não será detalhado neste capítulo.

4. Teste de agrupamento

Enquanto algum nó do cluster estiver conectado, seu modo de operação é basicamente o mesmo da versão stand-alone, sendo alterada apenas a estrutura de armazenamento.

Adicionar índices e mapas

PUT  http://127.0.0.1:9201/hello

Corpo da solicitação:

{
    "mappings": {
    "article": {
        "properties": {
            "id": {
                "type": "long",
                "store": true,
                 "index": "not_analyzed"
            },
            "title": {
                "type": "text",
                "store": true,
                "index": true,
                "analyzer": "ik_smart"
            },
            "content": {
                "type": "text",
                "store": true,
                "index": true,
                "analyzer": "ik_smart"
            }
        }
    }
    }
}

resultado de retorno:

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

adicionar documento

POST   http://127.0.0.1:9201/hello/article/1

Corpo da solicitação:

{
"id":1,
"title":"ElasticSearch是一个基于Lucene的搜索服务器",
"content":"它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
}

valor de retorno:

{
"_index": "hello",
"_type": "article",
"_id": "1",
"_version": 1,
"result": "created",
"_shards":{
"total": 2,
"successful": 2,
"failed": 0
},
"created": true
}

Ver no elasticsearch-head:

7. Instalação do ElasticSearch (Linux)

1) Certifique-se de ter instalado o ambiente java

Você pode copiar o passado diretamente no windows, sem necessidade de instalar, apenas descompactar.

tar -zxf elasticsearch-6.3.2.tar.gz

2) Modifique o arquivo de configuração

• Modifique o arquivo conf\jvm.option

将#-Xms2g                                  
  #-Xmx2g修改成为：
-Xms340m
-Xmx340m
否则因为虚拟机内存不够无法启动

• Modifique o arquivo conf\elasticsearch.yml

#elasticsearch-5.6.8\config\elasticsearch.yml中末尾加入：
http.cors.enabled: true
http.cors.allow-origin: "*"
network.host: 127.0.0.1
目的是使ES支持跨域请求

3) começar

Nota: No ambiente linux, usuários root não são suportados para iniciar diretamente (o motivo são questões de segurança)

• Adicionar usuário:

[root@coderxz bin]# useradd rxz -p rongxianzhao
[root@coderxz bin]# chown -R rxz:rxz /usr/local/elasticsearch/*
[root@coderxz bin]# su rxz

• implemento:

#注意：切换为非root用户执行哦
[rxz@coderxz bin]$ ./elasticsearch

• Verifique o status de execução:

检测是否运行：jps （显示所有的Java进程pid的命令）
	              ps aux|grep elasticsearch
				  [root@coderxz ~]# curl -X GET 'http://localhost:9200'

4) Para configurar o acesso à rede externa para a porta 9200, a porta do servidor precisa ser aberta

Modifique o arquivo de configuração config/elasticsearch.yml

rede.host: 0.0.0.0

5) Início em segundo plano

Se você instalou o Elasticsearch em um servidor e deseja desenvolver em sua máquina local, provavelmente precisará manter o Elasticsearch em execução ao fechar o terminal. A maneira mais fácil é usar nohup. Primeiro pressione Ctrl + C para parar o Elasticsearch atualmente em execução e use o seguinte comando para executar o Elasticsearch.

nohup ./bin/elasticsearch&