blast
v0.10.0
Este projeto não é mantido há muito tempo.
Blast é um servidor de indexação e pesquisa de texto completo escrito em Go construído sobre Bleve.
Ele fornece funções por meio de gRPC (HTTP/2 + Protocol Buffers) ou API RESTful tradicional (HTTP/1.1 + JSON).
Blast implementa um algoritmo de consenso Raft por hashicorp/raft. Ele alcança consenso entre todos os nós, garantindo que cada alteração feita no sistema seja feita em um quorum de nós, ou mesmo nenhuma. O Blast torna mais fácil para os programadores desenvolverem aplicativos de pesquisa com recursos avançados.
O Blast requer algumas bibliotecas C/C++ se você precisar habilitar cld2, icu, libstemmer ou leveldb. As seções a seguir são instruções para satisfazer dependências em plataformas específicas.
$ sudo apt-get update
$ sudo apt-get install -y
libicu-dev
libstemmer-dev
libleveldb-dev
gcc-4.8
g++-4.8
build-essential
$ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 80
$ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-8 80
$ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 90
$ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 90
$ export GOPATH= ${HOME} /go
$ mkdir -p ${GOPATH} /src/github.com/blevesearch
$ cd ${GOPATH} /src/github.com/blevesearch
$ git clone https://github.com/blevesearch/cld2.git
$ cd ${GOPATH} /src/github.com/blevesearch/cld2
$ git clone https://github.com/CLD2Owners/cld2.git
$ cd cld2/internal
$ ./compile_libs.sh
$ sudo cp * .so /usr/local/lib$ brew install
icu4c
leveldb
$ export GOPATH= ${HOME} /go
$ go get -u -v github.com/blevesearch/cld2
$ cd ${GOPATH} /src/github.com/blevesearch/cld2
$ git clone https://github.com/CLD2Owners/cld2.git
$ cd cld2/internal
$ perl -p -i -e ' s/soname=/install_name,/ ' compile_libs.sh
$ ./compile_libs.sh
$ sudo cp * .so /usr/local/libConstruindo Blast da seguinte forma:
$ mkdir -p ${GOPATH} /src/github.com/mosuka
$ cd ${GOPATH} /src/github.com/mosuka
$ git clone https://github.com/mosuka/blast.git
$ cd blast
$ make Se você omitir GOOS ou GOARCH , ele construirá o binário da plataforma que você está usando.
Se você deseja especificar a plataforma de destino, defina as variáveis de ambiente GOOS e GOARCH .
$ make GOOS=linux build$ make GOOS=darwin build$ make GOOS=windows buildO Blast suporta algumas extensões Bleve (blevex). Se você quiser construir com eles, defina CGO_LDFLAGS, CGO_CFLAGS, CGO_ENABLED e BUILD_TAGS. Por exemplo, construa o LevelDB para estar disponível para armazenamento de índice da seguinte maneira:
$ make GOOS=linux
BUILD_TAGS=icu
CGO_ENABLED=1
build$ make GOOS=linux
BUILD_TAGS= " kagome icu libstemmer cld2 "
CGO_ENABLED=1
build$ make GOOS=darwin
BUILD_TAGS= " kagome icu libstemmer cld2 "
CGO_ENABLED=1
CGO_LDFLAGS= " -L/usr/local/opt/icu4c/lib "
CGO_CFLAGS= " -I/usr/local/opt/icu4c/include "
buildConsulte a tabela a seguir para os sinalizadores de construção das extensões Bleve suportadas:
| BUILD_TAGS | CGO_ENABLED | Descrição |
|---|---|---|
| cld2 | 1 | Habilitar Detector Compacto de Idioma |
| kagome | 0 | Habilitar Analisador de Língua Japonesa |
| UTI | 1 | Habilitar ICU Tokenizer, analisador de idioma tailandês |
| biblioteca | 1 | Ativar lematizador de idioma (dinamarquês, alemão, inglês, espanhol, finlandês, francês, húngaro, italiano, holandês, norueguês, português, romeno, russo, sueco, turco) |
Se você deseja habilitar o recurso cujo CGO_ENABLE é 1 , instale-o consultando a seção Instalar dependências de compilação acima.
Você pode ver o arquivo binário quando a compilação for bem-sucedida, assim:
$ ls ./bin
blastSe você quiser testar suas alterações, execute o comando como a seguir:
$ make test Se você deseja especificar a plataforma de destino, defina as variáveis de ambiente GOOS e GOARCH da mesma forma que o build.
Para criar um pacote de distribuição, execute o seguinte comando:
$ make dist O Blast pode alterar suas opções de inicialização com arquivos de configuração, variáveis de ambiente e argumentos de linha de comando.
Consulte a tabela a seguir para ver as opções que podem ser configuradas.
| Sinalizador CLI | Variável de ambiente | Arquivo de configuração | Descrição |
|---|---|---|---|
| --config-arquivo | - | - | arquivo de configuração. se omitido, blast.yaml em /etc e no diretório inicial serão pesquisados |
| --eu ia | BLAST_ID | eu ia | ID do nó |
| --jangada-endereço | BLAST_RAFT_ADDRESS | endereço_jangada | Endereço de escuta do servidor Raft |
| --grpc-endereço | BLAST_GRPC_ADDRESS | grpc_address | endereço de escuta do servidor gRPC |
| --http-endereço | BLAST_HTTP_ADDRESS | http_endereço | Endereço de escuta do servidor HTTP |
| --diretório de dados | BLAST_DATA_DIRECTORY | diretório_dados | diretório de dados que armazena o índice e os logs do Raft |
| --mapping-file | BLAST_MAPPING_FILE | arquivo_mapeamento | caminho para o arquivo de mapeamento de índice |
| --peer-grpc-endereço | BLAST_PEER_GRPC_ADDRESS | peer_grpc_address | endereço de escuta do servidor gRPC existente no cluster de adesão |
| --certificado-arquivo | BLAST_CERTIFICATE_FILE | arquivo_certificado | caminho para o arquivo de certificado TLS do servidor cliente |
| --key-arquivo | BLAST_KEY_FILE | arquivo_chave | caminho para o arquivo de chave TLS do servidor cliente |
| --nome comum | BLAST_COMMON_NAME | nome_comum | nome comum do certificado |
| --cors-métodos permitidos | BLAST_CORS_ALLOWED_METHODS | cors_allowed_methods | Métodos permitidos pelo CORS (ex: GET,PUT,DELETE,POST) |
| --cors-allowed-origins | BLAST_CORS_ALLOWED_ORIGINS | cors_allowed_origins | Origens permitidas pelo CORS (ex: http://localhost:8080,http://localhost:80) |
| --cors-permitido-cabeçalhos | BLAST_CORS_ALLOWED_HEADERS | cors_allowed_headers | Cabeçalhos permitidos pelo CORS (ex: content-type,x-some-key) |
| --log-level | BLAST_LOG_LEVEL | nível_de_log | nível de registro |
| --log-arquivo | BLAST_LOG_FILE | arquivo_de_log | arquivo de registro |
| --log-tamanho máximo | BLAST_LOG_MAX_SIZE | log_max_size | tamanho máximo de um arquivo de log em megabytes |
| --log-max-backups | BLAST_LOG_MAX_BACKUPS | log_max_backups | contagem máxima de backup de arquivos de log |
| --log-max-idade | BLAST_LOG_MAX_AGE | log_max_age | idade máxima de um arquivo de log em dias |
| --log-comprimir | BLAST_LOG_COMPRESS | log_compress | compactar um arquivo de log |
Iniciar o servidor é fácil da seguinte forma:
$ ./bin/blast start
--id=node1
--raft-address=:7000
--http-address=:8000
--grpc-address=:9000
--data-directory=/tmp/blast/node1
--mapping-file=./examples/example_mapping.jsonVocê pode obter as informações do nó com o seguinte comando:
$ ./bin/blast node | jq .ou o seguinte URL:
$ curl -X GET http://localhost:8000/v1/node | jq .O resultado do comando acima é:
{
"node" : {
"raft_address" : " :7000 " ,
"metadata" : {
"grpc_address" : " :9000 " ,
"http_address" : " :8000 "
},
"state" : " Leader "
}
}Você pode verificar o status de integridade do nó.
$ ./bin/blast healthcheck | jq .Também fornece as seguintes APIs REST
Este endpoint sempre retorna 200 e deve ser usado para verificar a integridade do servidor.
$ curl -X GET http://localhost:8000/v1/liveness_check | jq .Este endpoint retorna 200 quando o servidor está pronto para atender o tráfego (ou seja, responder às consultas).
$ curl -X GET http://localhost:8000/v1/readiness_check | jq . Para colocar um documento, execute o seguinte comando:
$ ./bin/blast set 1 '
{
"fields": {
"title": "Search engine (computing)",
"text": "A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web.",
"timestamp": "2018-07-04T05:41:00Z",
"_type": "example"
}
}
' | jq .ou você pode usar a API RESTful da seguinte maneira:
$ curl -X PUT ' http://127.0.0.1:8000/v1/documents/1 ' --data-binary '
{
"fields": {
"title": "Search engine (computing)",
"text": "A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web.",
"timestamp": "2018-07-04T05:41:00Z",
"_type": "example"
}
}
' | jq .ou
$ curl -X PUT ' http://127.0.0.1:8000/v1/documents/1 ' -H " Content-Type: application/json " --data-binary @./examples/example_doc_1.jsonPara obter um documento, execute o seguinte comando:
$ ./bin/blast get 1 | jq .ou você pode usar a API RESTful da seguinte maneira:
$ curl -X GET ' http://127.0.0.1:8000/v1/documents/1 ' | jq .Você pode ver o resultado. O resultado do comando acima é:
{
"fields" : {
"_type" : " example " ,
"text" : " A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web. " ,
"timestamp" : " 2018-07-04T05:41:00Z " ,
"title" : " Search engine (computing) "
}
}Para pesquisar documentos, execute o seguinte comando:
$ ./bin/blast search '
{
"search_request": {
"query": {
"query": "+_all:search"
},
"size": 10,
"from": 0,
"fields": [
"*"
],
"sort": [
"-_score"
]
}
}
' | jq .ou você pode usar a API RESTful da seguinte maneira:
$ curl -X POST ' http://127.0.0.1:8000/v1/search ' --data-binary '
{
"search_request": {
"query": {
"query": "+_all:search"
},
"size": 10,
"from": 0,
"fields": [
"*"
],
"sort": [
"-_score"
]
}
}
' | jq .Você pode ver o resultado. O resultado do comando acima é:
{
"search_result" : {
"facets" : null ,
"hits" : [
{
"fields" : {
"_type" : " example " ,
"text" : " A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web. " ,
"timestamp" : " 2018-07-04T05:41:00Z " ,
"title" : " Search engine (computing) "
},
"id" : " 1 " ,
"index" : " /tmp/blast/node1/index " ,
"score" : 0.09703538256409851 ,
"sort" : [
" _score "
]
}
],
"max_score" : 0.09703538256409851 ,
"request" : {
"explain" : false ,
"facets" : null ,
"fields" : [
" * "
],
"from" : 0 ,
"highlight" : null ,
"includeLocations" : false ,
"query" : {
"query" : " +_all:search "
},
"search_after" : null ,
"search_before" : null ,
"size" : 10 ,
"sort" : [
" -_score "
]
},
"status" : {
"failed" : 0 ,
"successful" : 1 ,
"total" : 1
},
"took" : 171880 ,
"total_hits" : 1
}
}Excluindo um documento, execute o seguinte comando:
$ ./bin/blast delete 1ou você pode usar a API RESTful da seguinte maneira:
$ curl -X DELETE ' http://127.0.0.1:8000/v1/documents/1 ' Para indexar documentos em massa, execute o seguinte comando:
$ ./bin/blast bulk-index --file ./examples/example_bulk_index.jsonou você pode usar a API RESTful da seguinte maneira:
$ curl -X PUT ' http://127.0.0.1:8000/v1/documents ' -H " Content-Type: application/x-ndjson " --data-binary @./examples/example_bulk_index.jsonPara excluir documentos em massa, execute o seguinte comando:
$ ./bin/blast bulk-delete --file ./examples/example_bulk_delete.txtou você pode usar a API RESTful da seguinte maneira:
$ curl -X DELETE ' http://127.0.0.1:8000/v1/documents ' -H " Content-Type: text/plain " --data-binary @./examples/example_bulk_delete.txtBlast é fácil de trazer o cluster. o nó já está em execução, mas isso não é tolerante a falhas. Se você precisar aumentar a tolerância a falhas, crie mais 2 nós de dados como este:
$ ./bin/blast start
--id=node2
--raft-address=:7001
--http-address=:8001
--grpc-address=:9001
--peer-grpc-address=:9000
--data-directory=/tmp/blast/node2
--mapping-file=./examples/example_mapping.json$ ./bin/blast start
--id=node3
--raft-address=:7002
--http-address=:8002
--grpc-address=:9002
--peer-grpc-address=:9000
--data-directory=/tmp/blast/node3
--mapping-file=./examples/example_mapping.jsonO exemplo acima mostra cada nó Blast em execução no mesmo host, portanto, cada nó deve escutar em portas diferentes. Isso não seria necessário se cada nó fosse executado em um host diferente.
Isso instrui cada novo nó a ingressar em um nó existente, cada nó reconhece os clusters de adesão quando iniciado. Então você tem um cluster de 3 nós. Dessa forma você pode tolerar a falha de 1 nó. Você pode verificar o cluster com o seguinte comando:
$ ./bin/blast cluster | jq .ou você pode usar a API RESTful da seguinte maneira:
$ curl -X GET ' http://127.0.0.1:8000/v1/cluster ' | jq .Você pode ver o resultado no formato JSON. O resultado do comando acima é:
{
"cluster" : {
"nodes" : {
"node1" : {
"raft_address" : " :7000 " ,
"metadata" : {
"grpc_address" : " :9000 " ,
"http_address" : " :8000 "
},
"state" : " Leader "
},
"node2" : {
"raft_address" : " :7001 " ,
"metadata" : {
"grpc_address" : " :9001 " ,
"http_address" : " :8001 "
},
"state" : " Follower "
},
"node3" : {
"raft_address" : " :7002 " ,
"metadata" : {
"grpc_address" : " :9002 " ,
"http_address" : " :8002 "
},
"state" : " Follower "
}
},
"leader" : " node1 "
}
}Recomende 3 ou mais números ímpares de nós no cluster. Em cenários de falha, a perda de dados é inevitável, portanto evite implantar nós únicos.
No exemplo acima, o nó se junta ao cluster na inicialização, mas você também pode juntar o nó que já iniciou no modo autônomo ao cluster posteriormente, da seguinte forma:
$ ./bin/blast join --grpc-address=:9000 node2 127.0.0.1:9001ou você pode usar a API RESTful da seguinte maneira:
$ curl -X PUT ' http://127.0.0.1:8000/v1/cluster/node2 ' --data-binary '
{
"raft_address": ":7001",
"metadata": {
"grpc_address": ":9001",
"http_address": ":8001"
}
}
'Para remover um nó do cluster, execute o seguinte comando:
$ ./bin/blast leave --grpc-address=:9000 node2ou você pode usar a API RESTful da seguinte maneira:
$ curl -X DELETE ' http://127.0.0.1:8000/v1/cluster/node2 'O comando a seguir indexa documentos para qualquer nó do cluster:
$ ./bin/blast set 1 '
{
"fields": {
"title": "Search engine (computing)",
"text": "A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web.",
"timestamp": "2018-07-04T05:41:00Z",
"_type": "example"
}
}
' --grpc-address=:9000 | jq .Portanto, você pode obter o documento do nó especificado pelo comando acima da seguinte forma:
$ ./bin/blast get 1 --grpc-address=:9000 | jq .Você pode ver o resultado. O resultado do comando acima é:
value1
Você também pode obter o mesmo documento de outros nós do cluster da seguinte maneira:
$ ./bin/blast get 1 --grpc-address=:9001 | jq .
$ ./bin/blast get 1 --grpc-address=:9002 | jq .Você pode ver o resultado. O resultado do comando acima é:
{
"fields" : {
"_type" : " example " ,
"text" : " A search engine is an information retrieval system designed to help find information stored on a computer system. The search results are usually presented in a list and are commonly called hits. Search engines help to minimize the time required to find information and the amount of information which must be consulted, akin to other techniques for managing information overload. The most public, visible form of a search engine is a Web search engine which searches for information on the World Wide Web. " ,
"timestamp" : " 2018-07-04T05:41:00Z " ,
"title" : " Search engine (computing) "
}
}Você pode construir a imagem do contêiner Docker assim:
$ make docker-buildVocê também pode usar a imagem do contêiner Docker já registrada em docker.io assim:
$ docker pull mosuka/blast:latestConsulte https://hub.docker.com/r/mosuka/blast/tags/
Executando um nó de dados Blast no Docker. Inicie o nó Blast assim:
$ docker run --rm --name blast-node1
-p 7000:7000
-p 8000:8000
-p 9000:9000
-v $( pwd ) /etc/blast_mapping.json:/etc/blast_mapping.json
mosuka/blast:latest start
--id=node1
--raft-address=:7000
--http-address=:8000
--grpc-address=:9000
--data-directory=/tmp/blast/node1
--mapping-file=/etc/blast_mapping.jsonVocê pode executar o comando no contêiner docker da seguinte maneira:
$ docker exec -it blast-node1 blast node --grpc-address=:9000O Blast suporta acesso HTTPS, garantindo que toda a comunicação entre clientes e um cluster seja criptografada.
Uma forma de gerar os recursos necessários é via openssl. Por exemplo:
$ openssl req -x509 -nodes -newkey rsa:4096 -keyout ./etc/blast_key.pem -out ./etc/blast_cert.pem -days 365 -subj ' /CN=localhost '
Generating a 4096 bit RSA private key
............................++
........++
writing new private key to ' key.pem 'Iniciando um nó com HTTPS habilitado, criptografia nó a nó e com o arquivo de configuração acima. Presume-se que o certificado e a chave HTTPS X.509 estejam nos caminhos server.crt e key.pem respectivamente.
$ ./bin/blast start
--id=node1
--raft-address=:7000
--http-address=:8000
--grpc-address=:9000
--peer-grpc-address=:9000
--data-directory=/tmp/blast/node1
--mapping-file=./etc/blast_mapping.json
--certificate-file=./etc/blast_cert.pem
--key-file=./etc/blast_key.pem
--common-name=localhost$ ./bin/blast start
--id=node2
--raft-address=:7001
--http-address=:8001
--grpc-address=:9001
--peer-grpc-address=:9000
--data-directory=/tmp/blast/node2
--mapping-file=./etc/blast_mapping.json
--certificate-file=./etc/blast_cert.pem
--key-file=./etc/blast_key.pem
--common-name=localhost$ ./bin/blast start
--id=node3
--raft-address=:7002
--http-address=:8002
--grpc-address=:9002
--peer-grpc-address=:9000
--data-directory=/tmp/blast/node3
--mapping-file=./etc/blast_mapping.json
--certificate-file=./etc/blast_cert.pem
--key-file=./etc/blast_key.pem
--common-name=localhostVocê pode acessar o cluster adicionando uma sinalização, como o seguinte comando:
$ ./bin/blast cluster --grpc-address=:9000 --certificate-file=./etc/blast_cert.pem --common-name=localhost | jq .ou
$ curl -X GET https://localhost:8000/v1/cluster --cacert ./etc/cert.pem | jq .
