Crie um gerenciador e conector de pagamentos

Etapa 1: Abra a página de pagamentos

Etapa 2: configurar os detalhes do Payment Manager

Etapa 3: configurar as permissões

A seção Permissões especifica as permissões para esse gerente de pagamento e os AWS recursos que o pagamento pode acessar.

Para permissões do IAM, escolha uma das seguintes opções:

Etapa 4: configurar a autorização de entrada

A autorização de entrada controla quem pode acessar esse Gerenciador de pagamentos. Na seção Autenticação de entrada, para o tipo Autenticação de entrada, escolha uma das seguintes opções:

Para usar a autorização do IAM:

Para usar a autorização do JWT com o Amazon Cognito:

Para usar a autorização JWT com um provedor de identidade existente:

Etapa 5: adicionar um conector de pagamento (opcional)

Os conectores de pagamento armazenam as credenciais e a configuração necessárias para se conectar aos provedores de serviços de pagamento. Adicionar um conector durante a criação é opcional, mas é necessário um conector para que o serviço processe pagamentos.

Crie uma autenticação de pagamento

Quando você escolhe criar um novo na seção Autenticação de pagamento do conector, o painel Criar autenticação de pagamento é aberto. Nesse painel, você configura uma nova autenticação de pagamento — um provedor de credenciais de pagamento armazenado no AgentCore Identity.

Se você escolher a Coinbase, escolha como fornecer as credenciais para a autenticação de pagamento:

Use a criação rápida

Se você selecionar Configurações de criação rápida - recomendado, o AgentCore Payments cria a autenticação de pagamento para você depois de autorizar o acesso por meio da Coinbase. Execute as etapas a seguir:

Use as configurações existentes

Se você selecionar Usar configurações existentes, preencha os seguintes campos em Configurações do provedor de pagamento e escolha Criar autenticação de pagamento:

Se você escolher Stripe (Privy), preencha os seguintes campos em Configurações do provedor de pagamento e escolha Criar autenticação de pagamento:

Etapa 6: criar o gerenciador de pagamentos

Depois de escolher Criar Gerenciador de Pagamentos, o console navega até a página de detalhes do Gerenciador de Pagamentos. Um banner de sucesso confirma que o Gerenciador de pagamentos foi criado e fornece as próximas etapas a seguir:

A página de detalhes do Payment Manager inclui seções para conectores de pagamento, modelos de código de integração, autenticação de entrada, métricas de observabilidade e configuração de rastreamento e entregas de registros.

A AgentCore CLI cria o provedor de credenciais, o Payment Manager e o Payment Connector juntos a partir do diretório do seu projeto. Requer CLI v0.19.0 ou posterior.

Assistente interativo:

agentcore add payment-manager

O assistente solicita o nome do gerente, o padrão, a opção de pagamento automático, o limite de gastos e, opcionalmente, indica a adição de um conector com as credenciais do provedor.

Coinbase — Criação rápida (recomendada):

O Quick Create provisiona o provedor de credenciais da Coinbase para você, para que você não transmita nenhuma chave de API. Adicione o conector com a --provision-mode QUICK_CREATE bandeira e implante:

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

agentcore deploy

A CLI abre o fluxo de autorização da Coinbase. Depois de autorizar, o serviço fornece as credenciais e o conector chega. READY

Coinbase CDP — Fluxo manual (não interativo):

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) — Fluxo manual (não interativo):

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

A execução agentcore deploy provisiona funções do IAM, armazena credenciais no AgentCore Identity e cria o Payment Manager e o Connector.

O AgentCore SDK suporta a criação rápida do Coinbase (mostrada primeiro) e o provisionamento manual. Os exemplos manuais a seguir passam diretamente pelas credenciais do provedor. Eles usam o método de conveniênciacreate_payment_manager_with_connector, que cria o gerenciador de pagamentos, o provedor de credenciais e o conector em uma única chamada.

Coinbase — Criação rápida (recomendada):

Com a criação rápida, você cria o conector com uma credential_provider_configurations lista vazia provision_mode="QUICK_CREATE" e. O conector retorna o status PENDING_AUTHENTICATION e um URL de autorização. Depois de autorizar por meio da Coinbase, o serviço é fornecido pelo provedor de credenciais e pelo 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)

O URL de autorização é válido por cerca de 10 minutos. Se ele expirar, o conector faz a transição AUTHENTICATION_EXPIRED e você o recria.

CDP da Coinbase com autorização 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 com autorização 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) com autorização do 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) com autorização 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"]

Crie um gerenciador de pagamentos com autorização do 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

Crie um gerenciador de pagamentos com autorização do 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

O status do Gerenciador de pagamentos começa como CREATING e passa para READY quando o provisionamento é concluído.

Coinbase — Criação rápida (recomendada):

Com a criação rápida, você cria o conector com uma lista vazia de configurações do provedor de credenciais e. --provision-mode QUICK_CREATE Você não cria um provedor de credenciais primeiro.

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

A resposta tem status PENDING_AUTHENTICATION e umauthorizationUrl. Abra o URL, autorize por meio da Coinbase e faça uma pesquisa get-payment-connector até que o status seja. READY O URL é válido por cerca de 10 minutos; se expirar, o conector muda para AUTHENTICATION_EXPIRED e você o recria.

Fluxo manual: com o fluxo manual, você cria um provedor de credenciais de pagamento e depois faz referência ao ARN ao criar o conector. Esse é o único fluxo para o Stripe (Privy).

Depois que o Gerenciador de pagamentos estiver pronto, crie um provedor de credenciais de pagamento:

O exemplo a seguir cria um provedor de credenciais de pagamento para o 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

O exemplo a seguir cria um provedor de credenciais de pagamento para o 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

Depois que o provedor de credenciais estiver pronto, crie um 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

Crie um gerenciador de pagamentos com autorização do 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']}")

Crie um gerenciador de pagamentos com autorização do 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 — Criação rápida (recomendada):

Com a criação rápida, você cria o conector com uma credentialProviderConfigurations lista vazia provisionMode="QUICK_CREATE" e. Você não cria um provedor de credenciais primeiro.

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

O conector retorna status PENDING_AUTHENTICATION e umauthorizationUrl. Abra o URL, autorize por meio da Coinbase e faça uma pesquisa get_payment_connector até que o status seja. READY O URL é válido por cerca de 10 minutos; se expirar, o conector muda para AUTHENTICATION_EXPIRED e você o recria.

Fluxo manual: com o fluxo manual, você cria um provedor de credenciais de pagamento e depois faz referência ao ARN ao criar o conector. Esse é o único fluxo para o Stripe (Privy).

Depois que o Gerenciador de pagamentos atingir READY o status, crie um provedor de credenciais de pagamento:

O exemplo a seguir configura um provedor para o 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"
        }
    }
)

O exemplo a seguir configura um provedor para o 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"
        }
    }
)

Depois de criar o provedor de credenciais de pagamento, crie um 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), use a variante de stripePrivy configuração:

# 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

Os remove comandos atualizam a configuração local. O acompanhamento deploy destrói a infraestrutura de pagamento da sua conta.

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