

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# Amazon SQS での API の使用
<a name="sqs-working-with-apis"></a>

このトピックでは、Amazon SQS エンドポイントの構築、GET メソッドおよび POST メソッドを使用したクエリ API リクエストの作成、およびバッチ API アクションの使用に関する情報を提供します。パラメータ、エラー、例、および[データ型](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Types.html)を含む Amazon SQS [アクション](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html)の詳細については、「[Amazon Simple Queue Service API リファレンス**](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/)」を参照してください。

さまざまなプログラミング言語を使用して Amazon SQS にアクセスするには、以下の自動機能が含まれた [AWS SDK](https://aws.amazon.com/tools/#sdk) を使用することもできます。
+ サービスリクエストに暗号署名する
+ リクエストを再試行する
+ エラーレスポンスの処理をする

詳細については、「[AWS SDK での Amazon SQS の使用](sdk-general-information-section.md)」を参照してください。

コマンドラインツール情報については、「[AWS CLI コマンドリファレンス**](https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html)」の「Amazon SQS セクション」、および「[AWS Tools for PowerShell Cmdlet リファレンス**](https://docs.aws.amazon.com/powershell/latest/reference/)」を参照してください。

**AWS JSON プロトコルを使用した Amazon SQS API**

Amazon SQS は、指定された [AWS SDK バージョン](sqs-json-faqs.md#json-protocol-getting-started)上のすべての Amazon SQS API のトランスポートメカニズムとして AWS JSON プロトコルを使用します。AWSJSON プロトコルは、スループットの向上、レイテンシの低減、アプリケーション間の通信の高速化を実現します。AWSJSON プロトコルは、AWS クエリプロトコルと比較して、要求と応答のシリアル化/逆シリアル化においてより効率的です。それでも SQS API で AWS クエリプロトコルを使用したい場合は、Amazon SQS AWS クエリプロトコルをサポートする AWS SDK バージョンについて、「[Amazon SQS API で使用される AWS JSON プロトコルでは、どの言語がサポートされていますか? APIs](sqs-json-faqs.md#json-protocol-supported-languages)」を参照してください。

Amazon SQS は AWS JSON プロトコルを使用して AWS SDK クライアント (Java、Python、Golang、JavaScript など) と Amazon SQS サーバー間の通信を行います。Amazon SQS API オペレーションの HTTP リクエストは、JSON 形式の入力を受け付けます。Amazon SQS オペレーションが実行され、実行レスポンスが JSON 形式で SDK クライアントに送り返されます。AWS クエリと比較して、AWS JSON はクライアントとサーバー間のデータ転送がより簡単、迅速、効率的です。
+ AWS JSON プロトコルは Amazon SQS クライアントとサーバー間のメディエーターとして機能します。
+ サーバーは Amazon SQS オペレーションが作成されたプログラミング言語を理解しませんが、AWS JSON プロトコルは理解します。
+ AWS JSON プロトコルは、Amazon SQS クライアントとサーバー間のシリアル化 (オブジェクトを JSON 形式に変換) と逆シリアル化 (JSON 形式をオブジェクトに変換) を使用します。

Amazon SQS での AWS JSON プロトコルの詳細は、「[Amazon SQS AWS JSON プロトコルFAQs](sqs-json-faqs.md)」を参照してください。

AWS JSON プロトコルは特定の [AWS SDK バージョン](sqs-json-faqs.md#json-protocol-getting-started)で使用できます。さまざまな言語バージョンの SDK バージョンとリリース日を確認するには、「AWS SDK およびツールリファレンスガイド**」の「[AWS SDK とツールのバージョンサポートマトリックス](https://docs.aws.amazon.com/sdkref/latest/guide/version-support-matrix.html)」を参照してください。

# Amazon SQS での AWS JSON プロトコルを使用したクエリ API リクエストの実行 Amazon SQS
<a name="sqs-making-api-requests-json"></a>

このトピックでは、Amazon SQS エンドポイントを構築する方法、POST リクエストを行う方法、およびレスポンスを解釈する方法について説明します。

**注記**  
AWS JSON プロトコルは、ほとんどの言語バリアントでサポートされています。サポートされている言語のリストについては、「[Amazon SQS API で使用される AWS JSON プロトコルでは、どの言語がサポートされていますか? APIs](sqs-json-faqs.md#json-protocol-supported-languages)」を参照してください。

## エンドポイントの構築
<a name="sqs-api-constructing-endpoints-json"></a>

Amazon SQS キューを使用するには、エンドポイントを構築する必要があります。Amazon SQS エンドポイントの詳細については、「Amazon Web Services 全般のリファレンス**」の以下のページを参照してください。
+ [リージョンエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)
+ [Amazon Simple Queue Serviceエンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Amazon SQS エンドポイントはそれぞれ独立しています。例えば、2 つのキューの名前が MyQueue で、一方にはエンドポイント `sqs.us-east-2.amazonaws.com` があり、もう一方にはエンドポイント `sqs.eu-west-2.amazonaws.com` がある場合、2 つのキューは互いにどのデータも共有しません。**

キュー作成のクエストを行うエンドポイントの例を次に示します。

```
POST / HTTP/1.1
Host: sqs.us-west-2.amazonaws.com
X-Amz-Target: AmazonSQS.CreateQueue
X-Amz-Date: <Date>
Content-Type: application/x-amz-json-1.0
Authorization: <AuthParams>
Content-Length: <PayloadSizeBytes>
Connection: Keep-Alive 
{
    "QueueName":"MyQueue",
    "Attributes": {
        "VisibilityTimeout": "40"
    },
    "tags": {
        "QueueType": "Production"
    }
}
```

**注記**  
キュー名とキュー URL では、大文字と小文字が区別されます。  
*`AUTHPARAMS`* の構造は API リクエストの署名によって異なります。詳細については、*Amazon Web Services 全般のリファレンス*[の AWS API リクエストの署名](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)を参照してください。

## POST リクエストの作成
<a name="structure-post-request"></a>

Amazon SQS の POST リクエストは、クエリパラメータを HTTP リクエストボディの形で送信します。

以下は、`X-Amz-Target` が `AmazonSQS.<operationName>` に設定された HTTP ヘッダーと、`Content-Type` が `application/x-amz-json-1.0` に設定された HTTP ヘッダーの例です。

```
POST / HTTP/1.1
Host: sqs.<region>.<domain>
X-Amz-Target: AmazonSQS.SendMessage
X-Amz-Date: <Date>
Content-Type: application/x-amz-json-1.0
Authorization: <AuthParams>
Content-Length: <PayloadSizeBytes>
Connection: Keep-Alive 
{
    "QueueUrl": "https://sqs.<region>.<domain>/<awsAccountId>/<queueName>/",
    "MessageBody": "This is a test message"
}
```

この HTTP POST リクエストは、Amazon SQS キューにメッセージを送信します。

**注記**  
HTTP ヘッダー `X-Amz-Target` と `Content-Type` は両方とも必須です。  
HTTP クライアントは、クライアントの HTTP バージョンによっては、他の項目を HTTP リクエストに追加する可能性があります。

# Amazon SQS JSON API レスポンスの解釈
<a name="sqs-json-api-responses"></a>

Amazon SQS にリクエストを送信すると、結果を含む JSON レスポンスが返されます。レスポンス構造は、使用した API アクションによって異なります。

これらのレスポンスの詳細については、以下を参照してください。
+ *Amazon Simple Queue Service API リファレンス*の [API アクション](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html)に記載された具体的な API アクション
+ [Amazon SQS AWS JSON プロトコルFAQs](sqs-json-faqs.md)

## 正常な JSON レスポンス構造
<a name="sqs-json-api-successful-response-structure"></a>

リクエストが成功した場合、主なレスポンス要素は `x-amzn-RequestId` です。これには、リクエストの汎用一意識別子 (UUID) と、その他の付加されたレスポンスフィールドが含まれます。例えば、[https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) レスポンスには `QueueUrl` フィールドが含まれています。そのフィールドには、作成されたキューの URL が含まれています。

```
HTTP/1.1 200 OK
x-amzn-RequestId: <requestId>
Content-Length: <PayloadSizeBytes>
Date: <Date>
Content-Type: application/x-amz-json-1.0
{
    "QueueUrl":"https://sqs.us-east-1.amazonaws.com/111122223333/MyQueue"
}
```

## JSON エラーレスポンス構造
<a name="sqs-api-error-response-structure"></a>

リクエストが正常に行われなかった場合、Amazon SQS は HTTP ヘッダーとボディを含む主なレスポンスを返信します。

HTTP ヘッダーで、`x-amzn-RequestId` にはリクエストの UUID が含まれています。`x-amzn-query-error` には、エラーのタイプと、エラーがプロデューサーエラーかコンシューマーエラーかという 2 つの情報が含まれています。

レスポンスボディで、`"__type"` はその他のエラーの詳細を示し、`Message` は読みやすい形式でエラー状況を示します。

以下は、JSON 形式のエラーレスポンスの例です。

```
HTTP/1.1 400 Bad Request
x-amzn-RequestId: 66916324-67ca-54bb-a410-3f567a7a0571
x-amzn-query-error: AWS.SimpleQueueService.NonExistentQueue;Sender
Content-Length: <PayloadSizeBytes>
Date: <Date>
Content-Type: application/x-amz-json-1.0
{
    "__type": "com.amazonaws.sqs#QueueDoesNotExist",
    "message": "The specified queue does not exist."
}
```

# Amazon SQS AWS JSON プロトコルFAQs
<a name="sqs-json-faqs"></a>

このトピックでは、Amazon SQS での AWS JSON プロトコルの使用に関するよくある質問について説明します。

## AWS JSON プロトコルとは何ですか。また、既存の Amazon SQS API リクエストとレスポンスとどのように異なりますか?
<a name="json-protocol-what-is"></a>

JSON は、異種システム間の通信で最も広く使用され、受け入れられている配線方法の 1 つです。Amazon SQS は JSON を通信媒体として使用して、 AWS SDK クライアント (Java、Python、Golang、JavaScript など) と Amazon SQS サーバー間の通信を行います。Amazon SQS API オペレーションの HTTP リクエストは、JSON 形式の入力を受け付けます。Amazon SQS オペレーションが実行され、実行レスポンスが JSON 形式で SDK クライアントに共有されます。 AWS クエリと比較して、JSON はクライアントとサーバー間でより効率的にデータ転送できます。
+ Amazon SQS AWS JSON プロトコルは、Amazon SQS クライアントとサーバー間のメディエーターとして機能します。
+ サーバーは Amazon SQS オペレーションが作成されるプログラミング言語を理解していませんが、JSON AWS プロトコルを理解しています。
+ Amazon SQS AWS JSON プロトコルは、Amazon SQS クライアントとサーバー間のシリアル化 (オブジェクトを JSON 形式に変換) と逆シリアル化 (JSON 形式をオブジェクトに変換) を使用します。

## Amazon SQS の AWS JSON プロトコルの使用を開始するにはどうすればよいですか?
<a name="json-protocol-getting-started"></a>

Amazon SQS のメッセージングを高速化するために最新の AWS SDK バージョンの使用を開始するには、 AWS SDK を指定されたバージョンまたはそれ以降のバージョンにアップグレードします。SDK クライアントの詳細については、以下の表の「ガイド」列を参照してください。

以下は、Amazon SQS API で使用する JSON AWS プロトコルの言語バリアント間の SDK バージョンのリストです。 Amazon SQS APIs


| Language | SDK クライアントリポジトリ | 必要な SDK クライアントバージョン | ガイド | 
| --- | --- | --- | --- | 
|  C\$1\$1  |  [aws/aws-sdk-cpp](https://github.com/aws/aws-sdk-cpp)  |  [1.11.98](https://github.com/aws/aws-sdk-cpp/releases/tag/1.11.198)  |  [AWS SDK for C\$1\$1](https://aws.amazon.com/sdk-for-cpp/)  | 
|  Golang 1.x  |  [aws/aws-sdk-go](https://github.com/aws/aws-sdk-go)  |  [v1.47.7](https://github.com/aws/aws-sdk-go/releases/tag/v1.47.7)  |  [AWS SDK for Go](https://aws.amazon.com/sdk-for-go/)  | 
|  Golang 2.x  |  [aws/aws-sdk-go-v2](https://github.com/aws/aws-sdk-go-v2)  |  [v1.28.0](https://github.com/aws/aws-sdk-go-v2/blob/release-2023-11-09/service/sqs/CHANGELOG.md#v1270-2023-11-09)  |  [AWS SDK for Go V2](https://aws.github.io/aws-sdk-go-v2/docs/)  | 
|  Java 1.x  |  [aws/aws-sdk-java](https://github.com/aws/aws-sdk-java)  |  [1.12.585](https://github.com/aws/aws-sdk-java/releases/tag/1.12.585)  |  [AWS SDK for Java](https://aws.amazon.com/sdk-for-java/)  | 
|  Java 2.x  |  [aws/aws-sdk-java-v2](https://github.com/aws/aws-sdk-java-v2)  |  [2.21.19](https://github.com/aws/aws-sdk-java-v2/releases/tag/2.21.19)  |  [AWS SDK for Java](https://aws.amazon.com/sdk-for-java/)  | 
|  JavaScript v2.x  |  [aws/aws-sdk-js](https://github.com/aws/aws-sdk-js)  |  [での JavaScript AWS](https://aws.amazon.com/developer/language/javascript/)  | 
|  JavaScript v3.x  |  [aws/aws-sdk-js-v3](https://github.com/aws/aws-sdk-js-v3)  |  [v3.447.0](https://github.com/aws/aws-sdk-js-v3/releases/tag/v3.447.0)  |  [での JavaScript AWS](https://aws.amazon.com/developer/language/javascript/)  | 
|  .NET  |  [aws/aws-sdk-net](https://github.com/aws/aws-sdk-net)  |  [3.7.681.0](https://github.com/aws/aws-sdk-net/releases/tag/3.7.681.0)  |  [AWS SDK for .NET](https://aws.amazon.com/sdk-for-net/)  | 
|  PHP  |  [aws/aws-sdk-php](https://github.com/aws/aws-sdk-php)  |  [3.285.2](https://github.com/aws/aws-sdk-php/releases/tag/3.285.2)  |  [AWS SDK for PHP](https://aws.amazon.com/sdk-for-php/)  | 
|  Python-boto3  |   [boto/boto3](https://github.com/boto/boto3)   |  [1.28.82](https://github.com/boto/boto3/releases/tag/1.28.82)  |  [AWS SDK for Python (Boto3)](https://aws.amazon.com/sdk-for-python/)  | 
|  Python-botocore  |   [boto/botocore](https://github.com/boto/botocore/)   |  [1.31.82](https://github.com/boto/botocore/releases/tag/1.31.82)  |  [AWS SDK for Python (Boto3)](https://aws.amazon.com/sdk-for-python/)  | 
|  awscli  |  [AWS CLI](https://github.com/aws/aws-cli)  |  [1.29.82](https://github.com/aws/aws-cli/releases/tag/1.29.82)  |  [AWSコマンドラインインターフェイス](https://aws.amazon.com/cli/)  | 
|  Ruby  |  [aws/aws-sdk-ruby](https://github.com/aws/aws-sdk-ruby)  |  [1.67.0](https://rubygems.org/gems/aws-sdk-sqs/versions/1.67.0)  |  [AWS SDK for Ruby](https://aws.amazon.com/sdk-for-ruby/)  | 

## Amazon SQS ワークロードで JSON プロトコルを有効にすることにはどのようなリスクがありますか。
<a name="json-protocol-risks"></a>

 AWS SDK のカスタム実装、またはカスタムクライアントと AWS SDK の組み合わせを使用して、クエリベースの (XML ベースの) AWS レスポンスを生成する Amazon SQS とやり取りしている場合、JSON AWS プロトコルと互換性がない可能性があります。問題が発生した場合は、 AWS サポートにお問い合わせください。

## すでに最新の AWS SDK バージョンを使用しているが、オープンソースソリューションが JSON をサポートしていない場合はどうなりますか?
<a name="json-protocol-sdk-version-open-source"></a>

SDK のバージョンを、使用中のバージョンより前のバージョンに変更する必要があります。詳細については[Amazon SQS の AWS JSON プロトコルの使用を開始するにはどうすればよいですか?](#json-protocol-getting-started)、「」を参照してください。「」にリストされている AWS SDK バージョン[Amazon SQS の AWS JSON プロトコルの使用を開始するにはどうすればよいですか?](#json-protocol-getting-started)は、Amazon SQS API の JSON ワイヤプロトコルを使用します。 APIs AWS SDK を以前のバージョンに変更すると、Amazon SQS APIsは AWS クエリを使用します。

## Amazon SQS API で使用される AWS JSON プロトコルでは、どの言語がサポートされていますか? APIs
<a name="json-protocol-supported-languages"></a>

Amazon SQS は、 AWS SDKsされているすべての言語バリアント (GA) をサポートしています。現在、Kotlin、Rust、Swift はサポートしていません。他の言語バリアントについて詳しくは、「[AWSでの構築ツール](https://aws.amazon.com/developer/tools/)」を参照してください。

## Amazon SQS APIs で使用される AWS JSON プロトコルでサポートされているリージョン
<a name="json-protocol-supported-regions"></a>

Amazon SQS は AWS 、Amazon SQS が利用可能なすべての[AWS リージョン](https://docs.aws.amazon.com/general/latest/gr/sqs-service.html)で JSON プロトコルをサポートしています。 Amazon SQS 

## AWS JSON プロトコルを使用して Amazon SQS の指定された AWS SDK バージョンにアップグレードすると、どのようなレイテンシーの改善が期待できますか?
<a name="json-protocol-upgrading-sdk"></a>

AWS JSON プロトコルは、 AWS クエリプロトコルと比較して、リクエストとレスポンスのシリアル化と逆シリアル化がより効率的です。5 KB のメッセージペイロード AWS のパフォーマンステストに基づいて、Amazon SQS の JSON プロトコルはend-to-endのメッセージ処理レイテンシーを最大 23% 削減し、アプリケーションクライアント側の CPU とメモリの使用量を削減します。

## AWS クエリプロトコルは廃止されますか?
<a name="query-protocol"></a>

AWS クエリプロトコルは引き続きサポートされます。 AWS SDK バージョンが、「Amazon SQS の JSON プロトコルの開始方法」に記載されているもの以外の以前のバージョンに設定されている限り、 AWS クエリプロトコルを引き続き使用できます。 [AWS Amazon SQS](#json-protocol-getting-started)

## JSON AWS プロトコルの詳細については、どこで確認できますか?
<a name="json-protocol-more-info"></a>

JSON プロトコルの詳細については、*Smithy* ドキュメントの「[AWS JSON 1.0 プロトコル](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html)」を参照してください。 AWS JSON プロトコルを使用する Amazon SQS API リクエストの詳細については、「[Amazon SQS での AWS JSON プロトコルを使用したクエリ API リクエストの実行 Amazon SQS](sqs-making-api-requests-json.md)」を参照してください。

# Amazon SQS でのクエリプロトコルを使用した AWS クエリ API リクエストの実行 Amazon SQS
<a name="sqs-making-api-requests-xml"></a>

このトピックでは、Amazon SQS エンドポイントを構築する方法、GET および POST リクエストを行う方法、およびレスポンスを解釈する方法について説明します。

## エンドポイントの構築
<a name="sqs-api-constructing-endpoints"></a>

Amazon SQSキューを使用するには、エンドポイントを構築する必要があります。Amazon SQS エンドポイントの詳細については、「Amazon Web Services 全般のリファレンス**」の以下のページを参照してください。
+ [リージョンエンドポイント](https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region)
+ [Amazon Simple Queue Serviceエンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Amazon SQS エンドポイントはそれぞれ独立しています。例えば、2 つのキューの名前が MyQueue で、一方にはエンドポイント `sqs.us-east-2.amazonaws.com` があり、もう一方にはエンドポイント `sqs.eu-west-2.amazonaws.com` がある場合、2 つのキューは互いにどのデータも共有しません。**

キューを作成するリクエストを行うエンドポイントの例を次に示します。

```
https://sqs.eu-west-2.amazonaws.com/   
?Action=CreateQueue
&DefaultVisibilityTimeout=40
&QueueName=MyQueue
&Version=2012-11-05
&AUTHPARAMS
```

**注記**  
キュー名とキュー URL では、大文字と小文字が区別されます。  
*`AUTHPARAMS`* の構造は API リクエストの署名によって異なります。詳細については、*Amazon Web Services 全般のリファレンス*[の AWS API リクエストの署名](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)を参照してください。

## GETリクエストの作成
<a name="structure-get-request"></a>

Amazon SQS の GET リクエストは、以下を要素とする URLとして構成します。
+ **エンドポイント**-リクエストが作用するリソース ([キュー名と URL](sqs-queue-message-identifiers.md#queue-name-url))。たとえば: `https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue`
+ **アクション**-エンドポイントに実行したい [アクション](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html)。疑問符 (`?`) によってエンドポイントとアクションが区切られます。たとえば`?Action=SendMessage&MessageBody=Your%20Message%20Text`など:
+ **パラメータ** – 任意のリクエストパラメータ。パラメータごとにアンパサンド (`&`) で区切ります。例: `&Version=2012-11-05&AUTHPARAMS` 

メッセージを Amazon SQS キューに送信する GET リクエストの例を以下に示します。

```
https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue
?Action=SendMessage&MessageBody=Your%20message%20text
&Version=2012-11-05
&AUTHPARAMS
```

**注記**  
キュー名とキュー URL では、大文字と小文字が区別されます。  
GET リクエストは URL であるため、すべてのパラメータ値を URL エンコードする必要があります。URL にはスペースを使用できないため、各スペースは `%20` として URL エンコードします。例の残りについては、読みやすくするために URL エンコードしていません。

## POST リクエストの作成
<a name="structure-post-request"></a>

Amazon SQS の POST リクエストは、クエリパラメータを HTTP リクエストボディの形で送信します。

`Content-Type` を `application/x-www-form-urlencoded` に設定した HTTP ヘッダーの例を次に示します。

```
POST /123456789012/MyQueue HTTP/1.1
Host: sqs.us-east-2.amazonaws.com
Content-Type: application/x-www-form-urlencoded
```

ヘッダーの後には、メッセージを Amazon SQS キューに送信する `[form-urlencoded](https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2)` GET リクエストを続けます。各パラメータは、アンパサンド (`&`)で区切られています。

```
Action=SendMessage
&MessageBody=Your+Message+Text
&Expires=2020-10-15T12%3A00%3A00Z
&Version=2012-11-05
&AUTHPARAMS
```

**注記**  
`Content-Type`HTTPヘッダーのみが必須です。`AUTHPARAMS` は、GET リクエストの場合と同じです。  
HTTP クライアントは、クライアントの HTTP バージョンによっては、他の項目を HTTP リクエストに追加する可能性があります。

# Amazon SQS の XML API レスポンスの解釈
<a name="sqs-xml-api-responses"></a>

Amazon SQS にリクエストを送信すると、リクエストの結果を含む XML レスポンスが返されます。これらのレスポンスの構造と詳細を理解するには、「*Amazon Simple Queue Service API リファレンス*」の「[API アクション](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html)」を参照してください。

## 成功した XML レスポンス構造
<a name="sqs-api-successful-response-structure"></a>

リクエストが成功すると、メインのレスポンス要素は、アクション名の後に `Response` を続けた名前になります (例: `ActionNameResponse`)。

この要素には、以下の子要素が含まれています。
+ **`ActionNameResult`**-アクション固有の要素が含まれています。たとえば、`CreateQueueResult` 要素には `QueueUrl` 要素が含まれています。つまり、作成されたキューのURLが含まれています。
+ **`ResponseMetadata`** – `RequestId` を含み、この ID 内にリクエストのユニバーサルユニーク識別子 (UUID) が含まれています。

以下に、XML形式の正常なレスポンスの例を示します。

```
<CreateQueueResponse
   xmlns=https://sqs.us-east-2.amazonaws.com/doc/2012-11-05/
   xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance
   xsi:type=CreateQueueResponse>
   <CreateQueueResult>
      <QueueUrl>https://sqs.us-east-2.amazonaws.com/770098461991/queue2</QueueUrl>
   </CreateQueueResult>
   <ResponseMetadata>
      <RequestId>cb919c0a-9bce-4afe-9b48-9bdf2412bb67</RequestId>
   </ResponseMetadata>
</CreateQueueResponse>
```

## XML エラーレスポンス構造
<a name="sqs-api-error-response-structure"></a>

リクエストが正常に行われなかった場合、 Amazon SQSは常に主な応答要素を返信します`ErrorResponse`。この要素には `Error` 要素と `RequestId` 要素が含まれます。

`Error` 要素には、以下の子要素が含まれています。
+ **`Type`**-エラーがプロデューサーかコンシューマーのどちらかを特定します。
+ **`Code`**-エラーのタイプを特定します。
+ **`Message`**-読み取り可能な条件でエラー状況を特定します。
+ **`Detail`**-(オプション) エラーに関する追加の詳細を特定します。

`RequestId`要素には、リクエストのUUIDが含まれています。

以下に、XML形式のエラーレスポンスの例を示します。

```
<ErrorResponse>
   <Error>
      <Type>Sender</Type>
      <Code>InvalidParameterValue</Code>
      <Message>
         Value (quename_nonalpha) for parameter QueueName is invalid.
         Must be an alphanumeric String of 1 to 80 in length.
      </Message>
   </Error>
   <RequestId>42d59b56-7407-4c4a-be0f-4c88daeea257</RequestId>
</ErrorResponse>
```

# Amazon SQS のリクエストの認証
<a name="sqs-api-request-authentication"></a>

署名認証とは、リクエストの送信者を特定し、検証するプロセスです。認証の最初の段階で、 AWS はプロデューサーのアイデンティティと、プロデューサーが [AWSを使用するように登録されている](https://aws.amazon.com/)かどうかを確認します (詳細については、「[ステップ 1: AWS アカウント と IAM ユーザーを作成する](sqs-setting-up.md#sqs-creating-aws-account)」を参照してください)。次に、以下の手順 AWS に従います。

1. プロデューサー (送信者) が必要な証明書を取得します。

1. プロデューサーがリクエストと認証情報をコンシューマー (受信者) に送信します。

1. コンシューマーは証明書を使用して、プロデューサーが本当にリクエストを送信したか検証します。

1. 次のいずれかの結果になります。
   + 認証が成功すると、コンシューマーはリクエストを処理します。
   + 認証に失敗すると、コンシューマーによってリクエストが却下され、エラーが返されます。

## HMAC-SHA による基本的な認証のプロセス
<a name="sqs-api-basic-authentication-process"></a>

クエリAPIを使用してAmazon SQSにアクセスする場合は、リクエストの認証のために、以下の項目を準備する必要があります。
+ を識別する**AWS アクセスキー ID**。 AWS は AWS アカウントを使用してシークレットアクセスキーを検索します。
+ **HMAC-SHAリクエスト署名**、シークレットアクセスキーを使用して計算されます(共有シークレットはお客様と AWSだけが知っています。詳細については、[RFC2104](http://www.faqs.org/rfcs/rfc2104.html) を参照してください)。[AWS SDK](https://aws.amazon.com/code/) によって署名プロセスが処理されますが、HTTP または HTTPS 経由でクエリリクエストを送信した場合、各クエリリクエストに署名を含める必要があります。

  1. 署名バージョン4の署名キーを取得します。詳細については、「[Java を使用して署名キーを取得](https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java)」を参照してください。
**注記**  
Amazon SQSは署名バージョン4をサポートしています。署名バージョン4では、SHA256により以前のバージョンよりもセキュリティとパフォーマンスが向上しています。Amazon SQSを使用する新規のアプリケーションを作成する場合、署名バージョン4を使用します。

  1. リクエスト署名をBase64 エンコードします。以下のサンプルJavaコードによってこの処理が行われます。

     ```
     package amazon.webservices.common;
     
     // Define common routines for encoding data in AWS requests.
     public class Encoding {
     
         /* Perform base64 encoding of input bytes.
          * rawData is the array of bytes to be encoded.
          * return is the base64-encoded string representation of rawData.
          */
         public static String EncodeBase64(byte[] rawData) {
             return Base64.encodeBytes(rawData);
         }
     }
     ```
+ リクエストの**タイムスタンプ (または有効期限)**。リクエストで使用するタイムスタンプは、`dateTime` オブジェクトでなければなりません。[時、分、秒を含む詳細な日時](http://www.w3.org/TR/xmlschema-2/#dateTime)が必要です。たとえば、`2007-01-31T23:59:59Z` などです。必須ではありませんが、協定世界時 (グリニッジ標準時)を使用してオブジェクトを提供することが推奨されています。
**注記**  
あなたのサーバー時刻が正しく設定されていることを確認してください。(有効期限ではなく) タイムスタンプを指定すると、リクエストは指定された時刻から 15 分後に自動的に期限切れになります (サーバーの現在の時刻 AWS より 15 AWS 分以上前のタイムスタンプを持つリクエストは処理されません）。  
.NET を使用する場合、過度に厳密なタイムスタンプ情報を送信しないようご注意ください (タイムスタンプの処理プロセスの違いにより不具合が発生する可能性があるためです)。この場合、精度が 1ミリ秒以内の`dateTime`オブジェクトを手動で作成してください。

## パート 1: ユーザーからのリクエスト
<a name="sqs-authentication-user"></a>

HMAC-SHA AWS リクエスト署名を使用してリクエストを認証するには、次のプロセスに従う必要があります。

![\[ユーザーからのリクエストを説明する図。\]](http://docs.aws.amazon.com/ja_jp/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-user.png)


1. へのリクエストを作成します AWS。

1. シークレットアクセスキーを使用して、キー付きハッシュメッセージ認証コード (HMAC-SHA) 署名を計算します。

1. リクエストに署名とアクセスキー ID を含めてから、リクエストを送信します AWS。

## パート 2: からのレスポンス AWS
<a name="sqs-authentication-aws"></a>

AWS は応答として次のプロセスを開始します。

![\[AWSからのレスポンスを説明する図。\]](http://docs.aws.amazon.com/ja_jp/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-aws.png)


1. AWS はアクセスキー ID を使用してシークレットアクセスキーを検索します。

1. AWS は、リクエストで送信した署名の計算に使用したのと同じアルゴリズムを使用して、リクエストデータとシークレットアクセスキーから署名を生成します。

1. 次のいずれかの結果になります。
   + が AWS 生成する署名がリクエストで送信した署名と一致する場合、 はリクエストが本物である AWS と見なします。
   + 比較が失敗すると、リクエストは破棄され、エラー AWS が返されます。

# Amazon SQSのバッチアクション
<a name="sqs-batch-api-actions"></a>

Amazon SQS のバッチアクションを使用すると、コストを削減し、1 つのアクションで最大 10 件のメッセージを操作できます。バッチアクションは以下のとおりです。
+ `[SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)`
+ `[DeleteMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html)`
+ `[ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)`

バッチアクションを使用すると、1 回の API コールで複数のオペレーションを実行できるため、パフォーマンスを最適化してコストを削減できます。クエリ API または Amazon SQS バッチアクションをサポートする任意の AWS SDK を使用して、バッチ機能を活用できます。

**重要な詳細**
+ **メッセージのサイズ制限:** 1 回の `SendMessageBatch` コールで送信するすべてのメッセージの合計サイズは、1,048,576 バイト (1 MiB) を超えることができません。
+ **アクセス許可:** `SendMessageBatch`、`DeleteMessageBatch`、または `ChangeMessageVisibilityBatch` のアクセス許可を明示的に設定することはできません。`SendMessage`、`DeleteMessage`、または `ChangeMessageVisibility` のアクセス許可を設定すると、代わりに、アクションの対応するバッチバージョンのアクセス許可が設定されます。
+ **コンソールのサポート:** Amazon SQS コンソールは、バッチアクションをサポートしていません。バッチオペレーションを実行するには、クエリ API または AWS SDK を使用する必要があります。

## メッセージアクションのバッチ処理
<a name="batching-message-actions"></a>

コストと効率をさらに最適化するには、メッセージアクションのバッチ処理に関する以下のベストプラクティスを検討してください。
+ **バッチ API アクション:** 1 つのアクションで複数のメッセージを送信、受信、削除したり、複数のメッセージのメッセージ可視性タイムアウトを変更したりするには、[Amazon SQS のバッチ API アクション](#sqs-batch-api-actions)を使用します。これにより、API コールの数と関連コストを削減できます。
+ **クライアント側のバッファリングとロングポーリング:** ロングポーリングと AWS SDK for Javaに含まれる[バッファリング非同期クライアント](sqs-client-side-buffering-request-batching.md)を併用することで、クライアント側のバッファリングとリクエストバッチ処理を組み合わせます。このアプローチは、リクエスト数を最小限に抑え、大量のメッセージ処理を最適化するのに役立ちます。

**注記**  
Amazon SQSバッファリング非同期クライアントは現在 FIFOキューをサポートしていません。

# Amazon SQS でのクライアント側のバッファリングとリクエストのバッチ処理の有効化
<a name="sqs-client-side-buffering-request-batching"></a>

[AWS SDK for Java](https://aws.amazon.com/sdkforjava/)を含む`AmazonSQSBufferedAsyncClient`Amazon SQSにアクセスするもの。このクライアントを使用すると、クライアント側のバッファリングを使用したシンプルなリクエストバッチ処理が可能になります。クライアントから行われた呼び出しが最初にバッファされ、Amazon SQS へのバッチリクエストとして送信される方法について説明します。

クライアント側のバッファリングは最大10個のリクエストをバッファリングし、バッチリクエストとして送信できるため、Amazon SQSの利用コストを削減して、送信リクエストの数を減らすことができます。バッファリングは同期および非同期コールの両方を`AmazonSQSBufferedAsyncClient` バッファします。バッチ処理されたリクエストと[ ロングポーリングのサポート](sqs-short-and-long-polling.md)によって、スループットを向上させることもできます。詳細については、「[Amazon SQS での水平スケーリングとアクションのバッチ処理を使用したスループットの向上](sqs-throughput-horizontal-scaling-and-batching.md)」を参照してください。

`AmazonSQSBufferedAsyncClient`は`AmazonSQSAsyncClient`と同じインターフェイスを実行するため、`AmazonSQSAsyncClient` から `AmazonSQSBufferedAsyncClient` に移行するには通常既存のコードを最小限変更するだけです。

**注記**  
Amazon SQS バッファリング非同期クライアントは現在 FIFOキューをサポートしていません。

## AmazonSQSBufferedAsyncClient の使用
<a name="using-buffered-async-client"></a>

開始する前に、「[Amazon SQSのセットアップ](sqs-setting-up.md)」のステップを完了します。

### AWS SDK for Java 1.x
<a name="using-buffered-async-client-java1"></a>

 AWS SDK for Java 1.x では、次の例`AmazonSQSBufferedAsyncClient`に基づいて新しい を作成できます。

```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
 
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync);
```

新規の `AmazonSQSBufferedAsyncClient` を作成したら、これを使用して Amazon SQS に複数のリクエストを送信できます (`AmazonSQSAsyncClient` と同様です)。次に例を示します。

```
final CreateQueueRequest createRequest = new CreateQueueRequest().withQueueName("MyQueue");
 
final CreateQueueResult res = bufferedSqs.createQueue(createRequest);
 
final SendMessageRequest request = new SendMessageRequest();
final String body = "Your message text" + System.currentTimeMillis();
request.setMessageBody( body );
request.setQueueUrl(res.getQueueUrl());
 
final Future<SendMessageResult> sendResult = bufferedSqs.sendMessageAsync(request);
 
final ReceiveMessageRequest receiveRq = new ReceiveMessageRequest()
    .withMaxNumberOfMessages(1)
    .withQueueUrl(queueUrl);
final ReceiveMessageResult rx = bufferedSqs.receiveMessage(receiveRq);
```

### AmazonSQSBufferedAsyncClient の設定
<a name="configuring-buffered-async-client"></a>

`AmazonSQSBufferedAsyncClient` は、ほとんどのユースケースに合うように事前に設定されています。たとえば、`AmazonSQSBufferedAsyncClient` をさらに設定できます。'

1. 必要な設定パラメータを使用して、`QueueBufferConfig` クラスのインスタンスを作成します。

1. `AmazonSQSBufferedAsyncClient` コンストラクタにインスタンスを指定します。

```
// Create the basic Amazon SQS async client
final AmazonSQSAsync sqsAsync = new AmazonSQSAsyncClient();
 
final QueueBufferConfig config = new QueueBufferConfig()
    .withMaxInflightReceiveBatches(5)
    .withMaxDoneReceiveBatches(15);
 
// Create the buffered client
final AmazonSQSAsync bufferedSqs = new AmazonSQSBufferedAsyncClient(sqsAsync, config);
```


**QueueBufferConfig の設定パラメータ**  

| パラメータ | デフォルトの値 | 説明 | 
| --- | --- | --- | 
| longPoll | true |  `longPoll` が `true` に設定されている場合、`AmazonSQSBufferedAsyncClient` はメッセージの処理時にロングポーリングを使用しようとします。  | 
| longPollWaitTimeoutSeconds | 20 s |  空の受信結果を返すまでに、キュー内へのメッセージの出現をサーバーが待機するのを `ReceiveMessage` 呼び出しがブロックする最大秒数。  ロングポーリングが無効になっている場合、この設定に効果はありません。   | 
| maxBatchOpenMs | 200ms |  送信呼び出しが、同じタイプのメッセージをバッチ処理する他の呼び出しを待機する最大ミリ秒。 設定を大きくすればするほど、同じ量の処理を実行するのに必要なバッチが少なくなります (ただし、バッチ内の最初の呼び出しは待機時間が長くなります)。 このパラメータを `0` に設定した場合、送信されたリクエストは他のリクエストを待機しないため、バッチ処理が事実上無効になります。  | 
| maxBatchSize | バッチあたり 10 個のリクエスト |  1 つのバッチリクエストでまとめてバッチ処理されるメッセージの最大数。設定を大きくするほど、全体数が同じリクエストの処理に要するバッチ数が減ります。  バッチあたり 10 個のリクエストはAmazon SQSの最大許容値です。   | 
| maxBatchSizeBytes | 1 MiB |  クライアントがAmazon SQSに送信しようとするメッセージバッチの最大サイズ、バイト単位。  1 MiB は、Amazon SQS の最大許容値です。   | 
| maxDoneReceiveBatches | 10 個のバッチ |  `AmazonSQSBufferedAsyncClient` がプリフェッチし、クライアント側に保存する受信バッチの最大数。 設定を大きくすればするほど、Amazon SQSを呼び出さなくても多くの受信リクエストを満たすことができます (ただし、プリフェッチされるメッセージが多くなるほど、バッファにとどまる時間が長くなるため、それ自体の可視性タイムアウトが発生する可能性があります)。  `0` は、すべてのメッセージのプリフェッチが無効になっていて、メッセージはオンデマンドでのみ消費されることを示します。   | 
| maxInflightOutboundBatches | 5 個のバッチ |  同時に処理できるアクティブな送信バッチの最大数。 設定を大きくすればするほど、送信バッチの送信速度が速くなり (CPU や帯域幅などの他のクォータの影響を受けます)、`AmazonSQSBufferedAsyncClient` により消費されるスレッドが増えます。  | 
| maxInflightReceiveBatches | 10 個のバッチ |  同時に処理できるアクティブな受信バッチの最大数。 設定を大きくすればするほど、受信するメッセージが増え (CPU や帯域幅などの他のクォータの影響を受けます)、`AmazonSQSBufferedAsyncClient` により消費されるスレッドが増えます。  `0` は、すべてのメッセージのプリフェッチが無効になっていて、メッセージはオンデマンドでのみ消費されることを示します。   | 
| visibilityTimeoutSeconds | -1 |  このパラメータが 0 以外の正の値に設定されている場合、ここで設定した可視性タイムアウトにより、メッセージの処理元のキューで設定された可視性タイムアウトが上書きされます。  `-1` は、キューのデフォルト設定が選択されていることを示します。 可視性タイムアウトを `0` に設定することはできません。   | 

### AWS SDK for Java 2.x
<a name="using-buffered-async-client-java2"></a>

 AWS SDK for Java 2.x では、次の例`SqsAsyncBatchManager`に基づいて新しい を作成できます。

```
// Create the basic Sqs Async Client
SqsAsyncClient sqs = SqsAsyncClient.builder() 
    .region(Region.US_EAST_1) 
    .build();

// Create the batch manager
SqsAsyncBatchManager sqsAsyncBatchManager = sqs.batchManager();
```

新規の `SqsAsyncBatchManager` を作成したら、これを使用して Amazon SQS に複数のリクエストを送信できます (`SqsAsyncClient` と同様です)。次に例を示します。

```
final String queueName = "MyAsyncBufferedQueue" + UUID.randomUUID();
final CreateQueueRequest request = CreateQueueRequest.builder().queueName(queueName).build();
final String queueUrl = sqs.createQueue(request).join().queueUrl();
System.out.println("Queue created: " + queueUrl);


// Send messages
CompletableFuture<SendMessageResponse> sendMessageFuture;
for (int i = 0; i < 10; i++) {
    final int index = i;
    sendMessageFuture = sqsAsyncBatchManager.sendMessage(
            r -> r.messageBody("Message " + index).queueUrl(queueUrl));
    SendMessageResponse response= sendMessageFuture.join();
    System.out.println("Message " + response.messageId() + " sent!");
}

// Receive messages with customized configurations
CompletableFuture<ReceiveMessageResponse> receiveResponseFuture = customizedBatchManager.receiveMessage(
        r -> r.queueUrl(queueUrl)
                .waitTimeSeconds(10)
                .visibilityTimeout(20)
                .maxNumberOfMessages(10)
);
System.out.println("You have received " + receiveResponseFuture.join().messages().size() + " messages in total.");

// Delete messages
DeleteQueueRequest deleteQueueRequest =  DeleteQueueRequest.builder().queueUrl(queueUrl).build();
int code = sqs.deleteQueue(deleteQueueRequest).join().sdkHttpResponse().statusCode();
System.out.println("Queue is deleted, with statusCode " + code);
```

### SqsAsyncBatchManager の設定
<a name="configuring-SqsAsyncBatchManager"></a>

`SqsAsyncBatchManager` は、ほとんどのユースケースに合うように事前に設定されています。たとえば、`SqsAsyncBatchManager` をさらに設定できます。'

`SqsAsyncBatchManager.Builder` を使用したカスタム設定の作成:

```
SqsAsyncBatchManager customizedBatchManager = SqsAsyncBatchManager.builder() 
    .client(sqs)
    .scheduledExecutor(Executors.newScheduledThreadPool(5))
    .overrideConfiguration(b -> b 
        .maxBatchSize(10)
        .sendRequestFrequency(Duration.ofMillis(200))
        .receiveMessageMinWaitDuration(Duration.ofSeconds(10))
        .receiveMessageVisibilityTimeout(Duration.ofSeconds(20)) 
        .receiveMessageAttributeNames(Collections.singletonList("*"))
        .receiveMessageSystemAttributeNames(Collections.singletonList(MessageSystemAttributeName.ALL)))
    .build();
```


**`BatchOverrideConfiguration` 個のパラメータ**  

| パラメータ | デフォルトの値 | 説明 | 
| --- | --- | --- | 
| maxBatchSize |  バッチあたり 10 個のリクエスト  | 1 つのバッチリクエストでまとめてバッチ処理されるメッセージの最大数。設定を大きくするほど、全体数が同じリクエストの処理に要するバッチ数が減ります。  Amazon SQS の最大許容値はバッチあたり 10 個のリクエストです。  | 
| sendRequestFrequency |  200ms  | 送信呼び出しが、同じタイプのメッセージをバッチ処理する他の呼び出しを待機する最大ミリ秒。 設定を大きくすればするほど、同じ量の処理を実行するのに必要なバッチが少なくなります (ただし、バッチ内の最初の呼び出しは待機時間が長くなります)。 このパラメータを `0` に設定した場合、送信されたリクエストは他のリクエストを待機しないため、バッチ処理が事実上無効になります。 | 
| receiveMessageVisibilityTimeout |  -1  | このパラメータが 0 以外の正の値に設定されている場合、ここで設定した可視性タイムアウトにより、メッセージの処理元のキューで設定された可視性タイムアウトが上書きされます。   `1` は、キューのデフォルト設定が選択されていることを示します。可視性タイムアウトを `0` に設定することはできません。   | 
| receiveMessageMinWaitDuration |  50 ミリ秒  | `receiveMessage` 呼び出しが使用可能なメッセージの取得を待機する最小時間 (ミリ秒単位）。設定を大きくするほど、全体数が同じリクエストの処理に要するバッチ数が減ります。  | 

# Amazon SQS での水平スケーリングとアクションのバッチ処理を使用したスループットの向上
<a name="sqs-throughput-horizontal-scaling-and-batching"></a>

Amazon SQS は高スループットメッセージングをサポートしています。スループット制限の詳細については、「[Amazon SQS のメッセージキュー](quotas-messages.md)」を参照してください。

スループットを最大化するには:
+ それぞれのインスタンスを追加してプロデューサーとコンシューマーを水平方向に[スケール](#horizontal-scaling)します。
+ [アクションバッチ処理](#request-batching)を使用して、1 つのリクエストで複数のメッセージを送受信し、API コールのオーバーヘッドを削減します。

## 水平スケーリング
<a name="horizontal-scaling"></a>

Amazon SQSは HTTP リクエストレスポンスプロトコルを通じてアクセスするため、*リクエストのレイテンシー *(リクエストの開始からレスポンスの受信までの時間) により1回の接続を使用して1つのスレッドを処理した場合のスループットは制限されます。たとえば、Amazon EC2ベースのクライアントから同じリージョンにあるAmazon SQSへのレイテンシーが平均 20 ミリ秒の場合、1回の接続で1つのスレッドを処理した場合の最大スループットは平均で 50 TPS になります。

*水平スケーリング*には、全体的なキュースループットを高めるために、メッセージのプロデューサー (`[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` リクエストを生成) とコンシューマー (`[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` リクエストと `[DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)` リクエストを生成) の数を増やすことが必要です。水平スケーリングを行うには 3 つの方法があります。
+ クライアントあたりのスレッドの数を増やす
+ クライアントを追加する
+ クライアントあたりのスレッドの数を増やし、クライアントを追加する

クライアントを追加すると、基本的にはキューのスループットが直線的に向上します。たとえば、クライアントの数を 2 倍にした場合、スループットも 2 倍になります。

## アクションバッチ処理
<a name="request-batching"></a>

*バッチ処理*では、サービスへの各ラウンドトリップでより多くの処理が実行されます (たとえば、1 回の `SendMessageBatch` リクエストで複数のメッセージを送信する場合など)。Amazon SQS バッチ アクションは、`[SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)`、`[DeleteMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html)`、および `[ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)` です。プロデューサーやコンシューマーを変更することなくバッチ処理を活用するには、[Amazon SQSバファリング非同期クライアント](sqs-client-side-buffering-request-batching.md) を使用します。

**注記**  
`[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` は、一度に 10 件のメッセージを処理できるため、`ReceiveMessageBatch` アクションはありません。

バッチ処理では、1 件のメッセージのレイテンシー全体が受け入れられるのではなく、1 回のバッチリクエストの複数のメッセージにまたがるバッチアクションのレイテンシーが分散されます (たとえば、`[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` リクエストなど)。各ラウンドトリップがより多くの処理を実行するため、バッチリクエストがスレッドと接続をより効率的に使用するようになり、スループットが向上します。

マッチ処理と水平スケーリングを組み合わせて、個々のメッセージリクエストより少ないスレッド、接続、リクエストで一定のスループットを実現できます。バッチ処理されたAmazon SQSアクションを使用して、最大 10 通のメッセージを一度に送信、受信、または削除できます。Amazon SQSではリクエスト単位で課金されるため、バッチ処理はコストを大幅に削減できます。

バッチ処理により、アプリケーションがいくらか複雑になる可能性はあります (たとえば、アプリケーションはメッセージを送信前に累積する必要があります。または、レスポンスを長時間待機する必要が生じることもときどきあります)。しかし、それでもバッチ処理は次の場合に効果的です: 
+ アプリケーションが短い時間で多くのメッセージを生成するため、遅延が大幅に長くなることはない。
+ 一般的なメッセージプロデューサーが自身でコントロールしていないイベントに応答してメッセージを送信する必要があるのと異なり、メッセージコンシューマーは自身の判断でキューからメッセージを取得する。

**重要**  
バッチ内の個々のメッセージが失敗しても、バッチリクエストは成功することがあります。バッチリクエストの後、必ず個々のメッセージのエラーがないか確認し、必要に応じてアクションを再試行してください。

## 1 回のオペレーションおよびバッチリクエストでの Java の使用例
<a name="working-java-example-batch-requests"></a>

### 前提条件
<a name="batch-request-java-example-prerequisites"></a>

`aws-java-sdk-sqs.jar`パッケージ、`aws-java-sdk-ec2.jar` パッケージおよび `commons-logging.jar` パッケージを Java ビルドクラスパスに追加します。以下の例は、Maven プロジェクトの `pom.xml` ファイルにあるこれらの依存関係を示しています。

```
<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk-sqs</artifactId>
        <version>LATEST</version>
    </dependency>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk-ec2</artifactId>
        <version>LATEST</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>LATEST</version>
    </dependency>
</dependencies>
```

### SimpleProducerConsumer.java
<a name="batch-request-java-example-code"></a>

次の Java コード例では、簡単なプロデューサー-コンシューマーパターンが実行されています。メインスレッドでは、指定された時間に 1 KB のメッセージを処理するプロデューサーおよびコンシューマースレッドが多数発生します。この例には、単一オペレーションリクエストを生成するプロデューサーおよびコンシューマーと、バッチ処理リクエストを生成するプロデューサーおよびコンシューマーが含まれています。

```
/*
 * Copyright 2010-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *  https://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 */

import com.amazonaws.AmazonClientException;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.*;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Start a specified number of producer and consumer threads, and produce-consume
 * for the least of the specified duration and 1 hour. Some messages can be left
 * in the queue because producers and consumers might not be in exact balance.
 */
public class SimpleProducerConsumer {

    // The maximum runtime of the program.
    private final static int MAX_RUNTIME_MINUTES = 60;
    private final static Log log = LogFactory.getLog(SimpleProducerConsumer.class);

    public static void main(String[] args) throws InterruptedException {

        final Scanner input = new Scanner(System.in);

        System.out.print("Enter the queue name: ");
        final String queueName = input.nextLine();

        System.out.print("Enter the number of producers: ");
        final int producerCount = input.nextInt();

        System.out.print("Enter the number of consumers: ");
        final int consumerCount = input.nextInt();

        System.out.print("Enter the number of messages per batch: ");
        final int batchSize = input.nextInt();

        System.out.print("Enter the message size in bytes: ");
        final int messageSizeByte = input.nextInt();

        System.out.print("Enter the run time in minutes: ");
        final int runTimeMinutes = input.nextInt();

        /*
         * Create a new instance of the builder with all defaults (credentials
         * and region) set automatically. For more information, see Creating
         * Service Clients in the AWS SDK for Java Developer Guide.
         */
        final ClientConfiguration clientConfiguration = new ClientConfiguration()
                .withMaxConnections(producerCount + consumerCount);

        final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard()
                .withClientConfiguration(clientConfiguration)
                .build();

        final String queueUrl = sqsClient
                .getQueueUrl(new GetQueueUrlRequest(queueName)).getQueueUrl();

        // The flag used to stop producer, consumer, and monitor threads.
        final AtomicBoolean stop = new AtomicBoolean(false);

        // Start the producers.
        final AtomicInteger producedCount = new AtomicInteger();
        final Thread[] producers = new Thread[producerCount];
        for (int i = 0; i < producerCount; i++) {
            if (batchSize == 1) {
                producers[i] = new Producer(sqsClient, queueUrl, messageSizeByte,
                        producedCount, stop);
            } else {
                producers[i] = new BatchProducer(sqsClient, queueUrl, batchSize,
                        messageSizeByte, producedCount,
                        stop);
            }
            producers[i].start();
        }

        // Start the consumers.
        final AtomicInteger consumedCount = new AtomicInteger();
        final Thread[] consumers = new Thread[consumerCount];
        for (int i = 0; i < consumerCount; i++) {
            if (batchSize == 1) {
                consumers[i] = new Consumer(sqsClient, queueUrl, consumedCount,
                        stop);
            } else {
                consumers[i] = new BatchConsumer(sqsClient, queueUrl, batchSize,
                        consumedCount, stop);
            }
            consumers[i].start();
        }

        // Start the monitor thread.
        final Thread monitor = new Monitor(producedCount, consumedCount, stop);
        monitor.start();

        // Wait for the specified amount of time then stop.
        Thread.sleep(TimeUnit.MINUTES.toMillis(Math.min(runTimeMinutes,
                MAX_RUNTIME_MINUTES)));
        stop.set(true);

        // Join all threads.
        for (int i = 0; i < producerCount; i++) {
            producers[i].join();
        }

        for (int i = 0; i < consumerCount; i++) {
            consumers[i].join();
        }

        monitor.interrupt();
        monitor.join();
    }

    private static String makeRandomString(int sizeByte) {
        final byte[] bs = new byte[(int) Math.ceil(sizeByte * 5 / 8)];
        new Random().nextBytes(bs);
        bs[0] = (byte) ((bs[0] | 64) & 127);
        return new BigInteger(bs).toString(32);
    }

    /**
     * The producer thread uses {@code SendMessage}
     * to send messages until it is stopped.
     */
    private static class Producer extends Thread {
        final AmazonSQS sqsClient;
        final String queueUrl;
        final AtomicInteger producedCount;
        final AtomicBoolean stop;
        final String theMessage;

        Producer(AmazonSQS sqsQueueBuffer, String queueUrl, int messageSizeByte,
                 AtomicInteger producedCount, AtomicBoolean stop) {
            this.sqsClient = sqsQueueBuffer;
            this.queueUrl = queueUrl;
            this.producedCount = producedCount;
            this.stop = stop;
            this.theMessage = makeRandomString(messageSizeByte);
        }

        /*
         * The producedCount object tracks the number of messages produced by
         * all producer threads. If there is an error, the program exits the
         * run() method.
         */
        public void run() {
            try {
                while (!stop.get()) {
                    sqsClient.sendMessage(new SendMessageRequest(queueUrl,
                            theMessage));
                    producedCount.incrementAndGet();
                }
            } catch (AmazonClientException e) {
                /*
                 * By default, AmazonSQSClient retries calls 3 times before
                 * failing. If this unlikely condition occurs, stop.
                 */
                log.error("Producer: " + e.getMessage());
                System.exit(1);
            }
        }
    }

    /**
     * The producer thread uses {@code SendMessageBatch}
     * to send messages until it is stopped.
     */
    private static class BatchProducer extends Thread {
        final AmazonSQS sqsClient;
        final String queueUrl;
        final int batchSize;
        final AtomicInteger producedCount;
        final AtomicBoolean stop;
        final String theMessage;

        BatchProducer(AmazonSQS sqsQueueBuffer, String queueUrl, int batchSize,
                      int messageSizeByte, AtomicInteger producedCount,
                      AtomicBoolean stop) {
            this.sqsClient = sqsQueueBuffer;
            this.queueUrl = queueUrl;
            this.batchSize = batchSize;
            this.producedCount = producedCount;
            this.stop = stop;
            this.theMessage = makeRandomString(messageSizeByte);
        }

        public void run() {
            try {
                while (!stop.get()) {
                    final SendMessageBatchRequest batchRequest =
                            new SendMessageBatchRequest().withQueueUrl(queueUrl);

                    final List<SendMessageBatchRequestEntry> entries =
                            new ArrayList<SendMessageBatchRequestEntry>();
                    for (int i = 0; i < batchSize; i++)
                        entries.add(new SendMessageBatchRequestEntry()
                                .withId(Integer.toString(i))
                                .withMessageBody(theMessage));
                    batchRequest.setEntries(entries);

                    final SendMessageBatchResult batchResult =
                            sqsClient.sendMessageBatch(batchRequest);
                    producedCount.addAndGet(batchResult.getSuccessful().size());

                    /*
                     * Because SendMessageBatch can return successfully, but
                     * individual batch items fail, retry the failed batch items.
                     */
                    if (!batchResult.getFailed().isEmpty()) {
                        log.warn("Producer: retrying sending "
                                + batchResult.getFailed().size() + " messages");
                        for (int i = 0, n = batchResult.getFailed().size();
                             i < n; i++) {
                            sqsClient.sendMessage(new
                                    SendMessageRequest(queueUrl, theMessage));
                            producedCount.incrementAndGet();
                        }
                    }
                }
            } catch (AmazonClientException e) {
                /*
                 * By default, AmazonSQSClient retries calls 3 times before
                 * failing. If this unlikely condition occurs, stop.
                 */
                log.error("BatchProducer: " + e.getMessage());
                System.exit(1);
            }
        }
    }

    /**
     * The consumer thread uses {@code ReceiveMessage} and {@code DeleteMessage}
     * to consume messages until it is stopped.
     */
    private static class Consumer extends Thread {
        final AmazonSQS sqsClient;
        final String queueUrl;
        final AtomicInteger consumedCount;
        final AtomicBoolean stop;

        Consumer(AmazonSQS sqsClient, String queueUrl, AtomicInteger consumedCount,
                 AtomicBoolean stop) {
            this.sqsClient = sqsClient;
            this.queueUrl = queueUrl;
            this.consumedCount = consumedCount;
            this.stop = stop;
        }

        /*
         * Each consumer thread receives and deletes messages until the main
         * thread stops the consumer thread. The consumedCount object tracks the
         * number of messages that are consumed by all consumer threads, and the
         * count is logged periodically.
         */
        public void run() {
            try {
                while (!stop.get()) {
                    try {
                        final ReceiveMessageResult result = sqsClient
                                .receiveMessage(new
                                        ReceiveMessageRequest(queueUrl));

                        if (!result.getMessages().isEmpty()) {
                            final Message m = result.getMessages().get(0);
                            sqsClient.deleteMessage(new
                                    DeleteMessageRequest(queueUrl,
                                    m.getReceiptHandle()));
                            consumedCount.incrementAndGet();
                        }
                    } catch (AmazonClientException e) {
                        log.error(e.getMessage());
                    }
                }
            } catch (AmazonClientException e) {
                /*
                 * By default, AmazonSQSClient retries calls 3 times before
                 * failing. If this unlikely condition occurs, stop.
                 */
                log.error("Consumer: " + e.getMessage());
                System.exit(1);
            }
        }
    }

    /**
     * The consumer thread uses {@code ReceiveMessage} and {@code
     * DeleteMessageBatch} to consume messages until it is stopped.
     */
    private static class BatchConsumer extends Thread {
        final AmazonSQS sqsClient;
        final String queueUrl;
        final int batchSize;
        final AtomicInteger consumedCount;
        final AtomicBoolean stop;

        BatchConsumer(AmazonSQS sqsClient, String queueUrl, int batchSize,
                      AtomicInteger consumedCount, AtomicBoolean stop) {
            this.sqsClient = sqsClient;
            this.queueUrl = queueUrl;
            this.batchSize = batchSize;
            this.consumedCount = consumedCount;
            this.stop = stop;
        }

        public void run() {
            try {
                while (!stop.get()) {
                    final ReceiveMessageResult result = sqsClient
                            .receiveMessage(new ReceiveMessageRequest(queueUrl)
                                    .withMaxNumberOfMessages(batchSize));

                    if (!result.getMessages().isEmpty()) {
                        final List<Message> messages = result.getMessages();
                        final DeleteMessageBatchRequest batchRequest =
                                new DeleteMessageBatchRequest()
                                        .withQueueUrl(queueUrl);

                        final List<DeleteMessageBatchRequestEntry> entries =
                                new ArrayList<DeleteMessageBatchRequestEntry>();
                        for (int i = 0, n = messages.size(); i < n; i++)
                            entries.add(new DeleteMessageBatchRequestEntry()
                                    .withId(Integer.toString(i))
                                    .withReceiptHandle(messages.get(i)
                                            .getReceiptHandle()));
                        batchRequest.setEntries(entries);

                        final DeleteMessageBatchResult batchResult = sqsClient
                                .deleteMessageBatch(batchRequest);
                        consumedCount.addAndGet(batchResult.getSuccessful().size());

                        /*
                         * Because DeleteMessageBatch can return successfully,
                         * but individual batch items fail, retry the failed
                         * batch items.
                         */
                        if (!batchResult.getFailed().isEmpty()) {
                            final int n = batchResult.getFailed().size();
                            log.warn("Producer: retrying deleting " + n
                                    + " messages");
                            for (BatchResultErrorEntry e : batchResult
                                    .getFailed()) {

                                sqsClient.deleteMessage(
                                        new DeleteMessageRequest(queueUrl,
                                                messages.get(Integer
                                                        .parseInt(e.getId()))
                                                        .getReceiptHandle()));

                                consumedCount.incrementAndGet();
                            }
                        }
                    }
                }
            } catch (AmazonClientException e) {
                /*
                 * By default, AmazonSQSClient retries calls 3 times before
                 * failing. If this unlikely condition occurs, stop.
                 */
                log.error("BatchConsumer: " + e.getMessage());
                System.exit(1);
            }
        }
    }

    /**
     * This thread prints every second the number of messages produced and
     * consumed so far.
     */
    private static class Monitor extends Thread {
        private final AtomicInteger producedCount;
        private final AtomicInteger consumedCount;
        private final AtomicBoolean stop;

        Monitor(AtomicInteger producedCount, AtomicInteger consumedCount,
                AtomicBoolean stop) {
            this.producedCount = producedCount;
            this.consumedCount = consumedCount;
            this.stop = stop;
        }

        public void run() {
            try {
                while (!stop.get()) {
                    Thread.sleep(1000);
                    log.info("produced messages = " + producedCount.get()
                            + ", consumed messages = " + consumedCount.get());
                }
            } catch (InterruptedException e) {
                // Allow the thread to exit.
            }
        }
    }
}
```

### サンプル実行からのボリュームメトリクスのモニタリング
<a name="batch-request-java-example-monitoring-metrics"></a>

Amazon SQSは、メッセージの送信、受信、削除のボリュームメトリクスを自動的に生成します。これらのメトリックスと他のメトリックスにアクセスするには、キューの ｛**モニタリング**｝タブを使用するか、[[CloudWatchコンソール](https://console.aws.amazon.com/cloudwatch/home)]を使用します。

**注記**  
メトリクスを、キューが開始してから参照可能になるまで最大 15 分かかる場合があります。

# AWS SDK での Amazon SQS の使用
<a name="sdk-general-information-section"></a>

AWS ソフトウェア開発キット (SDK) は、多くの一般的なプログラミング言語で使用できます。各 SDK には、デベロッパーが好みの言語でアプリケーションを簡単に構築できるようにする API、コード例、およびドキュメントが提供されています。


| SDK ドキュメント | コードの例 | 
| --- | --- | 
| [AWS SDK for C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK for C\$1\$1 コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) | 
| [AWS CLI](https://docs.aws.amazon.com/cli) | [AWS CLI コードの例](https://docs.aws.amazon.com/code-library/latest/ug/cli_2_code_examples.html) | 
| [AWS SDK for Go](https://docs.aws.amazon.com/sdk-for-go) | [AWS SDK for Go コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2) | 
| [AWS SDK for Java](https://docs.aws.amazon.com/sdk-for-java) | [AWS SDK for Java コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) | 
| [AWS SDK for JavaScript](https://docs.aws.amazon.com/sdk-for-javascript) | [AWS SDK for JavaScript コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3) | 
| [AWS SDK for Kotlin](https://docs.aws.amazon.com/sdk-for-kotlin) | [AWS SDK for Kotlin コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin) | 
| [AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net) | [AWS SDK for .NET コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3) | 
| [AWS SDK for PHP](https://docs.aws.amazon.com/sdk-for-php) | [AWS SDK for PHP コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) | 
| [AWS Tools for PowerShell](https://docs.aws.amazon.com/powershell) | [AWS Tools for PowerShell コードの例](https://docs.aws.amazon.com/code-library/latest/ug/powershell_5_code_examples.html) | 
| [AWS SDK for Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) | [AWS SDK for Python (Boto3) コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python) | 
| [AWS SDK for Ruby](https://docs.aws.amazon.com/sdk-for-ruby) | [AWS SDK for Ruby コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby) | 
| [AWS SDK for Rust](https://docs.aws.amazon.com/sdk-for-rust) | [AWS SDK for Rust コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1) | 
| [AWS SDK for SAP ABAP](https://docs.aws.amazon.com/sdk-for-sapabap) | [AWS SDK for SAP ABAP コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap) | 
| [AWS SDK for Swift](https://docs.aws.amazon.com/sdk-for-swift) | [AWS SDK for Swift コードの例](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) | 

**可用性の例**  
必要なものが見つからなかった場合。このページの下側にある [**Provide feedback (フィードバックを送信)**] リンクから、コードの例をリクエストしてください。