Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Puntos finales públicos de Neptune

Información general

Los clústeres de Amazon Neptune se implementan normalmente en su VPC y solo se puede acceder a ellos desde esa VPC. Esto requiere configurar aplicaciones y entornos de desarrollo dentro de la VPC o utilizar servicios de proxy para conectarse a la VPC, lo que aumenta el tiempo y los costes de configuración.

Los puntos finales públicos simplifican esta experiencia al permitir conexiones directas a Neptuno a través de Internet, lo que facilita la introducción a las bases de datos de gráficos sin conocimientos especializados sobre redes.

¿Cuándo utilizar los puntos finales públicos

Considere la posibilidad de utilizar puntos finales públicos en los siguientes escenarios:

Consideraciones de seguridad

Cuando utilice terminales públicos, tenga en cuenta estas consideraciones de seguridad:

Habilitación de puntos finales públicos

De forma predeterminada, las nuevas bases de datos de Neptune se crean con los puntos finales públicos deshabilitados. Debe habilitar explícitamente el acceso público al crear o modificar un clúster.

Los puntos finales públicos son compatibles con la versión 1.4.6.x del motor Neptune. Debe actualizar los clústeres existentes al menos a esta versión para utilizar esta función.

La configuración de punto final público está disponible en la instancia de Neptuno y no en el clúster de Neptuno. Por lo tanto, un cúmulo de Neptune puede existir con algunas instancias con puntos finales públicos y otras sin ellas. Sin embargo, no recomendamos tener esa configuración. Para obtener más información al respecto, consulta: Cómo funcionan los terminales públicos

Requisitos previos

Configuración de autenticación de IAM en el clúster de Neptune

Antes de habilitar los puntos finales públicos en una instancia de Neptune, asegúrate de que tu clúster sea compatible con la autenticación de IAM. Si no es así, habilítela con el siguiente comando:

aws neptune modify-db-cluster \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-cluster-identifier neptune-public-endpoint \
  --enable-iam-database-authentication

Configuración de red

Crear una nueva instancia con puntos finales públicos

Puede crear una nueva instancia de Neptune con puntos finales públicos mediante la consola de AWS administración, la AWS CLI o el SDK. AWS

Uso de la AWS CLI:

aws neptune create-db-instance \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-cluster-identifier neptune-public-endpoint \
  --publicly-accessible

Modificación de una instancia existente para el acceso público

Para modificar una instancia de Neptune existente para permitir el acceso público:

aws neptune modify-db-instance \
  --region us-west-2 \
  --engine graphdb \
  --engine-version 1.4.6.x \
  --db-instance-identifier neptune-public-endpoint \
  --publicly-accessible

Uso de los puntos finales públicos

Para comprobar si se puede acceder a su base de datos, compruebe el estado mediante la NeptuneData API AWS CLI:

aws neptunedata get-engine-status \
  --endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

Si se puede acceder a la base de datos, la respuesta es similar a la siguiente:

{
    "status": "healthy",
    "startTime": "Sun Aug 10 06:54:15 UTC 2025",
    "dbEngineVersion": "1.4.6.0.R1",
    "role": "writer",
    "dfeQueryEngine": "viaQueryHint",
    "gremlin": {
        "version": "tinkerpop-3.7.1"
    },
    "sparql": {
        "version": "sparql-1.1"
    },
    "opencypher": {
        "version": "Neptune-9.0.20190305-1.0"
    },
    "labMode": {
        "ObjectIndex": "disabled",
        "ReadWriteConflictDetection": "enabled"
    },
    "features": {
        "SlowQueryLogs": "disabled",
        "InlineServerGeneratedEdgeId": "disabled",
        "ResultCache": {
            "status": "disabled"
        },
        "IAMAuthentication": "disabled",
        "Streams": "disabled",
        "AuditLog": "disabled"
    },
    "settings": {
        "StrictTimeoutValidation": "true",
        "clusterQueryTimeoutInMs": "120000",
        "SlowQueryLogsThreshold": "5000"
    }
}

Ejemplos de cómo consultar la base de datos

AWS CLI

aws neptunedata execute-open-cypher-query \
--open-cypher-query "MATCH (n) RETURN n LIMIT 10" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

Python

import boto3
import json
from botocore.config import Config

# Configuration - Replace with your actual Neptune cluster details
cluster_endpoint = "my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com"
port = 8182
region = "my-region"

# Configure Neptune client
# This disables retries and sets the client timeout to infinite 
#     (relying on Neptune's query timeout)
endpoint_url = f"https://{cluster_endpoint}:{port}"
config = Config(
    region_name=region,
    retries={'max_attempts': 1},
    read_timeout=None
)

client = boto3.client("neptunedata", config=config, endpoint_url=endpoint_url)

cypher_query = "MATCH (n) RETURN n LIMIT 5"
try:
    response = client.execute_open_cypher_query(openCypherQuery=cypher_query)
    print("openCypher Results:")
    for item in response.get('results', []):
        print(f"  {item}")
except Exception as e:
    print(f"openCypher query failed: {e}")

JavaScript

import {
    NeptunedataClient,
    GetPropertygraphSummaryCommand
} from "@aws-sdk/client-neptunedata";
import { inspect } from "util";
import { NodeHttpHandler } from "@smithy/node-http-handler";

/**
 * Main execution function
 */
async function main() {
    // Configuration - Replace with your actual Neptune cluster details
    const clusterEndpoint = 'my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com';
    const port = 8182;
    const region = 'my-region';

    // Configure Neptune client
    // This disables retries and sets the client timeout to infinite 
    //     (relying on Neptune's query timeout)
    const endpoint = `https://${clusterEndpoint}:${port}`;
    const clientConfig = {
        endpoint: endpoint,
        sslEnabled: true,
        region: region,
        maxAttempts: 1,  // do not retry
        requestHandler: new NodeHttpHandler({
            requestTimeout: 0  // no client timeout
        })
    };

    const client = new NeptunedataClient(clientConfig);
    try {
        try {
            const command = new GetPropertygraphSummaryCommand({ mode: "basic" });
            const response = await client.send(command);
            console.log("Graph Summary:", inspect(response.payload, { depth: null }));
        } catch (error) {
            console.log("Property graph summary failed:", error.message);
        }    
    } catch (error) {
        console.error("Error in main execution:", error);
    }
}

// Run the main function
main().catch(console.error);

Go

package main
import (
    "context"
    "fmt"
    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/neptunedata"
    "os"
    "encoding/json"
    "net/http"
)

func main() {    
    // Configuration - Replace with your actual Neptune cluster details
    clusterEndpoint := "my-cluster-name.cluster-abcdefgh1234.my-region.neptune.amazonaws.com"
    port := 8182
    region := "my-region"
    
    // Configure Neptune client
    // Configure HTTP client with no timeout
    //    (relying on Neptune's query timeout)
    endpoint := fmt.Sprintf("https://%s:%d", clusterEndpoint, port)
    // Load AWS SDK configuration
    sdkConfig, _ := config.LoadDefaultConfig(
        context.TODO(),
        config.WithRegion(region),
        config.WithHTTPClient(&http.Client{Timeout: 0}),
    )
    
    // Create Neptune client with custom endpoint
    client := neptunedata.NewFromConfig(sdkConfig, func(o *neptunedata.Options) {
        o.BaseEndpoint = aws.String(endpoint)
        o.Retryer = aws.NopRetryer{} // Do not retry calls if they fail
    })

    gremlinQuery := "g.addV('person').property('name','charlie').property(id,'charlie-1')"
    serializer := "application/vnd.gremlin-v1.0+json;types=false"
    
    gremlinInput := &neptunedata.ExecuteGremlinQueryInput{
        GremlinQuery: &gremlinQuery,
        Serializer:   &serializer,
    }
    gremlinResult, err := client.ExecuteGremlinQuery(context.TODO(), gremlinInput)
    if err != nil {
        fmt.Printf("Gremlin query failed: %v\n", err)
    } else {
        var resultMap map[string]interface{}
        err = gremlinResult.Result.UnmarshalSmithyDocument(&resultMap)
        if err != nil {
            fmt.Printf("Error unmarshaling Gremlin result: %v\n", err)
        } else {
            resultJSON, _ := json.MarshalIndent(resultMap, "", "  ")
            fmt.Printf("Gremlin Result: %s\n", string(resultJSON))
        }
    }
}

Cómo funcionan los puntos finales públicos

Cuando una instancia de Neptune es de acceso público:

Comportamiento del terminal del lector

Comportamiento del terminal del clúster

Comportamiento tras la conmutación por error del clúster

Requisitos de configuración de la red

Para que los terminales públicos funcionen correctamente:

Restringir la creación de acceso público

Puede usar las políticas de IAM para restringir quién puede crear o modificar clústeres de Neptune con acceso público. El siguiente ejemplo de política deniega la creación de instancias de Neptune con acceso público:

JSON

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Deny",
      "Action": [
        "rds:CreateDBInstance",
        "rds:ModifyDBInstance",
        "rds:RestoreDBInstanceFromDBSnapshot",
        "rds:RestoreDBInstanceToPointInTime"
      ],
      "Resource": "*",
      "Condition": {
        "Bool": {
          "rds:PubliclyAccessible": true
        }
      }
    }
  ]
}

Más información sobre la clave de condición de rds:PublicAccessEnabled IAM: Referencia de autorización del servicio Amazon RDS

AWS CloudFormation soporte

Puede utilizarlos AWS CloudFormation para lanzar clústeres de Neptune con los puntos finales públicos habilitados especificando el PubliclyAccessible parámetro en la plantilla. AWS CloudFormation

Compatibilidad con las funciones de Neptune

Un clúster con puntos finales públicos habilitados es compatible con todas las funciones de Neptune que admite un clúster solo para VPC, entre las que se incluyen:

Precios

Los terminales públicos están disponibles sin coste adicional, aparte del precio estándar de Neptune. Sin embargo, la conexión desde su entorno local a Neptune a través de una IP pública puede implicar un aumento de los costes de transferencia de datos.