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.
# Tutoriales de RabbitMQ
En los siguientes tutoriales, se muestra cómo configurar y utilizar RabbitMQ en Amazon MQ. Para obtener más información acerca de cómo trabajar con bibliotecas de cliente compatibles en distintos lenguajes de programación como Node.js, Python, .NET y otros, consulte el tema sobre [tutoriales de RabbitMQ](https://www.rabbitmq.com/getstarted.html) en la *Guía de introducción a RabbitMQ*.
**Topics**
+ [Edición de las preferencias del agente](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [Uso de Python Pika con Amazon MQ para RabbitMQ](amazon-mq-rabbitmq-pika.md)
+ [Resolver la sincronización de colas en pausa de RabbitMQ](rabbitmq-queue-sync.md)
+ [Reducir el número de conexiones y canales](reducing-connections-and-channels.md)
+ [Paso 2: Conectar al agente una aplicación basada en una JVM](#rabbitmq-connect-jvm-application)
+ [Connect your Amazon MQ for RabbitMQ broker to Lambda](#rabbitmq-connect-to-lambda)
+ [Uso de la autenticación y autorización de OAuth 2.0 para Amazon MQ para RabbitMQ](oauth-tutorial.md)
+ [Uso de la autenticación y autorización de IAM para Amazon MQ for RabbitMQ](rabbitmq-iam-tutorial.md)
+ [Uso de la autenticación y autorización LDAP para Amazon MQ for RabbitMQ](rabbitmq-ldap-tutorial.md)
+ [Uso de la autenticación y autorización HTTP para Amazon MQ for RabbitMQ](rabbitmq-http-tutorial.md)
+ [Uso de la autenticación con certificado SSL para Amazon MQ para RabbitMQ](rabbitmq-ssl-tutorial.md)
+ [Uso de mTLS para AMQP y puntos finales de administración](rabbitmq-mtls-tutorial.md)
+ [Conexión de la aplicación JMS](rabbitmq-tutorial-jms.md)
# Edición de las preferencias del agente
Puede editar las preferencias de su corredor, como habilitar o deshabilitar CloudWatch los registros, utilizando el. Consola de administración de AWS
## Editar opciones del agente de RabbitMQ
1. Inicie sesión en la [consola de Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. En la lista de corredores, seleccione su corredor (por ejemplo **MyBroker**) y, a continuación, elija **Editar**.
1. En la *MyBroker* página de **edición**, en la sección **Especificaciones**, seleccione una **versión de Broker Engine** o un **tipo de instancia de Broker**.
1. En la sección **CloudWatch Registros**, haga clic en el botón de alternancia para activar o desactivar los registros generales. No se requieren más pasos.
**nota**
En el caso de los corredores de RabbitMQ, Amazon MQ utiliza automáticamente un rol vinculado a servicios (SLR) para publicar los registros generales. CloudWatch Para obtener más información, consulte [Uso de roles vinculados a servicios para Amazon MQ](using-service-linked-roles.md)
Amazon MQ no admite registros de auditoría para los agentes de RabbitMQ.
1. En la sección **Maintenance (Mantenimiento)**, configure el programa de mantenimiento del agente:
**Para actualizar el bróker a nuevas versiones a medida que se vayan publicando, seleccione Activar las actualizaciones automáticas de las AWS versiones secundarias.** Las actualizaciones automáticas se producen durante el *periodo de mantenimiento* definido por el día de la semana, la hora del día (en formato de 24 horas) y la zona horaria (UTC de forma predeterminada).
1. Elija **Schedule modifications (Programar modificaciones)**.
**nota**
Si elige únicamente **Enable automatic minor version upgrades (Habilitar actualizaciones automáticas de versiones secundarias)**, el botón cambia a **Save (Guardar)** porque no es necesario reiniciar el agente.
Las preferencias se aplican al agente en el momento especificado.
# Uso de Python Pika con Amazon MQ para RabbitMQ
El siguiente tutorial muestra cómo configurar un cliente [Python Pika](https://github.com/pika/pika) con TLS configurado para conectarse a un agente de Amazon MQ para RabbitMQ. Pika es una implementación de Python del protocolo AMQP 0-9-1 para RabbitMQ. Este tutorial le guía a través de la instalación de Pika, la declaración de una cola, la configuración de un editor para enviar mensajes a la bolsa predeterminada del corredor y la configuración de un consumidor para que reciba los mensajes de la cola.
**Topics**
+ [Requisitos previos](#amazon-mq-rabbitmq-pika-prerequisites)
+ [Permisos](#amazon-mq-rabbitmq-pika-permissions)
+ [Paso uno: crear un cliente Python Pika básico](#amazon-mq-rabbitmq-pika-basic-client)
+ [Paso dos: crear un editor y enviar un mensaje](#amazon-mq-rabbitmq-pika-publisher-basic-publish)
+ [Paso tres: Crea un consumidor y recibe un mensaje](#amazon-mq-rabbitmq-pika-consumer-basic-get)
+ [Paso cuatro: (opcional) configurar un bucle de eventos y consumir mensajes](#amazon-mq-rabbitmq-pika-consumer-basic-consume)
+ [Siguientes pasos](#amazon-mq-rabbitmq-pika-whats-next)
## Requisitos previos
Para completar los pasos de este tutorial, necesita los siguientes requisitos previos:
+ Un agente de Amazon MQ para RabbitMQ. Para obtener más información, consulte [Creación de un agente de Amazon MQ para RabbitMQ](getting-started-rabbitmq.md#create-rabbitmq-broker).
+ Instalación de [Python 3](https://www.python.org/downloads/) para su sistema operativo.
+ Instalación de [Pika](https://pika.readthedocs.io/en/stable/) con Python `pip`. Para instalar Pika, abra una nueva ventana de terminal y ejecute lo siguiente.
```
$ python3 -m pip install pika
```
## Permisos
Para este tutorial, necesitas al menos un usuario del agente de Amazon MQ para RabbitMQ con permiso de escritura y lectura en un anfitrión. La siguiente tabla describe los permisos mínimos necesarios como patrones de expresión regular (regexp).
| Tags | Regexp Configure (Configuración) | Regexp Write (Escritura) | Regexp Read (Lectura) |
| --- | --- | --- | --- |
| none | | .\$1 | .\$1 |
Los permisos de usuario enumerados solo proporcionan permisos de lectura y escritura al usuario, sin conceder acceso al complemento de administración para realizar operaciones administrativas en el agente. Puede restringir aún más los permisos proporcionando patrones regexp que limiten el acceso del usuario a las colas especificadas. Por ejemplo, si se cambia el patrón regexp de lectura por `^[hello world].*`, el usuario solo tendrá permiso de lectura desde las colas que empiecen por `hello world`.
Para obtener más información acerca de cómo crear usuarios de RabbitMQ y administrar etiquetas y permisos de usuario, consulte [Usuarios de agentes de Amazon MQ para RabbitMQ.](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Paso uno: crear un cliente Python Pika básico
Para crear una clase base de cliente Python Pika que defina un constructor y proporcione el contexto SSL necesario para la configuración de TLS al interactuar con un agente de Amazon MQ para RabbitMQ, haga lo siguiente.
1. Abra una nueva ventana de terminal, cree un nuevo directorio para su proyecto y navegue hasta él.
```
$ mkdir pika-tutorial
$ cd pika-tutorial
```
1. Cree un nuevo archivo denominado `basicClient.py`, que contenga el siguiente código Python.
```
import ssl
import pika
class BasicPikaClient:
def __init__(self, rabbitmq_broker_id, rabbitmq_user, rabbitmq_password, region):
# SSL Context for TLS configuration of Amazon MQ for RabbitMQ
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.set_ciphers('ECDHE+AESGCM:!ECDSA')
url = f"amqps://{rabbitmq_user}:{rabbitmq_password}@{rabbitmq_broker_id}.mq.{region}.amazonaws.com:5671"
parameters = pika.URLParameters(url)
parameters.ssl_options = pika.SSLOptions(context=ssl_context)
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
```
Ahora puede definir clases adicionales para el editor y consumidor que heredan de `BasicPikaClient`.
## Paso dos: crear un editor y enviar un mensaje
Para crear un editor que declare una cola y envíe un solo mensaje, haga lo siguiente.
1. Copie el contenido del siguiente ejemplo de código y guárdelo localmente como `publisher.py` en el mismo directorio creado en el paso anterior.
```
from basicClient import BasicPikaClient
class BasicMessageSender(BasicPikaClient):
def declare_queue(self, queue_name):
print(f"Trying to declare queue({queue_name})...")
self.channel.queue_declare(queue=queue_name)
def send_message(self, exchange, routing_key, body):
channel = self.connection.channel()
channel.basic_publish(exchange=exchange,
routing_key=routing_key,
body=body)
print(f"Sent message. Exchange: {exchange}, Routing Key: {routing_key}, Body: {body}")
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Initialize Basic Message Sender which creates a connection
# and channel for sending messages.
basic_message_sender = BasicMessageSender(
"",
"",
"",
""
)
# Declare a queue
basic_message_sender.declare_queue("hello world queue")
# Send a message to the queue.
basic_message_sender.send_message(exchange="", routing_key="hello world queue", body=b'Hello World!')
# Close connections.
basic_message_sender.close()
```
La clase `BasicMessageSender` hereda de `BasicPikaClient` e implementa métodos adicionales para delimitar una cola, enviar un mensaje a la cola y cerrar conexiones. El código de ejemplo envía un mensaje al intercambio predeterminado, con una clave de enrutamiento igual al nombre de la cola.
1. En `if __name__ == "__main__":`, sustituya los parámetros pasados a la declaración constructor `BasicMessageSender` con la siguiente información.
+ **``**: ID único que genera Amazon MQ para el agente. Puede consultar el ID a partir del ARN de su agente. Por ejemplo, si se le da el ARN `arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`, el ID del agente sería `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`.
+ **``**: el nombre de usuario de un agente con permisos suficientes para escribir mensajes al agente.
+ **``**: la contraseña de usuario de un agente con permisos suficientes para escribir mensajes al agente.
+ **``**— La AWS región en la que creó su bróker Amazon MQ para RabbitMQ. Por ejemplo, `us-west-2`.
1. Ejecute el siguiente comando en el mismo directorio que creó `publisher.py`.
```
$ python3 publisher.py
```
Si el código se ejecuta correctamente, aparecerá el siguiente resultado en la ventana de terminal.
```
Trying to declare queue(hello world queue)...
Sent message. Exchange: , Routing Key: hello world queue, Body: b'Hello World!'
```
## Paso tres: Crea un consumidor y recibe un mensaje
Para crear un consumidor que reciba un solo mensaje de la cola, haga lo siguiente.
1. Copie el contenido del siguiente ejemplo de código y guárdelo localmente como `consumer.py` en el mismo directorio.
```
from basicClient import BasicPikaClient
class BasicMessageReceiver(BasicPikaClient):
def get_message(self, queue):
method_frame, header_frame, body = self.channel.basic_get(queue)
if method_frame:
print(method_frame, header_frame, body)
self.channel.basic_ack(method_frame.delivery_tag)
return method_frame, header_frame, body
else:
print('No message returned')
def close(self):
self.channel.close()
self.connection.close()
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection
# and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
basic_message_receiver.get_message("hello world queue")
# Close connections.
basic_message_receiver.close()
```
Al igual que el editor que creó en el paso anterior, `BasicMessageReceiver` hereda `BasicPikaClient` e implementa métodos adicionales para recibir un solo mensaje y cerrar las conexiones.
1. En la declaración `if __name__ == "__main__":`, sustituya los parámetros pasados al constructor `BasicMessageReceiver` por su información.
1. Ejecute el siguiente comando en el directorio de su proyecto.
```
$ python3 consumer.py
```
Si el código se ejecuta correctamente, verá el cuerpo del mensaje y los encabezados, incluida la clave de enrutamiento, en la ventana del terminal.
```
b'Hello World!'
```
## Paso cuatro: (opcional) configurar un bucle de eventos y consumir mensajes
Para consumir múltiples mensajes de una cola, utilice el método [https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume](https://pika.readthedocs.io/en/stable/modules/channel.html#pika.channel.Channel.basic_consume) de Pika y una función de devolución de llamada como se muestra a continuación
1. En `consumer.py`, agregue la siguiente definición de método a la clase `BasicMessageReceiver`.
```
def consume_messages(self, queue):
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
self.channel.basic_consume(queue=queue, on_message_callback=callback, auto_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
self.channel.start_consuming()
```
1. En `consumer.py`, dentro de `if __name__ == "__main__":`, invoque el método `consume_messages` que definió en el paso anterior.
```
if __name__ == "__main__":
# Create Basic Message Receiver which creates a connection and channel for consuming messages.
basic_message_receiver = BasicMessageReceiver(
"",
"",
"",
""
)
# Consume the message that was sent.
# basic_message_receiver.get_message("hello world queue")
# Consume multiple messages in an event loop.
basic_message_receiver.consume_messages("hello world queue")
# Close connections.
basic_message_receiver.close()
```
1. Ejecute `consumer.py` de nuevo, y si se ejecuta correctamente, los mensajes en cola se mostrarán en la ventana del terminal.
```
[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'
[x] Received b'Hello World!'
...
```
## Siguientes pasos
+ Para obtener más información sobre otras bibliotecas cliente RabbitMQ compatibles, consulte [Documentación del cliente de RabbitMQ](https://www.rabbitmq.com/clients.html) en el sitio web de RabbitMQ.
# Resolver la sincronización de colas en pausa de RabbitMQ
En una [implementación de clúster](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster) de Amazon MQ para RabbitMQ, los mensajes publicados en cada cola se replican en tres nodos de agente. Esta replicación, conocida como *espejo*, proporciona alta disponibilidad para los agentes de RabbitMQ. En una implementación de clúster, las colas constan de un nodo *principal* y una o más *réplicas*. Cada operación aplicada a una cola replicada, incluidos los mensajes en cola, se aplica primero a la cola principal y, a continuación, se replica en sus espejos.
Por ejemplo, considere una cola replicada en tres nodos: el nodo principal (`main`) y dos espejos (`mirror-1` y `mirror-2`). Si todos los mensajes de esta cola replicada se propagan correctamente a todos los espejos, la cola se sincroniza. Si un nodo (`mirror-1`) deja de estar disponible durante un intervalo de tiempo, la cola sigue funcionando y puede continuar poniendo mensajes en cola. Sin embargo, para que la cola se sincronice, los mensajes publicados en `main` mientras `mirror-1` no está disponible deben replicarse en `mirror-1`.
Para obtener más información acerca de la replicación, consulte el tema sobre [Colas replicadas clásicas](https://www.rabbitmq.com/ha.html) en el sitio web de RabbitMQ.
**Mantenimiento y sincronización de colas**
Durante los [periodos de mantenimiento](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console), Amazon MQ realiza todos los trabajos de mantenimiento de a un nodo por vez para garantizar que el agente permanezca operativo. Como resultado, es posible que las colas deban sincronizarse a medida que cada se vaya reanudando la operación de cada nodo. Durante la sincronización, los mensajes que deben replicarse en los espejos se cargan en la memoria del volumen correspondiente de Amazon Elastic Block Store (Amazon EBS) para procesarlos en lotes. El procesamiento de mensajes en lotes permite agilizar la sincronización de las colas.
Si las colas se mantienen cortas y los mensajes son pequeños, las colas se sincronizan correctamente y reanudan la operación según lo previsto. Sin embargo, si la cantidad de datos de un lote se acerca al límite de memoria del nodo, el nodo genera una alarma de memoria elevada y se pausa la sincronización de colas. Puede confirmar el uso de la memoria comparando las [métricas del `RabbitMemUsed` nodo `RabbitMqMemLimit` intermediario con las del nodo intermediario CloudWatch](amazon-mq-accessing-metrics.md). La sincronización no se puede completar hasta que se consuman o eliminen los mensajes, o se reduzca el número de mensajes del lote.
**nota**
La reducción del tamaño del lote de sincronización de colas puede generar mayor número de transacciones de replicación.
Para resolver una sincronización de colas en pausa, siga los pasos que se indican en este tutorial, que muestra la aplicación de una política `ha-sync-batch-size` y reinicio de la sincronización de colas.
**Topics**
+ [Requisitos previos](#rabbitmq-queue-sync-prerequisites)
+ [Paso 1: Aplicar una política `ha-sync-batch-size`](#rabbitmq-queue-sync-step-1)
+ [Paso 2: Reiniciar la sincronización de colas](#rabbitmq-queue-sync-step-2)
+ [Siguientes pasos](#rabbitmq-queue-sync-next-steps)
+ [Recursos relacionados](#rabbitmq-queue-sync-related-resources)
## Requisitos previos
Para este tutorial, debe tener un usuario de agente de Amazon MQ para RabbitMQ con permisos de administrador. Puede utilizar el usuario administrador que generó cuando creó el agente por primera vez, u otro usuario que podría haber creado después. La siguiente tabla proporciona la etiqueta y los permisos de usuario administrador necesarios como patrones de expresiones regulares (regexp).
| Tags | Regexp Read (Lectura) | Regexp Configure (Configuración) | Regexp Write (Escritura) |
| --- | --- | --- | --- |
| administrator | .\$1 | .\$1 | .\$1 |
Para obtener más información acerca de cómo crear usuarios de RabbitMQ y administrar etiquetas y permisos de usuario, consulte [Usuarios de agentes de Amazon MQ para RabbitMQ.](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Paso 1: Aplicar una política `ha-sync-batch-size`
Estos procedimientos se utilizan para agregar una política que se aplica a todas las colas creadas en el agente. Puede utilizar la consola web o la API de administración de RabbitMQ. Para obtener más información, consulte [Complemento de administración](https://www.rabbitmq.com/management.html) en el sitio web de RabbitMQ.
**Para aplicar una política `ha-sync-batch-size` a través de la consola web de RabbitMQ**
1. Inicie sesión en la [consola de Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. En el panel de navegación izquierdo, elija **Brokers** (Agentes).
1. En la lista de agentes, elija el nombre del agente al que desea aplicar la nueva política.
1. En la sección **Connections** (Conexiones) de la página del agente, elija la URL de la **consola web de RabbitMQ**. La consola web de RabbitMQ se abre en una nueva pestaña o ventana del navegador.
1. Inicie sesión en la consola web de RabbitMQ con las credenciales del usuario administrador del agente.
1. En la consola web de RabbitMQ, elija **Admin** (Administrador) en la parte superior de la página.
1. En la página **Admin** (Administrador), elija **Politicies** (Políticas) en el panel de navegación derecho.
1. En la página **Políticies** (Políticas), puede ver una lista de las **Políticas de usuario** actuales del agente. Debajo de las **políticas de usuario**, expanda **Add/update a policy** (Agregar/actualizar una política).
**nota**
De forma predeterminada, los clústeres de Amazon MQ para RabbitMQ se crean con una política de agente inicial con el nombre `ha-all-AWS-OWNED-DO-NOT-DELETE`. Amazon MQ administra esta política para garantizar que todas las colas del agente se repliquen en los tres nodos y que las colas se sincronicen automáticamente.
1. Para crear una nueva política de agente, en **Add/update a policy** (Agregar/actualizar una política), haga lo siguiente:
1. En **Name** (Nombre), escriba un nombre para su política, por ejemplo, **batch-size-policy**.
1. En **Pattern** (Patrón), ingrese el patrón regexp **.\$1** para que la política coincida con todas las colas del agente.
1. En **Apply to** (Aplicar a), elija **Exchanges and queues** (Intercambios y colas) en el menú desplegable.
1. En **Priority** (Prioridad), ingrese un número entero mayor que todas las demás políticas aplicadas al vhost. Puede aplicar exactamente un conjunto de definiciones de políticas a las colas e intercambios de RabbitMQ en cualquier momento dado. RabbitMQ elige la política de coincidencia con el valor de prioridad más alto. Para obtener más información acerca de las prioridades de las políticas y cómo combinar políticas, consulte el tema sobre [políticas](https://www.rabbitmq.com/parameters.html#policies) en la documentación del servidor de RabbitMQ.
1. En **Definition** (Definición), agregue los siguientes pares clave-valor:
+ **ha-sync-batch-size**=*100*. Elija **Número** en la lista desplegable.
**nota**
Es posible que deba ajustar y calibrar el valor de `ha-sync-batch-size` en función del número y el tamaño de los mensajes sin sincronizar de las colas.
+ **ha-mode**=**all**. Elija **String** (Cadena) en el menú desplegable.
**importante**
Se requiere la definición `ha-mode` para todas las políticas relacionadas con la alta disponibilidad. Si se omite, se produce un error de validación.
+ **ha-sync-mode**=**automatic**. Elija **String** (Cadena) en el menú desplegable.
**nota**
Se requiere la definición `ha-sync-mode` para todas las políticas personalizadas. Si se omite, Amazon MQ la agrega automáticamente.
1. Elija **Add/update policy** (Agregar/actualizar política).
1. Confirme que la nueva política aparezca en la lista de **políticas de usuario**.
**Para aplicar una política `ha-sync-batch-size` a través de la API de administración de RabbitMQ**
1. Inicie sesión en la [consola de Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. En el panel de navegación izquierdo, elija **Brokers** (Agentes).
1. En la lista de agentes, elija el nombre del agente al que desea aplicar la nueva política.
1. En la sección **Connections** (Conexiones) de la página del agente, anote la URL de la **consola web de RabbitMQ**. Este es el punto de enlace del agente que se utiliza en una solicitud HTTP.
1. Abra un terminal nuevo o la ventana de línea de comandos que desee.
1. Para crear una nueva política de agente, ingrese el comando `curl`. Este comando asume que hay una cola en el vhost `/` predeterminado, que está codificado como `%2F`.
**nota**
Sustituya *username* y por *password* las credenciales de inicio de sesión de administrador de su corredor. Puede que tengas que ajustar y calibrar el valor de `ha-sync-batch-size` (*100*) en función del número y el tamaño de los mensajes no sincronizados de tus colas. Reemplace el punto de enlace del agente por la URL que anotó anteriormente.
```
curl -i -u username:password -H "content-type:application/json" -XPUT \
-d '{"pattern":".*", "priority":1, "definition":{"ha-sync-batch-size":100, "ha-mode":"all", "ha-sync-mode":"automatic"}}' \
https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies/%2F/batch-size-policy
```
1. Para confirmar que se haya agregado la nueva política a las políticas de usuario de su agente, ingrese el comando `curl` para ver una lista de todas las políticas de agente.
```
curl -i -u username:password https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies
```
## Paso 2: Reiniciar la sincronización de colas
Después de aplicar una nueva política `ha-sync-batch-size` a su agente, reinicie la sincronización de colas.
**Para reiniciar la sincronización de colas a través de la consola web de RabbitMQ**
**nota**
Para abrir la consola web de RabbitMQ, consulte las instrucciones anteriores en el paso 1 de este tutorial.
1. En la consola web de RabbitMQ, en la parte superior de la página, elija **Queues** (Colas).
1. En la página **Queues** (Colas), en **All queues** (Todas las colas), busque la cola en pausa. En la fila **Policy** (Política), la cola debe mostrar el nombre de la nueva política que ha creado (por ejemplo, `batch-size-policy`).
1. Para reiniciar el proceso de sincronización con un tamaño de lote reducido, primero cancele la sincronización de la cola. A continuación, reinicie la sincronización de colas.
**nota**
Si la sincronización se detiene y no se completa correctamente, intente reducir el valor de `ha-sync-batch-size` y volver a reiniciar la sincronización de colas.
## Siguientes pasos
+ Una vez que la cola se sincronice correctamente, puede controlar la cantidad de memoria que utilizan sus nodos de RabbitMQ consultando la métrica de Amazon. CloudWatch `RabbitMQMemUsed` También puede consultar la métrica `RabbitMQMemLimit` para monitorear el límite de memoria de un nodo. Para obtener más información, consulte [Acceso a CloudWatch las métricas de Amazon MQ](amazon-mq-accessing-metrics.md) y [CloudWatch Métricas disponibles de Amazon MQ para corredores de RabbitMQ](rabbitmq-logging-monitoring.md).
+ Para evitar la sincronización de colas en pausa, recomendamos mantener las colas cortas y procesar mensajes. Para cargas de trabajo con tamaños de mensaje más grandes, también recomendamos actualizar el tipo de instancias del agente a un tamaño de instancia más grande con más memoria. Para obtener más información sobre los tipos de instancias y la edición de preferencias del agente, consulte [Edición de las preferencias del agente](amazon-mq-rabbitmq-editing-broker-preferences.md).
+ Cuando crea un nuevo agente de Amazon MQ para RabbitMQ, Amazon MQ aplica un conjunto de políticas y límites de anfitriones virtuales predeterminados para optimizar el rendimiento del agente. Si su agente no tiene las políticas y los límites predeterminados recomendados, le recomendamos que los cree usted mismo. Para obtener más información acerca de cómo crear políticas y límites de vhost predeterminados, consulte [https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html](https://docs.aws.amazon.com//amazon-mq/latest/developer-guide/rabbitmq-defaults.html).
## Recursos relacionados
+ [UpdateBrokerInput](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-model-updatebrokerinput)— Utilice esta propiedad de agente para actualizar un tipo de instancia de agente mediante la API Amazon MQ.
+ [Parámetros y políticas](https://www.rabbitmq.com/parameters.html)(Documentación del servidor de RabbitMQ): obtenga más información acerca de los parámetros y las políticas de RabbitMQ en el sitio web de RabbitMQ.
+ [API HTTP de administración de RabbitMQ](https://pulse.mozilla.org/api/): obtenga más información acerca de la API de administración de RabbitMQ.
# Reducir el número de conexiones y canales
Las conexiones al agente de RabbitMQ para Amazon MQ las pueden cerrar las aplicaciones cliente, o bien manualmente mediante la consola web de RabbitMQ. Para cerrar una conexión mediante la consola web de RabbitMQ, haga lo siguiente:
1. Inicie sesión en la consola Consola de administración de AWS web RabbitMQ de su bróker y ábrala.
1. En la consola de RabbitMQ, elija la pestaña **Connections** (Conexiones).
1. En la página **Connections** (Conexiones), en **All connections** (Todas las conexiones), elija el nombre de la conexión que desea cerrar en la lista.
1. En la página de detalles de la conexión, elija **Close this connection** (Cerrar esta conexión) para ampliar la sección y, a continuación, elija **Force Close** (Forzar cierre). Opcionalmente, puede reemplazar el texto predeterminado de **Reason** (Razón) con una descripción propia. RabbitMQ de Amazon MQ devolverá la razón que especifique al cliente cuando cierre la conexión.
1. Elija **OK** (Aceptar) en el cuadro de diálogo para confirmar y cerrar la conexión.
Cuando se cierra una conexión, los canales asociados a la conexión cerrada también se cierran.
**nota**
Es posible que las aplicaciones cliente estén configuradas para restablecer automáticamente las conexiones con el agente después de cerrarlas. En tal caso, cerrar las conexiones desde la consola web del agente no será suficiente para reducir el recuento de conexiones o canales.
En el caso de agentes sin acceso público, se pueden bloquear temporalmente las conexiones denegando el tráfico entrante en el puerto del protocolo de mensajes adecuado; por ejemplo, el puerto `5671` para las conexiones AMQP. Se puede bloquear el puerto del grupo de seguridad que se haya proporcionado a Amazon MQ al crear el agente. Para obtener más información sobre la modificación de un grupo de seguridad de VPC, consulte [Agregar reglas a un grupo de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#adding-security-group-rules) en la *Guía del usuario de Amazon VPC*.
## Paso 2: Conectar al agente una aplicación basada en una JVM
Después de crear un agente de RabbitMQ, puede conectar su aplicación con él. Los siguientes ejemplos muestran cómo puede utilizar la [biblioteca de cliente de Java de RabbitMQ](https://www.rabbitmq.com/java-client.html) para crear una conexión con su agente, crear una cola y enviar un mensaje. Puede conectarse con agentes de RabbitMQ mediante bibliotecas de cliente de RabbitMQ compatibles para varios idiomas. Para obtener más información de las bibliotecas de cliente de RabbitMQ compatibles, consulte el tema sobre [bibliotecas de cliente de RabbitMQ y herramientas para desarrolladores](https://www.rabbitmq.com/devtools.html).
### Requisitos previos
**nota**
Los siguientes requisitos previos solo se aplican a los agentes de RabbitMQ que se crean sin accesibilidad pública. Si está creando un agente con accesibilidad pública, puede omitirlos.
#### Habilitar atributos de VPC
Para asegurarse de poder acceder a su agente dentro de su VPC, debe habilitar los atributos `enableDnsHostnames` y `enableDnsSupport` de VPC. Para obtener más información, consulte el tema sobre [soporte de DNS en su VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) en la *Guía del usuario de Amazon VPC*.
#### Habilitar las conexiones entrantes
1. Inicie sesión en la [consola de Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. En la lista de corredores, elija el nombre de su corredor (por ejemplo,). **MyBroker**
1. En la ***MyBroker***página, en la sección **Conexiones**, anote las direcciones y los puertos de la URL de la consola web del bróker y de los protocolos a nivel de cable.
1. En la sección **Details** (Detalles), en **Security and network** (Seguridad y red), elija el nombre de su grupo de seguridad o ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/es_es/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
Aparecerá la página **Security Groups** (Grupos de seguridad) del panel de EC2.
1. En la lista de grupos de seguridad, elija el grupo de seguridad.
1. En la parte inferior de la página, elija **Inbound (Entrante)** y, a continuación, **Edit (Editar)**.
1. En el cuadro de diálogo **Edit inbound rules** (Editar reglas entrantes), agregue una regla para cada URL o punto de enlace que desee que sea accesible públicamente (en el ejemplo a continuación se muestra cómo hacerlo para una consola web de agente).
1. Seleccione **Add Rule (Agregar regla)**.
1. En **Type (Tipo)**, seleccione **Custom TCP (TCP personalizada)**.
1. Para **Source** (Fuente), deje seleccionada la opción **Custom** (Personalizada) y, luego, escriba la dirección IP del sistema que desea que pueda acceder a la consola web (por ejemplo, `192.0.2.1`).
1. Seleccione **Save**.
El agente ahora puede aceptar las conexiones entrantes.
#### Agregar dependencias de Java
Si está utilizando Apache Maven para automatizar compilaciones, agregue la siguiente dependencia a su archivo `pom.xml`. Para obtener más información de los archivos Project Object Model en Apache Maven, consulte el tema sobre [introducción a POM](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html).
```
com.rabbitmq
amqp-client
5.9.0
```
Si utiliza [Gradle](https://docs.gradle.org/current/userguide/userguide.html) para automatizar compilaciones, declare la siguiente dependencia.
```
dependencies {
compile 'com.rabbitmq:amqp-client:5.9.0'
}
```
#### Importar clases `Connection` y `Channel`
El cliente Java de RabbitMQ utiliza `com.rabbitmq.client` como su paquete de nivel superior, y las clases de API `Connection` y `Channel` representan una conexión AMQP 0-9-1 y un canal, respectivamente. Importe las clases `Connection` y `Channel` antes de usarlas, como se muestra en el ejemplo a continuación.
```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```
#### Crear un `ConnectionFactory` y conectarlo con su agente
Utilice el siguiente ejemplo para crear una instancia de la clase `ConnectionFactory` con los parámetros dados. Use el método `setHost` para configurar el punto de enlace del agente que anotó antes. Para conexiones de nivel de cable `AMQPS`, utilice el puerto `5671`.
```
ConnectionFactory factory = new ConnectionFactory();
factory.setUsername(username);
factory.setPassword(password);
//Replace the URL with your information
factory.setHost("b-c8352341-ec91-4a78-ad9c-a43f23d325bb.mq.us-west-2.amazonaws.com");
factory.setPort(5671);
// Allows client to establish a connection over TLS
factory.useSslProtocol();
// Create a connection
Connection conn = factory.newConnection();
// Create a channel
Channel channel = conn.createChannel();
```
#### Publicar un mensaje en un intercambio
Puede usar `Channel.basicPublish` para publicar mensajes en un intercambio. El siguiente ejemplo utiliza la clase `Builder` de AMQP para compilar un objeto de propiedades de mensaje con tipo de contenido `plain/text`.
```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
new AMQP.BasicProperties.Builder()
.contentType("text/plain")
.userId("userId")
.build(),
messageBodyBytes);
```
**nota**
Tenga en cuenta que `BasicProperties` es una clase interna de la clase titular generada automáticamente, que es `AMQP`.
#### Suscribirse a una cola y recibir un mensaje
Para recibir un mensaje, puede suscribirse a una cola a través de la interfaz `Consumer`. Una vez suscrito, los mensajes se entregarán automáticamente a medida que lleguen.
La forma más sencilla de implementar un `Consumer` es usar la subclase `DefaultConsumer`. Se puede pasar un objeto `DefaultConsumer` como parte de una ejecución `basicConsume` para configurar la suscripción como se muestra en el ejemplo a continuación.
```
boolean autoAck = false;
channel.basicConsume(queueName, autoAck, "myConsumerTag",
new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body)
throws IOException
{
String routingKey = envelope.getRoutingKey();
String contentType = properties.getContentType();
long deliveryTag = envelope.getDeliveryTag();
// (process the message components here ...)
channel.basicAck(deliveryTag, false);
}
});
```
**nota**
Dado que especificamos `autoAck = false`, es necesario reconocer los mensajes que se entregaron al `Consumer`, preferentemente a través del método `handleDelivery`, como se muestra en el ejemplo.
#### Cerrar la conexión y desconectarse del agente
Para desconectarse del agente de RabbitMQ, cierre el canal y la conexión como se muestra a continuación.
```
channel.close();
conn.close();
```
**nota**
Para obtener más información del uso de la biblioteca de cliente de Java de RabbitMQ, consulte la [Guía de API de cliente de Java de RabbitMQ](https://www.rabbitmq.com/api-guide.html).
## Paso 3: (Opcional) Conectarse a una AWS Lambda función
AWS Lambda puede conectarse a su agente de Amazon MQ y consumirlos. Cuando conecta un agente a Lambda, crea un [mapeo de origen de eventos](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) que lee mensajes de una cola e invoca la función [de forma sincrónica](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). El mapeo de origen de eventos que crea lee los mensajes de su agente en lotes y los convierte en una carga de Lambda en forma de objeto JSON.
**Conectar a su agente con una función Lambda**
1. Agregue los siguientes permisos de roles de IAM al [rol de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) de su función Lambda.
+ [mq: DescribeBroker](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
+ [ec2: CreateNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html)
+ [ec2: DeleteNetworkInterface](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteNetworkInterface.html)
+ [ec2: DescribeNetworkInterfaces](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeNetworkInterfaces.html)
+ [ec2: DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)
+ [ec2: DescribeSubnets](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSubnets.html)
+ [ec2: DescribeVpcs](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVpcs.html)
+ [registros: CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [registros: CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [registros: PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
+ [administrador de secretos: GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**nota**
Sin los permisos necesarios de IAM, su función no podrá leer correctamente los registros de los recursos de Amazon MQ.
1. (Opcional) Si ha creado un agente sin accesibilidad pública, debe realizar una de las siguientes acciones para permitir que Lambda se conecte con su agente:
+ Puede configurar una gateway NAT para cada subred pública. Para obtener más información, consulte el tema sobre [acceso a Internet y a los servicios para funciones conectadas a la VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet) en la *AWS Lambda Guía para desarrolladores*.
+ Cree una conexión entre Amazon Virtual Private Cloud (Amazon VPC) y Lambda a través de un punto de enlace de la VPC. Su Amazon VPC también debe conectarse a AWS Security Token Service (AWS STS) y a los puntos de conexión de Secrets Manager. Para obtener más información, consulte [Configuración de puntos de conexión de VPC de interfaz para Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) en la *AWS Lambda Guía para desarrolladores*.
1. [Configure el agente como origen de eventos](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping) para una función Lambda a través de la Consola de administración de AWS. También puede usar el [https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) AWS Command Line Interface comando.
1. Escriba algún código para que su función Lambda procese los mensajes de lo consumido desde su agente. La carga de Lambda que recupere el mapeo de origen de eventos depende del tipo de motor del agente. A continuación, se muestra un ejemplo de una carga de Lambda para una cola de RabbitMQ en Amazon MQ.
**nota**
En el ejemplo, `test` es el nombre de la cola y `/` es el nombre del anfitrión virtual predeterminado. Al recibir mensajes, el origen de eventos muestra los mensajes en`test::/`.
```
{
"eventSource": "aws:rmq",
"eventSourceArn": "arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
"rmqMessagesByQueue": {
"test::/": [
{
"basicProperties": {
"contentType": "text/plain",
"contentEncoding": null,
"headers": {
"header1": {
"bytes": [
118,
97,
108,
117,
101,
49
]
},
"header2": {
"bytes": [
118,
97,
108,
117,
101,
50
]
},
"numberInHeader": 10
}
"deliveryMode": 1,
"priority": 34,
"correlationId": null,
"replyTo": null,
"expiration": "60000",
"messageId": null,
"timestamp": "Jan 1, 1970, 12:33:41 AM",
"type": null,
"userId": "AIDACKCEVSQ6C2EXAMPLE",
"appId": null,
"clusterId": null,
"bodySize": 80
},
"redelivered": false,
"data": "eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ=="
}
]
}
}
```
Para obtener más información de cómo conectar Amazon MQ a Lambda, las opciones que admite Lambda para un origen de eventos de Amazon MQ y los errores de asignación de orígenes de eventos, consulte el tema sobre el [uso de Lambda con Amazon MQ](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html) en la *AWS Lambda Guía para desarrolladores*.
# Uso de la autenticación y autorización de OAuth 2.0 para Amazon MQ para RabbitMQ
En este tutorial se describe cómo configurar la [autenticación de OAuth 2.0](oauth-for-amq-for-rabbitmq.md) para sus agentes de Amazon MQ para RabbitMQ que utilizan Amazon Cognito como proveedor de OAuth 2.0.
**nota**
Amazon Cognito no está disponible en China (Pekín) y China (Ningxia).
**importante**
Este tutorial es específico de Amazon Cognito, pero puede utilizar otros proveedores de identidad (IdP). Para obtener más información, consulte [Ejemplos de autenticación de OAuth 2.0](https://www.rabbitmq.com/docs/oauth2-examples).
**Topics**
+ [Requisitos previos para configurar la autenticación OAuth 2.0](#oauth-tutorial-prerequisites)
+ [Configuración de la autenticación OAuth 2.0 con Amazon Cognito mediante AWS CLI](#oauth-tutorial-config-cognito-using-cli)
+ [Configuración de OAuth 2.0 y autenticación simple con Amazon Cognito](#oauth-tutorial-config-both-auth-methods-using-cli)
## Requisitos previos para configurar la autenticación OAuth 2.0
Puede configurar los recursos de Amazon Cognito necesarios en este tutorial mediante la implementación de la pila AWS CDK, [Pila de Amazon Cognito para el complemento OAuth 2 de RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample). Si va a configurar Amazon Cognito manualmente, asegúrese de cumplir los siguientes requisitos previos antes de configurar OAuth 2.0 en su Amazon MQ para agentes de RabbitMQ:
**Requisitos previos para configurar Amazon Cognito**
+ Configure un punto de conexión de Amazon Cognito mediante la creación de un grupo de usuarios. Para ello, consulte el blog [How to use OAuth 2.0 in Amazon Cognito: Learn about the different OAuth 2.0 grants](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/).
+ Cree un servidor de recursos llamado `rabbitmq` en el grupo de usuarios con los siguientes ámbitos definidos: `read:all`, `write:all`, `configure:all` y `tag:administrator`. Estos ámbitos se asociarán a los permisos de RabbitMQ.
Para obtener información sobre la creación de un servidor de recursos, consulte [Definir un servidor de recursos para su grupo de usuarios (Consola de administración de AWS)](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html#cognito-user-pools-define-resource-servers-console) en la *Guía para desarrolladores de Amazon Cognito*.
+ Cree los siguientes clientes de aplicaciones.
+ Cliente de aplicación para el grupo de usuarios de tipo `Machine-to-Machine application`. Se trata de un cliente confidencial con un secreto de cliente que se utilizará para los clientes AMQP de RabbitMQ. Para obtener más información sobre los clientes de aplicaciones y cómo crear uno, consulte [Tipos de clientes de aplicaciones](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#user-pool-settings-client-app-client-types) y [Creación de un cliente de aplicaciones.](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#cognito-user-pools-app-idp-settings-console-create)
+ Cliente de aplicación para el grupo de usuarios de tipo `Single-page application`. Se trata de un cliente público que se utilizará para iniciar sesión en la consola de administración de RabbitMQ. Debe actualizar este cliente de aplicación para incluir el punto de conexión del agente Amazon MQ para RabbitMQ que creará en el siguiente procedimiento como URL de devolución de llamada permitida. Para obtener más información, consulte [Configuración del inicio de sesión administrado con la consola de Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-managed-login.html#set-up-managed-login).
**Requisito previo para configurar Amazon MQ**
+ Una instalación de [Docker](https://docs.docker.com/engine/install/) que funcione para ejecutar un script de bash que compruebe si la configuración de OAuth 2.0 se ha realizado correctamente o no.
+ versión AWS CLI >= `2.28.23` para que añadir un nombre de usuario y una contraseña sea opcional durante la creación del agente.
## Configuración de la autenticación OAuth 2.0 con Amazon Cognito mediante AWS CLI
El siguiente procedimiento muestra cómo configurar la autenticación OAuth 2.0 para sus agentes de Amazon MQ for RabbitMQ que utilizan Amazon Cognito como IdP. Este procedimiento utiliza AWS CLI para crear y configurar los recursos necesarios.
En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición, como el ID de configuración y la revisión,** y *<2>* por sus valores reales.
1. Cree una configuración nueva mediante el comando AWS CLI [create-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/create-configuration.html) tal y como se muestra en el siguiente ejemplo.
```
aws mq create-configuration \
--name "rabbitmq-oauth2-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-oauth2-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-oauth2-config"
}
```
1. Cree un archivo de configuración llamado **rabbitmq.conf** para utilizar OAuth 2.0 como método de autenticación y autorización, como se muestra en el siguiente ejemplo.
```
auth_backends.1 = oauth2
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool.
# If you used the AWS CDK stack to deploy Amazon Cognito, this is one of the stack outputs.
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
# Amazon Cognito does not include an audience field in access tokens
auth_oauth2.verify_aud = false
# Amazon Cognito does not allow * in its custom scopes. Use aliases to translate between Amazon Cognito and RabbitMQ.
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
# Allow OAuth 2.0 login for RabbitMQ management console
management.oauth_enabled = true
# FIXME: Update this value with the client ID of your public application client
management.oauth_client_id = ${RabbitMqOAuth2TestStack.ManagementConsoleAppClientId}
# FIXME: Update this value with the base JWKS URI (without /.well-known/jwks.json)
auth_oauth2.issuer = ${RabbitMqOAuth2TestStack.Issuer}
management.oauth_scopes = rabbitmq/tag:administrator
```
Esta configuración utiliza [alias de ámbito](https://www.rabbitmq.com/docs/oauth2#scope-translation) para asignar los ámbitos definidos en Amazon Cognito a ámbitos compatibles con RabbitMQ.
1. Actualice la configuración mediante el comando AWS CLI [update-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/update-configuration.html), como se muestra en el siguiente ejemplo. En este comando, añada el identificador de configuración que recibió en la respuesta al paso 1 de este procedimiento. Por ejemplo, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca**.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-oauth2-config",
"Warnings": []
}
```
1. Cree un agente con la configuración de OAuth 2.0 creada en el paso 2 de este procedimiento. Para ello, utilice el comando [create-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/create-broker.html) de AWS CLI como se muestra en el siguiente ejemplo. En este comando, indique el identificador de configuración y el número de revisión que obtuvo en las respuestas de los pasos 1 y 2, respectivamente. Por ejemplo, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca** y **2**.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-oauth2-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Compruebe que el estado del agente pasa de `CREATION_IN_PROGRESS` a `RUNNING` mediante el comando [describe-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/describe-broker.html) de AWS CLI, tal como se muestra en el siguiente ejemplo. En este comando, proporcione el ID de agente que obtuvo en el resultado del paso anterior. Por ejemplo, **b-2a1b5133-a10c-49d2-879b-8c176c34cf73**.
```
aws mq describe-broker \
--broker-id ""
```
Este comando devuelve una respuesta de JSON similar a la siguiente. La siguiente respuesta es una versión abreviada del resultado completo que devuelve el comando `describe-broker`. Esta respuesta muestra el estado del agente y la estrategia de autenticación utilizada para proteger al agente. En este caso, la estrategia de autenticación `config_managed` indica que el agente utiliza el método de autenticación OAuth 2.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
Para iniciar sesión en la consola de administración de RabbitMQ mediante OAuth2, es necesario añadir el punto de conexión del agente como una URL de devolución de llamada válida en el cliente de la aplicación Amazon Cognito correspondiente. Para obtener más información, consulte el paso 5 de la configuración de nuestro ejemplo de [pila de CDK de Amazon Cognito](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample#step-5-update-callback-urls-if-using-placeholder-urls).
1. Verifique la autenticación y la autorización de OAuth 2.0 con el siguiente script de `perf-test.sh`.
Utilice este script de bash para probar la conectividad con su agente de Amazon MQ para RabbitMQ. Este script obtiene un token de Amazon Cognito y verifica si la conexión se configuró correctamente. Si se ha configurado correctamente, verá que su agente publica y consume mensajes.
Si recibe un error `ACCESS_REFUSED`, puede solucionar los problemas de configuración mediante los registros de CloudWatch de su agente. Encontrará el enlace al grupo de registros de CloudWatch de su agente en la consola de Amazon MQ.
En este script, deberá proporcionar los siguientes valores:
+ `CLIENT_ID` y `CLIENT_SECRET`: puede encontrar estos valores en la **App clients (Página de clientes de aplicación)** de la consola Amazon Cognito.
+ Dominio de Cognito: puede encontrarlo en la consola de Amazon Cognito. En **Branding (Marca)**, seleccione **Domain (Dominio)**. En la página **Domain (Dominio)**, encontrará este valor en la sección **Resource servers (Servidores de recursos)**.
+ Punto de conexión del agente de Amazon MQ: puede encontrar este valor en **Connections (Conexiones)**, en la página de detalles del agente de la consola de Amazon MQ.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
CLIENT_ID=${RabbitMqOAuth2TestStack.AmqpAppClientId}
CLIENT_SECRET=${RabbitMqOAuth2TestStack.AmqpAppClientSecret}
# FIXME: Update this value with the domain of your Amazon Cognito user pool
RESPONSE=$(curl -X POST ${RabbitMqOAuth2TestStack.TokenEndpoint} \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=client_credentials&client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}&scope=rabbitmq/configure:all rabbitmq/read:all rabbitmq/tag:administrator rabbitmq/write:all")
# Extract the access_token from the response.
# This token will be passed in the password field when connecting to the broker.
# Note that the username is left blank, the field is ignored by the plugin.
BROKER_PASSWORD=$(echo ${RESPONSE} | jq -r '.access_token')
# FIXME: Update this value with the endpoint of your broker. For example, b-89424106-7e0e-4abe-8e98-8de0dada7630.mq.us-east-1.on.aws.
BROKER_DNS=
CONNECTION_STRING=amqps://:${BROKER_PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--flag persistent --rate $PRODUCER_RATE
```
## Configuración de OAuth 2.0 y autenticación simple con Amazon Cognito
Al crear un agente con autenticación OAuth 2.0, puede especificar uno de los siguientes métodos de autenticación:
+ **Solo con OAuth 2.0**: para usar este método, no proporciones un nombre de usuario ni una contraseña al crear el agente. El [procedimiento anterior](#oauth-tutorial-config-cognito-using-cli) muestra cómo utilizar únicamente el método de autenticación OAuth 2.0.
+ **Tanto la autenticación OAuth 2.0 como la autenticación simple**: para utilizar este método, proporcione un nombre de usuario y una contraseña al crear el agente. Además, añada `auth_backends.2 = internal` a la configuración de su agente, como se muestra en el siguiente procedimiento.
En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición, como ** y **, por sus valores reales.
1. Para utilizar ambos métodos de autenticación, cree la configuración de agente, como se muestra en el siguiente ejemplo.
```
auth_backends.1 = oauth2
auth_backends.2 = internal
# FIXME: Update this value with the token signing key URL of your Amazon Cognito user pool
auth_oauth2.jwks_url = ${RabbitMqOAuth2TestStack.JwksUri}
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.verify_aud = false
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.scope_aliases.1.alias = rabbitmq/read:all
auth_oauth2.scope_aliases.1.scope = rabbitmq/read:*/*
auth_oauth2.scope_aliases.2.alias = rabbitmq/write:all
auth_oauth2.scope_aliases.2.scope = rabbitmq/write:*/*
auth_oauth2.scope_aliases.3.alias = rabbitmq/configure:all
auth_oauth2.scope_aliases.3.scope = rabbitmq/configure:*/*
```
Esta configuración utiliza [alias de ámbito](https://www.rabbitmq.com/docs/oauth2#scope-translation) para asignar los ámbitos definidos en Amazon Cognito a ámbitos compatibles con RabbitMQ.
1. Cree un agente que utilice los dos métodos de autenticación, como se muestra en el siguiente ejemplo.
```
aws mq create-broker \
--broker-name "rabbitmq-oauth2-broker-with-internal-user" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": }' \
--users '[{"Username":"","Password":""}]'
```
1. Compruebe que el estado del agente y la configuración para establecer el método de autenticación se hayan realizado correctamente, tal como se describe en los pasos 5 y 6 del procedimiento [Configuración de la autenticación OAuth 2.0 con Amazon Cognito](#oauth-tutorial-config-cognito-using-cli).
# Uso de la autenticación y autorización de IAM para Amazon MQ for RabbitMQ
El siguiente procedimiento muestra cómo habilitar la autenticación y la autorización de AWS IAM para un bróker de Amazon MQ for RabbitMQ. Tras habilitar la IAM, los usuarios pueden autenticarse con las credenciales de IAM para acceder a la API de administración de AWS RabbitMQ y conectarse a través de AMQP. Para obtener más información sobre cómo funciona la autenticación de IAM con Amazon MQ para RabbitMQ, consulte. [Autenticación y autorización de IAM para Amazon MQ para RabbitMQ](iam-for-amq-for-rabbitmq.md)
## Requisitos previos
+ AWS credenciales de administrador de la AWS cuenta propietaria del bróker Amazon MQ for RabbitMQ
+ Un entorno de shell configurado con estas credenciales de administrador (mediante perfiles AWS CLI o variables de entorno)
+ AWS CLI instalada y configurada
+ `jq`Procesador JSON de línea de comandos instalado
+ `curl`herramienta de línea de comandos instalada
## Configurar la autenticación y la autorización de IAM mediante AWS CLI
1. **Defina las variables de entorno**
Establezca las variables de entorno necesarias para su corredor:
```
export AWS_DEFAULT_REGION=
export BROKER_ID=
```
1. **Habilite los tokens JWT salientes**
Habilite la federación de identidades web salientes para su cuenta: AWS
```
ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
echo $ISSUER_IDENTIFIER
```
El resultado muestra una URL de identificador de emisor única para su cuenta en este formato. `https://.tokens.sts.global.api.aws`
1. **Cree el documento de política de IAM**
Cree un documento de política que conceda permisos para obtener tokens de identidad web:
```
cat > policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sts:GetWebIdentityToken",
"sts:TagGetWebIdentityToken"
],
"Resource": "*"
}
]
}
EOF
```
1. **Cree la política de confianza**
Recupera la identidad de la persona que llama y crea un documento de política de confianza:
```
CALLER_ARN=$(aws sts get-caller-identity --query Arn --output text)
cat > trust-policy.json << EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "$CALLER_ARN"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
1. **Cree el rol de IAM**
Cree el rol de IAM y adjunte la política:
```
aws iam create-role --role-name RabbitMqAdminRole --assume-role-policy-document file://trust-policy.json
aws iam put-role-policy --role-name RabbitMqAdminRole --policy-name RabbitMqAdminRolePolicy --policy-document file://policy.json
```
1. **Configure los ajustes de RabbitMQ OAuth2 **
Cree un archivo de configuración de RabbitMQ con los ajustes de autenticación y autorización: OAuth2
```
cat > rabbitmq.conf << EOF
auth_backends.1 = oauth2
auth_backends.2 = internal
auth_oauth2.jwks_url = ${ISSUER_IDENTIFIER}/.well-known/jwks.json
auth_oauth2.resource_server_id = rabbitmq
auth_oauth2.scope_prefix = rabbitmq/
auth_oauth2.additional_scopes_key = sub
auth_oauth2.scope_aliases.1.alias = arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole
auth_oauth2.scope_aliases.1.scope = rabbitmq/tag:administrator rabbitmq/read:*/* rabbitmq/write:*/* rabbitmq/configure:*/*
auth_oauth2.https.hostname_verification = wildcard
management.oauth_enabled = true
EOF
```
1. **Actualice la configuración del corredor**
Aplique la nueva configuración a su corredor:
```
# Retrieve the configuration ID
CONFIG_ID=$(aws mq describe-broker --broker-id $BROKER_ID --query 'Configurations[0].Id' --output text)
# Create a new configuration revision
REVISION=$(aws mq update-configuration --configuration-id $CONFIG_ID --data "$(cat rabbitmq.conf | base64 --wrap=0)" --query 'LatestRevision.Revision' --output text)
# Apply the configuration to the broker
aws mq update-broker --broker-id $BROKER_ID --configuration Id=$CONFIG_ID,Revision=$REVISION
# Reboot the broker to apply changes
aws mq reboot-broker --broker-id $BROKER_ID
```
Espere a que vuelva al estado de corredor `RUNNING` antes de continuar con el siguiente paso.
1. **Obtenga un token JWT**
Asuma el rol de IAM y obtenga un token de identidad web:
```
# Assume the RabbitMqAdminRole
ROLE_CREDS=$(aws sts assume-role --role-arn arn:aws:iam::$(aws sts get-caller-identity --query Account --output text):role/RabbitMqAdminRole --role-session-name rabbitmq-session)
# Configure the session with temporary credentials
export AWS_ACCESS_KEY_ID=$(echo "$ROLE_CREDS" | jq -r '.Credentials.AccessKeyId')
export AWS_SECRET_ACCESS_KEY=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SecretAccessKey')
export AWS_SESSION_TOKEN=$(echo "$ROLE_CREDS" | jq -r '.Credentials.SessionToken')
# Obtain the web identity token
TOKEN_RESPONSE=$(aws sts get-web-identity-token \
--audience "rabbitmq" \
--signing-algorithm ES384 \
--duration-seconds 300 \
--tags Key=scope,Value="rabbitmq/tag:administrator")
# Extract the token
TOKEN=$(echo "$TOKEN_RESPONSE" | jq -r '.WebIdentityToken')
```
1. **Acceda a la API de administración de RabbitMQ**
Utilice el token JWT para acceder a la API de administración de RabbitMQ:
```
BROKER_URL=.mq..on.aws
curl -u ":$TOKEN" \
-X GET https://${BROKER_URL}/api/overview \
-H "Content-Type: application/json"
```
Una respuesta correcta confirma que la autenticación de IAM funciona correctamente. La respuesta contiene información general sobre el corredor en formato JSON.
1. **Conéctese a través de AMQP utilizando el token JWT**
Pruebe la conectividad AMQP con el token JWT con la herramienta de prueba de rendimiento:
```
BROKER_DNS=
CONNECTION_STRING=amqps://:${TOKEN}@${BROKER_DNS}:5671
docker run -it --rm --ulimit nofile=40960:40960 pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-%d' --queue-pattern-from 1 --queue-pattern-to 1 \
--producers 1 --consumers 1 \
--uri ${CONNECTION_STRING} \
--flag persistent --rate 1
```
Si recibe un `ACCESS_REFUSED` error, puede solucionar los problemas de configuración utilizando los registros de su agente. CloudWatch Puede encontrar el enlace al grupo de CloudWatch registros de registros de su agente en la consola de Amazon MQ.
# Uso de la autenticación y autorización LDAP para Amazon MQ for RabbitMQ
En este tutorial se describe cómo configurar la autenticación y la autorización de LDAP para su Amazon MQ para corredores de RabbitMQ mediante. AWS Managed Microsoft AD
**Topics**
+ [Requisitos previos para configurar la autenticación y la autorización de LDAP](#rabbitmq-ldap-tutorial-prerequisites)
+ [Configuración de LDAP en RabbitMQ mediante CLI AWS](#rabbitmq-ldap-tutorial-configure-cli)
## Requisitos previos para configurar la autenticación y la autorización de LDAP
Puede configurar AWS los recursos necesarios en este tutorial mediante la implementación de la [pila de AWS CDK para la integración de LDAP de Amazon MQ para RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-ldap-activedirectory-sample/) con. AWS Managed Microsoft AD
Esta pila de CDK crea automáticamente todos los AWS recursos necesarios AWS Managed Microsoft AD, incluidos los usuarios y grupos de LDAP, Network Load Balancer, los certificados y las funciones de IAM. Consulte el paquete README para obtener una lista completa de los recursos creados por la pila.
Si va a configurar los recursos manualmente en lugar de utilizar la pila de CDK, asegúrese de disponer de la infraestructura equivalente antes de configurar LDAP en su Amazon MQ para corredores de RabbitMQ.
### Requisito previo para configurar Amazon MQ
AWS Versión CLI >= 2.28.23 para que la adición de un nombre de usuario y una contraseña sea opcional durante la creación del corredor.
## Configuración de LDAP en RabbitMQ mediante CLI AWS
Este procedimiento utiliza la AWS CLI para crear y configurar los recursos necesarios. En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición, como el ID de configuración y la revisión, `` por sus valores `<2>` reales.
1. Cree una nueva configuración mediante el comando `create-configuration` AWS CLI, como se muestra en el siguiente ejemplo.
```
aws mq create-configuration \
--name "rabbitmq-ldap-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ldap-config on RabbitMQ 3.13",
"Revision": 1
},
"Name": "rabbitmq-ldap-config"
}
```
1. Cree un archivo de configuración llamado `rabbitmq.conf` a utilizar LDAP como método de autenticación y autorización, como se muestra en el siguiente ejemplo. Sustituya todos los valores de marcador de posición de la plantilla (marcados con`${RabbitMqLdapTestStack.*}`) por valores reales de las salidas de la pila de requisitos AWS CDK previos implementada o de una infraestructura equivalente.
```
auth_backends.1 = ldap
# LDAP authentication settings - For more information,
# see https://www.rabbitmq.com/docs/ldap#basic
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_ldap.servers.1 = ${RabbitMqLdapTestStack.NlbDnsName}
auth_ldap.dn_lookup_bind.user_dn = ${RabbitMqLdapTestStack.DnLookupUserDn}
auth_ldap.dn_lookup_base = ${RabbitMqLdapTestStack.DnLookupBase}
auth_ldap.dn_lookup_attribute = ${RabbitMqLdapTestStack.DnLookupAttribute}
auth_ldap.port = 636
auth_ldap.use_ssl = true
auth_ldap.ssl_options.verify = verify_peer
auth_ldap.log = network
# AWS integration for secure credential retrieval
# - see: https://github.com/amazon-mq/rabbitmq-aws
# The aws plugin allows RabbitMQ to securely retrieve credentials and certificates
# from AWS services.
# Replace the ${RabbitMqLdapTestStack.*} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.auth_ldap.ssl_options.cacertfile = ${RabbitMqLdapTestStack.CaCertArn}
aws.arns.auth_ldap.dn_lookup_bind.password = ${RabbitMqLdapTestStack.DnLookupUserPasswordArn}
aws.arns.assume_role_arn = ${RabbitMqLdapTestStack.AmazonMqAssumeRoleArn}
# LDAP authorization queries - For more information,
# see: https://www.rabbitmq.com/docs/ldap#authorisation
# FIXME: Replace the ${RabbitMqLdapTestStack.*} placeholders with actual group DN
# values from your deployed prerequisite CDK stack outputs
# Uses Active Directory groups created by the prerequisite CDK stack
auth_ldap.queries.tags = '''
[{administrator, {in_group, "${RabbitMqLdapTestStack.RabbitMqAdministratorsGroupDn}"}},
{management, {in_group, "${RabbitMqLdapTestStack.RabbitMqMonitoringUsersGroupDn}"}}]
'''
# FIXME: This provides all authenticated users access to all vhosts
# - update to restrict access as required
auth_ldap.queries.vhost_access = '''
{constant, true}
'''
# FIXME: This provides all authenticated users full access to all
# queues and exchanges - update to restrict access as required
auth_ldap.queries.resource_access = '''
{for, [ {permission, configure, {constant, true}},
{permission, write,
{for, [{resource, queue, {constant, true}},
{resource, exchange, {constant, true}}]}},
{permission, read,
{for, [{resource, exchange, {constant, true}},
{resource, queue, {constant, true}}]}}
]
}
'''
# FIXME: This provides all authenticated users access to all topics
# - update to restrict access as required
auth_ldap.queries.topic_access = '''
{for, [{permission, write, {constant, true}},
{permission, read, {constant, true}}
]
}
'''
```
1. Actualice la configuración mediante el comando `update-configuration` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, añada el identificador de configuración que recibió en la respuesta al paso 1 de este procedimiento. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-b600ac8e-8183-4f74-a713-983e59f30e3d",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ldap-config",
"Warnings": []
}
```
1. Cree un broker con la configuración de LDAP que creó en el paso 2 de este procedimiento. Para ello, utilice el comando `create-broker` AWS CLI como se muestra en el siguiente ejemplo. En este comando, indique el identificador de configuración y el número de revisión que obtuvo en las respuestas de los pasos 1 y 2, respectivamente. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` y `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ldap-test-1" \
--engine-type "RABBITMQ" \
--engine-version "3.13" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "CLUSTER_MULTI_AZ" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ldap-broker:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
**Restricción de nombres de corredores**
Para empezar, el rol de IAM creado por la pila de CDK necesaria restringe los nombres de los corredores. `rabbitmq-ldap-test` Asegúrese de que el nombre de su corredor siga este patrón o el rol de IAM no tendrá permiso para asumir el rol para la resolución de ARN.
1. Compruebe que el estado del bróker pasa de `CREATION_IN_PROGRESS` a`RUNNING`, mediante el comando `describe-broker` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, proporcione el ID de agente que obtuvo en el resultado del paso anterior, por ejemplo, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Este comando devuelve una respuesta de JSON similar a la siguiente. La siguiente respuesta es una versión abreviada del resultado completo que devuelve el comando `describe-broker`. Esta respuesta muestra el estado del agente y la estrategia de autenticación utilizada para proteger al agente. En este caso, la estrategia de `config_managed` autenticación indica que el agente utiliza el método de autenticación LDAP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Valide el acceso a RabbitMQ con uno de los usuarios de prueba creados con la pila de CDK necesaria
```
# FIXME: Replace ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqLdapTestStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a user (should fail - console user only has monitoring permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/users/testuser \
-H "Content-Type: application/json" \
-d '{"password":"testpass","tags":"management"}'
```
# Uso de la autenticación y autorización HTTP para Amazon MQ for RabbitMQ
En este tutorial se describe cómo configurar la autenticación y la autorización HTTP para sus agentes de Amazon MQ for RabbitMQ mediante un servidor HTTP externo.
**nota**
El complemento de autenticación HTTP solo está disponible para Amazon MQ para RabbitMQ versión 4 y versiones posteriores.
**Topics**
+ [Requisitos previos para configurar la autenticación y la autorización HTTP](#rabbitmq-http-tutorial-prerequisites)
+ [Configuración de la autenticación HTTP en RabbitMQ mediante CLI AWS](#rabbitmq-http-tutorial-configure-cli)
## Requisitos previos para configurar la autenticación y la autorización HTTP
Puede configurar AWS los recursos necesarios en este tutorial mediante la implementación de la [pila de AWS CDK para la integración de autenticación HTTP de Amazon MQ para RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/).
Esta pila de CDK crea automáticamente todos los AWS recursos necesarios, incluidos el servidor de autenticación HTTP, los certificados y las funciones de IAM. Consulte el paquete README para obtener una lista completa de los recursos creados por la pila.
Si va a configurar los recursos manualmente en lugar de utilizar la pila de CDK, asegúrese de disponer de la infraestructura equivalente antes de configurar la autenticación HTTP en su Amazon MQ para agentes de RabbitMQ.
### Requisito previo para configurar Amazon MQ
AWS Versión CLI >= 2.28.23 para que agregar un nombre de usuario y una contraseña sea opcional durante la creación del corredor.
## Configuración de la autenticación HTTP en RabbitMQ mediante CLI AWS
Este procedimiento utiliza la AWS CLI para crear y configurar los recursos necesarios. En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición por sus valores reales.
1. Cree una nueva configuración mediante el comando `create-configuration` AWS CLI, como se muestra en el siguiente ejemplo.
```
aws mq create-configuration \
--name "rabbitmq-http-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-http-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-http-config"
}
```
1. Cree un archivo de configuración llamado `rabbitmq.conf` a utilizar HTTP como método de autenticación y autorización, como se muestra en el siguiente ejemplo. Sustituya todos los valores de marcador de posición de la plantilla (marcados con`${...}`) por valores reales de las salidas de la pila de AWS CDK requisitos previos implementada o de una infraestructura equivalente.
```
auth_backends.1 = cache
auth_backends.2 = http
auth_cache.cached_backend = http
# HTTP authentication settings
# For more information, see https://github.com/rabbitmq/rabbitmq-auth-backend-http
# FIXME: Replace the ${...} placeholders with actual values
# from your deployed prerequisite CDK stack outputs.
auth_http.http_method = post
auth_http.user_path = ${HttpServerUserPath}
auth_http.vhost_path = ${HttpServerVhostPath}
auth_http.resource_path = ${HttpServerResourcePath}
auth_http.topic_path = ${HttpServerTopicPath}
# TLS/HTTPS configuration
auth_http.ssl_options.verify = verify_peer
auth_http.ssl_options.sni = test.amazonaws.com
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.auth_http.ssl_options.cacertfile = ${CaCertArn}
```
1. Actualice la configuración mediante el comando `update-configuration` AWS CLI. Utilice el ID de configuración del paso 3.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-http-config",
"Warnings": []
}
```
1. Cree un intermediario con la configuración HTTP. Utilice el identificador de configuración y el número de revisión de los pasos anteriores.
```
aws mq create-broker \
--broker-name "rabbitmq-http-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}'
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-http-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Compruebe que el estado del bróker pasa de `CREATION_IN_PROGRESS` a`RUNNING`, mediante el comando `describe-broker` AWS CLI.
```
aws mq describe-broker \
--broker-id ""
```
Este comando devuelve una respuesta de JSON similar a la siguiente. La estrategia de `config_managed` autenticación indica que el agente utiliza el método de autenticación HTTP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Valide el acceso a RabbitMQ con uno de los usuarios de prueba creados con la pila de CDK necesaria
```
# FIXME: Replace ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} with the actual ARN from your deployed prerequisite CDK stack outputs
CONSOLE_PASSWORD=$(aws secretsmanager get-secret-value \
--secret-id ${RabbitMqHttpAuthElbStack.ConsoleUserPasswordArn} \
--query 'SecretString' --output text)
# FIXME: Replace BrokerConsoleURL with the actual ConsoleURL retrieved by
# calling describe-broker for the broker created above
# Call management API /api/overview (should succeed)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
https://${BrokerConsoleURL}/api/overview
# Try to create a vhost (should fail - console user only has management permissions)
curl -u RabbitMqConsoleUser:$CONSOLE_PASSWORD \
-X PUT https://${BrokerConsoleURL}/api/vhosts/test-vhost \
-H "Content-Type: application/json" \
-d '{}'
```
# Uso de la autenticación con certificado SSL para Amazon MQ para RabbitMQ
En este tutorial se describe cómo configurar la autenticación con certificado SSL para sus corredores de Amazon MQ for RabbitMQ mediante una autoridad de certificación privada.
**nota**
El complemento de autenticación con certificado SSL solo está disponible para Amazon MQ para RabbitMQ versión 4 y versiones posteriores.
**Topics**
+ [Requisitos previos para configurar la autenticación con certificado SSL](#rabbitmq-ssl-tutorial-prerequisites)
+ [Configuración de la autenticación con certificado SSL en RabbitMQ mediante CLI AWS](#rabbitmq-ssl-tutorial-configure-cli)
## Requisitos previos para configurar la autenticación con certificado SSL
La autenticación con certificados SSL utiliza el TLS mutuo (mTLS) para autenticar a los clientes mediante certificados X.509. Puede configurar AWS los recursos necesarios en este tutorial mediante la implementación de la [pila de AWS CDK para la integración de mTLS de Amazon MQ para RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/).
Esta pila de CDK crea automáticamente todos los AWS recursos necesarios, incluidos la autoridad de certificación, los certificados de cliente y las funciones de IAM. Consulte el paquete README para obtener una lista completa de los recursos creados por la pila.
**nota**
Antes de implementar la pila de CDK, defina la variable de `RABBITMQ_TEST_USER_NAME` entorno. Este valor se utilizará como nombre común (CN) en el certificado del cliente y debe coincidir con el nombre de usuario que utilice en los pasos del tutorial. Por ejemplo: `export RABBITMQ_TEST_USER_NAME="myuser"`
Si va a configurar los recursos manualmente en lugar de utilizar la pila de CDK, asegúrese de disponer de la infraestructura equivalente antes de configurar la autenticación con certificado SSL en su Amazon MQ para agentes de RabbitMQ.
### Requisito previo para configurar Amazon MQ
AWS Versión CLI >= 2.28.23 para que la adición de un nombre de usuario y una contraseña sea opcional durante la creación del corredor.
## Configuración de la autenticación con certificado SSL en RabbitMQ mediante CLI AWS
Este procedimiento utiliza la AWS CLI para crear y configurar los recursos necesarios. En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición, como el ID de configuración y la revisión, `` por sus valores `<2>` reales.
1. Cree una nueva configuración mediante el comando `create-configuration` AWS CLI, como se muestra en el siguiente ejemplo.
```
aws mq create-configuration \
--name "rabbitmq-ssl-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-ssl-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-ssl-config"
}
```
1. Cree un archivo de configuración denominado `rabbitmq.conf` para utilizar la autenticación con certificado SSL, como se muestra en el siguiente ejemplo. Sustituya todos los valores de marcador de posición de la plantilla (marcados con`${...}`) por valores reales de las salidas de la pila de AWS CDK requisitos previos implementada o de una infraestructura equivalente.
```
auth_mechanisms.1 = EXTERNAL
ssl_cert_login_from = common_name
auth_backends.1 = internal
# Reject if no client cert
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
```
1. Actualice la configuración mediante el comando `update-configuration` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, añada el identificador de configuración que recibió en la respuesta al paso 1 de este procedimiento. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-ssl-config",
"Warnings": []
}
```
1. Cree un agente con la configuración de autenticación del certificado SSL que creó en el paso 2 de este procedimiento. Para ello, utilice el comando `create-broker` AWS CLI tal y como se muestra en el siguiente ejemplo. En este comando, indique el identificador de configuración y el número de revisión que obtuvo en las respuestas de los pasos 1 y 2, respectivamente. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` y `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-ssl-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-ssl-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Compruebe que el estado del bróker pasa de `CREATION_IN_PROGRESS` a`RUNNING`, mediante el comando `describe-broker` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, proporcione el ID de corredor que obtuvo en el resultado del paso anterior. Por ejemplo, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Este comando devuelve una respuesta de JSON similar a la siguiente. La siguiente respuesta es una versión abreviada del resultado completo que devuelve el comando `describe-broker`. Esta respuesta muestra el estado del agente y la estrategia de autenticación utilizada para proteger al agente. En este caso, la estrategia de `config_managed` autenticación indica que el agente utiliza el método de autenticación con certificado SSL.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Verifique la autenticación del certificado SSL con el siguiente `ssl.sh` script.
Utilice este script de bash para probar la conectividad con su agente de Amazon MQ para RabbitMQ. Este script usa su certificado de cliente para la autenticación y verifica si la conexión se configuró correctamente. Si se ha configurado correctamente, verá que su agente publica y consume mensajes.
Si recibe un `ACCESS_REFUSED` error, puede solucionar los problemas de configuración utilizando los CloudWatch registros de su agente. Encontrará el enlace al grupo de CloudWatch registros de su agente en la consola de Amazon MQ.
En este script, deberá proporcionar los siguientes valores:
+ `USERNAME`: El nombre común (CN) de su certificado de cliente.
+ `CLIENT_KEYSTORE`: Ruta al archivo del almacén de claves del cliente (PKCS12 formato). Si ha utilizado la pila de CDK necesaria, la ruta por defecto es. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: contraseña para el almacén de claves de su cliente. Si ha utilizado la pila de CDK necesaria, la contraseña predeterminada es. `changeit`
+ `BROKER_DNS`: Puedes encontrar este valor en **Conexiones**, en la página de detalles del bróker de la consola Amazon MQ.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--sasl-external \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# Uso de mTLS para AMQP y puntos finales de administración
Este tutorial describe cómo configurar el TLS mutuo (mTLS) para las conexiones de los clientes AMQP y la interfaz de administración de RabbitMQ mediante una autoridad de certificación privada.
**nota**
El uso de autoridades de certificación privadas para los mTL solo está disponible para Amazon MQ para RabbitMQ versión 4 y versiones posteriores.
**Topics**
+ [Requisitos previos para configurar los mTLS](#rabbitmq-mtls-tutorial-prerequisites)
+ [Configuración de mTLS en RabbitMQ mediante CLI AWS](#rabbitmq-mtls-tutorial-configure-cli)
## Requisitos previos para configurar los mTLS
Puede configurar AWS los recursos necesarios en este tutorial implementando la [pila de AWS CDK para la integración de Amazon MQ para RabbitMQ mTLS](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) con.
Esta pila de CDK crea automáticamente todos los AWS recursos necesarios, incluidos la autoridad de certificación, los certificados de los clientes y las funciones de IAM. Consulte el paquete README para obtener una lista completa de los recursos creados por la pila.
Si va a configurar los recursos manualmente en lugar de utilizar la pila de CDK, asegúrese de disponer de la infraestructura equivalente antes de configurar mTLS en su Amazon MQ para corredores de RabbitMQ.
### Requisito previo para configurar Amazon MQ
AWS Versión CLI >= 2.28.23 para que la adición de un nombre de usuario y una contraseña sea opcional durante la creación del corredor.
## Configuración de mTLS en RabbitMQ mediante CLI AWS
Este procedimiento utiliza la AWS CLI para crear y configurar los recursos necesarios. En el siguiente procedimiento, asegúrese de reemplazar los valores de los marcadores de posición, como el ID de configuración y la revisión, `` por sus valores `<2>` reales.
1. Cree una nueva configuración mediante el comando `create-configuration` AWS CLI, como se muestra en el siguiente ejemplo.
```
aws mq create-configuration \
--name "rabbitmq-mtls-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"AuthenticationStrategy": "simple",
"Created": "2025-07-17T16:03:01.759943+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:03:01.759000+00:00",
"Description": "Auto-generated default for rabbitmq-mtls-config on RabbitMQ 4.2",
"Revision": 1
},
"Name": "rabbitmq-mtls-config"
}
```
1. Cree un archivo de configuración denominado `rabbitmq.conf` para configurar los mTLs para el AMQP y los puntos finales de administración, como se muestra en el siguiente ejemplo. Sustituya todos los valores de marcador de posición de la plantilla (marcados con`${...}`) por valores reales de las salidas de la pila de AWS CDK requisitos previos implementada o de una infraestructura equivalente.
```
auth_backends.1 = internal
# TLS configuration
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
management.ssl.verify = verify_peer
# AWS integration for secure credential retrieval
# For more information, see https://github.com/amazon-mq/rabbitmq-aws
# FIXME: Replace the ${...} placeholders with actual ARN values
# from your deployed prerequisite CDK stack outputs.
aws.arns.assume_role_arn = ${AmazonMqAssumeRoleArn}
aws.arns.ssl_options.cacertfile = ${CaCertArn}
aws.arns.management.ssl.cacertfile = ${CaCertArn}
```
1. Actualice la configuración mediante el comando `update-configuration` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, añada el identificador de configuración que recibió en la respuesta al paso 1 de este procedimiento. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"Arn": "arn:aws:mq:us-west-2:123456789012:configuration:c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"Created": "2025-07-17T16:57:04.520931+00:00",
"Id": "c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca",
"LatestRevision": {
"Created": "2025-07-17T16:57:39.172000+00:00",
"Revision": 2
},
"Name": "rabbitmq-mtls-config",
"Warnings": []
}
```
1. Cree un corredor con la configuración mTLS que creó en el paso 2 de este procedimiento. Para ello, utilice el comando `create-broker` AWS CLI tal y como se muestra en el siguiente ejemplo. En este comando, indique el identificador de configuración y el número de revisión que obtuvo en las respuestas de los pasos 1 y 2, respectivamente. Por ejemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` y `2`.
```
aws mq create-broker \
--broker-name "rabbitmq-mtls-test-1" \
--engine-type "RABBITMQ" \
--engine-version "4.2" \
--host-instance-type "mq.m7g.large" \
--deployment-mode "SINGLE_INSTANCE" \
--logs '{"General": true}' \
--publicly-accessible \
--configuration '{"Id": "","Revision": <2>}' \
--users '[{"Username":"testuser","Password":"testpassword"}]'
```
Este comando devuelve una respuesta de JSON similar a la siguiente.
```
{
"BrokerArn": "arn:aws:mq:us-west-2:123456789012:broker:rabbitmq-mtls-test-1:b-2a1b5133-a10c-49d2-879b-8c176c34cf73",
"BrokerId": "b-2a1b5133-a10c-49d2-879b-8c176c34cf73"
}
```
1. Compruebe que el estado del bróker pasa de `CREATION_IN_PROGRESS` a`RUNNING`, mediante el comando `describe-broker` AWS CLI, como se muestra en el siguiente ejemplo. En este comando, proporcione el ID de corredor que obtuvo en el resultado del paso anterior. Por ejemplo, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Este comando devuelve una respuesta de JSON similar a la siguiente. La siguiente respuesta es una versión abreviada del resultado completo que devuelve el comando `describe-broker`.
```
{
"AuthenticationStrategy": "simple",
...,
"BrokerState": "RUNNING",
...
}
```
1. Verifique la autenticación de mTLS con el siguiente `mtls.sh` script.
Utilice este script de bash para probar la conectividad con su agente de Amazon MQ para RabbitMQ. Este script usa su certificado de cliente para autenticarse y verificar si la conexión se configuró correctamente. Si se ha configurado correctamente, verá que su agente publica y consume mensajes.
Si recibe un `ACCESS_REFUSED` error, puede solucionar los problemas de configuración utilizando los CloudWatch registros de su agente. Encontrará el enlace al grupo de CloudWatch registros de su agente en la consola de Amazon MQ.
En este script, deberá proporcionar los siguientes valores:
+ `USERNAME`y`PASSWORD`: las credenciales de usuario de RabbitMQ que creó con el bróker.
+ `CLIENT_KEYSTORE`: Ruta al archivo del almacén de claves de su cliente (formato). PKCS12 Si ha utilizado la pila de CDK necesaria, la ruta por defecto es. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: contraseña para el almacén de claves de su cliente. Si ha utilizado la pila de CDK necesaria, la contraseña predeterminada es. `changeit`
+ `BROKER_DNS`: Puedes encontrar este valor en **Conexiones**, en la página de detalles del bróker de la consola Amazon MQ.
```
#! /bin/bash
set -e
# Client information
## FIXME: Update this value with the client ID and secret of your confidential application client
USERNAME=
PASSWORD=
CLIENT_KEYSTORE=$(pwd)/certs/client-keystore.p12
KEYSTORE_PASSWORD=changeit
BROKER_DNS=
CONNECTION_STRING=amqps://${USERNAME}:${PASSWORD}@${BROKER_DNS}:5671
# Produce/consume messages using the above connection string
QUEUES_COUNT=1
PRODUCERS_COUNT=1
CONSUMERS_COUNT=1
PRODUCER_RATE=1
finch run --rm --ulimit nofile=40960:40960 \
-v ${CLIENT_KEYSTORE}:/certs/client-keystore.p12:ro \
-e JAVA_TOOL_OPTIONS="-Djavax.net.ssl.keyStore=/certs/client-keystore.p12 -Djavax.net.ssl.keyStorePassword=${KEYSTORE_PASSWORD} -Djavax.net.ssl.keyStoreType=PKCS12" \
pivotalrabbitmq/perf-test:latest \
--queue-pattern 'test-queue-cert-%d' --queue-pattern-from 1 --queue-pattern-to $QUEUES_COUNT \
--producers $PRODUCERS_COUNT --consumers $CONSUMERS_COUNT \
--id "cert-test${QUEUES_COUNT}q${PRODUCERS_COUNT}p${CONSUMERS_COUNT}c${PRODUCER_RATE}r" \
--uri ${CONNECTION_STRING} \
--use-default-ssl-context \
--flag persistent --rate $PRODUCER_RATE
```
# Conexión de la aplicación JMS
En este tutorial se muestra cómo conectar la aplicación JMS al bróker Amazon MQ for RabbitMQ mediante el cliente JMS RabbitMQ. Aprenderá a crear un productor para enviar mensajes y un consumidor para recibir los mensajes de las colas de RabbitMQ.
Antes de empezar, añade la dependencia JMS de RabbitMQ adecuada a tu proyecto de Maven:
Para JMS 1.1 y 2.0:
```
com.rabbitmq.jms
rabbitmq-jms
2.12.0
```
Para JMS 3.1:
```
com.rabbitmq.jms
rabbitmq-jms
3.5.0
```
## Cree un productor
El siguiente ejemplo de código muestra cómo escribir en una cola de RabbitMQ mediante JMS:
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
connection = factory.createConnection();
connection.start();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination(queueName, true, false);
// Send the message to the queue
MessageProducer producer = session.createProducer(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
String msg_content = "Hello World!!";
TextMessage textMessage = session.createTextMessage(msg_content);
producer.send(textMessage);
System.out.printf("Published to AMQP queue '%s': %s", queueName, msg_content);
```
## Crea un consumidor
El siguiente ejemplo de código muestra cómo leer una cola de RabbitMQ mediante JMS:
```
import jakarta.jms.*;
import com.rabbitmq.jms.admin.*;
// Setting the connection factory
RMQConnectionFactory factory = new RMQConnectionFactory();
factory.setHost(envProps.getProperty("RABBITMQ_HOST", "localhost"));
factory.setPort(Integer.parseInt(envProps.getProperty("RABBITMQ_PORT", "5672")));
factory.setUsername(envProps.getProperty("RABBITMQ_USERNAME", "guest"));
factory.setPassword(envProps.getProperty("RABBITMQ_PASSWORD", "guest"));
factory.setVirtualHost(envProps.getProperty("RABBITMQ_VIRTUAL_HOST", "/"));
factory.useSslProtocol();
// Establish the connection and session
jakarta.jms.Connection connection = factory.createConnection();
String queueName = "test-queue-jms";
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
RMQDestination destination = new RMQDestination();
destination.setDestinationName(queueName);
destination.setAmqp(true);
destination.setAmqpQueueName(queueName);
// Initialize consumer
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(message -> {
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
System.out.printf("Message: %s%n", textMessage.getText());
} else if (message instanceof BytesMessage) {
BytesMessage bytesMessage = (BytesMessage) message;
byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
bytesMessage.readBytes(bytes);
String content = new String(bytes);
System.out.printf("Message: %s%n", content);
} else {
System.out.printf("Message: [%s]%n", message.getClass().getSimpleName());
}
} catch (JMSException e) {
System.err.printf("Error processing message: %s%n", e.getMessage());
}
});
connection.start();
```