- Console
-
Paso 1: Abre la página de pagos
-
Abre la AgentCore consola Amazon Bedrock.
-
En el panel de navegación, en Crear, selecciona Pagos.
-
En la sección Gestores de pagos, selecciona Crear gestor de pagos.
Paso 2: Configurar los detalles del administrador de pagos
-
En Nombre, introduce un nombre para tu gestor de pagos. El nombre debe comenzar por una letra. Los caracteres válidos sona–z,A–Z,0–9. El nombre puede tener hasta 48 caracteres.
-
(Opcional) Selecciona Descripción para ampliar la sección y, a continuación, introduce una descripción que ayude a identificar a este gestor de pagos.
Paso 3: Configurar los permisos
La sección de permisos especifica los permisos de este administrador de pagos y los AWS recursos a los que puede acceder el pago.
Para los permisos de IAM, elige una de las siguientes opciones:
-
Cree y utilice un nuevo rol de servicio: Amazon Bedrock AgentCore Payments crea un nuevo rol de servicio en su nombre. Se genera automáticamente un nombre de función de servicio predeterminado. Para obtener más información, consulte Permisos de roles de servicios.
-
Use un rol de servicio existente: use un rol de servicio que ya haya creado. Si elige esta opción, seleccione un rol de la lista desplegable.
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:
-
Elija Usar nombre de usuario de IAM. Utiliza el nombre de usuario de IAM que utilizaste para iniciar sesión en la AWS consola.
Para usar la autorización de JWT con Amazon Cognito:
-
Elija Usar tokens web JSON (JWT).
-
Para configurar el esquema JWT, elija Creación rápida de configuraciones con Cognito (recomendado). Amazon Bedrock AgentCore Payments crea las configuraciones de autorización entrante en su nombre utilizando Amazon Cognito como proveedor de identidad. No se necesita configuración adicional.
Para usar la autorización de JWT con un proveedor de identidad existente:
-
Elija Usar tokens web JSON (JWT).
-
Para configurar el esquema JWT, elija Usar las configuraciones de proveedores de identidad existentes. Esta opción te permite incorporar las configuraciones de autorización entrante existentes desde cualquier proveedor de identidad para habilitar OAuth 2.0.
-
En Discovery URL, introduce la URL de descubrimiento de tu proveedor de identidad (por ejemplo, Okta o Cognito), que normalmente se encuentra en la documentación de ese proveedor. Esto permite a su agente o herramienta obtener la configuración de inicio de sesión, el token de recursos intermedios y la configuración de verificación. Por ejemplo, https://accounts.cognito.com/.well-known/openid-configuration.
-
En Audiencias permitidas, introduzca los ID de cliente que estén registrados con los proveedores de identidad o cualquier cadena arbitraria de la afirmación de audiencia de JWT que el autorizador deba verificar. Seleccione + Añadir audiencia para añadir audiencias adicionales.
-
En Clientes permitidos, introduzca los ID de cliente que estén registrados con los proveedores de identidad o cualquier cadena arbitraria de la afirmación de audiencia de JWT que el autorizador deba verificar. Seleccione + Añadir cliente para añadir clientes adicionales.
-
En Ámbitos permitidos, introduzca los ámbitos necesarios. El acceso solo está permitido si el token contiene al menos uno de los ámbitos obligatorios configurados aquí. Seleccione + Añadir ámbito para añadir ámbitos adicionales.
-
(Opcional) En el caso de las notificaciones personalizadas, defina reglas que hagan coincidir las afirmaciones específicas del token entrante con los valores predefinidos. Para cada regla, especifique el nombre de la reclamación, el tipo de cadena, el operador y el valor. Seleccione + Añadir reclamación para añadir reclamaciones adicionales.
Paso 5: Agrega 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. Añadir un conector durante la creación es opcional, pero es necesario para que el servicio procese los pagos.
-
En la sección Conector de pagos: nuevo conector, en Nombre, introduzca un nombre para el conector. Los caracteres válidos son a–zA–Z,0–9, y _ (subrayado). El nombre puede tener un máximo de 48 caracteres.
-
(Opcional) Elija Descripción para expandir la sección y, a continuación, introduzca una descripción para el conector.
-
En la sección de autenticación de pagos, si quieres reutilizar una autenticación de pago (proveedor de credenciales de pago) creada anteriormente en AgentCore Identity, selecciona una autenticación de pago existente en el menú desplegable o elige crear una nueva para crear una nueva autenticación de pago. Si decides crear una nueva, consulta Crear una autenticación de pago.
-
(Opcional) Para añadir conectores adicionales, selecciona + Añadir conector y repite los pasos anteriores.
-
(Opcional) Decida cómo va a rotar las credenciales de este conector. Si crea la autenticación de pago con Coinbase Quick Create, las credenciales se gestionan mediante el servicio y puede rotarlas si lo desea desde la página de detalles del conector o durante la operación. RotatePaymentConnectorCredentials Si proporciona sus propias credenciales, las rota con el proveedor de pagos. Para obtener más información, consulte Rotar las credenciales de los conectores gestionados por el servicio.
Cree una autenticación de pago
Cuando 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: un proveedor de credenciales de pago que se almacena en Identity. AgentCore
-
En Nombre de autenticación de pago, introduce un nombre para la autenticación de pago. Los caracteres válidos sona–z, A–Z0–9, _ (subrayado) y - (guión).
-
En el caso del proveedor de pagos, selecciona un proveedor de pagos en el menú desplegable. Los proveedores disponibles son Coinbase y Stripe (Privy).
Si eliges Coinbase, elige cómo proporcionar las credenciales para la autenticación de pago:
-
Configuraciones de creación rápida: se recomiendan: la creación rápida le permite vincularse a su cuenta de Coinbase CDP y permitir que AgentCore los pagos creen las credenciales por usted sin salir de la consola. AgentCore Abre una ventana para registrarte o iniciar sesión en tu cuenta de Coinbase CDP. A continuación, el servicio proporciona la clave de API de Coinbase CDP y el secreto de Wallet y los almacena como autenticación de pago en tu nombre. No generas ni pegas ninguna clave.
-
Utilice las configuraciones existentes: proporcione las credenciales CDP de Coinbase que haya generado usted mismo en la plataforma de desarrolladores de Coinbase.
Utilice Quick Create
Si seleccionas las configuraciones de creación rápida (recomendadas), AgentCore Payments crea la autenticación de pago automáticamente después de que autorices el acceso a través de Coinbase. Realice los siguientes pasos:
-
Selecciona Configuraciones de creación rápida (recomendadas).
-
Selecciona Crear autenticación de pago. Se abre una ventana de Coinbase y muestra la conexión a Coinbase en curso.
-
En la ventana de Coinbase, inicie sesión o regístrese con su dirección de correo electrónico y número de teléfono y, a continuación, seleccione o cree un proyecto de CDP de Coinbase.
-
Revisa el acceso solicitado y, a continuación, autoriza AgentCore los pagos para crear y gestionar las credenciales de tu proyecto de Coinbase CDP.
-
Cuando finalice la autorización, la ventana de Coinbase mostrará que Coinbase está conectada y se cierra. AgentCore Payments proporciona la clave API CDP de Coinbase y el secreto de Wallet. El servicio los almacena de forma segura en AWS Secrets Manager y crea la autenticación de pago en tu nombre.
La creación rápida no admite la vinculación a un proyecto existente con un Wallet Secret. Si el proyecto de Coinbase que autorizas ya tiene un secreto de cartera, AgentCore los pagos se detendrán sin que se modifique. En su lugar, selecciona Usar las configuraciones existentes y proporciona tus credenciales manualmente.
Como Quick create proporciona las credenciales por usted, son gestionadas por el servicio y puede sustituirlas en cualquier momento sin generar claves en Coinbase. Para obtener más información, consulte Rotar las credenciales de los conectores gestionados por el servicio.
Utilice las configuraciones existentes
Si seleccionas Usar las configuraciones existentes, completa los siguientes campos en Configuraciones del proveedor de pagos y, a continuación, selecciona Crear autenticación de pago:
-
Como ID de clave de API, introduzca el identificador único de las credenciales de su cuenta de Coinbase CDP.
-
Para el secreto de la clave de API, introduzca la clave privada utilizada para autenticar y firmar las solicitudes a Coinbase CDP.
-
En Wallet secret, introduce la clave privada asimétrica que se utiliza para autenticar las operaciones confidenciales de escritura de carteras.
Si selecciona Coinbase como proveedor, su cuenta debe tener una suscripción activa a AWS Marketplace a la lista de Monederos para AgentCore Pagos de Coinbase. Se trata de una suscripción única para una cuenta. AWS Con esta suscripción, los cargos por el uso de su monedero Coinbase se consolidan en su AWS factura mensual en función de los precios de Coinbase en el sitio web de Coinbase. De lo contrario, la creación del conector fallará con un SubscriptionRequiredException (HTTP 403). Si no está suscrito, la consola muestra una AWS
alerta de suscripción a Coinbase para permitir la facturación mediante un botón de suscripción que puede utilizar para suscribirse sin salir del asistente. Para obtener más información, consulte Suscríbase a Coinbase Wallets para AgentCore pagos en Marketplace. AWS
Si eliges Stripe (privado), rellena los siguientes campos en Configuración del proveedor de pagos y, a continuación, selecciona Crear autenticación de pago:
-
En el caso del ID de aplicación, introduce el identificador único de las credenciales de tu cuenta privada.
-
En Secreto de aplicación, introduce la clave privada utilizada para autenticar y firmar las solicitudes a la aplicación Privy.
-
En el campo ID de autorización, introduzca el identificador único de la entidad de autorización.
-
En Clave privada de autorización, introduzca la clave privada utilizada para firmar las solicitudes de autorización.
Paso 6: Crea el administrador de pagos
-
Revise la configuración y, a continuación, seleccione Crear administrador de pagos.
Tras seleccionar Crear gestor de pagos, la consola accederá a la página de detalles del gestor de pagos. Un aviso de éxito confirma que se ha creado el gestor de pagos y proporciona los siguientes pasos:
-
Configure el instrumento y la sesión de pago y, si lo desea, especifique el presupuesto.
-
Integre el gestor de pagos en su estructura de agentes.
-
Descubra las herramientas y puntos finales de pago de MCP.
-
Habilite las entregas y los seguimientos de registros para ver las métricas en el panel de observabilidad.
La página de detalles del gestor de pagos incluye secciones sobre los conectores de pagos, las plantillas de códigos de integración, la autenticación entrante, las métricas de observabilidad y la configuración de envíos y seguimiento de registros.
- AgentCore CLI
-
La AgentCore CLI crea el proveedor de credenciales, el administrador de pagos y el conector de pago juntos desde el directorio del proyecto. Requiere 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, opcionalmente, explica cómo agregar un conector con las credenciales del proveedor.
Coinbase: creación rápida (recomendada):
Quick Create te proporciona el proveedor de credenciales de Coinbase para que no pases ninguna clave de API. Añada el conector con la --provision-mode QUICK_CREATE marca y, a continuación, despliegue:
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 llega a READY ellas.
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 (privado) — 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 administrador de pagos y el conector.
- AgentCore SDK
-
El AgentCore SDK admite la creación rápida de Coinbase (se muestra primero) y el aprovisionamiento manual. Los ejemplos del manual que aparecen a continuación transmiten directamente las credenciales del proveedor. Utilizan el práctico métodocreate_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 (recomendada):
Con Quick Create, se crea el conector con una credential_provider_configurations lista vacía yprovision_mode="QUICK_CREATE". El conector devuelve el estado PENDING_AUTHENTICATION y una URL de autorización. Una vez que autorices a través de Coinbase, el servicio se aprovisiona al proveedor de credenciales y al que llega el conector. 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 ser 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 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"]
- AWS CLI
-
Cree un administrador de pagos con 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
Cree un administrador 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 de administrador de pagos comienza cuando se completa el aprovisionamiento CREATING y pasa a ese estado READY cuando finaliza el aprovisionamiento.
Coinbase: creación rápida (recomendada):
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. Abra la URL, autorícela a través de Coinbase y, a continuación, sondee get-payment-connector hasta que el estado seaREADY. La URL es válida durante unos 10 minutos; si caduca, el conector pasa a ella AUTHENTICATION_EXPIRED y tú la vuelves a crear.
Las credenciales que proporciona Quick Create están gestionadas por el servicio, por lo que puede sustituirlas cuando lo desee. rotate-payment-connector-credentials Para obtener más información, consulte Rotar las credenciales de los conectores gestionados por el servicio.
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 administrador 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
El siguiente ejemplo 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
- AWS SDK
-
Cree un administrador de pagos con 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']}")
Cree un administrador 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 (recomendada):
Con Quick Create, se crea 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, autorícela a través de Coinbase y, a continuación, sondee get_payment_connector hasta que el estado seaREADY. La URL es válida durante unos 10 minutos; si caduca, el conector pasa a ella AUTHENTICATION_EXPIRED y tú la vuelves a crear.
Las credenciales que proporciona Quick Create están gestionadas por el servicio, por lo que puede sustituirlas cuando lo desee. rotate_payment_connector_credentials Para obtener más información, consulte Rotar las credenciales de los conectores gestionados por el servicio.
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 administrador 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, cree 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"
}
}
]
)
