Nutzungs- und Speicherlogs

In diesem Dokument wird erklärt, wie Sie Nutzungslogs und Speicherinformationen für Cloud Storage-Buckets herunterladen und mit Google BigQuery analysieren.

Einführung

Cloud Storage bietet Nutzungs- und Speicherlogs in Form von CSV-Dateien, die Sie herunterladen und sich ansehen können. Die stündlich erstellten Nutzungslogs enthalten Informationen zu allen Anfragen, die an einen bestimmten Bucket gestellt wurden. Die täglichen Speicherlogs liefern Informationen zum Speicherverbrauch dieses Buckets für den letzten Tag.

Nutzungs- und Speicherlogs werden nach der Einrichtung automatisch in dem von Ihnen bestimmten Bucket als neue Objekte erstellt.

Für Nutzungs- und Speicherlogs gelten dieselben Preise wie für andere in Cloud Storage gespeicherte Objekte.

Sollten Sie Nutzungslogs oder Cloud-Audit-Logs verwenden?

In den meisten Fällen ist Cloud-Audit-Logs die empfohlene Methode zum Erstellen von Logs, mit denen in Cloud Storage ausgeführte API-Vorgänge erfasst werden:

Cloud-Audit-Logs erfasst den Zugriff auf kontinuierliche Weise, wobei Ereignisse innerhalb von Sekunden nach ihrem Auftreten zugestellt werden.
Cloud-Audit-Logs erzeugt Logs, mit denen Sie einfacher arbeiten können.
Cloud-Audit-Logs können viele Ihrer Google Cloud-Dienste überwachen, nicht nur Cloud Storage.
In Cloud-Audit-Logs können optional detaillierte Informationen zu Anfragen und Antworten erfasst werden.

In einigen Fällen möchten Sie möglicherweise Nutzungslogs anstelle oder zusätzlich zu Cloud-Audit-Logs verwenden. Die Verwendung von Nutzungslogs eignet sich in der Regel in folgenden Situationen:

Sie möchten den Zugriff verfolgen, weil eine Ressource allUsers oder allAuthenticatedUsers in den Einstellungen der Zugriffssteuerung enthält, z. B. Zugriff auf Assets in einem Bucket, den Sie als statische Website konfiguriert haben.
Sie möchten durch die Verwaltung des Objektlebenszyklus oder die Autoclass-Funktionen vorgenommene Änderungen verfolgen.
Sie möchten authentifizierte Browserdownloads verwenden, um auf Objekte im Bucket zuzugreifen.
Sie möchten, dass Ihre Logs Latenzinformationen, die Größe von Anfragen und Antworten einzelner HTTP-Anfragen oder den vollständigen URL-Pfad und jeden Abfrageparameter enthalten.
Sie möchten den Zugriff nur auf bestimmte Buckets in Ihrem Projekt verfolgen und keine Audit-Logs zum Datenzugriff aktivieren, die den Zugriff auf alle Buckets in Ihrem Projekt verfolgen.

Beachten Sie, dass Nutzungslogs nur stündlich erstellt werden und verzögert sein können, insbesondere bei Berichten über Buckets mit hohen Anfrageraten.

Sollten Sie Speicherlogs oder Monitoring verwenden?

Im Allgemeinen sollten Sie keine Speicherlogs verwenden. Monitoring wird zur Messung des Speicherverbrauchs empfohlen. Es bietet Visualisierungstools sowie zusätzliche Messwerte zum Speicherverbrauch, die in Speicherlogs nicht berücksichtigt werden. Auf dem Console-Tab zur Bestimmung der Größe eines Buckets finden Sie eine Schritt-für-Schritt-Anleitung für die Verwendung von Monitoring.

Logübermittlung einrichten

Wenn Sie die Logbereitstellung einrichten, werden für den angegebenen Bucket sowohl Nutzungs- als auch Speicherlogs generiert. In den folgenden Schritten wird beschrieben, wie Sie die Logbereitstellung für einen Bucket einrichten. Falls Sie noch keinen Bucket haben, den Sie zum Speichern von Logs verwenden möchten, erstellen Sie den Bucket.

Befehlszeile

Weisen Sie Cloud Storage die Rolle roles/storage.objectCreator für den Bucket zu.
```
gcloud storage buckets add-iam-policy-binding gs://example-logs-bucket --member=group:cloud-storage-analytics@google.com --role=roles/storage.objectCreator
```
Die Rolle gewährt Cloud Storage, in Form der Gruppe cloud-storage-analytics@google.com, die Berechtigung, Ihre Logs als neue Objekte zu erstellen und zu speichern.

Logobjekte haben die Standard-Objekt-ACL des Log-Buckets, es sei denn, für den Bucket ist der einheitliche Zugriff auf Bucket-Ebene aktiviert.
Aktivieren Sie mit dem --log-bucket-Flag das Logging für Ihren Bucket:
```
gcloud storage buckets update gs://example-bucket --log-bucket=gs://example-logs-bucket [--log-object-prefix=log_object_prefix]
```
Optional können Sie mit dem --log-object-prefix-Flag ein Objektpräfix für Ihre Logobjekte festlegen. Dieses Präfix bildet den Anfang des Logobjektnamens. Es darf maximal 900 Zeichen umfassen und muss ein gültiger Objektname sein. Standardmäßig ist das Objektpräfix der Name des Buckets, für den die Logs aktiviert werden.

REST APIs

JSON API

Weisen Sie Cloud Storage die Rolle roles/storage.objectCreator für den Bucket zu. Wenn es für den Bucket zusätzliche IAM-Bindungen auf Bucket-Ebene gibt, achten Sie darauf, diese in die Anfrage aufzunehmen.
```
POST /storage/v1/b/example-logs-bucket/iam
Host: storage.googleapis.com
{
  "bindings":[
    {
      "role": "roles/storage.objectCreator",
      "members":[
        "group-cloud-storage-analytics@google.com"
      ]
    }
  ]
}
```
Die Rolle gewährt Cloud Storage, in Form der Gruppe cloud-storage-analytics@google.com, die Berechtigung, Ihre Logs als neue Objekte zu erstellen und zu speichern.

Logobjekte haben die Standard-Objekt-ACL des Log-Buckets, es sei denn, für den Bucket ist der einheitliche Zugriff auf Bucket-Ebene aktiviert.

Aktivieren Sie mit der folgenden Anfrage Logging für Ihren Bucket:

PATCH /storage/v1/b/example-bucket
Host: storage.googleapis.com

{
 "logging": {
  "logBucket": "example-logs-bucket",
  "logObjectPrefix": "log_object_prefix"
 }
}

XML API

Legen Sie Berechtigungen fest, um Cloud Storage die Berechtigung WRITE für den Bucket zu gewähren, damit Ihre Logs als neue Objekte erstellt und gespeichert werden. Sie müssen einen ACL-Eintrag für den Bucket hinzufügen, der der Gruppe cloud-storage-analytics@google.com Schreibzugriff gewährt. Achten Sie darauf, dass die Anfrage alle vorhandenen ACLs für den Bucket sowie die neue ACL enthält.
```
PUT /example-logs-bucket?acl HTTP/1.1
Host: storage.googleapis.com

<AccessControlList>
  <Entries>
    <Entry>
      <Scope type="GroupByEmail">
        <EmailAddress>cloud-storage-analytics@google.com</EmailAddress>
      </Scope>
     <Permission>WRITE</Permission>
    </Entry>
    
  </Entries>
</AccessControlList>
```

Aktivieren Sie Logging für Ihren Bucket mithilfe des Logging-Abfrageparameters:

PUT /example-bucket?logging HTTP/1.1
Host: storage.googleapis.com

<Logging>
    <LogBucket>example-logs-bucket</LogBucket>
    <LogObjectPrefix>log_object_prefix</LogObjectPrefix>
</Logging>

Logging-Status prüfen

Befehlszeile

Prüfen Sie das Logging mit dem buckets describe-Befehl mit dem --format-Flag:

gcloud storage buckets describe gs://example-bucket --format="default(logging_config)"

Außerdem können Sie die Logging-Konfiguration in einer Datei speichern:

gcloud storage buckets describe gs://example-bucket > your_logging_configuration_file --format="default(logging_config)"

Wenn das Logging aktiviert ist, gibt der Server in der Antwort die Logging-Konfiguration zurück:

logging:
  logBucket: example-logs-bucket
  logObjectPrefix: log_object_prefix

Ist das Logging nicht aktiviert, wird Folgendes zurückgegeben:

null

REST APIs

JSON API

Senden Sie eine GET-Anfrage für die Logging-Konfiguration des Buckets, wie im folgenden Beispiel gezeigt:

GET /storage/v1/b/example-bucket?fields=logging
Host: storage.googleapis.com

Wenn das Logging aktiviert ist, sendet der Server die Konfiguration in der Antwort. Eine Antwort könnte so aussehen:

{
 "logging": {
  "logBucket": "example-logs-bucket",
  "logObjectPrefix": "log_object_prefix"
  }
}

Ist das Logging nicht aktiviert, wird eine leere Konfiguration zurückgegeben:

{}

XML API

Senden Sie eine GET-Bucket-Anfrage für die Logging-Konfiguration des Buckets, wie im folgenden Beispiel gezeigt:

GET /example-bucket?logging HTTP/1.1
Host: storage.googleapis.com

Wenn das Logging aktiviert ist, sendet der Server die Konfiguration in der Antwort. Eine Antwort könnte so aussehen:

<?xml version="1.0" ?>
<Logging>
    <LogBucket>
        example-logs-bucket
    </LogBucket>
    <LogObjectPrefix>
        log_object_prefix
    </LogObjectPrefix>
</Logging>

Ist das Logging nicht aktiviert, wird eine leere Konfiguration zurückgegeben:

<?xml version="1.0" ?>
<Logging/>

Logs herunterladen

Speicherlogs werden einmal pro Tag erstellt und geben die Menge des Speicherplatzes an, die am Vortag genutzt wurde. In der Regel werden sie vor 19:00 Uhr MEZ generiert.

Nutzungslogs werden stündlich erstellt, wenn es in dem überwachten Bucket Aktivitäten gibt. Nutzungslogs werden normalerweise 15 Minuten nach Ablauf der Stunde generiert.

Hinweis:

Bei der Verarbeitung von Nutzungs-Logs sollten Sie berücksichtigen, dass diese später als 15 Minuten nach Ablauf einer Stunde gesendet werden können.
Normalerweise enthalten stündliche Nutzungslogobjekte Datensätze für alle Zugriffe während dieser Stunde. Es kann vorkommen, dass ein stündliches Nutzungs-Log-Objekt Datensätze für eine frühere Stunde enthält, jedoch niemals solche für eine spätere Stunde.
Cloud Storage kann mehrere Log-Objekte für dieselbe Stunde schreiben.
Gelegentlich tritt ein Datensatz zweimal in den Nutzungs-Logs auf. Wir bemühen uns zwar, doppelte Datensätze zu entfernen, aber Ihre Logverarbeitung sollte in der Lage sein, diese zu löschen, wenn das für Ihre Loganalyse wichtig ist. Über das Feld s_request_id lassen sich Duplikate ermitteln.

Am einfachsten können Sie Nutzungs- und Speicherlogs über den Bucket herunterladen, in dem sie gespeichert sind. Verwenden Sie dazu Google Cloud Console oder gcloud storage Befehlszeile. Die Nutzungslogs werden im CSV-Format erstellt und so benannt:

OBJECT_PREFIX_usage_TIMESTAMP_ID_v0

Speicherlogs werden folgendermaßen benannt:

OBJECT_PREFIX_storage_TIMESTAMP_ID_v0

Im Folgenden finden Sie beispielsweise den Namen eines Nutzungs-Log-Objekts, das das Standardobjektpräfix verwendet, das die Verwendung des Buckets mit dem Namen example-bucket meldet und am 18. Juni 2022 um 14:00 Uhr UTC erstellt wurde:

example-bucket_usage_2022_06_18_14_00_00_1702e6_v0

Ebenso lautet der Name des Speicher-Log-Objekts, das das Standardobjekt-Präfix verwendet und am 18. Juni 2022 für denselben Bucket erstellt wurde so:

example-bucket_storage_2022_06_18_07_00_00_1702e6_v0

So laden Sie Logs herunter:

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Wählen Sie den Bucket aus, in dem Ihre Logs gespeichert sind.
Laden Sie Ihre Logs herunter oder zeigen Sie sie an, indem Sie auf das entsprechende Log-Objekt klicken.

Befehlszeile

Führen Sie dazu diesen Befehl aus:

gcloud storage cp gs://BUCKET_NAME/LOGS_OBJECT DESTINATION

Dabei gilt:

BUCKET_NAME ist der Name des Buckets, in dem die Logs gespeichert werden. Beispiel: example-logs-bucket.
LOGS_OBJECT ist der Name des Nutzungs- oder Speicherlogs, das Sie herunterladen. Beispiel: example-bucket_usage_2022_06_18_14_00_00_1702e6_v0
DESTINATION ist der Speicherort, in den das Log heruntergeladen wird. Beispiel: Desktop/Logs.

Logs in BigQuery analysieren

Um Ihre Cloud Storage-Nutzung und Speicher-Logs abzufragen, können Sie Google BigQuery verwenden, das schnelle, SQL-ähnliche Abfragen in Tabellen ermöglicht, für die nur Anfügungen zulässig sind. Das BigQuery-Befehlszeilentool bq basiert auf Python und ermöglicht es Ihnen, über die Befehlszeile auf BigQuery zuzugreifen. Informationen zum Herunterladen und Verwenden von bq finden Sie auf der Referenzseite zum bq-Befehlszeilentool.

Logs in BigQuery laden

Wählen Sie ein Standardprojekt aus.

Weitere Informationen zum Auswählen eines Projekts finden Sie unter Mit Projekten arbeiten.

Erstellen Sie ein neues Dataset.

$ bq mk storageanalysis
Dataset 'storageanalysis' successfully created.

Listen Sie die Datasets im Projekt auf.

$ bq ls
 
datasetId
-----------------
storageanalysis

Speichern Sie die Nutzungs-und Speicherschemas auf Ihrem lokalen Computer, um sie im Ladebefehl verwenden zu können.

Die zu verwendenden Schemas finden Sie unter cloud_storage_usage_schema_v0 und cloud_storage_storage_schema_v0. Diese werden auch im Abschnitt Format von Nutzungs- und Speicherlogs beschrieben.
Laden Sie die Nutzungslogs in das Dataset.
```
$ bq load --skip_leading_rows=1 storageanalysis.usage \
      gs://example-logs-bucket/example-bucket_usage_2014_01_15_14_00_00_1702e6_v0 \
      ./cloud_storage_usage_schema_v0.json
$ bq load --skip_leading_rows=1 storageanalysis.storage \
      gs://example-logs-bucket/example-bucket_storage_2014_01_05_14_00_00_091c5f_v0 \
      ./cloud_storage_storage_schema_v0.json
```
Mit diesen Befehlen erledigen Sie Folgendes:
- Nutzungs- und Speicherlogs aus dem Bucket example-logs-bucket laden
- Die Tabellen usage und storage im Dataset storageanalysis erstellen.
- Schemadaten (.json-Datei) aus demselben Verzeichnis lesen, in dem der Befehl bq ausgeführt wird
- Erste Zeile jeder Logdatei überspringen, da sie Spaltenbeschreibungen enthält
Weil Sie in diesem Beispiel den Ladebefehl zum ersten Mal ausgeführt haben, wurden die Tabellen usage und storage erstellt. Sie können durch weitere Ladebefehle mit anderen Nutzungslogdateinamen oder Platzhaltern weiter Daten an diese Tabellen anfügen. Mit dem folgenden Befehl hängen Sie zum Beispiel Daten aus allen Logs, die mit "bucket_usuage_2014" beginnen, an die Tabelle storage an:
```
$ bq load --skip_leading_rows=1 storageanalysis.usage \
      gs://example-logs-bucket/bucket_usage_2014* \
      ./cloud_storage_usage_schema.json
```
Bei der Verwendung von Platzhaltern sollten Sie bereits in BiqQuery hochgeladene Logs in ein anderes Verzeichnis verschieben (z. B. gs://example-logs-bucket/processed), um Daten aus einem Log nicht mehrfach hochzuladen.

Auf die Funktionen von BiqQuery können Sie auch über das BigQuery-Browsertool zugreifen. Damit können Sie Daten im Rahmen des Prozesses zum Erstellen von Tabellen laden.

Weitere Informationen zum Laden von Daten aus Cloud Storage, einschließlich des programmatischen Ladens, finden Sie in Daten aus Cloud Storage laden.

Nutzungslog-Schema ändern

In manchen Fällen kann es hilfreich sein, Nutzungslogs vorzuverarbeiten, bevor sie in BigQuery geladen werden. Dabei können Sie beispielsweise zusätzliche Informationen zu den Nutzungslogs hinzufügen, um die Abfrageanalyse in BigQuery zu vereinfachen. In diesem Abschnitt erfahren Sie, wie Sie den Dateinamen jedes Speichernutzungslogs zum Log hinzufügen. Dazu müssen das vorhandene Schema und die Logdateien geändert werden.

Ändern Sie das vorhandene Schema cloud_storage_storage_schema_v0, um den Dateinamen wie unten gezeigt hinzuzufügen. Geben Sie dem Schema einen neuen Namen, zum Beispiel cloud_storage_storage_schema_custom.json, damit Sie es vom Original unterscheiden können.
```
[  {"name": "bucket", "type": "string", "mode": "REQUIRED"},
{"name": "storage_byte_hours","type": "integer","mode": "REQUIRED"},
{"name": "filename","type": "string","mode": "REQUIRED"}
]
```
Vorverarbeiten Sie die Speichernutzungslogdateien basierend auf dem neuen Schema, bevor Sie sie in BigQuery laden.

Die folgenden Befehle können beispielsweise in einer Linux-, macOS- oder Windows-Umgebung (Cygwin) verwendet werden:
```
gcloud storage cp gs://example-logs-bucket/example-bucket_storage\* .
for f in example-bucket_storage\*; do sed -i -e "1s/$/,\"filename\"/" -e "2s/$/,\""$f"\"/" $f; done
```
Mit dem gcloud storage-Befehl werden die Dateien in Ihr Arbeitsverzeichnis kopiert. Der zweite Befehl geht die Log-Dateien durch und fügt der Beschreibungszeile (erste Zeile) die Information "filename" sowie der Datenzeile (zweite Zeile) den eigentlichen Dateinamen hinzu. Hier sehen Sie ein Beispiel einer geänderten Log-Datei:
```
"bucket","storage_byte_hours","filename"
"example-bucket","5532482018","example-bucket_storage_2014_01_05_08_00_00_021fd_v0"
```

Laden Sie Ihre lokal geänderten Logs beim Laden der Speichernutzungslogs in BigQuery unter Verwendung des angepassten Schemas.

for f in example-bucket_storage\*; \
do ./bq.py load --skip_leading_rows=1 storageanalysis.storage $f ./cloud_storage_storage_schema_custom.json; done

Abfragelogs in BigQuery

Sobald die Logs in BigQuery geladen sind, können Sie die Nutzungslogs abfragen, um Informationen zu Ihren protokollierten Buckets zu erhalten. Das folgende Beispiel zeigt, wie Sie das bq-Tool in einem Szenario einsetzen, in dem Sie über die Nutzungslogs mehrerer Tage für einen Bucket verfügen und sie, wie unter Logs in BigQuery laden erklärt, geladen haben. Die unten stehenden Abfragen können Sie auch mit dem BigQuery-Browsertool ausführen.

Wechseln Sie im bq-Tool in den interaktiven Modus.
```
$ bq shell
```

Fragen Sie die Speicher-Log-Tabelle ab.

Die folgende Abfrage zeigt beispielsweise, wie sich die Speichernutzung eines protokollierten Buckets im Zeitverlauf ändert. Es wird davon ausgegangen, dass Sie die Speichernutzungslogs geändert haben, wie unter Nutzungslog-Schema ändern beschrieben, und dass die Logdateien "logstorage*" heißen.

project-name>SELECT SUBSTRING(filename, 13, 10) as day, storage_byte_hours/24 as size FROM [storageanalysis.storage] ORDER BY filename LIMIT 100

Beispielausgabe der Abfrage:

Waiting on bqjob_r36fbf5c164a966e8_0000014379bc199c_1 ... (0s) Current status: DONE
+------------+----------------------+
|    day     |         size         |
+------------+----------------------+
| 2014_01_05 | 2.3052008408333334E8 |
| 2014_01_06 | 2.3012297245833334E8 |
| 2014_01_07 | 3.3477797120833334E8 |
| 2014_01_08 | 4.4183686058333334E8 |
+-----------------------------------+

Falls Sie das Schema nicht geändert haben und das Standardschema verwenden, können Sie die folgende Abfrage ausführen:

project-name>SELECT storage_byte_hours FROM [storageanalysis.storage] LIMIT 100

Fragen Sie die Nutzungs-Log-Tabelle ab.

Die folgende Abfrage zeigt beispielsweise, wie die Anfragemethoden, die Clients für den Zugriff auf Ressourcen im protokollierten Bucket verwenden, zusammengefasst werden.

project-name>SELECT cs_method, COUNT(*) AS count FROM [storageanalysis.usage] GROUP BY cs_method

Beispielausgabe der Abfrage:

Waiting on bqjob_r1a6b4596bd9c29fb_000001437d6f8a52_1 ... (0s) Current status: DONE
+-----------+-------+
| cs_method | count |
+-----------+-------+
| PUT       |  8002 |
| GET       | 12631 |
| POST      |  2737 |
| HEAD      |  2173 |
| DELETE    |  7290 |
+-----------+-------+

Beenden Sie die interaktive Shell des bq-Tools.
```
project-name> quit
```

Logging deaktivieren

Befehlszeile

Deaktivieren Sie das Logging mit dem --clear-log-bucket-Flag im buckets update-Befehl:

gcloud storage buckets update gs://example-bucket --clear-log-bucket

Prüfen Sie mit dem buckets describe-Befehl, ob das Logging erfolgreich deaktiviert wurde:

gcloud storage buckets describe gs://example-bucket --format="default(logging_config)"

Wenn das Logging deaktiviert ist, wird Folgendes zurückgegeben:

null

REST APIs

JSON API

Deaktivieren Sie das Logging, indem Sie eine PATCH-Anfrage an die Logging-Konfiguration des Buckets senden, wie im folgenden Beispiel gezeigt:

PATCH /example-bucket?logging HTTP/1.1
Host: storage.googleapis.com

{
 "logging": null
}

XML API

Deaktivieren Sie Logging, indem Sie eine PUT-Anfrage an die Logging-Konfiguration des Buckets senden, wie im folgenden Beispiel gezeigt:

PUT /example-bucket?logging HTTP/1.1
Host: storage.googleapis.com

<Logging/>

Format von Nutzungs- und Speicherlogs

Die Nutzungs- und Speicherlogs können enorme Informationsmengen enthalten. Die folgenden Tabellen zeigen, welche Informationen Sie darin finden.

Nutzungslogfelder:

Feld	Typ	Beschreibung
`time_micros`	Ganzzahl	Die Zeit, in der die Anfrage abgeschlossen wurde, in Mikrosekunden seit der Unixzeit.
`c_ip`	String	Die IP-Adresse, von der die Anfrage gesendet wurde. Das Präfix "c" gibt an, dass es sich um Informationen über den Client handelt.
`c_ip_type`	Ganzzahl	Die Art der IP-Adresse im Feld "c_ip": Der Wert 1 weist auf eine IPV4-Adresse hin. Der Wert 2 steht für eine IPV6-Adresse.
`c_ip_region`	String	Reserviert für zukünftige Verwendungen.
`cs_method`	String	Die HTTP-Methode der Anfrage. Das Präfix "cs" gibt an, dass diese Informationen vom Client an den Server gesendet wurden.
`cs_uri`	String	Der URI der Anfrage.
`sc_status`	Ganzzahl	Der HTTP-Statuscode, den der Server als Antwort gesendet hat. Das Präfix "sc" gibt an, dass diese Information vom Server an den Client gesendet wurde.
`cs_bytes`	Ganzzahl	Die Anzahl der in der Anfrage gesendeten Byte.
`sc_bytes`	Ganzzahl	Die Anzahl der in der Antwort gesendeten Byte.
`time_taken_micros`	Ganzzahl	Die Zeit für das Verarbeiten der Anfrage in Mikrosekunden ab dem Zeitpunkt, als das erste Byte empfangen wurde, bis zum Senden der Antwort. Bei fortsetzbaren Uploads hängt der Endpunkt von der Antwort auf die letzte Upload-Anfrage ab, die Teil des fortsetzbaren Uploads war.
`cs_host`	String	Der Host in der ursprünglichen Anfrage.
`cs_referer`	String	Die HTTP-Verweis-URL für die Anfrage.
`cs_user_agent`	String	Der User-Agent der Anfrage. Bei Anfragen durch die Lebenszyklusverwaltung lautet der Wert `GCS Lifecycle Management`.
`s_request_id`	String	Die Anfragekennung.
`cs_operation`	String	Die Cloud Storage-Operation, z. B. `GET_Object` Dieser Wert kann null sein.
`cs_bucket`	String	Der in der Anfrage angegebene Bucket.
`cs_object`	String	Das in der Anfrage angegebene Objekt. Es kann null sein.

Speicherlogfelder:

Feld	Typ	Beschreibung
`bucket`	String	Der Name des Buckets.
`storage_byte_hours`	Ganzzahl	Durchschnittliche Größe des Buckets in Byte-Stunden über einen Zeitraum von 24 Stunden. Die Gesamtgröße erhalten Sie, indem Sie die Byte-Stunden durch 24 teilen.