Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai Kueri Amazon Managed Blockchain (AMB)
Gunakan step-by-step tutorial di bagian ini untuk mempelajari cara melakukan tugas dengan menggunakan Kueri Amazon Managed Blockchain (AMB). Prosedur ini membutuhkan beberapa prasyarat. Jika Anda baru mengenal AMB Query, Anda dapat meninjau bagian *Pengaturan* dari panduan ini. Untuk informasi selengkapnya, lihat [Menyiapkan Kueri Amazon Managed Blockchain (AMB)](ambq-setting-up.md).
**catatan**
Beberapa variabel dalam contoh-contoh ini sengaja dikaburkan. Ganti dengan yang valid dari Anda sendiri sebelum menjalankan contoh-contoh ini.
**Topics**
+ [Membuat kebijakan IAM untuk mengakses operasi AMB Query API](#getting-started-iam-policy)
+ [Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Go](#getting-started-go-example)
+ [Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Node.js](#node-amb-query-requests)
+ [Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Python](#python-amb-query-requests)
+ [Gunakan Kueri Amazon Managed Blockchain (AMB) Konsol Manajemen AWS untuk menjalankan operasi GetTokenBalance](#query-console-gettokenbalance-example)
## Membuat kebijakan IAM untuk mengakses operasi AMB Query API
Untuk membuat permintaan AMB Query API, Anda harus menggunakan kredensi pengguna (AWS\$1ACCESS\$1KEY\$1ID dan AWS\$1SECRET \$1ACCESS\$1KEY) yang memiliki izin IAM yang sesuai untuk Kueri Amazon Managed Blockchain (AMB). Di terminal dengan AWS CLI instalasi, jalankan perintah berikut untuk membuat kebijakan IAM untuk mengakses operasi AMB Query API:
```
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
```
Setelah Anda membuat kebijakan, lampirkan kebijakan tersebut ke Peran pengguna IAM agar kebijakan tersebut diterapkan. Di bagian Konsol Manajemen AWS, navigasikan ke layanan IAM, dan lampirkan kebijakan `AmazonManagedBlockchainQueryAccess` ke Peran yang ditetapkan ke pengguna IAM yang akan menggunakan layanan. Untuk informasi selengkapnya, lihat [Membuat Peran dan menetapkan ke pengguna IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
**catatan**
AWS merekomendasikan agar Anda memberikan akses ke operasi API tertentu daripada menggunakan wild-card`*`. Untuk informasi selengkapnya, lihat [Mengakses tindakan API Kueri Amazon Managed Blockchain (AMB) tertentu](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis).
## Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Go
Dengan Amazon Managed Blockchain (AMB) Query, Anda dapat membangun aplikasi yang bergantung pada akses instan ke data blockchain setelah dikonfirmasi di blockchain, bahkan jika belum mencapai *finalitas*. AMB Query memungkinkan beberapa kasus penggunaan seperti mengisi riwayat transaksi dompet, memberikan informasi kontekstual tentang transaksi berdasarkan hash transaksinya, atau mendapatkan saldo token asli serta token ERC-721, ERC-1155, dan ERC-20.
Contoh berikut dibuat dalam bahasa Go dan menggunakan operasi AMB Query API. Untuk informasi selengkapnya tentang Go, lihat [Dokumentasi Go](https://go.dev/doc/). Untuk informasi selengkapnya tentang AMB Query API, lihat Dokumentasi [Referensi API Kueri Amazon Managed Blockchain (AMB)](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html).
Contoh berikut menggunakan `ListTransactions` dan tindakan `GetTransaction` API untuk terlebih dahulu mendapatkan daftar semua transaksi untuk alamat yang dimiliki eksternal (EOA) tertentu di Ethereum Mainnet, dan kemudian contoh berikutnya mengambil detail transaksi untuk satu transaksi dari daftar.
**Example — Buat tindakan `ListTransactions` API menggunakan Go**
Salin kode berikut ke file bernama `listTransactions.go` dalam *ListTransactions*direktori.
```
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)
}
}
```
Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam *ListTransactions*direktori:`go run listTransactions.go`.
Output yang berikut menyerupai berikut ini:
```
{
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 — Buat tindakan `GetTransaction` API dengan menggunakan Go**
Contoh ini menggunakan hash transaksi dari output sebelumnya. Salin kode berikut ke file bernama `GetTransaction.go` dalam *GetTransaction*direktori.
```
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)
}
}
```
Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam *GetTransaction*direktori:`go run GetTransaction.go`.
Output yang berikut menyerupai berikut ini:
```
{
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
}
}
```
`GetTokenBalance`API menyediakan cara bagi Anda untuk mendapatkan saldo token asli (ETH dan BTC), yang dapat digunakan untuk mendapatkan saldo saat ini dari akun yang dimiliki secara eksternal (EOA) pada suatu titik waktu.
**Example — Gunakan tindakan `GetTokenBalance` API untuk mendapatkan saldo token asli di Go**
Dalam contoh berikut, Anda menggunakan `GetTokenBalance` API untuk mendapatkan saldo alamat Ether (ETH) di Ethereum Mainnet. Salin kode berikut ke file bernama `GetTokenBalanceEth.go` dalam *GetTokenBalance*direktori.
```
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)
}
}
```
Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam *GetTokenBalance*direktori:`go run GetTokenBalanceEth.go`.
Output yang berikut menyerupai berikut ini:
```
{
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"
}
}
```
## Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Node.js
Untuk menjalankan contoh Node ini, prasyarat berikut berlaku:
1. Anda harus memiliki node version manager (nvm) dan Node.js diinstal pada mesin Anda. Anda dapat menemukan instruksi instalasi untuk OS Anda [di sini](https://github.com/nvm-sh/nvm).
1. Gunakan `node --version` perintah dan konfirmasikan bahwa Anda menggunakan *Node versi 14* atau lebih tinggi. Jika diperlukan, Anda dapat menggunakan `nvm install 14` perintah, diikuti oleh `nvm use 14` perintah untuk menginstal *versi 14*.
1. Variabel lingkungan `AWS_ACCESS_KEY_ID` dan `AWS_SECRET_ACCESS_KEY` harus berisi kredensil yang terkait dengan akun.
Ekspor variabel ini sebagai string pada klien Anda dengan menggunakan perintah berikut. Ganti nilai yang disorot berikut ini dengan nilai yang sesuai dari akun pengguna IAM.
```
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
**catatan**
Setelah menyelesaikan semua prasyarat, Anda dapat mengirimkan permintaan yang ditandatangani melalui HTTPS untuk mengakses operasi API Kueri Amazon Managed Blockchain (AMB) dan membuat permintaan dengan menggunakan [modul https asli di Node.js](https://nodejs.org/api/https.html), atau Anda dapat menggunakan pustaka pihak ketiga seperti [AXIOS](https://www.npmjs.com/package/axios) dan mengambil data dari AMB Query.
Contoh ini menggunakan klien HTTP pihak ketiga untuk Node.js, tetapi Anda juga dapat menggunakan AWS JavaScript SDK untuk membuat permintaan ke AMB Query.
Contoh berikut menunjukkan cara membuat permintaan AMB Query API dengan menggunakan Axios dan modul AWS SDK untuk SiGv4.
Salin `package.json` file berikut ke direktori kerja lingkungan lokal Anda:
```
{
"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 — Ambil saldo token historis dari alamat yang dimiliki eksternal (EOA) tertentu dengan menggunakan AMB Query API `GetTokenBalance`**
Anda dapat menggunakan `GetTokenBalance` API untuk mendapatkan saldo berbagai token (misalnya,, ERC20, dan ERC1155) dan koin asli (misalnya ERC721, ETH dan BTC), yang dapat Anda gunakan untuk mendapatkan saldo saat ini dari akun yang dimiliki secara eksternal (EOA) berdasarkan historis `timestamp` (stempel waktu Unix - detik). Dalam contoh ini, Anda menggunakan [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 untuk mendapatkan saldo alamat ERC20 token, USDC, di Ethereum Mainnet.
Untuk menguji `GetTokenBalance` API, salin kode berikut ke dalam file bernama`token-balance.js`, dan simpan file ke direktori kerja yang sama:
```
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);
```
Untuk menjalankan kode, buka terminal di direktori yang sama dengan file Anda dan jalankan perintah berikut:
```
npm i
node token-balance.js
```
Perintah ini menjalankan skrip, meneruskan argumen yang ditentukan dalam kode untuk meminta saldo ERC20 USDC dari EOA yang terdaftar di Ethereum Mainnet. Responsnya terlihat seperti berikut:
```
{
atBlockchainInstant: { time: 1688076218 },
balance: '140386693440144',
lastUpdatedTime: { time: 1688074727 },
ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
tokenIdentifier: {
contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
network: 'ETHEREUM_MAINNET'
}
```
## Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Python
Untuk menjalankan contoh Python ini, prasyarat berikut berlaku:
1. Anda harus menginstal Python di mesin Anda. Anda dapat menemukan instruksi instalasi untuk OS Anda [di sini](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Instal [AWS SDK untuk Python (Boto3)](https://aws.amazon.com/sdk-for-python/).
1. Instal [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dan jalankan perintah `aws configure` untuk mengatur variabel untuk Anda`Access Key ID`,`Secret Access Key`, dan`Region`.
Setelah menyelesaikan semua prasyarat, Anda dapat menggunakan SDK AWS untuk Python melalui HTTPS untuk membuat permintaan API Kueri Amazon Managed Blockchain (AMB).
Contoh Python berikut menggunakan modul dari boto3 untuk mengirim permintaan yang ditempelkan dengan header SigV4 yang diperlukan ke operasi AMB Query API. `ListTransactionEvents` Contoh ini mengambil daftar peristiwa yang dipancarkan oleh transaksi tertentu di Ethereum Mainnet.
Salin `list-transaction-events.py` file berikut ke direktori kerja lingkungan lokal Anda:
```
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')))
```
Untuk menjalankan kode sampel ke`ListTransactionEvents`, simpan file di direktori kerja Anda dan kemudian jalankan perintah`python3 list-transaction-events.py`. Perintah ini menjalankan skrip, meneruskan argumen yang ditentukan dalam kode untuk meminta peristiwa yang terkait dengan hash transaksi yang diberikan di Ethereum Mainnet. Responsnya terlihat seperti berikut:
```
{
'events':
[
{
'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
'eventType': 'ERC20_TRANSFER',
'from': '0xab5801a7d398351b8be11c439e05c5b3********',
'network': 'ETHEREUM_MAINNET',
'to': '0xdead0000000000000000420694206942********',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
'value': '410241996771871894771826174755464'
}
]
}
```
## Gunakan Kueri Amazon Managed Blockchain (AMB) Konsol Manajemen AWS untuk menjalankan operasi GetTokenBalance
Contoh berikut menunjukkan cara mendapatkan saldo token di *Ethereum Mainnet* menggunakan Amazon Managed Blockchain (AMB) Query di Konsol Manajemen AWS
**Example**
1. Buka konsol Amazon Managed Blockchain di [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/).
1. Pilih **Editor kueri** dari bagian **Kueri**.
1. **Pilih **ETHEREUM\$1MAINNET** sebagai jaringan Blockchain.**
1. Pilih **GetTokenBalance**sebagai **tipe Query**.
1. Masukkan **alamat Blockchain** Anda untuk token.
1. Masukkan **alamat Kontrak** untuk token.
1. Masukkan **ID Token** opsional untuk token.
1. Pilih **Tanggal Pada** untuk saldo token.
1. Masukkan opsional **Pada waktu** untuk saldo token.
1. Pilih **Run query** (Jalankan kueri).
AMB Query akan menjalankan query Anda dan Anda akan melihat hasilnya di jendela **hasil Query**.