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.

# JSON-Prozessoren mutieren
<a name="CloudWatch-Logs-Transformation-JSONMutate"></a>

Dieser Abschnitt enthält Informationen zu den mutierten JSON-Prozessoren, die Sie mit einem Log-Event-Transformer verwenden können. 

**Contents**
+ [Schlüssel hinzufügen](#CloudWatch-Logs-Transformation-addKeys)
+ [Schlüssel löschen](#CloudWatch-Logs-Transformation-deleteKeys)
+ [MoveKeys](#CloudWatch-Logs-Transformation-moveKeys)
+ [Schlüssel umbenennen](#CloudWatch-Logs-Transformation-renameKeys)
+ [Wert kopieren](#CloudWatch-Logs-Transformation-copyValue)
+ [listToMap](#CloudWatch-Logs-Transformation-listToMap)

## Schlüssel hinzufügen
<a name="CloudWatch-Logs-Transformation-addKeys"></a>

Verwenden Sie den `addKeys` Prozessor, um dem Protokollereignis neue Schlüssel-Wert-Paare hinzuzufügen. 


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Einträge | Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder keyvalue, und enthalten. | Ja |  | Maximale Anzahl von Einträgen: 5 | 
| Schlüssel | Der Schlüssel des neuen Eintrags, der hinzugefügt werden soll | Ja |  | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| value | Der Wert des neuen Eintrags, der hinzugefügt werden soll | Ja |  | Maximale Länge: 256 | 
| overwriteIfExists | Wenn Sie dies auf setzentrue, wird der bestehende Wert überschrieben, falls er im Ereignis key bereits vorhanden ist. Der Standardwert ist false.  | Nein | false | Kein Limit | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

Die Transformer-Konfiguration sieht wie folgt aus und verwendet `addKeys` mit`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "addKeys": {
            "entries": [
                {
                    "key": "outer_key.new_key",
                    "value": "new_value"
                }
            ]
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
  "outer_key": {
    "inner_key": "inner_value",
    "new_key": "new_value"
  }
}
```

## Schlüssel löschen
<a name="CloudWatch-Logs-Transformation-deleteKeys"></a>

Verwenden Sie den `deleteKeys` Prozessor, um Felder aus einem Protokollereignis zu löschen. Diese Felder können Schlüssel-Wert-Paare enthalten. 


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Mit Schlüsseln | Die Liste der zu löschenden Schlüssel. | Ja | Kein Limit | Maximale Anzahl an Einträgen: 5 | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

Die Transformer-Konfiguration sieht wie folgt aus und verwendet `deleteKeys` mit`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "deleteKeys": {
            "withKeys":["outer_key.inner_key"]
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
  "outer_key": {}
}
```

## MoveKeys
<a name="CloudWatch-Logs-Transformation-moveKeys"></a>

Verwenden Sie den `moveKeys` Prozessor, um eine Taste von einem Feld in ein anderes zu verschieben. 


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Einträge | Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder sourcetarget, und enthalten. | Ja |  | Maximale Anzahl von Einträgen: 5 | 
| Quelle | Der Schlüssel zum Bewegen | Ja |  | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| Ziel | Der Schlüssel, zu dem gewechselt werden soll | Ja |  | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| overwriteIfExists | Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false.  | Nein | false | Kein Limit | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key1": {
        "inner_key1": "inner_value1"
    },
    "outer_key2": {
        "inner_key2": "inner_value2"
    }
}
```

Die Transformer-Konfiguration sieht wie folgt aus und verwendet `moveKeys` mit`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "moveKeys": {
            "entries": [
                {
                    "source": "outer_key1.inner_key1",
                    "target": "outer_key2"
                }
            ]
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
  "outer_key1": {},
  "outer_key2": {
    "inner_key2": "inner_value2",
    "inner_key1": "inner_value1"
  }
}
```

## Schlüssel umbenennen
<a name="CloudWatch-Logs-Transformation-renameKeys"></a>

Verwenden Sie den `renameKeys` Prozessor, um Schlüssel in einem Protokollereignis umzubenennen. 


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Einträge | Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder keytarget, und enthalten. | Ja | Kein Limit | Maximale Anzahl von Einträgen: 5 | 
| Schlüssel | Der Schlüssel zum Umbenennen | Ja | Kein Limit | Höchstlänge: 128 | 
| Ziel | Der neue Schlüsselname | Ja | Kein Limit | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| overwriteIfExists | Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false.  | Nein | false | Kein Limit | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

Die Transformer-Konfiguration sieht wie folgt aus und verwendet `renameKeys` mit`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "renameKeys": {
            "entries": [
                {
                    "key": "outer_key",
                    "target": "new_key"
                }
            ]
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
  "new_key": {
    "inner_key": "inner_value"
  }
}
```

## Wert kopieren
<a name="CloudWatch-Logs-Transformation-copyValue"></a>

Verwenden Sie den `copyValue` Prozessor, um Werte innerhalb eines Protokollereignisses zu kopieren. Sie können diesen Prozessor auch verwenden, um Metadaten zu Protokollereignissen hinzuzufügen, indem Sie die Werte der folgenden Metadatenschlüssel in die Protokollereignisse kopieren:`@logGroupName`,`@logGroupStream`,`@accountId`,`@regionName`. Dies wird im folgenden Beispiel veranschaulicht.


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Einträge | Reihe von Einträgen. Jedes Element im Array kann overwriteIfExists Felder sourcetarget, und enthalten. | Ja |  | Maximale Anzahl von Einträgen: 5 | 
| Quelle | Der Schlüssel zum Kopieren | Ja |  | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| Ziel | Der Schlüssel, in den der Wert kopiert werden soll | Ja | Kein Limit | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| overwriteIfExists | Wenn Sie dies auf setzentrue, wird der vorhandene Wert überschrieben, falls er im key Ereignis bereits vorhanden ist. Der Standardwert ist false.  | Nein | false | Kein Limit | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key": {
        "inner_key": "inner_value"
    }
}
```

Die Transformer-Konfiguration sieht wie folgt aus und verwendet `copyValue` mit`parseJSON`:

```
[
    {
        "parseJSON": {}
    },
    {
        "copyValue": {
            "entries": [
                {
                    "key": "outer_key.new_key",
                    "target": "new_key"
                },
                {
                    "source": "@logGroupName",
                    "target": "log_group_name"
                },
                {
                    "source": "@logGroupStream",
                    "target": "log_group_stream"
                },
                {
                    "source": "@accountId",
                    "target": "account_id"
                },
                {
                    "source": "@regionName",
                    "target": "region_name"
                }
            ]
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
  "outer_key": {
    "inner_key": "inner_value"
  },
  "new_key": "inner_value",
  "log_group_name": "myLogGroupName",
  "log_group_stream": "myLogStreamName",
  "account_id": "012345678912",
  "region_name": "us-east-1"
}
```

## listToMap
<a name="CloudWatch-Logs-Transformation-listToMap"></a>

Der `listToMap` Prozessor nimmt eine Liste von Objekten, die Schlüsselfelder enthalten, und konvertiert sie in eine Zuordnung von Zielschlüsseln. 


| Feld | Description | Erforderlich? | Standard | Einschränkungen | 
| --- | --- | --- | --- | --- | 
| Quelle | Der Schlüssel in der ProcessingEvent mit einer Liste von Objekten, die in eine Map konvertiert werden | Ja |  | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| Schlüssel | Der Schlüssel der Felder, die als Schlüssel in der generierten Map extrahiert werden sollen | Ja |  | Höchstlänge: 128 | 
| WertSchlüssel | Wenn dies angegeben ist, werden die Werte, die Sie in diesem Parameter angeben, aus den source Objekten extrahiert und in die Werte der generierten Map eingefügt. Andernfalls werden die Originalobjekte in der Quellliste in die Werte der generierten Map aufgenommen. | Nein |  | Höchstlänge: 128 | 
| Ziel | Der Schlüssel des Feldes, das die generierte Map enthalten soll  | Nein | Stammknoten | Höchstlänge: 128<br />Maximale Tiefe verschachtelter Schlüssel: 3 | 
| flatten | Ein boolescher Wert, der angibt, ob die Liste in einzelne Elemente reduziert wird oder ob es sich bei den Werten in der generierten Map um Listen handelt.<br />Standardmäßig werden die Werte für die passenden Schlüssel in einem Array dargestellt. Auf einstellen`true`, `flatten` um das Array basierend auf dem Wert von in einen einzelnen Wert umzuwandeln`flattenedElement`. | Nein | false |  | 
| flattenedElement | Wenn Sie flatten auf einstellentrue, geben Sie hier flattenedElement an, welches Element first oder last beibehalten werden soll.  | Erforderlich, wenn auf gesetzt `flatten` ist `true` |  | Der Wert kann nur first oder sein last | 

**Beispiel**

Nehmen wir das folgende Beispiel für ein Protokollereignis:

```
{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ]
}
```

**Transformator für Anwendungsfall 1:** `flatten` ist `false`

```
[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": false
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": [
        "val-a"
    ],
    "b": [
        "val-b1",
        "val-b2"
    ],
    "c": [
        "val-c"
    ]
}
```

**Transformator für Anwendungsfall 2:** `flatten` ist `true` und `flattenedElement` ist `first`

```
[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": true,
            "flattenedElement": "first"
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b1",
    "c": "val-c"
}
```

**Transformator für Anwendungsfall 3:** `flatten` ist `true` und `flattenedElement` ist `last`

```
[
    {
        "parseJSON": {}
    },
    {
        "listToMap": {
            "source": "outer_key"
            "key": "inner_key",
            "valueKey": "inner_value",
            "flatten": true,
            "flattenedElement": "last"
        }
    }
]
```

Das transformierte Protokollereignis wäre das Folgende.

```
{
    "outer_key": [
        {
            "inner_key": "a",
            "inner_value": "val-a"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b1"
        },
        {
            "inner_key": "b",
            "inner_value": "val-b2"
        },
        {
            "inner_key": "c",
            "inner_value": "val-c"
        }
    ],
    "a": "val-a",
    "b": "val-b2",
    "c": "val-c"
}
```