

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Mengaktifkan pencatatan akses server Amazon S3
<a name="enable-server-access-logging"></a>

Pencatatan akses server menyediakan catatan terperinci untuk permintaan yang dilakukan ke bucket Amazon S3 Anda. Log akses server bermanfaat untuk berbagai macam aplikasi. Misalnya, informasi log akses dapat berguna dalam audit keamanan dan akses. Informasi ini juga dapat membantu Anda untuk mempelajari basis pelanggan Anda, serta memahami tagihan Amazon S3.

Secara default, Amazon S3 tidak mengumpulkan log akses server. Saat Anda mengaktifkan pencatatan log, Amazon S3 mengirimkan pencatatan akses untuk bucket sumber ke bucket tujuan (juga dikenal sebagai *bucket target*) yang Anda pilih. Bucket tujuan harus sama Wilayah AWS dan Akun AWS sebagai ember sumber. 

Catatan log akses berisi detail tentang permintaan yang dilakukan ke bucket. Informasi ini dapat mencakup jenis permintaan, sumber daya yang ditentukan dalam permintaan, dan waktu serta tanggal pemrosesan permintaan. Untuk informasi lebih lanjut tentang dasar pencatatan log, lihat [Pencatatan permintaan dengan pencatatan akses server](ServerLogs.md). 

**penting**  
Tidak ada biaya tambahan untuk mengaktifkan pencatatan akses server di bucket Amazon S3. Namun, semua file log yang dikirim sistem kepada Anda akan dikenakan biaya penyimpanan yang biasa. (Anda dapat menghapus file log ini kapan saja.) Kami tidak menilai biaya transfer data untuk pengiriman file log, tetapi kami memang mengenakan tarif transfer data normal untuk mengakses file log.
bucket tujuan Anda seharusnya tidak memiliki akses server pencatatan yang diaktifkan. Anda dapat mengirimkan log ke bucket mana pun milik Anda yang berada di Wilayah yang sama dengan bucket sumber, termasuk bucket sumber itu sendiri. Namun, mengirimkan log ke bucket sumber akan menyebabkan loop log yang tak terbatas dan tidak disarankan. Tetapi untuk manajemen log yang lebih sederhana, kami sarankan agar Anda menyimpan log akses dalam bucket yang berbeda. Untuk informasi selengkapnya, lihat [Bagaimana cara mengaktifkan log pengiriman?](ServerLogs.md#server-access-logging-overview)
Bucket S3 yang mengaktifkan Kunci Objek S3 tidak dapat digunakan sebagai bucket tujuan untuk pencatatan akses server. Bucket tujuan Anda tidak boleh memiliki konfigurasi periode retensi default.
Bucket tujuan tidak boleh mengaktifkan Pembayaran oleh Pemohon.

Anda dapat mengaktifkan atau menonaktifkan pencatatan akses server dengan menggunakan konsol Amazon S3, Amazon S3 API,AWS CLI(), AWS Command Line Interface atau. AWS SDKs 

## Izin untuk pengiriman log
<a name="grant-log-delivery-permissions-general"></a>

Amazon S3 menggunakan akun pengiriman log kustom untuk menulis log akses server. Penulisan ini tunduk pada pembatasan kontrol akses biasa. Untuk pengiriman log akses, Anda harus memberikan akses kepada pengguna utama layanan pencatatan (`logging.s3.amazonaws.com`) ke bucket tujuan Anda.

Untuk memberikan izin ke Amazon S3 untuk pengiriman log, Anda dapat menggunakan kebijakan bucket atau daftar kontrol akses bucket ACLs (), tergantung pada setelan Kepemilikan Objek S3 bucket tujuan. Namun, kami menyarankan Anda menggunakan kebijakan bucket sebagai gantinya ACLs. 

**Pengaturan yang diberlakukan pemilik bucket untuk Kepemilikan Objek S3**  
Jika bucket tujuan menggunakan setelan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, akan ACLs dinonaktifkan dan tidak lagi memengaruhi izin. Dalam hal ini, Anda harus memperbarui kebijakan bucket untuk bucket tujuan untuk memberikan akses ke pengguna utama layanan logging. Anda tidak dapat memperbarui ACL bucket untuk memberikan akses ke grup pengiriman log S3. Anda juga tidak dapat menyertakan pemberian tujuan (juga dikenal sebagai *pemberian target*) dalam konfigurasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html) Anda. 

Untuk informasi tentang memigrasi bucket yang ada ACLs untuk pengiriman log akses ke kebijakan bucket, lihat[Berikan akses ke grup pengiriman log S3 untuk pencatatan akses server](object-ownership-migrating-acls-prerequisites.md#object-ownership-server-access-logs). Untuk informasi selengkapnya tentang Kepemilikan Objek, lihat [Mengontrol kepemilikan objek dan menonaktifkan bucket ACLs Anda](about-object-ownership.md). Saat Anda membuat bucket baru, dinonaktifkan ACLs secara default.

**memberikan akses dengan menggunakan kebijakan bucket**  
Untuk memberikan akses dengan menggunakan kebijakan bucket di bucket tujuan, perbarui kebijakan bucket untuk memberikan izin `s3:PutObject` kepada pengguna utama layanan logging. Jika Anda menggunakan konsol Amazon S3 untuk mengaktifkan pencatatan akses server, konsol secara otomatis memperbarui kebijakan bucket pada bucket tujuan untuk memberikan izin ini kepada pengguna utama layanan pencatatan. Jika Anda mengaktifkan pencatatan akses server secara terprogram, Anda harus memperbarui kebijakan bucket secara manual untuk bucket tujuan untuk memberikan akses ke pengguna utama layanan logging. 

Untuk contoh kebijakan bucket yang memberikan akses ke pengguna utama layanan logging, lihat [Berikan izin kepada pengguna utama layanan logging dengan menggunakan kebijakan bucket](#grant-log-delivery-permissions-bucket-policy).

**Memberikan akses dengan menggunakan bucket ACLs**  
Anda dapat menggunakan bucket secara bergantian ACLs untuk memberikan akses untuk pengiriman log akses. Anda menambahkan entri pemberian ke ACL bucket yang memberikan izin `WRITE` dan `READ_ACP` ke grup pengiriman log S3. Namun, pemberian akses ke grup pengiriman log S3 dengan menggunakan bucket tidak ACLs disarankan. Untuk informasi selengkapnya, lihat [Mengontrol kepemilikan objek dan menonaktifkan bucket ACLs Anda](about-object-ownership.md). Untuk informasi tentang memigrasi bucket yang ada ACLs untuk pengiriman log akses ke kebijakan bucket, lihat[Berikan akses ke grup pengiriman log S3 untuk pencatatan akses server](object-ownership-migrating-acls-prerequisites.md#object-ownership-server-access-logs). Untuk contoh ACL yang memberikan akses ke pengguna utama layanan logging, lihat [Berikan izin ke grup pengiriman log dengan menggunakan bucket ACL](#grant-log-delivery-permissions-acl).

### Berikan izin kepada pengguna utama layanan logging dengan menggunakan kebijakan bucket
<a name="grant-log-delivery-permissions-bucket-policy"></a>

Contoh kebijakan bucket ini memberikan `s3:PutObject` izin kepada pengguna utama layanan logging (`logging.s3.amazonaws.com`). Untuk menggunakan kebijakan bucket ini, ganti `user input placeholders` dengan informasi Anda sendiri. Dalam kebijakan berikut, `amzn-s3-demo-destination-bucket` adalah bucket tujuan tempat log akses server akan dikirimkan, dan `amzn-s3-demo-source-bucket` merupakan bucket sumber. `EXAMPLE-LOGGING-PREFIX`adalah awalan tujuan opsional (juga dikenal sebagai *awalan target*) yang ingin Anda gunakan untuk objek log Anda. `SOURCE-ACCOUNT-ID`adalah Akun AWS yang memiliki ember sumber. 

**catatan**  
Jika terdapat pernyataan `Deny` dalam kebijakan bucket Anda, pastikan pernyataan tersebut tidak mencegah Amazon S3 mengirimkan pencatatan akses.

------
#### [ 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"
                }
            }
        }
    ]
}
```

------

### Berikan izin ke grup pengiriman log dengan menggunakan bucket ACL
<a name="grant-log-delivery-permissions-acl"></a>

**catatan**  
Sebagai praktik keamanan terbaik, Amazon S3 menonaktifkan daftar kontrol akses (ACLs) secara default di semua bucket baru. Untuk informasi selengkapnya tentang izin ACL di konsol Amazon S3, lihat [Mengkonfigurasi ACLs](managing-acls.md). 

Meskipun kami tidak merekomendasikan pendekatan ini, Anda dapat memberikan izin ke grup pengiriman log dengan menggunakan bucket ACL. Namun, jika bucket tujuan menggunakan setelan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, Anda tidak dapat menyetel bucket atau objek ACLs. Anda juga tidak dapat menyertakan pemberian tujuan (juga dikenal sebagai *pemberian target*) dalam konfigurasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html) Anda. Sebagai gantinya, Anda harus menggunakan kebijakan bucket untuk memberikan akses ke pengguna utama layanan logging (`logging.s3.amazonaws.com`). Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#grant-log-delivery-permissions-general).

Di bucket ACL, grup pengiriman log direpresentasikan dengan URL berikut:

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

Untuk memberikan izin `WRITE` dan `READ_ACP` (ACL baca), menambahkan pemberian berikut ini ke ACL bucket tujuan:

```
 1. <Grant>
 2.     <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:type="Group">
 3.         <URI>http://acs.amazonaws.com/groups/s3/LogDelivery</URI> 
 4.     </Grantee>
 5.     <Permission>WRITE</Permission>
 6. </Grant>
 7. <Grant>
 8.     <Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:type="Group">
 9.         <URI>http://acs.amazonaws.com/groups/s3/LogDelivery</URI> 
10.     </Grantee>
11.     <Permission>READ_ACP</Permission>
12. </Grant>
```

Untuk contoh penambahan pemberian ACL secara terprogram, lihat [Mengkonfigurasi ACLs](managing-acls.md).

**penting**  
Saat Anda mengaktifkan pencatatan akses server Amazon S3 dengan menggunakan AWS CloudFormation pada bucket dan Anda gunakan ACLs untuk memberikan akses ke grup pengiriman log S3, Anda juga harus menambahkan "`AccessControl": "LogDeliveryWrite"`ke template Anda. CloudFormation Melakukannya penting karena Anda dapat memberikan izin tersebut hanya dengan membuat ACL untuk bucket, tetapi Anda tidak dapat membuat custom ACLs untuk bucket. CloudFormation Anda hanya dapat menggunakan kaleng ACLs dengan CloudFormation.

## Untuk mengaktifkan pencatatan log akses server
<a name="enable-server-logging"></a>

Untuk mengaktifkan pencatatan akses server menggunakan konsol Amazon S3, Amazon S3 REST API AWS SDKs, AWS CLI dan, gunakan prosedur berikut.

### Menggunakan konsol S3
<a name="server-access-logging"></a>

1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon S3 di. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Di panel navigasi kiri, pilih **Bucket tujuan umum**.

1. Dalam daftar bucket, pilih nama bucket yang ingin Anda aktifkan pencatatan akses server.

1. Pilih **Properti**.

1. Di **Pencatatan akses server** bagian, pilih **Edit**.

1. Di bawah **Pencatatan akses server**, pilih **Aktifkan**. 

1. Di **Bucket tujuan**, tentukan bucket dan prefiks opsional. Jika Anda menentukan prefiks, sebaiknya sertakan garis miring ke depan (`/`) setelah prefiks agar lebih mudah untuk menemukan log Anda. 
**catatan**  
Menentukan prefiks dengan garis miring (`/`) membuatnya lebih mudah bagi Anda untuk menemukan objek log. Misalnya, jika Anda menentukan nilai prefiks`logs/`, setiap objek log yang dibuat Amazon S3 dimulai dengan prefiks `logs/` pada kuncinya, sebagai berikut:  

   ```
   logs/2013-11-01-21-32-16-E568B2907131C0C0
   ```
Jika Anda menentukan nilai prefiks `logs`, objek log muncul sebagai berikut:  

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

1. Di bawah **Format kunci objek log **, lakukan salah satu langkah berikut:
   + Untuk memilih non-date-based partisi, pilih **[DestinationPrefix] [YYYY] - [MM] - [DD] - [hh] - [mm] - [ss] - []**. UniqueString
   + ****Untuk memilih partisi berbasis tanggal, pilih **[DestinationPrefix] []/[]/[SourceAccountId]/[SourceRegionYYYYSourceBucket]/[MM]/[DD]/[YYYY] - [MM] - [DD] - [hh] - [mm] - [ss] - [], lalu pilih waktu acara S3 atau Waktu pengiriman file log**. UniqueString****

1. Pilih **Simpan perubahan**.

   Saat Anda mengaktifkan pencatatan log akses server pada bucket, konsol keduanya memungkinkan pencatatan log pada bucket sumber dan memperbarui kebijakan bucket untuk bucket tujuan guna memberikan izin `s3:PutObject` kepada pengguna utama layanan pencatatan log (`logging.s3.amazonaws.com`). Untuk informasi lebih lanjut tentang kebijakan bucket ini, lihat [Berikan izin kepada pengguna utama layanan logging dengan menggunakan kebijakan bucket](#grant-log-delivery-permissions-bucket-policy).

   Anda dapat melihat pencatatan di dalam bucket tujuan. Setelah Anda mengaktifkan pencatatan akses server, mungkin perlu beberapa jam sebelum pencatatan dikirim ke bucket target. Untuk informasi selengkapnya tentang bagaimana dan kapan log dikirim, lihat [Bagaimana log dikirimkan?](ServerLogs.md#how-logs-delivered)

Untuk informasi selengkapnya, lihat [Melihat properti untuk bucket tujuan umum S3](view-bucket-properties.md).

### Penggunaan API REST
<a name="enable-logging-rest"></a>

Untuk mengaktifkan pencatatan log, Anda mengirimkan permintaan [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html) untuk menambahkan konfigurasi pencatatan log di bucket sumber. Permintaan menentukan bucket tujuan (juga dikenal sebagai *bucket target*) dan, secara opsional, prefiks yang akan digunakan dengan semua kunci objek log. 

Contoh berikut mengidentifikasi `amzn-s3-demo-destination-bucket` sebagai bucket tujuan, dan *`logs/`*sebagai prefiks. 

```
1. <BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
2.   <LoggingEnabled>
3.     <TargetBucket>amzn-s3-demo-destination-bucket</TargetBucket>
4.     <TargetPrefix>logs/</TargetPrefix>
5.   </LoggingEnabled>
6. </BucketLoggingStatus>
```

Contoh berikut mengidentifikasi `amzn-s3-demo-destination-bucket` sebagai bucket tujuan, *`logs/`* sebagai prefiks, dan `EventTime` sebagai format kunci objek log. 

```
 1. <BucketLoggingStatus xmlns="http://doc.s3.amazonaws.com/2006-03-01">
 2.   <LoggingEnabled>
 3.     <TargetBucket>amzn-s3-demo-destination-bucket</TargetBucket>
 4.     <TargetPrefix>logs/</TargetPrefix>
 5.     <TargetObjectKeyFormat>
 6.       <PartitionedPrefix>
 7.          <PartitionDateSource>EventTime</PartitionDateSource>
 8.       </PartitionedPrefix>
 9.   </TargetObjectKeyFormat>
10.   </LoggingEnabled>
11. </BucketLoggingStatus>
```

Objek log ditulis dan dimiliki oleh akun pengiriman log S3, dan pemilik bucket diberi izin penuh pada objek log. Anda dapat secara opsional menggunakan pemberian tujuan (juga dikenal sebagai *pemberian target*) untuk memberikan izin kepada pengguna lain sehingga mereka dapat mengakses log. Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTlogging.html). 

**catatan**  
Jika bucket tujuan menggunakan pengaturan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, Anda tidak dapat menggunakan pemberian tujuan untuk memberikan izin kepada pengguna lain. Untuk memberikan izin kepada orang lain, Anda dapat memperbarui kebijakan bucket di bucket tujuan. Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#grant-log-delivery-permissions-general). 

Untuk mengambil konfigurasi logging pada bucket, gunakan operasi API [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETlogging.html). 

Untuk menghapus konfigurasi pencatatan log, Anda mengirimkan `PutBucketLogging` permintaan dengan `BucketLoggingStatus` yang kosong: 

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

Untuk mengaktifkan logging pada bucket, Anda dapat menggunakan Amazon S3 API atau pustaka pembungkus AWS SDK.

### Menggunakan AWS SDKs
<a name="enable-logging-sdk"></a>

Contoh berikut mengaktifkan pencatatan log ke bucket. Anda harus membuat dua bucket, satu bucket sumber, dan satu bucket tujuan (target). Contoh ini memperbarui bucket ACL di bucket tujuan terlebih dahulu. Mereka kemudian memberikan ke grup pengiriman log izin yang diperlukan untuk menulis log ke bucket tujuan, dan kemudian mereka mengaktifkan pencatatan log ke bucket sumber. 

Contoh ini tidak akan berfungsi pada bucket tujuan yang menggunakan pengaturan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek.

Jika bucket tujuan (target) menggunakan setelan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, Anda tidak dapat menyetel bucket atau objek ACLs. Anda juga tidak dapat menyertakan hibah tujuan (target) dalam [PutBucketLogging](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html)konfigurasi Anda. Anda harus menggunakan kebijakan bucket untuk memberikan akses ke pengguna utama layanan pencatatan (`logging.s3.amazonaws.com`). Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#grant-log-delivery-permissions-general).

------
#### [ .NET ]

**SDK untuk .NET**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode AWS](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;

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

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

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

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

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

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

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

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

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

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

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

        /// <summary>
        /// Loads configuration from settings files.
        /// </summary>
        public static void LoadConfig()
        {
            _configuration = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("settings.json") // Load settings from .json file.
                .AddJsonFile("settings.local.json", true) // Optionally, load local settings.
                .Build();
        }
    }
```
+  Untuk detail API, lihat [PutBucketLogging](https://docs.aws.amazon.com/goto/DotNetSDKV3/s3-2006-03-01/PutBucketLogging)di *Referensi AWS SDK untuk .NET API*. 

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

}
```

------

### Menggunakan AWS CLI
<a name="enabling-s3-access-logs-for-requests"></a>

Kami menyarankan Anda membuat bucket logging khusus di setiap bucket S3 Wilayah AWS yang Anda miliki. Kemudian, mintalah log akses Amazon S3 dikirimkan ke bucket S3 tersebut. Untuk informasi dan contoh selengkapnya, lihat [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) di *Referensi AWS CLI *.

Jika bucket tujuan (target) menggunakan setelan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, Anda tidak dapat menyetel bucket atau objek ACLs. Anda juga tidak dapat menyertakan hibah tujuan (target) dalam [PutBucketLogging](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html)konfigurasi Anda. Anda harus menggunakan kebijakan bucket untuk memberikan akses ke pengguna utama layanan pencatatan (`logging.s3.amazonaws.com`). Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#grant-log-delivery-permissions-general).

**Example — Mengaktifkan pencatatan akses dengan lima bucket di dua Wilayah**  
Dalam contoh ini, Anda memiliki lima bucket berikut:   
+ `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`
**catatan**  
Langkah terakhir dari prosedur berikut memberikan contoh skrip bash yang dapat Anda gunakan untuk membuat bucket logging Anda dan mengaktifkan log akses server pada bucket ini. Untuk menggunakan skrip tersebut, Anda harus membuat file `policy.json` dan `logging.json`, seperti yang dijelaskan dalam prosedur berikut.

1. Buat dua bucket pencatatan di Wilayah AS Barat (Oregon) dan AS Timur (Virginia Utara), dan beri mereka nama-nama berikut ini:
   + `amzn-s3-demo-destination-bucket-logs-us-east-1`
   + `amzn-s3-demo-destination-bucket1-logs-us-west-2`

1. Kemudian dalam langkah-langkah ini, Anda akan mengaktifkan pencatatan akses server sebagai berikut:
   + `amzn-s3-demo-source-bucket-us-east-1` menyimpan log ke bucket S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` dengan prefiks `amzn-s3-demo-source-bucket-us-east-1`
   + `amzn-s3-demo-source-bucket1-us-east-1` menyimpan log ke bucket S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` dengan prefiks `amzn-s3-demo-source-bucket1-us-east-1`
   + `amzn-s3-demo-source-bucket2-us-east-1` menyimpan log ke bucket S3 `amzn-s3-demo-destination-bucket-logs-us-east-1` dengan prefiks `amzn-s3-demo-source-bucket2-us-east-1`
   + `amzn-s3-demo-bucket1-us-west-2` menyimpan log ke bucket S3 `amzn-s3-demo-destination-bucket1-logs-us-west-2` dengan prefiks `amzn-s3-demo-bucket1-us-west-2`
   + `amzn-s3-demo-bucket2-us-west-2` menyimpan log ke bucket S3 `amzn-s3-demo-destination-bucket1-logs-us-west-2` dengan prefiks `amzn-s3-demo-bucket2-us-west-2`

1. Untuk setiap bucket logging tujuan, berikan izin untuk pengiriman log akses server dengan menggunakan bucket ACL *atau* kebijakan bucket:
   + **Perbarui kebijakan bucket** (Disarankan)–Untuk memberikan izin kepada pengguna utama layanan logging, gunakan perintah `put-bucket-policy` berikut. Ganti `amzn-s3-demo-destination-bucket-logs` dengan nama bucket tujuan Anda.

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

     `Policy.json` adalah dokumen JSON di dalam folder saat ini, yang berisi kebijakan bucket berikut. Untuk menggunakan kebijakan bucket ini, ganti `user input placeholders` dengan informasi Anda sendiri. Dalam kebijakan berikut, *`amzn-s3-demo-destination-bucket-logs`*adalah bucket tujuan tempat log akses server akan dikirimkan, dan `amzn-s3-demo-source-bucket` merupakan bucket sumber. `SOURCE-ACCOUNT-ID` adalah Akun AWS yang memiliki bucket sumber.

------
#### [ 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"
                     }
                 }
             }
         ]
     }
     ```

------
   + **Perbarui bucket ACL**—Untuk memberikan izin ke grup pengiriman log S3, gunakan perintah `put-bucket-acl` berikut. Ganti *`amzn-s3-demo-destination-bucket-logs`* dengan nama bucket tujuan (target) Anda.

     ```
     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. Kemudian, buat file `logging.json` yang berisi konfigurasi logging Anda (berdasarkan salah satu dari tiga contoh berikut). Setelah Anda membuat file `logging.json`, Anda dapat menerapkan konfigurasi logging dengan menggunakan perintah `put-bucket-logging` berikut. Ganti *`amzn-s3-demo-destination-bucket-logs`* dengan nama bucket tujuan (target) Anda.

   ```
   1. aws s3api put-bucket-logging --bucket amzn-s3-demo-destination-bucket-logs --bucket-logging-status file://logging.json 
   ```
**catatan**  
Alih-alih menggunakan perintah `put-bucket-logging` ini untuk menerapkan konfigurasi logging pada setiap bucket tujuan, Anda dapat menggunakan salah satu skrip bash yang disediakan di langkah berikutnya. Untuk menggunakan skrip tersebut, Anda harus membuat file `policy.json` dan `logging.json`, seperti yang dijelaskan dalam prosedur ini.

   File `logging.json` ini adalah dokumen JSON di folder saat ini yang berisi konfigurasi pencatatan log. Jika bucket tujuan menggunakan pengaturan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, konfigurasi logging Anda tidak dapat berisi pemberian tujuan (target). Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#grant-log-delivery-permissions-general).  
**Example – `logging.json` tanpa pemberian tujuan (target)**  

   File contoh `logging.json` berikut tidak berisi pemberian tujuan (target). Oleh karena itu, Anda dapat menerapkan konfigurasi ini ke bucket tujuan (target) yang menggunakan pengaturan yang diterapkan pemilik Bucket untuk Kepemilikan Objek.

   ```
     {
         "LoggingEnabled": {
             "TargetBucket": "amzn-s3-demo-destination-bucket-logs",
             "TargetPrefix": "amzn-s3-demo-destination-bucket/"
          }
      }
   ```  
**Example – `logging.json` dengan pemberian tujuan (target)**  

   File contoh `logging.json` berikut berisi pemberian tujuan (target).

   Jika bucket tujuan menggunakan pengaturan yang diberlakukan pemilik Bucket untuk Kepemilikan Objek, Anda tidak dapat menyertakan pemberian tujuan (target) dalam konfigurasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLogging.html) Anda. Untuk informasi selengkapnya, lihat [Izin untuk pengiriman log](#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"
                  }
              ]
          }
      }
   ```

**Nilai penerima hibah**  
Anda dapat menentukan orang (penerima hibah) kepada siapa Anda menetapkan hak akses (dengan menggunakan elemen permintaan) dengan cara berikut:
   + Dengan ID orang tersebut:

     ```
     {
       "Grantee": {
         "Type": "CanonicalUser",
         "ID": "ID"
       }
     }
     ```
   + Oleh URI:

     ```
     {
       "Grantee": {
         "Type": "Group",
         "URI": "http://acs.amazonaws.com/groups/global/AuthenticatedUsers"
       }
     }
     ```  
**Example - `logging.json` dengan format kunci objek log yang diatur ke waktu peristiwa S3**  

   File `logging.json` berikut mengubah format kunci objek log ke waktu peristiwa S3. Untuk informasi selengkapnya tentang pengaturan format kunci objek log, lihat [Bagaimana cara mengaktifkan log pengiriman?](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. Gunakan salah satu skrip bash berikut untuk menambahkan pencatatan log akses untuk semua bucket dalam akun Anda. Ganti *`amzn-s3-demo-destination-bucket-logs`* dengan nama bucket tujuan (target) Anda, dan ganti `us-west-2` dengan nama Wilayah tempat bucket Anda berada.
**catatan**  
Script ini hanya berfungsi jika semua bucket Anda berada di Wilayah yang sama. Jika Anda memiliki bucket di beberapa Wilayah, Anda harus menyesuaikan skrip-nya.   
**Example – Memberikan akses dengan kebijakan bucket dan menambahkan logging untuk bucket di akun Anda**  

   ```
     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 — Berikan akses dengan bucket ACLs dan tambahkan logging untuk bucket di akun Anda**  

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

## Memverifikasi penyiapan log akses server Anda
<a name="verify-access-logs"></a>

Setelah Anda mengaktifkan pencatatan akses server, lakukan langkah berikut: 
+ Akses bucket tujuan dan verifikasi bahwa file log sedang dikirim. Setelah log akses disiapkan, Amazon S3 segera mulai menangkap permintaan dan mencatatnya. Namun, mungkin perlu beberapa jam sebelum log dikirim ke ember tujuan. Untuk informasi selengkapnya, lihat [Perubahan status pencatatan log bucket memerlukan waktu](ServerLogs.md#BucketLoggingStatusChanges) dan [Pengiriman log server dengan upaya terbaik](ServerLogs.md#LogDeliveryBestEffort).

  Anda juga dapat memverifikasi pengiriman log secara otomatis dengan menggunakan metrik permintaan Amazon S3 dan menyiapkan CloudWatch alarm Amazon untuk metrik ini. Untuk informasi selengkapnya, lihat [Memantau metrik dengan Amazon CloudWatch](cloudwatch-monitoring.md).
+ Verifikasi bahwa Anda dapat membuka dan membaca isi file log.

Untuk informasi pemecahan masalah pencatatan akses server, lihat [Memecahkan masalah pencatatan akses server](troubleshooting-server-access-logging.md).