There are more AWS SDK examples available in the [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub repo.
# Code examples for OpenSearch Service using AWS SDKs
The following code examples show you how to use Amazon OpenSearch Service with an AWS software development kit (SDK).
*Basics* are code examples that show you how to perform the essential operations within a service.
*Actions* are code excerpts from larger programs and must be run in context. While actions show you how to call individual service functions, you can see actions in context in their related scenarios.
*Scenarios* are code examples that show you how to accomplish specific tasks by calling multiple functions within a service or combined with other AWS services.
**More resources**
+ **[ OpenSearch Service User Guide](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/gsg.html)** – More information about OpenSearch Service.
+ **[OpenSearch Service API Reference](https://docs.aws.amazon.com/opensearch-service/latest/APIReference/Welcome.html)** – Details about all available OpenSearch Service actions.
+ **[AWS Developer Center](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-product=product%23opensearch-service)** – Code examples that you can filter by category or full-text search.
+ **[AWS SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples)** – GitHub repo with complete code in preferred languages. Includes instructions for setting up and running the code.
**Contents**
+ [Basics](opensearch_code_examples_basics.md)
+ [Hello OpenSearch Service](opensearch_example_opensearch_Hello_section.md)
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
+ [Actions](opensearch_code_examples_actions.md)
+ [`AddTags`](opensearch_example_opensearch_AddTags_section.md)
+ [`ChangeProgress`](opensearch_example_opensearch_ChangeProgress_section.md)
+ [`CreateDomain`](opensearch_example_opensearch_CreateDomain_section.md)
+ [`DeleteDomain`](opensearch_example_opensearch_DeleteDomain_section.md)
+ [`DescribeDomain`](opensearch_example_opensearch_DescribeDomain_section.md)
+ [`ListDomainNames`](opensearch_example_opensearch_ListDomainNames_section.md)
+ [`ListTags`](opensearch_example_opensearch_ListTags_section.md)
+ [`UpdateDomainConfig`](opensearch_example_opensearch_UpdateDomainConfig_section.md)
+ [Scenarios](opensearch_code_examples_scenarios.md)
+ [Getting started with Amazon OpenSearch Service](opensearch_example_opensearch_GettingStarted_016_section.md)
# Basic examples for OpenSearch Service using AWS SDKs
The following code examples show how to use the basics of Amazon OpenSearch Service with AWS SDKs.
**Contents**
+ [Hello OpenSearch Service](opensearch_example_opensearch_Hello_section.md)
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
+ [Actions](opensearch_code_examples_actions.md)
+ [`AddTags`](opensearch_example_opensearch_AddTags_section.md)
+ [`ChangeProgress`](opensearch_example_opensearch_ChangeProgress_section.md)
+ [`CreateDomain`](opensearch_example_opensearch_CreateDomain_section.md)
+ [`DeleteDomain`](opensearch_example_opensearch_DeleteDomain_section.md)
+ [`DescribeDomain`](opensearch_example_opensearch_DescribeDomain_section.md)
+ [`ListDomainNames`](opensearch_example_opensearch_ListDomainNames_section.md)
+ [`ListTags`](opensearch_example_opensearch_ListTags_section.md)
+ [`UpdateDomainConfig`](opensearch_example_opensearch_UpdateDomainConfig_section.md)
# Hello OpenSearch Service
The following code example shows how to get started using OpenSearch Service.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
import software.amazon.awssdk.services.opensearch.OpenSearchAsyncClient;
import software.amazon.awssdk.services.opensearch.model.ListVersionsRequest;
import java.util.List;
import java.util.concurrent.CompletableFuture;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class HelloOpenSearch {
public static void main(String[] args) {
try {
CompletableFuture future = listVersionsAsync();
future.join();
System.out.println("Versions listed successfully.");
} catch (RuntimeException e) {
System.err.println("Error occurred while listing versions: " + e.getMessage());
}
}
private static OpenSearchAsyncClient getAsyncClient() {
return OpenSearchAsyncClient.builder().build();
}
public static CompletableFuture listVersionsAsync() {
ListVersionsRequest request = ListVersionsRequest.builder()
.maxResults(10)
.build();
return getAsyncClient().listVersions(request).thenAccept(response -> {
List versionList = response.versions();
for (String version : versionList) {
System.out.println("Version info: " + version);
}
}).exceptionally(ex -> {
// Handle the exception, or propagate it as a RuntimeException
throw new RuntimeException("Failed to list versions", ex);
});
}
}
```
+ For API details, see [ListVersions](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ListVersions) in *AWS SDK for Java 2.x API Reference*.
------
# Learn core operations for Amazon OpenSearch Service using an AWS SDK
The following code example shows how to:
+ Create an OpenSearch Service domain.
+ Provides detailed information about a specific OpenSearch Service domain.
+ Lists all the OpenSearch Service domains owned by the account.
+ Waits until the OpenSearch Service domain's change status reaches a completed state.
+ Modifies the configuration of an existing OpenSearch Service domain.
+ Add a tag to the OpenSearch Service domain.
+ Lists the tags associated with an OpenSearch Service domain.
+ Removes tags from an OpenSearch Service domain.
+ Deletes the OpenSearch Service domain.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/batch#code-examples).
Run an interactive scenario demonstrating OpenSearch Service features.
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.services.opensearch.model.*;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.CompletableFuture;
public class OpenSearchScenario {
public static final String DASHES = new String(new char[80]).replace("\0", "-");
private static final Logger logger = LoggerFactory.getLogger(OpenSearchScenario.class);
static Scanner scanner = new Scanner(System.in);
static OpenSearchActions openSearchActions = new OpenSearchActions();
public static void main(String[] args) throws Throwable {
logger.info("""
Welcome to the Amazon OpenSearch Service Basics Scenario.
Use the Amazon OpenSearch Service API to create, configure, and manage OpenSearch Service domains.
The operations exposed by the AWS OpenSearch Service client are focused on managing the OpenSearch Service domains
and their configurations, not the data within the domains (such as indexing or querying documents).
For document management, you typically interact directly with the OpenSearch REST API or use other libraries,
such as the OpenSearch Java client (https://opensearch.org/docs/latest/clients/java/).
Let's get started...
""");
waitForInputToContinue(scanner);
try {
runScenario();
} catch (RuntimeException e) {
e.printStackTrace();
}
}
private static void waitForInputToContinue(Scanner scanner) {
while (true) {
logger.info("");
logger.info("Enter 'c' followed by to continue:");
String input = scanner.nextLine();
if (input.trim().equalsIgnoreCase("c")) {
logger.info("Continuing with the program...");
logger.info("");
break;
} else {
logger.info("Invalid input. Please try again.");
}
}
}
private static void runScenario() throws Throwable {
String currentTimestamp = String.valueOf(System.currentTimeMillis());
String domainName = "test-domain-" + currentTimestamp;
logger.info(DASHES);
logger.info("1. Create an Amazon OpenSearch domain");
logger.info("""
An Amazon OpenSearch domain is a managed instance of the OpenSearch engine,
which is an open-source search and analytics engine derived from Elasticsearch.
An OpenSearch domain is essentially a cluster of compute resources and storage that hosts
one or more OpenSearch indexes, enabling you to perform full-text searches, data analysis, and
visualizations.
In this step, we'll initiate the creation of the domain. We'll check on the progress in a later step.
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.createNewDomainAsync(domainName);
String domainId = future.join();
logger.info("Domain successfully created with ID: {}", domainId);
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
if (cause != null) {
if (cause instanceof OpenSearchException openSearchEx) {
logger.error("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.error("An unexpected error occurred: " + cause.getMessage(), cause);
}
} else {
logger.error("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("2. Describe the Amazon OpenSearch domain");
logger.info("In this step, we get back the Domain ARN which is used in an upcoming step.");
waitForInputToContinue(scanner);
String arn = "";
try {
CompletableFuture future = openSearchActions.describeDomainAsync(domainName);
arn = future.join();
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("3. List the domains in your account");
waitForInputToContinue(scanner);
try {
CompletableFuture> future = openSearchActions.listAllDomainsAsync();
List domainInfoList = future.join();
for (DomainInfo domain : domainInfoList) {
logger.info("Domain name is: " + domain.domainName());
}
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
while (cause.getCause() != null && !(cause instanceof OpenSearchException)) {
cause = cause.getCause();
}
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("4. Wait until the domain's change status reaches a completed state");
logger.info("""
In this step, we check on the change status of the domain that we initiated in Step 1.
Until we reach a COMPLETED state, we stay in a loop by sending a DescribeDomainChangeProgressRequest.
The time it takes for a change to an OpenSearch domain to reach a completed state can range
from a few minutes to several hours. In this case the change is creating a new domain that we initiated in Step 1.
The time varies depending on the complexity of the change and the current load on
the OpenSearch service. In general, simple changes, such as scaling the number of data nodes or
updating the OpenSearch version, may take 10-30 minutes.
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.domainChangeProgressAsync(domainName);
future.join();
logger.info("Domain change progress completed successfully.");
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
while (cause.getCause() != null && !(cause instanceof ResourceNotFoundException)) {
cause = cause.getCause();
}
if (cause instanceof ResourceNotFoundException resourceNotFoundException) {
logger.info("The specific AWS resource was not found: Error message: {}, Error code {}", resourceNotFoundException.awsErrorDetails().errorMessage(), resourceNotFoundException.awsErrorDetails().errorCode());
if (cause instanceof OpenSearchException ex) {
logger.info("An OpenSearch error occurred: Error message: " + ex.getMessage());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("5. Modify the domain");
logger.info("""
You can change your OpenSearch domain's settings, like the number of instances, without starting over from scratch.
This makes it easy to adjust your domain as your needs change, allowing you to scale up or
down quickly without recreating everything.
We modify the domain in this step by changing the number of instances.
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.updateSpecificDomainAsync(domainName);
UpdateDomainConfigResponse updateResponse = future.join();
logger.info("Domain update status: " + updateResponse.domainConfig().changeProgressDetails().configChangeStatusAsString());
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("6. Wait until the domain's change status reaches a completed state");
logger.info("""
In this step, we poll the status until the domain's change status reaches a completed state.
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.domainChangeProgressAsync(domainName);
future.join();
logger.info("Domain change progress completed successfully.");
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
if (cause instanceof OpenSearchException ex) {
logger.info("EC2 error occurred: Error message: " +ex.getMessage());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("7. Tag the Domain");
logger.info("""
Tags let you assign arbitrary information to an Amazon OpenSearch Service domain so you can
categorize and filter on that information. A tag is a key-value pair that you define and
associate with an OpenSearch Service domain. You can use these tags to track costs by grouping
expenses for similarly tagged resources.
In this scenario, we create tags with keys "service" and "instances".
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.addDomainTagsAsync(arn);
future.join();
logger.info("Domain tags added successfully.");
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
while (cause.getCause() != null && !(cause instanceof OpenSearchException)) {
cause = cause.getCause();
}
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
if (cause != null) {
if (cause instanceof OpenSearchException) {
logger.error("OpenSearch error occurred: Error message: " + cause.getMessage(), cause);
} else {
logger.error("An unexpected error occurred: " + cause.getMessage(), cause);
}
} else {
logger.error("An unexpected error occurred: " + rt.getMessage(), rt);
}
throw cause;
}
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("8. List Domain tags");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.listDomainTagsAsync(arn);
ListTagsResponse listTagsResponse = future.join();
listTagsResponse.tagList().forEach(tag -> logger.info("Tag Key: " + tag.key() + ", Tag Value: " + tag.value()));
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
while (cause.getCause() != null && !(cause instanceof OpenSearchException)) {
cause = cause.getCause();
}
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("9. Delete the domain");
logger.info("""
In this step, we'll delete the Amazon OpenSearch domain that we created in Step 1.
Deleting a domain will remove all data and configuration for that domain.
""");
waitForInputToContinue(scanner);
try {
CompletableFuture future = openSearchActions.deleteSpecificDomainAsync(domainName);
future.join();
logger.info("Domain successfully deleted.");
} catch (RuntimeException rt) {
Throwable cause = rt.getCause();
while (cause.getCause() != null && !(cause instanceof OpenSearchException)) {
cause = cause.getCause();
}
if (cause instanceof OpenSearchException openSearchEx) {
logger.info("OpenSearch error occurred: Error message: {}, Error code {}", openSearchEx.awsErrorDetails().errorMessage(), openSearchEx.awsErrorDetails().errorCode());
} else {
logger.info("An unexpected error occurred: " + rt.getMessage());
}
throw cause;
}
waitForInputToContinue(scanner);
logger.info(DASHES);
logger.info("Scenario complete!");
}
}
```
A wrapper class for OpenSearch Service SDK methods.
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.core.retry.RetryPolicy;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.nio.netty.NettyNioAsyncHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.opensearch.OpenSearchAsyncClient;
import software.amazon.awssdk.services.opensearch.model.AddTagsRequest;
import software.amazon.awssdk.services.opensearch.model.AddTagsResponse;
import software.amazon.awssdk.services.opensearch.model.ClusterConfig;
import software.amazon.awssdk.services.opensearch.model.CreateDomainRequest;
import software.amazon.awssdk.services.opensearch.model.DeleteDomainRequest;
import software.amazon.awssdk.services.opensearch.model.DeleteDomainResponse;
import software.amazon.awssdk.services.opensearch.model.DescribeDomainChangeProgressRequest;
import software.amazon.awssdk.services.opensearch.model.DescribeDomainChangeProgressResponse;
import software.amazon.awssdk.services.opensearch.model.DescribeDomainRequest;
import software.amazon.awssdk.services.opensearch.model.DomainInfo;
import software.amazon.awssdk.services.opensearch.model.DomainStatus;
import software.amazon.awssdk.services.opensearch.model.EBSOptions;
import software.amazon.awssdk.services.opensearch.model.ListDomainNamesRequest;
import software.amazon.awssdk.services.opensearch.model.ListTagsRequest;
import software.amazon.awssdk.services.opensearch.model.ListTagsResponse;
import software.amazon.awssdk.services.opensearch.model.NodeToNodeEncryptionOptions;
import software.amazon.awssdk.services.opensearch.model.Tag;
import software.amazon.awssdk.services.opensearch.model.UpdateDomainConfigRequest;
import software.amazon.awssdk.services.opensearch.model.UpdateDomainConfigResponse;
import software.amazon.awssdk.services.opensearch.model.VolumeType;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
public class OpenSearchActions {
private static final Logger logger = LoggerFactory.getLogger(OpenSearchActions.class);
private static OpenSearchAsyncClient openSearchClientAsyncClient;
private static OpenSearchAsyncClient getAsyncClient() {
if (openSearchClientAsyncClient == null) {
SdkAsyncHttpClient httpClient = NettyNioAsyncHttpClient.builder()
.maxConcurrency(100)
.connectionTimeout(Duration.ofSeconds(60))
.readTimeout(Duration.ofSeconds(60))
.writeTimeout(Duration.ofSeconds(60))
.build();
ClientOverrideConfiguration overrideConfig = ClientOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofMinutes(2))
.apiCallAttemptTimeout(Duration.ofSeconds(90))
.retryPolicy(RetryPolicy.builder()
.numRetries(3)
.build())
.build();
openSearchClientAsyncClient = OpenSearchAsyncClient.builder()
.region(Region.US_EAST_1)
.httpClient(httpClient)
.overrideConfiguration(overrideConfig)
.build();
}
return openSearchClientAsyncClient;
}
/**
* Creates a new OpenSearch domain asynchronously.
* @param domainName the name of the new OpenSearch domain to create
* @return a {@link CompletableFuture} containing the domain ID of the newly created domain
*/
public CompletableFuture createNewDomainAsync(String domainName) {
ClusterConfig clusterConfig = ClusterConfig.builder()
.dedicatedMasterEnabled(true)
.dedicatedMasterCount(3)
.dedicatedMasterType("t2.small.search")
.instanceType("t2.small.search")
.instanceCount(5)
.build();
EBSOptions ebsOptions = EBSOptions.builder()
.ebsEnabled(true)
.volumeSize(10)
.volumeType(VolumeType.GP2)
.build();
NodeToNodeEncryptionOptions encryptionOptions = NodeToNodeEncryptionOptions.builder()
.enabled(true)
.build();
CreateDomainRequest domainRequest = CreateDomainRequest.builder()
.domainName(domainName)
.engineVersion("OpenSearch_1.0")
.clusterConfig(clusterConfig)
.ebsOptions(ebsOptions)
.nodeToNodeEncryptionOptions(encryptionOptions)
.build();
logger.info("Sending domain creation request...");
return getAsyncClient().createDomain(domainRequest)
.handle( (createResponse, throwable) -> {
if (createResponse != null) {
logger.info("Domain status is {}", createResponse.domainStatus().changeProgressDetails().configChangeStatusAsString());
logger.info("Domain Id is {}", createResponse.domainStatus().domainId());
return createResponse.domainStatus().domainId();
}
throw new RuntimeException("Failed to create domain", throwable);
});
}
/**
* Deletes a specific domain asynchronously.
* @param domainName the name of the domain to be deleted
* @return a {@link CompletableFuture} that completes when the domain has been deleted
* or throws a {@link RuntimeException} if the deletion fails
*/
public CompletableFuture deleteSpecificDomainAsync(String domainName) {
DeleteDomainRequest domainRequest = DeleteDomainRequest.builder()
.domainName(domainName)
.build();
// Delete domain asynchronously
return getAsyncClient().deleteDomain(domainRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to delete the domain: " + domainName, exception);
}
});
}
/**
* Describes the specified domain asynchronously.
*
* @param domainName the name of the domain to describe
* @return a {@link CompletableFuture} that completes with the ARN of the domain
* @throws RuntimeException if the domain description fails
*/
public CompletableFuture describeDomainAsync(String domainName) {
DescribeDomainRequest request = DescribeDomainRequest.builder()
.domainName(domainName)
.build();
return getAsyncClient().describeDomain(request)
.handle((response, exception) -> { // Handle both response and exception
if (exception != null) {
throw new RuntimeException("Failed to describe domain", exception);
}
DomainStatus domainStatus = response.domainStatus();
String endpoint = domainStatus.endpoint();
String arn = domainStatus.arn();
String engineVersion = domainStatus.engineVersion();
logger.info("Domain endpoint is: " + endpoint);
logger.info("ARN: " + arn);
System.out.println("Engine version: " + engineVersion);
return arn; // Return ARN when successful
});
}
/**
* Asynchronously lists all the domains in the current AWS account.
* @return a {@link CompletableFuture} that, when completed, contains a list of {@link DomainInfo} objects representing
* the domains in the account.
* @throws RuntimeException if there was a failure while listing the domains.
*/
public CompletableFuture> listAllDomainsAsync() {
ListDomainNamesRequest namesRequest = ListDomainNamesRequest.builder()
.engineType("OpenSearch")
.build();
return getAsyncClient().listDomainNames(namesRequest)
.handle((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to list all domains", exception);
}
return response.domainNames(); // Return the list of domain names on success
});
}
/**
* Updates the configuration of a specific domain asynchronously.
* @param domainName the name of the domain to update
* @return a {@link CompletableFuture} that represents the asynchronous operation of updating the domain configuration
*/
public CompletableFuture updateSpecificDomainAsync(String domainName) {
ClusterConfig clusterConfig = ClusterConfig.builder()
.instanceCount(3)
.build();
UpdateDomainConfigRequest updateDomainConfigRequest = UpdateDomainConfigRequest.builder()
.domainName(domainName)
.clusterConfig(clusterConfig)
.build();
return getAsyncClient().updateDomainConfig(updateDomainConfigRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to update the domain configuration", exception);
}
// Handle success if needed (e.g., logging or additional actions)
});
}
/**
* Asynchronously checks the progress of a domain change operation in Amazon OpenSearch Service.
* @param domainName the name of the OpenSearch domain to check the progress for
* @return a {@link CompletableFuture} that completes when the domain change operation is completed
*/
public CompletableFuture domainChangeProgressAsync(String domainName) {
DescribeDomainChangeProgressRequest request = DescribeDomainChangeProgressRequest.builder()
.domainName(domainName)
.build();
return CompletableFuture.runAsync(() -> {
boolean isCompleted = false;
long startTime = System.currentTimeMillis();
while (!isCompleted) {
try {
// Handle the async client call using `join` to block synchronously for the result
DescribeDomainChangeProgressResponse response = getAsyncClient()
.describeDomainChangeProgress(request)
.handle((resp, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to check domain progress", ex);
}
return resp;
}).join();
String state = response.changeProgressStatus().statusAsString(); // Get the status as string
if ("COMPLETED".equals(state)) {
logger.info("\nOpenSearch domain status: Completed");
isCompleted = true;
} else {
for (int i = 0; i < 5; i++) {
long elapsedTimeInSeconds = (System.currentTimeMillis() - startTime) / 1000;
String formattedTime = String.format("%02d:%02d", elapsedTimeInSeconds / 60, elapsedTimeInSeconds % 60);
System.out.print("\rOpenSearch domain state: " + state + " | Time Elapsed: " + formattedTime + " ");
System.out.flush();
Thread.sleep(1_000);
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Thread was interrupted", e);
}
}
});
}
/**
* Asynchronously adds tags to an Amazon OpenSearch Service domain.
* @param domainARN the Amazon Resource Name (ARN) of the Amazon OpenSearch Service domain to add tags to
* @return a {@link CompletableFuture} that completes when the tags have been successfully added to the domain,
* or throws a {@link RuntimeException} if the operation fails
*/
public CompletableFuture addDomainTagsAsync(String domainARN) {
Tag tag1 = Tag.builder()
.key("service")
.value("OpenSearch")
.build();
Tag tag2 = Tag.builder()
.key("instances")
.value("m3.2xlarge")
.build();
List tagList = new ArrayList<>();
tagList.add(tag1);
tagList.add(tag2);
AddTagsRequest addTagsRequest = AddTagsRequest.builder()
.arn(domainARN)
.tagList(tagList)
.build();
return getAsyncClient().addTags(addTagsRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to add tags to the domain: " + domainARN, exception);
} else {
logger.info("Added Tags");
}
});
}
/**
* Asynchronously lists the tags associated with the specified Amazon Resource Name (ARN).
* @param arn the Amazon Resource Name (ARN) of the resource for which to list the tags
* @return a {@link CompletableFuture} that, when completed, will contain a list of the tags associated with the
* specified ARN
* @throws RuntimeException if there is an error listing the tags
*/
public CompletableFuture listDomainTagsAsync(String arn) {
ListTagsRequest tagsRequest = ListTagsRequest.builder()
.arn(arn)
.build();
return getAsyncClient().listTags(tagsRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to list domain tags", exception);
}
List tagList = response.tagList();
for (Tag tag : tagList) {
logger.info("Tag key is " + tag.key());
logger.info("Tag value is " + tag.value());
}
});
}
}
```
+ For API details, see the following topics in *AWS SDK for Java 2.x API Reference*.
+ [AddTags](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/AddTags)
+ [CreateDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/CreateDomain)
+ [DeleteDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/DeleteDomain)
+ [DescribeDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/DescribeDomain)
+ [DescribeDomainChangeProgress](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/DescribeDomainChangeProgress)
+ [ListDomainNames](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ListDomainNames)
+ [ListTags](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ListTags)
+ [UpdateDomainConfig](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/UpdateDomainConfig)
------
# Actions for OpenSearch Service using AWS SDKs
The following code examples demonstrate how to perform individual OpenSearch Service actions with AWS SDKs. Each example includes a link to GitHub, where you can find instructions for setting up and running the code.
These excerpts call the OpenSearch Service API and are code excerpts from larger programs that must be run in context. You can see actions in context in [Scenarios for OpenSearch Service using AWS SDKs](opensearch_code_examples_scenarios.md).
The following examples include only the most commonly used actions. For a complete list, see the [Amazon OpenSearch Service API Reference](https://docs.aws.amazon.com/opensearch-service/latest/APIReference/Welcome.html).
**Topics**
+ [`AddTags`](opensearch_example_opensearch_AddTags_section.md)
+ [`ChangeProgress`](opensearch_example_opensearch_ChangeProgress_section.md)
+ [`CreateDomain`](opensearch_example_opensearch_CreateDomain_section.md)
+ [`DeleteDomain`](opensearch_example_opensearch_DeleteDomain_section.md)
+ [`DescribeDomain`](opensearch_example_opensearch_DescribeDomain_section.md)
+ [`ListDomainNames`](opensearch_example_opensearch_ListDomainNames_section.md)
+ [`ListTags`](opensearch_example_opensearch_ListTags_section.md)
+ [`UpdateDomainConfig`](opensearch_example_opensearch_UpdateDomainConfig_section.md)
# Use `AddTags` with an AWS SDK
The following code example shows how to use `AddTags`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Asynchronously adds tags to an Amazon OpenSearch Service domain.
* @param domainARN the Amazon Resource Name (ARN) of the Amazon OpenSearch Service domain to add tags to
* @return a {@link CompletableFuture} that completes when the tags have been successfully added to the domain,
* or throws a {@link RuntimeException} if the operation fails
*/
public CompletableFuture addDomainTagsAsync(String domainARN) {
Tag tag1 = Tag.builder()
.key("service")
.value("OpenSearch")
.build();
Tag tag2 = Tag.builder()
.key("instances")
.value("m3.2xlarge")
.build();
List tagList = new ArrayList<>();
tagList.add(tag1);
tagList.add(tag2);
AddTagsRequest addTagsRequest = AddTagsRequest.builder()
.arn(domainARN)
.tagList(tagList)
.build();
return getAsyncClient().addTags(addTagsRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to add tags to the domain: " + domainARN, exception);
} else {
logger.info("Added Tags");
}
});
}
```
+ For API details, see [AddTags](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/AddTags) in *AWS SDK for Java 2.x API Reference*.
------
# Use `ChangeProgress` with an AWS SDK
The following code example shows how to use `ChangeProgress`.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Asynchronously checks the progress of a domain change operation in Amazon OpenSearch Service.
* @param domainName the name of the OpenSearch domain to check the progress for
* @return a {@link CompletableFuture} that completes when the domain change operation is completed
*/
public CompletableFuture domainChangeProgressAsync(String domainName) {
DescribeDomainChangeProgressRequest request = DescribeDomainChangeProgressRequest.builder()
.domainName(domainName)
.build();
return CompletableFuture.runAsync(() -> {
boolean isCompleted = false;
long startTime = System.currentTimeMillis();
while (!isCompleted) {
try {
// Handle the async client call using `join` to block synchronously for the result
DescribeDomainChangeProgressResponse response = getAsyncClient()
.describeDomainChangeProgress(request)
.handle((resp, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to check domain progress", ex);
}
return resp;
}).join();
String state = response.changeProgressStatus().statusAsString(); // Get the status as string
if ("COMPLETED".equals(state)) {
logger.info("\nOpenSearch domain status: Completed");
isCompleted = true;
} else {
for (int i = 0; i < 5; i++) {
long elapsedTimeInSeconds = (System.currentTimeMillis() - startTime) / 1000;
String formattedTime = String.format("%02d:%02d", elapsedTimeInSeconds / 60, elapsedTimeInSeconds % 60);
System.out.print("\rOpenSearch domain state: " + state + " | Time Elapsed: " + formattedTime + " ");
System.out.flush();
Thread.sleep(1_000);
}
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Thread was interrupted", e);
}
}
});
}
```
+ For API details, see [ChangeProgress](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ChangeProgress) in *AWS SDK for Java 2.x API Reference*.
------
# Use `CreateDomain` with an AWS SDK
The following code examples show how to use `CreateDomain`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Getting started with Amazon OpenSearch Service](opensearch_example_opensearch_GettingStarted_016_section.md)
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Creates a new OpenSearch domain asynchronously.
* @param domainName the name of the new OpenSearch domain to create
* @return a {@link CompletableFuture} containing the domain ID of the newly created domain
*/
public CompletableFuture createNewDomainAsync(String domainName) {
ClusterConfig clusterConfig = ClusterConfig.builder()
.dedicatedMasterEnabled(true)
.dedicatedMasterCount(3)
.dedicatedMasterType("t2.small.search")
.instanceType("t2.small.search")
.instanceCount(5)
.build();
EBSOptions ebsOptions = EBSOptions.builder()
.ebsEnabled(true)
.volumeSize(10)
.volumeType(VolumeType.GP2)
.build();
NodeToNodeEncryptionOptions encryptionOptions = NodeToNodeEncryptionOptions.builder()
.enabled(true)
.build();
CreateDomainRequest domainRequest = CreateDomainRequest.builder()
.domainName(domainName)
.engineVersion("OpenSearch_1.0")
.clusterConfig(clusterConfig)
.ebsOptions(ebsOptions)
.nodeToNodeEncryptionOptions(encryptionOptions)
.build();
logger.info("Sending domain creation request...");
return getAsyncClient().createDomain(domainRequest)
.handle( (createResponse, throwable) -> {
if (createResponse != null) {
logger.info("Domain status is {}", createResponse.domainStatus().changeProgressDetails().configChangeStatusAsString());
logger.info("Domain Id is {}", createResponse.domainStatus().domainId());
return createResponse.domainStatus().domainId();
}
throw new RuntimeException("Failed to create domain", throwable);
});
}
```
+ For API details, see [CreateDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/CreateDomain) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/opensearch#code-examples).
```
suspend fun createNewDomain(domainNameVal: String?) {
val clusterConfigOb =
ClusterConfig {
dedicatedMasterEnabled = true
dedicatedMasterCount = 3
dedicatedMasterType = OpenSearchPartitionInstanceType.fromValue("t2.small.search")
instanceType = OpenSearchPartitionInstanceType.fromValue("t2.small.search")
instanceCount = 5
}
val ebsOptionsOb =
EbsOptions {
ebsEnabled = true
volumeSize = 10
volumeType = VolumeType.Gp2
}
val encryptionOptionsOb =
NodeToNodeEncryptionOptions {
enabled = true
}
val request =
CreateDomainRequest {
domainName = domainNameVal
engineVersion = "OpenSearch_1.0"
clusterConfig = clusterConfigOb
ebsOptions = ebsOptionsOb
nodeToNodeEncryptionOptions = encryptionOptionsOb
}
println("Sending domain creation request...")
OpenSearchClient.fromEnvironment { region = "us-east-1" }.use { searchClient ->
val createResponse = searchClient.createDomain(request)
println("Domain status is ${createResponse.domainStatus}")
println("Domain Id is ${createResponse.domainStatus?.domainId}")
}
}
```
+ For API details, see [CreateDomain](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
# Use `DeleteDomain` with an AWS SDK
The following code examples show how to use `DeleteDomain`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Getting started with Amazon OpenSearch Service](opensearch_example_opensearch_GettingStarted_016_section.md)
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Deletes a specific domain asynchronously.
* @param domainName the name of the domain to be deleted
* @return a {@link CompletableFuture} that completes when the domain has been deleted
* or throws a {@link RuntimeException} if the deletion fails
*/
public CompletableFuture deleteSpecificDomainAsync(String domainName) {
DeleteDomainRequest domainRequest = DeleteDomainRequest.builder()
.domainName(domainName)
.build();
// Delete domain asynchronously
return getAsyncClient().deleteDomain(domainRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to delete the domain: " + domainName, exception);
}
});
}
```
+ For API details, see [DeleteDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/DeleteDomain) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/opensearch#code-examples).
```
suspend fun deleteSpecificDomain(domainNameVal: String) {
val request =
DeleteDomainRequest {
domainName = domainNameVal
}
OpenSearchClient.fromEnvironment { region = "us-east-1" }.use { searchClient ->
searchClient.deleteDomain(request)
println("$domainNameVal was successfully deleted.")
}
}
```
+ For API details, see [DeleteDomain](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
# Use `DescribeDomain` with an AWS SDK
The following code example shows how to use `DescribeDomain`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Getting started with Amazon OpenSearch Service](opensearch_example_opensearch_GettingStarted_016_section.md)
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Describes the specified domain asynchronously.
*
* @param domainName the name of the domain to describe
* @return a {@link CompletableFuture} that completes with the ARN of the domain
* @throws RuntimeException if the domain description fails
*/
public CompletableFuture describeDomainAsync(String domainName) {
DescribeDomainRequest request = DescribeDomainRequest.builder()
.domainName(domainName)
.build();
return getAsyncClient().describeDomain(request)
.handle((response, exception) -> { // Handle both response and exception
if (exception != null) {
throw new RuntimeException("Failed to describe domain", exception);
}
DomainStatus domainStatus = response.domainStatus();
String endpoint = domainStatus.endpoint();
String arn = domainStatus.arn();
String engineVersion = domainStatus.engineVersion();
logger.info("Domain endpoint is: " + endpoint);
logger.info("ARN: " + arn);
System.out.println("Engine version: " + engineVersion);
return arn; // Return ARN when successful
});
}
```
+ For API details, see [DescribeDomain](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/DescribeDomain) in *AWS SDK for Java 2.x API Reference*.
------
# Use `ListDomainNames` with an AWS SDK
The following code examples show how to use `ListDomainNames`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Asynchronously lists all the domains in the current AWS account.
* @return a {@link CompletableFuture} that, when completed, contains a list of {@link DomainInfo} objects representing
* the domains in the account.
* @throws RuntimeException if there was a failure while listing the domains.
*/
public CompletableFuture> listAllDomainsAsync() {
ListDomainNamesRequest namesRequest = ListDomainNamesRequest.builder()
.engineType("OpenSearch")
.build();
return getAsyncClient().listDomainNames(namesRequest)
.handle((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to list all domains", exception);
}
return response.domainNames(); // Return the list of domain names on success
});
}
```
+ For API details, see [ListDomainNames](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ListDomainNames) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/opensearch#code-examples).
```
suspend fun listAllDomains() {
OpenSearchClient.fromEnvironment { region = "us-east-1" }.use { searchClient ->
val response: ListDomainNamesResponse = searchClient.listDomainNames(ListDomainNamesRequest {})
response.domainNames?.forEach { domain ->
println("Domain name is " + domain.domainName)
}
}
}
```
+ For API details, see [ListDomainNames](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
# Use `ListTags` with an AWS SDK
The following code example shows how to use `ListTags`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Asynchronously adds tags to an Amazon OpenSearch Service domain.
* @param domainARN the Amazon Resource Name (ARN) of the Amazon OpenSearch Service domain to add tags to
* @return a {@link CompletableFuture} that completes when the tags have been successfully added to the domain,
* or throws a {@link RuntimeException} if the operation fails
*/
public CompletableFuture addDomainTagsAsync(String domainARN) {
Tag tag1 = Tag.builder()
.key("service")
.value("OpenSearch")
.build();
Tag tag2 = Tag.builder()
.key("instances")
.value("m3.2xlarge")
.build();
List tagList = new ArrayList<>();
tagList.add(tag1);
tagList.add(tag2);
AddTagsRequest addTagsRequest = AddTagsRequest.builder()
.arn(domainARN)
.tagList(tagList)
.build();
return getAsyncClient().addTags(addTagsRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to add tags to the domain: " + domainARN, exception);
} else {
logger.info("Added Tags");
}
});
}
```
+ For API details, see [ListTags](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/ListTags) in *AWS SDK for Java 2.x API Reference*.
------
# Use `UpdateDomainConfig` with an AWS SDK
The following code examples show how to use `UpdateDomainConfig`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn OpenSearch Service core operations](opensearch_example_opensearch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/opensearch#code-examples).
```
/**
* Updates the configuration of a specific domain asynchronously.
* @param domainName the name of the domain to update
* @return a {@link CompletableFuture} that represents the asynchronous operation of updating the domain configuration
*/
public CompletableFuture updateSpecificDomainAsync(String domainName) {
ClusterConfig clusterConfig = ClusterConfig.builder()
.instanceCount(3)
.build();
UpdateDomainConfigRequest updateDomainConfigRequest = UpdateDomainConfigRequest.builder()
.domainName(domainName)
.clusterConfig(clusterConfig)
.build();
return getAsyncClient().updateDomainConfig(updateDomainConfigRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Failed to update the domain configuration", exception);
}
// Handle success if needed (e.g., logging or additional actions)
});
}
```
+ For API details, see [UpdateDomainConfig](https://docs.aws.amazon.com/goto/SdkForJavaV2/es-2021-01-01/UpdateDomainConfig) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/opensearch#code-examples).
```
suspend fun updateSpecificDomain(domainNameVal: String?) {
val clusterConfigOb =
ClusterConfig {
instanceCount = 3
}
val request =
UpdateDomainConfigRequest {
domainName = domainNameVal
clusterConfig = clusterConfigOb
}
println("Sending domain update request...")
OpenSearchClient.fromEnvironment { region = "us-east-1" }.use { searchClient ->
val updateResponse = searchClient.updateDomainConfig(request)
println("Domain update response from Amazon OpenSearch Service:")
println(updateResponse.toString())
}
}
```
+ For API details, see [UpdateDomainConfig](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
# Scenarios for OpenSearch Service using AWS SDKs
The following code examples show you how to implement common scenarios in OpenSearch Service with AWS SDKs. These scenarios show you how to accomplish specific tasks by calling multiple functions within OpenSearch Service or combined with other AWS services. Each scenario includes a link to the complete source code, where you can find instructions on how to set up and run the code.
Scenarios target an intermediate level of experience to help you understand service actions in context.
**Topics**
+ [Getting started with Amazon OpenSearch Service](opensearch_example_opensearch_GettingStarted_016_section.md)
# Getting started with Amazon OpenSearch Service
The following code example shows how to:
+ Create an OpenSearch Service domain
+ Upload data to your domain
+ Clean up resources
------
#### [ Bash ]
**AWS CLI with Bash script**
There's more on GitHub. Find the complete example and learn how to set up and run in the [Sample developer tutorials](https://github.com/aws-samples/sample-developer-tutorials/tree/main/tuts/016-opensearch-service-gs) repository.
```
#!/bin/bash
# Amazon OpenSearch Service Getting Started Script - Version 8 Fixed
# This script creates an OpenSearch domain, uploads data, searches documents, and cleans up resources
# Based on the tested and working 4-tutorial-final.md
# FIXES IN V8-FIXED:
# 1. Fixed syntax error with regex pattern matching
# 2. Fixed access policy to be more permissive and work with fine-grained access control
# 3. Added proper resource-based policy that allows both IAM and internal user database access
# 4. Improved authentication test with better error handling
# 5. Better debugging and troubleshooting information
set -e # Exit on any error
# Set up logging
LOG_FILE="opensearch_tutorial_v8_fixed.log"
exec > >(tee -a "$LOG_FILE") 2>&1
echo "Starting Amazon OpenSearch Service tutorial script v8-fixed at $(date)"
echo "All commands and outputs will be logged to $LOG_FILE"
# Track if domain was successfully created
DOMAIN_CREATED=false
DOMAIN_ACTIVE=false
# Error handling function
handle_error() {
echo "ERROR: $1"
echo "Attempting to clean up resources..."
cleanup_resources
exit 1
}
# Function to clean up resources
cleanup_resources() {
echo "Cleaning up resources..."
if [[ "$DOMAIN_CREATED" == "true" ]]; then
echo "Checking if domain $DOMAIN_NAME exists before attempting to delete..."
# Check if domain exists before trying to delete
if aws opensearch describe-domain --domain-name "$DOMAIN_NAME" > /dev/null 2>&1; then
echo "Domain $DOMAIN_NAME exists. Proceeding with deletion."
aws opensearch delete-domain --domain-name "$DOMAIN_NAME"
echo "Domain deletion initiated. This may take several minutes to complete."
else
echo "Domain $DOMAIN_NAME does not exist or is not accessible. No deletion needed."
fi
else
echo "No domain was successfully created. Nothing to clean up."
fi
}
# Set up trap for cleanup on script exit
trap cleanup_resources EXIT
# Generate a random identifier for resource names to avoid conflicts
RANDOM_ID=$(openssl rand -hex 4)
DOMAIN_NAME="movies-${RANDOM_ID}"
MASTER_USER="master-user"
MASTER_PASSWORD='Master-Password123!'
echo "Using domain name: $DOMAIN_NAME"
echo "Using master username: $MASTER_USER"
echo "Using master password: $MASTER_PASSWORD"
# Get AWS account ID (matches tutorial)
echo "Retrieving AWS account ID..."
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
if [[ $? -ne 0 ]] || [[ -z "$ACCOUNT_ID" ]]; then
handle_error "Failed to retrieve AWS account ID. Please check your AWS credentials."
fi
echo "AWS Account ID: $ACCOUNT_ID"
# Get current region (matches tutorial)
echo "Retrieving current AWS region..."
AWS_REGION=$(aws configure get region)
if [[ -z "$AWS_REGION" ]]; then
AWS_REGION="us-east-1"
echo "No region found in AWS config, defaulting to $AWS_REGION"
else
echo "Using AWS region: $AWS_REGION"
fi
# Step 1: Create an OpenSearch Service Domain
echo "Creating OpenSearch Service domain..."
echo "This may take 15-30 minutes to complete."
# FIXED: Create a more permissive access policy that works with fine-grained access control
# This policy allows both IAM users and the internal user database to work
ACCESS_POLICY="{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":\"*\"},\"Action\":[\"es:ESHttpGet\",\"es:ESHttpPut\",\"es:ESHttpPost\",\"es:ESHttpDelete\",\"es:ESHttpHead\"],\"Resource\":\"arn:aws:es:${AWS_REGION}:${ACCOUNT_ID}:domain/${DOMAIN_NAME}/*\"}]}"
echo "Access policy created for region: $AWS_REGION"
echo "Access policy: $ACCESS_POLICY"
# Create the domain (matches tutorial command exactly)
echo "Creating domain $DOMAIN_NAME..."
CREATE_OUTPUT=$(aws opensearch create-domain \
--domain-name "$DOMAIN_NAME" \
--engine-version "OpenSearch_2.11" \
--cluster-config "InstanceType=t3.small.search,InstanceCount=1,ZoneAwarenessEnabled=false" \
--ebs-options "EBSEnabled=true,VolumeType=gp3,VolumeSize=10" \
--node-to-node-encryption-options "Enabled=true" \
--encryption-at-rest-options "Enabled=true" \
--domain-endpoint-options "EnforceHTTPS=true" \
--advanced-security-options "Enabled=true,InternalUserDatabaseEnabled=true,MasterUserOptions={MasterUserName=$MASTER_USER,MasterUserPassword=$MASTER_PASSWORD}" \
--access-policies "$ACCESS_POLICY" 2>&1)
# Check if domain creation was successful
if [[ $? -ne 0 ]]; then
echo "Failed to create OpenSearch domain:"
echo "$CREATE_OUTPUT"
handle_error "Domain creation failed"
fi
# Verify the domain was actually created by checking the output
if echo "$CREATE_OUTPUT" | grep -q "DomainStatus"; then
echo "Domain creation initiated successfully."
DOMAIN_CREATED=true
else
echo "Domain creation output:"
echo "$CREATE_OUTPUT"
handle_error "Domain creation may have failed - no DomainStatus in response"
fi
# Wait for domain to become active (improved logic)
echo "Waiting for domain to become active..."
RETRY_COUNT=0
MAX_RETRIES=45 # 45 minutes with 60 second intervals
while [[ $RETRY_COUNT -lt $MAX_RETRIES ]]; do
echo "Checking domain status... (attempt $((RETRY_COUNT+1))/$MAX_RETRIES)"
# Get domain status
DOMAIN_STATUS=$(aws opensearch describe-domain --domain-name "$DOMAIN_NAME" 2>&1)
if [[ $? -ne 0 ]]; then
echo "Error checking domain status:"
echo "$DOMAIN_STATUS"
# If domain not found after several attempts, it likely failed to create
if [[ $RETRY_COUNT -gt 5 ]] && echo "$DOMAIN_STATUS" | grep -q "ResourceNotFoundException"; then
handle_error "Domain not found after multiple attempts. Domain creation likely failed."
fi
echo "Will retry in 60 seconds..."
else
# Check if domain is no longer processing
if echo "$DOMAIN_STATUS" | grep -q '"Processing": false'; then
DOMAIN_ACTIVE=true
echo "Domain is now active!"
break
else
echo "Domain is still being created. Checking again in 60 seconds..."
fi
fi
sleep 60
RETRY_COUNT=$((RETRY_COUNT+1))
done
# Verify domain is active
if [[ "$DOMAIN_ACTIVE" != "true" ]]; then
echo "Domain creation is taking longer than expected ($((MAX_RETRIES)) minutes)."
echo "You can check the status later using:"
echo "aws opensearch describe-domain --domain-name $DOMAIN_NAME"
handle_error "Domain did not become active within the expected time"
fi
# Get domain endpoint (matches tutorial)
echo "Retrieving domain endpoint..."
DOMAIN_ENDPOINT=$(aws opensearch describe-domain --domain-name "$DOMAIN_NAME" --query 'DomainStatus.Endpoint' --output text)
if [[ $? -ne 0 ]] || [[ -z "$DOMAIN_ENDPOINT" ]] || [[ "$DOMAIN_ENDPOINT" == "None" ]]; then
handle_error "Failed to get domain endpoint"
fi
echo "Domain endpoint: $DOMAIN_ENDPOINT"
# Wait additional time for fine-grained access control to be fully ready
echo "Domain is active, but waiting additional time for fine-grained access control to be fully ready..."
echo "Fine-grained access control can take several minutes to initialize after domain becomes active."
echo "Waiting 8 minutes for full initialization..."
sleep 480 # Wait 8 minutes for fine-grained access control to be ready
# Verify variables are set correctly (matches tutorial)
echo "Verifying configuration..."
echo "Domain endpoint: $DOMAIN_ENDPOINT"
echo "Master user: $MASTER_USER"
echo "Password set: $(if [ -n "$MASTER_PASSWORD" ]; then echo "Yes"; else echo "No"; fi)"
# Step 2: Upload Data to the Domain
echo "Preparing to upload data to the domain..."
# Create a file for the single document (matches tutorial exactly)
echo "Creating single document JSON file..."
cat > single_movie.json << EOF
{
"director": "Burton, Tim",
"genre": ["Comedy","Sci-Fi"],
"year": 1996,
"actor": ["Jack Nicholson","Pierce Brosnan","Sarah Jessica Parker"],
"title": "Mars Attacks!"
}
EOF
# Create a file for bulk documents (matches tutorial exactly)
echo "Creating bulk documents JSON file..."
cat > bulk_movies.json << EOF
{ "index" : { "_index": "movies", "_id" : "2" } }
{"director": "Frankenheimer, John", "genre": ["Drama", "Mystery", "Thriller", "Crime"], "year": 1962, "actor": ["Lansbury, Angela", "Sinatra, Frank", "Leigh, Janet", "Harvey, Laurence", "Silva, Henry", "Frees, Paul", "Gregory, James", "Bissell, Whit", "McGiver, John", "Parrish, Leslie", "Edwards, James", "Flowers, Bess", "Dhiegh, Khigh", "Payne, Julie", "Kleeb, Helen", "Gray, Joe", "Nalder, Reggie", "Stevens, Bert", "Masters, Michael", "Lowell, Tom"], "title": "The Manchurian Candidate"}
{ "index" : { "_index": "movies", "_id" : "3" } }
{"director": "Baird, Stuart", "genre": ["Action", "Crime", "Thriller"], "year": 1998, "actor": ["Downey Jr., Robert", "Jones, Tommy Lee", "Snipes, Wesley", "Pantoliano, Joe", "Jacob, Irène", "Nelligan, Kate", "Roebuck, Daniel", "Malahide, Patrick", "Richardson, LaTanya", "Wood, Tom", "Kosik, Thomas", "Stellate, Nick", "Minkoff, Robert", "Brown, Spitfire", "Foster, Reese", "Spielbauer, Bruce", "Mukherji, Kevin", "Cray, Ed", "Fordham, David", "Jett, Charlie"], "title": "U.S. Marshals"}
{ "index" : { "_index": "movies", "_id" : "4" } }
{"director": "Ray, Nicholas", "genre": ["Drama", "Romance"], "year": 1955, "actor": ["Hopper, Dennis", "Wood, Natalie", "Dean, James", "Mineo, Sal", "Backus, Jim", "Platt, Edward", "Ray, Nicholas", "Hopper, William", "Allen, Corey", "Birch, Paul", "Hudson, Rochelle", "Doran, Ann", "Hicks, Chuck", "Leigh, Nelson", "Williams, Robert", "Wessel, Dick", "Bryar, Paul", "Sessions, Almira", "McMahon, David", "Peters Jr., House"], "title": "Rebel Without a Cause"}
EOF
# Check if curl is installed
if ! command -v curl &> /dev/null; then
echo "Warning: curl is not installed. Skipping data upload and search steps."
echo "You can manually upload the data later using the commands in the tutorial."
else
# IMPROVED: Test authentication with multiple approaches
echo "Testing authentication with the OpenSearch domain..."
echo "This test checks if fine-grained access control is ready for data operations."
# Test 1: Basic authentication with root endpoint
echo "Testing basic authentication with root endpoint..."
AUTH_TEST_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/" 2>&1)
echo "Basic auth test result:"
echo "$AUTH_TEST_RESULT"
# Extract HTTP status code
HTTP_CODE=$(echo "$AUTH_TEST_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
# Function to check if HTTP code is 2xx
is_success_code() {
local code=$1
if [[ "$code" =~ ^2[0-9][0-9]$ ]]; then
return 0
else
return 1
fi
}
# Check if basic authentication test was successful (200 or 2xx status codes)
if is_success_code "$HTTP_CODE"; then
echo "✓ Basic authentication test successful! (HTTP $HTTP_CODE)"
AUTH_SUCCESS=true
AUTH_METHOD="basic"
else
echo "Basic authentication failed with HTTP code: $HTTP_CODE"
# Test 2: Try cluster health endpoint
echo "Testing with cluster health endpoint..."
HEALTH_TEST_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/_cluster/health" 2>&1)
echo "Cluster health test result:"
echo "$HEALTH_TEST_RESULT"
HEALTH_HTTP_CODE=$(echo "$HEALTH_TEST_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
if is_success_code "$HEALTH_HTTP_CODE"; then
echo "✓ Cluster health authentication test successful! (HTTP $HEALTH_HTTP_CODE)"
AUTH_SUCCESS=true
AUTH_METHOD="basic"
else
echo "Cluster health authentication also failed with HTTP code: $HEALTH_HTTP_CODE"
# Check for specific error patterns
if echo "$AUTH_TEST_RESULT" | grep -q "anonymous is not authorized"; then
echo "Error: Request is being treated as anonymous (authentication not working)"
elif echo "$AUTH_TEST_RESULT" | grep -q "Unauthorized"; then
echo "Error: Authentication credentials rejected"
elif echo "$AUTH_TEST_RESULT" | grep -q "Forbidden"; then
echo "Error: Authentication succeeded but access is forbidden"
fi
echo "Waiting additional time and retrying with exponential backoff..."
# Retry authentication test with exponential backoff
AUTH_RETRY_COUNT=0
MAX_AUTH_RETRIES=5
WAIT_TIME=60
AUTH_SUCCESS=false
while [[ $AUTH_RETRY_COUNT -lt $MAX_AUTH_RETRIES ]]; do
echo "Retrying authentication test (attempt $((AUTH_RETRY_COUNT+1))/$MAX_AUTH_RETRIES) after ${WAIT_TIME} seconds..."
sleep $WAIT_TIME
# Try both endpoints
AUTH_TEST_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/" 2>&1)
HTTP_CODE=$(echo "$AUTH_TEST_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
echo "Retry result (HTTP $HTTP_CODE):"
echo "$AUTH_TEST_RESULT"
if is_success_code "$HTTP_CODE"; then
echo "✓ Authentication test successful after retry! (HTTP $HTTP_CODE)"
AUTH_SUCCESS=true
AUTH_METHOD="basic"
break
fi
# Also try cluster health
HEALTH_TEST_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/_cluster/health" 2>&1)
HEALTH_HTTP_CODE=$(echo "$HEALTH_TEST_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
if is_success_code "$HEALTH_HTTP_CODE"; then
echo "✓ Cluster health authentication successful after retry! (HTTP $HEALTH_HTTP_CODE)"
AUTH_SUCCESS=true
AUTH_METHOD="basic"
break
fi
AUTH_RETRY_COUNT=$((AUTH_RETRY_COUNT+1))
# Exponential backoff: double the wait time each retry (max 10 minutes)
WAIT_TIME=$((WAIT_TIME * 2))
if [[ $WAIT_TIME -gt 600 ]]; then
WAIT_TIME=600
fi
done
fi
fi
# Proceed with data operations if authentication is working
if [[ "$AUTH_SUCCESS" == "true" ]]; then
echo "Authentication successful using $AUTH_METHOD method. Proceeding with data operations."
# Upload single document (matches tutorial exactly)
echo "Uploading single document..."
UPLOAD_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request PUT \
--header 'Content-Type: application/json' \
--data @single_movie.json \
"https://${DOMAIN_ENDPOINT}/movies/_doc/1" 2>&1)
echo "Upload response:"
echo "$UPLOAD_RESULT"
UPLOAD_HTTP_CODE=$(echo "$UPLOAD_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
if is_success_code "$UPLOAD_HTTP_CODE" && echo "$UPLOAD_RESULT" | grep -q '"result"'; then
echo "✓ Single document uploaded successfully! (HTTP $UPLOAD_HTTP_CODE)"
else
echo "⚠ Warning: Single document upload may have failed (HTTP $UPLOAD_HTTP_CODE)"
fi
# Upload bulk documents (matches tutorial exactly)
echo "Uploading bulk documents..."
BULK_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request POST \
--header 'Content-Type: application/x-ndjson' \
--data-binary @bulk_movies.json \
"https://${DOMAIN_ENDPOINT}/movies/_bulk" 2>&1)
echo "Bulk upload response:"
echo "$BULK_RESULT"
BULK_HTTP_CODE=$(echo "$BULK_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
if is_success_code "$BULK_HTTP_CODE" && echo "$BULK_RESULT" | grep -q '"errors": false'; then
echo "✓ Bulk documents uploaded successfully! (HTTP $BULK_HTTP_CODE)"
else
echo "⚠ Warning: Bulk document upload may have failed (HTTP $BULK_HTTP_CODE)"
fi
# Wait a moment for indexing
echo "Waiting for documents to be indexed..."
sleep 5
# Step 3: Search Documents (matches tutorial exactly)
echo "Searching for documents containing 'mars'..."
SEARCH_RESULT=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/movies/_search?q=mars&pretty=true" 2>&1)
SEARCH_HTTP_CODE=$(echo "$SEARCH_RESULT" | grep "HTTP_CODE:" | cut -d: -f2)
echo "Search results for 'mars' (HTTP $SEARCH_HTTP_CODE):"
echo "$SEARCH_RESULT"
echo "Searching for documents containing 'rebel'..."
REBEL_SEARCH=$(curl -s -w "\nHTTP_CODE:%{http_code}" \
--user "${MASTER_USER}:${MASTER_PASSWORD}" \
--request GET \
"https://${DOMAIN_ENDPOINT}/movies/_search?q=rebel&pretty=true" 2>&1)
REBEL_HTTP_CODE=$(echo "$REBEL_SEARCH" | grep "HTTP_CODE:" | cut -d: -f2)
echo "Search results for 'rebel' (HTTP $REBEL_HTTP_CODE):"
echo "$REBEL_SEARCH"
# Verify search results
if is_success_code "$SEARCH_HTTP_CODE" && echo "$SEARCH_RESULT" | grep -q '"hits"'; then
echo "✓ Search functionality is working!"
else
echo "⚠ Warning: Search may not be working properly."
fi
else
echo ""
echo "=========================================="
echo "AUTHENTICATION TROUBLESHOOTING"
echo "=========================================="
echo "Authentication failed after all retries. This may be due to:"
echo "1. Fine-grained access control not fully initialized (most common)"
echo "2. Domain configuration issues"
echo "3. Network connectivity issues"
echo "4. AWS credentials or permissions issues"
echo ""
echo "DOMAIN CONFIGURATION DEBUG:"
echo "Let's check the domain configuration..."
# Debug domain configuration
DOMAIN_CONFIG=$(aws opensearch describe-domain --domain-name "$DOMAIN_NAME" --query 'DomainStatus.{AdvancedSecurityOptions: AdvancedSecurityOptions, AccessPolicies: AccessPolicies}' --output json 2>&1)
echo "Domain configuration:"
echo "$DOMAIN_CONFIG"
echo ""
echo "MANUAL TESTING COMMANDS:"
echo "You can try these commands manually in 10-15 minutes:"
echo ""
echo "# Test basic authentication:"
echo "curl --user \"${MASTER_USER}:${MASTER_PASSWORD}\" \"https://${DOMAIN_ENDPOINT}/\""
echo ""
echo "# Test cluster health:"
echo "curl --user \"${MASTER_USER}:${MASTER_PASSWORD}\" \"https://${DOMAIN_ENDPOINT}/_cluster/health\""
echo ""
echo "# Upload single document:"
echo "curl --user \"${MASTER_USER}:${MASTER_PASSWORD}\" --request PUT --header 'Content-Type: application/json' --data @single_movie.json \"https://${DOMAIN_ENDPOINT}/movies/_doc/1\""
echo ""
echo "# Search for documents:"
echo "curl --user \"${MASTER_USER}:${MASTER_PASSWORD}\" \"https://${DOMAIN_ENDPOINT}/movies/_search?q=mars&pretty=true\""
echo ""
echo "TROUBLESHOOTING TIPS:"
echo "- Wait 10-15 more minutes and try the manual commands"
echo "- Check AWS CloudTrail logs for authentication errors"
echo "- Verify your AWS region is correct: $AWS_REGION"
echo "- Ensure your AWS credentials have OpenSearch permissions"
echo "- Try accessing OpenSearch Dashboards to verify the master user works"
echo ""
echo "Skipping data upload and search operations for now."
echo "The domain is created and accessible via OpenSearch Dashboards."
fi
fi
# Display OpenSearch Dashboards URL (matches tutorial)
echo ""
echo "==========================================="
echo "OPENSEARCH DASHBOARDS ACCESS"
echo "==========================================="
echo "OpenSearch Dashboards URL: https://${DOMAIN_ENDPOINT}/_dashboards/"
echo "Username: $MASTER_USER"
echo "Password: $MASTER_PASSWORD"
echo ""
echo "You can access OpenSearch Dashboards using these credentials."
echo "If you uploaded data successfully, you can create an index pattern for 'movies'."
echo ""
# Summary of created resources
echo ""
echo "==========================================="
echo "RESOURCES CREATED"
echo "==========================================="
echo "OpenSearch Domain Name: $DOMAIN_NAME"
echo "OpenSearch Domain Endpoint: $DOMAIN_ENDPOINT"
echo "AWS Region: $AWS_REGION"
echo "Master Username: $MASTER_USER"
echo "Master Password: $MASTER_PASSWORD"
echo ""
echo "ESTIMATED COST: ~$0.038/hour (~$0.91/day) until deleted"
echo ""
echo "Make sure to save these details for future reference."
echo ""
# Ask user if they want to clean up resources
echo ""
echo "==========================================="
echo "CLEANUP CONFIRMATION"
echo "==========================================="
echo "Do you want to clean up all created resources now? (y/n): "
read -r CLEANUP_CHOICE
if [[ "${CLEANUP_CHOICE,,}" == "y" ]]; then
echo "Cleaning up resources..."
aws opensearch delete-domain --domain-name "$DOMAIN_NAME"
echo "✓ Cleanup initiated. Domain deletion may take several minutes to complete."
echo ""
echo "You can check the deletion status using:"
echo "aws opensearch describe-domain --domain-name $DOMAIN_NAME"
echo ""
echo "When deletion is complete, you'll see a 'Domain not found' error."
else
echo "Resources will NOT be deleted automatically."
echo ""
echo "To delete the domain later, use:"
echo "aws opensearch delete-domain --domain-name $DOMAIN_NAME"
echo ""
echo "⚠ IMPORTANT: Keeping these resources will incur ongoing AWS charges!"
echo " Estimated cost: ~$0.038/hour (~$0.91/day)"
fi
# Clean up temporary files
echo "Cleaning up temporary files..."
rm -f single_movie.json bulk_movies.json
# Disable the trap since we're handling cleanup manually
trap - EXIT
echo ""
echo "==========================================="
echo "SCRIPT COMPLETED SUCCESSFULLY"
echo "==========================================="
echo "Script completed at $(date)"
echo "All output has been logged to: $LOG_FILE"
echo ""
echo "Next steps:"
echo "1. Access OpenSearch Dashboards at: https://${DOMAIN_ENDPOINT}/_dashboards/"
echo "2. Create visualizations and dashboards"
echo "3. Explore the OpenSearch API"
echo "4. Remember to delete resources when done to avoid charges"
```
+ For API details, see the following topics in *AWS CLI Command Reference*.
+ [CreateDomain](https://docs.aws.amazon.com/goto/aws-cli/es-2021-01-01/CreateDomain)
+ [DeleteDomain](https://docs.aws.amazon.com/goto/aws-cli/es-2021-01-01/DeleteDomain)
+ [DescribeDomain](https://docs.aws.amazon.com/goto/aws-cli/es-2021-01-01/DescribeDomain)
+ [GetCallerIdentity](https://docs.aws.amazon.com/goto/aws-cli/sts-2011-06-15/GetCallerIdentity)
------