

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.

# Analysieren Sie Bucket-Zugriffsprotokolle mit Amazon Athena in Lightsail
<a name="amazon-lightsail-using-bucket-access-logs"></a>

In dieser Anleitung zeigen wir Ihnen, wie Sie Anforderungen an einen Bucket mithilfe von Zugriffsprotokollen identifizieren können. Weitere Informationen finden Sie unter [Bucketzugriffsprotokolle](amazon-lightsail-bucket-access-logs.md).

**Inhalt**
+ [Abfragen von Zugriffsprotokollen für Anfragen mit Amazon Athena](#querying-access-logs-for-requests)
+ [Verwenden von Amazon-S3-Zugriffsprotokollen zum Identifizieren von Objektzugriffsanforderungen](#identifying-object-access-requests)

## Abfragen von Zugriffsprotokollen für Anfragen mit Amazon Athena
<a name="querying-access-logs-for-requests"></a>

Sie können Amazon Athena verwenden, um Anfragen an einen Bucket in Zugriffsprotokollen abzufragen und zu identifizieren.

Lightsail speichert Zugriffsprotokolle als Objekte in einem Lightsail-Bucket. Es ist oft einfacher, ein Tool zu verwenden, mit dem die Protokolle analysiert werden können. Athena unterstützt die Analyse von Objekten und kann zur Abfrage von Zugriffsprotokollen verwendet werden.

**Beispiel**

Das folgende Beispiel zeigt, wie Sie Bucket-Server-Zugriffsprotokolle in Amazon Athena abfragen können.

**Anmerkung**  
Um einen Speicherort in einer Athena-Abfrage anzugeben, müssen Sie den Bucket-Namen des Ziel und das Präfix des Ziels, an das Ihre Protokolle als S3-URI übermittelt werden, wie folgt formatieren: `s3://amzn-s3-demo-bucket1-logs/prefix/`

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).

1. Führen Sie im **Abfrage-Editor** einen Befehl wie den folgenden aus.

   ```
   create database bucket_access_logs_db
   ```
**Anmerkung**  
Es hat sich bewährt, die Datenbank in derselben Datenbank AWS-Region wie Ihren S3-Bucket zu erstellen.

1. Führen Sie im **Abfrage-Editor** einen Befehl wie den folgenden aus, um in der in Schritt 2 erstellten Datenbank ein Tabellenschema zu erstellen. Die Datentypwerte `STRING` und `BIGINT` sind die Zugriffsprotokolleigenschaften. Sie können diese Eigenschaften in Athena abfragen. Geben Sie für `LOCATION` wie oben erwähnt den Pfad von Bucket und Präfix ein.

   ```
   CREATE EXTERNAL TABLE `s3_access_logs_db.amzn-s3-demo-bucket_logs`(
     `bucketowner` STRING, 
     `bucket_name` STRING, 
     `requestdatetime` STRING, 
     `remoteip` STRING, 
     `requester` STRING, 
     `requestid` STRING, 
     `operation` STRING, 
     `key` STRING, 
     `request_uri` STRING, 
     `httpstatus` STRING, 
     `errorcode` STRING, 
     `bytessent` BIGINT, 
     `objectsize` BIGINT, 
     `totaltime` STRING, 
     `turnaroundtime` STRING, 
     `referrer` STRING, 
     `useragent` STRING, 
     `versionid` STRING, 
     `hostid` STRING, 
     `sigv` STRING, 
     `ciphersuite` STRING, 
     `authtype` STRING, 
     `endpoint` STRING, 
     `tlsversion` STRING)
   ROW FORMAT SERDE 
     'org.apache.hadoop.hive.serde2.RegexSerDe' 
   WITH SERDEPROPERTIES ( 
     'input.regex'='([^ ]*) ([^ ]*) \\[(.*?)\\] ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) (-|[0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) ([^ ]*)(?: ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*))?.*$') 
   STORED AS INPUTFORMAT 
     'org.apache.hadoop.mapred.TextInputFormat' 
   OUTPUTFORMAT 
     'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
   LOCATION
     's3://amzn-s3-demo-bucket1-logs/prefix/'
   ```

1. Wählen Sie im Navigationsbereich unter **Database (Datenbank)** die Datenbank aus.

1. Wählen Sie unter **Tables (Tabellen)**neben dem Namen der Tabelle **Preview table (Tabellenvorschau)** aus.

   Im Fensterbereich **Results (Ergebnisse)** sollten Daten aus den Server-Zugriffsprotokollen angezeigt werden, also `bucketowner`, `bucket`, `requestdatetime` usw. Dies bedeutet, dass die Athena-Tabelle erfolgreich erstellt wurde. Sie können die Bucket-Server-Zugriffsprotokolle jetzt abfragen.

**Beispiel – Anzeigen, wer ein Objekt um welche Uhrzeit (Zeitstempel, IP-Adresse und IAM-Benutzer) gelöscht hat**

```
SELECT RequestDateTime, RemoteIP, Requester, Key 
FROM s3_access_logs_db.amzn-s3-demo-bucket_logs 
WHERE key = 'images/picture.jpg' AND operation like '%DELETE%';
```

**Beispiel – Anzeigen aller Vorgänge, die von einem IAM-Benutzer ausgeführt wurden**

```
SELECT * 
FROM s3_access_logs_db.amzn-s3-demo-bucket_logs 
WHERE requester='arn:aws:iam::123456789123:user/user_name';
```

**Beispiel – Anzeigen aller Vorgänge, die in einem bestimmten Zeitraum für ein Objekt ausgeführt wurden**

```
SELECT *
FROM s3_access_logs_db.amzn-s3-demo-bucket_logs
WHERE Key='prefix/images/picture.jpg' 
    AND parse_datetime(RequestDateTime,'dd/MMM/yyyy:HH:mm:ss Z')
    BETWEEN parse_datetime('2017-02-18:07:00:00','yyyy-MM-dd:HH:mm:ss')
    AND parse_datetime('2017-02-18:08:00:00','yyyy-MM-dd:HH:mm:ss');
```

**Beispiel – Anzeigen der Menge der von einer bestimmten IP-Adresse in einem bestimmten Zeitraum übertragenen Daten**

```
SELECT SUM(bytessent) AS uploadTotal,
      SUM(objectsize) AS downloadTotal,
      SUM(bytessent + objectsize) AS Total
FROM s3_access_logs_db.amzn-s3-demo-bucket_logs
WHERE RemoteIP='1.2.3.4'
AND parse_datetime(RequestDateTime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2017-06-01','yyyy-MM-dd')
AND parse_datetime('2017-07-01','yyyy-MM-dd');
```

## Verwenden von Amazon-S3-Zugriffsprotokollen zum Identifizieren von Objektzugriffsanforderungen
<a name="identifying-object-access-requests"></a>

Sie können Abfragen an Zugriffsprotokolle verwenden, um Objektzugriffsanforderungen für Operationen zu identifizieren, wie etwa *GET*, *PUT* und *DELETE* und weitere Informationen über diese Anforderungen zu erkunden.

Das folgende Amazon-Athena-Abfragebeispiel zeigt, wie alle `PUT`-Objektanfragen für einen Bucket aus dem Server-Zugriffsprotokoll abgerufen werden.

**Beispiel – Anzeigen aller Anforderer, die PUT-Objektanforderungen in einem bestimmten Zeitraum senden**

```
SELECT Bucket, Requester, RemoteIP, Key, HTTPStatus, ErrorCode, RequestDateTime
FROM s3_access_logs_db
WHERE Operation='REST.PUT.OBJECT' AND
parse_datetime(RequestDateTime,'dd/MMM/yyyy:HH:mm:ss Z') 
BETWEEN parse_datetime('2019-07-01:00:42:42','yyyy-MM-dd:HH:mm:ss')
AND 
parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```

Das folgende Amazon Athena-Abfragebeispiel zeigt, wie alle GET-Objektanfragen für Amazon S3 aus dem Server-Zugriffsprotokoll abgerufen werden.

**Beispiel – Anzeigen aller Anforderer, die GET-Objektanforderungen in einem bestimmten Zeitraum senden**

```
SELECT Bucket, Requester, RemoteIP, Key, HTTPStatus, ErrorCode, RequestDateTime
FROM s3_access_logs_db
WHERE Operation='REST.GET.OBJECT' AND
parse_datetime(RequestDateTime,'dd/MMM/yyyy:HH:mm:ss Z') 
BETWEEN parse_datetime('2019-07-01:00:42:42','yyyy-MM-dd:HH:mm:ss')
AND 
parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```

Das folgende Amazon Athena-Abfragebeispiel zeigt, wie alle anonymen Anforderungen aus dem Server-Zugriffsprotokoll in Ihre S3-Buckets gelangen.

**Beispiel – Anzeigen aller anonymen Anforderer, die in einem bestimmten Zeitraum Anforderungen an einen Bucket richten**

```
SELECT Bucket, Requester, RemoteIP, Key, HTTPStatus, ErrorCode, RequestDateTime
FROM s3_access_logs_db.amzn-s3-demo-bucket_logs
WHERE Requester IS NULL AND
parse_datetime(RequestDateTime,'dd/MMM/yyyy:HH:mm:ss Z') 
BETWEEN parse_datetime('2019-07-01:00:42:42','yyyy-MM-dd:HH:mm:ss')
AND 
parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```

**Anmerkung**  
Sie können den Datumsbereich an Ihre Anforderungen anpassen.
Diese Abfragebeispiele können auch für die Sicherheitsüberwachung nützlich sein. Sie können die Ergebnisse von `PutObject` oder `GetObject` Aufrufen von unerwarteten oder nicht autorisierten IP-Adressen überprüfen addresses/requesters und alle anonymen Anfragen an Ihre Buckets identifizieren.
Diese Abfrage ruft nur Informationen von der Zeit ab, zu der die Protokollierung aktiviert wurde.