As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usar APIs com o Amazon SQS
<a name="sqs-working-with-apis"></a>

Este tópico fornece informações sobre como criar endpoints do Amazon SQS, fazer solicitações da API de consulta com os métodos GET e POST e usar ações em lote da API. Para ter informações detalhadas sobre as [ações](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) do Amazon SQS, inclusive parâmetros, erros, exemplos e [tipos de dados](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Types.html), consulte a [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/).

Para acessar o Amazon SQS utilizando várias linguagens de programação, você também pode usar os [AWS SDKs](https://aws.amazon.com/tools/#sdk) que contêm a seguinte funcionalidade automática:
+ Assinar criptograficamente suas solicitações de serviço
+ Recuperar solicitações
+ Lidar com respostas de erro

Para obter mais informações, consulte [Usar o Amazon SQS com um SDK da AWS](sdk-general-information-section.md).

Para ter informações sobre a ferramenta da linha de comando, consulte as seções do Amazon SQS na [https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html](https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html) e na [https://docs.aws.amazon.com/powershell/latest/reference/](https://docs.aws.amazon.com/powershell/latest/reference/).

**APIs do Amazon SQS com protocolo JSON da AWS**

O Amazon SQS usa o protocolo JSON da AWS como mecanismo de transporte para todas as APIs do Amazon SQS nas [versões do AWS SDK](sqs-json-faqs.md#json-protocol-getting-started) especificadas.AWS O protocolo JSON fornece uma taxa mais alta de throughput, menor latência e comunicação mais rápida entre aplicações. AWS O protocolo JSON é mais eficiente na serialização/desserialização de solicitações e respostas quando comparado ao protocolo de consulta da AWS. Se você ainda preferir usar o protocolo de consulta da AWS com APIs SQS, consulte [Quais idiomas são compatíveis com o protocolo AWS JSON usado no Amazon APIs SQS?](sqs-json-faqs.md#json-protocol-supported-languages) para saber quais versões do AWS SDK são compatíveis com o protocolo de consulta da AWS do Amazon SQS.

O Amazon SQS usa o protocolo JSON da AWS para comunicação entre clientes do AWS SDK (por exemplo, Java, Python, Golang, JavaScript) e o servidor do Amazon SQS. Uma solicitação HTTP de uma operação de API do Amazon SQS aceita entrada formatada em JSON. A operação do Amazon SQS é executada, e a resposta de execução é enviada de volta ao cliente do SDK no formato JSON. Comparado com a consulta da AWS, o JSON da AWS é mais simples, rápido e eficiente para transportar dados entre o cliente e o servidor.
+ O protocolo JSON da AWS atua como um mediador entre o cliente e o servidor do Amazon SQS.
+ O servidor não entende a linguagem de programação na qual a operação do Amazon SQS é criada, mas ele entende o protocolo JSON da AWS.
+ O protocolo JSON da AWS usa a serialização (conversão do objeto no formato JSON) e a desserialização (conversão do formato JSON em objeto) entre o cliente e o servidor do Amazon SQS.

Para receber mais informações sobre o protocolo JSON da AWS com Amazon SQS, consulte [Protocolo Amazon SQS JSON AWS FAQs](sqs-json-faqs.md).

O protocolo JSON da AWS está disponível na [versão do AWS SDK](sqs-json-faqs.md#json-protocol-getting-started) especificada. Para examinar a versão do SDK e as datas de lançamento em todas as variantes de linguagem, consulte a [Matriz de suporte a versões de AWS SDKs e ferramentas](https://docs.aws.amazon.com/sdkref/latest/guide/version-support-matrix.html) no *Guia de referência de AWS SDKs e ferramentas*.

# Fazer solicitações de API de consulta usando o protocolo AWS JSON no Amazon SQS
<a name="sqs-making-api-requests-json"></a>

Este tópico explica como criar um endpoint do Amazon SQS, fazer solicitações POST e interpretar respostas.

**nota**  
AWS O protocolo JSON é compatível com a maioria das variantes de linguagem. Para ver uma lista completa de variantes de linguagem compatíveis, consulte [Quais idiomas são compatíveis com o protocolo AWS JSON usado no Amazon APIs SQS?](sqs-json-faqs.md#json-protocol-supported-languages).

## Criar um endpoint
<a name="sqs-api-constructing-endpoints-json"></a>

Para trabalhar com filas do Amazon SQS, você deve criar um endpoint. Para ter informações sobre endpoints do Amazon SQS, consulte as seguintes páginas na *Referência geral da Amazon Web Services*:
+ [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)
+ [Endpoints e cotas do Amazon Simple Queue Service](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Cada endpoint do Amazon SQS é totalmente independente. Por exemplo, se duas filas forem nomeadas *MyQueue*, uma tiver um endpoint `sqs.us-east-2.amazonaws.com` e a outra tiver o endpoint `sqs.eu-west-2.amazonaws.com`, elas não compartilham dados entre si.

Veja a seguir um exemplo de endpoint que faz uma solicitação para criar uma fila. 

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

**nota**  
Os nomes das filas e as URLs filas diferenciam maiúsculas de minúsculas.  
A estrutura de *`AUTHPARAMS`* depende de como você assina sua solicitação de API. Para obter mais informações, consulte [Assinar solicitações de AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) na *Referência geral da Amazon Web Services*.

## Como fazer uma solicitação POST
<a name="structure-post-request"></a>

As solicitações POST do Amazon SQS enviam parâmetros de consulta como um formulário no corpo de uma solicitação HTTP.

Veja a seguir um exemplo de cabeçalho HTTP com `X-Amz-Target` definido como `AmazonSQS.<operationName>` e um cabeçalho HTTP com `Content-Type` definido como `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"
}
```

Essa solicitação HTTP POST envia uma mensagem a uma fila do Amazon SQS.

**nota**  
Os dois cabeçalhos HTTP `X-Amz-Target` e `Content-Type` são obrigatórios.  
Seu cliente HTTP pode adicionar outros itens à solicitação HTTP, de acordo com a versão do HTTP do cliente.

# Interpretar as respostas da API JSON do Amazon SQS
<a name="sqs-json-api-responses"></a>

Quando você envia uma solicitação para o Amazon SQS, ela retorna uma resposta JSON com os resultados. A estrutura de resposta depende da ação da API que você usou.

Para entender os detalhes dessas respostas, consulte:
+ A ação específica da API nas [ações da API](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) na *Referência de API do Amazon Simple Queue Service*
+ A [Protocolo Amazon SQS JSON AWS FAQs](sqs-json-faqs.md)

## Estrutura de resposta JSON bem-sucedida
<a name="sqs-json-api-successful-response-structure"></a>

Se a solicitação for bem-sucedida, o principal elemento de resposta será `x-amzn-RequestId`, que contém o identificador único universal (UUID) da solicitação, bem como outros campos de resposta anexados. Por exemplo, a resposta [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) a seguir contém o campo `QueueUrl`, que, por sua vez, contém o URL da fila criada.

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

## Estrutura de resposta de erro JSON
<a name="sqs-api-error-response-structure"></a>

Se uma solicitação não for bem-sucedida, o Amazon SQS retornará a resposta principal, incluindo o cabeçalho HTTP e o corpo.

No cabeçalho HTTP, `x-amzn-RequestId` contém o UUID da solicitação. `x-amzn-query-error` contém duas informações: o tipo de erro e se o erro foi do produtor ou do consumidor. 

No corpo de resposta, `"__type"` indica outros detalhes do erro, e `Message` indica a condição de erro em um formato legível. 

Veja a seguir um exemplo de resposta de erro no formato 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."
}
```

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

Este tópico aborda perguntas frequentes sobre o uso do protocolo AWS JSON com o Amazon SQS.

## O que é o protocolo AWS JSON e como ele difere das solicitações e respostas existentes da API Amazon SQS?
<a name="json-protocol-what-is"></a>

JSON é um dos métodos de conexão mais amplamente usados e aceitos para comunicação entre sistemas heterogêneos. O Amazon SQS usa o JSON como meio de comunicação entre um cliente AWS SDK (por exemplo, Java, Python, Golang) JavaScript e o servidor Amazon SQS. Uma solicitação HTTP de uma operação de API do Amazon SQS aceita entrada formatada em JSON. A operação do Amazon SQS é executada, e a resposta de execução é compartilhada de volta com o cliente do SDK no formato JSON. Comparado com a consulta da  AWS , o JSON é mais eficiente para transportar dados entre o cliente e o servidor. 
+ O protocolo Amazon SQS AWS JSON atua como um mediador entre o cliente e o servidor do Amazon SQS.
+ O servidor não entende a linguagem de programação na qual a operação do Amazon SQS é criada, mas entende o protocolo AWS JSON.
+ O protocolo Amazon SQS AWS JSON usa a serialização (converter objeto no formato JSON) e a desserialização (converter formato JSON em objeto) entre o cliente e o servidor do Amazon SQS.

## Como faço para começar a usar os protocolos AWS JSON para o Amazon SQS?
<a name="json-protocol-getting-started"></a>

Para começar a usar a versão mais recente do AWS SDK e obter mensagens mais rápidas para o Amazon SQS, atualize AWS seu SDK para a versão especificada ou para qualquer versão posterior. Para saber mais sobre os clientes do SDK, consulte a coluna “Guia” na tabela abaixo.

A seguir está uma lista de versões do SDK em todas as variantes de linguagem do protocolo AWS JSON para uso com o Amazon SQS: APIs


| Linguagem | Repositório do cliente do SDK | Versão obrigatória do cliente do SDK | Guia | 
| --- | --- | --- | --- | 
|  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 para 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 para Go](https://aws.amazon.com/sdk-for-go/)  | 
|  Golang 2.x  |  [serra/ 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 para 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 para Java](https://aws.amazon.com/sdk-for-java/)  | 
|  Java 2.x  |  [serra/ 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 para Java](https://aws.amazon.com/sdk-for-java/)  | 
|  JavaScript v2.x  |  [aws/ aws-sdk-js](https://github.com/aws/aws-sdk-js)  |  [JavaScript em AWS](https://aws.amazon.com/developer/language/javascript/)  | 
|  JavaScript v3.x  |  [serra/ 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 em 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 para .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 para 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 para 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 para 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 para Ruby](https://aws.amazon.com/sdk-for-ruby/)  | 

## Quais são os riscos de habilitar o protocolo JSON para minhas workloads do Amazon SQS?
<a name="json-protocol-risks"></a>

Se você estiver usando uma implementação personalizada do AWS SDK ou uma combinação de clientes personalizados e AWS SDK para interagir com o Amazon SQS que AWS gera respostas baseadas em consultas (também conhecidas como baseadas em XML), ela pode ser incompatível com o protocolo JSON. AWS Se você encontrar algum problema, entre em contato com o AWS Support.

## E se eu já estiver usando a versão mais recente do AWS SDK, mas minha solução de código aberto não for compatível com JSON?
<a name="json-protocol-sdk-version-open-source"></a>

É necessário alterar a versão do SDK para a versão anterior à que você está usando. Consulte [Como faço para começar a usar os protocolos AWS JSON para o Amazon SQS?](#json-protocol-getting-started) para obter mais informações. AWS As versões do SDK listadas em [Como faço para começar a usar os protocolos AWS JSON para o Amazon SQS?](#json-protocol-getting-started) usam o protocolo de conexão JSON para o Amazon SQS. APIs Se você alterar seu AWS SDK para a versão anterior, seu Amazon APIs SQS AWS usará a consulta.

## Quais idiomas são compatíveis com o protocolo AWS JSON usado no Amazon APIs SQS?
<a name="json-protocol-supported-languages"></a>

O Amazon SQS oferece suporte a todas as variantes de idioma onde AWS SDKs estão disponíveis ao público em geral (GA). No momento, não há compatibilidade com Kotlin, Rust e Swift. Para saber mais sobre outras variantes de linguagem, consulte [Ferramentas para criar com a AWS](https://aws.amazon.com/developer/tools/).

## Quais regiões são compatíveis com o protocolo AWS JSON usado no Amazon SQS APIs
<a name="json-protocol-supported-regions"></a>

O Amazon SQS oferece suporte ao protocolo AWS JSON em todas as [AWS regiões](https://docs.aws.amazon.com/general/latest/gr/sqs-service.html) em que o Amazon SQS está disponível. 

## Quais melhorias de latência posso esperar ao atualizar para as versões especificadas do AWS SDK para o Amazon SQS usando o protocolo JSON? AWS
<a name="json-protocol-upgrading-sdk"></a>

AWS O protocolo JSON é mais eficiente na serialização e desserialização de solicitações e respostas quando comparado ao protocolo de consulta. AWS Com base em testes de AWS desempenho para uma carga útil de mensagem de 5 KB, o protocolo JSON para Amazon SQS end-to-end reduz a latência do processamento de mensagens em até 23% e reduz o uso da CPU e da memória do lado do cliente do aplicativo. 

## O protocolo AWS de consulta será descontinuado?
<a name="query-protocol"></a>

AWS o protocolo de consulta continuará sendo suportado. Você pode continuar usando o protocolo de AWS consulta, desde que sua versão do AWS SDK esteja definida como uma versão anterior diferente da listada em [Como começar a usar os protocolos AWS JSON para Amazon SQS.](#json-protocol-getting-started)

## Onde posso encontrar mais informações sobre o protocolo AWS JSON?
<a name="json-protocol-more-info"></a>

Você pode receber mais informações sobre o protocolo JSON em[AWS  JSON 1.0 protocol](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html) na documentação da *Smithy*. Para saber mais sobre as solicitações de API do Amazon SQS usando o protocolo JSON da  AWS , consulte [Fazer solicitações de API de consulta usando o protocolo AWS JSON no Amazon SQS](sqs-making-api-requests-json.md).

# Fazendo solicitações de API de AWS consulta usando o protocolo de consulta no Amazon SQS
<a name="sqs-making-api-requests-xml"></a>

Este tópico explica como criar um endpoint do Amazon SQS, fazer solicitações GET e POST e interpretar respostas.

## Criar um endpoint
<a name="sqs-api-constructing-endpoints"></a>

Para trabalhar com filas do Amazon SQS, você deve criar um endpoint. Para ter informações sobre endpoints do Amazon SQS, consulte as seguintes páginas na *Referência geral da Amazon Web Services*:
+ [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region)
+ [Endpoints e cotas do Amazon Simple Queue Service](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Cada endpoint do Amazon SQS é totalmente independente. Por exemplo, se duas filas forem nomeadas *MyQueue*, uma tiver um endpoint `sqs.us-east-2.amazonaws.com` e a outra tiver o endpoint `sqs.eu-west-2.amazonaws.com`, elas não compartilham dados entre si.

Veja a seguir um exemplo de um endpoint que faz uma solicitação para criar uma fila. 

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

**nota**  
Os nomes das filas e as URLs filas diferenciam maiúsculas de minúsculas.  
A estrutura de *`AUTHPARAMS`* depende de como você assina sua solicitação de API. Para obter mais informações, consulte [Assinar solicitações de AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) na *Referência geral da Amazon Web Services*.

## Como fazer uma solicitação GET
<a name="structure-get-request"></a>

Uma solicitação GET do Amazon SQS é estruturada como um URL que consiste no seguinte:
+ **Endpoint**: o recurso no qual a solicitação está agindo (o [nome da fila e o URL](sqs-queue-message-identifiers.md#queue-name-url)), por exemplo: `https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue`
+ **Ação**: a [ação](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) que você quer executar no endpoint. Um ponto de interrogação (`?`) separa o endpoint da ação, por exemplo: `?Action=SendMessage&MessageBody=Your%20Message%20Text`
+ **Parâmetros**: os parâmetros da solicitação. Cada parâmetro é separado por um E comercial (`&`); por exemplo: `&Version=2012-11-05&AUTHPARAMS` 

Veja a seguir um exemplo de solicitação GET que envia mensagens a uma fila do Amazon SQS.

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

**nota**  
Os nomes das filas e as URLs filas diferenciam maiúsculas de minúsculas.  
Como as solicitações GET são URLs, você deve codificar em URL todos os valores dos parâmetros. Como não é permitida a entrada de espaços URLs, cada espaço é codificado em URL como. `%20` O restante do exemplo não foi codificado no URL para facilitar a leitura.

## Como fazer uma solicitação POST
<a name="structure-post-request"></a>

As solicitações POST do Amazon SQS enviam parâmetros de consulta como um formulário no corpo de uma solicitação HTTP.

Veja a seguir um exemplo de cabeçalho HTTP com `Content-Type` definido como `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
```

O cabeçalho é seguido por uma solicitação GET `[form-urlencoded](https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2)` que envia uma mensagem a uma fila do Amazon SQS. Cada parâmetro é separado por um E comercial (`&`).

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

**nota**  
Somente o cabeçalho HTTP `Content-Type` é obrigatório. O `AUTHPARAMS` é o mesmo para a solicitação GET.  
Seu cliente HTTP pode adicionar outros itens à solicitação HTTP, de acordo com a versão do HTTP do cliente.

# Interpretar as respostas da API XML do Amazon SQS
<a name="sqs-xml-api-responses"></a>

Quando você envia uma solicitação para o Amazon SQS, ele retorna uma resposta XML que contém os resultados da solicitação. Para entender a estrutura e os detalhes dessas respostas, consulte as [ações de API](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) específicas na *Referência de API do Amazon Simple Queue Service*.

## Estrutura de resposta de XML bem-sucedida
<a name="sqs-api-successful-response-structure"></a>

Se a solicitação for bem-sucedida, o elemento de resposta principal receberá o nome da ação, com `Response` anexada (por exemplo, `ActionNameResponse`).

Esse elemento contém os seguintes elementos filho:
+ **`ActionNameResult`**: contém um elemento específico à ação. Por exemplo, o elemento `CreateQueueResult` contém o elemento `QueueUrl` que, por sua vez, contém o URL da fila criada.
+ **`ResponseMetadata`**: contém o `RequestId`, que, por sua vez, contém o Universal Unique Identifier (UUID) da solicitação.

Veja a seguir um exemplo de uma resposta bem-sucedida no formato 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>
```

## Estrutura de resposta de erro de XML
<a name="sqs-api-error-response-structure"></a>

Se uma solicitação não tiver êxito, o Amazon SQS retornará o elemento de resposta principal `ErrorResponse`. Esse elemento contém um elemento `Error` e um elemento `RequestId`.

O elemento `Error` contém os seguintes elementos filhos:
+ **`Type`**: especifica se o erro foi de um produtor ou de um consumidor.
+ **`Code`**: especifica o tipo de erro.
+ **`Message`**: especifica a condição do erro em um formato legível.
+ **`Detail`**: (opcional) especifica detalhes adicionais sobre o erro.

O elemento `RequestId` contém o UUID do pedido.

Veja a seguir um exemplo de uma resposta com erro no formato 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>
```

# Autenticação de solicitações para o Amazon SQS
<a name="sqs-api-request-authentication"></a>

A autenticação é o processo para identificar e verificar quem envia uma solicitação. Durante a primeira etapa de autenticação, a AWS verifica a identidade do produtor e se ele está [registrado para usar a AWS](https://aws.amazon.com/) (para obter mais informações, consulte [Etapa 1: criar um usuário Conta da AWS e IAM](sqs-setting-up.md#sqs-creating-aws-account)). Em seguida, AWS segue o seguinte procedimento:

1. O produtor (remetente) obtém as credenciais necessárias.

1. O produtor envia uma solicitação e a credencial para o consumidor (destinatário).

1. O consumidor usa a credencial para verificar se o produtor enviou a solicitação.

1. Uma das seguintes situações acontece:
   + Se a autenticação for bem-sucedida, o consumidor processará a solicitação.
   + Se a autenticação falhar, o consumidor rejeitará a solicitação e retornará um erro.

## Processo de autenticação básica com HMAC-SHA
<a name="sqs-api-basic-authentication-process"></a>

Ao acessar o Amazon SQS usando a API de consulta, você deve fornecer os seguintes itens para que a solicitação seja autenticada:
+ O **ID da chave de AWS acesso** que identifica sua Conta da AWS, que é AWS usado para pesquisar sua chave de acesso secreta.
+ A **assinatura da solicitação HMAC-SHA**, calculada usando sua chave de acesso secreta (um segredo compartilhado conhecido somente por você e AWS— para obter mais informações, consulte). [RFC2104](http://www.faqs.org/rfcs/rfc2104.html) O [SDK da AWS](https://aws.amazon.com/code/) lida com o processo de assinatura. No entanto, se você enviar uma solicitação de consulta por meio de HTTP ou HTTPS, precisará incluir uma assinatura em cada solicitação de consulta.

  1. Derive uma chave de assinatura Signature versão 4. Para obter mais informações, consulte [Derivar a chave de assinatura com Java](https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java).
**nota**  
O Amazon SQS oferece suporte à Signature versão 4, que fornece segurança e desempenho SHA256 aprimorados em relação às versões anteriores. Ao criar novas aplicações que usem o Amazon SQS, você deverá usar o Signature versão 4.

  1. Codifique a assinatura da solicitação usando base64. Este exemplo do código Java faz o seguinte:

     ```
     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);
         }
     }
     ```
+ O **timestamp (ou a expiração)** da solicitação. O timestamp que você usa na solicitação deve ser um objeto `dateTime`, com [a data completa, incluindo horas, minutos e segundos](http://www.w3.org/TR/xmlschema-2/#dateTime). Por exemplo: `2007-01-31T23:59:59Z` Embora isso não seja necessário, recomendamos que você informe o objeto usando o fuso horário Tempo Universal Coordenado (Horário de Greenwich).
**nota**  
Certifique-se de que a hora do servidor esteja definida corretamente. Se você especificar um registro de data e hora (em vez de uma expiração), a solicitação expirará automaticamente 15 minutos após o horário especificado (AWS não processará solicitações com carimbos de data e hora mais de 15 minutos antes da hora atual nos servidores). AWS   
Se você está usando .NET, não deve enviar timestamps excessivamente específicos (devido a interpretações diferentes em relação a como a precisão de tempo extra deve ser aplicada). Neste caso, você deve criar objetos `dateTime` manualmente com precisão inferior a um milissegundo.

## Parte 1: a solicitação do usuário
<a name="sqs-authentication-user"></a>

A seguir está o processo que você deve seguir para autenticar AWS solicitações usando uma assinatura de solicitação HMAC-SHA.

![\[Diagrama descrevendo a solicitação do usuário.\]](http://docs.aws.amazon.com/pt_br/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-user.png)


1. Crie uma solicitação para AWS. 

1. Calcule uma assinatura com código de autenticação de mensagem de hash com chave (HMAC-SHA) usando sua chave de acesso secreta.

1. Inclua a assinatura e o ID da chave de acesso na solicitação e, em seguida, envie a solicitação para AWS.

## Parte 2: A resposta de AWS
<a name="sqs-authentication-aws"></a>

AWS inicia o seguinte processo em resposta.

![\[Diagrama descrevendo a resposta da AWS.\]](http://docs.aws.amazon.com/pt_br/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-aws.png)


1. AWS usa o ID da chave de acesso para pesquisar sua chave de acesso secreta.

1. AWS gera uma assinatura a partir dos dados da solicitação e da chave de acesso secreta, usando o mesmo algoritmo usado para calcular a assinatura enviada na solicitação.

1. Uma das seguintes situações acontece:
   + Se a assinatura AWS gerada corresponder à que você enviou na solicitação, AWS considere a solicitação autêntica.
   + Se a comparação falhar, a solicitação será descartada e AWS retornará um erro. 

# Ações em lote do Amazon SQS
<a name="sqs-batch-api-actions"></a>

O Amazon SQS fornece ações em lote para ajudar você a reduzir custos e manipular até dez mensagens com uma única ação. Essas ações em lote incluem:
+ `[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)`

Com as ações em lote, é possível realizar várias operações em uma única chamada de API, o que ajuda a otimizar o desempenho e reduzir custos. Você pode aproveitar a funcionalidade em lote usando a API de consulta ou qualquer AWS SDK que ofereça suporte às ações em lote do Amazon SQS.

**Detalhes importantes**
+ **Limite de tamanho de mensagem:** o tamanho total de todas as mensagens enviadas em uma única chamada de `SendMessageBatch` não pode exceder 1.048.576 bytes (1 MiB)
+ **Permissões:** não é possível definir permissões explicitamente para `SendMessageBatch`, `DeleteMessageBatch` ou `ChangeMessageVisibilityBatch`. Em vez disso, a definição de permissões para `SendMessage`, `DeleteMessage` ou `ChangeMessageVisibility` define permissões para as versões de lote correspondentes dessas ações.
+ **Suporte do console:** o console do Amazon SQS não é compatível com ações em lote. Você deve usar a API de consulta ou um AWS SDK para realizar operações em lote.

## Agrupar ações de mensagem em lotes
<a name="batching-message-actions"></a>

Para otimizar ainda mais os custos e a eficiência, considere as seguintes práticas recomendadas para agrupar ações de mensagens em lote:
+ **Ações de API em lote:** use as [ações de API em lote do Amazon SQS](#sqs-batch-api-actions) para enviar, receber e excluir mensagens, e para alterar o tempo limite de visibilidade de várias mensagens com uma única ação. Isso reduz o número de chamadas de API e os custos associados.
+ **Buffer do lado do cliente e sondagem longa:** combine o buffer do lado do cliente com o agrupamento de solicitações em lote usando a sondagem longa com o [cliente assíncrono em buffer](sqs-client-side-buffering-request-batching.md) incluído no AWS SDK para Java. Essa abordagem ajuda a minimizar o número de solicitações e otimiza o gerenciamento de grandes volumes de mensagens.

**nota**  
Atualmente, o cliente assíncrono no buffer do Amazon SQS não oferece suporte a filas FIFO.

# Habilitar o buffer no lado do cliente e o agrupamento de solicitações em lote com o Amazon SQS
<a name="sqs-client-side-buffering-request-batching"></a>

O [AWS SDK para Java](https://aws.amazon.com/sdkforjava/) inclui o `AmazonSQSBufferedAsyncClient`, que acessa o Amazon SQS. Esse cliente permite um simples agrupamento em lote de solicitações usando o buffer do lado do cliente. Chamadas feitas do cliente são armazenadas primeiramente em buffer, depois enviadas como uma solicitação em lote para o Amazon SQS.

O armazenamento em buffer no lado do cliente permite que até 10 solicitações sejam armazenadas em buffer e enviadas como uma solicitação em lote, diminuindo o custo de uso do Amazon SQS e reduzindo o número de solicitações enviadas. O `AmazonSQSBufferedAsyncClient` armazena tanto as chamadas síncronas quanto as assíncronas em buffer. Solicitações em lote e suporte para [sondagem longa](sqs-short-and-long-polling.md) também podem ajudar a aumentar a taxa de transferência. Para obter mais informações, consulte [Aumento do throughput usando escalabilidade horizontal e processamento de ações em lote com o Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).

como o `AmazonSQSBufferedAsyncClient` implementa a mesma interface que o `AmazonSQSAsyncClient`, migrar de `AmazonSQSAsyncClient` para `AmazonSQSBufferedAsyncClient` normalmente requer apenas pequenas mudanças no seu código existente.

**nota**  
Atualmente, o cliente assíncrono no buffer do Amazon SQS não oferece suporte a filas FIFO.

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

Antes de começar, conclua as etapas em [Configurar o Amazon SQS](sqs-setting-up.md). 

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

Para o AWS SDK for Java 1.x, você pode criar um `AmazonSQSBufferedAsyncClient` novo com base no exemplo a seguir:

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

Depois de criar o novo `AmazonSQSBufferedAsyncClient`, você pode usá-lo para enviar várias solicitações ao Amazon SQS (da mesma forma que faria com o `AmazonSQSAsyncClient`), por exemplo:

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

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

O `AmazonSQSBufferedAsyncClient` é pré-configurado com configurações que funcionarão para a maioria dos casos de uso. Você pode configurar ainda mais o `AmazonSQSBufferedAsyncClient`, por exemplo:

1. Crie uma instância da classe `QueueBufferConfig` com os parâmetros de configuração necessários.

1. Informe a instância para o construtor `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 parâmetros de configuração**  

| Parâmetro | Valor padrão  | Description | 
| --- | --- | --- | 
| longPoll | true |  Quando `longPoll` está definido como `true`, `AmazonSQSBufferedAsyncClient` tenta usar a sondagem longa ao consumir mensagens.  | 
| longPollWaitTimeoutSeconds | 20 s |  A quantidade máxima de tempo, em segundos, em que uma chamada `ReceiveMessage` é bloqueada no servidor aguardando as mensagens aparecerem na fila antes de retornar com um resultado de recebimento vazio.  Quando a sondagem longa está desativada, essa configuração não tem efeito.   | 
| maxBatchOpenMs | 200ms |  A quantidade máxima de tempo (em milissegundos) que uma chamada de saída aguarda outras chamadas com as quais ela coloca mensagens do mesmo tipo em lote. Quanto maior for a configuração, menos lotes serão necessários para executar a mesma quantidade de trabalho (no entanto, a primeira chamada em um lote deve passar mais tempo em espera). Quando esse parâmetro é definido como `0`, as solicitações enviadas não aguardam outras solicitações, desativando efetivamente o processamento em lotes.  | 
| maxBatchSize | 10 solicitações por lote |  O número máximo de mensagens que são armazenadas em lote em uma única solicitação. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações.  Dez solicitações por lote é o valor máximo permitido para o Amazon SQS.   | 
| maxBatchSizeBytes | 1 MiB |  O tamanho máximo de um lote de mensagens, em bytes, que o cliente tenta enviar ao Amazon SQS.  1 MiB é o valor máximo permitido para o Amazon SQS.   | 
| maxDoneReceiveBatches | 10 lotes |  O número máximo de lotes de recebimento que `AmazonSQSBufferedAsyncClient` pré-busca e armazena no lado do cliente. Quanto maior for a configuração, mais solicitações de recebimento poderão ser atendidas sem a necessidade de fazer uma chamada ao Amazon SQS (no entanto, quanto mais mensagens forem buscadas previamente, mais tempo elas permanecerão no buffer, fazendo com que o tempo limite de visibilidade expire).  `0` indica que toda a pré-busca de mensagens está desabilitada e as mensagens são consumidas apenas sob demanda.   | 
| maxInflightOutboundBatches | 5 lotes |  O número máximo de lotes de saída ativos que podem ser processados ao mesmo tempo. Quanto maior for a configuração, mais rapidamente os lotes de saída poderão ser enviados (sujeito a outras cotas, como CPU ou largura de banda) e mais threads serão consumidos pelo `AmazonSQSBufferedAsyncClient`.  | 
| maxInflightReceiveBatches | 10 lotes |  O número máximo de lotes de recebimento ativos que podem ser processados ao mesmo tempo. Quanto maior for a configuração, mais mensagens serão recebidas (sujeito a outras cotas, como CPU ou largura de banda) e mais threads serão consumidos pelo `AmazonSQSBufferedAsyncClient`.  `0` indica que toda a pré-busca de mensagens está desabilitada e as mensagens são consumidas apenas sob demanda.   | 
| visibilityTimeoutSeconds | -1 |  Quando esse parâmetro é definido como um valor positivo e diferente de zero, o tempo limite de visibilidade definido aqui substitui o tempo limite de visibilidade definido na fila a partir da qual as mensagens são consumidas.  `-1` indica que a configuração padrão foi selecionada para a fila. Não é possível configurar o tempo limite de visibilidade para `0`.   | 

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

Para o AWS SDK for Java 2.x, você pode criar um `SqsAsyncBatchManager` novo com base no exemplo a seguir:

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

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

Depois de criar o novo `SqsAsyncBatchManager`, você pode usá-lo para enviar várias solicitações ao Amazon SQS (da mesma forma que faria com o `SqsAsyncClient`), por exemplo:

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

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

O `SqsAsyncBatchManager` é pré-configurado com configurações que funcionarão para a maioria dos casos de uso. Você pode configurar ainda mais o `SqsAsyncBatchManager`, por exemplo:

Como criar configurações personalizadas usando o `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();
```


**Parâmetros do `BatchOverrideConfiguration`**  

| Parâmetro | Valor padrão  | Description | 
| --- | --- | --- | 
| maxBatchSize |  10 solicitações por lote  | O número máximo de mensagens que são armazenadas em lote em uma única solicitação. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações.  O valor máximo permitido para o Amazon SQS é de 10 solicitações por lote.  | 
| sendRequestFrequency |  200ms  | A quantidade máxima de tempo (em milissegundos) que uma chamada de saída aguarda outras chamadas com as quais ela coloca mensagens do mesmo tipo em lote. Quanto maior for a configuração, menos lotes serão necessários para executar a mesma quantidade de trabalho (no entanto, a primeira chamada em um lote deve passar mais tempo em espera). Quando esse parâmetro é definido como `0`, as solicitações enviadas não aguardam outras solicitações, desativando efetivamente o processamento em lotes. | 
| receiveMessageVisibilityTimeout |  -1  | Quando esse parâmetro é definido como um valor positivo e diferente de zero, o tempo limite de visibilidade definido aqui substitui o tempo limite de visibilidade definido na fila a partir da qual as mensagens são consumidas.   `1` indica que a configuração padrão foi selecionada para a fila. Não é possível configurar o tempo limite de visibilidade para `0`.   | 
| receiveMessageMinWaitDuration |  50 ms  | O tempo mínimo (em milissegundos) que uma chamada de `receiveMessage` aguardará para que as mensagens disponíveis sejam buscadas. Quanto maior a configuração, menos lotes serão necessários para executar o mesmo número de solicitações.  | 

# Aumento do throughput usando escalabilidade horizontal e processamento de ações em lote com o Amazon SQS
<a name="sqs-throughput-horizontal-scaling-and-batching"></a>

O Amazon SQS é compatível com mensagens de alto throughput. Para obter detalhes sobre os limites de throughput, consulte [Cotas de mensagens do Amazon SQS](quotas-messages.md).

Para maximizar o throughput:
+ [Escale](#horizontal-scaling) produtores e consumidores horizontalmente adicionando mais instâncias de cada um.
+ Use o [agrupamento de ações em lote](#request-batching) para enviar ou receber várias mensagens em uma única solicitação, reduzindo a sobrecarga de chamadas da API.

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

Como você acessa o Amazon SQS por meio de um protocolo HTTP de solicitação-resposta, *a latência da solicitação* (o intervalo de tempo entre o início de uma solicitação e o recebimento de uma resposta) limita a taxa de transferência que você pode obter de uma única thread por meio de uma única conexão. Por exemplo, se a latência média de um cliente com base no Amazon EC2 para o Amazon SQS na mesma região for de cerca de 20 ms, a taxa de transferência máxima de uma única thread por meio de uma única conexão será em média 50 TPS. 

*A escalabilidade horizontal* envolve o aumento do número de produtores de mensagem (que fazem a solicitação `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)`) e dos consumidores (que fazem solicitações `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` e `[DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)`) para aumentar sua taxa de transferência de fila geral. Você pode escalar horizontalmente de três formas:
+ Aumentar o número de threads por cliente
+ Adicionar mais clientes
+ Aumentar o número de threads por cliente e adicionar mais clientes

Ao adicionar mais clientes, você obtém ganhos essencialmente lineares na taxa de transferência da fila. Por exemplo, se você dobrar o número de clientes, terá duas vezes a taxa de transferência. 

## Processamento de ações em lotes
<a name="request-batching"></a>

*O processamento em lotes* executa mais trabalho durante a ida e a volta do serviço (por exemplo, quando você envia várias mensagens com uma única solicitação `SendMessageBatch`). As ações de em lote do Amazon SQS são `[SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)`, `[DeleteMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html)` e `[ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)`. Para aproveitar o processamento em lotes sem alterar os produtores ou consumidores, você pode usar o [cliente assíncrono armazenado em buffer para o Amazon SQS](sqs-client-side-buffering-request-batching.md).

**nota**  
Como `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` pode processar 10 mensagens por vez, não há nenhuma ação `ReceiveMessageBatch`.

O processamento em lotes distribui a latência da ação de lote nas várias mensagens de uma solicitação em lote em vez de aceitar toda a latência para uma única mensagem (por exemplo, uma solicitação `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)`). Como cada ida e volta carrega mais trabalho, as solicitações de lote tornam mais eficiente o uso de threads e conexões, melhorando, dessa forma, a taxa de transferência.

Você pode combinar processamentos em lote com escalabilidade horizontal para fornecer taxa de transferência com menos threads, conexões e solicitações em comparação com as solicitações de mensagens individuais. Você pode usar ações em lotes do Amazon SQS para enviar, receber ou excluir até 10 mensagens por vez. Como o Amazon SQS cobra por solicitação, o processamento em lotes pode reduzir substancialmente os custos. 

O processamento em lotes pode criar certa complexidade para o seu aplicativo (por exemplo, o aplicativo precisa acumular as mensagens antes de enviá-las e, às vezes, precisará esperar mais por uma resposta). No entanto, o processamento em lotes pode ser eficaz nos seguintes casos: 
+ Seu aplicativo gera muitas mensagens em um curto intervalo de tempo, portanto, o atraso nunca é muito longo. 
+ Um consumidor de mensagem busca as mensagens de uma fila a seu critério, ao contrário de produtores de mensagem típicos que precisam enviar mensagens em resposta a eventos que eles não controlam. 

**Importante**  
Uma solicitação de lote pode ser bem-sucedida, mesmo que ocorra falha nas mensagens individuais no lote. Após uma solicitação de lote, você sempre deve verificar a existência de falhas em mensagens individuais e repetir a ação, se necessário.

## Exemplo de Java funcional para operações únicas e solicitações em lote
<a name="working-java-example-batch-requests"></a>

### Pré-requisitos
<a name="batch-request-java-example-prerequisites"></a>

Adicione os pacotes `aws-java-sdk-sqs.jar`, `aws-java-sdk-ec2.jar` e `commons-logging.jar` ao caminho da classe de compilação do Java. O exemplo a seguir mostra essas dependências em um arquivo `pom.xml` do projeto 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.java
<a name="batch-request-java-example-code"></a>

O exemplo de código Java a seguir implementa um padrão simples de produtor-consumidor. O thread principal gera um número de threads de produtor e consumidor que processam mensagens de 1 KB em um determinado momento. Ele inclui produtores e os consumidores que fazem solicitações de operação únicas e outros que fazem solicitações de lote.

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

### Monitorar métricas de volume da execução de exemplo
<a name="batch-request-java-example-monitoring-metrics"></a>

O Amazon SQS gera automaticamente métricas de volume para mensagens enviadas, recebidas e excluídas. Você pode acessar essas métricas e outras por meio da guia **Monitoring (Monitoramento)** de sua fila ou no [console do CloudWatch ](https://console.aws.amazon.com/cloudwatch/home).

**nota**  
As métricas podem levar até 15 minutos após a fila começar para ficar disponíveis.

# Usar o Amazon SQS com um SDK da AWS
<a name="sdk-general-information-section"></a>

AWSOs kits de desenvolvimento de software (SDKs) da estão disponíveis para muitas linguagens de programação populares. Cada SDK fornece uma API, exemplos de código e documentação que permitem que os desenvolvedores criem facilmente aplicações em seu idioma de preferência.


| Documentação do SDK | Exemplos de código | 
| --- | --- | 
| [AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK para C\$1\$1 Exemplos de código do](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) | 
| [AWS CLI](https://docs.aws.amazon.com/cli) | [AWS CLI Exemplos de código da](https://docs.aws.amazon.com/code-library/latest/ug/cli_2_code_examples.html) | 
| [AWS SDK para Go](https://docs.aws.amazon.com/sdk-for-go) | [AWS SDK para Go Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2) | 
| [AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java) | [AWS SDK para Java Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2) | 
| [AWS SDK para JavaScript](https://docs.aws.amazon.com/sdk-for-javascript) | [AWS SDK para JavaScript Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3) | 
| [AWS SDK para Kotlin](https://docs.aws.amazon.com/sdk-for-kotlin) | [AWS SDK para Kotlin Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin) | 
| [AWS SDK para .NET](https://docs.aws.amazon.com/sdk-for-net) | [AWS SDK para .NET Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3) | 
| [AWS SDK para PHP](https://docs.aws.amazon.com/sdk-for-php) | [AWS SDK para PHP Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) | 
| [Ferramentas da AWS para PowerShell](https://docs.aws.amazon.com/powershell) | [Ferramentas da AWS para PowerShell Exemplos de código da](https://docs.aws.amazon.com/code-library/latest/ug/powershell_5_code_examples.html) | 
| [AWS SDK para Python (Boto3)](https://docs.aws.amazon.com/pythonsdk) | [AWS SDK para Python (Boto3) Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python) | 
| [AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby) | [AWS SDK para Ruby Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby) | 
| [AWS SDK para Rust](https://docs.aws.amazon.com/sdk-for-rust) | [AWS SDK para Rust Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1) | 
| [AWS SDK para SAP ABAP](https://docs.aws.amazon.com/sdk-for-sapabap) | [AWS SDK para SAP ABAP Exemplos de código da](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap) | 
| [AWS SDK para Swift](https://docs.aws.amazon.com/sdk-for-swift) | [AWS SDK para Swift Exemplos de código do](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) | 

**Exemplo de disponibilidade**  
Não consegue encontrar o que precisa? Solicite um exemplo de código usando o link **Fornecer feedback** na parte inferior desta página.