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 de conexión públicos de Neptune

Descripción general de

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

Los puntos de conexión públicos simplifican esta experiencia al permitir conexiones directas a Neptune a través de Internet, lo que permite empezar a utilizar bases de datos de gráficos más fácilmente sin necesidad de conocimientos especializados en redes.

Cuándo utilizar puntos de conexión públicos

Considere la posibilidad de usar puntos de conexión públicos en las siguientes situaciones:

Consideraciones de seguridad

Cuando utilice puntos de conexión públicos, tenga en cuenta estas consideraciones de seguridad:

Habilitación de puntos de conexión públicos

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

Los puntos de conexión públicos son compatibles con la versión 1.4.6.x del motor de Neptune. Debe actualizar los clústeres existentes al menos a esta versión para poder utilizar esta característica.

La configuración de los puntos de conexión públicos está disponible en la instancia de Neptune y no en el clúster de Neptune. Por lo tanto, un clúster de Neptune puede admitir algunas instancias que cuenten con puntos de conexión públicos y otras que no. Sin embargo, no recomendamos tener esa configuración. Para obtener más información al respecto, consulta: Cómo funcionan los puntos de conexión públicos.

Requisitos previos

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

Antes de habilitar los puntos de conexión públicos en una instancia de Neptune, asegúrese de que el clúster admite 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

Creación de una nueva instancia con puntos de conexión 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 una instancia existente para acceso público

Para modificar una instancia de Neptune existente y habilitar 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 puntos de conexión 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 será 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

AWSCLI

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)
    // LoadAWSSDK 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 de conexión públicos

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

Comportamiento del punto de conexión del lector

Comportamiento del punto de conexión del clúster

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

Requisitos de configuración de la red

Para que los puntos de conexión públicos funcionen correctamente:

Restricción de la creación de acceso público

Puede usar políticas de IAM para restringir quién puede crear o modificar clústeres de Neptune con acceso público. La siguiente política de ejemplo 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
        }
      }
    }
  ]
}

Para obtener más información sobre la clave de condición de IAM rds:PublicAccessEnabled, consulte: Referencia de autorización del servicio de Amazon RDS

CloudFormationsoporte

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

Compatibilidad con las características de Neptune

Un clúster con puntos de conexión públicos habilitados es compatible con todas las características de Neptune que admite un clúster solo para VPC, entre las que se incluyen:

Precios

Los puntos de conexión públicos están disponibles sin costo adicional al precio estándar de Neptune. Sin embargo, la conexión desde el entorno local a Neptune a través de una IP pública puede suponer un aumento en los costos de transferencia de datos.