Habilitar o log de acesso ao servidor do Amazon S3 - Amazon Simple Storage Service
Permissões para entrega de logsPara habilitar o log de acesso ao servidorVerificar a configuração dos logs de acesso ao servidor

Habilitar o log de acesso ao servidor do Amazon S3

O registro em log de acesso ao servidor fornece detalhes sobre as solicitações que são feitas a um bucket do Amazon S3. Os logs de acesso ao servidor são úteis para muitos aplicativos. Por exemplo, as informações do log de acesso podem ser úteis em auditorias de segurança e acesso. Essas informações também podem ajudar você a conhecer sua base de clientes e entender a cobrança do Amazon S3.

Por padrão, o Amazon S3 não coleta logs de acesso ao servidor. Quando você habilita o registro em log, o Amazon S3 entrega os logs de acesso de um bucket de origem a um bucket de destino (também conhecido como bucket-alvo) de sua escolha. O bucket de destino deve estar nas mesmas Região da AWS e Conta da AWS que o bucket de origem.

Um registro do log de acesso contém detalhes sobre as solicitações feitas a um bucket. Essa informação pode incluir o tipo de solicitação, os recursos que foram especificados na solicitação e a hora e data em que a solicitação foi processada. Para obter mais informações sobre noções básicas de registro em log, consulte Registrar em log as solicitações com registro em log de acesso ao servidor.

Importante

  • Não há custo adicional para a ativação de registro de acesso ao servidor em um bucket do Amazon S3. No entanto, todos os arquivos de log que o sistema fornece acumularão as cobranças normais de armazenamento. Você pode excluir os arquivos de registro em log a qualquer momento. Não estimamos as cobranças pela transferência de dados por entrega de arquivo de log, mas cobramos a taxa normal de transferência de dados pelo acesso aos arquivos de log.

  • O bucket de destino não deve ter registro em log de acesso ao servidor habilitado. Os logs podem ser entregues a qualquer bucket que você possui e que esteja na mesma região que o bucket de origem, incluindo o próprio bucket de origem. No entanto, a entrega de logs para o bucket de origem causará um loop infinito de logs e não é recomendada. Para um gerenciamento de logs mais simples, recomendamos que você salve logs de acesso em um bucket diferente. Para ter mais informações, consulte Como faço para habilitar a entrega de logs?.

  • Os buckets do S3 com a funcionalidade Bloqueio de Objetos do S3 habilitada não podem ser usados como buckets de destino para logs de acesso ao servidor. O bucket de destino não pode ter uma configuração de período de retenção padrão.

  • O bucket de destino não pode ter a opção Pagamento pelo solicitante habilitada.

  • Você poderá usar a criptografia de bucket padrão no bucket de destino somente se usar a criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3), que usa o Advanced Encryption Standard de 256 bits (AES-256). A criptografia do lado do servidor padrão com chaves do AWS Key Management Service (AWS KMS) (SSE-KMS) não é compatível.

Você pode habilitar ou desabilitar o registro em log de acesso ao servidor usando o console do Amazon S3, a API do Amazon S3, a AWS Command Line Interface (AWS CLI) ou os AWS SDKs.

Permissões para entrega de logs

O Amazon S3 usa uma conta especial de entrega de logs para gravar logs de acesso ao servidor. Essas gravações estão sujeitas a restrições usuais de controle de acesso. Para a entrega dos logs de acesso, você deve conceder à entidade principal de serviço do registro em log (logging.s3.amazonaws.com) acesso ao bucket de destino.

Para conceder permissões ao Amazon S3 para a entrega de logs, você pode usar uma política de bucket ou listas de controle de acesso (ACLs) de bucket, dependendo das configurações da Propriedade de Objetos do S3 do bucket de destino. No entanto, recomendamos usar uma política de bucket em vez de ACLs.

Configuração aplicada pelo proprietário do bucket em S3 Object Ownership

Se o bucket de destino usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, as ACLs serão desabilitadas e não afetarão mais as permissões. Nesse caso, é necessário atualizar a política do bucket de destino para conceder acesso à entidade principal de serviço do registro em log. Não é possível atualizar sua ACL de bucket para conceder acesso ao grupo de entrega de logs do S3. Você também não pode incluir concessões de destino (também conhecidas como concessões-alvo) na configuração PutBucketLogging.

Para obter informações sobre como migrar ACLs de bucket existentes para entrega de logs de acesso para uma política de bucket, consulte Conceder acesso ao grupo de entrega de logs do S3 para registro em log de acesso ao servidor. Para obter informações sobre o Object Ownership, consulte Controlar a propriedade de objetos e desabilitar ACLs para seu bucket. Quando você cria um bucket, as ACLs são desabilitadas por padrão.

Conceder acesso usando uma política de bucket

Para conceder acesso usando uma política de bucket no bucket de destino, atualize a política de bucket para conceder a permissão s3:PutObject à entidade principal de serviço do registro em log. Se você usar o console do Amazon S3 para habilitar o registro em log de acesso ao servidor, o console atualizará automaticamente a política do bucket de destino para conceder essa permissão à entidade principal de serviço do registro em log. Se você habilitar o registro em log de acesso ao servidor de maneira programática, poderá atualizar manualmente a política do bucket de destino para conceder acesso à entidade principal de serviço do registro em log.

Para ver um exemplo de política de bucket que concede acesso à entidade principal de serviço do registro em log, consulte Conceder permissões à entidade principal do serviço de log usando uma política de bucket.

Conceder acesso usando ACLs de bucket

Você pode alternar com ACLs de bucket para conceder acesso à entrega de logs de acesso. Adicione uma entrada de concessão à ACL de bucket que concede as permissões WRITE e READ_ACP para o grupo de entrega de logs do S3. No entanto, não é recomendável conceder acesso ao grupo de entrega de logs do S3 usando ACLs de bucket. Para ter mais informações, consulte Controlar a propriedade de objetos e desabilitar ACLs para seu bucket. Para obter informações sobre como migrar ACLs de bucket existentes para entrega de logs de acesso para uma política de bucket, consulte Conceder acesso ao grupo de entrega de logs do S3 para registro em log de acesso ao servidor. Para ver um exemplo de ACL que concede acesso à entidade principal de serviço do registro em log, consulte Conceder permissões ao grupo de entrega de logs usando a ACL de bucket.

Conceder permissões à entidade principal do serviço de log usando uma política de bucket

Este exemplo de política de bucket concede a permissão s3:PutObject à entidade principal de serviço do registro em log (logging.s3.amazonaws.com). Para usar essa política de bucket, substitua os user input placeholders por suas próprias informações. Na política a seguir, DOC-EXAMPLE-DESTINATION-BUCKET é o bucket de destino em que os logs de acesso ao servidor serão entregues e DOC-EXAMPLE-SOURCE-BUCKET é o bucket de origem. EXAMPLE-LOGGING-PREFIX é o prefixo de destino opcional (também conhecido como prefixo-alvo) que você deseja usar para os objetos de log. SOURCE-ACCOUNT-ID é a Conta da AWS à qual o bucket de origem pertence.

nota

Se houver declarações Deny na política de bucket, verifique se elas não estão impedindo que o Amazon S3 entregue logs de acesso.

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

Conceder permissões ao grupo de entrega de logs usando a ACL de bucket

nota

Com base em uma prática recomendada de segurança, o Amazon S3 desabilita as listas de controle de acesso (ACLs) por padrão em todos os novos buckets. Para obter mais informações sobre permissões de ACL no console do Amazon S3, consulte Configurar ACLs.

Embora esse método não seja recomendado, é possível conceder permissões ao grupo de entrega de logs usando uma ACL de bucket. Porém, se o bucket de destino usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, você não poderá definir ACLs de bucket ou de objeto. Você também não pode incluir concessões de destino (também conhecidas como concessões-alvo) na configuração PutBucketLogging. Em vez disso, é necessário usar uma política de bucket para conceder acesso à entidade principal do serviço de log (logging.s3.amazonaws.com). Para ter mais informações, consulte Permissões para entrega de logs.

Na ACL de bucket, o grupo de entrega de logs é representado pelo seguinte URL:

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

Para conceder as permissões WRITE e READ_ACP (leitura de ACL), adicione as seguintes concessões à ACL do bucket de destino:

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

Para obter exemplos de adição de concessões de ACL de forma programada, consulte Configurar ACLs.

Importante

Ao habilitar o log de acesso ao servidor do Amazon S3 usando o AWS CloudFormation em um bucket e usar ACLs para conceder acesso ao grupo de entrega de logs do S3, você também deverá adicionar “AccessControl": "LogDeliveryWrite"” ao modelo do CloudFormation. Fazer isso é importante porque só é possível conceder essas permissões criando uma ACL para o bucket, mas não é possível criar ACLs personalizadas para buckets no CloudFormation. Você só pode usar ACLs predefinidas com o CloudFormation.

Para habilitar o log de acesso ao servidor

Para habilitar o registro em log de acesso ao servidor usando o console do Amazon S3, a API REST do Amazon S3, os AWS SDKs e a AWS CLI, use os procedimentos a seguir.

  1. Faça login no AWS Management Console e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

  2. Na lista Buckets, escolha o nome do bucket para o qual você deseja habilitar o log de acesso ao servidor.

  3. Escolha Properties (Propriedades).

  4. Na seção Server access logging (Registro de acesso ao servidor) escolha Edit (Editar).

  5. Em Registro em log de acesso ao servidor, selecione Habilitar.

  6. Em Bucket de destino, especifique um bucket e um prefixo opcional. Se você especificar um prefixo, recomendamos incluir uma barra (/) depois dele para facilitar a localização dos logs.

    nota

    Especificar um prefixo com uma barra (/) simplifica a localização de objetos de log. Por exemplo, se você especificar o valor do prefixo logs/, cada objeto de log criado pelo Amazon S3 começará com o prefixo logs/ na sua chave, da seguinte forma:

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

    Se você especificar o valor de prefixo logs, o objeto de log será exibido da seguinte forma:

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

  7. Em Formato da chave do objeto de log, execute uma das seguintes ações:

    • Para escolher o particionamento não baseado em data, escolha [DestinationPrefix][AAAA]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString].

    • Para escolher o particionamento baseado em data, escolha [DestinationPrefix][SourceAccountId]/[SourceRegion]/[SourceBucket]/[AAAA]/[MM]/[DD]/[AAAA]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString], depois escolha Hora do evento do S3 ou Hora de entrega do arquivo de log.

  8. Escolha Salvar alterações.

    Quando você habilita o registro em log de acesso ao servidor em um bucket, o console habilita o registro em log no bucket de origem e atualiza a política do bucket de destino para conceder a permissão s3:PutObject à entidade principal de serviço do registro em log (logging.s3.amazonaws.com). Para obter mais informações sobre esta política de bucket, consulte Conceder permissões à entidade principal do serviço de log usando uma política de bucket.

    Você pode visualizar os logs no bucket de destino. Depois de habilitar o registro em log de acesso ao servidor, pode demorar algumas horas antes que os logs sejam entregues no bucket de destino. Para obter mais informações sobre como e quando os logs são entregues, consulte Como os logs são entregues?.

Para ter mais informações, consulte Visualização das propriedades de um bucket do S3.

Para habilitar o registro em log, envie uma solicitação PutBucketLogging para adicionar a configuração de registro em log no bucket de origem. A solicitação especifica o bucket de destino (também conhecido como bucket-alvo) e, opcionalmente, o prefixo a ser usado com todas as chaves de objeto de log.

O exemplo a seguir identifica DOC-EXAMPLE-DESTINATION-BUCKET como o bucket de destino e logs/ como o prefixo. 

<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <LoggingEnabled>
    <TargetBucket>DOC-EXAMPLE-DESTINATION-BUCKET</TargetBucket>
    <TargetPrefix>logs/</TargetPrefix>
  </LoggingEnabled>
</BucketLoggingStatus>

O exemplo a seguir identifica DOC-EXAMPLE-DESTINATION-BUCKET como o bucket de destino, logs/ como o prefixo e EventTime como o formato da chave de objeto de log. 

<BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
  <LoggingEnabled>
    <TargetBucket>DOC-EXAMPLE-DESTINATION-BUCKET</TargetBucket>
    <TargetPrefix>logs/</TargetPrefix>
    <TargetObjectKeyFormat>
      <PartitionedPrefix>
         <PartitionDateSource>EventTime</PartitionDateSource>
      </PartitionedPrefix>
  </TargetObjectKeyFormat>
  </LoggingEnabled>
</BucketLoggingStatus>

Os objetos de log são gravados e pertencem à conta de entrega de logs do S3, e o proprietário do bucket tem permissões totais sobre os objetos de log. Você tem a opção de usar concessões de destino (também conhecidas como concessões-alvo) para conceder permissões a outros usuários para que eles possam acessar os logs. Para ter mais informações, consulte PutBucketLogging.

nota

Se o bucket de destino usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, você não poderá usar concessões de destino para conceder permissões a outros usuários. Para conceder permissões a outros, é possível atualizar a política de bucket no bucket de destino. Para ter mais informações, consulte Permissões para entrega de logs.

Para recuperar a configuração de registro em log de um bucket, use a operação de API GetBucketLogging.

Para excluir a configuração de registro em log, envie uma solicitação PutBucketLogging com um BucketLoggingStatus vazio: 

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

Para habilitar o registro em log em um bucket, é possível usar a API do Amazon S3 ou as bibliotecas wrapper do AWS SDK.

O exemplo a seguir habilita o registro em log em um bucket. Você deve criar dois buckets, um de origem e um de destino (alvo). Os exemplos atualizam primeiro a ACL do bucket de destino. Depois, eles concedem ao grupo de entrega de logs as permissões necessárias para gravar logs no bucket de destino e habilitam o registro em log no bucket de origem.

Este exemplo não funcionará em buckets de destino que usam a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos.

Se o bucket de destino (alvo) usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, você não poderá definir ACLs de bucket ou de objeto. Também não é possível incluir concessões de destino (alvo) na configuração PutBucketLogging. É necessário usar uma política de bucket para conceder acesso à entidade principal do serviço de log (logging.s3.amazonaws.com). Para ter mais informações, consulte Permissões para entrega de logs.

.NET
AWS SDK for .NET
nota

Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no AWSCode Examples Repository. 

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

  • Para obter detalhes da API, consulte PutBucketLogging na Referência da API do AWS SDK for .NET.

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

}

Recomendamos que você crie um bucket de registro dedicado em cada Região da AWS em que tenha buckets do S3. Depois, faça com que os logs de acesso do Amazon S3 sejam entregues a esse bucket do S3. Para obter mais informações e exemplos, consulte put-bucket-logging na Referência da AWS CLI.

Se o bucket de destino (alvo) usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, você não poderá definir ACLs de bucket ou de objeto. Também não é possível incluir concessões de destino (alvo) na configuração PutBucketLogging. É necessário usar uma política de bucket para conceder acesso à entidade principal do serviço de log (logging.s3.amazonaws.com). Para obter mais informações, consulte Permissões para entrega de logs.

exemplo : Habilite logs de acesso com cinco buckets em duas regiões

Neste exemplo, você tem estes cinco buckets:

  • 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

A etapa final do procedimento a seguir fornece exemplos de scripts bash que você pode usar para criar buckets de registro em log e habilitar o registro em log de acesso ao servidor nesses buckets. Para usar esses scripts, você deve criar os arquivos policy.json e logging.json, conforme descrito no procedimento a seguir.

  1. Crie dois buckets de destino do registro em log nas regiões Oeste dos EUA (Oregon) e Leste dos EUA (N. da Virgínia) e dê a eles os seguintes nomes:

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

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

  2. Posteriormente nessas etapas, você habilitará o registro em log de acesso ao servidor da seguinte forma:

    • Logs de 1-DOC-EXAMPLE-BUCKET1-us-east-1 no bucket do S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 com o prefixo 1-DOC-EXAMPLE-BUCKET1-us-east-1

    • Logs de 2-DOC-EXAMPLE-BUCKET1-us-east-1 no bucket do S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 com o prefixo 2-DOC-EXAMPLE-BUCKET1-us-east-1

    • Logs de 3-DOC-EXAMPLE-BUCKET1-us-east-1 no bucket do S3 DOC-EXAMPLE-BUCKET1-logs-us-east-1 com o prefixo 3-DOC-EXAMPLE-BUCKET1-us-east-1

    • Logs de 1-DOC-EXAMPLE-BUCKET1-us-west-2 no bucket do S3 DOC-EXAMPLE-BUCKET1-logs-us-west-2 com o prefixo 1-DOC-EXAMPLE-BUCKET1-us-west-2

    • Logs de 2-DOC-EXAMPLE-BUCKET1-us-west-2 no bucket do S3 DOC-EXAMPLE-BUCKET1-logs-us-west-2 com o prefixo 2-DOC-EXAMPLE-BUCKET1-us-west-2

  3. Para cada bucket de registro em log de destino, conceda permissões para a entrega de logs de acesso ao servidor usando uma ACL de bucket ou uma política de bucket:

    • Atualizar a política de bucket (recomendado): para conceder permissões à entidade principal do serviço de log, use o comando put-bucket-policy a seguir. Substitua DOC-EXAMPLE-DESTINATION-BUCKET-logs pelo nome de seu bucket de destino.

      aws s3api put-bucket-policy --bucket DOC-EXAMPLE-DESTINATION-BUCKET-logs --policy file://policy.json

      Policy.json é um documento JSON na pasta atual que contém a política de bucket a seguir. Para usar essa política de bucket, substitua os user input placeholders por suas próprias informações. Na política a seguir, DOC-EXAMPLE-DESTINATION-BUCKET-logs é o bucket de destino em que os logs de acesso ao servidor serão entregues e DOC-EXAMPLE-SOURCE-BUCKET é o bucket de origem. SOURCE-ACCOUNT-ID é a Conta da AWS à qual o bucket de origem pertence.

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

    • Atualizar a ACL de bucket: para conceder permissões ao grupo de entrega de logs do S3, use o comando put-bucket-acl a seguir. Substitua DOC-EXAMPLE-DESTINATION-BUCKET-logs pelo nome do bucket de destino (alvo).

      
aws s3api put-bucket-acl --bucket DOC-EXAMPLE-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. Depois, crie um arquivo logging.json que contenha a configuração de registro em log (com base em um dos três exemplos a seguir). Depois de criar o arquivo logging.json, você pode aplicar a configuração de registro em log usando o comando put-bucket-logging a seguir. Substitua DOC-EXAMPLE-DESTINATION-BUCKET-logs pelo nome do bucket de destino (alvo).

    
aws s3api put-bucket-logging --bucket DOC-EXAMPLE-DESTINATION-BUCKET-logs --bucket-logging-status file://logging.json
    nota

    Em vez de usar esse comando put-bucket-logging para aplicar a configuração de registro em log em cada bucket de destino, você pode usar um dos scripts bash fornecidos na próxima etapa. Para usar esses scripts, você deve criar os arquivos policy.json e logging.json, conforme descrito nesse procedimento.

    O arquivo logging.json é um documento JSON na pasta atual que contém a configuração do registro em log. Se um bucket de destino usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, a configuração de registro em log não poderá conter concessões de destino (alvo). Para ter mais informações, consulte Permissões para entrega de logs.

    exemplo : logging.json sem concessões de destino (alvo)

    O exemplo de arquivo logging.json a seguir não contém concessões de destino (alvo). Portanto, você pode aplicar essa configuração a um bucket de destino (alvo) que usa a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos.

    
  {
      "LoggingEnabled": {
          "TargetBucket": "DOC-EXAMPLE-DESTINATION-BUCKET-logs",
          "TargetPrefix": "DOC-EXAMPLE-DESTINATION-BUCKET/"
       }
   }
    exemplo : logging.json com concessões de destino (alvo)

    O exemplo de arquivo logging.json a seguir contém concessões de destino (alvo).

    Se o bucket de destino usar a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos, você não poderá incluir concessões de destino (alvo) na configuração PutBucketLogging. Para ter mais informações, consulte Permissões para entrega de logs.

    
  {
      "LoggingEnabled": {
          "TargetBucket": "DOC-EXAMPLE-DESTINATION-BUCKET-logs",
          "TargetPrefix": "DOC-EXAMPLE-DESTINATION-BUCKET/",
          "TargetGrants": [
               {
                  "Grantee": {
                      "Type": "AmazonCustomerByEmail",
                      "EmailAddress": "user@example.com"
                   },
                  "Permission": "FULL_CONTROL"
               }
           ]
       }
   }
    exemplo : logging.json com o formato da chave de objeto de log definido como a hora do evento do S3

    O arquivo logging.json a seguir altera o formato da chave de objeto de log para a hora do evento do S3. Para obter mais informações sobre como definir o formato da chave de objeto de log, consulte Como faço para habilitar a entrega de logs?.

    
  { 
    "LoggingEnabled": {
        "TargetBucket": "DOC-EXAMPLE-DESTINATION-BUCKET-logs",
        "TargetPrefix": "DOC-EXAMPLE-DESTINATION-BUCKET/",
        "TargetObjectKeyFormat": { 
            "PartitionedPrefix": { 
                "PartitionDateSource": "EventTime" 
            }
         }
    }
}

  5. Use um script bash a seguir para adicionar o registro em log de acesso a todos os buckets em sua conta. Substitua DOC-EXAMPLE-DESTINATION-BUCKET-logs pelo nome do bucket de destino (alvo) e substitua us-west-2 pelo nome da região em que os buckets estão localizados.

    nota

    Esse script só funcionará se todos os buckets estiverem na mesma região. Se você tiver buckets em várias regiões, deverá ajustar o script.

    exemplo – Conceda acesso com políticas de bucket e adicione log para os buckets de sua conta
    
  loggingBucket='DOC-EXAMPLE-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"
    exemplo – Conceda acesso com ACLs de bucket e adicione log para os buckets de sua conta
    
  loggingBucket='DOC-EXAMPLE-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"

Verificar a configuração dos logs de acesso ao servidor

Depois de habilitar o registro em log de acesso ao servidor, execute as seguintes etapas:

  • Acesse o bucket de destino e verifique se os arquivos de log estão sendo entregues. Depois de configurar os logs de acesso, pode levar mais de uma hora para que todas as solicitações sejam registradas e entregues adequadamente. Também é possível verificar automaticamente a entrega de logs usando métricas de solicitação do Amazon S3 e configurando alarmes do Amazon CloudWatch para essas métricas. Para ter mais informações, consulte Monitoramento de métricas com o Amazon CloudWatch.

  • Verifique se você consegue abrir e ler o conteúdo dos arquivos de log.

Para obter informações sobre solução de problemas do registro de acesso ao servidor, consulte Solução de problemas do registro em log de acessos ao servidor.