

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de API con Amazon SQS
<a name="sqs-working-with-apis"></a>

En esta tema se proporciona información sobre cómo crear puntos de conexión de Amazon SQS, realizar solicitudes de API de consulta mediante los métodos GET y POST y utilizar acciones de API por lotes. Para obtener información detallada sobre las [acciones](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) de Amazon SQS (como parámetros, errores, ejemplos y [tipos de datos](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Types.html)), consulte la [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/).

Si desea obtener acceso a Amazon SQS mediante diferentes lenguajes de programación, también puede utilizar los [AWS SDK](https://aws.amazon.com/tools/#sdk), que contienen la siguiente funcionalidad automática:
+ Firmar criptográficamente sus solicitudes de servicio
+ Reintentar solicitudes
+ Tratar las respuestas a errores

Para obtener más información, consulte [Uso de Amazon SQS con un AWS SDK](sdk-general-information-section.md).

Para obtener información sobre la herramienta de línea de comandos, consulte las secciones de Amazon SQS en la [https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html](https://docs.aws.amazon.com/cli/latest/reference/sqs/index.html) y la [https://docs.aws.amazon.com/powershell/latest/reference/](https://docs.aws.amazon.com/powershell/latest/reference/).

**API de Amazon SQS con protocolo AWS JSON**

Amazon SQS utiliza el protocolo AWS JSON como mecanismo de transporte para todas las API de Amazon SQS en las [versiones de AWS SDK](sqs-json-faqs.md#json-protocol-getting-started) especificadas. AWS El protocolo JSON proporciona un mayor rendimiento, menor latencia y una comunicación más rápida entre las aplicaciones. AWS El protocolo JSON es más eficiente en la serialización o deserialización de solicitudes y respuestas en comparación con el protocolo de consulta de AWS. Si aún así prefiere utilizar el protocolo de consulta de AWS con las API de SQS, consulte [¿Qué idiomas son compatibles con el protocolo AWS JSON que se utiliza en Amazon SQS? APIs](sqs-json-faqs.md#json-protocol-supported-languages) para las versiones de AWS SDK que admiten el protocolo de consulta de AWS de Amazon SQS.

Amazon SQS utiliza el protocolo AWS JSON para comunicar entre los clientes de AWS SDK (por ejemplo, Java, Python, Golang, JavaScript) y el servidor de Amazon SQS. Una solicitud HTTP de una operación de la API de Amazon SQS acepta la entrada con formato JSON. La operación de Amazon SQS se ejecuta y la respuesta de la ejecución se comparte de nuevo con el cliente del SDK en formato JSON. En comparación con las consultas de AWS, AWS JSON es más simple, rápido y eficiente a la hora de transportar datos entre el cliente y el servidor.
+ El protocolo AWS JSON actúa como mediador entre el cliente y el servidor de Amazon SQS.
+ El servidor no entiende el lenguaje de programación en el que se crea la operación de Amazon SQS, pero entiende el protocolo AWS JSON.
+ El protocolo AWS JSON utiliza la serialización (convertir el objeto al formato JSON) y la deserialización (convertir el formato JSON a objeto) entre el cliente y el servidor de Amazon SQS.

Para obtener más información sobre el protocolo AWS JSON con Amazon SQS, consulte [Protocolo Amazon SQS JSON AWS FAQs](sqs-json-faqs.md).

El protocolo AWS JSON está disponible en la [versión de AWS SDK](sqs-json-faqs.md#json-protocol-getting-started) especificada. Para consultar la versión y las fechas de lanzamiento del SDK en las distintas variantes de lenguaje, consulte [Matriz de compatibilidad para versiones de SDK y herramientas de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/version-support-matrix.html) en la *Guía de referencia de los SDK y las herramientas de AWS*.

# Realizar solicitudes de API de consulta mediante el protocolo AWS JSON en Amazon SQS
<a name="sqs-making-api-requests-json"></a>

En este tema se explica cómo crear un punto de conexión de Amazon SQS, realizar solicitudes POST e interpretar las respuestas.

**nota**  
AWS El protocolo JSON es compatible con la mayoría de las variantes de idioma. Para ver una lista completa de las variantes de lenguaje admitidas, consulte [¿Qué idiomas son compatibles con el protocolo AWS JSON que se utiliza en Amazon SQS? APIs](sqs-json-faqs.md#json-protocol-supported-languages).

## Construcción de un punto de enlace
<a name="sqs-api-constructing-endpoints-json"></a>

Para trabajar con colas de Amazon SQS, debe crear un punto de conexión. Para obtener información sobre los puntos de conexión de Amazon SQS, consulte las páginas siguientes en *Referencia general de Amazon Web Services*:
+ [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)
+ [Puntos de conexión y cuotas de Amazon Simple Queue Service](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Cada punto de conexión de Amazon SQS es independiente. Por ejemplo, si dos colas se denominan *MyQueue* y una tiene el punto de enlace `sqs.us-east-2.amazonaws.com` mientras que la otra tiene el punto de enlace `sqs.eu-west-2.amazonaws.com`, no comparten ningún dato entre ellas.

A continuación, se muestra un ejemplo de un punto de conexión que realiza una solicitud para crear una cola. 

```
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**  
Los nombres de las colas y las colas URLs distinguen mayúsculas de minúsculas.  
La estructura de *`AUTHPARAMS`* depende de la firma de la solicitud de API. Para obtener más información, consulte [Firmar solicitudes de AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) en la *Referencia general de Amazon Web Services*.

## Realizar una solicitud POST
<a name="structure-post-request"></a>

Las solicitudes POST de Amazon SQS envían parámetros de consulta como un formulario en el cuerpo de una solicitud HTTP.

A continuación, se muestra un ejemplo de un encabezado HTTP con `X-Amz-Target` establecido a `AmazonSQS.<operationName>` y de un encabezado HTTP con `Content-Type` establecido a `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"
}
```

Esta solicitud HTTP POST envía un mensaje a una cola de Amazon SQS.

**nota**  
Ambos encabezados HTTP `X-Amz-Target` y `Content-Type` son obligatorios.  
El cliente HTTP puede añadir otros elementos a la solicitud HTTP, según la versión de HTTP del cliente.

# Interpretación de las respuestas de la API JSON de Amazon SQS
<a name="sqs-json-api-responses"></a>

Cuando envía una solicitud a Amazon SQS, devuelve una respuesta JSON con los resultados. La estructura de la respuesta depende de la acción de la API que haya utilizado.

Para obtener más información sobre estas respuestas, consulte:
+ La acción específica de la API en las [acciones de la API](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) de la *Referencia de la API de Amazon Simple Queue Service*
+ la [Protocolo Amazon SQS JSON AWS FAQs](sqs-json-faqs.md),

## Estructura de una respuesta JSON correcta
<a name="sqs-json-api-successful-response-structure"></a>

Si la solicitud se realiza correctamente, el elemento de respuesta principal es `x-amzn-RequestId`, que contiene el identificador único universal (UUID) de la solicitud, así como otros campos de respuesta añadidos. Por ejemplo, la siguiente respuesta [https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_CreateQueue.html) contiene el campo `QueueUrl` que, a su vez, contiene la URL de la cola creada.

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

## Estructura de una respuesta de error JSON
<a name="sqs-api-error-response-structure"></a>

Si una solicitud no se realiza correctamente, Amazon SQS devuelve la respuesta principal, incluidos el encabezado HTTP y el cuerpo.

En el encabezado HTTP, `x-amzn-RequestId` contiene el UUID de la solicitud. `x-amzn-query-error` contiene dos informaciones: el tipo de error y si se trata de un error del productor o del consumidor. 

En el cuerpo de la respuesta, `"__type"` indica otros detalles del error y `Message` señala la condición del error en un formato legible. 

El siguiente es un ejemplo de respuesta de error en 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>

En este tema se tratan las preguntas más frecuentes sobre el uso del protocolo AWS JSON con Amazon SQS.

## ¿Qué es el protocolo AWS JSON y en qué se diferencia de las solicitudes y respuestas de la API Amazon SQS existentes?
<a name="json-protocol-what-is"></a>

JSON es uno de los métodos de conexión más utilizados y aceptados para la comunicación entre sistemas heterogéneos. Amazon SQS utiliza JSON como medio de comunicación entre un cliente AWS del SDK (por ejemplo, Java, Python, Golang JavaScript) y el servidor Amazon SQS. Una solicitud HTTP de una operación de la API de Amazon SQS acepta entradas en formato JSON. La operación de Amazon SQS se ejecuta y la respuesta de la ejecución se comparte de nuevo con el cliente del SDK en formato JSON. En comparación con las consultas de AWS , JSON es más eficiente a la hora de transportar datos entre el cliente y el servidor. 
+ El protocolo Amazon SQS AWS JSON actúa como mediador entre el cliente y el servidor de Amazon SQS.
+ El servidor no entiende el lenguaje de programación en el que se crea la operación de Amazon SQS, pero entiende el protocolo AWS JSON.
+ El protocolo Amazon SQS AWS JSON utiliza la serialización (convierte el objeto a formato JSON) y la deserialización (convierte el formato JSON en objeto) entre el cliente y el servidor de Amazon SQS.

## ¿Cómo puedo empezar a utilizar los protocolos AWS JSON para Amazon SQS?
<a name="json-protocol-getting-started"></a>

Para empezar a utilizar la última versión del AWS SDK y lograr una mensajería más rápida para Amazon SQS, actualice el AWS SDK a la versión especificada o a cualquier versión posterior. Para obtener más información sobre los clientes del SDK, consulte la columna Guía de la tabla siguiente.

La siguiente es una lista de las versiones del SDK en todas las variantes de idioma del protocolo AWS JSON para su uso con Amazon SQS: APIs


| Idioma | Repositorio de clientes del SDK | Versión de cliente del SDK requerida | Guía | 
| --- | --- | --- | --- | 
|  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  |  [aws/ 2 aws-sdk-go-v](https://github.com/aws/aws-sdk-go-v2)  |  [v1.28.0](https://github.com/aws/aws-sdk-go-v2/blob/release-2023-11-09/service/sqs/CHANGELOG.md#v1270-2023-11-09)  |  [AWS SDK 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  |  [aws/ 2 aws-sdk-java-v](https://github.com/aws/aws-sdk-java-v2)  |  [2.21.19](https://github.com/aws/aws-sdk-java-v2/releases/tag/2.21.19)  |  [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/)  | 
|  JavaScript v2.x  |  [aws/ aws-sdk-js](https://github.com/aws/aws-sdk-js)  |  [JavaScript en AWS](https://aws.amazon.com/developer/language/javascript/)  | 
|  JavaScript v3.x  |  [aws/ 3 aws-sdk-js-v](https://github.com/aws/aws-sdk-js-v3)  |  [v3.447.0](https://github.com/aws/aws-sdk-js-v3/releases/tag/v3.447.0)  |  [JavaScript en 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  |  [CLI de AWS](https://github.com/aws/aws-cli)  |  [1.29.82](https://github.com/aws/aws-cli/releases/tag/1.29.82)  |  [Interfaz de la línea de comandos de AWS](https://aws.amazon.com/cli/)  | 
|  Ruby  |  [aws/ aws-sdk-ruby](https://github.com/aws/aws-sdk-ruby)  |  [1.67.0](https://rubygems.org/gems/aws-sdk-sqs/versions/1.67.0)  |  [AWS SDK para Ruby](https://aws.amazon.com/sdk-for-ruby/)  | 

## ¿Cuáles son los riesgos de habilitar el protocolo JSON para mis cargas de trabajo de Amazon SQS?
<a name="json-protocol-risks"></a>

Si utiliza una implementación personalizada del AWS SDK o una combinación de clientes personalizados y un AWS SDK para interactuar con Amazon SQS que genera respuestas basadas en AWS consultas (también conocidas como basadas en XML), es posible que no sea compatible con el protocolo JSON. AWS Si tiene algún problema, póngase en contacto con AWS Support.

## ¿Qué sucede si ya tengo la última versión del AWS SDK, pero mi solución de código abierto no es compatible con JSON?
<a name="json-protocol-sdk-version-open-source"></a>

Debe cambiar la versión del SDK por la anterior a la que esté utilizando. Consulte [¿Cómo puedo empezar a utilizar los protocolos AWS JSON para Amazon SQS?](#json-protocol-getting-started) para obtener más información. AWS Las versiones del SDK que aparecen en [¿Cómo puedo empezar a utilizar los protocolos AWS JSON para Amazon SQS?](#json-protocol-getting-started) utilizan el protocolo JSON wire para Amazon SQS APIs. Si cambia el AWS SDK a la versión anterior, Amazon SQS APIs utilizará la AWS consulta.

## ¿Qué idiomas son compatibles con el protocolo AWS JSON que se utiliza en Amazon SQS? APIs
<a name="json-protocol-supported-languages"></a>

Amazon SQS admite todas las variantes de idioma en las que AWS SDKs estén disponibles de forma general (GA). Actualmente, no se admite Kotlin, Rust ni Swift. Para obtener más información sobre otras variantes de lenguaje, consulte [Herramientas para crear en AWS](https://aws.amazon.com/developer/tools/).

## ¿Qué regiones son compatibles con el protocolo AWS JSON utilizado en Amazon SQS? APIs
<a name="json-protocol-supported-regions"></a>

Amazon SQS admite el protocolo AWS JSON en todas [AWS las regiones](https://docs.aws.amazon.com/general/latest/gr/sqs-service.html) en las que Amazon SQS está disponible. 

## ¿Qué mejoras de latencia puedo esperar al actualizar a las versiones de AWS SDK especificadas para Amazon SQS mediante el protocolo AWS JSON?
<a name="json-protocol-upgrading-sdk"></a>

AWS El protocolo JSON es más eficiente en la serialización y deserialización de solicitudes y respuestas en comparación con el protocolo de consultas. AWS Según las pruebas de AWS rendimiento para una carga útil de mensajes de 5 KB, el protocolo JSON para Amazon SQS end-to-end reduce la latencia del procesamiento de mensajes hasta un 23% y reduce el uso de CPU y memoria del lado del cliente de la aplicación. 

## ¿Quedará AWS obsoleto el protocolo de consultas?
<a name="query-protocol"></a>

AWS el protocolo de consulta seguirá siendo compatible. Puede seguir utilizando el protocolo de AWS consultas siempre que la versión AWS del SDK esté configurada en una versión anterior distinta de la que se indica en [Cómo empezar con los protocolos AWS JSON para Amazon SQS](#json-protocol-getting-started).

## ¿Dónde puedo encontrar más información sobre el protocolo AWS JSON?
<a name="json-protocol-more-info"></a>

Puede encontrar más información sobre el protocolo JSON en [Protocolo AWS JSON 1.0](https://smithy.io/2.0/aws/protocols/aws-json-1_0-protocol.html) en la documentación de *Smithy*. Para obtener más información sobre las solicitudes de la API de Amazon SQS mediante el protocolo AWS JSON, consulte [Realizar solicitudes de API de consulta mediante el protocolo AWS JSON en Amazon SQS](sqs-making-api-requests-json.md).

# Realizar solicitudes de API de AWS consultas mediante el protocolo de consultas en Amazon SQS
<a name="sqs-making-api-requests-xml"></a>

En este tema se explica cómo crear un punto de conexión de Amazon SQS, realizar solicitudes GET y POST e interpretar respuestas.

## Construcción de un punto de enlace
<a name="sqs-api-constructing-endpoints"></a>

Para trabajar con colas de Amazon SQS, debe crear un punto de conexión. Para obtener información sobre los puntos de conexión de Amazon SQS, consulte las páginas siguientes en *Referencia general de Amazon Web Services*:
+ [Puntos de conexión regionales](https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region)
+ [Puntos de conexión y cuotas de Amazon Simple Queue Service](https://docs.aws.amazon.com/general/latest/gr/sqs-service)

Cada punto de conexión de Amazon SQS es independiente. Por ejemplo, si dos colas se denominan *MyQueue* y una tiene el punto de enlace `sqs.us-east-2.amazonaws.com` mientras que la otra tiene el punto de enlace `sqs.eu-west-2.amazonaws.com`, no comparten ningún dato entre ellas.

A continuación se muestra un ejemplo de un punto de enlace que realiza una solicitud para crear una cola. 

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

**nota**  
Los nombres de las colas y las colas URLs distinguen mayúsculas de minúsculas.  
La estructura de *`AUTHPARAMS`* depende de la firma de la solicitud de API. Para obtener más información, consulte [Firmar solicitudes de AWS API](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) en la *Referencia general de Amazon Web Services*.

## Realizar una solicitud GET
<a name="structure-get-request"></a>

Una solicitud GET de Amazon SQS se estructura como una URL que consta de los siguientes elementos:
+ **Punto de conexión**: el recurso sobre el que actúa la solicitud (el [nombre y la URL de la cola](sqs-queue-message-identifiers.md#queue-name-url)); por ejemplo, `https://sqs.us-east-2.amazonaws.com/123456789012/MyQueue`
+ **Acción**: la [acción](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) que se desea realizar en el punto de conexión. Se utiliza un signo de interrogación (`?`) para separar el punto de enlace de la acción; por ejemplo, `?Action=SendMessage&MessageBody=Your%20Message%20Text`
+ **Parámetros**: los parámetros de la solicitud. Cada parámetro está separado del siguiente por el signo `&`; por ejemplo, `&Version=2012-11-05&AUTHPARAMS` 

A continuación se muestra un ejemplo de una solicitud GET que envía un mensaje a una cola de Amazon SQS.

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

**nota**  
Los nombres de las colas y las colas URLs distinguen mayúsculas de minúsculas.  
Como las solicitudes GET lo son URLs, debe codificar en URL todos los valores de los parámetros. Como no se permite la entrada de espacios URLs, cada espacio está codificado como URL. `%20` El resto del ejemplo no se ha codificado como URL para facilitar su lectura.

## Realizar una solicitud POST
<a name="structure-post-request"></a>

Las solicitudes POST de Amazon SQS envían parámetros de consulta como un formulario en el cuerpo de una solicitud HTTP.

A continuación, se muestra un ejemplo de encabezado HTTP con `Content-Type` establecido a `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
```

Al encabezado le sigue una solicitud GET de `[form-urlencoded](https://www.w3.org/MarkUp/html-spec/html-spec_8.html#SEC8.2)` que envía un mensaje a una cola de Amazon SQS. Cada parámetro está separado del siguiente por un signo ampersand (`&`).

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

**nota**  
Solo es obligatorio el encabezado de HTTP `Content-Type`. El parámetro `AUTHPARAMS` es el mismo que para la solicitud GET.  
El cliente HTTP puede añadir otros elementos a la solicitud HTTP, según la versión de HTTP del cliente.

# Interpretación de las respuestas de la API XML de Amazon SQS
<a name="sqs-xml-api-responses"></a>

Cuando envía una solicitud a Amazon SQS, devuelve una respuesta XML que contiene los resultados de la solicitud. Para obtener más información sobre la estructura y los detalles de estas respuestas, consulte las [acciones de la API](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_Operations.html) específicas en la *Referencia de la API de Amazon Simple Queue Service*.

## Estructura de una respuesta XML correcta
<a name="sqs-api-successful-response-structure"></a>

Si la solicitud se realiza correctamente, el elemento principal de la respuesta tiene el mismo nombre que la acción, pero se le añade `Response` (por ejemplo, `ActionNameResponse`).

Este elemento contiene los siguientes elementos secundarios:
+ **`ActionNameResult`**: contiene un elemento específico de la acción. Por ejemplo, el elemento `CreateQueueResult` contiene el elemento `QueueUrl` que, a su vez, contiene la URL de la cola que se ha creado.
+ **`ResponseMetadata`**: contiene el `RequestId` que, a su vez, contiene el identificador único universal (UUID) de la solicitud.

A continuación se muestra un ejemplo de una respuesta correcta en 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>
```

## Estructura de una respuesta de error XML
<a name="sqs-api-error-response-structure"></a>

Si una solicitud no se realiza correctamente, Amazon SQS siempre devuelve el elemento principal de la respuesta `ErrorResponse`. Este elemento contiene un elemento `Error` y un elemento `RequestId`.

El elemento `Error` contiene los siguientes elementos secundarios:
+ **`Type`**: especifica si se trata de un error del productor o del consumidor.
+ **`Code`**: especifica el tipo de error.
+ **`Message`**: especifica la condición de error en formato legible.
+ **`Detail`**: (opcional) especifica información adicional sobre el error.

El elemento `RequestId` contiene el UUID de la solicitud.

A continuación se muestra un ejemplo de una respuesta de error en 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>
```

# Autenticación de solicitudes para Amazon SQS
<a name="sqs-api-request-authentication"></a>

La autenticación es un proceso para identificar y verificar a la parte que envía una solicitud. Durante la primera fase de la autenticación, AWS verifica la identidad del productor y si está [registrado para utilizar AWS](https://aws.amazon.com/) (para obtener más información, consulte [Paso 1: Crear un usuario de Cuenta de AWS AND IAM](sqs-setting-up.md#sqs-creating-aws-account)). A continuación AWS , sigue el siguiente procedimiento:

1. El productor (remitente) obtiene la credencial necesaria.

1. El productor envía una solicitud y la credencial al consumidor (receptor).

1. El consumidor utiliza la credencial para verificar si el productor envió la solicitud.

1. Se produce una de las circunstancias siguientes:
   + Si la autenticación se realiza correctamente, el consumidor procesa la solicitud.
   + Si se produce un error de autenticación, el consumidor rechaza la solicitud y devuelve un error.

## Proceso básico de autenticación con HMAC-SHA
<a name="sqs-api-basic-authentication-process"></a>

Cuando se obtiene acceso a Amazon SQS con la API de consultas, se deben proporcionar los siguientes elementos para autenticar la solicitud:
+ El **identificador de clave de AWS acceso** que lo identifica Cuenta de AWS y que se AWS utiliza para buscar su clave de acceso secreta.
+ La **firma de la solicitud del HMAC-SHA**, calculada con tu clave de acceso secreta (un secreto compartido que solo tú conoces y que AWS, para obtener más información, consulta). [RFC2104](http://www.faqs.org/rfcs/rfc2104.html) El [AWS SDK](https://aws.amazon.com/code/) se encarga del proceso de firma; sin embargo, si se realiza una solicitud de consulta a través de HTTP o HTTPS, se deberá incluir una firma en cada solicitud de consulta.

  1. Genere una clave firma Signature Version 4. Para obtener más información, consulte [Generación de la clave de firma con Java](https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java).
**nota**  
Amazon SQS es compatible con la versión 4 de Signature, que proporciona seguridad y rendimiento SHA256 mejorados en comparación con las versiones anteriores. Cuando cree aplicaciones nuevas que usen Amazon SQS, utilice Signature Version 4.

  1. codifique en formato base64 la firma de la solicitud. El siguiente ejemplo se de código Java lo hace:

     ```
     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);
         }
     }
     ```
+ La **marca temporal (o vencimiento)** de la solicitud. La marca temporal que utilice en la solicitud debe ser un objeto `dateTime`, con [la fecha completa, incluidas las horas, los minutos y los segundos](http://www.w3.org/TR/xmlschema-2/#dateTime). Por ejemplo: `2007-01-31T23:59:59Z` Aunque no es necesario, le recomendamos que proporcione el objeto utilizando la zona horaria de la hora universal coordinada (hora del meridiano de Greenwich).
**nota**  
Asegúrese de que la hora del servidor esté ajustada correctamente. Si especifica una marca de tiempo (en lugar de una fecha de caducidad), la solicitud caduca automáticamente 15 minutos después de la hora especificada (AWS no procesa las solicitudes con marcas de tiempo más de 15 minutos antes de la hora actual en los servidores). AWS   
Si utiliza .NET, no debe enviar marcas temporales demasiado específicas (debido a las diferentes interpretaciones con respecto a cómo se debe descartar la precisión adicional del tiempo). En este caso, debe crear manualmente objetos `dateTime` con una precisión de no más de un milisegundo.

## Parte 1: la solicitud del usuario
<a name="sqs-authentication-user"></a>

El siguiente es el proceso que debe seguir para autenticar las AWS solicitudes mediante una firma de solicitud del HMAC-SHA.

![\[Diagrama que describe la solicitud del usuario.\]](http://docs.aws.amazon.com/es_es/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-user.png)


1. Cree una solicitud para. AWS

1. Calcule la firma de código de autenticación de mensajes mediante algoritmos hash con clave (HMAC-SHA) utilizando su clave de acceso secreta.

1. Incluye la firma y tu ID de clave de acceso en la solicitud y, a continuación, envía la solicitud a AWS.

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

AWS comienza el siguiente proceso en respuesta.

![\[Diagrama que describe la respuesta de AWS.\]](http://docs.aws.amazon.com/es_es/AWSSimpleQueueService/latest/SQSDeveloperGuide/images/sqs-basic-authentication-process-hmac-aws.png)


1. AWS utiliza el identificador de clave de acceso para buscar su clave de acceso secreta.

1. AWS genera una firma a partir de los datos de la solicitud y la clave de acceso secreta, utilizando el mismo algoritmo que utilizó para calcular la firma que envió en la solicitud.

1. Se produce una de las circunstancias siguientes:
   + Si la firma que se AWS genera coincide con la que se envió en la solicitud, se considerará AWS que la solicitud es auténtica.
   + Si la comparación falla, la solicitud se descarta y AWS devuelve un error. 

# Acciones por lotes de Amazon SQS
<a name="sqs-batch-api-actions"></a>

Amazon SQS permite realizar acciones por lotes para ayudarle a reducir los costos y manipular hasta 10 mensajes con una sola acción. Estas acciones por lotes incluyen:
+ `[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)`

Al utilizar acciones por lotes, puede realizar varias operaciones en una sola llamada a la API, lo que ayuda a optimizar el rendimiento y reducir los costos. Puede aprovechar la funcionalidad por lotes mediante la API de consultas o cualquier AWS SDK que admita las acciones por lotes de Amazon SQS.

**Detalles importantes**
+ **Límite de tamaño de los mensajes:** el tamaño total de todos los mensajes enviados en una única llamada `SendMessageBatch` no puede superar los 1 048 576 bytes (1 MiB).
+ **Permisos:** no se pueden establecer permisos para `SendMessageBatch`, `DeleteMessageBatch` ni `ChangeMessageVisibilityBatch` de forma explícita. Sin embargo, al establecer permisos para `SendMessage`, `DeleteMessage` o `ChangeMessageVisibility`, se establecen también permisos para las versiones por lotes correspondientes de esas acciones.
+ **Soporte de consola:** la consola de Amazon SQS no es compatible con las acciones de procesamiento por lotes. Debe usar la API de consultas o un AWS SDK para realizar operaciones por lotes.

## Procesamiento por lotes de las acciones de los mensajes
<a name="batching-message-actions"></a>

Para optimizar aún más los costos y la eficiencia, tenga en cuenta las siguientes prácticas recomendadas para acciones de mensajes de procesamiento por lotes:
+ **Acciones de la API de procesamiento por lotes:** use las [acciones de la API de procesamiento por lotes de Amazon SQS](#sqs-batch-api-actions) para enviar, recibir y eliminar mensajes, y para cambiar el tiempo de espera de visibilidad de varios mensajes con una sola acción. Esto reduce el número de llamadas a la API y los costos asociados.
+ **Almacenamiento en búfer del cliente y sondeos largos:** combine el almacenamiento en búfer del cliente con el procesamiento de solicitudes por lotes mediante un sondeo largo junto con el [cliente asíncrono con almacenamiento en búfer](sqs-client-side-buffering-request-batching.md) incluido en el AWS SDK para Java. Este enfoque ayuda a minimizar el número de solicitudes y optimiza la gestión de grandes volúmenes de mensajes.

**nota**  
El cliente asíncrono con búfer de Amazon SQS no admite actualmente las colas FIFO.

# Habilitación del almacenamiento en búfer del cliente y del agrupamiento en lotes de solicitudes con Amazon SQS
<a name="sqs-client-side-buffering-request-batching"></a>

[AWS SDK para Java](https://aws.amazon.com/sdkforjava/) incluye `AmazonSQSBufferedAsyncClient` que tiene acceso a Amazon SQS. Este cliente permite agrupar fácilmente en lotes las solicitudes mediante el almacenamiento en búfer del cliente. Las llamadas realizadas desde el cliente se almacenan primero en búfer y, después, se envían como una solicitud por lotes a Amazon SQS.

El almacenamiento en búfer en el cliente permite almacenar en búfer hasta diez solicitudes y enviarlas como una solicitud por lotes, lo que disminuye el costo de uso de Amazon SQS y el número de solicitudes enviadas. `AmazonSQSBufferedAsyncClient` almacena en búfer tanto las llamadas sincrónicas como las asincrónicas. Las solicitudes por lotes y la compatibilidad con los [sondeos largos](sqs-short-and-long-polling.md) también pueden contribuir a mejorar el rendimiento. Para obtener más información, consulte [Aumento del rendimiento mediante el escalado horizontal y agrupación en lotes de acciones con Amazon SQS](sqs-throughput-horizontal-scaling-and-batching.md).

Dado que `AmazonSQSBufferedAsyncClient` implementa la misma interfaz que `AmazonSQSAsyncClient`, la migración de `AmazonSQSAsyncClient` a `AmazonSQSBufferedAsyncClient` solo suele requerir cambios mínimos en el código.

**nota**  
El cliente asíncrono con búfer de Amazon SQS no admite actualmente las colas FIFO.

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

Antes de comenzar, complete los pasos de [Configuración de Amazon SQS](sqs-setting-up.md). 

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

Para el AWS SDK para Java 1.x, puedes crear uno nuevo `AmazonSQSBufferedAsyncClient` basado en el siguiente ejemplo:

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

Después de crear el nuevo `AmazonSQSBufferedAsyncClient`, puede utilizarlo para enviar varias solicitudes a Amazon SQS (del mismo modo que con `AmazonSQSAsyncClient`), por ejemplo:

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

### Configuración de Amazon SQSBuffered AsyncClient
<a name="configuring-buffered-async-client"></a>

`AmazonSQSBufferedAsyncClient` está preconfigurado con ajustes válidos para la mayoría de los casos de uso. Se pueden configurar ajustes adicionales de `AmazonSQSBufferedAsyncClient`; por ejemplo:

1. Crear una instancia de la clase `QueueBufferConfig` con los parámetros de configuración necesarios.

1. Proporcionar la instancia al constructor `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 configuración**  

| Parámetro | Predeterminado | Description (Descripción) | 
| --- | --- | --- | 
| longPoll | true |  Cuando `longPoll` se establece en `true`, `AmazonSQSBufferedAsyncClient` intenta utilizar el sondeo largo a la hora de consumir mensajes.  | 
| longPollWaitTimeoutSeconds | 20 s |  El tiempo máximo, en segundos, que una llamada a `ReceiveMessage` se bloquea en el servidor a la espera de que aparezcan mensajes en la cola antes de devolver un resultado de recepción vacío.  Este parámetro no tiene ningún efecto cuando el sondeo largo está deshabilitado.   | 
| maxBatchOpenMs | 200ms |  El tiempo máximo, en milisegundos, que una llamada saliente espera otras llamadas para procesar por lotes mensajes del mismo tipo. Cuanto mayor sea el valor, menos lotes son necesarios para realizar la misma cantidad de trabajo (no obstante, la primera llamada de un lote tiene que esperar más tiempo). Cuando se establece este parámetro en `0`, las solicitudes enviadas no esperan a otras solicitudes, lo que en la práctica deshabilita el procesamiento por lotes.  | 
| maxBatchSize | 10 solicitudes por lote |  El número máximo de mensajes que se procesan juntos por lotes en una sola solicitud. Cuanto mayor sea la configuración, menos lotes serán necesarios para llevar a cabo el mismo número de solicitudes.  El valor máximo permitido para Amazon SQS es de diez solicitudes por lote.   | 
| maxBatchSizeBytes | 1 MiB |  El tamaño máximo de un lote de mensajes, en bytes, que el cliente intenta enviar a Amazon SQS.  El valor máximo permitido para Amazon SQS es de 1 MiB.   | 
| maxDoneReceiveBatches | 10 lotes |  El número máximo de lotes de recepción que `AmazonSQSBufferedAsyncClient` captura previamente y almacena en el lado del cliente. Cuanto mayor sea el valor, más solicitudes de recepción podrán satisfacerse sin tener que realizar una llamada a Amazon SQS (sin embargo, cuantos más mensajes se capturen previamente, más tiempo permanecerán en el búfer, lo que hará que caduque su propio tiempo de espera de visibilidad).  `0` indica que se ha deshabilitado la captura previa de mensajes y que estos solo se consumen bajo demanda.   | 
| maxInflightOutboundBatches | 5 lotes |  El número máximo de lotes salientes activos que se pueden procesar al mismo tiempo. Cuanto mayor sea el valor, más rápido se podrán enviar los lotes salientes (sujeto a cuotas como la CPU o el ancho de banda) y más subprocesos podrá consumir `AmazonSQSBufferedAsyncClient`.  | 
| maxInflightReceiveBatches | 10 lotes |  El número máximo de lotes de recepción activos que se pueden procesar al mismo tiempo. Cuanto mayor sea el valor, más mensajes de podrán recibir (sujeto a cuotas como la CPU o el ancho de banda) y más subprocesos podrá consumir `AmazonSQSBufferedAsyncClient`.  `0` indica que se ha deshabilitado la captura previa de mensajes y que estos solo se consumen bajo demanda.   | 
| visibilityTimeoutSeconds | -1 |  Cuando este parámetro se establece en un valor positivo distinto de cero, el tiempo de espera de visibilidad que se establece aquí anula el tiempo de espera de visibilidad definido en la cola desde la que se consumen los mensajes.  `-1` indica que está seleccionada la configuración predeterminada de la cola. No se puede establecer el tiempo de espera de visibilidad en `0`.   | 

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

Para el AWS SDK para Java 2.x, puede crear un nuevo `SqsAsyncBatchManager` basado en el siguiente ejemplo:

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

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

Después de crear el nuevo `SqsAsyncBatchManager`, puede utilizarlo para enviar varias solicitudes a Amazon SQS (del mismo modo que con `SqsAsyncClient`), por ejemplo:

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

`SqsAsyncBatchManager` está preconfigurado con ajustes válidos para la mayoría de los casos de uso. Se pueden configurar ajustes adicionales de `SqsAsyncBatchManager`; por ejemplo:

Creación de una configuración personalizada a través de `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 `BatchOverrideConfiguration`**  

| Parámetro | Predeterminado | Description (Descripción) | 
| --- | --- | --- | 
| maxBatchSize |  10 solicitudes por lote  | El número máximo de mensajes que se procesan juntos por lotes en una sola solicitud. Cuanto mayor sea la configuración, menos lotes serán necesarios para llevar a cabo el mismo número de solicitudes.  El valor máximo permitido para Amazon SQS es de 10 solicitudes por lote.  | 
| sendRequestFrequency |  200ms  | El tiempo máximo, en milisegundos, que una llamada saliente espera otras llamadas para procesar por lotes mensajes del mismo tipo. Cuanto mayor sea el valor, menos lotes son necesarios para realizar la misma cantidad de trabajo (no obstante, la primera llamada de un lote tiene que esperar más tiempo). Cuando se establece este parámetro en `0`, las solicitudes enviadas no esperan a otras solicitudes, lo que en la práctica deshabilita el procesamiento por lotes. | 
| receiveMessageVisibilityTimeout |  -1  | Cuando este parámetro se establece en un valor positivo distinto de cero, el tiempo de espera de visibilidad que se establece aquí anula el tiempo de espera de visibilidad definido en la cola desde la que se consumen los mensajes.   `1` indica que está seleccionada la configuración predeterminada de la cola. No se puede establecer el tiempo de espera de visibilidad en `0`.   | 
| receiveMessageMinWaitDuration |  50 ms  | La cantidad mínima de tiempo (en milisegundos) que una llamada `receiveMessage` espera a que se recuperen los mensajes disponibles. Cuanto mayor sea la configuración, menos lotes serán necesarios para llevar a cabo el mismo número de solicitudes.  | 

# Aumento del rendimiento mediante el escalado horizontal y agrupación en lotes de acciones con Amazon SQS
<a name="sqs-throughput-horizontal-scaling-and-batching"></a>

Amazon SQS admite mensajería de alto rendimiento. Para obtener más información sobre los límites de rendimiento, consulte [Cuotas de mensajes de Amazon SQS](quotas-messages.md).

Para maximizar el rendimiento:
+ [Escale](#horizontal-scaling) los productores y consumidores horizontalmente agregando más instancias de cada uno de ellos.
+ Utilice el procesamiento por [lotes de acciones](#request-batching) para enviar o recibir varios mensajes en una sola solicitud, lo que reduce la sobrecarga de llamadas a la API.

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

Dado que se accede a Amazon SQS a través de un protocolo HTTP de solicitud-respuesta, la *latencia de solicitudes* (el intervalo de tiempo que transcurre entre que se inicia una solicitud y se recibe una respuesta) limita el rendimiento que se puede alcanzar con un solo subproceso a través de una única conexión. Por ejemplo, si la latencia desde un cliente basado en Amazon EC2 hasta Amazon SQS en la misma región es de una media de 20 ms, el rendimiento máximo desde un único subproceso a través de una única conexión será de una media de 50 transacciones por segundo. 

El *escalado horizontal* supone aumentar el número de productores de mensajes (que realizan solicitudes `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)`) y consumidores de mensajes (que realizan solicitudes `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` y `[DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html)`) para aumentar el desempeño general de la cola. Existen tres métodos para realizar el escalado horizontal:
+ Aumentar el número de subprocesos por cliente
+ Añadir más clientes
+ Aumentar el número de subprocesos por cliente y añadir más clientes

Cuando se añaden más clientes, se consiguen ganancias prácticamente lineales en el desempeño de la cola. Por ejemplo, si se duplica el número de clientes, también se obtiene el doble de desempeño. 

## Agrupación en lotes de acciones
<a name="request-batching"></a>

La *agrupación por lotes* realiza más trabajo durante cada ciclo de ida y vuelta al servicio (por ejemplo, al enviar varios mensajes en una única solicitud `SendMessageBatch`). Las acciones de procesamiento por lotes de Amazon SQS son `[SendMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessageBatch.html)`, `[DeleteMessageBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessageBatch.html)` y `[ChangeMessageVisibilityBatch](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ChangeMessageVisibilityBatch.html)`. Para aprovechar el procesamiento por lotes sin modificar los productores ni los consumidores, puede utilizar el [Cliente asincrónico en búfer de Amazon SQS](sqs-client-side-buffering-request-batching.md).

**nota**  
Debido a que `[ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html)` puede procesar 10 mensajes a la vez, no hay ninguna acción `ReceiveMessageBatch`.

La agrupación en lotes distribuye la latencia de la acción por lotes entre varios mensajes en una solicitud por lotes, en lugar de aceptar toda la latencia para un único mensaje (por ejemplo, una solicitud `[SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html)`). Como en cada ciclo de ida y vuelta se realiza más trabajo, las solicitudes por lotes hacen un uso más eficaz de los subprocesos y las conexiones, por lo que se mejora el desempeño.

Puede combinar la agrupación en lotes con el escalado horizontal para proporcionar un desempeño con menos subprocesos, conexiones y solicitudes de los que serían necesarios en el caso de utilizar solicitudes de mensajes individuales. Puede utilizar acciones de Amazon SQS por lotes para enviar, recibir o eliminar hasta diez mensajes a la vez. Dado que el uso de Amazon SQS se factura por solicitudes, el procesamiento por lotes puede reducir significativamente los costos. 

La agrupación en lotes puede introducir cierta complejidad en una aplicación (por ejemplo, la aplicación debe acumular los mensajes antes de enviarlos, o a veces debe esperar más para recibir una respuesta). Sin embargo, la agrupación en lotes puede resultar eficaz en los casos siguientes: 
+ Cuando la aplicación genera muchos mensajes en poco tiempo, por lo que el retraso nunca es muy largo. 
+ Cuando un consumidor de mensajes busca mensajes en una cola a discreción, a diferencia de los productores de mensajes típicos que tienen que enviar mensajes como respuesta a eventos que no controlan. 

**importante**  
Una solicitud por lotes puede realizarse correctamente aunque se hayan producido errores en mensajes individuales del lote. Después de una solicitud por lotes, compruebe siempre si hay errores en mensajes individuales y vuelva a intentar la acción si es necesario.

## Ejemplo funcional en Java de solicitudes de una sola operación y por lotes
<a name="working-java-example-batch-requests"></a>

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

Añada los paquetes `aws-java-sdk-sqs.jar`, `aws-java-sdk-ec2.jar` y `commons-logging.jar` a la ruta de clases de compilación Java. Los siguientes ejemplos muestran estas dependencias en el archivo `pom.xml` de un proyecto 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>

En el siguiente ejemplo de código Java se implementa un patrón productor-consumidor sencillo. El subproceso principal genera una serie de subprocesos productores y consumidores que procesan mensajes de 1 KB durante el tiempo especificado. Este ejemplo incluye productores y consumidores que realizan solicitudes de una única operación y otros que realizan solicitudes por lotes.

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

### Monitoreo de las métricas de volumen de la ejecución del ejemplo
<a name="batch-request-java-example-monitoring-metrics"></a>

Amazon SQS genera automáticamente métricas de volumen para los mensajes enviados, recibidos y eliminados. Puede tener acceso a estas y otras métricas a través de la pestaña **Monitoring (Monitoreo)** de la cola o en la [CloudWatch consola](https://console.aws.amazon.com/cloudwatch/home).

**nota**  
Las métricas pueden tardar en estar disponibles hasta 15 minutos después del inicio de la cola.

# Uso de Amazon SQS con un AWS SDK
<a name="sdk-general-information-section"></a>

Los kits de desarrollo de software (SDK) de AWS se encuentran disponibles en muchos lenguajes de programación populares. Cada SDK proporciona una API, ejemplos de código y documentación que facilitan a los desarrolladores la creación de aplicaciones en su lenguaje preferido.


| Documentación de SDK | Ejemplos de código | 
| --- | --- | 
| [AWS SDK para C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp) | [AWS SDK para C\$1\$1 Ejemplos de código de la](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp) | 
| [AWS CLI](https://docs.aws.amazon.com/cli) | [Ejemplos de código de la AWS CLI](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php) | 
| [Herramientas de AWS para PowerShell](https://docs.aws.amazon.com/powershell) | [Herramientas de AWS para PowerShell Ejemplos de código de la](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) Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](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 Ejemplos de código de la](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift) | 

**Ejemplo de disponibilidad**  
¿No encuentra lo que necesita? Solicite un ejemplo de código a través del enlace de **Enviar comentarios** que se encuentra al final de esta página.