

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.

# Daten an einen Firehose-Stream senden
<a name="basic-write"></a>

In diesem Abschnitt wird beschrieben, wie Sie verschiedene Datenquellen verwenden können, um Daten an Ihren Firehose-Stream zu senden. Wenn Sie Amazon Data Firehose noch nicht kennen, nehmen Sie sich etwas Zeit, um sich mit den Konzepten und der Terminologie in [Was ist Amazon Data Firehose?](what-is-this-service.md) vertraut zu machen.

**Anmerkung**  
Einige AWS Dienste können nur Nachrichten und Ereignisse an einen Firehose-Stream senden, der sich in derselben Region befindet. Wenn Ihr Firehose-Stream bei der Konfiguration eines Ziels für Amazon CloudWatch Logs, CloudWatch Events oder nicht als Option angezeigt wird, stellen Sie sicher AWS IoT, dass sich Ihr Firehose-Stream in derselben Region wie Ihre anderen Dienste befindet. Informationen zu Service-Endpunkten für jede Region finden Sie unter [Amazon Data Firehose-Endpunkte.](https://docs.aws.amazon.com/general/latest/gr/fh.html#fh_region)

Sie können Daten aus den folgenden Datenquellen an Ihren Firehose-Stream senden.

**Topics**
+ [Kinesis-Agent für das Senden von Daten konfigurieren](writing-with-agents.md)
+ [Daten mit AWS SDK senden](writing-with-sdk.md)
+ [CloudWatch Logs an Firehose senden](writing-with-cloudwatch-logs.md)
+ [CloudWatch Ereignisse an Firehose senden](writing-with-cloudwatch-events.md)
+ [So konfigurieren AWS IoT , dass Daten an Firehose gesendet werden](writing-with-iot.md)

# Kinesis-Agent für das Senden von Daten konfigurieren
<a name="writing-with-agents"></a>

Amazon Kinesis Agent ist eine eigenständige Java-Softwareanwendung, die als Referenzimplementierung dient und zeigt, wie Sie Daten sammeln und an Firehose senden können. Der Agent überwacht kontinuierlich eine Reihe von Dateien und sendet neue Daten an Ihren Firehose-Stream. Der Agent zeigt, wie Sie mit Dateirotation, Checkpoints und Wiederholungen bei Fehlern umgehen können. Er zeigt, wie Sie Ihre Daten zuverlässig, zeitnah und einfach bereitstellen können. Außerdem wird gezeigt, wie Sie CloudWatch Metriken ausgeben können, um den Streaming-Prozess besser zu überwachen und Fehler zu beheben. Weitere Informationen finden Sie unter [awslabs/ amazon-kinesis-agent](https://github.com/awslabs/amazon-kinesis-agent).

Standardmäßig werden Datensätze aus den einzelnen Dateien anhand des Zeilenumbruchzeichens (`'\n'`) analysiert. Der Agent kann jedoch auch für die Analyse mehrzeiliger Datensätze konfiguriert werden (siehe [Geben Sie die Einstellungen der Agentenkonfiguration an](agent-config-settings.md)). 

Sie können den Agenten in Linux-Serverumgebungen installieren, beispielsweise auf Webservern, Protokollservern und Datenbankservern. Nachdem Sie den Agenten installiert haben, konfigurieren Sie ihn, indem Sie die zu überwachenden Dateien und den Firehose-Stream für die Daten angeben. Nach der Konfiguration sammelt der Agent dauerhaft Daten aus den Dateien und sendet sie zuverlässig an den Firehose-Stream.

## Voraussetzungen
<a name="prereqs"></a>

Bevor Sie Kinesis Agent verwenden, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
+ Ihr Betriebssystem muss Amazon Linux oder Red Hat Enterprise Linux Version 7 oder höher sein. 
+ Agent-Version 2.0.0 oder höher wird mit JRE-Version 1.8 oder höher ausgeführt. Agent-Version 1.1.x wird mit JRE 1.7 oder höher ausgeführt. 
+ Starten Sie Ihre EC2-Instance, wenn Sie Amazon EC2 verwenden, um den Agenten auszuführen.
+ Die von Ihnen angegebene IAM-Rolle oder die AWS Anmeldeinformationen müssen berechtigt sein, den Amazon Data [PutRecordBatch](https://docs.aws.amazon.com/firehose/latest/APIReference/API_PutRecordBatch.html)Firehose-Vorgang auszuführen, damit der Agent Daten an Ihren Firehose-Stream senden kann. Wenn Sie die CloudWatch Überwachung für den Agenten aktivieren, ist auch eine Genehmigung zur Durchführung des CloudWatch [PutMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_PutMetricData.html)Vorgangs erforderlich. Weitere Informationen finden Sie unter [Zugriffskontrolle mit Amazon Data Firehose](controlling-access.md)[Überwachen Sie den Zustand des Kinesis-Agenten](agent-health.md), und [Authentifizierung und Zugriffskontrolle für Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/auth-and-access-control-cw.html).

# AWS Anmeldeinformationen verwalten
<a name="agent-credentials"></a>

Verwalten Sie Ihre AWS Anmeldeinformationen mit einer der folgenden Methoden:
+ Erstellen Sie einen Anbieter benutzerdefinierter Anmeldeinformationen. Details hierzu finden Sie unter [Erstellen Sie benutzerdefinierte Anbieter für Anmeldeinformationen](custom-cred-provider.md).
+ Geben Sie eine IAM-Rolle an, wenn Sie Ihre EC2 Instance starten.
+ Geben Sie die AWS Anmeldeinformationen an, wenn Sie den Agenten konfigurieren (siehe die Einträge für `awsAccessKeyId` und `awsSecretAccessKey` in der Konfigurationstabelle unter[Geben Sie die Einstellungen der Agentenkonfiguration an](agent-config-settings.md)).
+ Bearbeiten Sie`/etc/sysconfig/aws-kinesis-agent`, um Ihre AWS Region und Ihre AWS Zugriffsschlüssel anzugeben.
+ Wenn sich Ihre EC2-Instance in einem anderen AWS Konto befindet, erstellen Sie eine IAM-Rolle, um Zugriff auf den Amazon Data Firehose-Service zu gewähren. [Geben Sie diese Rolle bei der Konfiguration des Agenten an (siehe [assumeRoleARN und assumeRoleExternal Id](agent-config-settings.md#assumeRoleARN)).](agent-config-settings.md#assumeRoleExternalId) Verwenden Sie eine der vorherigen Methoden, um die AWS Anmeldeinformationen eines Benutzers in dem anderen Konto anzugeben, der berechtigt ist, diese Rolle anzunehmen.

# Erstellen Sie benutzerdefinierte Anbieter für Anmeldeinformationen
<a name="custom-cred-provider"></a>

Sie können einen Anbieter für benutzerdefinierte Anmeldeinformationen erstellen und den Klassennamen und den JAR-Pfad zum Kinesis Agent in den folgenden Konfigurationseinstellungen angeben: `userDefinedCredentialsProvider.classname` und `userDefinedCredentialsProvider.location`. Die Beschreibungen dieser beiden Konfigurationseinstellungen finden Sie unter [Geben Sie die Einstellungen der Agentenkonfiguration an](agent-config-settings.md).

Um einen Anbieter benutzerdefinierte Anmeldeinformationen zu erstellen, definieren Sie eine Klasse, die die `AWS CredentialsProvider`-Schnittstelle implementiert, wie im folgenden Beispiel.

```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;

public class YourClassName implements AWSCredentialsProvider {
    public YourClassName() {
    }

    public AWSCredentials getCredentials() {
        return new BasicAWSCredentials("key1", "key2");
    }

    public void refresh() {
    }
}
```

Ihre Klasse muss über einen Konstruktor verfügen, der keine Argumente annimmt.

AWS ruft die Refresh-Methode regelmäßig auf, um aktualisierte Anmeldeinformationen abzurufen. Wenn Ihr Anmeldeinformationsanbieter während seiner gesamten Lebensdauer unterschiedliche Anmeldeinformationen bereitstellen soll, fügen Sie Code ein, um die Anmeldeinformationen in dieser Methode zu aktualisieren. Alternativ können Sie diese Methode leer lassen, wenn Sie einen Anmeldeinformationsanbieter wünschen, der statische (nicht ändernde) Anmeldeinformationen vergibt. 

# Laden Sie den Agenten herunter und installieren Sie ihn
<a name="download-install"></a>

Stellen Sie zunächst eine Verbindung mit Ihrer Instance her. Weitere Informationen finden Sie unter [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html) im *Amazon EC2 EC2-Benutzerhandbuch*. Wenn Sie Probleme mit der Verbindung haben, finden Sie weitere Informationen unter [Problembehandlung beim Herstellen einer Verbindung zu Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) im *Amazon EC2 EC2-Benutzerhandbuch*.

Installieren Sie als Nächstes mithilfe einer der folgenden Methoden den Agenten.
+ **So richten Sie den Agenten über die Amazon-Linux-Repositorys ein**

  Diese Methode funktioniert nur für Amazon-Linux-Instances. Verwenden Sie den folgenden Befehl:

  ```
  sudo yum install –y aws-kinesis-agent
  ```

  Agent v 2.0.0 oder höher ist auf Computern mit dem Betriebssystem Amazon Linux 2 (AL2) installiert. Diese Agent-Version erfordert Java-Version 1.8 oder höher. Falls die erforderliche Java-Version noch nicht vorhanden ist, wird sie bei der Agenteninstallation installiert. Weitere Informationen zu Amazon Linux 2 finden Sie unter [https://aws.amazon.com/amazon-linux-2/](https://aws.amazon.com/amazon-linux-2/).
+ **So richten Sie den Agenten über die Amazon-S3-Repositorys ein**

  Diese Methode funktioniert sowohl für Instances von Red Hat Enterprise Linux als auch von Amazon Linux 2, da sie den Agenten aus dem öffentlich verfügbaren Repository installiert. Verwenden Sie den folgenden Befehl, um die neueste Version der Agentenversion 2.x.x. herunterzuladen und zu installieren: 

  ```
  sudo yum install –y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-latest.amzn2.noarch.rpm
  ```

  Um eine bestimmte Version des Agents zu installieren, geben Sie die Versionsnummer im Befehl an. Mit dem folgenden Befehl wird beispielsweise Agent v 2.0.1. installiert. 

  ```
  sudo yum install –y https://streaming-data-agent.s3.amazonaws.com/aws-kinesis-agent-2.0.1-1.amzn1.noarch.rpm
  ```

  Wenn Sie Java 1.7 haben und es nicht aktualisieren möchten, können Sie die Agentenversion 1.x.x herunterladen, die mit Java 1.7 kompatibel ist. Um beispielsweise Agent v1.1.6 herunterzuladen, können Sie den folgenden Befehl verwenden: 

  ```
  sudo yum install –y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-1.1.6-1.amzn1.noarch.rpm
  ```

  Sie können den neuesten Agenten mit dem folgenden Befehl herunterladen

  ```
  sudo yum install -y https://s3.amazonaws.com/streaming-data-agent/aws-kinesis-agent-latest.amzn2.noarch.rpm
  ```
+ **Um den Agenten aus dem GitHub Repo einzurichten**

  1. Stellen Sie zunächst sicher, dass die erforderliche Java-Version installiert ist, je nach Agentenversion.

  1.  Laden Sie den Agenten aus dem [amazon-kinesis-agent GitHub awslabs/Repo](https://github.com/awslabs/amazon-kinesis-agent) herunter.

  1. Installieren Sie den Agenten, indem Sie zum Download-Verzeichnis navigieren und den folgenden Befehl ausführen:

     ```
     sudo ./setup --install
     ```
+ 

**So richten Sie den Agenten in einem Docker-Container ein**  
Kinesis Agent kann auch in einem Container über die [amazonlinux](https://docs.aws.amazon.com/AmazonECR/latest/userguide/amazon_linux_container_image.html)-Containerbasis ausgeführt werden. Verwenden Sie die folgende Docker-Datei und führen Sie dann `docker build` aus.

  ```
  FROM amazonlinux
  
  RUN yum install -y aws-kinesis-agent which findutils
  COPY agent.json /etc/aws-kinesis/agent.json
  
  CMD ["start-aws-kinesis-agent"]
  ```

# Konfigurieren und starten Sie den Agenten
<a name="config-start"></a>

**So konfigurieren und starten Sie den Agenten**

1. Öffnen und bearbeiten Sie die Konfigurationsdatei (als Superuser, wenn Sie standardmäßige Dateizugriffsberechtigungen nutzen): `/etc/aws-kinesis/agent.json` 

   Geben Sie in dieser Konfigurationsdatei die Dateien (`"filePattern"`) an, aus denen der Agent Daten sammelt, und den Namen des Firehose-Streams (`"deliveryStream"`), an den der Agent Daten sendet. Der Dateiname ein Muster ist und der Agent Dateirotationen erkennt. Sie können nur einmal pro Sekunde Dateien rotieren oder neue Dateien erstellen. Der Agent verwendet den Zeitstempel der Dateierstellung, um zu bestimmen, welche Dateien nachverfolgt und in Ihren Firehose-Stream aufgenommen werden sollen. Wenn Daten häufiger als einmal pro Sekunde neu erstellt oder rotiert werden, kann der Agent nicht richtig zwischen den Dateien unterscheiden.

   ```
   { 
      "flows": [
           { 
               "filePattern": "/tmp/app.log*", 
               "deliveryStream": "yourdeliverystream"
           } 
      ] 
   }
   ```

   Die AWS Standardregion ist`us-east-1`. Wenn Sie eine andere Region verwenden, fügen Sie der Konfigurationsdatei die Einstellung `firehose.endpoint` hinzu, um den Endpunkt für Ihre Region anzugeben. Weitere Informationen finden Sie unter [Geben Sie die Einstellungen der Agentenkonfiguration an](agent-config-settings.md).

1. Starten Sie den Agenten manuell:

   ```
   sudo service aws-kinesis-agent start
   ```

1. (Optional) Konfigurieren Sie den Agenten so, dass er beim Startup des Systems gestartet wird:

   ```
   sudo chkconfig aws-kinesis-agent on
   ```

Der Agent wird jetzt als Systemdienst im Hintergrund ausgeführt. Es überwacht kontinuierlich die angegebenen Dateien und sendet Daten an den angegebenen Firehose-Stream. Die Agentenaktivität wird in `/var/log/aws-kinesis-agent/aws-kinesis-agent.log` protokolliert. 

# Geben Sie die Einstellungen der Agentenkonfiguration an
<a name="agent-config-settings"></a>

Der Agent unterstützt zwei obligatorische Konfigurationseinstellungen, `filePattern` und `deliveryStream`, sowie optionale Konfigurationseinstellungen für zusätzliche Funktionen. Sie können sowohl die obligatorischen als auch die optionalen Konfigurationseinstellungen in `/etc/aws-kinesis/agent.json` festlegen.

Wenn Sie die Konfigurationsdatei ändern, müssen Sie den Agenten mit den folgenden Befehlen anhalten und starten:

```
sudo service aws-kinesis-agent stop
sudo service aws-kinesis-agent start
```

Alternativ können Sie auch den folgenden Befehl nutzen:

```
sudo service aws-kinesis-agent restart
```

Im Folgenden finden Sie die allgemeinen Konfigurationseinstellungen.


| Konfigurationseinstellung | Description | 
| --- | --- | 
| <a name="assumeRoleARN"></a>assumeRoleARN |  Der Amazon-Ressourcenname (ARN) der Rolle, die der Benutzer übernehmen soll. Weitere Informationen finden Sie unter [AWS Kontenübergreifendes Delegieren des Zugriffs mithilfe von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) im *IAM-Benutzerhandbuch*.  | 
| <a name="assumeRoleExternalId"></a>assumeRoleExternalId |  Eine optionale Kennung, die festlegt, wer die Rolle übernehmen kann. Weitere Informationen finden Sie unter [Verwendung einer externen ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) im *IAM-Benutzerhandbuch*.  | 
| <a name="awsAccessKeyId"></a>awsAccessKeyId |  AWS Zugriffsschlüssel-ID, die die Standardanmeldedaten überschreibt. Diese Einstellung hat Vorrang vor allen anderen Anbietern von Anmeldeinformationen.  | 
| <a name="awsSecretAccessKey"></a>awsSecretAccessKey |  AWS geheimer Schlüssel, der die Standardanmeldedaten überschreibt. Diese Einstellung hat Vorrang vor allen anderen Anbietern von Anmeldeinformationen.  | 
| cloudwatch.emitMetrics |  Ermöglicht dem Agenten, Metriken auszusenden, CloudWatch sofern diese Einstellung gesetzt ist (true). Standard: true  | 
| cloudwatch.endpoint |  Der regionale Endpunkt für CloudWatch. Standard: `monitoring.us-east-1.amazonaws.com`  | 
| firehose.endpoint |  Der regionale Endpunkt für Amazon Data Firehose. Standard: `firehose.us-east-1.amazonaws.com`  | 
| sts.endpoint |  Der regionale Endpunkt für den AWS Security Token Service. Standard: `https://sts.amazonaws.com`  | 
| userDefinedCredentialsProvider.classname | Wenn Sie einen Anbieter für benutzerdefinierte Anmeldeinformationen definieren, geben Sie den vollständig qualifizierten Klassennamen mit dieser Einstellung an. Fügen Sie .class nicht am Ende des Klassennamens ein.  | 
| userDefinedCredentialsProvider.location | Wenn Sie einen Anbieter für benutzerdefinierte Anmeldeinformationen definieren, verwenden Sie diese Einstellung, um den absoluten JAR-Pfad anzugeben, der den Anbieter für benutzerdefinierte Anmeldeinformationen enthält. Der Agent sucht auch am folgenden Speicherort nach der JAR-Datei: /usr/share/aws-kinesis-agent/lib/. | 

Im Folgenden finden Sie die Konfigurationseinstellungen für den Ablauf.


| Konfigurationseinstellung | Description | 
| --- | --- | 
| aggregatedRecordSizeBytes |  Geben Sie diese Einstellung an, damit der Agent Datensätze aggregiert und sie dann in einem Vorgang in den Firehose-Stream einfügt. Stellen Sie ihn auf die Größe ein, die der Aggregatdatensatz haben soll, bevor der Agent ihn in den Firehose-Stream einfügt.  Standard: 0 (keine Aggregation)  | 
| dataProcessingOptions |  Die Liste der Verarbeitungsoptionen, die auf jeden analysierten Datensatz angewendet werden, bevor er an den Firehose-Stream gesendet wird. Die Verarbeitungsoptionen werden in der angegebenen Reihenfolge ausgeführt. Weitere Informationen finden Sie unter [Daten mit Agenten vorverarbeiten](pre-processing.md).  | 
| deliveryStream |  [Erforderlich] Der Name des Firehose-Streams.  | 
| filePattern |  [Erforderlich] Glob für die Dateien, die vom Agent überwacht werden müssen. Eine Datei, die mit diesem Muster übereinstimmt, wird vom Agenten automatisch erfasst und überwacht. Gewähren Sie `aws-kinesis-agent-user` Leseberechtigung für alle Dateien, die diesem Muster entsprechen. Gewähren Sie `aws-kinesis-agent-user` Lese- und Ausführungsberechtigungen für das Verzeichnis mit den Dateien.  Der Agent verarbeitet jede Datei, die diesem Muster entspricht. Dieses Muster muss sorgfältig so ausgewählt werden, dass der Agent nur die gewünschten Datensätze verarbeitet.   | 
| initialPosition |  Die Position, an der mit der Analyse der Datei begonnen wurde. Gültige Werte sind `START_OF_FILE` und `END_OF_FILE`. Standard: `END_OF_FILE`  | 
| maxBufferAgeMillis |  Die maximale Zeit in Millisekunden, für die der Agent Daten zwischenspeichert, bevor er sie an den Firehose-Stream sendet. Wertebereich: 1 000–900 000 (1 Sekunde bis 15 Minuten) Standard: 60.000 (1 Minute)  | 
| maxBufferSizeBytes |  Die maximale Größe in Byte, für die der Agent Daten puffert, bevor er sie an den Firehose-Stream sendet. Wertebereich: 1–4 194 304 (4 MB) Standard: 4.194.304 (4 MB)  | 
| maxBufferSizeRecords |  Die maximale Anzahl von Datensätzen, für die der Agent Daten zwischenspeichert, bevor er sie an den Firehose-Stream sendet. Wertebereich: 1–500 Standard: 500  | 
| minTimeBetweenFilePollsMillis |  Das Zeitintervall (in Millisekunden), in dem der Agent die überwachten Dateien auf neue Daten abfragt und analysiert. Wertbereich: 1 oder höher Standard: 100  | 
| multiLineStartPattern |  Das Muster für die Identifizierung des Datensatzbeginns. Ein Datensatz besteht aus einer Zeile, die mit dem angegebenen Muster übereinstimmt, und allen folgenden Zeilen, die nicht dem Muster entsprechen. Gültige Werte sind reguläre Ausdrücke. Standardmäßig wird jede neue Zeile in den Protokolldateien als einziger Datensatz analysiert.  | 
| skipHeaderLines |  Die Anzahl der Zeilen, die der Agent überspringt, ehe mit der Analyse der überwachten Dateien begonnen wird. Wertbereich: 0 oder höher Standard: 0 (null)  | 
| truncatedRecordTerminator |  Die Zeichenfolge, die der Agent verwendet, um einen analysierten Datensatz zu kürzen, wenn die Datensatzgröße die Datensatzgrößenbeschränkung von Amazon Data Firehose überschreitet. (1,000 KB) Standard: `'\n'` (Zeilenumbruch)  | 

# Konfigurieren Sie mehrere Dateiverzeichnisse und Streams
<a name="sim-writes"></a>

Wenn Sie mehrere Ablaufkonfigurationseinstellungen angeben, können Sie den Agenten so konfigurieren, dass er mehrere Dateiverzeichnisse überwacht und Daten an verschiedene Streams sendet. Im folgenden Konfigurationsbeispiel überwacht der Agent zwei Dateiverzeichnisse und sendet Daten an einen Kinesis-Datenstream bzw. einen Firehose-Stream. Sie können unterschiedliche Endpunkte für Kinesis Data Streams und Amazon Data Firehose angeben, sodass sich Ihr Datenstream und Ihr Firehose-Stream nicht in derselben Region befinden müssen.

```
{
    "cloudwatch.emitMetrics": true,
    "kinesis.endpoint": "https://your/kinesis/endpoint", 
    "firehose.endpoint": "https://your/firehose/endpoint", 
    "flows": [
        {
            "filePattern": "/tmp/app1.log*", 
            "kinesisStream": "yourkinesisstream"
        }, 
        {
            "filePattern": "/tmp/app2.log*",
            "deliveryStream": "yourfirehosedeliverystream" 
        }
    ] 
}
```

Ausführlichere Informationen zur Verwendung des Agenten mit Amazon Kinesis Data Streams finden Sie unter [Schreiben in Amazon Kinesis Data Streams mit Kinesis Agent](https://docs.aws.amazon.com/kinesis/latest/dev/writing-with-agents.html).

# Daten mit Agenten vorverarbeiten
<a name="pre-processing"></a>

Der Agent kann die aus den überwachten Dateien analysierten Datensätze vorverarbeiten, bevor er sie an Ihren Firehose-Stream sendet. Sie können dieses Feature aktivieren, indem Sie Ihrem Dateifluss die Konfigurationseinstellung `dataProcessingOptions` hinzufügen. Sie können eine oder mehrere Verarbeitungsoptionen hinzufügen. Diese werden in der angegebenen Reihenfolge ausgeführt.

Der Agent unterstützt die folgenden Verarbeitungsoptionen. Der Agent ist ein Open-Source-Tool, sodass Sie dessen Verarbeitungsoptionen optimieren und erweitern können. Sie können den Agenten von [Kinesis Agent](https://github.com/awslabs/amazon-kinesis-agent) herunterladen.Verarbeitungsoptionen

`SINGLELINE`  
Konvertiert einen mehrzeiligen Datensatz in einen einzeiligen Datensatz, indem Zeilenumbruchzeichen sowie vorangestellte und folgende Leerzeichen entfernt werden.  

```
{
    "optionName": "SINGLELINE"
}
```

`CSVTOJSON`  
Konvertiert einen Datensatz aus dem durch Trennzeichen getrennten Format in einen Datensatz im JSON-Format.  

```
{
    "optionName": "CSVTOJSON",
    "customFieldNames": [ "field1", "field2", ... ],
    "delimiter": "yourdelimiter"
}
```  
`customFieldNames`  
[Erforderlich] Die Feldnamen, die als Schlüssel in den einzelnen JSON-Schlüssel-Wert-Paaren verwendet werden. Wenn Sie beispielsweise `["f1", "f2"]` angeben, wird der Datensatz „v1, v2“ in `{"f1":"v1","f2":"v2"}` konvertiert.  
`delimiter`  
Die Zeichenfolge, die als Trennzeichen im Datensatz verwendet wird. Standardmäßig wird ein Komma (,) verwendet.

`LOGTOJSON`  
Konvertiert einen Datensatz aus einem Protokollformat in einen Datensatz im JSON-Format. Folgende Protokollformate werden unterstützt: **Apache Common Log**, **Apache Combined Log**, **Apache Error Log** und **RFC3164 Syslog**.  

```
{
    "optionName": "LOGTOJSON",
    "logFormat": "logformat",
    "matchPattern": "yourregexpattern",
    "customFieldNames": [ "field1", "field2", … ]
}
```  
`logFormat`  
[Erforderlich] Das Format des Protokolleintrags. Folgende Werte sind möglich:  
+ `COMMONAPACHELOG` – Das Apache-Common-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes}`“.
+ `COMBINEDAPACHELOG` – Das Apache-Combined-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{host} %{ident} %{authuser} [%{datetime}] \"%{request}\" %{response} %{bytes} %{referrer} %{agent}`“.
+ `APACHEERRORLOG` – Das Apache-Error-Log-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`[%{timestamp}] [%{module}:%{severity}] [pid %{processid}:tid %{threadid}] [client: %{client}] %{message}`“.
+ `SYSLOG`— Das RFC3164 Syslog-Format. Jeder Protokolleintrag weist standardmäßig das folgende Muster auf: „`%{timestamp} %{hostname} %{program}[%{processid}]: %{message}`“.  
`matchPattern`  
Überschreibt das Standardmuster für das angegebene Protokollformat. Verwenden Sie diese Einstellung, um Werte aus Protokolleinträgen zu extrahieren, wenn sie ein benutzerdefiniertes Format verwenden. Wenn Sie `matchPattern` angeben, müssen Sie auch `customFieldNames` angeben.  
`customFieldNames`  
Die benutzerdefinierten Feldnamen, die als Schlüssel in den einzelnen JSON-Schlüssel-Wert-Paaren verwendet werden. Mit dieser Einstellung können Sie Feldnamen für Werte definieren, die aus `matchPattern` extrahiert wurden, oder die Standardfeldnamen von vordefinierten Protokollformaten überschreiben.

**Example : LOGTOJSON-Konfiguration**  <a name="example-logtojson"></a>
Nachfolgend ein Beispiel einer `LOGTOJSON`-Konfiguration für einen Apache Common Log-Eintrag, der in ein JSON-Format konvertiert wurde:  

```
{
    "optionName": "LOGTOJSON",
    "logFormat": "COMMONAPACHELOG"
}
```
Vor der Konvertierung:  

```
64.242.88.10 - - [07/Mar/2004:16:10:02 -0800] "GET /mailman/listinfo/hsdivision HTTP/1.1" 200 6291
```
Nach der Konvertierung:  

```
{"host":"64.242.88.10","ident":null,"authuser":null,"datetime":"07/Mar/2004:16:10:02 -0800","request":"GET /mailman/listinfo/hsdivision HTTP/1.1","response":"200","bytes":"6291"}
```

**Example : LOGTOJSON-Konfiguration mit benutzerdefinierten Feldern**  <a name="example-logtojson-custom-fields"></a>
Im Folgenden ein weiteres Beispiel einer `LOGTOJSON`-Konfiguration:  

```
{
    "optionName": "LOGTOJSON",
    "logFormat": "COMMONAPACHELOG",
    "customFieldNames": ["f1", "f2", "f3", "f4", "f5", "f6", "f7"]
}
```
Durch diese Konfigurationseinstellung wird der Apache Common Log-Eintrag aus dem vorherigen Beispiel wie folgt in ein JSON-Format konvertiert:  

```
{"f1":"64.242.88.10","f2":null,"f3":null,"f4":"07/Mar/2004:16:10:02 -0800","f5":"GET /mailman/listinfo/hsdivision HTTP/1.1","f6":"200","f7":"6291"}
```

**Example : Konvertieren eines Apache Common Log-Eintrags**  <a name="example-apache-common-log-entry"></a>
Bei der folgenden Ablaufkonfiguration wird ein Apache Common Log-Eintrag in einen einzeiligen Datensatz im JSON-Format umgewandelt:  

```
{ 
    "flows": [
        {
            "filePattern": "/tmp/app.log*", 
            "deliveryStream": "my-delivery-stream",
            "dataProcessingOptions": [
                {
                    "optionName": "LOGTOJSON",
                    "logFormat": "COMMONAPACHELOG"
                }
            ]
        }
    ] 
}
```

**Example : Konvertieren mehrzeiliger Datensätze**  <a name="example-convert-multi-line"></a>
Bei der folgenden Ablaufkonfiguration werden mehrzeilige Datensätze analysiert, deren erste Zeile mit „`[SEQUENCE=`“ beginnt. Jeder Datensatz wird in einen einzeiligen Datensatz konvertiert. Anschließend werden Werte aus dem Datensatz basierend auf einem Tabulatortrennzeichen extrahiert. Die extrahierten Werte werden zu angegebenen `customFieldNames`-Werten zugeordnet und ergeben so einen einzeiligen Datensatz im JSON-Format.  

```
{ 
    "flows": [
        {
            "filePattern": "/tmp/app.log*", 
            "deliveryStream": "my-delivery-stream",
            "multiLineStartPattern": "\\[SEQUENCE=",
            "dataProcessingOptions": [
                {
                    "optionName": "SINGLELINE"
                },
                {
                    "optionName": "CSVTOJSON",
                    "customFieldNames": [ "field1", "field2", "field3" ],
                    "delimiter": "\\t"
                }
            ]
        }
    ] 
}
```

**Example : LOGTOJSON-Konfiguration mit Übereinstimmungsmuster**  <a name="example-logtojson-match-pattern"></a>
Nachfolgend ein Beispiel einer `LOGTOJSON`-Konfiguration für einen Apache Common Log-Eintrag, der in das JSON-Format konvertiert wurde. Das letzte Feld (Bytes) wurde ausgelassen:  

```
{
    "optionName": "LOGTOJSON",
    "logFormat": "COMMONAPACHELOG",
    "matchPattern": "^([\\d.]+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4})\\] \"(.+?)\" (\\d{3})",
    "customFieldNames": ["host", "ident", "authuser", "datetime", "request", "response"]
}
```
Vor der Konvertierung:  

```
123.45.67.89 - - [27/Oct/2000:09:27:09 -0400] "GET /java/javaResources.html HTTP/1.0" 200
```
Nach der Konvertierung:  

```
{"host":"123.45.67.89","ident":null,"authuser":null,"datetime":"27/Oct/2000:09:27:09 -0400","request":"GET /java/javaResources.html HTTP/1.0","response":"200"}
```

# Verwenden Sie allgemeine Agent-CLI-Befehle
<a name="cli-commands"></a>

Die folgende Tabelle enthält eine Reihe gängiger Anwendungsfälle und die entsprechenden Befehle für die Arbeit mit dem AWS Kinesis-Agenten. 


| Anwendungsfall | Befehl | 
| --- | --- | 
|  Startet den Agenten beim Systemstart automatisch  |  <pre>sudo chkconfig aws-kinesis-agent on</pre>  | 
|  Überprüfen Sie den Status des Agenten  |  <pre>sudo service aws-kinesis-agent status</pre>  | 
|  Stoppen Sie den Agenten  |  <pre>sudo service aws-kinesis-agent stop</pre>  | 
|  Lesen Sie die Protokolldatei des Agenten von diesem Speicherort aus  |  <pre>/var/log/aws-kinesis-agent/aws-kinesis-agent.log</pre>  | 
|  Deinstallieren Sie den Agenten  |  <pre>sudo yum remove aws-kinesis-agent</pre>  | 

# Probleme beim Senden über Kinesis Agent beheben
<a name="agent-faq"></a>

Diese Tabelle enthält Informationen zur Fehlerbehebung und Lösungen für häufig auftretende Probleme bei der Verwendung des Amazon Kinesis Agent. 


| Problem | Lösung | 
| --- | --- | 
| Warum funktioniert Kinesis Agent nicht unter Windows? |  [Kinesis Agent für Windows](https://docs.aws.amazon.com/kinesis-agent-windows/latest/userguide/what-is-kinesis-agent-windows.html) ist eine andere Software als Kinesis Agent für Linux-Plattformen.  | 
| Warum verlangsamt sich Kinesis Agent und/oder RecordSendErrors nimmt zu? |  Dies ist normalerweise auf die Drosselung durch Kinesis zurückzuführen. Überprüfen Sie die `WriteProvisionedThroughputExceeded` Metrik für Kinesis Data Streams oder die `ThrottledRecords` Metrik für Firehose-Streams. Jede Erhöhung dieser Metriken von 0 zeigt an, dass die Stream-Grenzwerte erhöht werden müssen. Weitere Informationen finden Sie unter [Kinesis Data Stream-Grenzwerte und Firehose-Streams](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html)[.](https://docs.aws.amazon.com/firehose/latest/dev/limits.html) Sobald Sie die Drosselung ausgeschlossen haben, überprüfen Sie, ob der Kinesis Agent so konfiguriert ist, dass er eine große Menge kleiner Dateien durchsucht. Es gibt eine Verzögerung, wenn der Kinesis Agent eine neue Datei überwacht, daher sollte der Kinesis-Agent eine kleine Menge größerer Dateien überwachen. Versuchen Sie, Ihre Protokolldateien in größeren Dateien zusammenzufassen.  | 
| Wie löst man die Ausnahmen? java.lang.OutOfMemoryError | Dies passiert, wenn der Kinesis Agent nicht über genügend Arbeitsspeicher verfügt, um seine aktuelle Arbeitslast zu bewältigen. Versuchen Sie, JAVA\$1START\$1HEAP und JAVA\$1MAX\$1HEAP in /usr/bin/start-aws-kinesis-agent zu erhöhen und den Agenten neu zu starten. | 
| Wie behebt man die Ausnahmen? IllegalStateException : connection pool shut down | Kinesis Agent verfügt nicht über genügend Verbindungen, um seinen aktuellen Workload zu bewältigen. Versuchen Sie, maxConnections und maxSendingThreads in den allgemeinen Konfigurationseinstellungen des Agenten unter /etc/aws-kinesis/agent.json zu erhöhen. Der Standardwert für diese Felder ist das 12-fache der verfügbaren Laufzeitprozessoren. Weitere Informationen zu den Einstellungen für erweiterte Agentenkonfigurationen finden Sie unter [AgentConfiguration.java](https://github.com/awslabs/amazon-kinesis-agent/blob/master/src/com/amazon/kinesis/streaming/agent/config/AgentConfiguration.java).  | 
| Wie kann ich ein anderes Problem mit Kinesis Agent beheben? | DEBUG-Level-Protokolle können in /etc/aws-kinesis/log4j.xml aktiviert werden. | 
| Wie sollte ich Kinesis Agent konfigurieren? | Je kleiner das maxBufferSizeBytes, desto häufiger sendet der Kinesis Agent Daten. Dies kann nützlich sein, da es die Lieferzeit von Datensätzen verkürzt, aber es erhöht auch die Anfragen pro Sekunde an Kinesis.  | 
| Warum sendet Kinesis Agent doppelte Datensätze? | Dies ist auf eine Fehlkonfiguration bei der Dateiüberwachung zurückzuführen. Stellen Sie sicher, dass jedes fileFlow’s filePattern nur einer Datei entspricht. Dies kann auch auftreten, wenn der verwendete logrotate-Modus im copytruncate-Modus ist. Versuchen Sie, den Modus auf den Standard- oder Erstellungsmodus zu ändern, um Duplikate zu vermeiden. Weitere Informationen zum Umgang mit doppelten Datensätzen finden Sie unter [Umgang mit doppelten Datensätzen](https://docs.aws.amazon.com/streams/latest/dev/kinesis-record-processor-duplicates.html). | 

# Daten mit AWS SDK senden
<a name="writing-with-sdk"></a>

[Sie können die [Amazon Data Firehose-API verwenden](https://docs.aws.amazon.com/firehose/latest/APIReference/), um Daten mit dem [AWS SDK for Java](https://aws.amazon.com/sdk-for-java/), [.NET](https://aws.amazon.com/sdk-for-net/), [Node.js](https://aws.amazon.com/sdk-for-javascript/), [Python](https://aws.amazon.com/sdk-for-python/) oder Ruby an einen Firehose-Stream zu senden.](https://aws.amazon.com/sdk-for-ruby/) Wenn Sie Amazon Data Firehose noch nicht kennen, nehmen Sie sich etwas Zeit, um sich mit den Konzepten und der Terminologie in [Was ist Amazon Data Firehose?](what-is-this-service.md) vertraut zu machen. Weitere Informationen finden Sie unter [Entwickeln Sie Ihre Apps mit Amazon Web Services](https://aws.amazon.com/developers/getting-started/).

Diese Beispiele stellen keinen produktionsbereiten Code dar, d. h. es werden nicht alle möglichen Ausnahmen geprüft und es werden nicht alle möglichen Sicherheits- oder Leistungsüberlegungen berücksichtigt. 

Die Amazon Data Firehose-API bietet zwei Operationen zum Senden von Daten an Ihren Firehose-Stream: [PutRecord](https://docs.aws.amazon.com/firehose/latest/APIReference/API_PutRecord.html)und. [PutRecordBatch](https://docs.aws.amazon.com/firehose/latest/APIReference/API_PutRecordBatch.html) `PutRecord()`sendet einen Datensatz innerhalb eines Anrufs und `PutRecordBatch()` kann mehrere Datensätze innerhalb eines Anrufs senden. 

## Einzelne Schreiboperationen mit PutRecord
<a name="putrecord"></a>

Für das Einfügen von Daten sind nur der Firehose-Streamname und ein Bytepuffer (<=1000 KB) erforderlich. Da Amazon Data Firehose mehrere Datensätze stapelt, bevor die Datei in Amazon S3 geladen wird, möchten Sie möglicherweise ein Datensatztrennzeichen hinzufügen. Verwenden Sie den folgenden Code, um Daten datensatzweise in einen Firehose-Stream einzufügen:

```
PutRecordRequest putRecordRequest = new PutRecordRequest();
putRecordRequest.setDeliveryStreamName(deliveryStreamName);

String data = line + "\n";

Record record = new Record().withData(ByteBuffer.wrap(data.getBytes()));
putRecordRequest.setRecord(record);

// Put record into the DeliveryStream
firehoseClient.putRecord(putRecordRequest);
```

Weitere Informationen zum Codekontext finden Sie im Beispielcode, der im AWS SDK enthalten ist. Informationen zur Anfrage- und Antwortsyntax finden Sie im entsprechenden Thema unter [Firehose API Operations](https://docs.aws.amazon.com/firehose/latest/APIReference/API_Operations.html).

## Batch-Schreiboperationen mit PutRecordBatch
<a name="putrecordbatch"></a>

Für das Einfügen von Daten sind nur der Firehose-Stream-Name und eine Liste von Datensätzen erforderlich. Da Amazon Data Firehose mehrere Datensätze stapelt, bevor die Datei in Amazon S3 geladen wird, möchten Sie möglicherweise ein Datensatztrennzeichen hinzufügen. Verwenden Sie den folgenden Code, um Datensätze stapelweise in einen Firehose-Stream einzufügen:

```
PutRecordBatchRequest putRecordBatchRequest = new PutRecordBatchRequest();
putRecordBatchRequest.setDeliveryStreamName(deliveryStreamName);
putRecordBatchRequest.setRecords(recordList);

// Put Record Batch records. Max No.Of Records we can put in a
// single put record batch request is 500
firehoseClient.putRecordBatch(putRecordBatchRequest);

recordList.clear();
```

Weitere Informationen zum Codekontext finden Sie im Beispielcode, der AWS im SDK enthalten ist. Informationen zur Anfrage- und Antwortsyntax finden Sie im entsprechenden Thema unter [Firehose API Operations](https://docs.aws.amazon.com/firehose/latest/APIReference/API_Operations.html).

# CloudWatch Logs an Firehose senden
<a name="writing-with-cloudwatch-logs"></a>

CloudWatch Protokollereignisse können mithilfe von CloudWatch Abonnementfiltern an Firehose gesendet werden. Weitere Informationen finden Sie unter [Abonnementfilter mit Amazon Data Firehose](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SubscriptionFilters.html#FirehoseExample).

CloudWatch Protokollereignisse werden im komprimierten GZIP-Format an Firehose gesendet. Wenn Sie dekomprimierte Protokollereignisse an Firehose-Ziele senden möchten, können Sie die Dekomprimierungsfunktion in Firehose verwenden, um Logs automatisch zu dekomprimieren. CloudWatch 

**Wichtig**  
Derzeit unterstützt Firehose die Übermittlung von CloudWatch Protokollen an das Amazon OpenSearch Service-Ziel nicht, da Amazon mehrere Protokollereignisse zu einem Firehose-Datensatz CloudWatch zusammenfasst und Amazon OpenSearch Service nicht mehrere Protokollereignisse in einem Datensatz akzeptieren kann. Als Alternative können Sie erwägen, den [Abonnementfilter für Amazon OpenSearch Service in CloudWatch Logs zu verwenden](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_OpenSearch_Stream.html).

# Dekomprimieren Sie Protokolle CloudWatch
<a name="writing-with-cloudwatch-logs-decompression"></a>

[Wenn Sie Firehose zur Übertragung von CloudWatch Logs verwenden und dekomprimierte Daten an Ihr Firehose-Stream-Ziel liefern möchten, verwenden Sie Firehose [Data Format Conversion](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) (Parquet, ORC) oder Dynamic Partitioning.](https://docs.aws.amazon.com/firehose/latest/dev/dynamic-partitioning.html) Sie müssen die Dekomprimierung für Ihren Firehose-Stream aktivieren.

Sie können die Dekomprimierung mit dem AWS-Managementkonsole, oder aktivieren. AWS Command Line Interface AWS SDKs

**Anmerkung**  
Wenn Sie die Dekomprimierungsfunktion für einen Stream aktivieren, verwenden Sie diesen Stream ausschließlich für CloudWatch Logs-Abonnementfilter und nicht für Vending Logs. Wenn Sie die Dekomprimierungsfunktion für einen Stream aktivieren, der sowohl zum Ingestieren von Logs als auch von Vended CloudWatch Logs verwendet wird, schlägt das Ingestieren von Vended-Logs in Firehose fehl. Diese Dekomprimierungsfunktion ist nur für Logs verfügbar. CloudWatch 

# Extrahieren Sie die Nachricht nach der Dekomprimierung der Protokolle CloudWatch
<a name="Message_extraction"></a>

Wenn Sie die Dekomprimierung aktivieren, haben Sie die Möglichkeit, auch die Nachrichtenextraktion zu aktivieren. Bei der Verwendung der Nachrichtenextraktion filtert Firehose alle Metadaten wie Besitzer, Loggroup, Logstream und andere aus den dekomprimierten CloudWatch Logs-Datensätzen heraus und liefert nur den Inhalt in den Nachrichtenfeldern. Wenn Sie Daten an ein Splunk-Ziel senden, müssen Sie die Nachrichtenextraktion aktivieren, damit Splunk die Daten analysieren kann. Im Folgenden finden Sie Beispielausgaben nach der Dekomprimierung mit und ohne Nachrichtenextraktion.

Abb. 1: Beispielausgabe nach der Dekomprimierung ohne Nachrichtenextraktion:

```
{
 "owner": "111111111111",
 "logGroup": "CloudTrail/logs",
 "logStream": "111111111111_CloudTrail/logs_us-east-1",
 "subscriptionFilters": [
 "Destination"
 ],
 "messageType": "DATA_MESSAGE",
 "logEvents": [
 {
 "id": "31953106606966983378809025079804211143289615424298221568",
 "timestamp": 1432826855000,
 "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root1\"}"
 },
 {
 "id": "31953106606966983378809025079804211143289615424298221569",
 "timestamp": 1432826855000,
 "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root2\"}"
 },
 {
 "id": "31953106606966983378809025079804211143289615424298221570",
 "timestamp": 1432826855000,
 "message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root3\"}"
 }
 ]
}
```

Abb. 2: Beispielausgabe nach der Dekomprimierung mit Nachrichtenextraktion:

```
{"eventVersion":"1.03","userIdentity":{"type":"Root1"}
{"eventVersion":"1.03","userIdentity":{"type":"Root2"}
{"eventVersion":"1.03","userIdentity":{"type":"Root3"}
```

# Aktivieren Sie die Dekomprimierung für einen neuen Firehose-Stream von der Konsole
<a name="writing-with-cloudwatch-logs-decompression-enabling-console"></a>

**Um die Dekomprimierung in einem neuen Firehose-Stream zu aktivieren, verwenden Sie den AWS-Managementkonsole**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Kinesis-Konsole unter [https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis).

1. Wählen Sie im Navigationsbereich **Amazon Data Firehose** aus.

1. Wählen Sie **Create Firehose stream (Firehose-Stream erstellen)** aus.

1. Unter **Quelle und Ziel auswählen**  
****Quelle****  
Die Quelle deines Firehose-Streams. Wählen Sie eine der folgenden Quellen:  
   + **Direct PUT** — Wählen Sie diese Option, um einen Firehose zu erstellen, in den Producer-Anwendungen direkt schreiben. Eine Liste der AWS Dienste und Agenten sowie Open-Source-Dienste, die in Direct PUT in Firehose integriert sind, finden Sie in [diesem](create-name.md) Abschnitt.
   + **Kinesis-Stream:** Wählen Sie diese Option, um einen Firehose-Stream zu konfigurieren, der einen Kinesis-Datenstream als Datenquelle verwendet. Anschließend können Sie Firehose verwenden, um Daten einfach aus einem vorhandenen Kinesis-Datenstrom zu lesen und in Ziele zu laden. Weitere Informationen finden Sie unter [Mit Kinesis Data Streams in Firehose schreiben](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-kinesis-streams.html)  
****Ziel****  
Das Ziel Ihres Firehose-Streams. Wählen Sie eine der folgenden Optionen:  
   + Amazon S3
   + Splunk

1. Geben Sie **Firehose Firehose-Streamname** einen Namen für Ihren Stream ein.

1. (Optional) Unter **Datensätze transformieren**:
   + Wählen Sie im Abschnitt **Quelldatensätze aus Amazon CloudWatch Logs dekomprimieren** die Option **Dekomprimierung aktivieren** aus.
   + Wenn Sie die Nachrichtenextraktion nach der Dekomprimierung verwenden möchten, wählen Sie Nachrichtenextraktion **einschalten**.

# Aktivieren Sie die Dekomprimierung für einen vorhandenen Firehose-Stream
<a name="enabling-decompression-existing-stream-console"></a>

Dieser Abschnitt enthält Anweisungen zum Aktivieren der Dekomprimierung vorhandener Firehose-Streams. Es deckt zwei Szenarien ab: Streams mit deaktivierter Lambda-Verarbeitung und Streams mit bereits aktivierter Lambda-Verarbeitung. In den folgenden Abschnitten step-by-step werden die Verfahren für jeden Fall beschrieben, einschließlich der Erstellung oder Änderung von Lambda-Funktionen, der Aktualisierung der Firehose-Einstellungen und der Überwachung von CloudWatch Metriken, um eine erfolgreiche Implementierung der integrierten Firehose-Dekomprimierungsfunktion sicherzustellen.

## Dekomprimierung aktivieren, wenn die Lambda-Verarbeitung deaktiviert ist
<a name="enabling-decomp-exist-stream-lam-disable"></a>

Um die Dekomprimierung für einen vorhandenen Firehose mit deaktivierter Lambda-Verarbeitung zu aktivieren, müssen Sie zuerst die Lambda-Verarbeitung aktivieren. Diese Bedingung gilt nur für bestehende Streams. Die folgenden Schritte zeigen, wie die Dekomprimierung für bestehende Streams aktiviert wird, für die die Lambda-Verarbeitung nicht aktiviert ist.

1. Erstellen Sie eine Lambda-Funktion. Sie können entweder einen Dummy-Record-Passthrough erstellen oder diesen [Blueprint](https://github.com/aws-samples/aws-kinesis-firehose-resources/tree/main/blueprints/kinesis-firehose-cloudwatch-logs-processor) verwenden, um eine neue Lambda-Funktion zu erstellen. 

1. Aktualisieren Sie Ihren aktuellen Firehose-Stream, um die Lambda-Verarbeitung zu aktivieren, und verwenden Sie die Lambda-Funktion, die Sie für die Verarbeitung erstellt haben.

1. Sobald Sie den Stream mit der neuen Lambda-Funktion aktualisiert haben, kehren Sie zur Firehose-Konsole zurück und aktivieren Sie die Dekomprimierung.

1. Deaktivieren Sie die Lambda-Verarbeitung, die Sie in Schritt 1 aktiviert haben. Sie können jetzt die Funktion löschen, die Sie in Schritt 1 erstellt haben.

## Dekomprimierung aktivieren, wenn die Lambda-Verarbeitung aktiviert ist
<a name="enabling-decomp-exist-stream-lam-enable"></a>

Wenn Sie bereits über einen Firehose-Stream mit einer Lambda-Funktion verfügen, können Sie ihn zur Durchführung der Dekomprimierung durch die Firehose-Dekomprimierungsfunktion ersetzen. Bevor Sie fortfahren, überprüfen Sie Ihren Lambda-Funktionscode, um sicherzustellen, dass er nur Dekomprimierung oder Nachrichtenextraktion durchführt. Die Ausgabe Ihrer Lambda-Funktion sollte den Beispielen in Abb. [1 oder Abb. 2](Message_extraction.md) ähneln. Wenn die Ausgabe ähnlich aussieht, können Sie die Lambda-Funktion mithilfe der folgenden Schritte ersetzen.

1. Ersetzen Sie Ihre aktuelle Lambda-Funktion durch diesen [Blueprint](https://github.com/aws-samples/aws-kinesis-firehose-resources/tree/main/blueprints/kinesis-firehose-cloudwatch-logs-processor). Die neue Blueprint-Lambda-Funktion erkennt automatisch, ob die eingehenden Daten komprimiert oder dekomprimiert sind. Sie führt nur dann eine Dekomprimierung durch, wenn ihre Eingabedaten komprimiert sind.

1. Schalten Sie die Dekomprimierung mit der integrierten Firehose für die Dekomprimierung ein.

1. Aktivieren Sie CloudWatch Metriken für Ihren Firehose-Stream, falls er noch nicht aktiviert ist. Überwachen Sie die Metrik `CloudWatchProcessorLambda_IncomingCompressedData` und warten Sie, bis sich diese Metrik auf Null ändert. Dadurch wird bestätigt, dass alle an Ihre Lambda-Funktion gesendeten Eingabedaten dekomprimiert sind und die Lambda-Funktion nicht mehr benötigt wird.

1. Entfernen Sie die Lambda-Datentransformation, da Sie sie nicht mehr benötigen, um Ihren Stream zu dekomprimieren.

# Deaktivieren Sie die Dekomprimierung im Firehose-Stream
<a name="writing-with-cloudwatch-logs-decompression-disabling-console"></a>

****

Um die Dekomprimierung eines Datenstroms zu deaktivieren, verwenden Sie AWS-Managementkonsole

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Kinesis-Konsole unter [https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis).

1. Wählen Sie im Navigationsbereich **Amazon Data Firehose** aus.

1. Wählen Sie den Firehose-Stream aus, den Sie bearbeiten möchten.

1. Wählen Sie auf der Seite mit den **Firehose-Stream-Details** die Registerkarte **Konfiguration** aus.

1. Wählen Sie im Abschnitt **Datensätze transformieren und konvertieren** die Option **Bearbeiten**.

1. Deaktivieren Sie unter **Quelldatensätze aus Amazon CloudWatch Logs dekomprimieren** die Option **Dekomprimierung aktivieren** und wählen Sie dann Änderungen **speichern**.

# Fehlerbehebung bei der Dekomprimierung in Firehose
<a name="decomp-faq"></a>

Die folgende Tabelle zeigt, wie Firehose mit Fehlern bei der Datendekomprimierung und -verarbeitung umgeht, einschließlich der Übermittlung von Datensätzen an einen Fehler-S3-Bucket, der Protokollierung von Fehlern und der Ausgabe von Metriken. Es erklärt auch die Fehlermeldung, die bei nicht autorisierten Dateneingabevorgängen zurückgegeben wird.


| Problem | Lösung | 
| --- | --- | 
| Was passiert mit den Quelldaten im Falle eines Fehlers bei der Dekomprimierung? |  Wenn Amazon Data Firehose den Datensatz nicht dekomprimieren kann, wird der Datensatz unverändert (im komprimierten Format) an den Fehler S3-Bucket geliefert, den Sie bei der Erstellung des Firehose-Streams angegeben haben. Zusammen mit dem Datensatz enthält das gelieferte Objekt auch den Fehlercode und die Fehlermeldung. Diese Objekte werden an ein S3-Bucket-Präfix mit dem Namen gesendet. `decompression-failed` Firehose verarbeitet nach einer fehlgeschlagenen Dekomprimierung eines Datensatzes weiterhin andere Datensätze.  | 
| Was passiert mit den Quelldaten im Falle eines Fehlers in der Verarbeitungspipeline nach erfolgreicher Dekomprimierung? |  Wenn Amazon Data Firehose bei den Verarbeitungsschritten nach der Dekomprimierung Fehler macht, z. B. dynamische Partitionierung und Datenformatkonvertierung, wird der Datensatz in komprimiertem Format an den Fehler-S3-Bucket übermittelt, den Sie bei der Erstellung des Firehose-Streams angegeben haben. Zusammen mit dem Datensatz enthält das gelieferte Objekt auch einen Fehlercode und eine Fehlermeldung.  | 
| Wie werden Sie im Falle eines Fehlers oder einer Ausnahme informiert? |  Falls bei der Dekomprimierung ein Fehler oder eine Ausnahme auftritt und Sie CloudWatch Logs konfigurieren, protokolliert Firehose Fehlermeldungen in CloudWatch Logs. Darüber hinaus sendet Firehose Metriken an CloudWatch Metriken, die Sie überwachen können. Sie können optional auch Alarme erstellen, die auf von Firehose ausgegebenen Metriken basieren.  | 
| Was passiert, wenn put Operationen nicht aus CloudWatch Logs stammen? | Wenn der Kunde puts nicht aus den CloudWatch Logs kommt, wird die folgende Fehlermeldung zurückgegeben: <pre>Put to Firehose failed for AccountId: <accountID>, FirehoseName:  <firehosename> because the request is not originating from allowed source types.</pre> | 
| Welche Metriken gibt Firehose für die Dekomprimierungsfunktion aus? | Firehose gibt Metriken für die Dekomprimierung jedes Datensatzes aus. Sie sollten den Zeitraum (1 Minute), die Statistik (Summe) und den Datumsbereich auswählen, um die Anzahl der fehlgeschlagenen oder erfolgreichen oder DecompressedRecords fehlgeschlagenen oder erfolgreichen Daten zu ermitteln. DecompressedBytes Weitere Informationen finden Sie unter [CloudWatch Protokolliert Dekomprimierungsmetriken](monitoring-with-cloudwatch-metrics.md#decompression-metrics-cw). | 

# CloudWatch Ereignisse an Firehose senden
<a name="writing-with-cloudwatch-events"></a>

Sie können Amazon so konfigurieren, dass Ereignisse CloudWatch an einen Firehose-Stream gesendet werden, indem Sie einer CloudWatch Event-Regel ein Ziel hinzufügen.

**Um ein Ziel für eine CloudWatch Event-Regel zu erstellen, die Ereignisse an einen vorhandenen Firehose sendet**

1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Wählen Sie **Regel erstellen** aus.

1. Wählen Sie auf der Seite **Schritt 1: Regel erstellen** für **Ziele** die Option **Ziel hinzufügen** und dann **Firehose-Stream aus**.

1. Wählen Sie einen vorhandenen **Firehose-Stream** aus.

Weitere Informationen zum Erstellen von CloudWatch Event-Regeln finden Sie unter [Erste Schritte mit Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CWE_GettingStarted.html).

# So konfigurieren AWS IoT , dass Daten an Firehose gesendet werden
<a name="writing-with-iot"></a>

Sie können so konfigurieren AWS IoT , dass Informationen an einen Firehose-Stream gesendet werden, indem Sie eine Aktion hinzufügen.

**Um eine Aktion zu erstellen, die Ereignisse an einen vorhandenen Firehose sendet**

1. Wenn Sie eine Regel in der AWS IoT Konsole erstellen, wählen Sie auf der Seite **Regel erstellen** unter **Eine oder mehrere Aktionen festlegen** die Option **Aktion hinzufügen** aus.

1. Wählen Sie **Send messages to an Amazon Kinesis Firehose stream** (Senden von Nachrichten an einen Amazon-Kinesis-Firehose-Stream).

1. Wählen Sie **Configure action**.

1. Wählen Sie als **Streamname** einen vorhandenen Firehose aus. 

1. Wählen Sie für **Separator** ein Trennzeichen, das zwischen die Datensätze gesetzt werden soll.

1. Wählen Sie für **IAM role name** (IAM-Rollenname) eine vorhandene IAM;-Rolle oder wählen Sie **Create a new role** (Eine neue Rolle erstellen).

1. Wählen Sie **Aktion hinzufügen** aus.

Weitere Informationen zum Erstellen von AWS IoT Regeln finden Sie unter [Tutorials zu AWS IoT-Regeln](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules-tutorial.html).