Grundlagen der Ereignisfilterung Umgang mit Datensätzen, die die Filterkriterien nicht erfüllen Filterregelsyntax Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (Konsole)Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS CLI)Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS SAM)Verwenden von Filtern mit unterschiedlichen AWS-Services Filtern mit DynamoDB Filtern mit Kinesis Filtern mit Amazon MQ Filtern mit Amazon MSK und selbstverwaltetem Apache Kafka Filtern mit Amazon SQS

Lambda-Ereignisfilterung

Sie können die Ereignisfilterung verwenden, um zu steuern, welche Datensätze aus einem Stream oder einer Warteschlange Lambda an Ihre Funktion sendet. Sie können zum Beispiel einen Filter hinzufügen, damit Ihre Funktion nur Amazon-SQS-Nachrichten verarbeitet, die bestimmte Datenparameter enthalten. Die Ereignisfilterung funktioniert mit der Zuordnung von Ereignisquellen. Sie können Filter zu Ereignisquellenzuordnungen für die folgenden AWS Dienste hinzufügen:

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

Lambda unterstützt keine Ereignisfilterung für Amazon DocumentDB.

Standardmäßig können Sie bis zu fünf verschiedene Filter für eine einzelne Zuordnung von Ereignisquellen definieren. Ihre Filter sind logisch via OR verknüpft. Wenn ein Datensatz aus Ihrer Ereignisquelle einen oder mehrere Ihrer Filter erfüllt, nimmt Lambda den Datensatz in das nächste Ereignis auf, das es an Ihre Funktion sendet. Wenn keiner Ihrer Filter erfüllt ist, verwirft Lambda den Datensatz.

Anmerkung

Wenn Sie mehr als fünf Filter für eine Ereignisquelle definieren müssen, können Sie eine Kontingenterhöhung auf bis zu 10 Filter für jede Ereignisquelle beantragen. Wenn Sie versuchen, mehr Filter hinzuzufügen, als Ihr aktuelles Kontingent erlaubt, wird Lambda einen Fehler zurückgeben, wenn Sie versuchen, die Ereignisquelle zu erstellen.

Themen

Grundlagen der Ereignisfilterung
Umgang mit Datensätzen, die die Filterkriterien nicht erfüllen
Filterregelsyntax
Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (Konsole)
Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS CLI)
Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS SAM)
Verwenden von Filtern mit unterschiedlichen AWS-Services
Filtern mit DynamoDB
Filtern mit Kinesis
Filtern mit Amazon MQ
Filtern mit Amazon MSK und selbstverwaltetem Apache Kafka
Filtern mit Amazon SQS

Grundlagen der Ereignisfilterung

Ein Filterkriterienobjekt (FilterCriteria) ist eine Struktur, die aus einer Liste von Filtern (Filters) besteht. Jeder Filter ist eine Struktur, die ein Ereignisfiltermuster (Pattern) definiert. Ein Muster ist eine Zeichenkette, die eine JSON-Filterregel darstellt. Die Struktur eines FilterCriteria-Objekts ist wie folgt.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Ihr Filtermuster kann Metadateneigenschaften, Dateneigenschaften oder beides enthalten. Die verfügbaren Metadatenparameter und das Format der Datenparameter variieren je nachdem, AWS-Service welche Person als Ereignisquelle fungiert. Nehmen wir zum Beispiel an, dass Ihre Zuordnung von Ereignisquellen den folgenden Datensatz von einer Amazon-SQS-Warteschlange empfängt:


{
    "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"
}

Metadateneigenschaften sind die Felder, die Informationen über das Ereignis enthalten, das den Datensatz erstellt hat. Im Beispiel für den Amazon-SQS-Datensatz umfassen die Metadateneigenschaften Felder wie messageID, eventSourceArn und awsRegion.
Dateneigenschaften sind die Felder des Datensatzes, die die Daten aus Ihrem Stream oder Ihrer Warteschlange enthalten. Im Amazon-SQS-Ereignisbeispiel ist der Schlüssel für das Datenfeld body, und die Dateneigenschaften sind die Felder City, State und Temperature.

Verschiedene Arten von Ereignisquellen verwenden unterschiedliche Schlüsselwerte für ihre Datenfelder. Um nach Dateneigenschaften zu filtern, müssen sie den richtigen Schlüssel in Ihrem Filtermuster verwenden. Eine Liste der Datenfilterschlüssel und Beispiele für Filtermuster für die einzelnen unterstützten AWS-Service Schlüssel finden Sie unterVerwenden von Filtern mit unterschiedlichen AWS-Services.

Die Ereignisfilterung kann mehrstufige JSON-Filterung verarbeiten. Betrachten Sie zum Beispiel das folgende Fragment eines Datensatzes aus einem DynamoDB-Stream:


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

Angenommen, Sie möchten nur die Datensätze verarbeiten, bei denen die Number des Sortierschlüssels 4567 ist. In diesem Fall würde Ihr FilterCriteria-Objekt wie folgt aussehen:


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Umgang mit Datensätzen, die die Filterkriterien nicht erfüllen

Die Art und Weise, wie Datensätze behandelt werden, die Ihrem Filter nicht entsprechen, hängt von der Ereignisquelle ab.

Bei Amazon SQS entfernt Lambda die Nachricht automatisch aus der Warteschlange, wenn die Nachricht Ihren Filterkriterien nicht entspricht. Sie müssen diese Nachrichten in Amazon SQS nicht manuell löschen.
Bei Kinesis und DynamoDB geht der Stream-Iterator über einen Datensatz hinaus, sobald Ihre Filterkriterien einen Datensatz verarbeiten. Wenn der Datensatz Ihre Filterkriterien nicht erfüllt, müssen Sie den Datensatz nicht manuell aus Ihrer Ereignisquelle löschen. Nach Ablauf der Aufbewahrungsfrist löschen Kinesis und DynamoDB diese alten Datensätze automatisch. Wenn Sie möchten, dass Datensätze früher gelöscht werden, lesen Sie Ändern des Zeitraums der Datenaufbewahrung.
Bei Amazon MSK-, selbstverwalteten Apache-Kafka- und Amazon MQ-Nachrichten verwirft Lambda Nachrichten, die nicht allen im Filter enthaltenen Feldern entsprechen. Bei selbstverwaltetem Apache Kafka schreibt Lambda Offsets für übereinstimmende und nicht übereinstimmende Nachrichten fest, nachdem die Funktion erfolgreich aufgerufen wurde. Bei Amazon MQ bestätigt Lambda übereinstimmende Nachrichten nach erfolgreichem Aufruf der Funktion und bestätigt nicht übereinstimmende Nachrichten beim Filtern.

Filterregelsyntax

Für Filterregeln unterstützt Lambda die EventBridge Amazon-Regeln und verwendet dieselbe Syntax wie EventBridge. Weitere Informationen finden Sie unter Amazon EventBridge Event Patterns im EventBridge Amazon-Benutzerhandbuch.

Im Folgenden finden Sie eine Zusammenfassung aller Vergleichsoperatoren, die für die Lambda-Ereignisfilterung verfügbar sind.

Vergleichsoperator	Beispiel	Regelsyntax
Null	UserID is null	"UserID": [ null ]
Leer	LastName ist leer	"LastName": [""]
Gleichheitszeichen	Name is "Alice"	"Name": [ "Alice" ]
Gleich (Groß-/Kleinschreibung ignorieren)	Name is "Alice"	„Name“: [{"equals-ignore-case„: „Alice“}]
And	Location is "New York" and Day is "Monday"	"Location": [ "New York" ], "Day": ["Monday"]
Oder	PaymentType ist „Kredit“ oder „Lastschrift“	"PaymentType„: [„Kredit“, „Lastschrift"]
Oder (mehrere Felder)	Location is "New York", or Day is "Monday".	"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]
Nicht	Weather is anything but "Raining"	"Weather": [ { "anything-but": [ "Raining" ] } ]
Numeric (equals)	Price is 100	"Price": [ { "numeric": [ "=", 100 ] } ]
Numeric (range)	Price is more than 10, and less than or equal to 20	"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]
Vorhanden	ProductName existiert	"ProductName„: [{„existiert“: wahr}]
Nicht vorhanden	ProductName existiert nicht	"ProductName„: [{„existiert“: falsch}]
Beginnt mit	Region is in the US	"Region": [ {"prefix": "us-" } ]
Endet mit	FileName endet mit der Erweiterung.png.	"FileName„: [{„Suffix“: „.png“}]

Anmerkung

Wie bei EventBridge Zeichenketten verwendet Lambda den exakten character-by-character Abgleich ohne Umschaltung der Groß- und Kleinschreibung oder eine andere Normalisierung von Zeichenketten. Bei Zahlen verwendet Lambda auch eine Zeichenfolgendarstellung. 300, 300,0 und 3,0e2 werden z. B. nicht gleich behandelt.

Beachten Sie, dass der Exists-Operator nur für Blattknoten in Ihrer JSON-Ereignisquelle funktioniert. Er entspricht nicht den Zwischenknoten. Bei der folgenden JSON-Datei { "person": { "address": [ { "exists": true } ] } }" würde das Filtermuster beispielsweise keine Übereinstimmung finden, da es sich um einen Zwischenknoten "address" handelt.


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

Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (Konsole)

Führen Sie diese Schritte aus, um eine neue Ereignisquellenzuordnung mit Filterkriterien über die Lambda-Konsole zu erstellen.

Eine neue Ereignisquellenzuordnung mit Filterkriterien erstellen (Konsole)

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
Wählen Sie den Namen einer Funktion aus, für die eine Ereignisquellenzuordnung erstellt werden soll.
Wählen Sie unter Function overview (Funktionsübersicht) die Option Add trigger (Trigger hinzufügen).
Wählen Sie bei Trigger configuration (Auslöserkonfiguration) einen Auslösertyp aus, der Ereignisfilterung unterstützt. Eine Liste der unterstützten Services finden Sie in der Liste am Anfang dieser Seite.
Erweitern Sie Additional settings (Zusätzliche Einstellungen).
Wählen Sie unter Filter criteria (Filterkriterien) die Option Add (Hinzufügen) aus und definieren Sie anschließend Ihre Filter. Sie können z. B. Folgendes eingeben.
```
{ "Metadata" : [ 1, 2 ] }
```
Damit wird Lambda angewiesen, nur Datensätze zu verarbeiten, in denen das Feld Metadata gleich 1 oder 2 ist. Sie können weiterhin Hinzufügen auswählen, um weitere Filter bis zur maximal zulässigen Anzahl hinzuzufügen.
Wenn Sie fertig mit dem Hinzufügen Ihrer Filter sind, klicken Sie auf Speichern.

Wenn Sie Filterkriterien über die Konsole eingeben, geben Sie nur das Filtermuster ein und müssen weder den Pattern-Schlüssel noch Escape-Anführungszeichen angeben. In Schritt 6 der Anweisungen oben entspricht { "Metadata" : [ 1, 2 ] } den folgenden FilterCriteria.


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

Nachdem Sie Ihre Ereignisquellenzuordnung in der Konsole erstellt haben, sehen Sie die formatierten FilterCriteria in den Auslöserdetails. Weitere Beispiele zum Erstellen von Ereignisfiltern mithilfe der -Konsole finden Sie unter Verwenden von Filtern mit unterschiedlichen AWS-Services.

Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS CLI)

Angenommen, Sie möchten, dass eine Ereignisquellenzuordnung folgende hat FilterCriteria:


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

Führen Sie den folgenden Befehl aus, um mithilfe von AWS Command Line Interface (AWS CLI) eine neue Ereignisquellenzuordnung mit diesen Filterkriterien zu erstellen.


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

Dieser create-event-source-mappingBefehl erstellt eine neue Amazon SQS SQS-Ereignisquellenzuordnung für eine Funktion my-function mit dem angegebenen FilterCriteria Wert.

Führen Sie den folgenden Befehl aus, um diese Filterkriterien zu einer vorhandenen Zuordnung von Ereignisquellen hinzuzufügen.


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

Beachten Sie, dass Sie zum Aktualisieren einer Ereignisquellenzuordnung ihre UUID benötigen. Sie können die UUID aus einem Anruf abrufen. list-event-source-mappings Lambda gibt auch die UUID in der CLI-Antwort zurück. create-event-source-mapping

Um Filterkriterien aus einer Ereignisquelle zu entfernen, können Sie den folgenden update-event-source-mappingBefehl mit einem leeren Objekt ausführen. FilterCriteria


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

Weitere Beispiele für das Erstellen von Ereignisfiltern mithilfe von finden Sie unterVerwenden von Filtern mit unterschiedlichen AWS-Services. AWS CLI

Anhängen von Filterkriterien an eine Ereignisquellenzuordnung (AWS SAM)

Angenommen, Sie möchten eine Ereignisquelle so konfigurieren AWS SAM , dass sie die folgenden Filterkriterien verwendet:


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

Um diese Filterkriterien zu Ihrer Zuordnung von Ereignisquellen hinzuzufügen, fügen Sie das folgende Snippet in die YAML-Vorlage für Ihre Ereignisquelle ein.


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

Weitere Informationen zum Erstellen und Konfigurieren einer AWS SAM Vorlage für eine Ereignisquellenzuordnung finden Sie im EventSourceAbschnitt des AWS SAM Entwicklerhandbuchs. Weitere Beispiele für die Erstellung von Ereignisfiltern mithilfe von AWS SAM Vorlagen finden Sie unterVerwenden von Filtern mit unterschiedlichen AWS-Services.

Verwenden von Filtern mit unterschiedlichen AWS-Services

Verschiedene Arten von Ereignisquellen verwenden unterschiedliche Schlüsselwerte für ihre Datenfelder. Um nach Dateneigenschaften zu filtern, müssen sie den richtigen Schlüssel in Ihrem Filtermuster verwenden. In der folgenden Tabelle sind die Filterschlüssel für jeden unterstützten Schlüssel aufgeführt AWS-Service.

AWS-Service	Filterschlüssel
DynamoDB	`dynamodb`
Kinesis	`data`
Amazon MQ	`data`
Amazon MSK	`value`
Selbstverwaltetes Apache Kafka	`value`
Amazon SQS	`body`

In den folgenden Abschnitten finden Sie Beispiele für Filtermuster für verschiedene Arten von Ereignisquellen. Sie enthalten auch Definitionen der unterstützten Formate für eingehende Daten und Filtermuster für jeden unterstützten Service.

Filtern mit DynamoDB

Angenommen, Sie haben eine DynamoDB-Tabelle mit dem Primärschlüssel CustomerName und den Attributen AccountManager und PaymentTerms. Im Folgenden sehen Sie einen Beispieldatensatz aus dem Stream Ihrer DynamoDB-Tabelle.


{
      "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"
          }
      }
  }

Um anhand der Schlüssel- und Attributwerte in Ihrer DynamoDB-Tabelle zu filtern, verwenden Sie den dynamodb-Schlüssel im Datensatz. Die folgenden Abschnitte enthalten Beispiele für verschiedene Filtertypen.

Filtern mit Tabellenschlüsseln

Angenommen, Sie möchten, dass Ihre Funktion nur die Datensätze verarbeitet, bei denen der Primärschlüssel „AnyCompany Branchen“ CustomerName lautet. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer AWS SAM Vorlage hinzufügen.

Filtern mit Tabellenattributen

Mit DynamoDB können Sie auch die Schlüssel NewImage und OldImage verwenden, um nach Attributwerten zu filtern. Angenommen, Sie möchten Datensätze filtern, bei denen das AccountManager-Attribut im letzten Tabellenbild "Pat Candella" oder "Shirley Rodriguez" lautet. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer AWS SAM Vorlage hinzufügen.

Filtern mit booleschen Ausdrücken

Sie können Filter auch mithilfe von booleschen UND-Ausdrücken erstellen. Diese Ausdrücke können sowohl die Schlüssel- als auch die Attributparameter Ihrer Tabelle enthalten. Angenommen, Sie möchten Datensätze filtern, bei denen der NewImage-Wert von AccountManager „Pat Candella“ und der OldImage-Wert „Terry Whitlock“ ist. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer AWS SAM Vorlage hinzufügen.

Anmerkung

Die DynamoDB-Ereignisfilterung unterstützt nicht die Verwendung von numerischen Operatoren (numerisch gleich und numerisch Bereich). Auch wenn Elemente in Ihrer Tabelle als Zahlen gespeichert sind, werden diese Parameter im JSON-Datensatzobjekt in Strings umgewandelt.

Verwenden des Exists-Operators mit DynamoDB

Aufgrund der Art und Weise, wie JSON-Ereignisobjekte von DynamoDB strukturiert sind, erfordert die Verwendung des Exists-Operators besondere Vorsicht. Der Exists-Operator funktioniert nur für Blattknoten im Event-JSON. Wenn Ihr Filtermuster also Exists verwendet, um nach einem Zwischenknoten zu testen, funktioniert er nicht. Betrachten Sie das folgende DynamoDB-Tabellenelement:


{
  "UserID": {"S": "12345"},
  "Name": {"S": "John Doe"},
  "Organizations": {"L": [
      {"S":"Sales"},
      {"S":"Marketing"},
      {"S":"Support"}
    ]
  }
}

Möglicherweise möchten Sie ein Filtermuster wie das folgende erstellen, das auf Ereignisse prüft, die Folgendes enthalten: "Organizations"


{ "dynamodb" : { "NewImage" : { "Organizations" : [ { "exists": true } ] } } }

Dieses Filtermuster würde jedoch niemals eine Übereinstimmung zurückgeben, da "Organizations" es sich nicht um einen Blattknoten handelt. Das folgende Beispiel zeigt, wie der Exists-Operator richtig verwendet wird, um das gewünschte Filtermuster zu erstellen:


{ "dynamodb" : { "NewImage" : {"Organizations": {"L": {"S": [ {"exists": true } ] } } } } }

JSON-Format für DynamoDB-Filterung

Um Ereignisse aus DynamoDB-Quellen richtig zu filtern, müssen sowohl das Datenfeld als auch Ihre Filterkriterien für das Datenfeld (dynamodb) im gültigen JSON-Format vorliegen. Wenn eines der Felder kein gültiges JSON-Format hat, verwirft Lambda die Nachricht oder gibt eine Ausnahme aus. In der folgenden Tabelle ist das Verhalten zusammengefasst:

Format der eingehenden Daten	Filtermusterformat für Dateneigenschaften	Resultierende Aktion
Gültiges JSON	Gültiges JSON	Lambda filtert basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein JSON	Lambda gibt zum Zeitpunkt der Erstellung oder Aktualisierung der Ereignisquellenzuordnung eine Ausnahme aus. Das Filtermuster für Dateneigenschaften muss ein gültiges JSON-Format haben.
Kein JSON	Gültiges JSON	Lambda verwirft den Datensatz.
Kein JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Kein JSON	Kein JSON	Lambda gibt zum Zeitpunkt der Erstellung oder Aktualisierung der Ereignisquellenzuordnung eine Ausnahme aus. Das Filtermuster für Dateneigenschaften muss ein gültiges JSON-Format haben.

Filtern mit Kinesis

Angenommen, ein Producer gibt JSON-formatierte Daten in Ihren Kinesis-Datenstrom ein. Ein Beispieldatensatz würde wie folgt aussehen, wobei die JSON-Daten im data-Feld in eine Base64-kodierte Zeichenfolge umgewandelt wurden.


{
    "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"
}

Solange die Daten, die der Producer in den Stream einspeist, als JSON gültig sind, können Sie die Ereignisfilterung verwenden, um Datensätze anhand des data-Schlüssels zu filtern. Nehmen wir an, ein Produzent gibt Datensätze im folgenden JSON-Format in Ihren Kinesis-Stream ein.


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

Um nur die Datensätze zu filtern, bei denen der Auftragstyp "Kaufen" ist, würde das FilterCriteria-Objekt wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer AWS SAM Vorlage hinzufügen.

Um Ereignisse aus Kinesis-Quellen ordnungsgemäß zu filtern, müssen sowohl das Datenfeld als auch die Filterkriterien für das Datenfeld ein gültiges JSON-Format aufweisen. Wenn eines der Felder kein gültiges JSON-Format hat, verwirft Lambda die Nachricht oder gibt eine Ausnahme aus. In der folgenden Tabelle ist das Verhalten zusammengefasst:

Format der eingehenden Daten	Filtermusterformat für Dateneigenschaften	Resultierende Aktion
Gültiges JSON	Gültiges JSON	Lambda filtert basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein JSON	Lambda gibt zum Zeitpunkt der Erstellung oder Aktualisierung der Ereignisquellenzuordnung eine Ausnahme aus. Das Filtermuster für Dateneigenschaften muss ein gültiges JSON-Format haben.
Kein JSON	Gültiges JSON	Lambda verwirft den Datensatz.
Kein JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Kein JSON	Kein JSON	Lambda gibt zum Zeitpunkt der Erstellung oder Aktualisierung der Ereignisquellenzuordnung eine Ausnahme aus. Das Filtermuster für Dateneigenschaften muss ein gültiges JSON-Format haben.

Filtern von aggregierten Kinesis-Datensätzen

Mit Kinesis können Sie mehrere Datensätze in einem einzigen Kinesis-Datenstrom-Datensatz zusammenfassen, um Ihren Datendurchsatz zu erhöhen. Lambda kann Filterkriterien nur auf aggregierte Datensätze anwenden, wenn Sie Kinesis Enhanced Fanout verwenden. Das Filtern aggregierter Datensätze mit Standard-Kinesis wird nicht unterstützt. Bei der Verwendung von Enhanced Fan-Out konfigurieren Sie einen dedizierten Kinesis-Durchsatzverbraucher, der als Auslöser für Ihre Lambda-Funktion dient. Lambda filtert dann die aggregierten Datensätze und übergibt nur die Datensätze, die Ihren Filterkriterien entsprechen.

Weitere Informationen zur Aggregation von Kinesis-Datensätzen finden Sie im Abschnitt Aggregation auf der Seite mit den wichtigsten Konzepten der Kinesis Producer Library (KPL). Weitere Informationen zur Verwendung von Lambda mit Kinesis Enhanced Fan-Out finden Sie im Compute-Blog unter Steigerung der Echtzeit-Stream-Verarbeitungsleistung mit Amazon Kinesis Data Streams Enhanced Fan-Out und AWS Lambda. AWS

Filtern mit Amazon MQ

Angenommen, Ihre Amazon-MQ-Nachrichtenwarteschlange enthält Nachrichten entweder im gültigen JSON-Format oder als einfache Zeichenfolgen. Ein Beispieldatensatz würde wie folgt aussehen, wobei die Daten im data-Feld in eine Base64-kodierte Zeichenfolge umgewandelt wurden.

Sowohl für Active MQ- als auch für Rabbit MQ-Broker können Sie die Ereignisfilterung verwenden, um Datensätze anhand des data-Schlüssels zu filtern. Angenommen, Ihre Amazon-MQ-Warteschlange enthält Nachrichten im folgenden JSON-Format.


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

Um nur die Datensätze zu filtern, bei denen das timeout-Feld größer als 0 ist, würde das FilterCriteria-Objekt wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole oder einer Vorlage hinzufügen. AWS CLI AWS SAM

Mit Amazon MQ können Sie auch Datensätze filtern, bei denen die Nachricht eine einfache Zeichenfolge ist. Angenommen, Sie möchten nur Datensätze verarbeiten, bei denen die Meldung mit „Ergebnis:“ beginnt. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer Vorlage hinzufügen. AWS SAM

Amazon-MQ-Nachrichten müssen UTF-8-kodierte Zeichenfolgen sein (entweder einfache Zeichenfolgen oder im JSON-Format). Das liegt daran, dass Lambda Byte-Arrays von Amazon MQ vor Anwendung der Filterkriterien in UTF-8 dekodiert. Wenn Ihre Nachrichten eine andere Kodierung nutzen, z. B. UTF-16 oder ASCII, oder das Nachrichtenformat nicht dem FilterCriteria-Format entspricht, verarbeitet Lambda nur Metadatenfilter. In der folgenden Tabelle ist das Verhalten zusammengefasst:

-Format der eingehenden Nachricht	Filtermusterformat für Nachrichteneigenschaften	Resultierende Aktion
Einfache Zeichenfolge	Einfache Zeichenfolge	Lambda filtert basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Gültiges JSON	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Einfache Zeichenfolge	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Gültiges JSON	Lambda filtert basierend auf Ihren Filterkriterien.
Nicht UTF-8-kodierte Zeichenfolge	JSON, einfache Zeichenfolge oder kein Muster	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.

Filtern mit Amazon MSK und selbstverwaltetem Apache Kafka

Angenommen, ein Producer schreibt Nachrichten zu einem Thema in Ihrem Amazon MSK- oder selbstverwalteten Apache-Kafka-Cluster, entweder im gültigen JSON-Format oder als einfache Zeichenketten. Ein Beispieldatensatz würde wie folgt aussehen, wobei die Nachricht im value-Feld in eine Base64-kodierte Zeichenfolge umgewandelt wurde.


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

Angenommen, Ihr Apache-Kafka-Producer schreibt Nachrichten zu Ihrem Thema im folgenden JSON-Format.


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

Sie können den value-Schlüssel verwenden, um Datensätze zu filtern. Angenommen, Sie möchten nur die Datensätze filtern, bei denen device_ID mit den Buchstaben AB beginnen. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer Vorlage hinzufügen. AWS SAM

Mit Amazon MQ und selbstverwaltetem Apache Kafka können Sie auch Datensätze filtern, bei denen die Nachricht eine einfache Zeichenfolge ist. Angenommen, Sie möchten die Meldungen ignorieren, in denen die Zeichenfolge „error“ ist. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer Vorlage hinzufügen. AWS SAM

Amazon MSK- und selbstverwaltete Apache-Kafka-Nachrichten müssen UTF-8-kodierte Strings sein, entweder einfache Strings oder im JSON-Format. Das liegt daran, dass Lambda Byte-Arrays von Amazon MSK vor Anwendung der Filterkriterien in UTF-8 dekodiert. Wenn Ihre Nachrichten eine andere Kodierung nutzen, z. B. UTF-16 oder ASCII, oder das Nachrichtenformat nicht dem FilterCriteria-Format entspricht, verarbeitet Lambda nur Metadatenfilter. In der folgenden Tabelle ist das Verhalten zusammengefasst:

-Format der eingehenden Nachricht	Filtermusterformat für Nachrichteneigenschaften	Resultierende Aktion
Einfache Zeichenfolge	Einfache Zeichenfolge	Lambda filtert basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Gültiges JSON	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Einfache Zeichenfolge	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Gültiges JSON	Lambda filtert basierend auf Ihren Filterkriterien.
Nicht UTF-8-kodierte Zeichenfolge	JSON, einfache Zeichenfolge oder kein Muster	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.

Filtern mit Amazon SQS

Angenommen, Ihre Amazon-SQS-Warteschlange enthält Nachrichten im folgenden JSON-Format.


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

Ein Beispieldatensatz für diese Warteschlange würde wie folgt aussehen.


{
    "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"
}

Um anhand des Inhalts Ihrer Amazon-SQS-Nachrichten zu filtern, verwenden Sie den body-Schlüssel im Amazon-SQS-Nachrichtendatensatz. Angenommen, Sie möchten nur die Datensätze verarbeiten, bei denen RequestCode in Ihrer Amazon-SQS-Nachricht „BBBB“ ist. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer Vorlage hinzufügen. AWS SAM

Angenommen, Sie möchten, dass Ihre Funktion nur die Datensätze verarbeitet, bei denen RecordNumber größer als 9999 ist. Das FilterCriteria-Objekt würde wie folgt aussehen.


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

Zur Verdeutlichung sehen Sie hier den Wert des Filter-Pattern in reinem JSON.


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

Sie können Ihren Filter mithilfe der Konsole AWS CLI oder einer Vorlage hinzufügen. AWS SAM

Für Amazon SQS kann der Nachrichtenkörper eine beliebige Zeichenfolge sein. Dies kann jedoch problematisch sein, wenn die FilterCriteria erwarten, dass body ein gültiges JSON-Format hat. Umgekehrt gilt dasselbe – wenn der Textkörper der eingehenden Nachricht ein JSON-Format aufweist, die Filterkriterien jedoch erwarten, dass body eine einfache Zeichenfolge ist, kann dies zu unbeabsichtigtem Verhalten führen.

Um dieses Problem zu vermeiden, stellen Sie sicher, dass das Körperformat in Ihren FilterCriteria mit dem erwarteten Format von body in den Nachrichten übereinstimmt, die Sie von Ihrer Warteschlange erhalten. Bevor Sie Ihre Nachrichten filtern, wertet Lambda automatisch das Format des Körpers der eingehenden Nachricht und Ihres Filtermusters für body aus. Wenn es keine Übereinstimmung gibt, verwirft Lambda die Nachricht. In der folgenden Tabelle ist diese Auswertung zusammengefasst:

`body`-Format der eingehenden Nachricht	`body`-Format des Filtermusters	Resultierende Aktion
Einfache Zeichenfolge	Einfache Zeichenfolge	Lambda filtert basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Einfache Zeichenfolge	Gültiges JSON	Lambda verwirft die Nachricht.
Gültiges JSON	Einfache Zeichenfolge	Lambda verwirft die Nachricht.
Gültiges JSON	Kein Filtermuster für Dateneigenschaften	Lambda filtert (nur für die anderen Metadateneigenschaften) basierend auf Ihren Filterkriterien.
Gültiges JSON	Gültiges JSON	Lambda filtert basierend auf Ihren Filterkriterien.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Tutorial

Testen in der Konsole