Abilitazione della registrazione degli accessi al server Amazon S3

La registrazione degli accessi al server fornisce record dettagliati per le richieste che sono effettuate a un bucket Amazon S3. I log di accesso al server sono utili per numerose applicazioni. Ad esempio, le informazioni del log di accesso possono essere utili nei controlli di accesso e di sicurezza. Queste informazioni possono essere utili anche per comprendere la base clienti e la fattura Amazon S3.

Per default, Amazon S3 non raccoglie i log degli accessi al server. Quando abiliti la registrazione di log, Amazon S3 fornisce i log degli accessi per un bucket di origine a un bucket di destinazione scelto (noto anche come bucket target). Il bucket di destinazione si deve trovare nella stessa Regione AWS e nello stesso Account AWS del bucket di origine.

Un record di log degli accessi contiene informazioni dettagliate sulle richieste effettuate a un bucket, tra cui il tipo di richiesta, le risorse specificate nella richiesta, nonché l'ora e la data di elaborazione della richiesta. Per ulteriori informazioni sui principi di base della registrazione, consulta Registrazione delle richieste con registrazione dell'accesso al server.

Importante

• L'abilitazione della registrazione degli accessi al server per un bucket Amazon S3 non prevede addebiti aggiuntivi. Tuttavia, i file di log distribuiti dal sistema accumulano i consueti addebiti per lo storage. È possibile eliminare i file di log in qualsiasi momento. Il costo di trasferimento dei dati per la consegna dei file di log non viene valutato, ma viene addebitata la normale tariffa di trasferimento dei dati per l'accesso ai file di log.

• Il bucket di destinazione non deve avere la registrazione di log degli accessi al server abilitata. I registri possono essere distribuiti a tutti i bucket di cui si è proprietari che si trovano nella stessa regione del bucket di origine, incluso il bucket di origine stesso. Tuttavia, la distribuzione dei log nel bucket di origine causa un ciclo infinito di log e non è consigliata. Tuttavia, per una gestione più semplice dei log, si consiglia di salvare i log di accesso in un bucket diverso. Per ulteriori informazioni, consulta Come si abilita il recapito dei log?

• I bucket S3 con S3 Object Lock abilitato non possono essere utilizzati come bucket di destinazione per i log degli accessi al server. Il bucket di destinazione non deve avere una configurazione del periodo di conservazione predefinita.

• Il bucket di destinazione non deve avere l'opzione di pagamento a carico del cliente abilitata.

• Puoi utilizzare la crittografia bucket predefinita nel bucket di destinazione solo se utilizzi la crittografia lato server con chiavi gestite da Amazon S3 (SSE-S3), che utilizza Advanced Encryption Standard a 256 bit (AES-256). La crittografia predefinita lato server con chiavi () (SSE-KMS) non è supportata. AWS Key Management Service AWS KMS

Puoi abilitare o disabilitare la registrazione degli accessi al server utilizzando la console di Amazon S3, l'API Amazon S3, la AWS Command Line Interface (AWS CLI) o gli SDK AWS .

Autorizzazioni per la distribuzione dei registri

Amazon S3 utilizza uno speciale account di recapito dei registri per scrivere i registri degli accessi nel server. Queste scritture sono soggette alle normali restrizioni del controllo accessi. Per la consegna di log degli accessi, è necessario concedere al principale (logging.s3.amazonaws.com) del servizio di registrazione di log l'accesso al bucket di destinazione.

Per concedere le autorizzazioni ad Amazon S3 per la consegna di log, è possibile utilizzare una policy del bucket o le liste di controllo degli accessi (ACL) del bucket, a seconda delle impostazioni di Proprietà dell'oggetto S3 del bucket di destinazione. Invece di una lista di controllo degli accessi (ACL) consigliamo di utilizzare una policy del bucket.

Impostazione proprietario del bucket applicato per S3 Object Ownership

Se il bucket di destinazione utilizza l'impostazione proprietario del bucket applicato per Proprietà dell'oggetto, le ACL vengono disabilitate e non influiscono più sulle autorizzazioni. In questo caso, è necessario aggiornare la policy del bucket nel bucket di destinazione per concedere l'accesso al principale del servizio di registrazione di log. Non è possibile aggiornare l'ACL del bucket per concedere l'accesso al gruppo di consegna di log S3. Inoltre, non puoi includere concessioni di destinazione (note anche come concessioni target) nella configurazione PutBucketLogging.

Per informazioni sulla migrazione delle ACL bucket esistenti per la distribuzione di log di accesso a una policy di bucket, consulta Concedere l'accesso al gruppo di consegna di log S3 per la registrazione di log degli accessi al server. Per ulteriori informazioni su Object Ownership, consulta Controllo della proprietà degli oggetti e disabilitazione degli ACL per il bucket. Quando crei nuovi bucket, le ACL sono disabilitate per impostazione predefinita.

Concessione dell'accesso utilizzando una policy del bucket

Per concedere l'accesso utilizzando la policy del bucket nel bucket di destinazione, aggiorna la policy del bucket per concedere l'autorizzazione s3:PutObject al principale del servizio di registrazione di log. Se utilizzi la console di Amazon S3 per abilitare la registrazione di log degli accessi al server, la console aggiorna automaticamente la policy nel bucket di destinazione per concedere tali autorizzazioni al principale del servizio di registrazione di log. Se abiliti la registrazione di log degli accessi al server a livello di programmazione, puoi aggiornare manualmente la policy del bucket per il bucket di destinazione per concedere l'accesso al principale del servizio di registrazione di log.

Per un esempio di policy del bucket che concede l'accesso al principale del servizio di registrazione di log, consulta Concedi le autorizzazioni al principale del servizio di registrazione di log utilizzando una policy del bucket.

Concessione dell'accesso utilizzando le liste di controllo degli accessi (ACL) del bucket

Puoi utilizzare in alternativa le liste di controllo degli accessi (ACL) del bucket per concedere l'accesso per la consegna di log degli accessi. Aggiungi una voce apposita nell'ACL di bucket che conceda autorizzazioni WRITE e READ_ACP al gruppo di distribuzione di registri S3. Tuttavia, non è consigliabile concedere l'accesso al gruppo di distribuzione dei log S3 tramite le ACL bucket. Per ulteriori informazioni, consulta Controllo della proprietà degli oggetti e disabilitazione degli ACL per il bucket. Per informazioni sulla migrazione delle ACL bucket esistenti per la distribuzione di log di accesso a una policy di bucket, consulta Concedere l'accesso al gruppo di consegna di log S3 per la registrazione di log degli accessi al server. Per un esempio di ACL che concede l'accesso al principale del servizio di registrazione di log, consulta Concedere autorizzazioni al gruppo di distribuzione dei log utilizzando l'ACL bucket.

Concedi le autorizzazioni al principale del servizio di registrazione di log utilizzando una policy del bucket

Questo esempio di policy del bucket concede autorizzazioni s3:PutObject al principale del servizio di registrazione di log (logging.s3.amazonaws.com). Per utilizzare questa policy del bucket, sostituisci user input placeholders con le tue informazioni. Nella seguente politica, example-s3-destination-bucket è il bucket di destinazione in cui verranno consegnati i log di accesso al server ed è il bucket di origine. example-s3-source-bucket EXAMPLE-LOGGING-PREFIXè il prefisso di destinazione opzionale (noto anche come prefisso di destinazione) che si desidera utilizzare per gli oggetti di registro. SOURCE-ACCOUNT-IDè il proprietario del Account AWS bucket di origine.

Nota

Se nella policy del bucket sono presenti istruzioni Deny, assicurati che non impediscano ad Amazon S3 di distribuire i log di accesso.

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

Concedere autorizzazioni al gruppo di distribuzione dei log utilizzando l'ACL bucket

Nota

Come best practice di sicurezza, Amazon S3 disabilita le liste di controllo degli accessi (ACL) per impostazione predefinita in tutti i nuovi bucket. Per ulteriori informazioni sulle autorizzazioni ACL nella console di Amazon S3, consulta Configurazione delle ACL.

Sebbene questo approccio non sia consigliato, puoi concedere le autorizzazioni al gruppo di consegna di log utilizzando una ACL di bucket. Tuttavia, se il bucket di destinazione utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, non puoi impostare le ACL di bucket o di oggetti. Inoltre, non puoi includere concessioni di destinazione (note anche come concessioni target) nella configurazione PutBucketLogging. Invece, utilizza una policy del bucket per concedere l'accesso al principale del servizio di registrazione (logging.s3.amazonaws.com). Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

Nelle liste di controllo degli accessi del bucket, il gruppo di consegna di log è rappresentato dall'URL seguente.

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

Per concedere le autorizzazioni WRITE e READ_ACP (lettura ACL), aggiungi le seguenti concessioni all'ACL di bucket di destinazione:

<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>                                    

Per esempi sull'aggiunta a livello di programmazione di concessioni ACL, consulta la sezione Configurazione delle ACL.

Importante

Quando abiliti la registrazione degli accessi al server Amazon S3 utilizzando AWS CloudFormation su un bucket e utilizzi gli ACL per concedere l'accesso al gruppo di consegna dei log di S3, devi anche aggiungere "al tuo modello. AccessControl": "LogDeliveryWrite" CloudFormation Questa operazione è importante perché è possibile concedere tali autorizzazioni solo creando un ACL per il bucket, ma non è possibile creare ACL personalizzati per i bucket in cui si trovano. CloudFormation È possibile utilizzare solo gli ACL predefiniti con. CloudFormation

Come abilitare la registrazione degli accessi al server

Per abilitare la registrazione degli accessi al server utilizzando la console Amazon S3, l'API REST di Amazon S3, gli SDK AWS CLI e AWS , utilizza le seguenti procedure.

Utilizzo della console S3

1. Accedi AWS Management Console e apri la console Amazon S3 all'indirizzo https://console.aws.amazon.com/s3/.

2. Nell'elenco Buckets (Bucket) scegliere il nome del bucket per il quale si desidera abilitare la registrazione degli accessi al server.

3. Scegliere Properties (Proprietà).

4. Nella sezione Server access logging (Registrazione degli accessi al server) scegliere Edit (Modifica).

5. In Registrazione degli accessi al server, seleziona Abilita.

6. In Bucket di destinazione, specifica un bucket e un prefisso opzionale. Se specifichi un prefisso, ti consigliamo di includere una barra in avanti (/) dopo il prefisso per facilitare la ricerca dei log.

   Nota

   L'indicazione di un prefisso con una barra (/) semplifica l'individuazione degli oggetti del log. Se, ad esempio, specifichi il valore di prefisso logs/, la chiave di ogni oggetto del log creato da Amazon S3 è preceduta dal prefisso logs/, come segue:

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

   Se specifichi il valore del prefisso logs, l'oggetto del log viene visualizzato come segue:

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

7. In Formato della chiave dell'oggetto di log, esegui una delle seguenti operazioni:

   • Per scegliere il non-date-based partizionamento, scegli [DestinationPrefix] [YYYY] - [MM] - [DD] - [hh] - [mm] - [ss] - []. UniqueString

   • Per scegliere il partizionamento basato sulla data, scegli [DestinationPrefix] [SourceAccountId]/[SourceRegionSourceBucket]/[YYYY]/[MM]/[DD]/[YYYY] - [MM] - [DD] - [hh] - [mm] - [ss] - [UniqueString], quindi scegli S3 event time o Log file delivery time.

8. Seleziona Salvataggio delle modifiche.

   Quando abiliti la registrazione di log degli accessi al server in un bucket, la console abilita la registrazione nel bucket di origine e aggiorna la policy del bucket per il bucket di destinazione in modo da concedere autorizzazioni s3:PutObject al principale del servizio di registrazione di log (logging.s3.amazonaws.com). Per ulteriori informazioni su questa policy del bucket, consulta Concedi le autorizzazioni al principale del servizio di registrazione di log utilizzando una policy del bucket.

   Puoi visualizzare i log nel bucket di destinazione. Dopo aver abilitato la registrazione degli accessi al server, potrebbero essere necessarie ore prima che i log vengano consegnati al bucket di destinazione. Per ulteriori informazioni su come e quando vengono distribuiti i log, consultare Come vengono distribuiti i log?.

Per ulteriori informazioni, consulta Visualizzazione delle proprietà di un bucket S3.

Utilizzo di REST API

Per abilitare i log, devi inviare una richiesta PutBucketLogging per aggiungere la configurazione della registrazione di log nel bucket di origine. La richiesta specifica il bucket di destinazione (noto anche come bucket target) e, facoltativamente, il prefisso da utilizzare con tutte le chiavi degli oggetti del log.

L'esempio seguente identifica example-s3-destination-bucket come bucket di destinazione e logs/ come prefisso.

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

L'esempio seguente identifica example-s3-destination-bucket come bucket di destinazione, logs/ come prefisso e EventTime come il formato della chiave dell'oggetto di log.

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

Gli oggetti del registri vengono scritti dall'account di distribuzione di log S3 e sono di proprietà di tale account. Al proprietario del bucket vengono concesse autorizzazioni complete sugli oggetti del log. Puoi usare in modo opzionale le concessioni di destinazione (note anche come concessioni target) per concedere le autorizzazioni ad altri utenti in modo che possano accedere ai log. Per ulteriori informazioni, consulta PutBucketLogging.

Nota

Se il bucket di destinazione utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, non puoi utilizzare le concessioni di destinazione per assegnare autorizzazioni ad altri utenti. Per concedere autorizzazioni ad altri utenti, puoi aggiornare la policy del bucket nel bucket di destinazione. Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

Per recuperare la configurazione di registrazione di log su un bucket, utilizza l'operazione API GetBucketLogging.

Per eliminare la configurazione della registrazione di log, devi inviare una richiesta PutBucketLoggingcon un elemento BucketLoggingStatus vuoto:

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

Per abilitare la registrazione su un bucket, puoi utilizzare l'API Amazon S3 o le librerie wrapper SDK AWS .

Utilizzo degli SDK AWS

Gli esempi seguenti abilitano la registrazione di log in un bucket. Devi creare due bucket, uno di origine e uno di destinazione (target). Gli esempi aggiornano prima l'ACL del bucket sul bucket di destinazione. Quindi concedono al gruppo di consegna di log le autorizzazioni necessarie per scrivere i log sul bucket di destinazione e poi abilitano la registrazione di log sul bucket di origine.

Questi esempi non funzionano sui bucket di destinazione che utilizzano l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto.

Se il bucket di destinazione (target) utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, non sarà possibile impostare le ACL di bucket o di oggetti. Inoltre, non puoi includere sovvenzioni di destinazione (target) nella tua PutBucketLoggingconfigurazione. Occorre utilizzare una policy di bucket per concedere le autorizzazioni di accesso al principal del servizio di registrazione (logging.s3.amazonaws.com). Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

.NET

AWS SDK for .NET

Nota

C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel Repository di esempi di codice AWS.

    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();
        }
    }

• Per i dettagli sull'API, PutBucketLoggingconsulta AWS SDK for .NET API Reference.

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());
    }

}

Utilizzando il AWS CLI

Ti consigliamo di creare un bucket di registrazione dedicato in ogni bucket S3 in Regione AWS cui sono presenti bucket S3. Quindi, fare in modo che i log degli accessi Amazon S3 vengano recapitati al bucket S3. Per ulteriori informazioni ed esempi, consulta l'esempio put-bucket-logging in Riferimento ai comandi della AWS CLI .

Se il bucket di destinazione (target) utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, non sarà possibile impostare le ACL di bucket o di oggetti. Inoltre, non puoi includere sovvenzioni di destinazione (target) nella tua configurazione. PutBucketLogging Occorre utilizzare una policy di bucket per concedere le autorizzazioni di accesso al principal del servizio di registrazione (logging.s3.amazonaws.com). Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

Esempio - Abilitare i log degli accessi con cinque bucket in due regioni

In questo esempio, sono presenti i cinque bucket seguenti:

• 1-DOC-EXAMPLE-BUCKET1-us-east-1

• 2-DOC-EXAMPLE-BUCKET1-us-east-1

• 3-DOC-EXAMPLE-BUCKET1-us-east-1

• 1-DOC-EXAMPLE-BUCKET1-us-west-2

• 2-DOC-EXAMPLE-BUCKET1-us-west-2

Nota

Il passaggio finale della procedura seguente fornisce esempi di script bash che è possibile utilizzare per creare i bucket di registrazione di log e abilitare la registrazione di log degli accessi al server su questi bucket. Per utilizzare questi script, devi creare i file policy.json e logging.json, come descritto nella procedura seguente.

1. Crea due bucket di destinazione per la registrazione di log nelle regioni Stati Uniti occidentali (Oregon) e Stati Uniti orientali (N. Virginia) e assegna loro i nomi elencati di seguito:

   • DOC-EXAMPLE-BUCKET1-logs-us-east-1

   • DOC-EXAMPLE-BUCKET1-logs-us-west-2

2. Più avanti in questi passaggi, abiliterai la registrazione di log degli accessi al server come segue:

   • 1-DOC-EXAMPLE-BUCKET1-us-east-1 accede al bucket S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 con prefisso 1-DOC-EXAMPLE-BUCKET1-us-east-1

   • 2-DOC-EXAMPLE-BUCKET1-us-east-1 accede al bucket S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 con prefisso 2-DOC-EXAMPLE-BUCKET1-us-east-1

   • 3-DOC-EXAMPLE-BUCKET1-us-east-1 accede al bucket S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 con prefisso 3-DOC-EXAMPLE-BUCKET1-us-east-1

   • 1-DOC-EXAMPLE-BUCKET1-us-west-2 accede al bucket S3 DOC-EXAMPLE-BUCKET1-logs-us-west-2 con prefisso 1-DOC-EXAMPLE-BUCKET1-us-west-2

   • 2-DOC-EXAMPLE-BUCKET1-us-west-2 accede al bucket S3 DOC-EXAMPLE-BUCKET1-logs-us-west-2 con prefisso 2-DOC-EXAMPLE-BUCKET1-us-west-2

3. Per ogni bucket di registrazione di log di destinazione, concedi le autorizzazioni per la consegna di log di accesso al server utilizzando una ACL di bucket o una policy del bucket:

   • Aggiorna la policy del bucket (consigliato): per concedere autorizzazioni al principale del servizio di registrazione di log, utilizza il comando put-bucket-policy seguente. Sostituisci example-s3-destination-bucket-logs con il nome del tuo bucket di destinazione.

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

     Policy.json è un documento JSON nella cartella corrente che contiene la policy del bucket seguente. Per utilizzare questa policy del bucket, sostituisci user input placeholders con le tue informazioni. Nella policy seguente, example-s3-destination-bucket-logs è il bucket di destinazione in cui verranno distribuiti i log degli accessi al server e example-s3-source-bucket è il bucket di origine. SOURCE-ACCOUNT-ID è l' Account AWS proprietario del bucket di origine.

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

   • Aggiorna l'ACL bucket: per concedere le autorizzazioni al gruppo di distribuzione dei log S3, utilizza il comando put-bucket-acl seguente. Sostituisci example-s3-destination-bucket-logs con il nome del tuo bucket di destinazione (target).

     
     aws s3api put-bucket-acl --bucket example-s3-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. Quindi, crea un file logging.json che contenga la configurazione di registrazione di log (in base a uno dei tre esempi che seguono). Dopo aver creato il file logging.json, puoi applicare la configurazione di registrazione di log utilizzando il comando put-bucket-logging seguente. Sostituisci example-s3-destination-bucket-logs con il nome del tuo bucket di destinazione (target).

   
   aws s3api put-bucket-logging --bucket example-s3-destination-bucket-logs --bucket-logging-status file://logging.json 
                                       

   Nota

   Invece di usare questo comando put-bucket-logging per applicare la configurazione di registrazione di log su ogni bucket di destinazione, puoi usare uno degli script bash forniti nel passaggio successivo. Per utilizzare questi script, devi creare i file policy.json e logging.json, come descritto in questa procedura.

   Il file logging.json è un documento JSON nella cartella corrente che contiene la configurazione della registrazione di log. Se un bucket di destinazione utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, la configurazione di registrazione di log non può contenere concessioni di destinazione (target). Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

   Esempio – logging.json senza concessioni relative alla destinazione (target)

   Il seguente file di esempio logging.json contiene concessioni di destinazione (target). Pertanto, puoi applicare questa configurazione a un bucket di destinazione (target) che utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto.

   
     {
         "LoggingEnabled": {
             "TargetBucket": "example-s3-destination-bucket-logs",
             "TargetPrefix": "example-s3-destination-bucket/"
          }
      } 
                        

   Esempio – logging.json con concessioni relative alla destinazione (target)

   Il seguente file di esempio logging.json contiene concessioni di destinazione (target).

   Se un bucket di destinazione utilizza l'impostazione Proprietario del bucket applicato per Proprietà dell'oggetto, non sarà possibile includere concessioni di destinazione (target) nella configurazione PutBucketLogging. Per ulteriori informazioni, consulta Autorizzazioni per la distribuzione dei registri.

   
     {
         "LoggingEnabled": {
             "TargetBucket": "example-s3-destination-bucket-logs",
             "TargetPrefix": "example-s3-destination-bucket/",
             "TargetGrants": [
                  {
                     "Grantee": {
                         "Type": "AmazonCustomerByEmail",
                         "EmailAddress": "[e-mail]"
                      },
                     "Permission": "FULL_CONTROL"
                  }
              ]
          }
      } 
                        

   Esempio – logging.json con il formato della chiave dell'oggetto di log impostato sull'ora dell'evento S3

   Il file logging.json seguente modifica il formato della chiave dell'oggetto di log in Ora evento S3. Per informazioni sull'impostazione del formato della chiave dell'oggetto di log, consulta Come si abilita il recapito dei log?.

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

5. Utilizza uno dei seguenti script bash per aggiungere la registrazione di log degli accessi per tutti i bucket nel tuo account. Sostituisci example-s3-destination-bucket-logs con il nome del bucket di destinazione (target) e sostituisci us-west-2 con il nome della regione in cui si trovano i bucket.

   Nota

   Questo script funziona solo se tutti i bucket si trovano nella stessa regione. Se ci sono bucket in più regioni, è necessario modificare lo script.

   Esempio – Concedi l'accesso con le policy del bucket e aggiungi la registrazione per i bucket nel tuo account

   
     loggingBucket='example-s3-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"
   

   Esempio – Concedi l'accesso con ACL di bucket e aggiungi la registrazione per i bucket nel tuo account

   
     loggingBucket='example-s3-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"
   

Verifica della configurazione dei log degli accessi al server

Dopo aver abilitato la registrazione degli accessi al server, completa la procedura riportata di seguito:

• Accedi al bucket di destinazione e verifica che i file di log vengano distribuiti. Dopo che i log di accesso sono stati configurati, potrebbe essere necessaria più di un'ora prima che tutte le richieste vengano registrate e distribuite correttamente. Puoi anche verificare automaticamente la consegna dei log utilizzando i parametri delle richieste di Amazon S3 e configurando gli CloudWatch allarmi Amazon per questi parametri. Per ulteriori informazioni, consulta Monitoraggio delle metriche con Amazon CloudWatch.

• Verifica di essere in grado di aprire e leggere il contenuto dei file di log.

Per informazioni sulla risoluzione dei problemi relativi alla registrazione degli accessi al server, consultare Risoluzione dei problemi di registrazione degli accessi al server.