View a markdown version of this page

Configurer l'autorité de certification racine pour le navigateur Amazon Bedrock AgentCore - Amazon Bedrock AgentCore
Comment ça marcheConditions préalablesStockez votre certificat dans AWS Secrets ManagerDémarrez une session de navigateur avec des certificats personnalisésUtilisation de plusieurs certificatsConfiguration des certificats au niveau de l'outilExigences et limites des certificats

Configurer l'autorité de certification racine pour le navigateur Amazon Bedrock AgentCore

Par défaut, les sessions du AgentCore navigateur Amazon Bedrock ne font confiance qu'aux autorités de certification reconnues publiquement. Si vos agents ont besoin d'accéder à des services internes, à des sites Web d'entreprise ou à des ressources TLS-intercepting via un proxy utilisant des certificats signés par une autorité de certification privée, vous devez fournir vos certificats d'autorité racine personnalisés lors du démarrage d'une session.

Amazon Bedrock AgentCore récupère le contenu des PEM-encoded certificats auprès de AWS Secrets Manager à l'aide des informations d'identification de votre appelant, valide le X.509 format et l'expiration, et installe les certificats dans le magasin de confiance du système d'exploitation de la session. Cela permet au navigateur d'établir des connexions HTTPS fiables avec vos ressources internes.

Comment ça marche

L'autorité de certification racine pour le AgentCore navigateur Amazon Bedrock fonctionne comme suit :

  1. Vous fournissez une liste d'emplacements de certificats, chacun pointant vers un secret dans AWS Secrets Manager contenant un certificat CA PEM-encoded racine.

  2. Amazon Bedrock AgentCore utilise les informations d'identification de votre appelant pour récupérer chaque certificat auprès de AWS Secrets Manager.

  3. Chaque certificat est validé selon le format X.509 PEM correct et vérifié pour s'assurer qu'il n'a pas expiré et qu'il n'est pas utilisé avant sa date de début de validité.

  4. Les certificats valides sont déployés dans le magasin de confiance du système d'exploitation de la session, ce qui les met à la disposition du navigateur et de tous les clients réseau du sandbox.

Les certificats configurés au niveau de l'outil (jusqu'àCreateBrowser) sont combinés à tous les certificats fournis au début de la session. Cela vous permet de définir des certificats à l'échelle de l'organisation sur l'outil et d'ajouter des certificats spécifiques à la session si nécessaire.

Note

La configuration des certificats est une opération unique par session. Une fois les certificats installés, ils ne peuvent pas être modifiés pendant la durée de cette session.

Conditions préalables

Avant de configurer les certificats de l'autorité de certification racine, assurez-vous de disposer des éléments suivants :

  • Vous avez rempli les prérequis généraux.

  • Vos certificats CA racine sont stockés sous forme de AWS secrets dans Secrets Manager. Chaque secret doit contenir PEM-encoded X.509 un certificat valide

  • Autorisations IAM pour lire les secrets du certificat depuis AWS Secrets Manager. Ajoutez les autorisations suivantes à votre politique IAM :

    {
"Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "SecretsManagerCertificateAccess",
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue"
            ],
            "Resource": "arn:aws:secretsmanager:<Region>:<account-id>:secret:<secret-name>"
        }
    ]
}

Stockez votre certificat dans AWS Secrets Manager

Avant de pouvoir utiliser un certificat CA racine avec le AgentCore navigateur Amazon Bedrock, vous devez le stocker en tant que secret dans AWS Secrets Manager. La valeur secrète doit être le contenu du PEM-encoded certificat.

Exemple
AWS CLI

  1. aws secretsmanager create-secret \
  --name "my-corporate-root-ca" \
  --description "Corporate root CA certificate for AgentCore sessions" \
  --secret-string file://my-root-ca.pem \
  --region <region>
Boto3

  1. import boto3

client = boto3.client('secretsmanager', region_name='<region>')

# Read the PEM certificate file
with open('my-root-ca.pem', 'r') as f:
    cert_content = f.read()

response = client.create_secret(
    Name='my-corporate-root-ca',
    Description='Corporate root CA certificate for AgentCore sessions',
    SecretString=cert_content
)

print(f"Secret ARN: {response['ARN']}")

Notez l'ARN secret de la sortie. Vous utiliserez cet ARN lorsque vous démarrerez des sessions avec une configuration de certificat.

Important

Le secret doit contenir un PEM-encoded X.509 certificat valide. Le certificat ne doit pas être expiré et doit respecter sa période de validité. Amazon Bedrock AgentCore valide le format et l'expiration du certificat avant de l'installer.

Démarrez une session de navigateur avec des certificats personnalisés

Pour démarrer une session de navigateur qui fait confiance à vos certificats d'autorité de certification racine personnalisés, incluez le certificates paramètre dans votre StartBrowserSession demande.

Exemple
AWS CLI

  1. aws bedrock-agentcore start-browser-session \
  --browser-identifier "aws.browser.v1" \
  --name "session-with-custom-ca" \
  --certificates '[
    {
      "location": {
        "secretsManager": {
          "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:<secret-name>"
        }
      }
    }
  ]'
Boto3

  1. import boto3

client = boto3.client('bedrock-agentcore', region_name='<region>')

response = client.start_browser_session(
    browserIdentifier="aws.browser.v1",
    name="session-with-custom-ca",
    certificates=[
        {
            "location": {
                "secretsManager": {
                    "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:<secret-name>"
                }
            }
        }
    ]
)

print(f"Session ID: {response['sessionId']}")
print(f"Status: {response['status']}")
API

  1. {
  "name": "session-with-custom-ca",
  "certificates": [
    {
      "location": {
        "secretsManager": {
          "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:<secret-name>"
        }
      }
    }
  ]
}

Utilisation de plusieurs certificats

Vous pouvez fournir plusieurs certificats d'autorité de certification racine au cours d'une seule session de navigateur. Cela est utile lorsque votre environnement nécessite la confiance de plusieurs autorités de certification internes, telles que des autorités de certification distinctes pour différents services ou environnements internes.

Exemple
AWS CLI

  1. aws bedrock-agentcore start-browser-session \
  --browser-identifier "aws.browser.v1" \
  --name "session-with-multiple-cas" \
  --certificates '[
    {
      "location": {
        "secretsManager": {
          "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:corporate-root-ca"
        }
      }
    },
    {
      "location": {
        "secretsManager": {
          "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:proxy-ca"
        }
      }
    }
  ]'
Boto3

  1. response = client.start_browser_session(
    browserIdentifier="aws.browser.v1",
    name="session-with-multiple-cas",
    certificates=[
        {
            "location": {
                "secretsManager": {
                    "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:corporate-root-ca"
                }
            }
        },
        {
            "location": {
                "secretsManager": {
                    "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:proxy-ca"
                }
            }
        }
    ]
)

Configuration des certificats au niveau de l'outil

Vous pouvez configurer les certificats au niveau de l'outil lors de la création d'un navigateur personnalisé. Les certificats configurés au niveau de l'outil sont automatiquement appliqués à chaque session démarrée avec cet outil, en plus des certificats fournis au début de la session.

Cela est utile pour les certificats à l'échelle de l'organisation qui devraient être approuvés par toutes les sessions du navigateur.

Exemple
Boto3

  1. response = client.create_browser(
    name="corporate-browser",
    description="Browser with corporate CA trust",
    certificates=[
        {
            "location": {
                "secretsManager": {
                    "secretArn": "arn:aws:secretsmanager:<region>:<account-id>:secret:corporate-root-ca"
                }
            }
        }
    ]
)

browser_id = response['browserIdentifier']
print(f"Browser ID: {browser_id}")

Lorsque vous démarrez une session avec un navigateur dans lequel des certificats sont configurés, les certificats de niveau outil sont combinés à tous les certificats de niveau session. Tool-level les certificats sont appliqués en premier, suivis des certificats au niveau de la session.

Exigences et limites des certificats

Les certificats doivent répondre aux exigences suivantes :

Exigence Détails

Format

PEM-encoded X.509 certificat

Stockage

AWS Secret Secrets Manager (sous forme de chaîne, pas de binaire)

Validité

Le certificat ne doit pas être expiré et doit respecter sa période de validité (entre notBefore et notAfter dates)

Nombre maximum de certificats par session

10 par session et 10 par outil. Une session peut contenir jusqu'à 20 certificats au total.

Format d'ARN secret

arn:aws:secretsmanager:region:account-id:secret:secret-name

Type de lieu

Seul AWS Secrets Manager est pris en charge comme emplacement de certificats