

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.

# EventBridge Amazon-Event-Muster erstellen
<a name="eb-event-patterns"></a>

Wahrscheinlich möchten Sie nicht jedes einzelne Ereignis verarbeiten, das an einen bestimmten Event-Bus oder eine bestimmte Event-Pipe übertragen wird. Vielmehr werden Sie wahrscheinlich eine Teilmenge aller übermittelten Ereignisse auswählen wollen, basierend auf der Quelle des Ereignisses, dem Ereignistyp und den and/or Attributen dieser Ereignisse. 

Um anzugeben, welche Ereignisse an ein Ziel gesendet werden sollen, erstellen Sie ein *Ereignismuster*. Ein Ereignismuster definiert, anhand welcher Daten bestimmt EventBridge wird, ob das Ereignis an das Ziel gesendet werden soll. Wenn das Ereignismuster mit dem Ereignis übereinstimmt, wird das Ereignis an das Ziel EventBridge gesendet. Ereignismuster haben dieselbe Struktur wie die Ereignisse, mit denen sie übereinstimmen. Ein Ereignismuster stimmt entweder mit einem Ereignis überein oder nicht.

**Tipp**  
Sie können die EventBridge Sandbox verwenden, um Ereignismuster anhand von Beispielereignissen zu testen, bevor Sie Regeln erstellen oder aktualisieren. Weitere Informationen finden Sie unter [Testen von Ereignismustern mit der EventBridge Sandbox](eb-event-pattern-sandbox.md).

Stellen Sie sich zum Beispiel das folgende Ereignis von Amazon vor EC2:

```
{
  "version": "0",
  "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
  "detail-type": "EC2 Instance State-change Notification",
  "source": "aws.ec2",
  "account": "111122223333",
  "time": "2017-12-22T18:43:48Z",
  "region": "us-west-1",
  "resources": [
    "arn:aws:ec2:us-west-1:123456789012:instance/i-1234567890abcdef0"
  ],
  "detail": {
    "instance-id": "i-1234567890abcdef0",
    "state": "terminated"
  }
}
```

Das folgende Ereignismuster wählt alle EC2 `instance-termination` Amazon-Ereignisse aus. Das Ereignismuster tut dies, indem es drei Anforderungen spezifiziert, die einem Ereignis entsprechen:

1. Die Ereignisquelle muss Amazon sein EC2.

1. Bei dem Ereignis muss es sich um eine Benachrichtigung über eine EC2 Änderung des Amazon-Status handeln.

1. Der Status der EC2 Amazon-Instance muss sein`terminated`.

```
{
  "source": ["aws.ec2"],
  "detail-type": ["EC2 Instance State-change Notification"],
  "detail": {
    "state": ["terminated"]
  }
}
```

Beachten Sie, dass das Ereignismuster in diesem Beispiel Felder *über* das Ereignis-- `source` und `detail-type` --sowie ein Feld aus dem Ereignistext-- `state` enthält.

**Wichtig**  
In ist es möglich EventBridge, Regeln zu erstellen, die zu higher-than-expected Gebühren und Drosselungen führen können. Sie können beispielsweise versehentlich eine Regel erstellen, die zu einer Endlosschleife führt, bei der eine Regel rekursiv ohne Ende ausgelöst wird. Angenommen, Sie ACLs haben eine Regel erstellt, um zu erkennen, welche Änderungen in einem Amazon S3 S3-Bucket vorgenommen wurden, und die Software veranlassen, sie in den gewünschten Zustand zu versetzen. Wenn die Regel nicht sorgfältig geschrieben wurde, löst die nachfolgende Änderung die ACLs Regel erneut aus, wodurch eine Endlosschleife entsteht.  
Anleitungen zum Schreiben präziser Regeln und Ereignismuster zur Minimierung solcher unerwarteter Ergebnisse finden Sie unter [Bewährte Methoden für Regeln](eb-rules-best-practices.md) und [Best Practices](eb-patterns-best-practices.md).

## Ereignismuster für Event-Busse
<a name="eb-event-patterns-buses"></a>

Für Event-Busse können Sie für jede Regel, die Sie für den Bus erstellen, ein Ereignismuster angeben. Auf diese Weise können Sie auswählen, welche Ereignisse an bestimmte Ziele gesendet werden sollen. Die Ereignismuster für Event-Busse können mit der Ereignisquelle, den Ereignismetadaten und den and/or Ereignisdetailwerten abgeglichen werden.

![\[Ein Ereignis wird mit dem Ereignismuster jeder Busregel verglichen und an das Ziel gesendet, wenn es übereinstimmt.\]](http://docs.aws.amazon.com/de_de/eventbridge/latest/userguide/images/event-pattern-bus_eventbridge_architecture.svg)


 Im folgenden Video werden die Grundlagen von Ereignismustern für Event-Busse beschrieben:




## Ereignismuster für EventBridge Pipes
<a name="eb-event-patterns-pipes"></a>

Für EventBridge Pipes können Sie Ereignismuster angeben, um die Ereignisse aus der Pipe-Quelle zu filtern, die Sie an das Pipe-Ziel übertragen möchten. Da jede Pipe über eine einzige Ereignisquelle verfügt, können die Ereignismuster für Pipes mit den and/or Detailwerten der Ereignismetadaten abgeglichen werden.

![\[Ein Ereignis wird mit dem Ereignismuster der Pipe verglichen und an das Ziel gesendet, wenn es übereinstimmt.\]](http://docs.aws.amazon.com/de_de/eventbridge/latest/userguide/images/event-pattern-pipes_eventbridge_architecture.svg)


Nicht alle Ereignisfelder können zur Erstellung von Pipe-Ereignismustern verwendet werden. Weitere Informationen finden Sie unter [Filtern](eb-pipes-event-filtering.md).

# Syntax von Ereignismustern
<a name="eb-create-pattern"></a>

Wenn Sie ein Ereignismuster erstellen möchten, geben Sie die Felder eines Ereignisses an, denen das Ereignismuster entsprechen soll. Geben Sie nur die Felder an, die Sie für den Abgleich verwenden. 

Das folgende Beispiel für ein Ereignismuster liefert beispielsweise nur Werte für drei Felder: die Felder der obersten Ebene `"source"` und `"detail-type"` und das `"state"` Feld innerhalb des `"detail"` Objektfeldes. EventBridgeignoriert alle anderen Felder des Ereignisses, wenn die Regel angewendet wird.

```
{
  "source": ["aws.ec2"],
  "detail-type": ["EC2 Instance State-change Notification"],
  "detail": {
    "state": ["terminated"]
  }
}
```

Damit ein Ereignismuster einem Ereignis entspricht, muss das Ereignis alle Feldnamen enthalten, die im Ereignismuster aufgeführt sind. Die Feldnamen müssen im Ereignis auch mit derselben verschachtelten Struktur angezeigt werden.

Wenn Sie Ereignismuster für den Abgleich von Ereignissen schreiben, können Sie die `TestEventPattern`-API oder den CLI-Befehl `test-event-pattern` verwenden, um zu testen, ob Ihr Muster den korrekten Ereignissen entspricht. Weitere Informationen finden Sie unter [TestEventPattern](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_TestEventPattern.html).

## Abgleichen von Ereigniswerten
<a name="eb-filtering-match-values"></a>

In einem Ereignismuster befindet sich der abzugleichende Wert in einem JSON-Array, das von eckigen Klammern („[“, „]“) umgeben ist, sodass Sie mehrere Werte angeben können. Um beispielsweise Ereignisse von Amazon EC2 oder abzugleichen AWS Fargate, könnten Sie das folgende Muster verwenden, das Ereignisse abgleicht, bei denen der Wert für das `"source"` Feld entweder `"aws.ec2"` oder ist`"aws.fargate"`.

```
{
    "source": ["aws.ec2", "aws.fargate"]
}
```

Weitere Informationen finden Sie unter [Abgleich mehrerer Feldwerte](eb-event-patterns-arrays.md).

## Verwendung von Vergleichsoperatoren in EventBridge Amazon-Ereignismustern
<a name="eb-event-patterns-content-based-filtering"></a>

Amazon EventBridge unterstützt die deklarative Inhaltsfilterung mithilfe von Ereignismustern. Bei der Inhaltsfilterung können Sie komplexe Ereignismuster schreiben, die nur unter sehr spezifischen Bedingungen Ereignissen entsprechen. Sie können beispielsweise ein Ereignismuster erstellen, das einem Ereignis entspricht, wenn:
+ Ein Feld des Ereignisses innerhalb eines bestimmten numerischen Bereichs liegt
+ Das Ereignis von einer bestimmten IP-Adresse stammt
+ Ein bestimmtes Feld im Ereignis-JSON nicht vorhanden ist

Weitere Informationen finden Sie unter [Vergleichsoperatoren](eb-create-pattern-operators.md).

## Überlegungen zur Erstellung von Ereignismustern
<a name="eb-create-pattern-considerations"></a>

Im Folgenden finden Sie einige Dinge, die Sie beim Erstellen Ihrer Ereignismuster berücksichtigen sollten:
+ EventBridge ignoriert die Felder im Ereignis, die nicht im Ereignismuster enthalten sind. Das hat zur Folge, dass es einen `"*": "*"`-Platzhalter bei Feldern gibt, die nicht im Ereignismuster vorkommen.
+ Für die von Ereignismustern abgeglichenen Werte gelten JSON-Regeln. Sie können in Anführungszeichen (") gesetzte Zeichenfolgen sowie Zahlen und die Schlüsselwörter `true`, `false` und `null` verwenden.
+  EventBridge Verwendet für Zeichenketten den exakten character-by-character Abgleich ohne Umschaltung der Groß- und Kleinschreibung oder andere Normalisierung von Zeichenketten.
+  EventBridge Verwendet für Zahlen die Zeichenkettendarstellung. 300, 300,0 und 3,0e2 werden z. B. nicht gleich behandelt.
+ Wenn mehrere Muster für dasselbe JSON-Feld angegeben sind, wird EventBridge nur das letzte verwendet.
+ Beachten Sie, dass beim EventBridge Kompilieren von Ereignismustern zur Verwendung der Punkt (.) als Verbindungszeichen verwendet wird.

  Das bedeutet, EventBridge dass die folgenden Ereignismuster als identisch behandelt werden:

  ```
  ## has no dots in keys
  { "detail" : { "state": { "status": [ "running" ] } } }
  
  ## has dots in keys
  { "detail" : { "state.status": [ "running" ] } }
  ```

  Und dass beide Ereignismuster den folgenden beiden Ereignissen entsprechen: 

  ```
  ## has no dots in keys
  { "detail" : { "state": { "status": "running" } } }
  
  ## has dots in keys
  { "detail" : { "state.status": "running"  } }
  ```
**Anmerkung**  
Dies beschreibt EventBridge das aktuelle Verhalten und man sollte sich nicht darauf verlassen, dass es sich nicht ändert.
+ Ereignismuster, die doppelte Felder enthalten, sind ungültig. Wenn ein Muster doppelte Felder enthält, wird EventBridge nur der endgültige Feldwert berücksichtigt.

  Beispielsweise stimmen die folgenden Ereignismuster mit demselben Ereignis überein:

  ```
  ## has duplicate keys
  {
    "source": ["aws.s3"],
    "source": ["aws.sns"],
    "detail-type": ["AWS API Call via CloudTrail"],
    "detail":  {
        "eventSource": ["s3.amazonaws.com"],
        "eventSource": ["sns.amazonaws.com"]
    }
  }
  
  ## has unique keys
  {
    "source": ["aws.sns"],
    "detail-type": ["AWS API Call via CloudTrail"],
    "detail": { "eventSource": ["sns.amazonaws.com"] }
  }
  ```

  Und EventBridge behandelt die folgenden beiden Ereignisse als identisch: 

  ```
  ## has duplicate keys
  {
    "source": ["aws.s3"],
    "source": ["aws.sns"],
    "detail-type": ["AWS API Call via CloudTrail"],
    "detail":  [
      {
        "eventSource": ["s3.amazonaws.com"],
        "eventSource": ["sns.amazonaws.com"]
      }
    ]
  }
  
  ## has unique keys
  {
    "source": ["aws.sns"],
    "detail-type": ["AWS API Call via CloudTrail"],
    "detail": [
      { "eventSource": ["sns.amazonaws.com"] }
    ]
  }
  ```
**Anmerkung**  
Dies beschreibt EventBridge das aktuelle Verhalten und man sollte sich nicht darauf verlassen, dass es sich nicht ändert.

# Übereinstimmende Ereignisse anhand von Ereignisfeldwerten
<a name="eb-filtering-data-types"></a>

Sie können alle JSON-Datentypen und -Werte verwenden, um Ereignisse abzugleichen. Die folgenden Beispiele zeigen Ereignisse und die Ereignismuster, die ihnen entsprechen.

## Feldabgleich
<a name="eb-filtering-example"></a>

Sie können anhand des Werts eines Felds einen Abgleich vornehmen. Betrachten Sie das folgende Amazon EC2 Auto Scaling Scaling-Ereignis.

```
{
  "version": "0",
  "id": "3e3c153a-8339-4e30-8c35-687ebef853fe",
  "detail-type": "EC2 Instance Launch Successful",
  "source": "aws.autoscaling",
  "account": "123456789012",
  "time": "2015-11-11T21:31:47Z",
  "region": "us-east-1",
  "resources": [],
  "detail": {
    "eventVersion": "",
    "responseElements": null
  }
}
```

Für das vorhergehende Ereignis können Sie das entsprechende Feld `"responseElements"` verwenden.

```
{
  "source": ["aws.autoscaling"],
  "detail-type": ["EC2 Instance Launch Successful"],
  "detail": {
   "responseElements": [null]
  }
}
```

## Wertabgleich
<a name="eb-filtering-value-example"></a>

Betrachten Sie das folgende Ereignis von Amazon Macie, das gekürzt wurde.

```
{
  "version": "0",
  "id": "0948ba87-d3b8-c6d4-f2da-732a1example",
  "detail-type": "Macie Finding",
  "source": "aws.macie",
  "account": "123456789012",
  "time": "2021-04-29T23:12:15Z",
  "region":"us-east-1",
  "resources": [

  ],
  "detail": {
    "schemaVersion": "1.0",
    "id": "64b917aa-3843-014c-91d8-937ffexample",
    "accountId": "123456789012",
    "partition": "aws",
    "region": "us-east-1",
    "type": "Policy:IAMUser/S3BucketEncryptionDisabled",
    "title": "Encryption is disabled for the S3 bucket",
    "description": "Encryption is disabled for the Amazon S3 bucket. The data in the bucket isn’t encrypted 
        using server-side encryption.",
    "severity": {
        "score": 1,
        "description": "Low"
    },
    "createdAt": "2021-04-29T15:46:02Z",
    "updatedAt": "2021-04-29T23:12:15Z",
    "count": 2,
.
.
.
```

Das folgende Ereignismuster entspricht jedem Ereignis mit einem Schweregrad von 1 und einer Anzahl von 2.

```
{
  "source": ["aws.macie"],
  "detail-type": ["Macie Finding"],
  "detail": {
    "severity": {
      "score": [1]
    },
    "count":[2]
  }
}
```

# Übereinstimmende Ereignisse für Nullwerte und leere Zeichenketten in Amazon EventBridge
<a name="eb-event-patterns-null-values"></a>

**Wichtig**  
In ist es möglich EventBridge, Regeln zu erstellen, die zu higher-than-expected Gebühren und Drosselungen führen können. Sie können beispielsweise versehentlich eine Regel erstellen, die zu einer Endlosschleife führt, bei der eine Regel rekursiv ohne Ende ausgelöst wird. Angenommen, Sie ACLs haben eine Regel erstellt, um zu erkennen, welche Änderungen in einem Amazon S3 S3-Bucket vorgenommen wurden, und die Software veranlassen, sie in den gewünschten Zustand zu versetzen. Wenn die Regel nicht sorgfältig geschrieben wurde, löst die nachfolgende Änderung die ACLs Regel erneut aus, wodurch eine Endlosschleife entsteht.  
Anleitungen zum Schreiben präziser Regeln und Ereignismuster zur Minimierung solcher unerwarteter Ergebnisse finden Sie unter [Bewährte Methoden für Regeln](eb-rules-best-practices.md) und [Best Practices](eb-patterns-best-practices.md).

Sie können ein [Ereignismuster](eb-event-patterns.md) erstellen, das einem Feld in einem [Ereignis](eb-events.md) entspricht, das einen Nullwert oder eine leere Zeichenfolge hat. Betrachten Sie das folgende -Beispielereignis:

Informieren Sie sich über bewährte Methoden zur Vermeidung unerwarteter Gebühren und Drosselung.

```
{
  "version": "0",
  "id": "3e3c153a-8339-4e30-8c35-687ebef853fe",
  "detail-type": "EC2 Instance Launch Successful",
  "source": "aws.autoscaling",
  "account": "123456789012",
  "time": "2015-11-11T21:31:47Z",
  "region": "us-east-1",
  "resources": [
   ],
  "detail": {
    "eventVersion": "",
    "responseElements": null
   }
}
```

Wenn Sie Ereignisse abgleichen möchten, bei denen der Wert von `eventVersion` eine leere Zeichenfolge ist, verwenden Sie das folgende Ereignismuster, das dem vorhergehenden Ereignis entspricht.

```
{
  "detail": {
     "eventVersion": [""]
  }
}
```

Wenn Sie Ereignisse abgleichen möchten, bei denen der Wert von `responseElements` null ist, verwenden Sie das folgende Ereignismuster, das dem vorhergehenden Ereignis entspricht.

```
{
  "detail": {
     "responseElements": [null]
  }
}
```

**Anmerkung**  
Nullwerte und leere Zeichenfolgen sind beim Musterabgleich nicht austauschbar. Ein Ereignismuster, das mit leeren Zeichenfolgen übereinstimmt, entspricht nicht den Werten von `null`.

## Verwendung von Nullwerten in AWS CloudFormation Vorlagen
<a name="eb-event-patterns-null-values-cfn"></a>

AWS CloudFormation erlaubt keine `null` Werte in Vorlagen. Wenn Sie mithilfe der YAML- oder JSON-Objektsyntax ein Ereignismuster mit einem Nullwert definieren, schlägt die Vorlagenvalidierung mit dem folgenden Fehler fehl:`'null' values are not allowed in templates`.

Um diese Einschränkung zu umgehen, geben Sie die `EventPattern` Eigenschaft als JSON-Zeichenfolge statt als YAML- oder JSON-Objekt an. Das folgende Beispiel zeigt, wie bei Nullwerten in einer AWS CloudFormation Vorlage ein Abgleich durchgeführt wird:

```
MyRule:
  Type: AWS::Events::Rule
  Properties:
    EventPattern: '{"detail":{"responseElements":[null]}}'
```

# Abgleich mehrerer Werte für ein Ereignisfeld in Amazon EventBridge
<a name="eb-event-patterns-arrays"></a>

Der Wert jedes Felds in einem [Ereignismuster](eb-event-patterns.md) ist ein Array, das einen oder mehrere Werte enthält. Ein Ereignismuster entspricht dem [Ereignis](eb-events.md), wenn einer der Werte im Array mit dem Wert im Ereignis übereinstimmt. Ist der Wert im Ereignis ein Array, dann stimmt das Ereignismuster überein, wenn die Schnittmenge aus dem Ereignismuster-Array und dem Ereignis-Array nicht leer ist.

**Wichtig**  
In ist es möglich EventBridge, Regeln zu erstellen, die zu higher-than-expected Gebühren und Drosselungen führen können. Sie können beispielsweise versehentlich eine Regel erstellen, die zu einer Endlosschleife führt, bei der eine Regel rekursiv ohne Ende ausgelöst wird. Angenommen, Sie ACLs haben eine Regel erstellt, um zu erkennen, welche Änderungen in einem Amazon S3 S3-Bucket vorgenommen wurden, und die Software veranlassen, sie in den gewünschten Zustand zu versetzen. Wenn die Regel nicht sorgfältig geschrieben wurde, löst die nachfolgende Änderung die ACLs Regel erneut aus, wodurch eine Endlosschleife entsteht.  
Anleitungen zum Schreiben präziser Regeln und Ereignismuster zur Minimierung solcher unerwarteter Ergebnisse finden Sie unter [Bewährte Methoden für Regeln](eb-rules-best-practices.md) und [Best Practices](eb-patterns-best-practices.md).

Betrachten Sie beispielsweise ein Ereignismuster, das das folgende Feld enthält.

```
"resources": [
   "arn:aws:ec2:us-east-1:123456789012:instance/i-b188560f",
   "arn:aws:ec2:us-east-1:111122223333:instance/i-b188560f",
   "arn:aws:ec2:us-east-1:444455556666:instance/i-b188560f",
]
```

Das vorhergehende Ereignismuster stimmt mit einem Ereignis überein, das das folgende Feld enthält, da das erste Element im Ereignismuster-Array dem zweiten Element im Ereignis-Array entspricht.

```
"resources": [
   "arn:aws:autoscaling:us-east-1:123456789012:autoScalingGroup:eb56d16b-bbf0-401d-b893-d5978ed4a025:autoScalingGroupName/ASGTerminate",
   "arn:aws:ec2:us-east-1:123456789012:instance/i-b188560f" 
]
```

# 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.

# Bewährte Methoden für EventBridge Amazon-Ereignismuster
<a name="eb-patterns-best-practices"></a>

Im Folgenden finden Sie einige bewährte Methoden, die Sie bei der Definition von Ereignismustern in Ihren Event-Bus-Regeln berücksichtigen sollten.

## Vermeiden des Schreibens von Endlosschleifen
<a name="eb-patterns-best-practices-loops"></a>

In ist es möglich EventBridge, Regeln zu erstellen, die zu Endlosschleifen führen, bei denen eine Regel wiederholt ausgelöst wird. Eine Regel könnte beispielsweise erkennen, welche Änderungen in einem S3-Bucket vorgenommen ACLs wurden, und die Software veranlassen, sie in den gewünschten Zustand zu versetzen. Wenn die Regel nicht sorgfältig geschrieben wurde, löst die nachfolgende Änderung die ACLs Regel erneut aus, wodurch eine Endlosschleife entsteht.

Zur Vermeidung dieser Probleme sollten Sie die Ereignismuster für Ihre Regeln so präzise wie möglich schreiben, sodass sie nur den Ereignissen entsprechen, die Sie tatsächlich an das Ziel senden möchten. Im obigen Beispiel würden Sie ein Ereignismuster erstellen, das den Ereignissen entspricht, sodass die ausgelösten Aktionen nicht dieselbe Regel erneut auslösen. Erstellen Sie in Ihrer Regel beispielsweise ein Ereignismuster, das Ereignisse nur dann berücksichtigt, wenn ACLs sich herausstellt, dass sie sich in einem schlechten Zustand befinden, und nicht erst nach einer Änderung. Weitere Informationen erhalten Sie unter [Möglichst präzises Gestalten von Ereignismustern](#eb-patterns-best-practices-precision) und [Definieren Sie Ihre Ereignismuster so, dass sie Aktualisierungen der Ereignisquellen berücksichtigen](#eb-patterns-best-practices-future-proof).

Eine Endlosschleife kann schnell höhere Gebühren als erwartet verursachen. Dies kann auch zu Drosselung und verzögerter Ereigniszustellung führen. Sie können die Obergrenze Ihrer Aufrufraten überwachen, um vor unerwarteten Volumenspitzen gewarnt zu werden.

Verwenden Sie die Budgetierung, um Sie zu warnen, wenn die Gebühren das von Ihnen angegebene Limit überschreiten. Weitere Informationen finden Sie unter [Verwalten der Kosten mit Budgets](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html).

## Möglichst präzises Gestalten von Ereignismustern
<a name="eb-patterns-best-practices-precision"></a>

Je genauer Ihr Ereignismuster ist, desto wahrscheinlicher ist es, dass es nur mit den tatsächlich gewünschten Ereignissen übereinstimmt und unerwartete Übereinstimmungen vermieden werden, wenn neue Ereignisse zu einer Ereignisquelle hinzugefügt oder bestehende Ereignisse mit neuen Eigenschaften aktualisiert werden.

Ereignismuster können Filter enthalten, die einen Abgleich auf Folgendes durchführen:
+ Ereignismetadaten über das Ereignis, wie `source`, `detail-type`, `account` oder `region`.
+ Ereignisdaten, d. h. die Felder innerhalb des `detail`-Objekts.
+ Der Inhalt des Ereignisses oder die tatsächlichen Werte der Felder innerhalb des `detail`-Objekts.

Die meisten Muster sind einfach, z. B. nur die Angabe von `source`- und `detail-type`-Filtern. Zu den EventBridge Mustern gehört jedoch die Flexibilität, nach jedem Schlüssel oder Wert des Ereignisses zu filtern. Darüber hinaus können Sie Inhaltsfilter wie `prefix`- und `suffix`-Filter anwenden, um die Präzision Ihrer Muster zu verbessern. Weitere Informationen finden Sie unter [Verwendung von Vergleichsoperatoren in EventBridge Amazon-Ereignismustern](eb-create-pattern.md#eb-event-patterns-content-based-filtering).

### Geben Sie die Ereignisquelle und den Detailtyp als Filter an.
<a name="eb-patterns-best-practices-source"></a>

Sie können das Generieren von Endlosschleifen und das Abgleichen unerwünschter Ereignisse reduzieren, indem Sie Ihre Ereignismuster mithilfe der `source`- und `detail-type`-Metadatenfelder präzisieren.

Wenn Sie bestimmte Werte in zwei oder mehr Feldern abgleichen müssen, verwenden Sie den `$or`-Vergleichsoperator, anstatt alle möglichen Werte in einem einzigen Werte-Array aufzulisten.

Für Ereignisse, die per übermittelt werden AWS CloudTrail, empfehlen wir, das `eventName` Feld als Filter zu verwenden.

Das folgende Beispiel für ein Ereignismuster entspricht `CreateQueue` oder `SetQueueAttributes` aus dem Amazon Simple Queue Service Service `CreateKey` oder `DisableKeyRotation` Ereignissen aus dem AWS Key Management Service Service.

```
{
  "detail-type": ["AWS API Call via CloudTrail"],
  "$or": [{
      "source": [
        "aws.sqs"
        ],
      "detail": {
        "eventName": [
          "CreateQueue",
          "SetQueueAttributes"
        ]
      }
    },
    {
      "source": [
        "aws.kms"
        ],
      "detail": {
        "eventName": [
          "CreateKey",
          "DisableKeyRotation"
        ]
      }
    }
  ]
}
```

### Angeben von Konto und Region als Filter
<a name="eb-patterns-best-practices-accounts-regions"></a>

Wenn Sie `region`- und `account`-Felder in Ihr Ereignismuster aufnehmen, können Sie den konto- oder regionsübergreifenden Ereignisabgleich einschränken. 

### Angeben von Inhaltsfiltern
<a name="eb-patterns-best-practices-content"></a>

Die inhaltsbasierte Filterung kann dazu beitragen, die Genauigkeit von Ereignismustern zu verbessern und gleichzeitig die Länge des Ereignismusters auf ein Minimum zu beschränken. Beispielsweise kann ein Abgleich auf der Grundlage eines numerischen Bereichs hilfreich sein, anstatt alle möglichen numerischen Werte aufzulisten.

Weitere Informationen finden Sie unter [Verwendung von Vergleichsoperatoren in EventBridge Amazon-Ereignismustern](eb-create-pattern.md#eb-event-patterns-content-based-filtering).

## Definieren Sie Ihre Ereignismuster so, dass sie Aktualisierungen der Ereignisquellen berücksichtigen
<a name="eb-patterns-best-practices-future-proof"></a>

Bei der Erstellung von Ereignismustern sollten Sie berücksichtigen, dass sich Ereignisschemata und Ereignis-Domains im Laufe der Zeit weiterentwickeln und erweitern können. Auch hier hilft es Ihnen, Ihre Ereignismuster so präzise wie möglich zu gestalten, um unerwartete Übereinstimmungen zu vermeiden, wenn sich die Ereignisquelle ändert oder erweitert.

Nehmen wir zum Beispiel an, Sie führen einen Abgleich mit Ereignissen aus einem neuen Mikroservice durch, der Ereignisse im Zusammenhang mit Zahlungen veröffentlicht. Anfänglich verwendet der Service die Domain `acme.payments` und veröffentlicht ein einzelnes Ereignis, `Payment accepted`:

```
{
  "detail-type": "Payment accepted",
  "source": "acme.payments",
  "detail": {
    "type": "credit",
    "amount": "100",
    "date": "2023-06-10",
    "currency": "USD"
    }
  }
}
```

An dieser Stelle könnten Sie ein einfaches Ereignismuster erstellen, das „Zahlung akzeptiert“-Ereignissen entspricht:

```
{ “source” : “acme.payments” }
```

Nehmen wir jedoch an, dass der Service später ein neues Ereignis für abgelehnte Zahlungen einführt:

```
{
  "detail-type": "Payment rejected",
  "source": "acme.payments",
  "detail": {
  }
}
```

In diesem Fall wird das einfache Ereignismuster, das Sie erstellt haben, nun mit beiden `Payment rejected` Ereignissen `Payment accepted` abgeglichen. EventBridge leitet beide Ereignistypen zur Verarbeitung an das angegebene Ziel weiter, was möglicherweise zu Verarbeitungsfehlern und zusätzlichen Verarbeitungskosten führen kann.

Wenn Sie Ihr Ereignismuster nur auf `Payment accepted`-Ereignisse beschränken möchten, sollten Sie mindestens beide `source` und `detail-type` angeben:

```
{
  "detail-type": "Payment accepted",
  "source": "acme.payments"
  }
}
```

Sie können in Ihrem Ereignismuster auch Konto und Region angeben, um weiter einzuschränken, wann konto- oder regionsübergreifende Ereignisse dieser Regel entsprechen.

```
{
  "account": "012345678910",
  "source": "acme.payments",
  "region": "AWS-Region",
  "detail-type": "Payment accepted"
}
```

## Überprüfen von Ereignismustern
<a name="eb-patterns-best-practices-validate"></a>

Wenn Sie sicherstellen möchten, dass die Regeln mit den gewünschten Ereignissen übereinstimmen, empfehlen wir Ihnen dringend, Ihre Ereignismuster zu überprüfen. Sie können Ihre Ereignismuster mithilfe der EventBridge Konsole oder der API überprüfen:
+ In der EventBridge Konsole können Sie Ereignismuster [als Teil der Regelerstellung oder separat [mithilfe der Sandbox](eb-event-pattern-sandbox.md) erstellen](eb-create-rule-visual.md) und testen.
+ Sie können Ihre Ereignismuster AWS CLI mithilfe des [test-event-pattern](https://docs.aws.amazon.com/cli/latest/reference/events/test-event-pattern.html)Befehls testen.