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. # Verwendung der CloudTrail Processing Library Die CloudTrail Processing Library ist eine Java-Bibliothek, die eine einfache Möglichkeit bietet, AWS CloudTrail Logs zu verarbeiten. Sie geben Konfigurationsdetails zu Ihrer CloudTrail SQS-Warteschlange an und schreiben Code zur Verarbeitung von Ereignissen. Die CloudTrail Processing Library erledigt den Rest. Es fragt Ihre Amazon SQS SQS-Warteschlange ab, liest und analysiert Warteschlangennachrichten, lädt CloudTrail Protokolldateien herunter, analysiert Ereignisse in den Protokolldateien und übergibt die Ereignisse als Java-Objekte an Ihren Code. Die CloudTrail Processing Library ist hochgradig skalierbar und fehlertolerant. Sie verarbeitet Protokolldateien parallel, damit Sie so viele Protokolle verarbeiten können wie erforderlich. Sie verarbeitet Netzwerkausfälle im Zusammenhang mit Netzwerk-Timeouts und Ressourcen, auf die nicht zugegriffen werden kann. Das folgende Thema zeigt Ihnen, wie Sie die CloudTrail Processing Library verwenden, um CloudTrail Logs in Ihren Java-Projekten zu verarbeiten. Die Bibliothek wird als Apache-lizenziertes Open-Source-Projekt bereitgestellt, verfügbar unter:. GitHub [https://github.com/aws/aws-cloudtrail-processing-library](https://github.com/aws/aws-cloudtrail-processing-library) Die Bibliotheksquelle enthält Beispiel-Code, den Sie als Grundlage für Ihre eigenen Projekte verwenden können. **Topics** + [Mindestanforderungen](#use-the-cloudtrail-processing-library-prerequisites) + [Protokolle werden verarbeitet CloudTrail](#use-the-cloudtrail-processing-library-how-to) + [Erweiterte Themen](#use-the-cloudtrail-processing-library-advanced) + [Weitere Ressourcen](#UsingProcessingLib-ar) ## Mindestanforderungen Um die CloudTrail Processing Library verwenden zu können, benötigen Sie Folgendes: + [AWS SDK für Java 1.11.830](https://github.com/aws/aws-sdk-java) + [Java 1.8 (Java SE 8)](https://www.oracle.com/java/technologies/java-se-glance.html) ## Protokolle werden verarbeitet CloudTrail Um CloudTrail Logs in Ihrer Java-Anwendung zu verarbeiten: 1. [Hinzufügen der CloudTrail Processing Library zu Ihrem Projekt](#use-the-cloudtrail-processing-library-add-to-project) 1. [Konfiguration der CloudTrail Verarbeitungsbibliothek](#use-the-cloudtrail-processing-library-configure) 1. [Implementieren der Verarbeitungsausführung](#use-the-cloudtrail-processing-library-implement-events-processor) 1. [Instanziieren und Ausführen der Verarbeitungsausführung](#use-the-cloudtrail-processing-library-instantiate-and-run-executor) ### Hinzufügen der CloudTrail Processing Library zu Ihrem Projekt Um die CloudTrail Processing Library zu verwenden, fügen Sie sie dem Klassenpfad Ihres Java-Projekts hinzu. **Contents** + [Hinzufügen der Bibliothek zu einem Apache-Ant-Projekt](#use-the-cloudtrail-processing-library-add-to-project-apache-ant) + [Hinzufügen der Bibliothek zu einem Apache-Maven-Projekt](#use-the-cloudtrail-processing-library-add-to-project-apache-maven) + [Hinzufügen der Bibliothek zu einem Eclipse-Projekt](#use-the-cloudtrail-processing-library-add-to-project-eclipse) + [Hinzufügen der Bibliothek zu einem IntelliJ-Projekt](#use-the-cloudtrail-processing-library-add-to-intellij-project) #### Hinzufügen der Bibliothek zu einem Apache-Ant-Projekt **Um die CloudTrail Processing Library zu einem Apache Ant-Projekt hinzuzufügen** 1. Laden Sie den Quellcode der CloudTrail Processing Library herunter oder klonen Sie ihn von GitHub: + [https://github.com/aws/aws-cloudtrail-processing-library](https://github.com/aws/aws-cloudtrail-processing-library) 1. Erstellen Sie die JAR-Datei aus der Quelle, wie in der [README](https://github.com/aws/aws-cloudtrail-processing-library/blob/master/README.rst): ``` mvn clean install -Dgpg.skip=true ``` 1. Kopieren Sie die resultierende JAR-Datei in Ihr Projekt und fügen Sie sie zur Datei `build.xml` in Ihrem Projekt hinzu. Beispiel: ``` ``` #### Hinzufügen der Bibliothek zu einem Apache-Maven-Projekt Die CloudTrail Processing Library ist für [Apache Maven](https://maven.apache.org/) verfügbar. Sie können sie Ihrem Projekt hinzufügen, indem Sie in der `pom.xml`-Datei Ihres Projekts eine Einzelabhängigkeit schreiben. **Um die CloudTrail Processing Library zu einem Maven-Projekt hinzuzufügen** + Öffnen Sie die `pom.xml`-Datei Ihres Maven-Projekts und fügen Sie die folgende Abhängigkeit hinzu: ``` com.amazonaws aws-cloudtrail-processing-library 1.6.1 ``` #### Hinzufügen der Bibliothek zu einem Eclipse-Projekt **Um die CloudTrail Processing Library zu einem Eclipse-Projekt hinzuzufügen** 1. Laden Sie den Quellcode der CloudTrail Processing Library herunter oder klonen Sie ihn von GitHub: + [https://github.com/aws/aws-cloudtrail-processing-library](https://github.com/aws/aws-cloudtrail-processing-library) 1. Erstellen Sie die JAR-Datei aus der Quelle, wie in der [README](https://github.com/aws/aws-cloudtrail-processing-library/blob/master/README.rst)-Datei beschrieben: ``` mvn clean install -Dgpg.skip=true ``` 1. Kopieren Sie die erstellte aws-cloudtrail-processing-library Datei -1.6.1.jar in ein Verzeichnis in Ihrem Projekt (normalerweise). `lib` 1. Klicken Sie im Eclipse **Projekt-Explorer** mit der rechten Maustaste auf den Namen Ihres Projekts, wählen Sie **Pfad erstellen** und anschließend **Konfigurieren**. 1. Klicken Sie im Fenster **Java Build-Pfad** die Registerkarte **Bibliotheken**. 1. ** JARsWählen** Sie Hinzufügen... und navigieren Sie zu dem Pfad, in den Sie aws-cloudtrail-processing-library -1.6.1.jar kopiert haben. 1. Wähen Sie **OK**, um `.jar` Ihrem Projekt hinzuzufügen. #### Hinzufügen der Bibliothek zu einem IntelliJ-Projekt **Um die CloudTrail Processing Library zu einem IntelliJ-Projekt hinzuzufügen** 1. Laden Sie den Quellcode der CloudTrail Processing Library herunter oder klonen Sie ihn von: GitHub + [https://github.com/aws/aws-cloudtrail-processing-library](https://github.com/aws/aws-cloudtrail-processing-library) 1. Erstellen Sie die JAR-Datei aus der Quelle, wie in der [README](https://github.com/aws/aws-cloudtrail-processing-library/blob/master/README.rst): ``` mvn clean install -Dgpg.skip=true ``` 1. Wählen Sie in **Datei** die Option **Projektstruktur**. 1. Wählen Sie **Module** und anschließend **Abhängigkeiten**. 1. Wählen Sie **\$1 JARS oder Verzeichnisse** und navigieren Sie anschließend zu dem Pfad, in dem Sie `aws-cloudtrail-processing-library-1.6.1.jar` erstellt haben. 1. Wählen Sie **Anwenden** und anschließend **OK**, um die Hinzufügung von `.jar` zu Ihrem Projekt abzuschließen. ### Konfiguration der CloudTrail Verarbeitungsbibliothek Sie können die CloudTrail Verarbeitungsbibliothek konfigurieren, indem Sie eine Klassenpfad-Eigenschaftendatei erstellen, die zur Laufzeit geladen wird, oder indem Sie ein `ClientConfiguration` Objekt erstellen und Optionen manuell festlegen. #### Bereitstellen einer Eigenschaftendatei Sie können eine Klassenpfad-Eigenschaftendatei schreiben, die Konfigurationsoptionen zu Ihrer Anwendung bereitstellt. Die folgende Beispieldatei zeigt die Optionen, die Sie festlegen können: ``` # AWS access key. (Required) accessKey = your_access_key # AWS secret key. (Required) secretKey = your_secret_key # The SQS URL used to pull CloudTrail notification from. (Required) sqsUrl = your_sqs_queue_url # The SQS end point specific to a region. sqsRegion = us-east-1 # A period of time during which Amazon SQS prevents other consuming components # from receiving and processing that message. visibilityTimeout = 60 # The S3 region to use. s3Region = us-east-1 # Number of threads used to download S3 files in parallel. Callbacks can be # invoked from any thread. threadCount = 1 # The time allowed, in seconds, for threads to shut down after # AWSCloudTrailEventProcessingExecutor.stop() is called. If they are still # running beyond this time, they will be forcibly terminated. threadTerminationDelaySeconds = 60 # The maximum number of AWSCloudTrailClientEvents sent to a single invocation # of processEvents(). maxEventsPerEmit = 10 # Whether to include raw event information in CloudTrailDeliveryInfo. enableRawEventInfo = false # Whether to delete SQS message when the CloudTrail Processing Library is unable to process the notification. deleteMessageUponFailure = false ``` Die folgenden Parameter sind erforderlich: + `sqsUrl`— Stellt die URL bereit, von der Sie Ihre Benachrichtigungen abrufen können. CloudTrail Wenn Sie diesen Wert nicht angeben, gibt `AWSCloudTrailProcessingExecutor` eine `IllegalStateException` aus. + `accessKey`— Eine eindeutige Kennung für Ihr Konto, z. AKIAIOSFODNN7EXAMPLE B. + `secretKey`— Eine eindeutige Kennung für Ihr Konto, z. wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY B. Die `secretKey` Parameter `accessKey` und geben Ihre AWS Anmeldeinformationen für die Bibliothek an, sodass die Bibliothek in Ihrem Namen AWS darauf zugreifen kann. Die Standardwerte für die anderen Parameter werden von der Bibliothek festgelegt. Weitere Informationen finden Sie in der [AWS CloudTrail -Referenz zur Verarbeitungsbibliothek](https://docs.aws.amazon.com/awscloudtrail/latest/processinglib/). #### Erstellen eines ClientConfiguration Anstatt Optionen in den Klassenpfadeigenschaften festzulegen, können Sie Optionen für den `AWSCloudTrailProcessingExecutor` bereitstellen, indem Sie Optionen auf einem `ClientConfiguration`-Objekt initialisieren und festlegen, wie im folgenden Beispiel gezeigt: ``` ClientConfiguration basicConfig = new ClientConfiguration( "http://sqs.us-east-1.amazonaws.com/123456789012/queue2", new DefaultAWSCredentialsProviderChain()); basicConfig.setEnableRawEventInfo(true); basicConfig.setThreadCount(4); basicConfig.setnEventsPerEmit(20); ``` ### Implementieren der Verarbeitungsausführung Um CloudTrail Protokolle zu verarbeiten, müssen Sie einen implementieren`EventsProcessor`, der die CloudTrail Protokolldaten empfängt. Im Folgenden wird eine Beispielimplementierung gezeigt: ``` public class SampleEventsProcessor implements EventsProcessor { public void process(List events) { int i = 0; for (CloudTrailEvent event : events) { System.out.println(String.format("Process event %d : %s", i++, event.getEventData())); } } } ``` Bei der Implementierung von implementieren Sie den `process()` Callback, den der `AWSCloudTrailProcessingExecutor` verwendet, um Ihnen CloudTrail Ereignisse zu senden. `EventsProcessor` Ereignisse werden in einer Liste von `CloudTrailClientEvent`-Objekten bereitgestellt. Das `CloudTrailClientEvent` Objekt stellt ein Band `CloudTrailEvent` bereit`CloudTrailEventMetadata`, mit dem Sie die CloudTrail Ereignis- und Zustellungsinformationen lesen können. In diesem Beispiel werden die Ereignisinformationen zu den Ereignissen ausgegeben, die an die `SampleEventsProcessor` übergeben wurden. In Ihrer eigenen Implementierung können Sie Protokolle je nach Bedarf verarbeiten. Der `AWSCloudTrailProcessingExecutor` sendet solange Ereignisse an die `EventsProcessor`, wie er ausgeführt wird und Ereignisse zum Senden vorhanden sind. ### Instanziieren und Ausführen der Verarbeitungsausführung Nachdem Sie eine geschrieben `EventsProcessor` und Konfigurationswerte für die CloudTrail Processing Library festgelegt haben (entweder in einer Eigenschaftendatei oder mithilfe der `ClientConfiguration` Klasse), können Sie diese Elemente verwenden, um eine `AWSCloudTrailProcessingExecutor` zu initialisieren und zu verwenden. **Wird `AWSCloudTrailProcessingExecutor` zur Verarbeitung CloudTrail von Ereignissen verwendet** 1. Instantiieren Sie ein `AWSCloudTrailProcessingExecutor.Builder`-Objekt. Dem Konstruktor von `Builder` wird ein `EventsProcessor`-Objekt und der Name einer Klassenpfad-Eigenschaftendatei übergeben. 1. Rufen Sie die `Builder`-Factory-Methode im `build()` auf, um ein `AWSCloudTrailProcessingExecutor`-Objekt zu konfigurieren und abzurufen. 1. Verwenden Sie `AWSCloudTrailProcessingExecutor` die `stop()` Methoden `start()` und um die CloudTrail Ereignisverarbeitung zu starten und zu beenden. ``` public class SampleApp { public static void main(String[] args) throws InterruptedException { AWSCloudTrailProcessingExecutor executor = new AWSCloudTrailProcessingExecutor.Builder(new SampleEventsProcessor(), "/myproject/cloudtrailprocessing.properties").build(); executor.start(); Thread.sleep(24 * 60 * 60 * 1000); // let it run for a while (optional) executor.stop(); // optional } } ``` ## Erweiterte Themen **Topics** + [Filtern der zu verarbeitenden Ereignisse](#use-the-cloudtrail-processing-library-advanced-filter-events) + [Datenereignisverarbeitung](#use-the-cpl-advanced-integers-floats) + [Berichterstellung zum Fortschritt](#use-the-cloudtrail-processing-library-advanced-report-progress) + [Fehlerbehandlung](#use-the-cloudtrail-processing-library-advanced-handle-errors) ### Filtern der zu verarbeitenden Ereignisse Standardmäßig werden alle Protokolle im S3 Bucket der Amazon-SQS-Warteschlange und alle Ereignisse, die sie enthalten, an die `EventsProcessor` gesendet. Die CloudTrail Processing Library bietet optionale Schnittstellen, die Sie implementieren können, um die Quellen zu filtern, die zum Abrufen von CloudTrail Protokollen verwendet werden, und um die Ereignisse zu filtern, die Sie verarbeiten möchten. `SourceFilter` Sie können die `SourceFilter`-Schnittstelle implementieren, um zu wählen, ob Sie die Protokolle aus einer bereitgestellten Quelle verarbeiten möchten. `SourceFilter` deklariert eine einzelne Rückruf-Methode (`filterSource()`), die ein `CloudTrailSource`-Objekt abruft. Wenn Ereignisse aus einer bestimmten Quelle nicht verarbeitet werden sollen, geben Sie `false` über `filterSource()` zurück. Die CloudTrail Processing Library ruft die `filterSource()` Methode auf, nachdem die Bibliothek nach Protokollen in der Amazon SQS-Warteschlange gesucht hat. Dies erfolgt, bevor die Bibliothek mit dem Filtern von Ereignissen oder der Verarbeitung für die Protokolle beginnt. Im Folgenden wird eine Beispielimplementierung gezeigt: ``` public class SampleSourceFilter implements SourceFilter{ private static final int MAX_RECEIVED_COUNT = 3; private static List accountIDs ; static { accountIDs = new ArrayList<>(); accountIDs.add("123456789012"); accountIDs.add("234567890123"); } @Override public boolean filterSource(CloudTrailSource source) throws CallbackException { source = (SQSBasedSource) source; Map sourceAttributes = source.getSourceAttributes(); String accountId = sourceAttributes.get( SourceAttributeKeys.ACCOUNT_ID.getAttributeKey()); String receivedCount = sourceAttributes.get( SourceAttributeKeys.APPROXIMATE_RECEIVE_COUNT.getAttributeKey()); int approximateReceivedCount = Integer.parseInt(receivedCount); return approximateReceivedCount <= MAX_RECEIVED_COUNT && accountIDs.contains(accountId); } } ``` Wenn Sie keinen eigenen `SourceFilter` bereitstellen, wird `DefaultSourceFilter` verwendet. In diesem Fall können alle Quellen verarbeitet werden (es wird stets `true` ausgegeben). `EventFilter` Sie können die `EventFilter`-Schnittstelle implementieren, um zu wählen, ob ein CloudTrail-Ereignis an `EventsProcessor` gesendet wird. `EventFilter` deklariert eine einzelne Rückruf-Methode (`filterEvent()`), die ein `CloudTrailEvent`-Objekt abruft. Wenn das Ereignis nicht verarbeitet werden soll, geben Sie `false` über `filterEvent()` zurück. Die CloudTrail Processing Library ruft die `filterEvent()` Methode auf, nachdem die Bibliothek nach Protokollen in der Amazon SQS-Warteschlange gesucht hat und nach der Quellfilterung. Dies erfolgt, bevor die Bibliothek mit der Verarbeitung für die Protokolle beginnt. Im Folgenden wird eine Beispielimplementierung gezeigt: ``` public class SampleEventFilter implements EventFilter{ private static final String EC2_EVENTS = "ec2.amazonaws.com"; @Override public boolean filterEvent(CloudTrailClientEvent clientEvent) throws CallbackException { CloudTrailEvent event = clientEvent.getEvent(); String eventSource = event.getEventSource(); String eventName = event.getEventName(); return eventSource.equals(EC2_EVENTS) && eventName.startsWith("Delete"); } } ``` Wenn Sie keinen eigenen `EventFilter` bereitstellen, wird `DefaultEventFilter` verwendet. In diesem Fall können alle Ereignisse verarbeitet werden (es wird stets `true` ausgegeben). ### Datenereignisverarbeitung Bei der CloudTrail Verarbeitung von Datenereignissen werden Zahlen in ihrem ursprünglichen Format beibehalten, unabhängig davon, ob es sich um eine Ganzzahl (`int`) oder eine Zahl handelt `float` (eine Zahl, die eine Dezimalzahl enthält). Bei Ereignissen, die ganze Zahlen in den Feldern eines Datenereignisses enthielten, wurden diese Zahlen in der CloudTrail Vergangenheit als Gleitkommazahlen verarbeitet. Derzeit CloudTrail werden Zahlen in diesen Feldern unter Beibehaltung ihres ursprünglichen Formats verarbeitet. Um zu verhindern, dass Ihre Automatisierungen beschädigt werden, sollten Sie bei jedem Code oder jeder Automatisierung, die Sie zum Verarbeiten oder Filtern von CloudTrail Datenereignissen verwenden, flexibel sein `int` und beides sowie `float` formatierte Zahlen zulassen. Optimale Ergebnisse erzielen Sie, wenn Sie Version 1.4.0 oder höher der CloudTrail Processing Library verwenden. Der folgende Beispielausschnitt zeigt eine `float` formatierte Zahl,`2.0`, für den Parameter `desiredCount` im `ResponseParameters`-Block eines Datenereignisses. ``` "eventName": "CreateService", "awsRegion": "us-east-1", "sourceIPAddress": "000.00.00.00", "userAgent": "console.amazonaws.com", "requestParameters": { "clientToken": "EXAMPLE", "cluster": "default", "desiredCount": 2.0 ... ``` Der folgende Beispielausschnitt zeigt eine `int` formatierte Zahl, `2`, für den Parameter `desiredCount` im `ResponseParameters`-Block eines Datenereignisses. ``` "eventName": "CreateService", "awsRegion": "us-east-1", "sourceIPAddress": "000.00.00.00", "userAgent": "console.amazonaws.com", "requestParameters": { "clientToken": "EXAMPLE", "cluster": "default", "desiredCount": 2 ... ``` ### Berichterstellung zum Fortschritt Implementieren Sie die `ProgressReporter` Schnittstelle, um die Berichterstattung über den Fortschritt der CloudTrail Processing Library individuell anzupassen. `ProgressReporter`deklariert zwei Methoden: `reportStart()` und`reportEnd()`, die am Anfang und am Ende der folgenden Operationen aufgerufen werden: + Abrufen von Nachrichten aus Amazon SQS + Analyse von Nachrichten aus Amazon SQS + Verarbeitung einer Amazon SQS SQS-Quelle für Protokolle CloudTrail + Löschen von Nachrichten aus Amazon SQS + Eine CloudTrail Protokolldatei wird heruntergeladen + Eine CloudTrail Protokolldatei wird verarbeitet Beide Methoden erhalten ein `ProgressStatus`-Objekt mit Informationen zum Vorgang, der ausgeführt wurde. Das `progressState`-Element enthält ein Mitglied der `ProgressState`-Aufzählung, die den aktuellen Vorgang identifiziert. Dieses Element kann zusätzliche Informationen im `progressInfo`-Element enthalten. Darüber hinaus werden alle Objekte, die Sie aus `reportStart()` zurückgeben, an `reportEnd()` übergeben, sodass Sie kontextbezogene Informationen wie die Startzeit der Ereignisverarbeitung bereitstellen können. Im Folgenden finden Sie eine Beispielimplementierung, bei der Informationen zu der für den Vorgang benötigten Zeitdauer bereitgestellt werden: ``` public class SampleProgressReporter implements ProgressReporter { private static final Log logger = LogFactory.getLog(DefaultProgressReporter.class); @Override public Object reportStart(ProgressStatus status) { return new Date(); } @Override public void reportEnd(ProgressStatus status, Object startDate) { System.out.println(status.getProgressState().toString() + " is " + status.getProgressInfo().isSuccess() + " , and latency is " + Math.abs(((Date) startDate).getTime()-new Date().getTime()) + " milliseconds."); } } ``` Wenn Sie keinen eigenen `ProgressReporter` implementieren, wird `DefaultExceptionHandler` verwendet. Dabei wird stattdessen der Name des ausgeführten Status verwendet. ### Fehlerbehandlung Die `ExceptionHandler`-Schnittstelle ermöglicht Ihnen die Bereitstellung einer speziellen Verarbeitung, wenn während der Protokollverarbeitung eine Ausnahme auftritt. `ExceptionHandler` deklariert eine Rückruf-Methode (`handleException()`), der ein `ProcessingLibraryException`-Objekt mit Kontextinformationen zur aufgetretenen Ausnahme übergeben wird. Sie können die übergebene `ProcessingLibraryException`-Methode `getStatus()` verwenden, um zu ermitteln, welche Operation ausgeführt wurde, als die Ausnahme auftrat, und um zusätzliche Informationen zum Status der Operation abzurufen. `ProcessingLibraryException` ist von der `Exception` -Standardklasse von Java abgeleitet, sodass Sie Informationen zur Ausnahme abrufen können, indem eine der Ausnahmemethoden abgerufen wird. Im Folgenden wird eine Beispielimplementierung gezeigt: ``` public class SampleExceptionHandler implements ExceptionHandler{ private static final Log logger = LogFactory.getLog(DefaultProgressReporter.class); @Override public void handleException(ProcessingLibraryException exception) { ProgressStatus status = exception.getStatus(); ProgressState state = status.getProgressState(); ProgressInfo info = status.getProgressInfo(); System.err.println(String.format( "Exception. Progress State: %s. Progress Information: %s.", state, info)); } } ``` Wenn Sie keinen eigenen `ExceptionHandler` bereitstellen, wird `DefaultExceptionHandler` verwendet. Dabei wird stattdessen eine Standardfehlermeldung verwendet. **Anmerkung** Ist der `deleteMessageUponFailure` Parameter gleich`true`, unterscheidet die CloudTrail Processing Library nicht zwischen allgemeinen Ausnahmen und Verarbeitungsfehlern und löscht möglicherweise Warteschlangenmeldungen. Beispielsweise verwenden Sie den `SourceFilter`, um Nachrichten nach Zeitstempel zu filtern. Sie verfügen jedoch nicht über die erforderlichen Berechtigungen für den Zugriff auf den S3-Bucket, der die CloudTrail Protokolldateien empfängt. Da Sie nicht die erforderlichen Berechtigungen besitzen, wird eine `AmazonServiceException` ausgelöst. Die CloudTrail Processing Library verpackt dies in eine`CallBackException`. Der `DefaultExceptionHandler` protokolliert dies als einen Fehler, identifiziert jedoch nicht die Ursache, d. h., dass Sie die erforderlichen Berechtigungen nicht besitzen. Die CloudTrail Verarbeitungsbibliothek betrachtet dies als Verarbeitungsfehler und löscht die Nachricht, auch wenn die Nachricht eine gültige CloudTrail Protokolldatei enthält. Wenn Sie Nachrichten mit `SourceFilter` filtern möchten, müssen Sie überprüfen, ob Ihr `ExceptionHandler` zwischen Service-Ausnahmen und Verarbeitungsfehlern unterscheiden kann. ## Weitere Ressourcen Weitere Informationen zur CloudTrail Processing Library finden Sie im Folgenden: + [CloudTrail Processing GitHub Library-Projekt](https://github.com/aws/aws-cloudtrail-processing-library), das [Beispielcode](https://github.com/aws/aws-cloudtrail-processing-library/tree/master/src/sample) enthält, der veranschaulicht, wie eine CloudTrail Processing Library-Anwendung implementiert wird. + [CloudTrail Dokumentation zum Java-Paket der Verarbeitungsbibliothek](https://docs.aws.amazon.com/awscloudtrail/latest/processinglib/).