Notions de base du filtrage d’événements Traitement des enregistrements ne répondant pas aux critères de filtrage Syntaxe des règles de filtrage Attacher des critères de filtre à un mappage de sources d’événements (console)Attacher des critères de filtre à un mappage de sources d’événements (AWS CLI)Attacher des critères de filtre à un mappage de sources d’événements (AWS SAM)Utilisation de filtres avec différents Services AWS Filtrage avec DynamoDB Filtrage avec Kinesis Filtrage avec Amazon MQ Filtrage avec Amazon MSK et Apache Kafka autogéré Filtrage avec Amazon SQS

Filtrage des événements Lambda

Vous pouvez utiliser le filtrage d’événements pour contrôler les enregistrements d’un flux ou d’une file d’attente que Lambda envoie à votre fonction. Par exemple, vous pouvez ajouter un filtre pour que votre fonction ne traite que les messages Amazon SQS contenant certains paramètres de données. Le filtrage des sources d’événements fonctionne avec des mappages des sources d’événements. Vous pouvez ajouter des filtres aux mappages de sources d'événements pour les AWS services suivants :

Amazon DynamoDB
Amazon Kinesis Data Streams
Amazon MQ
Amazon Managed Streaming for Apache Kafka (Amazon MSK)
Self-managed Apache Kafka
Amazon Simple Queue Service (Amazon SQS)

Lambda ne prend pas en charge le filtrage d’événements pour Amazon DocumentDB.

Par défaut, vous pouvez définir jusqu’à cinq filtres différents pour un seul mappage des sources d’événements. Vos filtres sont logiquement combinés par OU. Si un enregistrement de votre source d’événement satisfait un ou plusieurs de vos filtres, Lambda inclut l’enregistrement dans le prochain événement qu’il envoie à votre fonction. Si aucun de vos filtres n’est satisfait, Lambda rejette l’enregistrement.

Note

Si vous avez besoin de définir plus de cinq filtres pour une source d’événement, vous pouvez demander une augmentation de quota jusqu’à 10 filtres pour chaque source d’événement. Si vous tentez d’ajouter plus de filtres que votre quota actuel ne le permet, Lambda renvoie une erreur lorsque vous tenterez de créer la source d’événement.

Rubriques

Notions de base du filtrage d’événements
Traitement des enregistrements ne répondant pas aux critères de filtrage
Syntaxe des règles de filtrage
Attacher des critères de filtre à un mappage de sources d’événements (console)
Attacher des critères de filtre à un mappage de sources d’événements (AWS CLI)
Attacher des critères de filtre à un mappage de sources d’événements (AWS SAM)
Utilisation de filtres avec différents Services AWS
Filtrage avec DynamoDB
Filtrage avec Kinesis
Filtrage avec Amazon MQ
Filtrage avec Amazon MSK et Apache Kafka autogéré
Filtrage avec Amazon SQS

Notions de base du filtrage d’événements

Un objet (FilterCriteria) de critères de filtre est une structure composée d’une liste de filtres (Filters). Chaque filtre est une structure qui définit un modèle de filtrage d’événements (Pattern). Un modèle est une représentation sous forme de chaîne d’une règle de filtre JSON. La structure d’un objet FilterCriteria est la suivante.


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

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


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

Votre modèle de filtrage peut inclure des propriétés de métadonnées, des propriétés de données ou les deux. Les paramètres de métadonnées disponibles et le format des paramètres de données varient en fonction de la Service AWS source de l'événement. Par exemple, supposons que votre mappage des sources d’événements reçoit l’enregistrement suivant d’une file d’attente 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"
}

Les propriétés de métadonnées sont les champs contenant des informations sur l’événement qui a créé l’enregistrement. Dans l’exemple d’enregistrement Amazon SQS, les propriétés de métadonnées comprennent des champs tels que messageID, eventSourceArn et awsRegion.
Les propriétés de données sont les champs de l’enregistrement contenant les données de votre flux ou file d’attente. Dans l’exemple d’événement Amazon SQS, la clé du champ de données est body et les propriétés de données sont les champs City State et Temperature.

Les différents types de sources d’événements utilisent des valeurs clés différentes pour leurs champs de données. Pour filtrer sur les propriétés de données, assurez-vous d’utiliser la bonne clé dans le modèle de votre filtre. Pour obtenir la liste des clés de filtrage des données et des exemples de modèles de filtre pris en charge pour chacune d'entre elles Service AWS, reportez-vous àUtilisation de filtres avec différents Services AWS.

Le filtrage d’événements peut gérer le filtrage JSON à plusieurs niveaux. Par exemple, considérez le fragment suivant d’un enregistrement provenant d’un flux DynamoDB :


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

Supposons que vous vouliez traiter uniquement les enregistrements dont la valeur de la clé de tri Number est 4 567. Dans ce cas, votre objet FilterCriteria se présente comme suit :


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

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


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

Traitement des enregistrements ne répondant pas aux critères de filtrage

La manière dont les enregistrements qui ne répondent pas à votre filtre sont traités dépend de la source de l’événement.

Pour Amazon SQS, si un message ne répond pas à vos critères de filtre, Lambda supprime automatiquement le message de la file d’attente. Vous n’avez pas besoin de supprimer manuellement ces messages dans Amazon SQS.
Pour Kineses et DynamoDB, une fois que vos critères de filtrage traitent un enregistrement, l’itérateur de flux avance au-delà de cet enregistrement. Si l’enregistrement ne répond pas à vos critères de filtre, vous n’avez pas besoin de supprimer manuellement l’enregistrement de la source de votre événement. Après la période de conservation, Kinesis et DynamoDB suppriment automatiquement ces anciens enregistrements. Si vous souhaitez que les enregistrements soient supprimés plus tôt, consultez Modification de la période de conservation des données.
Pour les messages Amazon MSK, Apache Kafka autogéré et Amazon MQ, Lambda supprime les messages qui ne correspondent pas à tous les champs inclus dans le filtre. Pour Apache Kafka autogéré, Lambda valide les décalages pour les messages correspondants et non correspondants une fois la fonction invoquée avec succès. Pour Amazon MQ, Lambda accuse réception des messages correspondants après avoir correctement invoqué la fonction et reconnaît les messages non correspondants lors du filtrage.

Syntaxe des règles de filtrage

Pour les règles de filtrage, Lambda prend en charge EventBridge les règles Amazon et utilise la même syntaxe que. EventBridge Pour plus d'informations, consultez les modèles EventBridge d'événements Amazon dans le guide de EventBridge l'utilisateur Amazon.

Voici un récapitulatif de tous les opérateurs de comparaison disponibles pour le filtrage d’événement Lambda.

Opérateur de comparaison	Exemple	Syntaxe des règles
Null	UserID est null	"UserID": [ null ]
Vide	LastName est vide	"LastName": [""]
Égal à	Le nom est « Alice »	"Name": [ "Alice" ]
Est égal à (ignorer les majuscules)	Le nom est « Alice »	« Nom » : [{"equals-ignore-case« : « alice »}]
And	Le lieu est « New York » et le jour est « Monday »	"Location": [ "New York" ], "Day": ["Monday"]
Ou	PaymentType est « Crédit » ou « Débit »	PaymentType« : [« Crédit », « Débit"]
Ou (plusieurs champs)	Location est « New York », ou Day est « Monday ».	"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]
Pas	La météo est tout sauf « Raining »	"Weather": [ { "anything-but": [ "Raining" ] } ]
Numérique (égal)	Le prix est de 100	"Price": [ { "numeric": [ "=", 100 ] } ]
Numérique (plage)	Le prix est supérieur à 10 et inférieur ou égal à 20	"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]
Existe	ProductName existe	ProductName« : [{« existe » : vrai}]
N’existe pas	ProductName n'existe pas	ProductName« : [{« existe » : faux}]
Commence par	La région se trouve aux États-Unis	"Region": [ {"prefix": "us-" } ]
Se termine par	FileName se termine par une extension .png.	FileName« : [{« suffixe » : « .png »}]

Note

Comme pour les chaînes EventBridge, Lambda utilise une character-by-character correspondance exacte sans pliage en majuscules ni aucune autre normalisation des chaînes. Pour les nombres, Lambda utilise également une représentation par chaîne. Par exemple, 300, 300,0 et 3.0e2 ne sont pas considérés égaux.

Attacher des critères de filtre à un mappage de sources d’événements (console)

Suivez ces étapes pour créer un nouveau mappage de source d’événement avec des critères de filtre à l’aide de la console Lambda.

Pour créer un nouveau mappage de sources d’événements avec des critères de filtre (console)

Ouvrez la page Functions (Fonctions) de la console Lambda.
Choisissez le nom d’une fonction pour laquelle créer un mappage de source d’événements.
Sous Function overview (Vue d’ensemble de la fonction), choisissez Add trigger (Ajouter un déclencheur).
Pour Trigger configuration (Configuration du déclencheur), choisissez un type de déclencheur qui prend en charge le filtrage des événements. Pour obtenir la liste des services pris en charge, reportez-vous à la liste figurant au début de cette page.
Développer Additional settings (Paramètres supplémentaires).
Sous Filter criteria (Critères de filtre), choisissez Add (Ajouter) puis définissez et saisissez vos filtres. Par exemple, vous pouvez saisir ce qui suit.
```
{ "Metadata" : [ 1, 2 ] }
```
Cela indique à Lambda de traiter uniquement les enregistrements où le champ Metadata est égal à 1 ou 2. Vous pouvez continuer à sélectionner Ajouter pour ajouter d’autres filtres jusqu’au nombre maximum autorisé.
Lorsque vous avez terminé d’ajouter vos filtres, sélectionnez Enregistrer.

Lorsque vous saisissez des critères de filtrage à l’aide de la console, vous n’entrez que le modèle de filtrage et n’avez pas besoin d’indiquer la touche Pattern ni d’échapper aux guillemets. À l’étape 6 des instructions précédentes, { "Metadata" : [ 1, 2 ] } correspond à ce qui suit FilterCriteria.


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

Après avoir créé le mappage de la source d’événements dans la console, vous pouvez voir les FilterCriteria formatés dans les détails du déclencheur. Pour plus d’exemples de création de filtres d’événements à l’aide de la console, consultez Utilisation de filtres avec différents Services AWS.

Attacher des critères de filtre à un mappage de sources d’événements (AWS CLI)

Supposons que vous souhaitiez que le mappage d’une source d’événements comporte les suivants FilterCriteria:


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

Pour créer un nouveau mappage de source d'événements avec ces critères de filtre à l'aide de AWS Command Line Interface (AWS CLI), exécutez la commande suivante.


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 ]}"}]}'

Cette create-event-source-mappingcommande crée un nouveau mappage de source d'événements Amazon SQS pour la fonction my-function avec la valeur spécifiée. FilterCriteria

Pour ajouter ces critères de filtre à un mappage des sources d’événements existant, exécutez la commande suivante.


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

Notez que pour mettre à jour un mappage de source d’événements, vous avez besoin de son UUID. Vous pouvez obtenir l'UUID lors d'un list-event-source-mappingsappel. Lambda renvoie également l'UUID dans la réponse de la CLI. create-event-source-mapping

Pour supprimer les critères de filtre d'une source d'événement, vous pouvez exécuter la update-event-source-mappingcommande suivante avec un FilterCriteria objet vide.


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

Pour plus d'exemples de création de filtres d'événements à l'aide du AWS CLI, voirUtilisation de filtres avec différents Services AWS.

Attacher des critères de filtre à un mappage de sources d’événements (AWS SAM)

Supposons que vous souhaitiez configurer une source d'événements AWS SAM pour utiliser les critères de filtre suivants :


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

Pour ajouter ces critères de filtre à votre mappage des sources d’événements, insérez l’extrait suivant dans le modèle YAML de votre source d’événements.


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

Pour plus d'informations sur la création et la configuration d'un AWS SAM modèle pour un mappage de sources d'événements, consultez la EventSourcesection du guide du AWS SAM développeur. Pour plus d'exemples de création de filtres d'événements à l'aide AWS SAM de modèles, consultezUtilisation de filtres avec différents Services AWS.

Utilisation de filtres avec différents Services AWS

Les différents types de sources d’événements utilisent des valeurs clés différentes pour leurs champs de données. Pour filtrer sur les propriétés de données, assurez-vous d’utiliser la bonne clé dans le modèle de votre filtre. Le tableau suivant indique les clés de filtrage pour chacune des clés prises en charge Service AWS.

Service AWS	Clé de filtrage
DynamoDB	`dynamodb`
Kinesis	`data`
Amazon MQ	`data`
Amazon MSK	`value`
Self-managed Apache Kafka	`value`
Amazon SQS	`body`

Les sections suivantes donnent des exemples de modèles de filtrage pour différents types de sources d’événements. Elles fournissent également des définitions des formats de données entrantes pris en charge et des formats de corps de modèle de filtre pour chaque service pris en charge.

Filtrage avec DynamoDB

Supposons que vous ayez une table DynamoDB avec la clé primaire CustomerName et les attributs AccountManager et PaymentTerms. La figure suivante montre un exemple d’enregistrement provenant du flux de votre table DynamoDB.


{
      "eventID": "1",
      "eventVersion": "1.0",
      "dynamodb": {
          "ApproximateCreationDateTime": "1678831218.0",
          "Keys": {
              "CustomerName": {
                  "S": "AnyCompany Industries"
              },
              "NewImage": {
                  "AccountManager": {
                      "S": "Pat Candella"
                  },
                  "PaymentTerms": {
                      "S": "60 days"
                  },
                  "CustomerName": {
                      "S": "AnyCompany Industries"
                  }
              },
              "SequenceNumber": "111",
              "SizeBytes": 26,
              "StreamViewType": "NEW_IMAGE"
          }
      }
  }

Pour filtrer sur la base des valeurs de clé et d’attribut de votre table DynamoDB, utilisez la clé dynamodb dans l’enregistrement. Supposons que vous souhaitiez que votre fonction traite uniquement les enregistrements dont la clé primaire CustomerName est « AnyCompany Industries ». L’objet FilterCriteria serait le suivant.


{
     "Filters": [
          {
              "Pattern": "{ \"dynamodb\" : { \"Keys\" : { \"CustomerName\" : { \"S\" : [ \"AnyCompany Industries\" ] } } } }"
          }
      ]
 }

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
     "dynamodb": {
          "Keys": {
              "CustomerName": {
                  "S": [ "AnyCompany Industries" ]
                  }
              }
          }
 }

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Avec DynamoDB, vous pouvez également utiliser les clés NewImage et OldImage pour filtrer les valeurs d’attributs. Supposons que vous vouliez filtrer les enregistrements où l’attribut AccountManager de la dernière image de la table est « Pat Candella » ou « Shirley Rodriguez ». L’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"dynamodb\" : { \"NewImage\" : { \"AccountManager\" : { \"S\" : [ \"Pat Candella\", \"Shirley Rodriguez\" ] } } } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "dynamodb": {
        "NewImage": {
            "AccountManager": {
                "S": [ "Pat Candella", "Shirley Rodriguez" ]
            }
        }
    }
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Vous pouvez également créer des filtres à l’aide des expressions booléennes AND. Ces expressions peuvent inclure les paramètres de clé et d’attribut de votre table. Supposons que vous souhaitiez filtrer les enregistrements dont la valeur NewImage d’AccountManager est « Pat Candella » et la valeur OldImage est « Terry Whitlock ». L’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"dynamodb\" : { \"NewImage\" : { \"AccountManager\" : { \"S\" : [ \"Pat Candella\" ] } } } , \"dynamodb\" : { \"OldImage\" : { \"AccountManager\" : { \"S\" : [ \"Terry Whitlock\" ] } } } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{ 
    "dynamodb" : { 
        "NewImage" : { 
            "AccountManager" : { 
                "S" : [ 
                    "Pat Candella" 
                ] 
            } 
        } 
    }, 
    "dynamodb": { 
        "OldImage": { 
            "AccountManager": { 
                "S": [ 
                    "Terry Whitlock" 
                ] 
            } 
        } 
    } 
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Note

Le filtrage d’événements DynamoDB ne prend pas en charge l’utilisation d’opérateurs numériques (égalité numérique et plage numérique). Même si les éléments de votre table sont stockés sous forme de nombres, ces paramètres sont convertis en chaînes dans l’objet d’enregistrement JSON.

Pour filtrer correctement les événements provenant de sources DynamoDB, le champ de données et vos critères de filtre pour le champ de données (dynamodb) doivent être au format JSON valide. Si l’un ou l’autre des champs n’est pas dans un format JSON valide, Lambda rejette le message ou lance une exception. Le tableau suivant résume le comportement spécifique :

Format des données entrantes	Pas de modèle de filtre pour les propriétés des données	Action obtenue.
JSON valide	JSON valide	Lambda filtre en fonction de vos critères de filtre.
JSON valide	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Non JSON	Lambda lance une exception au moment de la création ou de la mise à jour du mappage de sources d’événements. Le modèle de filtre des propriétés de données doit être au format JSON valide.
Non JSON	JSON valide	Lambda rejette l’enregistrement.
Non JSON	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
Non JSON	Non JSON	Lambda lance une exception au moment de la création ou de la mise à jour du mappage de sources d’événements. Le modèle de filtre des propriétés de données doit être au format JSON valide.

Filtrage avec Kinesis

Supposons qu’un producteur insère des données au format JSON dans votre flux de données Kinesis. Un exemple d’enregistrement ressemblerait à ce qui suit, avec les données JSON converties en chaîne encodée en Base64 dans le champ data.


{
    "kinesis": {
        "kinesisSchemaVersion": "1.0",
        "partitionKey": "1",
        "sequenceNumber": "49590338271490256608559692538361571095921575989136588898",
        "data": "eyJSZWNvcmROdW1iZXIiOiAiMDAwMSIsICJUaW1lU3RhbXAiOiAieXl5eS1tbS1kZFRoaDptbTpzcyIsICJSZXF1ZXN0Q29kZSI6ICJBQUFBIn0=",
        "approximateArrivalTimestamp": 1545084650.987
        },
    "eventSource": "aws:kinesis",
    "eventVersion": "1.0",
    "eventID": "shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
    "eventName": "aws:kinesis:record",
    "invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role",
    "awsRegion": "us-east-2",
    "eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream"
}

Tant que les données insérées dans le flux par le producteur sont des données JSON valides, vous pouvez utiliser le filtrage d’événements pour filtrer les enregistrements à l’aide de la clé data. Supposons qu’un producteur insère des enregistrements dans votre flux Kinesis au format JSON suivant.


{
    "record": 12345,
    "order": {
        "type": "buy",
        "stock": "ANYCO",
        "quantity": 1000
        }
}

Pour filtrer uniquement les enregistrements dont le type d’ordre est « buy », l’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"data\" : { \"order\" : { \"type\" : [ \"buy\" ] } } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "data": {
        "order": {
            "type": [ "buy" ]
            }
      }
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Pour filtrer correctement les événements provenant de sources Kinesis, le champ de données et vos critères de filtre pour le champ de données doivent être au format JSON valide. Si l’un ou l’autre des champs n’est pas dans un format JSON valide, Lambda rejette le message ou lance une exception. Le tableau suivant résume le comportement spécifique :

Format des données entrantes	Pas de modèle de filtre pour les propriétés des données	Action obtenue.
JSON valide	JSON valide	Lambda filtre en fonction de vos critères de filtre.
JSON valide	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Non JSON	Lambda lance une exception au moment de la création ou de la mise à jour du mappage de sources d’événements. Le modèle de filtre des propriétés de données doit être au format JSON valide.
Non JSON	JSON valide	Lambda rejette l’enregistrement.
Non JSON	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
Non JSON	Non JSON	Lambda lance une exception au moment de la création ou de la mise à jour du mappage de sources d’événements. Le modèle de filtre des propriétés de données doit être au format JSON valide.

Filtrage des enregistrements agrégés de Kinesis

Avec Kinesis, vous pouvez agréger plusieurs enregistrements en un seul enregistrement Kinesis Data Streams pour augmenter le débit de vos données. Lambda ne peut appliquer des critères de filtrage aux enregistrements agrégés que lorsque vous utilisez la distribution ramifiée améliorée de Kinesis. Le filtrage des enregistrements agrégés avec Kinesis standard n’est pas pris en charge. Lorsque vous utilisez la distribution ramifiée améliorée, vous configurez un consommateur Kinesis à débit dédié pour qu’il serve de déclencheur à votre fonction Lambda. Lambda filtre alors les enregistrements agrégés et ne transmet que les enregistrements qui répondent à vos critères de filtrage.

Pour en savoir plus sur l’agrégation d’enregistrements Kinesis, reportez-vous à la section Agrégation sur la page Concepts clés de Kinesis Producer Library (KPL). Pour en savoir plus sur l'utilisation de Lambda avec la fonction de ventilation améliorée de Kinesis, consultez la section Augmenter les performances de traitement des flux en temps réel grâce à la fonction de ventilation améliorée Amazon Kinesis Data Streams et à Lambda sur le blog consacré au calcul. AWS AWS

Filtrage avec Amazon MQ

Supposons que votre file d’attente de messages Amazon MQ contienne des messages au format JSON valide ou sous forme de chaînes simples. Un exemple d’enregistrement ressemblerait à ce qui suit, avec les données converties en chaîne encodée en Base64 dans le champ data.

Pour les agents Active MQ et Rabbit MQ, vous pouvez utiliser le filtrage d’événements pour filtrer les enregistrements à l’aide de la clé data. Supposons que votre file d’attente Amazon MQ contienne des messages au format JSON suivant.


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

Pour filtrer uniquement les enregistrements dont le champ timeout est supérieur à 0, l’objet FilterCriteria serait le suivant.


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

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


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

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Avec Amazon MQ, vous pouvez également filtrer les enregistrements dont le message est une chaîne simple. Supposons que vous vouliez traiter uniquement les enregistrements dont le message commence par « Result: ». L’objet FilterCriteria se présente comme suit.


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

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


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

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Les messages Amazon MQ doivent être des chaînes codées en UTF-8, soit des chaînes en texte brut, soit au format JSON. En effet, Lambda décode les tableaux d’octets Amazon MQ en UTF-8 avant d’appliquer des critères de filtre. Si vos messages utilisent un autre encodage, tel que UTF-16 ou ASCII, ou si le format du message ne correspond pas au format FilterCriteria, Lambda traite uniquement les filtres de métadonnées. Le tableau suivant résume le comportement spécifique :

Format du du message entrant	Modèle de filtre de format pour les propriétés des messages	Action obtenue.
Chaîne de texte brut	Chaîne de texte brut	Lambda filtre en fonction de vos critères de filtre.
Chaîne de texte brut	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
Chaîne de texte brut	JSON valide	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Chaîne de texte brut	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	JSON valide	Lambda filtre en fonction de vos critères de filtre.
Chaîne non codée UTF-8	JSON, chaîne de texte brut ou aucun modèle	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.

Filtrage avec Amazon MSK et Apache Kafka autogéré

Supposons qu’un producteur écrive des messages à une rubrique de votre cluster Amazon MSK ou Apache Kafka autogéré, au format JSON valide ou sous forme de chaînes simples. Un exemple d’enregistrement ressemblerait à ce qui suit, avec le message converti en chaîne encodée en Base64 dans le champ value.


{
    "mytopic-0":[
        {
            "topic":"mytopic",
            "partition":0,
            "offset":15,
            "timestamp":1545084650987,
            "timestampType":"CREATE_TIME",
            "value":"SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
            "headers":[]
        }
    ]
}

Supposons que votre producteur Apache Kafka écrive des messages dans votre rubrique au format JSON suivant.


{
    "device_ID": "AB1234",
    "session":{
        "start_time": "yyyy-mm-ddThh:mm:ss",
        "duration": 162
    }
}

Vous pouvez utiliser la clé value pour filtrer les enregistrements. Supposons que vous vouliez filtrer uniquement les enregistrements où device_ID commence par les lettres AB. L’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"value\" : { \"device_ID\" : [ { \"prefix\": \"AB\" } ] } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "value": {
        "device_ID": [ { "prefix": "AB" } ]
      }
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Avec Amazon MSK et Apache Kafka autogéré, vous pouvez également filtrer les enregistrements dont le message est une chaîne de caractères simple. Supposons que vous vouliez ignorer les messages dont la chaîne est « error ». L’objet FilterCriteria se présente comme suit.


{
    "Filters": [
        {
            "Pattern": "{ \"value\" : [ { \"anything-but\": [ \"error\" ] } ] }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "value": [
        {
        "anything-but": [ "error" ]
        }
    ]
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Les messages d’Amazon MSK et d’Apache Kafka autogéré doivent être des chaînes encodées en UTF-8, soit des chaînes simples, soit au format JSON. En effet, Lambda décode les tableaux d’octets Amazon MSK en UTF-8 avant d’appliquer des critères de filtre. Si vos messages utilisent un autre encodage, tel que UTF-16 ou ASCII, ou si le format du message ne correspond pas au format FilterCriteria, Lambda traite uniquement les filtres de métadonnées. Le tableau suivant résume le comportement spécifique :

Format du du message entrant	Modèle de filtre de format pour les propriétés des messages	Action obtenue.
Chaîne de texte brut	Chaîne de texte brut	Lambda filtre en fonction de vos critères de filtre.
Chaîne de texte brut	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
Chaîne de texte brut	JSON valide	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Chaîne de texte brut	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	JSON valide	Lambda filtre en fonction de vos critères de filtre.
Chaîne non codée UTF-8	JSON, chaîne de texte brut ou aucun modèle	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.

Filtrage avec Amazon SQS

Supposons que votre file d’attente Amazon SQS contienne des messages au format JSON suivant.


{
    "RecordNumber": 0000,
    "TimeStamp": "yyyy-mm-ddThh:mm:ss",
    "RequestCode": "AAAA"
}

Un exemple d’enregistrement pour cette file d’attente ressemblerait à ce qui suit.


{
    "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
    "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
    "body": "{\n "RecordNumber": 0000,\n "TimeStamp": "yyyy-mm-ddThh:mm:ss",\n "RequestCode": "AAAA"\n}",
    "attributes": {
        "ApproximateReceiveCount": "1",
        "SentTimestamp": "1545082649183",
        "SenderId": "AIDAIENQZJOLO23YVJ4VO",
        "ApproximateFirstReceiveTimestamp": "1545082649185"
        },
    "messageAttributes": {},
    "md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
    "eventSource": "aws:sqs",
    "eventSourceARN": "arn:aws:sqs:us-west-2:123456789012:my-queue",
    "awsRegion": "us-west-2"
}

Pour filtrer en fonction du contenu de vos messages Amazon SQS, utilisez la clé body dans l’enregistrement du message Amazon SQS. Supposons que vous vouliez traiter uniquement les enregistrements où le RequestCode de votre message Amazon SQS est « BBBB ». L’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"body\" : { \"RequestCode\" : [ \"BBBB\" ] } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "body": {
        "RequestCode": [ "BBBB" ]
        }
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Supposons que vous vouliez que votre fonction ne traite que les enregistrements où RecordNumber est supérieur à 9 999. L’objet FilterCriteria serait le suivant.


{
    "Filters": [
        {
            "Pattern": "{ \"body\" : { \"RecordNumber\" : [ { \"numeric\": [ \">\", 9999 ] } ] } }"
        }
    ]
}

Pour plus de clarté, voici la valeur du Pattern de filtre étendu en JSON simple :


{
    "body": {
        "RecordNumber": [
            {
                "numeric": [ ">", 9999 ]
            }
        ]
    }
}

Vous pouvez ajouter votre filtre à l'aide de la console AWS CLI ou d'un AWS SAM modèle.

Pour Amazon SQS, le corps du message peut être n’importe quelle chaîne. Toutefois, cela peut être problématique si votre FilterCriteria s’attend à ce que body se présente dans un format JSON valide. Le scénario inverse est également vrai, si le corps du message entrant est au format JSON, mais que votre critère de filtre s’attend à ce que body soit une chaîne de texte brut, cela peut entraîner un comportement inattendu.

Pour éviter ce problème, assurez-vous que le format du corps dans vos FilterCriteria correspond au format attendu de body dans les messages que vous recevez de votre file d’attente. Avant de filtrer vos messages, Lambda évalue automatiquement le format du corps de votre message entrant et de votre modèle de filtre pour body. En cas de décalage, Lambda abandonne le message. Le tableau suivant résume cette évaluation :

Format du `body` du message entrant	Format du `body` du modèle de filtre	Action obtenue.
Chaîne de texte brut	Chaîne de texte brut	Lambda filtre en fonction de vos critères de filtre.
Chaîne de texte brut	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
Chaîne de texte brut	JSON valide	Lambda rejette le message.
JSON valide	Chaîne de texte brut	Lambda rejette le message.
JSON valide	Pas de modèle de filtre pour les propriétés des données	Lambda filtre (uniquement selon les autres propriétés de métadonnées) en fonction de vos critères de filtre.
JSON valide	JSON valide	Lambda filtre en fonction de vos critères de filtre.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Mappage de source d’événement

États des fonctions