Crea un gestore e un connettore dei pagamenti

Passaggio 1: apri la pagina Pagamenti

Passaggio 2: configura i dettagli del gestore dei pagamenti

Fase 3: Configurare le autorizzazioni

La sezione Autorizzazioni specifica le autorizzazioni per questo gestore dei pagamenti e le AWS risorse a cui il pagamento può accedere.

Per le autorizzazioni IAM, scegli una delle seguenti opzioni:

Fase 4: Configurare l'autorizzazione in entrata

L'autorizzazione in entrata controlla chi può accedere a questo gestore dei pagamenti. Nella sezione Autenticazione in entrata, per il tipo di autenticazione in entrata, scegli una delle seguenti opzioni:

Per utilizzare l'autorizzazione IAM:

Per utilizzare l'autorizzazione JWT con Amazon Cognito:

Per utilizzare l'autorizzazione JWT con un provider di identità esistente:

Passaggio 5: aggiungere un connettore di pagamento (opzionale)

I connettori di pagamento memorizzano le credenziali e la configurazione necessarie per connettersi con i fornitori di servizi di pagamento. L'aggiunta di un connettore durante la creazione è facoltativa, ma è necessario un connettore affinché il servizio elabori i pagamenti.

Crea l'autenticazione dei pagamenti

Quando scegli di crearne uno nuovo nella sezione Autenticazione dei pagamenti del connettore, si apre il pannello Crea autenticazione pagamento. In questo pannello, configuri una nuova autenticazione di pagamento, un fornitore di credenziali di pagamento archiviato in Identity. AgentCore

Se scegli Coinbase, scegli come fornire le credenziali per l'autenticazione del pagamento:

Usa Creazione rapida

Se selezioni Creazione rapida delle configurazioni (consigliata), AgentCore payments crea automaticamente l'autorizzazione di pagamento dopo aver autorizzato l'accesso tramite Coinbase. Completa questa procedura:

Usa le configurazioni esistenti

Se selezioni Utilizza configurazioni esistenti, completa i seguenti campi in Configurazioni del gestore dei pagamenti, quindi scegli Crea autenticazione di pagamento:

Se scegli Stripe (Privy), completa i seguenti campi nelle configurazioni del gestore dei pagamenti, quindi scegli Crea autenticazione di pagamento:

Passaggio 6: creare il gestore dei pagamenti

Dopo aver scelto Crea gestore dei pagamenti, la console passa alla pagina dei dettagli del gestore dei pagamenti. Un banner con esito positivo conferma che il Payment Manager è stato creato e fornisce i seguenti passaggi successivi:

La pagina dei dettagli di Payment Manager include sezioni per i connettori di pagamento, i modelli di codice di integrazione, l'autenticazione in entrata, le metriche di osservabilità e la configurazione delle consegne e del tracciamento dei log.

La AgentCore CLI crea il fornitore di credenziali, il Payment Manager e il Payment Connector insieme dalla directory del progetto. Richiede CLI v0.19.0 o successivo.

Procedura guidata interattiva:

agentcore add payment-manager

La procedura guidata richiede il nome del gestore, lo schema, la modalità di attivazione del pagamento automatico, il limite di spesa e, facoltativamente, spiega come aggiungere un connettore con le credenziali del fornitore.

Coinbase — Creazione rapida (consigliata):

Quick create fornisce il provider di credenziali Coinbase per te, in modo da non passare alcuna chiave API. Aggiungi il connettore con la --provision-mode QUICK_CREATE bandiera, quindi implementa:

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

agentcore deploy

La CLI apre il flusso di autorizzazione di Coinbase. Dopo l'autorizzazione, il servizio fornisce le credenziali e il connettore le raggiunge. READY

Coinbase CDP — Flusso manuale (non interattivo):

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) — Flusso manuale (non interattivo):

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 esegue il agentcore deploy provisioning dei ruoli IAM, archivia le credenziali in AgentCore Identity e crea il Payment Manager e il Connector.

L' AgentCore SDK supporta la creazione rapida di Coinbase (mostrata per prima) e il provisioning manuale. Gli esempi manuali che seguono direttamente le credenziali del fornitore del pass. Usano il metodo convenientecreate_payment_manager_with_connector, che crea il Payment Manager, il fornitore di credenziali e il connettore in un'unica chiamata.

Coinbase — Creazione rapida (consigliata):

Con Quick create, crei il connettore con un credential_provider_configurations elenco vuoto eprovision_mode="QUICK_CREATE". Il connettore restituisce lo stato PENDING_AUTHENTICATION e un URL di autorizzazione. Dopo l'autorizzazione tramite Coinbase, il servizio fornisce le credenziali al fornitore di credenziali e al connettore. 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 di autorizzazione è valido per circa 10 minuti. Se scade, il connettore passa a AUTHENTICATION_EXPIRED e tu lo crei nuovamente.

Coinbase CDP con autorizzazione 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 autorizzazione 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 autorizzazione 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 autorizzazione 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 gestore dei pagamenti con autorizzazione 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 gestore dei pagamenti con autorizzazione 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

Lo stato di Payment Manager inizia CREATING e passa a READY quando viene completato il provisioning.

Coinbase — Creazione rapida (consigliata):

Con Quick create, crei il connettore con un elenco di configurazioni del fornitore di credenziali vuoto e. --provision-mode QUICK_CREATE Non è necessario creare prima un provider di credenziali.

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 risposta ha uno status PENDING_AUTHENTICATION e unauthorizationUrl. Apri l'URL, autorizza tramite Coinbase e poi esegui il polling get-payment-connector fino a ottenere lo stato. READY L'URL è valido per circa 10 minuti; se scade, il connettore passa a AUTHENTICATION_EXPIRED e tu lo crei nuovamente.

Flusso manuale: con il flusso manuale, crei un fornitore di credenziali di pagamento e quindi fai riferimento al relativo ARN quando crei il connettore. Questo è l'unico flusso per Stripe (Privy).

Quando il Payment Manager è pronto, crea un fornitore di credenziali di pagamento:

L'esempio seguente crea un fornitore di credenziali di pagamento per 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'esempio seguente crea un fornitore di credenziali di pagamento per 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

Quando il fornitore di credenziali è pronto, crea un connettore:

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 gestore dei pagamenti con autorizzazione 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 gestore dei pagamenti con autorizzazione 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 — Creazione rapida (consigliata):

Con Quick create, crei il connettore con un credentialProviderConfigurations elenco vuoto eprovisionMode="QUICK_CREATE". Non si crea prima un fornitore di credenziali.

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

Il connettore restituisce lo stato PENDING_AUTHENTICATION e unauthorizationUrl. Apri l'URL, autorizza tramite Coinbase e poi esegui il polling get_payment_connector fino a ottenere lo stato. READY L'URL è valido per circa 10 minuti; se scade, il connettore passa a AUTHENTICATION_EXPIRED e tu lo crei nuovamente.

Flusso manuale: con il flusso manuale, crei un fornitore di credenziali di pagamento e quindi fai riferimento al relativo ARN quando crei il connettore. Questo è l'unico flusso per Stripe (Privy).

Una volta raggiunto READY lo stato di Payment Manager, crea un fornitore di credenziali di pagamento:

L'esempio seguente configura un provider per 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'esempio seguente configura un provider per 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"
        }
    }
)

Dopo aver creato il fornitore di credenziali di pagamento, crea un connettore:

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

Per Stripe (Privy), utilizza la stripePrivy variante di configurazione:

# 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

I remove comandi aggiornano la configurazione locale. Il follow-up deploy distrugge l'infrastruttura di pagamento del tuo account.

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