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 do
Os clusters do Amazon Neptune normalmente são implantados na VPC e podem ser acessados somente de dentro da VPC. Isso requer configurar aplicações e ambientes de desenvolvimento dentro da VPC ou usar 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 ao Neptune pela Internet, facilitando começar a usar bancos de dados de grafos sem conhecimento especializado em rede.
## Quando usar endpoints públicos
Considere usar endpoints públicos nos seguintes cenários:
+ Você deseja testar rapidamente o Neptune em um ambiente de desenvolvimento ou teste sem configuração de rede complexa
+ Você não tem conhecimento especializado AWS em redes
+ A postura de segurança da sua aplicação não exige uma VPC privada
+ Você precisa se conectar ao Neptune em seu ambiente de desenvolvimento local
## Considerações sobre segurança
Ao usar endpoints públicos, tenha em mente estas considerações de segurança:
+ A autenticação do IAM é necessária para clusters com endpoints públicos habilitados.
+ O acesso ao banco de dados é controlado pelo grupo de segurança usado.
+ Você pode restringir quais endereços IP podem se conectar ao seu cluster.
+ Você pode usar políticas do IAM para controlar quem pode criar ou modificar clusters com acesso público. Consulte: [Restringir a criação de acesso público](#neptune-public-endpoints-restrict-access)
## Habilitar endpoints públicos
Por padrão, novos bancos de dados do Neptune são criados com endpoints públicos desabilitados. Você deve habilitar explicitamente o acesso público ao criar ou modificar um cluster.
Os endpoints públicos são compatíveis com o mecanismo Neptune versão 1.4.6.x. É necessário 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 do 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 esse assunto, consulte: [Como funcionam os endpoints públicos](#neptune-public-endpoints-how-they-work)
## Pré-requisitos
### Configuração de autenticação do IAM no cluster do Neptune
Antes de habilitar endpoints públicos em uma instância do Neptune, verifique se o cluster é compatível com a autenticação do IAM. Se não for, habilite 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
```
### Configurações de rede
1. A VPC deve ter sub-redes que habilitem o roteamento público (ter uma entrada para um gateway da internet na tabela de rotas das sub-redes). Se você não fornecer um parâmetro `db-subnet-group-name` ao criar o cluster, o grupo de sub-rede padrão será escolhido para a criação do cluster.
1. Verifique se grupo de segurança conectado ao cluster permite tráfego de entrada para os intervalos de IP e portas permitidos. Por exemplo, se você quiser permitir que o tráfego TCP de todos se conecte IPs à instância do Neptune em execução na porta 8182, a regra de entrada deve ter:
1. Tipo: Todas as TCP
1. Protocolo: TCP
1. Alcance de portas: 8182
1. Bloco CIDR: 0.0.0.0/0
**nota**
Embora você possa definir o intervalo de blocos CIDR como 0.0.0.0/0, recomendamos reduzi-lo a um intervalo de IP específico da aplicação cliente para garantir uma melhor postura de segurança.
## Criar uma 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
```
**nota**
O acesso público é habilitado no nível da instância, não no nível do cluster. Para garantir que seu cluster esteja sempre acessível por meio de endpoints públicos, todas as instâncias no cluster devem ter o acesso público habilitado.
## Usar 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 for 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 é acessível publicamente:
+ Seu endpoint de DNS é resolvido para o endereço IP privado de dentro da VPC do cluster de banco de dados.
+ Ele resolve para o endereço IP público exterior à VPC do cluster.
+ O acesso é controlado pelo grupo de segurança atribuído ao cluster.
+ Somente instâncias acessíveis ao público podem ser acessadas pela internet.
### Comportamento do endpoint do leitor
+ Se todas as instâncias do leitor estiverem acessíveis ao público, o endpoint do leitor sempre será resolvido pela internet pública.
+ Se somente algumas instâncias do leitor estiverem acessíveis ao público, o endpoint do leitor resolverá publicamente somente se selecionar uma instância acessível ao público para atender à consulta de leitura.
### Comportamento do endpoint do cluster
+ O endpoint do cluster de banco de dados sempre é resolvido para o endpoint da instância do gravador.
+ Se o endpoint público estiver habilitado na instância do gravador, o endpoint do cluster estará acessível publicamente, caso contrário, não estará.
### Comportamento após o failover do cluster
+ Um cluster do Neptune pode ter instâncias em diferentes configurações públicas acessíveis.
+ Se um cluster tiver um gravador público e um leitor não público e publicar um failover de cluster, o novo gravador (leitor anterior) se tornará não público e o novo leitor (gravador anterior) se tornará público.
## Requisitos de configuração de rede
Para os endpoints públicos funcionarem corretamente:
1. As instâncias do Neptune devem estar em sub-redes públicas dentro da sua VPC.
1. As tabelas de rota associada a essas sub-redes devem ter uma rota a um gateway da Internet de 0.0.0.0/0.
1. O grupo de segurança deve permitir o acesso dos endereços IP públicos ou dos intervalos CIDR aos quais você deseja conceder acesso.
## Restringir a criação de acesso público
Você pode usar políticas do IAM para restringir quem pode criar ou modificar clusters do Neptune com acesso público. O seguinte exemplo de política 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 informações sobre a chave de condição `rds:PublicAccessEnabled` do IAM: [Referência de autorização de serviço do Amazon RDS](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonrds.html#amazonrds-rds_PubliclyAccessible)
## CloudFormation apoio
Você pode usar CloudFormation para iniciar clusters do Neptune com endpoints públicos habilitados `PubliclyAccessible` especificando o parâmetro em seu modelo. CloudFormation
## Compatibilidade com os recursos do Neptune
Um cluster com endpoints públicos habilitados oferece suporte a todos os mesmos recursos do Neptune que um cluster somente de VPC, incluindo:
+ Bancada de trabalho do Neptune
+ Integração de pesquisa de texto completo
+ Fluxos do Neptune
+ Endpoints personalizados
+ Neptune Serverless
+ Graph Explorer
## Preços
Os endpoints públicos estão disponíveis sem qualquer custo adicional além do preço padrão do Neptune. No entanto, a conexão do seu ambiente local ao Neptune por meio de um IP público pode gerar maiores custos de transferência de dados.