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á.
# Visão geral da segurança no Amazon OpenSearch Serverless
A segurança no Amazon OpenSearch Serverless difere fundamentalmente da segurança no Amazon OpenSearch Service das seguintes maneiras:
| Recurso | OpenSearch Serviço | OpenSearch Sem servidor |
| --- | --- | --- |
| Controle de acesso a dados | O acesso aos dados é determinado por políticas do IAM e por controle de acesso minucioso. | O acesso aos dados é determinado por políticas de acesso a dados. |
| Criptografia em repouso | A criptografia em repouso é opcional para domínios. | A criptografia em repouso é obrigatória para coleções. |
| Configuração e administração da segurança | Você deve configurar a rede, a criptografia e o acesso aos dados individualmente para cada domínio. | É possível usar políticas de segurança para gerenciar as configurações de segurança de várias coleções em escala. |
O diagrama a seguir ilustra os componentes de segurança que compõem uma coleção funcional. Uma coleção deve ter uma chave de criptografia atribuída, configurações de acesso à rede e uma política de acesso a dados correspondente que conceda permissão aos seus recursos.
![\[Diagram showing encryption, network, data access, and authentication policies for a collection.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-security.png)
**Topics**
+ [
## Políticas de criptografia
](#serverless-security-encryption)
+ [
## Políticas de rede
](#serverless-security-network)
+ [
## Políticas de acesso a dados
](#serverless-security-data-access)
+ [
## Autenticação SAML e IAM
](#serverless-security-authentication)
+ [
## Segurança da infraestrutura
](#serverless-infrastructure-security)
+ [
# Introdução à segurança no Amazon OpenSearch Serverless
](serverless-tutorials.md)
+ [
# Identity and Access Management para Amazon OpenSearch Serverless
](security-iam-serverless.md)
+ [
# Criptografia no Amazon OpenSearch Serverless
](serverless-encryption.md)
+ [
# Acesso à rede para Amazon OpenSearch Serverless
](serverless-network.md)
+ [
# Conformidade com FIPS no Amazon Serverless OpenSearch
](fips-compliance-opensearch-serverless.md)
+ [
# Controle de acesso a dados para Amazon OpenSearch Serverless
](serverless-data-access.md)
+ [
# Acesso ao plano de dados por meio de AWS PrivateLink
](serverless-vpc.md)
+ [
# Controle o acesso ao avião por meio de AWS PrivateLink
](serverless-vpc-cp.md)
+ [
# Autenticação SAML para Amazon Serverless OpenSearch
](serverless-saml.md)
+ [
# Validação de conformidade para Amazon OpenSearch Serverless
](serverless-compliance-validation.md)
## Políticas de criptografia
[As políticas de criptografia](serverless-encryption.md) definem se suas coleções são criptografadas com uma chave gerenciada pelo cliente Chave pertencente à AWS ou com uma chave gerenciada pelo cliente. As políticas de criptografia consistem em dois componentes: um **padrão de recursos** e uma **chave de criptografia**. O padrão de recursos define a qual coleção ou coleções a política se aplica. A chave de criptografia determina como as coleções associadas serão protegidas.
Para aplicar uma política a várias coleções, inclua um curinga (\$1) na regra da política. Por exemplo, a política a seguir se aplica a todas as coleções com nomes que começam com “logs”.
![\[Input field for specifying a prefix term or collection name, with "logs*" entered.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-security-encryption.png)
As políticas de criptografia simplificam o processo de criação e gerenciamento de coleções, especialmente quando isso é feito de forma programática. É possível criar uma coleção especificando um nome, e uma chave de criptografia será automaticamente atribuída a ela na criação.
## Políticas de rede
As [políticas de rede](serverless-network.md) definem se as coleções são acessíveis de modo privado ou pela internet em redes públicas. *As coleções particulares podem ser acessadas por meio de endpoints VPC OpenSearch gerenciados sem servidor ou por pontos específicos, Serviços da AWS como o Amazon Bedrock, usando acesso privado.AWS service (Serviço da AWS) * Assim como as políticas de criptografia, as políticas de rede podem ser aplicadas a várias coleções, o que permite gerenciar o acesso à rede para muitas coleções em grande escala.
As políticas de rede consistem em dois componentes: um **tipo de acesso** e um **tipo de recurso**. O tipo de acesso pode ser público ou privado. O tipo de recurso determina se o acesso escolhido se aplica ao endpoint da coleção, ao endpoint do OpenSearch Dashboards ou a ambos.
![\[Access type and resource type options for configuring network policies in OpenSearch.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-security-network.png)
Se você planeja configurar o acesso à VPC dentro de uma política de rede, primeiro deve criar um ou mais VPC endpoints gerenciados [OpenSearch sem servidor](serverless-vpc.md). Esses endpoints permitem que você acesse o OpenSearch Serverless como se estivesse em sua VPC, sem o uso de um gateway de internet, dispositivo NAT, conexão VPN ou conexão. Direct Connect
O acesso privado ao só Serviços da AWS pode ser aplicado ao endpoint da coleção, não ao OpenSearch endpoint do OpenSearch Dashboards. Serviços da AWS não pode ter acesso aos OpenSearch painéis.
## Políticas de acesso a dados
As [políticas de acesso a dados](serverless-data-access.md) definem como seus usuários acessam os dados em suas coleções. As políticas de acesso a dados ajudam você a gerenciar coleções em grande escala atribuindo automaticamente permissões de acesso a coleções e índices que correspondam a um padrão específico. Várias políticas podem ser aplicadas a um único recurso.
As políticas de acesso a dados consistem em um conjunto de regras, cada uma com três componentes: um **tipo de recurso**, **recursos concedidos** e um conjunto de **permissões**. O tipo de recurso pode ser uma coleção ou um índice. Os recursos concedidos podem ser collection/index nomes ou padrões com um curinga (\$1). A lista de permissões especifica a quais [operações de OpenSearch API](serverless-genref.md#serverless-operations) a política concede acesso. Além disso, a política contém uma lista de **entidades principais**, que especificam os perfis e usuários do IAM e as identidades SAML aos quais conceder acesso.
![\[Selected principals and granted resources with permissions for collection and index access.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-data-access.png)
Para saber mais sobre o formato de uma política de acesso a dados, consulte a [sintaxe da política](serverless-data-access.md#serverless-data-access-syntax).
Antes de criar uma política de acesso a dados, é necessário ter um ou mais usuários ou perfis do IAM, ou identidades SAML, aos quais fornecer acesso na política. Consulte a próxima seção para obter detalhes.
**nota**
Mudar de acesso público para privado para sua coleção removerá a guia Índices no console de coleção OpenSearch sem servidor.
## Autenticação SAML e IAM
As entidades principais do IAM e as identidades do SAML são um dos alicerces de uma política de acesso a dados. Na declaração `principal` de uma política de acesso, é possível incluir usuários e perfis do IAM e identidades SAML. Em seguida, essas entidades principais recebem as permissões que você especifica nas regras de política associadas.
```
[
{
"Rules":[
{
"ResourceType":"index",
"Resource":[
"index/marketing/orders*"
],
"Permission":[
"aoss:*"
]
}
],
"Principal":[
"arn:aws:iam::123456789012:user/Dale",
"arn:aws:iam::123456789012:role/RegulatoryCompliance",
"saml/123456789012/myprovider/user/Annie"
]
}
]
```
Você configura a autenticação SAML diretamente no OpenSearch Serverless. Para obter mais informações, consulte [Autenticação SAML para Amazon Serverless OpenSearch](serverless-saml.md).
## Segurança da infraestrutura
O Amazon OpenSearch Serverless é protegido pela segurança de rede AWS global. Para obter informações sobre serviços AWS de segurança e como AWS proteger a infraestrutura, consulte [AWS Cloud Security](https://aws.amazon.com/security/). Para projetar seu AWS ambiente usando as melhores práticas de segurança de infraestrutura, consulte [Proteção](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) de infraestrutura no *Security Pillar AWS Well‐Architected* Framework.
Você usa chamadas de API AWS publicadas para acessar o Amazon OpenSearch Serverless pela rede. Os clientes devem ser compatíveis com o Transport Layer Security (TLS). Exigimos TLS 1.2 e recomendamos TLS 1.3. Para obter uma lista das cifras compatíveis com o TLS 1.3, consulte [Protocolos e cifras do TLS](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html#tls-protocols-ciphers) na documentação do Elastic Load Balancing.
Além disso, as solicitações devem ser assinadas usando um ID de chave de acesso e uma chave de acesso secreta associada a uma entidade principal do IAM. Ou você pode usar o [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) (AWS STS) para gerar credenciais de segurança temporárias para assinar solicitações.
# Introdução à segurança no Amazon OpenSearch Serverless
Os tutoriais a seguir ajudam você a começar a usar o Amazon OpenSearch Serverless. Ambos os tutoriais realizam as mesmas etapas básicas, mas um usa o console enquanto o outro usa a AWS CLI.
Observe que os casos de uso nestes tutoriais são simplificados. As políticas de rede e segurança são bastante abertas. Nas workloads de produção, recomendamos que você configure recursos de segurança mais robustos, como autenticação SAML, acesso por VPC e políticas de acesso a dados restritivas.
**Topics**
+ [
# Tutorial: Introdução à segurança no Amazon OpenSearch Serverless (console)
](gsg-serverless.md)
+ [
# Tutorial: Introdução à segurança no Amazon OpenSearch Serverless (CLI)
](gsg-serverless-cli.md)
# Tutorial: Introdução à segurança no Amazon OpenSearch Serverless (console)
Este tutorial mostra as etapas básicas para criar e gerenciar políticas de segurança usando o console Amazon OpenSearch Serverless.
Você concluirá as seguintes etapas neste tutorial:
1. [Configurar permissões](#gsgpermissions)
1. [Criar uma política de criptografia](#gsg-encryption)
1. [Criar uma política de rede](#gsg-network)
1. [Configurar uma política de acesso a dados](#gsg-data-access)
1. [Criar uma coleção](#gsgcreate-collection)
1. [Transferir e pesquisar dados](#gsgindex-collection)
Este tutorial explica como configurar uma coleção usando Console de gerenciamento da AWS o. Para ver as mesmas etapas usando o AWS CLI, consulte[Tutorial: Introdução à segurança no Amazon OpenSearch Serverless (CLI)](gsg-serverless-cli.md).
## Etapa 1: configurar permissões
**nota**
É possível pular esta etapa se já estiver usando uma política baseada em identidade mais ampla, como `Action":"aoss:*"` ou `Action":"*"`. Em ambientes de produção, no entanto, recomendamos que você siga a entidade principal do privilégio mínimo e atribua somente as permissões mínimas necessárias para concluir uma tarefa.
Para concluir este tutorial, você deve ter as permissões corretas do IAM. Seu usuário ou função deve ter uma [política baseada em identidade](security-iam-serverless.md#security-iam-serverless-id-based-policies) anexada com as seguintes permissões mínimas:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"aoss:ListCollections",
"aoss:BatchGetCollection",
"aoss:CreateCollection",
"aoss:CreateSecurityPolicy",
"aoss:GetSecurityPolicy",
"aoss:ListSecurityPolicies",
"aoss:CreateAccessPolicy",
"aoss:GetAccessPolicy",
"aoss:ListAccessPolicies"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Para obter uma lista completa das permissões OpenSearch sem servidor, consulte. [Identity and Access Management para Amazon OpenSearch Serverless](security-iam-serverless.md)
## Etapa 2: criar uma política de criptografia
[As políticas de criptografia](serverless-encryption.md) especificam a AWS KMS chave que o OpenSearch Serverless usará para criptografar a coleção. Você pode criptografar coleções com uma chave Chave gerenciada pela AWS ou uma chave diferente. Por simplicidade, neste tutorial, criptografaremos nossa coleção com uma Chave gerenciada pela AWS.
**Para criar uma política de criptografia**
1. Abra o console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home ).
1. No painel de navegação à esquerda, expanda **Sem Servidor** e escolha **Políticas de criptografia**.
1. Escolha **Criar política de criptografia**.
1. Nomeie a política como **books-policy**. Para a descrição, insira **Política de criptografia para coleção de livros**.
1. Em **Recursos**, insira **livros**, que é como você chamará sua coleção. Se você quiser ser mais amplo, inclua um asterisco (`books*`) para que a política se aplique a todas as coleções que comecem com a palavra “books” (livros).
1. Para **Criptografia**, mantenha a opção ** AWS Usar chave própria** selecionada.
1. Escolha **Criar**.
## Etapa 3: criar uma política de rede
[As políticas de rede](serverless-network.md) determinam se sua coleção pode ser acessada pela Internet a partir de redes públicas ou se ela deve ser acessada por meio de VPC endpoints OpenSearch gerenciados sem servidor. Neste tutorial, configuraremos o acesso público.
**Para criar uma política de rede**
1. Escolha **Políticas de rede** no painel de navegação à esquerda, e escolha **Criar política de rede**.
1. Nomeie a política como **books-policy**. Para a descrição, insira **Política de rede para coleção de livros**.
1. Na **Regra 1**, nomeie a regra como **Acesso público para coleção de livros** .
1. Para simplificar, neste tutorial, configuraremos o acesso público para a coleção *livros*. Para o tipo de acesso, selecione **Público**.
1. Vamos acessar a coleção a partir dos OpenSearch painéis. Para fazer isso, você precisa configurar o acesso à rede para painéis *e* o OpenSearch endpoint, caso contrário, os painéis não funcionarão.
Para o tipo de recurso, habilite o **acesso aos OpenSearch endpoints** e o **acesso aos OpenSearch painéis**.
1. Em ambas as caixas de entrada, insira **Nome da coleção = livros**. Essa configuração reduz o escopo da política para que ela se aplique somente a uma única coleção (`books`). Sua regra deve ser semelhante a esta:
![\[Search interface showing two input fields for collection or prefix term selection, both set to "books".\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-tutorial-network.png)
1. Escolha **Criar**.
## Etapa 4: Criar uma política de acesso a dados
Os dados da sua coleção não estarão acessíveis até que você configure o acesso aos dados. As [políticas de acesso a dados](serverless-data-access.md) são separadas da política baseada em identidade do IAM que você configurou na etapa 1. Elas permitem que os usuários acessem os dados reais de uma coleção.
Neste tutorial, forneceremos a um único usuário as permissões necessárias para indexar dados na coleção *livros*.
**Para criar uma política de acesso a dados**
1. No painel de navegação à esquerda, escolha **Políticas de acesso a dados** e, em seguida, **Criar política de acesso**.
1. Nomeie a política como **books-policy**. Para a descrição, insira **Política de acesso a dados para coleção de livros**.
1. Selecione **JSON** para o método de definição de política e cole a seguinte política no editor JSON.
Substitua o ARN principal pelo ARN da conta que você usará para fazer login nos OpenSearch painéis e indexar dados.
```
[
{
"Rules":[
{
"ResourceType":"index",
"Resource":[
"index/books/*"
],
"Permission":[
"aoss:CreateIndex",
"aoss:DescribeIndex",
"aoss:ReadDocument",
"aoss:WriteDocument",
"aoss:UpdateIndex",
"aoss:DeleteIndex"
]
}
],
"Principal":[
"arn:aws:iam::123456789012:user/my-user"
]
}
]
```
Esta política fornece a um único usuário as permissões mínimas necessárias para criar um índice na coleção *livros*, indexar alguns dados e pesquisá-los.
1. Escolha **Criar**.
## Etapa 5: Criar uma coleção
Agora que você configurou as políticas de criptografia e rede, será possível criar uma coleção correspondente e as configurações de segurança serão aplicadas automaticamente a ela.
**Para criar uma coleção OpenSearch sem servidor**
1. Escolha **Coleções** no painel de navegação à esquerda e escolha **Criar coleção**.
1. Dê o nome de **livros** à coleção.
1. Para o tipo de coleção, escolha **Pesquisar**.
1. Em **Criptografia**, OpenSearch Serverless informa que o nome da coleção corresponde à política de criptografia. `books-policy`
1. Em **Configurações de acesso à rede**, o OpenSearch Serverless informa que o nome da coleção corresponde à `books-policy` política de rede.
1. Escolha **Próximo**.
1. Em **Opções de política de acesso a dados**, o OpenSearch Serverless informa que o nome da coleção corresponde à política de acesso a `books-policy` dados.
1. Escolha **Próximo**.
1. Reveja a configuração da coleção e escolha **Enviar**. Normalmente, as coleções levam menos de um minuto para serem inicializadas.
## Etapa 6: transferir e pesquisar dados
Você pode carregar dados para uma coleção OpenSearch sem servidor usando Postman ou curl. Para resumir, esses exemplos usam **Dev Tools** no console OpenSearch Dashboards.
**Para indexar e pesquisar dados em uma coleção**
1. Escolha **Coleções** no painel de navegação à esquerda e escolha a coleção **livros** para abrir sua página de detalhes.
1. Escolha o URL dos OpenSearch painéis para a coleção. O URL assume o formato `https://collection-id.us-east-1.aoss.amazonaws.com/_dashboards`.
1. Faça login nos OpenSearch painéis usando as [chaves de AWS acesso e secretas](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-appendix-sign-up.html) do principal que você especificou em sua política de acesso a dados.
1. Em OpenSearch Painéis, abra o menu de navegação à esquerda e escolha **Ferramentas de desenvolvimento**.
1. Para criar um único índice chamado *books-index*, execute o seguinte comando:
```
PUT books-index
```
![\[OpenSearch Dashboards console showing PUT request for books-index with JSON response.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-createindex.png)
1. Para indexar um único documento em *books-index*, execute o seguinte comando:
```
PUT books-index/_doc/1
{
"title": "The Shining",
"author": "Stephen King",
"year": 1977
}
```
1. Para pesquisar dados em OpenSearch painéis, você precisa configurar pelo menos um padrão de índice. OpenSearch usa esses padrões para identificar quais índices você deseja analisar. Abra o menu principal do Dashboards, escolha **Gerenciamento de pilhas**, escolha **Padrões de índice** e, em seguida, escolha **Criar padrão de índice**. Para este tutorial, insira *books-index*.
1. Escolha **Próxima etapa** e, em seguida, **Criar padrão de índice**. Depois que o padrão é criado, você pode visualizar os vários campos do documento, como `author` e `title`.
1. Para começar a pesquisar seus dados, abra o menu principal novamente e escolha **Descobrir**, ou use a [API de pesquisa](https://opensearch.org/docs/latest/opensearch/rest-api/search/).
# Tutorial: Introdução à segurança no Amazon OpenSearch Serverless (CLI)
Este tutorial orienta você pelas etapas descritas no [tutorial de introdução do console](gsg-serverless.md) sobre segurança, mas usa o console AWS CLI em vez do OpenSearch Service console.
Você concluirá as seguintes etapas neste tutorial:
1. Criar uma política do IAM
1. Anexar a política do IAM ao perfil do IAM
1. Criar uma política de criptografia
1. Criar uma política de rede
1. Criar uma coleção
1. Configurar uma política de acesso a dados
1. Recuperar o endpoint da coleta
1. Carregar dados para sua conexão
1. Pesquisar dados em sua coleção
O objetivo deste tutorial é configurar uma única coleção OpenSearch Serverless com configurações bastante simples de criptografia, rede e acesso a dados. Por exemplo, configuraremos o acesso à rede pública, uma Chave gerenciada pela AWS para criptografia e uma política simplificada de acesso a dados que concede permissões mínimas a um único usuário.
Em um cenário de produção, considere implementar uma configuração mais robusta, incluindo autenticação SAML, uma chave de criptografia personalizada e acesso pela VPC.
**Para começar a usar as políticas de segurança no OpenSearch Serverless**
1.
**nota**
É possível pular esta etapa se já estiver usando uma política baseada em identidade mais ampla, como `Action":"aoss:*"` ou `Action":"*"`. Em ambientes de produção, no entanto, recomendamos que você siga a entidade principal do privilégio mínimo e atribua somente as permissões mínimas necessárias para concluir uma tarefa.
Para começar, crie uma AWS Identity and Access Management política com as permissões mínimas necessárias para executar as etapas deste tutorial. Daremos o nome de `TutorialPolicy` à política:
```
aws iam create-policy \
--policy-name TutorialPolicy \
--policy-document "{\"Version\": \"2012-10-17\",\"Statement\": [{\"Action\": [\"aoss:ListCollections\",\"aoss:BatchGetCollection\",\"aoss:CreateCollection\",\"aoss:CreateSecurityPolicy\",\"aoss:GetSecurityPolicy\",\"aoss:ListSecurityPolicies\",\"aoss:CreateAccessPolicy\",\"aoss:GetAccessPolicy\",\"aoss:ListAccessPolicies\"],\"Effect\": \"Allow\",\"Resource\": \"*\"}]}"
```
**Exemplo de resposta**
```
{
"Policy": {
"PolicyName": "TutorialPolicy",
"PolicyId": "ANPAW6WRAECKG6QJWUV7U",
"Arn": "arn:aws:iam::123456789012:policy/TutorialPolicy",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2022-10-16T20:57:18+00:00",
"UpdateDate": "2022-10-16T20:57:18+00:00"
}
}
```
1. Anexe `TutorialPolicy` ao perfil do IAM que indexará e pesquisará dados na coleção. Daremos o nome de `TutorialRole` ao usuário:
```
aws iam attach-role-policy \
--role-name TutorialRole \
--policy-arn arn:aws:iam::123456789012:policy/TutorialPolicy
```
1. Antes de criar uma coleção, você precisa criar uma [política de criptografia](serverless-encryption.md) que atribua uma Chave pertencente à AWS à coleção *livros* que você criará em uma etapa posterior.
Envie a seguinte solicitação para criar uma política de criptografia para a coleção *livros*:
```
aws opensearchserverless create-security-policy \
--name books-policy \
--type encryption --policy "{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/books\"]}],\"AWSOwnedKey\":true}"
```
**Exemplo de resposta**
```
{
"securityPolicyDetail": {
"type": "encryption",
"name": "books-policy",
"policyVersion": "MTY2OTI0MDAwNTk5MF8x",
"policy": {
"Rules": [
{
"Resource": [
"collection/books"
],
"ResourceType": "collection"
}
],
"AWSOwnedKey": true
},
"createdDate": 1669240005990,
"lastModifiedDate": 1669240005990
}
}
```
1. Crie uma [política de rede](serverless-network.md) que forneça acesso público à coleção *livros*:
```
aws opensearchserverless create-security-policy --name books-policy --type network \
--policy "[{\"Description\":\"Public access for books collection\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection\/books\"]},{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/books\"]}],\"AllowFromPublic\":true}]"
```
**Exemplo de resposta**
```
{
"securityPolicyDetail": {
"type": "network",
"name": "books-policy",
"policyVersion": "MTY2OTI0MDI1Njk1NV8x",
"policy": [
{
"Rules": [
{
"Resource": [
"collection/books"
],
"ResourceType": "dashboard"
},
{
"Resource": [
"collection/books"
],
"ResourceType": "collection"
}
],
"AllowFromPublic": true,
"Description": "Public access for books collection"
}
],
"createdDate": 1669240256955,
"lastModifiedDate": 1669240256955
}
}
```
1. Crie a coleção *livros*:
```
aws opensearchserverless create-collection --name books --type SEARCH
```
**Exemplo de resposta**
```
{
"createCollectionDetail": {
"id": "8kw362bpwg4gx9b2f6e0",
"name": "books",
"status": "CREATING",
"type": "SEARCH",
"arn": "arn:aws:aoss:us-east-1:123456789012:collection/8kw362bpwg4gx9b2f6e0",
"kmsKeyArn": "auto",
"createdDate": 1669240325037,
"lastModifiedDate": 1669240325037
}
}
```
1. Crie uma [política de acesso a dados](serverless-data-access.md) que forneça as permissões mínimas para indexar e pesquisar dados na coleção *livros*. Substitua o ARN da entidade principal pelo ARN do `TutorialRole` da etapa 1:
```
aws opensearchserverless create-access-policy \
--name books-policy \
--type data \
--policy "[{\"Rules\":[{\"ResourceType\":\"index\",\"Resource\":[\"index\/books\/books-index\"],\"Permission\":[\"aoss:CreateIndex\",\"aoss:DescribeIndex\",\"aoss:ReadDocument\",\"aoss:WriteDocument\",\"aoss:UpdateIndex\",\"aoss:DeleteIndex\"]}],\"Principal\":[\"arn:aws:iam::123456789012:role\/TutorialRole\"]}]"
```
**Exemplo de resposta**
```
{
"accessPolicyDetail": {
"type": "data",
"name": "books-policy",
"policyVersion": "MTY2OTI0MDM5NDY1M18x",
"policy": [
{
"Rules": [
{
"Resource": [
"index/books/books-index"
],
"Permission": [
"aoss:CreateIndex",
"aoss:DescribeIndex",
"aoss:ReadDocument",
"aoss:WriteDocument",
"aoss:UpdateDocument",
"aoss:DeleteDocument"
],
"ResourceType": "index"
}
],
"Principal": [
"arn:aws:iam::123456789012:role/TutorialRole"
]
}
],
"createdDate": 1669240394653,
"lastModifiedDate": 1669240394653
}
}
```
O `TutorialRole` agora deve ser capaz de indexar e pesquisar documentos na coleção *livros*.
1. Para fazer chamadas para a OpenSearch API, você precisa do endpoint da coleção. Envie a seguinte solicitação para recuperar o parâmetro `collectionEndpoint`:
```
aws opensearchserverless batch-get-collection --names books
```
**Exemplo de resposta**
```
{
"collectionDetails": [
{
"id": "8kw362bpwg4gx9b2f6e0",
"name": "books",
"status": "ACTIVE",
"type": "SEARCH",
"description": "",
"arn": "arn:aws:aoss:us-east-1:123456789012:collection/8kw362bpwg4gx9b2f6e0",
"createdDate": 1665765327107,
"collectionEndpoint": "https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com",
"dashboardEndpoint": "https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com/_dashboards"
}
],
"collectionErrorDetails": []
}
```
**nota**
Não será possível ver o endpoint da coleção até que o status da coleção mude para `ACTIVE`. Talvez seja necessário fazer várias chamadas para verificar o status até que a coleção seja criada com êxito.
1. Use uma ferramenta HTTP, como o [Postman](https://www.getpostman.com/) ou curl, para indexar dados na coleção *livros*. Criaremos um índice chamado *books-index* e adicionaremos um único documento.
Envie a solicitação a seguir para o endpoint da coleção que você recuperou na etapa anterior, usando as credenciais do `TutorialRole`.
```
PUT https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com/books-index/_doc/1
{
"title": "The Shining",
"author": "Stephen King",
"year": 1977
}
```
**Exemplo de resposta**
```
{
"_index" : "books-index",
"_id" : "1",
"_version" : 1,
"result" : "created",
"_shards" : {
"total" : 0,
"successful" : 0,
"failed" : 0
},
"_seq_no" : 0,
"_primary_term" : 0
}
```
1. Para começar a pesquisar dados em sua coleção, use a [API de pesquisa](https://opensearch.org/docs/latest/opensearch/rest-api/search/). A consulta a seguir executa uma pesquisa básica:
```
GET https://8kw362bpwg4gx9b2f6e0.us-east-1.aoss.amazonaws.com/books-index/_search
```
**Exemplo de resposta**
```
{
"took": 405,
"timed_out": false,
"_shards": {
"total": 6,
"successful": 6,
"skipped": 0,
"failed": 0
},
"hits": {
"total": {
"value": 2,
"relation": "eq"
},
"max_score": 1.0,
"hits": [
{
"_index": "books-index:0::3xJq14MBUaOS0wL26UU9:0",
"_id": "F_bt4oMBLle5pYmm5q4T",
"_score": 1.0,
"_source": {
"title": "The Shining",
"author": "Stephen King",
"year": 1977
}
}
]
}
}
```
# Identity and Access Management para Amazon OpenSearch Serverless
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* (conectado) e *autorizado* (tem permissões) para usar recursos sem OpenSearch servidor. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.
**Topics**
+ [
## Políticas baseadas em identidade para servidores sem servidor OpenSearch
](#security-iam-serverless-id-based-policies)
+ [
## Ações políticas para OpenSearch Serverless
](#security-iam-serverless-id-based-policies-actions)
+ [
## Recursos de políticas para OpenSearch Serverless
](#security-iam-serverless-id-based-policies-resources)
+ [
## Chaves de condição de política para Amazon OpenSearch Serverless
](#security_iam_serverless-conditionkeys)
+ [
## ABAC com Serverless OpenSearch
](#security_iam_serverless-with-iam-tags)
+ [
## Usando credenciais temporárias com Serverless OpenSearch
](#security_iam_serverless-tempcreds)
+ [
## Funções vinculadas a serviços para Serverless OpenSearch
](#security_iam_serverless-slr)
+ [
## Outros tipos de política
](#security_iam_access-manage-other-policies)
+ [
## Exemplos de políticas baseadas em identidade para Serverless OpenSearch
](#security_iam_serverless_id-based-policy-examples)
+ [
# Suporte do IAM Identity Center para Amazon OpenSearch Serverless
](serverless-iam-identity-center.md)
## Políticas baseadas em identidade para servidores sem servidor OpenSearch
**Compatível com políticas baseadas em identidade:** sim
As políticas baseadas em identidade são documentos de políticas de permissões JSON que podem ser anexados a uma identidade, como usuário do IAM, grupo de usuários ou perfil. Essas políticas controlam quais ações os usuários e perfis podem realizar, em quais recursos e em que 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*.
Com as políticas baseadas em identidade do IAM, é possível especificar ações e recursos permitidos ou negados, assim como as condições sob as quais as ações são permitidas ou negadas. Para saber mais sobre todos os elementos que podem ser usados em uma política JSON, consulte [Referência de elemento de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *Guia do usuário do IAM*.
### Exemplos de políticas baseadas em identidade para Serverless OpenSearch
Para ver exemplos de políticas baseadas em identidade OpenSearch sem servidor, consulte. [Exemplos de políticas baseadas em identidade para Serverless OpenSearch](#security_iam_serverless_id-based-policy-examples)
## Ações políticas para OpenSearch Serverless
**Compatível com ações de políticas:** sim
O elemento `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. As ações de política geralmente têm o mesmo nome da operação de AWS API associada. Existem algumas exceções, como *ações somente de permissão*, que não têm uma operação de API correspondente. Algumas operações também exigem várias ações em uma política. Essas ações adicionais são chamadas de *ações dependentes*.
Incluem ações em uma política para conceder permissões para executar a operação associada.
As ações de política no OpenSearch Serverless usam o seguinte prefixo antes da ação:
```
aoss
```
Para especificar várias ações em uma única declaração, separe-as com vírgulas.
```
"Action": [
"aoss:action1",
"aoss:action2"
]
```
É possível especificar várias ações usando caracteres curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `Describe`, inclua a seguinte ação:
```
"Action": "aoss:List*"
```
Para ver exemplos de políticas baseadas em identidade OpenSearch sem servidor, consulte. [Exemplos de políticas baseadas em identidade para Serverless OpenSearch](#security_iam_id-based-policy-examples)
## Recursos de políticas para OpenSearch Serverless
**Compatível com recursos de políticas:** sim
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento de política JSON `Resource` especifica o objeto ou os objetos aos quais a ação se aplica. Como prática recomendada, especifique um recurso usando seu [nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html). Para ações que não oferecem compatibilidade com permissões em nível de recurso, use um curinga (\$1) para indicar que a instrução se aplica a todos os recursos.
```
"Resource": "*"
```
## Chaves de condição de política para Amazon OpenSearch Serverless
**Compatível com chaves de condição de política específicas de serviço:** sim
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição AWS globais, consulte as [chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
Além do controle de acesso baseado em atributos (ABAC), o OpenSearch Serverless oferece suporte às seguintes chaves de condição:
+ `aoss:collection`
+ `aoss:CollectionId`
+ `aoss:index`
É possível usar essas chaves de condição mesmo ao fornecer permissões para políticas de acesso e políticas de segurança. Por exemplo:
```
[
{
"Effect":"Allow",
"Action":[
"aoss:CreateAccessPolicy",
"aoss:CreateSecurityPolicy"
],
"Resource":"*",
"Condition":{
"StringLike":{
"aoss:collection":"log"
}
}
}
]
```
Neste exemplo, a condição se aplica às políticas que contenham *regras* que correspondam a um nome ou padrão de coleção. As condições têm o seguinte comportamento:
+ `StringEquals`: aplica-se a políticas com regras que contenham a string de recurso “log” *exata* (ou seja, `collection/log`).
+ `StringLike`: aplica-se a políticas com regras que contenham uma string de recurso que *inclua* a string “log” (ou seja, `collection/log`, mas também `collection/logs-application` ou `collection/applogs123`).
**nota**
As chaves de condição *coleção* não se aplicam ao nível do índice. Por exemplo, na política acima, a condição não se aplicaria a uma política de acesso ou segurança contendo a string de recurso `index/logs-application/*`.
*Para ver uma lista de chaves de condição OpenSearch sem servidor, consulte [Chaves de condição para Amazon OpenSearch Serverless](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonopensearchserverless.html#amazonopensearchserverless-policy-keys) na Referência de autorização de serviço.* Para saber com quais ações e recursos você pode usar uma chave de condição, consulte [Ações definidas pelo Amazon OpenSearch Serverless](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonopensearchserverless.html#amazonopensearchserverless-actions-as-permissions).
## ABAC com Serverless OpenSearch
**Compatível com ABAC (tags em políticas):** sim
O controle de acesso por atributo (ABAC) é uma estratégia de autorização que define permissões com base em atributos chamados de tags. Você pode anexar tags a entidades e AWS recursos do IAM e, em seguida, criar políticas ABAC para permitir operações quando a tag do diretor corresponder à tag no recurso.
Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `aws:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`.
Se um serviço for compatível com as três chaves de condição para cada tipo de recurso, o valor será **Sim** para o serviço. Se um serviço for compatível com as três chaves de condição somente para alguns tipos de recursos, o valor será **Parcial**
Para saber mais sobre o ABAC, consulte [Definir permissões com autorização do ABAC](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html) no *Guia do usuário do IAM*. Para visualizar um tutorial com etapas para configurar o ABAC, consulte [Usar controle de acesso por atributo (ABAC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_attribute-based-access-control.html) no *Guia do usuário do IAM*.
Para obter mais informações sobre a marcação de recursos OpenSearch sem servidor, consulte. [Marcação de coleções Amazon OpenSearch Serverless](tag-collection.md)
## Usando credenciais temporárias com Serverless OpenSearch
**Compatível com credenciais temporárias:** sim
As credenciais temporárias fornecem acesso de curto prazo aos AWS recursos e são criadas automaticamente quando você usa a federação ou troca de funções. AWS recomenda que você gere credenciais temporárias dinamicamente em vez de usar chaves de acesso de longo prazo. Para ter mais informações, consulte [Credenciais de segurança temporárias no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) e [Serviços da Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
## Funções vinculadas a serviços para Serverless OpenSearch
**Compatibilidade com perfis vinculados a serviços:** sim
Uma função vinculada ao serviço é um tipo de função de serviço vinculada a um. AWS service (Serviço da AWS) O serviço pode assumir o perfil de executar uma ação em seu nome. As funções vinculadas ao serviço aparecem em você Conta da AWS e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não editar as permissões para perfis vinculados ao serviço.
Para obter detalhes sobre como criar e gerenciar funções vinculadas a serviços OpenSearch sem servidor, consulte. [Usando funções vinculadas a serviços para criar OpenSearch coleções sem servidor](serverless-service-linked-roles.md)
## Outros tipos de política
AWS oferece suporte a tipos de políticas adicionais menos comuns. Esses tipos de política podem definir o máximo de permissões concedidas a você pelos tipos de política mais comuns.
+ **Políticas de controle de serviço (SCPs)** — SCPs são políticas JSON que especificam as permissões máximas para uma organização ou unidade organizacional (OU) em AWS 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 [Políticas de controle de serviços](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) no *Guia AWS Organizations do Usuário*.
+ **Políticas de controle de recursos (RCPs)** — RCPs são políticas JSON que você pode usar para definir o máximo de permissões disponíveis para recursos em suas contas sem atualizar as políticas do IAM anexadas a cada recurso que você possui. A RCP limita as permissões para recursos nas contas-membro e pode afetar as permissões efetivas para identidades, incluindo o usuário-raiz da conta da AWS , independentemente de pertencerem a sua organização. Para obter mais informações sobre Organizations e RCPs, incluindo uma lista de AWS serviços que oferecem suporte RCPs, consulte [Políticas de controle de recursos (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) no *Guia AWS Organizations do usuário*.
## Exemplos de políticas baseadas em identidade para Serverless OpenSearch
Por padrão, usuários e funções não têm permissão para criar ou modificar recursos OpenSearch sem servidor. Para conceder permissão aos usuários para executar ações nos recursos que eles precisam, um administrador do IAM pode criar políticas do IAM.
Para aprender a criar uma política baseada em identidade do IAM ao usar esses documentos de política em JSON de exemplo, consulte [Criar políticas do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) no *Guia do usuário do IAM*.
*Para obter detalhes sobre ações e tipos de recursos definidos pelo Amazon OpenSearch Serverless, incluindo o formato de cada um dos ARNs tipos de recursos, consulte [Ações, recursos e chaves de condição do Amazon OpenSearch Serverless](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonopensearchserverless.html) na Referência de Autorização de Serviço.*
**Topics**
+ [
### Melhores práticas de políticas
](#security_iam_serverless-policy-best-practices)
+ [
### Usando o OpenSearch Serverless no console
](#security_iam_serverless_id-based-policy-examples-console)
+ [
### Administrando coleções sem OpenSearch servidor
](#security_iam_id-based-policy-examples-collection-admin)
+ [
### Visualizando OpenSearch coleções sem servidor
](#security_iam_id-based-policy-examples-view-collections)
+ [
### Usando operações OpenSearch de API
](#security_iam_id-based-policy-examples-data-plane)
+ [
### ABAC para operações de OpenSearch API
](#security_iam_id-based-policy-examples-data-plane-abac)
### Melhores práticas de políticas
As políticas baseadas em identidade são muito poderosas. Eles determinam se alguém pode criar, acessar ou excluir recursos OpenSearch sem servidor em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir recursos OpenSearch sem servidor em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas AWS gerenciadas e avance para as permissões de privilégios mínimos — Para começar a conceder permissões** aos seus usuários e cargas de trabalho, use as *políticas AWS gerenciadas* que concedem permissões para muitos casos de uso comuns. Eles estão disponíveis no seu Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo AWS cliente que sejam específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Você também pode usar condições para conceder acesso às ações de serviço se elas forem usadas por meio de uma ação específica AWS service (Serviço da AWS), como CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA**) — Se você tiver um cenário que exija usuários do IAM ou um usuário root, ative Conta da AWS a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.
Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
### Usando o OpenSearch Serverless no console
Para acessar o OpenSearch Serverless no console OpenSearch de serviço, você deve ter um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre os recursos OpenSearch sem servidor em sua AWS conta. Se você criar uma política baseada em identidade que seja mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para entidades (como perfis do IAM) com essa política.
Você não precisa permitir permissões mínimas do console para usuários que estão fazendo chamadas somente para a API AWS CLI ou para a AWS API. Em vez disso, permita o acesso somente às ações que corresponderem a operação da API que você estiver tentando executar.
A política a seguir permite que um usuário acesse o OpenSearch Serverless no console de OpenSearch serviço:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Resource": "*",
"Effect": "Allow",
"Action": [
"aoss:ListCollections",
"aoss:BatchGetCollection",
"aoss:ListAccessPolicies",
"aoss:ListSecurityConfigs",
"aoss:ListSecurityPolicies",
"aoss:ListTagsForResource",
"aoss:ListVpcEndpoints",
"aoss:GetAccessPolicy",
"aoss:GetAccountSettings",
"aoss:GetSecurityConfig",
"aoss:GetSecurityPolicy"
]
}
]
}
```
------
### Administrando coleções sem OpenSearch servidor
Essa política é um exemplo de política de “administrador de coleções” que permite ao usuário gerenciar e administrar coleções Amazon OpenSearch Serverless. O usuário pode criar, exibir e excluir coleções.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Resource": "arn:aws:aoss:us-east-1:111122223333:collection/*",
"Action": [
"aoss:CreateCollection",
"aoss:DeleteCollection",
"aoss:UpdateCollection"
],
"Effect": "Allow"
},
{
"Resource": "*",
"Action": [
"aoss:BatchGetCollection",
"aoss:ListCollections",
"aoss:CreateAccessPolicy",
"aoss:CreateSecurityPolicy"
],
"Effect": "Allow"
}
]
}
```
------
### Visualizando OpenSearch coleções sem servidor
Este exemplo de política permite que um usuário visualize detalhes de todas as coleções Amazon OpenSearch Serverless em sua conta. O usuário não pode modificar as coleções nem as políticas de segurança associadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Resource": "*",
"Action": [
"aoss:ListAccessPolicies",
"aoss:ListCollections",
"aoss:ListSecurityPolicies",
"aoss:ListTagsForResource",
"aoss:BatchGetCollection"
],
"Effect": "Allow"
}
]
}
```
------
### Usando operações OpenSearch de API
As operações da API do plano de dados consistem nas funções que você usa no OpenSearch Serverless para obter valor em tempo real do serviço. As operações da API do ambiente de gerenciamento consistem nas funções que você usa para configurar o ambiente.
Para acessar o plano de dados APIs e os OpenSearch painéis do Amazon OpenSearch Serverless a partir do navegador, você precisa adicionar duas permissões do IAM para recursos de coleta. Essas permissões são `aoss:APIAccessAll` e `aoss:DashboardsAccessAll`.
**nota**
A partir de 10 de maio de 2023, o OpenSearch Serverless exige essas duas novas permissões do IAM para recursos de coleta. A `aoss:APIAccessAll` permissão permite o acesso ao plano de dados e a `aoss:DashboardsAccessAll` permissão permite OpenSearch painéis a partir do navegador. A falha na adição das duas novas permissões do IAM resulta em um erro 403.
Este exemplo de política permite que um usuário acesse o plano APIs de dados de uma coleção específica em sua conta e acesse os OpenSearch painéis de todas as coleções em sua conta.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "aoss:APIAccessAll",
"Resource": "arn:aws:aoss:us-east-1:111122223333:collection/collection-id"
},
{
"Effect": "Allow",
"Action": "aoss:DashboardsAccessAll",
"Resource": "arn:aws:aoss:us-east-1:111122223333:dashboards/default"
}
]
}
```
------
Ambos `aoss:APIAccessAll` `aoss:DashboardsAccessAll` fornecem permissão total do IAM aos recursos da coleção, enquanto a permissão Dashboards também fornece acesso aos OpenSearch painéis. Cada permissão funciona de forma independente, portanto, uma negação explícita de `aoss:APIAccessAll` não bloqueia o acesso aos recursos de `aoss:DashboardsAccessAll`, incluindo as Ferramentas de desenvolvimento. O mesmo vale para uma negação`aoss:DashboardsAccessAll`. OpenSearch O Serverless oferece suporte às seguintes chaves de condição globais:
+ `aws:CalledVia`
+ `aws:CalledViaAWSService`
+ `aws:CalledViaFirst`
+ `aws:CalledViaLast`
+ `aws:CurrentTime`
+ `aws:EpochTime`
+ `aws:PrincipalAccount`
+ `aws:PrincipalArn`
+ `aws:PrincipallsAWSService`
+ `aws:PrincipalOrgID`
+ `aws:PrincipalOrgPaths`
+ `aws:PrincipalType`
+ `aws:PrincipalServiceName`
+ `aws:PrincipalServiceNamesList`
+ `aws:ResourceAccount`
+ `aws:ResourceOrgID`
+ `aws:ResourceOrgPaths`
+ `aws:RequestedRegion`
+ `aws:ResourceTag`
+ `aws:SourceIp`
+ `aws:SourceVpce`
+ `aws:SourceVpc`
+ `aws:userid`
+ `aws:username`
+ `aws:VpcSourceIp`
O seguinte exemplo mostra o uso de `aws:SourceIp` no bloco de condição da política do IAM da entidade principal para chamadas ao plano de dados:
```
"Condition": {
"IpAddress": {
"aws:SourceIp": "203.0.113.0"
}
}
```
O seguinte exemplo mostra o uso de `aws:SourceVpc` no bloco de condição da política do IAM da entidade principal para chamadas ao plano de dados:
```
"Condition": {
"StringEquals": {
"aws:SourceVpc": "vpc-0fdd2445d8EXAMPLE"
}
}
```
Além disso, é oferecido suporte para as seguintes chaves específicas do OpenSearch Serverless:
+ `aoss:CollectionId`
+ `aoss:collection`
O seguinte exemplo mostra o uso de `aoss:collection` no bloco de condição da política do IAM da entidade principal para chamadas ao plano de dados:
```
"Condition": {
"StringLike": {
"aoss:collection": "log-*"
}
}
```
### ABAC para operações de OpenSearch API
As políticas baseadas em identidade permitem que você use tags para controlar o acesso ao plano de dados Amazon OpenSearch Serverless. APIs A política a seguir é um exemplo para permitir que diretores anexados acessem o plano de dados APIs se a coleção tiver a `team:devops` tag:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "aoss:APIAccessAll",
"Resource": "arn:aws:aoss:us-east-1:111122223333:collection/collection-id",
"Condition": {
"StringEquals": {
"aws:ResourceTag/team": "devops"
}
}
}
]
}
```
------
A política a seguir é um exemplo para negar que diretores anexados acessem o plano de dados APIs e o acesso aos painéis se a coleção tiver a `environment:production` tag:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"aoss:APIAccessAll",
"aoss:DashboardsAccessAll"
],
"Resource": "arn:aws:aoss:us-east-1:111122223333:collection/collection-id"
}
]
}
```
------
O Amazon OpenSearch Serverless não oferece suporte a chaves `RequestTag` de condição `TagKeys` globais para planos de dados. APIs
# Suporte do IAM Identity Center para Amazon OpenSearch Serverless
## Suporte do IAM Identity Center para Amazon OpenSearch Serverless
Você pode usar os diretores do IAM Identity Center (usuários e grupos) para acessar dados do Amazon OpenSearch Serverless por meio dos Amazon Applications. OpenSearch Para habilitar o suporte do IAM Identity Center para Amazon OpenSearch Serverless, você precisará habilitar o uso do IAM Identity Center. Para saber mais sobre como fazer isso, consulte [O que é o IAM Identity?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)
**nota**
Para acessar as coleções do Amazon OpenSearch Serverless usando usuários ou grupos do IAM Identity Center, você deve usar o recurso OpenSearch UI (Applications). O acesso direto aos painéis OpenSearch sem servidor usando as credenciais do IAM Identity Center não é suportado. Para obter mais informações, consulte [Introdução à interface do OpenSearch usuário](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/application.html).
Depois que a instância do IAM Identity Center é criada, o administrador da conta do cliente precisa criar um aplicativo do IAM Identity Center para o OpenSearch serviço Amazon Serverless. Isso pode ser feito chamando o [CreateSecurityConfig:](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateSecurityConfig.html). O administrador da conta de cliente pode especificar quais atributos serão usados para autorizar a solicitação. Os atributos padrão usados são `UserId` e `GroupId.`
A integração do IAM Identity Center para o Amazon OpenSearch Serverless usa as seguintes permissões AWS do IAM Identity Center (IAM):
+ `aoss:CreateSecurityConfig`: criar um provedor do IAM Identity Center
+ `aoss:ListSecurityConfig`: listar todos os provedores do IAM Identity Center na conta atual.
+ `aoss:GetSecurityConfig`: visualizar informações do provedor do IAM Identity Center.
+ `aoss:UpdateSecurityConfig`: modificar uma determinada configuração do IAM Identity Center
+ `aoss:DeleteSecurityConfig`: excluir um provedor do IAM Identity Center
A seguinte política de acesso baseada em identidade pode ser usada para gerenciar todas as configurações do IAM Identity Center:
------
#### [ JSON ]
****
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"aoss:CreateSecurityConfig",
"aoss:DeleteSecurityConfig",
"aoss:GetSecurityConfig",
"aoss:UpdateSecurityConfig",
"aoss:ListSecurityConfigs"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**nota**
O elemento `Resource` deve ser um caractere curinga.
## Criar um provedor do IAM Identity Center (console)
Você pode criar um provedor do IAM Identity Center para habilitar a autenticação com o OpenSearch aplicativo. Para habilitar a autenticação do IAM Identity Center para OpenSearch painéis, execute as seguintes etapas:
1. Faça login no [console do Amazon OpenSearch Service](https://console.aws.amazon.com/aos/home.).
1. No painel de navegação à esquerda, expanda **Tecnologia sem servidor** e escolha **Autenticação**.
1. Escolha **Autenticação do IAM Identity Center**.
1. Selecione **Editar**
1. Marque a caixa ao lado de Autenticar com o IAM Identity Center.
1. Selecione a chave de atributo **usuário e grupo** no menu suspenso. Os atributos de usuário serão usados para autorizar usuários com base em `UserName`, `UserId` e `Email`. Os atributos de usuário serão usados para autorizar usuário com base em `GroupName` e `GroupId`.
1. Selecione a instância do **IAM Identity Center**.
1. Selecione **Salvar**.
## Criar provedor do IAM Identity Center (AWS CLI)
Para criar um provedor do IAM Identity Center usando o AWS Command Line Interface (AWS CLI), use o seguinte comando:
```
aws opensearchserverless create-security-config \
--region us-east-2 \
--name "iamidentitycenter-config" \
--description "description" \
--type "iamidentitycenter" \
--iam-identity-center-options '{
"instanceArn": "arn:aws:sso:::instance/ssoins-99199c99e99ee999",
"userAttribute": "UserName",
"groupAttribute": "GroupId"
}'
```
Depois que um IAM Identity Center é habilitado, os clientes somente podem modificar os atributos de **usuário e grupo**.
```
aws opensearchserverless update-security-config \
--region us-east-1 \
--id \
--config-version \
--iam-identity-center-options-updates '{
"userAttribute": "UserId",
"groupAttribute": "GroupId"
}'
```
Para visualizar o provedor do IAM Identity Center usando o AWS Command Line Interface, use o seguinte comando:
```
aws opensearchserverless list-security-configs --type iamidentitycenter
```
## Excluir provedor do IAM Identity Center
O IAM Identity Center oferece duas instâncias de provedores, uma para a conta da organização e outra para a sua conta de membro. Se precisar alterar a instância do IAM Identity Center, você terá que excluir a configuração de segurança por meio da API `DeleteSecurityConfig` e criar uma nova configuração de segurança usando a nova instância do IAM Identity Center. O seguinte comando pode ser usado para excluir um provedor do IAM Identity Center:
```
aws opensearchserverless delete-security-config \
--region us-east-1 \
--id
```
## Conceder ao IAM Identity Center acesso a dados de coleção
Depois que o provedor do IAM Identity Center está habilitado, você pode atualizar a política de acesso a dados da coleção para incluir as entidades principais do IAM Identity Center. As entidades principais do IAM Identity Center precisam ser atualizadas no seguinte formato:
```
[
{
"Rules":[
...
],
"Principal":[
"iamidentitycenter//user/",
"iamidentitycenter//group/"
]
}
]
```
**nota**
O Amazon OpenSearch Serverless oferece suporte a apenas uma instância do IAM Identity Center para todas as coleções de clientes e pode suportar até 100 grupos para um único usuário. Se você tentar usar mais do que o número permitido de instâncias, terá inconsistência no processamento da autorização da política de acesso a dados e receberá uma mensagem de erro `403`.
É possível conceder acesso a coleções, índices ou ambos. Se você quiser que usuários diferentes tenham permissões diferentes, precisará criar várias regras. Para obter uma lista das permissões disponíveis, consulte [Identity and Access Management no Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/ac.html). Para obter informações sobre como formatar uma política de acesso, consulte [Conceder a identidades SAML acesso a dados de coleções](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-saml.html#serverless-saml-policies).
# Criptografia no Amazon OpenSearch Serverless
## Criptografia em repouso
Cada coleção Amazon OpenSearch Serverless que você cria é protegida com criptografia de dados em repouso, um recurso de segurança que ajuda a impedir o acesso não autorizado aos seus dados. A criptografia em repouso usa AWS Key Management Service (AWS KMS) para armazenar e gerenciar suas chaves de criptografia. Ela usa o algoritmo Advanced Encryption Standard com chaves de 256 bits (AES-256) para executar a criptografia.
**Topics**
+ [
### Políticas de criptografia
](#serverless-encryption-policies)
+ [
### Considerações
](#serverless-encryption-considerations)
+ [
### Permissões obrigatórias
](#serverless-encryption-permissions)
+ [
### Política de chaves para uma chave gerenciada pelo cliente
](#serverless-customer-cmk-policy)
+ [
### Como o OpenSearch Serverless usa subsídios em AWS KMS
](#serverless-encryption-grants)
+ [
### Criação de políticas de criptografia (console)
](#serverless-encryption-console)
+ [
### Criação de políticas de criptografia (AWS CLI)
](#serverless-encryption-cli)
+ [
### Exibição de políticas de criptografia
](#serverless-encryption-list)
+ [
### Atualização de políticas de criptografia
](#serverless-encryption-update)
+ [
### Exclusão de políticas de criptografia
](#serverless-encryption-delete)
### Políticas de criptografia
Com as políticas de criptografia, é possível gerenciar várias coleções em grande escala atribuindo automaticamente uma chave de criptografia às coleções recém-criadas que correspondam a um nome ou padrão específico.
Ao criar uma política de criptografia, é possível especificar um *prefixo*, que é uma regra de correspondência baseada em curingas, como `MyCollection*`, ou inserir um único nome de coleção. Em seguida, quando você criar uma coleção que corresponda a esse padrão de nome ou prefixo, a política e a chave do KMS correspondente serão automaticamente atribuídas a ela.
Ao criar uma coleção, você pode especificar uma AWS KMS chave de duas maneiras: por meio de políticas de segurança ou diretamente na `CreateCollection` solicitação. Se você fornecer uma AWS KMS chave como parte da `CreateCollection` solicitação, ela terá precedência sobre qualquer política de segurança correspondente. Com essa abordagem, você tem a flexibilidade de substituir as configurações de criptografia baseadas em políticas para coleções específicas quando necessário.
![\[Encryption policy creation process with rules and collection matching to KMS key.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-encryption.png)
As políticas de criptografia contêm os seguintes elementos:
+ `Rules`: uma ou mais regras de correspondência de coleções, cada uma com os seguintes subelementos:
+ `ResourceType`: no momento, a única opção é “collection” (coleção). As políticas de criptografia se aplicam somente aos recursos de coleção.
+ `Resource`: um ou mais nomes ou padrões de coleção aos quais a política será aplicada, no formato `collection/`.
+ `AWSOwnedKey`: opção de uso de uma Chave pertencente à AWS.
+ `KmsARN`: se você definir `AWSOwnedKey` como falso, especifique o nome do recurso da Amazon (ARN) da chave do KMS com a qual criptografar as coleções associadas. Se você incluir esse parâmetro, o OpenSearch Serverless ignorará o parâmetro. `AWSOwnedKey`
O exemplo de política a seguir atribuirá uma chave gerenciada pelo cliente a qualquer coleção futura denominada `autopartsinventory`, bem como às coleções que comecem com o termo “sales” (vendas):
```
{
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/autopartsinventory",
"collection/sales*"
]
}
],
"AWSOwnedKey":false,
"KmsARN":"arn:aws:kms:us-east-1:123456789012:key/93fd6da4-a317-4c17-bfe9-382b5d988b36"
}
```
Mesmo que uma política corresponda a um nome de coleção, é possível optar por substituir essa atribuição automática durante a criação da coleção se o padrão do recurso contiver um caractere curinga (\$1). Se você optar por substituir a atribuição automática de chaves, o OpenSearch Serverless cria uma política de criptografia para você chamada **auto-< *collection-name* >** e a anexa à coleção. Inicialmente, a política só se aplica a uma única coleção, mas é possível modificá-la para incluir coleções adicionais.
Se você modificar as regras de política para que não correspondam mais a uma coleção, a chave do KMS associada não terá a atribuição a essa coleção cancelada. A coleção permanece sempre criptografada com sua chave de criptografia inicial. Se você desejar alterar a chave de criptografia de uma coleção, deverá recriar a coleção.
Se as regras de várias políticas corresponderem a uma coleção, a regra mais específica será usada. Por exemplo, se uma política contiver uma regra para `collection/log*` e outra para `collection/logSpecial`, a chave de criptografia da segunda política será usada porque é mais específica.
Você não pode usar um nome ou prefixo em uma política se ela já existir em outra política. OpenSearch O Serverless exibirá um erro se você tentar configurar padrões de recursos idênticos em políticas de criptografia diferentes.
### Considerações
Considere o seguinte ao configurar a criptografia de suas coleções:
+ A criptografia em repouso é *obrigatória* para todas as coleções do Sem Servidor.
+ Você tem a opção de usar uma chave gerenciada pelo cliente ou uma Chave pertencente à AWS. Se você escolher uma chave gerenciada pelo cliente, recomendamos habilitar a [rotação automática de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html).
+ Não é possível alterar a chave de criptografia de uma coleção depois que a coleção é criada. Escolha cuidadosamente qual AWS KMS usar na primeira vez que você configura uma coleção.
+ Uma coleção só pode corresponder a uma única política de criptografia.
+ Coleções com chaves KMS exclusivas não podem compartilhar Unidades de OpenSearch Computação (OCUs) com outras coleções. Cada coleção com uma chave exclusiva requer suas próprias 4 OCUs.
+ Se você atualizar a chave do KMS em uma política de criptografia, a alteração não afetará as coleções correspondentes existentes com as chaves do KMS já atribuídas.
+ OpenSearch O Serverless não verifica explicitamente as permissões do usuário nas chaves gerenciadas pelo cliente. Se um usuário tiver permissões para acessar uma coleção por meio de uma política de acesso a dados, ele poderá ingerir e consultar os dados criptografados com a chave associada.
### Permissões obrigatórias
A criptografia em repouso para OpenSearch Serverless usa as seguintes permissões AWS Identity and Access Management (IAM). É possível especificar as condições do IAM para restringir os usuários a coleções específicas.
+ `aoss:CreateSecurityPolicy`: cria uma política de criptografia.
+ `aoss:ListSecurityPolicies`: lista todas as políticas e coleções de criptografia às quais elas estão vinculadas.
+ `aoss:GetSecurityPolicy`: exibe os detalhes de uma política de criptografia específica.
+ `aoss:UpdateSecurityPolicy`: modifica uma política de criptografia.
+ `aoss:DeleteSecurityPolicy`: exclui uma política de criptografia.
O exemplo a seguir de política de acesso baseada em identidade fornece as permissões mínimas necessárias para que um usuário gerencie políticas de criptografia com o padrão de recursos `collection/application-logs`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"aoss:CreateSecurityPolicy",
"aoss:UpdateSecurityPolicy",
"aoss:DeleteSecurityPolicy",
"aoss:GetSecurityPolicy"
],
"Resource":"*",
"Condition":{
"StringEquals":{
"aoss:collection":"application-logs"
}
}
},
{
"Effect":"Allow",
"Action":[
"aoss:ListSecurityPolicies"
],
"Resource":"*"
}
]
}
```
------
### Política de chaves para uma chave gerenciada pelo cliente
Se você selecionar uma [chave gerenciada pelo cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) para proteger uma coleção, a OpenSearch Serverless obterá permissão para usar a chave KMS em nome do diretor que faz a seleção. Esse diretor, um usuário ou uma função, deve ter as permissões na chave KMS que o OpenSearch Serverless exige. É possível fornecer essas permissões em uma [política de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) ou em uma [política do IAM](https://docs.aws.amazon.com/kms/latest/developerguide/iam-policies.html).
OpenSearch O Serverless faz `GenerateDataKey` e faz chamadas à API `Decrypt` KMS durante operações de manutenção, como escalonamento automático e atualizações de software. Você pode observar essas chamadas fora dos padrões de tráfego típicos. Essas chamadas fazem parte das operações normais do serviço e não indicam tráfego ativo de usuários.
OpenSearch O Serverless gera um `KMSKeyInaccessibleException` quando não consegue acessar a chave KMS que criptografa seus dados em repouso. Isso ocorre quando você desativa ou exclui a chave KMS ou revoga as concessões que permitem que o OpenSearch Serverless use a chave.
No mínimo, o OpenSearch Serverless exige as seguintes permissões em uma chave gerenciada pelo cliente:
+ [kms: DescribeKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html)
+ [kms: CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)
Por exemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "kms:DescribeKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Dale"
},
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": "aoss.us-east-1.amazonaws.com"
}
}
},
{
"Action": "kms:CreateGrant",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/Dale"
},
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": "aoss.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey"
]
},
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
}
]
}
```
------
OpenSearch [Sem servidor, crie uma concessão com as permissões [kms: GenerateDataKey e kms:decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html).](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
Para saber mais, consulte [Uso de políticas de chaves no AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) no *Guia do desenvolvedor do AWS Key Management Service *.
### Como o OpenSearch Serverless usa subsídios em AWS KMS
OpenSearch O Serverless exige uma [concessão](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) para usar uma chave gerenciada pelo cliente.
Quando você cria uma política de criptografia em sua conta com uma nova chave, o OpenSearch Serverless cria uma concessão em seu nome enviando uma [CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)solicitação para. AWS KMS As concessões AWS KMS são usadas para dar acesso OpenSearch sem servidor a uma chave KMS em uma conta de cliente.
OpenSearch O Serverless exige que a concessão use sua chave gerenciada pelo cliente para as seguintes operações internas:
+ Envie [DescribeKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html)solicitações AWS KMS para verificar se a ID simétrica da chave gerenciada pelo cliente fornecida é válida.
+ Envie [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)solicitações para a chave KMS para criar chaves de dados com as quais criptografar objetos.
+ Envie solicitações de [descriptografia para AWS KMS descriptografar](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) as chaves de dados criptografadas para que elas possam ser usadas para criptografar seus dados.
É possível revogar o acesso à concessão, ou remover o acesso do serviço à chave gerenciada pelo cliente a qualquer momento. Se você fizer isso, o OpenSearch Serverless não poderá acessar nenhum dos dados criptografados pela chave gerenciada pelo cliente, o que afeta todas as operações que dependem desses dados, levando a `AccessDeniedException` erros e falhas nos fluxos de trabalho assíncronos.
OpenSearch O Serverless retira as concessões em um fluxo de trabalho assíncrono quando uma determinada chave gerenciada pelo cliente não está associada a nenhuma política ou coleção de segurança.
### Criação de políticas de criptografia (console)
Em uma política de criptografia, você especifica uma chave do KMS e uma série de padrões de coleção aos quais a política se aplicará. Qualquer nova coleção que corresponda a um dos padrões definidos na política receberá a chave do KMS correspondente quando você criar a coleção. Recomendamos que você crie políticas de criptografia *antes* de começar a criar coleções.
**Para criar uma política de criptografia OpenSearch sem servidor**
1. Abra o console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home).
1. No painel de navegação à esquerda, expanda **Sem Servidor** e escolha **Políticas de criptografia**.
1. Escolha **Criar política de criptografia**.
1. Forneça um nome e uma descrição para a política.
1. Em **Recursos**, insira um ou mais padrões de recursos para essa política de criptografia. Todas as coleções recém-criadas na Conta da AWS e região atual que correspondam a um dos padrões serão automaticamente atribuídas a essa política. Por exemplo, se você inserir `ApplicationLogs` (sem nenhum curinga) e depois criar uma coleção com esse nome, a política e a chave do KMS correspondente serão atribuídas a essa coleção.
Você também pode fornecer um prefixo como `Logs*`, que atribuirá a política a qualquer nova coleção com nomes começando com `Logs`. Usando curingas, é possível gerenciar as configurações de criptografia para várias coleções em grande escala.
1. Em **Criptografia**, escolha uma chave do KMS para usar.
1. Escolha **Criar**.
#### Próxima etapa: criar coleções
Depois de configurar uma ou mais políticas de criptografia, será possível começar a criar coleções que correspondam às regras definidas nessas políticas. Para instruções, consulte [Criação de coleções](serverless-create.md).
Na etapa **Criptografias** da criação da coleção, o OpenSearch Serverless informa que o nome inserido corresponde ao padrão definido em uma política de criptografia e atribui automaticamente a chave KMS correspondente à coleção. Se o padrão do recurso contiver um curinga (\$1), será possível optar por substituir a correspondência e selecionar sua própria chave.
### Criação de políticas de criptografia (AWS CLI)
Para criar uma política de criptografia usando as operações da API OpenSearch Serverless, você especifica padrões de recursos e uma chave de criptografia no formato JSON. A [CreateSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateSecurityPolicy.html)solicitação aceita políticas embutidas e arquivos.json.
As políticas de criptografia têm o formato a seguir. Esse arquivo `my-policy.json` de exemplo corresponde a qualquer coleção futura denominada `autopartsinventory`, bem como a qualquer coleção com nomes iniciando por `sales`.
```
{
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/autopartsinventory",
"collection/sales*"
]
}
],
"AWSOwnedKey":false,
"KmsARN":"arn:aws:kms:us-east-1:123456789012:key/93fd6da4-a317-4c17-bfe9-382b5d988b36"
}
```
Para usar uma chave de propriedade do serviço, defina `AWSOwnedKey` como `true`:
```
{
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/autopartsinventory",
"collection/sales*"
]
}
],
"AWSOwnedKey":true
}
```
A solicitação a seguir cria a política de criptografia:
```
aws opensearchserverless create-security-policy \
--name sales-inventory \
--type encryption \
--policy file://my-policy.json
```
Em seguida, use a operação da [CreateCollection](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateCollection.html)API para criar uma ou mais coleções que correspondam a um dos padrões de recursos.
### Exibição de políticas de criptografia
Antes de criar uma coleção, talvez você queira pré-visualizar as políticas de criptografia existentes em sua conta para ver qual delas tem um padrão de recurso que corresponda ao nome da sua coleção. A [ListSecurityPolicies](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_ListSecurityPolicies.html)solicitação a seguir lista todas as políticas de criptografia em sua conta:
```
aws opensearchserverless list-security-policies --type encryption
```
A solicitação retorna informações sobre todas as políticas de criptografia configuradas. Use o conteúdo do elemento `policy` para visualizar as regras de padrões definidas na política:
```
{
"securityPolicyDetails": [
{
"createdDate": 1663693217826,
"description": "Sample encryption policy",
"lastModifiedDate": 1663693217826,
"name": "my-policy",
"policy": "{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection/autopartsinventory\",\"collection/sales*\"]}],\"AWSOwnedKey\":true}",
"policyVersion": "MTY2MzY5MzIxNzgyNl8x",
"type": "encryption"
}
]
}
```
Para ver informações detalhadas sobre uma política específica, incluindo a chave KMS, use o [GetSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_GetSecurityPolicy.html)comando.
### Atualização de políticas de criptografia
Se você atualizar a chave do KMS em uma política de criptografia, a alteração só se aplicará às coleções recém-criadas que correspondam ao nome ou padrão configurado. Isso não afeta as coleções existentes que já tenham chaves do KMS atribuídas.
O mesmo se aplica às regras de correspondência das políticas. Se você adicionar, modificar ou excluir uma regra, a alteração só se aplicará às coleções recém-criadas. As coleções existentes não perdem suas chaves do KMS atribuídas se você modificar as regras de uma política para que ela não corresponda mais ao nome de uma coleção.
**Para atualizar uma política de criptografia no console OpenSearch sem servidor, escolha **Políticas de criptografia**, selecione a política a ser modificada e escolha Editar.** Faça suas alterações e escolha **Salvar**.
Para atualizar uma política de criptografia usando a API OpenSearch Serverless, use a [UpdateSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_UpdateSecurityPolicy.html)operação. A solicitação a seguir atualiza uma política de criptografia com um novo documento JSON de política:
```
aws opensearchserverless update-security-policy \
--name sales-inventory \
--type encryption \
--policy-version 2 \
--policy file://my-new-policy.json
```
### Exclusão de políticas de criptografia
Quando você exclui uma política de criptografia, todas as coleções que estiverem usando a chave do KMS definida na política não são afetadas. **Para excluir uma política no console OpenSearch sem servidor, selecione a política e escolha Excluir.**
Você também pode usar a [DeleteSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_DeleteSecurityPolicy.html)operação:
```
aws opensearchserverless delete-security-policy --name my-policy --type encryption
```
## Criptografia em trânsito
No OpenSearch Serverless, todos os caminhos em uma coleção são criptografados em trânsito usando o Transport Layer Security 1.2 (TLS) com uma cifra AES-256 padrão do setor. O acesso a todos APIs os painéis do Opensearch também é feito por meio do TLS 1.2. O TLS é um conjunto de protocolos criptográficos padrão do setor usados para criptografar informações que são trocadas pela rede.
# Acesso à rede para Amazon OpenSearch Serverless
As configurações de rede de uma coleção Amazon OpenSearch Serverless determinam se a coleção pode ser acessada pela Internet a partir de redes públicas ou se deve ser acessada de forma privada.
O acesso privado pode ser aplicado a um ou ambos os seguintes itens:
+ OpenSearch VPC endpoints gerenciados sem servidor
+ Compatível Serviços da AWS , como Amazon Bedrock
Você pode configurar o acesso à rede separadamente para o endpoint de uma coleção e o *OpenSearch*endpoint correspondente do *OpenSearch Dashboards*.
O acesso à rede é o mecanismo de isolamento para permitir o acesso de diferentes redes de origem. Por exemplo, se o endpoint de OpenSearch painéis de uma coleção estiver acessível publicamente, mas o endpoint da OpenSearch API não, um usuário poderá acessar os dados da coleção somente por meio de painéis ao se conectar a partir de uma rede pública. Se eles tentarem ligar OpenSearch APIs diretamente de uma rede pública, eles serão bloqueados. As configurações de rede podem ser usadas para essas permutações de origem para tipo de recurso. O Amazon OpenSearch Serverless oferece suporte a ambos IPv4 e IPv6 à conectividade.
**Topics**
+ [
## Políticas de rede
](#serverless-network-policies)
+ [
## Considerações
](#serverless-network-considerations)
+ [
## Permissões necessárias para configurar políticas de rede
](#serverless-network-permissions)
+ [
## Precedência das políticas
](#serverless-network-precedence)
+ [
## Criação de políticas de rede (console)
](#serverless-network-console)
+ [
## Criação de políticas de rede (AWS CLI)
](#serverless-network-cli)
+ [
## Exibição de políticas de rede
](#serverless-network-list)
+ [
## Atualização de políticas de rede
](#serverless-network-update)
+ [
## Exclusão de políticas de rede
](#serverless-network-delete)
## Políticas de rede
As políticas de rede permitem que você gerencie várias coleções em escala, atribuindo automaticamente configurações de acesso à rede a coleções que correspondam às regras definidas na política.
Em uma política de rede, você especifica uma série de *regras*. Essas regras definem as permissões de acesso aos endpoints da coleção e aos endpoints do OpenSearch Dashboards. Cada regra consiste em um tipo de acesso (público ou privado) e um tipo de recurso (coleção e/ou endpoint de OpenSearch painéis). Para cada tipo de recurso (`collection` e `dashboard`), você especifica uma série de regras que definem a quais coleções a política se aplicará.
Neste exemplo de política, a primeira regra especifica o acesso por endpoint da VPC ao endpoint da coleção e ao endpoint do Dashboards para todas as coleções que comecem com o termo `marketing*`. Também especifica o acesso ao Amazon Bedrock.
**nota**
O acesso privado Serviços da AWS , como o Amazon Bedrock, *só* se aplica ao endpoint da coleção, não ao OpenSearch endpoint do OpenSearch Dashboards. Mesmo que `ResourceType` seja`dashboard`, Serviços da AWS não é possível conceder acesso aos OpenSearch painéis.
A segunda regra especifica o acesso público à coleção `finance`, mas somente para o endpoint da coleção (sem acesso ao Dashboards).
```
[
{
"Description":"Marketing access",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/marketing*"
]
},
{
"ResourceType":"dashboard",
"Resource":[
"collection/marketing*"
]
}
],
"AllowFromPublic":false,
"SourceVPCEs":[
"vpce-050f79086ee71ac05"
],
"SourceServices":[
"bedrock.amazonaws.com"
],
},
{
"Description":"Sales access",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/finance"
]
}
],
"AllowFromPublic":true
}
]
```
Essa política fornece acesso público somente aos OpenSearch painéis para coleções que começam com “finanças”. Qualquer tentativa de acessar diretamente a OpenSearch API falhará.
```
[
{
"Description": "Dashboards access",
"Rules": [
{
"ResourceType": "dashboard",
"Resource": [
"collection/finance*"
]
}
],
"AllowFromPublic": true
}
]
```
As políticas de rede podem ser aplicadas tanto às coleções existentes quanto às futuras. Por exemplo, é possível criar uma coleção e depois criar uma política de rede com uma regra que corresponda ao nome da coleção. Não é necessário criar políticas de rede para criar coleções.
## Considerações
Considere o seguinte ao configurar o acesso de rede para suas coleções:
+ [Se você planeja configurar o acesso ao VPC endpoint para uma coleção, primeiro deve criar pelo menos um VPC endpoint gerenciado sem servidorOpenSearch .](serverless-vpc.md)
+ O acesso privado Serviços da AWS só se aplica ao endpoint da coleção, não ao OpenSearch endpoint do OpenSearch Dashboards. Mesmo que `ResourceType` seja`dashboard`, Serviços da AWS não é possível conceder acesso aos OpenSearch painéis.
+ Se uma coleção for acessível a partir de redes públicas, ela também poderá ser acessada por todos os VPC endpoints OpenSearch gerenciados sem servidor e tudo mais. Serviços da AWS
+ Várias políticas de rede podem ser aplicadas a uma única coleção. Para saber mais, consulte [Precedência das políticas](#serverless-network-precedence).
## Permissões necessárias para configurar políticas de rede
O acesso à rede para OpenSearch Serverless usa as seguintes permissões AWS Identity and Access Management (IAM). É possível especificar as condições do IAM para restringir os usuários a políticas de rede associadas a coleções específicas.
+ `aoss:CreateSecurityPolicy`: crie uma política de acesso à rede.
+ `aoss:ListSecurityPolicies`: lista todas as políticas de rede na conta atual.
+ `aoss:GetSecurityPolicy`: exibe uma especificação de política de acesso à rede.
+ `aoss:UpdateSecurityPolicy`: modifica uma determinada política de acesso à rede e altera o ID da VPC ou a designação de acesso público.
+ `aoss:DeleteSecurityPolicy`: exclui uma política de acesso à rede (depois que ela for separada de todas as coleções).
A política de acesso baseada em identidade a seguir permite que um usuário exiba todas as políticas de rede e atualize as políticas com o padrão de recursos `collection/application-logs`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aoss:UpdateSecurityPolicy"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aoss:collection": "application-logs"
}
}
},
{
"Effect": "Allow",
"Action": [
"aoss:ListSecurityPolicies",
"aoss:GetSecurityPolicy"
],
"Resource": "*"
}
]
}
```
------
**nota**
Além disso, o OpenSearch Serverless exige `aoss:DashboardsAccessAll` permissões `aoss:APIAccessAll` e permissões para recursos de coleta. Para obter mais informações, consulte [Usando operações OpenSearch de API](security-iam-serverless.md#security_iam_id-based-policy-examples-data-plane).
## Precedência das políticas
Pode haver situações em que as regras das políticas de rede se sobreponham, dentro ou entre as políticas. Quando isso acontece, uma regra que especifique o acesso público substitui uma regra que especifique o acesso privado para quaisquer coleções que sejam comuns a *ambas* as regras.
Por exemplo, na política a seguir, ambas as regras atribuem acesso de rede à coleção `finance`, mas uma regra especifica o acesso por VPC enquanto a outra especifica o acesso público. Nessa situação, o acesso público substitui o acesso por VPC *somente para a coleção finance* (porque ele existe em ambas as regras), de modo que a coleção finance será acessível a partir de redes públicas. A coleção de vendas terá acesso por VPC a partir do endpoint especificado.
```
[
{
"Description":"Rule 1",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/sales",
"collection/finance"
]
}
],
"AllowFromPublic":false,
"SourceVPCEs":[
"vpce-050f79086ee71ac05"
]
},
{
"Description":"Rule 2",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/finance"
]
}
],
"AllowFromPublic":true
}
]
```
Se vários endpoints da VPC de regras diferentes se aplicarem a uma coleção, as regras serão aditivas e a coleção poderá ser acessada de todos os endpoints especificados. Se você definir `AllowFromPublic``true`, mas também fornecer um ou mais `SourceVPCEs` ou`SourceServices`, o OpenSearch Serverless ignorará os endpoints de VPC e os identificadores de serviço, e as coleções associadas terão acesso público.
## Criação de políticas de rede (console)
As políticas de rede podem ser aplicadas tanto às coleções existentes quanto às futuras. Recomendamos que você crie políticas de rede antes de começar a criar coleções.
**Para criar uma política de rede OpenSearch sem servidor**
1. Abra o console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home ).
1. No painel de navegação à esquerda, expanda **Sem Servidor** e escolha **Políticas de rede**.
1. Escolha **Criar política de rede**.
1. Forneça um nome e uma descrição para a política.
1. Forneça uma ou mais *regras*. Essas regras definem permissões de acesso para suas coleções OpenSearch sem servidor e seus endpoints de OpenSearch painéis.
Cada regra contém os seguintes elementos:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/serverless-network.html)
Para cada tipo de recurso selecionado, você pode escolher coleções existentes às quais aplicar as configurações de política e and/or criar um ou mais padrões de recursos. Os padrões de recursos consistem em um prefixo e um caractere curinga (\$1), e definem a quais coleções as configurações de política se aplicarão.
Por exemplo, se você incluir um padrão chamado `Marketing*`, qualquer coleção nova ou existente cujos nomes comecem com “Marketing” terá as configurações de rede desta política aplicadas automaticamente a elas. Um único caractere curinga (`*`) aplica a política a todas as coleções atuais e futuras.
Além disso, você pode especificar o nome de uma coleção *futura* sem um caractere curinga, como`Finance`. OpenSearch O Serverless aplicará as configurações de política a qualquer coleção recém-criada com esse nome exato.
1. Quando estiver satisfeito com sua configuração de política, escolha **Criar**.
## Criação de políticas de rede (AWS CLI)
Para criar uma política de rede usando as operações da API OpenSearch Serverless, você especifica regras no formato JSON. A [CreateSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateSecurityPolicy.html)solicitação aceita políticas embutidas e arquivos.json. Todas as coleções e padrões devem assumir o formato `collection/`.
**nota**
O tipo de recurso `dashboards` só permite a permissão para OpenSearch painéis, mas para que os OpenSearch painéis funcionem, você também deve permitir o acesso à coleção das mesmas fontes. Veja a segunda política a seguir como um exemplo.
Para especificar o acesso privado, inclua um dos seguintes elementos, ou ambos:
+ `SourceVPCEs`— Especifique um ou mais VPC endpoints OpenSearch gerenciados sem servidor.
+ `SourceServices`— Especifique o identificador de um ou mais compatíveis Serviços da AWS. No momento, os seguintes identificadores de serviço não são compatíveis:
+ `bedrock.amazonaws.com`: Amazon Bedrock
O exemplo de política de rede a seguir fornece acesso privado a um endpoint da VPC e ao Amazon Bedrock, a endpoints de coleção apenas para coleções que comecem com o prefixo `log*`. Usuários autenticados não podem entrar nos OpenSearch painéis; eles só podem acessar o endpoint de coleta de forma programática.
```
[
{
"Description":"Private access for log collections",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/log*"
]
}
],
"AllowFromPublic":false,
"SourceVPCEs":[
"vpce-050f79086ee71ac05"
],
"SourceServices":[
"bedrock.amazonaws.com"
],
}
]
```
A política a seguir fornece acesso público ao OpenSearch endpoint *e* aos OpenSearch painéis para uma única coleção chamada. `finance` Se a coleção não existir, as configurações de rede serão aplicadas à coleção se e quando ela for criada.
```
[
{
"Description":"Public access for finance collection",
"Rules":[
{
"ResourceType":"dashboard",
"Resource":[
"collection/finance"
]
},
{
"ResourceType":"collection",
"Resource":[
"collection/finance"
]
}
],
"AllowFromPublic":true
}
]
```
A solicitação a seguir cria a política de rede acima:
```
aws opensearchserverless create-security-policy \
--name sales-inventory \
--type network \
--policy "[{\"Description\":\"Public access for finance collection\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection\/finance\"]},{\"ResourceType\":\"collection\",\"Resource\":[\"collection\/finance\"]}],\"AllowFromPublic\":true}]"
```
Para fornecer a política em um arquivo JSON, use o formato `--policy file://my-policy.json`
## Exibição de políticas de rede
Antes de criar uma coleção, talvez você queira pré-visualizar as políticas de rede existentes em sua conta para ver qual delas tem um padrão de recurso que corresponda ao nome da sua coleção. A [ListSecurityPolicies](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_ListSecurityPolicies.html)solicitação a seguir lista todas as políticas de rede em sua conta:
```
aws opensearchserverless list-security-policies --type network
```
A solicitação retorna informações sobre todas as políticas de rede configuradas. Para visualizar as regras de padrões definidas em uma política específica, encontre as informações sobre políticas no conteúdo do elemento `securityPolicySummaries` na resposta. Observe o `name` final `type` desta política e use essas propriedades em uma [GetSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_GetSecurityPolicy.html)solicitação para receber uma resposta com os seguintes detalhes da política:
```
{
"securityPolicyDetail": [
{
"type": "network",
"name": "my-policy",
"policyVersion": "MTY2MzY5MTY1MDA3Ml8x",
"policy": "[{\"Description\":\"My network policy rule\",\"Rules\":[{\"ResourceType\":\"dashboard\",\"Resource\":[\"collection/*\"]}],\"AllowFromPublic\":true}]",
"createdDate": 1663691650072,
"lastModifiedDate": 1663691650072
}
]
}
```
Para ver informações detalhadas sobre uma política específica, use o [GetSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_GetSecurityPolicy.html)comando.
## Atualização de políticas de rede
Quando você modifica os endpoints da VPC ou a designação de acesso público para uma rede, todas as coleções associadas são afetadas. **Para atualizar uma política de rede no console OpenSearch sem servidor, expanda **Políticas de rede**, selecione a política a ser modificada e escolha Editar.** Faça suas alterações e escolha **Salvar**.
Para atualizar uma política de rede usando a API OpenSearch Serverless, use o [UpdateSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_UpdateSecurityPolicy.html)comando. É necessário incluir uma versão da política na solicitação. É possível recuperar a versão da política usando os comandos `ListSecurityPolicies` ou `GetSecurityPolicy`. A inclusão da versão mais recente da política garante que você não anule inadvertidamente uma alteração feita por outra pessoa.
A solicitação a seguir atualiza uma política de rede com um novo documento JSON de política:
```
aws opensearchserverless update-security-policy \
--name sales-inventory \
--type network \
--policy-version MTY2MzY5MTY1MDA3Ml8x \
--policy file://my-new-policy.json
```
## Exclusão de políticas de rede
Antes de ser possível excluir uma política de rede, é preciso desvinculá-la de todas as coleções. **Para excluir uma política no console OpenSearch sem servidor, selecione a política e escolha Excluir.**
Você também pode usar o [DeleteSecurityPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_DeleteSecurityPolicy.html)comando:
```
aws opensearchserverless delete-security-policy --name my-policy --type network
```
# Conformidade com FIPS no Amazon Serverless OpenSearch
O Amazon OpenSearch Serverless oferece suporte ao Federal Information Processing Standards (FIPS) 140-2, que é um padrão do governo dos EUA e do Canadá que especifica requisitos de segurança para módulos criptográficos que protegem informações confidenciais. Quando você se conecta a endpoints habilitados para FIPS com o OpenSearch Serverless, as operações criptográficas ocorrem usando bibliotecas criptográficas validadas por FIPS.
OpenSearch Os endpoints FIPS sem servidor estão disponíveis Regiões da AWS onde o FIPS é suportado. Esses endpoints usam o TLS 1.2 ou posteriores e algoritmos criptográficos validados por FIPS em todas as comunicações. Para saber mais, consulte [Conformidade com FIPS](https://docs.aws.amazon.com/verified-access/latest/ug/fips-compliance.html) no *Guia do usuário de acesso verificado pela AWS *.
**Topics**
+ [
## Usando endpoints FIPS com Serverless OpenSearch
](#using-fips-endpoints-opensearch-serverless)
+ [
## Use endpoints FIPS com AWS SDKs
](#using-fips-endpoints-aws-sdks)
+ [
## Configurar grupos de segurança para endpoints da VPC
](#configuring-security-groups-vpc-endpoints)
+ [
## Usar o endpoint FIPS da VPC
](#using-fips-vpc-endpoint)
+ [
## Verificar a conformidade com FIPS
](#verifying-fips-compliance)
+ [
# Resolver problemas de conectividade de endpoint FIPS em zonas hospedadas privadas
](serverless-fips-endpoint-issues.md)
## Usando endpoints FIPS com Serverless OpenSearch
Regiões da AWS Onde o FIPS é suportado, as coleções OpenSearch sem servidor são acessíveis por meio de terminais padrão e compatíveis com FIPS. Para saber mais, consulte [Conformidade com FIPS](https://docs.aws.amazon.com/verified-access/latest/ug/fips-compliance.html) no *Guia do usuário de acesso verificado pela AWS *.
Nos exemplos a seguir, substitua *collection\$1id* e *Região da AWS* por seu ID de coleção e seu Região da AWS.
+ **Endpoint padrão**: **https://*collection\$1id*.*Região da AWS*.aoss.amazonaws.com**.
+ **Endpoints conformes com FIPS**: **https://*collection\$1id*.*Região da AWS*.aoss-fips.amazonaws.com**.
Da mesma forma, os OpenSearch painéis podem ser acessados por meio de terminais padrão e compatíveis com FIPS:
+ **Endpoint padrão do Dashboards**: **https://*collection\$1id*.*Região da AWS*.aoss.amazonaws.com/\$1dashboards**.
+ **Endpoint do Dashboards conforme com FIPS**: **https://*collection\$1id*.*Região da AWS*.aoss-fips.amazonaws.com/\$1dashboards**.
**nota**
Em regiões habilitadas para FIPS, tanto os endpoints padrão quanto os endpoints conformes com FIPS fornecem criptografia conforme com FIPS. Os endpoints específicos para FIPS ajudam você a atender aos requisitos de conformidade que exigem especificamente o uso de endpoints com **FIPS** no nome.
## Use endpoints FIPS com AWS SDKs
Ao usar AWS SDKs, você pode especificar o endpoint FIPS ao criar o cliente. No exemplo a seguir, substitua *collection\$1id* e *Região da AWS* por seu ID de coleção e seu Região da AWS.
```
# Python SDK example
from opensearchpy import OpenSearch, RequestsHttpConnection, AWSV4SignerAuth
import boto3
host = '"https://collection_id.Região da AWS.aoss-fips.amazonaws.com"
region = 'us-west-2'
service = 'aoss'
credentials = boto3.Session().get_credentials()
auth = AWSV4SignerAuth(credentials, region, service)
client = OpenSearch(
hosts = [{'host': host, 'port': 443}],
http_auth = auth,
use_ssl = True,
verify_certs = True,
connection_class = RequestsHttpConnection,
pool_maxsize = 20
)
```
## Configurar grupos de segurança para endpoints da VPC
Para garantir a comunicação adequada com seu endpoint Amazon VPC (VPC) compatível com FIPS, crie ou modifique um grupo de segurança para permitir o tráfego HTTPS de entrada (porta TCP 443) dos recursos em sua VPC que precisam acessar o Serverless. OpenSearch Depois, associe esse grupo de segurança ao endpoint da VPC durante a criação ou modificando o endpoint após a criação. Para saber mais, consulte [Criar um grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/creating-security-groups.html) no *Guia do usuário da Amazon VPC*.
## Usar o endpoint FIPS da VPC
Depois de criar o VPC endpoint compatível com FIPS, você pode usá-lo para acessar o OpenSearch Serverless a partir de recursos dentro da sua VPC. Para usar o endpoint para operações de API, configure o SDK para usar o endpoint FIPS regional, como descrito na seção [Usando endpoints FIPS com Serverless OpenSearch](#using-fips-endpoints-opensearch-serverless). Para acessar os OpenSearch painéis, use a URL específica dos painéis da coleção, que será roteada automaticamente pelo VPC endpoint compatível com FIPS quando acessada de dentro da sua VPC. Para obter mais informações, consulte [Usando OpenSearch painéis com o Amazon Service OpenSearch](dashboards.md).
## Verificar a conformidade com FIPS
Para verificar se suas conexões com o OpenSearch Serverless estão usando criptografia compatível com FIPS, use para monitorar as chamadas de API feitas AWS CloudTrail para o Serverless. OpenSearch Verifique se o `eventSource` campo nos CloudTrail registros é exibido `aoss-fips.amazonaws.com` para chamadas de API.
Para acessar os OpenSearch painéis, você pode usar as ferramentas do desenvolvedor do navegador para inspecionar os detalhes da conexão TLS e verificar se os conjuntos de criptografia compatíveis com FIPS estão sendo usados.
# Resolver problemas de conectividade de endpoint FIPS em zonas hospedadas privadas
Os endpoints FIPS funcionam com coleções Amazon OpenSearch Serverless que têm acesso público. Para coleções da VPC recém-criadas que usam endpoints da VPC recém-criados, os endpoints FIPS funcionam como esperado. Para outras coleções da VPC, talvez seja necessário realizar a configuração manual para garantir que os endpoints FIPS funcionem corretamente.
**Para configurar zonas hospedadas privadas FIPS no Amazon Route 53**
1. Abra o console do Route 53 em [https://console.aws.amazon.com/route53/](https://console.aws.amazon.com/route53/).
1. Revise as zonas hospedadas:
1. Localize as zonas hospedadas nas quais Regiões da AWS suas coleções estão.
1. Verifique os padrões de nomenclatura da zona hospedada:
+ Formato não FIPS: `region.aoss.amazonaws.com`.
+ Formato FIPS: `region.aoss-fips.amazonaws.com`.
1. Confirme que **Tipo** está definido como **Zona hospedada privada** para todas as zonas hospedadas.
1. Se a zona hospedada privada FIPS estiver faltando:
1. Selecione a zona hospedada privada não FIPS correspondente.
1. Copie as VPCs informações **associadas**. Por exemplo: `vpc-1234567890abcdef0 | us-east-2`.
1. Encontre o registro de domínio curinga. Por exemplo: `*.us-east-2.aoss.amazonaws.com`.
1. Copie as informações de **Valor/rotear tráfego para**. Por exemplo: `uoc1c1qsw7poexampleewjeno1pte3rw.3ym756xh7yj.aoss.searchservices.aws`.
1. Crie a zona hospedada privada FIPS:
1. Crie uma nova zona hospedada privada com o formato FIPS. Por exemplo: `us-east-2.aoss-fips.amazonaws.com`.
1. VPCsEm **Associado**, insira as informações de VPC que você copiou da zona hospedada privada não FIPS.
1. Adicione uma nova regra com as seguintes configurações:
1. Nome do registro: \$1
1. Tipo de registro: CNAME
1. Valor: insira as informações de **Valor/rotear tráfego para** que você copiou anteriormente.
## Problemas comuns
Se você tiver problemas de conectividade com os endpoints da VPC compatíveis com FIPS, use as informações a seguir para ajudar a resolver o problema.
+ Falhas na resolução de DNS: você não consegue resolver o nome de domínio do endpoint FIPS em sua VPC
+ Tempos limite de conexão: suas solicitações para o endpoint FIPS atingem o tempo limite
+ Erros de acesso negado: ocorre falha na autenticação ou autorização ao usar endpoints FIPS
+ Faltam registros de zona hospedada privada para coleções somente VPC
**Para solucionar problemas de conectividade de endpoints FIPS**
1. Verifique a configuração de zona hospedada privada:
1. Confirme se existe uma zona hospedada privada para o domínio do endpoint FIPS (`*.region.aoss-fips.amazonaws.com`.
1. Verifique se a zona hospedada privada está associada à VPC correta.
Para saber mais, consulte [Zonas hospedadas privadas](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted- zones-private.html) no *Guia do desenvolvedor do Amazon Route 53* e [Gerenciar nomes do DNS](https://docs.aws.amazon.com/vpc/latest/privatelink/manage-dns-names.html) no *Guia do AWS PrivateLink *.
1. Teste a resolução do DNS:
1. Conecte-se a uma instância do EC2 na sua VPC.
1. Execute este comando: .
```
nslookup collection-id.region.aoss-fips.amazonaws.com
```
1. Confirme se a resposta inclui o endereço IP privado do endpoint da VPC.
Para saber mais, consulte [Políticas de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints- access.html#endpoint-dns-verification) e [Atributos de DNS](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc- dns-troubleshooting) no *Guia do usuário da Amazon VPC*.
1. Verifique as configurações do grupo de segurança:
1. Verifique se o grupo de segurança conectado ao endpoint da VPC permite tráfego HTTPS (porta 443) vindo de seus recursos.
1. Confirme se os grupos de segurança dos recursos permitem tráfego de saída para o endpoint da VPC.
Para saber mais, consulte [Políticas de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html#vpc-endpoint-security-groups) no *Guia da AWS PrivateLink * e [Grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html#SecurityGroupRules) no *Guia do usuário da Amazon VPC*.
1. Revise a configuração de ACL da rede:
1. Verifique se a rede ACLs permite tráfego entre seus recursos e o VPC endpoint.
Para obter mais informações, consulte [Rede ACLs](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network- acls.html#nacl-troubleshooting) no Guia do *usuário da Amazon VPC*.
1. Revise a política de endpoint:
1. Verifique se a política de VPC endpoint permite as ações necessárias em seus recursos sem servidor. OpenSearch
Para saber mais, consulte [Permissões necessárias de endpoint da VPC](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-vpc.html#serverless-vpc-permissions) e [Política de endpoints](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints- access.html#vpc-endpoint-policies) no *Guia do AWS PrivateLink *.
**dica**
Se você usa resolvedores de DNS personalizados em sua VPC, configure-os para encaminhar solicitações de `*.amazonaws.com` domínios para os servidores. AWS
# Controle de acesso a dados para Amazon OpenSearch Serverless
Com o controle de acesso aos dados no Amazon OpenSearch Serverless, você pode permitir que os usuários acessem coleções e índices, independentemente do mecanismo de acesso ou da fonte de rede. É possível fornecer acesso a perfis do IAM e [identidades de SAML](serverless-saml.md).
Você gerencia as permissões de acesso por meio de *políticas de acesso a dados* que se aplicam às coleções e aos recursos de índice. As políticas de acesso a dados ajudam você a gerenciar coleções em grande escala atribuindo automaticamente permissões de acesso a coleções e índices que correspondam a um padrão específico. Várias políticas de acesso a dados podem ser aplicadas a um único recurso. Observe que você deve ter uma política de acesso a dados para sua coleção para acessar a URL do seu OpenSearch painel.
**Topics**
+ [
## Políticas de acesso a dados versus políticas do IAM
](#serverless-data-access-vs-iam)
+ [
## Permissões do IAM necessárias para configurar as políticas de acesso a dados
](#serverless-data-access-permissions)
+ [
## Sintaxe da política
](#serverless-data-access-syntax)
+ [
## Permissões de políticas com suporte
](#serverless-data-supported-permissions)
+ [
## Exemplos de conjuntos de dados em painéis OpenSearch
](#serverless-data-sample-index)
+ [
## Criação de políticas de acesso a dados (console)
](#serverless-data-access-console)
+ [
## Criação de políticas de acesso a dados (AWS CLI)
](#serverless-data-access-cli)
+ [
## Exibição de políticas de acesso a dados
](#serverless-data-access-list)
+ [
## Atualização de políticas de acesso a dados
](#serverless-data-access-update)
+ [
## Exclusão de políticas de acesso a dados
](#serverless-data-access-delete)
+ [
## Acesso a dados entre contas
](#serverless-data-access-cross)
## Políticas de acesso a dados versus políticas do IAM
As políticas de acesso aos dados são logicamente separadas das políticas AWS Identity and Access Management (IAM). As permissões do IAM controlam o acesso às [operações da API do Sem Servidor](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/Welcome.html), como `CreateCollection` e `ListAccessPolicies`. As políticas de acesso a dados controlam o acesso às [OpenSearch operações](#serverless-data-supported-permissions) suportadas pelo OpenSearch Serverless, como `PUT ` ou. `GET _cat/indices`
As permissões do IAM que controlam o acesso às operações da API da política de acesso a dados, como `aoss:CreateAccessPolicy` e `aoss:GetAccessPolicy` (descritas na próxima seção), não afetam a permissão especificada em uma política de acesso a dados.
Por exemplo, suponha que uma política do IAM impeça que um usuário crie políticas de acesso a dados para `collection-a`, mas permita que ele crie políticas de acesso a dados para todas as coleções (`*`):
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"aoss:CreateAccessPolicy"
],
"Resource": "*",
"Condition": {
"StringLike": {
"aoss:collection": "collection-a"
}
}
},
{
"Effect": "Allow",
"Action": [
"aoss:CreateAccessPolicy"
],
"Resource": "*"
}
]
}
```
------
Se o usuário criar uma política de acesso a dados que permita certa permissão para *todas* as coleções (`collection/*` ou `index/*/*`), a política será aplicada a todas as coleções, incluindo a coleção A.
**Importante**
Receber permissões em uma política de acesso a dados não é suficiente para acessar os dados em sua coleção OpenSearch Serverless. Uma entidade principal associada *também* deve ter acesso às permissões do IAM `aoss:APIAccessAll` e `aoss:DashboardsAccessAll`. Ambas as permissões concedem acesso total aos recursos da coleção, enquanto a permissão Painéis também fornece acesso aos OpenSearch Painéis. Se uma entidade principal não tiver essas duas permissões do IAM, receberá erros 403 ao tentar enviar solicitações para a coleção. Para saber mais, consulte [Usando operações OpenSearch de API](security-iam-serverless.md#security_iam_id-based-policy-examples-data-plane).
## Permissões do IAM necessárias para configurar as políticas de acesso a dados
O controle de acesso a dados para OpenSearch Serverless usa as seguintes permissões do IAM. É possível especificar condições do IAM para restringir os usuários a nomes de políticas de acesso específicas.
+ `aoss:CreateAccessPolicy`: criar uma política de acesso.
+ `aoss:ListAccessPolicies`: listar todas as políticas de acesso.
+ `aoss:GetAccessPolicy`: exibir detalhes sobre uma política de acesso específica.
+ `aoss:UpdateAccessPolicy`: modificar uma política de acesso.
+ `aoss:DeleteAccessPolicy`: excluir uma política de acesso.
A seguinte política de acesso baseada em identidade permite que um usuário exiba todas as políticas de acesso e atualize as políticas que contenham o padrão de recursos `collection/logs`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"aoss:ListAccessPolicies",
"aoss:GetAccessPolicy"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Action": [
"aoss:UpdateAccessPolicy"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aoss:collection": [
"logs"
]
}
}
}
]
}
```
------
**nota**
Além disso, o OpenSearch Serverless exige `aoss:DashboardsAccessAll` permissões `aoss:APIAccessAll` e permissões para recursos de coleta. Para obter mais informações, consulte [Usando operações OpenSearch de API](security-iam-serverless.md#security_iam_id-based-policy-examples-data-plane).
## Sintaxe da política
Uma política de acesso a dados inclui um conjunto de regras, cada uma com os seguintes elementos:
| Elemento | Description |
| --- | --- |
| ResourceType | O tipo de recurso (coleção ou índice) ao qual as permissões se aplicam. As permissões de alias e modelo estão no nível da coleção, enquanto as permissões para criar, modificar e pesquisar dados estão no nível do índice. Para saber mais, consulte [Permissões de políticas com suporte](#serverless-data-supported-permissions). |
| Resource | Uma lista de and/or padrões de nomes de recursos. Os padrões são prefixos seguidos por um curinga (\$1), que permitem que as permissões associadas sejam aplicadas a vários recursos.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/serverless-data-access.html) |
| Permission | Uma lista de permissões a serem concedidas para os recursos especificados Para obter uma lista completa de permissões e as operações da API que elas permitem, consulte [Operações e permissões de OpenSearch API suportadas](serverless-genref.md#serverless-operations). |
| Principal | Uma lista de uma ou mais entidades principais às quais conceder acesso. Os principais podem ser a função do IAM ARNs ou as identidades do SAML. Essas entidades principais devem estar dentro da Conta da AWS atual. As políticas de acesso a dados não oferecem suporte direto ao acesso entre contas, mas você pode incluir uma função em sua política que um usuário de outro usuário Conta da AWS possa assumir na conta proprietária da coleção. Para obter mais informações, consulte [Acesso a dados entre contas](#serverless-data-access-cross). |
O exemplo de política a seguir concede permissões de alias e modelo à coleção chamada `autopartsinventory`, bem como a quaisquer coleções iniciadas pelo prefixo `sales*`. Ele também concede permissões de leitura e gravação a todos os índices da coleção `autopartsinventory` e a todos os índices da coleção `salesorders` iniciados pelo prefixo `orders*`.
```
[
{
"Description": "Rule 1",
"Rules":[
{
"ResourceType":"collection",
"Resource":[
"collection/autopartsinventory",
"collection/sales*"
],
"Permission":[
"aoss:CreateCollectionItems",
"aoss:UpdateCollectionItems",
"aoss:DescribeCollectionItems"
]
},
{
"ResourceType":"index",
"Resource":[
"index/autopartsinventory/*",
"index/salesorders/orders*"
],
"Permission":[
"aoss:*"
]
}
],
"Principal":[
"arn:aws:iam::123456789012:user/Dale",
"arn:aws:iam::123456789012:role/RegulatoryCompliance",
"saml/123456789012/myprovider/user/Annie",
"saml/123456789012/anotherprovider/group/Accounting"
]
}
]
```
Você não pode negar explicitamente o acesso em uma política. Dessa forma, todas as permissões de política são aditivas. Por exemplo, se uma política conceder a um usuário `aoss:ReadDocument` e outra conceder `aoss:WriteDocument`, o usuário terá *ambas* as permissões. Se uma terceira política conceder ao mesmo usuário `aoss:*`, o usuário poderá realizar *todas* as ações no índice associado; permissões mais restritivas não substituem as menos restritivas.
## Permissões de políticas com suporte
Há suporte para as permissões a seguir nas políticas de acesso a dados. Para ver as operações de OpenSearch API que cada permissão permite, consulte[Operações e permissões de OpenSearch API suportadas](serverless-genref.md#serverless-operations).
**Permissões de coleção**
+ `aoss:CreateCollectionItems`
+ `aoss:DeleteCollectionItems`
+ `aoss:UpdateCollectionItems`
+ `aoss:DescribeCollectionItems`
+ `aoss:*`
**Permissões de índice**
+ `aoss:ReadDocument`
+ `aoss:WriteDocument`
+ `aoss:CreateIndex`
+ `aoss:DeleteIndex`
+ `aoss:UpdateIndex`
+ `aoss:DescribeIndex`
+ `aoss:*`
## Exemplos de conjuntos de dados em painéis OpenSearch
OpenSearch Os painéis fornecem [conjuntos de dados de amostra](https://opensearch.org/docs/latest/dashboards/quickstart-dashboards/#adding-sample-data) que vêm com visualizações, painéis e outras ferramentas para ajudá-lo a explorar os painéis antes de adicionar seus próprios dados. Para criar índices a partir desses dados de amostra, você precisa de uma política de acesso a dados que forneça permissões para o conjunto de dados com o qual você deseja trabalhar. A política a seguir usa um caractere curinga (`*`) para fornecer permissões aos três conjuntos de dados de amostra.
```
[
{
"Rules": [
{
"Resource": [
"index//opensearch_dashboards_sample_data_*"
],
"Permission": [
"aoss:CreateIndex",
"aoss:DescribeIndex",
"aoss:ReadDocument"
],
"ResourceType": "index"
}
],
"Principal": [
"arn:aws:iam:::user/"
]
}
]
```
## Criação de políticas de acesso a dados (console)
É possível criar uma política de acesso a dados usando o editor visual, ou no formato JSON. Qualquer nova coleção que corresponda a um dos padrões definidos na política receberá as permissões correspondentes quando você criar a coleção.
**Para criar uma política de OpenSearch acesso a dados sem servidor**
1. Abra o console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home ).
1. No painel de navegação à esquerda, expanda **Tecnologia sem servidor** e em **Segurança**, escolha **Políticas de acesso a dados**.
1. Selecione **Criar política de acesso**.
1. Forneça um nome e uma descrição para a política.
1. Forneça um nome para a primeira regra em sua política. Por exemplo, “Acesso à coleção de logs”.
1. Escolha **Adicionar entidades principais** e selecione um ou mais perfis do IAM, ou [usuários e grupos de SAML](serverless-saml.md) aos quais fornecer acesso aos dados.
**nota**
Para selecionar entidades principais nos menus suspensos, é necessário ter as permissões `iam:ListUsers` e `iam:ListRoles` (para entidades principais do IAM) e a permissão `aoss:ListSecurityConfigs` (para identidades de SAML).
1. Escolha **Conceder** e selecione o alias, o modelo e as permissões de índice para conceder às entidades principais associadas. Para obter uma lista completa de permissões e o acesso que elas permitem, consulte [Operações e permissões de OpenSearch API suportadas](serverless-genref.md#serverless-operations).
1. (Opcional) Configure regras adicionais para a política.
1. Escolha **Criar**. Pode haver cerca de um minuto de atraso entre a criação da política e o momento em que as permissões são aplicadas. Se demorar mais de 5 minutos, entre em contato com o [Suporte](https://console.aws.amazon.com/support/home).
**Importante**
Se sua política incluir apenas permissões de indexação (e nenhuma permissão de coleção), talvez você ainda veja uma mensagem sobre coleções correspondentes informando o seguinte: `Collection cannot be accessed yet. Configure data access policies so that users can access the data within this collection`. Você pode ignorar esse aviso. As entidades principais autorizadas ainda podem realizar suas operações relacionadas ao índice atribuídas na coleção.
## Criação de políticas de acesso a dados (AWS CLI)
Para criar uma política de acesso a dados usando a API OpenSearch Serverless, use o `CreateAccessPolicy` comando. O comando aceita tanto políticas em linha quanto arquivos .json. As políticas em linha devem ser codificadas como uma [string JSON com escape](https://www.freeformatter.com/json-escape.html).
A solicitação a seguir cria uma política de acesso a dados:
```
aws opensearchserverless create-access-policy \
--name marketing \
--type data \
--policy "[{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection/autopartsinventory\",\"collection/sales*\"],\"Permission\":[\"aoss:UpdateCollectionItems\"]},{\"ResourceType\":\"index\",\"Resource\":[\"index/autopartsinventory/*\",\"index/salesorders/orders*\"],\"Permission\":[\"aoss:ReadDocument\",\"aoss:DescribeIndex\"]}],\"Principal\":[\"arn:aws:iam::123456789012:user/Shaheen\"]}]"
```
Para fornecer a política em um arquivo .json, use o formato `--policy file://my-policy.json`.
Os diretores incluídos na política agora podem usar as [OpenSearch operações](#serverless-data-supported-permissions) às quais receberam acesso.
## Exibição de políticas de acesso a dados
Antes de criar uma coleção, talvez você queira pré-visualizar as políticas de acesso a dados existentes em sua conta para ver qual delas tem um padrão de recurso que corresponda ao nome da sua coleção. A [ListAccessPolicies](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_ListAccessPolicies.html)solicitação a seguir lista todas as políticas de acesso a dados em sua conta:
```
aws opensearchserverless list-access-policies --type data
```
A solicitação retorna informações sobre todas as políticas de acesso a dados configuradas. Para visualizar as regras de padrões definidas em uma política específica, encontre as informações sobre políticas no conteúdo do elemento `accessPolicySummaries` na resposta. Observe o `name` final `type` desta política e use essas propriedades em uma [GetAccessPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_GetAccessPolicy.html)solicitação para receber uma resposta com os seguintes detalhes da política:
```
{
"accessPolicyDetails": [
{
"type": "data",
"name": "my-policy",
"policyVersion": "MTY2NDA1NDE4MDg1OF8x",
"description": "My policy",
"policy": "[{\"Rules\":[{\"ResourceType\":\"collection\",\"Resource\":[\"collection/autopartsinventory\",\"collection/sales*\"],\"Permission\":[\"aoss:UpdateCollectionItems\"]},{\"ResourceType\":\"index\",\"Resource\":[\"index/autopartsinventory/*\",\"index/salesorders/orders*\"],\"Permission\":[\"aoss:ReadDocument\",\"aoss:DescribeIndex\"]}],\"Principal\":[\"arn:aws:iam::123456789012:user/Shaheen\"]}]",
"createdDate": 1664054180858,
"lastModifiedDate": 1664054180858
}
]
}
```
É possível incluir filtros de recursos para limitar os resultados às políticas que contenham coleções ou índices específicos:
```
aws opensearchserverless list-access-policies --type data --resource "index/autopartsinventory/*"
```
Para ver detalhes sobre uma política específica, use o [GetAccessPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_GetAccessPolicy.html)comando.
## Atualização de políticas de acesso a dados
Quando você atualiza uma política de acesso a dados, todas as coleções associadas são afetadas. **Para atualizar uma política de acesso a dados no console OpenSearch sem servidor, escolha **Controle de acesso a dados**, selecione a política a ser modificada e escolha Editar.** Faça suas alterações e escolha **Salvar**.
Para atualizar uma política de acesso a dados usando a API OpenSearch Serverless, envie uma `UpdateAccessPolicy` solicitação. É necessário incluir uma versão da política, que pode ser recuperada usando os comandos `ListAccessPolicies` ou `GetAccessPolicy`. A inclusão da versão mais recente da política garante que você não anule inadvertidamente uma alteração feita por outra pessoa.
A [UpdateAccessPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_UpdateAccessPolicy.html)solicitação a seguir atualiza uma política de acesso a dados com um novo documento JSON de política:
```
aws opensearchserverless update-access-policy \
--name sales-inventory \
--type data \
--policy-version MTY2NDA1NDE4MDg1OF8x \
--policy file://my-new-policy.json
```
Pode haver alguns minutos de atraso entre a atualização da política e o momento em que as novas permissões são aplicadas.
## Exclusão de políticas de acesso a dados
Quando você exclui uma política de acesso a dados, todas as coleções associadas perdem o acesso definido na política. Certifique-se de que seus usuários do IAM e do SAML tenham o acesso apropriado à coleção antes de excluir uma política. **Para excluir uma política no console OpenSearch sem servidor, selecione a política e escolha Excluir.**
Você também pode usar o [DeleteAccessPolicy](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_DeleteAccessPolicy.html)comando:
```
aws opensearchserverless delete-access-policy --name my-policy --type data
```
## Acesso a dados entre contas
Embora não seja possível criar uma política de acesso a dados com identidade entre contas ou coleções entre contas, você pode configurar o acesso entre contas com a opção de assumir perfil. Por exemplo, se a `account-a` possuir uma coleção à qual a `account-b` precisa ter acesso, o usuário da `account-b` poderá assumir um perfil na `account-a`. O perfil deve ter as permissões do IAM `aoss:APIAccessAll` e `aoss:DashboardsAccessAll`, e estar incluído na política de acesso a dados na `account-a`.
# Acesso ao plano de dados por meio de AWS PrivateLink
O Amazon OpenSearch Serverless oferece suporte a dois tipos de AWS PrivateLink conexões para operações de plano de controle e plano de dados. As operações do plano de controle incluem a criação e exclusão de coleções e o gerenciamento de políticas de acesso. As operações do plano de dados servem para indexar e consultar dados em uma coleção. Esta página aborda os endpoints VPC do plano de dados. Para obter informações sobre os AWS PrivateLink pontos finais do plano de controle, consulte[Controle o acesso ao avião por meio de AWS PrivateLink](serverless-vpc-cp.md).
Você pode usar AWS PrivateLink para criar uma conexão privada entre sua VPC e o Amazon OpenSearch Serverless. Você pode acessar o OpenSearch Serverless como se estivesse em sua VPC, sem o uso de um gateway de internet, dispositivo NAT, conexão VPN ou conexão. Direct Connect As instâncias em sua VPC não precisam de endereços IP públicos para acessar OpenSearch o Serverless. Para obter mais informações sobre o acesso à rede VPC, consulte [Padrões de conectividade de rede para Amazon OpenSearch Serverless](https://aws.amazon.com/blogs/big-data/network-connectivity-patterns-for-amazon-opensearch-serverless/).
Você estabelece essa conexão privada criando um *endpoint de interface*, alimentado pelo AWS PrivateLink. Criamos uma interface de rede de endpoint em cada sub-rede que você habilitar para o endpoint de interface. Essas são interfaces de rede gerenciadas pelo solicitante que servem como ponto de entrada para o tráfego destinado ao Serverless. OpenSearch
Para saber mais, consulte [Acessar os Serviços da AWS pelo AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/privatelink-access-aws-services.html) no *Guia do AWS PrivateLink *.
**Topics**
+ [
## Resolução de DNS dos endpoints de coleta
](#vpc-endpoint-dnc)
+ [
## VPCs e políticas de acesso à rede
](#vpc-endpoint-network)
+ [
## VPCs e políticas de endpoint
](#vpc-endpoint-policy)
+ [
## Considerações
](#vpc-endpoint-considerations)
+ [
## Permissões obrigatórias
](#serverless-vpc-permissions)
+ [
## Crie um endpoint de interface para Serverless OpenSearch
](#serverless-vpc-create)
+ [
## Configuração de VPC compartilhada para Amazon Serverless OpenSearch
](#shared-vpc-setup)
## Resolução de DNS dos endpoints de coleta
Quando você cria um endpoint VPC do plano de dados por meio do console OpenSearch Serverless, o serviço cria uma nova [zona hospedada Amazon Route 53 privada](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/hosted-zones-private.html) e a anexa à VPC. Essa zona hospedada privada consiste em um registro para resolver o registro DNS curinga para coleções OpenSearch sem servidor (`*.us-east-1.aoss.amazonaws.com`) para os endereços de interface usados para o endpoint. Você só precisa de um OpenSearch VPC endpoint sem servidor em uma VPC para acessar todas e quaisquer coleções e painéis em cada uma. Região da AWS Cada VPC com um endpoint para OpenSearch Serverless tem sua própria zona hospedada privada anexada.
O endpoint da interface OpenSearch sem servidor também cria um registro DNS curinga público do Route 53 para todas as coleções na região. O nome DNS é resolvido para os endereços IP OpenSearch públicos sem servidor. Clientes VPCs que não têm um endpoint OpenSearch VPC sem servidor ou clientes em redes públicas podem usar o resolvedor público do Route 53 e acessar as coleções e os painéis com esses endereços IP. [O tipo de endereço IP (IPv4 IPv6, ou Dualstack) do VPC endpoint é determinado com base nas sub-redes fornecidas quando você cria um endpoint de interface para Serverless. OpenSearch ](#serverless-vpc-create)
**nota**
OpenSearch O Serverless cria uma zona hospedada privada ``.opensearch.amazonaws.com` (`) adicional do Amazon Route 53 para OpenSearch uma resolução de domínio de serviço. Você pode atualizar seu IPv4 VPC endpoint existente para o Dualstack usando o comando no. [update-vpc-endpoint](https://docs.aws.amazon.com/cli/latest/reference/opensearchserverless/update-vpc-endpoint.html) AWS CLI
O endereço do resolvedor DNS de uma determinada VPC é o segundo endereço IP do CIDR da VPC. Qualquer cliente na VPC precisa usar esse resolvedor para obter o endereço do endpoint da VPC para qualquer coleção. O resolvedor usa uma zona hospedada privada criada pelo OpenSearch Serverless. É suficiente usar esse resolvedor para todas as coleções em qualquer conta. Também é possível usar o resolvedor da VPC para alguns endpoints de coleção e o resolvedor público para outros, embora isso normalmente não seja necessário.
## VPCs e políticas de acesso à rede
Para conceder permissão de rede OpenSearch APIs e painéis para suas coleções, você pode usar políticas de acesso à [rede OpenSearch ](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-network.html) sem servidor. Você pode controlar esse acesso à rede a partir dos seus endpoints da VPC ou de Internet pública. Como sua política de rede controla apenas as permissões de tráfego, você também deve configurar uma [política de acesso a dados](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-data-access.html) que especifique a permissão para operar com os dados em uma coleção e seus índices. Pense em um endpoint OpenSearch VPC sem servidor como um ponto de acesso ao serviço, uma política de acesso à rede como o ponto de acesso em nível de rede para coleções e painéis e uma política de acesso a dados como o ponto de acesso para controle de acesso refinado para qualquer operação com dados na coleção.
Como você pode especificar vários VPC endpoints IDs em uma política de rede, recomendamos criar um VPC endpoint para cada VPC que precisa acessar uma coleção. Eles VPCs podem pertencer a AWS contas diferentes da conta que possui a política de rede e coleção OpenSearch Serverless. Não recomendamos que você crie uma solução de VPC-to-VPC emparelhamento ou outra solução de proxy entre duas contas para que a VPC de uma conta possa usar o VPC endpoint de outra conta. Isso é menos seguro e econômico do que cada VPC ter seu próprio endpoint. A primeira VPC não será facilmente visível para o administrador da outra VPC, que configurou o acesso ao endpoint dessa VPC na política de rede.
## VPCs e políticas de endpoint
O Amazon OpenSearch Serverless oferece suporte a políticas de endpoint para. VPCs Uma política de endpoint é uma política baseada em recursos do IAM que você anexa a um VPC endpoint para controlar quais AWS entidades principais podem usar o endpoint para acessar seu serviço. AWS Para saber mais, consulte [Controlar o acesso a endpoints de VPC usando políticas de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html).
Para usar uma política de endpoint, primeiro você deve criar um endpoint de interface. Você pode criar um endpoint de interface usando o console OpenSearch Serverless ou a API Serverless. OpenSearch Depois de criar seu endpoint de interface, você precisará adicionar a política de endpoint a esse endpoint. Para obter mais informações, consulte [Crie um endpoint de interface para Serverless OpenSearch](#serverless-vpc-create).
**nota**
Você não pode definir uma política de endpoint diretamente no console OpenSearch de serviço.
Uma política de endpoint não substitui políticas baseadas em recursos, políticas de rede nem políticas de acesso a dados que você possa ter configurado. Para obter informações sobre como atualizar sua política de endpoint de VPC, consulte [Controlar o acesso a endpoints da VPC usando políticas de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html).
Por padrão, uma política de endpoint concede acesso total ao seu endpoint de VPC.
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "*",
"Resource": "*"
}
]
}
```
Embora a política padrão de endpoint de VPC conceda acesso total ao endpoint, você pode configurar uma política de endpoint de VPC para permitir acesso a perfis e usuários específicos. Para fazer isso, veja o exemplo a seguir:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"123456789012",
"987654321098"
]
},
"Action": "*",
"Resource": "*"
}
]
}
```
------
Você pode especificar uma coleção OpenSearch Serverless para ser incluída como um elemento condicional na sua política de VPC endpoint. Para fazer isso, veja o exemplo a seguir:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aoss:collection": [
"coll-abc"
]
}
}
}
]
}
```
------
`aoss:CollectionId` é compatível.
```
Condition": {
"StringEquals": {
"aoss:CollectionId": "collection-id"
}
}
```
Você pode usar identidades SAML em sua política de endpoint de VPC para determinar o acesso ao endpoint de VPC. Você deve usar um caractere curinga `(*)` na seção principal da sua política de endpoint de VPC. Para fazer isso, veja o exemplo a seguir:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "*",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"saml:cn": [
"saml/111122223333/idp123/group/football",
"saml/111122223333/idp123/group/soccer",
"saml/111122223333/idp123/group/cricket"
]
}
}
}
]
}
```
------
Além disso, você pode configurar sua política de endpoint para incluir uma política de entidade principal de SAML específica. Para isso, veja o seguinte:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "*",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalTag/Department": [
"Engineering"]
}
}
}
]
}
```
------
Para obter mais informações sobre o uso da autenticação SAML com o Amazon OpenSearch Serverless, consulte [Autenticação SAML para](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-saml.html) Amazon Serverless. OpenSearch
Você também pode incluir usuários do IAM e do SAML na mesma política de endpoint de VPC. Para fazer isso, veja o exemplo a seguir:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "*",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"saml:cn": [
"saml/111122223333/idp123/group/football",
"saml/111122223333/idp123/group/soccer",
"saml/111122223333/idp123/group/cricket"
]
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": [
"111122223333"
]
},
"Action": "*",
"Resource": "*"
}
]
}
```
------
Você também pode acessar uma coleção Amazon OpenSearch Serverless do Amazon EC2 por meio da interface VPC endpoints. Para obter mais informações, consulte [Acesse uma coleção OpenSearch sem servidor do Amazon EC2 (via interface VPC](https://aws.amazon.com/blogs/big-data/network-connectivity-patterns-for-amazon-opensearch-serverless/) endpoints).
## Considerações
Antes de configurar um endpoint de interface para OpenSearch Serverless, considere o seguinte:
+ OpenSearch O Serverless oferece suporte para fazer chamadas para todas as operações de [OpenSearch API suportadas (não operações](serverless-genref.md#serverless-operations) de API de configuração) por meio do endpoint da interface.
+ Depois de criar um endpoint de interface para OpenSearch Serverless, você ainda precisa incluí-lo nas [políticas de acesso à rede](serverless-network.md) para que ele acesse coleções sem servidor.
+ Por padrão, o acesso total ao OpenSearch Serverless é permitido por meio do endpoint da interface. Você pode associar um grupo de segurança às interfaces de rede do endpoint para controlar o tráfego para o OpenSearch Serverless por meio do endpoint da interface.
+ Um único Conta da AWS pode ter no máximo 50 endpoints OpenSearch VPC sem servidor.
+ Se você habilitar o acesso público à API ou aos painéis da sua coleção em uma política de rede, sua coleção poderá ser acessada por qualquer VPC e pela Internet pública.
+ Se você estiver no local e fora da VPC, não poderá usar um resolvedor de DNS diretamente para a resolução do endpoint da VPC OpenSearch sem servidor. Se você precisar de acesso à VPN, a VPC precisará de um resolvedor de proxy DNS para ser usado por clientes externos. O Route 53 fornece uma opção de endpoint de entrada que você pode usar para resolver consultas ao DNS à VPC, originadas na rede no local (on-premises) ou em outra VPC.
+ A zona hospedada privada que o OpenSearch Serverless cria e anexa à VPC é gerenciada pelo serviço, mas aparece nos seus Amazon Route 53 recursos e é cobrada na sua conta.
+ Para outras considerações, consulte [Considerações](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#considerations-interface-endpoints) no *Guia do AWS PrivateLink *.
## Permissões obrigatórias
O acesso à VPC para OpenSearch Serverless usa as seguintes permissões AWS Identity and Access Management (IAM). É possível especificar as condições do IAM para restringir os usuários a coleções específicas.
+ `aoss:CreateVpcEndpoint`: criar um endpoint da VPC.
+ `aoss:ListVpcEndpoints`: listar todos os endpoints da VPC.
+ `aoss:BatchGetVpcEndpoint`: veja detalhes sobre um subconjunto de endpoints da VPC.
+ `aoss:UpdateVpcEndpoint`: modificar um endpoint da VPC.
+ `aoss:DeleteVpcEndpoint`: excluir um endpoint da VPC.
Além disso, as seguintes permissões do Amazon EC2 e do Route 53 são necessárias para criar um endpoint de VPC.
+ `ec2:CreateTags`
+ `ec2:CreateVpcEndpoint`
+ `ec2:DeleteVpcEndPoints`
+ `ec2:DescribeSecurityGroups`
+ `ec2:DescribeSubnets`
+ `ec2:DescribeVpcEndpoints`
+ `ec2:DescribeVpcs`
+ `ec2:ModifyVpcEndPoint`
+ `route53:AssociateVPCWithHostedZone`
+ `route53:ChangeResourceRecordSets`
+ `route53:CreateHostedZone`
+ `route53:DeleteHostedZone`
+ `route53:GetChange`
+ `route53:GetHostedZone`
+ `route53:ListHostedZonesByName`
+ `route53:ListHostedZonesByVPC`
+ `route53:ListResourceRecordSets`
## Crie um endpoint de interface para Serverless OpenSearch
Você pode criar um endpoint de interface para OpenSearch Serverless usando o console ou a OpenSearch API Serverless.
**Para criar um endpoint de interface para uma coleção sem OpenSearch servidor**
1. Abra o console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home).
1. Expanda **Sem Servidor** no painel de navegação à esquerda e escolha **Endpoints da VPC**.
1. Escolha **Criar endpoint da VPC**.
1. Forneça um nome para o endpoint.
1. Para **VPC, selecione a VPC** a partir da qual você acessará o Serverless. OpenSearch
1. Em **Sub-redes, selecione uma sub-rede** a partir da qual você OpenSearch acessará o Serverless.
+ O endereço IP e o tipo de DNS do endpoint são baseados no tipo de sub-rede
+ Dualstack: se todas as sub-redes tiverem ambos os intervalos de endereços IPv4 IPv6
+ IPv6: Se todas as sub-redes forem IPv6 somente sub-redes
+ IPv4: Se todas as sub-redes tiverem intervalos de endereços IPv4
1. Em **Grupos de segurança**, selecione os grupos de segurança para associar às interfaces de rede do endpoint. Essa é uma etapa crítica em que você limita as portas, protocolos e fontes do tráfego de entrada que você está autorizando em seu endpoint. Certifique-se de que as regras do grupo de segurança permitam que os recursos que usarão o VPC endpoint se comuniquem com o OpenSearch Serverless se comuniquem com a interface de rede do endpoint.
1. Escolha **Criar endpoint**.
Para criar um VPC endpoint usando a API OpenSearch Serverless, use o comando. `CreateVpcEndpoint`
**nota**
Depois de criar um endpoint, anote seu ID (por exemplo, `vpce-abc123def4EXAMPLE`. Para fornecer ao endpoint acesso às suas coleções, será necessário incluir esse ID em uma ou mais políticas de acesso à rede.
Depois de criar um endpoint da interface, você deverá fornecer a ele acesso às coleções por meio de políticas de acesso à rede. Para obter mais informações, consulte [Acesso à rede para Amazon OpenSearch Serverless](serverless-network.md).
## Configuração de VPC compartilhada para Amazon Serverless OpenSearch
Você pode usar a Amazon Virtual Private Cloud (VPC) para compartilhar sub-redes VPC com outras pessoas Contas da AWS em sua organização, bem como compartilhar a infraestrutura de rede, como uma VPN, entre vários recursos. Contas da AWS
Atualmente, o Amazon OpenSearch Serverless não oferece suporte à criação de uma AWS PrivateLink conexão em uma VPC compartilhada, a menos que você seja proprietário dessa VPC. AWS PrivateLink também não suporta o compartilhamento de conexões entre Contas da AWS.
No entanto, com base na arquitetura flexível e modular do OpenSearch Serverless, você ainda pode configurar uma VPC compartilhada. Isso ocorre porque a infraestrutura de rede OpenSearch sem servidor é separada da infraestrutura de coleção individual (OpenSearch Serviço). Portanto, você pode criar um AWS PrivateLink VPCe endpoint para uma conta onde está localizada uma VPC e, em seguida, usar VPCe uma ID na política de rede de outras contas para restringir o tráfego proveniente somente dessa VPC compartilhada.
Os procedimentos a seguir se referem a uma *conta de proprietário* e a uma *conta de consumidor*.
Uma conta de proprietário funciona como uma conta de rede comum, na qual você configura e compartilha uma VPC com outras contas. As contas de consumidor são aquelas contas que criam e mantêm suas coleções OpenSearch sem servidor na VPC compartilhadas com elas pela conta do proprietário.
**Pré-requisitos**
Certifique-se de que os seguintes requisitos sejam atendidos antes de configurar a VPC compartilhada:
+ A conta de proprietário em questão já deve ter configurada uma VPC, sub-redes, uma tabela de rotas e os outros recursos necessários na Amazon Virtual Private Cloud. Para saber mais, consulte o *[Manual do usuário da Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/)*.
+ A conta de proprietário e as contas de consumidor em questão devem pertencer à mesma organização do AWS Organizations. Para obter mais informações, consulte o *Guia do usuário do [AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/)*.
**Para configurar uma VPC compartilhada em uma conta de account/common rede do proprietário.**
1. Faça login no console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home).
1. Siga as etapas em [Crie um endpoint de interface para Serverless OpenSearch](#serverless-vpc-create). Ao fazer isso, faça as seguintes seleções:
+ Selecione uma VPC e as sub-redes que são compartilhadas com as contas de consumidores da sua organização.
1. Depois de criar o endpoint, anote a VPCe ID gerada e forneça-a aos administradores que realizarão a tarefa de configuração nas contas de consumidores.
VPCe IDs estão no formato`vpce-abc123def4EXAMPLE`.
**Para configurar uma VPC compartilhada em uma conta de consumidor**
1. Faça login no console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home).
1. Use as informações em [Gerenciando coleções Amazon OpenSearch Serverless](serverless-manage.md) para criar uma coleção, se ainda não tiver uma.
1. Use as informações em [Criação de políticas de rede (console)](serverless-network.md#serverless-network-console) para criar uma política de rede. Ao fazer isso, faça as seleções a seguir.
**nota**
Também é possível atualizar uma política de rede existente para essa finalidade.
1. Em **Tipo de acesso**, selecione **VPC (recomendado)**.
1. **Para acessar os endpoints VPC**, escolha a VPCe ID fornecida pela conta do proprietário, no formato. `vpce-abc123def4EXAMPLE`
1. Na área **Tipo de recurso**, faça o seguinte:
+ Selecione a caixa **Habilitar acesso ao OpenSearch endpoint** e, em seguida, selecione o nome da coleção ou o padrão de coleção a ser usado para habilitar o acesso a partir dessa VPC compartilhada.
+ Selecione a caixa **Habilitar acesso ao OpenSearch painel** e, em seguida, selecione o nome da coleção ou o padrão de coleção a ser usado para habilitar o acesso a partir dessa VPC compartilhada.
1. Para uma nova política, escolha **Criar**. Para uma política existente, escolha **Atualizar**.
# Controle o acesso ao avião por meio de AWS PrivateLink
O Amazon OpenSearch Serverless oferece suporte a dois tipos de AWS PrivateLink conexões para operações de plano de controle e plano de dados. As operações do plano de controle incluem a criação e exclusão de coleções e o gerenciamento de políticas de acesso. As operações do plano de dados servem para indexar e consultar dados em uma coleção. Esta página aborda o AWS PrivateLink ponto final do plano de controle. Para obter informações sobre os endpoints VPC do plano de dados, consulte. [Acesso ao plano de dados por meio de AWS PrivateLink](serverless-vpc.md)
## Criando um ponto AWS PrivateLink final do plano de controle
Você pode melhorar a postura de segurança da sua VPC OpenSearch configurando o Serverless para usar uma interface VPC endpoint. Os endpoints de interface são alimentados por AWS PrivateLink. Essa tecnologia permite que você acesse de forma privada o OpenSearch Serverless APIs sem um gateway de internet, dispositivo NAT, conexão VPN ou conexão Direct AWS Connect.
Para obter mais informações sobre AWS PrivateLink endpoints de VPC, consulte VPC endpoints [no Guia do usuário da Amazon VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/concepts.html#concepts-vpc-endpoints).
### Considerações
+ Os endpoints de VPC são compatíveis somente na mesma região.
+ Os endpoints da VPC oferecem suporte somente a DNS fornecidos pela Amazon por meio do Amazon Route 53.
+ Os endpoints VPC oferecem suporte a políticas de endpoint para controlar o acesso a coleções, OpenSearch políticas e. VpcEndpoints
+ OpenSearch O Serverless oferece suporte somente a endpoints de interface. Endpoints de gateway não são aceitos.
### Criação do VPC endpoint
*Para criar o endpoint VPC do plano de controle para o Amazon OpenSearch Serverless, use o procedimento [Acesse um serviço AWS usando uma interface de VPC endpoint no Amazon VPC Developer](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint) Guide.* Crie o seguinte endpoint:
+ `com.amazonaws.region.aoss`
**Para criar um endpoint VPC do plano de controle usando o console**
1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. No painel de navegação, escolha **Endpoints**.
1. Escolha **Create Endpoint** (Criar endpoint).
1. Em **Service category** (Categoria de serviço), escolha **Serviços da AWS**.
1. Para **Serviços**, escolha`com.amazonaws.region.aoss`. Por exemplo, .`com.amazonaws.us-east-1.aoss`
1. Em **VPC**, escolha a VPC na qual deseja criar o endpoint.
1. Em **Subnets (Sub-redes)**, selecione as sub-redes (zonas de disponibilidade) nas quais você deseja criar as interfaces de rede do endpoint.
1. Em **Grupos de segurança**, escolha os grupos de segurança a serem associados às interfaces de rede do endpoint. Verifique se o HTTPS (porta 443) está permitido.
1. Em **Política**, escolha **Acesso total** para permitir todas as operações ou escolha **Personalizado** para anexar uma política personalizada.
1. Escolha **Criar endpoint**.
### Criar uma política de endpoint
Você pode anexar uma política de endpoint ao seu VPC endpoint que controla o acesso ao Amazon Serverless. OpenSearch Essa política especifica as seguintes informações:
+ A entidade principal que pode realizar ações.
+ As ações que podem ser realizadas.
+ Os recursos aos quais as ações podem ser aplicadas.
Para mais informações, consulte [Controlar o acesso a serviços com VPC endpoints](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) no *Guia do usuário da Amazon VPC*.
**Example Política de VPC endpoint para servidores sem servidor OpenSearch**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": [
"aoss:ListCollections",
"aoss:BatchGetCollection"
],
"Resource": "*"
}
]
}
```
**Example Política restritiva que permite somente operações de lista**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "aoss:ListCollections",
"Resource": "*"
}
]
}
```
# Autenticação SAML para Amazon Serverless OpenSearch
Com a autenticação SAML para Amazon OpenSearch Serverless, você pode usar seu provedor de identidade existente para oferecer login único (SSO) para os endpoints do Dashboards de coleções sem servidor. OpenSearch
A autenticação SAML permite que você use provedores de identidade terceirizados para entrar nos OpenSearch painéis para indexar e pesquisar dados. OpenSearch O Serverless oferece suporte a provedores que usam o padrão SAML 2.0, como IAM Identity Center, Okta, Keycloak, Active Directory Federation Services (AD FS) e Auth0. Você pode configurar o IAM Identity Center para sincronizar usuários e grupos de outras fontes de identidade OneLogin, como Okta e Microsoft Entra ID. Para ver uma lista das fontes de identidades compatíveis com o IAM Identity Center e as etapas para configurá-las, consulte os [Tutoriais de introdução](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) no *Guia do usuário do IAM*.
**nota**
A autenticação SAML serve apenas para acessar OpenSearch painéis por meio de um navegador da web. Usuários autenticados só podem fazer solicitações às operações da OpenSearch API por meio de **ferramentas de desenvolvimento** em OpenSearch painéis. Suas credenciais SAML *não* permitem que você faça solicitações HTTP diretas às operações da OpenSearch API.
Para configurar a autenticação SAML, primeiro é necessário configurar um provedor de identidade (IdP) SAML. Em seguida, você inclui um ou mais usuários desse IdP em uma [política de acesso a dados](serverless-data-access.md). Essa política concede certas permissões aos and/or índices de coleções. Em seguida, um usuário pode entrar nos OpenSearch painéis e realizar as ações permitidas na política de acesso a dados.
![\[SAML authentication flow with data access policy, OpenSearch interface, and JSON configuration.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/serverless-saml-flow.png)
**Topics**
+ [
## Considerações
](#serverless-saml-considerations)
+ [
## Permissões obrigatórias
](#serverless-saml-permissions)
+ [
## Criação de provedores de SAML (console)
](#serverless-saml-creating)
+ [
## Acessando OpenSearch painéis
](#serverless-saml-dashboards)
+ [
## Concessão de acesso de identidades do SAML a dados de coleções
](#serverless-saml-policies)
+ [
## Criação de provedores de SAML (AWS CLI)
](#serverless-saml-creating-api)
+ [
## Exibição de provedores de SAML
](#serverless-saml-viewing)
+ [
## Atualização de provedores de SAML
](#serverless-saml-updating)
+ [
## Exclusão de provedores de SAML
](#serverless-saml-deleting)
## Considerações
Considere o seguinte ao configurar a autenticação SAML:
+ Não há suporte para solicitações assinadas e criptografadas.
+ Não há suporte para declarações criptografadas.
+ Não há suporte para autenticação e desconexão iniciadas pelo IdP.
+ As Políticas de Controle de Serviços (SCP) não serão aplicáveis nem avaliadas no caso de identidades que não sejam do IAM (como SAML no OpenSearch Amazon Serverless e SAML e autorização básica de usuário interno para o Amazon Service). OpenSearch
## Permissões obrigatórias
A autenticação SAML para OpenSearch Serverless usa as seguintes permissões AWS Identity and Access Management (IAM):
+ `aoss:CreateSecurityConfig`: criar um provedor de SAML.
+ `aoss:ListSecurityConfig`: listar todos os provedores de SAML na conta atual.
+ `aoss:GetSecurityConfig`: exibir as informações do provedor de SAML.
+ `aoss:UpdateSecurityConfig`: modificar uma determinada configuração do provedor de SAML, incluindo os metadados XML.
+ `aoss:DeleteSecurityConfig`: excluir um provedor de SAML.
A seguinte política de acesso baseada em identidade permite que um usuário gerencie todas as configurações do IdP:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"aoss:CreateSecurityConfig",
"aoss:DeleteSecurityConfig",
"aoss:GetSecurityConfig",
"aoss:UpdateSecurityConfig",
"aoss:ListSecurityConfigs"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Observe que o elemento `Resource` deve ser um caractere curinga.
## Criação de provedores de SAML (console)
Estas etapas explicam como criar provedores de SAML. Isso permite a autenticação SAML com autenticação iniciada pelo provedor de serviços (SP) para OpenSearch painéis. Não há suporte para autenticação iniciada pelo IdP.
**Para habilitar a autenticação SAML para painéis OpenSearch**
1. Faça login no console do Amazon OpenSearch Service em [https://console.aws.amazon.com/aos/casa](https://console.aws.amazon.com/aos/home ).
1. No painel de navegação à esquerda, expanda **Sem Servidor** e escolha **Autenticação SAML**.
1. Escolha **Adicionar provedor de SAML**.
1. Forneça um nome e uma descrição para o provedor.
**nota**
O nome que você especificar pode ser acessado publicamente e aparecerá em um menu suspenso quando os usuários entrarem OpenSearch nos Painéis. Certifique-se de que o nome seja facilmente reconhecível e não revele informações confidenciais sobre seu provedor de identidade.
1. Em **Configurar seu IdP**, copie o URL do Assertion Consumer Service (ACS).
1. Use o URL do ACS que você acabou de copiar para configurar seu provedor de identidade. A terminologia e as etapas variam de acordo com o provedor. Consulte a documentação do seu provedor.
No Okta, por exemplo, você cria uma “aplicação Web SAML 2.0” e especifica o URL do ACS como **URL de login único**, **URL do destinatário** e **URL de destino**. Para Auth0, você o especifica em Allowed **Callback URLs**.
1. Forneça a restrição de público se seu IdP possuir um campo para isso. A restrição de público é um valor dentro da declaração do SAML que especifica a quem a declaração se destina. Com o OpenSearch Serverless, você pode fazer o seguinte. Certifique-se de substituir o código *content* no exemplo a seguir pelo seu próprio Conta da AWS ID:
1. Use a restrição de público padrão `:opensearch:111122223333`.
1. (Opcional) configure uma restrição de público personalizada usando a AWS CLI. Para obter mais informações, consulte [Criação de provedores de SAML (AWS CLI)](#serverless-saml-creating-api).
O nome do campo de restrição de público varia de acordo com o provedor. Para o Okta, é **URI do público, ID de entidade do SP**. Para o IAM Identity Center, é **Público de SAML da aplicação**.
1. Se você estiver usando o IAM Identity Center, você também precisará especificar o seguinte [mapeamento de atributos](https://docs.aws.amazon.com/singlesignon/latest/userguide/attributemappingsconcept.html): `Subject=${user:name}`, com um formato `unspecified`.
1. Aopis você configurar o provedor de identidade, ele gera um arquivo de metadados IdP. Esse arquivo XML contém informações sobre o provedor, como um certificado TLS, endpoints de acesso único e o ID de entidade do provedor de identidade.
Copie o texto no arquivo de metadados do IdP e cole-o no campo **Fornecer metadados do seu IdP**. Alternativamente, escolha **Importar de arquivo XML** e carregue o arquivo. O arquivo de metadados deve ser semelhante ao seguinte:
```
tls-certificate
s
urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified
urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
```
1. Mantenha o campo **Atributo de ID do usuário personalizado** vazio para usar o elemento `NameID` da declaração do SAML para o nome do usuário. Se sua asserção não usar este elemento padrão e, em vez disso, incluir o nome de usuário como um atributo personalizado, especifique esse atributo aqui. Os atributos diferenciam maiúsculas de minúsculas. Só há suporte para um único atributo de usuário.
O exemplo a seguir mostra um atributo de substituição para `NameID` na declaração do SAML:
```
annie
```
1. (Opcional) Especifique um atributo personalizado no campo **Atributo do grupo**, como `role` ou `group`. Só há suporte para um único atributo de grupo. Não há atributo de grupo padrão. Se você não especificar uma, suas políticas de acesso a dados só poderão conter entidades principais de usuários.
O exemplo a seguir mostra um atributo de grupo na declaração do SAML:
```
finance
```
1. Por padrão, os OpenSearch painéis desconectam os usuários após 24 horas. Você pode configurar esse valor para qualquer número entre 1 e 12 horas (15 e 720 minutos) especificando o tempo limite dos **OpenSearch painéis**. Se você tentar definir um tempo limite igual ou inferior a 15 minutos, sua sessão será redefinida para uma hora.
1. Escolha **Criar provedor de SAML**.
## Acessando OpenSearch painéis
Depois de configurar um provedor SAML, todos os usuários e grupos associados a esse provedor podem navegar até o endpoint do OpenSearch Dashboards. O URL do Dashboards tem o formato `collection-endpoint/_dashboards/` *para todas as coleções*.
Se você tiver o SAML ativado, selecionar o link no Console de gerenciamento da AWS direcionará você para a página de seleção do IdP, na qual você poderá fazer login usando suas credenciais do SAML. Primeiro, use o menu suspenso para selecionar um provedor de identidade:
![\[OpenSearch login page with dropdown menu for selecting SAML Identity Provider options.\]](http://docs.aws.amazon.com/pt_br/opensearch-service/latest/developerguide/images/idpList.png)
Em seguida, faça login usando suas credenciais do IdP.
Se você não tiver o SAML ativado, selecionar o link no Console de gerenciamento da AWS direcionará você a fazer login como usuário ou função do IAM, sem opção para SAML.
## Concessão de acesso de identidades do SAML a dados de coleções
Depois de criar um provedor de SAML, você ainda precisa conceder aos usuários e grupos subjacentes acesso aos dados em suas coleções. Você concede acesso por meio de [políticas de acesso a dados](serverless-data-access.md). Até que você forneça acesso aos usuários, eles não poderão ler, gravar ou excluir nenhum dado de suas coleções.
Para conceder acesso, crie uma política de acesso a dados e especifique seu and/or grupo de usuários do SAML IDs na `Principal` declaração:
```
[
{
"Rules":[
...
],
"Principal":[
"saml/987654321098/myprovider/user/Shaheen",
"saml/987654321098/myprovider/group/finance"
]
}
]
```
É possível conceder acesso a coleções, índices ou ambos. Se você quiser que usuários diferentes tenham permissões diferentes, crie várias regras. Para obter uma lista das permissões disponíveis, consulte [Permissões de políticas com suporte](serverless-data-access.md#serverless-data-supported-permissions). Para obter informações sobre como formatar uma política de acesso, consulte [Sintaxe das políticas](serverless-data-access.md).
## Criação de provedores de SAML (AWS CLI)
Para criar um provedor SAML usando a API OpenSearch Serverless, envie uma solicitação: [CreateSecurityConfig](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_CreateSecurityConfig.html)
```
aws opensearchserverless create-security-config \
--name myprovider \
--type saml \
--saml-options file://saml-auth0.json
```
Especifique `saml-options`, incluindo o XML de metadados, como um mapa de chave-valor em um arquivo .json. O XML de metadados deve ser codificado como uma [string de escape JSON](https://www.freeformatter.com/json-escape.html).
```
{
"sessionTimeout": 70,
"groupAttribute": "department",
"userAttribute": "userid",
"openSearchServerlessEntityId": "aws:opensearch:111122223333:app1",
"metadata": "EntityDescriptor xmlns=\"urn:oasis:names:tc:SAML:2.0:metadata\" ... ... ... IDPSSODescriptor\r\n\/EntityDescriptor"
}
```
**nota**
(Opcional) configure uma restrição de público personalizada usando a AWS CLI. Para obter mais informações, consulte [Criação de provedores de SAML (AWS CLI)](#serverless-saml-creating-api).
## Exibição de provedores de SAML
A [ListSecurityConfigs](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_ListSecurityConfigs.html)solicitação a seguir lista todos os provedores de SAML em sua conta:
```
aws opensearchserverless list-security-configs --type saml
```
A solicitação retorna informações sobre todos os provedores de SAML existentes, incluindo os metadados completos do IdP que seu provedor de identidade gera:
```
{
"securityConfigDetails": [
{
"configVersion": "MTY2NDA1MjY4NDQ5M18x",
"createdDate": 1664054180858,
"description": "Example SAML provider",
"id": "saml/111122223333/myprovider",
"lastModifiedDate": 1664054180858,
"samlOptions": {
"groupAttribute": "department",
"metadata": "EntityDescriptorxmlns=\"urn:oasis:names:tc:SAML:2.0:metadata\" ...... ...IDPSSODescriptor\r\n/EntityDescriptor",
"sessionTimeout": 120,
"openSearchServerlessEntityId": "aws:opensearch:111122223333:app1",
"userAttribute": "userid"
}
}
]
}
```
Para exibir detalhes sobre um provedor específico, inclusive a `configVersion` para futuras atualizações, envie uma solicitação `GetSecurityConfig`.
## Atualização de provedores de SAML
**Para atualizar um provedor SAML usando o console OpenSearch Serverless, escolha a **autenticação SAML**, selecione seu provedor de identidade e escolha Editar.** É possível modificar todos os campos, incluindo os metadados e os atributos personalizados.
Para atualizar um provedor por meio da API OpenSearch Serverless, envie uma [UpdateSecurityConfig](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_UpdateSecurityConfig.html)solicitação e inclua o identificador da política a ser atualizada. Também é necessário incluir uma versão da configuração, que pode ser recuperada usando os comandos `ListSecurityConfigs` ou `GetSecurityConfig`. A inclusão da versão mais recente garante que você não anule inadvertidamente uma alteração feita por outra pessoa.
A solicitação a seguir atualiza as opções do SAML para um provedor:
```
aws opensearchserverless update-security-config \
--id saml/123456789012/myprovider \
--type saml \
--saml-options file://saml-auth0.json \
--config-version MTY2NDA1MjY4NDQ5M18x
```
Especifique suas opções de configuração do SAML como um mapa de chave-valor em um arquivo .json.
**Importante**
**As atualizações nas opções do SAML *não* são incrementais**. Se você não especificar um valor para um parâmetro no objeto `SAMLOptions` ao fazer uma atualização, os valores existentes serão substituídos por valores vazios. Por exemplo, se a configuração atual contiver um valor para `userAttribute`, e você fizer uma atualização em seguida e não incluir esse valor, o valor será removido da configuração. Certifique-se de saber quais são os valores existentes antes de fazer uma atualização chamando a operação `GetSecurityConfig`.
## Exclusão de provedores de SAML
Quando você exclui um provedor de SAML, quaisquer referências a usuários e grupos associados em suas políticas de acesso a dados não funcionam mais. Para evitar confusão, sugerimos que você remova todas as referências ao endpoint em suas políticas de acesso antes de excluir o endpoint.
**Para excluir um provedor SAML usando o console OpenSearch sem servidor, escolha **Autenticação**, selecione o provedor e escolha Excluir.**
Para excluir um provedor por meio da API OpenSearch Serverless, envie uma [DeleteSecurityConfig](https://docs.aws.amazon.com/opensearch-service/latest/ServerlessAPIReference/API_DeleteSecurityConfig.html)solicitação:
```
aws opensearchserverless delete-security-config --id saml/123456789012/myprovider
```
# Validação de conformidade para Amazon OpenSearch Serverless
Auditores terceirizados avaliam a segurança e a conformidade do Amazon OpenSearch Serverless como parte de vários AWS programas de conformidade. Esses programas incluem SOC, PCI e HIPAA.
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/).