

# Usar o Lambda com o Amazon MQ
<a name="with-mq"></a>

**nota**  
Se você deseja enviar dados para um destino que não seja uma função do Lambda ou enriquecer os dados antes de enviá-los, consulte [Amazon EventBridge Pipes](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-pipes.html) (Pipes do Amazon EventBridge).

O Amazon MQ é um serviço gerenciado de agente de mensagem para o [Apache ActiveMQ](https://activemq.apache.org/) e o [RabbitMQ](https://www.rabbitmq.com). Um *agente de mensagens* habilita aplicações de software e componentes para se comunicarem usando várias linguagens de programação, sistemas operacionais e protocolos de mensagens formais por meio de destinos de eventos de tópico ou fila.

O Amazon MQ também pode gerenciar instâncias do Amazon Elastic Compute Cloud (Amazon EC2) em seu nome instalando agentes do ActiveMQ ou RabbitMQ e fornecendo diferentes topologias de rede e outras necessidades de infraestrutura.

Você pode usar uma função do Lambda para processar registros do seu agente de mensagens do Amazon MQ. O Lambda invoca sua função por meio de um [mapeamento de fontes de eventos](invocation-eventsourcemapping.md), um recurso do Lambda que lê mensagens de seu agente e invoca a função [de modo síncrono](invocation-sync.md).

**Atenção**  
Os mapeamentos da origem do evento do Lambda processam cada evento ao menos uma vez, podendo haver o processamento duplicado de registros. Para evitar possíveis problemas relacionados a eventos duplicados, é altamente recomendável tornar o código da função idempotente. Para saber mais, consulte [Como tornar minha função do Lambda idempotente](https://repost.aws/knowledge-center/lambda-function-idempotent) no Centro de Conhecimentos da AWS.

O mapeamento de fontes de eventos do Amazon MQ tem as seguintes restrições de configuração:
+ Simultaneidade: as funções do Lambda que usam um mapeamento de origem do evento do Amazon MQ têm uma configuração padrão de [simultaneidade](lambda-concurrency.md) máxima. Para o ActiveMQ, o serviço Lambda limita o número de ambientes de execução simultâneos a cinco por mapeamento da origem do evento do Amazon MQ. Para o RabbitMQ, o número de ambientes de execução simultânea é limitado a um por mapeamento da origem do evento do Amazon MQ. Mesmo que você altere as configurações de simultaneidade reservada ou provisionada da função, o serviço Lambda não disponibilizará mais ambientes de execução. Para solicitar um aumento na simultaneidade máxima padrão para um único mapeamento da origem do evento do Amazon MQ, entre em contato com o Suporte tendo a UUID do mapeamento da origem do evento e também a região. Como os aumentos são aplicados no nível do mapeamento da origem do evento específico, não no nível da conta ou da região, você precisa solicitar manualmente um aumento de escalação para cada mapeamento da origem do evento.
+ Contas cruzadas: o Lambda não é compatível com o processamento de contas cruzadas. Não é possível usar o Lambda para processar registros de um agente de mensagens do Amazon MQ que esteja em uma Conta da AWS diferente.
+ Autenticação: para o ActiveMQ, somente o [SimpleAuthenticationPlugin](https://activemq.apache.org/security#simple-authentication-plugin) do ActiveMQ é compatível. Para RabbitMQ, somente o[PLAIN](https://www.rabbitmq.com/access-control.html#mechanisms)Mecanismo de autenticação é compatível. Os usuários devem usar o AWS Secrets Manager para gerenciar suas credenciais. Para obter mais informações sobre a autenticação do ActiveMQ, consulte[Integração de corretores ActiveMQ com LDAP](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/security-authentication-authorization.html)no*Guia do desenvolvedor do Amazon MQ*.
+ Cota de conexão: os agentes têm um número máximo de conexões permitidas por protocolo de nível de transmissão de dados. Essa cota é baseada no tipo de instância do agente. Para obter mais informações, consulte o .[Operadores](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/amazon-mq-limits.html#broker-limits)seção do**Cotas no Amazon MQ**no*Guia do desenvolvedor do Amazon MQ*.
+ Conectividade: você pode criar agentes em uma Virtual Private Cloud (VPC) pública ou privada. Para VPCs privadas, sua função do Lambda precisa acessar a VPC para receber mensagens. Para obter mais informações, consulte [Configuração da segurança de rede](process-mq-messages-with-lambda.md#process-mq-messages-with-lambda-networkconfiguration) mais adiante nesta seção.
+ Destinos de eventos: somente destinos de fila são compatíveis. No entanto, você pode usar um tópico virtual, que se comporta como um tópico internamente enquanto interage com o Lambda como uma fila. Para obter mais informações, consulte [Virtual Destinations](https://activemq.apache.org/virtual-destinations) no site do Apache ActiveMQ e [Virtual Hosts](https://www.rabbitmq.com/vhosts.html) no site do RabbitMQ.
+ Topologia de rede: para o ActiveMQ, somente um agente de instância única ou em espera é aceito por mapeamento de fontes de eventos. Para o RabbitMQ, apenas um agente de instância única ou implantação de cluster é aceito por mapeamento de fonte de eventos. Os agentes de instância única requerem um endpoint de failover. Para obter mais informações sobre esses modos de implantação do agente, consulte[Arquitetura de operador do MQ](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/amazon-mq-broker-architecture.html)e[Arquitetura de MQ do Rabbit](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/rabbitmq-broker-architecture.html)no*Guia do desenvolvedor do Amazon MQ*.
+ Protocolos — Os protocolos suportados dependem do tipo de integração do Amazon MQ.
  + Para integrações do ActiveMQ, o Lambda consome mensagens usando o protocolo OpenWire/Java Message Service (JMS). Nenhum outro protocolo é compatível para o consumo de mensagens. Dentro do protocolo JMS, somente [https://activemq.apache.org/components/cms/api_docs/activemqcpp-3.6.0/html/classactivemq_1_1commands_1_1_active_m_q_text_message.html](https://activemq.apache.org/components/cms/api_docs/activemqcpp-3.6.0/html/classactivemq_1_1commands_1_1_active_m_q_text_message.html) e [https://activemq.apache.org/components/cms/api_docs/activemqcpp-3.9.0/html/classactivemq_1_1commands_1_1_active_m_q_bytes_message.html](https://activemq.apache.org/components/cms/api_docs/activemqcpp-3.9.0/html/classactivemq_1_1commands_1_1_active_m_q_bytes_message.html) são compatíveis. O Lambda também é compatível com propriedades personalizadas do JMS. Para obter mais informações sobre o protocolo OpenWire, consulte [OpenWire](https://activemq.apache.org/openwire.html) no site do Apache ActiveMQ.
  + Para integrações RabbitMQ, o Lambda consome mensagens usando o protocolo AMQP 0-9-1. Nenhum outro protocolo é compatível para o consumo de mensagens. Para obter mais informações sobre a implementação do protocolo AMQP 0-9-1 pelo RabbitMQ, consulte[AMQP 0-9-1 Guia de referência completo](https://www.rabbitmq.com/amqp-0-9-1-reference.html)no site do RabbitMQ.

O Lambda oferece suporte automaticamente às versões mais recentes do ActiveMQ e RabbitMQ que não têm suporte no Amazon MQ. Para obter as versões compatíveis mais recentes, consulte[Notas de versão do Amazon MQ](https://docs.aws.amazon.com/amazon-mq/latest/developer-guide/amazon-mq-release-notes.html)no*Guia do desenvolvedor do Amazon MQ*.

**nota**  
Por padrão, o Amazon MQ tem uma janela de manutenção semanal para agentes. Durante essa janela de tempo, os agentes não estão disponíveis. Para agentes sem espera, o Lambda não é possível processar nenhuma mensagem durante essa janela.

**Topics**
+ [Entender o grupo de consumidores do Lambda para o Amazon MQ](#services-mq-configure)
+ [Configuração da origem do evento do Amazon MQ para o Lambda](process-mq-messages-with-lambda.md)
+ [Parâmetros de mapeamento da origem do evento](services-mq-params.md)
+ [Filtrar eventos de uma origem de eventos do Amazon MQ](with-mq-filtering.md)
+ [Solucionar problemas de erro de mapeamento da origem do evento do Amazon MQ](services-mq-errors.md)

## Entender o grupo de consumidores do Lambda para o Amazon MQ
<a name="services-mq-configure"></a>

Para interagir com o Amazon MQ, o Lambda cria um grupo de consumidores que pode ler a partir de seus agentes do Amazon MQ. O grupo de consumidores é criado com o mesmo ID que um UUID de mapeamento da fonte de eventos.

Para fontes de evento do Amazon MQ, o Lambda divide os registros em lotes e os envia para sua função em uma única carga útil. Para controlar o comportamento, é necessário configurar a janela de lotes e o tamanho do lote. O Lambda extrai mensagens até processar o tamanho máximo da carga útil de 6 MB, a janela de lotes expirar ou o número de registros atingir o tamanho total do lote. Para obter mais informações, consulte [Comportamento de lotes](invocation-eventsourcemapping.md#invocation-eventsourcemapping-batching).

O grupo de consumidores recupera as mensagens como um BLOB de bytes, as codifica em base64 para uma única carga útil JSON e depois invoca a função. Se sua função retorna um erro para qualquer uma das mensagens em um lote, o Lambda tenta novamente todo o lote de mensagens até que o processamento seja bem-sucedido ou as mensagens expiram.

**nota**  
Embora as funções do Lambda normalmente tenham um limite máximo de tempo de 15 minutos, os mapeamentos da origem dos eventos para o Amazon MSK, o Apache Kafka autogerenciado, o Amazon DocumentDB e o Amazon MQ para ActiveMQ e RabbitMQ são compatíveis somente com funções com limites máximos de tempo limite de 14 minutos. Essa restrição garante que o mapeamento da origem do evento possa solucionar adequadamente os erros de função e repetições.

Você pode monitorar o uso da simultaneidade de uma determinada função usando a métrica `ConcurrentExecutions` no Amazon CloudWatch. Para obter mais informações sobre a simultaneidade, consulte [Configurar a simultaneidade reservada para uma função](configuration-concurrency.md).

**Example Eventos de registro do Amazon MQ**  

```
{
   "eventSource": "aws:mq",
   "eventSourceArn": "arn:aws:mq:us-east-2:111122223333:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8",
   "messages": [
      { 
        "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1---mq---us-east-2.amazonaws.com.rproxy.goskope.com-37557-1234520418293-4:1:1:1:1", 
        "messageType": "jms/text-message",
        "deliveryMode": 1,
        "replyTo": null,
        "type": null,
        "expiration": "60000",
        "priority": 1,
        "correlationId": "myJMSCoID",
        "redelivered": false,
        "destination": { 
          "physicalName": "testQueue" 
        },
        "data":"QUJDOkFBQUE=",
        "timestamp": 1598827811958,
        "brokerInTime": 1598827811958, 
        "brokerOutTime": 1598827811959, 
        "properties": {
          "index": "1",
          "doAlarm": "false",
          "myCustomProperty": "value"
        }
      },
      { 
        "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1---mq---us-east-2.amazonaws.com.rproxy.goskope.com-37557-1234520418293-4:1:1:1:1",
        "messageType": "jms/bytes-message",
        "deliveryMode": 1,
        "replyTo": null,
        "type": null,
        "expiration": "60000",
        "priority": 2,
        "correlationId": "myJMSCoID1",
        "redelivered": false,
        "destination": { 
          "physicalName": "testQueue" 
        },
        "data":"LQaGQ82S48k=",
        "timestamp": 1598827811958,
        "brokerInTime": 1598827811958, 
        "brokerOutTime": 1598827811959, 
        "properties": {
          "index": "1",
          "doAlarm": "false",
          "myCustomProperty": "value"
        }
      }
   ]
}
```

```
{
  "eventSource": "aws:rmq",
  "eventSourceArn": "arn:aws:mq:us-east-2:111122223333:broker:pizzaBroker:b-9bcfa592-423a-4942-879d-eb284b418fc8",
  "rmqMessagesByQueue": {
    "pizzaQueue::/": [
      {
        "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=="
      }
    ]
  }
}
```
No exemplo RabbitMQ,`pizzaQueue`é o nome da fila do RabbitMQ e`/`é o nome do host virtual. Ao receber mensagens, a origem do evento lista as mensagens em `pizzaQueue::/`.

# Configuração da origem do evento do Amazon MQ para o Lambda
<a name="process-mq-messages-with-lambda"></a>

**Topics**
+ [Configuração da segurança de rede](#process-mq-messages-with-lambda-networkconfiguration)
+ [Criar o mapeamento da origem do evento](#services-mq-eventsourcemapping)

## Configuração da segurança de rede
<a name="process-mq-messages-with-lambda-networkconfiguration"></a>

Para conceder ao Lambda acesso total ao Amazon MQ por meio do mapeamento da origem do evento, seu agente deve usar um endpoint público (endereço IP público) ou você deve fornecer acesso à Amazon VPC na qual o agente foi criado.

Ao usar o Amazon MQ com o Lambda, recomendamos a criação de [endpoints de VPC do AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) para conceder acesso da sua função aos recursos na sua Amazon VPC.

**nota**  
Os endpoints de VPC do AWS PrivateLink são necessários para funções com mapeamentos da origem de eventos que usam o modo padrão (sob demanda) para pesquisadores de eventos. Se o mapeamento da origem do evento usa o [modo provisionado](invocation-eventsourcemapping.md#invocation-eventsourcemapping-provisioned-mode), você não precisa configurar endpoints de VPC do AWS PrivateLink.

Crie um endpoint para fornecer acesso aos seguintes recursos:
+  Lambda: crie um endpoint para a entidade principal de serviço do Lambda. 
+  AWS STS: crie um endpoint para o AWS STS com a finalidade de possibilitar que uma entidade principal de serviço assuma um perfil em seu nome. 
+  Secrets Manager: caso o seu agente use o Secrets Manager para armazenar credenciais, crie um endpoint específico para o Secrets Manager. 

Como alternativa, configure um gateway NAT em cada sub-rede pública da Amazon VPC. Para obter mais informações, consulte [Habilitar o acesso à Internet para funções do Lambda conectadas à VPC](configuration-vpc-internet.md).

Ao criar um mapeamento da origem do evento para o Amazon MQ, o Lambda verifica se as interfaces de rede elástica (ENIs) já estão presentes nas sub-redes e nos grupos de segurança configurados para a Amazon VPC. Se o Lambda encontrar ENIs existentes, ele tentará reutilizá-las. Caso contrário, o Lambda criará novas ENIs para se conectar à origem do evento e invocar sua função.

**nota**  
As funções do Lambda sempre são executadas em VPCs de propriedade do serviço Lambda. A configuração de VPC da sua função não afetará o mapeamento da origem do evento. Somente a configuração de rede da origem dos eventos determina como o Lambda estabelece conexão com a origem dos eventos.

Configure os grupos de segurança para a Amazon VPC que contém o agente. Por padrão, o Amazon MQ usa as seguintes portas: `61617` (Amazon MQ para ActiveMQ) e `5671` (Amazon MQ para RabbitMQ).
+ Regras de entrada: permitem todo o tráfego na porta padrão do agente para o grupo de segurança associado à origem dos eventos. Como alternativa, é possível usar uma regra de grupo de segurança autorreferenciada para permitir o acesso de instâncias dentro do mesmo grupo de segurança.
+ Regras de saída: permitir todo o tráfego na porta `443` para destinos externos se sua função precisar se comunicar com serviços da AWS. Como alternativa, você também poderá usar uma regra de grupo de segurança autorreferenciada para limitar o acesso ao operador se não precisar se comunicar com outros serviços AWS.
+ Regras de entrada para o endpoint da Amazon VPC: caso você esteja usando um endpoint da Amazon VPC, o grupo de segurança associado ao endpoint da Amazon VPC deve permitir o tráfego de entrada na porta `443` usando o grupo de segurança do agente.

Caso o agente use autenticação, é possível restringir a política de endpoint para o endpoint do Secrets Manager. Para chamar a API do Secrets Manager, o Lambda usa seu perfil de função, e não a entidade principal de serviço do Lambda.

**Example Política de endpoint da VPC: endpoint do Secrets Manager**  

```
{
      "Statement": [
          {
              "Action": "secretsmanager:GetSecretValue",
              "Effect": "Allow",
              "Principal": {
                  "AWS": [
                      "arn:aws::iam::123456789012:role/my-role"
                  ]
              },
              "Resource": "arn:aws::secretsmanager:us-west-2:123456789012:secret:my-secret"
          }
      ]
  }
```

Quando você usa os endpoints da Amazon VPC, a AWS roteia suas chamadas de API para invocar sua função usando a interface de rede elástica (ENI) do endpoint. A entidade principal do serviço Lambda precisa chamar `lambda:InvokeFunction` para quaisquer perfis e funções que usem essas ENIs.

Por padrão, os endpoints da Amazon VPC têm políticas do IAM abertas que permitem amplo acesso aos recursos. A prática recomendada é restringir essas políticas para executar as ações necessárias usando esse endpoint. Para garantir que seu mapeamento da origem do evento seja capaz de invocar sua função do Lambda, a política de endpoint da VPC deve permitir que a entidade principal do serviço Lambda chame `sts:AssumeRole` e `lambda:InvokeFunction`. A restrição de suas políticas de endpoint da VPC para permitir apenas chamadas de API originadas em sua organização impedirá o funcionamento adequado do mapeamento da origem do evento; portanto, `"Resource": "*"` é necessário nessas políticas.

O seguinte exemplo de políticas de endpoint da VPC mostra como conceder o acesso necessário à entidade principal do serviço Lambda para os endpoints do AWS STS e Lambda.

**Example Política de endpoint da VPC: endpoint do AWS STS**  

```
{
      "Statement": [
          {
              "Action": "sts:AssumeRole",
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "lambda.amazonaws.com"
                  ]
              },
              "Resource": "*"
          }
      ]
    }
```

**Example Política de endpoint da VPC: endpoint do Lambda**  

```
{
      "Statement": [
          {
              "Action": "lambda:InvokeFunction",
              "Effect": "Allow",
              "Principal": {
                  "Service": [
                      "lambda.amazonaws.com"
                  ]
              },
              "Resource": "*"
          }
      ]
  }
```

## Criar o mapeamento da origem do evento
<a name="services-mq-eventsourcemapping"></a>

Crie um [mapeamento de fontes de eventos](invocation-eventsourcemapping.md) para instruir o Lambda a enviar registros de um agente do Amazon MQ para uma função do Lambda. É possível criar vários mapeamentos de origem de evento para processar os mesmos dados com várias funções ou processar itens de várias fontes com uma única função.

Para configurar sua função para ler do Amazon MQ, adicione as permissões necessárias e crie um acionador do **MQ** no console do Lambda.

Para ler os registros de um agente do Amazon MQ, a função do Lambda precisa das permissões a seguir. Você concede ao Lambda permissão para interagir com o agente do Amazon MQ e seus recursos subjacentes adicionando instruções de permissão ao [perfil de execução](lambda-intro-execution-role.md) da função:
+ [mq:DescribeBroker](https://docs.aws.amazon.com/amazon-mq/latest/api-reference/brokers-broker-id.html#brokers-broker-id-http-methods)
+ [secretsmanager:GetSecretValue](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html)
+ [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)
+ [logs:CreateLogGroup](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogGroup.html)
+ [logs:CreateLogStream](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLogStream.html)
+ [logs:PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)

**nota**  
Ao usar uma chave criptografada gerenciada pelo cliente, adicione a permissão `[kms:Decrypt](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-bootstrap-brokers.html#clusters-clusterarn-bootstrap-brokersget)` também.

**Para adicionar permissões e criar um acionador**

1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Escolha o nome de uma função.

1. Escolha a guia **Configuration** (Configuração) e, depois, **Permissions** (Permissões).

1. Em **Nome do perfil**, escolha o link para seu perfil de execução. Esse link abre o perfil no console do IAM.  
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/execution-role.png)

1. Escolha **Adicionar permissões** e, em seguida, **Criar política em linha**.  
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/inline-policy.png)

1. Na seção **Editor de políticas**, escolha **JSON**. Insira a seguinte política. A função precisa dessas permissões para ler de um agente do Amazon MQ.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
         {
           "Effect": "Allow",
           "Action": [
             "mq:DescribeBroker",
             "secretsmanager:GetSecretValue",
             "ec2:CreateNetworkInterface",
             "ec2:DeleteNetworkInterface",
             "ec2:DescribeNetworkInterfaces", 
             "ec2:DescribeSecurityGroups",
             "ec2:DescribeSubnets",
             "ec2:DescribeVpcs",
             "logs:CreateLogGroup",
             "logs:CreateLogStream", 
             "logs:PutLogEvents"		
           ],
           "Resource": "*"
         }
       ]
     }
   ```

------
**nota**  
Ao usar uma chave gerenciada pelo cliente criptografada, também é necessário adicionar a permissão `kms:Decrypt`.

1. Escolha **Próximo**. Digite um nome para a política e escolha **Criar política**.

1. Volte para a sua função no console do Lambda Em **Visão geral da função**, escolha **Adicionar gatilho**.  
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/add-trigger.png)

1. Selecione o tipo de acionador **MQ**.

1. Configure as opções necessárias e escolha **Add** (Adicionar).

O Lambda oferece suporte às seguintes opções de fontes de eventos do Amazon MQ:
+ **Agente do MQ**— Selecione um corretor do Amazon MQ.
+ **Batch size** (Tamanho do lote): defina o número máximo de mensagens a serem recuperadas em um único lote.
+ **Queue name** (Nome da fila): digite a fila do Amazon MQ a ser consumida.
+ **Configuração do acesso à fonte**— Insira as informações do host virtual e o segredo do Secrets Manager que armazena as credenciais do agente.
+ **Enable trigger** (Habilitar acionador): desabilite o acionador para interromper o processamento de registros.

Para habilitar ou desabilitar o trigger (ou excluí-lo), selecione o trigger do **MQ** no designer. Para reconfigurar o trigger, use as operações da API de mapeamento de fontes de eventos.

# Parâmetros de mapeamento da origem do evento
<a name="services-mq-params"></a>

Todos os tipos de origem de evento Lambda compartilham o mesmo[CreateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_CreateEventSourceMapping.html)e[UpdateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html)Operações de API do. No entanto, apenas alguns dos parâmetros se aplicam ao Amazon MQ e RabbitMQ.


| Parâmetro | Obrigatório | Padrão | Observações | 
| --- | --- | --- | --- | 
|  BatchSize  |  N  |  100  |  Máximo: 10.000.  | 
|  Habilitado  |  N  |  verdadeiro  | nenhuma | 
|  FunctionName  |  S  | N/D  | nenhuma | 
|  FilterCriteria  |  N  |  N/D   |  [Controlar quais eventos o Lambda envia para a função](invocation-eventfiltering.md)  | 
|  MaximumBatchingWindowInSeconds  |  N  |  500 ms  |  [Comportamento de lotes](invocation-eventsourcemapping.md#invocation-eventsourcemapping-batching)  | 
|  Filas  |  N  | N/D |  O nome da fila de destino do agente do Amazon MQ a ser consumido.  | 
|  SourceAccessConfigurations  |  N  | N/D  |  Para credenciais ActiveMQ, BASIC\$1AUTH. Para RabbitMQ, pode conter credenciais BASIC\$1AUTH e informações de VIRTUAL\$1HOST.  | 

# Filtrar eventos de uma origem de eventos do Amazon MQ
<a name="with-mq-filtering"></a>

É possível usar filtragem de eventos para controlar quais registros de um stream ou fila que o Lambda enviará para a função. Para obter informações gerais sobre como a filtragem de eventos funciona, consulte [Controlar quais eventos o Lambda envia para a função](invocation-eventfiltering.md).

Esta seção tem como foco a filtragem de eventos para as origens de eventos do Amazon MQ.

**nota**  
Os mapeamentos das origens dos eventos do Amazon MQ é compatível apenas com filtragem na chave `data`.

**Topics**
+ [Noções básicas da filtragem de eventos do Amazon MQ](#filtering-AMQ)

## Noções básicas da filtragem de eventos do Amazon MQ
<a name="filtering-AMQ"></a>

Suponha que sua fila de mensagens do Amazon MQ contenha mensagens em formato JSON válido ou como strings simples. Um exemplo de registro seria semelhante ao a seguir, com os dados convertidos em uma string codificada em Base64 no campo `data`.

------
#### [ ActiveMQ ]

```
{ 
    "messageID": "ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1---mq---us-east-2.amazonaws.com.rproxy.goskope.com-37557-1234520418293-4:1:1:1:1", 
    "messageType": "jms/text-message",
    "deliveryMode": 1,
    "replyTo": null,
    "type": null,
    "expiration": "60000",
    "priority": 1,
    "correlationId": "myJMSCoID",
    "redelivered": false,
    "destination": { 
      "physicalName": "testQueue" 
    },
    "data":"QUJDOkFBQUE=",
    "timestamp": 1598827811958,
    "brokerInTime": 1598827811958, 
    "brokerOutTime": 1598827811959, 
    "properties": {
      "index": "1",
      "doAlarm": "false",
      "myCustomProperty": "value"
    }
}
```

------
#### [ RabbitMQ ]

```
{
    "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 os agentes Active MQ e Rabbit MQ, é possível usar a filtragem de eventos para filtrar registros usando a chave `data`. Suponha que a fila do Amazon MQ contenha mensagens no formato JSON a seguir.

```
{
    "timeout": 0,
    "IPAddress": "203.0.113.254"
}
```

Para filtrar somente os registros onde o campo `timeout` é maior que 0, o objeto `FilterCriteria` seria como a seguir.

```
{
    "Filters": [
        {
            "Pattern": "{ \"data\" : { \"timeout\" : [ { \"numeric\": [ \">\", 0] } } ] } }"
        }
    ]
}
```

Para maior clareza, aqui está o valor de `Pattern` do filtro expandido em JSON simples.

```
{
    "data": {
        "timeout": [ { "numeric": [ ">", 0 ] } ]
        }
}
```

É possível adicionar seu filtro usando o console, a AWS CLI ou um modelo do AWS SAM.

------
#### [ Console ]

Para adicionar esse filtro usando o console, siga as instruções em [Anexar critérios de filtro a um mapeamento de fonte de eventos (console)](invocation-eventfiltering.md#filtering-console) e insira a string a seguir em **Critérios do filtro**.

```
{ "data" : { "timeout" : [ { "numeric": [ ">", 0 ] } ] } }
```

------
#### [ AWS CLI ]

Para criar um novo mapeamento da origem do evento com esses critérios de filtro usando a AWS Command Line Interface (AWS CLI), execute o comando a seguir.

```
aws lambda create-event-source-mapping \
    --function-name my-function \
    --event-source-arn arn:aws:mq:us-east-2:123456789012:broker:my-broker:b-8ac7cc01-5898-482d-be2f-a6b596050ea8 \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"data\" : { \"timeout\" : [ { \"numeric\": [ \">\", 0 ] } ] } }"}]}'
```

Para adicionar esses critérios de filtro a um mapeamento da origem do evento existente, execute o comando a seguir.

```
aws lambda update-event-source-mapping \
    --uuid "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE" \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"data\" : { \"timeout\" : [ { \"numeric\": [ \">\", 0 ] } ] } }"}]}'
```

Para adicionar esses critérios de filtro a um mapeamento da origem do evento existente, execute o comando a seguir.

```
aws lambda update-event-source-mapping \
    --uuid "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE" \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"data\" : { \"timeout\" : [ { \"numeric\": [ \">\", 0 ] } ] } }"}]}'
```

------
#### [ AWS SAM ]

Para adicionar esse filtro usando o AWS SAM, adicione o trecho a seguir ao modelo YAML da origem do evento.

```
FilterCriteria:
  Filters:
    - Pattern: '{ "data" : { "timeout" : [ { "numeric": [ ">", 0 ] } ] } }'
```

------

Com o Amazon MQ, você também pode filtrar registros onde a mensagem é uma string simples. Suponha que você queira processar somente registros onde a mensagem comece com “Resultado: ”. O objeto `FilterCriteria` seria como a seguir.

```
{
    "Filters": [
        {
            "Pattern": "{ \"data\" : [ { \"prefix\": \"Result: \" } ] }"
        }
    ]
}
```

Para maior clareza, aqui está o valor de `Pattern` do filtro expandido em JSON simples.

```
{
    "data": [
        {
        "prefix": "Result: "
        }
    ]
}
```

É possível adicionar seu filtro usando o console, a AWS CLI ou um modelo do AWS SAM.

------
#### [ Console ]

Para adicionar esse filtro usando o console, siga as instruções em [Anexar critérios de filtro a um mapeamento de fonte de eventos (console)](invocation-eventfiltering.md#filtering-console) e insira a string a seguir em **Critérios do filtro**.

```
{ "data" : [ { "prefix": "Result: " } ] }
```

------
#### [ AWS CLI ]

Para criar um novo mapeamento da origem do evento com esses critérios de filtro usando a AWS Command Line Interface (AWS CLI), execute o comando a seguir.

```
aws lambda create-event-source-mapping \
    --function-name my-function \
    --event-source-arn arn:aws:mq:us-east-2:123456789012:broker:my-broker:b-8ac7cc01-5898-482d-be2f-a6b596050ea8 \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"data\" : [ { \"prefix\": \"Result: \" } ] }"}]}'
```

Para adicionar esses critérios de filtro a um mapeamento da origem do evento existente, execute o comando a seguir.

```
aws lambda update-event-source-mapping \
    --uuid "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE" \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"data\" : [ { \"prefix\": \"Result: \" } ] }"}]}'
```

------
#### [ AWS SAM ]

Para adicionar esse filtro usando o AWS SAM, adicione o trecho a seguir ao modelo YAML da origem do evento.

```
FilterCriteria:
  Filters:
    - Pattern: '{ "data" : [ { "prefix": "Result " } ] }'
```

------

As mensagens do Amazon MQ devem ser strings codificadas em UTF-8, sejam em strings simples ou no formato JSON. Isso porque o Lambda decodifica as matrizes de bytes do Amazon MQ em UTF-8 antes de aplicar os critérios de filtragem. Se as mensagens usarem outra codificação, como UTF-16 ou ASCII, ou se o formato da mensagem não corresponder ao formato dos `FilterCriteria`, o Lambda processará somente os filtros de metadados. A tabela a seguir resume o comportamento específico:


| Formato do da mensagem recebida | Formato padrão de filtro para propriedades de mensagem | Ação resultante | 
| --- | --- | --- | 
|  String simples  |  String simples  |  Filtros do Lambda com base em seus critérios de filtro.  | 
|  String simples  |  Nenhum padrão de filtro para propriedades de dados  |  Filtros do Lambda (somente nas outras propriedades de metadados) com base nos seus critérios de filtro.  | 
|  String simples  |  JSON válido  |  Filtros do Lambda (somente nas outras propriedades de metadados) com base nos seus critérios de filtro.  | 
|  JSON válido  |  String simples  |  Filtros do Lambda (somente nas outras propriedades de metadados) com base nos seus critérios de filtro.  | 
|  JSON válido  |  Nenhum padrão de filtro para propriedades de dados  |  Filtros do Lambda (somente nas outras propriedades de metadados) com base nos seus critérios de filtro.  | 
|  JSON válido  |  JSON válido  |  Filtros do Lambda com base em seus critérios de filtro.  | 
|  String não codificada em UTF-8  |  JSON, string de texto simples ou nenhum padrão  |  Filtros do Lambda (somente nas outras propriedades de metadados) com base nos seus critérios de filtro.  | 

# Solucionar problemas de erro de mapeamento da origem do evento do Amazon MQ
<a name="services-mq-errors"></a>

Quando uma função do Lambda encontra um erro irrecuperável, o consumidor do Amazon MQ interrompe o processamento de registros. Qualquer outro consumidor pode continuar o processamento, contanto que não encontre o mesmo erro. Para determinar a possível causa de um consumidor interrompido, verifique o campo `StateTransitionReason` nos detalhes de devolução do `EventSourceMapping` para obter um dos seguintes códigos:

**`ESM_CONFIG_NOT_VALID`**  
A configuração do mapeamento da fonte de eventos não é válida.

**`EVENT_SOURCE_AUTHN_ERROR`**  
O Lambda falhou ao autenticar a fonte de eventos.

**`EVENT_SOURCE_AUTHZ_ERROR`**  
O Lambda não tem as permissões necessárias para acessar a fonte de eventos.

**`FUNCTION_CONFIG_NOT_VALID`**  
A configuração da função não é válida.

Os registros também não serão processados se o Lambda os descartar devido ao seu tamanho. O limite de tamanho para registros do Lambda é de 6 MB. Para entregar mensagens novamente após um erro da função, use uma Dead Letter Queue (DLQ – Fila de mensagens mortas). Para obter mais informações, consulte [Message Redelivery and DLQ Handling](https://activemq.apache.org/message-redelivery-and-dlq-handling) no site do Apache ActiveMQ e [Reliability Guide](https://www.rabbitmq.com/reliability.html) no site do RabbitMQ.

**nota**  
O Lambda não oferece suporte às políticas de reentrega personalizadas. Em vez disso, o Lambda usa uma política com os valores padrão da página [Política de reentrega](https://activemq.apache.org/redelivery-policy) no site do Apache ActiveMQ, com `maximumRedeliveries` definido como 6.