blast

โครงการนี้ถูกยึดครองโดย Phalanx

โครงการนี้ไม่ได้รับการบำรุงรักษามาเป็นเวลานาน

ระเบิด

Blast เป็นเซิร์ฟเวอร์การค้นหาและจัดทำดัชนีข้อความแบบเต็มที่เขียนด้วย Go ซึ่งสร้างขึ้นบน Bleve
มีฟังก์ชันผ่าน gRPC (HTTP/2 + Protocol Buffers) หรือ RESTful API แบบดั้งเดิม (HTTP/1.1 + JSON)
Blast ใช้อัลกอริธึมฉันทามติ Raft โดย hashicorp/raft โดยได้รับความเห็นพ้องต้องกันในทุกโหนด ทำให้มั่นใจได้ว่าทุกการเปลี่ยนแปลงที่ทำกับระบบจะทำกับองค์ประชุมของโหนด หรือไม่มีเลยเลย Blast ช่วยให้โปรแกรมเมอร์สามารถพัฒนาแอปพลิเคชันการค้นหาด้วยคุณสมบัติขั้นสูงได้อย่างง่ายดาย

คุณสมบัติ

• ค้นหา/จัดทำดัชนีข้อความแบบเต็ม
• การค้นหาแบบ Faceted
• การค้นหาเชิงพื้นที่/ภูมิสารสนเทศ
• การเน้นผลการค้นหา
• การจำลองแบบดัชนี
• การนำคลัสเตอร์ขึ้นมา
• HTTP API ที่ใช้งานง่าย
• CLI สามารถใช้ได้
• มีอิมเมจคอนเทนเนอร์นักเทียบท่าแล้ว

ติดตั้งการพึ่งพาการสร้าง

Blast ต้องการไลบรารี C/C++ บางตัว หากคุณต้องการเปิดใช้งาน cld2, icu, libstemmer หรือ leveldb ส่วนต่อไปนี้เป็นคำแนะนำสำหรับการตอบสนองการขึ้นต่อกันบนแพลตฟอร์มเฉพาะ

อูบุนตู 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 เวอร์ชั่น 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

สร้าง

ระเบิดอาคารดังต่อไปนี้:

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

หากคุณละเว้น GOOS หรือ GOARCH มันจะสร้างไบนารีของแพลตฟอร์มที่คุณใช้
หากคุณต้องการระบุแพลตฟอร์มเป้าหมาย โปรดตั้งค่าตัวแปรสภาพแวดล้อม GOOS และ GOARCH

ลินุกซ์

$ make GOOS=linux build

ระบบปฏิบัติการ macOS

$ make GOOS=darwin build

หน้าต่าง

$ make GOOS=windows build

สร้างด้วยส่วนขยาย

Blast รองรับส่วนขยาย Bleve บางส่วน (blevex) หากคุณต้องการสร้างด้วยโปรดตั้งค่า CGO_LDFLAGS, CGO_CFLAGS, CGO_ENABLED และ BUILD_TAGS ตัวอย่างเช่น สร้าง LevelDB เพื่อให้พร้อมใช้งานสำหรับการจัดเก็บดัชนีดังต่อไปนี้:

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

ลินุกซ์

$ 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

สร้างธง

โปรดดูตารางต่อไปนี้สำหรับแฟล็ก build ของส่วนขยาย Bleve ที่รองรับ:

BUILD_TAGS	CGO_เปิดใช้งานแล้ว	คำอธิบาย
ซีดี2	1	เปิดใช้งานตัวตรวจจับภาษาขนาดกะทัดรัด
คาโงเมะ	0	เปิดใช้งานตัววิเคราะห์ภาษาญี่ปุ่น
ห้องไอซียู	1	เปิดใช้งาน ICU Tokenizer เครื่องวิเคราะห์ภาษาไทย
libstemmer	1	เปิดใช้งานภาษา Stemmer (เดนมาร์ก เยอรมัน อังกฤษ สเปน ฟินแลนด์ ฝรั่งเศส ฮังการี อิตาลี ดัตช์ นอร์เวย์ โปรตุเกส โรมาเนีย รัสเซีย สวีเดน ตุรกี)

หากคุณต้องการเปิดใช้งานคุณสมบัติที่มี CGO_ENABLE เป็น 1 โปรดติดตั้งโดยอ้างอิงถึงส่วนการพึ่งพาการติดตั้งบิลด์ด้านบน

ไบนารี่

คุณสามารถดูไฟล์ไบนารี่ได้เมื่อสร้างสำเร็จดังนี้:

$ ls ./bin
blast

ทดสอบ

หากคุณต้องการทดสอบการเปลี่ยนแปลงของคุณ ให้รันคำสั่งดังต่อไปนี้:

$ make test

หากคุณต้องการระบุแพลตฟอร์มเป้าหมาย ให้ตั้งค่าตัวแปรสภาพแวดล้อม GOOS และ GOARCH ในลักษณะเดียวกับบิลด์

บรรจุุภัณฑ์

หากต้องการสร้างแพ็คเกจการแจกจ่าย ให้รันคำสั่งต่อไปนี้:

$ make dist

กำหนดค่า

Blast สามารถเปลี่ยนตัวเลือกการเริ่มต้นด้วยไฟล์กำหนดค่า ตัวแปรสภาพแวดล้อม และอาร์กิวเมนต์บรรทัดคำสั่ง
โปรดดูตารางต่อไปนี้สำหรับตัวเลือกที่สามารถกำหนดค่าได้

ธง CLI	ตัวแปรสภาพแวดล้อม	ไฟล์การกำหนดค่า	คำอธิบาย
--config-ไฟล์	-	-	ไฟล์กำหนดค่า หากละเว้น blast.yaml ใน /etc และโฮมไดเร็กทอรีจะถูกค้นหา
--รหัส	บลาสต์_ไอดี	รหัส	รหัสโหนด
--raft-address	BLAST_RAFT_ADDRESS	แพ_ที่อยู่	ที่อยู่การฟังเซิร์ฟเวอร์แพ
--grpc-address	BLAST_GRPC_ADDRESS	grpc_address	ที่อยู่การฟังของเซิร์ฟเวอร์ gRPC
--http-ที่อยู่	BLAST_HTTP_ADDRESS	http_address	ที่อยู่การฟังของเซิร์ฟเวอร์ HTTP
--data-ไดเรกทอรี	BLAST_DATA_DIRECTORY	data_directory	ไดเร็กทอรีข้อมูลที่เก็บดัชนีและบันทึกแพ
--ไฟล์การทำแผนที่	BLAST_MAPPING_FILE	mapping_file	เส้นทางไปยังไฟล์การแมปดัชนี
--peer-grpc-address	BLAST_PEER_GRPC_ADDRESS	peer_grpc_address	ฟังที่อยู่ของเซิร์ฟเวอร์ gRPC ที่มีอยู่ในคลัสเตอร์ที่เข้าร่วม
--ไฟล์ใบรับรอง	BLAST_CERTIFICATE_FILE	ใบรับรอง_ไฟล์	เส้นทางไปยังไฟล์ใบรับรอง TLS ของเซิร์ฟเวอร์ไคลเอ็นต์
--key-ไฟล์	BLAST_KEY_FILE	คีย์_ไฟล์	เส้นทางไปยังไฟล์คีย์ TLS ของเซิร์ฟเวอร์ไคลเอ็นต์
--ชื่อสามัญ	BLAST_COMMON_NAME	common_name	ชื่อสามัญของใบรับรอง
--cors-allowed-methods	BLAST_CORS_ALLOWED_วิธีการ	cors_allowed_methods	วิธีที่อนุญาต CORS (เช่น GET, PUT, DELETE, POST)
--cors-allowed-origins	BLAST_CORS_ALLOWED_ORIGINS	cors_allowed_origins	CORS อนุญาตต้นทาง (เช่น http://localhost:8080,http://localhost:80)
--cors-allowed-headers	BLAST_CORS_ALLOWED_HEADERS	cors_allowed_headers	ส่วนหัวที่อนุญาต CORS (เช่น content-type,x-some-key)
--บันทึกระดับ	BLAST_LOG_LEVEL	log_level	ระดับบันทึก
--log-file	BLAST_LOG_FILE	log_file	ไฟล์บันทึก
--log-max-size	BLAST_LOG_MAX_SIZE	log_max_size	ขนาดสูงสุดของไฟล์บันทึกในหน่วยเมกะไบต์
--log-max-การสำรองข้อมูล	BLAST_LOG_MAX_แบ็คอัพ	log_max_backups	จำนวนการสำรองไฟล์บันทึกสูงสุด
--log-max-age	BLAST_LOG_MAX_AGE	log_max_age	อายุสูงสุดของไฟล์บันทึกในหน่วยวัน
--บันทึกการบีบอัด	BLAST_LOG_COMPRESS	log_compress	บีบอัดไฟล์บันทึก

เริ่ม

การเริ่มต้นเซิร์ฟเวอร์นั้นง่ายดังนี้:

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

คุณสามารถรับข้อมูลโหนดได้ด้วยคำสั่งต่อไปนี้:

$ ./bin/blast node | jq .

หรือ URL ต่อไปนี้:

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

ผลลัพธ์ของคำสั่งข้างต้นคือ:

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

ตรวจสุขภาพ

คุณสามารถตรวจสอบสถานะความสมบูรณ์ของโหนดได้

$ ./bin/blast healthcheck | jq .

นอกจากนี้ยังมี REST API ต่อไปนี้ด้วย

พิสูจน์ความมีชีวิตชีวา

ตำแหน่งข้อมูลนี้จะคืนค่า 200 เสมอ และควรใช้เพื่อตรวจสอบความสมบูรณ์ของเซิร์ฟเวอร์

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

การสอบสวนความพร้อม

ตำแหน่งข้อมูลนี้จะส่งคืน 200 เมื่อเซิร์ฟเวอร์พร้อมที่จะให้บริการการรับส่งข้อมูล (เช่น ตอบสนองต่อแบบสอบถาม)

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

ใส่เอกสาร

หากต้องการใส่เอกสารให้ดำเนินการคำสั่งต่อไปนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

$ 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

รับเอกสาร

หากต้องการรับเอกสาร ให้ดำเนินการคำสั่งต่อไปนี้:

$ ./bin/blast get 1 | jq .

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

คุณสามารถเห็นผล ผลลัพธ์ของคำสั่งข้างต้นคือ:

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

ค้นหาเอกสาร

หากต้องการค้นหาเอกสาร ให้ดำเนินการคำสั่งต่อไปนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

คุณสามารถเห็นผล ผลลัพธ์ของคำสั่งข้างต้นคือ:

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

ลบเอกสาร

การลบเอกสาร ดำเนินการคำสั่งต่อไปนี้:

$ ./bin/blast delete 1

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

จัดทำดัชนีเอกสารเป็นกลุ่ม

หากต้องการจัดทำดัชนีเอกสารเป็นกลุ่ม ให้ดำเนินการคำสั่งต่อไปนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

ลบเอกสารเป็นกลุ่ม

หากต้องการลบเอกสารจำนวนมาก ให้ดำเนินการคำสั่งต่อไปนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

ทำให้เกิดคลัสเตอร์

Blast นั้นง่ายต่อการดึงคลัสเตอร์ขึ้นมา โหนดกำลังทำงานอยู่แล้ว แต่นั่นไม่ทนต่อข้อผิดพลาด หากคุณต้องการเพิ่มความทนทานต่อข้อผิดพลาด ให้เรียกโหนดข้อมูลเพิ่มอีก 2 โหนดดังนี้:

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

ตัวอย่างด้านบนแสดงโหนด Blast แต่ละโหนดที่ทำงานบนโฮสต์เดียวกัน ดังนั้นแต่ละโหนดจะต้องรับฟังบนพอร์ตที่ต่างกัน สิ่งนี้ไม่จำเป็นหากแต่ละโหนดทำงานบนโฮสต์ที่แตกต่างกัน

ซึ่งจะสั่งให้แต่ละโหนดใหม่เข้าร่วมโหนดที่มีอยู่ แต่ละโหนดจะจดจำคลัสเตอร์ที่เข้าร่วมเมื่อเริ่มต้น ดังนั้นคุณจึงมีคลัสเตอร์ 3 โหนด ด้วยวิธีนี้คุณสามารถทนต่อความล้มเหลวของ 1 โหนดได้ คุณสามารถตรวจสอบคลัสเตอร์ด้วยคำสั่งต่อไปนี้:

$ ./bin/blast cluster | jq .

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

คุณสามารถดูผลลัพธ์ในรูปแบบ JSON ผลลัพธ์ของคำสั่งข้างต้นคือ:

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

แนะนำโหนดในคลัสเตอร์จำนวนคี่ 3 ตัวขึ้นไป ในสถานการณ์ที่ล้มเหลว ข้อมูลสูญหายเป็นสิ่งที่หลีกเลี่ยงไม่ได้ ดังนั้นควรหลีกเลี่ยงการปรับใช้โหนดเดียว

ตัวอย่างข้างต้น โหนดเข้าร่วมกับคลัสเตอร์เมื่อเริ่มต้น แต่คุณยังสามารถรวมโหนดที่เริ่มต้นแล้วในโหมดสแตนด์อโลนเข้ากับคลัสเตอร์ในภายหลังได้ ดังนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

หากต้องการลบโหนดออกจากคลัสเตอร์ ให้ดำเนินการคำสั่งต่อไปนี้:

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

หรือคุณสามารถใช้ RESTful API ได้ดังนี้:

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

คำสั่งต่อไปนี้จัดทำดัชนีเอกสารไปยังโหนดใด ๆ ในคลัสเตอร์:

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

ดังนั้นคุณสามารถรับเอกสารจากโหนดที่ระบุโดยคำสั่งข้างต้นดังนี้:

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

คุณสามารถเห็นผล ผลลัพธ์ของคำสั่งข้างต้นคือ:

 value1

คุณยังสามารถรับเอกสารเดียวกันจากโหนดอื่นในคลัสเตอร์ได้ดังนี้:

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

คุณสามารถเห็นผล ผลลัพธ์ของคำสั่งข้างต้นคือ:

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

คุณสามารถสร้างอิมเมจคอนเทนเนอร์ Docker ได้ดังนี้:

$ make docker-build

ดึงอิมเมจคอนเทนเนอร์ Docker จาก docker.io

คุณยังสามารถใช้อิมเมจคอนเทนเนอร์ Docker ที่ลงทะเบียนแล้วใน docker.io ได้ดังนี้:

$ docker pull mosuka/blast:latest

ดู https://hub.docker.com/r/mosuka/blast/tags/

เริ่มที่นักเทียบท่า

ใช้งานโหนดข้อมูล Blast บน Docker เริ่มโหนด Blast ดังนี้:

$ 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

คุณสามารถรันคำสั่งในคอนเทนเนอร์นักเทียบท่าได้ดังนี้:

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

การรักษาความปลอดภัยระเบิด

Blast รองรับการเข้าถึง HTTPS ทำให้มั่นใจได้ว่าการสื่อสารทั้งหมดระหว่างไคลเอนต์และคลัสเตอร์ได้รับการเข้ารหัส

การสร้างใบรับรองและคีย์ส่วนตัว

วิธีหนึ่งในการสร้างทรัพยากรที่จำเป็นคือผ่าน openssl ตัวอย่างเช่น:

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

ตัวอย่างคลัสเตอร์ที่ปลอดภัย

การเริ่มต้นโหนดโดยเปิดใช้งาน HTTPS การเข้ารหัสแบบโหนดต่อโหนด และด้วยไฟล์การกำหนดค่าข้างต้น จะถือว่าใบรับรอง HTTPS X.509 และคีย์อยู่ที่เส้นทาง server.crt และ 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

คุณสามารถเข้าถึงคลัสเตอร์ได้โดยเพิ่มแฟล็ก เช่น คำสั่งต่อไปนี้:

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