Création d'un gestionnaire de paiements États de cycle de vie Optez pour un gestionnaire de paiements Lister les gestionnaires de paiements Supprimer un gestionnaire de paiements Étapes suivantes

Création d'un gestionnaire de paiement et d'un connecteur

Un gestionnaire de paiement est la ressource de haut niveau qui coordonne les opérations de paiement pour votre AWS compte. Lorsque vous créez un gestionnaire de paiements, vous spécifiez un type d'autorisation et un rôle IAM, et le service fournit une identité de charge de travail correspondante dans AgentCore Identity.

Ce guide explique comment créer un gestionnaire de paiements et associer un connecteur de paiement à l'aide de la console AWS de gestion ou du AWS SDK. Pour les schémas complets de demande et de réponse, consultez CreatePaymentManageret CreatePaymentConnectordans la référence de l'API.

Astuce

Vous pouvez automatiser les étapes de cette page à l'aide de la compétence AgentCore Paiements de la boîte à outils de l' AWS agent. Cette compétence fait partie du plugin aws-agents et permet à un agent de codage basé sur l'IA de créer votre gestionnaire de paiement, votre connecteur, votre fournisseur d'informations d'identification, votre instrument de paiement et votre session à l'aide de la agentcore CLI, et d'ajouter un outil de paiement x402 à votre agent. Pour plus de détails, consultez le guide de démarrage rapide et le kit d'outils de l'AWS agent sur GitHub.

Avant de commencer, assurez-vous de disposer des éléments suivants :

Vous avez rempli les conditions préalables (compte, informations d'identification, clés du fournisseur).
Configurez les rôles IAM requis (rôle d'administrateur et rôle de service).

Création d'un gestionnaire de paiements

Exemple

Console

Étape 1 : Ouvrez la page des paiements

Ouvrez la AgentCore console Amazon Bedrock.
Dans le volet de navigation, sous Build, sélectionnez Payments.
Dans la section Gestionnaires de paiements, choisissez Créer un gestionnaire de paiements.

Étape 2 : configurer les détails du gestionnaire de paiements

Dans Nom, saisissez le nom de votre gestionnaire de paiements. Le nom doit commencer par une lettre. Les caractères valides sont a–zA–Z,0–9. Le nom peut comporter jusqu'à 48 caractères.
(Facultatif) Choisissez Description pour développer la section, puis entrez une description pour aider à identifier ce gestionnaire de paiement.

Étape 3 : Configuration des autorisations

La section Autorisations indique les autorisations pour ce gestionnaire de paiement et les AWS ressources auxquelles le paiement peut accéder.

Pour les autorisations IAM, choisissez l'une des options suivantes :

Création et utilisation d'un nouveau rôle de service : Amazon Bedrock AgentCore Payments crée un nouveau rôle de service en votre nom. Un nom de rôle de service par défaut est généré automatiquement. Pour plus d'informations, consultez la section Autorisations relatives aux rôles de service.
Utiliser un rôle de service existant : utilisez un rôle de service que vous avez déjà créé. Si vous choisissez cette option, sélectionnez un rôle dans la liste déroulante.

Étape 4 : Configuration de l'autorisation entrante

L'autorisation entrante contrôle qui peut accéder à ce gestionnaire de paiements. Dans la section Inbound Auth, pour le type d'authentification entrante, choisissez l'une des options suivantes :

Pour utiliser l'autorisation IAM :

Choisissez Utiliser le nom d'utilisateur IAM. Cela utilise le nom d'utilisateur IAM que vous avez utilisé pour vous connecter à la AWS console.

Pour utiliser l'autorisation JWT avec Amazon Cognito :

Choisissez Utiliser des jetons Web JSON (JWT).
Pour la configuration du schéma JWT, choisissez Création rapide de configurations avec Cognito - recommandé. Amazon Bedrock AgentCore Payments crée les configurations d'autorisation entrante en votre nom en utilisant Amazon Cognito comme fournisseur d'identité. Aucune configuration supplémentaire n’est requise.

Pour utiliser l'autorisation JWT avec un fournisseur d'identité existant :

Choisissez Utiliser des jetons Web JSON (JWT).
Pour la configuration du schéma JWT, choisissez Utiliser les configurations du fournisseur d'identité existantes. Cette option vous permet d'importer les configurations d'autorisation entrante existantes de n'importe quel fournisseur d'identité pour activer OAuth 2.0.
Pour l'URL de découverte, entrez l'URL de découverte de votre fournisseur d'identité (par exemple, Okta ou Cognito), qui se trouve généralement dans la documentation de ce fournisseur. Cela permet à votre agent ou à votre outil de récupérer l'identifiant, le jeton de ressource en aval et les paramètres de vérification. Par exemple, https://accounts.cognito.com/.well-known/openid-configuration.
Pour les audiences autorisées, entrez les identifiants des clients enregistrés auprès des fournisseurs d'identité ou toute chaîne arbitraire dans la demande d'audience JWT que l'autorisateur doit vérifier. Choisissez + Ajouter une audience pour ajouter des audiences supplémentaires.
Pour les clients autorisés, entrez les identifiants clients enregistrés auprès des fournisseurs d'identité ou toute chaîne arbitraire dans la demande d'audience JWT que l'autorisateur doit vérifier. Choisissez + Ajouter un client pour ajouter des clients supplémentaires.
Pour Étendue autorisée, entrez les étendues requises. L'accès n'est autorisé que si le jeton contient au moins l'une des étendues requises configurées ici. Choisissez + Ajouter une étendue pour ajouter des étendues supplémentaires.
(Facultatif) Pour les réclamations personnalisées, définissez des règles qui font correspondre les demandes spécifiques du jeton entrant à des valeurs prédéfinies. Pour chaque règle, spécifiez le nom de la réclamation, le type de chaîne, l'opérateur et la valeur. Choisissez + Ajouter une réclamation pour ajouter des réclamations supplémentaires.

Étape 5 : Ajouter un connecteur de paiement (facultatif)

Les connecteurs de paiement stockent les informations d'identification et la configuration nécessaires pour se connecter aux fournisseurs de services de paiement. L'ajout d'un connecteur lors de la création est facultatif, mais un connecteur est requis pour que le service puisse traiter les paiements.

Dans la section Connecteur de paiement : Nouveau connecteur, dans Nom, entrez le nom du connecteur. Les caractères valides sonta–z, A–Z0–9, et _ (trait de soulignement). Le nom peut comporter jusqu'à 48 caractères.
(Facultatif) Choisissez Description pour développer la section, puis entrez une description pour le connecteur.
Dans la section Ajouter une authentification sortante, si vous souhaitez réutiliser un fournisseur d'informations de paiement créé précédemment dans AgentCore Identity, sélectionnez une authentification sortante existante dans la liste déroulante ; ou choisissez en créer un nouveau pour créer un nouveau fournisseur d'informations de paiement. Si vous choisissez d'en créer une nouvelle, voir Créer une nouvelle authentification sortante.
(Facultatif) Pour ajouter des connecteurs supplémentaires, choisissez + Ajouter un connecteur et répétez les étapes ci-dessus.

Création d'une nouvelle authentification sortante

Lorsque vous choisissez d'en créer un nouveau dans la section d'authentification sortante du connecteur, un panneau s'ouvre dans lequel vous pouvez configurer un nouveau fournisseur d'informations de paiement.

Dans Nom, entrez le nom de l'authentification sortante. Les caractères valides sonta–z, A–Z0–9, _ (trait de soulignement) et - (tiret).
Pour Fournisseur, sélectionnez un fournisseur de services de paiement dans le menu déroulant. Les fournisseurs disponibles sont Coinbase et Stripe (Privy).

Si vous choisissez Coinbase, renseignez les champs suivants sous Configurations du fournisseur de paiement :

Pour l'ID de clé API, entrez l'identifiant unique pour les informations d'identification de votre compte Coinbase CDP.
Pour le secret de la clé API, entrez la clé privée utilisée pour authentifier et signer les demandes adressées à Coinbase CDP.
Pour Wallet secret, entrez la clé privée asymétrique utilisée pour authentifier les opérations d'écriture sensibles du portefeuille.

Si vous choisissez Stripe (Privy), renseignez les champs suivants sous Configurations du fournisseur de paiement :

Pour App ID, entrez l'identifiant unique pour les informations d'identification de votre compte Privy.
Dans le champ App secret, entrez la clé privée utilisée pour authentifier et signer les demandes adressées à l'application Privy.
Dans le champ Numéro d'autorisation, entrez l'identifiant unique de l'entité d'autorisation.
Pour la clé privée d'autorisation, entrez la clé privée utilisée pour signer les demandes d'autorisation.

Une fois la configuration du fournisseur terminée, choisissez Add Outbound Auth.

Étape 6 : Création du gestionnaire de paiements

Vérifiez votre configuration, puis choisissez Create Payment Manager.

Après avoir choisi Create Payment Manager, la console accède à la page de détails du Payment Manager. Une bannière de réussite confirme que le gestionnaire de paiements a été créé et indique les étapes suivantes :

Configurez l'instrument de paiement et la session, spécifiez éventuellement le budget.
Intégrez le gestionnaire de paiements dans votre infrastructure d'agents.
Découvrez les outils et terminaux MCP payants.
Activez les livraisons de journaux et les traces pour afficher les métriques dans le tableau de bord d'observabilité.

La page détaillée du gestionnaire de paiements comprend des sections relatives aux connecteurs de paiement, aux modèles de code d'intégration, à l'authentification entrante, aux mesures d'observabilité, aux livraisons de journaux et à la configuration du suivi.

AgentCore CLI

La AgentCore CLI crée le fournisseur d'informations d'identification, le gestionnaire de paiement et le connecteur de paiement ensemble à partir du répertoire de votre projet. Nécessite la version 0.19.0 ou ultérieure de la CLI.

Assistant interactif :


agentcore add payment-manager

L'assistant demande le nom du responsable, le modèle, le mode de paiement automatique, la limite de dépenses et, éventuellement, ajoute un connecteur avec les informations d'identification du fournisseur.

Non-interactive (Coinbase CDP) :


agentcore add payment-manager \
  --name MyPaymentManager \
  --auto-payment \
  --default-spend-limit 10.00

agentcore add payment-connector \
  --manager MyPaymentManager \
  --name CoinbaseConnector \
  --provider CoinbaseCDP \
  --api-key-id <YOUR_API_KEY_ID> \
  --api-key-secret <YOUR_API_KEY_SECRET> \
  --wallet-secret <YOUR_WALLET_SECRET>

agentcore deploy

Non-interactive (Stripe/Privy):


agentcore add payment-manager \
  --name MyPaymentManager \
  --auto-payment \
  --default-spend-limit 10.00

agentcore add payment-connector \
  --manager MyPaymentManager \
  --name StripePrivyConnector \
  --provider StripePrivy \
  --app-id <YOUR_APP_ID> \
  --app-secret <YOUR_APP_SECRET> \
  --authorization-id <YOUR_AUTHORIZATION_ID> \
  --authorization-private-key <YOUR_PRIVATE_KEY_BASE64>

agentcore deploy

Running agentcore deploy fournit des rôles IAM, stocke les informations d'identification dans AgentCore Identity et crée le gestionnaire de paiements et le connecteur.

AgentCore SDK

Le AgentCore SDK fournit une méthode pratique create_payment_manager_with_connector qui permet de créer le gestionnaire de paiement, le fournisseur d'informations d'identification et le connecteur en un seul appel.

Coinbase CDP avec autorisation IAM :


from bedrock_agentcore.payments import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="MyPaymentManager",
    payment_manager_description="Payment manager for my agent.",
    authorizer_type="AWS_IAM",
    role_arn="arn:aws:iam::123456789012:role/MyPaymentRole",
    payment_connector_config={
        "name": "CoinbaseConnector",
        "description": "Coinbase CDP connector",
        "payment_credential_provider_config": {
            "name": "MyCoinbaseProvider",
            "credential_provider_vendor": "CoinbaseCDP",
            "credentials": {
                "api_key_id": "your-api-key-id",
                "api_key_secret": "your-api-key-secret",
                "wallet_secret": "your-wallet-secret",
            },
        },
    },
    wait_for_ready=True,
    max_wait=300,
    poll_interval=5,
)

payment_manager = response.get("paymentManager", {})
payment_connector = response.get("paymentConnector", {})
credential_provider = response.get("credentialProvider", {})

payment_manager_arn = payment_manager.get("paymentManagerArn")
payment_connector_id = payment_connector.get("paymentConnectorId")

print(f"Payment Manager ARN: {payment_manager_arn}")
print(f"Connector ID: {payment_connector_id}")

Coinbase CDP avec autorisation JWT :


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="CoinbasePaymentManagerJWT",
    payment_manager_description="Coinbase Payment Manager (JWT auth)",
    authorizer_type="CUSTOM_JWT",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "coinbase-connector-jwt",
        "description": "Coinbase Connector (JWT)",
        "payment_credential_provider_config": {
            "name": "my-coinbase-provider-jwt",
            "credential_provider_vendor": "CoinbaseCDP",
            "credentials": {
                "api_key_id": "your-api-key-id",
                "api_key_secret": "your-api-key-secret",
                "wallet_secret": "your-wallet-secret",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

Stripe (Privy) avec autorisation IAM :


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="StripePaymentManager",
    payment_manager_description="Stripe + Privy Payment Manager (IAM auth)",
    authorizer_type="AWS_IAM",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "stripe-privy-connector",
        "description": "Stripe + Privy Connector",
        "payment_credential_provider_config": {
            "name": "my-stripe-privy-provider",
            "credential_provider_vendor": "StripePrivy",
            "credentials": {
                "app_id": "your-privy-app-id",
                "app_secret": "your-privy-app-secret",
                "authorization_private_key": "your-authorization-private-key",
                "authorization_id": "your-authorization-id",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

Stripe (Privy) avec autorisation JWT :


from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")

response = payment_client.create_payment_manager_with_connector(
    payment_manager_name="StripePaymentManagerJWT",
    payment_manager_description="Stripe + Privy Payment Manager (JWT auth)",
    authorizer_type="CUSTOM_JWT",
    role_arn="arn:aws:iam::123456789012:role/BedrockAgentCoreFullAccess",
    payment_connector_config={
        "name": "stripe-privy-connector-jwt",
        "description": "Stripe + Privy Connector (JWT)",
        "payment_credential_provider_config": {
            "name": "my-stripe-privy-provider-jwt",
            "credential_provider_vendor": "StripePrivy",
            "credentials": {
                "app_id": "your-privy-app-id",
                "app_secret": "your-privy-app-secret",
                "authorization_private_key": "your-authorization-private-key",
                "authorization_id": "your-authorization-id",
            },
        },
    },
    wait_for_ready=True,
)

manager_arn = response["paymentManager"]["paymentManagerArn"]
connector_id = response["paymentConnector"]["paymentConnectorId"]
provider_arn = response["credentialProvider"]["credentialProviderArn"]

AWS CLI

Créez un gestionnaire de paiements avec autorisation IAM :


aws bedrock-agentcore-control create-payment-manager \
  --name "MyPaymentManager" \
  --authorizer-type AWS_IAM \
  --role-arn "arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole" \
  --region us-east-1

Créez un gestionnaire de paiement autorisé par JWT :


aws bedrock-agentcore-control create-payment-manager \
  --name "MyPaymentManager" \
  --authorizer-type CUSTOM_JWT \
  --role-arn "arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole" \
  --custom-jwt-authorizer-configuration '{
    "discoveryUrl": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE/.well-known/openid-configuration",
    "allowedAudience": ["your-client-id"],
    "allowedClients": ["your-client-id"]
  }' \
  --region us-east-1

Le statut de gestionnaire de paiements commence CREATING et passe à une READY fois le provisionnement terminé.

Une fois que le gestionnaire de paiements est prêt, créez un fournisseur d'informations de paiement :

L'exemple suivant crée un fournisseur d'informations de paiement pour Coinbase CDP :


aws bedrock-agentcore-control create-payment-credential-provider \
  --name "coinbase-provider" \
  --credential-provider-vendor CoinbaseCDP \
  --provider-configuration-input '{
    "coinbaseCdpConfiguration": {
      "apiKeyId": "your-coinbase-api-key-id",
      "apiKeySecret": "your-coinbase-api-key-secret",
      "walletSecret": "your-coinbase-wallet-secret"
    }
  }' \
  --region us-east-1

L'exemple suivant crée un fournisseur d'informations de paiement pour Stripe Privy :


aws bedrock-agentcore-control create-payment-credential-provider \
  --name "stripe-privy-provider" \
  --credential-provider-vendor StripePrivy \
  --provider-configuration-input '{
    "stripePrivyConfiguration": {
      "appId": "your-stripe-privy-app-id",
      "appSecret": "your-stripe-privy-app-secret",
      "authorizationPrivateKey": "your-stripe-privy-authorization-private-key",
      "authorizationId": "your-stripe-privy-authorization-id"
    }
  }' \
  --region us-east-1

Une fois que le fournisseur d'informations d'identification est prêt, créez un connecteur :


aws bedrock-agentcore-control create-payment-connector \
  --payment-manager-id <paymentManagerId> \
  --name "CoinbaseConnector" \
  --type CoinbaseCDP \
  --credential-provider-configurations '[{
    "coinbaseCDP": {
      "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-cdp-provider"
    }
  }]' \
  --region us-east-1

AWS SDK

Créez un gestionnaire de paiements avec autorisation IAM :


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

# Create PaymentManager with IAM authorization
payment_manager = client.create_payment_manager(
    name="MyPaymentManager",
    authorizerType="AWS_IAM",
    roleArn="arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole"
)

print(f"Payment Manager ID: {payment_manager['paymentManagerId']}")

Créez un gestionnaire de paiement autorisé par JWT :


payment_manager = client.create_payment_manager(
    name="MyPaymentManager",
    authorizerType="CUSTOM_JWT",
    roleArn="arn:aws:iam::123456789012:role/AgentCorePaymentsResourceRetrievalRole",
    customJWTAuthorizerConfiguration={
        "discoveryUrl": "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE/.well-known/openid-configuration",
        "allowedAudience": ["your-client-id"],
        "allowedClients": ["your-client-id"],
        "allowedScopes": ["payments:write"],
        "customClaims": [
            {
                "claimName": "tenant_id",
                "claimValue": "your-unique-tenant-id",
                "operation": "EQUALS"
            }
        ]
    }
)

Une fois que le gestionnaire de paiements a atteint READY le statut, créez un fournisseur d'informations de paiement :

L'exemple suivant configure un fournisseur pour Coinbase CDP :


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

coinbase_provider = client.create_payment_credential_provider(
    name="coinbase-provider",
    credentialProviderVendor="CoinbaseCDP",
    providerConfigurationInput={
        "coinbaseCdpConfiguration": {
            "apiKeyId": "your-coinbase-api-key-id",
            "apiKeySecret": "your-coinbase-api-key-secret",
            "walletSecret": "your-coinbase-wallet-secret"
        }
    }
)

L'exemple suivant configure un fournisseur pour Stripe Privy :


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-east-1")

stripe_privy_provider = client.create_payment_credential_provider(
    name="stripe-privy-provider",
    credentialProviderVendor="StripePrivy",
    providerConfigurationInput={
        "stripePrivyConfiguration": {
            "appId": "your-stripe-privy-app-id",
            "appSecret": "your-stripe-privy-app-secret",
            "authorizationPrivateKey": "your-stripe-privy-authorization-private-key",
            "authorizationId": "your-stripe-privy-authorization-id"
        }
    }
)

Après avoir créé le fournisseur d'informations de paiement, créez un connecteur :


# Create PaymentConnector for Coinbase CDP
payment_connector = client.create_payment_connector(
    paymentManagerId=payment_manager["paymentManagerId"],
    name="CoinbaseConnector",
    type="CoinbaseCDP",
    credentialProviderConfigurations=[
        {
            "coinbaseCDP": {
                "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-cdp-provider"
            }
        }
    ]
)

print(f"Connector ID: {payment_connector['paymentConnectorId']}")

Pour Stripe (Privy), utilisez la variante stripePrivy de configuration :


# Create PaymentConnector for Stripe (Privy)
payment_connector = client.create_payment_connector(
    paymentManagerId=payment_manager["paymentManagerId"],
    name="StripePrivyConnector",
    type="StripePrivy",
    credentialProviderConfigurations=[
        {
            "stripePrivy": {
                "credentialProviderArn": "arn:aws:bedrock-agentcore:us-east-1:123456789012:token-vault/default/paymentcredentialprovider/my-privy-provider"
            }
        }
    ]
)

États de cycle de vie

Après sa création, le gestionnaire de paiements passe par les états suivants :

State	Description
`CREATING`	État initial lors du provisionnement.
`READY`	Payment Manager est opérationnel et accepte les configurations de connecteurs.
`UPDATING`	Une modification de configuration est en cours d'application.
`CREATE_FAILED`	Échec du provisionnement.
`UPDATE_FAILED`	échec de l'opération de mise à jour.

Optez pour un gestionnaire de paiements

Exemple

Lister les gestionnaires de paiements

Exemple

Supprimer un gestionnaire de paiements

Exemple

Étapes suivantes

Après avoir créé votre gestionnaire de paiements, vous pouvez :

Configurer les instruments de paiement et les sessions : configurez les instruments de paiement et les sessions pour commencer à traiter les transactions. Consultez la section Création d'un instrument de paiement.
Intégrez votre infrastructure d'agents : utilisez les modèles de code d'intégration pour connecter le Payment Manager à votre flux de travail agentic. Consultez la section Traitement des paiements.
Découvrez les outils et points de terminaison MCP payants : connectez-vous à des serveurs MCP prêts à l'emploi avec des points de terminaison payants ou apportez vos propres points de terminaison marchands. Voir Coinbase Bazaar via AgentCore Gateway.
Activez l'observabilité : configurez les livraisons de journaux et le suivi pour surveiller les sessions, les appels d'API, les transactions et les taux d'erreur. Voir Observabilité.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Rôles IAM

Traitement des paiements