OpenSearch

https://docs.opensearch.org/3.3
Admin
OpenSearch is a highly scalable and extensible open-source software suite for search, analytics,...
Tokens:3,341,482
Snippets:20,598
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### OpenSearch CLI: Installation and Setup

Source: https://docs.opensearch.org/3.3/tools/cli

Provides commands for installing and setting up the OpenSearch CLI. This includes making the executable, adding it to the system's PATH, and verifying the installation.

```bash
chmod +x ./opensearch-cli
export PATH=$PATH:$(pwd)
opensearch-cli --version
```

--------------------------------

### Initialize Go Project and Install Client

Source: https://docs.opensearch.org/3.3/clients/go

Commands to initialize a new Go module and install the OpenSearch Go client dependency via go get.

```bash
go mod init <mymodulename>
go get github.com/opensearch-project/opensearch-go
```

--------------------------------

### Initialize and Test OpenSearch with Security Enabled

Source: https://docs.opensearch.org/3.3/opensearch/install/tar

Commands to navigate to the installation directory, start the OpenSearch service using the demo security script, and verify the node status and installed plugins using cURL.

```bash
cd /path/to/opensearch-3.3.2
export OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password>
./opensearch-tar-install.sh
curl -X GET https://localhost:9200 -u 'admin:<custom-admin-password>' --insecure
curl -X GET https://localhost:9200/_cat/plugins?v -u 'admin:<custom-admin-password>' --insecure
```

--------------------------------

### OpenSearch CLI: Detector Management Example

Source: https://docs.opensearch.org/3.3/tools/cli

Demonstrates moving an Anomaly Detection detector from a staging to a production cluster using opensearch-cli commands. This involves getting the detector configuration, creating it on the new cluster, starting it, and cleaning up.

```bash
opensearch-cli ad get ecommerce-count-quantity --profile staging > ecommerce-count-quantity.json
opensearch-cli ad create ecommerce-count-quantity.json --profile production
opensearch-cli ad start ecommerce-count-quantity.json --profile production
opensearch-cli ad stop ecommerce-count-quantity --profile staging
opensearch-cli ad delete ecommerce-count-quantity --profile staging
```

--------------------------------

### Install OpenSearch Dashboards using APT

Source: https://docs.opensearch.org/3.3/install-and-configure/install-dashboards/debian

Installs OpenSearch Dashboards from an APT repository. This involves updating package lists, importing a GPG key, adding the repository, and then installing the package. It also covers enabling and starting the service.

```bash
sudo apt-get update && sudo apt-get -y install lsb-release ca-certificates curl gnupg2
```

```bash
curl -o- https://artifacts.opensearch.org/publickeys/opensearch-release.pgp | sudo gpg --dearmor --batch --yes -o /etc/apt/keyrings/opensearch-release-keyring
```

```bash
echo "deb [signed-by=/etc/apt/keyrings/opensearch-release-keyring] https://artifacts.opensearch.org/releases/bundle/opensearch-dashboards/3.x/apt stable main" | sudo tee /etc/apt/sources.list.d/opensearch-dashboards-3.x.list
```

```bash
sudo apt-get update
```

```bash
sudo apt-get update --allow-releaseinfo-change
```

```bash
sudo apt list -a opensearch-dashboards
```

```bash
sudo apt-get install opensearch-dashboards
```

```bash
# Specify the version manually using opensearch=<version>
sudo apt-get install opensearch-dashboards=3.3.0
```

```bash
sudo systemctl enable opensearch-dashboards
```

```bash
sudo systemctl start opensearch-dashboards
```

```bash
sudo systemctl status opensearch-dashboards
```

--------------------------------

### Get Aliases Based on Wildcard (REST, Python)

Source: https://docs.opensearch.org/3.3/api-reference/alias/get-alias

Demonstrates how to retrieve aliases that match a wildcard pattern. This example shows how to get all aliases starting with '20'. This is useful for managing or querying multiple related aliases efficiently. Both REST and Python client examples are provided.

```REST
GET /_alias/20*
```

```Python
response = client.indices.get_alias(
  name = "20*"
)
```

--------------------------------

### Test OpenSearch Installation with cURL

Source: https://docs.opensearch.org/3.3/install-and-configure/install-opensearch/debian

Verify that your OpenSearch installation is running by sending GET requests to the default port 9200. This command uses the '--insecure' flag due to self-signed TLS certificates, which is common in initial setups. It requires admin credentials and returns cluster information.

```bash
curl -X GET https://localhost:9200 -u 'admin:<custom-admin-password>' --insecure
```

--------------------------------

### Run Data Prepper Docker Image (Initial Example)

Source: https://docs.opensearch.org/3.3/clients/data-prepper/get-started

An initial example command to run the Data Prepper Docker image, mounting a 'pipelines.yaml' file. This command is a simpler version and might be for older configurations or specific use cases before detailed versioning was introduced.

```bash
docker run --name data-prepper \
    -v /${PWD}/pipelines.yaml:/usr/share/data-prepper/pipelines/pipelines.yaml \
    opensearchproject/data-prepper:latest
```

--------------------------------

### Example Response for Get Snapshot API

Source: https://docs.opensearch.org/3.3/api-reference/snapshots/get-snapshot

This is an example of a successful response from the OpenSearch Get Snapshot API, detailing the information returned about a snapshot, including its state, indices, and timing.

```json
{
  "snapshots" : [
    {
      "snapshot" : "my-first-snapshot",
      "uuid" : "3P7Qa-M8RU6l16Od5n7Lxg",
      "version_id" : 136217927,
      "version" : "2.0.1",
      "indices" : [
        ".opensearch-observability",
        ".opendistro-reports-instances",
        ".opensearch-notifications-config",
        "shakespeare",
        ".opendistro-reports-definitions",
        "opensearch_dashboards_sample_data_flights",
        ".kibana_1"
      ],
      "data_streams" : [ ],
      "include_global_state" : true,
      "state" : "SUCCESS",
      "start_time" : "2022-08-11T20:30:00.399Z",
      "start_time_in_millis" : 1660249800399,
      "end_time" : "2022-08-11T20:30:14.851Z",
      "end_time_in_millis" : 1660249814851,
      "duration_in_millis" : 14452,
      "failures" : [ ],
      "shards" : {
        "total" : 7,
        "failed" : 0,
        "successful" : 7
      }
    }
  ]
}
```

--------------------------------

### Verify OpenSearch Benchmark Installation

Source: https://docs.opensearch.org/3.3/benchmark/quickstart

Executes the help command to ensure the benchmark tool is correctly installed and accessible in the system path.

```bash
opensearch-benchmark --help
```

--------------------------------

### Example Get Index API Response (OpenSearch)

Source: https://docs.opensearch.org/3.3/api-reference/index-apis/get-index

This is an example of the JSON response returned by the OpenSearch Get Index API when querying for index details. It includes information about aliases, mappings, and settings.

```JSON
{
  "sample-index1": {
    "aliases": {},
    "mappings": {},
    "settings": {
      "index": {
        "creation_date": "1633044652108",
        "number_of_shards": "2",
        "number_of_replicas": "1",
        "uuid": "XcXA0aZ5S0aiqx3i1Ce95w",
        "version": {
          "created": "135217827"
        },
        "provided_name": "sample-index1"
      }
    }
  }
}
```

--------------------------------

### Install Multiple OpenSearch Plugins

Source: https://docs.opensearch.org/3.3/install-and-configure/install-opensearch/plugins

Installs multiple OpenSearch plugins in a single command invocation. This is useful for installing several plugins at once, streamlining the setup process.

```bash
bin/opensearch-plugin install <plugin-name> <plugin-name> ... <plugin-name>
```

```bash
$ sudo ./opensearch-plugin install analysis-nori repository-s3
```

--------------------------------

### Initialize OpenSearch Client

Source: https://docs.opensearch.org/3.3/clients/javascript/index

Examples for establishing a connection to an OpenSearch cluster. Includes configurations for secure connections with SSL/TLS and basic authentication, as well as standard unauthenticated connections.

```javascript
const { Client } = require("@opensearch-project/opensearch");
const fs = require("fs");

// Secure connection with Security plugin
const clientSecure = new Client({
  node: "https://admin:<password>@localhost:9200",
  ssl: {
    ca: fs.readFileSync("/full/path/to/root-ca.pem")
  }
});

// Standard connection without Security plugin
const clientStandard = new Client({
  node: "http://localhost:9200"
});
```

--------------------------------

### Initialize and Perform CRUD with OpenSearch Java Client

Source: https://docs.opensearch.org/3.3/clients/java-rest-high-level

This example shows how to set up an authenticated connection to an OpenSearch cluster, create a custom index with specific shard and replica settings, index a document, retrieve it, and perform cleanup by deleting the document and index.

```java
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.opensearch.action.admin.indices.delete.DeleteIndexRequest;
import org.opensearch.action.delete.DeleteRequest;
import org.opensearch.action.delete.DeleteResponse;
import org.opensearch.action.get.GetRequest;
import org.opensearch.action.get.GetResponse;
import org.opensearch.action.index.IndexRequest;
import org.opensearch.action.index.IndexResponse;
import org.opensearch.action.support.master.AcknowledgedResponse;
import org.opensearch.client.RequestOptions;
import org.opensearch.client.RestClient;
import org.opensearch.client.RestClientBuilder;
import org.opensearch.client.RestHighLevelClient;
import org.opensearch.client.indices.CreateIndexRequest;
import org.opensearch.client.indices.CreateIndexResponse;
import org.opensearch.common.settings.Settings;
import java.io.IOException;
import java.util.HashMap;

public class RESTClientSample {
  public static void main(String[] args) throws IOException {
    System.setProperty("javax.net.ssl.trustStore", "/full/path/to/keystore");
    System.setProperty("javax.net.ssl.trustStorePassword", "password-to-keystore");
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("admin", "admin"));
    RestClientBuilder builder = RestClient.builder(new HttpHost("localhost", 9200, "https"))
      .setHttpClientConfigCallback(httpClientBuilder -> httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
    RestHighLevelClient client = new RestHighLevelClient(builder);
    CreateIndexRequest createIndexRequest = new CreateIndexRequest("custom-index");
    createIndexRequest.settings(Settings.builder().put("index.number_of_shards", 4).put("index.number_of_replicas", 3));
    HashMap<String, String> typeMapping = new HashMap<>();
    typeMapping.put("type", "integer");
    HashMap<String, Object> ageMapping = new HashMap<>();
    ageMapping.put("age", typeMapping);
    HashMap<String, Object> mapping = new HashMap<>();
    mapping.put("properties", ageMapping);
    createIndexRequest.mapping(mapping);
    CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
    IndexRequest request = new IndexRequest("custom-index").id("1");
    HashMap<String, String> stringMapping = new HashMap<>();
    stringMapping.put("message:", "Testing Java REST client");
    request.source(stringMapping);
    IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
    GetRequest getRequest = new GetRequest("custom-index", "1");
    GetResponse response = client.get(getRequest, RequestOptions.DEFAULT);
    System.out.println(response.getSourceAsString());
    client.delete(new DeleteRequest("custom-index", "1"), RequestOptions.DEFAULT);
    client.indices().delete(new DeleteIndexRequest("custom-index"), RequestOptions.DEFAULT);
    client.close();
  }
}
```

--------------------------------

### Running the Demo Batch Script

Source: https://docs.opensearch.org/3.3/install-and-configure/install-opensearch/windows

Instructions on how to run the OpenSearch Windows install batch script, including setting a custom admin password.

```APIDOC
## Running the Demo Batch Script

### Description
This section details how to execute the OpenSearch installation batch script for Windows, including setting a custom admin password.

### Steps
1. Open Command Prompt or PowerShell.
2. Navigate to the OpenSearch installation directory.
   ```
   cd \path\to\opensearch-3.3.2
   ```
3. Set the custom admin password environment variable (replace `<custom-admin-password>` with your desired password):
   ```
   > set OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password>
   ```
4. Run the batch script:
   ```
   .\opensearch-windows-install.bat
   ```
```

--------------------------------

### Start OpenSearch Dashboards (Tarball)

Source: https://docs.opensearch.org/3.3/security/configuration/disable-enable-security

Command to start OpenSearch Dashboards after installation or configuration changes when using a tarball distribution.

```bash
./bin/opensearch-dashboards
```

--------------------------------

### OpenSearch CLI: General Usage and Help

Source: https://docs.opensearch.org/3.3/tools/cli

Demonstrates the basic syntax for OpenSearch CLI commands and how to access help information. This includes retrieving detector information, querying the CAT API, and viewing command-specific help.

```bash
opensearch-cli <command> <subcommand> <flags>
opensearch-cli ad get my-detector --profile docker-local
opensearch-cli curl get --path _cat/plugins --profile aws
opensearch-cli -h
opensearch-cli ad -h
opensearch-cli ad get -h
```

--------------------------------

### Install HDFS Plugin via Dockerfile

Source: https://docs.opensearch.org/3.3/opensearch/snapshots/snapshot-restore

Example Dockerfile snippet to install the HDFS repository plugin during OpenSearch image build.

```dockerfile
FROM opensearchproject/opensearch:3.3.2

RUN /usr/share/opensearch/bin/opensearch-plugin install --batch repository-hdfs
```

--------------------------------

### Start OpenSearch Dashboards (RPM/Debian)

Source: https://docs.opensearch.org/3.3/security/configuration/disable-enable-security

Command to start the OpenSearch Dashboards service using systemctl, typically used in RPM or Debian-based installations.

```bash
sudo systemctl start opensearch-dashboards
```

--------------------------------

### Initialize and Test OpenSearch with Demo Security

Source: https://docs.opensearch.org/3.3/install-and-configure/install-opensearch/tar

Commands to navigate to the installation directory, set the admin password, and start the OpenSearch service using the demo security configuration.

```bash
cd /path/to/opensearch-3.3.2
export OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password>
./opensearch-tar-install.sh
```

--------------------------------

### Get Verbose Output for Aliases

Source: https://docs.opensearch.org/3.3/api-reference/cat/index

Example of using the `v` query parameter to get verbose output for the `_cat/aliases` operation, including all column headings.

```APIDOC
## GET /_cat/aliases?v

### Description
Retrieves alias information with verbose output, including all column headers.

### Method
GET

### Endpoint
/_cat/aliases?v

### Query Parameters
- **v** (boolean) - Required - Enables verbose output.

### Response
#### Success Response (200)
- **body** (string) - Tabular data of aliases with headers.

### Response Example
```
alias index filter routing.index routing.search is_write_index
.kibana .kibana_1 - - - -
sample-alias1 sample-index-1 - - - -
```
```

--------------------------------

### Start OpenSearch Dashboards

Source: https://docs.opensearch.org/3.3/install-and-configure/install-dashboards/tar

Execute the binary to start the OpenSearch Dashboards service.

```bash
./bin/opensearch-dashboards
```

--------------------------------

### Installing OpenSearch RPM with Demo Configuration

Source: https://docs.opensearch.org/3.3/security/configuration/demo-configuration

Command to install the OpenSearch RPM package, which includes the demo configuration setup. For versions 2.12+, the custom admin password can be provided during installation using the 'env' command.

```bash
sudo yum install opensearch-3.3.2-linux-x64.rpm
```

```bash
sudo env OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password> yum install opensearch-3.3.2-linux-x64.rpm
```

--------------------------------

### Configure Data Prepper Pipeline with SSL and Authentication

Source: https://docs.opensearch.org/3.3/data-prepper/common-use-cases/log-analytics

A YAML-based configuration example for a Data Prepper pipeline. It demonstrates setting up an HTTP source with SSL and basic authentication, a Grok processor for parsing Apache logs, and an OpenSearch sink for data storage.

```yaml
log-pipeline:
  source:
    http:
      ssl_certificate_file: "/full/path/to/certfile.crt"
      ssl_key_file: "/full/path/to/keyfile.key"
      authentication:
        http_basic:
          username: "myuser"
          password: "mys3cret"
  processor:
    - grok:
        match:
          log: [ "%{COMMONAPACHELOG}" ]
  sink:
    - opensearch:
        hosts: [ "https://localhost:9200" ]
        username: "admin"
        password: "admin"
        index: "apache_logs"
```

--------------------------------

### Sample Program: Full OpenSearch Workflow with Python

Source: https://docs.opensearch.org/3.3/clients/python-high-level

A comprehensive Python script demonstrating client creation, index creation with settings, document insertion, bulk operations, searching, document deletion, and index deletion.

```python
from opensearchpy import OpenSearch
from opensearch_dsl import Search, Document, Text, Keyword

host = 'localhost'
port = 9200

auth = ('admin', 'admin')  # For testing only. Don't store credentials in code.
ca_certs_path = 'root-ca.pem'

# Create the client with SSL/TLS enabled, but hostname verification disabled.
client = OpenSearch(
    hosts=[{'host': host, 'port': port}],
    http_compress=True,  # enables gzip compression for request bodies
    # http_auth=auth,
    use_ssl=False,
    verify_certs=False,
    ssl_assert_hostname=False,
    ssl_show_warn=False,
    # ca_certs=ca_certs_path
)
index_name = 'my-dsl-index'

index_body = {
  'settings': {
    'index': {
      'number_of_shards': 4
    }
  }
}

response = client.indices.create(index_name, index_body)
print('\nCreating index:')
print(response)

# Create the structure of the document
class Movie(Document):
    title = Text(fields={'raw': Keyword()})
    director = Text()
    year = Text()

    class Index:
        name = index_name

    def save(self, ** kwargs):
        return super(Movie, self).save(** kwargs)

# Set up the opensearch-py version of the document
Movie.init(using=client)
doc = Movie(meta={'id': 1}, title='Moneyball', director='Bennett Miller', year='2011')
response = doc.save(using=client)

print('\nAdding document:')
print(response)

# Perform bulk operations

movies = '{ "index" : { "_index" : "my-dsl-index", "_id" : "2" } } \n { "title" : "Interstellar", "director" : "Christopher Nolan", "year" : "2014"} \n { "create" : { "_index" : "my-dsl-index", "_id" : "3" } } \n { "title" : "Star Trek Beyond", "director" : "Justin Lin", "year" : "2015"} \n { "update" : {"_id" : "3", "_index" : "my-dsl-index" } } \n { "doc" : {"year" : "2016"} }'

client.bulk(movies)

# Search for the document.
s = Search(using=client, index=index_name) \
    .filter('term', year='2011') \
    .query('match', title='Moneyball')

response = s.execute()

print('\nSearch results:')
for hit in response:
    print(hit.meta.score, hit.title)
    
# Delete the document.
print('\nDeleting document:')
print(response)

# Delete the index.
response = client.indices.delete(
    index = index_name
)

print('\nDeleting index:')
print(response)

```

--------------------------------

### Example Generated Token Sequence

Source: https://docs.opensearch.org/3.3/benchmark/features/synthetic-data-generation/generating-vectors

An example output structure showing how token IDs and their corresponding weights are represented when using specific start and step configurations.

```JSON
{
  "1000": 0.3421,
  "1100": 0.5234,
  "1200": 0.7821,
  "1300": 0.1523,
  "1400": 0.9102
}
```

--------------------------------

### Full OpenSearch Ruby Client Operations Sample

Source: https://docs.opensearch.org/3.3/clients/ruby

A comprehensive example demonstrating index creation, mapping, CRUD operations, bulk indexing, multi-match searching, and scrolling through results.

```ruby
require 'opensearch'

client = OpenSearch::Client.new(host: 'http://localhost:9200')

# Create an index with non-default settings
index_name = 'students'
index_body = {
    'settings': {
      'index': {
        'number_of_shards': 1,
        'number_of_replicas': 2 
      }
    }
  } 

client.indices.create(
    index: index_name,
    body: index_body
)

# Create a mapping
client.indices.put_mapping(
    index: index_name, 
    body: {
        properties: {
            first_name: { type: 'keyword' },
            last_name: { type: 'keyword' }
        }  
    }
)

# Get mappings
response = client.indices.get_mapping(index: index_name)
puts 'Mappings for the students index:'
puts MultiJson.dump(response, pretty: "true")

# Add one document to the index
puts 'Adding one document:'
document = {
    first_name: 'Connor',
    last_name: 'James',
    gpa: 3.93,
    grad_year: 2021
}
id = 100
  
client.index(
    index: index_name,
    body: document,
    id: id,
    refresh: true
)
  
response = client.search(index: index_name)
puts MultiJson.dump(response, pretty: "true")
  
# Update a document
puts 'Updating a document:'
client.update(index: index_name, id: id, body: { doc: { gpa: 3.25 } }, refresh: true)
response = client.search(index: index_name)
puts MultiJson.dump(response, pretty: "true")
print 'The updated gpa is '
puts response['hits']['hits'].map { |doc| doc['_source']['gpa'] }

# Add many documents in bulk
documents = [
{ index: { _index: index_name, _id: '200' } },
{ first_name: 'James', last_name: 'Rodriguez', gpa: 3.91, grad_year: 2019},
{ index: { _index: index_name, _id: '300' } },
{ first_name: 'Nikki', last_name: 'Wolf', gpa: 3.87, grad_year: 2020}
]
client.bulk(body: documents, refresh: true)

# Get all documents in the index
response = client.search(index: index_name)
puts 'All documents in the index after bulk upload:'
puts MultiJson.dump(response, pretty: "true")

# Search for a document using a multi_match query
puts 'Searching for documents that match "James":'
q = 'James'
query = {
  'size': 5,
  'query': {
    'multi_match': {
      'query': q,
      'fields': ['first_name', 'last_name^2']
    }
  }
}

response = client.search(
  body: query,
  index: index_name
)
puts MultiJson.dump(response, pretty: "true")

# Delete the document
response = client.delete(
index: index_name,
id: id,
refresh: true
)

response = client.search(index: index_name)
puts 'Documents in the index after one document was deleted:'
puts MultiJson.dump(response, pretty: "true")

# Delete multiple documents
actions = [
    { delete: { _index: index_name, _id: 200 } },
    { delete: { _index: index_name, _id: 300 } }
]
client.bulk(body: actions, refresh: true)

response = client.search(index: index_name)

puts 'Documents in the index after all documents were deleted:'
puts MultiJson.dump(response, pretty: "true")

# Bulk several operations together
actions = [
    { index:  { _index: index_name, _id: 100, data: { first_name: 'Paulo', last_name: 'Santos', gpa: 3.29, grad_year: 2022 } } },
    { index:  { _index: index_name, _id: 200, data: { first_name: 'Shirley', last_name: 'Rodriguez', gpa: 3.92, grad_year: 2020 } } },
    { index:  { _index: index_name, _id: 300, data: { first_name: 'Akua', last_name: 'Mansa', gpa: 3.95, grad_year: 2022 } } },
    { index:  { _index: index_name, _id: 400, data: { first_name: 'John', last_name: 'Stiles', gpa: 3.72, grad_year: 2019 } } },
    { index:  { _index: index_name, _id: 500, data: { first_name: 'Li', last_name: 'Juan', gpa: 3.94, grad_year: 2022 } } },
    { index:  { _index: index_name, _id: 600, data: { first_name: 'Richard', last_name: 'Roe', gpa: 3.04, grad_year: 2020 } } },
    { update: { _index: index_name, _id: 100, data: { doc: { gpa: 3.73 } } } },
    { delete: { _index: index_name, _id: 200  } }
]
client.bulk(body: actions, refresh: true)

puts 'All documents in the index after bulk operations with scrolling:'
response = client.search(index: index_name, scroll: '2m', size: 2)

while response['hits']['hits'].size.positive?
    scroll_id = response['_scroll_id']
    puts(response['hits']['hits'].map { |doc| [doc['_source']['first_name'] + ' ' + doc['_source']['last_name']] })
    response = client.scroll(scroll: '1m', body: { scroll_id: scroll_id })
end

# Multi search
actions = [
    {},
    {query: {range: {gpa: {gt: 3.9}}}},
    {},
    {query: {range: {gpa: {lt: 3.1}}}}
]
response = client.msearch(index: index_name, body: actions)

puts 'Multi search results:'
puts MultiJson.dump(response, pretty: "true")
```

--------------------------------

### Navigate to Demos Folder (Shell)

Source: https://docs.opensearch.org/3.3/security/authentication-backends/saml

This command navigates the user to the demo folder within the downloaded OpenSearch SAML demo repository. It's a prerequisite for running the Docker example.

```shell
cd <path-to-demos-folder>/demo
```

--------------------------------

### GET /_plugins/_security/api/roles/

Source: https://docs.opensearch.org/3.3/api-reference/security/index

Example of retrieving security roles using the Security API.

```APIDOC
## GET /_plugins/_security/api/roles/

### Description
Retrieves the current configuration of security roles.

### Method
GET

### Endpoint
/_plugins/_security/api/roles/

### Request Example
```bash
curl -XGET https://localhost:9200/_plugins/_security/api/roles/ -u admin:admin -k
```

### Response
#### Success Response (200)
- **roles** (object) - A map of role definitions.

#### Response Example
```json
{
  "admin_role": {
    "cluster_permissions": ["*"],
    "index_permissions": [{
      "index_patterns": ["*"],
      "allowed_actions": ["*"]
    }]
  }
}
```
```

--------------------------------

### Kafka Buffer Configuration Example

Source: https://docs.opensearch.org/3.3/data-prepper/pipelines/configuration/buffers/kafka

This example demonstrates how to configure the Kafka buffer within an OpenSearch Data Prepper pipeline. It specifies the HTTP source, Kafka broker connection details, topic configuration, a grok processor, and a stdout sink. This setup is designed to run against a locally hosted Kafka cluster.

```yaml
kafka-buffer-pipeline:
  source:
    http:
  buffer:
    kafka:
      bootstrap_servers: ["localhost:9092"]
      encryption:
        type: none
      topics:
        - name: my-buffer-topic
          group_id: data-prepper
          create_topic: true
  processor:
    - grok:
        match:
          message: [ "%{{COMMONAPACHELOG}}" ]
  sink:
    - stdout:

```

--------------------------------

### Get Detector API - Request Example

Source: https://docs.opensearch.org/3.3/monitoring-plugins/ad/api

This is a sample GET request to retrieve all information about a specific detector using its ID. The `<detectorId>` should be replaced with the actual ID of the detector.

```http
GET _plugins/_anomaly_detection/detectors/<detectorId>
```

--------------------------------

### Install and Run OpenSearch

Source: https://docs.opensearch.org/3.3/vector-search/getting-started/index

Instructions to download and run a local OpenSearch instance using Docker for development and testing purposes.

```APIDOC
## Run OpenSearch with Docker

### Description
This command downloads the latest OpenSearch image and runs it as a single-node cluster. It exposes ports 9200 for HTTP traffic and 9600 for transport traffic. Security is disabled for simplicity.

### Method
N/A (Docker command)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```bash
docker pull opensearchproject/opensearch:latest && docker run -it -p 9200:9200 -p 9600:9600 -e "discovery.type=single-node" -e "DISABLE_SECURITY_PLUGIN=true" opensearchproject/opensearch:latest
```

### Response
OpenSearch will be running and accessible at `http://localhost:9200`.

#### Success Response (200)
```json
{
  "name" : "a937e018cee5",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "GLAjAG6bTeWErFUy_d-CLw",
  "version" : {
    "distribution" : "opensearch",
    "number" : "<version>",
    "build_type" : "<build-type>",
    "build_hash" : "<build-hash>",
    "build_date" : "<build-date>",
    "build_snapshot" : false,
    "lucene_version" : "<lucene-version>",
    "minimum_wire_compatibility_version" : "7.10.0",
    "minimum_index_compatibility_version" : "7.0.0"
  },
  "tagline" : "The OpenSearch Project: https://opensearch.org/"
}
```
```

--------------------------------

### Create OpenSearch Snapshot

Source: https://docs.opensearch.org/3.3/opensearch/snapshots/snapshot-restore

Demonstrates how to initiate a snapshot of the cluster state and indexes. Includes examples for basic snapshots and advanced configurations using index filters and completion waiting.

```HTTP
PUT /_snapshot/my-repository/1

PUT /_snapshot/my-repository/2
{
  "indices": "opensearch-dashboards*,my-index*,-my-index-2016",
  "ignore_unavailable": true,
  "include_global_state": false,
  "partial": false
}

PUT _snapshot/my-repository/3?wait_for_completion=true
```

--------------------------------

### Get Controller API Example Response (Success)

Source: https://docs.opensearch.org/3.3/ml-commons-plugin/api/controller-apis/get-controller

Example of a successful response when retrieving controller information. It returns the model ID and details about the user rate limiter.

```JSON
{
  "model_id": "T_S-cY0BKCJ3ot9qr0aP",
  "user_rate_limiter": {
    "user1": {
      "limit": "4",
      "unit": "MINUTES"
    },
    "user2": {
      "limit": "4",
      "unit": "MINUTES"
    }
  }
}
```

--------------------------------

### Full OpenSearch Client Program Example in Java

Source: https://docs.opensearch.org/3.3/clients/java

This comprehensive Java program demonstrates a full lifecycle of interacting with OpenSearch. It includes client initialization with authentication and SSL, creating an index, setting index configurations, indexing a document, searching for it, deleting the document, and finally deleting the index. It handles potential IOExceptions during operations.

```java
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.opensearch.client.RestClient;
import org.opensearch.client.RestClientBuilder;
import org.opensearch.client.base.RestClientTransport;
import org.opensearch.client.base.Transport;
import org.opensearch.client.json.jackson.JacksonJsonpMapper;
import org.opensearch.client.opensearch.OpenSearchClient;
import org.opensearch.client.opensearch._global.IndexRequest;
import org.opensearch.client.opensearch._global.IndexResponse;
import org.opensearch.client.opensearch._global.SearchResponse;
import org.opensearch.client.opensearch.indices.*;
import org.opensearch.client.opensearch.indices.put_settings.IndexSettingsBody;

import java.io.IOException;

public class OpenSearchClientExample {
  public static void main(String[] args) {
    RestClient restClient = null;
    try{
      System.setProperty("javax.net.ssl.trustStore", "/full/path/to/keystore");
      System.setProperty("javax.net.ssl.trustStorePassword", "password-to-keystore");

      //Only for demo purposes. Don't specify your credentials in code.
      final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
      credentialsProvider.setCredentials(AuthScope.ANY,
        new UsernamePasswordCredentials("admin", "admin"));

      //Initialize the client with SSL and TLS enabled
      restClient = RestClient.builder(new HttpHost("localhost", 9200, "https")).
        setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
          @Override
          public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
          return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
          }
        }).build();
      Transport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
      OpenSearchClient client = new OpenSearchClient(transport);

      //Create the index
      String index = "sample-index";
      CreateIndexRequest createIndexRequest = new CreateIndexRequest.Builder().index(index).build();
      client.indices().create(createIndexRequest);

      //Add some settings to the index
      IndexSettings indexSettings = new IndexSettings.Builder().autoExpandReplicas("0-all").build();
      IndexSettingsBody settingsBody = new IndexSettingsBody.Builder().settings(indexSettings).build();
      PutSettingsRequest putSettingsRequest = new PutSettingsRequest.Builder().index(index).value(settingsBody).build();
      client.indices().putSettings(putSettingsRequest);

      //Index some data
      IndexData indexData = new IndexData("first_name", "Bruce");
      IndexRequest<IndexData> indexRequest = new IndexRequest.Builder<IndexData>().index(index).id("1").document(indexData).build();
      client.index(indexRequest);

      //Search for the document
      SearchResponse<IndexData> searchResponse = client.search(s -> s.index(index), IndexData.class);
      for (int i = 0; i< searchResponse.hits().hits().size(); i++) {
        System.out.println(searchResponse.hits().hits().get(i).source());
      }

      //Delete the document
      client.delete(b -> b.index(index).id("1"));

      // Delete the index
      DeleteIndexRequest deleteIndexRequest = new DeleteRequest.Builder().index(index).build();
      DeleteIndexResponse deleteIndexResponse = client.indices().delete(deleteIndexRequest);
    } catch (IOException e){
      System.out.println(e.toString());
    } finally {
      try {
        if (restClient != null) {
          restClient.close();
        }
      } catch (IOException e) {
        System.out.println(e.toString());
      }
    }
  }
}
```

--------------------------------

### Example cURL Request for Memory Container

Source: https://docs.opensearch.org/3.3/ml-commons-plugin/api/agentic-memory-apis/get-memory-container

An example of how to call the Get Memory Container API using cURL to fetch a specific memory container identified by its ID.

```bash
curl -X GET "/_plugins/_ml/memory_containers/SdjmmpgBOh0h20Y9kWuN"
```

--------------------------------

### Start Replication with Role Mapping

Source: https://docs.opensearch.org/3.3/tuning-your-cluster/replication-plugin/permissions

Example of starting cross-cluster replication using specific leader and follower cluster roles. This is necessary for non-admin users to perform replication activities.

```APIDOC
## POST /_plugins/_replication/{follower_cluster_alias}/_start

### Description
Starts a cross-cluster replication process from a leader cluster to a follower cluster, specifying roles for backend tasks.

### Method
POST

### Endpoint
`/_plugins/_replication/{follower_cluster_alias}/_start`

### Parameters
#### Path Parameters
- **follower_cluster_alias** (string) - Required - The alias of the follower cluster.

#### Request Body
- **leader_alias** (string) - Required - The alias of the leader cluster.
- **leader_index** (string) - Required - The name of the index on the leader cluster to replicate.
- **use_roles** (object) - Required - An object containing role mappings for replication tasks.
  - **leader_cluster_role** (string) - Required - The role to use on the leader cluster for background replication tasks.
  - **follower_cluster_role** (string) - Required - The role to use on the follower cluster for background replication tasks.

### Request Example
```json
{
  "leader_alias": "leader-cluster",
  "leader_index": "leader-01",
  "use_roles":{
    "leader_cluster_role": "cross_cluster_replication_leader_full_access",
    "follower_cluster_role": "cross_cluster_replication_follower_full_access"
  }
}
```

### Response
#### Success Response (200)
Details about the replication process initiation.

#### Response Example
```json
{
  "acknowledged": true
}
```
```

--------------------------------

### Execute OpenSearch Benchmark in Docker

Source: https://docs.opensearch.org/3.3/benchmark/installing-benchmark

Demonstrates how to run the container to execute commands, such as displaying help text.

```bash
docker run opensearchproject/opensearch-benchmark -h
```

--------------------------------

### GET /_cat/plugins

Source: https://docs.opensearch.org/3.3/api-reference/cat/cat-plugins

Retrieves a list of installed plugins, including their names, components, and versions.

```APIDOC
## GET /_cat/plugins

### Description
Returns a list of all installed plugins across the cluster, including component names and version numbers.

### Method
GET

### Endpoint
/_cat/plugins

### Parameters
#### Query Parameters
- **cluster_manager_timeout** (String) - Optional - The amount of time allowed to establish a connection to the cluster manager node.
- **format** (String) - Optional - A short version of the Accept header, such as json or yaml.
- **h** (List) - Optional - A comma-separated list of column names to display.
- **help** (Boolean) - Optional - Returns help information. Default: false.
- **local** (Boolean) - Optional - Returns local information but does not retrieve the state from the cluster manager node. Default: false.
- **s** (List) - Optional - A comma-separated list of column names or column aliases to sort by.
- **v** (Boolean) - Optional - Enables verbose mode, which displays column headers. Default: false.

### Request Example
GET /_cat/plugins?v

### Response
#### Success Response (200)
- **name** (String) - The name of the node.
- **component** (String) - The name of the plugin component.
- **version** (String) - The version of the plugin.

#### Response Example
name       component                       version
odfe-node2 opendistro-alerting             1.13.1.0
odfe-node2 opendistro-sql                  1.13.2.0
```

--------------------------------

### Install and Verify OpenSearch Benchmark

Source: https://docs.opensearch.org/3.3/benchmark/user-guide/install-and-configure/installing-benchmark

Commands to install the OpenSearch Benchmark package using pip and to display the help menu to verify a successful installation.

```bash
pip install opensearch-benchmark
opensearch-benchmark -h
```

--------------------------------

### Ukrainian Analyzer Generated Tokens Example

Source: https://docs.opensearch.org/3.3/analyzers/language-analyzers/ukrainian

Example response showing the tokens generated by the Ukrainian analyzer for the input text. It includes the token, start and end offsets, type, and position.

```json
{
  "tokens": [
    {"token": "програміст", "start_offset": 2, "end_offset": 12, "type": "<ALPHANUM>", "position": 1},
    {"token": "працювати", "start_offset": 15, "end_offset": 21, "type": "<ALPHANUM>", "position": 3},
    {"token": "opensearch", "start_offset": 24, "end_offset": 34, "type": "<ALPHANUM>", "position": 5},
    {"token": "Україна", "start_offset": 37, "end_offset": 44, "type": "<ALPHANUM>", "position": 7}
  ]
}
```

--------------------------------

### Connect to MCP Server with Python

Source: https://docs.opensearch.org/3.3/ml-commons-plugin/api/mcp-server-apis/mcp-server

Demonstrates how to use the fastmcp library to initialize a connection to the OpenSearch MCP endpoint, list available tools, and invoke a specific tool.

```python
import asyncio, logging
from fastmcp import Client

async def main():
    async with Client("http://localhost:9200/_plugins/_ml/mcp") as client:
        for t in await client.list_tools():
            print(t.name)
        r = await client.call_tool("ListIndexTool", {})
        print("result: ", r)

asyncio.run(main())
```

--------------------------------

### Get Alerts Example Response

Source: https://docs.opensearch.org/3.3/observing-your-data/alerting/api

This JSON object represents an example response when retrieving alerts from the OpenSearch Alerting plugin. It includes details about active alerts, their monitors, triggers, and history.

```json
{
  "alerts": [
    {
      "id": "eQURa3gBKo1jAh6qUo49",
      "version": 300,
      "monitor_id": "awUMa3gBKo1jAh6qu47E",
      "schema_version": 2,
      "monitor_version": 2,
      "monitor_name": "Example_monitor_name",
      "monitor_user": {
        "name": "admin",
        "backend_roles": [
          "admin"
        ],
        "roles": [
          "all_access",
          "own_index"
        ],
        "custom_attribute_names": [],
        "user_requested_tenant": null
      },
      "trigger_id": "bQUQa3gBKo1jAh6qnY6G",
      "trigger_name": "Example_trigger_name",
      "state": "ACTIVE",
      "error_message": null,
      "alert_history": [
        {
          "timestamp": 1617314504873,
          "message": "Example error message"
        },
        {
          "timestamp": 1617312543925,
          "message": "Example error message"
        }
      ],
      "severity": "1",
      "action_execution_results": [
        {
          "action_id": "bgUQa3gBKo1jAh6qnY6G",
          "last_execution_time": 1617317979908,
          "throttled_count": 0
        }
      ],
      "start_time": 1616704000492,
      "last_notification_time": 1617317979908,
      "end_time": null,
      "acknowledged_time": null
    }
  ],
  "totalAlerts": 1
}
```

--------------------------------

### Create OpenSearch Keystore

Source: https://docs.opensearch.org/3.3/security/configuration/opensearch-keystore

Initializes a new OpenSearch keystore. If a keystore already exists, this command will prompt for confirmation to overwrite it. The keystore is created in the `$OPENSEARCH_HOME/config/opensearch.keystore` path.

```bash
./bin/opensearch-keystore create
```

--------------------------------

### Install S3 Repository Plugin for OpenSearch Snapshots

Source: https://docs.opensearch.org/3.3/tuning-your-cluster/availability-and-recovery/snapshots/snapshot-restore

Installs the repository-s3 plugin on OpenSearch nodes to enable using Amazon S3 buckets as snapshot repositories. This includes commands for both standard installations and Docker setups, along with keystore configuration for AWS credentials.

```bash
sudo ./bin/opensearch-plugin install repository-s3
```

```dockerfile
FROM opensearchproject/opensearch:3.3.2

ENV AWS_ACCESS_KEY_ID <access-key>
ENV AWS_SECRET_ACCESS_KEY <secret-key>

# Optional
ENV AWS_SESSION_TOKEN <optional-session-token>

RUN /usr/share/opensearch/bin/opensearch-plugin install --batch repository-s3
RUN /usr/share/opensearch/bin/opensearch-keystore create

RUN echo $AWS_ACCESS_KEY_ID | /usr/share/opensearch/bin/opensearch-keystore add --stdin s3.client.default.access_key
RUN echo $AWS_SECRET_ACCESS_KEY | /usr/share/opensearch/bin/opensearch-keystore add --stdin s3.client.default.secret_key
```

--------------------------------

### Configure and Install via YUM Repository

Source: https://docs.opensearch.org/3.3/install-and-configure/install-dashboards/rpm

Sets up the local YUM repository for OpenSearch Dashboards and installs the package from the repository.

```bash
sudo curl -SL https://artifacts.opensearch.org/releases/bundle/opensearch-dashboards/3.x/opensearch-dashboards-3.x.repo -o /etc/yum.repos.d/opensearch-dashboards-3.x.repo
sudo yum repolist
sudo yum clean all
sudo yum list opensearch-dashboards --showduplicates
sudo yum install opensearch-dashboards
```

--------------------------------

### Display OpenSearch Keystore Help

Source: https://docs.opensearch.org/3.3/security/configuration/opensearch-keystore

Shows comprehensive help information for the `opensearch-keystore` script, including all available commands and options.

```bash
./bin/opensearch-keystore help
```

--------------------------------

### Verify Cluster Names

Source: https://docs.opensearch.org/3.3/tuning-your-cluster/replication-plugin/getting-started

Commands to verify the cluster names after starting the Docker Compose setup.

```APIDOC
## Verify Cluster Names

### Description
These `curl` commands verify the cluster names of the two OpenSearch instances started via Docker Compose. Replace `<custom-admin-password>` with your actual password.

### Method
GET

### Endpoint
`https://localhost:9201` and `https://localhost:9200`

### Parameters
N/A

### Request Example
```bash
curl -XGET -u 'admin:<custom-admin-password>' -k 'https://localhost:9201'
curl -XGET -u 'admin:<custom-admin-password>' -k 'https://localhost:9200'
```

### Response
#### Success Response (200)
Returns cluster information including the `cluster_name`.

#### Response Example
```json
{
  "cluster_name" : "leader-cluster",
  ...
}
```

```json
{
  "cluster_name" : "follower-cluster",
  ...
}
```
```
Tokens:
Raw