Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Commencer à utiliser Amazon Managed Blockchain (AMB) Query
Utilisez les step-by-step didacticiels de cette section pour apprendre à effectuer des tâches à l'aide d'Amazon Managed Blockchain (AMB) Query. Ces procédures nécessitent certaines conditions préalables. Si vous utilisez AMB Query pour la première fois, vous pouvez consulter la section *Configuration* de ce guide. Pour de plus amples informations, veuillez consulter [Configuration de la requête Amazon Managed Blockchain (AMB)](ambq-setting-up.md).
**Note**
Certaines variables de ces exemples ont été délibérément masquées. Remplacez-les par vos propres modèles valides avant d'exécuter ces exemples.
**Topics**
+ [Créez une politique IAM pour accéder aux opérations de l'API AMB Query](#getting-started-iam-policy)
+ [Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide de Go](#getting-started-go-example)
+ [Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide du fichier Node.js](#node-amb-query-requests)
+ [Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide de Python](#python-amb-query-requests)
+ [Utilisez la requête Amazon Managed Blockchain (AMB) sur le AWS Management Console pour exécuter l'opération GetTokenBalance](#query-console-gettokenbalance-example)
## Créez une politique IAM pour accéder aux opérations de l'API AMB Query
Pour effectuer des demandes à l'API AMB Query, vous devez utiliser les informations d'identification utilisateur (AWS\$1ACCESS\$1KEY\$1ID et AWS\$1SECRET \$1ACCESS\$1KEY) qui disposent des autorisations IAM appropriées pour Amazon Managed Blockchain (AMB) Query. Dans un terminal sur lequel le est AWS CLI installé, exécutez la commande suivante pour créer une politique IAM permettant d'accéder aux opérations de l'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
```
Après avoir créé la stratégie, associez-la au rôle d'un utilisateur IAM pour qu'elle prenne effet. Dans le AWS Management Console, accédez au service IAM et attachez la politique `AmazonManagedBlockchainQueryAccess` au rôle attribué à l'utilisateur IAM qui utilisera le service. Pour plus d'informations, consultez [Création d'un rôle et attribution à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
**Note**
AWS vous recommande de donner accès à des opérations d'API spécifiques plutôt que d'utiliser le joker`*`. Pour de plus amples informations, veuillez consulter [Accès à des actions spécifiques de l'API de requête Amazon Managed Blockchain (AMB)](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis).
## Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide de Go
Avec Amazon Managed Blockchain (AMB) Query, vous pouvez créer des applications qui dépendent d'un accès instantané aux données de la blockchain une fois qu'elles sont confirmées sur la blockchain, même si elles n'ont pas encore atteint leur *finalité*. AMB Query permet plusieurs cas d'utilisation, tels que le remplissage de l'historique des transactions d'un portefeuille, la fourniture d'informations contextuelles sur une transaction en fonction de son hachage de transaction ou l'obtention du solde d'un jeton natif ainsi que de jetons ERC-721, ERC-1155 et ERC-20.
Les exemples suivants sont créés dans le langage Go et utilisent les opérations de l'API AMB Query. Pour plus d'informations sur Go, consultez la [documentation Go](https://go.dev/doc/). Pour plus d'informations sur l'API de requête AMB, consultez la documentation de [référence de l'API de requête Amazon Managed Blockchain (AMB)](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html).
Les exemples suivants utilisent les actions `ListTransactions` et l'`GetTransaction`API pour obtenir d'abord une liste de toutes les transactions pour une adresse externe donnée (EOA) sur le réseau principal Ethereum, puis l'exemple suivant récupère les détails des transactions pour une seule transaction dans la liste.
**Example — Effectue l'action de `ListTransactions` l'API en utilisant Go**
Copiez le code suivant dans un fichier nommé `listTransactions.go` dans le *ListTransactions*répertoire.
```
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)
}
}
```
Après avoir enregistré le fichier, exécutez le code en utilisant la commande suivante dans le *ListTransactions*répertoire :`go run listTransactions.go`.
Le résultat qui suit ressemble à ce qui suit :
```
{
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 — Effectue l'action de l'`GetTransaction`API en utilisant Go**
Cet exemple utilise un hachage de transaction issu de la sortie précédente. Copiez le code suivant dans un fichier nommé `GetTransaction.go` dans le *GetTransaction*répertoire.
```
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)
}
}
```
Après avoir enregistré le fichier, exécutez le code en utilisant la commande suivante dans le *GetTransaction*répertoire :`go run GetTransaction.go`.
Le résultat qui suit ressemble à ce qui suit :
```
{
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 vous permet d'obtenir le solde des jetons natifs (ETH et BTC), qui peuvent être utilisés pour obtenir le solde actuel d'un compte externe (EOA) à un moment donné.
**Example — Utilisez l'action `GetTokenBalance` API pour obtenir le solde d'un jeton natif dans Go**
Dans l'exemple suivant, vous utilisez l'`GetTokenBalance`API pour obtenir un solde d'adresses Ether (ETH) sur le réseau principal Ethereum. Copiez le code suivant dans un fichier nommé `GetTokenBalanceEth.go` dans le *GetTokenBalance*répertoire.
```
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)
}
}
```
Après avoir enregistré le fichier, exécutez le code en utilisant la commande suivante dans le *GetTokenBalance*répertoire :`go run GetTokenBalanceEth.go`.
Le résultat qui suit ressemble à ce qui suit :
```
{
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"
}
}
```
## Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide du fichier Node.js
Pour exécuter ces exemples de nœuds, les conditions préalables suivantes s'appliquent :
1. Le gestionnaire de version de nœud (nvm) et Node.js doivent être installés sur votre machine. Vous trouverez les instructions d'installation pour votre système d'exploitation [ici](https://github.com/nvm-sh/nvm).
1. Utilisez la `node --version` commande et confirmez que vous utilisez la *version 14 ou supérieure de Node*. Si nécessaire, vous pouvez utiliser la `nvm install 14` commande, puis la `nvm use 14` commande pour installer la *version 14*.
1. Les variables `AWS_ACCESS_KEY_ID` d'environnement `AWS_SECRET_ACCESS_KEY` doivent contenir les informations d'identification associées au compte.
Exportez ces variables sous forme de chaînes sur votre client à l'aide des commandes suivantes. Remplacez les valeurs surlignées ci-dessous par les valeurs appropriées du compte utilisateur IAM.
```
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
**Note**
Une fois toutes les conditions requises remplies, vous pouvez envoyer des demandes signées via HTTPS pour accéder aux opérations de l'API de requête Amazon Managed Blockchain (AMB) et effectuer des demandes à l'aide du [module https natif dans Node.js](https://nodejs.org/api/https.html), ou vous pouvez utiliser une bibliothèque tierce telle qu'[AXIOS](https://www.npmjs.com/package/axios) et récupérer des données depuis AMB Query.
Ces exemples utilisent un client HTTP tiers pour Node.js, mais vous pouvez également utiliser le AWS JavaScript SDK pour envoyer des requêtes à AMB Query.
L'exemple suivant vous montre comment effectuer des demandes d'API AMB Query à l'aide d'Axios et des modules AWS SDK pour SigV4.
Copiez le `package.json` fichier suivant dans le répertoire de travail de votre environnement local :
```
{
"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 — Récupérez le solde historique des jetons à partir d'une adresse externe spécifique (EOA) à l'aide de l'API AMB Query `GetTokenBalance`**
Vous pouvez utiliser l'`GetTokenBalance`API pour obtenir le solde de différents jetons (par exemple, ERC20 ERC721, et ERC1155) et de pièces natives (par exemple, ETH et BTC), que vous pouvez utiliser pour obtenir le solde actuel d'un compte externe (EOA) sur la base d'un historique `timestamp` (horodatage Unix - secondes). Dans cet exemple, vous utilisez 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 pour obtenir le solde d'adresses d'un ERC20 jeton, USDC, sur le réseau principal Ethereum.
Pour tester l'`GetTokenBalance`API, copiez le code suivant dans un fichier nommé `token-balance.js` et enregistrez le fichier dans le même répertoire de travail :
```
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);
```
Pour exécuter le code, ouvrez un terminal dans le même répertoire que vos fichiers et exécutez la commande suivante :
```
npm i
node token-balance.js
```
Cette commande exécute le script en transmettant les arguments définis dans le code pour demander le solde ERC20 USDC de l'EOA répertorié sur le réseau principal Ethereum. La réponse est similaire à ce qui suit :
```
{
atBlockchainInstant: { time: 1688076218 },
balance: '140386693440144',
lastUpdatedTime: { time: 1688074727 },
ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
tokenIdentifier: {
contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
network: 'ETHEREUM_MAINNET'
}
```
## Effectuez des demandes d'API de requête Amazon Managed Blockchain (AMB) à l'aide de Python
Pour exécuter ces exemples Python, les conditions préalables suivantes s'appliquent :
1. Python doit être installé sur votre machine. Vous trouverez les instructions d'installation pour votre système d'exploitation [ici](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Installez le [kit SDK AWS pour Python (Boto3).](https://aws.amazon.com/sdk-for-python/)
1. Installez l'[interface de ligne de AWS commande](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) et exécutez la commande `aws configure` pour définir les variables de votre `Access Key ID``Secret Access Key`, et`Region`.
Une fois tous les prérequis remplis, vous pouvez utiliser le AWS SDK pour Python via HTTPS pour effectuer des demandes d'API de requête Amazon Managed Blockchain (AMB).
L'exemple Python suivant utilise des modules de boto3 pour envoyer des requêtes associées aux en-têtes SigV4 requis à l'opération AMB Query API. `ListTransactionEvents` Cet exemple permet de récupérer une liste d'événements émis par une transaction donnée sur le réseau principal Ethereum.
Copiez le `list-transaction-events.py` fichier suivant dans le répertoire de travail de votre environnement local :
```
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')))
```
Pour exécuter l'exemple de code sur`ListTransactionEvents`, enregistrez le fichier dans votre répertoire de travail, puis exécutez la commande`python3 list-transaction-events.py`. Cette commande exécute le script en transmettant les arguments définis dans le code pour demander les événements associés au hachage de transaction donné sur le réseau principal Ethereum. La réponse est similaire à ce qui suit :
```
{
'events':
[
{
'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
'eventType': 'ERC20_TRANSFER',
'from': '0xab5801a7d398351b8be11c439e05c5b3********',
'network': 'ETHEREUM_MAINNET',
'to': '0xdead0000000000000000420694206942********',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
'value': '410241996771871894771826174755464'
}
]
}
```
## Utilisez la requête Amazon Managed Blockchain (AMB) sur le AWS Management Console pour exécuter l'opération GetTokenBalance
L'exemple suivant montre comment obtenir le solde d'un jeton sur le *réseau principal Ethereum* à l'aide de la requête Amazon Managed Blockchain (AMB) sur le AWS Management Console
**Example**
1. Ouvrez la console Amazon Managed Blockchain à l'adresse [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/).
1. Choisissez l'**éditeur de requête** **dans la section Requête**.
1. **Choisissez **ETHEREUM\$1MAINNET** comme réseau Blockchain.**
1. Choisissez **GetTokenBalance**comme **type de requête**.
1. Entrez votre **adresse Blockchain** pour le jeton.
1. Entrez l'**adresse du contrat** pour le jeton.
1. Entrez l'**ID de jeton** facultatif pour le jeton.
1. Choisissez la **date limite** pour le solde du jeton.
1. Entrez l'option **À l'heure** pour le solde du jeton.
1. Choisissez **Exécuter la requête**.
AMB Query exécutera votre requête et vous verrez les résultats dans la fenêtre des résultats de la **requête**.