기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# Amazon Managed Blockchain(AMB) 쿼리 시작하기
<a name="getting-started"></a>

이 섹션의 step-by-step 자습서를 사용하여 Amazon Managed Blockchain(AMB) 쿼리를 사용하여 작업을 수행하는 방법을 알아봅니다. 이러한 절차에는 몇 가지 사전 조건이 필요합니다. AMB 쿼리를 처음 사용하는 경우이 가이드의 *설정* 섹션을 검토할 수 있습니다. 자세한 내용은 [Amazon Managed Blockchain(AMB) 쿼리 설정](ambq-setting-up.md) 단원을 참조하십시오.

**참고**  
이 예제의 일부 변수는 의도적으로 난독화되었습니다. 이 예제를 실행하기 전에 해당 예제를 유효한 것으로 바꿉니다.

**Topics**
+ [AMB 쿼리 API 작업에 액세스하기 위한 IAM 정책 생성](#getting-started-iam-policy)
+ [Go를 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성](#getting-started-go-example)
+ [Node.js를 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성](#node-amb-query-requests)
+ [Python을 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성](#python-amb-query-requests)
+ [에서 Amazon Managed Blockchain(AMB) 쿼리 AWS Management Console 를 사용하여 GetTokenBalance 작업 실행](#query-console-gettokenbalance-example)

## AMB 쿼리 API 작업에 액세스하기 위한 IAM 정책 생성
<a name="getting-started-iam-policy"></a>

AMB 쿼리 API 요청을 하려면 Amazon Managed Blockchain(AMB) 쿼리에 대한 적절한 IAM 권한이 있는 사용자 자격 증명(AWS\_ACCESS\_KEY\_ID 및 AWS\_SECRET\_ACCESS\_KEY)을 사용해야 합니다. 이 AWS CLI 설치된 터미널에서 다음 명령을 실행하여 AMB 쿼리 API 작업에 액세스하는 IAM 정책을 생성합니다.

```
cat <<EOT > ~/{{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}}
```

정책을 생성한 후 해당 정책을 IAM 사용자의 역할에 연결하면 정책이 적용됩니다. 에서 IAM 서비스로 AWS Management Console이동하여 서비스를 사용할 IAM 사용자에게 할당된 `AmazonManagedBlockchainQueryAccess` 역할에 정책을 연결합니다. 자세한 내용은 [ 역할 생성 및 IAM 사용자에게 할당을 참조하세요](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).

**참고**  
AWS 에서는 와일드카드를 사용하는 대신 특정 API 작업에 대한 액세스 권한을 부여할 것을 권장합니다`*`. 자세한 내용은 [특정 Amazon Managed Blockchain(AMB) 쿼리 API 작업에 액세스](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis) 단원을 참조하십시오.

## Go를 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성
<a name="getting-started-go-example"></a>

Amazon Managed Blockchain(AMB) 쿼리를 사용하면 블록체인에서 확정된 블록체인 데이터에 대한 즉각적인 액세스에 의존하는 애플리케이션을 빌드할 수 있습니다. 이는 *아직 완료*되지 않은 경우에도 마찬가지입니다. AMB 쿼리를 사용하면 Wallet의 트랜잭션 기록을 채우거나, 트랜잭션 해시를 기반으로 트랜잭션에 대한 컨텍스트 정보를 제공하거나, 네이티브 토큰과 ERC-721, ERC-1155 및 ERC-20 토큰의 균형을 확보하는 등 여러 사용 사례를 사용할 수 있습니다.

다음 예제는 Go 언어로 생성되며 AMB 쿼리 API 작업을 사용합니다. Go에 대한 자세한 내용은 [Go 설명서를](https://go.dev/doc/) 참조하세요. AMB 쿼리 API에 대한 자세한 내용은 [Amazon Managed Blockchain(AMB) 쿼리 API 참조 설명서를](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html) 참조하세요.

다음 예제에서는 `ListTransactions` 및 `GetTransaction` API 작업을 사용하여 먼저 Ethereum Mainnet의 지정된 외부 소유 주소(EOA)에 대한 모든 트랜잭션 목록을 가져온 다음, 다음 예제에서는 목록에서 단일 트랜잭션에 대한 트랜잭션 세부 정보를 검색합니다.

**Example - Go를 사용하여 `ListTransactions` API 작업 수행**  
다음 코드를 *ListTransactions* 디렉터리`listTransactions.go`의 파일에 복사합니다.  

```
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)
    }
}
```

파일을 저장한 후 *ListTransactions* 디렉터리 내에서 다음 명령을 사용하여 코드를 실행합니다`go run listTransactions.go`.

다음 출력은 다음과 유사합니다.

```
{
  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 - Go를 사용하여 `GetTransaction` API 작업 수행**  
이 예제에서는 이전 출력의 트랜잭션 해시를 사용합니다. 다음 코드를 *GetTransaction* 디렉터리`GetTransaction.go`의 파일에 복사합니다.  

```
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)
    }
}
```
파일을 저장한 후 *GetTransaction* 디렉터리 내에서 다음 명령을 사용하여 코드를 실행합니다`go run GetTransaction.go`.  
다음 출력은 다음과 유사합니다.  

```
{
  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는 특정 시점에 외부 소유 계정(EOA)의 현재 밸런스를 가져오는 데 사용할 수 있는 네이티브 토큰(ETH 및 BTC)의 밸런스를 얻을 수 있는 방법을 제공합니다.

**Example - `GetTokenBalance` API 작업을 사용하여 Go에서 네이티브 토큰의 밸런스 가져오기**  
다음 예제에서는 `GetTokenBalance` API를 사용하여 Ethereum Mainnet에서 주소 Ether(ETH) 밸런스를 가져옵니다. 다음 코드를 *GetTokenBalance* 디렉터리`GetTokenBalanceEth.go`의 파일에 복사합니다.  

```
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)
    }
}
```
파일을 저장한 후 *GetTokenBalance* 디렉터리 내에서 다음 명령을 사용하여 코드를 실행합니다`go run GetTokenBalanceEth.go`.  
다음 출력은 다음과 유사합니다.  

```
{
  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"
  }
}
```

## Node.js를 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성
<a name="node-amb-query-requests"></a>

이러한 노드 예제를 실행하려면 다음 사전 조건이 적용됩니다.

1. 시스템에 노드 버전 관리자(nvm) 및 Node.js가 설치되어 있어야 합니다. OS에 대한 설치 지침은 [여기에서](https://github.com/nvm-sh/nvm) 확인할 수 있습니다.

1. `node --version` 명령을 사용하여 *노드 버전 14* 이상을 사용하고 있는지 확인합니다. 필요한 경우 `nvm install 14` 명령을 사용한 다음 `nvm use 14` 명령을 사용하여 *버전 14*를 설치할 수 있습니다.

1. 환경 변수 `AWS_ACCESS_KEY_ID` 및 에는 계정과 연결된 자격 증명이 포함되어야 `AWS_SECRET_ACCESS_KEY` 합니다.

   다음 명령을 사용하여 이러한 변수를 클라이언트에서 문자열로 내보냅니다. 다음에서 강조 표시된 값을 IAM 사용자 계정의 적절한 값으로 바꿉니다.

   ```
   export AWS_ACCESS_KEY_ID="{{AKIAIOSFODNN7EXAMPLE}}"
   export AWS_SECRET_ACCESS_KEY="{{wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY}}"
   ```

**참고**  
모든 사전 조건을 완료한 후 HTTPS를 통해 서명된 요청을 제출하여 Amazon Managed Blockchain(AMB) 쿼리 API 작업에 액세스하고 [ Node.js의 기본 https 모듈을](https://nodejs.org/api/https.html) 사용하여 요청하거나 [AXIOS](https://www.npmjs.com/package/axios)와 같은 타사 라이브러리를 사용하여 AMB 쿼리에서 데이터를 검색할 수 있습니다.
이 예제에서는 Node.js용 타사 HTTP 클라이언트를 사용하지만 AWS JavaScript SDK를 사용하여 AMB 쿼리를 요청할 수도 있습니다.
다음 예제에서는 Axios 및 AWS SigV4용 SDK 모듈을 사용하여 AMB 쿼리 API 요청을 수행하는 방법을 보여줍니다.

다음 `package.json` 파일을 로컬 환경의 작업 디렉터리에 복사합니다.

```
{
  "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 - AMB 쿼리 `GetTokenBalance` API를 사용하여 특정 외부 소유 주소(EOA)에서 과거 토큰 밸런스를 검색합니다.**  
`GetTokenBalance` API를 사용하여 다양한 토큰(예: ERC20, ERC721 및 ERC1155)과 네이티브 코인(예: ETH 및 BTC)의 밸런스를 가져올 수 있습니다. 이를 사용하여 기록`timestamp`(Unix 타임스탬프 - 초)을 기반으로 외부 소유 계정(EOA)의 현재 밸런스를 가져올 수 있습니다. 이 예제에서는 [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를 사용하여 Ethereum Mainnet에서 ERC20 토큰 USDC의 주소 밸런스를 가져옵니다.  
`GetTokenBalance` API를 테스트하려면 다음 코드를 라는 파일에 복사`token-balance.js`하고 파일을 동일한 작업 디렉터리에 저장합니다.  

```
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);
```
코드를 실행하려면 파일과 동일한 디렉터리에서 터미널을 열고 다음 명령을 실행합니다.  

```
npm i
node token-balance.js
```
 이 명령은 스크립트를 실행하여 코드에 정의된 인수를 전달하여 Ethereum Mainnet에 나열된 EOA의 ERC20 USDC 밸런스를 요청합니다. 응답은 다음과 유사합니다.  

```
 {
  atBlockchainInstant: { time: 1688076218 },
  balance: '140386693440144',
  lastUpdatedTime: { time: 1688074727 },
  ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
  tokenIdentifier: {
    contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
    network: 'ETHEREUM_MAINNET'
  }
```

## Python을 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청 생성
<a name="python-amb-query-requests"></a>

이러한 Python 예제를 실행하려면 다음 사전 조건이 적용됩니다.

1. 시스템에 Python이 설치되어 있어야 합니다. OS에 대한 설치 지침은 [여기에서](https://wiki.python.org/moin/BeginnersGuide/Download) 확인할 수 있습니다.

1. [Python용 AWS SDK(Boto3)를 ](https://aws.amazon.com/sdk-for-python/)설치합니다.

1. [AWS 명령줄 인터페이스를](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 설치하고 명령을 실행`aws configure`하여 `Access Key ID`, `Secret Access Key`및에 대한 변수를 설정합니다`Region`.

모든 사전 조건을 완료한 후 HTTPS를 AWS 통한 Python용 SDK를 사용하여 Amazon Managed Blockchain(AMB) 쿼리 API 요청을 할 수 있습니다.

다음 Python 예제에서는 boto3의 모듈을 사용하여 필요한 SigV4 헤더가 첨부된 요청을 AMB 쿼리 `ListTransactionEvents` API 작업으로 보냅니다. 이 예제에서는 Ethereum Mainnet의 지정된 트랜잭션에서 내보낸 이벤트 목록을 검색합니다.

다음 `list-transaction-events.py` 파일을 로컬 환경의 작업 디렉터리에 복사합니다.

```
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')))
```

샘플 코드를에 실행하려면 작업 디렉터리에 파일을 `ListTransactionEvents`저장한 다음 명령을 실행합니다`python3 list-transaction-events.py`. 이 명령은 스크립트를 실행하여 코드에 정의된 인수를 전달하여 Ethereum Mainnet에서 지정된 트랜잭션 해시와 연결된 이벤트를 요청합니다. 응답은 다음과 유사합니다.

```
{
 'events': 
 [
  {
      'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
      'eventType': 'ERC20_TRANSFER',
      'from': '0xab5801a7d398351b8be11c439e05c5b3********',
      'network': 'ETHEREUM_MAINNET',
      'to': '0xdead0000000000000000420694206942********',
      'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
      'value': '410241996771871894771826174755464'
  }
 ]
}
```

## 에서 Amazon Managed Blockchain(AMB) 쿼리 AWS Management Console 를 사용하여 GetTokenBalance 작업 실행
<a name="query-console-gettokenbalance-example"></a>

다음 예제는에서 Amazon Managed Blockchain(AMB) 쿼리를 사용하여 *Ethereum Mainnet*에서 토큰의 밸런스를 가져오는 방법을 보여줍니다. AWS Management Console

**Example**  

1. [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/) Amazon Managed Blockchain 콘솔을 엽니다.

1. **쿼리 섹션에서 쿼리 편집기**를 선택합니다. ** ** 

1. **ETHEREUM\_MAINNET**을 **블록체인 네트워크**로 선택합니다.

1. **쿼리 유형**으로 **GetTokenBalance**를 선택합니다.

1. 토큰의 **블록체인 주소를** 입력합니다.

1. 토큰의 **계약 주소를** 입력합니다.

1. 토큰의 선택적 **토큰 ID**를 입력합니다.

1. 토큰 밸런스의 **날짜**를 선택합니다.

1. 토큰 밸런스에 대한 선택적 **시**를 입력합니다.

1. **쿼리 실행**을 선택합니다.
AMB 쿼리는 쿼리를 실행하며 쿼리 결과 창에 **결과가** 표시됩니다.