instanceCheckFuture;
private static NeptuneAsyncClient neptuneAsyncClient;
private final Region region = Region.US_EAST_1;
private static final Logger logger = LoggerFactory.getLogger(NeptuneActions.class);
private final NeptuneClient neptuneClient = NeptuneClient.builder().region(region).build();
/**
* Retrieves an instance of the NeptuneAsyncClient.
*
* This method initializes and returns a singleton instance of the NeptuneAsyncClient. The client
* is configured with the following settings:
*
* - Maximum concurrency: 100
* - Connection timeout: 60 seconds
* - Read timeout: 60 seconds
* - Write timeout: 60 seconds
* - API call timeout: 2 minutes
* - API call attempt timeout: 90 seconds
* - Retry strategy: STANDARD
*
* The client is built using the NettyNioAsyncHttpClient.
*
* @return the singleton instance of the NeptuneAsyncClient
*/
private static NeptuneAsyncClient getAsyncClient() {
if (neptuneAsyncClient == 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))
.retryStrategy(RetryMode.STANDARD)
.build();
neptuneAsyncClient = NeptuneAsyncClient.builder()
.httpClient(httpClient)
.overrideConfiguration(overrideConfig)
.build();
}
return neptuneAsyncClient;
}
/**
* Asynchronously deletes a set of Amazon Neptune resources in a defined order.
*
* The method performs the following operations in sequence:
*
* - Deletes the Neptune DB instance identified by {@code dbInstanceId}.
* - Waits until the DB instance is fully deleted.
* - Deletes the Neptune DB cluster identified by {@code dbClusterId}.
* - Deletes the Neptune DB subnet group identified by {@code subnetGroupName}.
*
*
* If any step fails, the subsequent operations are not performed, and the exception
* is logged. This method blocks the calling thread until all operations complete.
*
* @param dbInstanceId the ID of the Neptune DB instance to delete
* @param dbClusterId the ID of the Neptune DB cluster to delete
* @param subnetGroupName the name of the Neptune DB subnet group to delete
*/
public void deleteNeptuneResourcesAsync(String dbInstanceId, String dbClusterId, String subnetGroupName) {
deleteDBInstanceAsync(dbInstanceId)
.thenCompose(v -> waitUntilInstanceDeletedAsync(dbInstanceId))
.thenCompose(v -> deleteDBClusterAsync(dbClusterId))
.thenCompose(v -> deleteDBSubnetGroupAsync(subnetGroupName))
.whenComplete((v, ex) -> {
if (ex != null) {
logger.info("Failed to delete Neptune resources: " + ex.getMessage());
} else {
logger.info("Neptune resources deleted successfully.");
}
})
.join(); // Waits for the entire async chain to complete
}
/**
* Deletes a subnet group.
*
* @param subnetGroupName the identifier of the subnet group to delete
* @return a {@link CompletableFuture} that completes when the cluster has been deleted
*/
public CompletableFuture deleteDBSubnetGroupAsync(String subnetGroupName) {
DeleteDbSubnetGroupRequest request = DeleteDbSubnetGroupRequest.builder()
.dbSubnetGroupName(subnetGroupName)
.build();
return getAsyncClient().deleteDBSubnetGroup(request)
.thenAccept(response -> logger.info("šļø Deleting Subnet Group: " + subnetGroupName));
}
/**
* Deletes a DB instance asynchronously.
*
* @param clusterId the identifier of the cluster to delete
* @return a {@link CompletableFuture} that completes when the cluster has been deleted
*/
public CompletableFuture deleteDBClusterAsync(String clusterId) {
DeleteDbClusterRequest request = DeleteDbClusterRequest.builder()
.dbClusterIdentifier(clusterId)
.skipFinalSnapshot(true)
.build();
return getAsyncClient().deleteDBCluster(request)
.thenAccept(response -> System.out.println("šļø Deleting DB Cluster: " + clusterId));
}
public CompletableFuture waitUntilInstanceDeletedAsync(String instanceId) {
CompletableFuture future = new CompletableFuture<>();
long startTime = System.currentTimeMillis();
checkInstanceDeletedRecursive(instanceId, startTime, future);
return future;
}
/**
* Deletes a DB instance asynchronously.
*
* @param instanceId the identifier of the DB instance to be deleted
* @return a {@link CompletableFuture} that completes when the DB instance has been deleted
*/
public CompletableFuture deleteDBInstanceAsync(String instanceId) {
DeleteDbInstanceRequest request = DeleteDbInstanceRequest.builder()
.dbInstanceIdentifier(instanceId)
.skipFinalSnapshot(true)
.build();
return getAsyncClient().deleteDBInstance(request)
.thenAccept(response -> System.out.println("šļø Deleting DB Instance: " + instanceId));
}
private void checkInstanceDeletedRecursive(String instanceId, long startTime, CompletableFuture future) {
DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
.dbInstanceIdentifier(instanceId)
.build();
getAsyncClient().describeDBInstances(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof NeptuneException &&
((NeptuneException) cause).awsErrorDetails().errorCode().equals("DBInstanceNotFound")) {
long elapsed = (System.currentTimeMillis() - startTime) / 1000;
logger.info("\r Instance %s deleted after %ds%n", instanceId, elapsed);
future.complete(null);
return;
}
future.completeExceptionally(new CompletionException("Error polling DB instance", cause));
return;
}
String status = response.dbInstances().get(0).dbInstanceStatus();
long elapsed = (System.currentTimeMillis() - startTime) / 1000;
System.out.printf("\r Waiting: Instance %s status: %-10s (%ds elapsed)", instanceId, status, elapsed);
System.out.flush();
CompletableFuture.delayedExecutor(20, TimeUnit.SECONDS)
.execute(() -> checkInstanceDeletedRecursive(instanceId, startTime, future));
});
}
public void waitForClusterStatus(String clusterId, String desiredStatus) {
System.out.printf("Waiting for cluster '%s' to reach status '%s'...\n", clusterId, desiredStatus);
CompletableFuture future = new CompletableFuture<>();
checkClusterStatusRecursive(clusterId, desiredStatus, System.currentTimeMillis(), future);
future.join();
}
private void checkClusterStatusRecursive(String clusterId, String desiredStatus, long startTime, CompletableFuture future) {
DescribeDbClustersRequest request = DescribeDbClustersRequest.builder()
.dbClusterIdentifier(clusterId)
.build();
getAsyncClient().describeDBClusters(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
future.completeExceptionally(
new CompletionException("Error checking Neptune cluster status", cause)
);
return;
}
List clusters = response.dbClusters();
if (clusters.isEmpty()) {
future.completeExceptionally(new RuntimeException("Cluster not found: " + clusterId));
return;
}
String currentStatus = clusters.get(0).status();
long elapsedSeconds = (System.currentTimeMillis() - startTime) / 1000;
System.out.printf("\r Elapsed: %-20s Cluster status: %-20s", formatElapsedTime((int) elapsedSeconds), currentStatus);
System.out.flush();
if (desiredStatus.equalsIgnoreCase(currentStatus)) {
System.out.printf("\r Neptune cluster reached desired status '%s' after %s.\n", desiredStatus, formatElapsedTime((int) elapsedSeconds));
future.complete(null);
} else {
CompletableFuture.delayedExecutor(20, TimeUnit.SECONDS)
.execute(() -> checkClusterStatusRecursive(clusterId, desiredStatus, startTime, future));
}
});
}
/**
* Starts an Amazon Neptune DB cluster.
*
* @param clusterIdentifier the unique identifier of the DB cluster to be stopped
*/
public CompletableFuture startDBClusterAsync(String clusterIdentifier) {
StartDbClusterRequest clusterRequest = StartDbClusterRequest.builder()
.dbClusterIdentifier(clusterIdentifier)
.build();
return getAsyncClient().startDBCluster(clusterRequest)
.whenComplete((response, error) -> {
if (error != null) {
Throwable cause = error.getCause() != null ? error.getCause() : error;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to start DB cluster: " + cause.getMessage(), cause);
} else {
logger.info("DB Cluster starting: " + clusterIdentifier);
}
});
}
/**
* Stops an Amazon Neptune DB cluster.
*
* @param clusterIdentifier the unique identifier of the DB cluster to be stopped
*/
public CompletableFuture stopDBClusterAsync(String clusterIdentifier) {
StopDbClusterRequest clusterRequest = StopDbClusterRequest.builder()
.dbClusterIdentifier(clusterIdentifier)
.build();
return getAsyncClient().stopDBCluster(clusterRequest)
.whenComplete((response, error) -> {
if (error != null) {
Throwable cause = error.getCause() != null ? error.getCause() : error;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to stop DB cluster: " + cause.getMessage(), cause);
} else {
logger.info("DB Cluster stopped: " + clusterIdentifier);
}
});
}
/**
* Asynchronously describes the specified Amazon RDS DB cluster.
*
* @param clusterId the identifier of the DB cluster to describe
* @return a {@link CompletableFuture} that completes when the operation is done, or throws a {@link RuntimeException}
* if an error occurs
*/
public CompletableFuture describeDBClustersAsync(String clusterId) {
DescribeDbClustersRequest request = DescribeDbClustersRequest.builder()
.dbClusterIdentifier(clusterId)
.build();
return getAsyncClient().describeDBClusters(request)
.thenAccept(response -> {
for (DBCluster cluster : response.dbClusters()) {
logger.info("Cluster Identifier: " + cluster.dbClusterIdentifier());
logger.info("Status: " + cluster.status());
logger.info("Engine: " + cluster.engine());
logger.info("Engine Version: " + cluster.engineVersion());
logger.info("Endpoint: " + cluster.endpoint());
logger.info("Reader Endpoint: " + cluster.readerEndpoint());
logger.info("Availability Zones: " + cluster.availabilityZones());
logger.info("Subnet Group: " + cluster.dbSubnetGroup());
logger.info("VPC Security Groups:");
cluster.vpcSecurityGroups().forEach(vpcGroup ->
logger.info(" - " + vpcGroup.vpcSecurityGroupId()));
logger.info("Storage Encrypted: " + cluster.storageEncrypted());
logger.info("IAM DB Auth Enabled: " + cluster.iamDatabaseAuthenticationEnabled());
logger.info("Backup Retention Period: " + cluster.backupRetentionPeriod() + " days");
logger.info("Preferred Backup Window: " + cluster.preferredBackupWindow());
logger.info("Preferred Maintenance Window: " + cluster.preferredMaintenanceWindow());
logger.info("------");
}
})
.exceptionally(ex -> {
Throwable cause = ex.getCause() != null ? ex.getCause() : ex;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to describe the DB cluster: " + cause.getMessage(), cause);
});
}
public CompletableFuture checkInstanceStatus(String instanceId, String desiredStatus) {
CompletableFuture future = new CompletableFuture<>();
long startTime = System.currentTimeMillis();
checkStatusRecursive(instanceId, desiredStatus.toLowerCase(), startTime, future);
return future;
}
/**
* Checks the status of a Neptune instance recursively until the desired status is reached or a timeout occurs.
*
* @param instanceId the ID of the Neptune instance to check
* @param desiredStatus the desired status of the Neptune instance
* @param startTime the start time of the operation, used to calculate the elapsed time
* @param future a {@link CompletableFuture} that will be completed when the desired status is reached
*/
private void checkStatusRecursive(String instanceId, String desiredStatus, long startTime, CompletableFuture future) {
DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
.dbInstanceIdentifier(instanceId)
.build();
getAsyncClient().describeDBInstances(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
future.completeExceptionally(
new CompletionException("Error checking Neptune instance status", cause)
);
return;
}
List instances = response.dbInstances();
if (instances.isEmpty()) {
future.completeExceptionally(new RuntimeException("Instance not found: " + instanceId));
return;
}
String currentStatus = instances.get(0).dbInstanceStatus();
long elapsedSeconds = (System.currentTimeMillis() - startTime) / 1000;
System.out.printf("\r Elapsed: %-20s Status: %-20s", formatElapsedTime((int) elapsedSeconds), currentStatus);
System.out.flush();
if (desiredStatus.equalsIgnoreCase(currentStatus)) {
System.out.printf("\r Neptune instance reached desired status '%s' after %s.\n", desiredStatus, formatElapsedTime((int) elapsedSeconds));
future.complete(null);
} else {
CompletableFuture.delayedExecutor(20, TimeUnit.SECONDS)
.execute(() -> checkStatusRecursive(instanceId, desiredStatus, startTime, future));
}
});
}
private String formatElapsedTime(int seconds) {
int minutes = seconds / 60;
int remainingSeconds = seconds % 60;
if (minutes > 0) {
return minutes + (minutes == 1 ? " min" : " mins") + ", " +
remainingSeconds + (remainingSeconds == 1 ? " sec" : " secs");
} else {
return remainingSeconds + (remainingSeconds == 1 ? " sec" : " secs");
}
}
/**
* Creates a new Amazon Neptune DB instance asynchronously.
*
* @param dbInstanceId the identifier for the new DB instance
* @param dbClusterId the identifier for the DB cluster that the new instance will be a part of
* @return a {@link CompletableFuture} that completes with the identifier of the newly created DB instance
* @throws CompletionException if the operation fails, with a cause of either:
* - {@link ServiceQuotaExceededException} if the request would exceed the maximum quota, or
* - a general exception with the failure message
*/
public CompletableFuture createDBInstanceAsync(String dbInstanceId, String dbClusterId) {
CreateDbInstanceRequest request = CreateDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceId)
.dbInstanceClass("db.r5.large")
.engine("neptune")
.dbClusterIdentifier(dbClusterId)
.build();
return getAsyncClient().createDBInstance(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create Neptune DB instance: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String instanceId = response.dbInstance().dbInstanceIdentifier();
logger.info("Created Neptune DB Instance: " + instanceId);
return instanceId;
});
}
/**
* Creates a new Amazon Neptune DB cluster asynchronously.
*
* @param dbName the name of the DB cluster to be created
* @return a CompletableFuture that, when completed, provides the ID of the created DB cluster
* @throws CompletionException if the operation fails for any reason, including if the request would exceed the maximum quota
*/
public CompletableFuture createDBClusterAsync(String dbName) {
CreateDbClusterRequest request = CreateDbClusterRequest.builder()
.dbClusterIdentifier(dbName)
.engine("neptune")
.deletionProtection(false)
.backupRetentionPeriod(1)
.build();
return getAsyncClient().createDBCluster(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create Neptune DB cluster: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String clusterId = response.dbCluster().dbClusterIdentifier();
logger.info("DB Cluster created: " + clusterId);
return clusterId;
});
}
/**
* Creates a new DB subnet group asynchronously.
*
* @param groupName the name of the subnet group to create
* @return a CompletableFuture that, when completed, returns the Amazon Resource Name (ARN) of the created subnet group
* @throws CompletionException if the operation fails, with a cause that may be a ServiceQuotaExceededException if the request would exceed the maximum quota
*/
public CompletableFuture createSubnetGroupAsync(String groupName) {
// Get the Amazon Virtual Private Cloud (VPC) where the Neptune cluster and resources will be created
String vpcId = getDefaultVpcId();
logger.info("VPC is : " + vpcId);
List subnetList = getSubnetIds(vpcId);
for (String subnetId : subnetList) {
System.out.println("Subnet group:" +subnetId);
}
CreateDbSubnetGroupRequest request = CreateDbSubnetGroupRequest.builder()
.dbSubnetGroupName(groupName)
.dbSubnetGroupDescription("Subnet group for Neptune cluster")
.subnetIds(subnetList)
.build();
return getAsyncClient().createDBSubnetGroup(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create subnet group: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String name = response.dbSubnetGroup().dbSubnetGroupName();
String arn = response.dbSubnetGroup().dbSubnetGroupArn();
logger.info("Subnet group created: " + name);
return arn;
});
}
private List getSubnetIds(String vpcId) {
try (Ec2Client ec2 = Ec2Client.builder().region(region).build()) {
DescribeSubnetsRequest request = DescribeSubnetsRequest.builder()
.filters(builder -> builder.name("vpc-id").values(vpcId))
.build();
DescribeSubnetsResponse response = ec2.describeSubnets(request);
return response.subnets().stream()
.map(Subnet::subnetId)
.collect(Collectors.toList());
}
}
public static String getDefaultVpcId() {
Ec2Client ec2 = Ec2Client.builder()
.region(Region.US_EAST_1)
.build();
Filter myFilter = Filter.builder()
.name("isDefault")
.values("true")
.build();
List filterList = new ArrayList<>();
filterList.add(myFilter);
DescribeVpcsRequest request = DescribeVpcsRequest.builder()
.filters(filterList)
.build();
DescribeVpcsResponse response = ec2.describeVpcs(request);
if (!response.vpcs().isEmpty()) {
Vpc defaultVpc = response.vpcs().get(0);
return defaultVpc.vpcId();
} else {
throw new RuntimeException("No default VPC found in this region.");
}
}
}
```
+ For API details, see the following topics in *AWS SDK for Java 2.x API Reference*.
+ [CreateDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBCluster)
+ [CreateDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBInstance)
+ [CreateDBSubnetGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBSubnetGroup)
+ [CreateGraph](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateGraph)
+ [DeleteDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBCluster)
+ [DeleteDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBInstance)
+ [DeleteDBSubnetGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBSubnetGroup)
+ [DescribeDBClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBClusters)
+ [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBInstances)
+ [ExecuteGremlinProfileQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinProfileQuery)
+ [ExecuteGremlinQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinQuery)
+ [ExecuteOpenCypherExplainQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteOpenCypherExplainQuery)
+ [ExecuteQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteQuery)
+ [StartDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StartDBCluster)
+ [StopDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StopDBCluster)
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
import boto3
import time
from botocore.exceptions import ClientError
# Constants used in this scenario
POLL_INTERVAL_SECONDS = 10
TIMEOUT_SECONDS = 1200 # 20 minutes
def delete_db_cluster(neptune_client, cluster_id: str):
"""
Deletes a Neptune DB cluster and throws exceptions to the caller.
Args:
neptune_client (boto3.client): The Neptune client object.
cluster_id (str): The ID of the Neptune DB cluster to be deleted.
Raises:
ClientError: If the delete operation fails.
"""
request = {
'DBClusterIdentifier': cluster_id,
'SkipFinalSnapshot': True
}
try:
print(f"Deleting DB Cluster: {cluster_id}")
neptune_client.delete_db_cluster(**request)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFoundFault":
print(f"Cluster '{cluster_id}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete DB cluster. {code}: {message}")
raise
def format_elapsed_time(seconds: int) -> str:
mins, secs = divmod(seconds, 60)
hours, mins = divmod(mins, 60)
return f"{hours:02}:{mins:02}:{secs:02}"
def delete_db_instance(neptune_client, instance_id: str):
"""
Deletes a Neptune DB instance and waits for its deletion to complete.
Raises exception to be handled by calling code.
"""
print(f"Initiating deletion of DB Instance: {instance_id}")
try:
neptune_client.delete_db_instance(
DBInstanceIdentifier=instance_id,
SkipFinalSnapshot=True
)
print(f"Waiting for DB Instance '{instance_id}' to be deleted...")
waiter = neptune_client.get_waiter('db_instance_deleted')
waiter.wait(
DBInstanceIdentifier=instance_id,
WaiterConfig={
'Delay': 30,
'MaxAttempts': 40
}
)
print(f"DB Instance '{instance_id}' successfully deleted.")
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBInstanceNotFoundFault":
print(f"Instance '{instance_id}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete DB instance. {code}: {message}")
raise
def delete_db_subnet_group(neptune_client, subnet_group_name):
"""
Deletes a Neptune DB subnet group synchronously using Boto3.
Args:
neptune_client (boto3.client): The Neptune client.
subnet_group_name (str): The name of the DB subnet group to delete.
Raises:
ClientError: If the delete operation fails.
"""
delete_group_request = {
'DBSubnetGroupName': subnet_group_name
}
try:
neptune_client.delete_db_subnet_group(**delete_group_request)
print(f"ļø Deleting Subnet Group: {subnet_group_name}")
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBSubnetGroupNotFoundFault":
print(f"Subnet group '{subnet_group_name}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete subnet group. {code}: {message}")
raise
def wait_for_cluster_status(
neptune_client,
cluster_id: str,
desired_status: str,
timeout_seconds: int = TIMEOUT_SECONDS,
poll_interval_seconds: int = POLL_INTERVAL_SECONDS
):
"""
Waits for a Neptune DB cluster to reach a desired status.
Args:
neptune_client (boto3.client): The Amazon Neptune client.
cluster_id (str): The identifier of the Neptune DB cluster.
desired_status (str): The target status (e.g., "available", "stopped").
timeout_seconds (int): Max time to wait in seconds (default: 1200).
poll_interval_seconds (int): Polling interval in seconds (default: 10).
Raises:
RuntimeError: If the desired status is not reached before timeout.
"""
print(f"Waiting for cluster '{cluster_id}' to reach status '{desired_status}'...")
start_time = time.time()
while True:
# Prepare request object
describe_cluster_request = {
'DBClusterIdentifier': cluster_id
}
# Call the Neptune API
response = neptune_client.describe_db_clusters(**describe_cluster_request)
clusters = response.get('DBClusters', [])
current_status = clusters[0].get('Status') if clusters else None
elapsed_seconds = int(time.time() - start_time)
status_str = current_status if current_status else "Unknown"
print(
f"\r Elapsed: {format_elapsed_time(elapsed_seconds):<20} Cluster status: {status_str:<20}",
end="", flush=True
)
if current_status and current_status.lower() == desired_status.lower():
print(
f"\nNeptune cluster reached desired status '{desired_status}' after {format_elapsed_time(elapsed_seconds)}."
)
return
if elapsed_seconds > timeout_seconds:
raise RuntimeError(f"Timeout waiting for Neptune cluster to reach status: {desired_status}")
time.sleep(poll_interval_seconds)
def start_db_cluster(neptune_client, cluster_identifier: str):
"""
Starts an Amazon Neptune DB cluster and waits until it reaches 'available'.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_identifier (str): The DB cluster identifier.
Raises:
ClientError: Propagates AWS API issues like resource not found.
RuntimeError: If cluster doesn't reach 'available' within timeout.
"""
try:
# Initial wait in case the cluster was just stopped
time.sleep(30)
neptune_client.start_db_cluster(DBClusterIdentifier=cluster_identifier)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't start DB cluster. Here's why: {code}: {message}")
raise
start_time = time.time()
paginator = neptune_client.get_paginator('describe_db_clusters')
while True:
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_identifier)
clusters = []
for page in pages:
clusters.extend(page.get('DBClusters', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFound":
print(f"Cluster '{cluster_identifier}' not found while polling. It may have been deleted.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
status = clusters[0].get('Status') if clusters else None
elapsed = time.time() - start_time
print(f"\rElapsed: {int(elapsed)}s ā Cluster status: {status}", end="", flush=True)
if status and status.lower() == 'available':
print(f"\nš Cluster '{cluster_identifier}' is available.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for cluster '{cluster_identifier}' to become available.")
time.sleep(POLL_INTERVAL_SECONDS)
def stop_db_cluster(neptune_client, cluster_identifier: str):
"""
Stops an Amazon Neptune DB cluster and waits until it's fully stopped.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_identifier (str): The DB cluster identifier.
Raises:
ClientError: For AWS API errors (e.g., resource not found).
RuntimeError: If the cluster doesn't stop within the timeout.
"""
try:
neptune_client.stop_db_cluster(DBClusterIdentifier=cluster_identifier)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't stop DB cluster. Here's why: {code}: {message}")
raise
start_time = time.time()
paginator = neptune_client.get_paginator('describe_db_clusters')
while True:
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_identifier)
clusters = []
for page in pages:
clusters.extend(page.get('DBClusters', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFound":
print(f"Cluster '{cluster_identifier}' not found while polling. It may have been deleted.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
status = clusters[0].get('Status') if clusters else None
elapsed = time.time() - start_time
print(f"\rElapsed: {int(elapsed)}s ā Cluster status: {status}", end="", flush=True)
if status and status.lower() == 'stopped':
print(f"\nCluster '{cluster_identifier}' is now stopped.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for cluster '{cluster_identifier}' to stop.")
time.sleep(POLL_INTERVAL_SECONDS)
def describe_db_clusters(neptune_client, cluster_id: str):
"""
Describes details of a Neptune DB cluster, paginating if needed.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_id (str): The ID of the cluster to describe.
Raises:
ClientError: If there's an AWS API error (e.g., cluster not found).
"""
paginator = neptune_client.get_paginator('describe_db_clusters')
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_id)
found = False
for page in pages:
for cluster in page.get('DBClusters', []):
found = True
print(f"Cluster Identifier: {cluster.get('DBClusterIdentifier')}")
print(f"Status: {cluster.get('Status')}")
print(f"Engine: {cluster.get('Engine')}")
print(f"Engine Version: {cluster.get('EngineVersion')}")
print(f"Endpoint: {cluster.get('Endpoint')}")
print(f"Reader Endpoint: {cluster.get('ReaderEndpoint')}")
print(f"Availability Zones: {cluster.get('AvailabilityZones')}")
print(f"Subnet Group: {cluster.get('DBSubnetGroup')}")
print("VPC Security Groups:")
for vpc_group in cluster.get('VpcSecurityGroups', []):
print(f" - {vpc_group.get('VpcSecurityGroupId')}")
print(f"Storage Encrypted: {cluster.get('StorageEncrypted')}")
print(f"IAM Auth Enabled: {cluster.get('IAMDatabaseAuthenticationEnabled')}")
print(f"Backup Retention Period: {cluster.get('BackupRetentionPeriod')} days")
print(f"Preferred Backup Window: {cluster.get('PreferredBackupWindow')}")
print(f"Preferred Maintenance Window: {cluster.get('PreferredMaintenanceWindow')}")
print("------")
if not found:
# Treat empty response as cluster not found
raise ClientError(
{"Error": {"Code": "DBClusterNotFound", "Message": f"No cluster found with ID '{cluster_id}'"}},
"DescribeDBClusters"
)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
elif code == "DBClusterNotFound":
print(f"Cluster '{cluster_id}' not found. Please verify the cluster ID.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
def check_instance_status(neptune_client, instance_id: str, desired_status: str):
"""
Polls the status of a Neptune DB instance until it reaches desired_status.
Uses pagination via describe_db_instances ā even for a single instance.
Raises:
ClientError: If describe_db_instances fails (e.g., instance not found).
RuntimeError: If timeout expires before reaching desired status.
"""
paginator = neptune_client.get_paginator('describe_db_instances')
start_time = time.time()
while True:
try:
pages = paginator.paginate(DBInstanceIdentifier=instance_id)
instances = []
for page in pages:
instances.extend(page.get('DBInstances', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBInstanceNotFound":
print(f"Instance '{instance_id}' not found. Please verify the instance ID.")
else:
print(f"Failed to describe DB instance. {code}: {message}")
raise
current_status = instances[0].get('DBInstanceStatus') if instances else None
elapsed = int(time.time() - start_time)
print(f"\rElapsed: {format_elapsed_time(elapsed)} Status: {current_status}", end="", flush=True)
if current_status and current_status.lower() == desired_status.lower():
print(f"\nInstance '{instance_id}' reached '{desired_status}' in {format_elapsed_time(elapsed)}.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for '{instance_id}' to reach '{desired_status}'")
time.sleep(POLL_INTERVAL_SECONDS)
def create_db_instance(neptune_client, db_instance_id: str, db_cluster_id: str) -> str:
try:
request = {
'DBInstanceIdentifier': db_instance_id,
'DBInstanceClass': 'db.r5.large',
'Engine': 'neptune',
'DBClusterIdentifier': db_cluster_id
}
print(f"Creating Neptune DB Instance: {db_instance_id}")
response = neptune_client.create_db_instance(**request)
instance = response.get('DBInstance')
if not instance or 'DBInstanceIdentifier' not in instance:
raise RuntimeError("Instance creation succeeded but no ID returned.")
print(f"Waiting for DB Instance '{db_instance_id}' to become available...")
waiter = neptune_client.get_waiter('db_instance_available')
waiter.wait(
DBInstanceIdentifier=db_instance_id,
WaiterConfig={'Delay': 30, 'MaxAttempts': 40}
)
print(f"DB Instance '{db_instance_id}' is now available.")
return instance['DBInstanceIdentifier']
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't create DB instance. Here's why: {code}: {message}")
raise
except Exception as e:
print(f"Unexpected error creating DB instance '{db_instance_id}': {e}")
raise RuntimeError(f"Unexpected error creating DB instance '{db_instance_id}': {e}") from e
def create_db_cluster(neptune_client, db_name: str) -> str:
"""
Creates a Neptune DB cluster and returns its identifier.
Args:
neptune_client (boto3.client): The Neptune client object.
db_name (str): The desired cluster identifier.
Returns:
str: The DB cluster identifier.
Raises:
RuntimeError: For any failure or AWS error, with a user-friendly message.
"""
request = {
'DBClusterIdentifier': db_name,
'Engine': 'neptune',
'DeletionProtection': False,
'BackupRetentionPeriod': 1
}
try:
response = neptune_client.create_db_cluster(**request)
cluster = response.get('DBCluster') or {}
cluster_id = cluster.get('DBClusterIdentifier')
if not cluster_id:
raise RuntimeError("Cluster created but no ID returned.")
print(f"DB Cluster created: {cluster_id}")
return cluster_id
except ClientError as e:
code = e.response["Error"]["Code"]
message = e.response["Error"]["Message"]
if code in ("ServiceQuotaExceededException", "DBClusterQuotaExceededFault"):
raise RuntimeError("You have exceeded the quota for Neptune DB clusters.") from e
else:
raise RuntimeError(f"AWS error [{code}]: {message}") from e
except Exception as e:
raise RuntimeError(f"Unexpected error creating DB cluster '{db_name}': {e}") from e
def get_subnet_ids(vpc_id: str) -> list[str]:
ec2_client = boto3.client('ec2')
describe_subnets_request = {
'Filters': [{'Name': 'vpc-id', 'Values': [vpc_id]}]
}
response = ec2_client.describe_subnets(**describe_subnets_request)
subnets = response.get('Subnets', [])
subnet_ids = [subnet['SubnetId'] for subnet in subnets if 'SubnetId' in subnet]
return subnet_ids
def get_default_vpc_id() -> str:
ec2_client = boto3.client('ec2')
describe_vpcs_request = {
'Filters': [{'Name': 'isDefault', 'Values': ['true']}]
}
response = ec2_client.describe_vpcs(**describe_vpcs_request)
vpcs = response.get('Vpcs', [])
if not vpcs:
raise RuntimeError("No default VPC found in this region.")
default_vpc_id = vpcs[0]['VpcId']
print(f"Default VPC ID: {default_vpc_id}")
return default_vpc_id
def create_subnet_group(neptune_client, group_name: str):
"""
Creates a Neptune DB subnet group and returns its name and ARN.
Args:
neptune_client (boto3.client): The Neptune client object.
group_name (str): The desired name of the subnet group.
Returns:
tuple(str, str): (subnet_group_name, subnet_group_arn)
Raises:
RuntimeError: For quota errors or other AWS-related failures.
"""
vpc_id = get_default_vpc_id()
subnet_ids = get_subnet_ids(vpc_id)
request = {
'DBSubnetGroupName': group_name,
'DBSubnetGroupDescription': 'My Neptune subnet group',
'SubnetIds': subnet_ids,
'Tags': [{'Key': 'Environment', 'Value': 'Dev'}]
}
try:
response = neptune_client.create_db_subnet_group(**request)
sg = response.get("DBSubnetGroup", {})
name = sg.get("DBSubnetGroupName")
arn = sg.get("DBSubnetGroupArn")
if not name or not arn:
raise RuntimeError("Response missing subnet group name or ARN.")
print(f"Subnet group created: {name}")
print(f"ARN: {arn}")
return name, arn
except ClientError as e:
code = e.response["Error"]["Code"]
msg = e.response["Error"]["Message"]
if code == "ServiceQuotaExceededException":
print("Subnet group quota exceeded.")
raise RuntimeError("Subnet group quota exceeded.") from e
else:
print(f"AWS error [{code}]: {msg}")
raise RuntimeError(f"AWS error [{code}]: {msg}") from e
except Exception as e:
print(f"Unexpected error creating subnet group '{group_name}': {e}")
raise RuntimeError(f"Unexpected error creating subnet group '{group_name}': {e}") from e
def wait_for_input_to_continue():
input("\nPress to continue...")
print("Continuing with the program...\n")
def run_scenario(neptune_client, subnet_group_name: str, db_instance_id: str, cluster_name: str):
print("-" * 88)
print("1. Create a Neptune DB Subnet Group")
wait_for_input_to_continue()
try:
name, arn = create_subnet_group(neptune_client, subnet_group_name)
print(f"Subnet group successfully created: {name}")
print("-" * 88)
print("2. Create a Neptune Cluster")
wait_for_input_to_continue()
db_cluster_id = create_db_cluster(neptune_client, cluster_name)
print("-" * 88)
print("3. Create a Neptune DB Instance")
wait_for_input_to_continue()
create_db_instance(neptune_client, db_instance_id, cluster_name)
print("-" * 88)
print("4. Check the status of the Neptune DB Instance")
print("""
Even though you're targeting a single DB instance,
describe_db_instances supports pagination and can return multiple pages.
Handling paginated responses ensures your method continues to work reliably
even if AWS returns large or paged results.
""")
wait_for_input_to_continue()
check_instance_status(neptune_client, db_instance_id, "available")
print("-" * 88)
print("5. Show Neptune Cluster details")
wait_for_input_to_continue()
describe_db_clusters(neptune_client, db_cluster_id)
print("-" * 88)
print("6. Stop the Amazon Neptune cluster")
print("""
Boto3 doesn't currently offer a
built-in waiter for stop_db_cluster,
This example implements a custom polling
strategy until the cluster is in a stopped state.
""")
wait_for_input_to_continue()
stop_db_cluster(neptune_client, db_cluster_id)
check_instance_status(neptune_client, db_instance_id, "stopped")
print("-" * 88)
print("7. Start the Amazon Neptune cluster")
print("""
Boto3 doesn't currently offer a
built-in waiter for start_db_cluster,
This example implements a custom polling
strategy until the cluster is in an available state.
""")
wait_for_input_to_continue()
start_db_cluster(neptune_client, db_cluster_id)
wait_for_cluster_status(neptune_client, db_cluster_id, "available")
check_instance_status(neptune_client, db_instance_id, "available")
print("All Neptune resources are now available.")
print("-" * 88)
print("-" * 88)
print("8. Delete the Neptune Assets")
print("Would you like to delete the Neptune Assets? (y/n)")
del_ans = input().strip().lower()
if del_ans == "y":
print("You selected to delete the Neptune assets.")
delete_db_instance(neptune_client, db_instance_id)
delete_db_cluster(neptune_client, db_cluster_id)
delete_db_subnet_group(neptune_client, subnet_group_name)
print("Neptune resources deleted successfully")
except ClientError as ce:
code = ce.response["Error"]["Code"]
if code in ("DBInstanceNotFound", "DBInstanceNotFoundFault", "ResourceNotFound"):
print(f"Instance '{db_instance_id}' not found.")
elif code in ("DBClusterNotFound", "DBClusterNotFoundFault", "ResourceNotFoundFault"):
print(f"Cluster '{cluster_name}' not found.")
elif code == "DBSubnetGroupNotFoundFault":
print(f"Subnet group '{subnet_group_name}' not found.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"AWS error [{code}]: {ce.response['Error']['Message']}")
raise # re-raise unexpected errors
except RuntimeError as re:
print(f"Runtime error or timeout: {re}")
def main():
neptune_client = boto3.client('neptune')
# Customize the following names to match your Neptune setup
# (You must change these to unique values for your environment)
subnet_group_name = "neptuneSubnetGroup111"
cluster_name = "neptuneCluster111"
db_instance_id = "neptuneDB111"
print("""
Amazon Neptune is a fully managed graph database service by AWS...
Let's get started!
""")
wait_for_input_to_continue()
run_scenario(neptune_client, subnet_group_name, db_instance_id, cluster_name)
print("""
Thank you for checking out the Amazon Neptune Service Use demo.
For more AWS code examples, visit:
https://docs.aws.amazon.com/code-library/latest/ug/what-is-code-library.html
""")
if __name__ == "__main__":
main()
```
+ For API details, see the following topics in *AWS SDK for Python (Boto3) API Reference*.
+ [CreateDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBCluster)
+ [CreateDBInstance](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBInstance)
+ [CreateDBSubnetGroup](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBSubnetGroup)
+ [CreateGraph](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateGraph)
+ [DeleteDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBCluster)
+ [DeleteDBInstance](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBInstance)
+ [DeleteDBSubnetGroup](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBSubnetGroup)
+ [DescribeDBClusters](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DescribeDBClusters)
+ [DescribeDBInstances](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DescribeDBInstances)
+ [ExecuteGremlinProfileQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteGremlinProfileQuery)
+ [ExecuteGremlinQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteGremlinQuery)
+ [ExecuteOpenCypherExplainQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteOpenCypherExplainQuery)
+ [ExecuteQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteQuery)
+ [StartDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/StartDBCluster)
+ [StopDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/StopDBCluster)
------
# Actions for Neptune using AWS SDKs
The following code examples demonstrate how to perform individual Neptune 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 Neptune API and are code excerpts from larger programs that must be run in context. You can see actions in context in [Scenarios for Neptune using AWS SDKs](neptune_code_examples_scenarios.md).
The following examples include only the most commonly used actions. For a complete list, see the [Amazon Neptune API Reference](https://docs.aws.amazon.com/neptune/latest/apiref/Welcome.html).
**Topics**
+ [`CreateDBCluster`](neptune_example_neptune_CreateDBCluster_section.md)
+ [`CreateDBInstance`](neptune_example_neptune_CreateDBInstance_section.md)
+ [`CreateDBSubnetGroup`](neptune_example_neptune_CreateDBSubnetGroup_section.md)
+ [`CreateGraph`](neptune_example_neptune_CreateGraph_section.md)
+ [`DeleteDBCluster`](neptune_example_neptune_DeleteDBCluster_section.md)
+ [`DeleteDBInstance`](neptune_example_neptune_DeleteDBInstance_section.md)
+ [`DeleteDBSubnetGroup`](neptune_example_neptune_DeleteDBSubnetGroup_section.md)
+ [`DescribeDBClusters`](neptune_example_neptune_DescribeDBClusters_section.md)
+ [`DescribeDBInstances`](neptune_example_neptune_DescribeDBInstances_section.md)
+ [`ExecuteGremlinProfileQuery`](neptune_example_neptune_ExecuteGremlinProfileQuery_section.md)
+ [`ExecuteGremlinQuery`](neptune_example_neptune_ExecuteGremlinQuery_section.md)
+ [`ExecuteOpenCypherExplainQuery`](neptune_example_neptune_ExecuteOpenCypherExplainQuery_section.md)
+ [`ExecuteQuery`](neptune_example_neptune_ExecuteQuery_section.md)
+ [`StartDBCluster`](neptune_example_neptune_StartDBCluster_section.md)
+ [`StopDBCluster`](neptune_example_neptune_StopDBCluster_section.md)
# Use `CreateDBCluster` with an AWS SDK
The following code examples show how to use `CreateDBCluster`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Creates a new Amazon Neptune DB cluster asynchronously.
*
* @param dbName the name of the DB cluster to be created
* @return a CompletableFuture that, when completed, provides the ID of the created DB cluster
* @throws CompletionException if the operation fails for any reason, including if the request would exceed the maximum quota
*/
public CompletableFuture createDBClusterAsync(String dbName) {
CreateDbClusterRequest request = CreateDbClusterRequest.builder()
.dbClusterIdentifier(dbName)
.engine("neptune")
.deletionProtection(false)
.backupRetentionPeriod(1)
.build();
return getAsyncClient().createDBCluster(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create Neptune DB cluster: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String clusterId = response.dbCluster().dbClusterIdentifier();
logger.info("DB Cluster created: " + clusterId);
return clusterId;
});
}
```
+ For API details, see [CreateDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def create_db_cluster(neptune_client, db_name: str) -> str:
"""
Creates a Neptune DB cluster and returns its identifier.
Args:
neptune_client (boto3.client): The Neptune client object.
db_name (str): The desired cluster identifier.
Returns:
str: The DB cluster identifier.
Raises:
RuntimeError: For any failure or AWS error, with a user-friendly message.
"""
request = {
'DBClusterIdentifier': db_name,
'Engine': 'neptune',
'DeletionProtection': False,
'BackupRetentionPeriod': 1
}
try:
response = neptune_client.create_db_cluster(**request)
cluster = response.get('DBCluster') or {}
cluster_id = cluster.get('DBClusterIdentifier')
if not cluster_id:
raise RuntimeError("Cluster created but no ID returned.")
print(f"DB Cluster created: {cluster_id}")
return cluster_id
except ClientError as e:
code = e.response["Error"]["Code"]
message = e.response["Error"]["Message"]
if code in ("ServiceQuotaExceededException", "DBClusterQuotaExceededFault"):
raise RuntimeError("You have exceeded the quota for Neptune DB clusters.") from e
else:
raise RuntimeError(f"AWS error [{code}]: {message}") from e
except Exception as e:
raise RuntimeError(f"Unexpected error creating DB cluster '{db_name}': {e}") from e
```
+ For API details, see [CreateDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `CreateDBInstance` with an AWS SDK
The following code examples show how to use `CreateDBInstance`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Creates a new Amazon Neptune DB instance asynchronously.
*
* @param dbInstanceId the identifier for the new DB instance
* @param dbClusterId the identifier for the DB cluster that the new instance will be a part of
* @return a {@link CompletableFuture} that completes with the identifier of the newly created DB instance
* @throws CompletionException if the operation fails, with a cause of either:
* - {@link ServiceQuotaExceededException} if the request would exceed the maximum quota, or
* - a general exception with the failure message
*/
public CompletableFuture createDBInstanceAsync(String dbInstanceId, String dbClusterId) {
CreateDbInstanceRequest request = CreateDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceId)
.dbInstanceClass("db.r5.large")
.engine("neptune")
.dbClusterIdentifier(dbClusterId)
.build();
return getAsyncClient().createDBInstance(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create Neptune DB instance: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String instanceId = response.dbInstance().dbInstanceIdentifier();
logger.info("Created Neptune DB Instance: " + instanceId);
return instanceId;
});
}
```
+ For API details, see [CreateDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBInstance) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def create_db_instance(neptune_client, db_instance_id: str, db_cluster_id: str) -> str:
try:
request = {
'DBInstanceIdentifier': db_instance_id,
'DBInstanceClass': 'db.r5.large',
'Engine': 'neptune',
'DBClusterIdentifier': db_cluster_id
}
print(f"Creating Neptune DB Instance: {db_instance_id}")
response = neptune_client.create_db_instance(**request)
instance = response.get('DBInstance')
if not instance or 'DBInstanceIdentifier' not in instance:
raise RuntimeError("Instance creation succeeded but no ID returned.")
print(f"Waiting for DB Instance '{db_instance_id}' to become available...")
waiter = neptune_client.get_waiter('db_instance_available')
waiter.wait(
DBInstanceIdentifier=db_instance_id,
WaiterConfig={'Delay': 30, 'MaxAttempts': 40}
)
print(f"DB Instance '{db_instance_id}' is now available.")
return instance['DBInstanceIdentifier']
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't create DB instance. Here's why: {code}: {message}")
raise
except Exception as e:
print(f"Unexpected error creating DB instance '{db_instance_id}': {e}")
raise RuntimeError(f"Unexpected error creating DB instance '{db_instance_id}': {e}") from e
```
+ For API details, see [CreateDBInstance](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBInstance) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `CreateDBSubnetGroup` with an AWS SDK
The following code examples show how to use `CreateDBSubnetGroup`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Creates a new DB subnet group asynchronously.
*
* @param groupName the name of the subnet group to create
* @return a CompletableFuture that, when completed, returns the Amazon Resource Name (ARN) of the created subnet group
* @throws CompletionException if the operation fails, with a cause that may be a ServiceQuotaExceededException if the request would exceed the maximum quota
*/
public CompletableFuture createSubnetGroupAsync(String groupName) {
// Get the Amazon Virtual Private Cloud (VPC) where the Neptune cluster and resources will be created
String vpcId = getDefaultVpcId();
logger.info("VPC is : " + vpcId);
List subnetList = getSubnetIds(vpcId);
for (String subnetId : subnetList) {
System.out.println("Subnet group:" +subnetId);
}
CreateDbSubnetGroupRequest request = CreateDbSubnetGroupRequest.builder()
.dbSubnetGroupName(groupName)
.dbSubnetGroupDescription("Subnet group for Neptune cluster")
.subnetIds(subnetList)
.build();
return getAsyncClient().createDBSubnetGroup(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
if (cause instanceof ServiceQuotaExceededException) {
throw new CompletionException("The operation was denied because the request would exceed the maximum quota.", cause);
}
throw new CompletionException("Failed to create subnet group: " + exception.getMessage(), exception);
}
})
.thenApply(response -> {
String name = response.dbSubnetGroup().dbSubnetGroupName();
String arn = response.dbSubnetGroup().dbSubnetGroupArn();
logger.info("Subnet group created: " + name);
return arn;
});
}
```
+ For API details, see [CreateDBSubnetGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBSubnetGroup) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def create_subnet_group(neptune_client, group_name: str):
"""
Creates a Neptune DB subnet group and returns its name and ARN.
Args:
neptune_client (boto3.client): The Neptune client object.
group_name (str): The desired name of the subnet group.
Returns:
tuple(str, str): (subnet_group_name, subnet_group_arn)
Raises:
RuntimeError: For quota errors or other AWS-related failures.
"""
vpc_id = get_default_vpc_id()
subnet_ids = get_subnet_ids(vpc_id)
request = {
'DBSubnetGroupName': group_name,
'DBSubnetGroupDescription': 'My Neptune subnet group',
'SubnetIds': subnet_ids,
'Tags': [{'Key': 'Environment', 'Value': 'Dev'}]
}
try:
response = neptune_client.create_db_subnet_group(**request)
sg = response.get("DBSubnetGroup", {})
name = sg.get("DBSubnetGroupName")
arn = sg.get("DBSubnetGroupArn")
if not name or not arn:
raise RuntimeError("Response missing subnet group name or ARN.")
print(f"Subnet group created: {name}")
print(f"ARN: {arn}")
return name, arn
except ClientError as e:
code = e.response["Error"]["Code"]
msg = e.response["Error"]["Message"]
if code == "ServiceQuotaExceededException":
print("Subnet group quota exceeded.")
raise RuntimeError("Subnet group quota exceeded.") from e
else:
print(f"AWS error [{code}]: {msg}")
raise RuntimeError(f"AWS error [{code}]: {msg}") from e
except Exception as e:
print(f"Unexpected error creating subnet group '{group_name}': {e}")
raise RuntimeError(f"Unexpected error creating subnet group '{group_name}': {e}") from e
```
+ For API details, see [CreateDBSubnetGroup](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateDBSubnetGroup) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `CreateGraph` with an AWS SDK
The following code examples show how to use `CreateGraph`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Executes the process of creating a new Neptune graph.
*
* @param client the Neptune graph client used to interact with the Neptune service
* @param graphName the name of the graph to be created
* @throws NeptuneGraphException if an error occurs while creating the graph
*/
public static void executeCreateGraph(NeptuneGraphClient client, String graphName) {
try {
// Create the graph request
CreateGraphRequest request = CreateGraphRequest.builder()
.graphName(graphName)
.provisionedMemory(16)
.build();
// Create the graph
CreateGraphResponse response = client.createGraph(request);
// Extract the graph name and ARN
String createdGraphName = response.name();
String graphArn = response.arn();
String graphEndpoint = response.endpoint();
System.out.println("Graph created successfully!");
System.out.println("Graph Name: " + createdGraphName);
System.out.println("Graph ARN: " + graphArn);
System.out.println("Graph Endpoint: " +graphEndpoint );
} catch (NeptuneGraphException e) {
System.err.println("Failed to create graph: " + e.awsErrorDetails().errorMessage());
} finally {
client.close();
}
}
```
+ For API details, see [CreateGraph](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateGraph) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
"""
Running this example.
----------------------------------------------------------------------------------
VPC Networking Requirement:
----------------------------------------------------------------------------------
Amazon Neptune must be accessed from **within the same VPC** as the Neptune cluster.
It does not expose a public endpoint, so this code must be executed from:
- An **AWS Lambda function** configured to run inside the same VPC
- An **EC2 instance** or **ECS task** running in the same VPC
- A connected environment such as a **VPN**, **AWS Direct Connect**, or a **peered VPC**
"""
GRAPH_NAME = "sample-analytics-graph"
def main():
config = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
client = boto3.client("neptune-graph", config=config)
execute_create_graph(client, GRAPH_NAME)
def execute_create_graph(client, graph_name):
try:
print("Creating Neptune graph...")
response = client.create_graph(
graphName=graph_name,
provisionedMemory = 16
)
created_graph_name = response.get("name")
graph_arn = response.get("arn")
graph_endpoint = response.get("endpoint")
print("Graph created successfully!")
print(f"Graph Name: {created_graph_name}")
print(f"Graph ARN: {graph_arn}")
print(f"Graph Endpoint: {graph_endpoint}")
except ClientError as e:
print(f"Failed to create graph: {e.response['Error']['Message']}")
except BotoCoreError as e:
print(f"Failed to create graph: {str(e)}")
except Exception as e:
print(f"Unexpected error: {str(e)}")
if __name__ == "__main__":
main()
```
+ For API details, see [CreateGraph](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/CreateGraph) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `DeleteDBCluster` with an AWS SDK
The following code examples show how to use `DeleteDBCluster`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Deletes a DB instance asynchronously.
*
* @param clusterId the identifier of the cluster to delete
* @return a {@link CompletableFuture} that completes when the cluster has been deleted
*/
public CompletableFuture deleteDBClusterAsync(String clusterId) {
DeleteDbClusterRequest request = DeleteDbClusterRequest.builder()
.dbClusterIdentifier(clusterId)
.skipFinalSnapshot(true)
.build();
return getAsyncClient().deleteDBCluster(request)
.thenAccept(response -> System.out.println("šļø Deleting DB Cluster: " + clusterId));
}
```
+ For API details, see [DeleteDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def delete_db_cluster(neptune_client, cluster_id: str):
"""
Deletes a Neptune DB cluster and throws exceptions to the caller.
Args:
neptune_client (boto3.client): The Neptune client object.
cluster_id (str): The ID of the Neptune DB cluster to be deleted.
Raises:
ClientError: If the delete operation fails.
"""
request = {
'DBClusterIdentifier': cluster_id,
'SkipFinalSnapshot': True
}
try:
print(f"Deleting DB Cluster: {cluster_id}")
neptune_client.delete_db_cluster(**request)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFoundFault":
print(f"Cluster '{cluster_id}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete DB cluster. {code}: {message}")
raise
```
+ For API details, see [DeleteDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `DeleteDBInstance` with an AWS SDK
The following code examples show how to use `DeleteDBInstance`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Deletes a DB instance asynchronously.
*
* @param instanceId the identifier of the DB instance to be deleted
* @return a {@link CompletableFuture} that completes when the DB instance has been deleted
*/
public CompletableFuture deleteDBInstanceAsync(String instanceId) {
DeleteDbInstanceRequest request = DeleteDbInstanceRequest.builder()
.dbInstanceIdentifier(instanceId)
.skipFinalSnapshot(true)
.build();
return getAsyncClient().deleteDBInstance(request)
.thenAccept(response -> System.out.println("šļø Deleting DB Instance: " + instanceId));
}
```
+ For API details, see [DeleteDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBInstance) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def delete_db_instance(neptune_client, instance_id: str):
"""
Deletes a Neptune DB instance and waits for its deletion to complete.
Raises exception to be handled by calling code.
"""
print(f"Initiating deletion of DB Instance: {instance_id}")
try:
neptune_client.delete_db_instance(
DBInstanceIdentifier=instance_id,
SkipFinalSnapshot=True
)
print(f"Waiting for DB Instance '{instance_id}' to be deleted...")
waiter = neptune_client.get_waiter('db_instance_deleted')
waiter.wait(
DBInstanceIdentifier=instance_id,
WaiterConfig={
'Delay': 30,
'MaxAttempts': 40
}
)
print(f"DB Instance '{instance_id}' successfully deleted.")
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBInstanceNotFoundFault":
print(f"Instance '{instance_id}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete DB instance. {code}: {message}")
raise
```
+ For API details, see [DeleteDBInstance](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBInstance) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `DeleteDBSubnetGroup` with an AWS SDK
The following code examples show how to use `DeleteDBSubnetGroup`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Deletes a subnet group.
*
* @param subnetGroupName the identifier of the subnet group to delete
* @return a {@link CompletableFuture} that completes when the cluster has been deleted
*/
public CompletableFuture deleteDBSubnetGroupAsync(String subnetGroupName) {
DeleteDbSubnetGroupRequest request = DeleteDbSubnetGroupRequest.builder()
.dbSubnetGroupName(subnetGroupName)
.build();
return getAsyncClient().deleteDBSubnetGroup(request)
.thenAccept(response -> logger.info("šļø Deleting Subnet Group: " + subnetGroupName));
}
```
+ For API details, see [DeleteDBSubnetGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBSubnetGroup) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def delete_db_subnet_group(neptune_client, subnet_group_name):
"""
Deletes a Neptune DB subnet group synchronously using Boto3.
Args:
neptune_client (boto3.client): The Neptune client.
subnet_group_name (str): The name of the DB subnet group to delete.
Raises:
ClientError: If the delete operation fails.
"""
delete_group_request = {
'DBSubnetGroupName': subnet_group_name
}
try:
neptune_client.delete_db_subnet_group(**delete_group_request)
print(f"ļø Deleting Subnet Group: {subnet_group_name}")
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBSubnetGroupNotFoundFault":
print(f"Subnet group '{subnet_group_name}' not found or already deleted.")
elif code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't delete subnet group. {code}: {message}")
raise
```
+ For API details, see [DeleteDBSubnetGroup](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DeleteDBSubnetGroup) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `DescribeDBClusters` with an AWS SDK
The following code examples show how to use `DescribeDBClusters`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Asynchronously describes the specified Amazon RDS DB cluster.
*
* @param clusterId the identifier of the DB cluster to describe
* @return a {@link CompletableFuture} that completes when the operation is done, or throws a {@link RuntimeException}
* if an error occurs
*/
public CompletableFuture describeDBClustersAsync(String clusterId) {
DescribeDbClustersRequest request = DescribeDbClustersRequest.builder()
.dbClusterIdentifier(clusterId)
.build();
return getAsyncClient().describeDBClusters(request)
.thenAccept(response -> {
for (DBCluster cluster : response.dbClusters()) {
logger.info("Cluster Identifier: " + cluster.dbClusterIdentifier());
logger.info("Status: " + cluster.status());
logger.info("Engine: " + cluster.engine());
logger.info("Engine Version: " + cluster.engineVersion());
logger.info("Endpoint: " + cluster.endpoint());
logger.info("Reader Endpoint: " + cluster.readerEndpoint());
logger.info("Availability Zones: " + cluster.availabilityZones());
logger.info("Subnet Group: " + cluster.dbSubnetGroup());
logger.info("VPC Security Groups:");
cluster.vpcSecurityGroups().forEach(vpcGroup ->
logger.info(" - " + vpcGroup.vpcSecurityGroupId()));
logger.info("Storage Encrypted: " + cluster.storageEncrypted());
logger.info("IAM DB Auth Enabled: " + cluster.iamDatabaseAuthenticationEnabled());
logger.info("Backup Retention Period: " + cluster.backupRetentionPeriod() + " days");
logger.info("Preferred Backup Window: " + cluster.preferredBackupWindow());
logger.info("Preferred Maintenance Window: " + cluster.preferredMaintenanceWindow());
logger.info("------");
}
})
.exceptionally(ex -> {
Throwable cause = ex.getCause() != null ? ex.getCause() : ex;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to describe the DB cluster: " + cause.getMessage(), cause);
});
}
```
+ For API details, see [DescribeDBClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBClusters) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def describe_db_clusters(neptune_client, cluster_id: str):
"""
Describes details of a Neptune DB cluster, paginating if needed.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_id (str): The ID of the cluster to describe.
Raises:
ClientError: If there's an AWS API error (e.g., cluster not found).
"""
paginator = neptune_client.get_paginator('describe_db_clusters')
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_id)
found = False
for page in pages:
for cluster in page.get('DBClusters', []):
found = True
print(f"Cluster Identifier: {cluster.get('DBClusterIdentifier')}")
print(f"Status: {cluster.get('Status')}")
print(f"Engine: {cluster.get('Engine')}")
print(f"Engine Version: {cluster.get('EngineVersion')}")
print(f"Endpoint: {cluster.get('Endpoint')}")
print(f"Reader Endpoint: {cluster.get('ReaderEndpoint')}")
print(f"Availability Zones: {cluster.get('AvailabilityZones')}")
print(f"Subnet Group: {cluster.get('DBSubnetGroup')}")
print("VPC Security Groups:")
for vpc_group in cluster.get('VpcSecurityGroups', []):
print(f" - {vpc_group.get('VpcSecurityGroupId')}")
print(f"Storage Encrypted: {cluster.get('StorageEncrypted')}")
print(f"IAM Auth Enabled: {cluster.get('IAMDatabaseAuthenticationEnabled')}")
print(f"Backup Retention Period: {cluster.get('BackupRetentionPeriod')} days")
print(f"Preferred Backup Window: {cluster.get('PreferredBackupWindow')}")
print(f"Preferred Maintenance Window: {cluster.get('PreferredMaintenanceWindow')}")
print("------")
if not found:
# Treat empty response as cluster not found
raise ClientError(
{"Error": {"Code": "DBClusterNotFound", "Message": f"No cluster found with ID '{cluster_id}'"}},
"DescribeDBClusters"
)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
elif code == "DBClusterNotFound":
print(f"Cluster '{cluster_id}' not found. Please verify the cluster ID.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
```
+ For API details, see [DescribeDBClusters](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DescribeDBClusters) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `DescribeDBInstances` with an AWS SDK
The following code examples show how to use `DescribeDBInstances`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Checks the status of a Neptune instance recursively until the desired status is reached or a timeout occurs.
*
* @param instanceId the ID of the Neptune instance to check
* @param desiredStatus the desired status of the Neptune instance
* @param startTime the start time of the operation, used to calculate the elapsed time
* @param future a {@link CompletableFuture} that will be completed when the desired status is reached
*/
private void checkStatusRecursive(String instanceId, String desiredStatus, long startTime, CompletableFuture future) {
DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
.dbInstanceIdentifier(instanceId)
.build();
getAsyncClient().describeDBInstances(request)
.whenComplete((response, exception) -> {
if (exception != null) {
Throwable cause = exception.getCause();
future.completeExceptionally(
new CompletionException("Error checking Neptune instance status", cause)
);
return;
}
List instances = response.dbInstances();
if (instances.isEmpty()) {
future.completeExceptionally(new RuntimeException("Instance not found: " + instanceId));
return;
}
String currentStatus = instances.get(0).dbInstanceStatus();
long elapsedSeconds = (System.currentTimeMillis() - startTime) / 1000;
System.out.printf("\r Elapsed: %-20s Status: %-20s", formatElapsedTime((int) elapsedSeconds), currentStatus);
System.out.flush();
if (desiredStatus.equalsIgnoreCase(currentStatus)) {
System.out.printf("\r Neptune instance reached desired status '%s' after %s.\n", desiredStatus, formatElapsedTime((int) elapsedSeconds));
future.complete(null);
} else {
CompletableFuture.delayedExecutor(20, TimeUnit.SECONDS)
.execute(() -> checkStatusRecursive(instanceId, desiredStatus, startTime, future));
}
});
}
```
+ For API details, see [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBInstances) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def check_instance_status(neptune_client, instance_id: str, desired_status: str):
"""
Polls the status of a Neptune DB instance until it reaches desired_status.
Uses pagination via describe_db_instances ā even for a single instance.
Raises:
ClientError: If describe_db_instances fails (e.g., instance not found).
RuntimeError: If timeout expires before reaching desired status.
"""
paginator = neptune_client.get_paginator('describe_db_instances')
start_time = time.time()
while True:
try:
pages = paginator.paginate(DBInstanceIdentifier=instance_id)
instances = []
for page in pages:
instances.extend(page.get('DBInstances', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBInstanceNotFound":
print(f"Instance '{instance_id}' not found. Please verify the instance ID.")
else:
print(f"Failed to describe DB instance. {code}: {message}")
raise
current_status = instances[0].get('DBInstanceStatus') if instances else None
elapsed = int(time.time() - start_time)
print(f"\rElapsed: {format_elapsed_time(elapsed)} Status: {current_status}", end="", flush=True)
if current_status and current_status.lower() == desired_status.lower():
print(f"\nInstance '{instance_id}' reached '{desired_status}' in {format_elapsed_time(elapsed)}.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for '{instance_id}' to reach '{desired_status}'")
time.sleep(POLL_INTERVAL_SECONDS)
```
+ For API details, see [DescribeDBInstances](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/DescribeDBInstances) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `ExecuteGremlinProfileQuery` with an AWS SDK
The following code examples show how to use `ExecuteGremlinProfileQuery`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Executes a Gremlin query against an Amazon Neptune database using the provided {@link NeptunedataClient}.
*
* @param client the {@link NeptunedataClient} instance to use for executing the Gremlin query
*/
public static void executeGremlinQuery(NeptunedataClient client) {
try {
System.out.println("Querying Neptune...");
ExecuteGremlinQueryRequest request = ExecuteGremlinQueryRequest.builder()
.gremlinQuery("g.V().has('code', 'ANC')")
.build();
ExecuteGremlinQueryResponse response = client.executeGremlinQuery(request);
System.out.println("Full Response:");
System.out.println(response);
// Retrieve and print the result
if (response.result() != null) {
System.out.println("Query Result:");
System.out.println(response.result().toString());
} else {
System.out.println("No result returned from the query.");
}
} catch (NeptunedataException e) {
System.err.println("Error calling Neptune: " + e.awsErrorDetails().errorMessage());
} catch (Exception e) {
System.err.println("Unexpected error: " + e.getMessage());
} finally {
client.close();
}
}
```
+ For API details, see [ExecuteGremlinProfileQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinProfileQuery) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
# Replace this with your actual Neptune endpoint
NEPTUNE_ENDPOINT = "https://[Specify Endpoint]:8182"
def main():
"""
Entry point of the program. Initializes the Neptune client and executes the Gremlin query.
"""
config = Config(connect_timeout=10, read_timeout=30, retries={'max_attempts': 3})
neptune_client = boto3.client(
"neptunedata",
endpoint_url=NEPTUNE_ENDPOINT,
config=config
)
execute_gremlin_query(neptune_client)
def execute_gremlin_query(neptune_client):
"""
Executes a Gremlin query against an Amazon Neptune database.
"""
try:
print("Querying Neptune...")
response = neptune_client.execute_gremlin_explain_query(
gremlinQuery="g.V().has('code', 'ANC')"
)
print("Full Response:")
print(response['output'].read().decode('UTF-8'))
except ClientError as e:
print(f"Error calling Neptune: {e.response['Error']['Message']}")
except BotoCoreError as e:
print(f"BotoCore error: {str(e)}")
except Exception as e:
print(f"Unexpected error: {str(e)}")
if __name__ == "__main__":
main()
```
+ For API details, see [ExecuteGremlinProfileQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteGremlinProfileQuery) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `ExecuteGremlinQuery` with an AWS SDK
The following code examples show how to use `ExecuteGremlinQuery`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Executes a Gremlin PROFILE query using the provided NeptunedataClient.
*
* @param client The NeptunedataClient instance to be used for executing the Gremlin PROFILE query.
*/
private static void executeGremlinProfileQuery(NeptunedataClient client) {
System.out.println("Executing Gremlin PROFILE query...");
ExecuteGremlinProfileQueryRequest request = ExecuteGremlinProfileQueryRequest.builder()
.gremlinQuery("g.V().has('code', 'ANC')")
.build();
ExecuteGremlinProfileQueryResponse response = client.executeGremlinProfileQuery(request);
if (response.output() != null) {
System.out.println("Query Profile Output:");
System.out.println(response.output());
} else {
System.out.println("No output returned from the profile query.");
}
}
```
+ For API details, see [ExecuteGremlinQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinQuery) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
"""
Running this example.
----------------------------------------------------------------------------------
VPC Networking Requirement:
----------------------------------------------------------------------------------
Amazon Neptune must be accessed from **within the same VPC** as the Neptune cluster.
It does not expose a public endpoint, so this code must be executed from:
- An **AWS Lambda function** configured to run inside the same VPC
- An **EC2 instance** or **ECS task** running in the same VPC
- A connected environment such as a **VPN**, **AWS Direct Connect**, or a **peered VPC**
"""
# Replace with your actual Neptune endpoint
NEPTUNE_ENDPOINT = "https://[Specify-Your-Endpoint]:8182"
def main():
"""
Entry point of the program. Initializes the Neptune client and runs both EXPLAIN and PROFILE queries.
"""
config = Config(connect_timeout=10, read_timeout=30, retries={'max_attempts': 3})
neptune_client = boto3.client(
"neptunedata",
endpoint_url=NEPTUNE_ENDPOINT,
config=config
)
try:
run_profile_query(neptune_client)
except ClientError as e:
print(f"Neptune error: {e.response['Error']['Message']}")
except BotoCoreError as e:
print(f"BotoCore error: {str(e)}")
except Exception as e:
print(f"Unexpected error: {str(e)}")
def run_profile_query(neptune_client):
"""
Runs a PROFILE query on the Neptune graph database.
"""
print("Running Gremlin PROFILE query...")
try:
response = neptune_client.execute_gremlin_profile_query(
gremlinQuery="g.V().has('code', 'ANC')"
)
print("Profile Query Result:")
output = response.get("output")
if output:
print(output.read().decode('utf-8'))
else:
print("No explain output returned.")
except Exception as e:
print(f"Failed to execute PROFILE query: {str(e)}")
if __name__ == "__main__":
main()
```
+ For API details, see [ExecuteGremlinQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteGremlinQuery) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `ExecuteOpenCypherExplainQuery` with an AWS SDK
The following code examples show how to use `ExecuteOpenCypherExplainQuery`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Executes an OpenCypher EXPLAIN query using the provided Neptune data client.
*
* @param client The Neptune data client to use for the query execution.
*/
public static void executeGremlinQuery(NeptunedataClient client) {
try {
System.out.println("Executing OpenCypher EXPLAIN query...");
ExecuteOpenCypherExplainQueryRequest request = ExecuteOpenCypherExplainQueryRequest.builder()
.openCypherQuery("MATCH (n {code: 'ANC'}) RETURN n")
.explainMode("debug")
.build();
ExecuteOpenCypherExplainQueryResponse response = client.executeOpenCypherExplainQuery(request);
if (response.results() != null) {
System.out.println("Explain Results:");
System.out.println(response.results().asUtf8String());
} else {
System.out.println("No explain results returned.");
}
} catch (NeptunedataException e) {
System.err.println("Neptune error: " + e.awsErrorDetails().errorMessage());
} catch (Exception e) {
System.err.println("Unexpected error: " + e.getMessage());
} finally {
client.close();
}
}
```
+ For API details, see [ExecuteOpenCypherExplainQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteOpenCypherExplainQuery) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
# Replace with your actual Neptune endpoint URL
NEPTUNE_ENDPOINT = "https://:8182"
def main():
"""
Entry point: Create Neptune client and execute different OpenCypher queries.
"""
config = Config(connect_timeout=10, read_timeout=30, retries={'max_attempts': 3})
neptune_client = boto3.client(
"neptunedata",
endpoint_url=NEPTUNE_ENDPOINT,
config=config
)
execute_open_cypher_query_without_params(neptune_client)
execute_open_cypher_query_with_params(neptune_client)
execute_open_cypher_explain_query(neptune_client)
def execute_open_cypher_query_without_params(client):
"""
Executes a simple OpenCypher query without parameters.
"""
try:
print("\nRunning OpenCypher query without parameters...")
resp = client.execute_open_cypher_query(
openCypherQuery="MATCH (n {code: 'ANC'}) RETURN n"
)
print("Results:")
print(resp['results'])
except Exception as e:
print(f"Error in simple OpenCypher query: {str(e)}")
def execute_open_cypher_query_with_params(client):
"""
Executes an OpenCypher query using parameters.
"""
try:
print("\nRunning OpenCypher query with parameters...")
parameters = {'code': 'ANC'}
resp = client.execute_open_cypher_query(
openCypherQuery="MATCH (n {code: $code}) RETURN n",
parameters=json.dumps(parameters)
)
print("Results:")
print(resp['results'])
except Exception as e:
print(f"Error in parameterized OpenCypher query: {str(e)}")
def execute_open_cypher_explain_query(client):
"""
Runs an OpenCypher EXPLAIN query in debug mode.
"""
try:
print("\nRunning OpenCypher EXPLAIN query (debug mode)...")
resp = client.execute_open_cypher_explain_query(
openCypherQuery="MATCH (n {code: 'ANC'}) RETURN n",
explainMode="details"
)
results = resp.get('results')
if results is None:
print("No explain results returned.")
else:
try:
print("Explain Results:")
print(results.read().decode('UTF-8'))
except Exception as e:
print(f"Error in OpenCypher EXPLAIN query: {str(e)}")
except ClientError as e:
print(f"Neptune error: {e.response['Error']['Message']}")
except BotoCoreError as e:
print(f"BotoCore error: {str(e)}")
except Exception as e:
print(f"Unexpected error: {str(e)}")
if __name__ == "__main__":
main()
```
+ For API details, see [ExecuteOpenCypherExplainQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteOpenCypherExplainQuery) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `ExecuteQuery` with an AWS SDK
The following code examples show how to use `ExecuteQuery`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Executes a Gremlin profile query on the Neptune Analytics graph.
*
* @param client the {@link NeptuneGraphClient} instance to use for the query
* @param graphId the identifier of the graph to execute the query on
*
* @throws NeptuneGraphException if an error occurs while executing the query on the Neptune Graph
* @throws Exception if an unexpected error occurs
*/
public static void executeGremlinProfileQuery(NeptuneGraphClient client, String graphId) {
try {
System.out.println("Running openCypher query on Neptune Analytics...");
ExecuteQueryRequest request = ExecuteQueryRequest.builder()
.graphIdentifier(graphId)
.queryString("MATCH (n {code: 'ANC'}) RETURN n")
.language("OPEN_CYPHER")
.build();
ResponseInputStream response = client.executeQuery(request);
try (BufferedReader reader = new BufferedReader(new InputStreamReader(response, StandardCharsets.UTF_8))) {
String result = reader.lines().collect(Collectors.joining("\n"));
System.out.println("Query Result:");
System.out.println(result);
} catch (Exception e) {
System.err.println("Error reading response: " + e.getMessage());
}
} catch (NeptuneGraphException e) {
System.err.println("NeptuneGraph error: " + e.awsErrorDetails().errorMessage());
} catch (Exception e) {
System.err.println("Unexpected error: " + e.getMessage());
} finally {
client.close();
}
}
```
+ For API details, see [ExecuteQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteQuery) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
"""
Running this example.
----------------------------------------------------------------------------------
VPC Networking Requirement:
----------------------------------------------------------------------------------
Amazon Neptune must be accessed from **within the same VPC** as the Neptune cluster.
It does not expose a public endpoint, so this code must be executed from:
- An **AWS Lambda function** configured to run inside the same VPC
- An **EC2 instance** or **ECS task** running in the same VPC
- A connected environment such as a **VPN**, **AWS Direct Connect**, or a **peered VPC**
"""
GRAPH_ID = ""
def main():
config = Config(retries={"total_max_attempts": 1, "mode": "standard"}, read_timeout=None)
client = boto3.client("neptune-graph", config=config)
try:
print("\n--- Running OpenCypher query without parameters ---")
run_open_cypher_query(client, GRAPH_ID)
print("\n--- Running OpenCypher query with parameters ---")
run_open_cypher_query_with_params(client, GRAPH_ID)
print("\n--- Running OpenCypher explain query ---")
run_open_cypher_explain_query(client, GRAPH_ID)
except Exception as e:
print(f"Unexpected error in main: {e}")
def run_open_cypher_query(client, graph_id):
"""
Run an OpenCypher query without parameters.
"""
try:
resp = client.execute_query(
graphIdentifier=graph_id,
queryString="MATCH (n {code: 'ANC'}) RETURN n",
language='OPEN_CYPHER'
)
print(resp['payload'].read().decode('UTF-8'))
except client.exceptions.InternalServerException as e:
print(f"InternalServerException: {e.response['Error']['Message']}")
except ClientError as e:
print(f"ClientError: {e.response['Error']['Message']}")
except Exception as e: # <--- ADD THIS BLOCK
print(f"Unexpected error: {e}")
def run_open_cypher_query_with_params(client, graph_id):
"""
Run an OpenCypher query with parameters.
"""
try:
parameters = {'code': 'ANC'}
resp = client.execute_query(
graphIdentifier=graph_id,
queryString="MATCH (n {code: $code}) RETURN n",
language='OPEN_CYPHER',
parameters=parameters
)
print(resp['payload'].read().decode('UTF-8'))
except client.exceptions.InternalServerException as e:
print(f"InternalServerException: {e.response['Error']['Message']}")
except ClientError as e:
print(f"ClientError: {e.response['Error']['Message']}")
except Exception as e: # <--- ADD THIS BLOCK
print(f"Unexpected error: {e}")
def run_open_cypher_explain_query(client, graph_id):
"""
Run an OpenCypher explain query (explainMode = "debug").
"""
try:
resp = client.execute_query(
graphIdentifier=graph_id,
queryString="MATCH (n {code: 'ANC'}) RETURN n",
language='OPEN_CYPHER',
explainMode='DETAILS'
)
print(resp['payload'].read().decode('UTF-8'))
except ClientError as e:
print(f"Neptune error: {e.response['Error']['Message']}")
except BotoCoreError as e:
print(f"Unexpected Boto3 error: {str(e)}")
except Exception as e: # <-- Add this generic catch
print(f"Unexpected error: {str(e)}")
if __name__ == "__main__":
main()
```
+ For API details, see [ExecuteQuery](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/ExecuteQuery) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `StartDBCluster` with an AWS SDK
The following code examples show how to use `StartDBCluster`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Starts an Amazon Neptune DB cluster.
*
* @param clusterIdentifier the unique identifier of the DB cluster to be stopped
*/
public CompletableFuture startDBClusterAsync(String clusterIdentifier) {
StartDbClusterRequest clusterRequest = StartDbClusterRequest.builder()
.dbClusterIdentifier(clusterIdentifier)
.build();
return getAsyncClient().startDBCluster(clusterRequest)
.whenComplete((response, error) -> {
if (error != null) {
Throwable cause = error.getCause() != null ? error.getCause() : error;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to start DB cluster: " + cause.getMessage(), cause);
} else {
logger.info("DB Cluster starting: " + clusterIdentifier);
}
});
}
```
+ For API details, see [StartDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StartDBCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def start_db_cluster(neptune_client, cluster_identifier: str):
"""
Starts an Amazon Neptune DB cluster and waits until it reaches 'available'.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_identifier (str): The DB cluster identifier.
Raises:
ClientError: Propagates AWS API issues like resource not found.
RuntimeError: If cluster doesn't reach 'available' within timeout.
"""
try:
# Initial wait in case the cluster was just stopped
time.sleep(30)
neptune_client.start_db_cluster(DBClusterIdentifier=cluster_identifier)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't start DB cluster. Here's why: {code}: {message}")
raise
start_time = time.time()
paginator = neptune_client.get_paginator('describe_db_clusters')
while True:
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_identifier)
clusters = []
for page in pages:
clusters.extend(page.get('DBClusters', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFound":
print(f"Cluster '{cluster_identifier}' not found while polling. It may have been deleted.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
status = clusters[0].get('Status') if clusters else None
elapsed = time.time() - start_time
print(f"\rElapsed: {int(elapsed)}s ā Cluster status: {status}", end="", flush=True)
if status and status.lower() == 'available':
print(f"\nš Cluster '{cluster_identifier}' is available.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for cluster '{cluster_identifier}' to become available.")
time.sleep(POLL_INTERVAL_SECONDS)
```
+ For API details, see [StartDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/StartDBCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
# Use `StopDBCluster` with an AWS SDK
The following code examples show how to use `StopDBCluster`.
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 the basics](neptune_example_neptune_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/neptune#code-examples).
```
/**
* Stops an Amazon Neptune DB cluster.
*
* @param clusterIdentifier the unique identifier of the DB cluster to be stopped
*/
public CompletableFuture stopDBClusterAsync(String clusterIdentifier) {
StopDbClusterRequest clusterRequest = StopDbClusterRequest.builder()
.dbClusterIdentifier(clusterIdentifier)
.build();
return getAsyncClient().stopDBCluster(clusterRequest)
.whenComplete((response, error) -> {
if (error != null) {
Throwable cause = error.getCause() != null ? error.getCause() : error;
if (cause instanceof ResourceNotFoundException) {
throw (ResourceNotFoundException) cause;
}
throw new RuntimeException("Failed to stop DB cluster: " + cause.getMessage(), cause);
} else {
logger.info("DB Cluster stopped: " + clusterIdentifier);
}
});
}
```
+ For API details, see [StopDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StopDBCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
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/python/example_code/neptune#code-examples).
```
def stop_db_cluster(neptune_client, cluster_identifier: str):
"""
Stops an Amazon Neptune DB cluster and waits until it's fully stopped.
Args:
neptune_client (boto3.client): The Neptune client.
cluster_identifier (str): The DB cluster identifier.
Raises:
ClientError: For AWS API errors (e.g., resource not found).
RuntimeError: If the cluster doesn't stop within the timeout.
"""
try:
neptune_client.stop_db_cluster(DBClusterIdentifier=cluster_identifier)
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "AccessDeniedException":
print("Access denied. Please ensure you have the necessary permissions.")
else:
print(f"Couldn't stop DB cluster. Here's why: {code}: {message}")
raise
start_time = time.time()
paginator = neptune_client.get_paginator('describe_db_clusters')
while True:
try:
pages = paginator.paginate(DBClusterIdentifier=cluster_identifier)
clusters = []
for page in pages:
clusters.extend(page.get('DBClusters', []))
except ClientError as err:
code = err.response["Error"]["Code"]
message = err.response["Error"]["Message"]
if code == "DBClusterNotFound":
print(f"Cluster '{cluster_identifier}' not found while polling. It may have been deleted.")
else:
print(f"Couldn't describe DB cluster. Here's why: {code}: {message}")
raise
status = clusters[0].get('Status') if clusters else None
elapsed = time.time() - start_time
print(f"\rElapsed: {int(elapsed)}s ā Cluster status: {status}", end="", flush=True)
if status and status.lower() == 'stopped':
print(f"\nCluster '{cluster_identifier}' is now stopped.")
return
if elapsed > TIMEOUT_SECONDS:
raise RuntimeError(f"Timeout waiting for cluster '{cluster_identifier}' to stop.")
time.sleep(POLL_INTERVAL_SECONDS)
```
+ For API details, see [StopDBCluster](https://docs.aws.amazon.com/goto/boto3/neptune-2014-10-31/StopDBCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
# Scenarios for Neptune using AWS SDKs
The following code examples show you how to implement common scenarios in Neptune with AWS SDKs. These scenarios show you how to accomplish specific tasks by calling multiple functions within Neptune 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 Neptune](neptune_example_ec2_GettingStarted_064_section.md)
+ [Use the Neptune API to query graph data](neptune_example_cross_Neptune_Query_section.md)
# Getting started with Amazon Neptune
The following code example shows how to:
+ Create a VPC for your Neptune database
+ Create subnets in multiple availability zones
+ Configure security for your Neptune database
+ Create a Neptune DB subnet group
+ Create a Neptune DB cluster and instance
+ Add data to your graph database
+ Query your graph database
------
#### [ 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/064-amazon-neptune-gs) repository.
```
#!/bin/bash
# Amazon Neptune Getting Started Script
# This script creates an Amazon Neptune database cluster and demonstrates basic operations
# Set up logging
LOG_FILE="neptune-setup.log"
echo "Starting Neptune setup at $(date)" > "$LOG_FILE"
# Function to log commands and their output
log_cmd() {
echo "Running: $1" | tee -a "$LOG_FILE"
eval "$1" 2>&1 | tee -a "$LOG_FILE"
return ${PIPESTATUS[0]}
}
# Function to check for errors in command output
check_error() {
local cmd_output="$1"
local cmd_status="$2"
local error_msg="$3"
if [[ $cmd_status -ne 0 || "$cmd_output" =~ [Ee][Rr][Rr][Oo][Rr] ]]; then
echo "ERROR: $error_msg" | tee -a "$LOG_FILE"
cleanup_on_error
exit 1
fi
}
# Function to clean up resources on error
cleanup_on_error() {
echo "Error encountered. Cleaning up resources..." | tee -a "$LOG_FILE"
# Only attempt to delete resources that were successfully created
if [[ -n "$DB_INSTANCE_ID" ]]; then
echo "Deleting DB instance $DB_INSTANCE_ID..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-instance --db-instance-identifier $DB_INSTANCE_ID --skip-final-snapshot"
log_cmd "aws neptune wait db-instance-deleted --db-instance-identifier $DB_INSTANCE_ID"
fi
if [[ -n "$DB_CLUSTER_ID" ]]; then
echo "Deleting DB cluster $DB_CLUSTER_ID..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-cluster --db-cluster-identifier $DB_CLUSTER_ID --skip-final-snapshot"
fi
if [[ -n "$DB_SUBNET_GROUP" ]]; then
echo "Deleting DB subnet group $DB_SUBNET_GROUP..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-subnet-group --db-subnet-group-name $DB_SUBNET_GROUP"
fi
if [[ -n "$SECURITY_GROUP_ID" ]]; then
echo "Deleting security group $SECURITY_GROUP_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-security-group --group-id $SECURITY_GROUP_ID"
fi
if [[ -n "$SUBNET_IDS" ]]; then
for SUBNET_ID in $SUBNET_IDS; do
echo "Deleting subnet $SUBNET_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-subnet --subnet-id $SUBNET_ID"
done
fi
if [[ -n "$VPC_ID" ]]; then
echo "Deleting VPC $VPC_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-vpc --vpc-id $VPC_ID"
fi
}
# Generate random identifier for resource names
RANDOM_ID=$(openssl rand -hex 4)
VPC_NAME="neptune-vpc-$RANDOM_ID"
DB_SUBNET_GROUP="neptune-subnet-group-$RANDOM_ID"
DB_CLUSTER_ID="neptune-cluster-$RANDOM_ID"
DB_INSTANCE_ID="neptune-instance-$RANDOM_ID"
SG_NAME="neptune-sg-$RANDOM_ID"
echo "Using random identifier: $RANDOM_ID" | tee -a "$LOG_FILE"
echo "VPC Name: $VPC_NAME" | tee -a "$LOG_FILE"
echo "DB Subnet Group: $DB_SUBNET_GROUP" | tee -a "$LOG_FILE"
echo "DB Cluster ID: $DB_CLUSTER_ID" | tee -a "$LOG_FILE"
echo "DB Instance ID: $DB_INSTANCE_ID" | tee -a "$LOG_FILE"
echo "Security Group Name: $SG_NAME" | tee -a "$LOG_FILE"
# Step 1: Create VPC
echo "Creating VPC..." | tee -a "$LOG_FILE"
VPC_OUTPUT=$(aws ec2 create-vpc --cidr-block 10.0.0.0/16 --tag-specifications "ResourceType=vpc,Tags=[{Key=Name,Value=$VPC_NAME}]" --output json)
check_error "$VPC_OUTPUT" $? "Failed to create VPC"
VPC_ID=$(echo "$VPC_OUTPUT" | grep -o '"VpcId": "[^"]*' | cut -d'"' -f4)
echo "VPC created with ID: $VPC_ID" | tee -a "$LOG_FILE"
# Enable DNS support for the VPC
log_cmd "aws ec2 modify-vpc-attribute --vpc-id $VPC_ID --enable-dns-support"
log_cmd "aws ec2 modify-vpc-attribute --vpc-id $VPC_ID --enable-dns-hostnames"
# Step 2: Create Internet Gateway and attach to VPC
echo "Creating Internet Gateway..." | tee -a "$LOG_FILE"
IGW_OUTPUT=$(aws ec2 create-internet-gateway --output json)
check_error "$IGW_OUTPUT" $? "Failed to create Internet Gateway"
IGW_ID=$(echo "$IGW_OUTPUT" | grep -o '"InternetGatewayId": "[^"]*' | cut -d'"' -f4)
echo "Internet Gateway created with ID: $IGW_ID" | tee -a "$LOG_FILE"
log_cmd "aws ec2 attach-internet-gateway --internet-gateway-id $IGW_ID --vpc-id $VPC_ID"
# Step 3: Create subnets in different AZs
echo "Creating subnets..." | tee -a "$LOG_FILE"
# Get available AZs
AZ_OUTPUT=$(aws ec2 describe-availability-zones --output json)
check_error "$AZ_OUTPUT" $? "Failed to get availability zones"
# Extract first 3 AZ names
AZ1=$(echo "$AZ_OUTPUT" | grep -o '"ZoneName": "[^"]*' | cut -d'"' -f4 | head -1)
AZ2=$(echo "$AZ_OUTPUT" | grep -o '"ZoneName": "[^"]*' | cut -d'"' -f4 | head -2 | tail -1)
AZ3=$(echo "$AZ_OUTPUT" | grep -o '"ZoneName": "[^"]*' | cut -d'"' -f4 | head -3 | tail -1)
# Create 3 subnets in different AZs
SUBNET1_OUTPUT=$(aws ec2 create-subnet --vpc-id $VPC_ID --cidr-block 10.0.1.0/24 --availability-zone $AZ1 --output json)
check_error "$SUBNET1_OUTPUT" $? "Failed to create subnet 1"
SUBNET1_ID=$(echo "$SUBNET1_OUTPUT" | grep -o '"SubnetId": "[^"]*' | cut -d'"' -f4)
SUBNET2_OUTPUT=$(aws ec2 create-subnet --vpc-id $VPC_ID --cidr-block 10.0.2.0/24 --availability-zone $AZ2 --output json)
check_error "$SUBNET2_OUTPUT" $? "Failed to create subnet 2"
SUBNET2_ID=$(echo "$SUBNET2_OUTPUT" | grep -o '"SubnetId": "[^"]*' | cut -d'"' -f4)
SUBNET3_OUTPUT=$(aws ec2 create-subnet --vpc-id $VPC_ID --cidr-block 10.0.3.0/24 --availability-zone $AZ3 --output json)
check_error "$SUBNET3_OUTPUT" $? "Failed to create subnet 3"
SUBNET3_ID=$(echo "$SUBNET3_OUTPUT" | grep -o '"SubnetId": "[^"]*' | cut -d'"' -f4)
SUBNET_IDS="$SUBNET1_ID $SUBNET2_ID $SUBNET3_ID"
echo "Created subnets: $SUBNET1_ID, $SUBNET2_ID, $SUBNET3_ID" | tee -a "$LOG_FILE"
# Step 4: Create route table and add route to Internet Gateway
echo "Creating route table..." | tee -a "$LOG_FILE"
ROUTE_TABLE_OUTPUT=$(aws ec2 create-route-table --vpc-id $VPC_ID --output json)
check_error "$ROUTE_TABLE_OUTPUT" $? "Failed to create route table"
ROUTE_TABLE_ID=$(echo "$ROUTE_TABLE_OUTPUT" | grep -o '"RouteTableId": "[^"]*' | cut -d'"' -f4)
echo "Route table created with ID: $ROUTE_TABLE_ID" | tee -a "$LOG_FILE"
# Add route to Internet Gateway
log_cmd "aws ec2 create-route --route-table-id $ROUTE_TABLE_ID --destination-cidr-block 0.0.0.0/0 --gateway-id $IGW_ID"
# Associate route table with subnets
log_cmd "aws ec2 associate-route-table --route-table-id $ROUTE_TABLE_ID --subnet-id $SUBNET1_ID"
log_cmd "aws ec2 associate-route-table --route-table-id $ROUTE_TABLE_ID --subnet-id $SUBNET2_ID"
log_cmd "aws ec2 associate-route-table --route-table-id $ROUTE_TABLE_ID --subnet-id $SUBNET3_ID"
# Step 5: Create security group
echo "Creating security group..." | tee -a "$LOG_FILE"
SG_OUTPUT=$(aws ec2 create-security-group --group-name $SG_NAME --description "Security group for Neptune" --vpc-id $VPC_ID --output json)
check_error "$SG_OUTPUT" $? "Failed to create security group"
SECURITY_GROUP_ID=$(echo "$SG_OUTPUT" | grep -o '"GroupId": "[^"]*' | cut -d'"' -f4)
echo "Security group created with ID: $SECURITY_GROUP_ID" | tee -a "$LOG_FILE"
# Add inbound rule for Neptune port (8182)
# Note: In production, you should restrict this to specific IP ranges
echo "Adding security group rule for Neptune port 8182..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 authorize-security-group-ingress --group-id $SECURITY_GROUP_ID --protocol tcp --port 8182 --cidr 10.0.0.0/16"
# Step 6: Create DB subnet group
echo "Creating DB subnet group..." | tee -a "$LOG_FILE"
DB_SUBNET_GROUP_OUTPUT=$(aws neptune create-db-subnet-group --db-subnet-group-name $DB_SUBNET_GROUP --db-subnet-group-description "Subnet group for Neptune" --subnet-ids $SUBNET1_ID $SUBNET2_ID $SUBNET3_ID --output json)
check_error "$DB_SUBNET_GROUP_OUTPUT" $? "Failed to create DB subnet group"
echo "DB subnet group created: $DB_SUBNET_GROUP" | tee -a "$LOG_FILE"
# Step 7: Create Neptune DB cluster
echo "Creating Neptune DB cluster..." | tee -a "$LOG_FILE"
DB_CLUSTER_OUTPUT=$(aws neptune create-db-cluster --db-cluster-identifier $DB_CLUSTER_ID --engine neptune --vpc-security-group-ids $SECURITY_GROUP_ID --db-subnet-group-name $DB_SUBNET_GROUP --output json)
check_error "$DB_CLUSTER_OUTPUT" $? "Failed to create Neptune DB cluster"
echo "Neptune DB cluster created: $DB_CLUSTER_ID" | tee -a "$LOG_FILE"
# Step 8: Create Neptune DB instance
echo "Creating Neptune DB instance..." | tee -a "$LOG_FILE"
DB_INSTANCE_OUTPUT=$(aws neptune create-db-instance --db-instance-identifier $DB_INSTANCE_ID --db-instance-class db.r5.large --engine neptune --db-cluster-identifier $DB_CLUSTER_ID --output json)
check_error "$DB_INSTANCE_OUTPUT" $? "Failed to create Neptune DB instance"
echo "Neptune DB instance created: $DB_INSTANCE_ID" | tee -a "$LOG_FILE"
# Step 9: Wait for the DB instance to become available
echo "Waiting for Neptune DB instance to become available..." | tee -a "$LOG_FILE"
log_cmd "aws neptune wait db-instance-available --db-instance-identifier $DB_INSTANCE_ID"
# Step 10: Get the Neptune endpoint
echo "Getting Neptune endpoint..." | tee -a "$LOG_FILE"
ENDPOINT_OUTPUT=$(aws neptune describe-db-clusters --db-cluster-identifier $DB_CLUSTER_ID --output json)
check_error "$ENDPOINT_OUTPUT" $? "Failed to get Neptune endpoint"
NEPTUNE_ENDPOINT=$(echo "$ENDPOINT_OUTPUT" | grep -o '"Endpoint": "[^"]*' | cut -d'"' -f4)
echo "Neptune endpoint: $NEPTUNE_ENDPOINT" | tee -a "$LOG_FILE"
# Step 11: Display information about how to connect to Neptune
echo "" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "NEPTUNE SETUP COMPLETE" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "Neptune Endpoint: $NEPTUNE_ENDPOINT" | tee -a "$LOG_FILE"
echo "Port: 8182" | tee -a "$LOG_FILE"
echo "" | tee -a "$LOG_FILE"
echo "To query your Neptune database using Gremlin, you can use curl:" | tee -a "$LOG_FILE"
echo "curl -X POST -d '{\"gremlin\":\"g.V().limit(1)\"}' https://$NEPTUNE_ENDPOINT:8182/gremlin" | tee -a "$LOG_FILE"
echo "" | tee -a "$LOG_FILE"
echo "To add data to your graph:" | tee -a "$LOG_FILE"
echo "curl -X POST -d '{\"gremlin\":\"g.addV(\\\"person\\\").property(\\\"name\\\", \\\"Howard\\\")\"}' https://$NEPTUNE_ENDPOINT:8182/gremlin" | tee -a "$LOG_FILE"
echo "" | tee -a "$LOG_FILE"
echo "Note: You may need to configure your client machine to access the Neptune instance within the VPC." | tee -a "$LOG_FILE"
echo "For production use, consider using an EC2 instance in the same VPC or setting up a bastion host." | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
# Step 12: List all created resources
echo "" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "RESOURCES CREATED" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "VPC: $VPC_ID" | tee -a "$LOG_FILE"
echo "Internet Gateway: $IGW_ID" | tee -a "$LOG_FILE"
echo "Subnets: $SUBNET1_ID, $SUBNET2_ID, $SUBNET3_ID" | tee -a "$LOG_FILE"
echo "Route Table: $ROUTE_TABLE_ID" | tee -a "$LOG_FILE"
echo "Security Group: $SECURITY_GROUP_ID" | tee -a "$LOG_FILE"
echo "DB Subnet Group: $DB_SUBNET_GROUP" | tee -a "$LOG_FILE"
echo "Neptune DB Cluster: $DB_CLUSTER_ID" | tee -a "$LOG_FILE"
echo "Neptune DB Instance: $DB_INSTANCE_ID" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
# Step 13: Ask if user wants to clean up resources
echo "" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "CLEANUP CONFIRMATION" | tee -a "$LOG_FILE"
echo "=============================================" | tee -a "$LOG_FILE"
echo "Do you want to clean up all created resources? (y/n): " | tee -a "$LOG_FILE"
read -r CLEANUP_CHOICE
if [[ "$CLEANUP_CHOICE" =~ ^[Yy]$ ]]; then
echo "Starting cleanup process..." | tee -a "$LOG_FILE"
# Delete DB instance
echo "Deleting DB instance $DB_INSTANCE_ID..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-instance --db-instance-identifier $DB_INSTANCE_ID --skip-final-snapshot"
# Wait for DB instance to be deleted
echo "Waiting for DB instance to be deleted..." | tee -a "$LOG_FILE"
log_cmd "aws neptune wait db-instance-deleted --db-instance-identifier $DB_INSTANCE_ID"
# Delete DB cluster
echo "Deleting DB cluster $DB_CLUSTER_ID..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-cluster --db-cluster-identifier $DB_CLUSTER_ID --skip-final-snapshot"
# Wait for DB cluster to be deleted (no specific wait command for this, so we'll sleep)
echo "Waiting for DB cluster to be deleted..." | tee -a "$LOG_FILE"
sleep 60
# Delete DB subnet group
echo "Deleting DB subnet group $DB_SUBNET_GROUP..." | tee -a "$LOG_FILE"
log_cmd "aws neptune delete-db-subnet-group --db-subnet-group-name $DB_SUBNET_GROUP"
# Delete security group
echo "Deleting security group $SECURITY_GROUP_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-security-group --group-id $SECURITY_GROUP_ID"
# Detach and delete internet gateway
echo "Detaching and deleting internet gateway $IGW_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 detach-internet-gateway --internet-gateway-id $IGW_ID --vpc-id $VPC_ID"
log_cmd "aws ec2 delete-internet-gateway --internet-gateway-id $IGW_ID"
# Delete subnets
echo "Deleting subnets..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-subnet --subnet-id $SUBNET1_ID"
log_cmd "aws ec2 delete-subnet --subnet-id $SUBNET2_ID"
log_cmd "aws ec2 delete-subnet --subnet-id $SUBNET3_ID"
# Delete route table
echo "Deleting route table $ROUTE_TABLE_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-route-table --route-table-id $ROUTE_TABLE_ID"
# Delete VPC
echo "Deleting VPC $VPC_ID..." | tee -a "$LOG_FILE"
log_cmd "aws ec2 delete-vpc --vpc-id $VPC_ID"
echo "Cleanup complete!" | tee -a "$LOG_FILE"
else
echo "Resources will not be cleaned up. You can delete them manually later." | tee -a "$LOG_FILE"
echo "See the list of resources above for reference." | tee -a "$LOG_FILE"
fi
echo "Script completed. See $LOG_FILE for details." | tee -a "$LOG_FILE"
```
+ For API details, see the following topics in *AWS CLI Command Reference*.
+ [AssociateRouteTable](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/AssociateRouteTable)
+ [AttachInternetGateway](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/AttachInternetGateway)
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/AuthorizeSecurityGroupIngress)
+ [CreateDbCluster](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/CreateDbCluster)
+ [CreateDbInstance](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/CreateDbInstance)
+ [CreateDbSubnetGroup](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/CreateDbSubnetGroup)
+ [CreateInternetGateway](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateInternetGateway)
+ [CreateRoute](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateRoute)
+ [CreateRouteTable](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateRouteTable)
+ [CreateSecurityGroup](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateSecurityGroup)
+ [CreateSubnet](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateSubnet)
+ [CreateVpc](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/CreateVpc)
+ [DeleteDbCluster](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/DeleteDbCluster)
+ [DeleteDbInstance](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/DeleteDbInstance)
+ [DeleteDbSubnetGroup](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/DeleteDbSubnetGroup)
+ [DeleteInternetGateway](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DeleteInternetGateway)
+ [DeleteRouteTable](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DeleteRouteTable)
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DeleteSecurityGroup)
+ [DeleteSubnet](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DeleteSubnet)
+ [DeleteVpc](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DeleteVpc)
+ [DescribeAvailabilityZones](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DescribeAvailabilityZones)
+ [DescribeDbClusters](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/DescribeDbClusters)
+ [DetachInternetGateway](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/DetachInternetGateway)
+ [ModifyVpcAttribute](https://docs.aws.amazon.com/goto/aws-cli/ec2-2016-11-15/ModifyVpcAttribute)
+ [Wait](https://docs.aws.amazon.com/goto/aws-cli/neptune-2014-10-31/Wait)
------
# Use the Amazon Neptune API to develop a Lambda function that queries graph data
The following code example shows how to use the Neptune API to query graph data.
------
#### [ Java ]
**SDK for Java 2.x**
Shows how to use Amazon Neptune Java API to create a Lambda function that queries graph data within the VPC.
For complete source code and instructions on how to set up and run, see the full example on [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_neptune_lambda).
**Services used in this example**
+ Lambda
+ Neptune
------