# AgentCore démarrage rapide des paiements Ce didacticiel vous explique comment configurer AgentCore les paiements et traiter votre première microtransaction. À la fin, votre agent paiera pour une ressource en utilisant le protocole x402 sur un réseau de test. Vous pouvez configurer les paiements de deux manières : + [Utilisation de la compétence AgentCore Paiements](#payments-getting-started-skill) — Une expérience de configuration automatisée qui fournit toutes les ressources par le biais d'une conversation guidée avec des agents de codage basés sur l'IA tels que Kiro, Claude Code ou Codex. La compétence gère les commandes CLI, les scripts du SDK et le câblage du framework à votre place. + [Utilisation de la CLI, du SDK ou de Boto3](#payments-getting-started-manual) : configuration manuelle étape par étape à l'aide de la CLI, du AWS SDK ou de la AgentCore CLI directement. AWS ## Utilisation de la compétence AgentCore Paiements La compétence AgentCore Paiements automatise l'ensemble du processus de configuration grâce à une expérience guidée interactive. Il fournit les ressources suivantes : + **PaymentCredentialProvider**— Stocke les informations d'identification du fournisseur de paiement dans AgentCore Identity. + **Payment Manager** : ressource de haut niveau qui coordonne les opérations de paiement. + **Connecteur de paiement** : relie le gestionnaire à vos informations d'identification via la AgentCore CLI. + **Instrument de paiement** — Un portefeuille crypté que votre agent utilise pour payer les commerçants au nom d'un utilisateur. + **Session de paiement** — Un contexte limité dans le temps avec des limites de dépenses. La compétence transfère également les paiements à votre agent à l'aide d'un outil indépendant du framework, de sorte qu'elle fonctionne avec Strands, le SDK LangGraph OpenAI Agents ou n'importe quel framework Python. ### Conditions préalables Avant de commencer, assurez-vous d'avoir : + ** AWS Compte** avec informations d'identification configurées (`aws configure`) + ** AWS Région dans laquelle AgentCore les paiements sont disponibles** : us-east-1, us-west-2, eu-central-1 ou ap-southeast-2. Voir [AWS Régions prises en charge](agentcore-regions.md). + **Node.js Plus de 20** personnes installées (la compétence installe automatiquement la AgentCore CLI) + **Un agent qui accède à un point de terminaison payant** : cette compétence permet à votre agent de payer pour des API protégées par x402. Pour les tests, vous pouvez utiliser le point de terminaison `https://sandbox.node4all.com/v1/x402-test` sandbox. + **L'[Agent Toolkit pour AWS](https://github.com/aws/agent-toolkit-for-aws) `aws-agents` le plugin** installé dans votre agent de codage AI : **Example** ------ #### [ Claude Code ] ``` /plugin marketplace add aws/agent-toolkit-for-aws /plugin install aws-agents@agent-toolkit-for-aws ``` ------ #### [ Codex ] Le plugin est découvert automatiquement à partir du manifeste du marché. Pour ajouter le site de vente, exécutez la commande suivante : ``` codex plugin marketplace add aws/agent-toolkit-for-aws ``` ------ ### Invoquez la compétence La compétence de paiement fait partie de la `agents-build` compétence de la boîte à [outils des agents pour AWS](https://github.com/aws/agent-toolkit-for-aws). Pour le déclencher, décrivez votre intention dans votre agent de codage AI. Par exemple : + « Ajouter des paiements à mon agent en utilisant le `aws-agents` plugin `agents-build` skill in » + « Configurer des microtransactions pour mon agent à l'aide du `aws-agents` plugin `agents-build` skill in » + « Je dois gérer 402 réponses de paiement requises à l'aide du `aws-agents` plugin `agents-build` skill in » + « Téléphonez à mon agent pour qu'il paie pour des API protégées par x402 en utilisant `agents-build` Skill in Plugin » `aws-agents` La compétence détecte les intentions liées au paiement et charge automatiquement le flux de travail des paiements. ### À quoi sert la compétence La compétence exécute un processus automatisé qui approvisionne votre infrastructure de paiement de bout en bout. La compétence exécute automatiquement la plupart des étapes et s'arrête deux fois pour que vous saisissiez : 1. Vérifie ou installe la AgentCore CLI et configure le projet 1. Crée le gestionnaire de paiement 1. **Pauses** — Vous courez `agentcore add payment-connector` pour saisir les secrets de votre fournisseur (informations d'identification Coinbase CDP ou Stripe Privy) 1. Déploie des ressources sur votre AWS compte () `agentcore deploy -y` 1. Transfère un outil de paiement indépendant du framework (`x402_payment_tool.py`) à votre agent 1. Crée un portefeuille (instrument) par utilisateur et une session limitée au budget via le SDK 1. **Pauses** — Vous autorisez le portefeuille (délégation) et vous le financez avec testnet USDC depuis le site Web de [Circle](https://faucet.circle.com/) Faucet 1. Définit les variables d'environnement et exécute un paiement test sur un point de terminaison payant Avant d'exécuter la commande connector, obtenez les informations d'identification de votre fournisseur : + **Coinbase CDP** — ID de clé d'API, secret de clé d'API et secret de portefeuille provenant du site Web de [Coinbase Developer Platform](https://portal.cdp.coinbase.com/) (avec signature déléguée activée). + **Stripe Privy** — ID d'application, secret de l'application, ID d'autorisation et clé privée d'autorisation depuis le site Web du tableau de [bord Privy.](https://dashboard.privy.io/) Une exécution réussie indique que l'agent appelle`x402_fetch`, détecte un paiement`402`, règle un paiement via le AgentCore SDK, puis réessaie de revenir `200` avec du contenu payant. ## Utilisation de la CLI, du SDK ou de Boto3 Cette section explique chaque étape manuellement à l'aide de la AgentCore CLI, de l'interface de AWS ligne de commande ou du AWS SDK (Boto3). ### Conditions préalables Avant de commencer, assurez-vous d'avoir : + ** AWS Compte** avec informations d'identification configurées (`aws configure`) + **Python 3.10\+ installé** + ** AWS Région dans laquelle AgentCore les paiements sont disponibles** : us-east-1, us-west-2, eu-central-1 ou ap-southeast-2. Voir [AWS Régions prises en charge](agentcore-regions.md). Installez les packages requis : ``` pip install boto3 bedrock-agentcore[strands-agents] strands-agents strands-agents-tools ``` Vérifiez que vos informations d'identification sont configurées : ``` aws sts get-caller-identity ``` **Astuce** Si la AgentCore CLI v0.19.0 ou version ultérieure est installée, vous pouvez utiliser les commandes de la CLI comme alternative au SDK aux étapes 2, 3, 5 et 6. Chaque étape ci-dessous montre les deux options. ### Étape 1 : obtenir les informations d'identification du fournisseur de services de paiement AgentCore payments se connecte à un fournisseur de paiement externe pour les opérations de portefeuille. Vous avez besoin des informations d'identification de l'un des fournisseurs pris en charge avant de continuer. **Example** 1. Connectez-vous à la [plateforme de développement Coinbase](https://docs.cdp.coinbase.com/api-reference/v2/authentication) et créez ou sélectionnez un projet. 1. Générez une clé d'API et notez l'**ID de la clé d'****API, le secret de la clé** d'API et le **secret du portefeuille**. 1. Sous **Projet** > **Portefeuilles** > **Non-custodial Portefeuille** > **Sécurité**, activez la **signature déléguée**. Vous utiliserez ces trois valeurs à l'étape suivante : | Informations d'identification | Description | | --- | --- | | `API Key ID` | Identifiant public pour votre projet CDP | | `API Key Secret` | Secret privé pour la signature des demandes d'API | | `Wallet Secret` | Secret pour les opérations de portefeuille cryptographique (dérivation d'adresses, signature de transactions) | 1. Créez une application **Privy dédiée** sur [dashboard.privy.io](https://dashboard.privy.io/). Ne réutilisez pas les applications qui servent à d'autres fins. 1. Copiez l'**identifiant** et le **secret de l'application** depuis les paramètres de votre application. 1. Accédez à **Wallet Infrastructure** > **Autorisation** et choisissez **New Key** pour générer une paire de P-256 clés. Vous utiliserez ces quatre valeurs à l'étape suivante : | Informations d'identification | Description | | --- | --- | | `App ID` | L'identifiant de votre application Privy | | `App Secret` | Secret de l'authentification de base de serveur à serveur | | `Authorization ID` | Identifiant de clé publique issu de la paire de P-256 clés | | `Authorization Private Key` | Clé privée issue de la paire de P-256 clés | Pour plus de détails, y compris les meilleures pratiques en matière de sécurité et la rotation des identifiants, consultez la section [Conditions préalables](payments-prerequisites.md). ### Étape 2 : Stocker les informations d'identification dans AgentCore Identity Conservez les informations d'identification de votre fournisseur de services de paiement sous forme de PaymentCredentialProvider. Cela permet de conserver les AWS secrets dans Secrets Manager plutôt que dans le code de votre application. **Example** ``` import boto3 client = boto3.client("bedrock-agentcore-control", region_name="us-west-2") credential_provider = client.create_payment_credential_provider( name="my-coinbase-credentials", credentialProviderVendor="CoinbaseCDP", coinbaseCdpConfig={ "apiKeyId": "", "apiKeySecret": "", "walletSecret": "" } ) CREDENTIAL_PROVIDER_ARN = credential_provider["credentialProviderArn"] print(f"Credential provider created: {CREDENTIAL_PROVIDER_ARN}") ``` ``` import boto3 client = boto3.client("bedrock-agentcore-control", region_name="us-west-2") credential_provider = client.create_payment_credential_provider( name="my-privy-credentials", credentialProviderVendor="StripePrivy", stripePrivyConfig={ "appId": "", "appSecret": "", "authorizationId": "", "authorizationPrivateKey": "" } ) CREDENTIAL_PROVIDER_ARN = credential_provider["credentialProviderArn"] print(f"Credential provider created: {CREDENTIAL_PROVIDER_ARN}") ``` Pour le schéma complet de demande et de réponse, reportez-vous [CreatePaymentCredentialProvider](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentCredentialProvider.html)à la référence de l'API. #### Alternative à la CLI : enregistrer les informations d'identification Avec la AgentCore CLI, le stockage des informations d'identification se fait automatiquement lorsque vous ajoutez un connecteur de paiement (étape 3). Ignorez cette étape si vous prévoyez d'utiliser le chemin de la CLI. ### Étape 3 : créer un gestionnaire de paiement et un connecteur Un gestionnaire de paiement est la ressource de haut niveau qui coordonne les opérations de paiement. Un connecteur de paiement relie le gestionnaire aux informations d'identification de votre fournisseur de paiement. Avant de créer ces ressources, configurez les rôles IAM requis, comme décrit dans la section Rôles [IAM pour AgentCore les paiements](payments-iam-roles.md). **Example** Pour une présentation complète de la console, y compris l'autorisation JWT et les réclamations personnalisées, voir [Créer un gestionnaire et un connecteur de paiements](payments-create-manager.md). 1. Ouvrez la [ AgentCore console Amazon Bedrock.](https://console.aws.amazon.com/bedrock-agentcore/) 1. Dans le volet de navigation, sous **Build**, sélectionnez **Payments**. 1. Choisissez **Créer un gestionnaire de paiements**. 1. Entrez le **nom** de votre gestionnaire de paiement. 1. Sous **Autorisations**, choisissez **Créer et utiliser un nouveau rôle de service** (ou sélectionnez un rôle existant). 1. Sous **Inbound Auth**, choisissez **Utiliser le nom d'utilisateur IAM pour l'autorisation IAM**. 1. (Facultatif) Dans la section **Connecteur de paiement**, choisissez un nom pour le connecteur et sélectionnez une authentification sortante existante ou créez-en une nouvelle en sélectionnant votre fournisseur (Coinbase ou Stripe Privy) et en saisissant vos informations d'identification. 1. Choisissez **Créer un gestionnaire de paiements**. La CLI crée le fournisseur d'informations d'identification, le gestionnaire de paiement et le connecteur de paiement en un seul flux. Depuis le répertoire de votre AgentCore projet, ajoutez un gestionnaire de paiement et un connecteur ensemble. **Assistant interactif :** ``` agentcore add payment-manager ``` L'assistant demande le nom du responsable, le modèle (intercepteur), le mode de paiement automatique et la limite de dépenses par défaut. Il demande ensuite s'il faut ajouter un connecteur et passe en revue la sélection du fournisseur et la saisie des informations d'identification. **Non-interactive (Coinbase CDP) :** ``` agentcore add payment-manager \ --name my-payment-manager \ --auto-payment \ --default-spend-limit 5.00 agentcore add payment-connector \ --manager my-payment-manager \ --name my-coinbase-connector \ --provider CoinbaseCDP \ --api-key-id \ --api-key-secret \ --wallet-secret ``` **Non-interactive (Privé) :** ``` agentcore add payment-manager \ --name my-payment-manager \ --auto-payment \ --default-spend-limit 5.00 agentcore add payment-connector \ --manager my-payment-manager \ --name my-privy-connector \ --provider StripePrivy \ --app-id \ --app-secret \ --authorization-id \ --authorization-private-key ``` Après l'ajout, déployez pour approvisionner l'infrastructure de paiement : ``` agentcore deploy ``` L'étape de déploiement crée des rôles IAM, stocke les informations d'identification dans AgentCore Identity et approvisionne le gestionnaire de paiements et le connecteur. Vous verrez « Création d'une infrastructure de paiement... » dans le résultat. Le AgentCore SDK crée le gestionnaire de paiements, le fournisseur d'identifiants et le connecteur en un seul appel. ``` from bedrock_agentcore.payments import PaymentClient payment_client = PaymentClient(region_name="us-west-2") response = payment_client.create_payment_manager_with_connector( payment_manager_name="my-first-payment-manager", payment_manager_description="Payment manager for my agent.", authorizer_type="AWS_IAM", role_arn="", payment_connector_config={ "name": "my-coinbase-connector", "description": "Coinbase CDP connector", "payment_credential_provider_config": { "name": "my-coinbase-provider", "credential_provider_vendor": "CoinbaseCDP", "credentials": { "api_key_id": "", "api_key_secret": "", "wallet_secret": "", }, }, }, wait_for_ready=True, max_wait=300, poll_interval=5, ) PAYMENT_MANAGER_ARN = response["paymentManager"]["paymentManagerArn"] PAYMENT_CONNECTOR_ID = response["paymentConnector"]["paymentConnectorId"] print(f"Payment Manager ARN: {PAYMENT_MANAGER_ARN}") print(f"Connector ID: {PAYMENT_CONNECTOR_ID}") ``` Pour Stripe Privy, remplacez le par `credential_provider_vendor: "StripePrivy"` et `payment_credential_provider_config` les informations d'identification Privy correspondantes. Créez le gestionnaire de paiements : ``` aws bedrock-agentcore-control create-payment-manager \ --name "my-first-payment-manager" \ --authorizer-type AWS_IAM \ --role-arn "" \ --region us-west-2 ``` Une fois que le responsable a atteint `READY` le statut, créez un fournisseur d'informations d'identification et un connecteur. Voir [Créer un gestionnaire de paiement et un connecteur](payments-create-manager.md) pour le flux de travail complet de la AWS CLI. Créez d'abord le gestionnaire de paiement (le même pour les deux fournisseurs) : ``` import time manager = client.create_payment_manager( name="my-first-payment-manager", authorizerType="AWS_IAM", roleArn="" ) PAYMENT_MANAGER_ARN = manager["paymentManagerArn"] print(f"Payment Manager created: {PAYMENT_MANAGER_ARN}") # Wait for the manager to reach READY state while True: status = client.get_payment_manager(paymentManagerArn=PAYMENT_MANAGER_ARN) if status["status"] == "READY": break print(f"Status: {status['status']}... waiting") time.sleep(5) ``` Créez ensuite le connecteur de paiement pour votre fournisseur : **Coinbase CDP :** ``` connector = client.create_payment_connector( paymentManagerArn=PAYMENT_MANAGER_ARN, name="my-coinbase-connector", paymentConnectorType="CoinbaseCDP", credentialProviderArn=CREDENTIAL_PROVIDER_ARN ) PAYMENT_CONNECTOR_ID = connector["paymentConnectorId"] print(f"Connector created: {PAYMENT_CONNECTOR_ID}") ``` **Confidentialité :** ``` connector = client.create_payment_connector( paymentManagerArn=PAYMENT_MANAGER_ARN, name="my-privy-connector", paymentConnectorType="StripePrivy", credentialProviderArn=CREDENTIAL_PROVIDER_ARN ) PAYMENT_CONNECTOR_ID = connector["paymentConnectorId"] print(f"Connector created: {PAYMENT_CONNECTOR_ID}") ``` Si vous n'avez pas de rôle de service, consultez la section [Rôles IAM pour les AgentCore paiements](payments-iam-roles.md) pour savoir comment en créer un. La console peut également créer un rôle en votre nom. Pour les schémas complets de demande et de réponse, consultez [CreatePaymentManager](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentManager.html)et [CreatePaymentConnector](https://docs.aws.amazon.com/bedrock-agentcore-control/latest/APIReference/API_CreatePaymentConnector.html)dans la référence de l'API. ### Étape 4 : Création d'un instrument de paiement Un instrument de paiement est un portefeuille crypté intégré que votre agent utilise pour payer les commerçants au nom d'un utilisateur. Chaque instrument est associé à un réseau de blockchain spécifique. **Example** ``` from bedrock_agentcore.payments import PaymentManager manager = PaymentManager( payment_manager_arn=PAYMENT_MANAGER_ARN, region_name="us-west-2" ) instrument = manager.create_payment_instrument( user_id="test-user-123", payment_connector_id=PAYMENT_CONNECTOR_ID, payment_instrument_type="EMBEDDED_CRYPTO_WALLET", payment_instrument_details={ "embeddedCryptoWallet": { "network": "ETHEREUM", "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}] } }, ) INSTRUMENT_ID = instrument["paymentInstrumentId"] REDIRECT_URL = instrument["paymentInstrumentDetails"]["redirectUrl"] print(f"Instrument created: {INSTRUMENT_ID}") print(f"Fund the wallet at: {REDIRECT_URL}") ``` ``` aws bedrock-agentcore create-payment-instrument \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-connector-id "$PAYMENT_CONNECTOR_ID" \ --user-id "test-user-123" \ --payment-instrument-type "EMBEDDED_CRYPTO_WALLET" \ --payment-instrument-details '{ "embeddedCryptoWallet": { "network": "ETHEREUM", "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}] } }' \ --client-token "$(uuidgen)" \ --region us-west-2 ``` Enregistrez le `paymentInstrumentId` et `redirectUrl` depuis la réponse. ``` import uuid dp_client = boto3.client("bedrock-agentcore", region_name="us-west-2", endpoint_url="https://bedrock-agentcore.us-west-2.amazonaws.com") instrument = dp_client.create_payment_instrument( userId="test-user-123", paymentManagerArn=PAYMENT_MANAGER_ARN, paymentConnectorId=PAYMENT_CONNECTOR_ID, paymentInstrumentType="EMBEDDED_CRYPTO_WALLET", paymentInstrumentDetails={ "embeddedCryptoWallet": { "network": "ETHEREUM", "linkedAccounts": [{"email": {"emailAddress": "your-email@example.com"}}] } }, clientToken=str(uuid.uuid4()), ) INSTRUMENT_ID = instrument["paymentInstrumentId"] REDIRECT_URL = instrument["paymentInstrumentDetails"]["redirectUrl"] print(f"Instrument created: {INSTRUMENT_ID}") print(f"Fund the wallet at: {REDIRECT_URL}") ``` Pour le schéma complet de demande et de réponse, reportez-vous [CreatePaymentInstrument](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_CreatePaymentInstrument.html)à la référence de l'API. #### Financez le portefeuille et accordez des autorisations Avant que l'agent puisse effectuer une transaction, l'utilisateur final doit approvisionner le portefeuille et accorder des autorisations de signature. Ouvrez le `redirectUrl` à partir de la réponse ci-dessus dans un navigateur. Depuis le hub de portefeuille, l'utilisateur peut : + Rechargez le portefeuille à l'aide d'un transfert crypté, d'une credit/debit carte, d'Apple Pay, de Google Pay ou d'ACH + Autoriser l'agent à signer des transactions en son nom Pour un environnement de test, approvisionnez le portefeuille avec testnet USDC. Après le financement, interrogez le statut de l'instrument jusqu'à ce qu'il devienne `ACTIVE` : **Example** ``` instrument = manager.get_payment_instrument( user_id="test-user-123", payment_instrument_id=INSTRUMENT_ID ) print(f"Status: {instrument['status']}") ``` ``` aws bedrock-agentcore get-payment-instrument \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-instrument-id "$INSTRUMENT_ID" \ --region us-west-2 ``` ``` while True: inst_status = dp_client.get_payment_instrument( paymentManagerArn=PAYMENT_MANAGER_ARN, paymentInstrumentId=INSTRUMENT_ID ) if inst_status["status"] == "ACTIVE": print("Instrument is active and funded.") break print(f"Instrument status: {inst_status['status']}... waiting for funding") time.sleep(10) ``` Pour plus de détails sur les flux de financement par fournisseur, voir [Financer le portefeuille](payments-how-it-works.md#payments-how-it-works-funding-wallet). ### Étape 5 : Création d'une session de paiement Une session de paiement est un contexte limité dans le temps avec des limites de dépenses facultatives. Lorsque la session expire ou que le budget est épuisé, l'agent ne peut pas effectuer d'autres paiements au cours de cette session. **Example** Lorsque vous utilisez la CLI, il n'est pas nécessaire de créer une session manuellement. Passez `--auto-session` à `agentcore invoke` et la CLI crée ou réutilise une session avec la limite de dépenses par défaut que vous avez configurée dans le gestionnaire de paiements. ``` agentcore invoke \ --prompt "your prompt here" \ --payment-instrument-id \ --auto-session \ --payment-user-id test-user-123 ``` Pour utiliser une session spécifique que vous avez créée via le SDK, passez `--payment-session-id` au lieu de`--auto-session`. ``` from bedrock_agentcore.payments import PaymentManager manager = PaymentManager( payment_manager_arn=PAYMENT_MANAGER_ARN, region_name="us-west-2" ) session = manager.create_payment_session( user_id="test-user-123", limits={"maxSpendAmount": {"value": "5.00", "currency": "USD"}}, expiry_time_in_minutes=60 ) SESSION_ID = session["paymentSessionId"] print(f"Session created: {SESSION_ID} (expires in 60 minutes, $5.00 limit)") ``` ``` aws bedrock-agentcore create-payment-session \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --user-id "test-user-123" \ --expiry-time-in-minutes 60 \ --limits '{"maxSpendAmount": {"value": "5.00", "currency": "USD"}}' \ --client-token "$(uuidgen)" \ --region us-west-2 ``` ``` session = dp_client.create_payment_session( userId="test-user-123", paymentManagerArn=PAYMENT_MANAGER_ARN, expiryTimeInMinutes=60, limits={"maxSpendAmount": {"value": "5.00", "currency": "USD"}}, clientToken=str(uuid.uuid4()), ) SESSION_ID = session["paymentSessionId"] print(f"Session created: {SESSION_ID} (expires in 60 minutes, $5.00 limit)") ``` Pour le schéma complet de demande et de réponse, reportez-vous [CreatePaymentSession](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_CreatePaymentSession.html)à la référence de l'API. ### Étape 6 : Effectuer un paiement avec un agent Strands Une fois toutes les ressources en place, créez un agent Strands qui gère automatiquement les paiements x402. Lorsque l'agent appelle un point de terminaison payant et reçoit une réponse HTTP 402, le plug-in de paiement signe la transaction et tente à nouveau la demande. **Example** Invoquez votre agent déployé avec le contexte de paiement. La CLI transmet l'instrument de paiement et la session à l'agent au moment de l'exécution, et l'intercepteur x402 de l'agent gère le paiement automatiquement. ``` agentcore invoke \ --prompt "Access the premium endpoint at https://example-x402-merchant.com/paid-api" \ --payment-instrument-id \ --auto-session \ --payment-user-id test-user-123 ``` Pour transmettre une session explicite au lieu d'en créer une automatiquement : ``` agentcore invoke \ --prompt "Access the premium endpoint at https://example-x402-merchant.com/paid-api" \ --payment-instrument-id \ --payment-session-id \ --payment-user-id test-user-123 ``` Utilisez la `PaymentManager` classe pour générer des en-têtes de paiement lorsque vous recevez une réponse HTTP 402 : ``` import uuid from bedrock_agentcore.payments import PaymentManager manager = PaymentManager( payment_manager_arn=PAYMENT_MANAGER_ARN, region_name="us-west-2" ) # When you receive a 402 response, generate payment proof payment_required_request = { "statusCode": 402, "headers": payment_required["headers"], "body": payment_required["body"], } payment_proof_headers = manager.generate_payment_header( user_id="test-user-123", payment_instrument_id=INSTRUMENT_ID, payment_session_id=SESSION_ID, payment_required_request=payment_required_request, client_token=str(uuid.uuid4()), ) ``` `payment_proof_headers`contient l'en-tête de preuve de paiement. Incluez cet en-tête lorsque vous réessayez d'envoyer la demande au point de terminaison payant. Appelez `process-payment` directement avec une charge utile x402 (utilisée lorsque vous gérez vous-même l'orchestration des paiements) : ``` aws bedrock-agentcore process-payment \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-session-id "$SESSION_ID" \ --payment-instrument-id "$INSTRUMENT_ID" \ --payment-type "CRYPTO_X402" \ --payment-input '{ "cryptoX402": { "version": "2", "payload": { "scheme": "exact", "network": "eip155:84532", "amount": "100000", "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "payTo": "0xMERCHANT_ADDRESS", "maxTimeoutSeconds": 300, "extra": {"name": "USDC", "version": "2"} } } }' \ --client-token "$(uuidgen)" \ --region us-west-2 ``` Pour le schéma complet de demande et de réponse, reportez-vous [ProcessPayment](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_ProcessPayment.html)à la référence de l'API. ``` from strands import Agent from strands_tools import http_request from bedrock_agentcore.payments.integrations.config import AgentCorePaymentsPluginConfig from bedrock_agentcore.payments.integrations.strands.plugin import AgentCorePaymentsPlugin config = AgentCorePaymentsPluginConfig( payment_manager_arn=PAYMENT_MANAGER_ARN, user_id="test-user-123", payment_instrument_id=INSTRUMENT_ID, payment_session_id=SESSION_ID, region="us-west-2", ) plugin = AgentCorePaymentsPlugin(config=config) agent = Agent( system_prompt="You are a helpful assistant that can access paid APIs.", tools=[http_request], plugins=[plugin], ) # The agent handles 402 responses automatically response = agent("Access the premium endpoint at https://example-x402-merchant.com/paid-api") print(response) ``` Pour le schéma complet de demande et de réponse de l'appel d'API sous-jacent, voir [ProcessPayment](https://docs.aws.amazon.com/bedrock-agentcore/latest/APIReference/API_ProcessPayment.html)la référence d'API. ### Vérifiez le paiement Une fois que l'agent a traité un paiement, vérifiez la session pour confirmer que la transaction a été enregistrée : **Example** ``` session = manager.get_payment_session( user_id="test-user-123", payment_session_id=SESSION_ID ) print(f"Status: {session['status']}, Remaining: {session['remainingAmount']}") ``` Vous pouvez également vérifier la balance de l'instrument : ``` balance = manager.get_payment_instrument_balance( user_id="test-user-123", payment_instrument_id=INSTRUMENT_ID ) print(f"Remaining balance: {balance['amount']} {balance['currency']}") ``` ``` aws bedrock-agentcore get-payment-session \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-session-id "$SESSION_ID" \ --region us-west-2 aws bedrock-agentcore get-payment-instrument-balance \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-instrument-id "$INSTRUMENT_ID" \ --region us-west-2 ``` ``` session_status = dp_client.get_payment_session( paymentManagerArn=PAYMENT_MANAGER_ARN, paymentSessionId=SESSION_ID ) print(f"Session status: {session_status['status']}") print(f"Amount spent: {session_status.get('spentAmount', '0.00')} USD") ``` Vous pouvez également vérifier la balance de l'instrument : ``` balance = dp_client.get_payment_instrument_balance( paymentManagerArn=PAYMENT_MANAGER_ARN, paymentInstrumentId=INSTRUMENT_ID ) print(f"Remaining balance: {balance['amount']} {balance['currency']}") ``` ## Résolution des problèmes Les problèmes suivants concernent à la fois les parcours de configuration manuels et basés sur les compétences. | Problème | Solution | | --- | --- | | Le gestionnaire de paiement est bloqué dans CREATING | Patientez jusqu'à 2 minutes. S'il passe à CREATE\_FAILED, vérifiez que l'ARN et les autorisations de votre rôle de service sont corrects. | | « PaymentInstrument  non actif » | L'utilisateur final doit approvisionner le portefeuille et accorder des autorisations de signature via l'URL de redirection avant que l'agent ne puisse effectuer une transaction. | | « Session expirée ou budget dépassé » | Créez une nouvelle session de paiement avec une expiration plus longue ou une limite de dépenses plus élevée. | | « CredentialProvider  non trouvé » | Vérifiez que l'ARN du fournisseur d'informations d'identification correspond à celui que vous avez créé à l'étape 2. Assurez-vous que la région est cohérente pour tous les appels. | | ProcessPayment Retours échoués | Vérifiez que le portefeuille dispose d'un solde USDC suffisant pour le montant de la transaction plus les frais d'essence. | ## Nettoyage Supprimez les ressources que vous avez créées au cours de ce didacticiel : **Example** ``` agentcore remove payment-connector --manager my-payment-manager --name my-coinbase-connector --yes agentcore remove payment-manager --name my-payment-manager --yes agentcore deploy ``` Les `remove` commandes mettent à jour la configuration locale. Le suivi `deploy` détruit l'infrastructure de paiement de votre compte. ``` from bedrock_agentcore.payments import PaymentClient payment_client = PaymentClient(region_name="us-west-2") payment_client.delete_payment_manager( payment_manager_id="" ) print("Payment Manager deleted.") ``` ``` aws bedrock-agentcore delete-payment-instrument \ --payment-manager-arn "$PAYMENT_MANAGER_ARN" \ --payment-instrument-id "$INSTRUMENT_ID" \ --region us-west-2 aws bedrock-agentcore-control delete-payment-connector \ --payment-manager-id "$PAYMENT_MANAGER_ID" \ --payment-connector-id "$PAYMENT_CONNECTOR_ID" \ --region us-west-2 aws bedrock-agentcore-control delete-payment-manager \ --payment-manager-id "$PAYMENT_MANAGER_ID" \ --region us-west-2 ``` ``` # Delete payment instrument dp_client.delete_payment_instrument( paymentManagerArn=PAYMENT_MANAGER_ARN, paymentInstrumentId=INSTRUMENT_ID ) # Delete payment connector client.delete_payment_connector( paymentManagerArn=PAYMENT_MANAGER_ARN, paymentConnectorId=PAYMENT_CONNECTOR_ID ) # Delete payment manager client.delete_payment_manager( paymentManagerArn=PAYMENT_MANAGER_ARN ) print("All payment resources deleted.") ``` ## Ce que vous avez construit Grâce à ce didacticiel, vous avez créé : + **PaymentCredentialProvider**— Informations d'identification du fournisseur de paiement stockées dans AgentCore Identity + **PaymentManager**— Top-level ressources coordonnant les opérations de paiement + **PaymentConnector**— Intégration entre votre responsable et le fournisseur de paiement externe + **PaymentInstrument**— Un portefeuille crypté intégré, financé et autorisé par l'utilisateur final + **PaymentSession**— Un contexte de paiement limité dans le temps et dans le budget + **Strands Agent** — Un agent d'IA qui gère automatiquement les paiements x402 ## Étapes suivantes + [Connectez-vous à Coinbase x402 Bazaar](payments-connect-bazaar.md) pour découvrir plus de 10 000 outils MCP payants. + [Intégrez l'outil de navigation](payments-browser.md) pour accéder à des sites Web paywallés. + [Activez l'observabilité](payments-observability.md) pour surveiller les opérations de paiement dans. CloudWatch + Passez en [revue les rôles IAM](payments-iam-roles.md) pour configurer l'accès avec le moindre privilège pour la production.