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á. # Proteger o banco de dados do Amazon Neptune A segurança na nuvem AWS é a maior prioridade. Como AWS cliente, você se beneficia de uma arquitetura de data center e rede criada para atender aos requisitos das organizações mais sensíveis à segurança. A segurança é uma responsabilidade compartilhada entre você AWS e você. O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isto como segurança *da* nuvem e segurança *na* nuvem. + **Segurança da nuvem** — AWS é responsável por proteger a infraestrutura que executa AWS os serviços na AWS nuvem. AWS também fornece serviços que você pode usar com segurança. Auditores de terceiros testam e verificam regularmente a eficácia da nossa segurança como parte dos [programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/). Para saber mais sobre os programas de conformidade que se aplicam ao Amazon Neptune, consulte [Serviços da AWS no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/). + **Segurança na nuvem** — Sua responsabilidade é determinada pelo AWS serviço que você usa. Você também é responsável por outros fatores, incluindo a confidencialidade de seus dados, os requisitos da empresa e as leis e regulamentos aplicáveis. Essa documentação ajuda a entender como aplicar o modelo de responsabilidade compartilhada ao usar o Neptune. Os tópicos a seguir mostram como configurar o Neptune para atender aos seus objetivos de segurança e conformidade. Você também aprenderá a usar outros AWS serviços que ajudam a monitorar e proteger seus recursos do Neptune. **Topics** + [Atualizações de sistema operacional do Amazon Neptune](security-os-upgrades.md) + [Proteger dados em seu banco de dados do Amazon Neptune](data-protection.md) + [Autenticando seu banco de dados Amazon Neptune com AWS Identity and Access Management](iam-auth.md) + [Habilitar a autenticação de banco de dados do IAM no Amazon Neptune](iam-auth-enable.md) + [Conectando-se ao seu banco de dados Amazon Neptune usando autenticação AWS Identity and Access Management](iam-auth-connecting.md) + [Gerenciar o acesso aos bancos de dados do Amazon Neptune usando políticas do IAM](security-iam-access-manage.md) + [Usar perfis vinculados a serviço no Amazon Neptune](security-iam-service-linked-roles.md) + [Usar credenciais temporárias para se conectar ao Amazon Neptune](iam-auth-temporary-credentials.md) + [Registrar em log e monitorar o uso e desempenho no Amazon Neptune](security-monitoring.md) + [Amazon Neptune e endpoints de interface VPC ()AWS PrivateLink](vpc-interface-endpoints.md) + [Considerações de conformidade para o Amazon Neptune](neptune-compliance.md) + [Criar implantações do Amazon Neptune resilientes e tolerantes a desastres](disaster-recovery-resiliency.md) # Atualizações de sistema operacional do Amazon Neptune O Amazon Neptune garante melhorias contínuas no desempenho, na segurança e na estabilidade do banco de dados por meio de atualizações regulares do sistema operacional. Essas atualizações são aplicadas tanto ao banco de dados do Neptune quanto ao Neptune Analytics, seguindo um processo de atualização estruturado. O Amazon Neptune lança atualizações de sistema operacional pelo menos uma vez por mês. As atualizações de sistema operacional do banco de dados do Neptune que não exigem tempo de inatividade são aplicadas automaticamente durante a janela de manutenção. Algumas atualizações de sistema operacional (por exemplo: atualização da versão do kernel) exigem a reinicialização da instância. Essas atualizações são opcionais e não têm uma data definida para aplicação. No entanto, se você não aplicar essas atualizações, elas poderão eventualmente se tornar necessárias e aplicadas automaticamente durante a janela de manutenção da sua instância. **Neptune Analytics**: as atualizações de sistema operacional do Neptune Analytics são perfeitas e não exigem nenhuma ação do cliente. Essas atualizações são aplicadas automaticamente em segundo plano sem tempo de inatividade. Para manter a segurança e conformidade, recomendamos que você aplique todas as atualizações disponibilizadas pelo Amazon Neptune rotineiramente durante sua janela de manutenção. Ter todas as atualizações opcionais e obrigatórias ajuda a incorporar patches de segurança essenciais e garante o alinhamento com várias obrigações de conformidade. Versões desatualizadas de sistema operacional podem resultar em não conformidade com requisitos regulamentares. ## Minimizar o tempo de inatividade para atualizações de sistema operacional que exigem reinicialização Para atualizações de sistema operacional que exigem reinicialização, recomendamos que você atualize primeiro as instâncias do leitor em um cluster, e depois a instância do gravador a fim de maximizar a disponibilidade do cluster. Não recomendamos atualizar as instâncias do leitor e do gravador ao mesmo tempo, pois isso pode ocasionar um tempo de inatividade mais longo no caso de um failover. ## Aplicar atualizações de sistema operacional à instância de banco de dados do Neptune As instâncias de banco de dados do Neptune ocasionalmente exigem atualizações de sistema operacional. O Amazon Neptune faz upgrade do sistema operacional para uma versão mais recente para melhorar o desempenho do banco de dados e o procedimento de segurança geral dos clientes. Em geral, essas atualizações demoram cerca de dez minutos. As atualizações do sistema operacional não alteram a versão do mecanismo de banco de dados nem a classe de uma instância de banco de dados. Para receber notificações sobre quando uma nova atualização opcional estiver disponível, assine o `RDS-EVENT-0230` na categoria de aplicação de patches de segurança. Para obter informações sobre como se inscrever em eventos do Amazon Neptune, consulte [Inscrever-se na notificação de eventos do Neptune](https://docs.aws.amazon.com//neptune/latest/userguide/events-subscribing.html). **Importante** Sua instância de banco de dados do Amazon Neptune permanecerá off-line durante a atualização do sistema operacional. É possível minimizar o tempo de inatividade do cluster com um cluster de várias instâncias. Se você não tiver um cluster de várias instâncias, poderá optar por criar temporariamente um adicionando instâncias secundárias para realizar essa manutenção e, em seguida, excluindo as instâncias de leitura adicionais quando a manutenção for concluída (cobranças regulares pela instância secundária serão aplicadas). Você pode usar o Console de gerenciamento da AWS ou a AWS CLI para determinar se uma atualização está disponível. ### Usando o Console de gerenciamento da AWS Como determinar se uma atualização está disponível usando o Console de gerenciamento da AWS: 1. [Faça login no AWS Management Console e abra o console do Amazon Neptune em casa. https://console.aws.amazon.com/neptune/](https://console.aws.amazon.com/neptune/home) 1. No painel de navegação, escolha **Clusters** e selecione a instância. 1. Escolha **Manutenção**. 1. Na seção **Manutenção pendente**, encontre a atualização do sistema operacional. ![\[Uma imagem mostrando a seção Console de gerenciamento da AWS Manutenção e uma atualização de sistema operacional disponível.\]](http://docs.aws.amazon.com/pt_br/neptune/latest/userguide/images/consoleForOSUpgrades.png) É possível selecionar a atualização do sistema operacional e clicar em **Aplicar agora** ou **Aplicar na próxima janela de manutenção** na seção **Manutenção pendente**. Se o valor de manutenção for **próxima janela**, adie os itens de manutenção escolhendo **Adiar atualização**. Não é possível adiar uma ação de manutenção que já tiver sido iniciada. Como alternativa, é possível escolher a instância em uma lista de clusters clicando em **Clusters** no painel de navegação e selecionando **Aplicar agora** ou **Aplicar na próxima janela de manutenção** no menu **Ações**. ### Usando a AWS CLI Para determinar se uma atualização está disponível usando o AWS CLI, chame o `describe-pending-maintenance-actions` comando: ``` aws neptune describe-pending-maintenance-actions ``` ``` { "ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:db:myneptune", "PendingMaintenanceActionDetails": [ { "Action": "system-update", "Description": "New Operating System update is available" } ] } ``` Para aplicar as atualizações de sistema operacional, chame o comando `apply-pending-maintenance-action`: ``` aws neptune apply-pending-maintenance-action \ --apply-action system-update \ --resource-identifier (ARN of your DB instance) \ --opt-in-type immediate ``` # Proteger dados em seu banco de dados do Amazon Neptune O [modelo de responsabilidade AWS compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) se aplica à proteção de dados no Amazon Neptune. Conforme descrito neste modelo, AWS é responsável por proteger a infraestrutura global que executa todos os Nuvem AWS. Você é responsável por manter o controle sobre o conteúdo hospedado nessa infraestrutura. Você também é responsável pelas tarefas de configuração e gerenciamento de segurança dos Serviços da AWS que usa. Para saber mais sobre a privacidade de dados, consulte as [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/). Para saber mais sobre a proteção de dados na Europa, consulte a postagem do blog [AWS Shared Responsibility Model and RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no *Blog de segurança da AWS *. Para fins de proteção de dados, recomendamos que você proteja Conta da AWS as credenciais e configure usuários individuais com Centro de Identidade do AWS IAM ou AWS Identity and Access Management (IAM). Dessa maneira, cada usuário receberá apenas as permissões necessárias para cumprir suas obrigações de trabalho. Recomendamos também que você proteja seus dados das seguintes formas: + Use uma autenticação multifator (MFA) com cada conta. + Use SSL/TLS para se comunicar com AWS os recursos. Exigimos TLS 1.2 e recomendamos TLS 1.3. + Configure a API e o registro de atividades do usuário com AWS CloudTrail. Para obter informações sobre o uso de CloudTrail trilhas para capturar AWS atividades, consulte Como [trabalhar com CloudTrail trilhas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) no *Guia AWS CloudTrail do usuário*. + Use soluções de AWS criptografia, juntamente com todos os controles de segurança padrão Serviços da AWS. + Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados sensíveis armazenados no Amazon S3. + Se você precisar de módulos criptográficos validados pelo FIPS 140-3 ao acessar AWS por meio de uma interface de linha de comando ou de uma API, use um endpoint FIPS. Para saber mais sobre os endpoints FIPS disponíveis, consulte [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/). É altamente recomendável que nunca sejam colocadas informações confidenciais ou sensíveis, como endereços de e-mail de clientes, em tags ou campos de formato livre, como um campo **Nome**. Isso inclui quando você trabalha com o Neptune ou Serviços da AWS outro usando o console, a API AWS CLI ou. AWS SDKs Quaisquer dados inseridos em tags ou em campos de texto de formato livre usados para nomes podem ser usados para logs de faturamento ou de diagnóstico. Se você fornecer um URL para um servidor externo, é fortemente recomendável que não sejam incluídas informações de credenciais no URL para validar a solicitação nesse servidor. **Importante** O TLS 1.3 só é compatível com a versão 1.3.2.0 e superior do mecanismo do Neptune. Você usa chamadas de API AWS publicadas para gerenciar o Neptune por meio da rede. Os clientes devem oferecer compatibilidade com Transport Layer Security (TLS) 1.2 ou posterior usando pacotes de criptografia fortes, como descrito em [A criptografia se conecta aos bancos de dados do Neptune](security-ssl.md). A maioria dos sistemas modernos, como Java 7 e versões posteriores, comporta esses modos. As seções a seguir descrevem com mais detalhes como os dados do Neptune são protegidos. **Topics** + [Proteger o banco de dados do Amazon Neptune com a Amazon VPC](security-vpc.md) + [Criptografas conexões com seu banco de dados do Amazon Neptune com SSL/HTTPS](security-ssl.md) + [Criptografar dados em repouso no banco de dados do Amazon Neptune](encrypt.md) # Proteger o banco de dados do Amazon Neptune com a Amazon VPC Um cluster de banco de dados do Amazon Neptune *só* pode ser criado em uma Amazon Virtual Private Cloud (Amazon VPC) e seus endpoints são acessíveis dentro dessa VPC, em geral, por uma instância do Amazon Elastic Compute Cloud (Amazon EC2) em execução nessa VPC. Como alternativa, ele pode ser acessado usando um endpoint público. Para obter mais informações sobre endpoints públicos, consulte [Endpoints públicos do Neptune](neptune-public-endpoints.md). É possível proteger os dados do Neptune limitando o acesso à VPC em que o cluster de banco de dados do Neptune está localizado, conforme descrito em [Conectar-se a um cluster do Amazon Neptune](get-started-connecting.md). # Criptografas conexões com seu banco de dados do Amazon Neptune com SSL/HTTPS O Amazon Neptune só permite conexões Secure Sockets Layer (SSL) por meio de HTTPS para qualquer instância ou endpoint de cluster. O Neptune exige no mínimo TLS versão 1.2, usando os seguintes pacotes de criptografia forte: + `TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256` + `TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384` + `TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256` + `TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384` A partir da versão 1.3.2.0 do mecanismo do Neptune, o Neptune oferece suporte à versão 1.3 do TLS usando os seguintes conjuntos de criptografia: + TLS\$1AES\$1128\$1GCM\$1 SHA256 + TLS\$1AES\$1256\$1GCM\$1 SHA384 Mesmo quando as conexões HTTP são permitidas em versões anteriores do mecanismo, qualquer cluster de banco de dados que use um novo grupo de parâmetros de cluster de banco de dados precisa usar SSL por padrão. *Para proteger os dados, os endpoints do Neptune na versão `1.0.4.0` do mecanismo e posterior são compatíveis apenas com solicitações HTTPS.* Consulte [Usar o endpoint REST HTTP para conectar-se a uma instância de banco de dados do Neptune](access-graph-sparql-http-rest.md) para obter mais informações. O Neptune fornece automaticamente certificados SSL para instâncias de banco de dados do Neptune. Você não precisa solicitar nenhum certificado. Os certificados são fornecidos ao criar uma nova instância. O Neptune atribui um único certificado SSL curinga às instâncias em sua conta para cada região. AWS O certificado fornece entradas para os endpoints do cluster, endpoints somente leitura do cluster e endpoints de instância. **Detalhes do Certificado** As seguintes entradas estão inclusas no certificado fornecido: + Endpoint do cluster: `*.cluster-a1b2c3d4wxyz.region.neptune.amazonaws.com` + Endpoint somente leitura: `*.cluster-ro-a1b2c3d4wxyz.region.neptune.amazonaws.com` + Endpoints da instância: `*.a1b2c3d4wxyz.region.neptune.amazonaws.com` Somente as entradas listadas aqui são compatíveis. **Proxy-Connections** Os certificados oferecem suporte apenas aos nomes de host listados na seção anterior. Se você estiver usando um balanceador de carga ou um servidor proxy (como HAProxy), deverá usar a terminação SSL e ter seu próprio certificado SSL no servidor proxy. A passagem SSL não funciona porque os certificados SSL fornecidos não correspondem ao nome do host do servidor de proxy. **Certificados Root CA** Os certificados para as instâncias do Neptune são normalmente validados usando o armazenamento de confiança local do sistema operacional ou SDK (como o SDK do Java). Se for necessário fornecer um certificado raiz manualmente, faça download do [certificado CA raiz da Amazon](https://www.amazontrust.com/repository/AmazonRootCA1.pem) no formato PEM do [Amazon Services Trust Policy Repository](https://www.amazontrust.com/repository/). **Mais informações** Para obter mais informações sobre como se conectar aos endpoints do Neptune com o SSL, consulte [Configurar o console do Gremlin para conectar-se a uma instância de banco de dados do Neptune](access-graph-gremlin-console.md) e [Usar o endpoint REST HTTP para conectar-se a uma instância de banco de dados do Neptune](access-graph-sparql-http-rest.md). # Criptografar dados em repouso no banco de dados do Amazon Neptune As instâncias criptografadas do Neptune fornecem uma camada adicional de proteção de dados, ajudando a proteger os dados contra acesso não autorizado ao armazenamento subjacente. É possível usar a criptografia do Neptune para aumentar a segurança dos dados das aplicações implantadas na nuvem. Você também pode usá-lo para atender aos requisitos de conformidade para data-at-rest criptografia. [Para gerenciar as chaves usadas para criptografar e descriptografar seus recursos do Neptune, você usa ().AWS Key Management ServiceAWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/) AWS KMS combina hardware e software seguros e de alta disponibilidade para fornecer um sistema de gerenciamento de chaves dimensionado para a nuvem. Usando AWS KMS, você pode criar chaves de criptografia e definir as políticas que controlam como essas chaves podem ser usadas. AWS KMS suporta AWS CloudTrail, para que você possa auditar o uso das chaves para verificar se as chaves estão sendo usadas adequadamente. Você pode usar suas AWS KMS chaves em combinação com o Neptune e serviços AWS compatíveis, como Amazon Simple Storage Service (Amazon S3), Amazon Elastic Block Store (Amazon EBS) e Amazon Redshift. Para obter uma lista dos serviços que oferecem suporte AWS KMS, consulte [Como AWS os serviços são usados AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/services.html) no *Guia do AWS Key Management Service desenvolvedor*. Todos os logs, backups e snapshots são criptografados para uma instância criptografada do Neptune. ## Habilitar a criptografia para uma instância de banco de dados do Neptune Para habilitar a criptografia para uma nova instância de banco de dados do Neptune, selecione **Sim** na seção **Habilitar criptografia** no console do Neptune. Para obter informações sobre como criar uma instância de banco de dados do Neptune, consulte [Criar um cluster do Amazon Neptune](get-started-create-cluster.md). Ao criar uma instância de banco de dados Neptune criptografada, você também pode fornecer AWS KMS o identificador de chave para sua chave de criptografia. Se você não especificar um identificador de AWS KMS chave, o Neptune usará sua chave de criptografia padrão do Amazon RDS `aws/rds` () para sua nova instância de banco de dados Neptune. AWS KMS cria sua chave de criptografia padrão para Neptune para sua conta. AWS Sua AWS conta tem uma chave de criptografia padrão diferente para cada AWS região. Depois de criar uma instância de banco de dados criptografada do Neptune, não é possível alterar a chave de criptografia para essa instância. Portanto, determine os requisitos da chave de criptografia antes de criar a instância de banco de dados do Neptune criptografada. Você pode usar o nome do recurso da Amazon (ARN) de uma chave de outra conta para criptografar uma instância de banco de dados do Neptune. Se você criar uma instância de banco de dados Neptune com a AWS mesma conta que possui AWS KMS a chave de criptografia usada para criptografar essa nova instância de banco de dados Neptune AWS KMS , o ID da chave que você passa pode AWS KMS ser o alias da chave em vez do ARN da chave. **Importante** Se o Neptune perder o acesso à chave de criptografia de uma instância de banco de dados do Neptune, por exemplo, quando o acesso do Neptune a uma chave for revogado, a instância de banco de dados criptografada será colocada em estado terminal e só poderá ser restaurada a partir de um backup. É altamente recomendável que você sempre habilite backups para instâncias de banco de dados criptografadas do Neptune para se proteger contra a perda de dados criptografados nos bancos de dados. ## Permissões de chave necessárias ao habilitar a criptografia O usuário ou o perfil do IAM que está criando uma instância de banco de dados criptografada do Neptune deve ter pelo menos as seguintes permissões para a chave do KMS: + `"kms:Encrypt"` + `"kms:Decrypt"` + `"kms:GenerateDataKey"` + `"kms:ReEncryptTo"` + `"kms:GenerateDataKeyWithoutPlaintext"` + `"kms:CreateGrant"` + `"kms:ReEncryptFrom"` + `"kms:DescribeKey"` Veja um exemplo de política de chave que inclui as permissões necessárias: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Id": "key-consolepolicy-3", "Statement": [ { "Sid": "Allow use of the key for Neptune", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess" }, "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:GenerateDataKey", "kms:ReEncryptTo", "kms:GenerateDataKeyWithoutPlaintext", "kms:CreateGrant", "kms:ReEncryptFrom", "kms:DescribeKey" ], "Resource": "*", "Condition": { "StringEquals": { "kms:ViaService": "rds.us-east-1.amazonaws.com" } } }, { "Sid": "Deny use of the key for non Neptune", "Effect": "Deny", "Principal": { "AWS": "arn:aws:iam::123456789012:role/NeptuneFullAccess" }, "Action": [ "kms:*" ], "Resource": "*", "Condition": { "StringNotEquals": { "kms:ViaService": "rds.us-east-1.amazonaws.com" } } } ] } ``` ------ + A primeira declaração fornece acesso a tudo o que é necessário AWS KMS APIs para essa função, com escopo limitado ao Diretor de Serviço do RDS. + A segunda declaração reforça ainda mais a segurança ao impor que essa chave não pode ser usada por essa função em nenhum outro serviço. AWS Você também pode reduzir ainda mais o escopo das permissões `createGrant` adicionando: ``` "Condition": { "Bool": { "kms:GrantIsForAWSResource": true } } ``` ## Limitações da criptografia do Neptune Existem as seguintes limitações para a criptografia de clusters do Neptune: + Não é possível converter um cluster de banco de dados não criptografado em um criptografado. Além disso, é possível restaurar um snapshot de cluster de banco de dados não criptografado do para um cluster de banco de dados criptografado do . Para fazer isso, especifique uma chave de criptografia do KMS ao restaurar a partir do snapshot do cluster de banco de dados não criptografado. + Não é possível converter uma instância de banco de dados não criptografada em uma criptografado. Você só pode habilitar a criptografia para uma instância de banco de dados ao criá-la. + Além disso, as instâncias criptografadas de bancos de dados não podem ser modificadas para desabilitar a criptografia. + Você não pode ter uma réplica de leitura criptografada de uma instância de banco de dados não criptografada nem uma réplica de leitura não criptografada de uma instância de banco de dados criptografada. + Réplicas de leitura criptografadas devem ser criptografadas com a mesma chave que a instância do banco de dados de origem. # Autenticando seu banco de dados Amazon Neptune com AWS Identity and Access Management AWS Identity and Access Management (IAM) é uma ferramenta AWS service (Serviço da AWS) que ajuda o administrador a controlar com segurança o acesso aos AWS recursos. Os administradores do IAM controlam quem pode ser *autenticado* (fazer login) e *autorizado* (ter permissões) para usar recursos do Neptune. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional. Você pode usar AWS Identity and Access Management (IAM) para se autenticar em sua instância de banco de dados ou cluster de banco de dados Neptune. Quando a autenticação do banco de dados do IAM está ativada, cada solicitação deve ser assinada usando o AWS Signature Version 4. AWS A versão 4 do Signature adiciona informações de autenticação às AWS solicitações. Para segurança, todas as solicitações para clusters de banco de dados do Neptune DB com autenticação do IAM habilitada devem ser assinadas com uma chave de acesso. Essa chave consiste em um ID de chave de acesso e uma chave de acesso secreta. A autenticação é gerenciada externamente usando políticas do IAM. O Neptune se autentica na conexão e, WebSockets para conexões, verifica as permissões periodicamente para garantir que o usuário ainda tenha acesso. **nota** A revogação, a exclusão ou a troca de credenciais associadas ao usuário do IAM não são recomendadas porque não encerram nenhuma conexão já aberta. Há limites no número de WebSocket conexões simultâneas por instância do banco de dados e por quanto tempo uma conexão pode permanecer aberta. Para obter mais informações, consulte [WebSockets Limites](limits.md#limits-websockets). ## O uso do IAM depende de sua função A forma como você usa AWS Identity and Access Management (IAM) difere, dependendo do trabalho que você faz em Neptune. **Usuário do serviço**: se você usa o serviço do Neptune para fazer o trabalho, o administrador fornece as credenciais e as permissões necessárias para usar o plano de dados do Neptune. À medida que você precisa de mais acesso para fazer seu trabalho, entender como o acesso é gerenciado pode ajudar você a solicitar as permissões corretas ao administrador. **Administrador do serviço**: se você for o responsável pelos recursos do Neptune na empresa, provavelmente terá acesso às ações de gerenciamento do Neptune, que correspondem à [API de gerenciamento do Neptune.](api.md) Também pode ser seu trabalho determinar quais ações de acesso a dados e recursos do Neptune de que os usuários do serviço precisam para realizar o trabalho. Assim, um administrador do IAM poderá aplicar políticas do IAM para alterar as permissões dos usuários do serviço. **Administrador do IAM**: se você for administrador do IAM, precisará elaborar políticas do IAM para gerenciar o gerenciamento e o acesso aos dados ao Neptune. Para visualizar exemplos de política baseada em identidade do Neptune que podem ser usadas, consulte [Usar diferentes tipos de política do IAM para controle de acesso ao Neptune](security-iam-access-manage.md#iam-auth-policy). ## Autenticação com identidades A autenticação é a forma como você faz login AWS usando suas credenciais de identidade. Você deve estar autenticado como usuário do IAM ou assumindo uma função do IAM. Usuário raiz da conta da AWS Você pode fazer login como uma identidade federada usando credenciais de uma fonte de identidade como Centro de Identidade do AWS IAM (IAM Identity Center), autenticação de login único ou credenciais. Google/Facebook Para ter mais informações sobre como fazer login, consulte [Como fazer login em sua Conta da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Guia do usuário do Início de Sessão da AWS *. Para acesso programático, AWS fornece um SDK e uma CLI para assinar solicitações criptograficamente. Para ter mais informações, consulte [AWS Signature Version 4 para solicitações de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) no *Guia do usuário do IAM*. ### Conta da AWS usuário root Ao criar um Conta da AWS, você começa com uma identidade de login chamada *usuário Conta da AWS raiz* que tem acesso completo a todos Serviços da AWS os recursos. É altamente recomendável não usar o usuário-raiz em tarefas diárias. Consulte as tarefas que exigem credenciais de usuário-raiz em [Tarefas que exigem credenciais de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) no *Guia do usuário do IAM*. ### Grupos e usuários do IAM Um *[usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* é uma identidade com permissões específicas para uma única pessoa ou aplicação. É recomendável usar credenciais temporárias, em vez de usuários do IAM com credenciais de longo prazo. Para obter mais informações, consulte [Exigir que usuários humanos usem a federação com um provedor de identidade para acessar AWS usando credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*. Um [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica um conjunto de usuários do IAM e facilita o gerenciamento de permissões para grandes conjuntos de usuários. Para ter mais informações, consulte [Casos de uso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) no *Guia do usuário do IAM*. ### Perfis do IAM Uma *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade com permissões específicas que oferece credenciais temporárias. Você pode assumir uma função [mudando de um usuário para uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou chamando uma operação de AWS API AWS CLI ou. Para saber mais, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*. Os perfis do IAM são úteis para acesso de usuário federado, permissões de usuário do IAM temporárias, acesso entre contas, acesso entre serviços e aplicações em execução no Amazon EC2. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*. # Habilitar a autenticação de banco de dados do IAM no Amazon Neptune Por padrão, a autenticação de banco de dados do IAM é desabilitada quando você cria um cluster de banco de dados do Amazon Neptune. Você pode habilitar a autenticação de banco de dados do IAM (ou desabilitá-la novamente) usando o Console de gerenciamento da AWS Para criar um cluster de banco de dados do Neptune com autenticação do IAM usando o console, siga as instruções para criar um cluster de banco de dados do Neptune em [Iniciando um cluster de banco de dados Neptune usando o Console de gerenciamento da AWS](manage-console-launch-console.md). Na segunda página do processo de criação, selecione **Yes (Sim)** para **Enable IAM DB Authentication (Habilitar a autenticação de banco de dados do IAM)**. **Para habilitar ou desabilitar a autenticação do IAM para um cluster ou instância de banco de dados existente** 1. [Faça login no AWS Management Console e abra o console do Amazon Neptune em casa. https://console.aws.amazon.com/neptune/](https://console.aws.amazon.com/neptune/home) 1. No painel de navegação, escolha **Clusters**. 1. Escolha o cluster de banco de dados do Neptune que você deseja modificar e selecione **Ações de cluster**. Depois, selecione **Modify Cluster (Modificar cluster)**. 1. Na seção **Opções de banco de dados**, em **Autenticação do banco de dados do IAM**, selecione **Habilitar a autorização do banco de dados do IAM** ou **Não** (para desabilitar). Depois, escolha **Continue (Continuar)**. 1. Para aplicar as alterações imediatamente, escolha **Apply immediately**. 1. Escolha **Modificar Cluster**. # 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); } } } } ``` # Gerenciar o acesso aos bancos de dados do Amazon Neptune usando políticas do IAM As [políticas do IAM](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html) são objetos JSON que definem permissões para usar ações e recursos. Você controla o acesso AWS criando políticas e anexando-as a AWS identidades ou recursos. Uma política define permissões quando associada a uma identidade ou recurso. AWS avalia essas políticas quando um diretor faz uma solicitação. A maioria das políticas é armazenada AWS como documentos JSON. Para ter mais informações sobre documentos de política JSON, consulte [Visão geral das políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) no *Guia do usuário do IAM*. Por meio de políticas, os administradores especificam quem tem acesso a que, definindo qual **entidade principal** pode realizar **ações** em quais **recursos** e sob quais **condições**. Por padrão, usuários e perfis não têm permissões. Um administrador do IAM cria políticas do IAM e as adiciona aos perfis, os quais os usuários podem então assumir. As políticas do IAM definem permissões, independentemente do método usado para realizar a operação. ## Políticas baseadas em identidade As políticas baseadas em identidade são documentos de políticas de permissão JSON que você anexa a uma identidade (usuário, grupo ou perfil). Essas políticas controlam quais ações as identidades podem realizar, em quais recursos e sob quais condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*. As políticas baseadas em identidade podem ser políticas *em linha* (incorporadas diretamente em uma única identidade) ou *políticas gerenciadas* (políticas autônomas anexadas a várias identidades). Para saber como escolher entre uma política gerenciada e políticas em linha, consulte [Escolher entre políticas gerenciadas e políticas em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) no *Guia do usuário do IAM*. ## Usando políticas de controle de serviços (SCP) com organizações AWS As políticas de controle de serviço (SCPs) são políticas JSON que especificam as permissões máximas para uma organização ou unidade organizacional (OU) em [AWS Organizations](https://aws.amazon.com/organizations/). AWS Organizations é um serviço para agrupar e gerenciar centralmente várias AWS contas que sua empresa possui. Se você habilitar todos os recursos em uma organização, poderá aplicar políticas de controle de serviço (SCPs) a qualquer uma ou a todas as suas contas. O SCP limita as permissões para entidades nas contas dos membros, incluindo cada usuário raiz AWS da conta. Para obter mais informações sobre Organizations e SCPs, consulte [Como SCPs trabalhar](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html) no Guia AWS Organizations do Usuário. Os clientes que implantam o Amazon Neptune AWS em uma conta AWS dentro de uma organização SCPs podem usar o Amazon Neptune para controlar quais contas podem usar o Neptune. Para garantir o acesso ao Neptune em uma conta de membro: + Permita o acesso a `rds:*` e `neptune-db:*` para as operações de banco de dados do Neptune. Consulte [Why are Amazon RDS permissions and resources required to use Neptune Database?](https://aws.amazon.com/neptune/faqs/) para obter detalhes sobre por que as permissões do Amazon RDS são necessárias para o banco de dados do Neptune. + Permita o acesso a `neptune-graph:*` para operações do Neptune Analytics. ## Permissões necessárias para usar o console do Amazon Neptune Para um usuário trabalhar com o console do Amazon Neptune, esse usuário deve ter um conjunto mínimo de permissões. Essas permissões possibilitam que o usuário descreva os recursos do Neptune para a conta da AWS e forneça outras informações relacionadas, inclusive informações de segurança e rede do Amazon EC2. Se você criar uma política do IAM que seja mais restritiva que as permissões mínimas necessárias, o console do não funcionará como pretendido para os usuários com essa política do IAM. Para garantir que esses usuários ainda consigam usar o console do Neptune, associe também a política gerenciada `NeptuneReadOnlyAccess` ao usuário, conforme descrito em [Usando políticas AWS gerenciadas para acessar bancos de dados do Amazon Neptune](security-iam-access-managed-policies.md). Você não precisa permitir permissões mínimas de console para usuários que estão fazendo chamadas somente para a API do Amazon Neptune AWS CLI ou para a Amazon Neptune. ## Como associar uma política do IAM a um usuário do IAM Para aplicar uma política gerenciada ou personalizada, associe-a a um usuário do IAM. Para obter um tutorial sobre esse tópico, consulte [ Criar e anexar sua primeira política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) no *Guia do usuário do IAM*. À medida que avança pelo tutorial, você pode usar um dos exemplos de política mostrados nessa seção como um ponto de partida e adequá-lo às suas necessidades. No fim do tutorial, você terá um usuário do IAM com uma política anexada que pode usar a ação `neptune-db:*`. **Importante** As alterações em uma política do IAM demoram até dez minutos para ser aplicadas aos recursos do Neptune especificados. As políticas do IAM aplicadas a um cluster de banco de dados do Neptune aplicam-se a todas as instâncias desse cluster. ## Usar diferentes tipos de política do IAM para controle de acesso ao Neptune Para conceder acesso às ações administrativas do Neptune ou aos dados em um cluster de banco de dados do Neptune, associe políticas a um usuário ou um perfil do IAM. Para obter informações sobre como anexar uma política do IAM, consulte [Como associar uma política do IAM a um usuário do IAM](#iam-auth-policy-attaching). Para obter informações sobre como associar uma política a um perfil, consulte [Adding and Removing IAM Policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM* Para ter acesso geral ao Neptune, é possível usar uma das [políticas gerenciadas](security-iam-access-managed-policies.md) do Neptune. Para ter um acesso mais restrito, você pode criar a própria política personalizada usando as [ações administrativas](neptune-iam-admin-actions.md) e os [recursos](iam-admin-resources.md) compatíveis com o Neptune. Em uma política personalizada do IAM, é possível usar dois tipos diferentes de declaração de política que controlam diferentes modos de acesso a um cluster de banco de dados do Neptune: + [Declarações de política administrativa](iam-admin-policies.md) — As declarações de política administrativa fornecem acesso ao APIs gerenciamento do [Neptune](api.md) que você usa para criar, configurar e gerenciar um cluster de banco de dados e suas instâncias. Como o Neptune compartilha a funcionalidade com o Amazon RDS, as ações administrativas, os recursos e as chaves de condição nas políticas do Neptune usam um prefixo `rds:` por design. + [Declarações de política de acesso a dados](iam-data-access-policies.md): as declarações de política de acesso a dados usam [ações de acesso a dados](iam-dp-actions.md), [recursos](iam-data-resources.md) e [chaves de condição](iam-data-condition-keys.md#iam-neptune-condition-keys) para controlar o acesso aos dados contidos em um cluster de banco de dados. As ações de acesso a dados, os recursos e as chaves de condição do Neptune usam um prefixo `neptune-db:`. ## Usar chaves de contexto de condição do IAM no Amazon Neptune É possível especificar condições em uma declaração de política do IAM que controle o acesso ao Neptune. A declaração de política terá efeito apenas quando as condições forem verdadeiras. Por exemplo, é recomendável que uma declaração de política só entre em vigor após uma data específica ou viabilize o acesso apenas quando um valor específico estiver presente na solicitação. Para expressar condições, use chaves de condição predefinidas no elemento [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma declaração de política com [operadores de política de condição do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menos do que”. Se você especificar vários elementos de `Condition` em uma declaração ou várias chaves em um único elemento de `Condition`, a AWS os avaliará usando uma operação lógica `AND`. Se você especificar vários valores para uma única chave de condição, AWS avalia a condição usando uma `OR` operação lógica. Todas as condições devem ser atendidas antes que as permissões da instrução sejam concedidas. Você também pode usar variáveis de espaço reservado ao especificar condições. Por exemplo, é possível conceder a um usuário do IAM permissão para acessar um recurso somente se ele estiver marcado com seu nome de usuário do IAM. Para obter mais informações, consulte [Elementos de política do IAM: variáveis e tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html) no *Guia do usuário do IAM*. O tipo de dados de uma chave de condição determina quais operadores de condição você pode usar para comparar valores na solicitação com os valores na declaração de política. Se você usar um operador de condição que não seja compatível com esse tipo de dados, a correspondência sempre falhará, e a declaração da política nunca será aplicada. O Neptune aceita conjuntos de chaves de condição para declarações de política administrativa diferentes dos aceitos para declarações de política de acesso a dados: + [Chaves de condição para declarações de política administrativa](iam-admin-condition-keys.md) + [Chaves de condição para declarações de política de acesso a dados](iam-data-condition-keys.md#iam-neptune-condition-keys) ## Suporte para políticas do IAM e recursos de controle de acesso no Amazon Neptune A tabela a seguir mostra quais atributos do IAM o Neptune aceita para declarações de política administrativa e declarações de política de acesso a dados: **Atributos do IAM que você pode usar com o Neptune** | Recurso do IAM | Administração | Acesso aos dados | | --- | --- | --- | | [Políticas baseadas em identidade](#security_iam_access-manage-id-based-policies) | Sim | Sim | | [Políticas baseadas em recurso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) | Não | Não | | [Ações de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_action.html) | Sim | Sim | | [Recursos de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html) | Sim | Sim | | [Chaves de condições globais](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) | Sim | (um subconjunto) | | [Chaves de condição baseadas em tags](iam-admin-condition-keys.md#iam-rds-tag-based-condition-keys) | Sim | Não | | [Listas de controle de acesso (ACLs)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acls.html) | Não | Não | | [Políticas de controle de serviços (SCPs)](#security_iam_access-manage-scp) | Sim | Sim | | [Funções vinculadas ao serviço](security-iam-service-linked-roles.md) | Sim | Não | ## Limitações da política do IAM As alterações em uma política do IAM demoram até dez minutos para ser aplicadas aos recursos do Neptune especificados. As políticas do IAM aplicadas a um cluster de banco de dados do Neptune aplicam-se a todas as instâncias desse cluster. Atualmente, o Neptune não é compatível com o controle de acesso entre contas no nível de plano de dados. O controle de acesso entre contas só é compatível durante o carregamento em massa e usando o encadeamento de perfis. Para obter mais informações, consulte o [Tutorial de carregamento em massa](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-chain-roles.html#bulk-load-tutorial-chain-cross-account). # Usando políticas AWS gerenciadas para acessar bancos de dados do Amazon Neptune AWS aborda muitos casos de uso comuns fornecendo políticas autônomas do IAM que são criadas e administradas pela AWS. As políticas gerenciadas concedem permissões necessárias para casos de uso comuns, de maneira que você possa evitar a necessidade de investigar quais permissões são necessárias. Para obter mais informações, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*. As seguintes políticas AWS gerenciadas, que você pode anexar aos usuários em sua conta, são para usar o gerenciamento do Amazon APIs Neptune: + **[NeptuneReadOnlyAccess](read-only-access-iam-managed-policy.md)**— Concede acesso somente de leitura a todos os recursos do Neptune para fins administrativos e de acesso a dados na conta raiz. AWS + **[NeptuneFullAccess](full-access-iam-managed-policy.md)**— Concede acesso total a todos os recursos do Neptune para fins administrativos e de acesso a dados na conta raiz. AWS Isso é recomendado se você precisar de acesso total ao Neptune a partir AWS CLI do SDK ou, mas não para acesso. Console de gerenciamento da AWS + **[NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)**— Concede acesso total na AWS conta raiz a todas as ações e recursos administrativos do Neptune, mas não a quaisquer ações ou recursos de acesso a dados. Também inclui permissões adicionais para simplificar o acesso ao Neptune pelo console, inclusive permissões limitadas do IAM e do Amazon EC2 (VPC). + **[NeptuneGraphReadOnlyAccess ](graph-read-only-access-iam-managed-policy.md)**— Fornece acesso somente de leitura a todos os recursos do Amazon Neptune Analytics, além de permissões somente de leitura para serviços dependentes + **[AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md)**— Permite que o Neptune Analytics crie gráficos para CloudWatch publicar métricas e registros operacionais e de uso. As políticas e os perfis do IAM no Neptune concedem algum acesso aos recursos do Amazon RDS, pois o Neptune compartilha tecnologia operacional com o Amazon RDS para determinados atributos de gerenciamento. Isso inclui permissões administrativas da API, e é por isso que as ações administrativas do Neptune têm um prefixo `rds:`. ## Atualizações nas políticas gerenciadas do AWS Neptune A seguinte tabela monitora as atualizações das políticas gerenciadas do Neptune a partir do momento em que o Neptune começou a monitorar essas alterações: | Política | Description | Data | | --- | --- | --- | | AWS políticas gerenciadas para o Amazon Neptune — atualização das políticas existentes | As políticas gerenciadas `NeptuneReadOnlyAcess` e `NeptuneFullAccess` agora incluem `Sid` (ID da instrução) como identificador na declaração de política. | 2024-01-22 | | [NeptuneGraphReadOnlyAccess](read-only-access-iam-managed-policy.md)(lançado) | Lançado para fornecer acesso somente leitura aos grafos e recursos do Neptune Analytics. | 2023-11-29 | | [AWSServiceRoleForNeptuneGraphPolicy](aws-service-role-for-neptune-graph-policy.md)(lançado) | Lançado para permitir o acesso aos gráficos do Neptune Analytics CloudWatch para publicar métricas e registros operacionais e de uso. Consulte [Uso de funções vinculadas ao serviço (SLRs) no Neptune Analytics](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html). | 2023-11-29 | | [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)(permissões adicionadas) | As permissões adicionadas dão todo o acesso necessário para interagir com os grafos do Neptune Analytics. | 2023-11/29 | | [NeptuneFullAccess](full-access-iam-managed-policy.md)(permissões adicionadas) | Foram adicionadas permissões de acesso a dados e permissões para o novo banco de dados global. APIs | 2022-07-28 | | [NeptuneConsoleFullAccess](console-full-access-iam-managed-policy.md)(permissões adicionadas) | Permissões adicionadas para o novo banco de dados global APIs. | 2022-07-21 | | O Neptune iniciou o rastreamento das alterações | A Neptune começou a monitorar as mudanças em suas políticas gerenciadas AWS . | 2022-07-21 | # Concessão `NeptuneReadOnlyAccess` aos bancos de dados Amazon Neptune usando política gerenciada AWS A política [NeptuneReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneReadOnlyAccess)gerenciada abaixo concede acesso somente de leitura a todas as ações e recursos do Neptune para fins administrativos e de acesso a dados. **nota** Essa política foi atualizada em 21/07/2022 para incluir permissões de acesso a dados somente leitura, bem como permissões administrativas somente leitura, além de incluir permissões para ações globais do banco de dados. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowReadOnlyPermissionsForRDS", "Effect": "Allow", "Action": [ "rds:DescribeAccountAttributes", "rds:DescribeCertificates", "rds:DescribeDBClusterParameterGroups", "rds:DescribeDBClusterParameters", "rds:DescribeDBClusterSnapshotAttributes", "rds:DescribeDBClusterSnapshots", "rds:DescribeDBClusters", "rds:DescribeDBEngineVersions", "rds:DescribeDBInstances", "rds:DescribeDBLogFiles", "rds:DescribeDBParameterGroups", "rds:DescribeDBParameters", "rds:DescribeDBSubnetGroups", "rds:DescribeEventCategories", "rds:DescribeEventSubscriptions", "rds:DescribeEvents", "rds:DescribeGlobalClusters", "rds:DescribeOrderableDBInstanceOptions", "rds:DescribePendingMaintenanceActions", "rds:DownloadDBLogFilePortion", "rds:ListTagsForResource" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForCloudwatch", "Effect": "Allow", "Action": [ "cloudwatch:GetMetricStatistics", "cloudwatch:ListMetrics" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForEC2", "Effect": "Allow", "Action": [ "ec2:DescribeAccountAttributes", "ec2:DescribeAvailabilityZones", "ec2:DescribeInternetGateways", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeVpcAttribute", "ec2:DescribeVpcs" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForKMS", "Effect": "Allow", "Action": [ "kms:ListKeys", "kms:ListRetirableGrants", "kms:ListAliases", "kms:ListKeyPolicies" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForLogs", "Effect": "Allow", "Action": [ "logs:DescribeLogStreams", "logs:GetLogEvents" ], "Resource": [ "arn:aws:logs:*:*:log-group:/aws/rds/*:log-stream:*", "arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*" ] }, { "Sid": "AllowReadOnlyPermissionsForNeptuneDB", "Effect": "Allow", "Action": [ "neptune-db:Read*", "neptune-db:Get*", "neptune-db:List*" ], "Resource": [ "*" ] } ] } ``` ------ # Concessão `NeptuneFullAccess` aos bancos de dados Amazon Neptune usando política gerenciada AWS A política [NeptuneFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneFullAccess)gerenciada abaixo concede acesso total a todas as ações e recursos do Neptune para fins administrativos e de acesso a dados. É recomendável se você precisar de acesso total do AWS CLI ou de um SDK, mas não do Console de gerenciamento da AWS. **nota** Essa política foi atualizada em 21/07/2022 para incluir permissões de acesso a dados total, bem como permissões administrativas totais, além de incluir permissões para ações globais do banco de dados. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowNeptuneCreate", "Effect": "Allow", "Action": [ "rds:CreateDBCluster", "rds:CreateDBInstance" ], "Resource": [ "arn:aws:rds:*:*:*" ], "Condition": { "StringEquals": { "rds:DatabaseEngine": [ "graphdb", "neptune" ] } } }, { "Sid": "AllowManagementPermissionsForRDS", "Effect": "Allow", "Action": [ "rds:AddRoleToDBCluster", "rds:AddSourceIdentifierToSubscription", "rds:AddTagsToResource", "rds:ApplyPendingMaintenanceAction", "rds:CopyDBClusterParameterGroup", "rds:CopyDBClusterSnapshot", "rds:CopyDBParameterGroup", "rds:CreateDBClusterEndpoint", "rds:CreateDBClusterParameterGroup", "rds:CreateDBClusterSnapshot", "rds:CreateDBParameterGroup", "rds:CreateDBSubnetGroup", "rds:CreateEventSubscription", "rds:CreateGlobalCluster", "rds:DeleteDBCluster", "rds:DeleteDBClusterEndpoint", "rds:DeleteDBClusterParameterGroup", "rds:DeleteDBClusterSnapshot", "rds:DeleteDBInstance", "rds:DeleteDBParameterGroup", "rds:DeleteDBSubnetGroup", "rds:DeleteEventSubscription", "rds:DeleteGlobalCluster", "rds:DescribeDBClusterEndpoints", "rds:DescribeAccountAttributes", "rds:DescribeCertificates", "rds:DescribeDBClusterParameterGroups", "rds:DescribeDBClusterParameters", "rds:DescribeDBClusterSnapshotAttributes", "rds:DescribeDBClusterSnapshots", "rds:DescribeDBClusters", "rds:DescribeDBEngineVersions", "rds:DescribeDBInstances", "rds:DescribeDBLogFiles", "rds:DescribeDBParameterGroups", "rds:DescribeDBParameters", "rds:DescribeDBSecurityGroups", "rds:DescribeDBSubnetGroups", "rds:DescribeEngineDefaultClusterParameters", "rds:DescribeEngineDefaultParameters", "rds:DescribeEventCategories", "rds:DescribeEventSubscriptions", "rds:DescribeEvents", "rds:DescribeGlobalClusters", "rds:DescribeOptionGroups", "rds:DescribeOrderableDBInstanceOptions", "rds:DescribePendingMaintenanceActions", "rds:DescribeValidDBInstanceModifications", "rds:DownloadDBLogFilePortion", "rds:FailoverDBCluster", "rds:FailoverGlobalCluster", "rds:ListTagsForResource", "rds:ModifyDBCluster", "rds:ModifyDBClusterEndpoint", "rds:ModifyDBClusterParameterGroup", "rds:ModifyDBClusterSnapshotAttribute", "rds:ModifyDBInstance", "rds:ModifyDBParameterGroup", "rds:ModifyDBSubnetGroup", "rds:ModifyEventSubscription", "rds:ModifyGlobalCluster", "rds:PromoteReadReplicaDBCluster", "rds:RebootDBInstance", "rds:RemoveFromGlobalCluster", "rds:RemoveRoleFromDBCluster", "rds:RemoveSourceIdentifierFromSubscription", "rds:RemoveTagsFromResource", "rds:ResetDBClusterParameterGroup", "rds:ResetDBParameterGroup", "rds:RestoreDBClusterFromSnapshot", "rds:RestoreDBClusterToPointInTime", "rds:StartDBCluster", "rds:StopDBCluster" ], "Resource": [ "*" ] }, { "Sid": "AllowOtherDepedentPermissions", "Effect": "Allow", "Action": [ "cloudwatch:GetMetricStatistics", "cloudwatch:ListMetrics", "ec2:DescribeAccountAttributes", "ec2:DescribeAvailabilityZones", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeVpcAttribute", "ec2:DescribeVpcs", "kms:ListAliases", "kms:ListKeyPolicies", "kms:ListKeys", "kms:ListRetirableGrants", "logs:DescribeLogStreams", "logs:GetLogEvents", "sns:ListSubscriptions", "sns:ListTopics", "sns:Publish" ], "Resource": [ "*" ] }, { "Sid": "AllowPassRoleForNeptune", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*", "Condition": { "StringEquals": { "iam:passedToService": "rds.amazonaws.com" } } }, { "Sid": "AllowCreateSLRForNeptune", "Effect": "Allow", "Action": "iam:CreateServiceLinkedRole", "Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS", "Condition": { "StringLike": { "iam:AWSServiceName": "rds.amazonaws.com" } } }, { "Sid": "AllowDataAccessForNeptune", "Effect": "Allow", "Action": [ "neptune-db:*" ], "Resource": [ "*" ] } ] } ``` ------ # Concessão `NeptuneConsoleFullAccess` usando política AWS gerenciada A política [NeptuneConsoleFullAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneConsoleFullAccess)gerenciada abaixo concede acesso total a todas as ações e recursos do Neptune para fins administrativos, mas não para fins de acesso a dados. Também inclui permissões adicionais para simplificar o acesso ao Neptune pelo console, inclusive permissões limitadas do IAM e do Amazon EC2 (VPC). **nota** Esta política foi atualizada em 29/11/2023 para incluir as permissões necessárias para interagir com os grafos do Neptune Analytics. Atualizada em 21/07/2022 para incluir permissões para ações globais do banco de dados. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowNeptuneCreate", "Effect": "Allow", "Action": [ "rds:CreateDBCluster", "rds:CreateDBInstance" ], "Resource": [ "arn:aws:rds:*:*:*" ], "Condition": { "StringEquals": { "rds:DatabaseEngine": [ "graphdb", "neptune" ] } } }, { "Sid": "AllowManagementPermissionsForRDS", "Action": [ "rds:AddRoleToDBCluster", "rds:AddSourceIdentifierToSubscription", "rds:AddTagsToResource", "rds:ApplyPendingMaintenanceAction", "rds:CopyDBClusterParameterGroup", "rds:CopyDBClusterSnapshot", "rds:CopyDBParameterGroup", "rds:CreateDBClusterParameterGroup", "rds:CreateDBClusterSnapshot", "rds:CreateDBParameterGroup", "rds:CreateDBSubnetGroup", "rds:CreateEventSubscription", "rds:DeleteDBCluster", "rds:DeleteDBClusterParameterGroup", "rds:DeleteDBClusterSnapshot", "rds:DeleteDBInstance", "rds:DeleteDBParameterGroup", "rds:DeleteDBSubnetGroup", "rds:DeleteEventSubscription", "rds:DescribeAccountAttributes", "rds:DescribeCertificates", "rds:DescribeDBClusterParameterGroups", "rds:DescribeDBClusterParameters", "rds:DescribeDBClusterSnapshotAttributes", "rds:DescribeDBClusterSnapshots", "rds:DescribeDBClusters", "rds:DescribeDBEngineVersions", "rds:DescribeDBInstances", "rds:DescribeDBLogFiles", "rds:DescribeDBParameterGroups", "rds:DescribeDBParameters", "rds:DescribeDBSecurityGroups", "rds:DescribeDBSubnetGroups", "rds:DescribeEngineDefaultClusterParameters", "rds:DescribeEngineDefaultParameters", "rds:DescribeEventCategories", "rds:DescribeEventSubscriptions", "rds:DescribeEvents", "rds:DescribeOptionGroups", "rds:DescribeOrderableDBInstanceOptions", "rds:DescribePendingMaintenanceActions", "rds:DescribeValidDBInstanceModifications", "rds:DownloadDBLogFilePortion", "rds:FailoverDBCluster", "rds:ListTagsForResource", "rds:ModifyDBCluster", "rds:ModifyDBClusterParameterGroup", "rds:ModifyDBClusterSnapshotAttribute", "rds:ModifyDBInstance", "rds:ModifyDBParameterGroup", "rds:ModifyDBSubnetGroup", "rds:ModifyEventSubscription", "rds:PromoteReadReplicaDBCluster", "rds:RebootDBInstance", "rds:RemoveRoleFromDBCluster", "rds:RemoveSourceIdentifierFromSubscription", "rds:RemoveTagsFromResource", "rds:ResetDBClusterParameterGroup", "rds:ResetDBParameterGroup", "rds:RestoreDBClusterFromSnapshot", "rds:RestoreDBClusterToPointInTime" ], "Effect": "Allow", "Resource": [ "*" ] }, { "Sid": "AllowOtherDepedentPermissions", "Action": [ "cloudwatch:GetMetricStatistics", "cloudwatch:ListMetrics", "ec2:AllocateAddress", "ec2:AssignIpv6Addresses", "ec2:AssignPrivateIpAddresses", "ec2:AssociateAddress", "ec2:AssociateRouteTable", "ec2:AssociateSubnetCidrBlock", "ec2:AssociateVpcCidrBlock", "ec2:AttachInternetGateway", "ec2:AttachNetworkInterface", "ec2:CreateCustomerGateway", "ec2:CreateDefaultSubnet", "ec2:CreateDefaultVpc", "ec2:CreateInternetGateway", "ec2:CreateNatGateway", "ec2:CreateNetworkInterface", "ec2:CreateRoute", "ec2:CreateRouteTable", "ec2:CreateSecurityGroup", "ec2:CreateSubnet", "ec2:CreateVpc", "ec2:CreateVpcEndpoint", "ec2:CreateVpcEndpoint", "ec2:DescribeAccountAttributes", "ec2:DescribeAccountAttributes", "ec2:DescribeAddresses", "ec2:DescribeAvailabilityZones", "ec2:DescribeAvailabilityZones", "ec2:DescribeCustomerGateways", "ec2:DescribeInstances", "ec2:DescribeNatGateways", "ec2:DescribeNetworkInterfaces", "ec2:DescribePrefixLists", "ec2:DescribeRouteTables", "ec2:DescribeSecurityGroupReferences", "ec2:DescribeSecurityGroups", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeSubnets", "ec2:DescribeVpcAttribute", "ec2:DescribeVpcAttribute", "ec2:DescribeVpcEndpoints", "ec2:DescribeVpcs", "ec2:DescribeVpcs", "ec2:ModifyNetworkInterfaceAttribute", "ec2:ModifySubnetAttribute", "ec2:ModifyVpcAttribute", "ec2:ModifyVpcEndpoint", "iam:ListRoles", "kms:ListAliases", "kms:ListKeyPolicies", "kms:ListKeys", "kms:ListRetirableGrants", "logs:DescribeLogStreams", "logs:GetLogEvents", "sns:ListSubscriptions", "sns:ListTopics", "sns:Publish" ], "Effect": "Allow", "Resource": [ "*" ] }, { "Sid": "AllowPassRoleForNeptune", "Action": "iam:PassRole", "Effect": "Allow", "Resource": "*", "Condition": { "StringEquals": { "iam:passedToService": "rds.amazonaws.com" } } }, { "Sid": "AllowCreateSLRForNeptune", "Action": "iam:CreateServiceLinkedRole", "Effect": "Allow", "Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS", "Condition": { "StringLike": { "iam:AWSServiceName": "rds.amazonaws.com" } } }, { "Sid": "AllowManagementPermissionsForNeptuneAnalytics", "Effect": "Allow", "Action": [ "neptune-graph:CreateGraph", "neptune-graph:DeleteGraph", "neptune-graph:GetGraph", "neptune-graph:ListGraphs", "neptune-graph:UpdateGraph", "neptune-graph:ResetGraph", "neptune-graph:CreateGraphSnapshot", "neptune-graph:DeleteGraphSnapshot", "neptune-graph:GetGraphSnapshot", "neptune-graph:ListGraphSnapshots", "neptune-graph:RestoreGraphFromSnapshot", "neptune-graph:CreatePrivateGraphEndpoint", "neptune-graph:GetPrivateGraphEndpoint", "neptune-graph:ListPrivateGraphEndpoints", "neptune-graph:DeletePrivateGraphEndpoint", "neptune-graph:CreateGraphUsingImportTask", "neptune-graph:GetImportTask", "neptune-graph:ListImportTasks", "neptune-graph:CancelImportTask" ], "Resource": [ "arn:aws:neptune-graph:*:*:*" ] }, { "Sid": "AllowPassRoleForNeptuneAnalytics", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*", "Condition": { "StringEquals": { "iam:passedToService": "neptune-graph.amazonaws.com" } } }, { "Sid": "AllowCreateSLRForNeptuneAnalytics", "Effect": "Allow", "Action": "iam:CreateServiceLinkedRole", "Resource": "arn:aws:iam::*:role/aws-service-role/neptune-graph.amazonaws.com/AWSServiceRoleForNeptuneGraph", "Condition": { "StringLike": { "iam:AWSServiceName": "neptune-graph.amazonaws.com" } } } ] } ``` ------ # Concessão `NeptuneGraphReadOnlyAccess` usando política AWS gerenciada A política [NeptuneGraphReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/NeptuneGraphReadOnlyAccess)gerenciada abaixo fornece acesso somente de leitura a todos os recursos do Amazon Neptune Analytics, além de permissões somente de leitura para serviços dependentes. Esta política inclui permissões para fazer o seguinte: + **Para Amazon EC2** — Recupere informações sobre sub-redes VPCs, grupos de segurança e zonas de disponibilidade. + **Para AWS KMS** — Recupere informações sobre chaves e aliases do KMS. + **Para CloudWatch** — Recupere informações sobre CloudWatch métricas. + **Para CloudWatch registros** — recupere informações sobre fluxos de CloudWatch registros e eventos. **nota** Esta política foi lançada em 29/11/2023. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowReadOnlyPermissionsForNeptuneGraph", "Effect": "Allow", "Action": [ "neptune-graph:Get*", "neptune-graph:List*", "neptune-graph:Read*" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForEC2", "Effect": "Allow", "Action": [ "ec2:DescribeVpcEndpoints", "ec2:DescribeVpcAttribute", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeVpcs", "ec2:DescribeAvailabilityZones" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForKMS", "Effect": "Allow", "Action": [ "kms:ListKeys", "kms:ListAliases" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForCloudwatch", "Effect": "Allow", "Action": [ "cloudwatch:GetMetricData", "cloudwatch:ListMetrics", "cloudwatch:GetMetricStatistics" ], "Resource": "*" }, { "Sid": "AllowReadOnlyPermissionsForLogs", "Effect": "Allow", "Action": [ "logs:DescribeLogStreams", "logs:GetLogEvents" ], "Resource": [ "arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*" ] } ] } ``` ------ # Conceder acesso ao grafo do Netuno usando `AWSServiceRoleForNeptuneGraphPolicy` A política [AWSServiceRoleForNeptuneGraphPolicy](https://console.aws.amazon.com/iam/home#policies/AWSServiceRoleForNeptuneGraphPolicy)gerenciada abaixo fornece acesso a gráficos CloudWatch para publicar métricas e registros operacionais e de uso. Consulte [nan-service-linked-roles](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/nan-service-linked-roles.html). **nota** Esta política foi lançada em 29/11/2023. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "GraphMetrics", "Effect": "Allow", "Action": [ "cloudwatch:PutMetricData" ], "Resource": "*", "Condition": { "StringEquals": { "cloudwatch:namespace": [ "AWS/Neptune", "AWS/Usage" ] } } }, { "Sid": "GraphLogGroup", "Effect": "Allow", "Action": [ "logs:CreateLogGroup" ], "Resource": [ "arn:aws:logs:*:*:log-group:/aws/neptune/*" ], "Condition": { "StringEquals": { "aws:ResourceAccount": "${aws:PrincipalAccount}" } } }, { "Sid": "GraphLogEvents", "Effect": "Allow", "Action": [ "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:*:*:log-group:/aws/neptune/*:log-stream:*" ], "Condition": { "StringEquals": { "aws:ResourceAccount": "${aws:PrincipalAccount}" } } } ] } ``` ------ # Personalizar o acesso aos recursos do Amazon Neptune usando chaves de contexto de condição do IAM É possível especificar as condições nas políticas do IAM que controlam às ações de gerenciamento e aos recursos do Neptune. A declaração de política terá efeito apenas quando as condições forem verdadeiras. Por exemplo, é recomendável que uma declaração de política só entre em vigor após uma data específica ou viabilize o acesso apenas quando um valor específico estiver presente na solicitação da API. Para expressar condições, use chaves de condição predefinidas no elemento [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma declaração de política com [operadores de política de condição do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menos do que”. Se você especificar vários elementos de `Condition` em uma declaração ou várias chaves em um único elemento de `Condition`, a AWS os avaliará usando uma operação lógica `AND`. Se você especificar vários valores para uma única chave de condição, AWS avalia a condição usando uma `OR` operação lógica. Todas as condições devem ser atendidas antes que as permissões da instrução sejam concedidas. Você também pode usar variáveis de espaço reservado ao especificar condições. Por exemplo, é possível conceder a um usuário do IAM permissão para acessar um recurso somente se ele estiver marcado com seu nome de usuário do IAM. Para obter mais informações, consulte [Elementos de política do IAM: variáveis e tags](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html) no *Guia do usuário do IAM*. O tipo de dados de uma chave de condição determina quais operadores de condição você pode usar para comparar valores na solicitação com os valores na declaração de política. Se você usar um operador de condição que não seja compatível com esse tipo de dados, a correspondência sempre falhará, e a declaração da política nunca será aplicada. **Chaves de condição do IAM para declarações de política administrativa do Neptune** + [Chaves de condição globais](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) — Você pode usar a maioria das chaves de condição AWS globais nas declarações de política administrativa do Neptune. + [Chaves de condição específicas do serviço](iam-admin-condition-keys.md) — são chaves definidas para serviços específicos AWS . Aquelas compatíveis com o Neptune para declarações de política administrativa estão listadas em [Chaves de condição do IAM para administrar o Amazon Neptune](iam-admin-condition-keys.md). **Chaves de condição do IAM para declarações de política de acesso a dados do Neptune** + [Chaves de condição globais](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html): o subconjunto dessas chaves aceitas pelo Neptune nas declarações de política de acesso a dados está listado em [AWS chaves de contexto de condição global suportadas pelo Neptune em declarações de política de acesso a dados](iam-data-condition-keys.md#iam-data-global-condition-keys). + As chaves de condição específicas do serviço que o Neptune define para declarações de política de acesso a dados estão listadas em [Chaves de condição](iam-data-condition-keys.md). # Criar declarações personalizadas de políticas do IAM para administrar o Amazon Neptune As declarações de política administrativa permitem controlar o que um usuário do IAM pode fazer para gerenciar um banco de dados Neptune. Uma declaração de política administrativa do Neptune concede acesso a uma ou [ações administrativas](neptune-iam-admin-actions.md) e [recursos administrativos](iam-admin-resources.md) aceitos pelo Neptune. Você também pode usar [Chaves de condição](iam-admin-condition-keys.md) para tornar as permissões administrativas mais específicas. **nota** Como o Neptune compartilha a funcionalidade com o Amazon RDS, as ações administrativas, os recursos e as chaves de condição específicas do serviço em declarações de política administrativa usam um prefixo `rds:` por design. **Topics** + [Ações do IAM para administrar o Amazon Neptune](neptune-iam-admin-actions.md) + [Tipos de recursos do IAM para administrar o Amazon Neptune](iam-admin-resources.md) + [Chaves de condição do IAM para administrar o Amazon Neptune](iam-admin-condition-keys.md) + [Criar declarações de política administrativa do IAM para o Amazon Neptune](iam-admin-policy-examples.md) # Ações do IAM para administrar o Amazon Neptune Você pode usar as ações administrativas listadas abaixo no `Action` elemento de uma declaração de política do IAM para controlar o acesso ao gerenciamento do [ APIsNeptune](api.md). Quando usa uma ação em uma política, você geralmente permite ou nega acesso à operação da API ou ao comando da CLI com o mesmo nome. No entanto, em alguns casos, uma única ação controla o acesso a mais de uma operação. Como alternativa, algumas operações exigem várias ações diferentes. O campo `Resource type` na lista abaixo indica se cada ação é compatível com permissões em nível de recurso. Se não houver valor para esse campo, você deverá especificar todos os recursos ("\$1") no elemento `Resource` de sua declaração de política. Se a coluna incluir um tipo de recurso, você poderá especificar um ARN de recurso desse tipo em uma declaração com essa ação. Os tipos de recurso administrativo do Neptune estão listados [nesta página](iam-admin-resources.md). Os recursos obrigatórios são indicados na lista abaixo com um asterisco (\$1). Se você especificar um ARN de permissão no nível do recurso em uma instrução que esteja usando essa ação, ele deverá ser desse tipo. Algumas ações oferecem suporte a vários tipos de recursos. Se um tipo de recurso for opcional (em outras palavras, não estiver marcado com um asterisco), não será necessário incluí-lo. Para obter mais informações sobre os campos listados aqui, consulte [action table](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_actions-resources-contextkeys.html#actions_table) no [Guia do usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/). ## vermelhos: AddRoleTo DBCluster `AddRoleToDBCluster` associa um perfil do IAM a um cluster de banco de dados do Neptune. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). ## vermelhos: AddSourceIdentifierToSubscription `AddSourceIdentifierToSubscription` adiciona um identificador de origem a uma assinatura de notificações de eventos existente do Neptune. *Nível de acesso:* `Write`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## vermelhos: AddTagsToResource `AddTagsToResource` associa um perfil do IAM a um cluster de banco de dados do Neptune. *Nível de acesso:* `Write`. *Tipos de recurso:* + [db](iam-admin-resources.md#neptune-db-resource) + [es](iam-admin-resources.md#neptune-es-resource) + [pg](iam-admin-resources.md#neptune-pg-resource) + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## vermelhos: ApplyPendingMaintenanceAction `ApplyPendingMaintenanceAction` aplica uma ação de manutenção pendente a um recurso. *Nível de acesso:* `Write`. *Tipo de recurso:* [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). ## RDS: copiar DBCluster ParameterGroup `CopyDBClusterParameterGroup` copia o grupo de parâmetros de cluster de banco de dados especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS:Copiar instantâneo DBCluster `CopyDBClusterSnapshot` copia um snapshot de um cluster de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). ## RDS: Grupo DBParameter de cópias `CopyDBParameterGroup` copia o grupo de parâmetros de banco de dados especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: criar DBCluster `CreateDBCluster` cria um cluster de banco de dados do Neptune. *Nível de acesso:* `Tagging`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) + [netuno-rds\$1 DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine) ## RDS: criar DBCluster ParameterGroup `CreateDBClusterParameterGroup` cria um grupo de parâmetros de cluster de banco de dados. *Nível de acesso:* `Tagging`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: Criar instantâneo DBCluster `CreateDBClusterSnapshot` cria um snapshot de um cluster de banco de dados. *Nível de acesso:* `Tagging`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: criar DBInstance `CreateDBInstance` cria uma instância de banco de dados. *Nível de acesso:* `Tagging`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). + [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: Criar grupo DBParameter `CreateDBParameterGroup` cria um novo grupo de parâmetros de banco de dados. *Nível de acesso:* `Tagging`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: Criar grupo DBSubnet `CreateDBSubnetGroup` cria um grupo de sub-redes de banco de dados. *Nível de acesso:* `Tagging`. *Tipo de recurso:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## vermelhos: CreateEventSubscription `CreateEventSubscription` cria uma assinatura de notificação de eventos do Neptune. *Nível de acesso:* `Tagging`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: excluir DBCluster `DeleteDBCluster` exclui um cluster de banco de dados do Neptune existente. *Nível de acesso:* `Write`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). ## RDS: excluir DBCluster ParameterGroup `DeleteDBClusterParameterGroup` exclui um grupo de parâmetros de cluster de banco de dados especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: excluir instantâneo DBCluster `DeleteDBClusterSnapshot` exclui um snapshot do cluster de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). ## RDS: excluir DBInstance `DeleteDBInstance` exclui uma instância de banco de dados especificada. *Nível de acesso:* `Write`. *Tipo de recurso:* [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). ## RDS: Excluir grupo DBParameter `DeleteDBParameterGroup`exclui um DBParameter grupo especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: Excluir grupo DBSubnet `DeleteDBSubnetGroup` exclui um grupo de sub-redes de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). ## vermelhos: DeleteEventSubscription `DeleteEventSubscription` exclui uma assinatura de notificações de eventos. *Nível de acesso:* `Write`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## RDS: descrever DBCluster ParameterGroups `DescribeDBClusterParameterGroups`retorna uma lista de DBCluster ParameterGroup descrições. *Nível de acesso:* `List`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: Descreva DBCluster os parâmetros `DescribeDBClusterParameters` gera a lista de parâmetros detalhada de um grupo de parâmetros de cluster de banco de dados. *Nível de acesso:* `List`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: descrever DBCluster SnapshotAttributes `DescribeDBClusterSnapshotAttributes` gera uma lista de nomes e valores de atributos de snapshot do cluster de banco de dados de um snapshot manual do cluster de banco de dados. *Nível de acesso:* `List`. *Tipo de recurso:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). ## RDS:Descreva DBCluster os instantâneos `DescribeDBClusterSnapshots` gera informações sobre snapshots do cluster banco de dados. *Nível de acesso:* `Read`. ## RDS: descrever DBClusters `DescribeDBClusters` gera informações sobre um cluster de banco de dados provisionados do Neptune. *Nível de acesso:* `List`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). ## RDS:Descreva DBEngine as versões `DescribeDBEngineVersions` gera uma lista dos mecanismos de banco de dados disponíveis. *Nível de acesso:* `List`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: descrever DBInstances `DescribeDBInstances` gera informações sobre instâncias de banco de dados. *Nível de acesso:* `List`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## RDS: Descrever grupos DBParameter `DescribeDBParameterGroups`retorna uma lista de descrições de DBParameter grupos. *Nível de acesso:* `List`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: descrever DBParameters `DescribeDBParameters` exibe a lista de parâmetros detalhada de um grupo de parâmetros de banco de dados específico. *Nível de acesso:* `List`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: Descrever grupos DBSubnet `DescribeDBSubnetGroups`retorna uma lista de descrições de DBSubnet grupos. *Nível de acesso:* `List`. *Tipo de recurso:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). ## vermelhos: DescribeEventCategories `DescribeEventCategories` exibe uma lista de categorias de todos os tipos de origem de eventos ou, se especificado, de um determinado tipo de origem. *Nível de acesso:* `List`. ## vermelhos: DescribeEventSubscriptions `DescribeEventSubscriptions` lista todas as descrições de assinaturas de uma conta de cliente. *Nível de acesso:* `List`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## vermelhos: DescribeEvents `DescribeEvents` exibe os eventos relacionados a instâncias de bancos de dados, grupos de segurança de banco de dados e grupos de parâmetros de banco de dados dos últimos 14 dias. *Nível de acesso:* `List`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## rds: Opções DescribeOrderable DBInstance `DescribeOrderableDBInstanceOptions` gera uma lista de opções de instância de banco de dados que podem ser solicitadas para o mecanismo especificado. *Nível de acesso:* `List`. ## vermelhos: DescribePendingMaintenanceActions `DescribePendingMaintenanceActions` gera uma lista de recursos (por exemplo, instâncias de banco de dados) que têm pelo menos uma ação de manutenção pendente. *Nível de acesso:* `List`. *Tipo de recurso:* [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). ## rds: DescribeValid DBInstance Modificações `DescribeValidDBInstanceModifications` lista as modificações disponíveis que podem ser realizadas na instância de banco de dados. *Nível de acesso:* `List`. *Tipo de recurso:* [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). ## RDS: Failover DBCluster `FailoverDBCluster` força um failover para um cluster de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). ## vermelhos: ListTagsForResource `ListTagsForResource` lista todas as tags em um recurso do Neptune. *Nível de acesso:* `Read`. *Tipos de recurso:* + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) + [db](iam-admin-resources.md#neptune-db-resource) + [es](iam-admin-resources.md#neptune-es-resource) + [pg](iam-admin-resources.md#neptune-pg-resource) + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) ## RDS: modificar DBCluster `ModifyDBCluster` Modifica uma configuração de um cluster de banco de dados do Neptune. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: modificar DBCluster ParameterGroup `ModifyDBClusterParameterGroup` modifica os parâmetros de um grupo de parâmetros de cluster de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: modificar DBCluster SnapshotAttribute `ModifyDBClusterSnapshotAttribute` adiciona um atributo e os valores ou remove um atributo e os valores de um snapshot do cluster de banco de dados manual. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). ## RDS: modificar DBInstance `ModifyDBInstance` modifica as configurações de uma instância de banco de dados. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). + [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: Modificar grupo DBParameter `ModifyDBParameterGroup` modifica os parâmetros de um grupo de parâmetros de banco de dados. *Nível de acesso:* `Write`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: Modificar grupo DBSubnet `ModifyDBSubnetGroup` modifica um grupo de sub-redes de banco de dados existente. *Nível de acesso:* `Write`. *Tipo de recurso:* [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). ## vermelhos: ModifyEventSubscription `ModifyEventSubscription` modifica uma assinatura de notificações de eventos existente do Neptune. *Nível de acesso:* `Write`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## RDS: reinicialização DBInstance `RebootDBInstance` reinicia o serviço de mecanismo de banco de dados para a instância. *Nível de acesso:* `Write`. *Tipo de recurso:* [db](iam-admin-resources.md#neptune-db-resource) (obrigatório). ## vermelhos: RemoveRoleFrom DBCluster `RemoveRoleFromDBCluster`dissocia uma função de AWS Identity and Access Management (IAM) de um cluster de banco de dados Amazon Neptune. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). ## vermelhos: RemoveSourceIdentifierFromSubscription `RemoveSourceIdentifierFromSubscription` remove um identificador de origem de uma assinatura de notificações de eventos existente do Neptune. *Nível de acesso:* `Write`. *Tipo de recurso:* [es](iam-admin-resources.md#neptune-es-resource) (obrigatório). ## vermelhos: RemoveTagsFromResource `RemoveTagsFromResource` remove as tags de metadados de um recurso do Neptune. *Nível de acesso:* `Tagging`. *Tipos de recurso:* + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) + [db](iam-admin-resources.md#neptune-db-resource) + [es](iam-admin-resources.md#neptune-es-resource) + [pg](iam-admin-resources.md#neptune-pg-resource) + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: redefinir DBCluster ParameterGroup `ResetDBClusterParameterGroup` modifica os parâmetros de um grupo de parâmetros de cluster de banco de dados para o valor padrão. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster-pg](iam-admin-resources.md#neptune-cluster-pg-resource) (obrigatório). ## RDS: Redefinir grupo DBParameter `ResetDBParameterGroup`modifica os parâmetros de um grupo de parâmetros do banco de dados para o valor engine/system padrão. *Nível de acesso:* `Write`. *Tipo de recurso:* [pg](iam-admin-resources.md#neptune-pg-resource) (obrigatório). ## RDS: restaurar DBCluster FromSnapshot `RestoreDBClusterFromSnapshot` cria um cluster de banco de dados a partir de um snapshot de cluster de banco de dados. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [cluster-snapshot](iam-admin-resources.md#neptune-cluster-snapshot-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: restaurar DBCluster ToPointInTime `RestoreDBClusterToPointInTime` restaura um cluster de banco de dados para um momento arbitrário. *Nível de acesso:* `Write`. *Ações dependentes:* `iam:PassRole`. *Tipos de recurso:* + [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). + [subgrp](iam-admin-resources.md#neptune-subgrp-resource) (obrigatório). *Chaves de condição:* + [leis:RequestTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_RequestTag) + [leis: TagKeys](iam-admin-condition-keys.md#admin-aws_TagKeys) ## RDS: Iniciar DBCluster `StartDBCluster` inicia o cluster de banco de dados especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). ## RDS: parar DBCluster `StopDBCluster` interrompe o cluster de banco de dados especificado. *Nível de acesso:* `Write`. *Tipo de recurso:* [cluster](iam-admin-resources.md#neptune-cluster-resource) (obrigatório). # Tipos de recursos do IAM para administrar o Amazon Neptune O Neptune é compatível com os tipos de recurso na tabela a seguir para uso no elemento `Resource` das declarações de política de administração do IAM. Para obter mais informações sobre o elemento `Resource`, consulte [Elementos de políticas JSON do IAM: recurso](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_resource.html). A [list of Neptune administration actions](neptune-iam-admin-actions.md) identifica os tipos de recurso que podem ser especificados com cada ação. Um tipo de recurso também determina quais chaves de condição você pode incluir em uma política, como especificado na última coluna da tabela abaixo. A coluna `ARN` na tabela abaixo especifica o nome do recurso da Amazon (ARN) que você deve usar para fazer referência a recursos desse tipo. As partes precedidas por um ` $ ` devem ser substituídas pelos valores reais do cenário. Por exemplo, se você vir `$user-name` em um ARN, deverá substituir essa string pelo nome do usuário real do IAM ou por uma variável de política que contenha um nome do usuário do IAM. Para obter mais informações sobre ARNs ARNs, consulte [IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) [Trabalhando com administrativos ARNs no Amazon Neptune](tagging-arns.md) e. A coluna ` Condition Keys ` especifica chaves de contexto de condição que você pode incluir em uma declaração de política do IAM apenas quando esse recurso e uma ação de apoio compatível estão incluídos na declaração. **** | Tipos de recursos | ARN | Chaves de condição | | --- | --- | --- | | `cluster` (um cluster de banco de dados) | arn:partition:rds:region:account-id:cluster:instance-name | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: cluster-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-tag) | | `cluster-pg` (um grupo de parâmetros do cluster de banco de dados) | arn:partition:rds:region:account-id:cluster-pg:neptune-DBClusterParameterGroupName | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) | | `cluster-snapshot` (um snapshot de cluster de banco de dados) | arn:partition:rds:region:account-id:cluster-snapshot:neptune-DBClusterSnapshotName | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [Vermelhos:/cluster-snapshot-tag*tag-key*](iam-admin-condition-keys.md#admin-rds_cluster-snapshot-tag) | | `db` (uma instância de banco de dados) | arn:partition:rds:region:account-id:db:neptune-DbInstanceName | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [vermelhos: DatabaseClass](iam-admin-condition-keys.md#admin-rds_DatabaseClass) [vermelhos: DatabaseEngine](iam-admin-condition-keys.md#admin-rds_DatabaseEngine) [rds: db-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_db-tag) | | `es` (uma assinatura de eventos) | arn:partition:rds:region:account-id:es:neptune-CustSubscriptionId | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: es-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_es-tag) | | `pg` (um grupo de parâmetros de banco de dados) | arn:partition:rds:region:account-id:pg:neptune-ParameterGroupName | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: pg-tag/ *tag-key*](iam-admin-condition-keys.md#admin-rds_pg-tag) | | `subgrp` (um grupo de sub-redes de banco de dados) | arn:partition:rds:region:account-id:subgrp:neptune-DBSubnetGroupName\$1 | [leis:ResourceTag/*tag-key*](iam-admin-condition-keys.md#admin-aws_ResourceTag) [rds: subgrp-tag/*tag-key*](iam-admin-condition-keys.md#admin-rds_subgrp-tag) | # Chaves de condição do IAM para administrar o Amazon Neptune [Usando chaves de condição](security-iam-access-manage.md#iam-using-condition-keys), é possível especificar as condições em uma declaração de política do IAM para que a declaração só entre em vigor quando as condições forem verdadeiras. As chaves de condição que você pode usar nas declarações de política administrativa do Neptune se enquadram nas seguintes categorias: + [Chaves de condição globais](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) — Elas são definidas por AWS para uso geral com AWS serviços. A maioria pode ser usada em declarações de política administrativa do Neptune. + [Chaves de condição de propriedades de recursos administrativos](#iam-rds-property-condition-keys): essas chaves, listadas [abaixo](#iam-rds-property-condition-keys), são baseadas nas propriedades de recursos administrativos. + [Chaves de condição de acesso baseadas em tags](#iam-rds-tag-based-condition-keys): essas chaves, listadas [abaixo](#iam-rds-tag-based-condition-keys), são baseadas em [tags da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) associadas aos recursos administrativos. ## Chaves de condição de propriedades de recursos administrativos do Neptune | Chaves de condição | Descrição | Tipo | | --- | --- | --- | | rds:DatabaseClass | Filtra o acesso pelo tipo de classe da instância de banco de dados. | String | | rds:DatabaseEngine | Filtra o acesso pelo mecanismo do banco de dados Para valores possíveis, consulte o parâmetro do mecanismo em Create DBInstance API | String | | rds:DatabaseName | Filtra o acesso pelo nome definido pelo usuário do banco de dados na instância de banco de dados | String | | rds:EndpointType | Filtra o acesso pelo tipo de endpoint Um dos seguintes: READER, WRITER, CUSTOM | String | | rds:Vpc | Filtra o acesso pelo valor que especifica se a instância de banco de dados é executada em uma Amazon Virtual Private Cloud (Amazon VPC). Para indicar que a instância de banco de dados é executada em uma Amazon VPC, especifique true. | Booleano | ## Chaves de condição administrativas baseadas em tag O Amazon Neptune é compatível com a especificação de condições em uma política do IAM usando tags personalizadas, para controlar o acesso ao Neptune por meio da [Referência da API de gerenciamento](api.md). Por exemplo, se você adicionar uma tag denominada `environment` às instâncias de banco de dados, com valores, como `beta`, `staging`, `production` e , depois, você poderá criar uma política que restrinja o acesso às instâncias com base no valor dessa tag. **Importante** Se você gerenciar o acesso aos recursos do Neptune usando marcação, proteja o acesso às tags. Você pode restringir o acesso às tags criando políticas para as ações `AddTagsToResource` e `RemoveTagsFromResource`. Por exemplo, você pode usar a política a seguir para negar aos usuários a capacidade de adicionar ou remover tags para todos os recursos. Depois, você pode criar políticas para permitir que usuários específicos adicionem ou removam tags. **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid": "DenyTagUpdates", "Effect": "Deny", "Action": [ "rds:AddTagsToResource", "rds:RemoveTagsFromResource" ], "Resource":"*" } ] } ``` As chaves de condição baseadas em tags a seguir só funcionam com recursos administrativos em declarações de política administrativa. **Chaves de condição administrativas baseadas em tag** | Chaves de condição | Descrição | Tipo | | --- | --- | --- | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requesttag) | Filtra o acesso com base na presença de pares de chave-valor da tag na solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-resourcetag) | Filtra o acesso com base nos pares de chave-valor da tag anexados ao recurso. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keyss) | Filtra o acesso com base na presença de chaves da tag na solicitação. | String | | rds:cluster-pg-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um grupo de parâmetros do cluster de banco de dados. | String | | rds:cluster-snapshot-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um snapshot do cluster de banco de dados. | String | | rds:cluster-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um cluster de banco de dados. | String | | rds:db-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a uma instância de banco de dados. | String | | rds:es-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a uma assinatura de evento. | String | | rds:pg-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um grupo de parâmetros de banco de dados. | String | | rds:req-tag/\$1\$1TagKey\$1 | Filtra o acesso pelo conjunto de chaves da tag e valores que podem ser usados para marcar um recurso. | String | | rds:secgrp-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um grupo de segurança de banco de dados. | String | | rds:snapshot-tag/\$1\$1TagKey\$1 | Filtra o acesso pela tag anexada a um snapshot de banco de dados. | String | | rds:subgrp-tag/\$1\$1TagKey\$1 | Filtra o acesso pela etiqueta anexada a um grupo de sub-redes de banco de dados | String | # Criar declarações de política administrativa do IAM para o Amazon Neptune ## Exemplos de política administrativa geral Os exemplos a seguir mostram como criar políticas administrativas do Neptune que concedem permissões para realizar várias ações de gerenciamento em um cluster de banco de dados. ### Política que impede que um usuário do IAM exclua uma instância de banco de dados especificada Veja a seguir um exemplo de política que impede que um usuário do IAM exclua uma instância especificada do banco de dados Neptune: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "DenyDeleteOneInstance", "Effect": "Deny", "Action": "rds:DeleteDBInstance", "Resource": "arn:aws:rds:us-west-2:123456789012:db:my-instance-name" } ] } ``` ------ ### Política que concede permissão para criar instâncias de banco de dados Veja a seguir um exemplo de política que permite a um usuário do IAM criar instâncias de bancos de dados em um cluster de banco de dados especificado do Neptune: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowCreateInstance", "Effect": "Allow", "Action": "rds:CreateDBInstance", "Resource": "arn:aws:rds:us-west-2:123456789012:cluster:my-cluster" } ] } ``` ------ ### Política que concede permissão para criar instâncias de banco de dados que usem um grupo de parâmetros de banco de dados específico Veja a seguir um exemplo de política que permite a um usuário do IAM criar instâncias de banco de dados em um cluster de banco de dados especificado (aqui, `us-west-2`) em um cluster de banco de dados especificado do Neptune usando somente um grupo de parâmetros de banco de dados especificado. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowCreateInstanceWithPG", "Effect": "Allow", "Action": "rds:CreateDBInstance", "Resource": [ "arn:aws:rds:us-west-2:123456789012:cluster:my-cluster", "arn:aws:rds:us-west-2:123456789012:pg:my-instance-pg" ] } ] } ``` ------ ### Política que concede permissão para descrever qualquer recurso Veja a seguir um exemplo de política que permite a um usuário do IAM descrever qualquer recurso do Neptune. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowDescribe", "Effect": "Allow", "Action": "rds:Describe*", "Resource": "*" } ] } ``` ------ ## Exemplos de política administrativa baseada em tag Os exemplos a seguir mostram como criar políticas administrativas do Neptune que concedam permissões para realizar várias ações de gerenciamento em um cluster de banco de dados. ### Exemplo 1: conceder permissão para ações em um recurso usando uma tag personalizada que pode ter vários valores A política abaixo permite o uso da API `ModifyDBInstance`, `CreateDBInstance` ou `DeleteDBInstance` em qualquer instância de banco de dados que tenha a tag `env` definida como `dev` ou `test`: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowDevTestAccess", "Effect": "Allow", "Action": [ "rds:ModifyDBInstance", "rds:CreateDBInstance", "rds:DeleteDBInstance" ], "Resource": "*", "Condition": { "StringEquals": { "rds:db-tag/env": [ "dev", "test" ], "rds:DatabaseEngine": "neptune" } } } ] } ``` ------ ### Exemplo 2: Limitar o conjunto de chaves de tag e valores que podem ser usados para identificar um recurso Esta política usa uma chave `Condition` para permitir que uma tag com a chave `env` e o valor `test`, `qa` ou `dev` seja adicionada a um recurso: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowTagAccessForDevResources", "Effect": "Allow", "Action": [ "rds:AddTagsToResource", "rds:RemoveTagsFromResource" ], "Resource": "*", "Condition": { "StringEquals": { "rds:req-tag/env": [ "test", "qa", "dev" ], "rds:DatabaseEngine": "neptune" } } } ] } ``` ------ ### Exemplo 3: permitir acesso total aos recursos do Neptune com base em `aws:ResourceTag` A seguinte política é semelhante ao primeiro exemplo acima, mas usa `aws:ResourceTag`: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowFullAccessToDev", "Effect": "Allow", "Action": [ "rds:*" ], "Resource": "*", "Condition": { "StringEquals": { "aws:ResourceTag/env": "dev", "rds:DatabaseEngine": "neptune" } } } ] } ``` ------ # Criar declarações personalizadas de políticas do IAM para acessar dados no Amazon Neptune As declarações de política de acesso a dados do Neptune usam [ações de acesso a dados](iam-dp-actions.md), [recursos](iam-data-resources.md) e [chaves de condição](iam-data-condition-keys.md#iam-neptune-condition-keys), todos precedidos por um prefixo `neptune-db:`. **Topics** + [Usar ações de consulta nas declarações de política de acesso a dados do Neptune](#iam-data-query-actions) + [Ações do IAM para acesso a dados no Amazon Neptune](iam-dp-actions.md) + [Tipos de recursos do IAM para acessar dados no Amazon Neptune](iam-data-resources.md) + [Chaves de condição do IAM para acessar dados no Amazon Neptune](iam-data-condition-keys.md) + [Criar políticas de acesso a dados do IAM no Amazon Neptune](iam-data-access-examples.md) ## Usar ações de consulta nas declarações de política de acesso a dados do Neptune Há três ações de consulta do Neptune que podem ser usadas em declarações de política de acesso a dados, a saber, `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Uma consulta específica pode precisar de permissões para realizar mais de uma dessas ações e nem sempre é óbvio qual combinação dessas ações deve ser permitida para executar uma consulta. Antes de executar uma consulta, o Neptune determina as permissões necessárias para executar cada etapa da consulta e as combina no conjunto completo de permissões que a consulta exige. Observe que esse conjunto completo de permissões inclui todas as ações que a consulta *pode* realizar, o que não é necessariamente o conjunto de ações que a consulta realmente executará quando for realizada em seus dados. Isso significa que, para permitir que uma consulta específica seja executada, é necessário conceder permissões para cada ação que a consulta possa realizar, independentemente de ela realmente as executar ou não. Veja alguns exemplos de consulta do Gremlin em que isso é explicado com mais detalhes: + ``` g.V().count() ``` `g.V()` e `count()` exigem apenas acesso de leitura, portanto, a consulta como um todo exige apenas acesso `ReadDataViaQuery`. + ``` g.addV() ``` `addV()` precisa conferir se um vértice com um ID específico existe ou não antes de inserir um novo. Isso significa que ele exige acesso `ReadDataViaQuery` e `WriteDataViaQuery`. + ``` g.V('1').as('a').out('created').addE('createdBy').to('a') ``` `g.V('1').as('a')` e `out('created')` exigem apenas acesso de leitura, mas `addE().from('a')` requer acesso de leitura e gravação porque `addE()` precisa ler os vértices `from` e `to` e conferir se uma borda com o mesmo ID já existe antes de adicionar uma nova. A consulta como um todo, portanto, precisa de acesso `ReadDataViaQuery` e `WriteDataViaQuery`. + ``` g.V().drop() ``` `g.V()` exige apenas acesso de leitura. `drop()` requer acesso de leitura e exclusão porque precisa ler um vértice ou uma borda antes de excluí-lo, portanto, a consulta como um todo exige acesso `ReadDataViaQuery` e `DeleteDataViaQuery`. + ``` g.V('1').property(single, 'key1', 'value1') ``` `g.V('1')` requer apenas acesso de leitura, mas `property(single, 'key1', 'value1')` exige acesso de leitura, gravação e exclusão. Aqui, a etapa `property()` vai inserir a chave e o valor se eles ainda não existirem no vértice, mas se já existirem, ela vai excluir o valor da propriedade existente e inserir um novo valor em seu lugar. Portanto, a consulta como um todo exige acesso `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Qualquer consulta que contenha uma etapa `property()` precisará de permissões `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Veja a seguir alguns exemplos do openCypher: + ``` MATCH (n) RETURN n ``` Essa consulta lê todos os nós no banco de dados e os gera, o que exige apenas acesso `ReadDataViaQuery`. + ``` MATCH (n:Person) SET n.dept = 'AWS' ``` Essa consulta exige acesso `ReadDataViaQuery`, `WriteDataViaQuery` e `DeleteDataViaQuery`. Ela lê todos os nós com o rótulo “Pessoa” e adiciona uma nova propriedade com a chave `dept` e o valor `AWS` a eles ou, se a propriedade `dept` já existir, vai excluir o valor antigo e inserir `AWS` em seu lugar. Além disso, se o valor a ser definido for `null`, `SET` excluirá completamente a propriedade. Como, em alguns casos, a cláusula `SET` talvez precise excluir um valor existente, ela **sempre** precisará de permissões `DeleteDataViaQuery`, além de permissões `ReadDataViaQuery` e `WriteDataViaQuery`. + ``` MATCH (n:Person) DETACH DELETE n ``` Essa consulta precisa das permissões `ReadDataViaQuery` e `DeleteDataViaQuery`. Ela encontra todos os nós com o rótulo `Person` e os exclui junto com as bordas conectadas a esses nós e todas as propriedades e os rótulos associados. + ``` MERGE (n:Person {name: 'John'})-[:knows]->(:Person {name: 'Peter'}) RETURN n ``` Essa consulta precisa das permissões `ReadDataViaQuery` e `WriteDataViaQuery`. A cláusula `MERGE` corresponde a um padrão especificado ou o cria. Como uma gravação poderá ocorrer se não houver correspondência ao padrão, são necessárias permissões de gravação e leitura. # Ações do IAM para acesso a dados no Amazon Neptune Observe que as ações de acesso a dados do Neptune têm o prefixo `neptune-db:`, enquanto as ações administrativas no Neptune têm o prefixo `rds:`. O nome do recurso da Amazon (ARN) de um recursos de dados no IAM não é o mesmo ARN atribuído ao cluster na criação. Você deve criar o ARN, conforme mostrado em [Specifying data resources](iam-data-resources.md). Esse recurso de dados ARNs pode usar curingas para incluir vários recursos. As declarações de política de acesso a dados também podem incluir a chave de QueryLanguage condição [neptune-db:](iam-data-condition-keys.md#iam-neptune-condition-keys) para restringir o acesso por linguagem de consulta. A partir da [Versão: 1.2.0.0 (21/07/2022)](engine-releases-1.2.0.0.md), o Neptune é compatível com a restrição de permissões a uma ou mais [ações específicas do Neptune](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonneptune.html). Isso oferece um controle de acesso mais detalhado do que era possível anteriormente. **Importante** As alterações em uma política do IAM demoram até dez minutos para ser aplicadas aos recursos do Neptune especificados. As políticas do IAM aplicadas a um cluster de banco de dados do Neptune são aplicadas a todas as instâncias desse cluster. ## *Ações de acesso a dados baseadas em consulta* **nota** Nem sempre é óbvio quais permissões são necessárias para executar uma consulta específica, porque as consultas podem realizar mais de uma ação, dependendo dos dados processados. Consulte [Usar ações de consulta](iam-data-access-policies.md#iam-data-query-actions) para obter mais informações. ## `neptune-db:ReadDataViaQuery` `ReadDataViaQuery` possibilita ao usuário ler dados do banco de dados Neptune enviando consultas. *Grupos de ações:* somente leitura, leitura e gravação. *Chaves de contexto de ação:* `neptune-db:QueryLanguage`. *Recursos necessários:* banco de dados. ## `neptune-db:WriteDataViaQuery` `WriteDataViaQuery` possibilita ao usuário gravar dados no banco de dados Neptune enviando consultas. *Grupos de ações:* leitura e gravação. *Chaves de contexto de ação:* `neptune-db:QueryLanguage`. *Recursos necessários:* banco de dados. ## `neptune-db:DeleteDataViaQuery` `DeleteDataViaQuery` possibilita ao usuário excluir dados do banco de dados Neptune enviando consultas. *Grupos de ações:* leitura e gravação. *Chaves de contexto de ação:* `neptune-db:QueryLanguage`. *Recursos necessários:* banco de dados. ## `neptune-db:GetQueryStatus` `GetQueryStatus` possibilita ao usuário conferir o status de todas as consultas ativas. *Grupos de ações:* somente leitura, leitura e gravação. *Chaves de contexto de ação:* `neptune-db:QueryLanguage`. *Recursos necessários:* banco de dados. ## `neptune-db:GetStreamRecords` `GetStreamRecords` possibilita ao usuário buscar registros de fluxo do Neptune. *Grupos de ações:* leitura e gravação. *Chaves de contexto de ação:* `neptune-db:QueryLanguage`. *Recursos necessários:* banco de dados. ## `neptune-db:CancelQuery` `CancelQuery` possibilita ao usuário cancelar uma consulta. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## *Ações gerais de acesso a dados* ## `neptune-db:GetEngineStatus` `GetEngineStatus` possibilita ao usuário conferir o status do mecanismo do Neptune. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetStatisticsStatus` `GetStatisticsStatus` possibilita ao usuário conferir o status das estatísticas que estão sendo coletadas para o banco de dados. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetGraphSummary` `GetGraphSummary` A API de resumo do grafo possibilita a você recuperar um resumo somente leitura do grafo. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:ManageStatistics` `ManageStatistics` possibilita ao usuário gerenciar a coleta de estatísticas para o banco de dados. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:DeleteStatistics` `DeleteStatistics` permite ao usuário excluir todas as estatísticas no banco de dados. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:ResetDatabase` `ResetDatabase` possibilita ao usuário obter o token necessário para uma redefinição e redefinir o banco de dados Neptune. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## *Ações de acesso a dados do carregador em massa* ## `neptune-db:StartLoaderJob` `StartLoaderJob` possibilita ao usuário iniciar um trabalho de carregador em massa. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetLoaderJobStatus` `GetLoaderJobStatus` possibilita ao usuário conferir o status de um trabalho de carregador em massa. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:ListLoaderJobs` `ListLoaderJobs` possibilita ao usuário listar todos os trabalhos de carregador em massa. *Grupos de ações:* somente lista, somente leitura e gravação e leitura. *Recursos necessários:* banco de dados. ## `neptune-db:CancelLoaderJob` `CancelLoaderJob` possibilita ao usuário cancelar um trabalho de carregador. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## *Ações de acesso a dados de machine learning* ## `neptune-db:StartMLDataProcessingJob` `StartMLDataProcessingJob` possibilita a um usuário iniciar um trabalho de processamento de dados do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:StartMLModelTrainingJob` `StartMLModelTrainingJob` possibilita a um usuário iniciar um trabalho de treinamento de modelo de ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:StartMLModelTransformJob` `StartMLModelTransformJob` possibilita a um usuário iniciar um trabalho de transformação de modelo de ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:CreateMLEndpoint` `CreateMLEndpoint` possibilita a um usuário criar um endpoint do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetMLDataProcessingJobStatus` `GetMLDataProcessingJobStatus` possibilita a um usuário conferir o status de um trabalho de processamento de dados do Neptune ML. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetMLModelTrainingJobStatus` `GetMLModelTrainingJobStatus` possibilita a um usuário conferir o status de um trabalho de treinamento de modelos do Neptune ML. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetMLModelTransformJobStatus` `GetMLModelTransformJobStatus` possibilita a um usuário conferir o status de um trabalho de transformação de modelos do Neptune ML. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:GetMLEndpointStatus` `GetMLEndpointStatus` possibilita a um usuário conferir o status de um endpoint do Neptune ML. *Grupos de ações:* somente leitura, leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:ListMLDataProcessingJobs` `ListMLDataProcessingJobs` possibilita a um usuário listar trabalhos de processamento de dados do Neptune ML. *Grupos de ações:* somente lista, somente leitura e gravação e leitura. *Recursos necessários:* banco de dados. ## `neptune-db:ListMLModelTrainingJobs` `ListMLModelTrainingJobs` possibilita a um usuário listar todos os trabalhos de treinamento de modelos do Neptune ML. *Grupos de ações:* somente lista, somente leitura e gravação e leitura. *Recursos necessários:* banco de dados. ## `neptune-db:ListMLModelTransformJobs` `ListMLModelTransformJobs` possibilita a um usuário listar todos os trabalhos de transformação de modelos de ML. *Grupos de ações:* somente lista, somente leitura e gravação e leitura. *Recursos necessários:* banco de dados. ## `neptune-db:ListMLEndpoints` `ListMLEndpoints` possibilita a um usuário listar todos os endpoints do Neptune ML. *Grupos de ações:* somente lista, somente leitura e gravação e leitura. *Recursos necessários:* banco de dados. ## `neptune-db:CancelMLDataProcessingJob` `CancelMLDataProcessingJob` possibilita a um usuário cancelar um trabalho de processamento de dados do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:CancelMLModelTrainingJob` `CancelMLModelTrainingJob` possibilita a um usuário cancelar um trabalho de treinamento de modelos do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:CancelMLModelTransformJob` `CancelMLModelTransformJob` possibilita a um usuário cancelar um trabalho de transformação de modelos do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. ## `neptune-db:DeleteMLEndpoint` `DeleteMLEndpoint` possibilita a um usuário excluir um endpoint do Neptune ML. *Grupos de ações:* leitura e gravação. *Recursos necessários:* banco de dados. # Tipos de recursos do IAM para acessar dados no Amazon Neptune Recursos de dados, como ações de dados, têm um prefixo `neptune-db:`. Em uma política de acesso a dados do Neptune, você especifica o cluster de banco de dados ao qual está concedendo acesso a um ARN com o seguinte formato: ``` arn:aws:neptune-db:region:account-id:cluster-resource-id/* ``` Esse ARN de recurso contém as seguintes partes: + `region`é a AWS região do cluster de banco de dados Amazon Neptune. + `account-id` é o número da conta da AWS do cluster de banco de dados. + `cluster-resource-id` é um ID de recurso do cluster de banco de dados. **Importante** O `cluster-resource-id` é diferente do identificador do cluster. Para encontrar um ID de recurso de cluster no Console de gerenciamento da AWS Neptune, procure na seção Configuração **o** cluster de banco de dados em questão. # Chaves de condição do IAM para acessar dados no Amazon Neptune [Usando chaves de condição](security-iam-access-manage.md#iam-using-condition-keys), é possível especificar as condições em uma declaração de política do IAM para que a declaração só entre em vigor quando as condições forem verdadeiras. As chaves de condição que você pode usar em declarações de política de acesso a dados do Neptune se enquadram nas seguintes categorias: + [Chaves de [condição globais — O subconjunto de chaves](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) de condição AWS globais que o Neptune suporta nas declarações de política de acesso a dados está listado abaixo.](#iam-data-global-condition-keys) + [Chaves de condição específicas do serviço](#iam-neptune-condition-keys): são chaves definidas pelo Neptune especificamente para uso em declarações de política de acesso a dados. No momento, há apenas um, [neptune-db: QueryLanguage](#neptune-db-query-language), que concede acesso somente se uma linguagem de consulta específica estiver sendo usada. ## AWS chaves de contexto de condição global suportadas pelo Neptune em declarações de política de acesso a dados A seguinte tabela lista o subconjunto de [chaves de contexto de condição globais da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) aceitas pelo Amazon Neptune para uso em declarações de política de acesso a dados: **Chaves de condição globais que você pode usar em declarações de política de acesso a dados** | Chaves de condição | Descrição | Tipo | | --- | --- | --- | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) | Filtra o acesso pela data e hora atuais da solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime) | Filtra o acesso pela data e hora da solicitação expressa como um valor de época do UNIX. | Numeric | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalaccount) | Filtra o acesso pela conta à qual a entidade principal solicitante pertence. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalarn) | Filtra o acesso pelo ARN da entidade principal que faz a solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalisawsservice) | Permite acesso somente se a chamada estiver sendo feita diretamente por um responsável pelo AWS serviço. | Boolean | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgid) | Filtra o acesso pelo identificador da organização em AWS Organizations à qual o principal solicitante pertence. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principalorgpaths) | Filtra o acesso pelo caminho AWS Organizations para o diretor que está fazendo a solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) | Filtra o acesso por uma tag associada à entidade principal que faz a solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltype) | Filtra o acesso pelo tipo de entidade principal que faz a solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) | Filtra o acesso pela AWS região que foi chamada na solicitação. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) | Viabilizará o acesso somente se a solicitação tiver sido enviada usando SSL. | Boolean | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip) | Filtra o acesso pelo endereço IP do solicitante. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime) | Filtra o acesso pela data e a hora em que as credenciais de segurança temporárias foram emitidas. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-useragent) | Filtra o acesso pelo aplicativo cliente do solicitante. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-userid) | Filtra o acesso pelo identificador da entidade principal do solicitante. | String | | [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-viaawsservice) | Permite acesso somente se um AWS serviço tiver feito a solicitação em seu nome. | Boolean | ## Chaves de condição específicas do serviço do Neptune O Neptune é compatível com a seguinte chave de condição específica do serviço para políticas do IAM: **Chaves de condição específicas do serviço do Neptune** | Chaves de condição | Descrição | Tipo | | --- | --- | --- | | neptune-db:QueryLanguage | Filtra o acesso aos dados pela linguagem de consulta que está sendo usada. Os valores válidos são: `Gremlin`, `OpenCypher` e `Sparql`. As ações compatíveis são `ReadDataViaQuery`, `WriteDataViaQuery`, `DeleteDataViaQuery`, `GetQueryStatus` e `CancelQuery`. | String | # Criar políticas de acesso a dados do IAM no Amazon Neptune [Os exemplos a seguir mostram como criar políticas personalizadas do IAM que usam controle de acesso refinado do plano de dados APIs e das ações, introduzidas na versão 1.2.0.0 do Neptune Engine.](engine-releases-1.2.0.0.md) ## Exemplo de política que viabiliza acesso irrestrito aos dados em um cluster de banco de dados do Neptune O exemplo de política a seguir permite que um usuário do IAM se conecte a um cluster de banco de dados do Neptune usando a autenticação de banco de dados do IAM e usa o caractere “`*`“ para corresponder a todas as ações disponíveis. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ O exemplo anterior inclui um ARN de recurso em um formato específico da autenticação do IAM no Neptune. Para criar o ARN, consulte [Specifying data resources](iam-data-resources.md). Observe que o ARN usando para um `Resource` de autorização do IAM não é o mesmo ARN atribuído ao cluster na criação. ## Exemplo de política que viabiliza acesso somente leitura a um cluster de banco de dados do Neptune A política a seguir concede permissão para acesso total somente leitura aos dados em um cluster de banco de dados do Neptune: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect": "Allow", "Action": [ "neptune-db:Read*", "neptune-db:Get*", "neptune-db:List*" ], "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que nega acesso todo o acesso a um cluster de banco de dados do Neptune A ação padrão do IAM é negar o acesso a um cluster de banco de dados a menos que um *Effect* `Allow` seja concedido. No entanto, a política a seguir nega todo o acesso a um cluster de banco de dados para uma determinada AWS conta e região, que então tem precedência sobre qualquer `Allow` efeito. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que concede acesso de leitura por meio de consultas A seguinte política apenas concede permissão para leitura de um cluster de banco de dados do Neptune usando uma consulta: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "neptune-db:ReadDataViaQuery", "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que só permite consultas do Gremlin A seguinte política usa a chave de condição `neptune-db:QueryLanguage` para conceder permissão para consultar o Neptune somente usando a linguagem de consulta Gremlin: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "neptune-db:ReadDataViaQuery", "neptune-db:WriteDataViaQuery", "neptune-db:DeleteDataViaQuery" ], "Resource": "*", "Condition": { "StringEquals": { "neptune-db:QueryLanguage": "Gremlin" } } } ] } ``` ------ ## Exemplo de política que permite todo o acesso, exceto ao gerenciamento de modelos do Neptune ML A seguinte política concede acesso total às operações de grafo do Neptune, exceto os atributos de gerenciamento de modelos do Neptune ML: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect": "Allow", "Action": [ "neptune-db:CancelLoaderJob", "neptune-db:CancelQuery", "neptune-db:DeleteDataViaQuery", "neptune-db:DeleteStatistics", "neptune-db:GetEngineStatus", "neptune-db:GetLoaderJobStatus", "neptune-db:GetQueryStatus", "neptune-db:GetStatisticsStatus", "neptune-db:GetStreamRecords", "neptune-db:ListLoaderJobs", "neptune-db:ManageStatistics", "neptune-db:ReadDataViaQuery", "neptune-db:ResetDatabase", "neptune-db:StartLoaderJob", "neptune-db:WriteDataViaQuery" ], "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que permite acesso ao gerenciamento de modelos do Neptune ML Essa política concede acesso aos atributos de gerenciamento de modelos do Neptune ML: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect": "Allow", "Action": [ "neptune-db:CancelMLDataProcessingJob", "neptune-db:CancelMLModelTrainingJob", "neptune-db:CancelMLModelTransformJob", "neptune-db:CreateMLEndpoint", "neptune-db:DeleteMLEndpoint", "neptune-db:GetMLDataProcessingJobStatus", "neptune-db:GetMLEndpointStatus", "neptune-db:GetMLModelTrainingJobStatus", "neptune-db:GetMLModelTransformJobStatus", "neptune-db:ListMLDataProcessingJobs", "neptune-db:ListMLEndpoints", "neptune-db:ListMLModelTrainingJobs", "neptune-db:ListMLModelTransformJobs", "neptune-db:StartMLDataProcessingJob", "neptune-db:StartMLModelTrainingJob", "neptune-db:StartMLModelTransformJob" ], "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que concede acesso total por consulta A seguinte política concede acesso total às operações de consulta de grafo do Neptune, mas não a atributos, como redefinição rápida, fluxos, carregador em massa, gerenciamento de modelos do Neptune ML, etc.: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect": "Allow", "Action": [ "neptune-db:ReadDataViaQuery", "neptune-db:WriteDataViaQuery", "neptune-db:DeleteDataViaQuery", "neptune-db:GetEngineStatus", "neptune-db:GetQueryStatus", "neptune-db:CancelQuery" ], "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ ## Exemplo de política que concede acesso total somente para consultas do Gremlin A seguinte política concede acesso total às operações de consulta de grafo do Neptune usando a linguagem de consulta Gremlin, mas não a consultas em outras linguagens e não a atributos, como redefinição rápida, fluxos, carregador em massa, gerenciamento de modelos do Neptune ML, etc.: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement":[ { "Effect": "Allow", "Action": [ "neptune-db:ReadDataViaQuery", "neptune-db:WriteDataViaQuery", "neptune-db:DeleteDataViaQuery", "neptune-db:GetEngineStatus", "neptune-db:GetQueryStatus", "neptune-db:CancelQuery" ], "Resource": [ "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" ], "Condition": { "StringEquals": { "neptune-db:QueryLanguage":"Gremlin" } } } ] } ``` ------ ## Exemplo de política que concede acesso total, exceto para redefinição rápida A seguinte política concede acesso total a um cluster de banco de dados do Neptune, exceto para uso de redefinição rápida: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "neptune-db:*", "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" }, { "Effect": "Deny", "Action": "neptune-db:ResetDatabase", "Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-ABCD1234EFGH5678IJKL90MNOP/*" } ] } ``` ------ # Usar perfis vinculados a serviço no Amazon Neptune [O Amazon Neptune AWS Identity and Access Management usa funções vinculadas a serviços (IAM).](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) A função vinculada ao serviço é um tipo exclusivo de perfil do IAM vinculado diretamente ao Neptune. As funções vinculadas ao serviço são predefinidas pelo Neptune e incluem todas as permissões que o serviço exige para chamar outros serviços em seu nome. AWS **Importante** Para determinados atributos de gerenciamento, o Amazon Neptune usa tecnologia operacional compartilhada com o Amazon RDS. Isso inclui a *Função vinculada ao serviço* e permissões da API de gerenciamento. Um perfil vinculado ao serviço facilita a configuração do Neptune porque você não precisa adicionar as permissões necessárias manualmente. O Neptune define as permissões dos perfis vinculados a serviços e, exceto se definido de outra forma, somente o Neptune pode assumir os perfis. As permissões definidas incluem a política de confiança e a política de permissões, que não pode ser anexada a nenhuma outra entidade do IAM. Você pode excluir os perfis somente depois de primeiro excluir seus recursos relacionados. Isso protege os recursos do Neptune, pois você não pode remover por engano as permissões para acessar os recursos. Para obter informações sobre outros serviços que oferecem suporte a funções vinculadas a serviços, consulte [AWS Serviços que funcionam com IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) e procure os serviços que têm **Sim** na coluna Função **vinculada ao serviço**. Escolha um **Sim** com um link para visualizar a documentação do perfil vinculado para esse serviço. ## Permissões de perfil vinculado ao serviço para Neptune O Neptune usa `AWSServiceRoleForRDS` a função vinculada ao serviço para permitir que o Neptune e o Amazon AWS RDS chamem serviços em nome de suas instâncias de banco de dados. O perfil vinculado ao serviço `AWSServiceRoleForRDS` confia no serviço `rds.amazonaws.com` para presumir o perfil. A política de permissões do perfil permite que o Neptune conclua as seguintes ações nos recursos especificados: + Ações em `ec2`: + `AssignPrivateIpAddresses` + `AuthorizeSecurityGroupIngress` + `CreateNetworkInterface` + `CreateSecurityGroup` + `DeleteNetworkInterface` + `DeleteSecurityGroup` + `DescribeAvailabilityZones` + `DescribeInternetGateways` + `DescribeSecurityGroups` + `DescribeSubnets` + `DescribeVpcAttribute` + `DescribeVpcs` + `ModifyNetworkInterfaceAttribute` + `RevokeSecurityGroupIngress` + `UnassignPrivateIpAddresses` + Ações em `sns`: + `ListTopic` + `Publish` + Ações em `cloudwatch`: + `PutMetricData` + `GetMetricData` + `CreateLogStream` + `PullLogEvents` + `DescribeLogStreams` + `CreateLogGroup` **nota** É necessário configurar permissões para que uma entidade do IAM (por exemplo, um usuário, grupo ou função) crie, edite ou exclua um perfil vinculado ao serviço. Você pode encontrar a seguinte mensagem de erro: Impossível criar o recurso. Você se você tem permissão para criar o perfil vinculado ao serviço. Caso contrário, aguarde e tente novamente mais tarde. Se essa mensagem for exibida, verifique se você tem as seguintes permissões habilitadas: ``` { "Action": "iam:CreateServiceLinkedRole", "Effect": "Allow", "Resource": "arn:aws:iam::*:role/aws-service-role/rds.amazonaws.com/AWSServiceRoleForRDS", "Condition": { "StringLike": { "iam:AWSServiceName":"rds.amazonaws.com" } } } ``` Para saber mais, consulte [Permissões de Função Vinculadas ao Serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) no *Guia do Usuário do IAM*. ## Criar um perfil vinculado ao serviço para Neptune Não é necessário criar manualmente um perfil vinculado ao serviço. Quando você cria uma instância ou um cluster, o Neptune cria um perfil vinculado a serviço para você. **Importante** Para saber mais, consulte [A New Role Appeared in My IAM Account](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared) no *Guia do usuário do IAM*. Se você excluir essa função vinculada ao serviço e precisar criá-la novamente, poderá usar esse mesmo processo para recriar a função em sua conta. Quando você cria uma instância ou um cluster, o Neptune cria o perfil vinculado ao serviço novamente. ## Editar um perfil vinculado ao serviço para Neptune O Neptune não permite editar o perfil vinculada ao serviço `AWSServiceRoleForRDS`. Depois que criar um perfil vinculado ao serviço, você não poderá alterar o nome do perfil, pois várias entidades podem fazer referência a ele. No entanto, será possível editar a descrição do perfil usando o IAM. Para saber mais, consulte [Editar uma função vinculada a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) no *Guia do usuário do IAM*. ## Excluir um perfil vinculado ao serviço para Neptune Se você não precisar mais usar um atributo ou serviço que requer uma função vinculada a serviço, é recomendável excluí-la. Dessa forma, você não tem uma entidade não utilizada que não seja monitorada ativamente ou mantida. Contudo, você deve excluir todas as suas instâncias e clusters para poder excluir a função vinculada a serviço associada. ### Limpeza de uma função vinculada a serviço antes da exclusão Antes de você poder usar o IAM para excluir uma função vinculada ao serviço, você deve primeiro confirmar que a função não tem sessões ativas e remover quaisquer recursos usados pela função. **Para verificar se a função vinculada ao serviço tem uma sessão ativa no console do IAM** 1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. No painel de navegação do console do IAM, escolha **Funções**. A seguir, selecione o nome (não a caixa de seleção) da função `AWSServiceRoleForRDS`. 1. Na página **Resumo** para a função selecionada, escolha a guia **Consultor de Acesso**. 1. Na guia **Consultor de Acesso**, revise a atividade recente para a função vinculada ao serviço. **nota** Se não tiver certeza se o Neptune está usando o perfil `AWSServiceRoleForRDS`, você poderá tentar excluir o perfil. Se o serviço estiver usando a função, a exclusão falhará e você poderá visualizar as regiões da em que a função está sendo usada. Se a função está sendo usada, você deve aguardar a sessão final antes de excluir a função. Não é possível revogar a sessão de uma função vinculada a um serviço. Se deseja remover a função `AWSServiceRoleForRDS`, você deve primeiro excluir *todas* as suas instâncias e clusters. #### Exclusão de todas as instâncias Use um destes procedimentos para excluir cada uma de suas instâncias. **Para excluir uma instância (console)** 1. Abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. No painel de navegação, escolha **Instâncias**. 1. Na lista **Instances**, escolha a instância que você deseja excluir. 1. Escolha **Instance actions** e, em seguida, escolha **Delete**. 1. Se for exibido **Create final Snapshot? (Criar snapshot final?)**, escolha **Yes (Sim)** ou **No (Não)**. 1. Se você escolher **Yes (Sim)** na etapa anterior, em **Final snapshot name (Nome do snapshot final)**, digite o nome do snapshot final. 1. Escolha **Excluir**. **Como excluir uma instância (AWS CLI)** Consulte `[delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-instance.html)` no *AWS CLI Command Reference*. **Para excluir uma instância (API)** Consulte `[DeleteDBInstance](&doc-domaiAPI_DeleteDBInstance.html)`. #### Exclusão de todos os clusters Siga um destes procedimentos para excluir um único cluster e, depois, repita o procedimento para cada um dos seus clusters. **Para excluir um cluster (console)** 1. [Faça login no AWS Management Console e abra o console do Amazon Neptune em casa. https://console.aws.amazon.com/neptune/](https://console.aws.amazon.com/neptune/home) 1. Na lista **Clusters**, escolha o cluster que você deseja excluir. 1. Escolha **Ações de cluster** e **Excluir**. 1. Escolha **Excluir**. **Para excluir um cluster (CLI)** Consulte `[delete-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/neptune/delete-db-cluster.html)` no *AWS CLI Command Reference*. **Para excluir um cluster (API)** Consulte `[DeleteDBCluster](API_DeleteDBCluster.html)` É possível usar o console, a CLI ou a API do IAM para excluir o perfil vinculado ao serviço `AWSServiceRoleForRDS`. Para saber mais, consulte [Excluir um perfil vinculado ao serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) no *Guia do usuário do IAM*. # Usar credenciais temporárias para se conectar ao Amazon Neptune O Amazon Neptune é compatível com a autenticação do IAM usando credenciais temporárias. Você pode usar uma função assumida para autenticar ao usar uma política de autenticação do IAM como uma das políticas de exemplo nas seções anteriores. 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** As credenciais temporárias expiram 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). As seções a seguir descrevem como permitir o acesso e recuperar credenciais temporárias. **Para autenticar usando credenciais temporárias** 1. Criar um perfil do IAM com permissão para acessar um cluster do Neptune. Para obter informações sobre como criar essa função, consulte [Usar diferentes tipos de política do IAM para controle de acesso ao Neptune](security-iam-access-manage.md#iam-auth-policy). 1. Adicionar um relacionamento de confiança à função que permita acesso as credenciais. Recupere as credenciais temporárias, incluindo `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, e `AWS_SESSION_TOKEN`. 1. Conecte-se ao cluster do Neptune e assine as solicitações usando as credenciais temporárias. Para obter mais informações sobre como conectar e assinar solicitações, consulte [Conectando-se ao seu banco de dados Amazon Neptune usando autenticação AWS Identity and Access Management](iam-auth-connecting.md). Há vários métodos para recuperar credenciais temporárias dependendo do ambiente. **Topics** + [Obtendo credenciais temporárias usando o AWS CLI](#iam-auth-temporary-credentials-cli) + [Configurando o AWS Lambda para a autenticação do Neptune IAM](#iam-auth-temporary-credentials-lambda) + [Configurar o Amazon EC2 para autenticação do IAM do Neptune](#iam-auth-temporary-credentials-ec2) ## Obtendo credenciais temporárias usando o AWS CLI Para obter credenciais usando o AWS Command Line Interface (AWS CLI), primeiro você precisa adicionar uma relação de confiança que conceda permissão para assumir a função ao AWS usuário que executará o AWS CLI comando. Adicione o seguinte relacionamento de confiança ao perfil de autenticação do IAM do Neptune. Se você não tiver um perfil de autenticação do IAM do Neptune, consulte [Usar diferentes tipos de política do IAM para controle de acesso ao Neptune](security-iam-access-manage.md#iam-auth-policy). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:user/test" }, "Action": "sts:AssumeRole" } ] } ``` ------ Para obter informações sobre como ampliar a relação de confiança à função, consulte [Editar a relação de confiança de uma função existente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) no *Guia de administração do AWS Directory Service *. Se a política do Neptune ainda não estiver associada a um perfil, crie um perfil. Associe a política de autenticação do IAM do Neptune e, depois, adicione a política de confiança. Para obter informações sobre como criar uma nova função, consulte [Como criar uma função](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html). **nota** As seções a seguir pressupõem que você tenha o AWS CLI instalado. **Para executar o AWS CLI manualmente** 1. Digite o comando a seguir para solicitar as credenciais usando a AWS CLI. Substitua o ARN da função, nome de sessão e perfil com seus próprios valores. ``` aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile ``` 1. A seguir está um exemplo de saída do comando. A seção `Credentials` contém os valores de que você precisa. **nota** Anote o valor `Expiration`, pois ele será necessário para obter novas credenciais após esse período. ``` { "AssumedRoleUser": { "AssumedRoleId": "AROA3XFRBF535PLBIFPI4:s3-access-example", "Arn": "arn:aws:sts::123456789012:assumed-role/xaccounts3access/s3-access-example" }, "Credentials": { "SecretAccessKey": "9drTJvcXLB89EXAMPLELB8923FB892xMFI", "SessionToken": "AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU=", "Expiration": "2016-03-15T00:05:07Z", "AccessKeyId": "ASIAJEXAMPLEXEG2JICEA" } } ``` 1. Defina as variáveis do ambiente usando as credenciais retornadas. ``` export AWS_ACCESS_KEY_ID=ASIAJEXAMPLEXEG2JICEA export AWS_SECRET_ACCESS_KEY=9drTJvcXLB89EXAMPLELB8923FB892xMFI export AWS_SESSION_TOKEN=AQoXdzELDDY//////////wEaoAK1wvxJY12r2IrDFT2IvAzTCn3zHoZ7YNtpiQLF0MqZye/qwjzP2iEXAMPLEbw/m3hsj8VBTkPORGvr9jM5sgP+w9IZWZnU+LWhmg+a5fDi2oTGUYcdg9uexQ4mtCHIHfi4citgqZTgco40Yqr4lIlo4V2b2Dyauk0eYFNebHtYlFVgAUj+7Indz3LU0aTWk1WKIjHmmMCIoTkyYp/k7kUG7moeEYKSitwQIi6Gjn+nyzM+PtoA3685ixzv0R7i5rjQi0YE0lf1oeie3bDiNHncmzosRM6SFiPzSvp6h/32xQuZsjcypmwsPSDtTPYcs0+YN/8BRi2/IcrxSpnWEXAMPLEXSDFTAQAM6Dl9zR0tXoybnlrZIwMLlMi1Kcgo5OytwU= 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 ``` 1. Conectar-se usando um dos seguintes métodos. + [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 Python](iam-auth-connecting-python.md) **Para usar um script para obter as credenciais** 1. Execute o seguinte comando para instalar comando **jq**. O script usa esse comando para analisar a saída do AWS CLI comando. ``` sudo yum -y install jq ``` 1. Crie um arquivo chamado `credentials.sh` em um editor de texto e adicione o texto a seguir. Substitua a região de serviço, ARN da função, nome de sessão e perfil com seus próprios valores. ``` #!/bin/bash creds_json=$(aws sts assume-role --role-arn arn:aws:iam::123456789012:role/NeptuneIAMAuthRole --role-session-name test --profile testprofile) export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .Credentials.AccessKeyId |tr -d '"') export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .Credentials.SecretAccessKey| tr -d '"') export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Credentials.SessionToken|tr -d '"') 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 ``` 1. Conectar-se usando um dos seguintes métodos. + [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 Python](iam-auth-connecting-python.md) ## Configurando o AWS Lambda para a autenticação do Neptune IAM AWS Lambda inclui credenciais automaticamente sempre que a função Lambda é executada. Primeiro, adicione uma relação de confiança que conceda permissão para assumir o perfil ao serviço do Lambda. Adicione o seguinte relacionamento de confiança ao perfil de autenticação do IAM do Neptune. Se você não tiver um perfil de autenticação do IAM do Neptune, consulte [Usar diferentes tipos de política do IAM para controle de acesso ao Neptune](security-iam-access-manage.md#iam-auth-policy). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Para obter informações sobre como ampliar a relação de confiança à função, consulte [Editar a relação de confiança de uma função existente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) no *Guia de administração do AWS Directory Service*. Se a política do Neptune ainda não estiver associada a um perfil, crie um perfil. Associe a política de autenticação do IAM do Neptune e, depois, adicione a política de confiança. Para obter informações sobre como criar uma função, consulte [Criar uma função](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html) no *Guia de administração do AWS Directory Service *. **Como acessar o Neptune pelo Lambda** 1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Crie uma nova função do Lambda para Python versão 3.6. 1. Atribua a função `AWSLambdaVPCAccessExecutionRole` para a função Lambda. Isso é necessário para acessar os recursos do Neptune, que são apenas VPC. 1. Atribua o perfil do IAM de autenticação do Neptune para a função do Lambda. Para obter mais informações, consulte [AWS Lambda Permissions](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html) no *Guia do desenvolvedor do AWS Lambda *. 1. Copie o exemplo de Python de autenticação do IAM no código de função Lambda. Para obter mais informações sobre os exemplos e os códigos de exemplo, consulte [Conectar-se a bancos de dados do Amazon Neptune usando a autenticação do IAM com Python](iam-auth-connecting-python.md). ## Configurar o Amazon EC2 para autenticação do IAM do Neptune O Amazon EC2 permite que você use perfis de instância para fornecer automaticamente as credenciais. Para obter mais informações, consulte [Using Instance Profiles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) no *Guia do usuário do IAM*. Primeiro, adicione uma relação de confiança que conceda permissão para assumir o perfil ao serviço do Amazon EC2. Adicione o seguinte relacionamento de confiança ao perfil de autenticação do IAM do Neptune. Se você não tiver um perfil de autenticação do IAM do Neptune, consulte [Usar diferentes tipos de política do IAM para controle de acesso ao Neptune](security-iam-access-manage.md#iam-auth-policy). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "ec2.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } ``` ------ Para obter informações sobre como ampliar a relação de confiança à função, consulte [Editar a relação de confiança de uma função existente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html) no *Guia de administração do AWS Directory Service *. Se a política do Neptune ainda não estiver associada a um perfil, crie um perfil. Associe a política de autenticação do IAM do Neptune e, depois, adicione a política de confiança. Para obter informações sobre como criar uma função, consulte [Criar uma função](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/create_role.html) no *Guia de administração do AWS Directory Service *. **Para usar um script para obter as credenciais** 1. Execute o seguinte comando para instalar comando **jq**. O script usa esse comando para analisar a saída do comando **curl**. ``` sudo yum -y install jq ``` 1. Crie um arquivo chamado `credentials.sh` em um editor de texto e adicione o texto a seguir. Substitua a região de serviço com o seu próprio valor. ``` TOKEN=$( curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" ) role_name=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/ ) creds_json=$( curl -H "X-aws-ec2-metadata-token: $TOKEN" http://169.254.169.254/latest/meta-data/iam/security-credentials/${role_name} ) export AWS_ACCESS_KEY_ID=$(echo "$creds_json" | jq .AccessKeyId |tr -d '"') export AWS_SECRET_ACCESS_KEY=$(echo "$creds_json" | jq .SecretAccessKey| tr -d '"') export AWS_SESSION_TOKEN=$(echo "$creds_json" | jq .Token|tr -d '"') 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 ``` 1. Execute o script no shell `bash` usando o comando `source`: ``` source credentials.sh ``` Melhor ainda é adicionar os comandos deste script ao arquivo `.bashrc` em sua instância do EC2 para que eles sejam invocados automaticamente quando você fizer login, disponibilizando credenciais temporárias para o console Gremlin. 1. Conectar-se usando um dos seguintes métodos. + [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 Python](iam-auth-connecting-python.md) # Registrar em log e monitorar o uso e desempenho no Amazon Neptune O Amazon Neptune é compatível com vários métodos para monitorar o desempenho e o uso: + **Status do cluster**: confira a integridade do mecanismo de banco de dados do grafo de um cluster do Neptune. Para obter mais informações, consulte [Conferir o status de integridade de uma instância do Neptune](access-graph-status.md). + **Amazon CloudWatch** — Neptune envia métricas automaticamente e também oferece suporte CloudWatch a alarmes. CloudWatch Para obter mais informações, consulte [Monitorando Neptune usando a Amazon CloudWatch](cloudwatch.md). + **Arquivos de log de auditoria**: visualize, baixe ou observe arquivos de log de banco de dados usando o console do Neptune. Para obter mais informações, consulte [Usar logs de auditoria com clusters do Amazon Neptune](auditing.md). + **Publicação de registros no Amazon CloudWatch Logs** — Você pode configurar um cluster de banco de dados Neptune para publicar dados de log de auditoria em um grupo de logs no Amazon Logs. CloudWatch Com o CloudWatch Logs, você pode realizar análises em tempo real dos dados de log, usar CloudWatch para criar alarmes e visualizar métricas, e usar o CloudWatch Logs para armazenar seus registros de log em um armazenamento altamente durável. Para obter mais informações, consulte [Registros de Netuno CloudWatch ](cloudwatch-logs.md). + **AWS CloudTrail**— O Neptune suporta o registro de API usando. CloudTrail Para obter mais informações, consulte [Registro de chamadas de API do Amazon Neptune com AWS CloudTrail](cloudtrail.md). + **Marcação**: use tags para adicionar metadados aos recursos do Neptune e monitorar o uso com base em tags. Para obter mais informações, consulte [Marcar recursos do Amazon Neptune](tagging.md). # Amazon Neptune e endpoints de interface VPC ()AWS PrivateLink Você pode usar [AWS PrivateLink](https://aws.amazon.com/privatelink/)para criar uma conexão privada entre sua VPC e os endpoints da API Amazon Neptune. Você pode acessar as operações da API do Amazon Neptune como se elas estivessem em sua VPC, sem o uso de um gateway de internet, dispositivo NAT, conexão VPN ou conexão. O tráfego entre sua VPC e o Amazon Neptune permanece dentro da rede Amazon. O Amazon Neptune compartilha a infraestrutura de API com o Amazon Relational Database Service. *Para configurar endpoints de VPC de interface para o Amazon Neptune, siga as instruções na [API do Amazon RDS e faça a interface de VPC endpoints](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/vpc-interface-endpoints.html) () no Guia do usuário do Amazon Aurora.AWS PrivateLink* # Considerações de conformidade para o Amazon Neptune Para saber se um AWS service (Serviço da AWS) está dentro do escopo de programas de conformidade específicos, consulte [Serviços da AWS Escopo por Programa de Conformidade Serviços da AWS](https://aws.amazon.com/compliance/services-in-scope/) e escolha o programa de conformidade em que você está interessado. Para obter informações gerais, consulte Programas de [AWS conformidade Programas AWS](https://aws.amazon.com/compliance/programs/) de . Você pode baixar relatórios de auditoria de terceiros usando AWS Artifact. Para obter mais informações, consulte [Baixar relatórios em AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) . Sua responsabilidade de conformidade ao usar Serviços da AWS é determinada pela confidencialidade de seus dados, pelos objetivos de conformidade de sua empresa e pelas leis e regulamentações aplicáveis. Para obter mais informações sobre sua responsabilidade de conformidade ao usar Serviços da AWS, consulte a [Documentação AWS de segurança](https://docs.aws.amazon.com/security/). # Criar implantações do Amazon Neptune resilientes e tolerantes a desastres A infraestrutura AWS global é construída em torno de AWS regiões e zonas de disponibilidade. AWS As regiões fornecem várias zonas de disponibilidade fisicamente separadas e isoladas, conectadas a redes de baixa latência, alta taxa de transferência e alta redundância. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que executam o failover automaticamente entre as zonas de disponibilidade sem interrupção. As zonas de disponibilidade são mais altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais. Um cluster de banco de dados do Amazon Neptune só pode ser criado em uma Amazon VPC com pelo menos duas sub-redes em pelo menos duas zonas de disponibilidade. Ao distribuir as instâncias de cluster em pelo menos duas zonas de disponibilidade, o Neptune ajuda a garantir que haverá instâncias disponíveis no cluster de banco de dados no caso improvável de ocorrer uma falha na zona de disponibilidade. O volume do cluster de banco de dados do Neptune sempre abrange três zonas de disponibilidade para fornecer um armazenamento durável com menor possibilidade de perda de dados. Para obter mais informações sobre AWS regiões e zonas de disponibilidade, consulte [Infraestrutura AWS global](https://aws.amazon.com/about-aws/global-infrastructure/).