Opensearch Connector

This connector provides sinks that can request document actions to an Opensearch Index. To use this connector, add the following dependency to your project:

Opensearch versionMaven Dependency
1.x
  1. <dependency>
  2.     <groupId>org.apache.flink</groupId>
  3.     <artifactId>flink-connector-opensearch</artifactId>
  4.     <version>1.1.0-1.18</version>
  5. </dependency>
Copied to clipboard!
2.x
  1. <dependency>
  2.               <groupId>org.apache.flink</groupId>
  3.               <artifactId>flink-connector-opensearch</artifactId>
  4.               <version>1.1.0-1.18</version>
  5.           </dependency>
Copied to clipboard!
  1.       By default, Apache Flink Opensearch Connector uses 1.3.x client libraries. You could switch to use 2.x (or upcoming 3.x) clients noting that those require JDK-11 or above, for example.
  3.       xml
  4.       &lt;dependencyManagement&gt;
  5.           &lt;dependencies&gt;
  6.               &lt;dependency&gt;
  7.                   &lt;groupId&gt;org.opensearch&lt;/groupId&gt;
  8.                   &lt;artifactId&gt;opensearch&lt;/artifactId&gt;
  9.                   &lt;version&gt;2.5.0&lt;/version&gt;
  10.               &lt;/dependency&gt;          
  11.               &lt;dependency&gt;
  12.                   &lt;groupId&gt;org.opensearch.client&lt;/groupId&gt;
  13.                   &lt;artifactId&gt;opensearch-rest-high-level-client&lt;/artifactId&gt;
  14.                   &lt;version&gt;2.5.0&lt;/version&gt;
  15.               &lt;/dependency&gt;
  16.           &lt;/dependencies&gt;
  17.       &lt;/dependencyManagement&gt;
  18.     </td>
  19. </tr>

Note that the streaming connectors are currently not part of the binary distribution. See here for information about how to package the program with the libraries for cluster execution.

Installing Opensearch

Instructions for setting up an Opensearch cluster can be found here.

Opensearch Sink

The example below shows how to configure and create a sink:

Java

  1. import org.apache.flink.api.common.functions.MapFunction;
  2. import org.apache.flink.connector.opensearch.sink.OpensearchSinkBuilder;
  3. import org.apache.flink.streaming.api.datastream.DataStream;
  5. import org.apache.http.HttpHost;
  6. import org.opensearch.action.index.IndexRequest;
  7. import org.opensearch.client.Requests;
  9. import java.util.HashMap;
  10. import java.util.Map;
  12. DataStream<String> input = ...;
  14. input.sinkTo(
  15.     new OpensearchSinkBuilder<String>()
  16.         .setBulkFlushMaxActions(1) // Instructs the sink to emit after every element, otherwise they would be buffered
  17.         .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
  18.         .setEmitter(
  19.         (element, context, indexer) ->
  20.         indexer.add(createIndexRequest(element)))
  21.         .build());
  23. private static IndexRequest createIndexRequest(String element) {
  24.     Map<String, Object> json = new HashMap<>();
  25.     json.put("data", element);
  27.     return Requests.indexRequest()
  28.         .index("my-index")
  29.         .id(element)
  30.         .source(json);
  31. }

Scala

  1. import org.apache.flink.api.connector.sink.SinkWriter
  2. import org.apache.flink.connector.opensearch.sink.{OpensearchSinkBuilder, RequestIndexer}
  3. import org.apache.flink.streaming.api.datastream.DataStream
  4. import org.apache.http.HttpHost
  5. import org.opensearch.action.index.IndexRequest
  6. import org.opensearch.client.Requests
  8. val input: DataStream[String] = ...
  10. input.sinkTo(
  11.   new OpensearchSinkBuilder[String]
  12.     .setBulkFlushMaxActions(1) // Instructs the sink to emit after every element, otherwise they would be buffered
  13.     .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
  14.     .setEmitter((element: String, context: SinkWriter.Context, indexer: RequestIndexer) => 
  15.     indexer.add(createIndexRequest(element)))
  16.     .build())
  18. def createIndexRequest(element: (String)): IndexRequest = {
  20.   val json = Map(
  21.     "data" -> element.asInstanceOf[AnyRef]
  22.   )
  24.   Requests.indexRequest.index("my-index").source(mapAsJavaMap(json))
  25. }

Note that the example only demonstrates performing a single index request for each incoming element. Generally, the OpensearchEmitter can be used to perform requests of different types (ex., DeleteRequest, UpdateRequest, etc.).

Internally, each parallel instance of the Flink Opensearch Sink uses a BulkProcessor to send action requests to the cluster. This will buffer elements before sending them in bulk to the cluster. The BulkProcessor executes bulk requests one at a time, i.e. there will be no two concurrent flushes of the buffered actions in progress.

Opensearch Sinks and Fault Tolerance

With Flink’s checkpointing enabled, the Flink Opensearch Sink guarantees at-least-once delivery of action requests to Opensearch clusters. It does so by waiting for all pending action requests in the BulkProcessor at the time of checkpoints. This effectively assures that all requests before the checkpoint was triggered have been successfully acknowledged by Opensearch, before proceeding to process more records sent to the sink.

More details on checkpoints and fault tolerance are in the fault tolerance docs.

To use fault tolerant Opensearch Sinks, checkpointing of the topology needs to be enabled at the execution environment:

Java

  1. final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  2. env.enableCheckpointing(5000); // checkpoint every 5000 msecs

Scala

  1. val env = StreamExecutionEnvironment.getExecutionEnvironment()
  2. env.enableCheckpointing(5000) // checkpoint every 5000 msecs

IMPORTANT: Checkpointing is not enabled by default but the default delivery guarantee is `AT_LEAST_ONCE`. This causes the sink to buffer requests until it either finishes or the `BulkProcessor` flushes automatically. By default, the `BulkProcessor` will flush after `1000` added actions. To configure the processor to flush more frequently, please refer to the BulkProcessor configuration section.

Using `UpdateRequests` with deterministic IDs and the upsert method it is possible to achieve exactly-once semantics in Opensearch when `AT_LEAST_ONCE` delivery is configured for the connector.

Handling Failing Opensearch Requests

Opensearch action requests may fail due to a variety of reasons, including temporarily saturated node queue capacity or malformed documents to be indexed. The Flink Opensearch Sink allows the user to retry requests by specifying a backoff-policy.

Below is an example:

Java

  1. DataStream<String> input = ...;
  3. input.sinkTo(
  4.     new OpensearchSinkBuilder<String>()
  5.         .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
  6.         .setEmitter(
  7.         (element, context, indexer) ->
  8.         indexer.add(createIndexRequest(element)))
  9.         // This enables an exponential backoff retry mechanism, with a maximum of 5 retries and an initial delay of 1000 milliseconds
  10.         .setBulkFlushBackoffStrategy(FlushBackoffType.EXPONENTIAL, 5, 1000)
  11.         .build());

Scala

  1. val input: DataStream[String] = ...
  3. input.sinkTo(
  4.   new OpensearchSinkBuilder[String]
  5.     .setHosts(new HttpHost("127.0.0.1", 9200, "http"))
  6.     .setEmitter((element: String, context: SinkWriter.Context, indexer: RequestIndexer) => 
  7.     indexer.add(createIndexRequest(element)))
  8.     // This enables an exponential backoff retry mechanism, with a maximum of 5 retries and an initial delay of 1000 milliseconds
  9.     .setBulkFlushBackoffStrategy(FlushBackoffType.EXPONENTIAL, 5, 1000)
  10.     .build())

The above example will let the sink re-add requests that failed due to resource constrains (e.g. queue capacity saturation). For all other failures, such as malformed documents, the sink will fail. If no BulkFlushBackoffStrategy (or FlushBackoffType.NONE) is configured, the sink will fail for any kind of error.

IMPORTANT: Re-adding requests back to the internal BulkProcessor on failures will lead to longer checkpoints, as the sink will also need to wait for the re-added requests to be flushed when checkpointing. For example, when using FlushBackoffType.EXPONENTIAL, checkpoints will need to wait until Opensearch node queues have enough capacity for all the pending requests, or until the maximum number of retries has been reached.

Configuring the Internal Bulk Processor

The internal BulkProcessor can be further configured for its behaviour on how buffered action requests are flushed, by using the following methods of the OpensearchSinkBuilder:

  • setBulkFlushMaxActions(int numMaxActions): Maximum amount of actions to buffer before flushing.
  • setBulkFlushMaxSizeMb(int maxSizeMb): Maximum size of data (in megabytes) to buffer before flushing.
  • setBulkFlushInterval(long intervalMillis): Interval at which to flush regardless of the amount or size of buffered actions.

Configuring how temporary request errors are retried is also supported:

  • setBulkFlushBackoffStrategy(FlushBackoffType flushBackoffType, int maxRetries, long delayMillis): The type of backoff delay, either CONSTANT or EXPONENTIAL, the amount of backoff retries to attempt, the amount of delay for backoff. For constant backoff, this is simply the delay between each retry. For exponential backoff, this is the initial base delay.

More information about Opensearch can be found here.

Packaging the Opensearch Connector into an Uber-Jar

For the execution of your Flink program, it is recommended to build a so-called uber-jar (executable jar) containing all your dependencies (see here for further information).

Alternatively, you can put the connector’s jar file into Flink’s lib/ folder to make it available system-wide, i.e. for all job being run.