

# Cross-account acesso à memória
<a name="memory-cross-account-access"></a>

O Amazon Bedrock AgentCore Memory oferece suporte ao acesso entre contas, permitindo que você crie arquiteturas de várias contas em que os recursos de memória e os agentes consumidores abrangem várias contas. AWS Cross-account o acesso abrange dois cenários:
+  **Operações do plano de dados de outra conta** — Os diretores da Conta B podem chamar APIs do plano de dados de memória (criar eventos, gravar registros, recuperar registros) em um recurso de memória na Conta A. Isso é configurado anexando uma política baseada em recursos ao recurso de memória.

  High-level etapas:

  1. Configure seu recurso de memória para permitir o acesso entre contas anexando uma política baseada em recursos.

  1. Faça referência ao ARN da memória nas chamadas de API do seu plano de dados da Conta B.
+  **Destinos de entrega em outra conta** — Seu recurso de memória na Conta A pode entregar cargas e eventos de streaming para buckets do Amazon S3, tópicos do Amazon SNS e Amazon Kinesis Data Streams que residem na Conta B. Isso é configurado no momento da criação da memória por meio da função de execução da memória e das políticas de recursos nos recursos de destino.

  High-level etapas:

  1. Crie uma função de execução de memória na Conta A com permissões para acessar os recursos de destino.

  1. Adicione políticas baseadas em recursos aos recursos de destino na Conta B para permitir a função de execução.

  1. Crie a memória na Conta A, referenciando a função de execução e os ARNs de recursos entre contas.

**Topics**
+ [Pré-requisitos](#memory-cross-account-access-prerequisites)
+ [Cross-account acesso ao plano de dados](#memory-cross-account-access-data-plane)
+ [Cross-account destinos de entrega](#memory-cross-account-access-delivery-destinations)
+ [Práticas recomendadas](#memory-cross-account-access-best-practices)

## Pré-requisitos
<a name="memory-cross-account-access-prerequisites"></a>

Antes de configurar o acesso à memória entre contas, verifique se você tem:
+ Um recurso de memória criado na conta do proprietário do recurso (Conta A)
+ O ARN completo do recurso de memória (por exemplo,) `arn:aws:bedrock-agentcore:us-east-1:<account-id>:memory/<memory-id>`
+ Para acesso ao plano de dados: uma função ou usuário do IAM na Conta B com permissões baseadas em identidade que permitem as ações desejadas `bedrock-agentcore`
+ Para destinos de entrega: o bucket S3 de destino, o tópico do SNS ou o Kinesis Data Stream criado na Conta B

## Cross-account acesso ao plano de dados
<a name="memory-cross-account-access-data-plane"></a>

Você pode permitir que diretores em outra conta chamem APIs de plano de dados de memória diretamente em seu recurso de memória. Isso é configurado anexando uma política baseada em recursos à memória usando a API. `PutResourcePolicy` Para obter mais informações sobre políticas baseadas em recursos, consulte as políticas [Resource-based do Amazon](resource-based-policies.md) Bedrock. AgentCore

### Como funciona
<a name="memory-cross-account-access-data-plane-how-it-works"></a>

1. A conta A cria um recurso de memória.

1. A conta A anexa uma política baseada em recursos ao recurso de memória usando a `PutResourcePolicy` API, concedendo ações específicas a um principal na Conta B.

1. Um principal na Conta B chama APIs do plano de dados de memória, especificando o ARN completo do recurso de memória na Conta A como o. `memory-id`

1.  AWS avalia a política baseada em recursos na memória e a política baseada em identidade vinculada ao principal da Conta B. Se ambos permitirem a ação (e nenhuma política a negar explicitamente), a solicitação será bem-sucedida.

### Ações compatíveis
<a name="memory-cross-account-access-supported-actions"></a>

Você pode conceder acesso entre contas para qualquer ação do plano de dados de memória. A tabela a seguir lista as ações disponíveis:


| Ação | Description | 
| --- | --- | 
|  `bedrock-agentcore:CreateEvent`  | Crie um evento de memória de curto prazo | 
|  `bedrock-agentcore:GetEvent`  | Recuperar um evento específico | 
|  `bedrock-agentcore:DeleteEvent`  | Excluir um evento específico | 
|  `bedrock-agentcore:ListEvents`  | Listar eventos em uma sessão | 
|  `bedrock-agentcore:ListActors`  | Listar atores em uma memória | 
|  `bedrock-agentcore:ListSessions`  | Listar sessões para um ator | 
|  `bedrock-agentcore:GetMemoryRecord`  | Recuperar um registro de memória específico | 
|  `bedrock-agentcore:ListMemoryRecords`  | Listar registros de memória em um namespace | 
|  `bedrock-agentcore:RetrieveMemoryRecords`  | Pesquise semanticamente registros de memória | 
|  `bedrock-agentcore:DeleteMemoryRecord`  | Excluir um registro de memória específico | 
|  `bedrock-agentcore:BatchCreateMemoryRecords`  | Crie vários registros de memória | 
|  `bedrock-agentcore:BatchUpdateMemoryRecords`  | Atualizar vários registros de memória | 
|  `bedrock-agentcore:BatchDeleteMemoryRecords`  | Excluir vários registros de memória | 
|  `bedrock-agentcore:ListMemoryExtractionJobs`  | Listar trabalhos de extração para uma memória | 
|  `bedrock-agentcore:StartMemoryExtractionJobs`  | Reiniciar trabalhos de extração com falha | 

### Anexar uma política baseada em recursos a uma memória
<a name="memory-cross-account-access-attach-policy"></a>

#### Conceder uma única ação a outra conta
<a name="memory-cross-account-access-grant-single-action"></a>

O exemplo a seguir concede permissão à Conta B (`<account-B-id>`) para chamar `BatchCreateMemoryRecords` um recurso de memória na Conta A (`<account-A-id>`):

```
aws bedrock-agentcore-control put-resource-policy \
    --region us-east-1 \
    --resource-arn "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --policy '{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "AllowCrossAccountBatchCreate",
                "Effect": "Allow",
                "Principal": {
                    "AWS": "arn:aws:iam::<account-B-id>:root"
                },
                "Action": "bedrock-agentcore:BatchCreateMemoryRecords",
                "Resource": "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>"
            }
        ]
    }'
```

#### Conceder várias ações a outra conta
<a name="memory-cross-account-access-grant-multiple-actions"></a>

O exemplo a seguir concede à Conta B acesso total de leitura e gravação aos registros e eventos de memória:

```
aws bedrock-agentcore-control put-resource-policy \
    --region us-east-1 \
    --resource-arn "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --policy '{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "AllowCrossAccountMemoryReadWrite",
                "Effect": "Allow",
                "Principal": {
                    "AWS": "arn:aws:iam::<account-B-id>:root"
                },
                "Action": [
                    "bedrock-agentcore:CreateEvent",
                    "bedrock-agentcore:GetEvent",
                    "bedrock-agentcore:ListEvents",
                    "bedrock-agentcore:ListActors",
                    "bedrock-agentcore:ListSessions",
                    "bedrock-agentcore:BatchCreateMemoryRecords",
                    "bedrock-agentcore:BatchUpdateMemoryRecords",
                    "bedrock-agentcore:BatchDeleteMemoryRecords",
                    "bedrock-agentcore:ListMemoryRecords",
                    "bedrock-agentcore:RetrieveMemoryRecords",
                    "bedrock-agentcore:GetMemoryRecord",
                    "bedrock-agentcore:DeleteMemoryRecord"
                ],
                "Resource": "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>"
            }
        ]
    }'
```

#### Conceder acesso a uma função específica do IAM
<a name="memory-cross-account-access-grant-specific-role"></a>

Para seguir o princípio do menor privilégio, conceda acesso a uma função específica em vez da conta inteira:

```
aws bedrock-agentcore-control put-resource-policy \
    --region us-east-1 \
    --resource-arn "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --policy '{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Sid": "AllowSpecificRoleReadAccess",
                "Effect": "Allow",
                "Principal": {
                    "AWS": "arn:aws:iam::<account-B-id>:role/AgentMemoryReaderRole"
                },
                "Action": [
                    "bedrock-agentcore:RetrieveMemoryRecords",
                    "bedrock-agentcore:ListMemoryRecords",
                    "bedrock-agentcore:GetMemoryRecord"
                ],
                "Resource": "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>"
            }
        ]
    }'
```

### Remover uma política baseada em recursos
<a name="memory-cross-account-access-remove-policy"></a>

Para revogar o acesso ao plano de dados entre contas, exclua a política baseada em recursos:

```
aws bedrock-agentcore-control delete-resource-policy \
    --region us-east-1 \
    --resource-arn "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>"
```

Depois de excluir a política, todas as solicitações subsequentes entre contas retornam uma. `AccessDeniedException`

### Chame as APIs do plano de dados da Conta B
<a name="memory-cross-account-access-calling-from-account-b"></a>

Depois que a política baseada em recursos é anexada, um diretor na Conta B pode chamar as APIs do plano de dados especificando o ARN da memória completa como o. `memory-id`

Crie registros de memória a partir da Conta B:

```
aws bedrock-agentcore batch-create-memory-records \
    --region us-east-1 \
    --memory-id "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --records '[
      {
        "requestIdentifier": "rec-001",
        "content": {"text": "User prefers morning meeting times before 10 AM"},
        "namespaces": ["preferences/user-123"],
        "timestamp": "1729525989"
      }
    ]'
```

Recupere registros de memória da Conta B:

```
aws bedrock-agentcore retrieve-memory-records \
    --region us-east-1 \
    --memory-id "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --namespace "preferences/user-123" \
    --search-criteria '{"searchQuery": "meeting preferences"}' \
    --max-results 10
```

Crie eventos a partir da Conta B:

```
aws bedrock-agentcore create-event \
    --region us-east-1 \
    --memory-id "arn:aws:bedrock-agentcore:us-east-1:<account-A-id>:memory/<memory-id>" \
    --actor-id "agent-in-account-b" \
    --session-id "cross-account-session-1" \
    --event-timestamp "$(date -u +"%Y-%m-%dT%H:%M:%S.%3NZ")" \
    --payload '[
      {
        "conversational": {
          "content": {"text": "Schedule my standup for 9 AM tomorrow"},
          "role": "USER"
        }
      }
    ]'
```

## Cross-account destinos de entrega
<a name="memory-cross-account-access-delivery-destinations"></a>

Quando você cria uma memória com uma estratégia personalizada (autogerenciada) ou configuração de entrega de streaming, o Amazon Bedrock AgentCore usa uma função de execução de memória para entregar cargas aos seus recursos de destino. Quando esses recursos residem em uma conta diferente, você deve configurar os dois lados: a função de execução na Conta A precisa de permissões para acessar os recursos, e os recursos na Conta B precisam de políticas que permitam o acesso da Conta A.

### Como funciona
<a name="memory-cross-account-access-delivery-how-it-works"></a>

1. Você cria recursos de destino (bucket do S3, tópico do SNS ou Kinesis Data Stream) na Conta B com políticas baseadas em recursos que permitem a função de execução de memória na Conta A.

1. Você cria uma função de execução de memória na Conta A com uma política de confiança para o Amazon Bedrock AgentCore e uma política de permissões que concede acesso aos recursos entre contas na Conta B.

1. Você cria a memória na Conta A, referenciando a função de execução e os ARNs de recursos entre contas.

1. O Amazon Bedrock AgentCore assume a função de execução e a usa para entregar cargas ou transmitir eventos para os recursos na Conta B.

### Configurar a função de execução de memória
<a name="memory-cross-account-access-execution-role"></a>

Crie a função de execução de memória na Conta A. A função exige uma política de confiança que permita AgentCore ao Amazon Bedrock assumi-la e uma política de permissões que conceda acesso aos recursos de destino na Conta B.

Política de confiança:

```
{
"Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "bedrock-agentcore.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "ArnLike": {
          "aws:SourceArn": "arn:aws:bedrock-agentcore:<region>:<account-A-id>:memory/*"
        }
      }
    }
  ]
}
```

Política de permissões (inclua somente as declarações relevantes aos recursos que você está usando):

```
{
"Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowS3Access",
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::<bucket-name-in-account-B>/*"
    },
    {
      "Sid": "AllowSNSPublish",
      "Effect": "Allow",
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:<region>:<account-B-id>:<topic-name>"
    },
    {
      "Sid": "AllowKinesisAccess",
      "Effect": "Allow",
      "Action": [
        "kinesis:PutRecords",
        "kinesis:DescribeStream"
      ],
      "Resource": "arn:aws:kinesis:<region>:<account-B-id>:stream/<stream-name>"
    }
  ]
}
```

### Configurar a política de bucket do S3 na Conta B
<a name="memory-cross-account-access-s3-policy"></a>

Adicione a seguinte política baseada em recursos ao bucket do S3 na Conta B para permitir que a função de execução de memória na Conta A forneça cargas úteis:

```
{
"Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowMemoryExecutionRoleAccess",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::<account-A-id>:role/<memory-execution-role-name>"
      },
      "Action": [
        "s3:PutObject",
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::<bucket-name>/*"
    }
  ]
}
```

### Configurar a política de tópicos do SNS na Conta B
<a name="memory-cross-account-access-sns-policy"></a>

Adicione a seguinte política baseada em recursos ao tópico SNS na Conta B para permitir que a função de execução de memória na Conta A publique notificações:

```
{
"Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowMemoryExecutionRolePublish",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::<account-A-id>:role/<memory-execution-role-name>"
      },
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:<region>:<account-B-id>:<topic-name>"
    }
  ]
}
```

### Configurar a política do Kinesis Data Stream na Conta B
<a name="memory-cross-account-access-kinesis-policy"></a>

Adicione a seguinte política baseada em recursos ao Kinesis Data Stream na Conta B para permitir que a função de execução de memória na Conta A transmita eventos:

```
{
"Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowMemoryExecutionRolePutRecords",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::<account-A-id>:role/<memory-execution-role-name>"
      },
      "Action": [
        "kinesis:PutRecords",
        "kinesis:DescribeStream"
      ],
      "Resource": "arn:aws:kinesis:<region>:<account-B-id>:stream/<stream-name>"
    }
  ]
}
```

### Crie uma memória com contas cruzadas S3 e SNS
<a name="memory-cross-account-access-create-memory-s3-sns"></a>

Depois de configurar a função de execução e as políticas de recursos, crie uma memória na Conta A que faça referência aos recursos entre contas na Conta B:

```
aws bedrock-agentcore-control create-memory \
    --region us-east-1 \
    --name "cross-account-memory" \
    --description "Memory with cross-account S3 and SNS delivery" \
    --event-expiry-duration 30 \
    --memory-execution-role-arn "arn:aws:iam::<account-A-id>:role/MemoryCrossAccountRole" \
    --memory-strategies '[
      {
        "customMemoryStrategy": {
          "name": "cross_account_strategy",
          "configuration": {
            "selfManagedConfiguration": {
              "triggerConditions": [
                {"messageBasedTrigger": {"messageCount": 5}}
              ],
              "invocationConfiguration": {
                "topicArn": "arn:aws:sns:us-east-1:<account-B-id>:memory-notifications",
                "payloadDeliveryBucketName": "<bucket-name>"
              },
              "historicalContextWindowSize": 10
            }
          }
        }
      }
    ]'
```

### Crie uma memória com o streaming Kinesis entre contas
<a name="memory-cross-account-access-create-memory-kinesis"></a>

```
aws bedrock-agentcore-control create-memory \
    --region us-east-1 \
    --name "cross-account-streaming-memory" \
    --description "Memory with cross-account Kinesis streaming" \
    --event-expiry-duration 30 \
    --memory-execution-role-arn "arn:aws:iam::<account-A-id>:role/MemoryCrossAccountRole" \
    --stream-delivery-resources '{
      "resources": [
        {
          "kinesis": {
            "dataStreamArn": "arn:aws:kinesis:us-east-1:<account-B-id>:stream/memory-record-stream",
            "contentConfigurations": [
              {
                "type": "MEMORY_RECORDS",
                "level": "FULL_CONTENT"
              }
            ]
          }
        }
      ]
    }'
```

## Práticas recomendadas
<a name="memory-cross-account-access-best-practices"></a>
+  **Conceda o mínimo de privilégio** — conceda somente as ações específicas necessárias para o responsável pela conta cruzada.
+  **Use diretores específicos** — conceda acesso a funções específicas do IAM em vez de toda a raiz da conta para limitar o raio de explosão.
+  **Audite o acesso entre contas** — use AWS CloudTrail para monitorar chamadas de API entre contas para seus recursos de memória.
+  **Acesso separado de leitura e gravação** — Crie declarações de política separadas para consumidores somente de leitura e produtores de leitura e gravação.
+  **Valide antes de remover políticas** — Antes de remover uma política baseada em recursos, verifique se nenhuma carga de trabalho ativa em outras contas depende do acesso.