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

Étape 1 : Ouvrez la page des paiements

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

É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 :

É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 :

Pour utiliser l'autorisation JWT avec Amazon Cognito :

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

É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.

Créer une autorisation de paiement

Lorsque vous choisissez d'en créer une nouvelle dans la section Autorisation de paiement du connecteur, le panneau Créer une authentification de paiement s'ouvre. Dans ce panneau, vous configurez une nouvelle authentification de paiement, c'est-à-dire un fournisseur d'informations de paiement stocké dans AgentCore Identity.

Si vous choisissez Coinbase, choisissez comment fournir les informations d'identification pour l'authentification de paiement :

Utiliser la création rapide

Si vous sélectionnez Configuration rapide - recommandé, AgentCore Payments crée l'authentification de paiement pour vous après avoir autorisé l'accès via Coinbase. Procédez comme suit :

Comme Quick Create fournit les informations d'identification pour vous, elles sont gérées par des services et vous pouvez les remplacer à tout moment sans générer de clés dans Coinbase. Pour plus d'informations, voir Rotation des informations d'identification du connecteur géré par le service.

Utiliser les configurations existantes

Si vous sélectionnez Utiliser les configurations existantes, renseignez les champs suivants sous Configurations du fournisseur de services de paiement, puis choisissez Créer une autorisation de paiement :

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

Étape 6 : Création du gestionnaire de paiements

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 :

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.

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.

Coinbase — Création rapide (recommandé) :

Quick Create fournit le fournisseur d'informations d'identification Coinbase pour vous, afin que vous ne transmettiez aucune clé d'API. Ajoutez le connecteur avec le --provision-mode QUICK_CREATE drapeau, puis déployez :

agentcore add payment-connector \
  --manager MyPaymentManager \
  --name CoinbaseConnector \
  --provider CoinbaseCDP \
  --provision-mode QUICK_CREATE

agentcore deploy

La CLI ouvre le flux d'autorisation Coinbase. Une fois que vous avez autorisé, le service fournit les informations d'identification et le connecteur les atteintREADY.

Coinbase CDP — Flux manuel (non interactif) :

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

Stripe (Privy) — Flux manuel (non interactif) :

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.

Le AgentCore SDK prend en charge la création rapide de Coinbase (illustré en premier) et le provisionnement manuel. Les exemples de manuels qui suivent transmettent directement les informations d'identification du fournisseur. Ils utilisent la méthode pratiquecreate_payment_manager_with_connector, qui crée le gestionnaire de paiement, le fournisseur d'identifiants et le connecteur en un seul appel.

Coinbase — Création rapide (recommandé) :

Avec la création rapide, vous créez le connecteur avec une credential_provider_configurations liste vide etprovision_mode="QUICK_CREATE". Le connecteur renvoie le statut PENDING_AUTHENTICATION et une URL d'autorisation. Une fois que vous avez autorisé via Coinbase, le service fournit le fournisseur d'informations d'identification et le connecteur atteint. READY

import time
import webbrowser

from bedrock_agentcore.payments.client import PaymentClient

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

connector = payment_client.create_payment_connector(
    payment_manager_id="<paymentManagerId>",
    name="CoinbaseConnector",
    connector_type="CoinbaseCDP",
    credential_provider_configurations=[],
    provision_mode="QUICK_CREATE",
)

# Authorize through Coinbase using the returned URL.
webbrowser.open(connector["authorizationUrl"])

# Terminal states that mean provisioning did not succeed.
TERMINAL_FAILURES = {
    "AUTHENTICATION_EXPIRED",
    "AUTHENTICATION_FAILED",
    "AWS_MARKETPLACE_SUBSCRIPTION_REQUIRED",
    "CREATE_FAILED",
}

# Poll until the connector reaches READY or fails.
while True:
    response = payment_client.get_payment_connector(
        payment_connector_id=connector["paymentConnectorId"]
    )
    status = response["status"]
    if status == "READY":
        break
    if status in TERMINAL_FAILURES:
        raise RuntimeError(f"Connector provisioning failed: {status}")
    time.sleep(5)

L'URL d'autorisation est valide pendant environ 10 minutes. S'il expire, le connecteur est transféré AUTHENTICATION_EXPIRED et vous le recréez.

Coinbase CDP 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="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"]

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é.

Coinbase — Création rapide (recommandé) :

Avec Quick Create, vous créez le connecteur avec une liste vide de configurations de fournisseurs d'informations d'identification et. --provision-mode QUICK_CREATE Vous ne devez pas d'abord créer un fournisseur d'informations d'identification.

aws bedrock-agentcore-control create-payment-connector \
  --payment-manager-id <paymentManagerId> \
  --name "CoinbaseConnector" \
  --type CoinbaseCDP \
  --credential-provider-configurations '[]' \
  --provision-mode QUICK_CREATE \
  --region us-east-1

La réponse possède un statut PENDING_AUTHENTICATION et unauthorizationUrl. Ouvrez l'URL, autorisez via Coinbase, puis interrogez get-payment-connector jusqu'à ce que le statut soit READY rétabli. L'URL est valide pendant environ 10 minutes ; si elle expire, le connecteur passe à cette adresse AUTHENTICATION_EXPIRED et vous la recréez.

Les informations d'identification fournies par Quick Create sont gérées par le service. Vous pouvez donc les remplacer à la demande. rotate-payment-connector-credentials Pour plus d'informations, voir Rotation des informations d'identification du connecteur géré par le service.

Flux manuel : avec le flux manuel, vous créez un fournisseur d'informations de paiement, puis vous référencez son ARN lorsque vous créez le connecteur. Il s'agit du seul flux pour Stripe (Privy).

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

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"
            }
        ]
    }
)

Coinbase — Création rapide (recommandé) :

Avec la création rapide, vous créez le connecteur avec une credentialProviderConfigurations liste vide etprovisionMode="QUICK_CREATE". Vous ne devez pas d'abord créer un fournisseur d'informations d'identification.

# Create a Coinbase connector with Quick create
connector = client.create_payment_connector(
    paymentManagerId=payment_manager["paymentManagerId"],
    name="CoinbaseConnector",
    type="CoinbaseCDP",
    credentialProviderConfigurations=[],
    provisionMode="QUICK_CREATE"
)

print(f"Status: {connector['status']}")
print(f"Authorization URL: {connector.get('authorizationUrl')}")

Le connecteur renvoie l'état PENDING_AUTHENTICATION et unauthorizationUrl. Ouvrez l'URL, autorisez via Coinbase, puis interrogez get_payment_connector jusqu'à ce que le statut soit READY rétabli. L'URL est valide pendant environ 10 minutes ; si elle expire, le connecteur passe à cette adresse AUTHENTICATION_EXPIRED et vous la recréez.

Les informations d'identification fournies par Quick Create sont gérées par le service. Vous pouvez donc les remplacer à la demande. rotate_payment_connector_credentials Pour plus d'informations, voir Rotation des informations d'identification du connecteur géré par le service.

Flux manuel : avec le flux manuel, vous créez un fournisseur d'informations de paiement, puis vous référencez son ARN lorsque vous créez le connecteur. Il s'agit du seul flux pour Stripe (Privy).

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"
            }
        }
    ]
)

agentcore status

from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")
response = payment_client.get_payment_manager(
    payment_manager_id="<paymentManagerId>"
)
print(f"Status: {response['status']}")

aws bedrock-agentcore-control get-payment-manager \
  --payment-manager-id <paymentManagerId> \
  --region us-east-1

response = client.get_payment_manager(
    paymentManagerId="<paymentManagerId>"
)
print(f"Status: {response['status']}")

agentcore status

from bedrock_agentcore.payments.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")
response = payment_client.list_payment_managers()
for pm in response['paymentManagers']:
    print(f"{pm['name']} - {pm['status']}")

aws bedrock-agentcore-control list-payment-managers \
  --region us-east-1

response = client.list_payment_managers()
for pm in response['paymentManagers']:
    print(f"{pm['name']} - {pm['status']}")

agentcore remove payment-connector --manager MyPaymentManager --name CoinbaseConnector --yes
agentcore remove payment-manager --name MyPaymentManager --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.client import PaymentClient

payment_client = PaymentClient(region_name="us-east-1")
payment_client.delete_payment_manager(
    payment_manager_id="<paymentManagerId>"
)

aws bedrock-agentcore-control delete-payment-manager \
  --payment-manager-id <paymentManagerId> \
  --region us-east-1

client.delete_payment_manager(
    paymentManagerId="<paymentManagerId>"
)