Crea un gestore dei pagamenti Stati del ciclo di vita Ottieni un gestore dei pagamenti Elenca gestori di pagamenti Eliminare un gestore dei pagamenti Fasi successive

Crea un gestore e un connettore dei pagamenti

Un Payment Manager è la risorsa di primo livello che coordina le operazioni di pagamento per il tuo AWS account. Quando crei un Payment Manager, specifichi un tipo di autorizzazione e un ruolo IAM e il servizio fornisce un'identità del carico di lavoro corrispondente in Identity. AgentCore

Questa guida illustra come creare un Payment Manager e collegare un Payment Connector utilizzando la Console di AWS gestione o l'SDK. AWS Per gli schemi completi di richiesta e risposta, consulta CreatePaymentManagere CreatePaymentConnectornell'API Reference.

Suggerimento

Puoi automatizzare i passaggi di questa pagina con l'abilità AgentCore Pagamenti nel toolkit per AWS agenti. L'abilità fa parte del plug-in aws-agents e consente a un agente di codifica AI di creare Payment Manager, connettore, fornitore di credenziali, strumento di pagamento e sessione utilizzando la agentcore CLI e di aggiungere uno strumento di pagamento x402 al tuo agente. Per i dettagli, consulta il quickstart e il toolkit per agenti su.AWS GitHub

Prima di iniziare, assicurati di disporre dei seguenti elementi:

Sono stati completati i prerequisiti (account, credenziali, chiavi del provider).
Imposta i ruoli IAM richiesti (ruolo di amministratore e ruolo di servizio).

Crea un gestore dei pagamenti

Esempio

Console

Passaggio 1: apri la pagina Pagamenti

Apri la AgentCore console Amazon Bedrock.
Nel pannello di navigazione, in Crea, scegli Pagamenti.
Nella sezione Gestori dei pagamenti, scegli Crea gestore dei pagamenti.

Passaggio 2: configura i dettagli di Payment Manager

In Nome, inserisci un nome per il tuo Payment Manager. Il nome deve iniziare con una lettera. I caratteri validi sono a–zA–Z,0–9. Il nome può contenere fino a 48 caratteri.
(Facoltativo) Scegli Descrizione per espandere la sezione, quindi inserisci una descrizione per identificare questo Payment Manager.

Passaggio 3: Configurare le autorizzazioni

La sezione Autorizzazioni specifica le autorizzazioni per questo Payment Manager e le AWS risorse a cui il pagamento può accedere.

Per le autorizzazioni IAM, scegli una delle seguenti opzioni:

Crea e usa un nuovo ruolo di servizio: Amazon Bedrock AgentCore payments crea un nuovo ruolo di servizio per tuo conto. Il nome del ruolo di servizio predefinito viene generato automaticamente. Per ulteriori informazioni, consulta Autorizzazioni dei ruoli di servizio.
Usa un ruolo di servizio esistente: utilizza un ruolo di servizio che hai già creato. Se scegli questa opzione, seleziona un ruolo dall'elenco a discesa.

Fase 4: Configurare l'autorizzazione in entrata

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

Per utilizzare l'autorizzazione IAM:

Scegli Usa nome utente IAM. Questo utilizza il nome utente IAM che hai usato per accedere alla AWS console.

Per utilizzare l'autorizzazione JWT con Amazon Cognito:

Scegli Usa JSON Web Tokens (JWT).
Per la configurazione dello schema JWT, scegli Creazione rapida di configurazioni con Cognito: opzione consigliata. Amazon Bedrock AgentCore Payments crea le configurazioni di autorizzazione in entrata per tuo conto utilizzando Amazon Cognito come provider di identità. e non sono necessarie ulteriori configurazioni.

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

Scegli Usa token Web JSON (JWT).
Per la configurazione dello schema JWT, scegli Usa configurazioni di provider di identità esistenti. Questa opzione consente di importare le configurazioni di autorizzazione in entrata esistenti da qualsiasi provider di identità per abilitare OAuth 2.0.
Per Discovery URL, inserisci l'URL di rilevamento del tuo provider di identità (ad esempio, Okta o Cognito), che in genere si trova nella documentazione di quel provider. Ciò consente al tuo agente o strumento di recuperare le impostazioni di accesso, il token di risorse downstream e le impostazioni di verifica. Ad esempio, https://accounts.cognito.com/.well-known/openid-configuration.
Per i destinatari consentiti, inserisci gli ID client registrati presso i provider di identità o qualsiasi stringa arbitraria nel gruppo di destinatari JWT che l'autorizzatore deve verificare. Scegli + Aggiungi pubblico per aggiungere altri segmenti di pubblico.
Per i client consentiti, inserisci gli ID client registrati presso i provider di identità o qualsiasi stringa arbitraria nell'audience JWT che l'autorizzatore deve verificare. Scegli + Aggiungi cliente per aggiungere altri clienti.
In Ambiti consentiti, inserisci gli ambiti richiesti. L'accesso è consentito solo se il token contiene almeno uno degli ambiti richiesti configurati qui. Scegli + Aggiungi ambito per aggiungere altri ambiti.
(Facoltativo) Per le attestazioni personalizzate, definisci le regole che abbinano le attestazioni specifiche nel token in entrata a valori predefiniti. Per ogni regola, specifica il nome, il tipo di stringa, l'operatore e il valore dell'attestazione. Scegli + Aggiungi rivendicazione per aggiungere altre rivendicazioni.

Passaggio 5: aggiungi 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 per consentire al servizio di elaborare i pagamenti.

Nella sezione Connettore di pagamento: nuovo connettore, in Nome, inserisci un nome per il connettore. I caratteri validi sono a–zA–Z,0–9, e _ (trattino basso). Il nome può contenere fino a 48 caratteri.
(Facoltativo) Scegliete Descrizione per espandere la sezione, quindi inserite una descrizione per il connettore.
Nella sezione Aggiungi autenticazione in uscita, se desideri riutilizzare un fornitore di credenziali di pagamento precedentemente creato in AgentCore Identity, seleziona un'autenticazione in uscita esistente dal menu a discesa oppure scegli creane uno nuovo per creare un nuovo fornitore di credenziali di pagamento. Se scegli di crearne una nuova, consulta Creare una nuova autenticazione in uscita.
(Facoltativo) Per aggiungere connettori aggiuntivi, scegli + Aggiungi connettore e ripeti i passaggi precedenti.

Crea una nuova autenticazione in uscita

Quando scegli di crearne una nuova nella sezione di autenticazione in uscita del connettore, si apre un pannello in cui puoi configurare un nuovo fornitore di credenziali di pagamento.

In Nome, inserisci un nome per l'autenticazione in uscita. I caratteri validi sonoa–z,A–Z,0–9, _ (trattino basso) e - (trattino).
Per Provider, seleziona un gestore dei pagamenti dal menu a discesa. I provider disponibili sono Coinbase e Stripe (Privy).

Se scegli Coinbase, completa i seguenti campi in Configurazioni del fornitore di servizi di pagamento:

Per l'ID della chiave API, inserisci l'identificatore univoco per le credenziali del tuo account Coinbase CDP.
Per il segreto della chiave API, inserisci la chiave privata utilizzata per autenticare e firmare le richieste a Coinbase CDP.
Per Wallet secret, inserisci la chiave privata asimmetrica utilizzata per autenticare le operazioni di scrittura sensibili del portafoglio.

Se scegli Stripe (Privy), completa i seguenti campi in Configurazioni del fornitore di servizi di pagamento:

Per App ID, inserisci l'identificatore univoco per le credenziali del tuo account Privy.
Per App secret, inserisci la chiave privata utilizzata per autenticare e firmare le richieste all'applicazione Privy.
Per ID di autorizzazione, inserisci l'identificatore univoco dell'entità di autorizzazione.
Per Chiave privata di autorizzazione, inserisci la chiave privata utilizzata per firmare le richieste di autorizzazione.

Dopo aver completato la configurazione del provider, scegli Aggiungi autenticazione in uscita.

Passaggio 6: creare il gestore dei pagamenti

Controlla la configurazione, quindi scegli Crea gestore dei pagamenti.

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

Imposta lo strumento di pagamento e la sessione, facoltativamente specifica il budget.
Integra Payment Manager nel tuo framework di agenti.
Scopri gli strumenti e gli endpoint MCP a pagamento.
Abilita le consegne e le tracce dei log per visualizzare le metriche nella dashboard di osservabilità.

La pagina dei dettagli di Payment Manager include sezioni relative ai connettori di pagamento, ai modelli di codice di integrazione, all'autenticazione in entrata, alle metriche di osservabilità e alla configurazione delle consegne e della tracciabilità dei registri.

AgentCore CLI

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

Procedura guidata interattiva:


agentcore add payment-manager

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

Non-interactive (Coinbase CDP):


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

Non-interactive (Stripe/Privy):


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 Payment Manager e Connector.

AgentCore SDK

L' AgentCore SDK offre un metodo pratico create_payment_manager_with_connector che consente di creare Payment Manager, provider di credenziali e connettore in un'unica chiamata.

Coinbase CDP con autorizzazione IAM:


from bedrock_agentcore.payments 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"]

AWS CLI

Crea un Payment Manager 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 Payment Manager 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 al READY termine del provisioning.

Dopo che 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

Dopo che 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

AWS SDK

Crea un Payment Manager 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 Payment Manager 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"
            }
        ]
    }
)

Dopo che il Payment Manager ha raggiunto READY lo stato, 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), usa 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"
            }
        }
    ]
)

Stati del ciclo di vita

Dopo la creazione, Payment Manager passa attraverso i seguenti stati:

Stato	Description
`CREATING`	Stato iniziale durante l'approvvigionamento.
`READY`	Payment Manager è operativo e accetta configurazioni di connettori.
`UPDATING`	Viene applicata una modifica alla configurazione.
`CREATE_FAILED`	Errore di provisioning.
`UPDATE_FAILED`	Operazione di aggiornamento non riuscita.

Ottieni un gestore dei pagamenti

Esempio

Elenca gestori di pagamenti

Esempio

Eliminare un gestore dei pagamenti

Esempio

Fasi successive

Dopo aver creato il tuo Payment Manager, puoi:

Configurare strumenti e sessioni di pagamento: configura gli strumenti e le sessioni di pagamento per avviare l'elaborazione delle transazioni. Vedi Creare uno strumento di pagamento.
Integra con il tuo framework per agenti: utilizza i modelli di codice di integrazione per connettere Payment Manager al tuo flusso di lavoro agentico. Vedi Elaborazione dei pagamenti.
Scopri gli strumenti e gli endpoint MCP a pagamento: connettiti a server MCP pronti all'uso con endpoint pay-per-use o porta i tuoi endpoint commerciali. Vedi AgentCore Coinbase Bazaar tramite Gateway.
Abilita l'osservabilità: configura le consegne e il tracciamento dei log per monitorare sessioni, chiamate alle API, transazioni e tassi di errore. Vedi Osservabilità.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Ruoli IAM

Elaborazione dei pagamenti