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á. # Conectando-se ao seu banco de dados Amazon Neptune usando autenticação AWS Identity and Access Management Os recursos do Amazon Neptune que têm a autenticação de banco de dados do IAM habilitada exigem que todas as solicitações HTTP sejam assinadas AWS usando o Signature versão 4. Para obter informações gerais sobre como assinar solicitações com o AWS Signature versão 4, consulte [Assinatura de solicitações AWS da API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-signing.html). AWS A versão 4 do Signature é o processo para adicionar informações de autenticação às AWS solicitações. Por motivos de segurança, a maioria das solicitações AWS deve ser assinada com uma chave de acesso, que consiste em uma ID da chave de acesso e uma chave de acesso secreta. **nota** Se você estiver usando credenciais temporárias, elas expirarão após um intervalo especificado, *incluindo o token de sessão*. Você deve atualizar o seu token de sessão ao solicitar novas credenciais. Para obter mais informações, consulte [Usando credenciais de segurança temporárias para solicitar acesso aos AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). **Importante** O acesso ao Neptune com autenticação baseada no IAM exige que você crie solicitações HTTP e assine-as. **Como funciona o Signature versão 4** 1. Você cria uma solicitação canônica. 1. Você usa a solicitação canônica e algumas outras informações para criar uma. string-to-sign 1. Você usa sua chave de acesso AWS secreta para derivar uma chave de assinatura e, em seguida, usa essa chave de assinatura e a string-to-sign para criar uma assinatura. 1. Você adiciona a assinatura resultante para a solicitação de HTTP em um cabeçalho ou como um parâmetro de string de consulta. Quando recebe a solicitação, o Neptune executa as mesmas etapas que você executou para calcular a assinatura. Depois, o Neptune compara a assinatura calculada com a enviada com a solicitação. Se as assinaturas corresponderem, a solicitação é processada. Se as assinaturas não corresponderem, a solicitação é negada. Para obter informações gerais sobre como assinar solicitações com o AWS Signature versão 4, consulte [Processo de assinatura do Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) no *Referência geral da AWS*. As seções a seguir mostram exemplos que ilustram como enviar solicitações assinadas aos endpoints do Gremlin e do SPARQL de uma instância de banco de dados do Neptune com a autenticação do IAM habilitada. **Topics** + [Pré-requisitos para conectar bancos de dados do Amazon Neptune usando a autenticação do IAM](iam-auth-connect-prerq.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM na linha de comando](iam-auth-connect-command-line.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com o console do Gremlin](iam-auth-connecting-gremlin-console.md) + [Conectar-se a bancos de dados do Amazon Neptune usando o IAM com o Gremlin Java](iam-auth-connecting-gremlin-java.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Java e SPARQL](iam-auth-connecting-sparql-java.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com SPARQL e Node.js](iam-auth-connecting-sparql-node.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Python](iam-auth-connecting-python.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin Python](gremlin-python-iam-auth.md) + [Conectando-se aos bancos de dados do Amazon Neptune usando a autenticação IAM com o Gremlin JavaScript](gremlin-javascript-iam-auth.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin Go](gremlin-go-iam-auth.md) + [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin .NET](gremlin-dotnet-iam-auth.md) # Pré-requisitos para conectar bancos de dados do Amazon Neptune usando a autenticação do IAM Veja as instruções para instalar o Apache Maven e Java 8 em uma instância do Amazon EC2. Elas são necessárias para exemplos de autenticação do Amazon Neptune Signature versão 4. **Para instalar o Apache Maven e o Java 8 na instância do EC2** 1. Conecte-se à instância do Amazon EC2 com um cliente SSH. 1. Instale o Apache Maven na instância do EC2. Se estiver usando o Amazon Linux 2023 (preferencial), use: ``` sudo dnf update -y sudo dnf install maven -y ``` Se estiver usando o Amazon Linux 2, baixe o binário mais recente em [https://maven.apache.org/download.cgi: ](https://maven.apache.org/download.cgi:) ``` sudo yum remove maven -y wget https://dlcdn.apache.org/maven/maven-3/ /binaries/apache-maven--bin.tar.gz sudo tar -xzf apache-maven--bin.tar.gz -C /opt/ sudo ln -sf /opt/apache-maven- /opt/maven echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc source ~/.bashrc ``` 1. As bibliotecas do Gremlin exigem o Java 8. Insira o seguinte para instalar o Java 8 na instância do EC2. ``` sudo yum install java-1.8.0-devel ``` 1. Insira o seguinte para definir o Java 8 como o tempo de execução padrão na instância do EC2. ``` sudo /usr/sbin/alternatives --config java ``` Quando solicitado, insira o número do Java 8. 1. Insira o seguinte para definir o Java 8 como o compilador padrão na instância do EC2. ``` sudo /usr/sbin/alternatives --config javac ``` Quando solicitado, insira o número do Java 8. # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM na linha de comando Ter uma ferramenta de linha de comando para enviar consultas ao cluster de banco de dados do Neptune é muito útil, conforme ilustrado em muitos dos exemplos desta documentação. A ferramenta [curl](https://curl.haxx.se/) é uma excelente opção para se comunicar com os endpoints do Neptune quando a autenticação do IAM não está habilitada. **No entanto, para manter os dados seguros, é melhor habilitar a autenticação do IAM.** Quando a autenticação do IAM está habilitada, cada solicitação deve ser [assinada usando o Signature versão 4 (Sig4)](https://docs.aws.amazon.com/general/latest/gr/signing-aws-api-requests.html). A ferramenta de linha de comando [awscurl](https://github.com/okigan/awscurl) de terceiros usa a mesma sintaxe que `curl` e pode assinar consultas usando a assinatura Sig4. A seção [Usar o `awscurl`](#iam-auth-connect-awscurl) abaixo explica como usar `awscurl` com segurança credenciais temporárias. ## Configurar uma ferramenta de linha de comando para usar HTTPS O Neptune exige que todas as conexões usem HTTPS. Qualquer ferramenta de linha de comando, como `curl` ou `awscurl`, precisa acessar os certificados apropriados, a fim de usar HTTPS. Desde que o `curl` e o `awscurl` possam localizar os certificados adequados, eles tratam as conexões HTTPS da mesma forma que as conexões HTTP, sem precisar de parâmetros extras. Os exemplos desta documentação se baseiam nesse cenário. Para saber como obter esses certificados e como formatá-los corretamente em um armazenamento de certificados (CA) que o `curl` possa usar, consulte [SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html) na documentação do `curl`. Depois, você pode especificar o local desse armazenamento de certificados CA usando a variável de ambiente `CURL_CA_BUNDLE`. No Windows, o `curl` os procura automaticamente em um arquivo chamado `curl-ca-bundle.crt`. Ele procura primeiro no mesmo diretório `curl.exe` e, em seguida, em outros lugares no caminho. Para obter mais informações, consulte [SSL Certificate Verification](https://curl.haxx.se/docs/sslcerts.html). ## Usar `awscurl` com credenciais temporárias para se conectar com segurança a um cluster de banco de dados com a autenticação do IAM habilitada A ferramenta [awscurl](https://github.com/okigan/awscurl) usa a mesma sintaxe que `curl`, mas também precisa de informações adicionais: + **`--access_key`**: uma chave de acesso válida. Se não for fornecida usando esse parâmetro, ela deverá ser fornecida na variável de ambiente `AWS_ACCESS_KEY_ID` ou em um arquivo de configuração. + **`--secret_key`**: a chave de acesso secreta que corresponde à chave de acesso. Se não for fornecida usando esse parâmetro, ela deverá ser fornecida na variável de ambiente `AWS_SECRET_ACCESS_KEY` ou em um arquivo de configuração. + **`--security_token`**: um token de sessão válido. Se não for fornecida usando esse parâmetro, ela deverá ser fornecida na variável de ambiente `AWS_SECURITY_TOKEN` ou em um arquivo de configuração. No passado, era uma prática comum usar credenciais persistentes com `awscurl`, como credenciais de usuário do IAM ou até mesmo credenciais raiz, mas isso não é recomendado. Em vez disso, gere credenciais temporárias usando um dos [AWS Security Token Service (STS) APIs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) ou um de seus [AWS CLI wrappers](https://docs.aws.amazon.com/cli/latest/reference/sts/index.html). É melhor colocar os valores `AccessKeyId`, `SecretAccessKey` e `SessionToken` são gerados pela chamada STS nas variáveis de ambiente apropriadas em sua sessão de shell e não em um arquivo de configuração. Então, quando o shell for encerrado, as credenciais serão automaticamente descartadas, diferente de um arquivo de configuração. Da mesma forma, não solicite para as credenciais temporárias uma duração maior do que você provavelmente precisará. O exemplo a seguir mostra as etapas que você pode executar em um shell Linux para obter credenciais temporárias válidas por meia hora usando [sts assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role) e, depois, colocá-las em variáveis de ambiente em que `awscurl` pode encontrá-las: ``` aws sts assume-role \ --duration-seconds 1800 \ --role-arn "arn:aws:iam::(account-id):role/(rolename)" \ --role-session-name AWSCLI-Session > $output AccessKeyId=$(echo $output | jq '.Credentials''.AccessKeyId') SecretAccessKey=$(echo $output | jq '.Credentials''.SecretAccessKey') SessionToken=$(echo $output | jq '.Credentials''.SessionToken') export AWS_ACCESS_KEY_ID=$AccessKeyId export AWS_SECRET_ACCESS_KEY=$SecretAccessKey export AWS_SESSION_TOKEN=$SessionToken ``` Depois, você pode usar `awscurl` para fazer uma solicitação assinada para o cluster de banco de dados mais ou menos desta forma: ``` awscurl (your cluster endpoint):8182/status \ --region us-east-1 \ --service neptune-db ``` # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com o console do Gremlin Para se conectar ao Amazon Neptune usando o console Gremlin com a autenticação Signature Version 4, você `requestInterceptor()` usa para conectar um assinante SigV4 à conexão estabelecida pelo comando. `:remote` Isso exige que você configure o `Cluster` objeto manualmente e depois o passe para o `:remote` comando. Observe que isso é bem diferente da situação típica em que o comando `:remote` usa um arquivo de configuração para estabelecer a conexão. A abordagem do arquivo de configuração não funcionará porque `requestInterceptor()` deve ser definida de modo programático e não pode carregar a configuração por um arquivo. **nota** Os exemplos a seguir usam`requestInterceptor()`, que foi introduzido em TinkerPop 3.6.6. Se você estiver usando uma TinkerPop versão anterior à 3.6.6 (mas 3.5.5 ou superior), use `requestInterceptor()` em `handshakeInterceptor()` vez dos exemplos de código abaixo. Os seguintes pré-requisitos são necessários: + É necessário ter as credenciais do IAM necessárias para assinar as solicitações. Consulte [Uso da cadeia de fornecedores de credenciais padrão](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/credentials-chain.html) no Guia do AWS SDK para Java desenvolvedor. + Você deve ter instalado uma versão do console do Gremlin que seja compatível com a versão do mecanismo do Neptune que está sendo usada pelo cluster de banco de dados. Se você estiver usando credenciais temporárias, elas vão expirar após um intervalo especificado, assim como o token da sessão. Portanto, é necessário atualizar o token da sessão ao solicitar novas credenciais. Consulte [Uso de credenciais de segurança temporárias para solicitar acesso aos AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no Guia do usuário do IAM. Para obter ajuda na conexão usando SSL/TLS, consulte [Configuração de SSL/TLS](access-graph-gremlin-java.md#access-graph-gremlin-java-ssl). **Conecte o console Gremlin com a assinatura Sig4** 1. Inicie o console do Gremlin: ``` $ bin/gremlin.sh ``` 1. No prompt `gremlin>`, instale a biblioteca `amazon-neptune-sigv4-signer` (é necessário realizar esse procedimento apenas uma vez para o console): ``` :install com.amazonaws amazon-neptune-sigv4-signer 2.4.0 ``` Se você encontrar problemas com essa etapa, pode ser útil consultar a [TinkerPop documentação](https://tinkerpop.apache.org/docs/current/reference/#gremlin-applications) sobre a configuração do [Grape](http://docs.groovy-lang.org/latest/html/documentation/grape.html). **nota** Se você estiver usando um proxy HTTP, poderá encontrar erros nessa etapa em que o comando `:install` não é concluído. Para corrigir esse problema, execute os comandos a seguir para informar o console sobre o proxy: ``` System.setProperty("https.proxyHost", "(the proxy IP address)") System.setProperty("https.proxyPort", "(the proxy port)") ``` 1. Importe a classe necessária para lidar com o login em `requestInterceptor()`: ``` :import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider :import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer ``` 1. Se você estiver usando credenciais temporárias, também precisará fornecer o token de sessão da seguinte forma: ``` System.setProperty("aws.sessionToken","(your session token)") ``` 1. Se você não estabeleceu as credenciais da conta de outra forma, poderá atribuí-las da seguinte maneira: ``` System.setProperty("aws.accessKeyId","(your access key)") System.setProperty("aws.secretKey","(your secret key)") ``` 1. Crie manualmente o objeto `Cluster` para conectar-se ao Neptune: ``` cluster = Cluster.build("(host name)") \ .enableSsl(true) \ .requestInterceptor { r -> \ def sigV4Signer = new NeptuneNettyHttpSigV4Signer("(Amazon region)", \ DefaultCredentialsProvider.create()); \ sigV4Signer.signRequest(r); \ return r; } \ .create() ``` Para obter ajuda para encontrar o nome do host de uma instância de banco de dados do Neptune, consulte [Conectar-se a endpoints do Amazon Neptune](feature-overview-endpoints.md). 1. Estabeleça a conexão `:remote` usando o nome da variável do objeto `Cluster` na etapa anterior: ``` :remote connect tinkerpop.server cluster ``` 1. Insira o comando a seguir para alternar para modo remoto. Isso envia todas as consultas do Gremlin para a conexão remota: ``` :remote console ``` # Conectar-se a bancos de dados do Amazon Neptune usando o IAM com o Gremlin Java Aqui está um exemplo de como se conectar ao Neptune usando a API Gremlin Java com assinatura Sig4 (pressupõe conhecimento geral sobre o uso do Maven). Este exemplo usa a biblioteca [Amazon Neptune SigV4 Signer](https://github.com/aws/amazon-neptune-sigv4-signer) para auxiliar na assinatura de solicitações. Primeiro, defina as dependências como parte do arquivo `pom.xml`: **nota** Os exemplos a seguir usam`requestInterceptor()`, que foi introduzido em TinkerPop 3.6.6. Se você estiver usando uma TinkerPop versão anterior à 3.6.6 (mas 3.5.5 ou superior), use `requestInterceptor()` em `handshakeInterceptor()` vez dos exemplos de código abaixo. ``` com.amazonaws amazon-neptune-sigv4-signer 3.1.0 ``` O Amazon Neptune SigV4 Signer é compatível com as versões 1.x e 2.x do Java SDK. AWS Os exemplos a seguir usam 2.x, onde `DefaultCredentialsProvider` é uma `software.amazon.awssdk.auth.credentials.AwsCredentialsProvider` instância. Se você estiver atualizando da versão 1.x para a versão 2.x, consulte as [alterações do provedor de credenciais](https://docs.aws.amazon.com//sdk-for-java/latest/developer-guide/migration-client-credentials.html) na documentação do SDK for AWS Java 2.x. ``` import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider; import com.amazonaws.neptune.auth.NeptuneNettyHttpSigV4Signer; import com.amazonaws.neptune.auth.NeptuneSigV4SignerException; ... System.setProperty("aws.accessKeyId","your-access-key"); System.setProperty("aws.secretKey","your-secret-key"); ... Cluster cluster = Cluster.build((your cluster)) .enableSsl(true) .requestInterceptor( r -> { try { NeptuneNettyHttpSigV4Signer sigV4Signer = new NeptuneNettyHttpSigV4Signer("(your region)", DefaultCredentialsProvider.create()); sigV4Signer.signRequest(r); } catch (NeptuneSigV4SignerException e) { throw new RuntimeException("Exception occurred while signing the request", e); } return r; } ).create(); try { Client client = cluster.connect(); client.submit("g.V().has('code','IAD')").all().get(); } catch (Exception e) { throw new RuntimeException("Exception occurred while connecting to cluster", e); } ``` ## Autenticação do IAM entre contas O Amazon Neptune oferece suporte à autenticação do IAM entre contas por meio do uso da suposição de perfil, também conhecida como [encadeamento de perfis](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account). Para fornecer acesso a um cluster Neptune a partir de um aplicativo hospedado em uma conta diferente: AWS + Crie um novo usuário ou função do IAM na AWS conta do aplicativo, com uma política de confiança que permita que o usuário ou a função assumam outra função do IAM. Atribua esse perfil à computação que hospeda a aplicação (instância do EC2, função do Lambda, tarefa do ECS, etc.). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "assumeRolePolicy", "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111122223333:role/role-name" } ] } ``` ------ + Crie uma nova função do IAM na conta do banco de dados do Neptune que permita o acesso ao AWS banco de dados do Neptune e permita a suposição do papel a partir do usuário/função do IAM da conta do aplicativo. Use uma política de confiança de: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": [ "(ARN of application account IAM user or role)" ] }, "Action": "sts:AssumeRole", "Condition": {} } ] } ``` ------ + Use o exemplo de código a seguir como orientação para usar esses dois perfis para permitir que a aplicação acesse o Neptune. Neste exemplo, a função da conta do aplicativo será assumida por meio do [DefaultCredentialProviderChain](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/credentials.html)ao criar `STSclient` o. Em seguida, `STSclient` é usado por meio do `STSAssumeRoleSessionCredentialsProvider` para assumir a função hospedada na conta do banco de dados Neptune AWS . ``` public static void main( String[] args ) { /* * Establish an STS client from the application account. */ AWSSecurityTokenService client = AWSSecurityTokenServiceClientBuilder .standard() .build(); /* * Define the role ARN that you will be assuming in the database account where the Neptune cluster resides. */ String roleArnToAssume = "arn:aws:iam::012345678901:role/CrossAccountNeptuneRole"; String crossAccountSessionName = "cross-account-session-" + UUID.randomUUID(); /* * Change the Credentials Provider in the SigV4 Signer to use the STSAssumeRole Provider and provide it * with both the role to be assumed, the original STS client, and a session name (which can be * arbitrary.) */ Cluster cluster = Cluster.build() .addContactPoint("neptune-cluster.us-west-2.neptune.amazonaws.com") .enableSsl(true) .port(8182) .requestInterceptor( r -> { try { NeptuneNettyHttpSigV4Signer sigV4Signer = // new NeptuneNettyHttpSigV4Signer("us-west-2", DefaultCredentialsProvider.create()); new NeptuneNettyHttpSigV4Signer( "us-west-2", new STSAssumeRoleSessionCredentialsProvider .Builder(roleArnToAssume, crossAccountSessionName) .withStsClient(client) .build()); sigV4Signer.signRequest(r); } catch (NeptuneSigV4SignerException e) { throw new RuntimeException("Exception occurred while signing the request", e); } return r; } ).create(); GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster)); /* whatever application code is necessary */ cluster.close(); } ``` # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Java e SPARQL Esta seção mostra como se conectar ao Neptune usando J RDF4 ou Apache Jena com a autenticação Signature Version 4. **Pré-requisitos** + Java 8 ou posterior. + Apache Maven 3.3 ou posterior. Para obter informações sobre como instalar esses pré-requisitos em uma instância do EC2 executando o Amazon Linux, consulte [Pré-requisitos para conectar bancos de dados do Amazon Neptune usando a autenticação do IAM](iam-auth-connect-prerq.md). + Credenciais do IAM para assinar as solicitações. Para obter mais informações, consulte [Using the Default Credential Provider Chain](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) no *Guia do desenvolvedor do AWS SDK para Java *. **nota** Se você estiver usando credenciais temporárias, elas expirarão após um intervalo especificado, *incluindo o token de sessão*. Você deve atualizar o seu token de sessão ao solicitar novas credenciais. Para obter mais informações, consulte Como [usar credenciais de segurança temporárias para solicitar acesso a AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) no *Guia do usuário do IAM*. + Defina a variável `SERVICE_REGION` como um dos seguintes, indicando a região da instância de banco de dados do Neptune: + Leste dos EUA (Norte da Virgínia): `us-east-1` + Leste dos EUA (Ohio): `us-east-2` + Oeste dos EUA (N. da Califórnia): `us-west-1` + Oeste dos EUA (Oregon): `us-west-2` + Canadá (Central): `ca-central-1` + Oeste do Canadá (Calgary): `ca-west-1` + América do Sul (São Paulo): `sa-east-1` + Europa (Estocolmo): `eu-north-1` + Europa (Espanha): `eu-south-2` + Europa (Irlanda): `eu-west-1` + Europa (Londres): `eu-west-2` + Europa (Paris): `eu-west-3` + Europa (Frankfurt): `eu-central-1` + Oriente Médio (Bahrein): `me-south-1` + Oriente Médio (Emirados Árabes Unidos): `me-central-1` + Israel (Tel Aviv):   `il-central-1` + África (Cidade do Cabo): `af-south-1` + Ásia-Pacífico (Hong Kong): `ap-east-1` + Ásia-Pacífico (Tóquio): `ap-northeast-1` + Ásia-Pacífico (Seul): `ap-northeast-2` + Ásia-Pacífico (Osaka): `ap-northeast-3` + Ásia-Pacífico (Singapura): `ap-southeast-1` + Ásia-Pacífico (Sydney): `ap-southeast-2` + Ásia-Pacífico (Jacarta): `ap-southeast-3` + Ásia-Pacífico (Melbourne): `ap-southeast-4` + Ásia-Pacífico (Malásia): `ap-southeast-5` + Ásia-Pacífico (Mumbai): `ap-south-1` + Ásia-Pacífico (Hyderabad): `ap-south-2` + China (Pequim): `cn-north-1` + China (Ningxia): `cn-northwest-1` + AWS GovCloud (Oeste dos EUA): `us-gov-west-1` + AWS GovCloud (Leste dos EUA): `us-gov-east-1` **Para se conectar ao Neptune usando J RDF4 ou Apache Jena com assinatura Signature Version 4** 1. Clone o repositório de amostra de. GitHub ``` git clone https://github.com/aws/amazon-neptune-sparql-java-sigv4.git ``` 1. Altere no diretório clonado. ``` cd amazon-neptune-sparql-java-sigv4 ``` 1. Obtenha a versão mais recente do projeto marcando a ramificação com a última tag. ``` git checkout $(git describe --tags `git rev-list --tags --max-count=1`) ``` 1. Digite um dos comandos a seguir para compilar e executar o código de exemplo. *your-neptune-endpoint*Substitua pelo nome do host ou endereço IP da sua instância de banco de dados Neptune. A porta padrão é 8182. **nota** Para obter informações sobre como localizar o nome do host da instância de banco de dados do Neptune, consulte a seção [Conectar-se a endpoints do Amazon Neptune](feature-overview-endpoints.md). **Eclipse J RDF4** Digite o seguinte para executar o exemplo RDF4 J. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.rdf4j.NeptuneRdf4JSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:portsparql region-name" ``` **Apache Jena** Digite o seguinte para executar o Apache Jena de exemplo. ``` mvn compile exec:java \ -Dexec.mainClass="com.amazonaws.neptune.client.jena.NeptuneJenaSigV4Example" \ -Dexec.args="https://your-neptune-endpoint:port" ``` 1. Para visualizar o código-fonte do exemplo, consulte os exemplos no diretório `src/main/java/com/amazonaws/neptune/client/`. Para usar o driver de assinatura SigV4 no seu próprio aplicativo Java, adicione o pacote Maven `amazon-neptune-sigv4-signer` à seção `` do `pom.xml`. Recomendamos que você use os exemplos como um ponto de partida. # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com SPARQL e Node.js ## Consulta usando a assinatura Signature V4 e o AWS SDK para Javascript V3 Aqui está um exemplo de como se conectar ao Neptune SPARQL usando o Node.js com a autenticação Signature versão 4 e AWS o SDK para Javascript V3: ``` const { HttpRequest } = require('@smithy/protocol-http'); const { fromNodeProviderChain } = require('@aws-sdk/credential-providers'); const { SignatureV4 } = require('@smithy/signature-v4'); const { Sha256 } = require('@aws-crypto/sha256-universal'); const https = require('https'); var region = 'us-west-2'; // e.g. us-west-1 var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com' var query = `query=PREFIX rdf: PREFIX class: PREFIX resource: PREFIX prop: PREFIX objprop: SELECT ?movies ?title WHERE { ?jel prop:name "James Earl Jones" . ?movies ?p2 ?jel . ?movies prop:title ?title } LIMIT 10`; runQuery(query); function runQuery(q) { var request = new HttpRequest({ hostname: neptune_endpoint, port: 8182, path: 'sparql', body: encodeURI(query), headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'host': neptune_endpoint + ':8182', }, method: 'POST', }); const credentialProvider = fromNodeProviderChain(); let credentials = credentialProvider(); credentials.then( (cred)=>{ var signer = new SignatureV4({credentials: cred, region: region, sha256: Sha256, service: 'neptune-db'}); signer.sign(request).then( (req)=>{ var responseBody = ''; var sendreq = https.request( { host: req.hostname, port: req.port, path: req.path, method: req.method, headers: req.headers, }, (res) => { res.on('data', (chunk) => { responseBody += chunk; }); res.on('end', () => { console.log(JSON.parse(responseBody)); }); }); sendreq.write(req.body); sendreq.end(); } ); }, (err)=>{ console.error(err); } ); } ``` ## Consulta usando a assinatura Signature V4 e o AWS SDK para Javascript V2 Aqui está um exemplo de como se conectar ao Neptune SPARQL usando o Node.js com a autenticação Signature versão 4 e AWS o SDK para Javascript V2: ``` var AWS = require('aws-sdk'); var region = 'us-west-2'; // e.g. us-west-1 var neptune_endpoint = 'your-Neptune-cluster-endpoint'; // like: 'cluster-id.region.neptune.amazonaws.com' var query = `query=PREFIX rdf: PREFIX class: PREFIX resource: PREFIX prop: PREFIX objprop: SELECT ?movies ?title WHERE { ?jel prop:name "James Earl Jones" . ?movies ?p2 ?jel . ?movies prop:title ?title } LIMIT 10`; runQuery(query); function runQuery(q) { var endpoint = new AWS.Endpoint(neptune_endpoint); endpoint.port = 8182; var request = new AWS.HttpRequest(endpoint, region); request.path += 'sparql'; request.body = encodeURI(query); request.headers['Content-Type'] = 'application/x-www-form-urlencoded'; request.headers['host'] = neptune_endpoint; request.method = 'POST'; var credentials = new AWS.CredentialProviderChain(); credentials.resolve((err, cred)=>{ var signer = new AWS.Signers.V4(request, 'neptune-db'); signer.addAuthorization(cred, new Date()); }); var client = new AWS.HttpClient(); client.handleRequest(request, null, function(response) { console.log(response.statusCode + ' ' + response.statusMessage); var responseBody = ''; response.on('data', function (chunk) { responseBody += chunk; }); response.on('end', function (chunk) { console.log('Response body: ' + responseBody); }); }, function(error) { console.log('Error: ' + error); }); } ``` # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Python Esta seção mostra um exemplo de programa escrito em Python que ilustra como trabalhar com o Signature versão 4 no Amazon Neptune. Este exemplo é baseado nos exemplos da seção [Processo de assinatura do Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html) na *Referência geral da Amazon Web Services*. Para trabalhar com esse programa de exemplo, você precisa do seguinte: + O Python 3.x. instalado em seu computador, que você pode obter no [site da Python](https://www.python.org/downloads/). Esses programas foram testados usando Python 3.6. + A [biblioteca de solicitações do Python](https://pypi.python.org/pypi/requests), que é usada no script de exemplo para fazer solicitações da web. Uma forma conveniente para instalar pacotes do Python é usar `pip`, que obtém pacotes do site de índices de pacotes da Python. Depois, você pode instalar o `requests` executando `pip install requests` na linha de comando. + Uma chave de acesso (ID da chave de acesso e chave de acesso secreta) em variáveis de ambiente chamadas `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY`. Como melhores práticas, recomendamos que você *não* incorpore credenciais no código. Para obter mais informações, consulte [Melhores práticas para contas da AWS](https://docs.aws.amazon.com//accounts/latest/reference/best-practices.html) no *Guia de referência do AWS Gerenciamento de contas *. A região do cluster de banco de dados do Neptune na variável de ambiente denominada `SERVICE_REGION`. Se estiver usando credenciais temporárias, você deve especificar `AWS_SESSION_TOKEN` bem como `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, e `SERVICE_REGION`. **nota** Se você estiver usando credenciais temporárias, elas expirarão após um intervalo especificado, *incluindo o token de sessão*. Você deve atualizar o seu token de sessão ao solicitar novas credenciais. Para obter mais informações, consulte [Using Temporary Security Credentials to Request Access to AWS Resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). O exemplo a seguir mostra como fazer solicitações assinadas ao Neptune usando o Python. A solicitação faz uma solicitação GET ou POST. As informações de autenticação são transmitidas usando o cabeçalho de solicitação `Authorization`. Esse exemplo também funciona como uma AWS Lambda função. Para obter mais informações, consulte [Configurando o AWS Lambda para a autenticação do Neptune IAM](iam-auth-temporary-credentials.md#iam-auth-temporary-credentials-lambda). **Como fazer solicitações assinadas aos endpoints do Gremlin e do SPARQL no Neptune** 1. Crie um novo arquivo denominado `neptunesigv4.py` e abra-o em um editor de texto. 1. Copie e cole o seguinte código no arquivo `neptunesigv4.py`. ``` # Amazon Neptune version 4 signing example (version v3) # The following script requires python 3.6+ # (sudo yum install python36 python36-virtualenv python36-pip) # => the reason is that we're using urllib.parse() to manually encode URL # parameters: the problem here is that SIGV4 encoding requires whitespaces # to be encoded as %20 rather than not or using '+', as done by previous/ # default versions of the library. # See: https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html import sys, datetime, hashlib, hmac import requests # pip3 install requests import urllib import os import json from botocore.auth import SigV4Auth from botocore.awsrequest import AWSRequest from botocore.credentials import ReadOnlyCredentials from types import SimpleNamespace from argparse import RawTextHelpFormatter from argparse import ArgumentParser # Configuration. https is required. protocol = 'https' # The following lines enable debugging at httplib level (requests->urllib3->http.client) # You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA. # # The only thing missing will be the response.body which is not logged. # # import logging # from http.client import HTTPConnection # HTTPConnection.debuglevel = 1 # logging.basicConfig() # logging.getLogger().setLevel(logging.DEBUG) # requests_log = logging.getLogger("requests.packages.urllib3") # requests_log.setLevel(logging.DEBUG) # requests_log.propagate = True # Read AWS access key from env. variables. Best practice is NOT # to embed credentials in code. access_key = os.getenv('AWS_ACCESS_KEY_ID', '') secret_key = os.getenv('AWS_SECRET_ACCESS_KEY', '') region = os.getenv('SERVICE_REGION', '') # AWS_SESSION_TOKEN is optional environment variable. Specify a session token only if you are using temporary # security credentials. session_token = os.getenv('AWS_SESSION_TOKEN', '') ### Note same script can be used for AWS Lambda (runtime = python3.6). ## Steps to use this python script for AWS Lambda # 1. AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and AWS_SESSION_TOKEN and AWS_REGION variables are already part of Lambda's Execution environment # No need to set them up explicitly. # 3. Create Lambda deployment package https://docs.aws.amazon.com/lambda/latest/dg/lambda-python-how-to-create-deployment-package.html # 4. Create a Lambda function in the same VPC and assign an IAM role with neptune access def lambda_handler(event, context): # sample_test_input = { # "host": "END_POINT:8182", # "method": "GET", # "query_type": "gremlin", # "query": "g.V().count()" # } # Lambda uses AWS_REGION instead of SERVICE_REGION global region region = os.getenv('AWS_REGION', '') host = event['host'] method = event['method'] query_type = event['query_type'] query = event['query'] return make_signed_request(host, method, query_type, query) def validate_input(method, query_type): # Supporting GET and POST for now: if (method != 'GET' and method != 'POST'): print('First parameter must be "GET" or "POST", but is "' + method + '".') sys.exit() # SPARQL UPDATE requires POST if (method == 'GET' and query_type == 'sparqlupdate'): print('SPARQL UPDATE is not supported in GET mode. Please choose POST.') sys.exit() def get_canonical_uri_and_payload(query_type, query, method): # Set the stack and payload depending on query_type. if (query_type == 'sparql'): canonical_uri = '/sparql/' payload = {'query': query} elif (query_type == 'sparqlupdate'): canonical_uri = '/sparql/' payload = {'update': query} elif (query_type == 'gremlin'): canonical_uri = '/gremlin/' payload = {'gremlin': query} if (method == 'POST'): payload = json.dumps(payload) elif (query_type == 'openCypher'): canonical_uri = '/openCypher/' payload = {'query': query} elif (query_type == "loader"): canonical_uri = "/loader/" payload = query elif (query_type == "status"): canonical_uri = "/status/" payload = {} elif (query_type == "gremlin/status"): canonical_uri = "/gremlin/status/" payload = {} elif (query_type == "openCypher/status"): canonical_uri = "/openCypher/status/" payload = {} elif (query_type == "sparql/status"): canonical_uri = "/sparql/status/" payload = {} else: print( 'Third parameter should be from ["gremlin", "sparql", "sparqlupdate", "loader", "status] but is "' + query_type + '".') sys.exit() ## return output as tuple return canonical_uri, payload def make_signed_request(host, method, query_type, query): service = 'neptune-db' endpoint = protocol + '://' + host print() print('+++++ USER INPUT +++++') print('host = ' + host) print('method = ' + method) print('query_type = ' + query_type) print('query = ' + query) # validate input validate_input(method, query_type) # get canonical_uri and payload canonical_uri, payload = get_canonical_uri_and_payload(query_type, query, method) # assign payload to data or params data = payload if method == 'POST' else None params = payload if method == 'GET' else None # create request URL request_url = endpoint + canonical_uri # create and sign request creds = SimpleNamespace( access_key=access_key, secret_key=secret_key, token=session_token, region=region, ) request = AWSRequest(method=method, url=request_url, data=data, params=params) SigV4Auth(creds, service, region).add_auth(request) r = None # ************* SEND THE REQUEST ************* if (method == 'GET'): print('++++ BEGIN GET REQUEST +++++') print('Request URL = ' + request_url) r = requests.get(request_url, headers=request.headers, verify=False, params=params) elif (method == 'POST'): print('\n+++++ BEGIN POST REQUEST +++++') print('Request URL = ' + request_url) if (query_type == "loader"): request.headers['Content-type'] = 'application/json' r = requests.post(request_url, headers=request.headers, verify=False, data=data) else: print('Request method is neither "GET" nor "POST", something is wrong here.') if r is not None: print() print('+++++ RESPONSE +++++') print('Response code: %d\n' % r.status_code) response = r.text r.close() print(response) return response help_msg = ''' export AWS_ACCESS_KEY_ID=[MY_ACCESS_KEY_ID] export AWS_SECRET_ACCESS_KEY=[MY_SECRET_ACCESS_KEY] export AWS_SESSION_TOKEN=[MY_AWS_SESSION_TOKEN] export SERVICE_REGION=[us-east-1|us-east-2|us-west-2|eu-west-1] python version >=3.6 is required. Examples: For help python3 program_name.py -h Examples: Queries python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}' python3 program_name.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}' python3 program_name.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}' Environment variables must be defined as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY and SERVICE_REGION. You should also set AWS_SESSION_TOKEN environment variable if you are using temporary credentials (ex. IAM Role or EC2 Instance profile). Current Limitations: - Query mode "sparqlupdate" requires POST (as per the SPARQL 1.1 protocol) ''' def exit_and_print_help(): print(help_msg) exit() def parse_input_and_query_neptune(): parser = ArgumentParser(description=help_msg, formatter_class=RawTextHelpFormatter) group_host = parser.add_mutually_exclusive_group() group_host.add_argument("-ho", "--host", type=str) group_port = parser.add_mutually_exclusive_group() group_port.add_argument("-p", "--port", type=int, help="port ex. 8182, default=8182", default=8182) group_action = parser.add_mutually_exclusive_group() group_action.add_argument("-a", "--action", type=str, help="http action, default = GET", default="GET") group_endpoint = parser.add_mutually_exclusive_group() group_endpoint.add_argument("-q", "--query_type", type=str, help="query_type, default = status ", default="status") group_data = parser.add_mutually_exclusive_group() group_data.add_argument("-d", "--data", type=str, help="data required for the http action", default="") args = parser.parse_args() print(args) # Read command line parameters host = args.host port = args.port method = args.action query_type = args.query_type query = args.data if (access_key == ''): print('!!! ERROR: Your AWS_ACCESS_KEY_ID environment variable is undefined.') exit_and_print_help() if (secret_key == ''): print('!!! ERROR: Your AWS_SECRET_ACCESS_KEY environment variable is undefined.') exit_and_print_help() if (region == ''): print('!!! ERROR: Your SERVICE_REGION environment variable is undefined.') exit_and_print_help() if host is None: print('!!! ERROR: Neptune DNS is missing') exit_and_print_help() host = host + ":" + str(port) make_signed_request(host, method, query_type, query) if __name__ == "__main__": parse_input_and_query_neptune() ``` 1. Em um terminal, navegue até o local do arquivo `neptunesigv4.py`. 1. Digite os comandos a seguir, substituindo a chave de acesso, a chave secreta e a região pelos valores corretos. ``` export AWS_ACCESS_KEY_ID=MY_ACCESS_KEY_ID export AWS_SECRET_ACCESS_KEY=MY_SECRET_ACCESS_KEY export SERVICE_REGION=us-east-1 or us-east-2 or us-west-1 or us-west-2 or ca-central-1 or ca-west-1 or sa-east-1 or eu-north-1 or eu-south-2 or eu-west-1 or eu-west-2 or eu-west-3 or eu-central-1 or me-south-1 or me-central-1 or il-central-1 or af-south-1 or ap-east-1 or ap-northeast-1 or ap-northeast-2 or ap-northeast-3 or ap-southeast-1 or ap-southeast-2 or ap-southeast-3 or ap-southeast-4 or ap-southeast-5 or ap-south-1 or ap-south-2 or cn-north-1 or cn-northwest-1 or us-gov-east-1 or us-gov-west-1 ``` Se estiver usando credenciais temporárias, você deve especificar `AWS_SESSION_TOKEN` bem como `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, e `SERVICE_REGION`. ``` export AWS_SESSION_TOKEN=MY_AWS_SESSION_TOKEN ``` **nota** Se você estiver usando credenciais temporárias, elas expirarão após um intervalo especificado, *incluindo o token de sessão*. Você deve atualizar o seu token de sessão ao solicitar novas credenciais. Para obter mais informações, consulte [Using Temporary Security Credentials to Request Access to AWS Resources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html). 1. Digite um dos comandos a seguir para enviar uma solicitação assinada à instância de banco de dados do Neptune. Estes exemplos usam o Python versão 3.6. **O status do endpoint** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q status ``` **Gremlin** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin -d "g.V().count()" python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q gremlin -d "g.V().count()" ``` **Status do Gremlin** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q gremlin/status ``` **SPARQL** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql -d "SELECT ?s WHERE { ?s ?p ?o }" ``` **SPARQL UPDATE** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q sparqlupdate -d "INSERT DATA { }" ``` **Status do SPARQL** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q sparql/status ``` **openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q openCypher -d "MATCH (n1) RETURN n1 LIMIT 1;" ``` **Status do openCypher** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q openCypher/status ``` **Carregador** ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{"loadId": "68b28dcc-8e15-02b1-133d-9bd0557607e6"}' python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a GET -q loader -d '{}' python3.6 neptunesigv4.py -ho your-neptune-endpoint -p 8182 -a POST -q loader -d '{"source": "source", "format" : "csv", "failOnError": "fail_on_error", "iamRoleArn": "iam_role_arn", "region": "region"}' ``` 1. A sintaxe para executar o script do Python é a seguinte: ``` python3.6 neptunesigv4.py -ho your-neptune-endpoint -p port -a GET|POST -q gremlin|sparql|sparqlupdate|loader|status -d "string0data" ``` O UPDATE SPARQL requer o `POST`. # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin Python ## Visão geral do Este guia demonstra como se conectar a um banco de dados Amazon Neptune com a autenticação IAM habilitada usando o driver Gremlin Python, com a autenticação Signature versão 4 e o SDK AWS for Python (Boto3). ## Criar uma conexão básica Use o exemplo de código a seguir como orientação sobre como estabelecer uma conexão básica com a autenticação do IAM usando o driver Gremlin Python. ``` from boto3 import Session from botocore.auth import SigV4Auth from botocore.awsrequest import AWSRequest from gremlin_python.process.anonymous_traversal import traversal from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection def main(): endpoint = 'your.cluster.endpoint.neptune.amazonaws.com' conn_string = 'wss://' + endpoint + ':8182/gremlin' default_region = 'us-east-1' service = 'neptune-db' credentials = Session().get_credentials() if credentials is None: raise Exception("No AWS credentials found") creds = credentials.get_frozen_credentials() # region set inside config profile or via AWS_DEFAULT_REGION environment variable will be loaded region = Session().region_name if Session().region_name else default_region request = AWSRequest(method='GET', url=conn_string, data=None) SigV4Auth(creds, service, region).add_auth(request) rc = DriverRemoteConnection(conn_string, 'g', headers=request.headers.items()) g = traversal().with_remote(rc) # simple query to verify connection count = g.V().count().next() print('Vertex count: ' + str(count)) # cleanup rc.close() if __name__ == "__main__": main() ``` # Conectando-se aos bancos de dados do Amazon Neptune usando a autenticação IAM com o Gremlin JavaScript ## Visão geral do Este guia demonstra como se conectar a um banco de dados Amazon Neptune com a autenticação IAM habilitada usando JavaScript o driver Gremlin, com a autenticação Signature versão 4 e o SDK para Javascript v3. AWS ## Pré-requisitos + Um cluster do Amazon Neptune com autenticação do IAM habilitada. + Node 13 ou posterior (consulte as versões mínimas do Gremlin JavaScript e do [AWS SDK para Javascript](https://docs.aws.amazon.com//AWSJavaScriptSDK/v3/latest/introduction/#release-cadence) v3). + AWS credenciais configuradas (por meio de variáveis de ambiente, arquivo de credenciais compartilhado ou função do IAM). ## Criar uma conexão básica Use o exemplo de código a seguir como orientação sobre como estabelecer uma conexão básica com a autenticação do IAM usando o driver Gremlin JavaScript . ``` const { fromNodeProviderChain } = require('@aws-sdk/credential-providers'); const { getUrlAndHeaders } = require('gremlin-aws-sigv4/lib/utils'); const { loadConfig } = require("@smithy/node-config-provider"); const { NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS } = require("@smithy/config-resolver"); const gremlin = require('gremlin'); const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection; const traversal = gremlin.process.AnonymousTraversalSource.traversal; const DEFAULT_REGION = 'us-east-1'; const getCredentials = async () => { try { // Loads the default credential provider chain return await fromNodeProviderChain(); } catch (e) { console.error("No credentials found", e); throw e; } }; (main = async () => { console.log('Starting'); const credentials = await getCredentials(); try { // region set inside config profile or via AWS_REGION environment variable will be loaded credentials['region'] = await loadConfig(NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS)(); } catch (e) { credentials['region'] = DEFAULT_REGION } const connInfo = getUrlAndHeaders( 'you.cluster.endpoint.neptune.amazonaws.com', '8182', credentials, '/gremlin', 'wss'); const dc = new DriverRemoteConnection(connInfo['url'], {headers: connInfo['headers']}); const g = traversal().withRemote(dc); const query = g.V().limit(5).count(); const count = await query.next(); console.log("Vertex count: " + count.value); await dc.close(); }) main(); ``` # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin Go ## Visão geral do Este guia demonstra como se conectar a um banco de dados Amazon Neptune com a autenticação IAM habilitada usando o driver Gremlin Go, com a autenticação Signature versão 4 e o SDK para GO v2. AWS ## Pré-requisitos + Um cluster do Amazon Neptune com autenticação do IAM habilitada. + Go 1.22 ou posterior (consulte as versões mínimas compatíveis para [Gremlin Go](https://pkg.go.dev/github.com/apache/tinkerpop/gremlin-go/v3/driver) e [AWS SDK para Go v2](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2)). + AWS credenciais configuradas (por meio de variáveis de ambiente, arquivo de credenciais compartilhado ou função do IAM) ## Criar uma conexão básica Use o exemplo de código a seguir como orientação sobre como estabelecer uma conexão básica com a autenticação do IAM usando o driver Gremlin Go. ``` package main import ( "context" "fmt" "github.com/aws/aws-sdk-go-v2/config" "net/http" "strings" "time" gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver" v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4" ) const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` func main() { neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com" connString := "wss://" + neptuneEndpoint + ":8182/gremlin" service := "neptune-db" defaultRegion := "us-east-1" // Create request to sign req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader("")) if err != nil { fmt.Println(err) return } // Loads the default config with default credentials provider // See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { fmt.Println(err) return } // Retrieve loaded credentials cr, err := cfg.Credentials.Retrieve(context.TODO()) if err != nil { fmt.Println(err) return } region := defaultRegion if cfg.Region != "" { // region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded region = cfg.Region } signer := v4.NewSigner() // Sign request err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, "us-east-2", time.Now()) if err != nil { fmt.Println(err) return } // Pass the signed request header into gremlingo.HeaderAuthInfo() driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString, func(settings *gremlingo.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = gremlingo.HeaderAuthInfo(req.Header) // settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991 }) if err != nil { fmt.Println(err) return } // Cleanup defer driverRemoteConnection.Close() // Creating graph traversal g := gremlingo.Traversal_().WithRemote(driverRemoteConnection) // Query execution count, err := g.V().Limit(5).Count().Next() if err != nil { fmt.Println(err) return } fmt.Println("Vertex count:", *count) } ``` ## Atualização dinâmica de credenciais do Gremlin Go O Gremlin Go DynamicAuth permite a injeção de um ponteiro de função para recuperar credenciais e gerar o cabeçalho, o que evita a expiração do cabeçalho com conexões de longa duração. ``` package main import ( "context" "crypto/tls" "fmt" "github.com/aws/aws-sdk-go-v2/config" "net/http" "strings" "time" gremlingo "github.com/apache/tinkerpop/gremlin-go/v3/driver" v4 "github.com/aws/aws-sdk-go-v2/aws/signer/v4" ) const emptyStringSHA256 = `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` func main() { neptuneEndpoint := "you.cluster.endpoint.neptune.amazonaws.com" connString := "wss://" + neptuneEndpoint + ":8182/gremlin" service := "neptune-db" defaultRegion := "us-east-1" //Create the request to sign req, err := http.NewRequest(http.MethodGet, connString, strings.NewReader("")) if err != nil { fmt.Println(err) return } // Loads the default config with default credentials provider // See https://github.com/aws/aws-sdk-go-v2 for additional docs on API usage cfg, err := config.LoadDefaultConfig(context.TODO()) if err != nil { fmt.Println(err) return } region := defaultRegion if cfg.Region != "" { // region set inside config profile, or via AWS_REGION or AWS_DEFAULT_REGION environment variable will be loaded region = cfg.Region } signer := v4.NewSigner() // This is the function that will be used for dynamic refreseh of credentials and signed headers gen := func() gremlingo.AuthInfoProvider { // Retrieve loaded credentials cr, err := cfg.Credentials.Retrieve(context.TODO()) fmt.Println("AWS Credentials: ", cr) if err != nil { fmt.Println(err) return } // Sign request err = signer.SignHTTP(context.TODO(), cr, req, emptyStringSHA256, service, region, time.Now()) if err != nil { fmt.Println(err) return } fmt.Println(req.Header) return gremlingo.HeaderAuthInfo(req.Header) } // Pass the function into gremlingo.NewDynamicAuth(), which will generate the AuthInfoProvider to pass into gremlingo.DriverRemoteConnectionSettings below auth := gremlingo.NewDynamicAuth(gen) driverRemoteConnection, err := gremlingo.NewDriverRemoteConnection(connString, func(settings *gremlingo.DriverRemoteConnectionSettings) { settings.TraversalSource = "g" settings.AuthInfo = auth // settings.TlsConfig = &tls.Config{InsecureSkipVerify: true} // Use this only if you're on a Mac running Go 1.18+ doing local dev. See https://github.com/golang/go/issues/51991 }) if err != nil { fmt.Println(err) return } // Cleanup defer driverRemoteConnection.Close() // Creating graph traversal g := gremlingo.Traversal_().WithRemote(driverRemoteConnection) // Query execution count, err := g.V().Limit(5).Count().Next() if err != nil { fmt.Println(err) return } fmt.Println("Vertex count:", *count) } ``` # Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Gremlin .NET ## Visão geral do Este guia demonstra como se conectar a um banco de dados Amazon Neptune com a autenticação IAM habilitada usando o driver Gremlin .NET, com a autenticação Signature versão 4 e o SDK AWS para.NET v3. ## Criar uma conexão básica [Para se conectar ao Gremlin .NET, use o arquivo `SigV4RequestSigner` fonte da biblioteca https://github.com/aws/ amazon-neptune-gremlin-dotnet personalizada -sigv4.](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4) Um exemplo de configuração de projeto está localizado em [ https://github.com/aws/amazon-neptune-gremlin-dotnettree/main/example-sigv4/](https://github.com/aws/amazon-neptune-gremlin-dotnet-sigv4/tree/main/example) e é refletido abaixo. Arquivo do projeto: ``` Exe netcoreapp8.0 ``` Exemplo de programa: ``` using System; using System.Collections.Generic; using System.Net.WebSockets; using System.Linq; using System.Net.Http; using System.Security.Cryptography; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Web; using Gremlin.Net; using Gremlin.Net.Driver; using Gremlin.Net.Driver.Remote; using Gremlin.Net.Process; using Gremlin.Net.Process.Traversal; using Gremlin.Net.Structure; using static Gremlin.Net.Process.Traversal.AnonymousTraversalSource; using static Gremlin.Net.Process.Traversal.__; using static Gremlin.Net.Process.Traversal.P; using static Gremlin.Net.Process.Traversal.Order; using static Gremlin.Net.Process.Traversal.Operator; using static Gremlin.Net.Process.Traversal.Pop; using static Gremlin.Net.Process.Traversal.Scope; using static Gremlin.Net.Process.Traversal.TextP; using static Gremlin.Net.Process.Traversal.Column; using static Gremlin.Net.Process.Traversal.Direction; using static Gremlin.Net.Process.Traversal.T; using Amazon.Runtime.CredentialManagement; using Amazon.Runtime; using Amazon; using Amazon.Util; using Amazon.Neptune.Gremlin.Driver; namespace NeptuneExample { class Program { static void Main(string[] args) { /* Include your Neptune endpoint and port below. */ var neptune_host = "neptune-endpoint"; // ex: mycluster.cluster.us-east-1.neptune.amazonaws.com var neptune_port = 8182; var gremlinServer = new GremlinServer(neptune_host, neptune_port); var gremlinClient = new GremlinClient(gremlinServer, webSocketConfiguration: new SigV4RequestSigner().signRequest(neptune_host, neptune_port)); var remoteConnection = new DriverRemoteConnection(gremlinClient); var g = Traversal().WithRemote(remoteConnection); /* Example code to pull the first 5 vertices in a graph. */ Console.WriteLine("Get List of Node Labels:"); Int32 limitValue = 5; var output = g.V().Limit(limitValue).ToList(); foreach(var item in output) { Console.WriteLine(item); } } } } ```