

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
<a name="rabbitmq-on-amazon-mq"></a>

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)

## Etapa 2: conectar uma aplicação baseada em JVM ao seu agente
<a name="rabbitmq-connect-jvm-application"></a>

 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
<a name="rabbitmq-connect-application-prerequisites-getting-started"></a>

**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
<a name="rabbitmq-connect-application-enable-vpc-attributes-getting-started"></a>

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
<a name="rabbitmq-connect-application-allow-inbound-connections-getting-started"></a>

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
<a name="rabbitmq-connect-application-java-dependencies-getting-started"></a>

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).

```
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.9.0</version>
</dependency>
```

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`
<a name="rabbitmq-import-connections-and-channels"></a>

 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
<a name="rabbitmq-create-connection-factory-and-connect"></a>

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
<a name="rabbitmq-publish-message"></a>

 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
<a name="rabbitmq-subscribe-receive-message"></a>

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
<a name="rabbitmq-disconnect"></a>

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
<a name="rabbitmq-connect-to-lambda"></a>

 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 *.