

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan APIs dengan Amazon SQS
<a name="sqs-working-with-apis"></a>

Topik ini memberikan informasi tentang membangun endpoint Amazon SQS, membuat permintaan API kueri menggunakan metode GET dan POST, dan menggunakan tindakan API batch. Untuk informasi terperinci tentang [tindakan](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) Amazon SQS —termasuk parameter, kesalahan, contoh, dan [tipe data](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Types.html), lihat Referensi API Layanan [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/).

Untuk mengakses Amazon SQS menggunakan berbagai bahasa pemrograman, Anda juga dapat menggunakan [AWS SDKs](https://aws.amazon.com/tools/#sdk), yang berisi fungsionalitas otomatis berikut:
+ Secara kriptografi menandatangani permintaan layanan Anda
+ Mencoba kembali permintaan
+ Menangani respons kesalahan

Untuk informasi selengkapnya, lihat [Menggunakan Amazon SQS dengan SDK AWS](sdk-general-information-section.md).

Untuk informasi alat baris perintah, lihat bagian Amazon SQS di Referensi [https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html](https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html) [https://docs.aws.amazon.com/powershell/latest/reference/](https://docs.aws.amazon.com/powershell/latest/reference/).

**Amazon SQS APIs dengan protokol JSON AWS **

[Amazon SQS menggunakan protokol AWS JSON sebagai mekanisme transportasi untuk semua Amazon SQS APIs pada versi SDK yang ditentukan.AWS](sqs-json-faqs.md#json-protocol-getting-started) AWS Protokol JSON menyediakan throughput yang lebih tinggi, latensi yang lebih rendah, dan komunikasi yang lebih cepat. application-to-application AWS Protokol JSON lebih efisien dalam serialization/deserialization permintaan dan tanggapan jika dibandingkan dengan protokol AWS kueri. Jika Anda masih lebih suka menggunakan protokol AWS kueri dengan SQS APIs, lihat [Bahasa apa yang didukung untuk protokol AWS JSON yang digunakan di Amazon APIs SQS?](sqs-json-faqs.md#json-protocol-supported-languages) versi AWS SDK yang mendukung protokol kueri Amazon AWS SQS.

Amazon SQS menggunakan protokol AWS JSON untuk berkomunikasi antara klien AWS SDK (misalnya, Java, Python, Golang,) dan JavaScript server Amazon SQS. Permintaan HTTP dari operasi Amazon SQS API menerima input berformat JSON. Operasi Amazon SQS dijalankan, dan respons eksekusi dikirim kembali ke klien SDK dalam format JSON. Dibandingkan dengan AWS query, AWS JSON lebih sederhana, lebih cepat, dan lebih efisien untuk mengangkut data antara klien dan server.
+ AWS Protokol JSON bertindak sebagai mediator antara klien dan server Amazon SQS.
+ Server tidak memahami bahasa pemrograman di mana operasi Amazon SQS dibuat, tetapi memahami protokol AWS JSON.
+ Protokol AWS JSON menggunakan serialisasi (konversi objek ke format JSON) dan de-serialisasi (konversi format JSON ke objek) antara klien Amazon SQS dan server.

Untuk informasi selengkapnya tentang protokol AWS JSON dengan Amazon SQS, lihat. [Protokol JSON Amazon SQS AWS FAQs](sqs-json-faqs.md)

AWS Protokol JSON tersedia pada versi [AWS SDK](sqs-json-faqs.md#json-protocol-getting-started) yang ditentukan. Untuk meninjau versi SDK dan tanggal rilis di seluruh varian bahasa, lihat [matriks dukungan versi AWS SDKs dan Alat](https://docs.aws.amazon.com/sdkref/latest/guide/version-support-matrix.html) di Panduan *Referensi Alat AWS SDKs dan*

# Membuat permintaan API kueri menggunakan protokol AWS JSON di Amazon SQS
<a name="sqs-making-api-requests-json"></a>

Topik ini menjelaskan cara membuat endpoint Amazon SQS, membuat permintaan POST, dan menafsirkan tanggapan.

**catatan**  
AWS Protokol JSON didukung untuk sebagian besar varian bahasa. Untuk daftar lengkap varian bahasa yang didukung, lihat[Bahasa apa yang didukung untuk protokol AWS JSON yang digunakan di Amazon APIs SQS?](sqs-json-faqs.md#json-protocol-supported-languages).

## Membangun titik akhir
<a name="sqs-api-constructing-endpoints-json"></a>

Untuk bekerja dengan antrian Amazon SQS, Anda harus membuat titik akhir. Untuk informasi tentang titik akhir Amazon SQS, lihat halaman berikut di: *Referensi Umum Amazon Web*
+ [Titik akhir regional](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)
+ [Titik akhir dan kuota Layanan Antrian Sederhana Amazon](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Setiap titik akhir Amazon SQS bersifat independen. Misalnya, jika dua antrian diberi nama *MyQueue*dan satu memiliki titik akhir `sqs.us-east-2.amazonaws.com` sementara yang lain memiliki titik akhir`sqs.eu-west-2.amazonaws.com`, kedua antrian tidak berbagi data apa pun satu sama lain.

Berikut ini adalah contoh dari endpoint yang membuat permintaan untuk membuat antrian. 

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

**catatan**  
Nama antrian dan antrian peka huruf URLs besar/kecil.  
Struktur *`AUTHPARAMS`* tergantung pada tanda tangan permintaan API. Untuk informasi selengkapnya, lihat [Menandatangani Permintaan AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) di *Referensi Umum Amazon Web Services*.

## Membuat permintaan POST
<a name="structure-post-request"></a>

Permintaan Amazon SQS POST mengirimkan parameter kueri sebagai formulir di badan permintaan HTTP.

Berikut ini adalah contoh dari header HTTP dengan `X-Amz-Target` set ke`AmazonSQS.<operationName>`, dan header HTTP dengan `Content-Type` set ke`application/x-amz-json-1.0`.

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

Permintaan HTTP POST ini mengirimkan pesan ke antrian Amazon SQS.

**catatan**  
Baik header HTTP `X-Amz-Target` dan `Content-Type` diperlukan.  
Klien HTTP Anda mungkin menambahkan item lain ke permintaan HTTP, sesuai dengan versi HTTP klien.

# Menafsirkan tanggapan Amazon SQS JSON API
<a name="sqs-json-api-responses"></a>

Saat Anda mengirim permintaan ke Amazon SQS, ia mengembalikan respons JSON dengan hasilnya. Struktur respons bergantung pada tindakan API yang Anda gunakan.

Untuk memahami detail tanggapan ini, lihat:
+ Tindakan API spesifik dalam [tindakan API di Referensi](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) *API Layanan Antrian Sederhana Amazon*
+ Sebuah [Protokol JSON Amazon SQS AWS FAQs](sqs-json-faqs.md)

## Struktur respons JSON yang sukses
<a name="sqs-json-api-successful-response-structure"></a>

Jika permintaan berhasil, elemen respons utama adalah`x-amzn-RequestId`, yang berisi Universal Unique Identifier (UUID) permintaan, serta bidang respons tambahan lainnya. Misalnya, [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html)respons berikut berisi `QueueUrl` bidang, yang, pada gilirannya, berisi URL antrian yang dibuat.

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

## Struktur respons kesalahan JSON
<a name="sqs-api-error-response-structure"></a>

Jika permintaan tidak berhasil, Amazon SQS mengembalikan respons utama, termasuk header HTTP dan isi.

Di header HTTP, `x-amzn-RequestId` berisi UUID permintaan. `x-amzn-query-error`berisi dua informasi: jenis kesalahan, dan apakah kesalahan itu adalah kesalahan produsen atau konsumen. 

Di badan respons, `"__type"` menunjukkan detail kesalahan lainnya, dan `Message` menunjukkan kondisi kesalahan dalam format yang dapat dibaca. 

Berikut ini adalah contoh respon kesalahan dalam format 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."
}
```

# Protokol JSON Amazon SQS AWS FAQs
<a name="sqs-json-faqs"></a>

Topik ini mencakup pertanyaan umum tentang penggunaan protokol AWS JSON dengan Amazon SQS.

## Apa itu protokol AWS JSON, dan apa bedanya dengan permintaan dan tanggapan Amazon SQS API yang ada?
<a name="json-protocol-what-is"></a>

JSON adalah salah satu metode pengkabelan yang paling banyak digunakan dan diterima untuk komunikasi antara sistem heterogen. Amazon SQS menggunakan JSON sebagai media untuk berkomunikasi antara klien AWS SDK (misalnya, Java, Python, Golang,) JavaScript dan server Amazon SQS. Permintaan HTTP dari operasi Amazon SQS API menerima masukan dalam bentuk JSON. Operasi Amazon SQS dijalankan dan respons eksekusi dibagikan kembali ke klien SDK dalam bentuk JSON. Dibandingkan dengan AWS query, JSON lebih efisien dalam mengangkut data antara klien dan server. 
+ Protokol Amazon SQS AWS JSON bertindak sebagai mediator antara klien dan server Amazon SQS.
+ Server tidak memahami bahasa pemrograman di mana operasi Amazon SQS dibuat, tetapi memahami protokol AWS JSON.
+ Protokol Amazon SQS AWS JSON menggunakan serialisasi (konversi objek ke format JSON) dan deserialisasi (konversi format JSON ke objek) antara klien Amazon SQS dan server.

## Bagaimana cara memulai protokol AWS JSON untuk Amazon SQS?
<a name="json-protocol-getting-started"></a>

Untuk memulai dengan versi AWS SDK terbaru untuk mencapai pengiriman pesan yang lebih cepat untuk Amazon SQS, tingkatkan SDK AWS Anda ke versi yang ditentukan atau versi berikutnya. Untuk mempelajari lebih lanjut tentang klien SDK, lihat kolom Panduan pada tabel di bawah ini.

Berikut ini adalah daftar versi SDK di seluruh varian bahasa untuk protokol AWS JSON untuk digunakan dengan Amazon SQS: APIs


| Bahasa | Repositori klien SDK | Versi klien SDK yang diperlukan | Panduan | 
| --- | --- | --- | --- | 
|  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/ 2 aws-sdk-go-v](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/ 2 aws-sdk-java-v](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 pada AWS](https://aws.amazon.com/developer/language/javascript/)  | 
|  JavaScript v3.x  |  [aws/ 3 aws-sdk-js-v](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 pada 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 untuk 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 untuk 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 Antarmuka Baris Perintah](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/)  | 

## Apa risiko mengaktifkan protokol JSON untuk beban kerja Amazon SQS saya?
<a name="json-protocol-risks"></a>

Jika Anda menggunakan implementasi khusus AWS SDK atau kombinasi klien kustom dan AWS SDK untuk berinteraksi dengan Amazon SQS yang AWS menghasilkan respons berbasis Kueri (alias berbasis XML), mungkin tidak kompatibel dengan protokol JSON. AWS Jika Anda mengalami masalah, hubungi AWS Support.

## Bagaimana jika saya sudah menggunakan versi AWS SDK terbaru, tetapi solusi open source saya tidak mendukung JSON?
<a name="json-protocol-sdk-version-open-source"></a>

Anda harus mengubah versi SDK Anda ke versi sebelumnya yang Anda gunakan. Lihat [Bagaimana cara memulai protokol AWS JSON untuk Amazon SQS?](#json-protocol-getting-started) untuk informasi lebih lanjut. AWS Versi SDK yang tercantum dalam [Bagaimana cara memulai protokol AWS JSON untuk Amazon SQS?](#json-protocol-getting-started) menggunakan protokol kawat JSON untuk Amazon SQS. APIs Jika Anda mengubah AWS SDK ke versi sebelumnya, Amazon APIs SQS Anda akan menggunakan AWS kueri.

## Bahasa apa yang didukung untuk protokol AWS JSON yang digunakan di Amazon APIs SQS?
<a name="json-protocol-supported-languages"></a>

Amazon SQS mendukung semua varian bahasa yang umumnya AWS SDKs tersedia (GA). Saat ini, kami tidak mendukung Kotlin, Rust, atau Swift. Untuk mempelajari lebih lanjut tentang varian bahasa lain, lihat [Alat untuk Dibangun AWS](https://aws.amazon.com/developer/tools/).

## Wilayah apa yang didukung untuk protokol AWS JSON yang digunakan di Amazon SQS APIs
<a name="json-protocol-supported-regions"></a>

Amazon SQS mendukung protokol AWS JSON di semua [AWS wilayah](https://docs.aws.amazon.com/general/latest/gr/sqs-service.html) tempat Amazon SQS tersedia. 

## Peningkatan latensi apa yang dapat saya harapkan saat memutakhirkan ke versi AWS SDK yang ditentukan untuk Amazon SQS menggunakan protokol JSON? AWS
<a name="json-protocol-upgrading-sdk"></a>

AWS Protokol JSON lebih efisien dalam serialisasi dan deserialisasi permintaan dan tanggapan jika dibandingkan dengan protokol kueri. AWS Berdasarkan pengujian AWS kinerja untuk muatan pesan 5 KB, protokol JSON untuk Amazon SQS end-to-end mengurangi latensi pemrosesan pesan hingga 23%, dan mengurangi penggunaan CPU dan memori sisi klien aplikasi. 

## Apakah protokol AWS kueri akan tidak digunakan lagi?
<a name="query-protocol"></a>

AWS protokol kueri akan terus didukung. Anda dapat terus menggunakan protokol AWS kueri selama versi AWS SDK Anda disetel versi sebelumnya selain yang tercantum di [Bagaimana cara memulai dengan protokol AWS JSON untuk Amazon](#json-protocol-getting-started) SQS.

## Di mana saya dapat menemukan informasi lebih lanjut tentang protokol AWS JSON?
<a name="json-protocol-more-info"></a>

Anda dapat menemukan informasi lebih lanjut tentang protokol JSON di protokol [AWS JSON 1.0 di dokumentasi](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html) *Smithy*. Untuk selengkapnya tentang permintaan Amazon SQS API menggunakan protokol AWS JSON, lihat. [Membuat permintaan API kueri menggunakan protokol AWS JSON di Amazon SQS](sqs-making-api-requests-json.md)

# Membuat permintaan API kueri menggunakan protokol AWS kueri di Amazon SQS
<a name="sqs-making-api-requests-xml"></a>

Topik ini menjelaskan cara membuat endpoint Amazon SQS, membuat permintaan GET dan POST, dan menafsirkan tanggapan.

## Membangun titik akhir
<a name="sqs-api-constructing-endpoints"></a>

Agar dapat bekerja dengan antrian Amazon SQS, Anda harus membuat titik akhir. Untuk informasi tentang titik akhir Amazon SQS, lihat halaman berikut di: *Referensi Umum Amazon Web*
+ [Titik akhir regional](https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region)
+ [Titik akhir dan kuota Layanan Antrian Sederhana Amazon](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Setiap titik akhir Amazon SQS bersifat independen. Misalnya, jika dua antrian diberi nama *MyQueue*dan satu memiliki titik akhir `sqs.us-east-2.amazonaws.com` sementara yang lain memiliki titik akhir`sqs.eu-west-2.amazonaws.com`, kedua antrian tidak berbagi data apa pun satu sama lain.

Berikut ini adalah contoh dari endpoint yang membuat permintaan untuk membuat antrian. 

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

**catatan**  
Nama antrian dan antrian peka huruf URLs besar/kecil.  
Struktur *`AUTHPARAMS`* tergantung pada tanda tangan permintaan API. Untuk informasi selengkapnya, lihat [Menandatangani Permintaan AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) di *Referensi Umum Amazon Web Services*.

## Membuat permintaan GET
<a name="structure-get-request"></a>

Permintaan Amazon SQS GET disusun sebagai URL yang terdiri dari berikut ini:
+ **Endpoint** — Sumber daya tempat permintaan bertindak ([nama antrian dan URL](sqs-queue-message-identifiers.md#queue-name-url)), misalnya: `https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue`
+ **Tindakan** — [Tindakan](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) yang ingin Anda lakukan di titik akhir. Tanda tanya (`?`) memisahkan titik akhir dari tindakan, misalnya: `?Action=SendMessage&MessageBody=Your%20Message%20Text`
+ **Parameter — Parameter** permintaan apa pun. Setiap parameter dipisahkan oleh ampersand (`&`), misalnya: `&Version=2012-11-05&AUTHPARAMS` 

Berikut ini adalah contoh permintaan GET yang mengirim pesan ke antrian Amazon SQS.

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

**catatan**  
Nama antrian dan antrian peka huruf URLs besar/kecil.  
Karena permintaan GET adalah URLs, Anda harus mengkodekan URL semua nilai parameter. Karena spasi tidak diizinkan masuk URLs, setiap spasi dikodekan URL sebagai. `%20` Contoh lainnya tidak dikodekan URL untuk membuatnya lebih mudah dibaca.

## Membuat permintaan POST
<a name="structure-post-request"></a>

Permintaan Amazon SQS POST mengirimkan parameter kueri sebagai formulir di badan permintaan HTTP.

Berikut ini adalah contoh header HTTP dengan `Content-Type` set ke`application/x-www-form-urlencoded`.

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

Header diikuti oleh permintaan `[form-urlencoded](https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2)` GET yang mengirim pesan ke antrian Amazon SQS. Setiap parameter dipisahkan oleh ampersand ()`&`.

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

**catatan**  
Hanya header `Content-Type` HTTP yang diperlukan. Sama seperti untuk permintaan GET. `AUTHPARAMS`  
Klien HTTP Anda mungkin menambahkan item lain ke permintaan HTTP, sesuai dengan versi HTTP klien.

# Menafsirkan tanggapan Amazon SQS XMLAPI
<a name="sqs-xml-api-responses"></a>

Saat Anda mengirim permintaan ke Amazon SQS, permintaan tersebut akan mengembalikan respons XMLyang berisi hasil permintaan. Untuk memahami struktur dan detail tanggapan ini, lihat [tindakan API tertentu di Referensi API](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) *Layanan Antrian Sederhana Amazon*.

## Struktur respons XHTML yang sukses
<a name="sqs-api-successful-response-structure"></a>

Jika permintaan berhasil, elemen respons utama dinamai setelah tindakan, dengan `Response` ditambahkan (misalnya,`ActionNameResponse`).

Elemen ini berisi elemen turunan berikut:
+ **`ActionNameResult`**— Berisi elemen khusus tindakan. Misalnya, `CreateQueueResult` elemen berisi `QueueUrl` elemen yang, pada gilirannya, berisi URL antrian yang dibuat.
+ **`ResponseMetadata`**— Berisi `RequestId` yang, pada gilirannya, berisi Universal Unique Identifier (UUID) dari permintaan.

Berikut ini adalah contoh respon sukses dalam format 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>
```

## Struktur respon kesalahan XML
<a name="sqs-api-error-response-structure"></a>

Jika permintaan tidak berhasil, Amazon SQS selalu mengembalikan elemen respons utama. `ErrorResponse` Elemen ini berisi elemen `Error` dan elemen `RequestId`.

`Error`Elemen berisi elemen anak berikut:
+ **`Type`**- Menentukan apakah kesalahan adalah produsen atau kesalahan konsumen.
+ **`Code`**- Menentukan jenis kesalahan.
+ **`Message`**- Menentukan kondisi kesalahan dalam format yang dapat dibaca.
+ **`Detail`**- (Opsional) Menentukan rincian tambahan tentang kesalahan.

`RequestId`Elemen berisi UUID permintaan.

Berikut ini adalah contoh respon kesalahan dalam format 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>
```

# Mengautentikasi permintaan untuk Amazon SQS
<a name="sqs-api-request-authentication"></a>

Otentikasi adalah proses mengidentifikasi dan memverifikasi pihak yang mengirim permintaan. Selama tahap pertama otentikasi, AWS verifikasi identitas produsen dan apakah produsen [terdaftar untuk digunakan AWS(untuk](https://aws.amazon.com/) informasi lebih lanjut, lihat[Langkah 1: Buat pengguna Akun AWS dan IAM](sqs-setting-up.md#sqs-creating-aws-account)). Selanjutnya, AWS patuhi prosedur berikut:

1. Produser (pengirim) memperoleh kredensi yang diperlukan.

1. Produser mengirimkan permintaan dan kredensi kepada konsumen (penerima).

1. Konsumen menggunakan kredensi untuk memverifikasi apakah produsen mengirim permintaan.

1. Salah satu hal berikut terjadi:
   + Jika otentikasi berhasil, konsumen memproses permintaan.
   + Jika otentikasi gagal, konsumen menolak permintaan dan mengembalikan kesalahan.

## Proses otentikasi dasar dengan HMAC-SHA
<a name="sqs-api-basic-authentication-process"></a>

Saat mengakses Amazon SQS menggunakan Query API, Anda harus memberikan item berikut untuk mengautentikasi permintaan Anda:
+ **ID Kunci AWS Akses** yang mengidentifikasi Anda Akun AWS, yang AWS digunakan untuk mencari Kunci Akses Rahasia Anda.
+ **Tanda tangan permintaan HMAC-SHA**, dihitung menggunakan Kunci Akses Rahasia Anda (rahasia bersama yang hanya diketahui oleh Anda dan AWS—untuk informasi lebih lanjut, lihat). [RFC2104](http://www.faqs.org/rfcs/rfc2104.html) [AWS SDK](https://aws.amazon.com/code/) menangani proses penandatanganan; namun, jika Anda mengirimkan permintaan kueri melalui HTTP atau HTTPS, Anda harus menyertakan tanda tangan di setiap permintaan kueri.

  1. Dapatkan Kunci Penandatanganan Versi Tanda Tangan 4. Untuk informasi selengkapnya, lihat [Menurunkan Kunci Penandatanganan dengan Java](https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java).
**catatan**  
Amazon SQS mendukung Signature Version 4, yang menyediakan peningkatan keamanan SHA256 berbasis dan kinerja dibandingkan versi sebelumnya. Saat Anda membuat aplikasi baru yang menggunakan Amazon SQS, gunakan Signature Version 4.

  1. Base64-encode tanda tangan permintaan. Contoh kode Java berikut melakukan ini:

     ```
     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);
         }
     }
     ```
+ **Stempel waktu (atau kedaluwarsa) permintaan**. Stempel waktu yang Anda gunakan dalam permintaan harus berupa `dateTime` objek, dengan [tanggal lengkap, termasuk jam, menit, dan detik](http://www.w3.org/TR/xmlschema-2/#dateTime). Misalnya: `2007-01-31T23:59:59Z` Meskipun ini tidak diperlukan, kami sarankan untuk menyediakan objek menggunakan zona waktu Waktu Universal Terkoordinasi (Greenwich Mean Time).
**catatan**  
Pastikan waktu server Anda diatur dengan benar. Jika Anda menentukan stempel waktu (bukan kedaluwarsa), permintaan secara otomatis akan kedaluwarsa 15 menit setelah waktu yang ditentukan (AWS tidak memproses permintaan dengan stempel waktu lebih dari 15 menit lebih awal dari waktu saat ini di server). AWS   
Jika Anda menggunakan .NET, Anda tidak boleh mengirim stempel waktu yang terlalu spesifik (karena interpretasi yang berbeda tentang bagaimana presisi waktu ekstra harus dihapus). Dalam hal ini, Anda harus secara manual membangun `dateTime` objek dengan presisi tidak lebih dari satu milidetik.

## Bagian 1: Permintaan dari pengguna
<a name="sqs-authentication-user"></a>

Berikut ini adalah proses yang harus Anda ikuti untuk mengautentikasi AWS permintaan menggunakan tanda tangan permintaan HMAC-SHA.

![\[Diagram yang menjelaskan permintaan dari pengguna.\]](http://docs.aws.amazon.com/id_id/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-user.png)


1. Membangun permintaan untuk AWS. 

1. Hitung tanda tangan kode otentikasi pesan hash kunci (HMAC-SHA) menggunakan Kunci Akses Rahasia Anda.

1. Sertakan tanda tangan dan ID Kunci Akses Anda dalam permintaan, lalu kirim permintaan ke AWS.

## Bagian 2: Tanggapan dari AWS
<a name="sqs-authentication-aws"></a>

AWS memulai proses berikut sebagai tanggapan.

![\[Diagram yang menggambarkan respons dari AWS.\]](http://docs.aws.amazon.com/id_id/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-aws.png)


1. AWS menggunakan ID Kunci Akses untuk mencari Kunci Akses Rahasia Anda.

1. AWS menghasilkan tanda tangan dari data permintaan dan Kunci Akses Rahasia, menggunakan algoritma yang sama yang Anda gunakan untuk menghitung tanda tangan yang Anda kirim dalam permintaan.

1. Salah satu hal berikut terjadi:
   + Jika tanda tangan yang AWS dihasilkan cocok dengan yang Anda kirim dalam permintaan, AWS anggap permintaan tersebut asli.
   + Jika perbandingan gagal, permintaan dibuang, dan AWS mengembalikan kesalahan. 

# Tindakan batch Amazon SQS
<a name="sqs-batch-api-actions"></a>

Amazon SQS menyediakan tindakan batch untuk membantu Anda mengurangi biaya dan memanipulasi hingga 10 pesan dengan satu tindakan. Tindakan batch ini meliputi:
+ `[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)`

Dengan menggunakan tindakan batch, Anda dapat melakukan beberapa operasi dalam satu panggilan API, yang membantu mengoptimalkan kinerja dan mengurangi biaya. Anda dapat memanfaatkan fungsionalitas batch menggunakan API kueri atau AWS SDK apa pun yang mendukung tindakan batch Amazon SQS.

**Detail Penting**
+ **Batas Ukuran Pesan:** Ukuran total semua pesan yang dikirim dalam satu `SendMessageBatch` panggilan tidak boleh melebihi 1.048.576 byte (1 MiB)
+ **Izin:** Anda tidak dapat menetapkan izin secara eksplisit untuk`SendMessageBatch`,, atau. `DeleteMessageBatch` `ChangeMessageVisibilityBatch` Sebagai gantinya, menyetel izin untuk `SendMessage``DeleteMessage`,, atau `ChangeMessageVisibility` menetapkan izin untuk versi batch tindakan yang sesuai.
+ **Dukungan Konsol:** Konsol Amazon SQS tidak mendukung tindakan batch. Anda harus menggunakan API kueri atau AWS SDK untuk melakukan operasi batch.

## Tindakan pesan batching
<a name="batching-message-actions"></a>

Untuk lebih mengoptimalkan biaya dan efisiensi, pertimbangkan praktik terbaik berikut untuk tindakan pengelompokan pesan:
+ **Tindakan API Batch:** Gunakan tindakan [tindakan API batch Amazon SQS](#sqs-batch-api-actions) untuk mengirim, menerima, dan menghapus pesan, serta mengubah batas waktu visibilitas pesan untuk beberapa pesan dengan satu tindakan. Ini mengurangi jumlah panggilan API dan biaya terkait.
+ **Buffering Sisi Klien dan Polling Panjang:** [Gabungkan buffering sisi klien dengan batch permintaan dengan menggunakan polling panjang bersama dengan klien asinkron buffer yang disertakan dengan.](sqs-client-side-buffering-request-batching.md) AWS SDK untuk Java Pendekatan ini membantu meminimalkan jumlah permintaan dan mengoptimalkan penanganan pesan dalam jumlah besar.

**catatan**  
Klien Asinkron Buffered Amazon SQS saat ini tidak mendukung antrian FIFO.

# Mengaktifkan buffering sisi klien dan batching permintaan dengan Amazon SQS
<a name="sqs-client-side-buffering-request-batching"></a>

[AWS SDK untuk Java](https://aws.amazon.com/sdkforjava/)Termasuk `AmazonSQSBufferedAsyncClient` yang mengakses Amazon SQS. Klien ini memungkinkan batching permintaan sederhana menggunakan buffering sisi klien. Panggilan yang dilakukan dari klien pertama kali di-buffer dan kemudian dikirim sebagai permintaan batch ke Amazon SQS.

Buffering sisi klien memungkinkan hingga 10 permintaan untuk di-buffer dan dikirim sebagai permintaan batch, mengurangi biaya penggunaan Amazon SQS dan mengurangi jumlah permintaan yang dikirim. `AmazonSQSBufferedAsyncClient`buffer panggilan sinkron dan asinkron. Permintaan batch dan dukungan untuk [polling panjang](sqs-short-and-long-polling.md) juga dapat membantu meningkatkan throughput. Untuk informasi selengkapnya, lihat [Meningkatkan throughput menggunakan penskalaan horizontal dan batching aksi dengan Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).

Karena `AmazonSQSBufferedAsyncClient` mengimplementasikan antarmuka yang sama seperti`AmazonSQSAsyncClient`, migrasi dari `AmazonSQSAsyncClient` ke `AmazonSQSBufferedAsyncClient` biasanya hanya memerlukan sedikit perubahan pada kode Anda yang ada.

**catatan**  
Klien Asinkron Buffered Amazon SQS saat ini tidak mendukung antrian FIFO.

## Menggunakan Amazon SQSBuffered AsyncClient
<a name="using-buffered-async-client"></a>

Sebelum memulai, selesaikan langkah-langkah di [Menyiapkan Amazon SQS](sqs-setting-up.md). 

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

Untuk AWS SDK for Java 1.x, Anda dapat membuat yang `AmazonSQSBufferedAsyncClient` baru berdasarkan contoh berikut:

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

Setelah Anda membuat yang baru`AmazonSQSBufferedAsyncClient`, Anda dapat menggunakannya untuk mengirim beberapa permintaan ke Amazon SQS (seperti yang Anda bisa dengan`AmazonSQSAsyncClient`), misalnya:

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

### Mengkonfigurasi Amazon SQSBuffered AsyncClient
<a name="configuring-buffered-async-client"></a>

`AmazonSQSBufferedAsyncClient`telah dikonfigurasi sebelumnya dengan pengaturan yang berfungsi untuk sebagian besar kasus penggunaan. Anda dapat mengkonfigurasi lebih lanjut`AmazonSQSBufferedAsyncClient`, misalnya:

1. Buat instance `QueueBufferConfig` kelas dengan parameter konfigurasi yang diperlukan.

1. Berikan instance ke `AmazonSQSBufferedAsyncClient` konstruktor.

```
// 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 parameter konfigurasi**  

| Parameter | Nilai default | Deskripsi | 
| --- | --- | --- | 
| longPoll | true |  Ketika `longPoll` diatur ke`true`, `AmazonSQSBufferedAsyncClient` mencoba untuk menggunakan polling panjang ketika mengkonsumsi pesan.  | 
| longPollWaitTimeoutSeconds | 20 s |  Jumlah waktu maksimum (dalam detik) yang diblokir `ReceiveMessage` panggilan di server, menunggu pesan muncul dalam antrian sebelum kembali dengan hasil penerimaan kosong.  Ketika polling panjang dinonaktifkan, pengaturan ini tidak berpengaruh.   | 
| maxBatchOpenMs | 200 ms |  Jumlah waktu maksimum (dalam milidetik) panggilan keluar menunggu panggilan lain yang dengannya ia mengumpulkan pesan dari jenis yang sama. Semakin tinggi pengaturan, semakin sedikit batch yang diperlukan untuk melakukan jumlah pekerjaan yang sama (namun, panggilan pertama dalam batch harus menghabiskan waktu lebih lama menunggu). Saat Anda menyetel parameter ini`0`, permintaan yang dikirimkan tidak menunggu permintaan lain, yang secara efektif menonaktifkan batching.  | 
| maxBatchSize | 10 permintaan per batch |  Jumlah maksimum pesan yang dikumpulkan bersama dalam satu permintaan. Semakin tinggi pengaturan, semakin sedikit batch yang diperlukan untuk melakukan jumlah permintaan yang sama.  10 permintaan per batch adalah nilai maksimum yang diizinkan untuk Amazon SQS.   | 
| maxBatchSizeBytes | 1 MiB |  Ukuran maksimum kumpulan pesan, dalam byte, yang coba dikirim klien ke Amazon SQS.  1 MiB adalah nilai maksimum yang diizinkan untuk Amazon SQS.   | 
| maxDoneReceiveBatches | 10 batch |  Jumlah maksimum batch penerima yang `AmazonSQSBufferedAsyncClient` mengambil dan menyimpan sisi klien. Semakin tinggi pengaturan, semakin banyak permintaan penerimaan yang dapat dipenuhi tanpa harus melakukan panggilan ke Amazon SQS (namun, semakin banyak pesan yang diambil sebelumnya, semakin lama mereka tetap berada di buffer, menyebabkan batas waktu visibilitas mereka sendiri kedaluwarsa).  `0`menunjukkan bahwa semua pesan pra-pengambilan dinonaktifkan dan pesan hanya dikonsumsi sesuai permintaan.   | 
| maxInflightOutboundBatches | 5 batch |  Jumlah maksimum batch keluar aktif yang dapat diproses secara bersamaan. Semakin tinggi pengaturan, batch keluar yang lebih cepat dapat dikirim (tunduk pada kuota seperti CPU atau bandwidth) dan semakin banyak thread yang dikonsumsi oleh. `AmazonSQSBufferedAsyncClient`  | 
| maxInflightReceiveBatches | 10 batch |  Jumlah maksimum batch penerima aktif yang dapat diproses pada saat yang bersamaan. Semakin tinggi pengaturan, semakin banyak pesan yang dapat diterima (tunduk pada kuota seperti CPU atau bandwidth), dan semakin banyak utas yang dikonsumsi`AmazonSQSBufferedAsyncClient`.  `0`menunjukkan bahwa semua pesan pra-pengambilan dinonaktifkan dan pesan hanya dikonsumsi sesuai permintaan.   | 
| visibilityTimeoutSeconds | -1 |  Ketika parameter ini disetel ke nilai positif, bukan nol, batas waktu visibilitas yang ditetapkan di sini akan mengganti batas waktu visibilitas yang ditetapkan pada antrian dari mana pesan dikonsumsi.  `-1`menunjukkan bahwa pengaturan default dipilih untuk antrian. Anda tidak dapat mengatur batas waktu visibilitas ke. `0`   | 

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

Untuk AWS SDK for Java 2.x, Anda dapat membuat yang `SqsAsyncBatchManager` baru berdasarkan contoh berikut:

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

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

Setelah Anda membuat yang baru`SqsAsyncBatchManager`, Anda dapat menggunakannya untuk mengirim beberapa permintaan ke Amazon SQS (seperti yang Anda bisa dengan`SqsAsyncClient`), misalnya:

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

### Mengkonfigurasi SqsAsyncBatchManager
<a name="configuring-SqsAsyncBatchManager"></a>

`SqsAsyncBatchManager`telah dikonfigurasi sebelumnya dengan pengaturan yang berfungsi untuk sebagian besar kasus penggunaan. Anda dapat mengkonfigurasi lebih lanjut`SqsAsyncBatchManager`, misalnya:

Membuat konfigurasi khusus melalui`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();
```


**Parameter `BatchOverrideConfiguration`**  

| Parameter | Nilai default | Deskripsi | 
| --- | --- | --- | 
| maxBatchSize |  10 permintaan per batch  | Jumlah maksimum pesan yang dikumpulkan bersama dalam satu permintaan. Semakin tinggi pengaturan, semakin sedikit batch yang diperlukan untuk melakukan jumlah permintaan yang sama.  Nilai maksimum yang diizinkan untuk Amazon SQS adalah 10 permintaan per batch.  | 
| sendRequestFrequency |  200 ms  | Jumlah waktu maksimum (dalam milidetik) panggilan keluar menunggu panggilan lain yang dengannya ia mengumpulkan pesan dari jenis yang sama. Semakin tinggi pengaturan, semakin sedikit batch yang diperlukan untuk melakukan jumlah pekerjaan yang sama (namun, panggilan pertama dalam batch harus menghabiskan waktu lebih lama menunggu). Saat Anda menyetel parameter ini`0`, permintaan yang dikirimkan tidak menunggu permintaan lain, yang secara efektif menonaktifkan batching. | 
| receiveMessageVisibilityTimeout |  -1  | Ketika parameter ini disetel ke nilai positif, bukan nol, batas waktu visibilitas yang ditetapkan di sini akan mengganti batas waktu visibilitas yang ditetapkan pada antrian dari mana pesan dikonsumsi.   `1`menunjukkan bahwa pengaturan default dipilih untuk antrian. Anda tidak dapat mengatur batas waktu visibilitas ke. `0`   | 
| receiveMessageMinWaitDuration |  50 ms  | Jumlah waktu minimal (dalam milidetik) `receiveMessage` panggilan menunggu pesan yang tersedia diambil. Semakin tinggi pengaturan, semakin sedikit batch yang diperlukan untuk melakukan jumlah permintaan yang sama.  | 

# Meningkatkan throughput menggunakan penskalaan horizontal dan batching aksi dengan Amazon SQS
<a name="sqs-throughput-horizontal-scaling-and-batching"></a>

Amazon SQS mendukung perpesanan throughput tinggi. Untuk detail tentang batas throughput, lihat. [Kuota pesan Amazon SQS](quotas-messages.md)

Untuk memaksimalkan throughput:
+ [Skalakan](#horizontal-scaling) produsen dan konsumen secara horizontal dengan menambahkan lebih banyak contoh masing-masing.
+ Gunakan [batch tindakan](#request-batching) untuk mengirim atau menerima beberapa pesan dalam satu permintaan, sehingga mengurangi overhead panggilan API.

## Penskalaan horizontal
<a name="horizontal-scaling"></a>

Karena Anda mengakses Amazon SQS melalui protokol permintaan-respons HTTP, *latensi permintaan* (interval antara memulai permintaan dan menerima respons) membatasi throughput yang dapat Anda capai dari satu utas menggunakan satu koneksi. Misalnya, jika latensi dari klien berbasis Amazon EC2 ke Amazon SQS di wilayah yang sama rata-rata 20 ms, throughput maksimum dari satu utas melalui satu koneksi rata-rata 50 TPS. 

*Penskalaan horizontal* melibatkan peningkatan jumlah produsen pesan (yang membuat `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` permintaan) dan konsumen (yang membuat `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` dan `[DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)` meminta) untuk meningkatkan throughput antrian Anda secara keseluruhan. Anda dapat menskalakan secara horizontal dengan tiga cara:
+ Meningkatkan jumlah thread per klien
+ Tambahkan lebih banyak klien
+ Tingkatkan jumlah thread per klien dan tambahkan lebih banyak klien

Ketika Anda menambahkan lebih banyak klien, Anda mencapai keuntungan linier pada dasarnya dalam throughput antrian. Misalnya, jika Anda menggandakan jumlah klien, Anda juga menggandakan throughput. 

## Aksi batching
<a name="request-batching"></a>

*Batching* melakukan lebih banyak pekerjaan selama setiap perjalanan pulang pergi ke layanan (misalnya, ketika Anda mengirim beberapa pesan dengan satu `SendMessageBatch` permintaan). Tindakan batch Amazon SQS adalah`[SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)`,`[DeleteMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html)`, dan. `[ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)` Untuk memanfaatkan batching tanpa mengubah produsen atau konsumen, Anda dapat menggunakan [Amazon SQS Buffered](sqs-client-side-buffering-request-batching.md) Asynchronous Client.

**catatan**  
Karena `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` dapat memproses 10 pesan sekaligus, tidak ada `ReceiveMessageBatch` tindakan.

Batching mendistribusikan latensi tindakan batch melalui beberapa pesan dalam permintaan batch, daripada menerima seluruh latensi untuk satu pesan (misalnya, permintaan). `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` Karena setiap perjalanan pulang pergi membawa lebih banyak pekerjaan, permintaan batch membuat penggunaan thread dan koneksi lebih efisien, meningkatkan throughput.

Anda dapat menggabungkan batching dengan penskalaan horizontal untuk menyediakan throughput dengan thread, koneksi, dan permintaan yang lebih sedikit daripada permintaan pesan individual. Anda dapat menggunakan tindakan Amazon SQS batch untuk mengirim, menerima, atau menghapus hingga 10 pesan sekaligus. Karena Amazon SQS mengenakan biaya berdasarkan permintaan, batching dapat secara substansional mengurangi biaya Anda. 

Batching dapat menimbulkan beberapa kerumitan untuk aplikasi Anda (misalnya, aplikasi Anda harus mengumpulkan pesan sebelum mengirimnya, atau terkadang harus menunggu lebih lama untuk respons). Namun, batching masih bisa efektif dalam kasus-kasus berikut: 
+ Aplikasi Anda menghasilkan banyak pesan dalam waktu singkat, sehingga penundaan tidak pernah terlalu lama. 
+ Konsumen pesan mengambil pesan dari antrian atas kebijakannya sendiri, tidak seperti produsen pesan biasa yang perlu mengirim pesan sebagai respons terhadap peristiwa yang tidak mereka kendalikan. 

**penting**  
Permintaan batch mungkin berhasil meskipun pesan individual dalam batch gagal. Setelah permintaan batch, selalu periksa kegagalan pesan individual dan coba lagi tindakan jika perlu.

## Contoh Java yang berfungsi untuk permintaan operasi tunggal dan batch
<a name="working-java-example-batch-requests"></a>

### Prasyarat
<a name="batch-request-java-example-prerequisites"></a>

Tambahkan`aws-java-sdk-sqs.jar`,`aws-java-sdk-ec2.jar`, dan `commons-logging.jar` paket ke jalur kelas build Java Anda. Contoh berikut menampilkan dependensi ini dalam file `pom.xml` proyek Maven.

```
<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.jawa
<a name="batch-request-java-example-code"></a>

Contoh kode Java berikut mengimplementasikan pola produsen-konsumen sederhana. Thread utama memunculkan sejumlah thread produsen dan konsumen yang memproses pesan 1 KB untuk waktu tertentu. Contoh ini mencakup produsen dan konsumen yang membuat permintaan operasi tunggal dan mereka yang membuat permintaan batch.

```
/*
 * 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.
            }
        }
    }
}
```

### Memantau metrik volume dari contoh yang dijalankan
<a name="batch-request-java-example-monitoring-metrics"></a>

Amazon SQS secara otomatis menghasilkan metrik volume untuk pesan yang dikirim, diterima, dan dihapus. [Anda dapat mengakses metrik tersebut dan lainnya melalui tab **Monitoring** untuk antrian Anda atau di CloudWatch konsol.](https://console.aws.amazon.com/cloudwatch/home)

**catatan**  
Metrik dapat memakan waktu hingga 15 menit setelah antrian mulai tersedia.

# Menggunakan Amazon SQS dengan SDK AWS
<a name="sdk-general-information-section"></a>

AWS kit pengembangan perangkat lunak (SDKs) tersedia untuk banyak bahasa pemrograman populer. Setiap SDK menyediakan API, contoh kode, dan dokumentasi yang memudahkan developer untuk membangun aplikasi dalam bahasa pilihan mereka.


| Dokumentasi SDK | Contoh kode | 
| --- | --- | 
| [AWS SDK untuk C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK untuk C\$1\$1 contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) | 
| [AWS CLI](https://docs.aws.amazon.com/cli) | [AWS CLI contoh kode](https://docs.aws.amazon.com/code-library/latest/ug/cli_2_code_examples.html) | 
| [AWS SDK untuk Go](https://docs.aws.amazon.com/sdk-for-go) | [AWS SDK untuk Go contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2) | 
| [AWS SDK untuk Java](https://docs.aws.amazon.com/sdk-for-java) | [AWS SDK untuk Java contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) | 
| [AWS SDK untuk JavaScript](https://docs.aws.amazon.com/sdk-for-javascript) | [AWS SDK untuk JavaScript contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3) | 
| [AWS SDK untuk Kotlin](https://docs.aws.amazon.com/sdk-for-kotlin) | [AWS SDK untuk Kotlin contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin) | 
| [AWS SDK untuk .NET](https://docs.aws.amazon.com/sdk-for-net) | [AWS SDK untuk .NET contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3) | 
| [AWS SDK untuk PHP](https://docs.aws.amazon.com/sdk-for-php) | [AWS SDK untuk PHP contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) | 
| [Alat AWS untuk PowerShell](https://docs.aws.amazon.com/powershell) | [Alat AWS untuk PowerShell contoh kode](https://docs.aws.amazon.com/code-library/latest/ug/powershell_5_code_examples.html) | 
| [AWS SDK untuk Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) | [AWS SDK untuk Python (Boto3) contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python) | 
| [AWS SDK untuk Ruby](https://docs.aws.amazon.com/sdk-for-ruby) | [AWS SDK untuk Ruby contoh kode](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 contoh kode](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 contoh kode](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 contoh kode](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) | 

**Ketersediaan contoh**  
Tidak dapat menemukan apa yang Anda butuhkan? Minta contoh kode menggunakan tautan **Berikan umpan balik** di bagian bawah halaman ini.