Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Guida introduttiva ad Amazon Managed Blockchain (AMB) Query
Utilizza step-by-step i tutorial in questa sezione per imparare a eseguire attività utilizzando Amazon Managed Blockchain (AMB) Query. Queste procedure richiedono alcuni prerequisiti. Se non conosci AMB Query, puoi consultare la sezione *Configurazione* di questa guida. Per ulteriori informazioni, consulta [Configurazione di Amazon Managed Blockchain (AMB) Query](ambq-setting-up.md).
**Nota**
Alcune variabili in questi esempi sono state deliberatamente offuscate. Sostituiscile con altre valide prima di eseguire questi esempi.
**Topics**
+ [Crea una policy IAM per accedere alle operazioni dell'API AMB Query](#getting-started-iam-policy)
+ [Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Go](#getting-started-go-example)
+ [Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Node.js](#node-amb-query-requests)
+ [Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Python](#python-amb-query-requests)
+ [Usa Amazon Managed Blockchain (AMB) Query su Console di gestione AWS per eseguire l'operazione GetTokenBalance](#query-console-gettokenbalance-example)
## Crea una policy IAM per accedere alle operazioni dell'API AMB Query
Per effettuare richieste API AMB Query, devi utilizzare le credenziali utente (AWS\_ACCESS\_KEY\_ID e AWS\_SECRET \_ACCESS\_KEY) che dispongono delle autorizzazioni IAM appropriate per Amazon Managed Blockchain (AMB) Query. In un terminale su cui è AWS CLI installato, esegui il seguente comando per creare una policy IAM per accedere alle operazioni dell'API AMB Query:
```
cat < ~/{{amb-query-access-policy.json}}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid" : "{{AMBQueryAccessPolicy}}",
"Effect": "Allow",
"Action": [
"managedblockchain-query:*"
],
"Resource": "*"
}
]
}
EOT
aws iam create-policy --policy-name AmazonManagedBlockchainQueryAccess --policy-document {{file://$HOME/amb-query-access-policy.json}}
```
Dopo aver creato la policy, associala al ruolo di un utente IAM per renderla effettiva. Nella Console di gestione AWS, accedi al servizio IAM e collega la policy `AmazonManagedBlockchainQueryAccess` al ruolo assegnato all'utente IAM che utilizzerà il servizio. Per ulteriori informazioni, consulta [Creazione di un ruolo e assegnazione a un utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
**Nota**
AWS consiglia di consentire l'accesso a operazioni API specifiche anziché utilizzare la `*` wild-card. Per ulteriori informazioni, consulta [Accesso a specifiche azioni dell'API Amazon Managed Blockchain (AMB) Query](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis).
## Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Go
Con Amazon Managed Blockchain (AMB) Query, puoi creare applicazioni che dipendono dall'accesso istantaneo ai dati della blockchain una volta confermati sulla blockchain, anche se non sono ancora stati raggiunti*.* AMB Query consente diversi casi d'uso, come la compilazione della cronologia delle transazioni di un portafoglio, la fornitura di informazioni contestuali su una transazione in base all'hash della transazione o l'ottenimento del saldo di un token nativo e dei token ERC-721, ERC-1155 ed ERC-20.
I seguenti esempi sono creati nel linguaggio Go e utilizzano le operazioni dell'API AMB Query. Per ulteriori informazioni su Go, consulta la [documentazione di Go](https://go.dev/doc/). Per ulteriori informazioni sull'API AMB Query, consulta la documentazione di [riferimento sull'API Query di Amazon Managed Blockchain (AMB)](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html).
Gli esempi seguenti utilizzano le azioni `ListTransactions` e le `GetTransaction` API per ottenere prima un elenco di tutte le transazioni per un determinato indirizzo di proprietà esterna (EOA) sulla rete principale di Ethereum, quindi l'esempio successivo recupera i dettagli della transazione per una singola transazione dall'elenco.
**Example — Effettua l'azione API usando Go `ListTransactions`**
Copia il codice seguente in un file denominato `listTransactions.go` nella *ListTransactions*directory.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
"time"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("{{us-east-1}}"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// Inputs for ListTransactions API
ownerAddress := "{{0x00000bf26964af9d7eed9e03e53415d********}}"
network := managedblockchainquery.{{QueryNetworkEthereumMainnet}}
sortOrder := managedblockchainquery.{{SortOrderAscending}}
fromTime := time.{{Date(1971, 1, 1, 1, 1, 1, 1, time.UTC)}}
toTime := {{time.Now()}}
nonFinal := "{{NONFINAL}}"
// Call ListTransactions API. Transactions that have reached finality are always returned
listTransactionRequest, listTransactionResponse := client.ListTransactionsRequest(&managedblockchainquery.ListTransactionsInput{
Address: &ownerAddress,
Network: &network,
Sort: &managedblockchainquery.ListTransactionsSort{
SortOrder: &sortOrder,
},
FromBlockchainInstant: &managedblockchainquery.BlockchainInstant{
Time: &fromTime,
},
ToBlockchainInstant: &managedblockchainquery.BlockchainInstant{
Time: &toTime,
},
ConfirmationStatusFilter: &managedblockchainquery.ConfirmationStatusFilter{
Include: []*string{&nonFinal},
},
})
errors := listTransactionRequest.Send()
if errors == nil {
// handle API response
fmt.Println(listTransactionResponse)
} else {
// handle API errors
fmt.Println(errors)
}
}
```
Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della *ListTransactions*directory:`go run listTransactions.go`.
L'output che segue è simile al seguente:
```
{
Transactions: [
{
ConfirmationStatus: "FINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x12345ea404b45323c0cf458ac755ecc45985fbf2b18e2996af3c8e8693354321",
TransactionTimestamp: 2020-06-01 01:59:11 +0000 UTC
},
{
ConfirmationStatus: "FINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x1234547c65675d867ebd2935bb7ebe0996e9ec8e432a579a4516c7113bf54321",
TransactionTimestamp: 2021-09-01 20:06:59 +0000 UTC
},
{
ConfirmationStatus: "NONFINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x123459df7c1cd42336cd1c444cae0eb660ccf13ef3a159f05061232a24954321",
TransactionTimestamp: 2024-01-23 17:10:11 +0000 UTC
}
]
}
```
**Example — Esegui l'azione dell'`GetTransaction`API utilizzando Go**
Questo esempio utilizza un hash di transazione dell'output precedente. Copia il codice seguente in un file denominato `GetTransaction.go` nella *GetTransaction*directory.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("us-east-1"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// inputs for GetTransaction API
transactionHash := "{{0x123452695a82868950d9db8f64dfb2f6f0ad79284a6c461d115ede8930754321}}"
network := managedblockchainquery.{{QueryNetworkEthereumMainnet}}
// Call GetTransaction API. This operation will return transaction details for all
// transactions that are confirmed on the blockchain, even if they have not
// reached finality.
getTransactionRequest, getTransactionResponse := client.GetTransactionRequest(&managedblockchainquery.{{GetTransactionInput}}{
Network: &network,
TransactionHash: &transactionHash,
})
errors := getTransactionRequest.Send()
if errors == nil {
// handle API response
fmt.Println({{getTransactionResponse}})
} else {
// handle API errors
fmt.Println(errors)
}
}
```
Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della *GetTransaction*directory:`go run GetTransaction.go`.
L'output che segue è simile al seguente:
```
{
Transaction: {
BlockHash: "0x000005c6a71d1afbc005a652b6ceca71cd516d97b0fc514c2a1d0f2ca3912345",
BlockNumber: "11111111",
CumulativeGasUsed: "5555555",
EffectiveGasPrice: "44444444444",
From: "0x9157f4de39ab4c657ad22b9f19997536********",
GasUsed: "22222",
Network: "ETHEREUM_MAINNET",
NumberOfTransactions: 111,
SignatureR: "0x99999894fd2df2d039b3555dab80df66753f84be475069dfaf6c6103********",
SignatureS: "0x77777a101e7f37dd2dd0bf878b39080d5ecf3bf082c9bd4f40de783e********",
SignatureV: 0,
ConfirmationStatus: "FINAL",
ExecutionStatus: "SUCCEEDED",
To: "0x5555564f282bf135d62168c1e513280d********",
TransactionHash: "0x123452695a82868950d9db8f64dfb2f6f0ad79284a6c461d115ede8930754321",
TransactionIndex: 11,
TransactionTimestamp: 2022-02-02 01:01:59 +0000 UTC
}
}
```
L'`GetTokenBalance`API consente di ottenere il saldo dei token nativi (ETH e BTC), che possono essere utilizzati per ottenere il saldo corrente di un conto di proprietà esterna (EOA) in un determinato momento.
**Example — Usa l'azione `GetTokenBalance` API per ottenere il saldo di un token nativo in Go**
Nell'esempio seguente, utilizzi l'`GetTokenBalance`API per ottenere un saldo in Ether (ETH) di un indirizzo sulla rete principale di Ethereum. Copia il codice seguente in un file denominato `GetTokenBalanceEth.go` nella *GetTokenBalance*directory.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("us-east-1"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// inputs for GetTokenBalance API
ownerAddress := "{{0xBeE510AF9804F3B459C0419826b6f225********}}"
network := managedblockchainquery.{{QueryNetworkEthereumMainnet}}
nativeTokenId := "{{eth}}" //Ether on Ethereum mainnet
// call GetTokenBalance API
getTokenBalanceRequest, getTokenBalanceResponse := client.GetTokenBalanceRequest(&managedblockchainquery.{{GetTokenBalanceInput}}{
TokenIdentifier: &managedblockchainquery.TokenIdentifier{
Network: &network,
TokenId: &nativeTokenId,
},
OwnerIdentifier: &managedblockchainquery.OwnerIdentifier{
Address: &ownerAddress,
},
})
errors := getTokenBalanceRequest.Send()
if errors == nil {
// process API response
fmt.Println(getTokenBalanceResponse)
} else {
// process API errors
fmt.Println(errors)
}
}
```
Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della *GetTokenBalance*directory:`go run GetTokenBalanceEth.go`.
L'output che segue è simile al seguente:
```
{
AtBlockchainInstant: {
Time: 2020-12-05 11:51:01 +0000 UTC
},
Balance: "4343260710",
LastTransactionHash: "0x00000ce94398e56641888f94a7d586d51664eb9271bf2b3c48297a50a0711111",
LastTransactionTime: 2023-03-14 18:33:59 +0000 UTC,
OwnerIdentifier: {
Address: "0x12345d31750D727E6A3a7B534255BADd********"
},
TokenIdentifier: {
Network: "ETHEREUM_MAINNET",
TokenId: "eth"
}
}
```
## Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Node.js
Per eseguire questi esempi di nodi, si applicano i seguenti prerequisiti:
1. È necessario che il node version manager (nvm) e Node.js siano installati sul computer. [Puoi trovare le istruzioni di installazione per il tuo sistema operativo qui.](https://github.com/nvm-sh/nvm)
1. Usa il `node --version` comando e conferma che stai usando la *versione 14 o successiva di Node*. Se necessario, è possibile utilizzare il `nvm install 14` comando, seguito dal `nvm use 14` comando per installare la *versione 14*.
1. Le variabili `AWS_ACCESS_KEY_ID` di ambiente `AWS_SECRET_ACCESS_KEY` devono contenere le credenziali associate all'account.
Esporta queste variabili come stringhe sul tuo client utilizzando i seguenti comandi. Sostituisci i valori evidenziati di seguito con i valori appropriati dell'account utente IAM.
```
export AWS_ACCESS_KEY_ID="{{AKIAIOSFODNN7EXAMPLE}}"
export AWS_SECRET_ACCESS_KEY="{{wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY}}"
```
**Nota**
Dopo aver completato tutti i prerequisiti, puoi inviare richieste firmate tramite HTTPS per accedere alle operazioni dell'API Amazon Managed Blockchain (AMB) Query ed effettuare richieste utilizzando il [modulo https nativo in Node.js](https://nodejs.org/api/https.html), oppure puoi utilizzare una libreria di terze parti come [AXIOS](https://www.npmjs.com/package/axios) e recuperare dati da AMB Query.
Questi esempi utilizzano un client HTTP di terze parti per Node.js, ma puoi anche utilizzare l' AWS JavaScript SDK per effettuare richieste a AMB Query.
L'esempio seguente mostra come effettuare richieste API AMB Query utilizzando Axios e i moduli AWS SDK per SigV4.
Copiate il seguente `package.json` file nella directory di lavoro del vostro ambiente locale:
```
{
"name": "{{amb-query-examples}}",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"@aws-crypto/sha256-js": "^4.0.0",
"@aws-sdk/credential-provider-node": "^3.360.0",
"@aws-sdk/protocol-http": "^3.357.0",
"@aws-sdk/signature-v4": "^3.357.0",
"axios": "^1.4.0"
}
}
```
**Example — Recupera il saldo storico dei token da uno specifico indirizzo di proprietà esterna (EOA) utilizzando l'API AMB Query `GetTokenBalance`**
Puoi utilizzare l'`GetTokenBalance`API per ottenere il saldo di vari token (ad esempio, e ERC1155) e monete native (ad esempio ERC20 ERC721, ETH e BTC), che puoi utilizzare per ottenere il saldo corrente di un account di proprietà esterna (EOA) in base a uno storico `timestamp` (timestamp Unix: secondi). In questo esempio, si utilizza l'[https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/GetTokenBalance.html](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/GetTokenBalance.html)API per ottenere il saldo degli indirizzi di un ERC20 token, USDC, sulla rete principale di Ethereum.
Per testare l'`GetTokenBalance`API, copia il codice seguente in un file denominato `token-balance.js` e salva il file nella stessa directory di lavoro:
```
const axios = require('axios').default;
const SHA256 = require('@aws-crypto/sha256-js').Sha256
const defaultProvider = require('@aws-sdk/credential-provider-node').defaultProvider
const HttpRequest = require('@aws-sdk/protocol-http').HttpRequest
const SignatureV4 = require('@aws-sdk/signature-v4').SignatureV4
// define a signer object with AWS service name, credentials, and region
const signer = new SignatureV4({
credentials: defaultProvider(),
service: 'managedblockchain-query',
region: '{{us-east-1}}',
sha256: SHA256,
});
const queryRequest = async (path, data) => {
//query endpoint
let queryEndpoint = `https://managedblockchain-query.{{us-east-1}}.amazonaws.com/${path}`;
// parse the URL into its component parts (e.g. host, path)
const url = new URL(queryEndpoint);
// create an HTTP Request object
const req = new HttpRequest({
hostname: url.hostname.toString(),
path: url.pathname.toString(),
body: JSON.stringify(data),
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Accept-Encoding': 'gzip',
host: url.hostname,
}
});
// use AWS SignatureV4 utility to sign the request, extract headers and body
const signedRequest = await signer.sign(req, { signingDate: new Date() });
try {
//make the request using axios
const response = await axios({...signedRequest, url: queryEndpoint, data: data})
console.log(response.data)
} catch (error) {
console.error('Something went wrong: ', error)
throw error
}
}
let methodArg = 'get-token-balance';
let dataArg = {
" atBlockchainInstant": {
"time": {{1688071493}}
},
"ownerIdentifier": {
"address": "{{0xf3B0073E3a7F747C7A38B36B805247B2********}}" // externally owned address
},
"tokenIdentifier": {
"contractAddress":"{{0xA0b86991c6218b36c1d19D4a2e9Eb0cE********}}", //USDC contract address
"network":"ETHEREUM_MAINNET"
}
}
//Run the query request.
queryRequest(methodArg, dataArg);
```
Per eseguire il codice, aprite un terminale nella stessa directory dei file ed eseguite il seguente comando:
```
npm i
node token-balance.js
```
Questo comando esegue lo script, passando gli argomenti definiti nel codice per richiedere il saldo ERC20 USDC dell'EOA elencato sulla rete principale di Ethereum. La risposta è simile a quella riportata di seguito.
```
{
atBlockchainInstant: { time: 1688076218 },
balance: '140386693440144',
lastUpdatedTime: { time: 1688074727 },
ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
tokenIdentifier: {
contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
network: 'ETHEREUM_MAINNET'
}
```
## Effettua richieste API Amazon Managed Blockchain (AMB) Query utilizzando Python
Per eseguire questi esempi in Python, si applicano i seguenti prerequisiti:
1. Devi avere Python installato sulla tua macchina. Puoi trovare le istruzioni di installazione per il tuo sistema operativo [qui](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Installa l'[SDK AWS per Python (](https://aws.amazon.com/sdk-for-python/)Boto3).
1. Installa l'[interfaccia a riga di AWS comando](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) ed esegui il comando `aws configure` per impostare le variabili per, e. `Access Key ID` `Secret Access Key` `Region`
Dopo aver completato tutti i prerequisiti, puoi utilizzare l' AWS SDK per Python su HTTPS per effettuare richieste API Amazon Managed Blockchain (AMB) Query.
Il seguente esempio di Python utilizza i moduli di boto3 per inviare richieste apposte con le intestazioni SigV4 richieste all'operazione AMB Query API. `ListTransactionEvents` Questo esempio recupera un elenco di eventi emessi da una determinata transazione sulla rete principale di Ethereum.
Copia il seguente `list-transaction-events.py` file nella directory di lavoro del tuo ambiente locale:
```
import json
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.session import Session
from botocore.httpsession import URLLib3Session
def signed_request(url, method, params, service, region):
session = Session()
sigv4 = SigV4Auth(session.get_credentials(), service, region)
data = json.dumps(params)
request = AWSRequest(method, url, data=data)
sigv4.add_auth(request)
http_session = URLLib3Session()
response = http_session.send(request.prepare())
return(response)
url = 'https://managedblockchain-query.{{us-east-1}}.amazonaws.com/{{list-transaction-events}}'
method = 'POST'
params = {
'network': 'ETHEREUM_MAINNET',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c5222984f905'
}
service = 'managedblockchain-query'
region = '{{us-east-1}}'
# Call the listTransactionEvents operation. This operation will return transaction details for
# all transactions that are confirmed on the blockchain, even if they have not reached
# finality.
listTransactionEvents = signed_request(url, method, params, service, region)
print(json.loads({{listTransactionEvents}}.content.decode('utf-8')))
```
Per eseguire il codice di esempio su`ListTransactionEvents`, salvate il file nella directory di lavoro, quindi eseguite il comando`python3 list-transaction-events.py`. Questo comando esegue lo script, passando gli argomenti definiti nel codice per richiedere gli eventi associati all'hash della transazione specificato sulla rete principale di Ethereum. La risposta è simile a quella riportata di seguito.
```
{
'events':
[
{
'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
'eventType': 'ERC20_TRANSFER',
'from': '0xab5801a7d398351b8be11c439e05c5b3********',
'network': 'ETHEREUM_MAINNET',
'to': '0xdead0000000000000000420694206942********',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
'value': '410241996771871894771826174755464'
}
]
}
```
## Usa Amazon Managed Blockchain (AMB) Query su Console di gestione AWS per eseguire l'operazione GetTokenBalance
L'esempio seguente mostra come ottenere il saldo di un token sulla *rete principale di Ethereum* utilizzando Amazon Managed Blockchain (AMB) Query su Console di gestione AWS
**Example**
1. Apri la console Amazon Managed Blockchain all'indirizzo [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/).
1. Scegli **Query editor** dalla sezione **Query**.
1. **Scegli **ETHEREUM\_MAINNET** come rete Blockchain.**
1. **Scegli **GetTokenBalance**come tipo di query.**
1. Inserisci il tuo **indirizzo Blockchain** per il token.
1. Inserisci l'**indirizzo del contratto** per il token.
1. Inserisci l'**ID token** opzionale per il token.
1. Scegli la **data di scadenza** per il saldo del token.
1. Inserisci l'opzione **At time** per il saldo del token.
1. Scegli **Esegui query**.
AMB Query eseguirà la tua interrogazione e vedrai i risultati nella finestra dei **risultati della query**.