# Registrar em log as solicitações com registro em log de acesso ao servidor
O registro em log de acesso ao servidor fornece detalhes sobre as solicitações que são feitas a um bucket. 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.
**nota**
Os logs de acesso ao servidor não registram informações sobre erros de redirecionamento a regiões erradas para regiões lançadas após 20 de março de 2019. Erros de redirecionamento para regiões erradas ocorrem quando uma solicitação para um objeto ou bucket é feita fora da região em que o bucket existe.
## Como faço para habilitar a entrega de logs?
Para habilitar a entrega de logs, execute as seguintes etapas básicas. Para obter mais detalhes, consulte [Habilitar o log de acesso ao servidor do Amazon S3](enable-server-access-logging.md).
1. **Forneça o nome do bucket de destino** (também conhecido como *bucket de destino*). Esse bucket é onde você deseja que o Amazon S3 salve os logs de acesso como objetos. Os buckets de origem e de destino devem estar na mesma Região da AWS e pertencer à mesma conta. O bucket de destino não pode ter uma configuração de período de retenção padrão da funcionalidade Bloqueio de Objetos do S3. O bucket de destino também não pode ter a opção Pagamento pelo solicitante habilitada.
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, para um gerenciamento de logs mais simples, recomendamos que você salve logs de acesso em um bucket diferente.
Quando o bucket de origem e o bucket de destino são os mesmos, logs adicionais serão criados para os logs que forem gravados no bucket, o que criará um ciclo infinito de logs. Não recomendamos fazer isso, pois pode gerar um pequeno aumento na cobrança do armazenamento. Além disso, com os logs adicionais sobre logs, pode ser mais difícil encontrar o log que você está procurando.
Se você optar por salvar os logs de acesso no bucket de origem, recomendamos que especifique um prefixo de destino (também conhecido como *prefixo-alvo*) para todas as chaves de objeto de log. Quando você especifica um prefixo, todos os nomes de objeto de log começam com uma string comum, o que facilita a identificação dos objetos de log.
1. **(Opcional) Atribua um prefixo de destino a todas as chaves de objeto de log do Amazon S.** O prefixo de destino (também conhecido como *prefixo-alvo*) facilita 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, por exemplo:
```
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
```
Os [prefixos](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#keyprefix) também são úteis para distinguir entre buckets de origem quando vários buckets são registrados em log no mesmo bucket de destino.
Esse prefixo também ajuda ao excluir os logs. Por exemplo, você pode definir uma regra de configuração do ciclo de vida para que o Amazon S3 exclua objetos com um prefixo específico. Para obter mais informações, consulte [Exclusão de arquivos de log do Amazon S3](deleting-log-files-lifecycle.md).
1. **(Opcional) Defina permissões **para que outros possam acessar os logs gerados.** Por padrão, somente o proprietário do bucket sempre tem acesso completo aos objetos de log. Se o bucket de destino usam a configuração Imposto pelo proprietário do bucket para a Propriedade de Objetos do S3 a fim de desabilitar as listas de controle de acesso (ACLs), você não pode conceder permissões nas concessões de destino (também chamadas de *concessões-alvo*) que usam ACLs. Porém, você pode atualizar a política do bucket de destino para conceder acesso a outros. Para obter mais informações, consulte [Gerenciamento de identidade e acesso para o Amazon S3](security-iam.md) e [Permissões para entrega de logs](enable-server-access-logging.md#grant-log-delivery-permissions-general).
1. **(Opcional) Defina um formato de chave de objeto de log para os arquivos de log.** Você tem duas opções para o formato da chave de objeto de log (também conhecido como *formato da chave de objeto-alvo*):
+ **Particionamento não baseado em data**: esse é o formato original da chave de objeto de log. Se você escolher esse formato, o formato da chave de arquivo de log será exibido da seguinte forma:
```
[DestinationPrefix][YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
Por exemplo, se você especificar `logs/` como prefixo, os objetos de log serão nomeados assim:
```
logs/2013-11-01-21-32-16-E568B2907131C0C0
```
+ **Particionamento baseado em data**: se você escolher o particionamento baseado em data, poderá escolher a hora do evento ou a hora de entrega do arquivo de log como a fonte de data usada no formato do log. Esse formato facilita a consulta dos logs.
Se você escolher o particionamento baseado em data, o formato da chave de arquivo de log será exibido da seguinte forma:
```
[DestinationPrefix][SourceAccountId]/[SourceRegion]/[SourceBucket]/[YYYY]/[MM]/[DD]/[YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
Por exemplo, se você especificar `logs/` como prefixo-alvo, os objetos de log serão nomeados assim:
```
logs/123456789012/us-west-2/amzn-s3-demo-source-bucket/2023/03/01/2023-03-01-21-32-16-E568B2907131C0C0
```
Para a entrega na hora de entrega, a hora nos nomes de arquivo de log corresponde à hora de entrega dos arquivos de log.
Para a entrega na hora do evento, o ano, o mês e o dia correspondem ao dia em que o evento ocorreu, e a hora, os minutos e os segundos são definidos como `00` na chave. Os logs entregues nesses arquivos de log são somente para um dia específico.
Se você estiver configurando os logs por meio da AWS Command Line Interface (AWS CLI), AWS SDKs ou API REST do Amazon S3, use `TargetObjectKeyFormat` para especificar o formato da chave de objeto de log. Para especificar o particionamento não baseado em data, use `SimplePrefix`. Para especificar o particionamento baseado em data, use `PartitionedPrefix`. Se você usar `PartitionedPrefix`, use `PartitionDateSource` para especificar `EventTime` ou `DeliveryTime`.
Para `SimplePrefix`, o formato da chave de arquivo de log aparece da seguinte forma:
```
[TargetPrefix][YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
Para `PartitionedPrefix` com hora do evento ou hora da entrega, o formato da chave de arquivo de log aparece da seguinte forma:
```
[TargetPrefix][SourceAccountId]/[SourceRegion]/[SourceBucket]/[YYYY]/[MM]/[DD]/[YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
## Formato da chave de objeto de log
O Amazon S3 usa os seguintes formatos de chave de objeto para os objetos de log carregados no bucket de destino:
+ **Particionamento não baseado em data**: esse é o formato original da chave de objeto de log. Se você escolher esse formato, o formato da chave de arquivo de log será exibido da seguinte forma:
```
[DestinationPrefix][YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
+ **Particionamento baseado em data**: se você escolher o particionamento baseado em data, poderá escolher a hora do evento ou a hora de entrega do arquivo de log como a fonte de data usada no formato do log. Esse formato facilita a consulta dos logs.
Se você escolher o particionamento baseado em data, o formato da chave de arquivo de log será exibido da seguinte forma:
```
[DestinationPrefix][SourceAccountId]/[SourceRegion]/[SourceBucket]/[YYYY]/[MM]/[DD]/[YYYY]-[MM]-[DD]-[hh]-[mm]-[ss]-[UniqueString]
```
Na chave de objeto de log, `YYYY`, `MM`, `DD`, `hh`, `mm` e `ss` são os dígitos do ano, mês, dia, hora, minutos e segundos (respectivamente). Essas datas e horas estão em Tempo Universal Coordenado (UTC).
Um arquivo de log entregue em um horário específico pode conter registros gravados a qualquer momento até aquele horário. Não há como saber se todos os logs de um certo intervalo de tempo foram entregues ou não.
O componente `UniqueString` da chave existe para impedir que arquivos sejam substituídos por outros. Ele não tem significado, e o software de processamento de logs deve ignorá-lo.
## Como os logs são entregues?
O Amazon S3 coleta periodicamente os registros de log de acesso, consolida-os em arquivos de log e faz upload desses arquivos no bucket de destino como objetos de log. Caso o registro em log esteja habilitado em diversos buckets de origem que identifiquem o mesmo bucket de destino, esse bucket de destino terá os logs de acesso de todos os buckets de origem. No entanto, cada objeto de log relata registros de log para um bucket de origem específico.
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. Recomendamos atualizar a política do bucket de destino para conceder acesso à entidade principal de serviço do registro em log (`logging.s3.amazonaws.com`) para entrega de logs de acesso. Você também pode conceder acesso para a entrega de logs de acesso ao grupo de entrega de logs do S3 por meio da lista de controle de acesso (ACL) do bucket. No entanto, não é recomendável conceder acesso ao grupo de entrega de logs do S3 usando a ACL do bucket.
Ao habilitar o registro em log de acesso ao servidor e conceder acesso para a entrega de logs de acesso por meio da política do bucket de destino, atualize a política para permitir acesso `s3:PutObject` para a 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 essas permissões à entidade principal de serviço do registro em log. Para obter mais informações sobre como conceder permissões para logs de acesso ao servidor, consulte [Permissões para entrega de logs](enable-server-access-logging.md#grant-log-delivery-permissions-general).
**nota**
O S3 não é compatível com a entrega de logs do CloudTrail ou logs de acesso ao servidor ao solicitante ou ao proprietário do bucket para solicitações de endpoint da VPC quando a política de endpoint da VPC as nega ou para solicitações que falham antes da política da VPC ser avaliada.
**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. É necessário atualizar a política do bucket de destino para conceder acesso à entidade principal de serviço do registro em log. Para obter informações sobre o Object Ownership, consulte [Conceder acesso ao grupo de entrega de logs do S3 para registro em log de acesso ao servidor](object-ownership-migrating-acls-prerequisites.md#object-ownership-server-access-logs).
## Entrega de logs do servidor de melhor esforço
Os registros de log de acesso ao servidor são entregues com base no melhor esforço. A maioria das solicitações para um bucket configurado corretamente para registro em log tem como resultado um registro do log entregue. A maioria dos registros de log é entregue dentro de algumas horas após o tempo em que forem registrados, mas eles podem ser entregues com mais frequência.
A integralidade e a pontualidade do registro em log do servidor não são garantidas. O registro de log de uma solicitação específica pode ser entregue muito depois de a solicitação ter sido realmente processada ou *pode nem ser entregue*. É possível que você até veja uma duplicação de um registro de log. A finalidade dos logs do servidor é proporcionar uma ideia da natureza do tráfego no bucket. Embora a perda ou a duplicação de registros de log sejam acontecimentos raros, esteja ciente de que o registro em log do servidor não tem como objetivo ser uma contabilidade completa de todas as solicitações.
Devido à natureza de melhor esforço do registro em log do servidor, os relatórios de uso podem incluir uma ou mais solicitações de acesso que não aparecem em um log do servidor entregue. Você pode encontrar esses relatórios de uso em **Cost & usage reports** no console do Gerenciamento de Faturamento e Custos da AWS.
## As alterações do status do registro de bucket em logs entram em vigor ao longo do tempo
As alterações no status do log de um bucket levam tempo para realmente afetar a entrega de arquivos de log. Por exemplo, se você habilitar o registro em log para um bucket, algumas solicitações feitas na hora seguinte poderão ser registradas, enquanto outras não. Suponha que você altere o bucket de destino para registro em log do bucket A para o bucket B. Durante a hora seguinte, alguns logs poderão continuar sendo entregues ao bucket A, enquanto outros serão entregues ao novo bucket de destino B. Em todo caso, as novas configurações entrarão em vigor posteriormente, sem a necessidade de ações adicionais.
Para obter mais informações sobre registro em log e arquivos de log, consulte as seguintes seções:
**Topics**
+ [
## Como faço para habilitar a entrega de logs?
](#server-access-logging-overview)
+ [
## Formato da chave de objeto de log
](#server-log-keyname-format)
+ [
## Como os logs são entregues?
](#how-logs-delivered)
+ [
## Entrega de logs do servidor de melhor esforço
](#LogDeliveryBestEffort)
+ [
## As alterações do status do registro de bucket em logs entram em vigor ao longo do tempo
](#BucketLoggingStatusChanges)
+ [
# Habilitar o log de acesso ao servidor do Amazon S3
](enable-server-access-logging.md)
+ [
# Formato dos logs de acesso ao servidor do Amazon S3
](LogFormat.md)
+ [
# Exclusão de arquivos de log do Amazon S3
](deleting-log-files-lifecycle.md)
+ [
# Usar logs de acesso ao servidor do Amazon S3 para identificar solicitações
](using-s3-access-logs-to-identify-requests.md)
+ [
# Solução de problemas do registro em log de acessos ao servidor
](troubleshooting-server-access-logging.md)
# 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](ServerLogs.md).
**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 obter mais informações, consulte . [Como faço para habilitar a entrega de logs?](ServerLogs.md#server-access-logging-overview)
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ê 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 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html).
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](object-ownership-migrating-acls-prerequisites.md#object-ownership-server-access-logs). Para obter informações sobre o Object Ownership, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](about-object-ownership.md). 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](#grant-log-delivery-permissions-bucket-policy).
**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 obter mais informações, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](about-object-ownership.md). 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](object-ownership-migrating-acls-prerequisites.md#object-ownership-server-access-logs). 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](#grant-log-delivery-permissions-acl).
### 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, `amzn-s3-demo-destination-bucket` é o bucket de destino ao qual os logs de acesso ao servidor serão entregues e `amzn-s3-demo-source-bucket` é o bucket de origem. `EXAMPLE-LOGGING-PREFIX` é o prefixo de destino opcional (também conhecido como *prefixo de destino*) que você deve 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.
------
#### [ JSON ]
****
```
{
"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"
}
}
}
]
}
```
------
### 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](managing-acls.md).
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 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html). 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 obter mais informações, consulte [Permissões para entrega de logs](#grant-log-delivery-permissions-general).
Na ACL de bucket, o grupo de entrega de logs é representado pelo seguinte URL:
```
1. 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:
```
1.
2.
3. http://acs.amazonaws.com/groups/s3/LogDelivery
4.
5. WRITE
6.
7.
8.
9. http://acs.amazonaws.com/groups/s3/LogDelivery
10.
11. READ_ACP
12.
```
Para obter exemplos de adição de concessões de ACL de forma programada, consulte [Configurar ACLs](managing-acls.md).
**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.
### Usar o console do S3
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel de navegação à esquerda, escolha **Buckets de uso geral**.
1. Na lista de buckets, escolha o nome do bucket para o qual você deseja habilitar o registro em log do acesso ao servidor.
1. Escolha **Properties (Propriedades)**.
1. Na seção **Server access logging (Registro de acesso ao servidor)** escolha **Edit (Editar)**.
1. Em **Registro em log de acesso ao servidor**, selecione **Habilitar**.
1. 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
```
1. 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**.
1. 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](#grant-log-delivery-permissions-bucket-policy).
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?](ServerLogs.md#how-logs-delivered).
Para obter mais informações, consulte [Visualizar das propriedades de um bucket de uso geral do S3](view-bucket-properties.md).
### Uso da API REST
Para habilitar o registro em log, envie uma solicitação [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html) 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 `amzn-s3-demo-destination-bucket` como o bucket de destino e *`logs/`* como o prefixo.
```
1.
2.
3. amzn-s3-demo-destination-bucket
4. logs/
5.
6.
```
O exemplo a seguir identifica `amzn-s3-demo-destination-bucket` como o bucket de destino, *`logs/`* como o prefixo e `EventTime` como o formato da chave de objeto de log.
```
1.
2.
3. amzn-s3-demo-destination-bucket
4. logs/
5.
6.
7. EventTime
8.
9.
10.
11.
```
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 obter mais informações, consulte [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html).
**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 obter mais informações, consulte [Permissões para entrega de logs](#grant-log-delivery-permissions-general).
Para recuperar a configuração de registro em log de um bucket, use a operação de API [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlogging.html).
Para excluir a configuração de registro em log, envie uma solicitação `PutBucketLogging` com um `BucketLoggingStatus` vazio:
```
1.
2.
```
Para habilitar o registro em log em um bucket, é possível usar a API do Amazon S3 ou as bibliotecas wrapper do AWS SDK.
### Usar SDKs da AWS
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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html). É 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](#grant-log-delivery-permissions-general).
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/S3#code-examples).
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.S3;
using Amazon.S3.Model;
using Microsoft.Extensions.Configuration;
///
/// 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.
///
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}");
}
}
///
/// This method grants appropriate permissions for logging to the
/// Amazon S3 bucket where the logs will be stored.
///
/// The initialized Amazon S3 client which will be used
/// to apply the bucket policy.
/// The name of the source bucket.
/// The name of the bucket where logging
/// information will be stored.
/// The logging prefix where the logs should be delivered.
/// The account id of the account where the source bucket exists.
/// Async task.
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.");
}
///
/// 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.
///
/// The initialized Amazon S3 client which will be used
/// to configure and apply logging to the selected Amazon S3 bucket.
/// The name of the Amazon S3 bucket for which you
/// wish to enable logging.
/// The name of the Amazon S3 bucket where logging
/// information will be stored.
/// The prefix to prepend to each
/// object key.
/// Async task.
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.");
}
///
/// Loads configuration from settings files.
///
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();
}
}
```
+ Consulte detalhes da API em [PutBucketLogging](https://docs.aws.amazon.com/goto/DotNetSDKV3/s3-2006-03-01/PutBucketLogging) na *Referência da API do AWS SDK para .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());
}
}
```
------
### Como usar o AWS CLI
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 [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-logging.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-logging.html) 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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html). É 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](#grant-log-delivery-permissions-general).
**Example : Habilite logs de acesso com cinco buckets em duas regiões**
Neste exemplo, você tem estes cinco buckets:
+ `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`
**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:
+ `amzn-s3-demo-destination-bucket-logs-us-east-1`
+ `amzn-s3-demo-destination-bucket1-logs-us-west-2`
1. Posteriormente nessas etapas, você habilitará o registro em log de acesso ao servidor da seguinte forma:
+ Logs de `amzn-s3-demo-source-bucket-us-east-1` no bucket do S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` com o prefixo `amzn-s3-demo-source-bucket-us-east-1`
+ Logs de `amzn-s3-demo-source-bucket1-us-east-1` no bucket do S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` com o prefixo `amzn-s3-demo-source-bucket1-us-east-1`
+ Logs de `amzn-s3-demo-source-bucket2-us-east-1` no bucket do S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` com o prefixo `amzn-s3-demo-source-bucket2-us-east-1`
+ Logs de `amzn-s3-demo-bucket1-us-west-2` no bucket do S3 `amzn-s3-demo-destination-bucket1-logs-us-west-2` com o prefixo `amzn-s3-demo-bucket1-us-west-2`
+ Logs de `amzn-s3-demo-bucket2-us-west-2` no bucket do S3 `amzn-s3-demo-destination-bucket1-logs-us-west-2` com o prefixo `amzn-s3-demo-bucket2-us-west-2`
1. 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 `amzn-s3-demo-destination-bucket-logs` pelo nome de seu bucket de destino.
```
1. aws s3api put-bucket-policy --bucket amzn-s3-demo-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, *`amzn-s3-demo-destination-bucket-logs`* é o bucket de destino em que os logs de acesso ao servidor serão entregues e `amzn-s3-demo-source-bucket` é o bucket de origem. `SOURCE-ACCOUNT-ID` é a Conta da AWS à qual o bucket de origem pertence.
------
#### [ JSON ]
****
```
{
"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"
}
}
}
]
}
```
------
+ **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 *`amzn-s3-demo-destination-bucket-logs`* pelo nome do bucket de destino (alvo).
```
1. 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
```
1. 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 *`amzn-s3-demo-destination-bucket-logs`* pelo nome do bucket de destino (alvo).
```
1. aws s3api put-bucket-logging --bucket amzn-s3-demo-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 obter mais informações, consulte [Permissões para entrega de logs](#grant-log-delivery-permissions-general).
**Example : `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": "amzn-s3-demo-destination-bucket-logs",
"TargetPrefix": "amzn-s3-demo-destination-bucket/"
}
}
```
**Example : `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 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html). Para obter mais informações, consulte [Permissões para entrega de logs](#grant-log-delivery-permissions-general).
```
{
"LoggingEnabled": {
"TargetBucket": "amzn-s3-demo-destination-bucket-logs",
"TargetPrefix": "amzn-s3-demo-destination-bucket/",
"TargetGrants": [
{
"Grantee": {
"Type": "CanonicalUser",
"ID": "79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be"
},
"Permission": "FULL_CONTROL"
}
]
}
}
```
**Valores referentes ao beneficiário**
Você pode especificar a pessoa (beneficiária) a quem você está atribuindo direitos de acesso (usando elementos de solicitação) das seguintes formas:
+ Pelo ID da pessoa:
```
{
"Grantee": {
"Type": "CanonicalUser",
"ID": "ID"
}
}
```
+ Por URI:
```
{
"Grantee": {
"Type": "Group",
"URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
}
}
```
**Example : `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?](ServerLogs.md#server-access-logging-overview).
```
{
"LoggingEnabled": {
"TargetBucket": "amzn-s3-demo-destination-bucket-logs",
"TargetPrefix": "amzn-s3-demo-destination-bucket/",
"TargetObjectKeyFormat": {
"PartitionedPrefix": {
"PartitionDateSource": "EventTime"
}
}
}
}
```
1. Use um script bash a seguir para adicionar o registro em log de acesso a todos os buckets em sua conta. Substitua *`amzn-s3-demo-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.
**Example – Conceda acesso com políticas de bucket e adicione log para os buckets de sua conta**
```
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"
```
**Example – Conceda acesso com ACLs de bucket e adicione log para os buckets de sua conta**
```
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"
```
## 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 que os logs de acesso são configurados, o Amazon S3 começa imediatamente a capturar as solicitações e registrá-las em log. No entanto, pode demorar algumas horas para que os logs sejam entregues ao bucket de destino. Para obter mais informações, consulte [As alterações do status do registro de bucket em logs entram em vigor ao longo do tempo](ServerLogs.md#BucketLoggingStatusChanges) e [Entrega de logs do servidor de melhor esforço](ServerLogs.md#LogDeliveryBestEffort).
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 obter mais informações, consulte [Monitoramento de métricas com o Amazon CloudWatch](cloudwatch-monitoring.md).
+ 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](troubleshooting-server-access-logging.md).
# Formato dos logs 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. Você pode usar logs de acesso ao servidor para as seguintes finalidades:
+ Realizar auditorias de segurança e acesso
+ Aprender sobre sua base de clientes
+ Entender sua fatura do Amazon S3
Esta seção descreve o formato e outros detalhes sobre os arquivos de log de acesso ao servidor do Amazon S3.
Os arquivos de log de acesso ao servidor consistem em uma sequência de registros de log delimitados por novas linhas. Cada registro do log representa uma solicitação e consiste em campos delimitados por espaço.
Veja a seguir o exemplo de um log que consiste em cinco registros de log.
**nota**
Qualquer campo pode ser definido como `-` para indicar que os dados eram desconhecidos ou estavam indisponíveis ou que o campo não era aplicável para essa solicitação.
```
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be amzn-s3-demo-bucket1 [06/Feb/2019:00:00:38 +0000] 192.0.2.3 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be 3E57427F3EXAMPLE REST.GET.VERSIONING - "GET /amzn-s3-demo-bucket1?versioning HTTP/1.1" 200 - 113 - 7 - "-" "S3Console/0.4" - s9lzHYrFp76ZVxRcpX9+5cjAnEH2ROuNkd2BHfIa6UkFVdtjf5mKR3/eTPFvsiP/XV/VLi31234= SigV4 ECDHE-RSA-AES128-GCM-SHA256 AuthHeader amzn-s3-demo-bucket1.s3.us-west-1.amazonaws.com TLSV1.2 arn:aws:s3:us-west-1:123456789012:accesspoint/example-AP Yes us-east-1
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be amzn-s3-demo-bucket1 [06/Feb/2019:00:00:38 +0000] 192.0.2.3 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be 891CE47D2EXAMPLE REST.GET.LOGGING_STATUS - "GET /amzn-s3-demo-bucket1?logging HTTP/1.1" 200 - 242 - 11 - "-" "S3Console/0.4" - 9vKBE6vMhrNiWHZmb2L0mXOcqPGzQOI5XLnCtZNPxev+Hf+7tpT6sxDwDty4LHBUOZJG96N1234= SigV4 ECDHE-RSA-AES128-GCM-SHA256 AuthHeader amzn-s3-demo-bucket1.s3.us-west-1.amazonaws.com TLSV1.2 - - us-east-1
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be amzn-s3-demo-bucket1 [06/Feb/2019:00:00:38 +0000] 192.0.2.3 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be A1206F460EXAMPLE REST.GET.BUCKETPOLICY - "GET /amzn-s3-demo-bucket1?policy HTTP/1.1" 404 NoSuchBucketPolicy 297 - 38 - "-" "S3Console/0.4" - BNaBsXZQQDbssi6xMBdBU2sLt+Yf5kZDmeBUP35sFoKa3sLLeMC78iwEIWxs99CRUrbS4n11234= SigV4 ECDHE-RSA-AES128-GCM-SHA256 AuthHeader amzn-s3-demo-bucket1.s3.us-west-1.amazonaws.com TLSV1.2 - Yes us-east-1
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be amzn-s3-demo-bucket1 [06/Feb/2019:00:01:00 +0000] 192.0.2.3 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be 7B4A0FABBEXAMPLE REST.GET.VERSIONING - "GET /amzn-s3-demo-bucket1?versioning HTTP/1.1" 200 - 113 - 33 - "-" "S3Console/0.4" - Ke1bUcazaN1jWuUlPJaxF64cQVpUEhoZKEG/hmy/gijN/I1DeWqDfFvnpybfEseEME/u7ME1234= SigV4 ECDHE-RSA-AES128-GCM-SHA256 AuthHeader amzn-s3-demo-bucket1.s3.us-west-1.amazonaws.com TLSV1.2 - - us-east-1
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be amzn-s3-demo-bucket1 [06/Feb/2019:00:01:57 +0000] 192.0.2.3 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be DD6CC733AEXAMPLE REST.PUT.OBJECT s3-dg.pdf "PUT /amzn-s3-demo-bucket1/s3-dg.pdf HTTP/1.1" 200 - - 4406583 41754 28 "-" "S3Console/0.4" - 10S62Zv81kBW7BB6SX4XJ48o6kpcl6LPwEoizZQQxJd5qDSCTLX0TgS37kYUBKQW3+bPdrg1234= SigV4 ECDHE-RSA-AES128-SHA AuthHeader amzn-s3-demo-bucket1.s3.us-west-1.amazonaws.com TLSV1.2 - Yes us-east-1
```
Veja a seguir um exemplo de registro de log para a operação **Calcular soma de verificação**.
```
7cd47ef2be amzn-s3-demo-bucket [06/Feb/2019:00:00:38 +0000] - 79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be e5042925-b524-4b3b-a869-f3881e78ff3a S3.COMPUTE.OBJECT.CHECKSUM example-object - - - - 1048576 - - - - - bPf7qjG4XwYdPgDQTl72GW/uotRhdPz2UryEyAFLDSRmKrakUkJCYLtAw6fdANcrsUYc1M/kIulXM1u5vZQT5g== - - - - - - - -
```
**Topics**
+ [
## Campos de registro de log
](#log-record-fields)
+ [
## Registro em log adicional para operações de cópia
](#AdditionalLoggingforCopyOperations)
+ [
## Informações personalizadas do log de acesso
](#LogFormatCustom)
+ [
## Considerações de programação para o formato do log de acesso ao servidor extensível
](#LogFormatExtensible)
## Campos de registro de log
A lista a seguir descreve os campos dos registros em log.
**Proprietário do bucket**
O ID canônico do usuário do proprietário do bucket de origem. O ID de usuário canônico é outra forma de ID da Conta da AWS. Para obter mais informações sobre IDs de usuário canônico, consulte [Identificadores de Conta da AWS](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) na *Referência geral da AWS*. Para obter informações sobre como encontrar o ID de usuário canônico da conta, consulte [Como localizar o ID de usuário canônico de sua Conta da AWS](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html#FindCanonicalId).
**Exemplo de registro**
```
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be
```
**Bucket**
O nome do bucket no qual a solicitação foi processada. Se o sistema receber uma solicitação malformada e não puder determinar o bucket, a solicitação não aparecerá em nenhum log de acesso ao servidor.
**Exemplo de entrada**
```
amzn-s3-demo-bucket1
```
**Tempo**
O horário em que a solicitação foi recebida. As datas e horas estão em Tempo Universal Coordenado (UTC). O formato que usa a terminologia `strftime()` é o seguinte: `[%d/%b/%Y:%H:%M:%S %z]`
**Exemplo de entrada**
```
[06/Feb/2019:00:00:38 +0000]
```
**IP remoto**
O endereço IP aparente do solicitante. Os proxies e os firewalls intermediários podem obscurecer o endereço IP real da máquina que faz a solicitação.
**Exemplo de entrada**
```
192.0.2.3
```
**Solicitante**
O ID canônico do usuário do solicitante ou um `-` para solicitações não autenticadas. Se o solicitante for um usuário do IAM, esse campo retornará o nome do usuário do IAM do solicitante com o Conta da AWS ao qual o usuário do IAM pertence. Esse identificador é o mesmo usado para fins de controle de acesso.
**Exemplo de entrada**
```
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be
```
Se o solicitante estiver usando um perfil assumido, esse campo retornará o perfil do IAM assumido.
**Exemplo de entrada**
```
arn:aws:sts::123456789012:assumed-role/roleName/test-role
```
**ID da solicitação**
Uma string gerada pelo Amazon S3 para identificar exclusivamente cada solicitação. Para solicitações de trabalho de **cálculo de soma de verificação**, o campo **ID da solicitação** exibe o ID do trabalho correspondente. Para obter mais informações, consulte [Calcular somas de verificação](batch-ops-compute-checksums.md).
**Exemplo de entrada**
```
3E57427F33A59F07
```
**Operação**
A operação listada aqui é declarada como `SOAP.operation`, `REST.HTTP_method.resource_type`, `WEBSITE.HTTP_method.resource_type` ou `BATCH.DELETE.OBJECT`, ou `S3.action.resource_type` para [Ciclo de Vida do S3 e registro em log](lifecycle-and-other-bucket-config.md#lifecycle-general-considerations-logging). Para solicitações de trabalho de [https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-compute-checksums.html](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-compute-checksums.html), a operação é listada como `S3.COMPUTE.OBJECT.CHECKSUM`.
**Exemplo de entrada**
```
REST.PUT.OBJECT
S3.COMPUTE.OBJECT.CHECKSUM
```
**Chave**
A parte da chave (nome do objeto) da solicitação.
**Exemplo de entrada**
```
/photos/2019/08/puppy.jpg
```
**Request-URI**
A parte `Request-URI` da mensagem de solicitação HTTP. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Entrada de exemplo**
```
"GET /amzn-s3-demo-bucket1/photos/2019/08/puppy.jpg?x-foo=bar HTTP/1.1"
```
**Status HTTP**
O código numérico do status do HTTP da resposta.
**Exemplo de entrada**
```
200
```
**Código de erro**
As [respostas de erro](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html) do Amazon S3, ou `-` se não houver erros.
**Exemplo de entrada**
```
NoSuchBucket
```
**Bytes enviados**
O número de bytes de resposta enviados, excluindo a sobrecarga do protocolo HTTP, ou `-` se zero.
**Exemplo de entrada**
```
2662992
```
**Tamanho do objeto**
O tamanho total do objeto em questão.
**Exemplo de entrada**
```
3462992
```
**Tempo total**
O número de milissegundos (ms) em que a solicitação esteve em trânsito da perspectiva do servidor. Esse valor é medido do momento do recebimento da solicitação até o momento em que o último byte da resposta é enviado. As medidas feitas da perspectiva do cliente podem ser mais longas devido à latência da rede.
**Exemplo de entrada**
```
70
```
**Tempo de retorno**
O número de milissegundos que o Amazon S3 gastou processando a solicitação. Esse valor é medido do momento do recebimento do último byte da solicitação até o momento em que o primeiro byte da resposta foi enviado.
**Exemplo de entrada**
```
10
```
**Referer**
O valor do cabeçalho do `Referer` HTTP, se presente. Os agentes do usuário HTTP (por exemplo, navegadores) normalmente definem esse cabeçalho como o URL da página de vinculação ou incorporação ao fazer uma solicitação. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Exemplo de entrada**
```
"http://www.example.com/webservices"
```
**User-Agent**
O valor do cabeçalho do `User-Agent` HTTP. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Exemplo de entrada**
```
"curl/7.15.1"
```
**Id da versão**
O ID da versão na solicitação ou `-` se a operação não usar um parâmetro `versionId`.
**Exemplo de entrada**
```
3HL4kqtJvjVBH40Nrjfkd
```
**ID do host**
O `x-amz-id-2` ou o ID de solicitação estendida do Amazon S3.
**Exemplo de entrada**
```
s9lzHYrFp76ZVxRcpX9+5cjAnEH2ROuNkd2BHfIa6UkFVdtjf5mKR3/eTPFvsiP/XV/VLi31234=
```
**Versão do Signature**
A versão do Signature, `SigV2` ou `SigV4`, que foi usada para autenticar a solicitação ou `-` para solicitações não autenticadas.
**Exemplo de entrada**
```
SigV2
```
**Pacote de criptografia**
A cifra de Transport Layer Security (TLS) que foi negociada para uma solicitação HTTPS, ou um `-` para HTTP.
**Exemplo de entrada**
```
ECDHE-RSA-AES128-GCM-SHA256
```
**Tipo de autenticação**
O tipo de autenticação de solicitação usada: `AuthHeader` para cabeçalhos de autenticação, `QueryString` para string de consulta (URL pré-assinado) ou um `-` para solicitações não autenticadas.
**Exemplo de entrada**
```
AuthHeader
```
**Cabeçalho de host**
O endpoint usado para conectar-se ao Amazon S3.
**Exemplo de entrada**
```
s3.us-west-2.amazonaws.com
```
Algumas regiões mais antigas oferecem suporte a endpoints herdados. Você poderá ver esses endpoints nos logs de acesso ao servidor ou nos logs do AWS CloudTrail. Para obter mais informações, consulte [Endpoints herdados](VirtualHosting.md#s3-legacy-endpoints). Para obter uma lista completa de regiões e endpoints do Amazon S3, consulte [Endpoints e cotas do Amazon S3](https://docs.aws.amazon.com/general/latest/gr/s3.html) na *Referência geral da Amazon Web Services*.
**Versão do TLS**
A versão do Transport Layer Security (TLS) negociada pelo cliente. O valor é um dos seguintes: `TLSv1.1`, `TLSv1.2`, `TLSv1.3` ou `-` se o TLS não foi usado.
**Exemplo de entrada**
```
TLSv1.2
```
**ARN do ponto de acesso**
O nome de recurso da Amazon (ARN) do ponto de acesso da solicitação. Se o ARN do ponto de acesso estiver malformado ou se não for usado, o campo apresentará um `-`. Para obter mais informações sobre pontos de acesso, consulte [Usar o recurso Pontos de Acesso Amazon S3 para buckets de uso geral](using-access-points.md). Para obter mais informações sobre ARNs, consulte [Nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) no *Guia de referência da AWS*.
**Exemplo de entrada**
```
arn:aws:s3:us-east-1:123456789012:accesspoint/example-AP
```
**aclRequired**
Uma string que indica se a solicitação exigiu uma lista de controle de acesso (ACL) para autorização. Se a solicitação exigiu uma ACL para autorização, a string é `Yes`. Se nenhuma ACL foi necessária, a string é `-`. Para ter mais informações sobre ACLs, consulte [Visão geral da lista de controle de acesso (ACL)](acl-overview.md). Para obter mais informações sobre como usar o campo `aclRequired` para desativar ACLs, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](about-object-ownership.md).
**Exemplo de entrada**
```
Yes
```
**Região de origem**
A região da AWS da qual a solicitação se originou. Esse campo mostra um traço (`-`) quando a região de origem não pode ser determinada (como em conexões do PrivateLink, conexões do Direct Connect, traga seus próprios endereços IP (BYOIP) ou endereços IP que não são da AWS) ou quando o registro é gerado por operações acionadas com base em políticas ou ações definidas pelo cliente, como ciclo de vida e soma de verificação.
**Exemplo de entrada**
```
us-east-1
```
## Registro em log adicional para operações de cópia
Uma operação de cópia envolve um `GET` e um `PUT`. Por esse motivo, registramos dois registros em log ao executar uma operação de cópia. A seção anterior descreve os campos relacionados à parte `PUT` da operação. A lista a seguir descreve os campos no registro que se relacionam à parte `GET` da operação de cópia.
**Proprietário do bucket**
O ID canônico do usuário do bucket que armazena o objeto que está sendo copiado. O ID de usuário canônico é outra forma de ID da Conta da AWS. Para obter mais informações sobre IDs de usuário canônico, consulte [Identificadores de Conta da AWS](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) na *Referência geral da AWS*. Para obter informações sobre como encontrar o ID de usuário canônico da conta, consulte [Como localizar o ID de usuário canônico de sua Conta da AWS](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html#FindCanonicalId).
**Exemplo de registro**
```
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be
```
**Bucket**
O nome do bucket que armazena o objeto que está sendo copiado.
**Exemplo de entrada**
```
amzn-s3-demo-bucket1
```
**Tempo**
O horário em que a solicitação foi recebida. As datas e horas estão em Tempo Universal Coordenado (UTC). O formato que usa a terminologia `strftime()` é o seguinte: `[%d/%B/%Y:%H:%M:%S %z]`
**Exemplo de entrada**
```
[06/Feb/2019:00:00:38 +0000]
```
**IP remoto**
O endereço IP aparente do solicitante. Os proxies e os firewalls intermediários podem obscurecer o endereço IP real da máquina que faz a solicitação.
**Exemplo de entrada**
```
192.0.2.3
```
**Solicitante**
O ID canônico do usuário do solicitante ou um `-` para solicitações não autenticadas. Se o solicitante for um usuário do IAM, esse campo retornará o nome do usuário do IAM do solicitante junto com o Usuário raiz da conta da AWS ao qual o usuário do IAM pertence. Esse identificador é o mesmo usado para fins de controle de acesso.
**Exemplo de entrada**
```
79a59df900b949e55d96a1e698fbacedfd6e09d98eacf8f8d5218e7cd47ef2be
```
Se o solicitante estiver usando um perfil assumido, esse campo retornará o perfil do IAM assumido.
**Exemplo de entrada**
```
arn:aws:sts::123456789012:assumed-role/roleName/test-role
```
**ID da solicitação**
Uma string gerada pelo Amazon S3 para identificar exclusivamente cada solicitação. Para solicitações de trabalho de **cálculo de soma de verificação**, o campo **ID da solicitação** exibe o ID do trabalho correspondente. Para obter mais informações, consulte [Calcular somas de verificação](batch-ops-compute-checksums.md).
**Exemplo de entrada**
```
3E57427F33A59F07
```
**Operação**
A operação listada aqui é declarada como `SOAP.operation`, `REST.HTTP_method.resource_type`, `WEBSITE.HTTP_method.resource_type` ou `BATCH.DELETE.OBJECT`.
**Exemplo de entrada**
```
REST.COPY.OBJECT_GET
```
**Chave**
A chave (nome do objeto) do objeto que está sendo copiado, ou `-` se a operação não usar um parâmetro de chave.
**Exemplo de entrada**
```
/photos/2019/08/puppy.jpg
```
**Request-URI**
A parte `Request-URI` da mensagem de solicitação HTTP. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Exemplo de entrada**
```
"GET /amzn-s3-demo-bucket1/photos/2019/08/puppy.jpg?x-foo=bar"
```
**Status HTTP**
O código numérico do status do HTTP da parte `GET` da operação de cópia.
**Exemplo de entrada**
```
200
```
**Código de erro**
As [respostas de erro](https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html) do Amazon S3, ou a parte `GET` da operação de cópia, ou `-` se não houver erros.
**Exemplo de entrada**
```
NoSuchBucket
```
**Bytes enviados**
O número de bytes de resposta enviados, excluindo a sobrecarga do protocolo HTTP, ou `-` se zero.
**Exemplo de entrada**
```
2662992
```
**Tamanho do objeto**
O tamanho total do objeto em questão.
**Exemplo de entrada**
```
3462992
```
**Tempo total**
O número de milissegundos (ms) em que a solicitação esteve em trânsito da perspectiva do servidor. Esse valor é medido do momento do recebimento da solicitação até o momento em que o último byte da resposta é enviado. As medidas feitas da perspectiva do cliente podem ser mais longas devido à latência da rede.
**Exemplo de entrada**
```
70
```
**Tempo de retorno**
O número de milissegundos que o Amazon S3 gastou processando a solicitação. Esse valor é medido do momento do recebimento do último byte da solicitação até o momento em que o primeiro byte da resposta foi enviado.
**Exemplo de entrada**
```
10
```
**Referer**
O valor do cabeçalho do `Referer` HTTP, se presente. Os agentes do usuário HTTP (por exemplo, navegadores) normalmente definem esse cabeçalho como o URL da página de vinculação ou incorporação ao fazer uma solicitação. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Exemplo de entrada**
```
"http://www.example.com/webservices"
```
**User-Agent**
O valor do cabeçalho do `User-Agent` HTTP. Esse campo pode incluir aspas sem escape da entrada do usuário.
**Exemplo de entrada**
```
"curl/7.15.1"
```
**Id da versão**
O ID da versão do objeto que está sendo copiado, ou `-` se o cabeçalho `x-amz-copy-source` não tiver especificado um parâmetro `versionId` como parte da fonte da cópia.
**Entrada de exemplo**
```
3HL4kqtJvjVBH40Nrjfkd
```
**ID do host**
O `x-amz-id-2` ou o ID de solicitação estendida do Amazon S3.
**Exemplo de entrada**
```
s9lzHYrFp76ZVxRcpX9+5cjAnEH2ROuNkd2BHfIa6UkFVdtjf5mKR3/eTPFvsiP/XV/VLi31234=
```
**Versão do Signature**
A versão de assinatura, `SigV2` ou `SigV4`, que foi usada para autenticar a solicitação, ou um `-` para solicitações não autenticadas.
**Exemplo de entrada**
```
SigV4
```
**Pacote de criptografia**
A cifra de Transport Layer Security (TLS) que foi negociada para uma solicitação HTTPS ou um `-` para HTTP.
**Exemplo de entrada**
```
ECDHE-RSA-AES128-GCM-SHA256
```
**Tipo de autenticação**
O tipo de autenticação de solicitação usada: `AuthHeader` para cabeçalhos de autenticação, `QueryString` para strings de consulta (URL pré-assinados) ou um `-` para solicitações não autenticadas.
**Exemplo de entrada**
```
AuthHeader
```
**Cabeçalho de host**
O endpoint que foi usado para conectar ao Amazon S3.
**Exemplo de entrada**
```
s3.us-west-2.amazonaws.com
```
Algumas regiões mais antigas oferecem suporte a endpoints herdados. Você poderá ver esses endpoints nos logs de acesso ao servidor ou nos logs do AWS CloudTrail. Para obter mais informações, consulte [Endpoints herdados](VirtualHosting.md#s3-legacy-endpoints). Para obter uma lista completa de regiões e endpoints do Amazon S3, consulte [Endpoints e cotas do Amazon S3](https://docs.aws.amazon.com/general/latest/gr/s3.html) na *Referência geral da Amazon Web Services*.
**Versão do TLS**
A versão do Transport Layer Security (TLS) negociada pelo cliente. O valor é um dos seguintes: `TLSv1.1`, `TLSv1.2`, `TLSv1.3` ou `-` se o TLS não foi usado.
**Exemplo de entrada**
```
TLSv1.2
```
**ARN do ponto de acesso**
O nome de recurso da Amazon (ARN) do ponto de acesso da solicitação. Se o ARN do ponto de acesso estiver malformado ou se não for usado, o campo apresentará um `-`. Para obter mais informações sobre pontos de acesso, consulte [Usar o recurso Pontos de Acesso Amazon S3 para buckets de uso geral](using-access-points.md). Para obter mais informações sobre ARNs, consulte [Nome do recurso da Amazon (ARN)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) no *Guia de referência da AWS*.
**Exemplo de entrada**
```
arn:aws:s3:us-east-1:123456789012:accesspoint/example-AP
```
**aclRequired**
Uma string que indica se a solicitação exigiu uma lista de controle de acesso (ACL) para autorização. Se a solicitação exigiu uma ACL para autorização, a string é `Yes`. Se nenhuma ACL foi necessária, a string é `-`. Para ter mais informações sobre ACLs, consulte [Visão geral da lista de controle de acesso (ACL)](acl-overview.md). Para obter mais informações sobre como usar o campo `aclRequired` para desativar ACLs, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](about-object-ownership.md).
**Exemplo de entrada**
```
Yes
```
**Região de origem**
A região da AWS da qual a solicitação se originou. Esse campo mostra um traço (`-`) quando a região de origem não pode ser determinada (como em conexões do PrivateLink, conexões do Direct Connect, traga seus próprios endereços IP (BYOIP) ou endereços IP que não são da AWS) ou quando o registro é gerado por operações acionadas com base em políticas ou ações definidas pelo cliente, como ciclo de vida e soma de verificação.
**Exemplo de entrada**
```
us-east-1
```
## Informações personalizadas do log de acesso
Você pode incluir informações personalizadas a serem armazenadas no registro de log de acesso de uma solicitação. Para fazer isso, adicione um parâmetro de string de consulta personalizado à URL da solicitação. O Amazon S3 ignora os parâmetros query-string que começam com `x-`, mas inclui esses parâmetros no registro do log de acesso da solicitação, como parte do campo `Request-URI` do registro do log.
Por exemplo, uma solicitação `GET` para `"s3.amazonaws.com/amzn-s3-demo-bucket1/photos/2019/08/puppy.jpg?x-user=johndoe"` funciona da mesma forma que a solicitação para `"s3.amazonaws.com/amzn-s3-demo-bucket1/photos/2019/08/puppy.jpg"`, exceto pelo fato de que a string `"x-user=johndoe"` está incluída no campo `Request-URI` do registro de log associado. Essa funcionalidade está disponível apenas na interface REST.
## Considerações de programação para o formato do log de acesso ao servidor extensível
Ocasionalmente, podemos estender o formato de registro de log de acesso adicionando novos campos ao final de cada linha. Portanto, certifique-se de que qualquer código que analise logs de acesso ao servidor consiga lidar com os campos finais que talvez não entenda.
# Exclusão de arquivos de log do Amazon S3
Um bucket do Amazon S3 com registro em log de acesso ao servidor habilitado pode acumular muitos objetos de log do servidor ao longo do tempo. Seu aplicativo pode precisar desses logs de acesso por um período específico após sua criação e, depois disso, você poderá excluí-los. Use a configuração da funcionalidade Ciclo de Vida do Amazon S3 para definir regras de modo que o Amazon S3 organize esses objetos automaticamente para exclusão ao final de suas vidas.
É possível definir uma configuração de ciclo de vida para um subconjunto de objetos no bucket do S3 usando um prefixo compartilhado. Se você especificou um prefixo na sua configuração do registro em log de acesso ao servidor, defina uma regra de configuração do ciclo de vida para excluir objetos de log com esse prefixo.
Por exemplo, suponha que os objetos de log tenham o prefixo `logs/`. Você pode definir uma regra de configuração do ciclo de vida para excluir todos os objetos no bucket com o prefixo `logs/` após um período especificado.
Para obter mais informações sobre a configuração do ciclo de vida, consulte [Gerenciar o ciclo de vida dos objetos](object-lifecycle-mgmt.md).
Para obter mais informações sobre o registro em log de acesso ao servidor, consulte [Registrar em log as solicitações com registro em log de acesso ao servidor](ServerLogs.md).
# Usar logs de acesso ao servidor do Amazon S3 para identificar solicitações
Você pode identificar solicitações do Amazon S3 usando os logs de acesso ao servidor do Amazon S3.
**nota**
Para identificar as solicitações do Amazon S3, recomendamos que você use eventos de dados do AWS CloudTrail em vez de logs de acesso ao servidor do Amazon S3. Os eventos de dados do CloudTrail são mais fáceis de configurar e contêm mais informações. Para obter mais informações, consulte [Identificar solicitações do Amazon S3 usando o CloudTrail](cloudtrail-request-identification.md).
Dependendo de quantas solicitações de acesso você receber, a análise dos logs poderá exigir mais recursos ou tempo do que o uso dos eventos de dados do CloudTrail.
**Topics**
+ [
## Consultar logs de acesso para solicitações usando o Amazon Athena
](#querying-s3-access-logs-for-requests)
+ [
## Identificar solicitações do Signature Version 2 usando logs de acesso do Amazon S3
](#using-s3-access-logs-to-identify-sigv2-requests)
+ [
## Identificar solicitações de acesso a objetos usando logs de acesso do Amazon S3
](#using-s3-access-logs-to-identify-objects-access)
## Consultar logs de acesso para solicitações usando o Amazon Athena
Você pode identificar solicitações do Amazon S3 com logs de acesso do Amazon S3 usando o Amazon Athena.
O Amazon S3 armazena logs de acesso ao servidor como objetos em um bucket do S3. Muitas vezes, é mais fácil usar uma ferramenta que possa analisar os logs no Amazon S3. O Athena oferece suporte à análise de objetos do S3 e pode ser usado para consultar logs de acesso do Amazon S3.
**Example**
O exemplo a seguir mostra como você pode consultar os logs de acesso ao servidor do Amazon S3 no Amazon Athena. Substitua os `user input placeholders` utilizados nos exemplos a seguir por suas próprias informações.
Para especificar um local do Amazon S3 em uma consulta do Athena, é necessário fornecer um URI do S3 para o bucket ao qual os logs são entregues. Esse URI deve incluir o nome e o prefixo do bucket no seguinte formato: `s3://amzn-s3-demo-bucket1-logs/prefix/`
1. Abra o console do Athena em [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. No Query Editor, execute um comando semelhante ao seguinte: Substitua `s3_access_logs_db` pelo nome que você deseja atribuir ao banco de dados.
```
CREATE DATABASE s3_access_logs_db
```
**nota**
É uma prática recomendada criar o banco de dados na mesma Região da AWS em que o bucket do S3 está.
1. No Query Editor, execute um comando semelhante ao seguinte para criar um esquema de tabela no banco de dados criado na etapa 2. Substitua `s3_access_logs_db.mybucket_logs` pelo nome que você deseja atribuir à tabela. Os valores dos tipo de dados `STRING` e `BIGINT` são propriedades do log de acesso. É possível consultar essas propriedades no Athena. Para `LOCATION`, insira o bucket do S3 e o caminho do prefixo conforme indicado anteriormente.
------
#### [ Date-based partitioning ]
```
CREATE EXTERNAL TABLE s3_access_logs_db.mybucket_logs(
`bucketowner` STRING,
`bucket_name` STRING,
`requestdatetime` STRING,
`remoteip` STRING,
`requester` STRING,
`requestid` STRING,
`operation` STRING,
`key` STRING,
`request_uri` STRING,
`httpstatus` STRING,
`errorcode` STRING,
`bytessent` BIGINT,
`objectsize` BIGINT,
`totaltime` STRING,
`turnaroundtime` STRING,
`referrer` STRING,
`useragent` STRING,
`versionid` STRING,
`hostid` STRING,
`sigv` STRING,
`ciphersuite` STRING,
`authtype` STRING,
`endpoint` STRING,
`tlsversion` STRING,
`accesspointarn` STRING,
`aclrequired` STRING,
`sourceregion` STRING)
PARTITIONED BY (
`timestamp` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'input.regex'='([^ ]*) ([^ ]*) \\[(.*?)\\] ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) (-|[0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) ([^ ]*)(?: ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*))?.*$')
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://bucket-name/prefix-name/account-id/region/source-bucket-name/'
TBLPROPERTIES (
'projection.enabled'='true',
'projection.timestamp.format'='yyyy/MM/dd',
'projection.timestamp.interval'='1',
'projection.timestamp.interval.unit'='DAYS',
'projection.timestamp.range'='2024/01/01,NOW',
'projection.timestamp.type'='date',
'storage.location.template'='s3://bucket-name/prefix-name/account-id/region/source-bucket-name/${timestamp}')
```
------
#### [ Non-date-based partitioning ]
```
CREATE EXTERNAL TABLE `s3_access_logs_db.mybucket_logs`(
`bucketowner` STRING,
`bucket_name` STRING,
`requestdatetime` STRING,
`remoteip` STRING,
`requester` STRING,
`requestid` STRING,
`operation` STRING,
`key` STRING,
`request_uri` STRING,
`httpstatus` STRING,
`errorcode` STRING,
`bytessent` BIGINT,
`objectsize` BIGINT,
`totaltime` STRING,
`turnaroundtime` STRING,
`referrer` STRING,
`useragent` STRING,
`versionid` STRING,
`hostid` STRING,
`sigv` STRING,
`ciphersuite` STRING,
`authtype` STRING,
`endpoint` STRING,
`tlsversion` STRING,
`accesspointarn` STRING,
`aclrequired` STRING,
`sourceregion` STRING)
ROW FORMAT SERDE
'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'input.regex'='([^ ]*) ([^ ]*) \\[(.*?)\\] ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) (-|[0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\"|-) ([^ ]*)(?: ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*))?.*$')
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket1-logs/prefix/'
```
------
1. No painel de navegação, em **Database (Banco de dados)**, escolha o banco de dados.
1. Em **Tables (Tabelas)**, selecione **Preview table (Visualizar tabela)** ao lado do nome da tabela.
No painel **Results (Resultados)**, você deve ver dados dos logs de acesso ao servidor, como `bucketowner`, `bucket`, `requestdatetime` e assim por diante. Isso significa que você criou a tabela do Athena com êxito. Agora você pode consultar os logs de acesso ao servidor do Amazon S3.
**Example : Mostre quem excluiu um objeto e quando (timestamp, endereço IP e usuário IAM)**
```
SELECT requestdatetime, remoteip, requester, key
FROM s3_access_logs_db.mybucket_logs
WHERE key = 'images/picture.jpg' AND operation like '%DELETE%';
```
**Example : Mostre todas as operações que foram realizadas por um usuário do IAM**
```
SELECT *
FROM s3_access_logs_db.mybucket_logs
WHERE requester='arn:aws:iam::123456789123:user/user_name';
```
**Example : mostrar todas as operações que foram realizadas em um objeto em um determinado período**
```
SELECT *
FROM s3_access_logs_db.mybucket_logs
WHERE Key='prefix/images/picture.jpg'
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2017-02-18:07:00:00','yyyy-MM-dd:HH:mm:ss')
AND parse_datetime('2017-02-18:08:00:00','yyyy-MM-dd:HH:mm:ss');
```
**Example : Mostrar a quantidade de dados transferidos por um endereço IP específico em determinado período**
```
SELECT coalesce(SUM(bytessent), 0) AS bytessenttotal
FROM s3_access_logs_db.mybucket_logs
WHERE remoteip='192.0.2.1'
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2022-06-01','yyyy-MM-dd')
AND parse_datetime('2022-07-01','yyyy-MM-dd');
```
**Example – Encontre IDs de solicitação para erros HTTP 5xx em um período específico**
```
SELECT requestdatetime, key, httpstatus, errorcode, requestid, hostid
FROM s3_access_logs_db.mybucket_logs
WHERE httpstatus like '5%' AND timestamp
BETWEEN '2024/01/29'
AND '2024/01/30'
```
**nota**
Para reduzir o tempo de retenção dos logs, você pode criar uma configuração da funcionalidade Ciclo de Vida do S3 para o bucket de logs de acesso ao servidor. Crie regras de configuração de ciclo de vida para remover os arquivos de log periodicamente. Fazer isso reduz a quantidade de dados que o Athena analisa para cada consulta. Para obter mais informações, consulte [Definir uma configuração do Ciclo de Vida do S3 em um bucket](how-to-set-lifecycle-configuration-intro.md).
## Identificar solicitações do Signature Version 2 usando logs de acesso do Amazon S3
O suporte do Amazon S3 para o Signature versão 2 será desativado (defasado). Depois disso, o Amazon S3 não aceitará mais solicitações que usam o Signature versão 2 e todas as solicitações deverão usar assinaturas do Signature versão 4. É possível identificar solicitações de acesso do Signature Version 2 usando os logs de acesso do Amazon S3.
**nota**
Para identificar as solicitações do Signature Version 2, recomendamos que você use eventos de dados do AWS CloudTrail em vez de logs de acesso ao servidor do Amazon S3. Os eventos de dados do CloudTrail são mais fáceis de configurar e contêm mais informações do que os logs de acesso ao servidor. Para obter mais informações, consulte [Identificar solicitações de Signature Version 2 do Amazon S3 usando o CloudTrail](cloudtrail-request-identification.md#cloudtrail-identification-sigv2-requests).
**Example : mostrar todos os solicitantes que estão enviando tráfego do Signature versão 2**
```
SELECT requester, sigv, Count(sigv) as sigcount
FROM s3_access_logs_db.mybucket_logs
GROUP BY requester, sigv;
```
## Identificar solicitações de acesso a objetos usando logs de acesso do Amazon S3
É possível usar consultas em logs de acesso ao servidor do Amazon S3 para identificar solicitações de acesso a objetos do Amazon S3, para operações como `GET`, `PUT` e `DELETE`, e descobrir mais informações sobre essas solicitações.
O exemplo de consulta do Amazon Athena a seguir mostra como obter todas as solicitações `PUT` de objetos para o Amazon S3 de um log de acesso ao servidor.
**Example : Mostrar todos os solicitantes que estão enviando solicitações `PUT` de objetos em determinado período**
```
SELECT bucket_name, requester, remoteip, key, httpstatus, errorcode, requestdatetime
FROM s3_access_logs_db.mybucket_logs
WHERE operation='REST.PUT.OBJECT'
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2019-07-01:00:42:42',yyyy-MM-dd:HH:mm:ss')
AND parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```
O exemplo de consulta do Amazon Athena a seguir mostra como obter todas as solicitações `GET` de objetos para o Amazon S3 do log de acesso ao servidor.
**Example : Mostrar todos os solicitantes que estão enviando solicitações `GET` de objetos em determinado período**
```
SELECT bucket_name, requester, remoteip, key, httpstatus, errorcode, requestdatetime
FROM s3_access_logs_db.mybucket_logs
WHERE operation='REST.GET.OBJECT'
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2019-07-01:00:42:42','yyyy-MM-dd:HH:mm:ss')
AND parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```
O exemplo de consulta do Amazon Athena a seguir mostra como obter todas as solicitações anônimas ao seu bucket do S3 do log de acesso ao servidor.
**Example : Mostrar todos os solicitantes anônimos que estão fazendo solicitações a um bucket em determinado período**
```
SELECT bucket_name, requester, remoteip, key, httpstatus, errorcode, requestdatetime
FROM s3_access_logs_db.mybucket_logs
WHERE requester IS NULL
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2019-07-01:00:42:42','yyyy-MM-dd:HH:mm:ss')
AND parse_datetime('2019-07-02:00:42:42','yyyy-MM-dd:HH:mm:ss')
```
A consulta do Amazon Athena a seguir mostra como identificar todas as solicitações feitas aos seus buckets do S3 que exigiram uma lista de controle de acesso (ACL) para autorização. Você pode usar essas informações para migrar essas permissões de ACL para as políticas de bucket apropriadas e desativar as ACLs. Depois de criar essas políticas de bucket, você pode desativar as ACLs para esses buckets. Para obter mais informações sobre como desativar as ACLs, consulte [Pré-requisitos para desabilitar ACLs](object-ownership-migrating-acls-prerequisites.md).
**Example : Identifique todas as solicitações que exigiram uma ACL para autorização**
```
SELECT bucket_name, requester, key, operation, aclrequired, requestdatetime
FROM s3_access_logs_db.mybucket_logs
WHERE aclrequired = 'Yes'
AND parse_datetime(requestdatetime,'dd/MMM/yyyy:HH:mm:ss Z')
BETWEEN parse_datetime('2022-05-10:00:00:00','yyyy-MM-dd:HH:mm:ss')
AND parse_datetime('2022-08-10:00:00:00','yyyy-MM-dd:HH:mm:ss')
```
**nota**
É possível modificar o intervalo de datas conforme necessário para atender às suas necessidades.
Esses exemplos de consulta também podem ser úteis para o monitoramento de segurança. Você pode ver os resultados de chamadas `PutObject` ou `GetObject` de solicitantes ou endereços IP inesperados ou não autorizados e identificar solicitações anônimas aos seus buckets.
Essa consulta recupera somente informações do momento no qual o registro estava habilitado.
Se você estiver usando logs do AWS CloudTrail, consulte [Identificar o acesso a objetos do S3 usando o CloudTrail](cloudtrail-request-identification.md#cloudtrail-identification-object-access).
# Solução de problemas do registro em log de acessos ao servidor
Os tópicos a seguir podem ajudar a solucionar problemas que você pode encontrar ao configurar o registro em log com o Amazon S3.
**Topics**
+ [
## Mensagens de erro comuns ao configurar o registro em log
](#common-errors)
+ [
## Solução de problemas de falha de entrega
](#delivery-failures)
## Mensagens de erro comuns ao configurar o registro em log
As seguintes mensagens de erro comuns podem aparecer quando você ativa o registro em log por meio da AWS Command Line Interface (AWS CLI) e dos AWS SDKs:
Erro: registro em log de localização cruzada do S3 não é permitido
Se o bucket de destino (também conhecido como *bucket-alvo*) estiver em uma região diferente do bucket de origem, ocorrerá um erro Não é permitido o registro em log entre locais do S3. Para resolver esse erro, verifique se o bucket de destino configurado para receber os logs de acesso está na mesma Região da AWS e Conta da AWS que o bucket de origem.
Erro: o proprietário do bucket a ser registrado e o bucket de destino devem ser os mesmos
Quando você habilitar o registro em log de acesso ao servidor, esse erro ocorrerá se o bucket de destino especificado pertencer a uma conta diferente. Para resolver esse erro, verifique se o bucket de destino está na mesma Conta da AWS que o bucket de origem.
**nota**
Recomendamos que você escolha um bucket de destino diferente do bucket de origem. Quando o bucket de origem e o bucket de destino são os mesmos, logs adicionais são criados para os logs que são gravados no bucket, o que pode aumentar a fatura de armazenamento. Esses logs extras sobre logs também podem dificultar a localização dos logs específicos que você está procurando. Para um gerenciamento de logs mais simples, recomendamos salvar logs de acesso em um bucket diferente. Para obter mais informações, consulte [Como faço para habilitar a entrega de logs?](ServerLogs.md#server-access-logging-overview).
Erro: o bucket de destino para registro em log não existe
O bucket de destino precisa existir antes de definir a configuração. Esse erro indica que o bucket de destino não existe ou não pôde ser encontrado. Verifique se o nome do bucket está escrito corretamente e tente novamente.
Erro: concessões de destino não são permitidas para buckets com proprietário de bucket aplicado
Esse erro indica que o bucket de destino usa a configuração Imposto pelo proprietário do bucket para a funcionalidade Propriedade de Objetos do S3. A configuração Imposto pelo proprietário do bucket não é compatível com concessões de destino (alvo). Para obter mais informações, consulte [Permissões para entrega de logs](enable-server-access-logging.md#grant-log-delivery-permissions-general).
## Solução de problemas de falha de entrega
Para evitar problemas de registro em log de acesso ao servidor, siga estas práticas recomendadas:
+ **O grupo de entrega de logs do S3 tem acesso de gravação ao bucket de destino**: o grupo de entrega de logs do S3 entrega logs de acesso ao servidor para o bucket de destino. Uma política de bucket ou uma lista de controle de acesso (ACL) do bucket para conceder acesso de gravação ao bucket de destino. No entanto, recomendamos usar uma política de bucket em vez de uma ACL. Para obter mais informações sobre como conceder acesso de gravação ao bucket de destino, consulte [Permissões para entrega de logs](enable-server-access-logging.md#grant-log-delivery-permissions-general).
**nota**
Se o bucket de destino usar a configuração Imposto pelo proprietário do bucket para a funcionalidade Propriedade de Objetos, esteja ciente do seguinte:
As ACLs estão desativadas e não afetam mais as permissões. Isso significa que não é possível atualizar a ACL do bucket para conceder acesso ao grupo de entrega de log do S3. Em vez disso, para conceder acesso à entidade principal de serviço do registro em log, é necessário atualizar a política de bucket para o bucket de destino.
Não é possível incluir concessões de destino na configuração de `PutBucketLogging`.
+ **A política de bucket para o bucket de destino permite o acesso aos logs**: verifique a política do bucket de destino. Pesquise na política de bucket declarações que contenham `"Effect": "Deny"`. Depois, verifique se a declaração `Deny` não está impedindo que os logs de acesso sejam gravados no bucket.
+ **A funcionalidade Bloqueio de Objetos do S3 não está habilitada no bucket de destino**: verifique se o bucket de destino está com a funcionalidade Bloqueio de Objetos habilitada. O bloqueio de objetos bloqueia a entrega do log de acesso ao servidor. Você deve escolher um bucket de destino que não esteja com funcionalidade Bloqueio de Objetos habilitada.
+ **As chaves gerenciadas pelo Amazon S3 (SSE-S3) são selecionadas se a criptografia padrão está habilitada no bucket de destino**: é possível usar a criptografia de bucket padrão no bucket de destino somente se você usa a criptografia do lado do servidor com as chaves gerenciadas pelo Amazon S3 (SSE-S3). A criptografia padrão do lado do servidor com chaves do AWS Key Management Service (AWS KMS) (SSE-KMS) não é compatível com os buckets de destino do registro em log de acesso ao servidor. Para obter mais informações sobre como ativar a criptografia padrão, consulte [Configurar a criptografia padrão](default-bucket-encryption.md).
+ **O bucket de destino não tem a opção Pagamento pelo solicitante habilitada**: o uso de um bucket de Pagamento pelo solicitante como bucket de destino para o registro em log de acesso ao servidor não é compatível. Para permitir a entrega de logs de acesso ao servidor, desabilite a opção Pagamento pelo solicitante no bucket de destino.
+ **Revise as políticas de controle de serviços (SCPs) e as políticas de controle de recursos (RCPs) do AWS Organizations**: ao usar o AWS Organizations, verifique as políticas de controle de serviços e as políticas de controle de recursos para garantir que o acesso ao Amazon S3 seja permitido. Essas políticas especificam o número máximo de permissões para entidades principais e recursos nas contas afetadas. Pesquise nas políticas as instruções que contenham `"Effect": "Deny"` e verifique se as instruções `Deny` não estão impedindo que os logs de acesso sejam gravados no bucket. Consulte mais informações em [Authorization policies in AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_authorization_policies.html) no *Guia do usuário do AWS Organizations*.
+ **Aguarde um tempo para que as alterações recentes na configuração do registro em log entrem em vigor**: as ações de habilitar o registro em log de acesso ao servidor pela primeira vez ou alterar o bucket de destino para os logs levam tempo para entrar em vigor totalmente. Pode levar mais de uma hora para que todas as solicitações sejam registradas e entregues adequadamente.
Para verificar se há falha de entrega de log, ative as métricas de solicitação do Amazon CloudWatch. Se os logs não forem entregues em algumas horas, procure a métrica `4xxErrors`, que pode indicar falhas na entrega dos logs. Para obter mais informações sobre como ativar as métricas de solicitação, consulte [Criar uma configuração de métricas do CloudWatch para todos os objetos em seu bucket](configure-request-metrics-bucket.md).