blast Télécharger - blast Téléchargement du code source

Ce projet a été repris par Phalanx.

Ce projet n'a pas été maintenu depuis longtemps.

Explosion

Blast est un serveur de recherche et d'indexation en texte intégral écrit en Go et construit sur Bleve.
Il fournit des fonctions via gRPC (HTTP/2 + Protocol Buffers) ou l'API RESTful traditionnelle (HTTP/1.1 + JSON).
Blast implémente un algorithme de consensus Raft par hashicorp/raft. Il parvient à un consensus sur tous les nœuds, garantissant que chaque modification apportée au système est apportée à un quorum de nœuds, voire aucune. Blast permet aux programmeurs de développer facilement des applications de recherche dotées de fonctionnalités avancées.

Caractéristiques

Recherche/indexation en texte intégral
Recherche à facettes
Recherche spatiale/géospatiale
Mise en évidence des résultats de recherche
Réplication d'index
Faire apparaître le cluster
Une API HTTP facile à utiliser
La CLI est disponible
L'image du conteneur Docker est disponible

Installer les dépendances de build

Blast nécessite certaines bibliothèques C/C++ si vous devez activer cld2, icu, libstemmer ou leveldb. Les sections suivantes sont des instructions pour satisfaire les dépendances sur des plates-formes particulières.

Ubuntu 18.10

$ 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

macOS High Sierra version 10.13.6

$ 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/lib

Construire

Building Blast comme suit :

$ mkdir -p ${GOPATH} /src/github.com/mosuka
$ cd ${GOPATH} /src/github.com/mosuka
$ git clone https://github.com/mosuka/blast.git
$ cd blast
$ make

Si vous omettez GOOS ou GOARCH , il construira le binaire de la plateforme que vous utilisez.
Si vous souhaitez spécifier la plate-forme cible, veuillez définir les variables d'environnement GOOS et GOARCH .

Linux

$ make GOOS=linux build

macOS

$ make GOOS=darwin build

Fenêtres

$ make GOOS=windows build

Construire avec des extensions

Blast prend en charge certaines extensions Bleve (blevex). Si vous souhaitez construire avec eux, veuillez définir CGO_LDFLAGS, CGO_CFLAGS, CGO_ENABLED et BUILD_TAGS. Par exemple, créez LevelDB pour qu'il soit disponible pour le stockage d'index comme suit :

$ make GOOS=linux 
       BUILD_TAGS=icu 
       CGO_ENABLED=1 
       build

Linux

$ make GOOS=linux 
       BUILD_TAGS= " kagome icu libstemmer cld2 " 
       CGO_ENABLED=1 
       build

macOS

$ 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 " 
       build

Construire des drapeaux

Reportez-vous au tableau suivant pour connaître les indicateurs de build des extensions Bleve prises en charge :

BUILD_TAGS	CGO_ENABLED	Description
cld2	1	Activer le détecteur de langue compact
kagomé	0	Activer l'analyseur de langue japonaise
icu	1	Activer ICU Tokenizer, l'analyseur de langue thaïlandaise
libstemmer	1	Activer le code de langue (danois, allemand, anglais, espagnol, finnois, français, hongrois, italien, néerlandais, norvégien, portugais, roumain, russe, suédois, turc)

Si vous souhaitez activer la fonctionnalité dont CGO_ENABLE est 1 , veuillez l'installer en vous référant à la section Installer les dépendances de build ci-dessus.

Binaire

Vous pouvez voir le fichier binaire une fois la construction réussie, comme ceci :

$ ls ./bin
blast

Test

Si vous souhaitez tester vos modifications, exécutez la commande comme suivante :

$ make test

Si vous souhaitez spécifier la plate-forme cible, définissez les variables d'environnement GOOS et GOARCH de la même manière que la build.

Emballer

Pour créer un package de distribution, exécutez la commande suivante :

$ make dist

Configurer

Blast peut modifier ses options de démarrage avec des fichiers de configuration, des variables d'environnement et des arguments de ligne de commande.
Reportez-vous au tableau suivant pour connaître les options pouvant être configurées.

Indicateur CLI	Variable d'environnement	Fichier de configuration	Description
--fichier-config	-	-	fichier de configuration. en cas d'omission, blast.yaml dans /etc et le répertoire personnel seront recherchés
--identifiant	BLAST_ID	identifiant	ID de nœud
--adresse-radeau	BLAST_RAFT_ADDRESS	adresse_radeau	Adresse d'écoute du serveur Raft
--adresse-grpc	BLAST_GRPC_ADDRESS	adresse_grpc	Adresse d'écoute du serveur gRPC
--adresse-http	BLAST_HTTP_ADDRESS	adresse_http	Adresse d'écoute du serveur HTTP
--répertoire-de-données	BLAST_DATA_DIRECTORY	répertoire_données	répertoire de données qui stocke les journaux d'index et Raft
--fichier-mapping	BLAST_MAPPING_FILE	fichier_mapping	chemin d'accès au fichier de mappage d'index
--adresse-peer-grpc	BLAST_PEER_GRPC_ADDRESS	adresse_grpc_pair	adresse d'écoute du serveur gRPC existant dans le cluster qui rejoint
--fichier-certificat	BLAST_CERTIFICATE_FILE	fichier_certificat	chemin d'accès au fichier de certificat TLS du serveur client
--fichier-clé	BLAST_KEY_FILE	fichier_clé	chemin d'accès au fichier de clé TLS du serveur client
--nom-commun	BLAST_COMMON_NAME	nom_commun	nom commun du certificat
--cors-permis-méthodes	BLAST_CORS_ALLOWED_METHODS	cors_allowed_methods	Méthodes autorisées CORS (ex : GET, PUT, DELETE, POST)
--cors-origines-autorisées	BLAST_CORS_ALLOWED_ORIGINS	cors_allowed_origins	Origines autorisées CORS (ex : http://localhost:8080,http://localhost:80)
--cors-allowed-headers	BLAST_CORS_ALLOWED_HEADERS	cors_allowed_headers	En-têtes CORS autorisés (ex : content-type,x-some-key)
--niveau de journal	BLAST_LOG_LEVEL	niveau_log	niveau de journalisation
--fichier-journal	BLAST_LOG_FILE	fichier_journal	fichier journal
--log-max-taille	BLAST_LOG_MAX_SIZE	log_max_size	taille maximale d'un fichier journal en mégaoctets
--log-max-sauvegardes	BLAST_LOG_MAX_BACKUPS	log_max_backups	nombre maximum de sauvegardes de fichiers journaux
--log-max-âge	BLAST_LOG_MAX_AGE	log_max_age	âge maximum d'un fichier journal en jours
--log-compresser	BLAST_LOG_COMPRESS	log_compress	compresser un fichier journal

Commencer

Le démarrage du serveur est simple comme suit :

$ ./bin/blast start 
              --id=node1 
              --raft-address=:7000 
              --http-address=:8000 
              --grpc-address=:9000 
              --data-directory=/tmp/blast/node1 
              --mapping-file=./examples/example_mapping.json

Vous pouvez obtenir les informations sur le nœud avec la commande suivante :

$ ./bin/blast node | jq .

ou l'URL suivante :

$ curl -X GET http://localhost:8000/v1/node | jq .

Le résultat de la commande ci-dessus est :

{
  "node" : {
    "raft_address" : " :7000 " ,
    "metadata" : {
      "grpc_address" : " :9000 " ,
      "http_address" : " :8000 "
    },
    "state" : " Leader "
  }
}

Bilan de santé

Vous pouvez vérifier l'état de santé du nœud.

$ ./bin/blast healthcheck | jq .

Fournit également les API REST suivantes

La vivacité prouve

Ce point de terminaison renvoie toujours 200 et doit être utilisé pour vérifier l’état du serveur.

$ curl -X GET http://localhost:8000/v1/liveness_check | jq .

Sonde de préparation

Ce point de terminaison renvoie 200 lorsque le serveur est prêt à servir le trafic (c'est-à-dire répondre aux requêtes).

$ curl -X GET http://localhost:8000/v1/readiness_check | jq .

Mettre un document

Pour mettre un document, exécutez la commande suivante :

$ ./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, vous pouvez utiliser l'API RESTful comme suit :

$ 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 .

$ curl -X PUT ' http://127.0.0.1:8000/v1/documents/1 ' -H " Content-Type: application/json " --data-binary @./examples/example_doc_1.json

Obtenir un document

Pour obtenir un document, exécutez la commande suivante :

$ ./bin/blast get 1 | jq .

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X GET ' http://127.0.0.1:8000/v1/documents/1 ' | jq .

Vous pouvez voir le résultat. Le résultat de la commande ci-dessus est :

{
  "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) "
  }
}

Rechercher des documents

Pour rechercher des documents, exécutez la commande suivante :

$ ./bin/blast search '
{
  "search_request": {
    "query": {
      "query": "+_all:search"
    },
    "size": 10,
    "from": 0,
    "fields": [
      "*"
    ],
    "sort": [
      "-_score"
    ]
  }
}
' | jq .

ou, vous pouvez utiliser l'API RESTful comme suit :

$ 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 .

Vous pouvez voir le résultat. Le résultat de la commande ci-dessus est :

{
  "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
  }
}

Supprimer un document

En supprimant un document, exécutez la commande suivante :

$ ./bin/blast delete 1

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X DELETE ' http://127.0.0.1:8000/v1/documents/1 '

Indexer des documents en masse

Pour indexer des documents en masse, exécutez la commande suivante :

$ ./bin/blast bulk-index --file ./examples/example_bulk_index.json

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X PUT ' http://127.0.0.1:8000/v1/documents ' -H " Content-Type: application/x-ndjson " --data-binary @./examples/example_bulk_index.json

Supprimer des documents en masse

Pour supprimer des documents en masse, exécutez la commande suivante :

$ ./bin/blast bulk-delete --file ./examples/example_bulk_delete.txt

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X DELETE ' http://127.0.0.1:8000/v1/documents ' -H " Content-Type: text/plain " --data-binary @./examples/example_bulk_delete.txt

Faire apparaître un cluster

Blast est facile à faire apparaître le cluster. le nœud est déjà en cours d'exécution, mais ce n'est pas tolérant aux pannes. Si vous devez augmenter la tolérance aux pannes, affichez 2 nœuds de données supplémentaires comme ceci :

$ ./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.json

L'exemple ci-dessus montre chaque nœud Blast exécuté sur le même hôte, chaque nœud doit donc écouter sur des ports différents. Cela ne serait pas nécessaire si chaque nœud s'exécutait sur un hôte différent.

Cela demande à chaque nouveau nœud de rejoindre un nœud existant, chaque nœud reconnaît les clusters qui se joignent au démarrage. Vous disposez donc d’un cluster à 3 nœuds. De cette façon, vous pouvez tolérer la panne d’un nœud. Vous pouvez vérifier le cluster avec la commande suivante :

$ ./bin/blast cluster | jq .

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X GET ' http://127.0.0.1:8000/v1/cluster ' | jq .

Vous pouvez voir le résultat au format JSON. Le résultat de la commande ci-dessus est :

{
  "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 "
  }
}

Recommandez 3 nombres impairs ou plus de nœuds dans le cluster. Dans les scénarios de panne, la perte de données est inévitable, évitez donc de déployer des nœuds uniques.

Dans l'exemple ci-dessus, le nœud se joint au cluster au démarrage, mais vous pouvez également joindre le nœud qui a déjà démarré en mode autonome au cluster ultérieurement, comme suit :

$ ./bin/blast join --grpc-address=:9000 node2 127.0.0.1:9001

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X PUT ' http://127.0.0.1:8000/v1/cluster/node2 ' --data-binary '
{
  "raft_address": ":7001",
  "metadata": {
    "grpc_address": ":9001",
    "http_address": ":8001"
  }
}
'

Pour supprimer un nœud du cluster, exécutez la commande suivante :

$ ./bin/blast leave --grpc-address=:9000 node2

ou, vous pouvez utiliser l'API RESTful comme suit :

$ curl -X DELETE ' http://127.0.0.1:8000/v1/cluster/node2 '

La commande suivante indexe les documents sur n'importe quel nœud du 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 .

Ainsi, vous pouvez obtenir le document à partir du nœud spécifié par la commande ci-dessus comme suit :

$ ./bin/blast get 1 --grpc-address=:9000 | jq .

Vous pouvez voir le résultat. Le résultat de la commande ci-dessus est :

 value1

Vous pouvez également obtenir le même document à partir d'autres nœuds du cluster comme suit :

$ ./bin/blast get 1 --grpc-address=:9001 | jq .
$ ./bin/blast get 1 --grpc-address=:9002 | jq .

Vous pouvez voir le résultat. Le résultat de la commande ci-dessus est :

{
  "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) "
  }
}

Docker

Créer une image de conteneur Docker

Vous pouvez créer l'image du conteneur Docker comme ceci :

$ make docker-build

Extraire l'image du conteneur Docker de docker.io

Vous pouvez également utiliser l'image du conteneur Docker déjà enregistrée dans docker.io comme ceci :

$ docker pull mosuka/blast:latest

Voir https://hub.docker.com/r/mosuka/blast/tags/

Démarrer sur Docker

Exécution d'un nœud de données Blast sur Docker. Démarrez le nœud Blast comme ceci :

$ 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.json

Vous pouvez exécuter la commande dans le conteneur Docker comme suit :

$ docker exec -it blast-node1 blast node --grpc-address=:9000

Explosion sécurisée

Blast prend en charge l'accès HTTPS, garantissant que toutes les communications entre les clients et un cluster sont cryptées.

Générer un certificat et une clé privée

Une façon de générer les ressources nécessaires est via openssl. Par exemple:

$ 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 '

Exemple de cluster sécurisé

Démarrage d'un nœud avec HTTPS activé, cryptage de nœud à nœud et avec le fichier de configuration ci-dessus. On suppose que le certificat et la clé HTTPS X.509 se trouvent respectivement sur les chemins server.crt et key.pem.

$ ./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=localhost

Vous pouvez accéder au cluster en ajoutant un indicateur, tel que la commande suivante :

$ ./bin/blast cluster --grpc-address=:9000 --certificate-file=./etc/blast_cert.pem --common-name=localhost | jq .

$ curl -X GET https://localhost:8000/v1/cluster --cacert ./etc/cert.pem | jq .

Développer