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

Étape 1 : Ouvrez la page des paiements

Étape 2 : Configuration des informations relatives au gestionnaire de paiement

Étape 3 : Configuration des autorisations

La section Autorisations spécifie 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 paiement. Dans la section Authentification entrante, pour 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 prestataires de services de paiement. L'ajout d'un connecteur lors de la création est facultatif, mais un connecteur est nécessaire pour que le service puisse traiter les paiements.

Créer une authentification de paiement

Lorsque vous choisissez d'en créer un nouveau dans la section Authentification des paiements 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 qui est 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 de création rapide - recommandé, AgentCore Payments crée l'autorisation de paiement pour vous une fois que vous avez autorisé l'accès via Coinbase. Procédez comme suit :

Utiliser les configurations existantes

Si vous sélectionnez Utiliser les configurations existantes, complétez les champs suivants sous Configurations des fournisseurs de paiement, puis choisissez Créer une authentification de paiement :

Si vous choisissez Stripe (Privy), complétez les champs suivants sous Configurations du fournisseur de paiement, puis choisissez Créer une authentification de paiement :

Étape 6 : Création du gestionnaire de paiement

Une fois que vous avez choisi Créer un gestionnaire de paiement, la console accède à la page de détails du gestionnaire de paiement. Une bannière de réussite confirme que le gestionnaire de paiement a été créé et indique les étapes suivantes :

La page de détails de Payment Manager comprend des sections relatives aux connecteurs de paiement, aux modèles de code d'intégration, à l'authentification entrante, aux mesures d'observabilité, ainsi qu'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 de votre répertoire de projet. Nécessite la CLI v0.19.0 ou version ultérieure.

Assistant interactif :

agentcore add payment-manager

L'assistant demande le nom du responsable, le modèle, l'option de paiement automatique, la limite de dépenses et, éventuellement, vous explique comment ajouter 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, de sorte 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 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 provisionne les rôles IAM, stocke les informations d'identification dans AgentCore Identity et crée le gestionnaire de paiement et le connecteur.

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

Coinbase — Création rapide (recommandé) :

Avec Quick create, 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 passe à 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 paiement 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 avec l'autorisation 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 Payment Manager commence au fur CREATING et à mesure et passe à la READY fin du provisionnement.

Coinbase — Création rapide (recommandé) :

Avec Quick create, vous créez le connecteur avec une liste de configurations de fournisseurs d'informations d'identification vide 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 effectuez un sondage get-payment-connector jusqu'à ce que le statut soit READY atteint. L'URL est valide pendant environ 10 minutes ; si elle expire, le connecteur passe à AUTHENTICATION_EXPIRED et vous le recréez.

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

Une fois que le gestionnaire de paiement 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 paiement 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 avec l'autorisation 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 Quick create, 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 effectuez un sondage get_payment_connector jusqu'à ce que le statut soit READY atteint. L'URL est valide pendant environ 10 minutes ; si elle expire, le connecteur passe à AUTHENTICATION_EXPIRED et vous le recréez.

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

Une fois que le Payment Manager 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>"
)