As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Endpoints públicos do Neptune

Visão geral

Os clusters do Amazon Neptune são normalmente implantados em sua VPC e só podem ser acessados de dentro dessa VPC. Isso requer a configuração de aplicativos e ambientes de desenvolvimento dentro da VPC ou o uso de serviços de proxy para se conectar à VPC, o que aumenta o tempo e os custos de configuração.

Os endpoints públicos simplificam essa experiência ao permitir conexões diretas com o Neptune pela Internet, facilitando o início com bancos de dados gráficos sem conhecimento especializado em rede.

Quando usar endpoints públicos

Considere o uso de endpoints públicos nos seguintes cenários:

Considerações sobre segurança

Ao usar endpoints públicos, tenha em mente estas considerações de segurança:

Habilitando endpoints públicos

Por padrão, novos bancos de dados Neptune são criados com endpoints públicos desativados. Você deve habilitar explicitamente o acesso público ao criar ou modificar um cluster.

Os endpoints públicos são compatíveis com a versão 1.4.6.x do Neptune Engine. Você precisa atualizar os clusters existentes para pelo menos essa versão para usar esse recurso.

A configuração de endpoint público está disponível na instância do Neptune e não no cluster do Neptune. Portanto, um cluster Neptune pode existir com algumas instâncias com endpoints públicos e outras sem. No entanto, não recomendamos ter essa configuração. Para obter mais informações sobre isso, consulte: Como funcionam os endpoints públicos

Pré-requisitos

Configuração de autenticação do IAM no cluster Neptune

Antes de habilitar endpoints públicos em uma instância do Neptune, certifique-se de que seu cluster seja compatível com a autenticação do IAM. Caso contrário, ative-o usando o seguinte 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

Network settings (Configurações de rede)

Criação de uma nova instância com endpoints públicos

Você pode criar uma nova instância do Neptune com endpoints públicos usando o AWS Management Console, a AWS CLI ou o SDK. AWS

Usando a 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

Modificar uma instância existente para acesso público

Para modificar uma instância existente do Neptune para permitir o acesso 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

Usando os endpoints públicos

Para verificar se seu banco de dados está acessível, verifique o status usando a API CLI: AWS NeptuneData

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

Se o banco de dados estiver acessível, a resposta será:

{
    "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"
    }
}

Exemplos de como consultar o banco de dados

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))
        }
    }
}

Como funcionam os endpoints públicos

Quando uma instância do Neptune está acessível ao público:

Comportamento do endpoint do leitor

Comportamento do endpoint do cluster

Comportamento após o failover do cluster

Requisitos de configuração de rede

Para que os endpoints públicos funcionem corretamente:

Restringindo a criação de acesso público

Você pode usar as políticas do IAM para restringir quem pode criar ou modificar clusters do Neptune com acesso público. O exemplo de política a seguir nega a criação de instâncias do Neptune com acesso 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
        }
      }
    }
  ]
}

Mais sobre a chave de condição rds:PublicAccessEnabled do IAM: Referência de autorização de serviço do Amazon RDS

AWS CloudFormation apoio

Você pode usar AWS CloudFormation para iniciar clusters do Neptune com endpoints públicos habilitados PubliclyAccessible especificando o parâmetro em seu modelo. AWS CloudFormation

Compatibilidade com os recursos do Neptune

Um cluster com endpoints públicos habilitados oferece suporte a todos os recursos do Neptune que um cluster somente de VPC suporta, incluindo:

Preços

Os endpoints públicos estão disponíveis sem custo adicional além do preço padrão do Neptune. No entanto, conectar-se do seu ambiente local ao Neptune por meio de um IP público pode gerar maiores custos de transferência de dados.