View a markdown version of this page

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

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, l'interface de ligne de commande configure automatiquement l'autorisation JWT-based entrante et IAM-based l'autorisation sortante pour vous.

Note

Si vous appelez votre passerelle en utilisantagentcore 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 programmatique, vous devez autoriser avec les éléments suivants :

  • Autorisation entrante à l'aide de JWT : obtenez le jeton d'accès issu 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 BedrockAgentCoreFullAccessgérée).

    • La fonction Lambda créée est configurée avec votre rôle de service de passerelle en tant Principal que personne capable de 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 ListGatewaysrequête ou une GetGatewayrequête à votre passerelle.

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

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

Collectez d'abord 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, sélectionnez 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 autorisés à 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 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 jeton. Stockez la valeur de l'ID.

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

AWS CLI

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

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

  2. Dans la réponse, notez ce qui se discoveryUrl trouve authorizerConfiguration dans le champ :

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

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

    • Accédez au discoveryUrl dans un navigateur et stockez 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 identifiant 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 du 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 le spécifierBearer.

Python requests package

  1. Exécutez le code Python suivant pour obtenir votre jeton d'accès. Le code suppose 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"]