As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutoriais do RabbitMQ
Os tutoriais a seguir mostram como é possível configurar e usar o RabbitMQ no Amazon MQ. Para saber mais sobre como trabalhar com bibliotecas de clientes compatíveis com várias linguagens de programação como Node.js, Python, .NET e muito mais, consulte [Tutoriais do RabbitMQ](https://www.rabbitmq.com/getstarted.html) no *Guia de conceitos básicos do RabbitMQ*.
**Topics**
+ [Editar as preferências de agente](amazon-mq-rabbitmq-editing-broker-preferences.md)
+ [Como usar Python Pika com o Amazon MQ para RabbitMQ](amazon-mq-rabbitmq-pika.md)
+ [Resolvendo a sincronização de fila pausada do RabbitMQ](rabbitmq-queue-sync.md)
+ [Reduzir o número de conexões e canais](reducing-connections-and-channels.md)
+ [Etapa 2: conectar uma aplicação baseada em JVM ao seu agente](#rabbitmq-connect-jvm-application)
+ [Connect your Amazon MQ for RabbitMQ broker to Lambda](#rabbitmq-connect-to-lambda)
+ [Uso da autorização e da autenticação OAuth 2.0 para Amazon MQ para RabbitMQ](oauth-tutorial.md)
+ [Usando autenticação e autorização do IAM para Amazon MQ para RabbitMQ](rabbitmq-iam-tutorial.md)
+ [Usando autenticação e autorização LDAP para Amazon MQ para RabbitMQ](rabbitmq-ldap-tutorial.md)
+ [Usando autenticação e autorização HTTP para Amazon MQ para RabbitMQ](rabbitmq-http-tutorial.md)
+ [Usando a autenticação de certificado SSL para Amazon MQ para RabbitMQ](rabbitmq-ssl-tutorial.md)
+ [Usando mTLS para AMQP e endpoints de gerenciamento](rabbitmq-mtls-tutorial.md)
+ [Conectando seu aplicativo JMS](rabbitmq-tutorial-jms.md)
# Editar as preferências de agente
Você pode editar suas preferências de corretor, como ativar ou desativar CloudWatch registros usando o. Console de gerenciamento da AWS
## Editar opções do agente RabbitMQ
1. Faça login no [console do Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Na lista de corretores, selecione seu corretor (por exemplo **MyBroker**) e escolha **Editar**.
1. Na *MyBroker* página **Editar**, na seção **Especificações**, selecione uma **versão do mecanismo Broker** ou um **tipo de Instância do Broker**.
1. Na seção **CloudWatch Registros**, clique no botão de alternância para ativar ou desativar os registros gerais. Nenhuma outra etapa é necessária.
**nota**
Para os corretores do RabbitMQ, o Amazon MQ usa automaticamente uma função vinculada ao serviço (SLR) para publicar registros gerais. CloudWatch Para obter mais informações, consulte [Uso de funções vinculadas ao serviço para o Amazon MQ](using-service-linked-roles.md).
O Amazon MQ não é compatível com registros de auditoria para agentes RabbitMQ.
1. Na seção **Maintenance (Manutenção)**, configure a programação de manutenção do agente:
Para atualizar o broker para novas versões à medida que as AWS libera, escolha **Habilitar atualizações automáticas de versões secundárias**. Atualizações automáticas ocorrem durante a *janela de manutenção* definida pelo dia da semana, a hora do dia (no formato de 24 horas) e o fuso horário (UTC, por padrão).
1. Selecione **Schedule modifications (Programar modificações)**.
**nota**
Se você selecionar somente **Enable automatic minor version upgrades (Habilitar atualizações automáticas de versão secundária)**, o botão será alterado para **Save (Salvar)**, pois não será necessária nenhuma reinicialização do agente.
Suas preferências serão aplicadas ao agente no horário especificado.
# Como usar Python Pika com o Amazon MQ para RabbitMQ
O tutorial a seguir mostra como você pode configurar um cliente [Python Pika](https://github.com/pika/pika) com o TLS configurado para estabelecer conexão com o agente Amazon MQ para RabbitMQ. O Pika é uma implementação Python do protocolo AMQP 0-9-1 para RabbitMQ. Este tutorial orienta você na instalação do Pika, na declaração de uma fila, na configuração de um editor para enviar mensagens para a bolsa padrão da corretora e na configuração de um consumidor para receber mensagens da fila.
**Topics**
+ [Pré-requisitos](#amazon-mq-rabbitmq-pika-prerequisites)
+ [Permissões](#amazon-mq-rabbitmq-pika-permissions)
+ [Etapa um: criar um cliente Python Pika básico](#amazon-mq-rabbitmq-pika-basic-client)
+ [Etapa dois: criar um publicador e enviar uma mensagem](#amazon-mq-rabbitmq-pika-publisher-basic-publish)
+ [Etapa três: criar um consumidor e receber uma mensagem](#amazon-mq-rabbitmq-pika-consumer-basic-get)
+ [Etapa quatro: (opcional) configurar um loop de eventos e consumir mensagens](#amazon-mq-rabbitmq-pika-consumer-basic-consume)
+ [Próximas etapas](#amazon-mq-rabbitmq-pika-whats-next)
## Pré-requisitos
Para concluir as etapas neste tutorial, você precisa dos seguintes pré-requisitos:
+ Um agente Amazon MQ para RabbitMQ. Para mais informações, consulte [Criar um agente Amazon MQ para RabbitMQ](getting-started-rabbitmq.md#create-rabbitmq-broker).
+ O [Python 3](https://www.python.org/downloads/) instalado para o seu sistema operacional.
+ O [Pika](https://pika.readthedocs.io/en/stable/) instalado usando o Python `pip`. Para instalar o Pika, abra uma nova janela de terminal e execute o seguinte.
```
$ python3 -m pip install pika
```
## Permissões
Para este tutorial, você precisa de pelo menos um usuário do agente Amazon MQ para RabbitMQ com permissão para gravação em e leitura de um vhost. A tabela a seguir descreve as permissões mínimas necessárias como padrões de expressão regular (regexp).
| Tags | Configurar regexp | Escrever regexp | Ler regexp |
| --- | --- | --- | --- |
| none | | .\$1 | .\$1 |
As permissões de usuário listadas fornecem apenas permissões de leitura e gravação para o usuário, sem conceder acesso ao plugin de gerenciamento para executar operações administrativas no agente. Você pode restringir ainda mais as permissões fornecendo padrões regexp que limitem o acesso do usuário às filas especificadas. Por exemplo, se você alterar o padrão regexp de leitura para `^[hello world].*`, o usuário só terá permissão de leitura para as filas que começam com `hello world`.
Para obter mais informações sobre criar usuários RabbitMQ e gerenciar etiquetas e permissões de usuário, consulte [Usuários do agente do Amazon MQ para RabbitMQ](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Etapa um: criar um cliente Python Pika básico
Para criar uma classe base de cliente Python Pika que define um construtor e fornece o contexto SSL necessário para a configuração TLS durante a interação com um agente Amazon MQ para RabbitMQ, faça o seguinte.
1. Abra uma nova janela de terminal, crie um novo diretório para seu projeto e acesse o diretório.
```
$ mkdir pika-tutorial
$ cd pika-tutorial
```
1. Crie um novo arquivo chamado `basicClient.py` contendo o seguinte 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()
```
Agora você pode definir classes adicionais para seu publicador e consumidor que herdam de `BasicPikaClient`.
## Etapa dois: criar um publicador e enviar uma mensagem
Para criar um publicador que declara uma fila e envia uma única mensagem, faça o seguinte.
1. Copie o conteúdo da amostra de código a seguir e salve localmente como `publisher.py` no mesmo diretório que você criou na etapa 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()
```
A classe `BasicMessageSender` herda de `BasicPikaClient` e implementa métodos adicionais para declarar uma fila, enviar uma mensagem para a fila e fechar conexões. A amostra de código encaminha uma mensagem para a troca padrão, com uma chave de roteamento igual ao nome da fila.
1. Em `if __name__ == "__main__":`, substitua os parâmetros transmitidos para a declaração do construtor `BasicMessageSender` com as seguintes informações.
+ **``** — O ID exclusivo que o Amazon MQ gera para o agente. Você pode analisar o ID do ARN do seu agente. Por exemplo, considerando o seguinte ARN, `arn:aws:mq:us-east-2:123456789012:broker:MyBroker:b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`, o ID do agente seria `b-1234a5b6-78cd-901e-2fgh-3i45j6k178l9`.
+ **``**: o nome de usuário de um usuário agente com permissões suficientes para gravação de mensagens no agente.
+ **``**: a senha de um usuário agente com permissões suficientes para gravação de mensagens no agente.
+ **``**— A AWS região na qual você criou seu corretor Amazon MQ para RabbitMQ. Por exemplo, .`us-west-2`
1. Execute o seguinte comando no mesmo diretório que você criou `publisher.py`.
```
$ python3 publisher.py
```
Se o código for executado com êxito, você verá o resultado a seguir na janela do seu terminal.
```
Trying to declare queue(hello world queue)...
Sent message. Exchange: , Routing Key: hello world queue, Body: b'Hello World!'
```
## Etapa três: criar um consumidor e receber uma mensagem
Para criar um consumidor que receba uma única mensagem da fila, faça o seguinte.
1. Copie o conteúdo da amostra de código a seguir e salve localmente como `consumer.py` no mesmo diretório.
```
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()
```
Semelhante ao editor que você criou na etapa anterior, `BasicMessageReceiver` herda `BasicPikaClient` e implementa métodos adicionais para receber uma única mensagem e fechar conexões.
1. Na declaração `if __name__ == "__main__":`, substitua os parâmetros transmitidos ao construtor `BasicMessageReceiver` com suas informações.
1. Execute o seguinte comando no diretório do projeto.
```
$ python3 consumer.py
```
Se o código for executado com êxito, você verá o corpo da mensagem e os cabeçalhos, incluindo a chave de roteamento, exibidos na janela do seu terminal.
```
b'Hello World!'
```
## Etapa quatro: (opcional) configurar um loop de eventos e consumir mensagens
Para consumir várias mensagens de uma fila, use o 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) do Pika e uma função de retorno de chamada conforme mostrado a seguir
1. Em `consumer.py`, adicione a definição de método a seguir à classe `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. Em `consumer.py`, sob `if __name__ == "__main__":`, invoque o método `consume_messages` definido por você na etapa 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. Execute `consumer.py` novamente e, se bem-sucedidas, as mensagens na fila serão exibidas na janela do seu terminal.
```
[*] Waiting for messages. To exit press CTRL+C
[x] Received b'Hello World!'
[x] Received b'Hello World!'
...
```
## Próximas etapas
+ Para mais informações sobre outras bibliotecas suportadas de cliente do RabbitMQ, consulte [Documentação do cliente RabbitMQ](https://www.rabbitmq.com/clients.html) no site do RabbitMQ.
# Resolvendo a sincronização de fila pausada do RabbitMQ
Em uma [implantação de cluster](rabbitmq-broker-architecture.md#rabbitmq-broker-architecture-cluster) do Amazon MQ para RabbitMQ, as mensagens publicadas em cada fila são replicadas em três nós de agente. Esta replicação, chamada de *espelhamento*, fornece alta disponibilidade (HA) para agentes RabbitMQ. As filas em uma implantação de cluster consistem em uma réplica *principal* em um nó e um ou mais *espelhos*. Cada operação aplicada a uma fila espelhada, incluindo o enfileiramento de mensagens, é aplicada primeiro à fila principal e, em seguida, replicada em seus espelhos.
Por exemplo, considere uma fila espelhada replicada em três nós: o nó principal (`main`) e dois espelhos (`mirror-1` e `mirror-2`). Se todas as mensagens nessa fila espelhada forem propagadas com êxito para todos os espelhos, a fila será sincronizada. Se um nó (`mirror-1`) se tornar indisponível por um intervalo de tempo, a fila ainda estará operacional e poderá continuar a enfileirar mensagens. No entanto, para sincronizar a fila, as mensagens publicadas no `main` enquanto `mirror-1` estiver indisponível devem ser replicadas para `mirror-1`.
Para obter mais informações sobre o espelhamento, consulte [Filas Espelhadas Clássicas](https://www.rabbitmq.com/ha.html) no site RabbitMQ.
**Manutenção e sincronização de filas**
Durante as [janelas de manutenção](amazon-mq-rabbitmq-editing-broker-preferences.md#rabbitmq-edit-current-configuration-console), o Amazon MQ executa todos os trabalhos de manutenção um nó de cada vez para garantir que o agente permaneça operacional. Como resultado, as filas podem precisar sincronizar à medida que cada nó retoma a operação. Durante a sincronização, as mensagens que precisam ser replicadas em espelhos são carregadas na memória do volume correspondente do Amazon Elastic Block Store (Amazon EBS) para serem processadas em lotes. O processamento de mensagens em lotes permite que as filas sejam sincronizadas mais rapidamente.
Se as filas forem mantidas curtas e as mensagens forem pequenas, as filas serão sincronizadas com êxito e retomarão a operação conforme esperado. No entanto, se a quantidade de dados em um lote se aproximar do limite de memória do nó, o nó gera um alarme de memória alta, pausando a sincronização de fila. Você pode confirmar o uso da memória comparando as [métricas do nó `RabbitMemUsed` e do `RabbitMqMemLimit` broker em CloudWatch](amazon-mq-accessing-metrics.md). A sincronização não pode ser concluída até que as mensagens sejam consumidas ou excluídas ou o número de mensagens no lote seja reduzido.
**nota**
Reduzir o tamanho do lote de sincronização de fila pode resultar em um número maior de transações de replicação.
Para resolver uma sincronização de fila pausada, siga as etapas deste tutorial, que demonstra a aplicação de uma política `ha-sync-batch-size` e reiniciar a sincronização de filas.
**Topics**
+ [Pré-requisitos](#rabbitmq-queue-sync-prerequisites)
+ [Etapa 1: Aplicar uma política `ha-sync-batch-size`](#rabbitmq-queue-sync-step-1)
+ [Etapa 2: Reiniciar a sincronização de filas](#rabbitmq-queue-sync-step-2)
+ [Próximas etapas](#rabbitmq-queue-sync-next-steps)
+ [Recursos relacionados](#rabbitmq-queue-sync-related-resources)
## Pré-requisitos
Para este tutorial, você deve ter um usuário do agente Amazon MQ para RabbitMQ com permissões de administrador. Você pode usar o usuário administrador criado quando criou o agente pela primeira vez ou outro usuário que você possa ter criado posteriormente. A tabela a seguir fornece a etiqueta de usuário administrador necessária e as permissões como padrões de expressão regular (regexp).
| Etiquetas | Ler regexp | Configurar regexp | Escrever regexp |
| --- | --- | --- | --- |
| administrator | .\$1 | .\$1 | .\$1 |
Para obter mais informações sobre criar usuários RabbitMQ e gerenciar etiquetas e permissões de usuário, consulte [Usuários do agente do Amazon MQ para RabbitMQ](rabbitmq-simple-auth-broker-users.md#rabbitmq-basic-elements-user).
## Etapa 1: Aplicar uma política `ha-sync-batch-size`
Os procedimentos a seguir demonstram a adição de uma política que se aplica a todas as filas criadas no agente. Você pode usar o console da Web do RabbitMQ ou a API de gerenciamento do RabbitMQ. Para obter mais informações, consulte [Plugin Gerenciamento](https://www.rabbitmq.com/management.html) no site do RabbitMQ.
**Para aplicar uma política `ha-sync-batch-size` usando o console da Web RabbitMQ**
1. Faça login no [console do Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. No painel de navegação à esquerda, escolha **Agentes**.
1. Na lista de agentes, escolha o nome do agente ao qual você deseja aplicar a nova política.
1. Na página do agente, na seção **Conexões**, escolha a URL **RabbitMQ web console (Console da Web RabbitMQ)**. O console da Web do RabbitMQ é aberto em uma nova guia ou janela do navegador.
1. Faça login no console da Web do RabbitMQ com as credenciais de login de administrador do agente.
1. No console da Web do RabbitMQ, na parte superior da página, escolha **Admin**.
1. Na página **Admin**, no painel de navegação da direita, selecione **Políticas**.
1. Na página **Políticas**, você pode ver uma lista das **Políticas de usuário** atuais do agente. Abaixo das **User policies** (Políticas de usuário), expanda **Add/update a policy** (Adicionar/atualizar uma política).
**nota**
Por padrão, os clusters Amazon MQ para RabbitMQ são criados com uma política de agente inicial chamada `ha-all-AWS-OWNED-DO-NOT-DELETE`. O Amazon MQ gerencia essa política para garantir que cada fila no agente seja replicada para todos os três nós e que as filas sejam sincronizadas automaticamente.
1. Para criar uma política de agente, em **Add/update a policy** (Adicionar/atualizar uma política), faça o seguinte:
1. Em **Nome**, insira um nome para a sua política, por exemplo **batch-size-policy**.
1. Para **Pattern** (Padrão), insira o padrão de expressão regular **.\$1** para que a política corresponda a todas as filas no agente.
1. Para **Apply to** (Aplicar em), escolha **Exchanges and queues** (Trocas e filas) na lista suspensa.
1. Para **Priority** (Prioridade), insira um número inteiro maior que todas as outras políticas aplicadas ao vhost. Você pode aplicar exatamente um conjunto de definições de política a filas e trocas RabbitMQ a qualquer momento. O RabbitMQ escolhe a política correspondente com o valor de prioridade mais alto. Para obter mais informações sobre prioridades de política e como combinar políticas, consulte [Policies](https://www.rabbitmq.com/parameters.html#policies) (Políticas) na Documentação do Servidor RabbitMQ.
1. Para **Definition** (Definição), adicione os seguintes pares de chave-valor:
+ **ha-sync-batch-size**=*100*. Escolha **Número** na lista suspensa.
**nota**
Talvez seja necessário ajustar e calibrar o valor de `ha-sync-batch-size` com base no número e tamanho das mensagens não sincronizadas nas filas.
+ **ha-mode**=**all**. Selecione **String (String)** na lista suspensa.
**Importante**
A definição `ha-mode` é necessária para todas as políticas relacionadas a HA. Omitir isso resulta em uma falha de validação.
+ **ha-sync-mode**=**automatic**. Selecione **String (String)** na lista suspensa.
**nota**
A definição `ha-sync-mode` é necessária para todas as políticas personalizadas. Se isso for omitido, o Amazon MQ anexará automaticamente a definição.
1. Escolha **Add/update policy (Adicionar/atualizar política)**.
1. Confirme se a nova política aparece na lista de **User policies** (Políticas de usuário).
**Para aplicar uma política `ha-sync-batch-size` usando a API de gerenciamento RabbitMQ**
1. Faça login no [console do Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. No painel de navegação à esquerda, escolha **Agentes**.
1. Na lista de agentes, escolha o nome do agente ao qual você deseja aplicar a nova política.
1. Na página do agente, na seção **Connections** (Conexões), anote a URL do **RabbitMQ web console** (Console da Web RabbitMQ). Este é o endpoint do agente que você usa em uma solicitação HTTP.
1. Abra uma nova janela de terminal ou linha de comando de sua escolha.
1. Para criar uma nova política de agente, insira o comando `curl` a seguir. Este comando assume uma fila no vhost `/` padrão, que é codificada como `%2F`.
**nota**
Substitua *username* e *password* por suas credenciais de login de administrador do corretor. Talvez seja necessário ajustar e calibrar o valor de `ha-sync-batch-size` (*100*) com base no número e no tamanho das mensagens não sincronizadas em suas filas. Substitua o endpoint do agente com a URL que você anotou 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 se a nova política foi adicionada às políticas de usuário do seu agente, insira o seguinte comando `curl` para listar todas as políticas de agente.
```
curl -i -u username:password https://b-589c045f-f8ln-4ab0-a89c-co62e1c32ef8.mq.us-west-2.amazonaws.com/api/policies
```
## Etapa 2: Reiniciar a sincronização de filas
Depois de aplicar uma nova política `ha-sync-batch-size` para seu agente, reinicie a sincronização de fila.
**Para reiniciar a sincronização de filas usando o console da Web RabbitMQ**
**nota**
Para abrir o console da Web RabbitMQ, consulte as instruções anteriores na Etapa 1 deste tutorial.
1. No console da Web do RabbitMQ, na parte superior da página, escolha **Queues (Filas)**.
1. Na página **Filas**, em **Todas as filas**, localize sua fila pausada. Na coluna **Política**, sua fila deve listar o nome da nova política que você criou (por exemplo, `batch-size-policy`).
1. Para reiniciar o processo de sincronização com um tamanho de lote reduzido, primeiro cancele a sincronização da fila. Em seguida, reinicie a sincronização da fila.
**nota**
Se a sincronização for interrompida e não for concluída com êxito, tente reduzir o valor `ha-sync-batch-size` e reiniciar a sincronização de fila novamente.
## Próximas etapas
+ Depois que sua fila for sincronizada com sucesso, você poderá monitorar a quantidade de memória que seus nós do RabbitMQ usam visualizando a métrica da Amazon. CloudWatch `RabbitMQMemUsed` Você também pode visualizar a métrica `RabbitMQMemLimit` para monitorar o limite de memória de um nó. Para obter mais informações, consulte [Acessando CloudWatch métricas para o Amazon MQ](amazon-mq-accessing-metrics.md) e [CloudWatch Métricas disponíveis para Amazon MQ para corretores RabbitMQ](rabbitmq-logging-monitoring.md).
+ Para evitar pausar a sincronização de filas, recomendamos manter as filas curtas e processar as mensagens. Para workloads com tamanhos de mensagem maiores, também recomendamos atualizar o tipo de instância do agente para um tamanho de instância maior com mais memória. Para obter mais informações sobre os tipos de instância do agente e como editar as preferências do agente consulte [Editar as preferências de agente](amazon-mq-rabbitmq-editing-broker-preferences.md).
+ Quando você cria um novo Amazon MQ para o agente RabbitMQ, o Amazon MQ aplica um conjunto de políticas padrão e limites de host virtual para otimizar a performance do agente. Se o seu agente não tiver as políticas e limites padrão recomendados, recomendamos criá-las você mesmo. Para obter mais informações sobre como criar políticas padrão e limites vhost, 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)— Use essa propriedade de agente para atualizar um tipo de instância de agente usando a API do Amazon MQ.
+ [Parâmetros e Políticas](https://www.rabbitmq.com/parameters.html) (Documentação do Servidor RabbitMQ): Saiba mais sobre os parâmetros e políticas do RabbitMQ no site do RabbitMQ.
+ [API HTTP de gerenciamento do RabbitMQ](https://pulse.mozilla.org/api/) — Saiba mais sobre a API de gerenciamento do RabbitMQ.
# Reduzir o número de conexões e canais
As conexões com o agente do RabbitMQ no Amazon MQ podem ser encerradas por suas aplicações cliente ou manualmente com o uso do console da Web do RabbitMQ. Para encerrar uma conexão usando o console da Web do RabbitMQ, faça o seguinte.
1. Faça login Console de gerenciamento da AWS e abra o console web RabbitMQ do seu corretor.
1. No console do RabbitMQ, escolha a guia **Connections** (Conexões).
1. Na página **Connections** (Conexões), em **All connections** (Todas as conexões), escolha na lista o nome da conexão que você deseja encerrar.
1. Na página de detalhes da conexão, escolha **Close this connection** (Encerrar esta conexão) para expandir a seção e depois escolha **Force Close** (Forçar encerramento). Como opção, você pode substituir o texto padrão do campo **Reason** (Motivo) pela sua própria descrição. O RabbitMQ no Amazon MQ retornará o motivo especificado para o cliente quando você encerrar a conexão.
1. Escolha **OK** na caixa de diálogo para confirmar e encerrar a conexão.
Quando você encerrar uma conexão, todos os canais associados à conexão encerrada também serão encerrados.
**nota**
Suas aplicações cliente podem ser configuradas para restabelecer automaticamente as conexões com o agentes depois que estas são encerradas. Nesse caso, encerrar conexões pelo console da Web do agente não será suficiente para reduzir a contagem de conexões ou canais.
Para agentes sem acesso público, você pode bloquear as conexões temporariamente, negando o tráfego de entrada na porta de protocolo de mensagem apropriada, por exemplo, a porta `5671` para conexões AMQP. É possível bloquear a porta no grupo de segurança que você forneceu ao Amazon MQ ao criar o agente. Para obter mais informações sobre como modificar seu grupo de segurança, consulte o tópico sobre como [Adicionar regras a um grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#adding-security-group-rules), no *Guia do usuário da Amazon VPC*.
## Etapa 2: conectar uma aplicação baseada em JVM ao seu agente
Depois de criar um agente do RabbitMQ, você pode conectar sua aplicação a ele. Os exemplos a seguir mostram como usar a [Biblioteca de cliente Java](https://www.rabbitmq.com/java-client.html) para criar uma conexão com seu agente, criar uma fila e enviar uma mensagem. Você pode se conectar a agentes RabbitMQ usando bibliotecas de cliente RabbitMQ compatíveis para vários idiomas. Para obter mais informações sobre bibliotecas de cliente do RabbitMQ com suporte, consulte [Bibliotecas de cliente e ferramentas de desenvolvedor do RabbitMQ](https://www.rabbitmq.com/devtools.html).
### Pré-requisitos
**nota**
As etapas de pré-requisito a seguir são aplicáveis somente a agentes RabbitMQ criados sem acessibilidade pública. Se você estiver criando um agente com acessibilidade pública, pode ignorar essas etapas.
#### Habilitar atributos da VPC
Para garantir que seu agente esteja acessível dentro da sua VPC, você deve habilitar os atributos VPC `enableDnsHostnames` e `enableDnsSupport`. Para obter mais informações, consulte [Compatibilidade com DNS para a sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) no *Manual do usuário da Amazon VPC*.
#### Habilitar conexões de entrada
1. Faça login no [console do Amazon MQ](https://console.aws.amazon.com/amazon-mq/).
1. Na lista de corretores, escolha o nome do seu corretor (por exemplo, **MyBroker**).
1. Na ***MyBroker***página, na seção **Conexões**, observe os endereços e portas do URL do console web e dos protocolos de nível de fio do broker.
1. Na seção **Details** (Detalhes), em **Security and network** (Segurança e rede), escolha o nome do seu grupo de segurança ou ![\[Pencil icon indicating an edit or modification action.\]](http://docs.aws.amazon.com/pt_br/amazon-mq/latest/developer-guide/images/amazon-mq-tutorials-broker-details-link.png).
A página **Grupos de segurança** do painel do EC2 é exibida.
1. Na lista de security group, escolha seu security group.
1. Na parte inferior da página, escolha **Inbound (Entrada)** e a seguir selecione **Edit (Editar)**.
1. Na caixa de diálogo **Edit inbound rules** (Editar regras de entrada), adicione uma regra para cada URL ou endpoint que você deseja que seja acessível publicamente (o exemplo a seguir mostra como fazer isso para um console da Web do agente).
1. Escolha **Add Rule (Adicionar regra)**.
1. Em **Type (Tipo)**, selecione **Custom TCP (TCP personalizado)**.
1. Para **Source **(Origem), deixe **Custom **(Personalizado) selecionado e, depois, digite o endereço IP do sistema ao qual deseja ser capaz de acessar o console da Web (por exemplo, `192.0.2.1`).
1. Escolha **Salvar**.
Agora seu agente pode aceitar conexões de entrada.
#### Adicionar dependências de Java
Se você estiver usando o Apache Maven para automatizar compilações, adicione a seguinte dependência a seu arquivo `pom.xml`. Para obter mais informações sobre arquivos do Project Object Model no Apache Maven, consulte [Introdução ao POM](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html).
```
com.rabbitmq
amqp-client
5.9.0
```
Se você estiver usando o [Gradle](https://docs.gradle.org/current/userguide/userguide.html) para automatizar compilações, declare a seguinte dependência.
```
dependencies {
compile 'com.rabbitmq:amqp-client:5.9.0'
}
```
#### Importar `Connection` e classes `Channel`
O cliente Java do RabbitMQ usa `com.rabbitmq.client` como seu pacote de nível superior, com as classes da API `Connection` e `Channel` representando uma conexão AMQP 0-9-1 e um canal, respectivamente. Importe as classes `Connection` e `Channel` antes de usá-las, conforme mostrado no exemplo a seguir.
```
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
```
#### Crie um `ConnectionFactory` e conecte ao seu agente
Use o exemplo a seguir para criar uma instância da classe `ConnectionFactory` com os parâmetros fornecidos. Use o método `setHost` para configurar o endpoint do agente que você anotou anteriormente. Para conexões `AMQPS` de nível de conexão, use a porta `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 uma mensagem em uma troca
Você pode usar o `Channel.basicPublish` para publicar mensagens em uma troca. O exemplo a seguir usa a classe AMQP `Builder` para construir um objeto de propriedades de mensagem com tipo de conteúdo `plain/text`.
```
byte[] messageBodyBytes = "Hello, world!".getBytes();
channel.basicPublish(exchangeName, routingKey,
new AMQP.BasicProperties.Builder()
.contentType("text/plain")
.userId("userId")
.build(),
messageBodyBytes);
```
**nota**
Observe que `BasicProperties` é uma classe interna da classe titular gerada automaticamente, `AMQP`.
#### Inscrever-se em uma fila e receber uma mensagem
Você pode receber uma mensagem inscrevendo-se em uma fila usando a Interface `Consumer`. Depois de inscrito, as mensagens serão entregues automaticamente à medida que chegarem.
A maneira mais fácil de implementar um `Consumer` é usar a subclasse `DefaultConsumer`. Um objeto `DefaultConsumer` pode ser transmitido como parte de uma chamada `basicConsume` para configurar a assinatura, conforme mostrado no exemplo a seguir.
```
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**
Como nós especificamos `autoAck = false`, é necessário reconhecer as mensagens entregues ao `Consumer`, o que é feito de maneira mais conveniente no método `handleDelivery`, conforme mostrado no exemplo.
#### Fechar sua conexão e desconectar do agente
Para se desconectar do seu agente RabbitMQ, feche o canal e a conexão, conforme mostrado a seguir.
```
channel.close();
conn.close();
```
**nota**
Para obter mais informações sobre como trabalhar com a biblioteca de cliente Java do RabbitMQ, consulte o [Guia da API do cliente Java do RabbitMQ](https://www.rabbitmq.com/api-guide.html).
## Etapa 3: (opcional) conectar-se a uma AWS Lambda função
AWS Lambda pode se conectar e consumir mensagens do seu agente Amazon MQ. Quando você conecta um agente ao Lambda, você cria um [Mapeamento da origem do evento](https://docs.aws.amazon.com/lambda/latest/dg/invocation-eventsourcemapping.html) que lê mensagens de uma fila e invoca a função [sincronicamente](https://docs.aws.amazon.com/lambda/latest/dg/invocation-sync.html). O mapeamento da origem do evento que você cria lê mensagens de seu agente em lotes e as converte em uma carga útil do Lambda na forma de um objeto JSON.
**Para conectar seu agente a uma função do Lambda**
1. Adicione as permissões de Função do IAM a seguir à sua [função de execução](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) da função Lambda.
+ [metros quadrados: 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)
+ [troncos: CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [troncos: CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [troncos: PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)
+ [gerente de segredos: GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
**nota**
Sem as permissões necessárias do IAM, sua função não poderá ler registros com êxito dos recursos do Amazon MQ.
1. (Opcional) Se você criou um agente sem acessibilidade pública, você deve fazer um dos seguintes procedimentos para permitir que o Lambda se conecte ao seu agente:
+ Configure um gateway NAT por sub-rede pública. Para obter mais informações, consulte [Acesso aos serviços e à Internet para funções conectadas à VPC](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html#vpc-internet) no *AWS Lambda Guia do desenvolvedor*.
+ Crie uma conexão entre a Amazon Virtual Private Cloud (Amazon VPC) e o Lambda usando um endpoint da VPC. Sua Amazon VPC também deve se conectar aos endpoints AWS Security Token Service (AWS STS) e Secrets Manager. Para obter mais informações, consulte [Configurar endpoints da VPC de interface para o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) no *Guia do desenvolvedor AWS Lambda *.
1. [Configure seu agente como uma origem do evento](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html#services-mq-eventsourcemapping) para uma função do Lambda usando Console de gerenciamento da AWS. Você também pode usar o [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. Escreva algum código para sua função do Lambda para processar as suas mensagens consumidas pelo seu agente. A carga útil do Lambda recuperada pelo mapeamento da origem do evento depende do tipo de mecanismo do agente. Veja a seguir um exemplo de uma carga útil do Lambda para uma fila do Amazon MQ para RabbitMQ.
**nota**
No exemplo, `test` é o nome da fila e `/` é o nome do host virtual padrão. Ao receber mensagens, a origem do evento lista as mensagens em `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 obter mais informações sobre como conectar o Amazon MQ ao Lambda, as opções para as quais o Lambda oferece suporte para uma origem de evento do Amazon MQ e erros de mapeamento da origem do evento, consulte [Usar o Lambda com o Amazon MQ](https://docs.aws.amazon.com/lambda/latest/dg/with-mq.html) no *Guia do desenvolvedor AWS Lambda *.
# Uso da autorização e da autenticação OAuth 2.0 para Amazon MQ para RabbitMQ
Esse tutorial descrever como configura a [autenticação OAuth 2.0](oauth-for-amq-for-rabbitmq.md) para agentes do Amazon MQ para RabbitMQ usando o Amazon Cognito como provedor do OAuth 2.0.
**nota**
O Amazon Cognito está disponível nas regiões China (Pequim) e China (Ningxia).
**Importante**
Esse tutorial é específico para o Amazon Cognito, mas você pode usar outros provedores de identidade (IDPs). Para obter mais informações, consulte [Exemplos de autenticação OAuth 2.0](https://www.rabbitmq.com/docs/oauth2-examples).
**Topics**
+ [Pré-requisitos para configurar a autenticação OAuth 2.0](#oauth-tutorial-prerequisites)
+ [Configuração da autenticação OAuth 2.0 com o Amazon Cognito usando-se a AWS CLI](#oauth-tutorial-config-cognito-using-cli)
+ [Configuração do OAuth 2.0 e autenticação simples com o Amazon Cognito](#oauth-tutorial-config-both-auth-methods-using-cli)
## Pré-requisitos para configurar a autenticação OAuth 2.0
Você pode definir os recursos do Amazon Cognito necessários neste tutorial implantando a pilha AWS CDK, [pilha do Amazon Cognito para plug-in OAuth 2 do RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/tree/main/rabbitmq-samples/rabbitmq-oauth2-cognito-sample). Se você estiver configurando o Amazon Cognito manualmente, certifique-se de cumprir os seguintes pré-requisitos antes de configurar o OAuth 2.0 nos agentes do Amazon MQ para RabbitMQ:
**Pré-requisitos para configurar o Amazon Cognito**
+ Configure um endpoint do Amazon Cognito criando um grupo de usuários. Para fazer isso, consulte o blog intitulado [Como usar o OAuth 2.0 no Amazon Cognito: Saiba mais sobre as diferentes concessões do OAuth 2.0](https://aws.amazon.com/blogs/security/how-to-use-oauth-2-0-in-amazon-cognito-learn-about-the-different-oauth-2-0-grants/).
+ Crie um servidor de recursos chamado `rabbitmq` no grupo de usuários com os seguintes escopos definidos: `read:all``write:all`,`configure:all` e `tag:administrator`. Esses escopos serão associados às permissões do RabbitMQ.
Para obter informações sobre a criação de um servidor de recursos, consulte [Definição de um servidor de recursos para o grupo de usuários (Console de gerenciamento da AWS)](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-define-resource-servers.html#cognito-user-pools-define-resource-servers-console) no *Guia do desenvolvedor do Amazon Cognito*.
+ Crie as aplicações a seguir.
+ Cliente de aplicativo para o grupo de usuários do tipo `Machine-to-Machine application`. Esse é um cliente confidencial com um segredo de cliente que será usado pelos clientes do RabbitMQ AMQP. Para obter mais informações sobre clientes de aplicações e como criar um, consulte [Tipos de clientes de aplicação](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#user-pool-settings-client-app-client-types) e [Criação de um cliente de aplicação](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html#cognito-user-pools-app-idp-settings-console-create).
+ Cliente de aplicativo para o grupo de usuários do tipo `Single-page application`. Esse é um cliente público que será usado para fazer login de usuários no console de gerenciamento do RabbitMQ. Você deve atualizar esse cliente do aplicativo para incluir o endpoint do agente do Amazon MQ para RabbitMQ que você criará no procedimento a seguir como uma URL de retorno de chamada permitida. Para obter mais informações, consulte [Configuração do login gerenciado com o console do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-managed-login.html#set-up-managed-login).
**Pré-requisito para configurar o Amazon MQ**
+ Uma instalação funcional do [Docker](https://docs.docker.com/engine/install/) para executar um script bash que verifica se a configuração do OAuth 2.0 foi bem-sucedida ou não.
+ Versão da AWS CLI >= `2.28.23` para tornar opcional a adição de um nome de usuário e senha durante a criação do agente.
## Configuração da autenticação OAuth 2.0 com o Amazon Cognito usando-se a AWS CLI
O procedimento a seguir mostra como configurar a autenticação OAuth 2.0 para os agentes do Amazon MQ para RabbitMQ usando-se o Amazon Cognito como IdP. Esse procedimento usa a AWS CLI para criar e configurar os recursos necessários.
No procedimento a seguir, certifique-se de substituir os valores do espaço reservado, como configurationID e Revision, ** e *<2>*, por seus valores reais.
1. Crie uma nova configuração usando o comando da AWS CLI [create-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/create-configuration.html) conforme mostrado no exemplo a seguir.
```
aws mq create-configuration \
--name "rabbitmq-oauth2-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um arquivo de configuração chamado **rabbitmq.conf** para usar o OAuth 2.0 como método de autenticação e autorização, conforme mostrado no exemplo a seguir.
```
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
```
Essa configuração usa [aliases de escopo](https://www.rabbitmq.com/docs/oauth2#scope-translation) para mapear os escopos definidos no Amazon Cognito para escopos compatíveis do RabbitMQ.
1. Atualize a configuração usando o comando da AWS CLI [update-configuration](https://docs.aws.amazon.com/cli/latest/reference/mq/update-configuration.html) conforme mostrado no exemplo a seguir. Nesse comando, adicione o ID de configuração que você recebeu na resposta da Etapa 1 do procedimento. Por exemplo, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca**.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um agente com a configuração do OAuth 2.0 criada na Etapa 2 deste procedimento. Para fazer isso, use o comando [create-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/create-broker.html) da AWS CLI, conforme mostrado no exemplo a seguir. Nesse comando, forneça o ID de configuração e o número da revisão obtidos nas respostas das etapas 1 e 2, respectivamente. Por exemplo, **c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca** e **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>}' \
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Verifique se o status do agente muda de `CREATION_IN_PROGRESS` para`RUNNING`, usando o comando da AWS CLI [describe-broker](https://docs.aws.amazon.com/cli/latest/reference/mq/describe-broker.html), conforme mostrado no exemplo a seguir. Nesse comando, forneça o ID do corretor que você obteve no resultado da etapa anterior. Por exemplo,**b-2a1b5133-a10c-49d2-879b-8c176c34cf73**.
```
aws mq describe-broker \
--broker-id ""
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir. A resposta a seguir é uma versão abreviada da saída completa que o comando `describe-broker` retorna. Essa resposta mostra o status do agente e a estratégia de autenticação usada para proteger o agente. Nesse caso, a estratégia de autenticação `config_managed` indica que o agente usa o método de autenticação OAuth 2.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
Para fazer login no console de gerenciamento do RabbitMQ usando o OAuth2, o endpoint do agente precisa ser adicionado como uma URL de retorno de chamada válida no cliente da aplicação Amazon Cognito correspondente. Para obter mais informações, consulte a Etapa 5 na configuração do nosso exemplo de [pilha de CDK do 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 a autenticação e a autorização do OAuth 2.0 com o script a seguir `perf-test.sh`.
Use esse script bash para testar a conectividade com o agente do Amazon MQ para RabbitMQ. Esse script obtém um token do Amazon Cognito e verifica se a conexão foi configurada corretamente. Se for configurado com sucesso, você verá seu agente publicar e consumir mensagens.
Se você receber um erro `ACCESS_REFUSED`, poderá solucionar os problemas de configuração usando os CloudWatch Logs para o agente. Você pode encontrar o link para o grupo de logs do CloudWatch para o agente no console do Amazon MQ.
Nesse script, é necessário fornecer os seguintes valores:
+ `CLIENT_ID` e `CLIENT_SECRET`: Você pode encontrar esses valores na página de **clientes de aplicativos** do console do Amazon Cognito.
+ Domínio Cognito: você pode encontrar isso no console do Amazon Cognito. Em **Branding (Marca),** escolha **Domain (Domínio)**. Na página **Domain (Domínio)**, você pode descobrir esse valor na seção **Resource servers (Servidores de recursos)**.
+ Endpoint do agente Amazon MQ: você pode encontrar esse valor em **Conexões** na página de detalhes do agente no console do 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
```
## Configuração do OAuth 2.0 e autenticação simples com o Amazon Cognito
Quando criar um agente com autenticação OAuth 2.0, você pode especificar um dos seguintes métodos de autenticação:
+ **Somente o OAuth 2.0**: para usar esse método, forneça um nome de usuário e uma senha quando criar o agente. O [procedimento anterior](#oauth-tutorial-config-cognito-using-cli) mostra como usar somente o método de autenticação OAuth 2.0.
+ **Autenticação simples e a OAuth 2.0**: para usar esse método, forneça um nome de usuário e uma senha quando criar o agente. Além disso, adicione `auth_backends.2 = internal` à configuração do agente, conforme mostrado no procedimento a seguir.
No procedimento a seguir, certifique-se de substituir os valores do espaço reservado, como*** e *, por seus valores reais.
1. Para usar os dois métodos de autenticação, crie a configuração do agente, conforme mostrado no exemplo a seguir.
```
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:*/*
```
Essa configuração usa [aliases de escopo](https://www.rabbitmq.com/docs/oauth2#scope-translation) para mapear os escopos definidos no Amazon Cognito para escopos compatíveis do RabbitMQ.
1. Crie um agente que use os dois métodos de autenticação, conforme mostrado no exemplo a seguir.
```
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. Verifique se o status do agente e a configuração para definir o método de autenticação foram bem-sucedidos, conforme descrito nas etapas 5 e 6 do procedimento [Configuração da autenticação OAuth 2.0 com o Amazon Cognito](#oauth-tutorial-config-cognito-using-cli).
# Usando autenticação e autorização do IAM para Amazon MQ para RabbitMQ
O procedimento a seguir demonstra como habilitar a autenticação e autorização AWS do IAM para um agente Amazon MQ for RabbitMQ. Depois de habilitar o IAM, os usuários podem se autenticar usando as credenciais AWS do IAM para acessar a API de gerenciamento do RabbitMQ e se conectar via AMQP. Para obter detalhes sobre como a autenticação do IAM funciona com o Amazon MQ para RabbitMQ, consulte. [Autenticação e autorização do IAM para Amazon MQ para RabbitMQ](iam-for-amq-for-rabbitmq.md)
## Pré-requisitos
+ AWS credenciais de administrador para a AWS conta proprietária do agente Amazon MQ for RabbitMQ
+ Um ambiente de shell configurado com essas credenciais de administrador (usando perfis AWS CLI ou variáveis de ambiente)
+ AWS CLI instalada e configurada
+ `jq`processador JSON de linha de comando instalado
+ `curl`ferramenta de linha de comando instalada
## Configurando a autenticação e autorização do IAM usando AWS CLI
1. **Definir variáveis de ambiente**
Defina as variáveis de ambiente necessárias para seu corretor:
```
export AWS_DEFAULT_REGION=
export BROKER_ID=
```
1. **Ativar tokens JWT de saída**
Ative a federação externa de identidade da web para sua AWS conta:
```
ISSUER_IDENTIFIER=$(aws iam enable-outbound-web-identity-federation --query 'IssuerIdentifier' --output text)
echo $ISSUER_IDENTIFIER
```
A saída exibe um URL de identificador de emissor exclusivo para sua conta no formato`https://.tokens.sts.global.api.aws`.
1. **Crie o documento de política do IAM**
Crie um documento de política que conceda permissões para obter tokens de identidade da web:
```
cat > policy.json << 'EOF'
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sts:GetWebIdentityToken",
"sts:TagGetWebIdentityToken"
],
"Resource": "*"
}
]
}
EOF
```
1. **Crie a política de confiança**
Recupere sua identidade de chamador e crie um documento de política de confiança:
```
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. **Crie a função do IAM**
Crie a função do IAM e anexe a 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. **Definir as configurações do OAuth2 RabbitMQ**
Crie um arquivo de configuração do RabbitMQ com configurações de OAuth2 autenticação e autorização:
```
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. **Atualizar a configuração do broker**
Aplique a nova configuração ao seu corretor:
```
# 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
```
Aguarde até que o status do corretor retorne `RUNNING` antes de prosseguir para a próxima etapa.
1. **Obtenha um token JWT**
Assuma a função do IAM e obtenha um token de identidade da 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. **Acesse a API de gerenciamento do RabbitMQ**
Use o token JWT para acessar a API de gerenciamento do RabbitMQ:
```
BROKER_URL=.mq..on.aws
curl -u ":$TOKEN" \
-X GET https://${BROKER_URL}/api/overview \
-H "Content-Type: application/json"
```
Uma resposta bem-sucedida confirma que a autenticação do IAM está funcionando corretamente. A resposta contém informações de visão geral do corretor no formato JSON.
1. **Conecte-se via AMQP usando o token JWT**
Teste a conectividade AMQP usando o token JWT com a ferramenta perf-test:
```
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
```
Se você receber um `ACCESS_REFUSED` erro, poderá solucionar seus problemas de configuração usando os CloudWatch registros do seu corretor. Você pode encontrar o link para o grupo de CloudWatch registros de registros do seu agente no console do Amazon MQ.
# Usando autenticação e autorização LDAP para Amazon MQ para RabbitMQ
Este tutorial descreve como configurar a autenticação e autorização LDAP para seu Amazon MQ para corretores RabbitMQ usando. AWS Managed Microsoft AD
**Topics**
+ [Pré-requisitos para configurar a autenticação e autorização LDAP](#rabbitmq-ldap-tutorial-prerequisites)
+ [Configurando o LDAP no RabbitMQ usando CLI AWS](#rabbitmq-ldap-tutorial-configure-cli)
## Pré-requisitos para configurar a autenticação e autorização LDAP
Você pode configurar os AWS recursos necessários neste tutorial implantando a [pilha AWS CDK para a integração do Amazon MQ for RabbitMQ LDAP](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-ldap-activedirectory-sample/) com. AWS Managed Microsoft AD
Essa pilha de CDK cria automaticamente todos os AWS recursos necessários AWS Managed Microsoft AD, incluindo usuários e grupos LDAP, Network Load Balancer, certificados e funções do IAM. Consulte o pacote README para obter uma lista completa dos recursos criados pela pilha.
Se você estiver configurando os recursos manualmente em vez de usar a pilha de CDK, certifique-se de ter a infraestrutura equivalente antes de configurar o LDAP em seus corretores Amazon MQ para RabbitMQ.
### Pré-requisito para configurar o Amazon MQ
AWS Versão CLI >= 2.28.23 para tornar opcional a adição de um nome de usuário e senha durante a criação do broker.
## Configurando o LDAP no RabbitMQ usando CLI AWS
Esse procedimento usa a AWS CLI para criar e configurar os recursos necessários. No procedimento a seguir, certifique-se de substituir os valores do espaço reservado, como configurationId e Revision, `` e`<2>`, por seus valores reais.
1. Crie uma nova configuração usando o comando `create-configuration` AWS CLI, conforme mostrado no exemplo a seguir.
```
aws mq create-configuration \
--name "rabbitmq-ldap-config" \
--engine-type "RABBITMQ" \
--engine-version "3.13"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um arquivo de configuração chamado `rabbitmq.conf` para usar o LDAP como método de autenticação e autorização, conforme mostrado no exemplo a seguir. Substitua todos os valores de espaço reservado no modelo (marcados com`${RabbitMqLdapTestStack.*}`) pelos valores reais das saídas de pilha de AWS CDK pré-requisitos implantadas ou da infraestrutura 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. Atualize a configuração usando o comando `update-configuration` AWS CLI, conforme mostrado no exemplo a seguir. Nesse comando, adicione o ID de configuração recebido na resposta da Etapa 1 do procedimento. Por exemplo, .`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um broker com a configuração LDAP que você criou na Etapa 2 deste procedimento. Para fazer isso, use o comando `create-broker` AWS CLI conforme mostrado no exemplo a seguir. Nesse comando, informe o ID de configuração e o número da revisão obtidos nas respostas das etapas 1 e 2, respectivamente. Por exemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` e `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>}'
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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"
}
```
**Restrição de nomenclatura do corretor**
A função do IAM criada pela pilha CDK de pré-requisito restringe os nomes dos corretores para começar. `rabbitmq-ldap-test` Certifique-se de que o nome do seu corretor siga esse padrão ou a função do IAM não terá permissão para assumir a função na resolução do ARN.
1. Verifique se o status do broker muda de `CREATION_IN_PROGRESS` para`RUNNING`, usando o comando `describe-broker` AWS CLI, conforme mostrado no exemplo a seguir. Nesse comando, informe o ID do agente obtido no resultado da etapa anterior. Por exemplo, `b-2a1b5133-a10c-49d2-879b-8c176c34cf73`.
```
aws mq describe-broker \
--broker-id ""
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir. A resposta a seguir é uma versão abreviada da saída completa que o comando `describe-broker` retorna. Essa resposta mostra o status do agente e a estratégia de autenticação usada para proteger o agente. Nesse caso, a estratégia de `config_managed` autenticação indica que o agente usa o método de autenticação LDAP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Valide o acesso ao RabbitMQ usando um dos usuários de teste criados pela pilha CDK de pré-requisito
```
# 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"}'
```
# Usando autenticação e autorização HTTP para Amazon MQ para RabbitMQ
Este tutorial descreve como configurar a autenticação e autorização HTTP para seus corretores Amazon MQ para RabbitMQ usando um servidor HTTP externo.
**nota**
O plug-in de autenticação HTTP está disponível somente para o Amazon MQ for RabbitMQ versão 4 e superior.
**Topics**
+ [Pré-requisitos para configurar a autenticação e autorização HTTP](#rabbitmq-http-tutorial-prerequisites)
+ [Configurando a autenticação HTTP no RabbitMQ usando CLI AWS](#rabbitmq-http-tutorial-configure-cli)
## Pré-requisitos para configurar a autenticação e autorização HTTP
Você pode configurar os AWS recursos necessários neste tutorial implantando a [pilha AWS CDK para Amazon MQ para integração de autenticação HTTP RabbitMQ](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-http-sample/).
Essa pilha de CDK cria automaticamente todos os AWS recursos necessários, incluindo o servidor de autenticação HTTP, certificados e funções do IAM. Consulte o pacote README para obter uma lista completa dos recursos criados pela pilha.
Se você estiver configurando os recursos manualmente em vez de usar a pilha CDK, certifique-se de ter a infraestrutura equivalente antes de configurar a autenticação HTTP em seus corretores Amazon MQ para RabbitMQ.
### Pré-requisito para configurar o Amazon MQ
AWS Versão CLI >= 2.28.23 para tornar opcional a adição de um nome de usuário e senha durante a criação do broker.
## Configurando a autenticação HTTP no RabbitMQ usando CLI AWS
Esse procedimento usa a AWS CLI para criar e configurar os recursos necessários. No procedimento a seguir, certifique-se de substituir os valores do espaço reservado por seus valores reais.
1. Crie uma nova configuração usando o comando `create-configuration` AWS CLI, conforme mostrado no exemplo a seguir.
```
aws mq create-configuration \
--name "rabbitmq-http-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um arquivo de configuração chamado `rabbitmq.conf` para usar HTTP como método de autenticação e autorização, conforme mostrado no exemplo a seguir. Substitua todos os valores de espaço reservado no modelo (marcados com`${...}`) pelos valores reais das saídas de pilha de AWS CDK pré-requisitos implantadas ou da infraestrutura 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. Atualize a configuração usando o `update-configuration` AWS comando CLI. Use o ID de configuração da Etapa 3.
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um broker com a configuração HTTP. Use o ID de configuração e o número da revisão das etapas 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>}'
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Verifique se o status do broker muda de `CREATION_IN_PROGRESS` para`RUNNING`, usando o comando `describe-broker` AWS CLI.
```
aws mq describe-broker \
--broker-id ""
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir. A estratégia de `config_managed` autenticação indica que o agente usa o método de autenticação HTTP.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Valide o acesso ao RabbitMQ usando um dos usuários de teste criados pela pilha CDK de pré-requisito
```
# 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 '{}'
```
# Usando a autenticação de certificado SSL para Amazon MQ para RabbitMQ
Este tutorial descreve como configurar a autenticação de certificado SSL para seus corretores Amazon MQ para RabbitMQ usando uma autoridade de certificação privada.
**nota**
O plug-in de autenticação de certificado SSL está disponível somente para o Amazon MQ for RabbitMQ versão 4 e superior.
**Topics**
+ [Pré-requisitos para configurar a autenticação do certificado SSL](#rabbitmq-ssl-tutorial-prerequisites)
+ [Configurando a autenticação de certificado SSL no RabbitMQ usando CLI AWS](#rabbitmq-ssl-tutorial-configure-cli)
## Pré-requisitos para configurar a autenticação do certificado SSL
A autenticação de certificado SSL usa TLS mútuo (mTLS) para autenticar clientes usando certificados X.509. Você pode configurar os AWS recursos necessários neste tutorial implantando a [pilha de AWS CDK para a integração entre Amazon MQ e RabbitMQ mTLS](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/).
Essa pilha de CDK cria automaticamente todos os AWS recursos necessários, incluindo autoridade de certificação, certificados de cliente e funções do IAM. Consulte o pacote README para obter uma lista completa dos recursos criados pela pilha.
**nota**
Antes de implantar a pilha CDK, defina a `RABBITMQ_TEST_USER_NAME` variável de ambiente. Esse valor será usado como o Nome Comum (CN) no certificado do cliente e deve corresponder ao nome de usuário usado nas etapas do tutorial. Por exemplo: `export RABBITMQ_TEST_USER_NAME="myuser"`
Se você estiver configurando os recursos manualmente em vez de usar a pilha de CDK, certifique-se de ter a infraestrutura equivalente antes de configurar a autenticação de certificado SSL em seus corretores Amazon MQ para RabbitMQ.
### Pré-requisito para configurar o Amazon MQ
AWS Versão CLI >= 2.28.23 para tornar opcional a adição de um nome de usuário e senha durante a criação do broker.
## Configurando a autenticação de certificado SSL no RabbitMQ usando CLI AWS
Esse procedimento usa a AWS CLI para criar e configurar os recursos necessários. No procedimento a seguir, certifique-se de substituir os valores do espaço reservado, como configurationId e Revision, `` e`<2>`, por seus valores reais.
1. Crie uma nova configuração usando o comando `create-configuration` AWS CLI, conforme mostrado no exemplo a seguir.
```
aws mq create-configuration \
--name "rabbitmq-ssl-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um arquivo de configuração chamado `rabbitmq.conf` para usar a autenticação de certificado SSL, conforme mostrado no exemplo a seguir. Substitua todos os valores de espaço reservado no modelo (marcados com`${...}`) pelos valores reais das saídas de pilha de AWS CDK pré-requisitos implantadas ou da infraestrutura 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. Atualize a configuração usando o comando `update-configuration` AWS CLI, conforme mostrado no exemplo a seguir. Nesse comando, adicione o ID de configuração recebido na resposta da Etapa 1 do procedimento. Por exemplo, .`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um broker com a configuração de autenticação do certificado SSL que você criou na Etapa 2 deste procedimento. Para fazer isso, use o comando `create-broker` AWS CLI conforme mostrado no exemplo a seguir. Nesse comando, informe o ID de configuração e o número da revisão obtidos nas respostas das etapas 1 e 2, respectivamente. Por exemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` e `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"}]'
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Verifique se o status do broker muda de `CREATION_IN_PROGRESS` para`RUNNING`, usando o comando `describe-broker` AWS CLI, conforme mostrado no exemplo a seguir. Neste comando, forneça a ID do agente que você obteve no resultado da etapa anterior. Por exemplo, .`b-2a1b5133-a10c-49d2-879b-8c176c34cf73`
```
aws mq describe-broker \
--broker-id ""
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir. A resposta a seguir é uma versão abreviada da saída completa que o comando `describe-broker` retorna. Essa resposta mostra o status do agente e a estratégia de autenticação usada para proteger o agente. Nesse caso, a estratégia de `config_managed` autenticação indica que o agente usa o método de autenticação de certificado SSL.
```
{
"AuthenticationStrategy": "config_managed",
...,
"BrokerState": "RUNNING",
...
}
```
1. Verifique a autenticação do certificado SSL com o `ssl.sh` script a seguir.
Use esse script bash para testar a conectividade com o agente do Amazon MQ para RabbitMQ. Esse script usa seu certificado de cliente para autenticação e verifica se a conexão foi configurada corretamente. Se for configurado com sucesso, você verá seu corretor publicar e consumir mensagens.
Se você receber um `ACCESS_REFUSED` erro, poderá solucionar seus problemas de configuração usando os CloudWatch registros do seu corretor. Você pode encontrar o link para o grupo de CloudWatch registros do seu agente no console do Amazon MQ.
Nesse script, é necessário fornecer os seguintes valores:
+ `USERNAME`: O nome comum (CN) do seu certificado de cliente.
+ `CLIENT_KEYSTORE`: caminho para o arquivo de armazenamento de chaves do seu cliente (PKCS12 formato). Se você usou a pilha CDK de pré-requisito, o caminho padrão é. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: Senha para o armazenamento de chaves do seu cliente. Se você usou a pilha CDK de pré-requisito, a senha padrão é. `changeit`
+ `BROKER_DNS`: Você pode encontrar esse valor em **Conexões** na página de detalhes do broker do console do 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
```
# Usando mTLS para AMQP e endpoints de gerenciamento
Este tutorial descreve como configurar o TLS mútuo (mTLS) para conexões de clientes AMQP e a interface de gerenciamento do RabbitMQ usando uma autoridade de certificação privada.
**nota**
O uso de autoridades de certificação privadas para mTLS está disponível somente para Amazon MQ para RabbitMQ versão 4 e superior.
**Topics**
+ [Pré-requisitos para configurar o mTLS](#rabbitmq-mtls-tutorial-prerequisites)
+ [Configurando mTLS no RabbitMQ usando CLI AWS](#rabbitmq-mtls-tutorial-configure-cli)
## Pré-requisitos para configurar o mTLS
Você pode configurar os AWS recursos necessários neste tutorial implantando a [pilha AWS CDK para a integração do Amazon MQ para RabbitMQ mTLS](https://github.com/aws-samples/amazon-mq-samples/blob/main/rabbitmq-samples/rabbitmq-mtls-sample/) com.
Essa pilha de CDK cria automaticamente todos os AWS recursos necessários, incluindo autoridade de certificação, certificados de cliente e funções do IAM. Consulte o pacote README para obter uma lista completa dos recursos criados pela pilha.
Se você estiver configurando os recursos manualmente em vez de usar a pilha CDK, certifique-se de ter a infraestrutura equivalente antes de configurar o mTLS em seus corretores Amazon MQ para RabbitMQ.
### Pré-requisito para configurar o Amazon MQ
AWS Versão CLI >= 2.28.23 para tornar opcional a adição de um nome de usuário e senha durante a criação do broker.
## Configurando mTLS no RabbitMQ usando CLI AWS
Esse procedimento usa a AWS CLI para criar e configurar os recursos necessários. No procedimento a seguir, certifique-se de substituir os valores do espaço reservado, como ConfigurationId e Revision, `` e`<2>`, por seus valores reais.
1. Crie uma nova configuração usando o comando `create-configuration` AWS CLI, conforme mostrado no exemplo a seguir.
```
aws mq create-configuration \
--name "rabbitmq-mtls-config" \
--engine-type "RABBITMQ" \
--engine-version "4.2"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um arquivo de configuração chamado `rabbitmq.conf` para configurar mTLS para AMQP e endpoints de gerenciamento, conforme mostrado no exemplo a seguir. Substitua todos os valores de espaço reservado no modelo (marcados com`${...}`) pelos valores reais das saídas de pilha de AWS CDK pré-requisitos implantadas ou da infraestrutura 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. Atualize a configuração usando o comando `update-configuration` AWS CLI, conforme mostrado no exemplo a seguir. Nesse comando, adicione o ID de configuração recebido na resposta da Etapa 1 do procedimento. Por exemplo, .`c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca`
```
aws mq update-configuration \
--configuration-id "" \
--data "$(cat rabbitmq.conf | base64 --wrap=0)"
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Crie um broker com a configuração mTLS que você criou na Etapa 2 deste procedimento. Para fazer isso, use o comando `create-broker` AWS CLI conforme mostrado no exemplo a seguir. Nesse comando, informe o ID de configuração e o número da revisão obtidos nas respostas das etapas 1 e 2, respectivamente. Por exemplo, `c-fa3390a5-7e01-4559-ae0c-eb15b38b22ca` e `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"}]'
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir.
```
{
"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. Verifique se o status do broker muda de `CREATION_IN_PROGRESS` para`RUNNING`, usando o comando `describe-broker` AWS CLI, conforme mostrado no exemplo a seguir. Neste comando, forneça a ID do agente que você obteve no resultado da etapa anterior. Por exemplo, .`b-2a1b5133-a10c-49d2-879b-8c176c34cf73`
```
aws mq describe-broker \
--broker-id ""
```
Esse comando retorna uma resposta semelhante ao exemplo a seguir. A resposta a seguir é uma versão abreviada da saída completa que o comando `describe-broker` retorna.
```
{
"AuthenticationStrategy": "simple",
...,
"BrokerState": "RUNNING",
...
}
```
1. Verifique a autenticação mTLS com o `mtls.sh` script a seguir.
Use esse script bash para testar a conectividade com o agente do Amazon MQ para RabbitMQ. Esse script usa seu certificado de cliente para autenticar e verificar se a conexão foi configurada corretamente. Se for configurado com sucesso, você verá seu corretor publicar e consumir mensagens.
Se você receber um `ACCESS_REFUSED` erro, poderá solucionar seus problemas de configuração usando os CloudWatch registros do seu broker. Você pode encontrar o link para o grupo de CloudWatch registros do seu agente no console do Amazon MQ.
Nesse script, é necessário fornecer os seguintes valores:
+ `USERNAME`e`PASSWORD`: As credenciais de usuário do RabbitMQ que você criou com o corretor.
+ `CLIENT_KEYSTORE`: caminho para o arquivo de armazenamento de chaves do seu cliente (PKCS12 formato). Se você usou a pilha CDK de pré-requisito, o caminho padrão é. `$(pwd)/certs/client-keystore.p12`
+ `KEYSTORE_PASSWORD`: Senha para o armazenamento de chaves do seu cliente. Se você usou a pilha CDK de pré-requisito, a senha padrão é. `changeit`
+ `BROKER_DNS`: Você pode encontrar esse valor em **Conexões** na página de detalhes do broker do console do 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
```
# Conectando seu aplicativo JMS
Este tutorial mostra como conectar seu aplicativo JMS ao agente Amazon MQ for RabbitMQ usando o cliente RabbitMQ JMS. Você aprenderá como criar um produtor para enviar mensagens e um consumidor para receber mensagens das filas do RabbitMQ.
Antes de começar, adicione a dependência apropriada do RabbitMQ JMS ao seu projeto Maven:
Para JMS 1.1 e 2.0:
```
com.rabbitmq.jms
rabbitmq-jms
2.12.0
```
Para o JMS 3.1:
```
com.rabbitmq.jms
rabbitmq-jms
3.5.0
```
## Crie um produtor
O exemplo de código a seguir mostra como gravar em uma fila do RabbitMQ usando 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);
```
## Crie um consumidor
O exemplo de código a seguir mostra como ler de uma fila do RabbitMQ usando 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();
```