

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

# 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) 및 [AWS Tools for PowerShell Cmdlet 참조**](https://docs.aws.amazon.com/powershell/latest/reference/)의 Amazon SQS 섹션을 참조하세요.

**AWS JSON 프로토콜을 사용하는 Amazon SQS API**

Amazon SQS는 지정된 [AWS SDK 버전](sqs-json-faqs.md#json-protocol-getting-started)의 모든 Amazon SQS API에 대한 전송 메커니즘으로 AWS JSON 프로토콜을 사용합니다. AWS JSON 프로토콜은 더 높은 처리량, 더 짧은 지연 시간, 더 빠른 애플리케이션 간 통신을 제공합니다. AWS JSON 프로토콜은 AWS 쿼리 프로토콜에 비해 요청 및 응답의 직렬화/역직렬화에 더 효율적입니다. SQS API에서 AWS 쿼리 프로토콜을 계속 사용하고 싶다면 Amazon SQS AWS 쿼리 프로토콜을 지원하는 AWS SDK 버전에 대해 [Amazon SQS APIs에서 사용되는 AWS JSON 프로토콜에는 어떤 언어가 지원되나요?](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 JSON은 AWS 쿼리에 비해 클라이언트와 서버 간에 데이터를 전송하는 데 더 간단하고 빠르며 효율적입니다.
+ 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 요청 수행
<a name="sqs-making-api-requests-json"></a>

이 주제에서는 Amazon SQS 엔드포인트를 구성하고, POST 요청을 수행하고, 응답을 해석하는 방법을 설명합니다.

**참고**  
AWS JSON 프로토콜은 대부분의 언어 변형에서 지원됩니다. 지원되는 언어 변형의 전체 목록은 [Amazon SQS APIs에서 사용되는 AWS JSON 프로토콜에는 어떤 언어가 지원되나요?](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 엔드포인트는 독립적입니다. 예를 들어 두 대기열의 이름이 **MyQueue인데 한 대기열에는 `sqs.us-east-2.amazonaws.com` 엔드포인트가 있고 다른 대기열에는 `sqs.eu-west-2.amazonaws.com` 엔드포인트가 있는 경우 두 대기열은 서로 어떤 데이터도 공유하지 않습니다.

다음은 대기열을 생성하는 요청을 만드는 엔드포인트의 예제입니다.

```
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 요청에 다른 항목을 추가할 수 있습니다.

# 아마존 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>

요청이 성공하면 기본 응답 요소는 요청의 범용 고유 식별자(UUID)와 기타 추가된 응답 필드를 포함하는 `x-amzn-RequestId`입니다. 예를 들어 다음 [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) 응답에는 생성된 대기열의 URL이 포함된 `QueueUrl` 필드가 포함되어 있습니다.

```
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`에는 오류 유형, 오류가 생산자 오류인지 소비자 오류인지 여부라는 두 가지 정보가 포함되어 있습니다.

응답 본문에서 `"__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은 이기종 시스템 간 통신에 가장 널리 사용되고 수용되는 연결 방법 중 하나입니다. Amazon SQS는 JSON을 매체로 사용하여 AWS SDK 클라이언트(예: Java, Python, Golang, JavaScript)와 Amazon SQS 서버 간에 통신합니다. Amazon SQS API 작업의 HTTP 요청은 JSON 형식의 입력을 수락합니다. Amazon SQS 작업이 실행되고 실행 응답이 JSON 형식으로 SDK 클라이언트에 다시 공유됩니다. JSON은 AWS 쿼리에 비해 클라이언트와 서버 간에 데이터를 전송하는 데 효율적입니다.
+ Amazon SQS AWS JSON 프로토콜은 Amazon SQS 클라이언트와 서버 간의 매개자 역할을 합니다.
+ 서버는 Amazon SQS 작업이 생성되는 프로그래밍 언어를 이해하지 못하지만 AWS JSON 프로토콜을 이해합니다.
+ Amazon SQS AWS JSON 프로토콜은 Amazon SQS 클라이언트와 서버 간의 직렬화(객체를 JSON 형식으로 변환) 및 역직렬화(JSON 형식을 객체로 변환)를 사용합니다.

## Amazon SQS용 AWS JSON 프로토콜을 시작하려면 어떻게 해야 하나요? Amazon SQS
<a name="json-protocol-getting-started"></a>

Amazon SQS에 대한 더 빠른 메시징을 위해 최신 AWS SDK 버전을 시작하려면 AWS SDK를 지정된 버전 또는 후속 버전으로 업그레이드하세요. SDK 클라이언트에 대해 자세히 알아보려면 아래 표의 안내서 열을 참조하세요.

다음은 Amazon SQS API와 함께 사용할 수 있는 AWS JSON 프로토콜의 언어 변형 간 SDK 버전 목록입니다. APIs


| 언어 | 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 Command Line Interface](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의 조합을 사용하여 AWS 쿼리 기반(XML 기반) 응답을 생성하는 Amazon SQS와 상호 작용하는 경우 AWS JSON 프로토콜과 호환되지 않을 수 있습니다. 문제가 발생하면 AWS Support에 문의하세요.

## 이미 최신 AWS SDK 버전을 사용하고 있지만 오픈 소스 솔루션이 JSON을 지원하지 않는 경우 어떻게 해야 합니까?
<a name="json-protocol-sdk-version-open-source"></a>

SDK 버전을 사용 중인 것보다 이전 버전으로 변경해야 합니다. [Amazon SQS용 AWS JSON 프로토콜을 시작하려면 어떻게 해야 하나요? Amazon SQS](#json-protocol-getting-started) 자세한 내용은 섹션을 참조하세요.에 나열된 AWS SDK 버전은 Amazon SQS APIs용 JSON 유선 프로토콜을 [Amazon SQS용 AWS JSON 프로토콜을 시작하려면 어떻게 해야 하나요? Amazon SQS](#json-protocol-getting-started) 사용합니다. AWS SDK를 이전 버전으로 변경하면 Amazon SQS APIs AWS 쿼리를 사용합니다.

## Amazon SQS APIs에서 사용되는 AWS JSON 프로토콜에는 어떤 언어가 지원되나요?
<a name="json-protocol-supported-languages"></a>

Amazon SQS는 AWS SDKs을 지원합니다. 현재 Kotlin, Rust 또는 Swift는 지원하지 않습니다. 다른 언어 변형에 대해 자세히 알아보려면 [AWS에서의 빌드를 위한 도구](https://aws.amazon.com/developer/tools/)를 참조하세요.

## Amazon SQS APIs에서 사용되는 AWS JSON 프로토콜에 지원되는 리전
<a name="json-protocol-supported-regions"></a>

Amazon SQS는 Amazon SQS를 사용할 수 있는 모든 [AWS 리전](https://docs.aws.amazon.com/general/latest/gr/sqs-service.html)에서 AWS JSON 프로토콜을 지원합니다.

## AWS JSON 프로토콜을 사용하여 Amazon SQS용 지정된 AWS SDK 버전으로 업그레이드할 때 어떤 지연 시간 개선을 기대할 수 있습니까?
<a name="json-protocol-upgrading-sdk"></a>

AWS JSON 프로토콜은 AWS 쿼리 프로토콜에 비해 요청 및 응답의 직렬화 및 역직렬화에 더 효율적입니다. 5KB 메시지 페이로드에 대한 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)

## AWS JSON 프로토콜에 대한 자세한 내용은 어디에서 확인할 수 있습니까?
<a name="json-protocol-more-info"></a>

**Smithy 설명서의 [AWS JSON 1.0 프로토콜](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html)에서 JSON 프로토콜에 대한 자세한 내용을 확인할 수 있습니다. AWS JSON 프로토콜을 사용하는 Amazon SQS API 요청에 대한 자세한 내용은 [Amazon SQS에서 AWS JSON 프로토콜을 사용하여 쿼리 API 요청 수행](sqs-making-api-requests-json.md) 섹션을 참조하세요.

# Amazon SQS에서 쿼리 프로토콜을 사용하여 AWS 쿼리 API 요청 수행
<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 엔드포인트는 독립적입니다. 예를 들어 두 대기열의 이름이 **MyQueue인데 한 대기열에는 `sqs.us-east-2.amazonaws.com` 엔드포인트가 있고 다른 대기열에는 `sqs.eu-west-2.amazonaws.com` 엔드포인트가 있는 경우 두 대기열은 서로 어떤 데이터도 공유하지 않습니다.

다음은 대기열을 생성하는 요청을 만드는 엔드포인트의 예제입니다.

```
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`를 포함하며, 결과적으로 요청의 Universal Unique Identifier(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 
+ 비밀 액세스 키(사용자와 AAA에게만 알려진 공유 비밀 - 자세한 내용은 RFC2104 참조)를 사용하여 계산된 HMAC-SHA 요청 서명입니다. [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는 이전 버전보다 SHA256 기반 보안과 성능이 강화된 서명 버전 4를 지원합니다. 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);
         }
     }
     ```
+ 요청의 **타임스탬프(또는 만료)**입니다. 요청에 사용하는 타임스탬프는 [시간, 분, 초를 포함한 전체 날짜가](http://www.w3.org/TR/xmlschema-2/#dateTime) 포함된 `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/ko_kr/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/ko_kr/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는 비용을 절감하고 단일 작업으로 최대 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)`

배치 작업을 사용하면 단일 API 직접 호출로 여러 작업을 수행할 수 있으므로 성능을 최적화하고 비용을 절감할 수 있습니다. Amazon SQS 배치 작업을 지원하는 쿼리 API 또는 AWS SDK를 사용하여 배치 기능을 활용할 수 있습니다.

**중요한 세부 정보**
+ **메시지 크기 제한:** 단일 `SendMessageBatch` 직접 호출로 전송되는 모든 메시지의 총 크기는 1,048,576바이트(1MiB)를 초과할 수 없습니다.
+ **권한:** `SendMessageBatch`, `DeleteMessageBatch` 또는 `ChangeMessageVisibilityBatch`에 대한 권한을 명시적으로 설정할 수 없습니다. `SendMessage`, `DeleteMessage` 또는 `ChangeMessageVisibility`에 대한 권한을 설정하면 작업의 해당 배치 버전에 대한 권한도 설정됩니다.
+ **콘솔 지원:** Amazon SQS 콘솔은 배치 작업을 지원하지 않습니다. 쿼리 API 또는 AWS SDK를 사용하여 배치 작업을 수행해야 합니다.

## 메시지 작업 일괄 처리
<a name="batching-message-actions"></a>

비용 및 효율성을 더욱 최적화하려면 메시지 작업 배치 처리를 위한 다음 모범 사례를 고려하세요.
+ **배치 API 작업:** [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/)는 Amazon SQS에 액세스하는 `AmazonSQSBufferedAsyncClient`를 포함합니다. 이 클라이언트는 클라이언트 측 버퍼링을 사용하여 간단한 요청 배치 처리를 허용합니다. 클라이언트에서 수행한 직접 호출을 먼저 버퍼링한 후 배치 요청 형태로 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 Java 1.x용 SDK
<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 | 20s |  `ReceiveMessage` 호출이 서버에서 차단되고 빈 수신 결과를 반환하기 전에 메시지가 대기열에 나타나기까지 대기하는 최대 시간(초)입니다.  긴 폴링을 비활성화하면 이 설정은 영향을 주지 않습니다.   | 
| maxBatchOpenMs | 200ms |  발신 호출이 동일한 유형의 메시지를 배치 처리할 다른 호출을 대기하는 최대 시간(밀리초)입니다. 설정이 높을수록 동일한 작업량을 수행하는 데 필요한 배치 수가 감소합니다(그러나 배치의 첫 번째 호출을 대기하는 시간이 길어짐). 이 파라미터를 `0`으로 설정하면, 제출된 요청은 다른 요청을 기다리지 않으므로 사실상 일괄 처리하지 않게 됩니다.  | 
| maxBatchSize | 배치당 요청 10개 |  단일 요청에서 배치 방식으로 함께 처리되는 최대 메시지 수입니다. 설정이 높을수록 동일한 요청 수를 수행하는 데 필요한 배치 수가 감소합니다.  배치당 요청 10개는 Amazon SQS에 허용되는 최대값입니다.   | 
| maxBatchSizeBytes | 1MiB |  클라이언트가 Amazon SQS에 전송하려고 시도하는 메시지 배치의 최대 크기(바이트 단위)입니다.  1MiB는 Amazon SQS에 허용되는 최댓값입니다.   | 
| maxDoneReceiveBatches | 배치 10개 |  `AmazonSQSBufferedAsyncClient`가 클라이언트 측에서 미리 가져와서 저장하는 수신 배치의 최대 개수입니다. 설정이 높을수록 Amazon SQS에 호출을 전송하지 않고도 만족할 수 있는 수신 요청 개수가 늘어납니다(그러나 미리 가져오는 메시지가 많을수록 메시지가 버퍼에 있는 시간이 길어지므로 표시 제한 시간이 만료될 수 있음).  `0`은 모든 메시지 미리 가져오기 기능이 비활성화되고 메시지가 요청 시에만 사용됨을 나타냅니다.   | 
| maxInflightOutboundBatches | 배치 5개 |  동시에 처리될 수 있는 활성 아웃바운드 배치의 최대 개수입니다. 설정이 높을수록 아웃바운드 배치 전송 속도가 빨라지고(CPU 또는 대역폭과 같은 할당량도 영향을 줌), `AmazonSQSBufferedAsyncClient`에서 사용하는 스레드 수가 많아집니다.  | 
| maxInflightReceiveBatches | 배치 10개 |  동시에 처리될 수 있는 활성 수신 배치의 최대 개수입니다. 설정이 높을수록 수신 가능한 메시지가 많아지고(CPU 또는 대역폭과 같은 할당량도 영향을 줌), `AmazonSQSBufferedAsyncClient`에서 사용하는 스레드 수가 많아집니다.  `0`은 모든 메시지 미리 가져오기 기능이 비활성화되고 메시지가 요청 시에만 사용됨을 나타냅니다.   | 
| visibilityTimeoutSeconds | -1 |  이 파라미터를 0이 아닌 양수 값으로 설정하면, 여기에 설정된 제한 시간 초과는 메시지가 사용되는 대기열에서 설정된 제한 시간 초과를 재정의합니다.  `-1`은 대기열에서 기본 설정이 선택되어 있음을 나타냅니다. 제한 시간 초과를 `0`으로 설정할 수 없습니다.   | 

### AWS Java 2.x용 SDK
<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개  | 단일 요청에서 배치 방식으로 함께 처리되는 최대 메시지 수입니다. 설정이 높을수록 동일한 요청 수를 수행하는 데 필요한 배치 수가 감소합니다.  Amazon SQS에 허용되는 최댓값은 배치당 요청 10개입니다.  | 
| sendRequestFrequency |  200ms  | 발신 호출이 동일한 유형의 메시지를 배치 처리할 다른 호출을 대기하는 최대 시간(밀리초)입니다. 설정이 높을수록 동일한 작업량을 수행하는 데 필요한 배치 수가 감소합니다(그러나 배치의 첫 번째 호출을 대기하는 시간이 길어짐). 이 파라미터를 `0`으로 설정하면, 제출된 요청은 다른 요청을 기다리지 않으므로 사실상 일괄 처리하지 않게 됩니다. | 
| receiveMessageVisibilityTimeout |  -1  | 이 파라미터를 0이 아닌 양수 값으로 설정하면, 여기에 설정된 제한 시간 초과는 메시지가 사용되는 대기열에서 설정된 제한 시간 초과를 재정의합니다.   `1`은 대기열에서 기본 설정이 선택되어 있음을 나타냅니다. 제한 시간 초과를 `0`으로 설정할 수 없습니다.   | 
| receiveMessageMinWaitDuration |  50ms  | 사용 가능한 메시지를 가져올 때까지 `receiveMessage` 직접 호출이 대기하는 최소 시간(밀리초)입니다. 설정이 높을수록 동일한 요청 수를 수행하는 데 필요한 배치 수가 감소합니다.  | 

# Amazon SQS로 수평적 조정과 작업 배치 처리를 사용하여 처리량 증대
<a name="sqs-throughput-horizontal-scaling-and-batching"></a>

Amazon SQS는 처리량이 많은 메시징을 지원합니다. 처리량 한도에 대한 자세한 내용은 [Amazon SQS 메시지 할당량](quotas-messages.md) 섹션을 참조하세요.

처리량을 극대화하는 방법:
+ 각 인스턴스를 더 추가하여 생산자와 소비자를 수평적으로 [규모를 조정](#horizontal-scaling)합니다.
+ [작업 배치 처리](#request-batching)를 사용하여 단일 요청으로 여러 메시지를 보내거나 수신하여 API 직접 호출 오버헤드를 줄입니다.

## 수평 크기 조정
<a name="horizontal-scaling"></a>

HTTP 요청-응답 프로토콜을 통해 Amazon SQS에 액세스하기 때문에 요청 지연 시간**(요청을 시작해서 응답을 받기까지의 시간 간격)은 단일 연결을 사용하여 단일 스레드에서 확보할 수 있는 처리량을 제한합니다. 예를 들어, 동일한 리전에서 Amazon EC2 기반 클라이언트부터 Amazon SQS까지 지연 시간이 평균 20ms인 경우 단일 연결을 통한 단일 스레드의 최대 처리량은 평균 50TPS입니다.

*수평적 조정*은 메시지 생성자(`[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)` 요청 전송) 수를 늘리는 것으로 전체 대기열 처리량을 높여줍니다. 다음 세 가지 방법으로 수평 확장할 수 있습니다.
+ 클라이언트당 스레드 수 늘리기
+ 클라이언트 추가
+ 클라이언트당 스레드 수를 늘리고 클라이언트 추가

클라이언트를 더 추가하면 대기열 처리량이 선형적으로 증가합니다. 예를 들어 클라이언트 개수를 2배 늘리면 처리량도 2배가 됩니다.

## 작업 일괄 처리
<a name="request-batching"></a>

*일괄 처리*는 서비스까지 왕복할 때마다 더 많은 작업을 수행합니다(예: `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` 작업이 없습니다.

일괄 처리는 메시지 하나의 전체 지연 시간을 수락하는 것이 아니라, 배치 작업의 지연 시간을 배치 요청의 여러 메시지로 분산시키는 것입니다(예: `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)` 요청). 각 왕복마다 더 많은 작업을 수행하기 때문에 배치 요청은 스레드와 연결을 보다 효율적으로 사용하므로 처리량이 개선됩니다.

일괄 처리와 수평적 조정을 함께 사용하면 개별 메시지 요청보다 스레드, 연결 및 요청 수가 적은 처리량을 얻습니다. 배치 처리된 Amazon SQS 작업을 사용하여 한 번에 최대 10개 메시지를 전송, 수신 또는 삭제할 수 있습니다. Amazon SQS는 요청별로 요금을 부과하기 때문에 배치 처리 시 비용을 대폭 절감할 수 있습니다.

일괄 처리를 사용하면 애플리케이션에 어느 정도 복잡성이 수반됩니다(예를 들어 애플리케이션이 메시지를 누적한 후 메시지를 전송하고 때로는 응답을 받기까지 대기 시간이 길어짐). 그러나 다음과 같은 상황에서는 일괄 처리가 효과적일 수 있습니다.
+ 애플리케이션이 단시간에 많은 메시지를 생성하지만 지연 시간이 매우 길지 않은 경우.
+ 제어하지 못하는 이벤트에 대응하여 메시지를 전송해야 하는 일반적인 메시지 생성자와 달리 메시지 소비자가 단독 재량으로 대기열에서 메시지를 가져오는 경우.

**중요**  
배치의 개별 메시지에 오류가 발생하더라도 배치 요청이 성공할 수 있습니다. 배치 요청 후에는 항상 개별 메시지의 오류 여부를 확인하고 필요에 따라 작업을 다시 시도해야 합니다.

## 단일 작업 및 배치 요청에 대한 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 코드 예제는 단순한 생성자-소비자 패턴을 구현한 것입니다. 기본 스레드는 지정된 시간 동안 1KB 메시지를 처리하는 생성자와 소비자 스레드를 다수 생성합니다. 이 예제에는 단일 작업을 요청하는 생성자와 소비자뿐 아니라 배치 요청을 하는 생성자와 소비자가 포함되어 있습니다.

```
/*
 * 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) | 

**가용성 예제**  
필요한 예제를 찾을 수 없습니까? 이 페이지 하단의 **피드백 제공** 링크를 사용하여 코드 예시를 요청하세요.