blast

Dieses Projekt wurde von Phalanx übernommen.

Dieses Projekt wurde schon lange nicht mehr gepflegt.

Explosion

Blast ist ein in Go geschriebener Volltextsuch- und Indexierungsserver, der auf Bleve aufbaut.
Es stellt Funktionen über gRPC (HTTP/2 + Protokollpuffer) oder die traditionelle RESTful-API (HTTP/1.1 + JSON) bereit.
Blast implementiert einen Raft-Konsensalgorithmus von hashicorp/raft. Es erreicht einen Konsens über alle Knoten hinweg und stellt so sicher, dass jede am System vorgenommene Änderung an einem Quorum von Knoten oder überhaupt nicht vorgenommen wird. Blast erleichtert Programmierern die Entwicklung von Suchanwendungen mit erweiterten Funktionen.

Merkmale

• Volltextsuche/Indizierung
• Facettensuche
• Räumliche/georäumliche Suche
• Hervorhebung der Suchergebnisse
• Indexreplikation
• Cluster wird aufgerufen
• Eine benutzerfreundliche HTTP-API
• CLI ist verfügbar
• Docker-Container-Image ist verfügbar

Build-Abhängigkeiten installieren

Blast erfordert einige C/C++-Bibliotheken, wenn Sie cld2, icu, libstemmer oder leveldb aktivieren müssen. Die folgenden Abschnitte enthalten Anweisungen zum Erfüllen von Abhängigkeiten auf bestimmten Plattformen.

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

Bauen

Gebäudeexplosion wie folgt:

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

Wenn Sie GOOS oder GOARCH weglassen, wird die Binärdatei der von Ihnen verwendeten Plattform erstellt.
Wenn Sie die Zielplattform angeben möchten, legen Sie bitte die Umgebungsvariablen GOOS und GOARCH fest.

Linux

$ make GOOS=linux build

macOS

$ make GOOS=darwin build

Windows

$ make GOOS=windows build

Erstellen Sie mit Erweiterungen

Blast unterstützt einige Bleve-Erweiterungen (blevex). Wenn Sie damit bauen möchten, legen Sie bitte CGO_LDFLAGS, CGO_CFLAGS, CGO_ENABLED und BUILD_TAGS fest. Erstellen Sie LevelDB beispielsweise wie folgt so, dass es für die Indexspeicherung verfügbar ist:

$ 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

Flaggen bauen

In der folgenden Tabelle finden Sie die Build-Flags der unterstützten Bleve-Erweiterungen:

BUILD_TAGS	CGO_ENABLED	Beschreibung
cld2	1	Aktivieren Sie den kompakten Sprachdetektor
kagome	0	Aktivieren Sie den japanischen Sprachanalysator
icu	1	Aktivieren Sie ICU Tokenizer und Thai Language Analyzer
libstemmer	1	Sprach-Stemmer aktivieren (Dänisch, Deutsch, Englisch, Spanisch, Finnisch, Französisch, Ungarisch, Italienisch, Niederländisch, Norwegisch, Portugiesisch, Rumänisch, Russisch, Schwedisch, Türkisch)

Wenn Sie die Funktion aktivieren möchten, deren CGO_ENABLE 1 ist, installieren Sie sie bitte unter Bezugnahme auf den Abschnitt „Build-Abhängigkeiten installieren“ oben.

Binär

Sie können die Binärdatei nach erfolgreicher Erstellung wie folgt sehen:

$ ls ./bin
blast

Prüfen

Wenn Sie Ihre Änderungen testen möchten, führen Sie den folgenden Befehl aus:

$ make test

Wenn Sie die Zielplattform angeben möchten, legen Sie die Umgebungsvariablen GOOS und GOARCH auf die gleiche Weise wie beim Build fest.

Paket

Um ein Distributionspaket zu erstellen, führen Sie den folgenden Befehl aus:

$ make dist

Konfigurieren

Blast kann seine Startoptionen mit Konfigurationsdateien, Umgebungsvariablen und Befehlszeilenargumenten ändern.
Die konfigurierbaren Optionen finden Sie in der folgenden Tabelle.

CLI-Flag	Umgebungsvariable	Konfigurationsdatei	Beschreibung
--config-Datei	-	-	config-Datei. Wenn es weggelassen wird, wird „blast.yaml“ in /etc und im Home-Verzeichnis durchsucht
--Ausweis	BLAST_ID	Ausweis	Knoten-ID
--raft-address	BLAST_RAFT_ADDRESS	Raft_Adresse	Abhöradresse des Raft-Servers
--grpc-Adresse	BLAST_GRPC_ADDRESS	grpc_address	gRPC-Server-Abhöradresse
--http-Adresse	BLAST_HTTP_ADDRESS	http_address	Abhöradresse des HTTP-Servers
--data-directory	BLAST_DATA_DIRECTORY	Datenverzeichnis	Datenverzeichnis, in dem der Index und die Raft-Protokolle gespeichert sind
--mapping-file	BLAST_MAPPING_FILE	Mapping_Datei	Pfad zur Indexzuordnungsdatei
--peer-grpc-address	BLAST_PEER_GRPC_ADDRESS	peer_grpc_address	Abhöradresse des vorhandenen gRPC-Servers im beitretenden Cluster
--certificate-file	BLAST_CERTIFICATE_FILE	Zertifikatsdatei	Pfad zur Client-Server-TLS-Zertifikatdatei
--key-file	BLAST_KEY_FILE	key_file	Pfad zur TLS-Schlüsseldatei des Client-Servers
--common-name	BLAST_COMMON_NAME	allgemeiner_name	Allgemeiner Name des Zertifikats
--cors-allowed-methods	BLAST_CORS_ALLOWED_METHODS	cors_allowed_methods	CORS erlaubte Methoden (z. B. GET, PUT, DELETE, POST)
--cors-allowed-origins	BLAST_CORS_ALLOWED_ORIGINS	cors_allowed_origins	CORS erlaubte Ursprünge (z. B. http://localhost:8080,http://localhost:80)
--cors-allowed-headers	BLAST_CORS_ALLOWED_HEADERS	cors_allowed_headers	CORS erlaubte Header (z. B. Content-Type, X-Some-Key)
--log-level	BLAST_LOG_LEVEL	log_level	Protokollebene
--log-Datei	BLAST_LOG_FILE	log_file	Protokolldatei
--log-max-size	BLAST_LOG_MAX_SIZE	log_max_size	Maximale Größe einer Protokolldatei in Megabyte
--log-max-backups	BLAST_LOG_MAX_BACKUPS	log_max_backups	Maximale Anzahl an Backups von Protokolldateien
--log-max-age	BLAST_LOG_MAX_AGE	log_max_age	Maximales Alter einer Protokolldatei in Tagen
--log-compress	BLAST_LOG_COMPRESS	log_compress	Komprimieren Sie eine Protokolldatei

Start

Das Starten des Servers geht ganz einfach wie folgt:

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

Sie können die Knoteninformationen mit dem folgenden Befehl abrufen:

$ ./bin/blast node | jq .

oder die folgende URL:

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

Das Ergebnis des obigen Befehls ist:

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

Gesundheitscheck

Sie können den Gesundheitsstatus des Knotens überprüfen.

$ ./bin/blast healthcheck | jq .

Stellt außerdem die folgenden REST-APIs bereit

Lebendigkeit beweisen

Dieser Endpunkt gibt immer 200 zurück und sollte zur Überprüfung des Serverzustands verwendet werden.

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

Bereitschaftssonde

Dieser Endpunkt gibt 200 zurück, wenn der Server bereit ist, Datenverkehr zu verarbeiten (d. h. auf Anfragen zu antworten).

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

Legen Sie ein Dokument ein

Um ein Dokument einzufügen, führen Sie den folgenden Befehl aus:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

oder

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

Holen Sie sich ein Dokument

Um ein Dokument abzurufen, führen Sie den folgenden Befehl aus:

$ ./bin/blast get 1 | jq .

Oder Sie können die RESTful-API wie folgt verwenden:

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

Sie können das Ergebnis sehen. Das Ergebnis des obigen Befehls ist:

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

Dokumente durchsuchen

Um Dokumente zu durchsuchen, führen Sie den folgenden Befehl aus:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

Sie können das Ergebnis sehen. Das Ergebnis des obigen Befehls ist:

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

Ein Dokument löschen

Um ein Dokument zu löschen, führen Sie den folgenden Befehl aus:

$ ./bin/blast delete 1

Oder Sie können die RESTful-API wie folgt verwenden:

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

Indizieren Sie Dokumente in großen Mengen

Um Dokumente in großen Mengen zu indizieren, führen Sie den folgenden Befehl aus:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

Löschen Sie Dokumente in großen Mengen

Um Dokumente in großen Mengen zu löschen, führen Sie den folgenden Befehl aus:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

Einen Cluster aufrufen

Blast ist einfach, den Cluster hochzufahren. Der Knoten läuft bereits, aber das ist nicht fehlertolerant. Wenn Sie die Fehlertoleranz erhöhen müssen, rufen Sie zwei weitere Datenknoten auf, etwa so:

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

Das obige Beispiel zeigt, dass jeder Blast-Knoten auf demselben Host läuft, sodass jeder Knoten unterschiedliche Ports überwachen muss. Dies wäre nicht notwendig, wenn jeder Knoten auf einem anderen Host laufen würde.

Dadurch wird jeder neue Knoten angewiesen, einem vorhandenen Knoten beizutreten. Jeder Knoten erkennt beim Start die beitretenden Cluster. Sie haben also einen 3-Knoten-Cluster. Auf diese Weise können Sie den Ausfall eines Knotens tolerieren. Sie können den Cluster mit dem folgenden Befehl überprüfen:

$ ./bin/blast cluster | jq .

Oder Sie können die RESTful-API wie folgt verwenden:

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

Sie können das Ergebnis im JSON-Format sehen. Das Ergebnis des obigen Befehls ist:

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

Empfehlen Sie 3 oder mehr ungerade Anzahl von Knoten im Cluster. In Fehlerszenarien ist ein Datenverlust unvermeidlich. Vermeiden Sie daher die Bereitstellung einzelner Knoten.

Im obigen Beispiel verbindet sich der Knoten beim Start mit dem Cluster. Sie können den Knoten, der bereits im Standalone-Modus gestartet wurde, jedoch auch später wie folgt mit dem Cluster verbinden:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

Um einen Knoten aus dem Cluster zu entfernen, führen Sie den folgenden Befehl aus:

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

Oder Sie können die RESTful-API wie folgt verwenden:

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

Der folgende Befehl indiziert Dokumente für jeden Knoten im 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 .

Sie können das Dokument also wie folgt von dem durch den obigen Befehl angegebenen Knoten abrufen:

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

Sie können das Ergebnis sehen. Das Ergebnis des obigen Befehls ist:

 value1

Sie können dasselbe Dokument auch wie folgt von anderen Knoten im Cluster abrufen:

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

Sie können das Ergebnis sehen. Das Ergebnis des obigen Befehls ist:

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

Erstellen Sie ein Docker-Container-Image

Sie können das Docker-Container-Image wie folgt erstellen:

$ make docker-build

Ziehen Sie das Docker-Container-Image von docker.io

Sie können auch das bereits in docker.io registrierte Docker-Container-Image wie folgt verwenden:

$ docker pull mosuka/blast:latest

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

Beginnen Sie mit Docker

Ausführen eines Blast-Datenknotens auf Docker. Starten Sie den Blast-Knoten wie folgt:

$ 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

Sie können den Befehl im Docker-Container wie folgt ausführen:

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

Explosion sichern

Blast unterstützt HTTPS-Zugriff und stellt so sicher, dass die gesamte Kommunikation zwischen Clients und einem Cluster verschlüsselt ist.

Generieren eines Zertifikats und eines privaten Schlüssels

Eine Möglichkeit, die notwendigen Ressourcen zu generieren, ist openSSL. Zum Beispiel:

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

Beispiel für einen sicheren Cluster

Starten eines Knotens mit aktiviertem HTTPS, Knoten-zu-Knoten-Verschlüsselung und der oben genannten Konfigurationsdatei. Es wird davon ausgegangen, dass sich das HTTPS-X.509-Zertifikat und der Schlüssel in den Pfaden server.crt bzw. key.pem befinden.

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

Sie können auf den Cluster zugreifen, indem Sie ein Flag hinzufügen, z. B. den folgenden Befehl:

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

oder

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