Unduhan blast - unduhan kode sumber blast

Proyek ini telah diambil alih oleh Phalanx.

Proyek ini sudah lama tidak dipertahankan.

Ledakan

Blast adalah server pencarian dan pengindeksan teks lengkap yang ditulis dalam Go yang dibangun di atas Bleve.
Ini menyediakan fungsi melalui gRPC (HTTP/2 + Protocol Buffer) atau RESTful API tradisional (HTTP/1.1 + JSON).
Blast mengimplementasikan algoritma konsensus Raft oleh hashicorp/raft. Hal ini mencapai konsensus di seluruh node, memastikan bahwa setiap perubahan yang dilakukan pada sistem dilakukan pada kuorum node, atau tidak sama sekali. Blast memudahkan pemrogram untuk mengembangkan aplikasi pencarian dengan fitur-fitur canggih.

Fitur

Pencarian/pengindeksan teks lengkap
Pencarian segi
Pencarian Spasial/Geospasial
Sorotan hasil pencarian
Replikasi indeks
Memunculkan cluster
API HTTP yang mudah digunakan
CLI tersedia
Gambar kontainer Docker tersedia

Instal dependensi build

Blast memerlukan beberapa pustaka C/C++ jika Anda perlu mengaktifkan cld2, icu, libstemmer, atau leveldb. Bagian berikut adalah instruksi untuk memenuhi ketergantungan pada platform tertentu.

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 Sierra Tinggi Versi 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

Membangun

Ledakan Bangunan sebagai berikut:

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

Jika Anda menghilangkan GOOS atau GOARCH , ini akan membangun biner platform yang Anda gunakan.
Jika Anda ingin menentukan platform target, harap atur variabel lingkungan GOOS dan GOARCH .

Linux

$ make GOOS=linux build

macOS

$ make GOOS=darwin build

jendela

$ make GOOS=windows build

Bangun dengan ekstensi

Blast mendukung beberapa Ekstensi Bleve (blevex). Jika Anda ingin membangun dengan mereka, silakan atur CGO_LDFLAGS, CGO_CFLAGS, CGO_ENABLED dan BUILD_TAGS. Misalnya, buat LevelDB agar tersedia untuk penyimpanan indeks sebagai berikut:

$ 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

Bangun bendera

Lihat tabel berikut untuk flag build dari ekstensi Bleve yang didukung:

BUILD_TAGS	CGO_ENABLED	Keterangan
cld2	1	Aktifkan Detektor Bahasa Ringkas
kagome	0	Aktifkan Penganalisis Bahasa Jepang
icu	1	Aktifkan ICU Tokenizer, Penganalisis Bahasa Thailand
libstemmer	1	Aktifkan Stemmer Bahasa (Denmark, Jerman, Inggris, Spanyol, Finlandia, Prancis, Hongaria, Italia, Belanda, Norwegia, Portugis, Rumania, Rusia, Swedia, Turki)

Jika Anda ingin mengaktifkan fitur yang CGO_ENABLE -nya 1 , silakan instal dengan mengacu pada bagian Instal build dependensi di atas.

Biner

Anda dapat melihat file biner ketika build berhasil seperti:

$ ls ./bin
blast

Tes

Jika Anda ingin menguji perubahan Anda, jalankan perintah seperti berikut:

$ make test

Jika Anda ingin menentukan platform target, atur variabel lingkungan GOOS dan GOARCH dengan cara yang sama seperti build.

Kemasan

Untuk membuat paket distribusi, jalankan perintah berikut:

$ make dist

Konfigurasikan

Blast dapat mengubah opsi permulaannya dengan file konfigurasi, variabel lingkungan, dan argumen baris perintah.
Lihat tabel berikut untuk opsi yang dapat dikonfigurasi.

Bendera CLI	Variabel lingkungan	File Konfigurasi	Keterangan
--file konfigurasi	-	-	file konfigurasi. jika dihilangkan, blast.yaml di direktori /etc dan home akan dicari
--pengenal	BLAST_ID	pengenal	ID simpul
--alamat-rakit	BLAST_RAFT_ADDRESS	rakit_alamat	Alamat mendengarkan server rakit
--grpc-alamat	BLAST_GRPC_ADDRESS	grpc_address	alamat mendengarkan server gRPC
--http-alamat	BLAST_HTTP_ADDRESS	http_alamat	Alamat mendengarkan server HTTP
--direktori-data	BLAST_DATA_DIRECTORY	direktori_data	direktori data yang menyimpan indeks dan log Rakit
--file pemetaan	BLAST_MAPPING_FILE	pemetaan_file	jalur ke file pemetaan indeks
--alamat-rekan-grpc	BLAST_PEER_GRPC_ADDRESS	peer_grpc_address	mendengarkan alamat server gRPC yang ada di cluster yang bergabung
--file-sertifikat	BLAST_CERTIFICATE_FILE	sertifikat_file	jalur ke file sertifikat TLS server klien
--file kunci	BLAST_KEY_FILE	file_kunci	jalur ke file kunci TLS server klien
--nama-umum	BLAST_COMMON_NAME	nama_umum	nama umum sertifikat
--cors-diizinkan-metode	BLAST_CORS_ALLOWED_METHODS	cors_allowed_methods	Metode yang diizinkan CORS (misal: GET,PUT,DELETE,POST)
--cors-diizinkan-asal	BLAST_CORS_ALLOWED_ORIGINS	cors_allowed_origins	Asal yang diizinkan CORS (misal: http://localhost:8080,http://localhost:80)
--cors-diizinkan-header	BLAST_CORS_ALLOWED_HEADERS	cors_allowed_headers	Header yang diizinkan CORS (misal: tipe konten, x-some-key)
--tingkat log	BLAST_LOG_LEVEL	log_level	tingkat log
--file-log	BLAST_LOG_FILE	log_file	berkas log
--log-ukuran maksimal	BLAST_LOG_MAX_SIZE	log_max_size	ukuran maksimal file log dalam megabyte
--log-max-backup	BLAST_LOG_MAX_BACKUPS	log_max_backup	jumlah cadangan maksimum file log
--log-usia maksimal	BLAST_LOG_MAX_AGE	log_max_age.log_max_age	usia maksimal file log dalam beberapa hari
--log-kompres	BLAST_LOG_COMPRESS	log_kompres	kompres file log

Awal

Memulai server semudah berikut:

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

Anda bisa mendapatkan informasi node dengan perintah berikut:

$ ./bin/blast node | jq .

atau URL berikut:

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

Hasil dari perintah di atas adalah:

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

Pemeriksaan kesehatan

Anda dapat memeriksa status kesehatan node.

$ ./bin/blast healthcheck | jq .

Juga menyediakan REST API berikut

Keaktifan membuktikan

Titik akhir ini selalu mengembalikan 200 dan harus digunakan untuk memeriksa kesehatan server.

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

Pemeriksaan kesiapan

Titik akhir ini mengembalikan 200 ketika server siap melayani lalu lintas (yaitu merespons pertanyaan).

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

Letakkan dokumen

Untuk meletakkan dokumen, jalankan perintah berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

atau

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

Dapatkan dokumen

Untuk mendapatkan dokumen, jalankan perintah berikut:

$ ./bin/blast get 1 | jq .

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Anda bisa melihat hasilnya. Hasil dari perintah di atas adalah:

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

Cari dokumen

Untuk mencari dokumen, jalankan perintah berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Anda bisa melihat hasilnya. Hasil dari perintah di atas adalah:

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

Hapus dokumen

Menghapus dokumen, jalankan perintah berikut:

$ ./bin/blast delete 1

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Indeks dokumen secara massal

Untuk mengindeks dokumen secara massal, jalankan perintah berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Hapus dokumen secara massal

Untuk menghapus dokumen secara massal, jalankan perintah berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Memunculkan sebuah cluster

Blast mudah untuk memunculkan cluster. node sudah berjalan, tapi itu tidak toleran terhadap kesalahan. Jika Anda perlu meningkatkan toleransi kesalahan, tampilkan 2 node data lagi seperti:

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

Contoh di atas menunjukkan setiap node Blast berjalan pada host yang sama, sehingga setiap node harus mendengarkan pada port yang berbeda. Ini tidak diperlukan jika setiap node dijalankan pada host yang berbeda.

Ini menginstruksikan setiap node baru untuk bergabung dengan node yang sudah ada, setiap node mengenali cluster yang bergabung ketika dimulai. Jadi, Anda memiliki cluster 3-node. Dengan begitu Anda bisa mentolerir kegagalan 1 node. Anda dapat memeriksa cluster dengan perintah berikut:

$ ./bin/blast cluster | jq .

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Anda dapat melihat hasilnya dalam format JSON. Hasil dari perintah di atas adalah:

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

Merekomendasikan 3 atau lebih jumlah node ganjil dalam cluster. Dalam skenario kegagalan, kehilangan data tidak dapat dihindari, jadi hindari penerapan node tunggal.

Contoh di atas, node bergabung ke cluster saat startup, namun Anda juga dapat menggabungkan node yang sudah dimulai dalam mode standalone ke cluster nanti, sebagai berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Untuk menghapus node dari cluster, jalankan perintah berikut:

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

atau, Anda dapat menggunakan RESTful API sebagai berikut:

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

Perintah berikut mengindeks dokumen ke node mana pun di klaster:

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

Jadi, Anda bisa mendapatkan dokumen dari node yang ditentukan oleh perintah di atas sebagai berikut:

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

Anda bisa melihat hasilnya. Hasil dari perintah di atas adalah:

 value1

Anda juga bisa mendapatkan dokumen yang sama dari node lain di cluster sebagai berikut:

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

Anda bisa melihat hasilnya. Hasil dari perintah di atas adalah:

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

Buruh pelabuhan

Bangun gambar kontainer Docker

Anda dapat membuat image container Docker seperti ini:

$ make docker-build

Tarik gambar kontainer Docker dari docker.io

Anda juga dapat menggunakan image container Docker yang sudah terdaftar di docker.io seperti:

$ docker pull mosuka/blast:latest

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

Mulai di Docker

Menjalankan node data Blast di Docker. Mulai node Blast seperti ini:

$ 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

Anda dapat menjalankan perintah di wadah buruh pelabuhan sebagai berikut:

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

Mengamankan Ledakan

Blast mendukung akses HTTPS, memastikan bahwa semua komunikasi antara klien dan cluster dienkripsi.

Menghasilkan sertifikat dan kunci pribadi

Salah satu cara untuk menghasilkan sumber daya yang diperlukan adalah melalui openssl. Misalnya:

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

Contoh cluster yang aman

Memulai node dengan HTTPS diaktifkan, enkripsi node-ke-node, dan dengan file konfigurasi di atas. Diasumsikan sertifikat dan kunci HTTPS X.509 masing-masing berada di jalur server.crt dan 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

Anda dapat mengakses klaster dengan menambahkan tanda, seperti perintah berikut:

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

atau

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

Memperluas