Cross-account accès à la mémoire

Amazon Bedrock AgentCore Memory prend en charge l'accès entre comptes, ce qui vous permet de créer des architectures multicomptes dans lesquelles les ressources de mémoire et les agents consommateurs s'étendent sur plusieurs comptes. AWS Cross-account access couvre deux scénarios :

Conditions préalables

Avant de configurer l'accès à la mémoire entre comptes, vérifiez que vous disposez des éléments suivants :

Cross-account accès au plan de données

Vous pouvez autoriser les principaux d'un autre compte à appeler les API du plan de données mémoire directement sur votre ressource mémoire. Ceci est configuré en attachant une politique basée sur les ressources à la mémoire à l'aide de l'PutResourcePolicyAPI. Pour plus d'informations sur les politiques basées sur les ressources, consultez les politiques d'Amazon Resource-based Bedrock. AgentCore

Comment ça marche

Actions prises en charge

Vous pouvez accorder un accès entre comptes pour n'importe quelle action sur le plan de données de la mémoire. Le tableau suivant répertorie les actions disponibles :

Associer une politique basée sur les ressources à une mémoire

Accorder une seule action à un autre compte

L'exemple suivant autorise le compte B (<account-B-id>) à appeler BatchCreateMemoryRecords une ressource mémoire dans le compte 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>"
            }
        ]
    }'

Accorder plusieurs actions à un autre compte

L'exemple suivant accorde au compte B un accès complet en lecture et en écriture aux enregistrements et événements en mémoire :

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>"
            }
        ]
    }'

Accorder l'accès à un rôle IAM spécifique

Pour respecter le principe du moindre privilège, accordez l'accès à un rôle spécifique plutôt qu'à l'intégralité du compte :

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>"
            }
        ]
    }'

Supprimer une politique basée sur les ressources

Pour révoquer l'accès au plan de données entre comptes, supprimez la politique basée sur les ressources :

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>"

Après avoir supprimé la politique, toutes les demandes intercomptes suivantes renvoient unAccessDeniedException.

Appelez les API du plan de données depuis le compte B

Une fois que la politique basée sur les ressources est attachée, un principal du compte B peut appeler les API du plan de données en spécifiant l'ARN de la mémoire complète comme étant le. memory-id

Créez des enregistrements de mémoire à partir du compte 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"
      }
    ]'

Récupérez les enregistrements de mémoire du compte 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

Créez des événements à partir du compte 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 destinations de livraison

Lorsque vous créez une mémoire avec une stratégie personnalisée (autogérée) ou une configuration de diffusion de flux, Amazon Bedrock AgentCore utilise un rôle d'exécution de mémoire pour acheminer les charges utiles vers vos ressources de destination. Lorsque ces ressources résident dans un compte différent, vous devez configurer les deux côtés : le rôle d'exécution dans le compte A nécessite des autorisations pour accéder aux ressources, et les ressources dans le compte B ont besoin de politiques autorisant l'accès depuis le compte A.

Comment ça marche

Configuration du rôle d'exécution de la mémoire

Créez le rôle d'exécution de la mémoire dans le compte A. Ce rôle nécessite une politique de confiance qui permet AgentCore à Amazon Bedrock de l'assumer, et une politique d'autorisation qui accorde l'accès aux ressources cibles dans le compte B.

Stratégie d'approbation :

{
"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/*"
        }
      }
    }
  ]
}

Politique d'autorisation (incluez uniquement les déclarations relatives aux ressources que vous utilisez) :

{
"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>"
    }
  ]
}

Configurer la politique du compartiment S3 dans le compte B

Ajoutez la politique basée sur les ressources suivante au compartiment S3 du compte B pour permettre au rôle d'exécution de la mémoire du compte A de fournir des charges utiles :

{
"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>/*"
    }
  ]
}

Configurer la politique des rubriques SNS dans le compte B

Ajoutez la politique basée sur les ressources suivante à la rubrique SNS du compte B pour permettre au rôle d'exécution de la mémoire dans le compte A de publier des notifications :

{
"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>"
    }
  ]
}

Configuration de la politique Kinesis Data Stream dans le compte B

Ajoutez la politique basée sur les ressources suivante au flux de données Kinesis dans le compte B pour permettre au rôle d'exécution de la mémoire dans le compte A de diffuser des événements :

{
"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>"
    }
  ]
}

Créez une mémoire avec S3 et SNS entre comptes

Après avoir configuré le rôle d'exécution et les politiques de ressources, créez une mémoire dans le compte A qui référence les ressources entre comptes dans le compte 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
            }
          }
        }
      }
    ]'

Créez une mémoire grâce au streaming Kinesis entre comptes

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"
              }
            ]
          }
        }
      ]
    }'

Bonnes pratiques