

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Vergleichsoperatoren zur Verwendung in Ereignismustern in Amazon EventBridge
<a name="eb-create-pattern-operators"></a>

Nachfolgend finden Sie eine Zusammenfassung aller Vergleichsoperatoren, die in EventBridge verfügbar sind. 

Vergleichsoperatoren funktionieren nur in Blattknoten, mit Ausnahme von `$or` und `anything-but`. 


| **Vergleich** | **Beispiel** | **Regelsyntax** | **Unterstützung für Event-Busse** | **Stütze für Rohre** | 
| --- | --- | --- | --- | --- | 
|  Bedingung 2  |  Location is "New York" and Day is "Monday"  |  `"Location": [ "New York" ], "Day": ["Monday"]`  |  Ja  |  Ja  | 
| [Alles außer](#eb-filtering-anything-but) | State ist ein beliebiger Wert außer „initialisieren“. | `"state": [ { "anything-but": "initializing" } ]` |  Ja  |  Ja  | 
| [Alles andere als (beginnt mit)](#eb-filtering-anything-but-prefix) | Die Region liegt nicht in den USA. |  `"Region": [ { "anything-but": {"prefix": "us-" } } ]`  |  Ja  |  Nein  | 
| [Alles andere als (endet mit)](#eb-filtering-anything-but-suffix) | FileName endet nicht mit der Erweiterung.png. |  `"FileName": [ { "anything-but": { "suffix": ".png" } } ]`  |  Ja  |  Nein  | 
| [Alles außer (Groß- und Kleinschreibung ignorieren)](#eb-filtering-anything-but-ignore-case) | State ist ein beliebiger Wert außer „initialisieren“ oder einer anderen Variante der Groß-/Kleinschreibung, z. B. „INITIALIZING“. | `"state": : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}` |  Ja  |  Nein  | 
| [Alles, nur nicht die Verwendung eines Platzhalters](#eb-filtering-anything-but-wildcard) | FileName ist kein Dateipfad, der Folgendes beinhaltet. `/lib/` |  `"FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]`  |  Ja  |  Nein  | 
|  [Beginnt mit](#eb-filtering-prefix-matching)  |  Die Region befindet sich in den USA.  |  `"Region": [ {"prefix": "us-" } ]`  |  Ja  |  Ja  | 
| Beginnt mit (Groß- und Kleinschreibung ignorieren) | Der Dienstname beginnt mit den Buchstaben „eventb“, unabhängig von der Groß- und Kleinschreibung. | `{"service" : [{ "prefix": { "equals-ignore-case": "eventb" }}]}` |  Ja  |  Ja  | 
|  [Leer](eb-event-patterns-null-values.md)  |  LastName ist leer.  |  `"LastName": [""]`  |  Ja  |  Ja  | 
|  Gleich  |  Name is "Alice"  |  `"Name": [ "Alice" ]`  |  Ja  |  Ja  | 
|  [Gleich (Groß-/Kleinschreibung ignorieren)](#eb-filtering-equals-ignore-case-matching)  |  Name is "Alice"  |  `"Name": [ { "equals-ignore-case": "alice" } ]`  |  Ja  |  Ja  | 
|  [Endet mit](#eb-filtering-suffix-matching)  |  FileName endet mit der Erweiterung.png  |  `"FileName": [ { "suffix": ".png" } ]`  |  Ja  |  Ja  | 
| Endet mit (Groß- und Kleinschreibung ignorieren) | Der Dienstname endet mit den Buchstaben „tbridge“ oder einer anderen Variante der Groß-/Kleinschreibung, z. B. „TBRIDGE“. | `{"service" : [{ "suffix": { "equals-ignore-case": "tBridge" }}]}` |  Ja  |  Ja  | 
|  [Vorhanden](#eb-filtering-exists-matching)  |  ProductName existiert  |  `"ProductName": [ { "exists": true } ]`  |  Ja  |  Ja  | 
|  [Nicht vorhanden](#eb-filtering-exists-matching)  |  ProductName existiert nicht  |  `"ProductName": [ { "exists": false } ]`  |  Ja  |  Ja  | 
|  [Nicht](#eb-filtering-anything-but)  |  Weather is anything but "Raining"  |  `"Weather": [ { "anything-but": [ "Raining" ] } ]`  |  Ja  |  Ja  | 
|  [Null](eb-event-patterns-null-values.md)  |  UserID is null  |  `"UserID": [ null ]`  |  Ja  |  Ja  | 
|  [Numerisch (ist gleich)](#filtering-numeric-matching)  |  Price is 100  |  `"Price": [ { "numeric": [ "=", 100 ] } ]`  |  Ja  |  Ja  | 
|  [Numerisch (Bereich)](#filtering-numeric-matching)  |  Price is more than 10, and less than or equal to 20  |  `"Price": [ { "numeric": [ ">", 10, "<=", 20 ] } ]`  |  Ja  |  Ja  | 
|  Oder  |  PaymentType ist „Kredit“ oder „Lastschrift“  |  `"PaymentType": [ "Credit", "Debit"]`  |  Ja  |  Ja  | 
|  [Oder (mehrere Felder)](#eb-filtering-complex-example-or)  |  Location is "New York", or Day is "Monday".  |  `"$or": [ { "Location": [ "New York" ] }, { "Day": [ "Monday" ] } ]`  |  Ja  |  Ja  | 
|  [Platzhalter](#eb-filtering-wildcard-matching)  |  Jede Datei mit der Erweiterung .png, die sich im Ordner „dir“ befindet  |  `"FileName": [ { "wildcard": "dir/*.png" } ] `  |  Ja  |  Nein  | 

## Übereinstimmung mit einem Präfix
<a name="eb-filtering-prefix-matching"></a>

Sie können ein Ereignis abhängig vom Präfix eines Werts in der Ereignisquelle abgleichen. Sie können den Präfix-Abgleich für Zeichenfolgenwerte verwenden.

Beispielsweise würde das folgende Ereignismuster mit jedem Ereignis übereinstimmen, bei dem das Feld `"time"` mit `"2017-10-02"` wie `"time": "2017-10-02T18:43:48Z"` beginnt. 

```
{
  "time": [ { "prefix": "2017-10-02" } ]
}
```

### Präfixabgleich ohne Berücksichtigung der Groß- und Kleinschreibung
<a name="eb-filtering-prefix-matching-ignore-case"></a>

Sie können einen Präfixwert auch unabhängig von der Groß- und Kleinschreibung der Zeichen abgleichen, mit denen ein Wert beginnt, und zwar `equals-ignore-case` in Verbindung mit `prefix.`

Das folgende Ereignismuster würde beispielsweise auf jedes Ereignis zutreffen, bei dem das `service` Feld mit der Zeichenfolge begann`EventB`, aber auch `EVENTB` auf jede andere Groß-/Kleinschreibung dieser Zeichen. `eventb`

```
{
  "detail": {"service" : [{ "prefix": { "equals-ignore-case": "EventB" }}]}
}
```

## Suffix-Abgleich
<a name="eb-filtering-suffix-matching"></a>

Sie können ein Ereignis abhängig vom Suffix eines Werts in der Ereignisquelle abgleichen. Sie können den Suffix-Abgleich für Zeichenfolgenwerte verwenden.

Beispielsweise würde das folgende Ereignismuster mit jedem Ereignis übereinstimmen, bei dem das Feld `"FileName"` mit der Dateierweiterung `.png` endet. 

```
{
  "FileName": [ { "suffix": ".png" } ]
}
```

### Suffixabgleich ohne Berücksichtigung der Groß- und Kleinschreibung
<a name="eb-filtering-suffix-matching-ignore-case"></a>

Sie können einen Suffixwert auch unabhängig von der Groß- und Kleinschreibung der Zeichen, mit denen ein Wert endet, abgleichen, indem Sie ihn in Verbindung mit verwenden `equals-ignore-case` `suffix.`

Das folgende Ereignismuster würde beispielsweise jedem Ereignis entsprechen, bei dem das `FileName` Feld mit der Zeichenfolge endet`.png`, aber auch `.PNG` mit jeder anderen Groß-/Kleinschreibung dieser Zeichen.

```
{
  "detail": {"FileName" : [{ "suffix": { "equals-ignore-case": ".png" }}]}
}
```

## „Alles außer“-Abgleich
<a name="eb-filtering-anything-but"></a>

*Alles andere als übereinstimmend entspricht allem,* außer dem, was in der Regel angegeben ist. 

Sie können den „Alles andere als“-Abgleich mit Zeichenfolgen und numerischen Werten verwenden, einschließlich Listen, die nur Zeichenfolgen oder nur Zahlen enthalten.

Im Folgenden Ereignismuster ist ein „Alles andere als“-Abgleich mit Zeichenfolgen und Zahlen dargestellt.

```
{
  "detail": {
    "state": [ { "anything-but": "initializing" } ]
  }
}

{
  "detail": {
    "x-limit": [ { "anything-but": 123 } ]
  }
}
```

Im Folgenden Ereignismuster ist ein „Alles andere als“-Abgleich mit einer Liste von Zeichenfolgen dargestellt.

```
{
  "detail": {
    "state": [ { "anything-but": [ "stopped", "overloaded" ] } ]
  }
}
```

Im Folgenden Ereignismuster ist ein „Alles andere als“-Abgleich mit einer Liste von Zahlen dargestellt.

```
{
  "detail": {
    "x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
  }
}
```

### Alles andere als übereinstimmend, wobei die Groß- und Kleinschreibung ignoriert wird
<a name="eb-filtering-anything-but-ignore-case"></a>

Sie können es auch zusammen mit verwenden `equals-ignore-case``anything-but`, um Zeichenkettenwerte unabhängig von der Groß- und Kleinschreibung abzugleichen.

Das folgende Ereignismuster entspricht `state` Feldern, die nicht die Zeichenfolge „initializing“, „INITIALIZING“, „Initializing“ oder eine andere Groß- und Kleinschreibung dieser Zeichen enthalten. 

```
{
  "detail": {"state" : [{ "anything-but": { "equals-ignore-case": "initializing" }}]}
}
```

Sie können es auch `equals-ignore-case` in Verbindung mit verwenden`anything-but`, um einen Vergleich mit einer Werteliste vorzunehmen:

```
{
  "detail": {"state" : [{ "anything-but": { "equals-ignore-case": ["initializing", "stopped"] }}]}
}
```

### Alles andere als übereinstimmende Präfixe
<a name="eb-filtering-anything-but-prefix"></a>

Sie können es `prefix` in Verbindung mit verwenden`anything-but`, um Zeichenkettenwerte abzugleichen, die nicht mit dem angegebenen Wert beginnen. Dazu gehören Einzelwerte oder eine Liste von Werten.

Das folgende Ereignismuster zeigt alles andere als eine Übereinstimmung, die mit jedem Ereignis übereinstimmt, für das das Präfix nicht `"init"` im Feld steht. `"state"`

```
{
  "detail": {
    "state": [ { "anything-but": { "prefix": "init" } } ]
  }
}
```

Das folgende Ereignismuster zeigt, dass alles andere als eine Übereinstimmung mit einer Liste von Präfixwerten verwendet wird. Dieses Ereignismuster entspricht jedem Ereignis, das weder das Präfix noch das Feld `"init"` enthält. `"stop"` `"state"`

```
{
"detail": {
  "state" : [{ "anything-but": { "prefix": ["init", "stop"] } } ] }
  }
}
```

### Alles andere als übereinstimmende Suffixe
<a name="eb-filtering-anything-but-suffix"></a>

Sie können es `suffix` in Verbindung mit verwenden`anything-but`, um Zeichenkettenwerte abzugleichen, die nicht mit dem angegebenen Wert enden. Dazu gehören Einzelwerte oder eine Liste von Werten.

Das folgende Ereignismuster entspricht allen Werten für das `FileName` Feld, die nicht mit enden`.txt`.

```
{
  "detail": {
    "FileName": [ { "anything-but": { "suffix": ".txt" } } ]
  }
}
```

Das folgende Ereignismuster zeigt, dass alles andere als eine Übereinstimmung mit einer Liste von Suffixwerten verwendet wird. Dieses Ereignismuster entspricht allen Werten für das `FileName` Feld, die nicht mit einem oder enden. `.txt` `.rtf`

```
{
  "detail": {
    "FileName": [ { "anything-but": { "suffix": [".txt", ".rtf"] } } ]
  }
}
```

### Alles andere als ein Abgleich mithilfe von Platzhaltern
<a name="eb-filtering-anything-but-wildcard"></a>

Sie können das Platzhalterzeichen (\$1) in den von Ihnen angegebenen Werten für alles andere als für einen Abgleich verwenden. Dazu gehören Einzelwerte oder eine Liste von Werten.

Das folgende Ereignismuster entspricht allen Werten für das `FileName` Feld, die nicht enthalten`/lib/`.

```
{
"detail": {
  "FilePath" : [{ "anything-but": { "wildcard": "*/lib/*" }}]
  }
}
```

Das folgende Ereignismuster zeigt alles andere als übereinstimmende Werte mit einer Liste von Werten, einschließlich Platzhaltern. Dieses Ereignismuster entspricht allen Werten für das `FileName` Feld, die weder oder enthalten. `/lib/` `/bin/`

```
{
"detail": {
  "FilePath" : [{ "anything-but": { "wildcard": ["*/lib/*", "*/bin/*"] }}]
  }
}
```

Weitere Informationen finden Sie unter [Abgleich mithilfe von Platzhaltern](#eb-filtering-wildcard-matching).

## Numerischer Abgleich
<a name="filtering-numeric-matching"></a>

Der numerische Abgleich funktioniert mit Werten, bei denen es sich um JSON-Zahlen handelt. Sie ist beschränkt auf Werte von -5.0e9 bis einschließlich \$15.0e9, auf 15 Stellen genau oder sechs Stellen rechts vom Dezimalzeichen.

Im Folgenden wird der numerische Abgleich für ein Ereignismuster gezeigt, das nur Ereignissen entspricht, die für alle Felder zutreffend sind. 

```
{
  "detail": {
    "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
    "d-count": [ { "numeric": [ "<", 10 ] } ],
    "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ]
  }
}
```

## Abgleich von IP-Adressen
<a name="eb-filtering-ip-matching"></a>

Sie können den IP-Adressabgleich für IPv4 und IPv6 Adressen verwenden. Das folgende Ereignismuster zeigt den Abgleich der IP-Adressen, die mit 10.0.0 beginnen und mit einer Zahl zwischen 0 und 255 enden.

```
{
  "detail": {
    "sourceIPAddress": [ { "cidr": "10.0.0.0/24" } ]
  }
}
```

## „Vorhanden“-Abgleich
<a name="eb-filtering-exists-matching"></a>

Bei dem *„Vorhanden“*-Abgleich kommt es auf das Vorhandensein oder Fehlen eines Feldes in den JSON-Daten des Ereignisses an.

Der „Vorhanden“-Abgleich funktioniert nur auf Blattknoten. Auf Zwischenknoten funktioniert sie nicht.

Das folgende Ereignismuster entspricht jedem Ereignis, das über ein `detail.state`-Feld verfügt.

```
{
  "detail": {
    "state": [ { "exists": true  } ]
  }
}
```

Das vorhergehende Ereignismuster stimmt mit dem folgenden Ereignis überein.

```
{
  "version": "0",
  "id": "7bf73129-1428-4cd3-a780-95db273d1602",
  "detail-type": "EC2 Instance State-change Notification",
  "source": "aws.ec2",
  "account": "123456789012",
  "time": "2015-11-11T21:29:54Z",
  "region": "us-east-1",
  "resources": ["arn:aws:ec2:us-east-1:123456789012:instance/i-abcd1111"],
  "detail": {
    "instance-id": "i-abcd1111",
    "state": "pending"
  }
}
```

Das vorhergehende Ereignismuster stimmt NICHT mit dem folgenden Ereignis überein, da es kein `detail.state`-Feld hat.

```
{
  "detail-type": [ "EC2 Instance State-change Notification" ],
  "resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
  "detail": {
    "c-count" : {
       "c1" : 100
    }
  }
}
```

## Equals-ignore-case übereinstimmend
<a name="eb-filtering-equals-ignore-case-matching"></a>

Der *quals-ignore-caseE-Abgleich* funktioniert bei Zeichenkettenwerten unabhängig von der Groß- und Kleinschreibung.

Das folgende Ereignismuster entspricht jedem Ereignis, dessen `detail-type`-Feld der angegebenen Zeichenfolge entspricht, unabhängig von der Groß- und Kleinschreibung.

```
{
  "detail-type": [ { "equals-ignore-case": "ec2 instance state-change notification" } ]
}
```

Das vorhergehende Ereignismuster stimmt mit dem folgenden Ereignis überein.

```
{
  "detail-type": [ "EC2 Instance State-change Notification" ],
  "resources": [ "arn:aws:ec2:us-east-1:123456789012:instance/i-02ebd4584a2ebd341" ],
  "detail": {
    "c-count" : {
       "c1" : 100
    }
  }
}
```

## Abgleich mithilfe von Platzhaltern
<a name="eb-filtering-wildcard-matching"></a>

Sie können das Platzhalterzeichen (\$1) verwenden, um Zeichenfolgenwerte in Ereignismustern abzugleichen.

**Anmerkung**  
Derzeit wird das Platzhalterzeichen nur in Event-Bus-Regeln unterstützt.

Überlegungen zur Verwendung von Platzhaltern in Ihren Ereignismustern:
+ Sie können eine beliebige Anzahl von Platzhalterzeichen in einem bestimmten Zeichenfolgenwert angeben. Aufeinanderfolgende Platzhalterzeichen werden jedoch nicht unterstützt.
+ EventBridge unterstützt die Verwendung des Backslash-Zeichens (\$1) zur Angabe der Literalzeichen \$1 und\$1 in Platzhalterfiltern:
  + Die Zeichenfolge `\*` steht für das Literalzeichen \$1
  + Die Zeichenfolge `\\` steht für das Literalzeichen \$1

  Die Verwendung des umgekehrten Schrägstrichs, um andere Zeichen durch ein Escape-Zeichen zu schützen, wird nicht unterstützt.

### Platzhalter und Komplexität von Ereignismustern
<a name="eb-filtering-wildcard-matching-complexity"></a>

Es gibt eine Grenze, wie komplex eine Regel sein kann, die Platzhalter verwendet. Wenn eine Regel zu komplex ist, wird `InvalidEventPatternException` beim Versuch, die Regel zu erstellen, ein EventBridge zurückgegeben. Wenn Ihre Regel einen solchen Fehler generiert, sollten Sie die folgenden Anleitungen verwenden, um die Komplexität des Ereignismusters zu reduzieren:
+ **Reduzieren der Anzahl der verwendeten Platzhalterzeichen**

  Verwenden Sie Platzhalterzeichen nur dann, wenn Sie tatsächlich einen Abgleich mit mehreren möglichen Werten durchführen müssen. Stellen Sie sich zum Beispiel das folgende Ereignismuster vor, bei dem Sie einen Abgleich mit Event Buses in derselben Region durchführen möchten:

  ```
  {
  "EventBusArn": [ { "wildcard": "*:*:*:*:*:event-bus/*" } ]
  }
  ```

  Im obigen Fall hängen viele Abschnitte des ARN direkt von der Region ab, in der sich Ihre Event Buses befinden. Wenn Sie also die Region `us-east-1` verwenden, könnte das folgende Beispiel ein weniger komplexes Muster sein, das immer noch den gewünschten Werten entspricht:

  ```
  {
  "EventBusArn": [ { "wildcard": "arn:aws:events:us-east-1:*:event-bus/*" } ]
  }
  ```
+ **Reduzieren sich wiederholender Zeichenfolgen, die nach einem Platzhalterzeichen vorkommen**

  Wenn dieselbe Zeichenfolge nach der Verwendung eines Platzhalters mehrfach vorkommt, erhöht sich die Komplexität der Verarbeitung des Ereignismusters. Formulieren Sie Ihr Ereignismuster neu, um wiederholte Sequenzen zu minimieren. Betrachten Sie beispielsweise das folgende Beispiel, das mit der `doc.txt`-Dateinamendatei für jeden Benutzer übereinstimmt:

  ```
  {
  "FileName": [ { "wildcard": "/Users/*/dir/dir/dir/dir/dir/doc.txt" } ]
  }
  ```

  Wenn Sie wüssten, dass die Datei `doc.txt` nur im angegebenen Pfad vorkommt, könnten Sie die wiederholte Zeichenfolge auf diese Weise reduzieren:

  ```
  {
  "FileName": [ { "wildcard": "/Users/*/doc.txt" } ]
  }
  ```

## Komplexes Beispiel mit mehrfachem Abgleich
<a name="eb-filtering-complex-example"></a>

Sie können mehrere Übereinstimmungskriterien zu einem komplexeren Ereignismuster kombinieren. Das folgende Ereignismuster kombiniert beispielsweise `anything-but` und `numeric`.

```
{
  "time": [ { "prefix": "2017-10-02" } ],
  "detail": {
    "state": [ { "anything-but": "initializing" } ],
    "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ],
    "d-count": [ { "numeric": [ "<", 10 ] } ],
    "x-limit": [ { "anything-but": [ 100, 200, 300 ] } ]
  }
}
```

**Anmerkung**  
Wenn Sie beim Erstellen von Ereignismustern einen Schlüssel mehrfach angeben, wird die letzte Referenz zur Auswertung von Ereignissen verwendet. Zum Beispiel für das folgende Muster:  

```
{
  "detail": {
    "location": [ { "prefix": "us-" } ],
    "location": [ { "anything-but": "us-east" } ]
  }
}
```
Wird bei der Auswertung des `location` nur `{ "anything-but": "us-east" }` berücksichtigt

## Komplexes Beispiel mit `$or`-Abgleich
<a name="eb-filtering-complex-example-or"></a>

Sie können auch komplexe Ereignismuster erstellen, mit denen überprüft wird, ob *beliebige* Feldwerte in mehreren Feldern übereinstimmen. Verwenden Sie `$or`, um ein Ereignismuster zu erstellen, das überprüft, ob beliebige Werte für mehrere Felder übereinstimmen.

Beachten Sie, dass Sie andere Filtertypen, wie z. B. den [numerischen Abgleich](#filtering-numeric-matching) und [Arrays](eb-event-patterns-arrays.md), in den Musterabgleich für einzelne Felder in Ihrem `$or`-Konstrukt einbeziehen können.

Das folgende Ereignismuster stimmt überein, wenn eine der folgenden Bedingungen erfüllt ist:
+ Das Feld `c-count` ist größer als 0 oder kleiner als oder gleich 5.
+ Das Feld `d-count` ist kleiner als 10.
+ Das Feld `x-limit` entspricht 3.018e2.

```
{
  "detail": {
    "$or": [
      { "c-count": [ { "numeric": [ ">", 0, "<=", 5 ] } ] },
      { "d-count": [ { "numeric": [ "<", 10 ] } ] },
      { "x-limit": [ { "numeric": [ "=", 3.018e2 ] } ] }
    ]
  }
}
```

**Anmerkung**  
APIs die ein Ereignismuster (wie`PutRule`,, und`TestEventPattern`) akzeptieren `CreateArchive``UpdateArchive`, lösen eine Meldung aus, `InvalidEventPatternException` wenn die Verwendung von mehr als 1000 Regelkombinationen `$or` ergibt.  
Wenn Sie die Anzahl der Regelkombinationen in einem Ereignismuster ermitteln möchten, multiplizieren Sie die Gesamtzahl der Argumente aus jedem `$or`-Array im Ereignismuster. Das obige Muster enthält beispielsweise ein einzelnes `$or`-Array mit drei Argumenten, sodass die Gesamtzahl der Regelkombinationen ebenfalls drei beträgt. Wenn Sie ein weiteres `$or`-Array mit zwei Argumenten hinzufügen würden, wäre die Gesamtzahl der Regelkombinationen dann sechs.