IntruSearch – Domine pesquisas e otimize projetos

O IntruSearch é uma ferramenta poderosa que oferece muitos benefícios para os desenvolvedores que desejam trabalhar com o mecanismo de busca de código aberto, OpenSearch. Uma de suas principais vantagens é que ela (a ferramenta IntruSearch) simplifica o processo de consulta e manipulação de índices de pesquisa, tornando o seu uso fácil, mesmo para iniciantes.

O Intrusearch pode economizar aos desenvolvedores uma quantidade significativa de tempo e esforço, além de ajudá-los a melhorar suas habilidades de programação de projetos em Go ao trabalhar com uma biblioteca poderosa e intuitiva.

Outra grande vantagem do IntruSearch é sua compatibilidade com a versão mais recente do OpenSearch. Isso significa que os desenvolvedores podem confiar no IntruSearch para seus projetos relacionados ao OpenSearch e podem confiar que ele funcionará perfeitamente com sua base de código existente.

Nota: a versão mais recente do OpenSearch foi considerada até o dia da publicação dessa postagem.

O IntruSearch está constantemente sendo aprimorado e atualizado, o que garante que ele continue sendo uma ferramenta confiável e atualizada para trabalhar com o OpenSearch.

Além disso, o IntruSearch oferece excelente desempenho e estabilidade, o que o torna uma escolha confiável para aplicações de alto tráfego e sistemas críticos. Isso se deve, em parte, à sua API simplificada e eficiente, que minimiza a quantidade de sobrecarga e tráfego de rede necessários para cada solicitação.

Em geral, o IntruSearch é uma excelente opção para os desenvolvedores que desejam trabalhar com o OpenSearch de maneira rápida, eficiente e confiável. Se você é um desenvolvedor experiente ou está apenas começando, o IntruSearch pode ajudá-lo a aproveitar ao máximo seus projetos OpenSearch e levar suas habilidades de programação para o próximo nível.

Nota: Para acessar o passo a passo de como instalar o IntruSearch, você pode seguir este link para a documentação no Github: [https://github.com/intruderlabs/intrusearch#installation]. Lá você encontrará instruções detalhadas sobre como baixar e instalar a ferramenta em diferentes sistemas operacionais, além de um guia passo a passo sobre como começar a usar o IntruSearch para seus projetos OpenSearch.

Mas na prática, será que vale mesmo a pena utilizar essa nova API? Observe abaixo a diferença entre a criação de índices sem o IntruSearch:

Criação de índice sem o IntruSearch:

O código abaixo apresenta um exemplo de criação de índice sem o uso do IntruSearch. Essa abordagem direta utiliza a biblioteca Go para interagir diretamente com o OpenSearch. O código mostra como configurar a conexão com o OpenSearch e criar um novo índice com mapeamento personalizado.

package main

import (
	"context"
	"fmt"
	"github.com/elastic/go-elasticsearch/v8"
	"log"
	"strings"
)

func main() {
	// Set up connection configuration with OpenSearch
	config := elasticsearch.Config{
		Addresses: []string{
			"http://localhost:9200", // OpenSearch URL
		},
	}

	// Create a new client
	client, err := elasticsearch.NewClient(config)
	if err != nil {
		log.Fatalf("Error creating the client: %s", err)
	}

	// Define the settings for the new index
	indexName := "my-new-index"
	mapping := `{
		"mappings": {
			"properties": {
				"title": {
					"type": "text"
				},
				"description": {
					"type": "text"
				},
				"publication_date": {
					"type": "date"
				}
			}
		}
	}`

	// Create the new index
	res, err := client.Indices.Create(
		indexName,
		client.Indices.Create.WithBody(strings.NewReader(mapping)),
		client.Indices.Create.WithContext(context.Background()),
	)
	if err != nil {
		log.Fatalf("Error creating the index: %s", err)
	}

	defer res.Body.Close()

	// Check if the index creation was successful
	if res.IsError() {
		log.Fatalf("Error creating the index: %s", res.Status())
	}

	fmt.Printf("The index %s was successfully created!", indexName)
}

Criação de índice com o IntruSearch:

Já nesse exemplo abaixo, é apresentado um código para criar índices com o uso do IntruSearch. O código apresentado é muito mais simples, mostrando como criar um cliente de busca e criar um novo índice. A biblioteca IntruSearch abstrai a complexidade do processo de criação de índices, tornando-o mais fácil e intuitiva.

package main

import (
	intrusearch "github.com/intruderlabs/intrusearch/main"
)

func main() {
	client := NewSearchClient()
	client.CreateIndex("test")
}

func NewSearchClient() *intrusearch.Client {
	openSearchAddress := "http://127.0.0.1" // OpenSearch address
	awsSamLocal := true                     // is your environment development? (debug mode)

	client := intrusearch.NewClient(openSearchAddress, awsSamLocal) // instance for creating a new OpenSearch client

	return &client
}

Exemplo de pesquisa sem o IntruSearch:

Este é um exemplo de pesquisa de índice sem o IntruSearch. O exemplo mostra como realizar uma pesquisa em um índice diretamente no OpenSearch, usando Go. A pesquisa é feita enviando um pedido HTTP para a URL do OpenSearch, fornecendo o nome do índice e o corpo da pesquisa em formato JSON. Os resultados da pesquisa são analisados em uma estrutura de dados SearchResult que contém as fontes dos documentos que correspondem à pesquisa.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

type SearchResult struct {
	Hits struct {
		Hits []struct {
			Source json.RawMessage `json:"_source"`
		} `json:"hits"`
	} `json:"hits"`
}

func main() {
	// Set up connection configuration with OpenSearch
	url := "http://localhost:9200" // OpenSearch URL
	indexName := "my-new-index" // Name of the index to search in
	query := "search query" // The search query

	// Create the request body for the search
	requestBody := fmt.Sprintf(`{
		"query": {
			"multi_match": {
				"query": "%s",
				"fields": ["title", "description"]
			}
		}
	}`, query)

	// Make the HTTP request to search in the OpenSearch index
	resp, err := http.Post(fmt.Sprintf("%s/%s/_search", url, indexName), "application/json", strings.NewReader(requestBody))
	if err != nil {
		panic(err)
	}

	defer resp.Body.Close()

	// Parse the response body into a SearchResult struct
	var result SearchResult
	err = json.NewDecoder(resp.Body).Decode(&result)
	if err != nil {
		panic(err)
	}

	// Print out the results
	for _, hit := range result.Hits.Hits {
		fmt.Println(string(hit.Source))
	}
}

Exemplo de pesquisa de índice com o IntruSearch:

Este segundo exemplo mostra como realizar a mesma pesquisa usando o IntruSearch. A pesquisa é realizada através do método ClientSearchRequest fornecido pelo pacote intrusearch. A pesquisa é configurada para retornar resultados que correspondem a um determinado conteúdo usando a consulta content:*any content*.

package main

import (
	intrusearch "github.com/intruderlabs/intrusearch/main"
	"github.com/intruderlabs/intrusearch/main/infrastructure/requests"
    "github.com/intruderlabs/intrusearch/main/infrastructure/responses"
)

type SearchRequestExample struct {
	client intrusearch.ClientInterface
}

func (itself SearchRequestExample) FindContent(content string) responses.OsResponse {
	println("initialize findContent to keyword search")

	response, _ := itself.client.ClientSearchRequest(requests.OsSearchRequest{
		From:        10,
		Size:        10,
		QueryString: "content:*" + content + "*",
	})

	return response
}

func main() {
    search := SearchRequestExample{}
    search.FindContent("any content")
}

Se você está cansado de lidar com pesquisas manuais e quer otimizar seu fluxo de trabalho, o IntruSearch é a solução perfeita para você! Clique aqui.