

# Controle qué eventos envía Lambda a la función
<a name="invocation-eventfiltering"></a>

Puede utilizar el filtrado de eventos para controlar qué registros de un flujo o una cola envía Lambda a su función. Por ejemplo, puede agregar un filtro para que la función solo procese los mensajes de Amazon SQS que contengan ciertos parámetros de datos. El filtrado de eventos solo funciona con determinadas asignaciones de orígenes de eventos. Puede agregar filtros a las asignaciones de orígenes de eventos de los siguientes Servicios de AWS:
+ Amazon DynamoDB
+ Amazon Kinesis Data Streams
+ Amazon MQ
+ Amazon Managed Streaming for Apache Kafka (Amazon MSK)
+ Apache Kafka autoadministrado
+ Amazon Simple Queue Service (Amazon SQS)

Para obtener información específica sobre el filtrado con orígenes de eventos específicos, consulte [Uso de filtros con diferentes Servicios de AWS](#filtering-by-service). Lambda no es compatible con el filtrado de eventos para Amazon DocumentDB.

De manera predeterminada, puede definir hasta cinco filtros diferentes para una única asignación de orígenes de eventos. Los filtros se unen de forma lógica. Si un registro del origen de eventos cumple con uno o más de sus filtros, Lambda incluye el registro en el siguiente evento que envíe a su función. Si no se cumple con ninguno de los filtros, Lambda descarta el registro.

**nota**  
Si necesita definir más de cinco filtros para un origen de eventos, puede solicitar un aumento de cuota de hasta 10 filtros para cada origen de eventos. Si intenta agregar más filtros de los que permite su cuota actual, Lambda devolverá un error al intentar crear el origen de eventos.

**Topics**
+ [

## Conceptos básicos del filtrado de eventos
](#filtering-basics)
+ [

## Gestión de registros que no cumplen con los criterios de filtro
](#filtering-criteria-not-met)
+ [

## Sintaxis de la regla de filtro
](#filtering-syntax)
+ [

## Adjuntar criterios de filtro a una asignación de origen de eventos (consola)
](#filtering-console)
+ [

## Adjuntar criterios de filtro a una asignación de origen de eventos (AWS CLI)
](#filtering-cli)
+ [

## Adjuntar criterios de filtro a una asignación de origen de eventos (AWS SAM)
](#filtering-sam)
+ [

## Cifrado de los criterios de filtro
](#filter-criteria-encryption)
+ [

## Uso de filtros con diferentes Servicios de AWS
](#filtering-by-service)

## Conceptos básicos del filtrado de eventos
<a name="filtering-basics"></a>

Un objeto de criterios de filtro (`FilterCriteria`) es una estructura que consta de una lista de filtros (`Filters`). Cada filtro es una estructura que define un patrón de filtrado de eventos (`Pattern`). Un patrón es una representación de cadenas de una regla de filtro de JSON. La estructura de un objeto `FilterCriteria` es la siguiente:

```
{
   "Filters": [
        {
            "Pattern": "{ \"Metadata1\": [ rule1 ], \"data\": { \"Data1\": [ rule2 ] }}"
        }
    ]
}
```

Para mayor claridad, este es el valor del `Pattern` del filtro ampliado en JSON no cifrado.

```
{
    "Metadata1": [ rule1 ],
    "data": {
        "Data1": [ rule2 ]
    }
}
```

El patrón de filtro puede incluir propiedades de metadatos, propiedades de datos o ambas. Los parámetros de metadatos disponibles y el formato de los parámetros de datos varían según el Servicio de AWS que actúe como origen del evento. Por ejemplo, supongamos que su asignación de orígenes de eventos recibe el siguiente registro de una cola de Amazon SQS:

```
{
    "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
    "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
    "body": "{\\n \"City\": \"Seattle\",\\n \"State\": \"WA\",\\n \"Temperature\": \"46\"\\n}",
    "attributes": {
        "ApproximateReceiveCount": "1",
        "SentTimestamp": "1545082649183",
        "SenderId": "AIDAIENQZJOLO23YVJ4VO",
        "ApproximateFirstReceiveTimestamp": "1545082649185"
    },
    "messageAttributes": {},
    "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
    "eventSource": "aws:sqs",
    "eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
    "awsRegion": "us-east-2"
}
```
+ Las **propiedades de metadatos** son los campos que contienen información sobre el evento que creó el registro. En el registro de Amazon SQS de ejemplo, las propiedades de metadatos incluyen campos como `messageID`, `eventSourceArn` y `awsRegion`.
+ Las **propiedades de datos** son los campos del registro que contienen los datos de su flujo o cola. En el evento de Amazon SQS de ejemplo, la clave del campo de datos es `body` y las propiedades de datos son los campos `City`, `State` y `Temperature`.

Los diferentes tipos de orígenes de eventos utilizan diferentes valores de clave para sus campos de datos. Para filtrar las propiedades de datos, asegúrese de utilizar la clave correcta en el patrón del filtro. Para obtener una lista de las claves de filtrado de datos y ver ejemplos de patrones de filtro para cada uno de los Servicio de AWS compatibles, consulte [Uso de filtros con diferentes Servicios de AWS](#filtering-by-service).

El filtrado de eventos puede gestionar el filtrado JSON multinivel. Por ejemplo, fíjese en el siguiente fragmento de un registro de un flujo de DynamoDB:

```
"dynamodb": {
    "Keys": {
        "ID": {
            "S": "ABCD"
        }
        "Number": {
            "N": "1234"
    },
    ...
}
```

Supongamos que desea procesar solo los registros en los que el valor de la clave de clasificación `Number` sea 4567. En este caso, el objeto `FilterCriteria` sería similar al siguiente:

```
{
    "Filters": [
        {
            "Pattern": "{ \"dynamodb\": { \"Keys\": { \"Number\": { \"N\": [ "4567" ] } } } }"
        }
    ]
}
```

Para mayor claridad, este es el valor del `Pattern` del filtro ampliado en JSON no cifrado. 

```
{
    "dynamodb": {
        "Keys": {
            "Number": {
                "N": [ "4567" ]
                }
            }
        }
}
```

## Gestión de registros que no cumplen con los criterios de filtro
<a name="filtering-criteria-not-met"></a>

La forma en que Lambda gestiona los registros que no cumplen con los criterios del filtrado depende del origen del evento.
+ En **Amazon SQS**, si un mensaje no cumple con los criterios de filtro, Lambda lo elimina automáticamente de la cola. No tiene que eliminar manualmente estos mensajes en Amazon SQS.
+ En **Kinesis** y **DynamoDB**, después de que los criterios de filtro evalúan un registro, el iterador de flujos supera este registro. Si el registro no cumple los criterios de filtro, no tiene que eliminarlo manualmente del origen de eventos. Tras el periodo de retención, Kinesis y DynamoDB eliminan automáticamente estos registros antiguos. Si quiere que los registros se eliminen antes, consulte [Changing the Data Retention Period](https://docs.aws.amazon.com/streams/latest/dev/kinesis-extended-retention.html) (Cambiar el periodo de retención de datos).
+ En el caso de los mensajes de **Amazon MSK**, **Apache Kafka autoadministrado** y **Amazon MQ**, Lambda elimina los mensajes que no coinciden con todos los campos incluidos en el filtro. Para Amazon MSK y Apache Kafka autoadministrado, Lambda compila los desplazamientos de los mensajes coincidentes y no coincidentes después de invocar la función de forma correcta. En el caso de Amazon MQ, Lambda reconoce los mensajes coincidentes después de invocar la función de forma correcta y reconoce los mensajes no coincidentes al filtrarlos.

## Sintaxis de la regla de filtro
<a name="filtering-syntax"></a>

Para las reglas de filtro, Lambda es compatible con las reglas de Amazon EventBridge y utiliza la misma sintaxis que EventBridge. Para obtener más información, consulte [Patrones de eventos de Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) en la *Guía del usuario de Amazon EventBridge*.

A continuación, se muestra un resumen de todos los operadores de comparación disponibles para el filtrado de eventos de Lambda.


| Operador de comparación | Ejemplo | Sintaxis de reglas | 
| --- | --- | --- | 
|  Nulo  |  El valor de UserID (ID de usuario) es nulo  |  “UserID”: [null]  | 
|  Vacío  |  LastName (Apellido) está vacío  |  “LastName”: [“”]  | 
|  Igual a  |  El valor de Name (Nombre) es “Alice”  |  “Name”: [“Alice”]  | 
|  Es igual a (omitir mayúsculas y minúsculas)  |  El valor de Name (Nombre) es “Alice”  |  "Name": [ \$1 "equals-ignore-case": "alice" \$1 ]  | 
|  Y  |  El valor de Location (Ubicación) es “New York” y el de Day (Día) es “Monday”  |  “Location”: [“New York”], “Day”: [“Monday”]  | 
|  O  |  El valor de PaymentType (Tipo de pago) es “Credit” (Crédito) o “Debit” (Débito)  |  “PaymentType”: [“Credit”, “Debit”]  | 
|  O (varios campos)  |  El valor de Location (Ubicación) es “New York” o el de Day (Día) es “Monday”.  |  "\$1or": [ \$1 "Location": [ "New York" ] \$1, \$1 "Day": [ "Monday" ] \$1 ]   | 
|  No  |  El valor de Weather (Tiempo) es cualquier valor menos “Raining” (Lluvia)  |  “Weather”: [\$1“anything-but”: [“Raining”]\$1]  | 
|  Valor numérico (igual a)  |  El valor de Price (Precio) es 100  |  “Price”: [\$1“numeric”: [“=”, 100]\$1]  | 
|  Valor numérico (rango)  |  El valor de Price (Precio) es superior a 10 e inferior o igual a 20  |  “Price”: [\$1“numeric”: [“>”, 10, “<=”, 20]\$1]  | 
|  Existe  |  ProductName (Nombre de producto) existe  |  “ProductName”: [\$1“exists”: true\$1]  | 
|  No existe  |  El valor de ProductName (Nombre de producto) no existe  |  “ProductName”: [\$1“exists”: false\$1]  | 
|  Comienza por  |  El valor de Region (Región) se encuentra en US (EE. UU.)  |  “Region”: [\$1“prefix”: “us-”\$1]  | 
|  Acaba con  |  FileName termina con la extensión .png.  |  "FileName": [ \$1 "suffix": ".png" \$1 ]   | 

**nota**  
Al igual que EventBridge, para las cadenas, Lambda usa coincidencia exacta (carácter a carácter) sin necesidad de cambio de mayúsculas y minúsculas ni cualquier otra normalización de cadenas. Para los números, Lambda también usa la representación de cadenas. Por ejemplo, 300, 300.0 y 3.0e2 no se consideran iguales.

Tenga en cuenta que el operador Exists solo funciona en los nodos hoja del origen de eventos JSON. No coincide con nodos intermedios. Por ejemplo, con el siguiente JSON, el patrón de filtro `{ "person": { "address": [ { "exists": true } ] } }"` no encontraría ninguna coincidencia porque `"address"` es un nodo intermedio.

```
{
  "person": {
    "name": "John Doe",
    "age": 30,
    "address": {
      "street": "123 Main St",
      "city": "Anytown",
      "country": "USA"
    }
  }
}
```

## Adjuntar criterios de filtro a una asignación de origen de eventos (consola)
<a name="filtering-console"></a>

Siga estos pasos para crear una nueva asignación de origen de eventos con criterios de filtro mediante la consola de Lambda.

**Para crear una nueva asignación de origen de eventos con criterios de filtro (consola)**

1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.

1. Elija el nombre de la función para la que se creará una asignación de origen de eventos.

1. En **Descripción general de la función**, elija **Agregar desencadenador**.

1. En **Trigger configuration** (Configuración del desencadenador), elija un tipo de desencadenador compatible con el filtrado de eventos. Para obtener una lista de los servicios compatibles, consulte la lista que aparece al principio de esta página.

1. Amplíe **Configuración adicional**.

1. En **Filter criteria** (Criterios de filtro), seleccione **Add** (Agregar), y luego defina e ingrese los filtros. Por ejemplo, puede ingresar lo siguiente.

   ```
   { "Metadata" : [ 1, 2 ] }
   ```

   De este modo, Lambda solo procesa los registros en los que el campo `Metadata` es igual a 1 o 2. Puede volver a seleccionar **Agregar** para agregar más filtros hasta la cantidad máxima permitida.

1. Cuando haya terminado de agregar filtros, elija **Guardar**.

Al ingresar criterios de filtro mediante la consola, solo ingresa el patrón de filtro y no necesita ingresar la clave `Pattern` ni las comillas de escape. En el paso 6 de las instrucciones anteriores, `{ "Metadata" : [ 1, 2 ] }` corresponde a los siguientes `FilterCriteria`.

```
{
   "Filters": [
      {
          "Pattern": "{ \"Metadata\" : [ 1, 2 ] }"
      }
   ]
}
```

Después de crear la asignación de origen de eventos en la consola, puede ver los `FilterCriteria` con formato en los detalles del desencadenador. Para obtener más ejemplos de cómo crear filtros de eventos con la consola, consulte [Uso de filtros con diferentes Servicios de AWS](#filtering-by-service).

## Adjuntar criterios de filtro a una asignación de origen de eventos (AWS CLI)
<a name="filtering-cli"></a>

Supongamos que quiere que una asignación de origen de eventos tenga los siguientes `FilterCriteria`:

```
{
   "Filters": [
      {
          "Pattern": "{ \"Metadata\" : [ 1, 2 ] }"
      }
   ]
}
```

Para crear una nueva asignación de orígenes de eventos con estos criterios de filtro mediante la AWS Command Line Interface (AWS CLI), ejecute el siguiente comando.

```
aws lambda create-event-source-mapping \
    --function-name my-function \
    --event-source-arn arn:aws:sqs:us-east-2:123456789012:my-queue \
    --filter-criteria '{"Filters": [{"Pattern": "{ \"Metadata\" : [ 1, 2 ]}"}]}'
```

El comando [create-event-source-mapping](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html) crea una nueva asignación de orígenes de eventos de Amazon SQS para la función `my-function` con los `FilterCriteria` especificados.

Para agregar estos criterios de filtro a una asignación de orígenes de eventos existente, ejecute el siguiente comando.

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

Tenga en cuenta que, para actualizar una asignación de origen de eventos, necesita su UUID. Puede obtener el UUID con una llamada a [list-event-source-mappings](https://docs.aws.amazon.com/cli/latest/reference/lambda/list-event-source-mappings.html). Lambda también devuelve el UUID en la respuesta de la CLI [create-event-source-mapping](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-event-source-mapping.html).

Para eliminar los criterios de filtro de un origen de eventos, puede ejecutar el comando [update-event-source-mapping](https://docs.aws.amazon.com/cli/latest/reference/lambda/update-event-source-mapping.html) con un objeto de `FilterCriteria` vacío.

```
aws lambda update-event-source-mapping \
    --uuid "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE" \
    --filter-criteria "{}"
```

Para obtener más ejemplos de cómo crear filtros de eventos con la AWS CLI, consulte [Uso de filtros con diferentes Servicios de AWS](#filtering-by-service).

## Adjuntar criterios de filtro a una asignación de origen de eventos (AWS SAM)
<a name="filtering-sam"></a>

 Supongamos que desea configurar un origen de eventos en AWS SAM para utilizar los siguientes criterios de filtro: 

```
{
   "Filters": [
      {
          "Pattern": "{ \"Metadata\" : [ 1, 2 ] }"
      }
   ]
}
```

 Para agregar estos criterios de filtro a su asignación de orígenes de eventos, inserte el siguiente fragmento en la plantilla YAML de su origen de eventos.

```
FilterCriteria: 
  Filters: 
    - Pattern: '{"Metadata": [1, 2]}'
```

 Para obtener más información sobre cómo crear y configurar una plantilla AWS SAM para una asignación de orígenes de eventos, consulte la sección [EventSource](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-eventsource.html) de la Guía para desarrolladores de AWS SAM. Para obtener más ejemplos de cómo crear filtros de eventos con AWS SAM, consulte [Uso de filtros con diferentes Servicios de AWS](#filtering-by-service). 

## Cifrado de los criterios de filtro
<a name="filter-criteria-encryption"></a>

De forma predeterminada, Lambda no cifra el objeto de criterios de filtro. En los casos de uso en los que pueda incluir información confidencial en el objeto de criterios de filtro, puede utilizar su propia [clave de KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys) para cifrarlo.

Tras cifrar el objeto de criterios de filtro, puede ver su versión de texto sin formato mediante una llamada a la API [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html). Debe tener permisos `kms:Decrypt` para poder ver correctamente los criterios de filtro en texto sin formato.

**nota**  
Si el objeto de criterios de filtro está cifrado, Lambda oculta el valor del campo `FilterCriteria` en la respuesta a las llamadas a [ListEventSourceMappings](https://docs.aws.amazon.com/lambda/latest/api/API_ListEventSourceMappings.html). En su lugar, este campo se muestra como `null`. Para ver el valor real de `FilterCriteria`, use la API [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html).  
Para ver el valor descifrado de `FilterCriteria` en la consola, asegúrese de que su rol de IAM contenga permisos para [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html).

Puede especificar su propia clave de KMS mediante la consola, la API, la CLI o CloudFormation.

**Cifrado de los criterios de filtro con una clave de KMS propiedad del cliente (consola)**

1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.

1. Elija **Add trigger (Añadir disparador)**. Si ya tiene un desencadenador, seleccione la pestaña **Configuración** y, a continuación, seleccione **Desencadenadores**. Seleccione el desencadenador existente y, a continuación, elija **Editar**.

1. Seleccione la casilla de verificación situada junto a **Cifrar con una clave de KMS administrada por el cliente**.

1. En **Elegir una clave de cifrado de KMS administrada por el cliente**, seleccione una clave habilitada existente o cree una clave nueva. En función de la operación, necesitará algunos de los permisos siguientes (o todos): `kms:DescribeKey`, `kms:GenerateDataKey` y `kms:Decrypt`. Use la política de claves de KMS para conceder estos permisos.

Si utiliza su propia clave de KMS, en la [política de claves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) deben permitirse las siguientes operaciones de la API:
+ `kms:Decrypt`: debe otorgarse a la entidad principal de servicio regional de Lambda (`lambda.AWS_region.amazonaws.com`). Permite a Lambda descifrar los datos con esta clave de KMS.
  + Para evitar un [problema de suplente confuso entre servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html), la política de claves usa la clave de condición global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn). El valor correcto de la clave `aws:SourceArn` es el ARN del recurso de asignación de orígenes de eventos, por lo que solo puede agregarlo a su política si conoce su ARN. Lambda también reenvía las claves `aws:lambda:FunctionArn` y `aws:lambda:EventSourceArn` y sus correspondientes valores en el [contexto de cifrado](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) al hacer una solicitud de descifrado a KMS. Estos valores deben coincidir con las condiciones especificadas en la política de claves para que la solicitud de descifrado se complete correctamente. No es necesario incluir EventSourceArn para los orígenes de eventos de Kafka autoadministrados, ya que no tienen EventSourceArn.
+ `kms:Decrypt`: también se debe conceder a la entidad principal que pretenda utilizar la clave para ver los criterios de filtro de texto sin formato en las llamadas a las API [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html) o [DeleteEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteEventSourceMapping.html).
+ `kms:DescribeKey`: proporciona los detalles de la clave administrada por el cliente para permitir que la entidad principal especificada use la clave.
+ `kms:GenerateDataKey`: proporciona permisos para que Lambda genere una clave de datos para cifrar los criterios de filtro, en nombre de la entidad principal especificada ([cifrado de sobre](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping)).

Puede utilizar AWS CloudTrail para hacer un seguimiento de las solicitudes de AWS KMS que Lambda hace en su nombre. Para ver ejemplos de eventos de CloudTrail, consulte [Supervisión de las claves de cifrado para Lambda](security-encryption-at-rest.md#encryption-key-monitoring).

También recomendamos usar la clave de condición [https://docs.aws.amazon.com/kms/latest/developerguide/conditions-kms.html#conditions-kms-via-service](https://docs.aws.amazon.com/kms/latest/developerguide/conditions-kms.html#conditions-kms-via-service) para limitar el uso de la clave de KMS únicamente a las solicitudes de Lambda. El valor de esta clave es la entidad principal de servicio regional de Lambda (`lambda.AWS_region.amazonaws.com`). A continuación se incluye un ejemplo de política de claves que concede todos los permisos pertinentes:

**Example AWS KMSPolítica de claves de**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Id": "example-key-policy-1",
    "Statement": [
        {
            "Sid": "Allow Lambda to decrypt using the key",
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.us-east-1.amazonaws.com"
            },
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": "*",
            "Condition": {
                "ArnEquals" : {
                    "aws:SourceArn": [
                        "arn:aws:lambda:us-east-1:123456789012:event-source-mapping:<esm_uuid>"
                    ]
                },
                "StringEquals": {
                    "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:123456789012:function:test-function",
                    "kms:EncryptionContext:aws:lambda:EventSourceArn": "arn:aws:sqs:us-east-1:123456789012:test-queue"
                }
            }
        },
        {
            "Sid": "Allow actions by an AWS account on the key",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:root"
            },
            "Action": "kms:*",
            "Resource": "*"
        },
        {
            "Sid": "Allow use of the key to specific roles",
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:role/ExampleRole"
            },
            "Action": [
                "kms:Decrypt",
                "kms:DescribeKey",
                "kms:GenerateDataKey"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals" : {
                    "kms:ViaService": "lambda.us-east-1.amazonaws.com"
                }
            }
        }
    ]
}
```

Para usar su propia clave de KMS para cifrar los criterios de filtro, también puede usar el siguiente comando de la AWS CLI [CreateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_CreateEventSourceMapping.html). Especifique el ARN de la clave de KMS con la marca `--kms-key-arn`.

```
aws lambda create-event-source-mapping --function-name my-function \
    --maximum-batching-window-in-seconds 60 \
    --event-source-arn arn:aws:sqs:us-east-1:123456789012:my-queue \
    --filter-criteria "{\"filters\": [{\"pattern\": \"{\"a\": [\"1\", \"2\"]}\" }]}" \
    --kms-key-arn arn:aws:kms:us-east-1:123456789012:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```

Si ya tiene una asignación de orígenes de eventos, utilice el comando [UpdateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html) de la AWS CLI en su lugar. Especifique el ARN de la clave de KMS con la marca `--kms-key-arn`.

```
aws lambda update-event-source-mapping --function-name my-function \
    --maximum-batching-window-in-seconds 60 \
    --event-source-arn arn:aws:sqs:us-east-1:123456789012:my-queue \
    --filter-criteria "{\"filters\": [{\"pattern\": \"{\"a\": [\"1\", \"2\"]}\" }]}" \
    --kms-key-arn arn:aws:kms:us-east-1:123456789012:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```

Esta operación sobrescribe cualquier clave de KMS que se haya especificado anteriormente. Si especifica la marca `--kms-key-arn` junto con un argumento vacío, Lambda deja de usar la clave de KMS para cifrar los criterios de filtro. En su lugar, Lambda vuelve a utilizar de forma predeterminada una clave propiedad de Amazon.

Para especificar su propia clave de KMS en una plantilla de CloudFormation, utilice la propiedad `KMSKeyArn` del tipo de recurso `AWS::Lambda::EventSourceMapping`. Por ejemplo, puede insertar el siguiente fragmento en la plantilla YAML de su origen de eventos.

```
MyEventSourceMapping:
  Type: AWS::Lambda::EventSourceMapping
  Properties:
    ...
    FilterCriteria:
      Filters:
        - Pattern: '{"a": [1, 2]}'
    KMSKeyArn: "arn:aws:kms:us-east-1:123456789012:key/055efbb4-xmpl-4336-ba9c-538c7d31f599"
    ...
```

Para poder ver sus criterios de filtro cifrados en texto plano en una llamada a las API [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html) o [DeleteEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteEventSourceMapping.html), debe tener permisos `kms:Decrypt`.

Desde el 6 de agosto de 2024, el campo `FilterCriteria` ya no aparece en los registros de AWS CloudTrail de las llamadas a las API [CreateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_CreateEventSourceMapping.html), [UpdateEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html) y [DeleteEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteEventSourceMapping.html) si su función no usa el filtrado de eventos. Si su función usa el filtrado de eventos, el campo `FilterCriteria` aparece vacío (`{}`). Puede seguir viendo los criterios de filtro en texto sin formato en la respuesta a las llamadas a la API [GetEventSourceMapping](https://docs.aws.amazon.com/lambda/latest/api/API_GetEventSourceMapping.html) si tiene permisos `kms:Decrypt` para la clave de KMS correcta.

### Ejemplo de entrada de registro de CloudTrail para las llamadas a Create/Update/DeleteEventSourceMapping
<a name="filter-criteria-encryption-cloudtrail"></a>

En el siguiente ejemplo de entrada de registro de AWS CloudTrail para una llamada a CreateEventSourceMapping, `FilterCriteria` aparece vacío (`{}`) porque la función utiliza el filtrado de eventos. Este es el caso incluso si el objeto `FilterCriteria` contiene criterios de filtro válidos que la función esté utilizando activamente. Si la función no utiliza el filtrado de eventos, CloudTrail no mostrará el campo `FilterCriteria` en las entradas de registro.

```
{
    "eventVersion": "1.08",
    "userIdentity": {
        "type": "AssumedRole",
        "principalId": "AROA123456789EXAMPLE:userid1",
        "arn": "arn:aws:sts::123456789012:assumed-role/Example/example-role",
        "accountId": "123456789012",
        "accessKeyId": "ASIAIOSFODNN7EXAMPLE",
        "sessionContext": {
            "sessionIssuer": {
                "type": "Role",
                "principalId": "AROA987654321EXAMPLE",
                "arn": "arn:aws:iam::123456789012:role/User1",
                "accountId": "123456789012",
                "userName": "User1"
            },
            "webIdFederationData": {},
            "attributes": {
                "creationDate": "2024-05-09T20:35:01Z",
                "mfaAuthenticated": "false"
            }
        },
        "invokedBy": "AWS Internal"
    },
    "eventTime": "2024-05-09T21:05:41Z",
    "eventSource": "lambda.amazonaws.com",
    "eventName": "CreateEventSourceMapping20150331",
    "awsRegion": "us-east-2",
    "sourceIPAddress": "AWS Internal",
    "userAgent": "AWS Internal",
    "requestParameters": {
        "eventSourceArn": "arn:aws:sqs:us-east-2:123456789012:example-queue",
        "functionName": "example-function",
        "enabled": true,
        "batchSize": 10,
        "filterCriteria": {},
        "kMSKeyArn": "arn:aws:kms:us-east-2:123456789012:key/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "scalingConfig": {},
        "maximumBatchingWindowInSeconds": 0,
        "sourceAccessConfigurations": []
    },
    "responseElements": {
        "uUID": "a1b2c3d4-5678-90ab-cdef-EXAMPLEaaaaa",
        "batchSize": 10,
        "maximumBatchingWindowInSeconds": 0,
        "eventSourceArn": "arn:aws:sqs:us-east-2:123456789012:example-queue",
        "filterCriteria": {},
        "kMSKeyArn": "arn:aws:kms:us-east-2:123456789012:key/a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
        "functionArn": "arn:aws:lambda:us-east-2:123456789012:function:example-function",
        "lastModified": "May 9, 2024, 9:05:41 PM",
        "state": "Creating",
        "stateTransitionReason": "USER_INITIATED",
        "functionResponseTypes": [],
        "eventSourceMappingArn": "arn:aws:lambda:us-east-2:123456789012:event-source-mapping:a1b2c3d4-5678-90ab-cdef-EXAMPLEbbbbb"
    },
    "requestID": "a1b2c3d4-5678-90ab-cdef-EXAMPLE33333",
    "eventID": "a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
    "readOnly": false,
    "eventType": "AwsApiCall",
    "managementEvent": true,
    "recipientAccountId": "123456789012",
    "eventCategory": "Management",
    "sessionCredentialFromConsole": "true"
}
```

## Uso de filtros con diferentes Servicios de AWS
<a name="filtering-by-service"></a>

Los diferentes tipos de orígenes de eventos utilizan diferentes valores de clave para sus campos de datos. Para filtrar las propiedades de datos, asegúrese de utilizar la clave correcta en el patrón del filtro. En la siguiente tabla se muestran las claves de filtrado para cada Servicio de AWS compatible.


| Servicio de AWS | Clave de filtrado | 
| --- | --- | 
| DynamoDB | dynamodb | 
| Kinesis | data | 
| Amazon MQ | data | 
| Amazon MSK | value | 
| Apache Kafka autoadministrado | value | 
| Amazon SQS | body | 

En las siguientes secciones se ofrecen ejemplos de patrones de filtro para diferentes tipos de orígenes de eventos. También proporcionan definiciones de los formatos de datos entrantes compatibles y los formatos de cuerpo de los patrones de filtro para cada servicio compatible.
+ [Uso del filtrado de eventos con una fuente de eventos de DynamoDB](with-ddb-filtering.md)
+ [Uso del filtrado de eventos con una fuente de eventos de Kinesis](with-kinesis-filtering.md)
+ [Filtrar eventos de una fuente de eventos de Amazon MQ](with-mq-filtering.md)
+ [Filtrado de eventos de Amazon MSK y de fuentes de eventos autoadministrados de Apache Kafka](kafka-filtering.md)
+ [Uso del filtrado de eventos con una fuente de eventos de Amazon SQS](with-sqs-filtering.md)