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.");
}
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK for Java 2.x *.
+ [CreaDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBCluster)
+ [CreaDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBInstance)
+ [Crea DBSubnet gruppo](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)
+ [EliminaDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBCluster)
+ [EliminaDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBInstance)
+ [Elimina DBSubnet gruppo](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBSubnetGroup)
+ [Descriva DBClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBClusters)
+ [Descriva DBInstances](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)
+ [Start (Avvio)DBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StartDBCluster)
+ [InterrompiDBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StopDBCluster)
## Azioni
### `CreateDBCluster`
Il seguente esempio di codice mostra come usare`CreateDBCluster`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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;
});
}
```
+ Per i dettagli sull'API, consulta [Create DBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBCluster) in *AWS SDK for Java 2.x API Reference*.
### `CreateDBInstance`
Il seguente esempio di codice mostra come utilizzare`CreateDBInstance`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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;
});
}
```
+ Per i dettagli sull'API, consulta [Create DBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBInstance) in *AWS SDK for Java 2.x API Reference*.
### `CreateDBSubnetGroup`
Il seguente esempio di codice mostra come utilizzare`CreateDBSubnetGroup`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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;
});
}
```
+ Per i dettagli sull'API, consulta [Create DBSubnet Group](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateDBSubnetGroup) in *AWS SDK for Java 2.x API Reference*.
### `CreateGraph`
Il seguente esempio di codice mostra come utilizzare`CreateGraph`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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();
}
}
```
+ Per i dettagli sull'API, [CreateGraph](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/CreateGraph)consulta *AWS SDK for Java 2.x API Reference*.
### `DeleteDBCluster`
Il seguente esempio di codice mostra come utilizzare`DeleteDBCluster`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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));
}
```
+ Per i dettagli sull'API, consulta [Delete DBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBCluster) in *AWS SDK for Java 2.x API Reference*.
### `DeleteDBInstance`
Il seguente esempio di codice mostra come utilizzare`DeleteDBInstance`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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));
}
```
+ Per i dettagli sull'API, consulta [Delete DBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBInstance) in *AWS SDK for Java 2.x API Reference*.
### `DeleteDBSubnetGroup`
Il seguente esempio di codice mostra come utilizzare`DeleteDBSubnetGroup`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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));
}
```
+ Per i dettagli sull'API, consulta [Delete DBSubnet Group](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DeleteDBSubnetGroup) in *AWS SDK for Java 2.x API Reference*.
### `DescribeDBClusters`
Il seguente esempio di codice mostra come utilizzare`DescribeDBClusters`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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);
});
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBClusters) in *AWS SDK for Java 2.x API Reference*.
### `DescribeDBInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeDBInstances`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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));
}
});
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/DescribeDBInstances) in *AWS SDK for Java 2.x API Reference*.
### `ExecuteGremlinProfileQuery`
Il seguente esempio di codice mostra come utilizzare`ExecuteGremlinProfileQuery`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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();
}
}
```
+ Per i dettagli sull'API, [ExecuteGremlinProfileQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinProfileQuery)consulta *AWS SDK for Java 2.x API Reference*.
### `ExecuteGremlinQuery`
Il seguente esempio di codice mostra come utilizzare`ExecuteGremlinQuery`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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.");
}
}
```
+ Per i dettagli sull'API, [ExecuteGremlinQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteGremlinQuery)consulta *AWS SDK for Java 2.x API Reference*.
### `ExecuteOpenCypherExplainQuery`
Il seguente esempio di codice mostra come utilizzare`ExecuteOpenCypherExplainQuery`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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();
}
}
```
+ Per i dettagli sull'API, [ExecuteOpenCypherExplainQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteOpenCypherExplainQuery)consulta *AWS SDK for Java 2.x API Reference*.
### `ExecuteQuery`
Il seguente esempio di codice mostra come utilizzare`ExecuteQuery`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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();
}
}
```
+ Per i dettagli sull'API, [ExecuteQuery](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/ExecuteQuery)consulta *AWS SDK for Java 2.x API Reference*.
### `StartDBCluster`
Il seguente esempio di codice mostra come utilizzare`StartDBCluster`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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);
}
});
}
```
+ Per i dettagli sull'API, consulta [Start DBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StartDBCluster) in *AWS SDK for Java 2.x API Reference*.
### `StopDBCluster`
Il seguente esempio di codice mostra come utilizzare`StopDBCluster`.
**SDK per Java 2.x**
C'è altro da fare GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](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);
}
});
}
```
+ Per i dettagli sull'API, consulta [Stop DBCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/neptune-2014-10-31/StopDBCluster) in *AWS SDK for Java 2.x API Reference*.
## Scenari
### Utilizzare l’API Neptune per eseguire query sui dati del grafico
L’esempio di codice seguente mostra come utilizzare l’API Neptune per eseguire query sui dati del grafico.
**SDK per Java 2.x**
Mostra come utilizzare l’API Java di Amazon Neptune per creare una funzione Lambda che eseguano query sui dati del grafico all’interno del VPC.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_neptune_lambda).
**Servizi utilizzati in questo esempio**
+ Lambda
+ Neptune