Aktivieren Sie die Amazon-S3-Server-Zugriffsprotokollierung - Amazon Simple Storage Service
Berechtigungen für ProtokollbereitstellungVorgehensweise zum Aktivieren der Server-ZugriffsprotokollierungÜberprüfen der Einrichtung Ihrer Serverzugriffsprotokolle

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.

Aktivieren Sie die Amazon-S3-Server-Zugriffsprotokollierung

Die Server-Zugriffsprotokollierung bietet detaillierte Aufzeichnungen über die Anfragen, die an einen Amazon-S3-Bucket gestellt wurden. Server-Zugriffsprotokolle sind für viele Anwendungen nützlich. Beispielsweise können Zugriffsprotokoll-Informationen bei Sicherheits- und Zugriffsprüfungen nützlich sein. Diese Informationen können Ihnen auch helfen, mehr über Ihre Kundenbasis zu erfahren und Ihre Amazon-S3-Rechnung zu verstehen.

Standardmäßig erfasst Amazon S3 keine Server-Zugriffsprotokolle. Wenn Sie die Protokollierung aktivieren, stellt Amazon S3 Zugriffsprotokolle für einen Quell-Bucket in einem von Ihnen ausgewählten Ziel-Bucket (Ziel-Bucket) bereit. Der Ziel-Bucket muss sich im selben AWS-Region und AWS-Konto wie der Quell-Bucket befinden.

Ein Zugriffsprotokollsatz enthält Details über die Anforderungen, die an einen Bucket gestellt werden. Dabei kann es sich um den Anforderungstyp, die in der Anfrage angegebenen Ressourcen sowie Uhrzeit und Datum der Anfrageverarbeitung handeln. Weitere Informationen zu den Grundlagen der Protokollierung finden Sie unter Protokollieren von Anfragen mit Server-Zugriffsprotokollierung.

Wichtig

  • Für die Aktivierung der Server-Zugriffsprotokollierung auf einem Amazon-S3-Bucket fallen keine zusätzlichen Kosten an. Für die Speicherung der Protokolldateien, die das System an Sie überträgt, fallen allerdings die normalen Gebühren an. (Sie können die Protokolldateien jederzeit löschen.) Wir berechnen keine Datenübertragungskosten für die Bereitstellung von Protokolldateien. Für den Zugriff auf die Protokolldateien fallen jedoch die regulären Kosten für Datenübertragungen an.

  • Für Ihren Ziel-Bucket sollte keine Serverzugriffsprotokollierung aktiviert sein. Sie können Protokolle in jeden Bucket speichern lassen, der sich in der gleichen Region wie der Quell-Bucket befindet, einschließlich des Quell-Buckets selbst. Die Zustellung von Protokollen an den Quell-Bucket führt jedoch zu einer unendlichen Schleife von Protokollen und wird nicht empfohlen. Zur einfacheren Protokollverwaltung empfehlen wir, Zugriffsprotokolle in einem anderen Bucket zu speichern. Weitere Informationen finden Sie unter Wie aktiviere ich die Protokollzustellung?

  • S3-Buckets, für die S3 Object Lock aktiviert ist, können nicht als Ziel-Buckets für Serverzugriffsprotokolle verwendet werden. Ihr Ziel-Bucket darf nicht für eine Standardaufbewahrungsdauer konfiguriert sein.

  • Für den Ziel-Bucket darf die Option „Zahlung durch den Anforderer“ nicht aktiviert sein.

  • Sie können die Standard-Bucket-Verschlüsselung für den Ziel-Bucket nur verwenden, wenn Sie serverseitige Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) verwenden, die den 256-Bit-Advanced Encryption Standard (-256) verwenden. AES Die serverseitige Standardverschlüsselung mit AWS Key Management Service (AWS KMS) Schlüsseln (SSE-) wird nicht unterstützt. KMS

Sie können die Serverzugriffsprotokollierung aktivieren oder deaktivieren, indem Sie die Amazon S3-Konsole, Amazon S3API, die AWS Command Line Interface (AWS CLI) oder verwenden AWS SDKs.

Berechtigungen für Protokollbereitstellung

Amazon S3 verwendet ein spezielles Protokollbereitstellungskonto zum Schreiben der Server-Zugriffsprotokolle. Für diese Protokolle gelten die normalen Zugriffskontrollbeschränkungen. Zur Bereitstellung von Zugriffsprotokollen müssen Sie dem Protokollierungsservice-Prinzipal (logging.s3.amazonaws.com) Zugriff auf den Ziel-Bucket gewähren.

Um Amazon S3 Berechtigungen für die Protokollzustellung zu gewähren, können Sie entweder eine Bucket-Richtlinie oder Bucket-Zugriffskontrolllisten (ACLs) verwenden, abhängig von den Einstellungen für den Besitz von S3-Objekten in Ihrem Ziel-Bucket. Wir empfehlen jedoch, stattdessen eine Bucket-Richtlinie zu verwendenACLs.

Vom Bucket-Eigentümer erzwungene Einstellung für S3 Object Ownership

Wenn der Ziel-Bucket die erzwungene Einstellung für Object Ownership verwendet, ACLs sind sie deaktiviert und wirken sich nicht mehr auf die Berechtigungen aus. In diesem Fall müssen Sie die Bucket-Richtlinie für den Ziel-Bucket aktualisieren, um Zugriff auf den Protokollierungsservice-Prinzipal zu gewähren. Sie können Ihren Bucket nicht aktualisierenACL, um Zugriff auf die S3-Protokollbereitstellungsgruppe zu gewähren. Sie können auch keine Zielzuschüsse (auch Zielzuschüsse genannt) in Ihre aufnehmen PutBucketLogging-Konfiguration.

Informationen zur Migration eines vorhandenen Buckets ACLs für die Zugriffs-Log-Zustellung zu einer Bucket-Richtlinie finden Sie unterGewähren von Zugriff auf die S3-Protokollbereitstellungsgruppe für die Protokollierung des Serverzugriffs. Informationen zu Object Ownership finden Sie unter Kontrolle des Besitzes von Objekten und Deaktivierung ACLs für Ihren Bucket. Wenn Sie neue Buckets erstellen, ACLs sind diese standardmäßig deaktiviert.

Gewähren von Zugriff über eine Bucket-Richtlinie

Um über die Bucket-Richtlinie Zugriff auf den Ziel-Bucket zu gewähren, aktualisieren Sie die Bucket-Richtlinie so, dass sie die s3:PutObject-Berechtigung für den Protokollierungsservice-Prinzipal zulässt. Wenn Sie die Serverzugriffsprotokollierung über die Amazon-S3-Konsole aktivieren, aktualisiert die Konsole die Bucket-Richtlinie für den Ziel-Bucket automatisch, um dem Protokollierungsservice-Prinzipal diese Berechtigung zu gewähren. Wenn Sie die Serverzugriffsprotokollierung programmgesteuert aktivieren, müssen Sie die Bucket-Richtlinie für den Ziel-Bucket manuell aktualisieren, um Zugriff auf den Protokollierungsservice-Prinzipal zu gewähren.

Ein Beispiel für eine Bucket-Richtlinie, die Zugriff auf den Protokollierungsservice-Prinzipal gewährt, finden Sie unter Erteilen von Berechtigungen für den Prinzipal des Protokollierungsservices mithilfe einer Bucket-Richtlinie.

Zugriff mithilfe eines Buckets gewähren ACLs

Sie können auch Bucket verwenden, ACLs um Zugriff auf die Zugriffs-Log-Zustellung zu gewähren. Sie fügen dem Bucket einen Grant-Eintrag hinzuACL, der der S3-Protokollbereitstellungsgruppe READ_ACP Berechtigungen gewährtWRITE. Es wird jedoch nicht empfohlen, mithilfe eines Buckets ACLs Zugriff auf die S3-Protokollbereitstellungsgruppe zu gewähren. Weitere Informationen finden Sie unter Kontrolle des Besitzes von Objekten und Deaktivierung ACLs für Ihren Bucket. Hinweise zur Migration eines vorhandenen Buckets ACLs für die Zugriffs-Log-Zustellung zu einer Bucket-Richtlinie finden Sie unterGewähren von Zugriff auf die S3-Protokollbereitstellungsgruppe für die Protokollierung des Serverzugriffs. Ein BeispielACL, das Zugriff auf den Logging-Dienstprinzipal gewährt, finden Sie unterGewähren Sie der Protokollbereitstellungsgruppe mithilfe eines Buckets Berechtigungen ACL.

Erteilen von Berechtigungen für den Prinzipal des Protokollierungsservices mithilfe einer Bucket-Richtlinie

Diese Bucket-Beispielrichtlinie gewährt dem Protokollierungsservice-Prinzipal (logging.s3.amazonaws.com) die s3:PutObject-Berechtigung. Wenn Sie diese Bucket-Richtlinie verwenden möchten, ersetzen Sie user input placeholders durch Ihre eigenen Informationen. In der folgenden Richtlinie amzn-s3-demo-destination-bucket handelt es sich um den Ziel-Bucket, in den Serverzugriffsprotokolle übermittelt werden, und amzn-s3-demo-source-bucket um den Quell-Bucket. EXAMPLE-LOGGING-PREFIXist das optionale Zielpräfix (auch als Zielpräfix bezeichnet), das Sie für Ihre Protokollobjekte verwenden möchten. SOURCE-ACCOUNT-IDist der AWS-Konto , dem der Quell-Bucket gehört.

Anmerkung

Wenn Ihre Bucket-Richtlinie Deny-Anweisungen enthält, stellen Sie sicher, dass diese Anweisungen Amazon S3 nicht daran hindern, Zugriffsprotokolle bereitzustellen.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3ServerAccessLogsPolicy",
            "Effect": "Allow",
            "Principal": {
                "Service": "logging.s3.amazonaws.com"
            },
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket/EXAMPLE-LOGGING-PREFIX*",
            "Condition": {
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-source-bucket"
                },
                "StringEquals": {
                    "aws:SourceAccount": "SOURCE-ACCOUNT-ID"
                }
            }
        }
    ]
}

Gewähren Sie der Protokollbereitstellungsgruppe mithilfe eines Buckets Berechtigungen ACL

Anmerkung

Aus Sicherheitsgründen deaktiviert Amazon S3 die Zugriffskontrolllisten (ACLs) standardmäßig in allen neuen Buckets. Weitere Informationen zu ACL Berechtigungen in der Amazon S3 S3-Konsole finden Sie unterKonfiguration ACLs.

Obwohl wir diesen Ansatz nicht empfehlen, können Sie der Protokollbereitstellungsgruppe mithilfe eines Buckets Berechtigungen erteilenACL. Wenn der Ziel-Bucket jedoch die vom Bucket-Besitzer erzwungene Einstellung für Object Ownership verwendet, können Sie Bucket oder Objekt ACLs nicht festlegen. Sie können auch keine Zielzuschüsse (auch als Zielzuschüsse bezeichnet) in Ihre PutBucketLogging-Konfiguration. Stattdessen müssen Sie eine Bucket-Richtlinie verwenden, um dem Prinzipal des Protokollierungsservices (logging.s3.amazonaws.com) Zugriff zu gewähren. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

Im Bucket ACL wird die Protokollbereitstellungsgruppe wie folgt dargestelltURL:

http://acs.amazonaws.com/groups/s3/LogDelivery

Um Berechtigungen WRITE und READ_ACP (ACLLese-) Berechtigungen zu erteilen, fügen Sie dem Ziel-Bucket die folgenden Berechtigungen hinzuACL:

<Grant>
    <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:type="Group">
        <URI>http://acs.amazonaws.com/groups/s3/LogDelivery</URI> 
    </Grantee>
    <Permission>WRITE</Permission>
</Grant>
<Grant>
    <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:type="Group">
        <URI>http://acs.amazonaws.com/groups/s3/LogDelivery</URI> 
    </Grantee>
    <Permission>READ_ACP</Permission>
</Grant>

Beispiele für das programmgesteuerte Hinzufügen von ACL Zuschüssen finden Sie unter. Konfiguration ACLs

Wichtig

Wenn Sie die Amazon S3 S3-Serverzugriffsprotokollierung mithilfe AWS CloudFormation eines Buckets aktivieren und Zugriff auf die S3-Protokollzustellungsgruppe gewähren möchten, müssen Sie Ihrer CloudFormation Vorlage auch "AccessControl": "LogDeliveryWrite"hinzufügen. ACLs Dies ist wichtig, da Sie diese Berechtigungen nur gewähren können, indem Sie eine ACL für den Bucket erstellen, aber Sie können keine benutzerdefinierten Berechtigungen ACLs für Buckets in CloudFormation erstellen. Sie können nur in Dosen ACLs mit CloudFormation verwenden.

Vorgehensweise zum Aktivieren der Server-Zugriffsprotokollierung

Gehen Sie wie folgt vor, um die Serverzugriffsprotokollierung mithilfe der Amazon S3-Konsole AWS CLI, Amazon S3 RESTAPI, und zu aktivieren. AWS SDKs

  1. Melden Sie sich bei der an AWS Management Console und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.

  2. Wählen Sie in der Liste Buckets den Namen des Buckets aus, für den Sie die Server-Zugriffsprotokollierung aktivieren möchten.

  3. Wählen Sie Properties (Eigenschaften).

  4. Wählen Sie im Abschnitt Server access logging (Server-Zugriffsprotokollierung) die Option Edit (Bearbeiten) aus.

  5. Wählen Sie unter Serverzugriffsprotokollierung) die Option Aktivieren aus.

  6. Geben Sie unter Ziel-Bucket einen Bucket und ein optionales Präfix an. Wenn Sie ein Präfix angeben, sollten Sie nach dem Präfix einen Schrägstrich (/) einfügen, damit Sie Ihre Protokolle leichter finden können.

    Anmerkung

    Wenn Sie ein Präfix mit einem Schrägstrich (/) angeben, können Sie die Protokollobjekte leichter finden. Wenn Sie beispielsweise den Präfixwert logs/ angeben, beginnt jedes von Amazon S3 erstellte Protokollobjekt mit dem Präfix logs/ im Schlüssel wie folgt:

    logs/2013-11-01-21-32-16-E568B2907131C0C0

    Wenn Sie den Präfixwert logs angeben, sieht das Protokollobjekt wie folgt aus:

    logs2013-11-01-21-32-16-E568B2907131C0C0

  7. Führen Sie unter Protokollobjekt-Schlüsselformat eine der folgenden Aktionen aus:

    • Um die non-date-based Partitionierung auszuwählen, wählen Sie [DestinationPrefixYYYY] [] - [MM] - [DD] - [hh] - [mm] - [ss] - [UniqueString].

    • Um die datumsbasierte Partitionierung zu wählen, wählen Sie [DestinationPrefixSourceAccountId] [SourceRegion]/[SourceBucket]/[YYYY]/[MM]/[DD]/[] - [MMYYYY] - [MM] - [DD] - [hh] - [mm] - [ss] - [UniqueString] und wählen Sie dann S3 event time oder Log file delivery time.

  8. Wählen Sie Änderungen speichern.

    Wenn Sie die Serverzugriffsprotokollierung für einen Bucket aktivieren, aktiviert die Konsole die Protokollierung für den Quell-Bucket und aktualisiert die Bucket-Richtlinie für den Ziel-Bucket, um dem Protokollierungsservice-Prinzipal (logging.s3.amazonaws.com) die s3:PutObject-Berechtigung zu gewähren. Weitere Informationen zu dieser Bucket-Richtlinie finden Sie unter Erteilen von Berechtigungen für den Prinzipal des Protokollierungsservices mithilfe einer Bucket-Richtlinie.

    Sie können die Protokolle im Ziel-Bucket anzeigen. Nachdem Sie die Server-Zugriffsprotokollierung aktiviert haben, kann es einige Stunden dauern, bis die Protokolle in den Ziel-Bucket geliefert werden. Weitere Informationen darüber, wie und wann Protokolle bereitgestellt werden, finden Sie unter Wie werden Protokolle ausgeliefert?.

Weitere Informationen finden Sie unter Anzeigen der Eigenschaften eines S3-Buckets.

Um die Protokollierung zu aktivieren, reichen Sie ein PutBucketLoggingAnfrage zum Hinzufügen der Logging-Konfiguration zum Quell-Bucket. Die Anforderung gibt den Ziel-Bucket (Ziel-Bucket) und optional das Präfix an, das für alle Protokollobjektschlüssel verwendet werden soll.

Das folgende Beispiel identifiziert sich amzn-s3-demo-destination-bucket als Ziel-Bucket und logs/ als Präfix. 

<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <LoggingEnabled>
    <TargetBucket>amzn-s3-demo-destination-bucket</TargetBucket>
    <TargetPrefix>logs/</TargetPrefix>
  </LoggingEnabled>
</BucketLoggingStatus>

Das folgende Beispiel identifiziert sich amzn-s3-demo-destination-bucket als Ziel-Bucket, logs/ als Präfix und EventTime als Schlüsselformat für das Protokollobjekt. 

<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <LoggingEnabled>
    <TargetBucket>amzn-s3-demo-destination-bucket</TargetBucket>
    <TargetPrefix>logs/</TargetPrefix>
    <TargetObjectKeyFormat>
      <PartitionedPrefix>
         <PartitionDateSource>EventTime</PartitionDateSource>
      </PartitionedPrefix>
  </TargetObjectKeyFormat>
  </LoggingEnabled>
</BucketLoggingStatus>

Die Protokollobjekte werden vom S3-Protokollübermittlungskonto geschrieben und besitzen dessen Eigentümer, und der Bucket-Eigentümer erhält vollständige Berechtigungen für die Protokollobjekte. Sie können optional Zielgewährungen verwenden (Zielgewährungen), um anderen Benutzern Berechtigungen zu gewähren, damit diese auf die Protokolle zugreifen können. Weitere Informationen finden Sie unter PutBucketLogging.

Anmerkung

Wenn der Ziel-Bucket die Einstellung „Von Bucket-Besitzer erzwungen“ für Object Ownership verwendet, können Sie keine Zielgewährungen verwenden, um anderen Benutzern Berechtigungen zu gewähren. Um anderen Benutzern Berechtigungen zu gewähren, können Sie die Bucket-Richtlinie für den Ziel-Bucket aktualisieren. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

Um die Logging-Konfiguration für einen Bucket abzurufen, verwenden Sie GetBucketLoggingAPIOperation.

Um die Protokollierungskonfiguration zu löschen, senden Sie eine PutBucketLogging-Anforderung mit einem leeren BucketLoggingStatus: 

<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
</BucketLoggingStatus>

Um die Protokollierung in einem Bucket zu aktivieren, können Sie entweder die Amazon S3 API - oder die AWS SDK Wrapper-Bibliotheken verwenden.

In den folgenden Beispielen wird die Protokollierung für einen Bucket aktiviert. Sie müssen zwei Buckets erstellen, einen Quell-Bucket und einen Ziel-Bucket. In den Beispielen wird zuerst der Bucket ACL im Ziel-Bucket aktualisiert. Anschließend werden der Protokollbereitstellungsgruppe die notwendigen Berechtigungen für das Schreiben von Protokollen zum Ziel-Bucket gewährt, bevor die Protokollierung für den Quell-Bucket aktiviert wird.

Diese Beispiele funktionieren nicht für Ziel-Buckets, die die Einstellung „Von Bucket-Besitzer erzwungen“ für Object Ownership verwenden.

Wenn der Ziel-Bucket (Ziel-Bucket) die vom Bucket-Besitzer erzwungene Einstellung für Objekteigentum verwendet, können Sie weder Bucket noch Objekt ACLs festlegen. Sie können auch keine Zielzuschüsse (Zielzuschüsse) in Ihre PutBucketLoggingKonfiguration aufnehmen. Sie müssen eine Bucket-Richtlinie verwenden, um dem Protokollierungsserviceprinzipal (logging.s3.amazonaws.com) Zugriff zu gewähren. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

.NET
AWS SDK for .NET
Anmerkung

Es gibt noch mehr dazu GitHub. Sie sehen das vollständige Beispiel und erfahren, wie Sie das AWS -Code-Beispiel-Repository einrichten und ausführen. 

    using System;
    using System.IO;
    using System.Threading.Tasks;
    using Amazon.S3;
    using Amazon.S3.Model;
    using Microsoft.Extensions.Configuration;

    /// <summary>
    /// This example shows how to enable logging on an Amazon Simple Storage
    /// Service (Amazon S3) bucket. You need to have two Amazon S3 buckets for
    /// this example. The first is the bucket for which you wish to enable
    /// logging, and the second is the location where you want to store the
    /// logs.
    /// </summary>
    public class ServerAccessLogging
    {
        private static IConfiguration _configuration = null!;

        public static async Task Main()
        {
            LoadConfig();

            string bucketName = _configuration["BucketName"];
            string logBucketName = _configuration["LogBucketName"];
            string logObjectKeyPrefix = _configuration["LogObjectKeyPrefix"];
            string accountId = _configuration["AccountId"];

            // If the AWS Region defined for your default user is different
            // from the Region where your Amazon S3 bucket is located,
            // pass the Region name to the Amazon S3 client object's constructor.
            // For example: RegionEndpoint.USWest2 or RegionEndpoint.USEast2.
            IAmazonS3 client = new AmazonS3Client();

            try
            {
                // Update bucket policy for target bucket to allow delivery of logs to it.
                await SetBucketPolicyToAllowLogDelivery(
                    client,
                    bucketName,
                    logBucketName,
                    logObjectKeyPrefix,
                    accountId);

                // Enable logging on the source bucket.
                await EnableLoggingAsync(
                    client,
                    bucketName,
                    logBucketName,
                    logObjectKeyPrefix);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine($"Error: {e.Message}");
            }
        }

        /// <summary>
        /// This method grants appropriate permissions for logging to the
        /// Amazon S3 bucket where the logs will be stored.
        /// </summary>
        /// <param name="client">The initialized Amazon S3 client which will be used
        /// to apply the bucket policy.</param>
        /// <param name="sourceBucketName">The name of the source bucket.</param>
        /// <param name="logBucketName">The name of the bucket where logging
        /// information will be stored.</param>
        /// <param name="logPrefix">The logging prefix where the logs should be delivered.</param>
        /// <param name="accountId">The account id of the account where the source bucket exists.</param>
        /// <returns>Async task.</returns>
        public static async Task SetBucketPolicyToAllowLogDelivery(
            IAmazonS3 client,
            string sourceBucketName,
            string logBucketName,
            string logPrefix,
            string accountId)
        {
            var resourceArn = @"""arn:aws:s3:::" + logBucketName + "/" + logPrefix + @"*""";

            var newPolicy = @"{
                                ""Statement"":[{
                                ""Sid"": ""S3ServerAccessLogsPolicy"",
                                ""Effect"": ""Allow"",
                                ""Principal"": { ""Service"": ""logging.s3.amazonaws.com"" },
                                ""Action"": [""s3:PutObject""],
                                ""Resource"": [" + resourceArn + @"],
                                ""Condition"": {
                                ""ArnLike"": { ""aws:SourceArn"": ""arn:aws:s3:::" + sourceBucketName + @""" },
                                ""StringEquals"": { ""aws:SourceAccount"": """ + accountId + @""" }
                                        }
                                    }]
                                }";
            Console.WriteLine($"The policy to apply to bucket {logBucketName} to enable logging:");
            Console.WriteLine(newPolicy);

            PutBucketPolicyRequest putRequest = new PutBucketPolicyRequest
            {
                BucketName = logBucketName,
                Policy = newPolicy,
            };
            await client.PutBucketPolicyAsync(putRequest);
            Console.WriteLine("Policy applied.");
        }

        /// <summary>
        /// This method enables logging for an Amazon S3 bucket. Logs will be stored
        /// in the bucket you selected for logging. Selected prefix
        /// will be prepended to each log object.
        /// </summary>
        /// <param name="client">The initialized Amazon S3 client which will be used
        /// to configure and apply logging to the selected Amazon S3 bucket.</param>
        /// <param name="bucketName">The name of the Amazon S3 bucket for which you
        /// wish to enable logging.</param>
        /// <param name="logBucketName">The name of the Amazon S3 bucket where logging
        /// information will be stored.</param>
        /// <param name="logObjectKeyPrefix">The prefix to prepend to each
        /// object key.</param>
        /// <returns>Async task.</returns>
        public static async Task EnableLoggingAsync(
            IAmazonS3 client,
            string bucketName,
            string logBucketName,
            string logObjectKeyPrefix)
        {
            Console.WriteLine($"Enabling logging for bucket {bucketName}.");
            var loggingConfig = new S3BucketLoggingConfig
            {
                TargetBucketName = logBucketName,
                TargetPrefix = logObjectKeyPrefix,
            };

            var putBucketLoggingRequest = new PutBucketLoggingRequest
            {
                BucketName = bucketName,
                LoggingConfig = loggingConfig,
            };
            await client.PutBucketLoggingAsync(putBucketLoggingRequest);
            Console.WriteLine($"Logging enabled.");
        }

        /// <summary>
        /// Loads configuration from settings files.
        /// </summary>
        public static void LoadConfig()
        {
            _configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("settings.json") // Load settings from .json file.
                .AddJsonFile("settings.local.json", true) // Optionally, load local settings.
                .Build();
        }
    }

  • APIEinzelheiten finden Sie PutBucketLoggingin der AWS SDK for .NET APIReferenz.

Java
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.BucketLoggingStatus;
import software.amazon.awssdk.services.s3.model.LoggingEnabled;
import software.amazon.awssdk.services.s3.model.PartitionedPrefix;
import software.amazon.awssdk.services.s3.model.PutBucketLoggingRequest;
import software.amazon.awssdk.services.s3.model.TargetObjectKeyFormat;

// Class to set a bucket policy on a target S3 bucket and enable server access logging on a source S3 bucket.
public class ServerAccessLogging {
    private static S3Client s3Client;

    public static void main(String[] args) {
        String sourceBucketName = "SOURCE-BUCKET";
        String targetBucketName = "TARGET-BUCKET";
        String sourceAccountId = "123456789012";
        String targetPrefix = "logs/";

        // Create S3 Client.
        s3Client = S3Client.builder().
                region(Region.US_EAST_2)
                .build();

        // Set a bucket policy on the target S3 bucket to enable server access logging by granting the
        // logging.s3.amazonaws.com principal permission to use the PutObject operation.
        ServerAccessLogging serverAccessLogging = new ServerAccessLogging();
        serverAccessLogging.setTargetBucketPolicy(sourceAccountId, sourceBucketName, targetBucketName);

        // Enable server access logging on the source S3 bucket.
        serverAccessLogging.enableServerAccessLogging(sourceBucketName, targetBucketName,
                targetPrefix);

    }

    // Function to set a bucket policy on the target S3 bucket to enable server access logging by granting the
    // logging.s3.amazonaws.com principal permission to use the PutObject operation.
    public void setTargetBucketPolicy(String sourceAccountId, String sourceBucketName, String targetBucketName) {
        String policy = "{\n" +
                "    \"Version\": \"2012-10-17\",\n" +
                "    \"Statement\": [\n" +
                "        {\n" +
                "            \"Sid\": \"S3ServerAccessLogsPolicy\",\n" +
                "            \"Effect\": \"Allow\",\n" +
                "            \"Principal\": {\"Service\": \"logging.s3.amazonaws.com\"},\n" +
                "            \"Action\": [\n" +
                "                \"s3:PutObject\"\n" +
                "            ],\n" +
                "            \"Resource\": \"arn:aws:s3:::" + targetBucketName + "/*\",\n" +
                "            \"Condition\": {\n" +
                "                \"ArnLike\": {\n" +
                "                    \"aws:SourceArn\": \"arn:aws:s3:::" + sourceBucketName + "\"\n" +
                "                },\n" +
                "                \"StringEquals\": {\n" +
                "                    \"aws:SourceAccount\": \"" + sourceAccountId + "\"\n" +
                "                }\n" +
                "            }\n" +
                "        }\n" +
                "    ]\n" +
                "}";
        s3Client.putBucketPolicy(b -> b.bucket(targetBucketName).policy(policy));
    }

    // Function to enable server access logging on the source S3 bucket.
    public void enableServerAccessLogging(String sourceBucketName, String targetBucketName,
            String targetPrefix) {
        TargetObjectKeyFormat targetObjectKeyFormat = TargetObjectKeyFormat.builder()
                .partitionedPrefix(PartitionedPrefix.builder().partitionDateSource("EventTime").build())
                .build();
        LoggingEnabled loggingEnabled = LoggingEnabled.builder()
                .targetBucket(targetBucketName)
                .targetPrefix(targetPrefix)
                .targetObjectKeyFormat(targetObjectKeyFormat)
                .build();
        BucketLoggingStatus bucketLoggingStatus = BucketLoggingStatus.builder()
                .loggingEnabled(loggingEnabled)
                .build();
        s3Client.putBucketLogging(PutBucketLoggingRequest.builder()
                .bucket(sourceBucketName)
                .bucketLoggingStatus(bucketLoggingStatus)
                .build());
    }

}

Wir empfehlen, dass Sie in jedem, in dem Sie S3-Buckets haben AWS-Region , einen eigenen Logging-Bucket erstellen. Anschließend können Sie Ihre Amazon-S3-Zugriffsprotokolle in diesem S3-Bucket bereitstellen lassen. Weitere Informationen und Beispiele finden Sie unter put-bucket-loggingin der AWS CLI Referenz.

Wenn der Ziel-Bucket (Ziel-Bucket) die vom Bucket-Besitzer erzwungene Einstellung für Objekteigentum verwendet, können Sie weder Bucket noch Objekt ACLs festlegen. Sie können auch keine Zielzuschüsse (Zielzuschüsse) in Ihre PutBucketLoggingKonfiguration aufnehmen. Sie müssen eine Bucket-Richtlinie verwenden, um dem Protokollierungsserviceprinzipal (logging.s3.amazonaws.com) Zugriff zu gewähren. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

Beispiel – Aktivieren von Zugriffsprotokollen für fünf Buckets in zwei Regionen

In diesem Beispiel werden die folgenden fünf Buckets verwendet:

  • amzn-s3-demo-source-bucket-us-east-1

  • amzn-s3-demo-source-bucket1-us-east-1

  • amzn-s3-demo-source-bucket2-us-east-1

  • amzn-s3-demo-bucket1-us-west-2

  • amzn-s3-demo-bucket2-us-west-2

Anmerkung

Der letzte Schritt im folgenden Verfahren enthält Bash-Beispielskripts, mit denen Sie Ihre Protokollierungs-Buckets erstellen und die Serverzugriffsprotokollierung für diese Buckets aktivieren können. Um diese Skripts verwenden zu können, müssen Sie die Dateien policy.json und logging.json erstellen wie im folgenden Verfahren beschrieben.

  1. Erstellen Sie in den Regionen USA West (Oregon) und USA Ost (Nord-Virginia) zwei Ziel-Buckets für die Protokollierung mit den folgenden Namen:

    • amzn-s3-demo-destination-bucket-logs-us-east-1

    • amzn-s3-demo-destination-bucket1-logs-us-west-2

  2. Später im Verfahren aktivieren Sie die Serverzugriffsprotokollierung wie folgt:

    • amzn-s3-demo-source-bucket-us-east-1 protokolliert zum S3-Bucket amzn-s3-demo-destination-bucket-logs-us-east-1 mit dem Präfix amzn-s3-demo-source-bucket-us-east-1

    • amzn-s3-demo-source-bucket1-us-east-1 protokolliert zum S3-Bucket amzn-s3-demo-destination-bucket-logs-us-east-1 mit dem Präfix amzn-s3-demo-source-bucket1-us-east-1

    • amzn-s3-demo-source-bucket2-us-east-1 protokolliert zum S3-Bucket amzn-s3-demo-destination-bucket-logs-us-east-1 mit dem Präfix amzn-s3-demo-source-bucket2-us-east-1

    • amzn-s3-demo-bucket1-us-west-2 protokolliert zum S3-Bucket amzn-s3-demo-destination-bucket1-logs-us-west-2 mit dem Präfix amzn-s3-demo-bucket1-us-west-2

    • amzn-s3-demo-bucket2-us-west-2 protokolliert zum S3-Bucket amzn-s3-demo-destination-bucket1-logs-us-west-2 mit dem Präfix amzn-s3-demo-bucket2-us-west-2

  3. Erteilen Sie für jeden Ziel-Logging-Bucket mithilfe eines Buckets ACL oder einer Bucket-Richtlinie Berechtigungen für die Übermittlung von Serverzugriffsprotokollen:

    • Aktualisieren Sie die Bucket-Richtlinie (Empfohlen) – Verwenden Sie den folgenden put-bucket-policy-Befehl, um dem Prinzipal des Protokollierungsservices Berechtigungen zu erteilen. Ersetzen Sie amzn-s3-demo-destination-bucket-logs durch den Namen Ihres Ziel-Buckets.

      aws s3api put-bucket-policy --bucket amzn-s3-demo-destination-bucket-logs --policy file://policy.json

      Policy.jsonist ein JSON Dokument im aktuellen Ordner, das die folgende Bucket-Richtlinie enthält. Wenn Sie diese Bucket-Richtlinie verwenden möchten, ersetzen Sie user input placeholders durch Ihre eigenen Informationen. In der folgenden Richtlinie amzn-s3-demo-destination-bucket-Protokolle ist der Ziel-Bucket, in den Serverzugriffsprotokolle übermittelt werden, und amzn-s3-demo-source-bucket ist der Quell-Bucket. SOURCE-ACCOUNT-IDist der AWS-Konto , dem der Quell-Bucket gehört.

      
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "S3ServerAccessLogsPolicy",
            "Effect": "Allow",
            "Principal": {
                "Service": "logging.s3.amazonaws.com"
            },
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::amzn-s3-demo-destination-bucket-logs/*",
            "Condition": {
                "ArnLike": {
                    "aws:SourceArn": "arn:aws:s3:::amzn-s3-demo-source-bucket"
                },
                "StringEquals": {
                    "aws:SourceAccount": "SOURCE-ACCOUNT-ID"
                }
            }
        }
    ]
}

    • Bucket aktualisieren ACL — Verwenden Sie den folgenden put-bucket-acl Befehl, um der S3-Protokollzustellungsgruppe Berechtigungen zu erteilen. Ersetzen amzn-s3-demo-destination-bucket-loggt mit dem Namen Ihres Ziel-Buckets (Ziel-Buckets).

      
aws s3api put-bucket-acl --bucket amzn-s3-demo-destination-bucket-logs  --grant-write URI=http://acs.amazonaws.com/groups/s3/LogDelivery --grant-read-acp URI=http://acs.amazonaws.com/groups/s3/LogDelivery

  4. Erstellen Sie dann eine logging.json-Datei, die Ihre Protokollierungskonfiguration enthält (basierend auf einem der drei folgenden Beispiele). Nach der Erstellung der logging.json-Datei können Sie mit dem folgenden put-bucket-logging-Befehl die Protokollierungskonfiguration anwenden. Ersetzen amzn-s3-demo-destination-bucket-Logs mit dem Namen Ihres Ziel-Buckets (Ziel-Buckets).

    
aws s3api put-bucket-logging --bucket amzn-s3-demo-destination-bucket-logs --bucket-logging-status file://logging.json
    Anmerkung

    Anstatt mit diesem diesen put-bucket-logging-Befehl die Protokollierungskonfiguration auf jeden einzelnen Ziel-Bucket anzuwenden, können Sie eines der im nächsten Schritt bereitgestellten Bash-Skripts verwenden. Um diese Skripts verwenden zu können, müssen Sie die Dateien policy.json und logging.json erstellen wie in diesem Verfahren beschrieben.

    Die logging.json Datei ist ein JSON Dokument im aktuellen Ordner, das Ihre Logging-Konfiguration enthält. Wenn ein Ziel-Bucket die Einstellung „Von Bucket-Besitzer erzwungen“ für Object Ownership verwendet, kann Ihre Protokollierungskonfiguration keine Zielgewährungen enthalten. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

    Beispiel – logging.json ohne Zielgewährungen

    Die folgende logging.json-Beispieldatei enthält keine Zielgewährungen. Daher können Sie diese Konfiguration auf einen Ziel-Bucket anwenden, der die Einstellung „Von Bucket-Besitzer erzwungen“ für Objekt Ownership verwendet.

    
  {
      "LoggingEnabled": {
          "TargetBucket": "amzn-s3-demo-destination-bucket-logs",
          "TargetPrefix": "amzn-s3-demo-destination-bucket/"
       }
   }
    Beispiel – logging.json mit Zielgewährungen

    Die folgende logging.json-Beispieldatei enthält Zielgewährungen.

    Wenn der Ziel-Bucket die vom Bucket-Besitzer erzwungene Einstellung für Objekteigentum verwendet, können Sie Zielzuschüsse (Zielzuschüsse) nicht in Ihre PutBucketLogging-Konfiguration. Weitere Informationen finden Sie unter Berechtigungen für Protokollbereitstellung.

    
  {
      "LoggingEnabled": {
          "TargetBucket": "amzn-s3-demo-destination-bucket-logs",
          "TargetPrefix": "amzn-s3-demo-destination-bucket/",
          "TargetGrants": [
               {
                  "Grantee": {
                      "Type": "AmazonCustomerByEmail",
                      "EmailAddress": "user@example.com"
                   },
                  "Permission": "FULL_CONTROL"
               }
           ]
       }
   }
    Beispiel – logging.json mit auf S3-Ereigniszeit festgelegtem Protokollobjekt-Schlüsselformat

    In der folgenden logging.json-Datei wird das Protokollobjekt-Schlüsselformat in S3-Ereigniszeit geändert. Weitere Informationen zum Einrichten des Protokollobjekt-Schlüsselformats finden Sie unter Wie aktiviere ich die Protokollzustellung?.

    
  { 
    "LoggingEnabled": {
        "TargetBucket": "amzn-s3-demo-destination-bucket-logs",
        "TargetPrefix": "amzn-s3-demo-destination-bucket/",
        "TargetObjectKeyFormat": { 
            "PartitionedPrefix": { 
                "PartitionDateSource": "EventTime" 
            }
         }
    }
}

  5. Sie können eines der folgenden Bash-Skripts verwenden, um allen Buckets in Ihrem Konto Zugriffsprotokollierung hinzuzufügen. Ersetzen amzn-s3-demo-destination-bucket-Logs mit dem Namen Ihres Ziel-Buckets (Ziel-Buckets) und us-west-2 ersetzen Sie es durch den Namen der Region, in der sich Ihre Buckets befinden.

    Anmerkung

    Dieses Skript funktioniert nur, wenn sich alle Buckets in derselben Region befinden. Sind die Buckets auf mehrere Regionen verteilt, müssen Sie das Skript anpassen.

    Beispiel - Gewähren Sie Zugriff mit Bucket-Richtlinien und fügen Sie die Protokollierung für die Buckets in Ihrem Konto hinzu
    
  loggingBucket='amzn-s3-demo-destination-bucket-logs'
  region='us-west-2'
  
  
  # Create the logging bucket.
  aws s3 mb s3://$loggingBucket --region $region
  
  aws s3api put-bucket-policy --bucket $loggingBucket --policy file://policy.json
  
  # List the buckets in this account.
  buckets="$(aws s3 ls | awk '{print $3}')"
  
  # Put a bucket logging configuration on each bucket.
  for bucket in $buckets
      do 
        # This if statement excludes the logging bucket.
        if [ "$bucket" != "$loggingBucket" ] ; then
            continue;
        fi
        printf '{
          "LoggingEnabled": {
            "TargetBucket": "%s",
            "TargetPrefix": "%s/"
        }
      }' "$loggingBucket" "$bucket"  > logging.json
      aws s3api put-bucket-logging --bucket $bucket --bucket-logging-status file://logging.json
      echo "$bucket done"
  done
  
  rm logging.json
  
  echo "Complete"
    Beispiel — Gewähren Sie Zugriff mit einem Bucket ACLs und fügen Sie die Protokollierung für die Buckets in Ihrem Konto hinzu
    
  loggingBucket='amzn-s3-demo-destination-bucket-logs'
  region='us-west-2'
  
  
  # Create the logging bucket.
  aws s3 mb s3://$loggingBucket --region $region
  
  aws s3api put-bucket-acl --bucket $loggingBucket --grant-write URI=http://acs.amazonaws.com/groups/s3/LogDelivery --grant-read-acp URI=http://acs.amazonaws.com/groups/s3/LogDelivery
  
  # List the buckets in this account.
  buckets="$(aws s3 ls | awk '{print $3}')"
  
  # Put a bucket logging configuration on each bucket.
  for bucket in $buckets
      do 
        # This if statement excludes the logging bucket.
        if [ "$bucket" != "$loggingBucket" ] ; then
            continue;
        fi
        printf '{
          "LoggingEnabled": {
            "TargetBucket": "%s",
            "TargetPrefix": "%s/"
        }
      }' "$loggingBucket" "$bucket"  > logging.json
      aws s3api put-bucket-logging --bucket $bucket --bucket-logging-status file://logging.json
      echo "$bucket done"
  done
  
  rm logging.json
  
  echo "Complete"

Überprüfen der Einrichtung Ihrer Serverzugriffsprotokolle

Führen Sie nach dem Aktivieren der Serverzugriffsprotokollierung die folgenden Schritte aus:

  • Greifen Sie auf den Ziel-Bucket zu und überprüfen Sie, ob die Protokolldateien bereitgestellt werden. Nachdem die Zugriffsprotokolle eingerichtet wurden, fängt Amazon S3 sofort an, Anfragen zu erfassen und zu protokollieren. Es kann jedoch einige Stunden dauern, bis die Protokolle an den Ziel-Bucket übermittelt werden. Weitere Informationen erhalten Sie unter Statusänderungen in der Bucket-Protokollierung werden mit der Zeit wirksam und Best-Effort-Serverprotokollbereitstellung.

    Sie können die Protokollzustellung auch automatisch überprüfen, indem Sie Amazon S3 S3-Anforderungsmetriken verwenden und CloudWatch Amazon-Alarme für diese Metriken einrichten. Weitere Informationen finden Sie unter Metriken mit Amazon überwachen CloudWatch.

  • Vergewissern Sie sich, dass Sie den Inhalt der Protokolldateien öffnen und lesen können.

Informationen zur Fehlerbehebung bei der Serverzugriffsprotokollierung finden Sie unter Behebung von Fehlern bei der Server-Zugriffsprotokollierung.