View a markdown version of this page

Exemple : autorisation pour la passerelle et la cible par défaut créées par la AgentCore CLI - Base rocheuse de l'Amazonie AgentCore

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exemple : autorisation pour la passerelle et la cible par défaut créées par la AgentCore CLI

Si vous avez utilisé la AgentCore CLI pour créer une passerelle et une cible Lambda, la CLI configure automatiquement l'autorisation JWT-based entrante et l'autorisation IAM-based sortante pour vous.

Note

Si vous appelez votre passerelle à l'aide deagentcore invoke, la CLI gère automatiquement l'authentification. Les étapes ci-dessous ne sont nécessaires que si vous souhaitez appeler la passerelle par programmation (par exemple, à l'aide du AWS SDK ou). curl

Pour l'accès par programmation, vous devez autoriser comme suit :

  • Autorisation entrante à l'aide de JWT  : obtenez le jeton d'accès à partir de l'autorisation Amazon Cognito qui a été automatiquement configurée pour vous et incluez-le dans l'en-tête d'autorisation. Consultez l'exemple ci-dessous pour savoir comment obtenir le jeton.

  • Autorisation sortante à l'aide d'IAM — La AgentCore CLI configure les autorisations suivantes pour vous, vous n'avez donc pas besoin de configuration supplémentaire :

    • Votre rôle de service de passerelle est autorisé à invoquer toutes les fonctions de Lambda (fournies par la politique BedrockAgentCoreFullAccess gérée).

    • La fonction Lambda créée est configurée avec votre rôle de service de passerelle, Principal qui peut l'invoquer.

Vous pouvez obtenir le jeton d'accès créé pour votre passerelle par la AgentCore CLI à l'aide d'Amazon Cognito en collectant les informations suivantes :

  • Point de terminaison du jeton  : recherchez l'URL de découverte dans la configuration de l'autorisateur pour la passerelle. Si vous utilisez l'API, vous pouvez trouver l'URL de découverte en envoyant une ListGateways requête ou une GetGateway requête pour votre passerelle.

  • ID client  : recherchez les informations du groupe d'utilisateurs Amazon Cognito. Si vous utilisez l'API, vous pouvez envoyer une ListUserPools demande ou une DescribeUserPool demande pour le groupe d'utilisateurs associé à votre passerelle.

  • Secret du client  : recherchez les informations sur le client de l'application du groupe d'utilisateurs Amazon Cognito. Si vous utilisez l'API, vous pouvez envoyer une DescribeUserPoolClient demande en spécifiant l'ID client et l'ID du groupe d'utilisateurs associés à votre passerelle.

Commencez par collecter ces valeurs à l'aide de l'une des méthodes suivantes. Sélectionnez l'une des méthodes suivantes :

Exemple
Console

  1. Obtenez le point de terminaison du jeton  :

    1. Ouvrez la AgentCore console à l'adresse https://console.aws.amazon.com/bedrock-agentcore/home #.

    2. Dans le volet de navigation de gauche, choisissez Gateways.

    3. Dans la section Passerelles, sélectionnez votre passerelle.

    4. Dans la section Identité entrante, notez les valeurs suivantes :

      • Clients autorisés  : ID des clients qui peuvent accéder à la passerelle.

      • URL de découverte  : le format doit êtrehttps://cognito-idp.${Region}.amazonaws.com/${UserPoolId}/.well-known/openid-configuration. Stockez les valeurs suivantes :

        • ${UserPoolId}— Extrait de l'URL de découverte.

        • Point de terminaison du jeton  : sélectionnez le lien URL de découverte et recherchez la valeur dans le token_endpoint champ.

  2. Obtenez l'ID client et le code secret du client  :

    1. Ouvrez la console Amazon Cognito à l'adresse https://console.aws.amazon.com/cognito.

    2. Dans le volet de navigation de gauche, sélectionnez Groupes d'utilisateurs.

    3. Sélectionnez l'ID du groupe d'utilisateurs associé à votre passerelle.

    4. Dans le volet de navigation de gauche, choisissez App clients.

    5. Sélectionnez un client d'application dont l'ID client correspond aux clients autorisés pour votre point de terminaison de jeton. Enregistrez la valeur de l'ID.

    6. Sous Secret client, sélectionnez Afficher le secret client et enregistrez cette valeur.

AWS CLI

  1. Exécutez la AgentCore get-gateway commande dans un terminal et spécifiez l'ID de votre passerelle dans l'--gateway-identifierargument, comme dans l'exemple suivant :

    aws bedrock-agentcore-control get-gateway --gateway-identifier my-gateway-id

  2. À partir de la réponse, notez ce qui discoveryUrl suit authorizerConfiguration dans le champ :

    • Stockez le ${UserPoolId} contenu de l'URL. Le format doit êtrehttps://cognito-idp.${Region}.amazonaws.com/${UserPoolId}/.well-known/openid-configuration.

    • Stockez les allowedClients valeurs. Il s'agit des ID clients qui peuvent accéder au point de terminaison du jeton.

    • Accédez au discoveryUrl dans un navigateur et enregistrez la token_endpoint valeur.

  3. Exécutez la describe-user-pool-client commande Amazon Cognito dans un terminal et spécifiez l'ID du groupe d'utilisateurs dans l'--user-pool-idargument et un ID client autorisé dans le --client-id champ, comme dans l'exemple suivant :

    aws cognito-idp describe-user-pool-client --user-pool-id my-user-pool-id --client-id my-client-id

  4. Stockez la ClientSecret valeur.

AWS Python SDK (Boto3)

  1. Exécutez le code Python suivant pour stocker le point de terminaison du jeton, l'ID client et le secret client sous forme de variables :

    import requests
  import boto3

  # Initialize AWS clients
  agentcore_client = boto3.client("bedrock-agentcore-control")
  cognito_client = boto3.client("cognito-idp")

  # Replace with your actual gateway ID
  gateway_id = "my-gateway-id"

  # Get discovery URL and first allowed client
  auth_config = agentcore_client.get_gateway(gatewayIdentifier=gateway_id)["authorizerConfiguration"]["customJWTAuthorizer"]
  discovery_url, client_id = auth_config["discoveryUrl"], auth_config["allowedClients"][0]

  # Get token endpoint from discovery URL
  discovery_url_json = requests.get(discovery_url).json()
  token_endpoint, user_pool_id = discovery_url_json["token_endpoint"], discovery_url_json["issuer"].split("/")[-1]

  # Get client secret
  client_secret = cognito_client.describe_user_pool_client(
      UserPoolId=user_pool_id,
      ClientId=client_id
  )["UserPoolClient"]["ClientSecret"]

Ensuite, utilisez les valeurs que vous avez collectées pour accéder au jeton depuis le point de terminaison du jeton. Sélectionnez l'une des méthodes suivantes :

Exemple
curl

  1. Exécutez la commande suivante dans un terminal, en remplaçant le point de terminaison du jeton, l'ID client et les valeurs secrètes du client.

    curl --http1.1 -X POST ${TokenEndpoint} \
    -H "Content-Type: application/x-www-form-urlencoded" \
    -d "grant_type=client_credentials&client_id=${ClientId}&client_secret=${ClientSecret}"

    Le jeton se trouve dans le access_token champ de la réponse, alors que le token_type champ doit spécifierBearer.

Python requests package

  1. Exécutez le code Python suivant pour obtenir votre jeton d'accès. Le code part du principe que vous avez enregistré les client_secret valeurs token_endpointclient_id, et de l'étape précédente :

    import requests
  import json

  def get_access_token(token_endpoint, client_id, client_secret):
      headers={
          "Content-Type": "application/x-www-form-urlencoded"
      }

      payload={
          "grant_type": "client_credentials",
          "client_id": client_id,
          "client_secret": client_secret
      }

      response = requests.post(token_endpoint, headers=headers, data=payload)
      return response.json()

  # Replace the argument values as necessary, if you didn't previously store them as these variables
  access_token_response = get_access_token(
      token_endpoint=token_endpoint,
      client_id=client_id,
      client_secret=client_secret
  )

  access_token = access_token_response["access_token"]