Crear un administrador de pagos y un conector

Paso 1: Abre la página de pagos

Paso 2: Configurar los detalles del administrador de pagos

Paso 3: Configurar los permisos

La sección de permisos especifica los permisos de este gestor de pagos y los AWS recursos a los que puede acceder el pago.

Para los permisos de IAM, elige una de las siguientes opciones:

Paso 4: Configurar la autorización entrante

La autorización entrante controla quién puede acceder a este administrador de pagos. En la sección Autenticación entrante, para el tipo de autenticación entrante, elige una de las siguientes opciones:

Para usar la autorización de IAM:

Para usar la autorización de JWT con Amazon Cognito:

Para usar la autorización de JWT con un proveedor de identidad existente:

Paso 5: Añade un conector de pago (opcional)

Los conectores de pago almacenan las credenciales y la configuración necesarias para conectarse con los proveedores de servicios de pago. Agregar un conector durante la creación es opcional, pero se requiere un conector para que el servicio procese los pagos.

Crea una autenticación de pago

Si eliges crear una nueva en la sección de autenticación de pagos del conector, se abre el panel Crear autenticación de pago. En este panel, configuras una nueva autenticación de pago, es decir, un proveedor de credenciales de pago que se almacena en Identity. AgentCore

Si eliges Coinbase, elige cómo proporcionar las credenciales para la autenticación del pago:

Usa Quick create

Si seleccionas Configuración de creación rápida (recomendada), AgentCore Payments crea la autenticación de pago automáticamente tras autorizar el acceso a través de Coinbase. Realice los siguientes pasos:

Usa las configuraciones existentes

Si seleccionas Usar configuraciones existentes, completa los siguientes campos en Configuraciones del proveedor de pagos y, a continuación, selecciona Crear autenticación de pago:

Si eliges Stripe (Privy), completa los siguientes campos en Configuraciones del proveedor de pagos y, a continuación, selecciona Crear autenticación de pago:

Paso 6: Crea el administrador de pagos

Tras seleccionar Crear gestor de pagos, la consola pasa a la página de detalles del gestor de pagos. Un aviso de éxito confirma que el gestor de pagos se creó y muestra los siguientes pasos a seguir:

La página de detalles de Payment Manager incluye secciones sobre los conectores de pago, las plantillas de códigos de integración, la autenticación entrante, las métricas de observabilidad y la configuración de seguimiento y entregas de registros.

La AgentCore CLI crea el proveedor de credenciales, el administrador de pagos y el conector de pagos juntos a partir del directorio de su proyecto. Requiere la CLI v0.19.0 o posterior.

Asistente interactivo:

agentcore add payment-manager

El asistente solicita el nombre del administrador, el patrón, la opción de pago automático y el límite de gasto y, si lo desea, le explica cómo agregar un conector con las credenciales del proveedor.

Coinbase: creación rápida (recomendado):

Quick Create te proporciona el proveedor de credenciales de Coinbase para que no pases ninguna clave de API. Añade el conector con la --provision-mode QUICK_CREATE bandera y, a continuación, despliega:

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

agentcore deploy

La CLI abre el flujo de autorización de Coinbase. Tras la autorización, el servicio proporciona las credenciales y el conector llegaREADY.

Coinbase CDP — Flujo manual (no interactivo):

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) — Flujo manual (no interactivo):

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 aprovisiona las funciones de IAM, almacena las credenciales en AgentCore Identity y crea el gestor de pagos y el conector.

El AgentCore SDK admite la creación rápida de Coinbase (se muestra primero) y el aprovisionamiento manual. Los ejemplos manuales que siguen a las credenciales del proveedor pasan directamente a las credenciales del proveedor. Utilizan el método prácticocreate_payment_manager_with_connector, que crea el administrador de pagos, el proveedor de credenciales y el conector en una sola llamada.

Coinbase: creación rápida (recomendado):

Con Quick create, creas el conector con una credential_provider_configurations lista vacía yprovision_mode="QUICK_CREATE". El conector muestra el estado PENDING_AUTHENTICATION y una URL de autorización. Tras la autorización a través de Coinbase, el servicio proporciona al proveedor de credenciales y el conector llega hasta él. 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)

La URL de autorización es válida durante unos 10 minutos. Si caduca, el conector pasa a AUTHENTICATION_EXPIRED y usted lo vuelve a crear.

Coinbase CDP con autorización de 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 con autorización de 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) con autorización de 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) con autorización de 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"]

Crea un gestor de pagos con la autorización de 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

Crea un gestor de pagos con la autorización de 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

El estado del gestor de pagos comienza como CREATING y pasa a ser READY cuando se completa el aprovisionamiento.

Coinbase: creación rápida (recomendado):

Con Quick create, se crea el conector con una lista vacía de configuraciones de proveedores de credenciales y. --provision-mode QUICK_CREATE No se crea primero un proveedor de credenciales.

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 respuesta tiene un estado PENDING_AUTHENTICATION y unauthorizationUrl. Abre la URL, autorízala a través de Coinbase y, a continuación, sondea get-payment-connector hasta que el estado seaREADY. La URL es válida durante unos 10 minutos; si caduca, el conector pasa a AUTHENTICATION_EXPIRED y tú lo vuelves a crear.

Flujo manual: con el flujo manual, se crea un proveedor de credenciales de pago y, a continuación, se hace referencia a su ARN al crear el conector. Este es el único flujo para Stripe (Privy).

Cuando el gestor de pagos esté listo, crea un proveedor de credenciales de pago:

El siguiente ejemplo crea un proveedor de credenciales de pago para 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

En el siguiente ejemplo, se crea un proveedor de credenciales de pago para 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

Cuando el proveedor de credenciales esté listo, crea un conector:

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

Crea un gestor de pagos con la autorización de 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']}")

Crea un gestor de pagos con la autorización de 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: creación rápida (recomendado):

Con Quick create, creas el conector con una credentialProviderConfigurations lista vacía yprovisionMode="QUICK_CREATE". No se crea primero un proveedor de credenciales.

# 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')}")

El conector devuelve el estado PENDING_AUTHENTICATION y unauthorizationUrl. Abra la URL, autorice a través de Coinbase y, a continuación, realice una encuesta get_payment_connector hasta que el estado seaREADY. La URL es válida durante unos 10 minutos; si caduca, el conector pasa a AUTHENTICATION_EXPIRED y tú lo vuelves a crear.

Flujo manual: con el flujo manual, se crea un proveedor de credenciales de pago y, a continuación, se hace referencia a su ARN al crear el conector. Este es el único flujo para Stripe (Privy).

Cuando el gestor de pagos alcance el READY estado, crea un proveedor de credenciales de pago:

El siguiente ejemplo configura un proveedor para 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"
        }
    }
)

El siguiente ejemplo configura un proveedor para 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"
        }
    }
)

Tras crear el proveedor de credenciales de pago, crea un conector:

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

Para Stripe (Privy), usa la variante de stripePrivy configuración:

# 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

Los remove comandos actualizan la configuración local. El seguimiento deploy destruye la infraestructura de pago de tu cuenta.

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