^
--result-file=/tmp/binlog.txt
```
Amazon RDS biasanya membersihkan log biner sesegera mungkin. Namun, log biner harus tetap tersedia di instans untuk diakses oleh mysqlbinlog. Untuk menentukan jumlah jam RDS untuk mempertahankan log biner, gunakan prosedur yang `mysql.rds_set_configuration` disimpan. Tentukan periode dengan waktu yang cukup bagi Anda untuk mengunduh log. Setelah Anda mengatur periode retensi, pantau penggunaan penyimpanan untuk instans DB guna memastikan bahwa log biner yang dipertahankan tidak memakan terlalu banyak ruang penyimpanan.
Contoh berikut menetapkan periode retensi ke 1 hari.
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
Untuk menampilkan pengaturan saat ini, gunakan prosedur tersimpan `mysql.rds_show_configuration`.
```
call mysql.rds_show_configuration;
```
# Mengaktifkan anotasi log biner MariaDB
Dalam instance MariaDB, Anda dapat menggunakan acara `Annotate_rows` tersebut untuk membuat anotasi peristiwa baris dengan salinan kueri yang menyebabkan peristiwa baris. SQL Pendekatan ini menyediakan fungsionalitas serupa untuk mengaktifkan `binlog_rows_query_log_events` parameter pada instance RDS for My SQL DB.
Anda dapat mengaktifkan anotasi log biner secara global dengan membuat grup parameter kustom dan mengatur parameter `binlog_annotate_row_events` ke **1**. Anda juga dapat mengaktifkan anotasi pada tingkat sesi, dengan memanggil `SET SESSION binlog_annotate_row_events = 1`. Gunakan `replicate_annotate_row_events` untuk mereplikasi anotasi log biner instans replika jika pencatatan log biner diaktifkan pada instans tersebut. Tidak ada hak istimewa khusus yang diperlukan untuk menggunakan pengaturan ini.
Berikut ini adalah contoh dari transaksi berbasis baris di MariaDB. Penggunaan pencatatan log berbasis baris dipicu dengan mengatur tingkat isolasi transaksi ke read-committed.
```
CREATE DATABASE IF NOT EXISTS test;
USE test;
CREATE TABLE square(x INT PRIMARY KEY, y INT NOT NULL) ENGINE = InnoDB;
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN
INSERT INTO square(x, y) VALUES(5, 5 * 5);
COMMIT;
```
Tanpa anotasi, entri log biner untuk transaksi terlihat seperti berikut:
```
BEGIN
/*!*/;
# at 1163
# at 1209
#150922 7:55:57 server id 1855786460 end_log_pos 1209 Table_map: `test`.`square` mapped to number 76
#150922 7:55:57 server id 1855786460 end_log_pos 1247 Write_rows: table id 76 flags: STMT_END_F
### INSERT INTO `test`.`square`
### SET
### @1=5
### @2=25
# at 1247
#150922 7:56:01 server id 1855786460 end_log_pos 1274 Xid = 62
COMMIT/*!*/;
```
Pernyataan berikut memungkinkan anotasi tingkat sesi untuk transaksi yang sama ini, dan menonaktifkannya setelah melakukan transaksi:
```
CREATE DATABASE IF NOT EXISTS test;
USE test;
CREATE TABLE square(x INT PRIMARY KEY, y INT NOT NULL) ENGINE = InnoDB;
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET SESSION binlog_annotate_row_events = 1;
BEGIN;
INSERT INTO square(x, y) VALUES(5, 5 * 5);
COMMIT;
SET SESSION binlog_annotate_row_events = 0;
```
Dengan anotasi, entri log biner untuk transaksi terlihat seperti berikut:
```
BEGIN
/*!*/;
# at 423
# at 483
# at 529
#150922 8:04:24 server id 1855786460 end_log_pos 483 Annotate_rows:
#Q> INSERT INTO square(x, y) VALUES(5, 5 * 5)
#150922 8:04:24 server id 1855786460 end_log_pos 529 Table_map: `test`.`square` mapped to number 76
#150922 8:04:24 server id 1855786460 end_log_pos 567 Write_rows: table id 76 flags: STMT_END_F
### INSERT INTO `test`.`square`
### SET
### @1=5
### @2=25
# at 567
#150922 8:04:26 server id 1855786460 end_log_pos 594 Xid = 88
COMMIT/*!*/;
```
# Amazon RDS untuk file log database Amazon RDS for Microsoft SQL Server
Anda dapat mengakses log kesalahan, log agen, file jejak, dan file dump Microsoft SQL Server menggunakan konsol Amazon RDS, AWS CLI, atau RDS API. Untuk mengetahui informasi selengkapnya tentang cara melihat, mengunduh, dan melihat log basis data berbasis file, lihat [Memantau file RDS Amazon](USER_LogAccess.md).
## Jadwal retensi
File log dirotasi setiap hari dan setiap kali instans DB Anda dimulai ulang. Berikut ini adalah jadwal retensi untuk log Microsoft SQL Server di Amazon RDS.
****
| Jenis log | Jadwal retensi |
| --- | --- |
| Log kesalahan | Maksimal 30 log kesalahan dipertahankan. Amazon RDS dapat menghapus log kesalahan yang lebih lama dari 7 hari. |
| Log agen | Maksimal 10 log agen dipertahankan. Amazon RDS dapat menghapus log agen yang lebih lama dari 7 hari. |
| File jejak | File jejak dipertahankan sesuai dengan periode retensi file jejak instans DB Anda. Periode retensi file jejak default adalah 7 hari. Untuk mengubah periode retensi file jejak untuk instans DB, lihat [Mengatur periode retensi untuk file pelacakan dan dump](Appendix.SQLServer.CommonDBATasks.TraceFiles.md#Appendix.SQLServer.CommonDBATasks.TraceFiles.PurgeTraceFiles). |
| File dump | File jejak dipertahankan sesuai dengan periode retensi file dump instans DB Anda. Periode retensi file dump default adalah 7 hari. Untuk mengubah periode retensi file dump untuk instans DB, lihat [Mengatur periode retensi untuk file pelacakan dan dump](Appendix.SQLServer.CommonDBATasks.TraceFiles.md#Appendix.SQLServer.CommonDBATasks.TraceFiles.PurgeTraceFiles). |
## Melihat log kesalahan SQL Server menggunakan prosedur rds\$1read\$1error\$1log
Anda dapat menggunakan prosedur tersimpan Amazon RDS `rds_read_error_log` untuk melihat log kesalahan dan log agen. Untuk informasi selengkapnya, lihat [Melihat log kesalahan dan agen](Appendix.SQLServer.CommonDBATasks.Logs.md#Appendix.SQLServer.CommonDBATasks.Logs.SP).
## Menerbitkan log SQL Server ke Amazon CloudWatch Logs
Dengan Amazon RDS for SQL Server, Anda dapat mempublikasikan kesalahan dan peristiwa log agen langsung ke Amazon Logs. CloudWatch Analisis data log dengan CloudWatch Log, lalu gunakan CloudWatch untuk membuat alarm dan melihat metrik.
Dengan CloudWatch Log, Anda dapat melakukan hal berikut:
+ Menyimpan log dalam ruang penyimpanan durabel dengan periode retensi yang Anda tentukan.
+ Mencari dan memfilter data log.
+ Berbagi data log antar-akun.
+ Mengekspor log ke Amazon S3.
+ Streaming data ke OpenSearch Layanan Amazon.
+ Memproses data log secara real-time dengan Amazon Kinesis Data Streams. Untuk informasi selengkapnya, lihat [Bekerja dengan Amazon CloudWatch Logs](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/cloudwatch-logs.html) di *Amazon Managed Service for Apache Flink for SQL Applications* Developer Guide.
Amazon RDS menerbitkan setiap log basis data SQL Server sebagai aliran basis data terpisah dalam grup log. Misalnya, jika Anda mempublikasikan log agen dan log kesalahan, data kesalahan disimpan dalam aliran log kesalahan di grup `/aws/rds/instance/my_instance.node1/error` log, dan data log agen disimpan dalam grup `/aws/rds/instance/my_instance.node1/agent` log.
Untuk instans DB Multi-AZ, Amazon RDS menerbitkan log basis data sebagai dua aliran terpisah dalam grup log. Misalnya, jika Anda menerbitkan log kesalahan, data kesalahan akan disimpan dalam log stream kesalahan `/aws/rds/instance/my_instance.node1/error` dan `/aws/rds/instance/my_instance.node2/error` masing-masing. Log stream tidak berubah selama failover dan log stream kesalahan setiap simpul dapat berisi log kesalahan dari instans primer atau sekunder. Dengan Multi-AZ, aliran log secara otomatis dibuat `/aws/rds/instance/my_instance/rds-events` untuk menyimpan data peristiwa seperti kegagalan instans DB.
**catatan**
Menerbitkan log SQL Server ke CloudWatch Log tidak diaktifkan secara default. Menerbitkan file jejak dan dump tidak didukung. Menerbitkan log SQL Server ke CloudWatch Log didukung di semua wilayah.
### Konsol
**Untuk mempublikasikan log SQL Server DB ke CloudWatch Log dari Konsol Manajemen AWS**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis Data**, kemudian pilih instans DB yang ingin diubah.
1. Pilih **Modifikasi**.
1. Di bagian **Log ekspor**, pilih log yang ingin Anda mulai terbitkan ke CloudWatch Log.
Anda dapat memilih **Log agen**, **Log kesalahan**, atau keduanya.
1. Pilih **Lanjutkan**, lalu pilih **Ubah Instans DB** di halaman ringkasan.
### AWS CLI
Untuk menerbitkan log SQL Server, Anda dapat menggunakan perintah [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) dengan parameter berikut:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**catatan**
Perubahan pada opsi `--cloudwatch-logs-export-configuration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, opsi `--apply-immediately` dan `--no-apply-immediately` tidak akan berpengaruh.
Anda juga dapat menerbitkan log SQL Server menggunakan perintah berikut:
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
**Example**
Contoh berikut membuat instance SQL Server DB dengan penerbitan CloudWatch Log diaktifkan. Nilai `--enable-cloudwatch-logs-exports` adalah rangkaian JSON dari string yang dapat mencakup `error`, `agent`, atau keduanya.
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--enable-cloudwatch-logs-exports '["error","agent"]' \
--db-instance-class db.m4.large \
--engine sqlserver-se
```
Untuk Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--enable-cloudwatch-logs-exports "[\"error\",\"agent\"]" ^
--db-instance-class db.m4.large ^
--engine sqlserver-se
```
Saat menggunakan command prompt Windows, Anda harus meng-escape tanda kutip ganda (") dalam kode JSON dengan memberikan garis miring terbalik (\$1) di depannya.
**Example**
Contoh berikut memodifikasi instance SQL Server DB yang ada untuk mempublikasikan file log ke Log. CloudWatch Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `EnableLogTypes`, dan nilainya berupa rangkaian string yang dapat mencakup `error`, `agent`, atau keduanya.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["error","agent"]}'
```
Untuk Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"EnableLogTypes\":[\"error\",\"agent\"]}"
```
Saat menggunakan command prompt Windows, Anda harus meng-escape tanda kutip ganda (") dalam kode JSON dengan memberikan garis miring terbalik (\$1) di depannya.
**Example**
Contoh berikut memodifikasi instance SQL Server DB yang ada untuk menonaktifkan file log agen penerbitan ke CloudWatch Log. Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `DisableLogTypes`, dan nilainya berupa rangkaian string yang dapat mencakup `error`, `agent`, atau keduanya.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["agent"]}'
```
Untuk Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"DisableLogTypes\":[\"agent\"]}"
```
Saat menggunakan command prompt Windows, Anda harus meng-escape tanda kutip ganda (") dalam kode JSON dengan memberikan garis miring terbalik (\$1) di depannya.
# File log
Anda dapat memantau log langsung melalui konsol Amazon RDS, Amazon RDS API, atau. AWS CLI AWS SDKs Anda juga dapat mengakses log MySQL dengan mengarahkan log ke tabel basis data di basis data utama dan mengueri tabel tersebut. Anda dapat menggunakan utilitas mysqlbinlog untuk mengunduh log biner.
Untuk mengetahui informasi selengkapnya tentang cara melihat, mengunduh, dan melihat log basis data berbasis file, lihat [Memantau file RDS Amazon](USER_LogAccess.md).
**Topics**
+ [Ringkasan log basis data RDS for MySQL](USER_LogAccess.MySQL.LogFileSize.md)
+ [Menerbitkan log MySQL ke Amazon Logs CloudWatch](USER_LogAccess.MySQLDB.PublishtoCloudWatchLogs.md)
+ [Mengirim ke tabel](Appendix.MySQL.CommonDBATasks.Logs.md)
+ [Mengkonfigurasi MySQL RDS untuk pencatatan biner MySQL untuk database Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md)
+ [Mengkonfigurasi pencatatan biner MySQL untuk cluster DB Multi-AZ](USER_Binlog.MultiAZ.md)
+ [Mengakses log biner MySQL](USER_LogAccess.MySQL.Binarylog.md)
# Ringkasan log basis data RDS for MySQL
Anda dapat memantau jenis file log RDS for MySQL berikut:
+ Log kesalahan
+ Log kueri lambat
+ Log umum
+ Log audit
+ Log contoh
+ Log kesalahan otentikasi basis data IAM
Log kesalahan RDS for MySQL dihasilkan secara default. Anda dapat membuat kueri lambat dan log umum dengan mengatur parameter di grup parameter DB Anda.
**Topics**
+ [Log kesalahan RDS for MySQL](#USER_LogAccess.MySQL.Errorlog)
+ [Log umum dan kueri lambat RDS for MySQL](#USER_LogAccess.MySQL.Generallog)
+ [Log audit MySQL](#USER_LogAccess.MySQL.Auditlog)
+ [Rotasi dan retensi log untuk RDS for MySQL](#USER_LogAccess.MySQL.LogFileSize.retention)
+ [Batas ukuran pada log redo](#USER_LogAccess.MySQL.LogFileSize.RedoLogs)
## Log kesalahan RDS for MySQL
Kesalahan tulis RDS for MySQL dalam file `mysql-error.log`. Setiap file log memiliki jam pembuatan (dalam UTC) yang ditambahkan pada namanya. File log juga memiliki stempel waktu yang membantu Anda menentukan kapan entri log ditulis.
RDS for MySQL ditulis ke log kesalahan hanya saat dinyalakan, dimatikan, dan saat terjadi kesalahan. Instan DB dapat memakan waktu berjam-jam atau berhari-hari tanpa perlu menulis entri baru ke log kesalahan. Jika Anda melihat tidak ada entri terbaru, berarti server tidak mengalami kesalahan yang akan mengakibatkan entri log.
Secara desain, log kesalahan difilter sehingga hanya peristiwa tak terduga seperti kesalahan yang ditampilkan. Namun, log kesalahan juga berisi beberapa informasi basis data tambahan, misalnya kemajuan kueri, yang tidak ditampilkan. Oleh karena itu, bahkan tanpa kesalahan aktual, ukuran log kesalahan mungkin meningkat dikarenakan aktivitas basis data yang sedang berlangsung. Dan sementara Anda mungkin melihat ukuran tertentu dalam byte atau kilobyte untuk log kesalahan di Konsol Manajemen AWS, mereka mungkin memiliki 0 byte saat Anda mengunduhnya.
RDS for MySQL menulis `mysql-error.log` ke disk setiap 5 menit. Ini menambahkan konten log ke `mysql-error-running.log`.
RDS for MySQL merotasi file `mysql-error-running.log` setiap jam. Ini mempertahankan log yang dihasilkan selama dua minggu terakhir.
**catatan**
Periode retensi log berbeda antara Amazon RDS dan Aurora.
## Log umum dan kueri lambat RDS for MySQL
Anda dapat menulis log umum dan log kueri lambat RDS for MySQL ke file atau tabel basis data. Untuk melakukannya, atur parameter di grup parameter DB Anda. Untuk mengetahui informasi tentang cara membuat dan memodifikasi grup parameter DB, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md). Anda harus mengatur parameter ini sebelum dapat melihat log kueri lambat atau log umum di konsol Amazon RDS atau dengan menggunakan Amazon RDS API, Amazon RDS CLI, atau. AWS SDKs
Anda dapat mengontrol pencatatan log RDS for MySQL dengan menggunakan parameter dalam daftar ini:
+ `slow_query_log`: Untuk membuat log kueri lambat, atur ke 1. Default-nya adalah 0.
+ `general_log`: Untuk membuat log umum, atur ke 1. Default-nya adalah 0.
+ `long_query_time`: Untuk mencegah pencatatan log kueri yang berjalan cepat dalam log kueri lambat, tentukan nilai untuk runtime kueri terpendek yang akan dicatat, dalam detik. Nilai default-nya adalah 10 detik; nilai minimumnya adalah 0. Jika log\$1output = FILE, Anda dapat menentukan nilai titik mengambang yang masuk ke resolusi mikrodetik. Jika log\$1output = TABLE, Anda harus menentukan nilai integer dengan resolusi kedua. Hanya kueri yang runtime-nya melebihi nilai `long_query_time` yang akan dicatat. Misalnya, mengatur `long_query_time` ke 0,1 akan mencegah pencatatan log kueri apa pun yang berjalan kurang dari 100 milidetik.
+ `log_queries_not_using_indexes`: Untuk mencatat semua kueri yang tidak menggunakan indeks pada log kueri lambat, atur ke 1. Kueri yang tidak menggunakan indeks dicatat meskipun runtime-nya kurang dari nilai parameter `long_query_time`. Default-nya adalah 0.
+ `log_output option`: Anda dapat menentukan salah satu opsi berikut untuk parameter `log_output`.
+ **TABLE** (default) – Menulis kueri umum ke tabel `mysql.general_log`, dan kueri lambat ke tabel `mysql.slow_log`.
+ **FILE** – Menulis log umum dan log kueri lambat ke sistem file.
+ **TIDAK ADA** – Menonaktifkan pencatatan log.
Agar data kueri lambat muncul di CloudWatch Log Amazon, kondisi berikut harus dipenuhi:
+ CloudWatch Log harus dikonfigurasi untuk menyertakan log kueri yang lambat.
+ `slow_query_log`harus diaktifkan.
+ `log_output` harus diatur ke `FILE`.
+ Kueri harus memakan waktu lebih lama dari waktu yang dikonfigurasi`long_query_time`.
Untuk mengetahui informasi selengkapnya tentang log umum dan kueri lambat, buka topik berikut di dokumentasi MySQL:
+ [Log kueri lambat](https://dev.mysql.com/doc/refman/8.0/en/slow-query-log.html)
+ [Log kueri umum](https://dev.mysql.com/doc/refman/8.0/en/query-log.html)
## Log audit MySQL
Untuk mengakses log audit, instans DB harus menggunakan grup opsi kustom dengan opsi `MARIADB_AUDIT_PLUGIN`. Untuk informasi selengkapnya, lihat [Dukungan MariaDB Audit Plugin untuk MySQL](Appendix.MySQL.Options.AuditPlugin.md).
## Rotasi dan retensi log untuk RDS for MySQL
Saat pencatatan log diaktifkan, Amazon RDS merotasi log tabel atau menghapus file log secara berkala. Langkah ini merupakan tindakan pencegahan untuk mengurangi kemungkinan file log besar memblokir penggunaan basis data atau memengaruhi performa. RDS for MySQL menangani rotasi dan penghapusan sebagai berikut:
+ Ukuran file log umum, log kesalahan, dan log kueri lambat MySQL dibatasi hingga tidak lebih dari 2 persen dari ruang penyimpanan yang dialokasikan untuk instans DB. Untuk mempertahankan ambang batas ini, log secara otomatis dirotasi setiap jam. MySQL menghapus file log yang berusia lebih dari dua minggu. Jika ukuran file log gabungan melebihi ambang batas setelah file log lama dihapus, file log paling lama akan dihapus hingga ukuran file log tidak lagi melebihi ambang batas.
+ Jika pencatatan log `FILE` diaktifkan, file log akan diperiksa setiap jam dan file log yang berusia lebih dari dua minggu akan dihapus. Dalam beberapa kasus, ukuran file log gabungan yang tersisa setelah penghapusan mungkin melebihi ambang batas 2 persen dari ruang yang dialokasikan oleh instans DB. Dalam kasus ini, file log yang paling lama akan dihapus hingga ukuran file log tidak lagi melebihi ambang batas.
+ Saat pencatatan log `TABLE` diaktifkan, dalam beberapa kasus tabel log dirotasi setiap 24 jam. Rotasi ini terjadi jika ruang yang digunakan oleh log tabel lebih dari 20 persen dari ruang penyimpanan yang dialokasikan. Rotasi ini juga terjadi jika ukuran semua log yang digabungkan lebih besar dari 10 GB. Jika jumlah ruang yang digunakan untuk instans DB lebih besar dari 90 persen dari ruang penyimpanan yang dialokasikan untuk instans DB, ambang batas untuk rotasi log akan berkurang. Tabel log ini kemudian dirotasi jika ruang yang digunakan oleh log tabel lebih dari 10 persen bagi ruang penyimpanan yang dialokasikan. Tabel ini juga dirotasi jika ukuran semua log yang digabungkan lebih besar dari 5 GB. Anda dapat berlangganan kategori `low storage` acara untuk diberi tahu saat tabel log diputar untuk mengosongkan ruang. Untuk informasi selengkapnya, lihat [Bekerja dengan pemberitahuan RDS acara Amazon](USER_Events.md).
Saat tabel log dirotasi, tabel log saat ini akan disalin terlebih dahulu ke tabel log cadangan. Kemudian, entri dalam tabel log saat ini dihapus. Jika sudah ada, tabel log cadangan akan dihapus sebelum tabel log saat ini disalin ke cadangan. Anda dapat meminta tabel log cadangan jika diperlukan. Tabel log cadangan untuk tabel `mysql.general_log` bernama `mysql.general_log_backup`. Tabel log cadangan untuk tabel `mysql.slow_log` bernama `mysql.slow_log_backup`.
Anda dapat merotasi tabel `mysql.general_log` dengan mengikuti prosedur `mysql.rds_rotate_general_log`. Anda dapat merotasi `mysql.slow_log` tabel dengan mengikuti `mysql.rds_rotate_slow_log` prosedur.
Log tabel dirotasi selama peningkatan versi basis data.
Untuk bekerja dengan log dari konsol Amazon RDS, Amazon RDS API, Amazon RDS CLI, AWS SDKs atau, atur `log_output` parameter ke FILE. Seperti log kesalahan MySQL, file log ini dirotasi setiap jam. File log yang dihasilkan selama dua minggu sebelumnya akan dipertahankan. Perhatikan bahwa periode retensi log berbeda antara Amazon RDS dan Aurora.
## Batas ukuran pada log redo
Untuk RDS for MySQL versi 8.0.32 dan yang lebih rendah, nilai default parameter ini adalah 256 MB. Jumlah ini diturunkan dengan mengalikan nilai default parameter `innodb_log_file_size` (128 MB) dengan nilai default parameter `innodb_log_files_in_group` (2). Untuk mengetahui informasi selengkapnya, lihat [Praktik terbaik untuk mengonfigurasi parameter untuk Amazon RDS for MySQL, bagian 1: Parameter yang terkait dengan performa](https://aws.amazon.com/blogs/database/best-practices-for-configuring-parameters-for-amazon-rds-for-mysql-part-1-parameters-related-to-performance/).
Untuk RDS untuk MySQL versi 8.0.33 dan versi minor yang lebih tinggi, Amazon RDS menggunakan parameter alih-alih parameter. `innodb_redo_log_capacity` `innodb_log_file_size` Nilai default Amazon RDS parameter `innodb_redo_log_capacity` adalah 2 GB. Untuk mengetahui informasi selengkapnya, lihat [Changes in MySQL 8.0.30](https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-30.html) di dokumentasi MySQL.
Dimulai dengan MySQL 8.4, Amazon RDS mengaktifkan parameter secara default. `innodb_dedicated_server` Dengan `innodb_dedicated_server` parameter, mesin database menghitung `innodb_buffer_pool_size` dan `innodb_redo_log_capacity` parameter. Untuk informasi selengkapnya, lihat [Mengkonfigurasi ukuran kolam buffer dan mengulang kapasitas log di MySQL 8.4](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md).
# Menerbitkan log MySQL ke Amazon Logs CloudWatch
Anda dapat mengonfigurasi instans MySQL DB Anda untuk mempublikasikan data log ke grup log di Amazon Logs. CloudWatch Dengan CloudWatch Log, Anda dapat melakukan analisis real-time dari data log, dan menggunakannya CloudWatch untuk membuat alarm dan melihat metrik. Anda dapat menggunakan CloudWatch Log untuk menyimpan catatan log Anda dalam penyimpanan yang sangat tahan lama.
Amazon RDS menerbitkan setiap log basis data MySQL sebagai aliran basis data terpisah di grup log. Misalnya, jika Anda mengonfigurasi fungsi ekspor untuk menyertakan log kueri lambat, data kueri lambat akan disimpan dalam log stream kueri lambat di grup log `/aws/rds/instance/my_instance/slowquery`.
Log kesalahan diaktifkan secara default. Tabel berikut merangkum persyaratan untuk log MySQL lain.
| Log | Persyaratan |
| --- | --- |
| Log audit | Instans DB harus menggunakan grup opsi kustom dengan opsi `MARIADB_AUDIT_PLUGIN`. |
| Log umum | Instans DB harus menggunakan grup parameter kustom dengan pengaturan parameter `general_log = 1` untuk mengaktifkan log umum. |
| Log kueri lambat | Instans DB harus menggunakan grup parameter kustom dengan pengaturan parameter `slow_query_log = 1` untuk mengaktifkan log kueri lambat. |
| Log kesalahan otentikasi basis data IAM | Anda harus mengaktifkan jenis log `iam-db-auth-error` untuk instans DB dengan membuat atau memodifikasi instans DB. |
| Output log | DB instance harus menggunakan grup parameter khusus dengan pengaturan parameter `log_output = FILE` untuk mencatat log ke sistem file dan menerbitkannya ke CloudWatch Logs. |
## Konsol
**Untuk mempublikasikan log MySQL CloudWatch ke Log menggunakan konsol**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis Data**, kemudian pilih instans DB yang ingin diubah.
1. Pilih **Modifikasi**.
1. Di bagian **Log ekspor**, pilih log yang ingin Anda mulai terbitkan ke CloudWatch Log.
1. Pilih **Lanjutkan**, lalu pilih **Ubah Instans DB** di halaman ringkasan.
## AWS CLI
Anda dapat mempublikasikan log MySQL dengan file. AWS CLI Anda dapat memanggil perintah [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) dengan parameter berikut:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**catatan**
Perubahan pada opsi `--cloudwatch-logs-export-configuration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, opsi `--apply-immediately` dan `--no-apply-immediately` tidak akan berpengaruh.
Anda juga dapat mempublikasikan log MySQL dengan memanggil perintah berikut: AWS CLI
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
Jalankan salah satu AWS CLI perintah ini dengan opsi berikut:
+ `--db-instance-identifier`
+ `--enable-cloudwatch-logs-exports`
+ `--db-instance-class`
+ `--engine`
Opsi lain mungkin diperlukan tergantung pada AWS CLI perintah yang Anda jalankan.
**Example**
Contoh berikut memodifikasi instance MySQL DB yang ada untuk mempublikasikan file log ke Log. CloudWatch Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `EnableLogTypes`, dan nilainya adalah serangkaian string dengan setiap kombinasi `audit`, `error`, `general`, dan `slowquery`.
Untuk Linux, macOS, atau Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
Untuk Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
**Example**
Contoh berikut membuat instance MySQL DB dan menerbitkan file log ke Log. CloudWatch Nilai `--enable-cloudwatch-logs-exports` adalah rangkaian string JSON. String dapat berupa kombinasi `audit`, `error`, `general`, dan `slowquery`.
Untuk Linux, macOS, atau Unix:
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --enable-cloudwatch-logs-exports '["audit","error","general","slowquery"]' \
4. --db-instance-class db.m4.large \
5. --engine MySQL
```
Untuk Windows:
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --enable-cloudwatch-logs-exports '["audit","error","general","slowquery"]' ^
4. --db-instance-class db.m4.large ^
5. --engine MySQL
```
## API RDS
Anda dapat menerbitkan log MySQL dengan RDS API. Anda dapat memanggil tindakan [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**catatan**
Perubahan pada parameter `CloudwatchLogsExportConfiguration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, parameter `ApplyImmediately` tidak memiliki dampak.
Anda juga dapat menerbitkan log MySQL dengan memanggil operasi RDS API berikut:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Jalankan salah satu operasi RDS API ini dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Parameter lain mungkin diperlukan tergantung pada AWS CLI perintah yang Anda jalankan.
# Mengirim ke tabel
Anda dapat mengarahkan log umum dan log kueri lambat ke tabel di instans DB dengan membuat grup parameter DB dan menetapkan parameter server `log_output` ke `TABLE`. Kueri umum lalu dicatat ke tabel `mysql.general_log` dan kueri lambat dicatat ke tabel `mysql.slow_log`. Anda dapat mengueri tabel untuk mengakses informasi log. Mengaktifkan pencatatan log ini akan meningkatkan jumlah data yang akan ditulis ke basis data, yang dapat menurunkan performa.
Log umum dan log kueri lambat dinonaktifkan secara default. Untuk mengaktifkan pencatatan log ke tabel, Anda juga harus mengatur parameter server `general_log` dan `slow_query_log` ke `1`.
Tabel log terus bertambah hingga aktivitas pencatatan log masing-masing dinonaktifkan dengan mengatur ulang parameter yang sesuai ke `0`. Banyak data yang sering terakumulasi seiring berjalannya waktu. Hal ini dapat menghabiskan cukup banyak ruang penyimpanan yang dialokasikan. Amazon RDS tidak memungkinkan Anda memotong tabel log, tetapi Anda dapat memindahkan konten tabel. Merotasi tabel akan menyimpan kontennya ke tabel cadangan dan membuat tabel log kosong yang baru. Anda dapat merotasi tabel log secara manual dengan mengikuti prosedur perintah berikut, tempat permintaan perintah ditunjukkan oleh `PROMPT>`:
```
PROMPT> CALL mysql.rds_rotate_slow_log;
PROMPT> CALL mysql.rds_rotate_general_log;
```
Untuk menghapus data lama sepenuhnya dan mengosongkan kembali ruang disk, panggil prosedur yang sesuai dua kali secara berurutan.
# Mengkonfigurasi MySQL RDS untuk pencatatan biner MySQL untuk database Single-AZ
*Log biner* adalah sekumpulan file log yang berisi informasi tentang modifikasi data yang dibuat ke instans server MySQL. Log biner berisi informasi seperti berikut:
+ Peristiwa yang menggambarkan perubahan basis data seperti pembuatan tabel atau modifikasi baris
+ Informasi tentang durasi setiap pernyataan yang memperbarui data
+ Peristiwa untuk pernyataan yang bisa saja memperbarui data, tetapi tidak
Log biner mencatat pernyataan yang dikirim selama replikasi. Log ini juga diperlukan untuk beberapa operasi pemulihan. Untuk informasi selengkapnya, lihat [Log Biner](https://dev.mysql.com/doc/refman/8.0/en/binary-log.html) dalam dokumentasi MySQL.
Fitur cadangan otomatis menentukan apakah pencatatan log biner diaktifkan atau dinonaktifkan untuk MySQL. Anda memiliki opsi berikut:
Mengaktifkan pencatatan log biner
Mengatur periode retensi cadangan ke nilai non-nol positif.
Menonaktifkan pencatatan log biner
Mengatur periode retensi cadangan ke nol.
Untuk informasi selengkapnya, lihat [Mengaktifkan pencadangan otomatis](USER_WorkingWithAutomatedBackups.Enabling.md).
MySQL di Amazon RDS mendukung format pencatatan log biner *berbasis baris*, *berbasis pernyataan*, dan *campuran*. Kami merekomendasikan campuran kecuali Anda memerlukan format binlog tertentu. Untuk detail tentang berbagai format log biner , lihat [Format Pencatatan](https://dev.mysql.com/doc/refman/8.0/en/binary-log-formats.html) Biner dalam dokumentasi MySQL.
Jika Anda berencana menggunakan replikasi, format pencatatan log biner diperlukan karena menentukan catatan perubahan data yang dicatat di sumber dan dikirim ke target replikasi. Untuk informasi tentang kelebihan dan kekurangan format logging biner yang berbeda untuk replikasi, lihat [Keuntungan dan Kerugian Replikasi Berbasis Pernyataan dan Berbasis Baris dalam dokumentasi MySQL.](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html)
**penting**
Dengan MySQL 8.0.34, MySQL menghentikan parameter. `binlog_format` Di versi MySQL selanjutnya, MySQL berencana untuk menghapus parameter dan hanya mendukung replikasi berbasis baris. Sebagai hasilnya, sebaiknya gunakan logging berbasis baris untuk pengaturan replikasi MySQL baru. Untuk informasi selengkapnya, lihat [binlog\$1format dalam dokumentasi](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_format) MySQL.
MySQL versi 8.0 dan 8.4 menerima parameter. `binlog_format` Saat menggunakan parameter ini, MySQL mengeluarkan peringatan penghentian. Dalam rilis utama future, MySQL akan menghapus parameter. `binlog_format`
Replikasi berbasis pernyataan dapat menyebabkan inkonsistensi antara instans DB dan replika baca. Untuk informasi selengkapnya, lihat [Penentuan Pernyataan Aman dan Tidak Aman di Binary Logging](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html) di dokumentasi MySQL.
Mengaktifkan logging biner meningkatkan jumlah I/O operasi write disk ke instance DB. Anda dapat memantau penggunaan IOPS dengan `WriteIOPS` `` CloudWatch metrik.
**Untuk mengatur format pencatatan log biner MySQL**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Grup parameter**.
1. Pilih grup parameter DB, yang terkait dengan instans DB, yang ingin dimodifikasi.
Anda tidak dapat mengubah grup parameter default. Jika instans DB menggunakan grup parameter default, buat grup parameter baru dan hubungkan dengan instans DB.
Untuk mengetahui informasi selengkapnya tentang grup parameter, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md).
1. Dari **Tindakan**, pilih **Edit**.
1. Atur parameter `binlog_format` ke format pencatatan log biner pilihan Anda (`ROW`, `STATEMENT`, atau `MIXED`).
Anda dapat menonaktifkan pencatatan log biner dengan mengatur periode retensi cadangan instans DB ke nol, tetapi tindakan ini akan menonaktifkan cadangan otomatis harian. Menonaktifkan backup otomatis mematikan atau menonaktifkan variabel sesi. `log_bin` Ini menonaktifkan logging biner pada RDS untuk instance MySQL DB, yang pada gilirannya mengatur ulang variabel `binlog_format` sesi ke nilai default dalam database. `ROW` Sebaiknya jangan menonaktifkan cadangan. Untuk mengetahui informasi selengkapnya tentang pengaturan **Periode penyimpanan cadangan**, lihat [Pengaturan untuk instans DB](USER_ModifyInstance.Settings.md).
1. Pilih **Simpan perubahan** untuk menyimpan pembaruan ke grup parameter DB.
Karena `binlog_format` parameternya dinamis di RDS untuk MySQL, Anda tidak perlu me-reboot instance DB agar perubahan diterapkan. (Perhatikan bahwa di Aurora MySQL, parameter ini statis. Untuk informasi selengkapnya, lihat [Mengonfigurasi logging biner MySQL Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.MySQL.BinaryFormat.html).)
**penting**
Mengubah grup parameter DB memengaruhi semua instans DB yang menggunakan grup parameter tersebut. Jika Anda ingin menentukan format logging biner yang berbeda untuk instance MySQL DB yang berbeda di Wilayah, instance DB harus AWS menggunakan grup parameter DB yang berbeda. Grup parameter ini mengidentifikasikan format logging yang berbeda. Tetapkan grup parameter DB yang sesuai ke masing-masing instans DB.
# Mengkonfigurasi pencatatan biner MySQL untuk cluster DB Multi-AZ
Binary logging di Amazon RDS for MySQL Multi-AZ DB cluster mencatat semua perubahan database untuk mendukung replikasi, pemulihan, dan audit. point-in-time Dalam cluster DB multi-AZ, log biner menyinkronkan node sekunder dengan node utama, memastikan konsistensi data di seluruh Availability Zones dan memungkinkan failover yang mulus.
Untuk mengoptimalkan pencatatan biner, Amazon RDS mendukung kompresi transaksi log biner, yang mengurangi persyaratan penyimpanan untuk log biner dan meningkatkan efisiensi replikasi.
**Topics**
+ [Kompresi transaksi log biner untuk cluster DB multi-AZ](#USER_Binlog.MultiAZ.compression)
+ [Mengkonfigurasi kompresi transaksi log biner untuk cluster DB multi-AZ](#USER_Binlog.MultiAZ.configuring)
## Kompresi transaksi log biner untuk cluster DB multi-AZ
Kompresi transaksi log biner menggunakan algoritma zstd untuk mengurangi ukuran data transaksi yang disimpan dalam log biner. Saat diaktifkan, mesin database MySQL memampatkan muatan transaksi menjadi satu peristiwa, meminimalkan dan menyimpan overhead. I/O Fitur ini meningkatkan kinerja database, mengurangi ukuran log biner, dan mengoptimalkan penggunaan sumber daya untuk mengelola dan mereplikasi log di cluster DB multi-AZ.
Amazon RDS menyediakan kompresi transaksi log biner untuk RDS untuk cluster DB Multi-AZ MySQL melalui parameter berikut:
+ `binlog_transaction_compression`— Ketika diaktifkan (`1`), mesin database memampatkan muatan transaksi dan menuliskannya ke log biner sebagai satu peristiwa. Ini mengurangi penggunaan penyimpanan dan I/O overhead. Parameter dinonaktifkan secara default.
+ `binlog_transaction_compression_level_zstd`— Mengkonfigurasi tingkat kompresi zstd untuk transaksi log biner. Nilai yang lebih tinggi meningkatkan rasio kompresi, mengurangi kebutuhan penyimpanan lebih lanjut tetapi meningkatkan penggunaan CPU dan memori untuk kompresi. Nilai default adalah 3, dengan kisaran 1-22.
Parameter ini memungkinkan Anda menyempurnakan kompresi log biner berdasarkan karakteristik beban kerja dan ketersediaan sumber daya. Untuk informasi selengkapnya, lihat [Kompresi Transaksi Log Biner](https://dev.mysql.com/doc/refman/8.4/en/binary-log-transaction-compression.html) di dokumentasi MySQL.
Kompresi transaksi log biner memiliki manfaat utama sebagai berikut:
+ Kompresi mengurangi ukuran log biner, terutama untuk beban kerja dengan transaksi besar atau volume tulis tinggi.
+ Log biner yang lebih kecil mengurangi jaringan dan I/O overhead, meningkatkan kinerja replikasi.
+ `binlog_transaction_compression_level_zstd`Parameter memberikan kontrol atas trade-off antara rasio kompresi dan konsumsi sumber daya.
## Mengkonfigurasi kompresi transaksi log biner untuk cluster DB multi-AZ
Untuk mengonfigurasi kompresi transaksi log biner untuk klaster DB RDS untuk MySQL Multi-AZ, ubah pengaturan parameter cluster yang relevan agar sesuai dengan persyaratan beban kerja Anda.
### Konsol
**Untuk mengaktifkan kompresi transaksi log biner**
1. Ubah grup parameter cluster DB untuk mengatur `binlog_transaction_compression` parameter ke`1`.
1. (Opsional) Sesuaikan nilai `binlog_transaction_compression_level_zstd` parameter berdasarkan persyaratan beban kerja dan ketersediaan sumber daya Anda.
Untuk informasi selengkapnya, lihat [Memodifikasi parameter dalam grup parameter cluster DB Aurora](USER_WorkingWithParamGroups.ModifyingCluster.md).
### AWS CLI
Untuk mengkonfigurasi kompresi transaksi log biner menggunakan AWS CLI, gunakan perintah [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html).
**Example**
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name your-cluster-parameter-group \
--parameters "ParameterName=binlog_transaction_compression,ParameterValue=1,ApplyMethod=pending-reboot"
```
Untuk Windows:
```
aws rds modify-db-cluster-parameter-group ^
--db-cluster-parameter-group-name your-cluster-parameter-group ^
--parameters "ParameterName=binlog_transaction_compression,ParameterValue=1,ApplyMethod=pending-reboot"
```
### API RDS
Untuk mengonfigurasi kompresi transaksi log biner menggunakan Amazon RDS API, gunakan [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html)operasi.
# Mengakses log biner MySQL
Anda dapat menggunakan utilitas mysqlbinlog untuk mengunduh atau mengalirkan log biner dari instans DB RDS for MySQL. Log biner diunduh ke komputer lokal, tempat Anda dapat melakukan tindakan seperti memutar ulang log menggunakan utilitas mysql. Untuk mengetahui informasi selengkapnya tentang cara menggunakan utilitas mysqlbinlog, lihat [Using mysqlbinlog to back up binary log files](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-backup.html) dalam dokumentasi MySQL.
Untuk menjalankan utilitas mysqlbinlog terhadap instans Amazon RDS, gunakan opsi berikut:
+ `--read-from-remote-server` – Wajib diisi.
+ `--host` – Nama DNS dari titik akhir instans.
+ `--port` – Port yang digunakan oleh instans.
+ `--user` – Pengguna MySQL yang telah diberi izin `REPLICATION SLAVE`.
+ `--password` – Kata sandi untuk pengguna MySQL, atau hapus nilai kata sandi agar utilitas meminta Anda memasukkan kata sandi.
+ `--raw` – Mengunduh file dalam format biner.
+ `--result-file` – File lokal untuk menerima output mentah.
+ `--stop-never` – Mengalirkan file log biner.
+ `--verbose` – Jika Anda menggunakan format binlog `ROW`, sertakan opsi ini untuk melihat peristiwa baris sebagai pernyataan pseudo-SQL. Untuk mengetahui informasi selengkapnya tentang opsi `--verbose`, lihat [mysqlbinlog row event display](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-row-events.html) dalam dokumentasi MySQL.
+ Tentukan nama satu atau beberapa file log biner. Untuk mendapatkan daftar log yang tersedia, gunakan perintah SQL `SHOW BINARY LOGS`.
Untuk mengetahui informasi selengkapnya tentang opsi mysqlbinlog, lihat [mysqlbinlog — Utility for processing binary log files](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog.html) dalam dokumentasi MySQL.
Contoh berikut menunjukkan cara menggunakan utilitas mysqlbinlog.
Untuk Linux, macOS, atau Unix:
```
mysqlbinlog \
--read-from-remote-server \
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com \
--port=3306 \
--user ReplUser \
--password \
--raw \
--verbose \
--result-file=/tmp/ \
binlog.00098
```
Untuk Windows:
```
mysqlbinlog ^
--read-from-remote-server ^
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com ^
--port=3306 ^
--user ReplUser ^
--password ^
--raw ^
--verbose ^
--result-file=/tmp/ ^
binlog.00098
```
Log biner harus tetap tersedia pada instance DB untuk utilitas mysqlbinlog untuk mengaksesnya. Untuk memastikan ketersediaannya, gunakan prosedur yang [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) disimpan dan tentukan periode dengan waktu yang cukup bagi Anda untuk mengunduh log. Jika konfigurasi ini tidak disetel, Amazon RDS membersihkan log biner sesegera mungkin, yang menyebabkan celah di log biner yang diambil oleh utilitas mysqlbinlog.
Contoh berikut menetapkan periode retensi ke 1 hari.
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
Untuk menampilkan pengaturan saat ini, gunakan prosedur tersimpan [mysql.rds\$1show\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_show_configuration).
```
call mysql.rds_show_configuration;
```
# File log database Amazon RDS for Oracle
Anda dapat mengakses log peringatan, file audit, dan file jejak Oracle dengan menggunakan konsol Amazon RDS atau API. Untuk mengetahui informasi selengkapnya tentang cara melihat, mengunduh, dan melihat log basis data berbasis file, lihat [Memantau file RDS Amazon](USER_LogAccess.md).
File audit Oracle yang disediakan adalah file audit Oracle standar. Amazon RDS mendukung fitur audit mendetail (FGA) Oracle. Namun, akses log tidak menyediakan akses ke peristiwa FGA yang disimpan di tabel `SYS.FGA_LOG$` yang dapat diakses melalui tampilan `DBA_FGA_AUDIT_TRAIL`.
Operasi API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html) yang mencantumkan file log Oracle yang tersedia untuk instans DB mengabaikan parameter `MaxRecords` dan menampilkan hingga 1.000 data. Panggilan menampilkan `LastWritten` sebagai tanggal POSIX dalam milidetik.
**Topics**
+ [Jadwal retensi](#USER_LogAccess.Concepts.Oracle.Retention)
+ [Menggunakan file jejak Oracle](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles)
+ [Menerbitkan log Oracle ke Amazon CloudWatch Logs](#USER_LogAccess.Oracle.PublishtoCloudWatchLogs)
+ [Mengakses log peringatan dan log pendengar](#USER_LogAccess.Concepts.Oracle.AlertLogAndListenerLog)
## Jadwal retensi
Mesin basis data Oracle dapat merotasi file log jika menjadi sangat besar. Untuk mempertahankan file audit atau jejak, unduh semuanya. Jika menyimpan file secara lokal, Anda dapat menurunkan biaya penyimpanan Amazon RDS dan menyediakan lebih banyak ruang untuk data Anda.
Tabel berikut menunjukkan jadwal retensi untuk log peringatan, file audit, dan file jejak Oracle di Amazon RDS.
****
| Jenis log | Jadwal retensi |
| --- | --- |
| Log peringatan | Log peringatan teks dirotasi setiap hari dengan 30 hari retensi yang dikelola oleh Amazon RDS. Log peringatan XML dipertahankan selama setidaknya tujuh hari. Anda dapat mengakses log ini dengan menggunakan tampilan `ALERTLOG`. |
| File audit | Periode retensi default untuk file audit adalah tujuh hari. Amazon RDS mungkin menghapus file audit yang lebih lama dari tujuh hari. |
| File jejak | Periode retensi default untuk file jejak adalah tujuh hari. Amazon RDS mungkin menghapus file jejak yang lebih lama dari tujuh hari. |
| Log pendengar | Periode retensi default untuk log pendengar adalah tujuh hari. Amazon RDS mungkin menghapus log pendengar yang lebih lama dari tujuh hari. |
**catatan**
File audit dan file jejak memiliki konfigurasi penyimpanan yang sama.
## Menggunakan file jejak Oracle
Selanjutnya, Anda dapat menemukan deskripsi prosedur Amazon RDS untuk membuat, menyegarkan, mengakses, dan menghapus file jejak.
**Topics**
+ [Membuat daftar file](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest)
+ [Membuat file jejak dan melacak sesi](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Generating)
+ [Mengambil file jejak](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Retrieving)
+ [Membersihkan file jejak](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Purging)
### Membuat daftar file
Anda dapat menggunakan salah satu dari dua prosedur untuk mengizinkan akses ke file apa pun di jalur `background_dump_dest`. Prosedur pertama menyegarkan tampilan yang berisi daftar semua file saat ini ada di `background_dump_dest`.
```
1. EXEC rdsadmin.manage_tracefiles.refresh_tracefile_listing;
```
Setelah tampilan dimuat ulang, buat kueri tampilan berikut untuk mengakses hasil.
```
1. SELECT * FROM rdsadmin.tracefile_listing;
```
Alternatif untuk proses sebelumnya adalah menggunakan `FROM table` untuk mengalirkan data non-relasional dalam format seperti tabel untuk mencantumkan konten direktori basis data.
```
1. SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('BDUMP'));
```
Kueri berikut menunjukkan teks file log.
```
1. SELECT text FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP','alert_dbname.log.date'));
```
Pada replika baca, dapatkan nama direktori BDUMP dengan mengueri `V$DATABASE.DB_UNIQUE_NAME`. Jika nama uniknya adalah `DATABASE_B`, direktori BDUMP-nya adalah `BDUMP_B`. Contoh berikut mengueri nama BDUMP pada replika dan kemudian menggunakan nama ini untuk mengueri konten `alert_DATABASE.log.2020-06-23`.
```
1. SELECT 'BDUMP' || (SELECT regexp_replace(DB_UNIQUE_NAME,'.*(_[A-Z])', '\1') FROM V$DATABASE) AS BDUMP_VARIABLE FROM DUAL;
2.
3. BDUMP_VARIABLE
4. --------------
5. BDUMP_B
6.
7. SELECT TEXT FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP_B','alert_DATABASE.log.2020-06-23'));
```
### Membuat file jejak dan melacak sesi
Karena tidak ada batasan pada `ALTER SESSION`, banyak metode standar untuk menghasilkan file jejak dalam Oracle yang tetap tersedia untuk instans DB Amazon RDS. Prosedur berikut disediakan untuk file jejak yang memerlukan akses lebih besar.
****
| Metode Oracle | Metode Amazon RDS |
| --- | --- |
| `oradebug hanganalyze 3 ` | `EXEC rdsadmin.manage_tracefiles.hanganalyze; ` |
| `oradebug dump systemstate 266 ` | `EXEC rdsadmin.manage_tracefiles.dump_systemstate;` |
Anda dapat menggunakan berbagai metode standar untuk melacak sesi individu yang terhubung ke instans DB Oracle di Amazon RDS. Untuk mengaktifkan penelusuran untuk sesi, Anda dapat menjalankan subprogram dalam PL/SQL paket yang disediakan oleh Oracle, seperti dan. `DBMS_SESSION` `DBMS_MONITOR` Untuk mengetahui informasi selengkapnya, lihat [ Mengaktifkan pelacakan untuk sesi](https://docs.oracle.com/database/121/TGSQL/tgsql_trace.htm#GUID-F872D6F9-E015-481F-80F6-8A7036A6AD29) dalam dokumentasi Oracle.
### Mengambil file jejak
Anda dapat mengambil file jejak apa pun dalam `background_dump_dest` menggunakan kueri SQL standar di tabel eksternal yang dikelola Amazon RDS. Untuk menggunakan metode ini, Anda harus menjalankan prosedur untuk menetapkan lokasi untuk tabel ini ke file jejak spesifik.
Misalnya, Anda dapat menggunakan tampilan `rdsadmin.tracefile_listing` yang disebutkan sebelumnya untuk mencantumkan semua file jejak pada sistem. Anda kemudian dapat mengatur tampilan `tracefile_table` untuk diarahkan ke file ke jejak yang dimaksud dengan menggunakan prosedur berikut.
```
1. EXEC rdsadmin.manage_tracefiles.set_tracefile_table_location('CUST01_ora_3260_SYSTEMSTATE.trc');
```
Contoh berikut membuat tabel eksternal dalam skema saat ini dengan lokasi yang diatur ke file yang disediakan. Anda dapat mengambil konten ke dalam file lokal menggunakan kueri SQL.
```
1. SPOOL /tmp/tracefile.txt
2. SELECT * FROM tracefile_table;
3. SPOOL OFF;
```
### Membersihkan file jejak
File jejak dapat terakumulasi dan menghabiskan ruang disk. Amazon RDS menghapus file jejak secara default dan file log yang lebih lama dari tujuh hari. Anda dapat melihat dan mengatur periode retensi file jejak menggunakan prosedur `show_configuration`. Anda harus menjalankan perintah `SET SERVEROUTPUT ON` agar dapat melihat hasil konfigurasi.
Contoh berikut menunjukkan periode retensi file jejak saat ini, lalu mengatur periode retensi file jejak baru.
```
1. # Show the current tracefile retention
2. SQL> EXEC rdsadmin.rdsadmin_util.show_configuration;
3. NAME:tracefile retention
4. VALUE:10080
5. DESCRIPTION:tracefile expiration specifies the duration in minutes before tracefiles in bdump are automatically deleted.
6.
7. # Set the tracefile retention to 24 hours:
8. SQL> EXEC rdsadmin.rdsadmin_util.set_configuration('tracefile retention',1440);
9. SQL> commit;
10.
11. #show the new tracefile retention
12. SQL> EXEC rdsadmin.rdsadmin_util.show_configuration;
13. NAME:tracefile retention
14. VALUE:1440
15. DESCRIPTION:tracefile expiration specifies the duration in minutes before tracefiles in bdump are automatically deleted.
```
Selain proses pembersihan berkala, Anda dapat menghapus file secara manual dari `background_dump_dest`. Contoh berikut menunjukkan cara membersihkan semua file yang lebih lama dari lima menit.
```
EXEC rdsadmin.manage_tracefiles.purge_tracefiles(5);
```
Anda juga dapat membersihkan semua file yang cocok dengan pola tertentu (jika Anda melakukannya, jangan sertakan ekstensi file, seperti .trc). Contoh berikut menunjukkan cara membersihkan semua file yang dimulai dengan `SCHPOC1_ora_5935`.
```
1. EXEC rdsadmin.manage_tracefiles.purge_tracefiles('SCHPOC1_ora_5935');
```
## Menerbitkan log Oracle ke Amazon CloudWatch Logs
Anda dapat mengonfigurasi RDS untuk instans Oracle DB untuk mempublikasikan data log ke grup log di Amazon CloudWatch Logs. Dengan CloudWatch Log, Anda dapat menganalisis data log, dan menggunakannya CloudWatch untuk membuat alarm dan melihat metrik. Anda dapat menggunakan CloudWatch Log untuk menyimpan catatan log Anda dalam penyimpanan yang sangat tahan lama.
Amazon RDS menerbitkan setiap log basis data Oracle sebagai aliran basis data terpisah di grup log. Misalnya, jika Anda mengonfigurasi fungsi ekspor untuk menyertakan log audit, data audit akan disimpan dalam log stream audit di grup log `/aws/rds/instance/my_instance/audit`. Tabel berikut merangkum persyaratan untuk RDS untuk Oracle untuk mempublikasikan log ke Amazon Logs. CloudWatch
| Nama log | Persyaratan | Default |
| --- | --- | --- |
| Log peringatan | Tidak ada. Anda tidak dapat menonaktifkan log ini. | Diaktifkan |
| Log jejak | Atur parameter `trace_enabled` ke `TRUE` atau biarkan diatur ke pengaturan default. | `TRUE` |
| Log audit | Atur `audit_trail` parameter ke salah satu nilai yang diizinkan berikut: { none | os | db [, extended] | xml [, extended] } | `none` |
| Log pendengar | Tidak ada. Anda tidak dapat menonaktifkan log ini. | Diaktifkan |
| Log Agen Manajemen Oracle | Tidak ada. Anda tidak dapat menonaktifkan log ini. | Diaktifkan |
Log Agen Manajemen Oracle ini terdiri dari grup log yang ditunjukkan pada tabel berikut.
****
| Nama log | CloudWatch grup log |
| --- | --- |
| emctl.log | oemagent-emctl |
| emdctlj.log | oemagent-emdctlj |
| gcagent.log | oemagent-gcagent |
| gcagent\$1errors.log | oemagent-gcagent-errors |
| emagent.nohup | oemagent-emagent-nohup |
| secure.log | oemagent-secure |
Untuk informasi selengkapnya, lihat [Locating Management Agent Log and Trace Files](https://docs.oracle.com/en/enterprise-manager/cloud-control/enterprise-manager-cloud-control/13.4/emadm/locating-management-agent-log-and-trace-files1.html#GUID-9C710D78-6AA4-42E4-83CD-47B5FF4892DF) dalam dokumentasi Oracle.
### Konsol
**Untuk mempublikasikan log Oracle DB ke CloudWatch Log dari Konsol Manajemen AWS**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis Data**, kemudian pilih instans DB yang ingin diubah.
1. Pilih **Modifikasi**.
1. Di bagian **Log ekspor**, pilih log yang ingin Anda mulai terbitkan ke CloudWatch Log.
1. Pilih **Lanjutkan**, lalu pilih **Ubah Instans DB** di halaman ringkasan.
### AWS CLI
Untuk menerbitkan log Oracle, Anda dapat menggunakan perintah [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) untuk parameter berikut ini:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**catatan**
Perubahan pada opsi `--cloudwatch-logs-export-configuration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, opsi `--apply-immediately` dan `--no-apply-immediately` tidak akan berpengaruh.
Anda juga dapat menerbitkan log Oracle menggunakan perintah berikut:
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
**Example**
Contoh berikut membuat instance Oracle DB dengan penerbitan CloudWatch Log diaktifkan. Nilai `--cloudwatch-logs-export-configuration` adalah rangkaian string JSON. String dapat berupa kombinasi `alert`, `audit`, `listener`, dan `trace`.
Untuk Linux, macOS, atau Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '["trace","audit","alert","listener","oemagent"]' \
--db-instance-class db.m5.large \
--allocated-storage 20 \
--engine oracle-ee \
--engine-version 19.0.0.0.ru-2024-04.rur-2024-04.r1 \
--license-model bring-your-own-license \
--master-username myadmin \
--manage-master-user-password
```
Untuk Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration trace alert audit listener oemagent ^
--db-instance-class db.m5.large ^
--allocated-storage 20 ^
--engine oracle-ee ^
--engine-version 19.0.0.0.ru-2024-04.rur-2024-04.r1 ^
--license-model bring-your-own-license ^
--master-username myadmin ^
--manage-master-user-password
```
**Example**
Contoh berikut memodifikasi instance Oracle DB yang ada untuk mempublikasikan file log ke Log. CloudWatch Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `EnableLogTypes`, dan nilainya adalah serangkaian string dengan setiap kombinasi `alert`, `audit`, `listener`, dan `trace`.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["trace","alert","audit","listener","oemagent"]}'
```
Untuk Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration EnableLogTypes=\"trace\",\"alert\",\"audit\",\"listener\",\"oemagent\"
```
**Example**
Contoh berikut memodifikasi instans Oracle DB yang ada untuk menonaktifkan audit penerbitan dan file log pendengar ke Log. CloudWatch Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `DisableLogTypes`, dan nilainya adalah serangkaian string dengan setiap kombinasi `alert`, `audit`, `listener`, dan `trace`.
Untuk Linux, macOS, atau Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["audit","listener"]}'
```
Untuk Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration DisableLogTypes=\"audit\",\"listener\"
```
### RDS API
Anda dapat menerbitkan log DB Oracle dengan RDS API. Anda dapat memanggil tindakan [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**catatan**
Perubahan pada parameter `CloudwatchLogsExportConfiguration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, parameter `ApplyImmediately` tidak memiliki dampak.
Anda juga dapat menerbitkan log Oracle dengan memanggil operasi RDS API berikut:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Jalankan salah satu operasi RDS API ini dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Parameter lain mungkin diperlukan bergantung pada operasi RDS yang Anda jalankan.
## Mengakses log peringatan dan log pendengar
Anda dapat melihat log peringatan menggunakan konsol Amazon RDS. Anda juga dapat menggunakan pernyataan SQL berikut.
```
1. SELECT message_text FROM alertlog;
```
Akses log pendengar menggunakan Amazon CloudWatch Logs.
**catatan**
Oracle merotasi log peringatan dan pendengar jika melebihi 10 MB. Pada saat itu, log ini tidak tersedia dari tampilan Amazon RDS.
#
Anda dapat memantau jenis file log berikut:
+ Log PostgreSQL
+ Log peningkatan
+ Log kesalahan otentikasi basis data IAM
**catatan**
Untuk mengaktifkan log kesalahan otentikasi database IAM, Anda harus terlebih dahulu mengaktifkan otentikasi database IAM untuk Aurora Anda. Untuk informasi selengkapnya tentang mengaktifkan autentikasi database IAM, lihat. [Mengaktifkan dan menonaktifkan autentikasi basis data IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
RDS for PostgreSQL mencatat aktivitas basis data ke file log PostgreSQL default. Untuk instans DB PostgreSQL on-premise, pesan ini disimpan secara titik waktu di `log/postgresql.log`. Untuk instans DB RDS for PostgreSQL, file log tersedia di instans Amazon RDS. Log ini juga dapat diakses melalui Konsol Manajemen AWS, di mana Anda dapat melihat atau mengunduhnya. Tingkat pencatatan log default menangkap kegagalan masuk, kesalahan server fatal, kebuntuan, dan kegagalan kueri.
Untuk mengetahui informasi selengkapnya tentang cara menampilkan, mengunduh, dan melihat log basis data berbasis file, lihat [Memantau file RDS Amazon](USER_LogAccess.md). Untuk mempelajari selengkapnya tentang log PostgreSQL, lihat [Menggunakan log Amazon RDS dan Aurora PostgreSQL: Bagian 1](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/) dan [Menggunakan log Amazon RDS dan Aurora PostgreSQL: Bagian 2](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-2/).
Selain log PostgreSQL standar yang dibahas dalam topik ini, RDS for PostgreSQL juga mendukung ekstensi PostgreSQL Audit (`pgAudit`). Sebagian besar industri dan lembaga pemerintah yang teregulasi perlu mempertahankan log audit atau jejak audit perubahan yang dibuat pada data untuk memenuhi persyaratan hukum. Untuk mengetahui informasi tentang cara menginstal dan menggunakan pgAudit, lihat [Menggunakan pgAudit untuk mencatat aktivitas database](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md).
**Topics**
+ [Parameter untuk masuk](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md)
+ [Mengaktifkan pencatatan kueri untuk](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md)
+ [Menerbitkan log PostgreSQL ke Amazon Logs CloudWatch](#USER_LogAccess.Concepts.PostgreSQL.PublishtoCloudWatchLogs)
# Parameter untuk masuk
Anda dapat menyesuaikan perilaku pencatatan log untuk instans DB RDS for PostgreSQL dengan mengubah berbagai parameter. Dalam tabel berikut, Anda dapat menemukan parameter yang memengaruhi durasi penyimpanan log, waktu untuk memutar log, dan apakah akan menampilkan log sebagai format CSV (nilai yang dipisahkan koma). Anda juga dapat menemukan output teks yang dikirim ke STDERR, di antara pengaturan lainnya. Untuk mengubah pengaturan parameter yang dapat diubah, gunakan grup parameter DB kustom untuk Instans RDS for PostgreSQL. Untuk mengetahui informasi selengkapnya, lihat [Grup parameter DB untuk instans Amazon RDS Aurora DB](USER_WorkingWithDBInstanceParamGroups.md).
| Parameter | Default | Deskripsi |
| --- | --- | --- |
| log\$1destination | stderr | Menetapkan format output untuk log. Default-nya adalah `stderr`, tetapi Anda juga dapat menentukan nilai dipisahkan koma (CSV) dengan menambahkan `csvlog` ke pengaturan. Untuk informasi selengkapnya, lihat [Mengatur tujuan log (`stderr`, `csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format). |
| log\$1filename | postgresql.log.%Y-%m-%d-%H | Menentukan pola untuk nama file log. Selain default, parameter ini mendukung `postgresql.log.%Y-%m-%d` dan `postgresql.log.%Y-%m-%d-%H%M` untuk pola nama file. |
| log\$1line\$1prefix | %t:%r:%u@%d:[%p]: | Mendefinisikan awalan untuk setiap baris log yang akan ditulis ke `stderr`, untuk mencatat waktu (%t), host jarak jauh (%r), pengguna (%u), basis data (%d), dan ID proses (%p). |
| log\$1rotation\$1age | 60 | Menit setelah file log dirotasi secara otomatis. Anda dapat mengubah nilai ini dalam kisaran 1 dan 1440 menit. Untuk informasi selengkapnya, lihat [Mengatur rotasi file log](#USER_LogAccess.Concepts.PostgreSQL.log_rotation). |
| log\$1rotation\$1size | – | Ukuran (kB) tempat log dirotasi secara otomatis. Secara default, parameter ini tidak digunakan karena log diputar berdasarkan `log_rotation_age` parameter. Untuk mempelajari selengkapnya, lihat [Mengatur rotasi file log](#USER_LogAccess.Concepts.PostgreSQL.log_rotation). |
| rds.log\$1retention\$1period | 4320 | Log PostgreSQL yang lebih lama dari jumlah menit yang ditentukan dihapus. Nilai default 4320 menit menghapus file log setelah 3 hari. Untuk informasi selengkapnya, lihat [Mengatur periode retensi log](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period). |
Untuk mengidentifikasi masalah aplikasi, Anda dapat mencari kegagalan kueri, kegagalan masuk, kebuntuan, dan kesalahan server fatal di log. Misalnya, anggaplah Anda mengonversi aplikasi lama dari Oracle ke Amazon RDS PostgreSQL, tetapi tidak semua kueri dikonversi dengan benar. Kueri yang salah format ini menghasilkan pesan kesalahan yang dapat Anda temukan di log untuk membantu mengidentifikasi masalah. Untuk mengetahui informasi selengkapnya tentang pencatatan log kueri, lihat [Mengaktifkan pencatatan kueri untuk ](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md).
Dalam topik berikut, Anda dapat menemukan informasi tentang cara mengatur berbagai parameter yang mengontrol detail dasar untuk log PostgreSQL Anda.
**Topics**
+ [Mengatur periode retensi log](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period)
+ [Mengatur rotasi file log](#USER_LogAccess.Concepts.PostgreSQL.log_rotation)
+ [Mengatur tujuan log (`stderr`, `csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format)
+ [Memahami parameter log\$1line\$1prefix](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix)
## Mengatur periode retensi log
Parameter `rds.log_retention_period` menentukan berapa lama instans DB RDS for PostgreSQL menyimpan file log-nya. Pengaturan default-nya adalah 3 hari (4.320 menit), tetapi Anda dapat mengatur nilai ini ke mana saja dari 1 hari (1.440 menit) hingga 7 hari (10.080 menit). Pastikan bahwa instans DB RDS for PostgreSQL Anda memiliki penyimpanan yang cukup untuk menyimpan file log selama periode waktu tertentu.
Kami menyarankan agar log Anda dipublikasikan secara rutin ke Amazon CloudWatch Logs sehingga Anda dapat melihat dan menganalisis data sistem lama setelah log dihapus dari cluster DB Aurora Anda. Instans DB RDS for PostgreSQL. Untuk mengetahui informasi selengkapnya, lihat [Menerbitkan log PostgreSQL ke Amazon Logs CloudWatch](USER_LogAccess.Concepts.PostgreSQL.md#USER_LogAccess.Concepts.PostgreSQL.PublishtoCloudWatchLogs). .
## Mengatur rotasi file log
Amazon RDS membuat file log baru setiap jam secara default. Waktu dikontrol oleh parameter `log_rotation_age`. Parameter ini memiliki nilai default 60 (menit), tetapi Anda dapat mengaturnya ke mana saja dari 1 menit hingga 24 jam (1.440 menit). Ketika tiba waktunya rotasi, file log baru yang berbeda akan dibuat. File ini diberi nama sesuai dengan pola yang ditentukan oleh parameter `log_filename`.
File log juga dapat dirotasi sesuai dengan ukurannya, seperti yang ditentukan dalam parameter `log_rotation_size`. Parameter ini menentukan bahwa log harus dirotasi saat mencapai ukuran yang ditentukan (dalam kilobyte). Untuk instans DB RDS for PostgreSQL, `log_rotation_size` tidak diatur, yaitu tidak ada nilai yang ditentukan. Namun, Anda dapat mengatur parameter dari 0-2097151 kB (kilobyte).
Nama file log didasarkan pada pola nama file yang ditentukan dalam parameter `log_filename`. Pengaturan yang tersedia untuk parameter ini adalah sebagai berikut:
+ `postgresql.log.%Y-%m-%d` – Format default untuk nama file log. Termasuk tahun, bulan, dan tanggal dalam nama file log.
+ `postgresql.log.%Y-%m-%d-%H` – Termasuk jam dalam format nama file log.
Untuk mengetahui informasi selengkapnya, lihat [https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-AGE](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-AGE) dan [https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-SIZE](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-SIZE) dalam dokumentasi PostgreSQL.
## Mengatur tujuan log (`stderr`, `csvlog`)
Secara default, Amazon RDS PostgreSQL menghasilkan log dalam format kesalahan standar (stderr). Format ini adalah pengaturan default untuk parameter `log_destination`. Setiap pesan diawali menggunakan pola yang ditentukan dalam parameter `log_line_prefix`. Untuk mengetahui informasi selengkapnya, lihat [Memahami parameter log\$1line\$1prefix](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix).
RDS for PostgreSQL juga dapat menghasilkan log dalam format `csvlog`. `csvlog` berguna untuk menganalisis data log sebagai data nilai yang dipisahkan koma (CSV). Misalnya, anggaplah Anda menggunakan ekstensi `log_fdw` untuk bekerja dengan log Anda sebagai tabel asing. Tabel asing yang dibuat pada file log `stderr` berisi satu kolom dengan data peristiwa log. Dengan menambahkan `csvlog` ke parameter `log_destination`, Anda mendapatkan file log dalam format CSV dengan demarkasi untuk beberapa kolom tabel asing. Anda kini dapat mengurutkan dan menganalisis log dengan lebih mudah. Untuk mempelajari cara menggunakan `log_fdw` dengan `csvlog`, lihat [Menggunakan ekstensi log\$1fdw untuk mengakses log DB dengan SQL](CHAP_PostgreSQL.Extensions.log_fdw.md).
Jika Anda menentukan `csvlog` untuk parameter ini, perhatikan bahwa file `stderr` dan `csvlog` dihasilkan. Pastikan untuk memantau penyimpanan yang digunakan oleh log, dengan mempertimbangkan `rds.log_retention_period` dan pengaturan lain yang memengaruhi penyimpanan log dan omset. Menggunakan `stderr` dan `csvlog` lebih dari dua kali lipat penyimpanan yang digunakan oleh log.
Jika Anda menambahkan `csvlog` ke `log_destination` dan ingin kembali ke `stderr` sendiri, Anda perlu mengatur ulang parameter. Untuk melakukannya, buka Konsol Amazon RDS, lalu buka grup parameter DB untuk instans Anda. Pilih parameter `log_destination`, pilih **Edit parameter**, lalu pilih **Atur ulang**.
Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi pencatatan log, lihat [Menggunakan log Amazon RDS dan Aurora PostgreSQL: Bagian 1](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/).
## Memahami parameter log\$1line\$1prefix
Format `stderr` log awalan setiap pesan log dengan rincian yang ditentukan oleh parameter. `log_line_prefix` Nilai defaultnya adalah:
```
%t:%r:%u@%d:[%p]:t
```
Mulai dari Aurora PostgreSQL versi 16, Anda juga dapat memilih:
```
%m:%r:%u@%d:[%p]:%l:%e:%s:%v:%x:%c:%q%a
```
Setiap entri log yang dikirim ke stderr mencakup informasi berikut berdasarkan nilai yang dipilih:
+ `%t`— Waktu entri log tanpa milidetik
+ `%m`— Waktu entri log dengan milidetik
+ `%r` – Alamat host jarak jauh
+ `%u@%d` – Nama pengguna @ nama basis data
+ `[%p]` – ID Proses jika tersedia
+ `%l`— Nomor baris log per sesi
+ `%e`— Kode kesalahan SQL
+ `%s`— Stempel waktu mulai proses
+ `%v`— Id transaksi virtual
+ `%x`— ID Transaksi
+ `%c`— ID Sesi
+ `%q`— Terminator non-sesi
+ `%a`— Nama aplikasi
# Mengaktifkan pencatatan kueri untuk
Anda dapat mengumpulkan informasi yang lebih mendetail tentang aktivitas basis data, termasuk kueri, kueri yang menunggu kunci, titik pemeriksaan, dan banyak detail lainnya dengan mengatur beberapa parameter yang tercantum dalam tabel berikut. Topik ini berfokus pada kueri pencatatan log.
| Parameter | Default | Deskripsi |
| --- | --- | --- |
| log\$1connections | – | Mencatat log setiap koneksi yang berhasil. |
| log\$1disconnections | – | Mencatat log akhir setiap sesi dan durasinya. |
| log\$1checkpoints | 1 | Log setiap pos pemeriksaan. |
| log\$1lock\$1waits | – | Mencatat log waktu tunggu kunci yang panjang. Secara default, parameter ini tidak diatur. |
| log\$1min\$1duration\$1sample | – | (md) Menetapkan waktu eksekusi minimum yang jika terlampaui akan membuat sampel pernyataan dicatat. Ukuran sampel diatur menggunakan parameter log\$1statement\$1sample\$1rate. |
| log\$1min\$1duration\$1statement | – | Setiap pernyataan SQL yang berjalan setidaknya selama periode waktu tertentu atau lebih lama akan dicatat. Secara default, parameter ini tidak diatur. Mengaktifkan parameter ini dapat membantu Anda menemukan kueri yang belum dioptimalkan. |
| log\$1statement | – | Mengatur jenis pernyataan yang dicatat. Secara default, parameter ini tidak diatur, tetapi Anda dapat mengubahnya ke `all`, `ddl`, atau `mod` untuk menentukan jenis pernyataan SQL yang ingin Anda catat. Jika menentukan apa pun selain `none` untuk parameter ini, Anda juga harus mengambil langkah-langkah tambahan untuk mencegah eksposur kata sandi dalam file log. Untuk informasi selengkapnya, lihat [Mengurangi risiko eksposur kata sandi saat menggunakan pencatatan log kueriMengurangi risiko eksposur kata sandi](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk). |
| log\$1statement\$1sample\$1rate | – | Persentase pernyataan melebihi waktu yang ditentukan dalam `log_min_duration_sample` untuk dicatat, yang dinyatakan sebagai nilai titik mengambang antara 0,0 dan 1,0. |
| log\$1statement\$1stats | – | Menulis statistik performa kumulatif ke log server. |
## Menggunakan pencatatan log untuk menemukan kueri performa lambat
Anda dapat mencatat pernyataan dan kueri SQL untuk membantu menemukan kueri performa lambat. Anda mengaktifkan kemampuan ini dengan memodifikasi pengaturan di `log_statement` dan parameter `log_min_duration` seperti yang diuraikan dalam bagian ini. Sebelum mengaktifkan pencatatan log kueri untuk instans DB RDS for PostgreSQL, Anda harus mengetahui kemungkinan eksposur kata sandi di dalam log dan cara mengurangi risiko ini. Untuk informasi selengkapnya, lihat [Mengurangi risiko eksposur kata sandi saat menggunakan pencatatan log kueriMengurangi risiko eksposur kata sandi](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk).
Berikut ini, Anda dapat menemukan informasi referensi tentang parameter `log_statement` dan `log_min_duration`.log\$1statement
Parameter ini menentukan jenis pernyataan SQL yang harus dikirim ke log. Nilai default-nya adalah `none`. Jika Anda mengubah parameter ini ke `all`, `ddl`, atau `mod`, pastikan untuk menerapkan tindakan yang disarankan untuk mengurangi risiko eksposur kata sandi di dalam log. Untuk informasi selengkapnya, lihat [Mengurangi risiko eksposur kata sandi saat menggunakan pencatatan log kueriMengurangi risiko eksposur kata sandi](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk).
**all**
Mencatat log semua pernyataan. Pengaturan ini direkomendasikan untuk tujuan debugging.
**ddl**
Mencatat log semua pernyataan bahasa definisi data (DDL), seperti CREATE, ALTER, DROP, dan seterusnya.
**mod**
Mencatat log semua pernyataan DDL dan pernyataan bahasa manipulasi data (DL), seperti INSERT, UPDATE, dan DELETE, yang mengubah data.
**none**
Tidak ada pernyataan SQL yang dicatat. Kami merekomendasikan pengaturan ini untuk menghindari risiko eksposur kata sandi di dalam log.log\$1min\$1duration\$1statement
Setiap pernyataan SQL yang berjalan setidaknya selama periode waktu tertentu atau lebih lama akan dicatat. Secara default, parameter ini tidak diatur. Mengaktifkan parameter ini dapat membantu Anda menemukan kueri yang belum dioptimalkan.
**–1–2147483647**
Jumlah milidetik (md) runtime di mana pernyataan dicatat.
**Untuk menyiapkan pencatatan log kueri**
Langkah-langkah ini mengasumsikan bahwa Instans DB RDS for PostgreSQL menggunakan grup parameter DB kustom.
1. Atur parameter `log_statement` ke `all`. Contoh berikut ini menunjukkan informasi yang ditulis ke file `postgresql.log` dengan pengaturan parameter ini.
```
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:LOG: statement: SELECT feedback, s.sentiment,s.confidence
FROM support,aws_comprehend.detect_sentiment(feedback, 'en') s
ORDER BY s.confidence DESC;
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:LOG: QUERY STATISTICS
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:DETAIL: ! system usage stats:
! 0.017355 s user, 0.000000 s system, 0.168593 s elapsed
! [0.025146 s user, 0.000000 s system total]
! 36644 kB max resident size
! 0/8 [0/8] filesystem blocks in/out
! 0/733 [0/1364] page faults/reclaims, 0 [0] swaps
! 0 [0] signals rcvd, 0/0 [0/0] messages rcvd/sent
! 19/0 [27/0] voluntary/involuntary context switches
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:STATEMENT: SELECT feedback, s.sentiment,s.confidence
FROM support,aws_comprehend.detect_sentiment(feedback, 'en') s
ORDER BY s.confidence DESC;
2022-10-05 22:05:56 UTC:52.95.4.1(11335):postgres@labdb:[3639]:ERROR: syntax error at or near "ORDER" at character 1
2022-10-05 22:05:56 UTC:52.95.4.1(11335):postgres@labdb:[3639]:STATEMENT: ORDER BY s.confidence DESC;
----------------------- END OF LOG ----------------------
```
1. Atur parameter `log_min_duration_statement`. Contoh berikut ini menunjukkan informasi yang ditulis ke file `postgresql.log` saat pengaturan parameter ini diatur ke `1`.
Kueri yang melebihi durasi yang ditentukan dalam parameter `log_min_duration_statement` dicatat. Bagian berikut menunjukkan satu contoh. Anda dapat melihat file log untuk instans DB RDS for PostgreSQL di Konsol Amazon RDS.
```
2022-10-05 19:05:19 UTC:52.95.4.1(6461):postgres@labdb:[6144]:LOG: statement: DROP table comments;
2022-10-05 19:05:19 UTC:52.95.4.1(6461):postgres@labdb:[6144]:LOG: duration: 167.754 ms
2022-10-05 19:08:07 UTC::@:[355]:LOG: checkpoint starting: time
2022-10-05 19:08:08 UTC::@:[355]:LOG: checkpoint complete: wrote 11 buffers (0.0%); 0 WAL file(s) added, 0 removed, 0 recycled; write=1.013 s, sync=0.006 s, total=1.033 s; sync files=8, longest=0.004 s, average=0.001 s; distance=131028 kB, estimate=131028 kB
----------------------- END OF LOG ----------------------
```
### Mengurangi risiko eksposur kata sandi saat menggunakan pencatatan log kueri
Sebaiknya Anda tetap mengatur `log_statement` ke `none` agar tidak mengekspos kata sandi. Jika Anda mengatur `log_statement` ke `all`, `ddl`, atau `mod`, sebaiknya Anda mengambil satu atau beberapa langkah berikut.
+ Untuk klien, enkripsi informasi sensitif. Untuk mengetahui informasi selengkapnya, lihat [Opsi Enkripsi](https://www.postgresql.org/docs/current/encryption-options.html) dalam dokumentasi PostgreSQL. Gunakan opsi `ENCRYPTED` (dan `UNENCRYPTED`) dari pernyataan `CREATE` dan `ALTER`. Untuk mengetahui informasi selengkapnya, lihat [CREATE USER](https://www.postgresql.org/docs/current/sql-createuser.html) dalam dokumentasi PostgreSQL.
+ Untuk instans DB RDS for PostgreSQL, siapkan dan gunakan ekstensi PostgreSQL Audit (pgAaudit). Ekstensi ini menyunting informasi sensitif dalam pernyataan CREATE dan ALTER yang dikirim ke log. Untuk informasi selengkapnya, lihat [Menggunakan pgAudit untuk mencatat aktivitas database](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md).
+ Batasi akses ke CloudWatch log.
+ Gunakan mekanisme autentikasi yang lebih kuat seperti IAM.
## Menerbitkan log PostgreSQL ke Amazon Logs CloudWatch
Untuk menyimpan catatan log PostgreSQL Anda dalam penyimpanan yang sangat tahan lama, Anda dapat menggunakan Amazon Logs. CloudWatch Dengan CloudWatch Log, Anda juga dapat melakukan analisis real-time data log dan digunakan CloudWatch untuk melihat metrik dan membuat alarm. Misalnya, jika Anda mengatur `log_statement` ke `ddl`, Anda dapat menyiapkan alarm untuk memperingatkan Anda setiap kali pernyataan DDL dijalankan. Anda dapat memilih agar log PostgreSQL Anda diunggah ke Log selama proses pembuatan RDS CloudWatch untuk instance PostgreSQL DB. Jika memilih untuk tidak mengunggah log pada saat itu, Anda nantinya dapat mengubah instans untuk mulai mengunggah log sejak saat itu. Dengan kata lain, log yang ada tidak diunggah. Hanya log baru yang diunggah saat dibuat pada instans DB RDS for PostgreSQL Anda yang dimodifikasi.
Semua RDS yang tersedia saat ini untuk versi PostgreSQL mendukung penerbitan file log ke Log. CloudWatch Untuk mengetahui informasi selengkapnya, lihat [Pembaruan Amazon RDS for PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-versions.html) di *Catatan Rilis Amazon RDS for PostgreSQL*.
Untuk bekerja dengan CloudWatch Log, konfigurasikan RDS Anda untuk instans PostgreSQL DB untuk mempublikasikan data log ke grup log.
Anda dapat mempublikasikan jenis log berikut ke CloudWatch Log untuk RDS untuk PostgreSQL:
+ Log PostgreSQL
+ Log peningkatan
+ Log kesalahan otentikasi basis data IAM
Setelah Anda menyelesaikan konfigurasi, Amazon RDS menerbitkan peristiwa log untuk mencatat aliran dalam grup log. CloudWatch Sebagai contoh, data log PostgreSQL disimpan dalam grup log `/aws/rds/instance/my_instance/postgresql`. Untuk melihat log Anda, buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
### Konsol
**Untuk mempublikasikan log PostgreSQL ke Log menggunakan konsol CloudWatch**
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih **Basis data**.
1. Pilih instans DB yang ingin diubah, lalu pilih **Ubah**.
1. Di bagian **Log ekspor**, pilih log yang ingin Anda mulai terbitkan ke CloudWatch Log.
Bagian **ekspor Log** hanya tersedia untuk versi PostgreSQL yang mendukung penerbitan ke Log. CloudWatch
1. Pilih **Lanjutkan**, lalu pilih **Ubah Instans DB** di halaman ringkasan.
### AWS CLI
Anda dapat mempublikasikan log PostgreSQL dengan file. AWS CLI Anda dapat memanggil perintah [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) dengan parameter berikut.
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**catatan**
Perubahan pada opsi `--cloudwatch-logs-export-configuration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, opsi `--apply-immediately` dan `--no-apply-immediately` tidak akan berpengaruh.
Anda juga dapat menerbitkan log PostgreSQL dengan memanggil perintah CLI berikut:
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
Jalankan salah satu perintah CLI ini dengan opsi berikut:
+ `--db-instance-identifier`
+ `--enable-cloudwatch-logs-exports`
+ `--db-instance-class`
+ `--engine`
Opsi lain mungkin diperlukan bergantung pada perintah CLI yang Anda jalankan.
**Example Memodifikasi instance untuk mempublikasikan log ke CloudWatch Log**
Contoh berikut memodifikasi instance PostgreSQL DB yang ada untuk mempublikasikan file log ke Log. CloudWatch Nilai `--cloudwatch-logs-export-configuration` adalah objek JSON. Kunci untuk objek ini adalah `EnableLogTypes`, dan nilainya adalah serangkaian string dengan kombinasi `postgresql` dan `upgrade` apa pun.
Untuk Linux, macOS, atau Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql", "upgrade"]}'
```
Untuk Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql","upgrade"]}'
```
**Example Buat instance untuk mempublikasikan log ke CloudWatch Log**
Contoh berikut membuat instance PostgreSQL DB dan menerbitkan file log ke Log. CloudWatch Nilai `--enable-cloudwatch-logs-exports` adalah rangkaian string JSON. String dapat berupa kombinasi `postgresql` dan `upgrade` apa pun.
Untuk Linux, macOS, atau Unix:
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --enable-cloudwatch-logs-exports '["postgresql","upgrade"]' \
4. --db-instance-class db.m4.large \
5. --engine postgres
```
Untuk Windows:
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --enable-cloudwatch-logs-exports '["postgresql","upgrade"]' ^
4. --db-instance-class db.m4.large ^
5. --engine postgres
```
### RDS API
Anda dapat menerbitkan log PostgreSQL dengan RDS API. Anda dapat memanggil tindakan [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**catatan**
Perubahan pada parameter `CloudwatchLogsExportConfiguration` selalu diterapkan ke instans DB secara langsung. Oleh karena itu, parameter `ApplyImmediately` tidak memiliki dampak.
Anda juga dapat menerbitkan log PostgreSQL dengan memanggil operasi RDS API berikut:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Jalankan salah satu operasi RDS API ini dengan parameter berikut:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Parameter lain mungkin diperlukan bergantung pada operasi yang Anda jalankan.