added data examples

Author: scmacdon

.doc_gen/metadata/neptune_metadata.yaml

@@ -16,6 +16,32 @@ neptune_Hello:
                 - neptune.java2.hello.main
   services:
     neptune: {DescribeDBClustersPaginator}
+neptune_ExecuteGremlinProfileQuery:
+  languages:
+    Java:
+      versions:
+        - sdk_version: 2
+          github: javav2/example_code/neptune
+          sdkguide:
+          excerpts:
+            - description:
+              snippet_tags:
+                - neptune.java2.data.query.gremlin.main
+  services:
+    neptune: {ExecuteGremlinProfileQuery}
+neptune_ExecuteGremlinQuery:
+  languages:
+    Java:
+      versions:
+        - sdk_version: 2
+          github: javav2/example_code/neptune
+          sdkguide:
+          excerpts:
+            - description:
+              snippet_tags:
+                - neptune.java2.data.query.gremlin.profile.main
+  services:
+    neptune: {ExecuteGremlinQuery}
 neptune_DeleteDBSubnetGroup:
   languages:
     Java:

javav2/example_code/neptune/src/main/java/com/example/neptune/analytics/CreateNeptuneGraphExample.java

@@ -2,20 +2,32 @@
 
 import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
 import software.amazon.awssdk.regions.Region;
-import software.amazon.awssdk.services.neptunedata.NeptunedataClient;
 import software.amazon.awssdk.services.neptunegraph.NeptuneGraphClient;
 import software.amazon.awssdk.services.neptunegraph.model.CreateGraphRequest;
 import software.amazon.awssdk.services.neptunegraph.model.CreateGraphResponse;
-import software.amazon.awssdk.services.neptunegraph.model.GraphStatus;
 import software.amazon.awssdk.services.neptunegraph.model.NeptuneGraphException;
 
+/**
+ * This Java example demonstrates how to query Amazon Neptune Analytics (Neptune Graph) using the AWS SDK for Java V2.
+ *
+ * VPC NETWORKING REQUIREMENT:
+ * ----------------------------------------------------------------------
+ * Amazon Neptune Analytics must be accessed from within an Amazon VPC. This means:
+ *
+ * 1. Your application must run within a VPC environment such as EC2, Lambda, ECS, Cloud9, or an AWS managed notebook.
+ * 2. You **cannot run this code from your local machine** unless you are connected via a VPN or Direct Connect.
+ * 3. Ensure that your Neptune Graph cluster endpoint is accessible and security groups allow inbound access from your client.
+ * 4. Always use the HTTPS endpoint when setting the `endpointOverride()` value.
+ *
+ * You can test access by running:
+ *     curl https://<graph-endpoint>:8182/status
+ * ----------------------------------------------------------------------
+ */
+
 public class CreateNeptuneGraphExample {
 
     public static void main(String[] args) {
-        // Set the desired region
         Region region = Region.US_EAST_1;
-
-        // Set the name for your new graph
         String graphName = "sample-analytics-graph";
 
         // Create the NeptuneGraph client
@@ -25,7 +37,6 @@ public static void main(String[] args) {
                 .build();
 
         executeCreateGraph(client, graphName);
-
     }
 
     /**

javav2/example_code/neptune/src/main/java/com/example/neptune/data/GremlinProfileQueryExample.java

@@ -8,12 +8,9 @@
 import software.amazon.awssdk.http.apache.ApacheHttpClient;
 import software.amazon.awssdk.regions.Region;
 import software.amazon.awssdk.services.neptunedata.NeptunedataClient;
-
-
 import software.amazon.awssdk.services.neptunedata.model.ExecuteGremlinProfileQueryRequest;
 import software.amazon.awssdk.services.neptunedata.model.ExecuteGremlinProfileQueryResponse;
 import software.amazon.awssdk.services.neptunedata.model.NeptunedataException;
-
 import java.net.URI;
 import java.time.Duration;
 
@@ -25,17 +22,14 @@
  * ----------------------------------------------------------------------------------
  * 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 EC2 instance, Lambda function, ECS task, Cloud9 IDE, or
- *   - A connected environment (VPN, Direct Connect, or peered VPC).
+ *
+ *  - 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**
  *
  * To see an example, see Creating an AWS Lambda function that queries Neptune graph data within the VPC
  * in the AWS Code Library.
  *
- * Notes:
- * - Ensure Neptune's security group allows inbound traffic on port 8182.
- * - Replace the endpoint below with your Neptune cluster's HTTPS endpoint.
- * - To verify access, run: curl https://<your-neptune-endpoint>:8182/status
- * ----------------------------------------------------------------------------------
  */
 public class GremlinProfileQueryExample {
 
@@ -67,6 +61,7 @@ public static void main(String[] args) {
         }
     }
 
+    // snippet-start:[neptune.java2.data.query.gremlin.profile.main]
     /**
      * Executes a Gremlin PROFILE query using the provided NeptunedataClient.
      *
@@ -87,4 +82,5 @@ private static void executeGremlinProfileQuery(NeptunedataClient client) {
             System.out.println("No output returned from the profile query.");
         }
     }
+    // snippet-end:[neptune.java2.data.query.gremlin.profile.main]
 }

javav2/example_code/neptune/src/main/java/com/example/neptune/data/NeptuneGremlinExplainAndProfileExample.java

@@ -21,32 +21,18 @@
  *
  * VPC NETWORKING REQUIREMENT:
  * ----------------------------------------------------------------------
- * Amazon Neptune is designed to be **accessed from within an Amazon VPC**.
- * It does not expose a public endpoint. This means:
+ * 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:
  *
- * 1. Your Java application must run **within the same VPC** (e.g., via an EC2 instance, Lambda function, ECS task,
- *    or AWS Cloud9 environment), or from a peered VPC that has network access to Neptune.
- *
- * 2. You cannot run this example directly from your local machine (e.g., via IntelliJ or PyCharm on your laptop)
- *    unless you set up a VPN or AWS Direct Connect that bridges your local environment to your VPC.
- *
- * 3. You must ensure the **VPC Security Group** attached to your Neptune cluster allows **inbound access on port 8182**
- *    from the instance or environment where this Java code runs.
- *
- * 4. The `endpointOverride()` must use the **HTTPS Neptune endpoint** including the `:8182` port.
+ *  - 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**
  *
  * To see an example, see Creating an AWS Lambda function that queries Neptune graph data within the VPC
  * in the AWS Code Library.
  *
- *  TIP:
- * You can test connectivity using `curl` or `telnet` from your instance to:
- *     curl https://<neptune-endpoint>:8182/status
- * If this fails, it’s likely a networking or security group issue.
- *
- * ----------------------------------------------------------------------
  */
 public class NeptuneGremlinExplainAndProfileExample {
-
     // Specify the endpoint. You can obtain an endpoint by running
     // the main scenario.
      private static final String NEPTUNE_ENDPOINT = "https://[Specify-Your-Endpoint]:8182";
@@ -63,7 +49,7 @@ public static void main(String[] args) {
                         .build())
                 .build();
 
-        executeGremlinExplainQuery(NeptunedataClient client)
+        executeGremlinExplainQuery(client);
     }
 
     /**

javav2/example_code/neptune/src/main/java/com/example/neptune/data/NeptuneGremlinQueryExample.java

@@ -18,29 +18,16 @@
  *
  * VPC NETWORKING REQUIREMENT:
  * ----------------------------------------------------------------------
- * Amazon Neptune is designed to be **accessed from within an Amazon VPC**.
- * It does not expose a public endpoint. This means:
+ * 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:
  *
- * 1. Your Java application must run **within the same VPC** (e.g., via an EC2 instance, Lambda function, ECS task,
- *    or AWS Cloud9 environment), or from a peered VPC that has network access to Neptune.
- *
- * 2. You cannot run this example directly from your local machine (e.g., via IntelliJ or PyCharm on your laptop)
- *    unless you set up a VPN or AWS Direct Connect that bridges your local environment to your VPC.
- *
- * 3. You must ensure the **VPC Security Group** attached to your Neptune cluster allows **inbound access on port 8182**
- *    from the instance or environment where this Java code runs.
- *
- * 4. The `endpointOverride()` must use the **HTTPS Neptune endpoint** including the `:8182` port.
+ *  - 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**
  *
  * To see an example, see Creating an AWS Lambda function that queries Neptune graph data within the VPC
  * in the AWS Code Library.
  *
- *  TIP:
- * You can test connectivity using `curl` or `telnet` from your instance to:
- *     curl https://<neptune-endpoint>:8182/status
- * If this fails, it’s likely a networking or security group issue.
- *
- * ----------------------------------------------------------------------
  */
 
 public class NeptuneGremlinQueryExample {
@@ -62,6 +49,7 @@ public static void main(String[] args) {
                 .build();
     }
 
+    // snippet-start:[neptune.java2.data.query.gremlin.main]
     /**
      * Executes a Gremlin query against an Amazon Neptune database using the provided {@link NeptunedataClient}.
      *
@@ -94,4 +82,5 @@ public static void executeGremlinQuery(NeptunedataClient client) {
             client.close();
         }
     }
+    // snippet-end:[neptune.java2.data.query.gremlin.main]
 }

javav2/example_code/neptune/src/main/java/com/example/neptune/data/OpenCypherExplainExample.java

@@ -20,23 +20,16 @@
  * ------------------------------------------------------------------------------
  * VPC NETWORKING REQUIREMENT:
  * ------------------------------------------------------------------------------
- * Amazon Neptune must be accessed from within an Amazon VPC. It does not expose
- * a public endpoint.
+ * 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:
  *
- * 1. This Java application must run from an environment inside the same VPC as the Neptune cluster,
- *    such as EC2, ECS, AWS Lambda, AWS Cloud9, or a connected network via VPN or Direct Connect.
- *
- * 2. Ensure the Neptune cluster’s security group allows inbound access on port 8182 from the host
- *    running this application.
- *
- * 3. Use the Neptune HTTPS endpoint with port 8182 in `endpointOverride()`.
+ *  - 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**
  *
  * To see an example, see Creating an AWS Lambda function that queries Neptune graph data within the VPC
- * in the AWS Code Library. *
+ * in the AWS Code Library.
  *
- * Test connectivity with:
- *     curl https://<your-neptune-endpoint>:8182/status
- * ------------------------------------------------------------------------------
  */
 public class OpenCypherExplainExample {
 
@@ -57,6 +50,7 @@ public static void main(String[] args) {
         executeGremlinQuery(client);
     }
 
+    // snippet-start:[neptune.java2.data.query.opencypher.main]
     /**
      * Executes an OpenCypher EXPLAIN query using the provided Neptune data client.
      *
@@ -87,4 +81,5 @@ public static void executeGremlinQuery(NeptunedataClient client) {
             client.close();
         }
     }
+    // snippet-end:[neptune.java2.data.query.opencypher.main]
 }

javav2/usecases/creating_neptune_lambda/README.md

@@ -10,7 +10,7 @@
 
 This guide provides a step-by-step walkthrough for creating and deploying an AWS Lambda function that queries an Amazon Neptune graph database using the Neptune Data API.
 
-Amazon Neptune is a fully managed graph database service designed to operate within a Virtual Private Cloud (VPC). Because of this, any Lambda function that needs to access Neptune must also run inside the same VPC and be granted appropriate network and IAM permissions—external access is not supported.
+Amazon Neptune is a fully managed graph database service designed to operate within a Virtual Private Cloud (VPC). Because of this, any Lambda function that needs to access Neptune must also run inside the same VPC and be granted appropriate network and IAM permissions. External access is not supported.
 
 To ensure secure and reliable communication between Lambda and Neptune, you’ll configure key AWS infrastructure components, including VPC subnets, security groups, and IAM roles. This guide covers all necessary setup and configuration tasks to help you successfully connect your Lambda function to Neptune using the Neptune Data API.
 
@@ -19,6 +19,7 @@ To ensure secure and reliable communication between Lambda and Neptune, you’ll
 
 #### Topics
 +	Prerequisites
++ Set Up the Amazon Neptune Cluster and VPC
 +	Create an AWS Identity and Access Management (IAM) role that is used to execute Lambda functions
 +	Create an IntelliJ project
 +	Add the POM dependencies to your project
@@ -39,13 +40,13 @@ To follow along with this tutorial, you need the following:
 ### Important
 
 + The AWS services included in this document are included in the [AWS Free Tier](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc).
-+  This code has not been tested in all AWS Regions. Some AWS services are available only in specific Regions. For more information, see [AWS Regional Services](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services). 
++ This code has not been tested in all AWS Regions. Some AWS services are available only in specific Regions. For more information, see [AWS Regional Services](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services). 
 + Running this code might result in charges to your AWS account. 
 + Be sure to delete all of the resources that you create during this tutorial so that you won't be charged.
 
 ## Set Up the Amazon Neptune Cluster and VPC
 
-Amazon Neptune requires a VPC (Virtual Private Cloud) with at least two subnets in different Availability Zones (AZs) to ensure high availability and fault tolerance.
+Amazon Neptune requires a VPC with at least two subnets in different Availability Zones (AZs) to ensure high availability and fault tolerance.
 
 If you're unsure which VPC or subnets to use, you can easily generate the required resources by running the Amazon Neptune Basics scenario from the AWS Code Library. This setup will provision: