^
--result-file=/tmp/binlog.txt
```
Normalmente, Amazon RDS limpia un registro binario lo antes posible. Sin embargo, el registro binario debe seguir estando disponible en la instancia para que mysqlbinlog pueda obtener acceso a él. Para especificar el número de horas que RDS retiene los registros binarios, use el procedimiento almacenado `mysql.rds_set_configuration`. Especifique un período con tiempo suficiente para descargar los registros. Una vez que haya definido el periodo de retención, monitorice el uso del almacenamiento para la instancia de base de datos con el fin de asegurarse de que los registros binarios conservados no consuman demasiado almacenamiento.
En el siguiente ejemplo se define el periodo de retención en 1 día.
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
Para mostrar el valor actual, utilice el procedimiento almacenado `mysql.rds_show_configuration`.
```
call mysql.rds_show_configuration;
```
# Habilitación de la anotación de registros binarios de MariaDB
En una instancia de base de datos de MariaDB, puede usar el evento `Annotate_rows` para incluir en un evento de fila una copia de la consulta de SQL que causó el evento de fila. Este enfoque proporciona una funcionalidad similar a la habilitación del parámetro `binlog_rows_query_log_events` en una instancia de base de datos de RDS para MySQL.
Puede habilitar globalmente las anotaciones de registros binarios creando un grupo de parámetros personalizado y definiendo el parámetro `binlog_annotate_row_events` como **1**. También puede habilitar las anotaciones en el nivel de sesión llamando a `SET SESSION binlog_annotate_row_events = 1`. Use `replicate_annotate_row_events` para reproducir las anotaciones de registros binarios en la instancia réplica si el registro binario está habilitado en ella. No se requieren privilegios especiales para usar estos ajustes.
A continuación se muestra un ejemplo de una transacción basada en filas de MariaDB. El uso del registro basado en filas se dispara definiendo el nivel de aislamiento de transacciones como de lectura confirmada.
```
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;
```
Sin anotaciones, las entradas de los registros binarios de la transacción tendrán un aspecto similar al siguiente:
```
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/*!*/;
```
La siguiente instrucción habilita las anotaciones de nivel de sesión para esta misma transacción y las deshabilita después de confirmar la transacción:
```
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;
```
Con anotaciones, las entradas de los registros binarios de la transacción tendrán un aspecto similar al siguiente:
```
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/*!*/;
```
# Archivos de registro de base de datos de Amazon RDS para Microsoft SQL Server
Puede acceder a registros de errores, registros de agentes, archivos de seguimiento y archivos de volcado de Microsoft SQL Server mediante la consola de Amazon RDS, la AWS CLI o la API de RDS. Para obtener más información acerca de la visualización, descarga y vigilancia de los registros de bases de datos basados en archivos, consulte [Supervisión de archivos de registro de Amazon RDS](USER_LogAccess.md).
## Calendario de retención
Los archivos de registro rotan cada día y cuando se reinicia la instancia de base de datos. A continuación, se muestra el calendario de retención para los registros de Microsoft SQL Server en Amazon RDS.
****
| Log type (Tipo de registro) | Calendario de retención |
| --- | --- |
| Registros de errores | Se retiene un máximo de 30 registros de errores. Amazon RDS podría eliminar los registros de errores que tienen más de 7 días. |
| Registros de agentes | Se retiene un máximo de 10 registros de agente. Amazon RDS podría eliminar los registros de agente que tienen más de 7 días. |
| Archivos de seguimiento | Los archivos de seguimiento se conservan según el periodo de retención de archivos de seguimiento de la instancia de base de datos. El periodo de retención de archivos de seguimiento predeterminado es de 7 días. Para modificar el periodo de retención de archivos de seguimiento de la instancia de base de datos, consulte [Definición del periodo de retención para los archivos de seguimiento y volcado](Appendix.SQLServer.CommonDBATasks.TraceFiles.md#Appendix.SQLServer.CommonDBATasks.TraceFiles.PurgeTraceFiles). |
| Archivos de volcado | Los archivos de volcado se conservan según el periodo de retención de archivos de volcado de la instancia de base de datos. El periodo de retención predeterminado para los archivos de volcado es de 7 días. Para modificar el periodo de retención de los archivos de volcado de la instancia de base de datos, consulte [Definición del periodo de retención para los archivos de seguimiento y volcado](Appendix.SQLServer.CommonDBATasks.TraceFiles.md#Appendix.SQLServer.CommonDBATasks.TraceFiles.PurgeTraceFiles). |
## Visualización del registro de errores de SQL Server mediante el procedimiento rds\$1read\$1error\$1log
Puede utilizar el procedimiento almacenado `rds_read_error_log` de Amazon RDS para ver registros de errores y registros de agentes. Para obtener más información, consulte [Visualización de registros de agentes y errores](Appendix.SQLServer.CommonDBATasks.Logs.md#Appendix.SQLServer.CommonDBATasks.Logs.SP).
## Publicación de registros de SQL Server en Amazon CloudWatch Logs
Con Amazon RDS for SQL Server, puede publicar eventos de errores y registros de agente directamente en Amazon CloudWatch Logs. Analice los datos de registro con CloudWatch Logs y utilice CloudWatch para crear alarmas y ver métricas.
En CloudWatch Logs, tiene las siguientes opciones:
+ Almacenar registros en un espacio de almacenamiento de larga duración con un periodo de retención que defina.
+ Buscar y filtrar los datos de registro.
+ Compartir datos de registro entre cuentas.
+ Exportar registros a Amazon S3.
+ Transmitir datos por streaming a Amazon OpenSearch Service.
+ Procesar los datos de registros en tiempo real con Amazon Kinesis Data Streams. Para obtener más información, consulte [Uso de Registros de Amazon CloudWatch](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/cloudwatch-logs.html) en la *Guía para desarrolladores de aplicaciones SQL de Amazon Managed Service para Apache Flink*.
Amazon RDS publica cada registro de base de datos de SQL Server como un flujo de base de datos independiente en el grupo de registros. Por ejemplo, si publica registros de agentes y registros de errores, se almacenan datos de errores en un flujo de registro de errores en el grupo de registro `/aws/rds/instance/my_instance.node1/error` y se almacenan los datos de registros de agentes en el grupo de registro `/aws/rds/instance/my_instance.node1/agent`.
Para las instancias de base de datos Multi-AZ, Amazon RDS publica el registro de la base de datos como dos flujos independientes en el grupo de registro. Por ejemplo, si publica registros de errores, los datos de errores se almacenan en los flujos de registro de errores `/aws/rds/instance/my_instance.node1/error` y `/aws/rds/instance/my_instance.node2/error` respectivamente. Los flujos de registro no cambian durante una conmutación por error y el flujo de registro de errores de cada nodo puede contener registros de errores de la instancia principal o secundaria. Con multi-AZ, se crea automáticamente un flujo de registro para que `/aws/rds/instance/my_instance/rds-events` almacene los datos de eventos, como las conmutaciones por error de instancias de base de datos.
**nota**
La publicación de registros de SQL Server en CloudWatch Logs no está habilitado de manera predeterminada. La publicación de archivos de seguimiento y volcado no es compatible. La publicación de registros de SQL Server en CloudWatch Logs es compatible en todas las regiones.
### Consola
**Para publicar registros de base de datos de SQL Server en CloudWatch Logs desde Consola de administración de AWS**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Databases (Bases de datos)** y, a continuación, seleccione la instancia de base de datos que desee modificar.
1. Elija **Modify**.
1. En la sección **Logs exports (Exportaciones de registros)**, elija los registros que desea comenzar a publicar en CloudWatch Logs.
Puede elegir **Agent log (Registro de agentes)**, **Error log (Registro de errores)** o ambos.
1. Elija **Continue**, seguido de **Modify DB Instance** en la página de resumen.
### AWS CLI
Para publicar registros de SQL Server, puede utilizar el comando [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) con los siguientes parámetros:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**nota**
Los cambios en la opción `--cloudwatch-logs-export-configuration` siempre se aplican a la instancia de base de datos inmediatamente. Por lo tanto, las opciones `--apply-immediately` y `--no-apply-immediately` no tienen ningún efecto.
También puede publicar registros de SQL Server utilizando los siguientes comandos:
+ [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**
En el siguiente ejemplo se crea una instancia de base de datos de SQL Server con la publicación de registros de CloudWatch Logs habilitada. El valor `--enable-cloudwatch-logs-exports` es una matriz de cadenas JSON que puede incluir `error`, `agent` o ambos.
Para Linux, macOS o 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
```
Para 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
```
Al utilizar el símbolo del sistema de Windows, debe aplicar escape con comillas dobles (") en código JSON al ponerlas como prefijo con una barra invertida (\$1).
**Example**
En el siguiente ejemplo se modifica una instancia de base de datos SQL Server existente para publicar archivos de registro en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `EnableLogTypes` y su valor es una matriz de cadenas que puede incluir `error`, `agent` o ambos.
Para Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["error","agent"]}'
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"EnableLogTypes\":[\"error\",\"agent\"]}"
```
Al utilizar el símbolo del sistema de Windows, debe aplicar escape con comillas dobles (") en código JSON al ponerlas como prefijo con una barra invertida (\$1).
**Example**
En el siguiente ejemplo se modifica una instancia de base de datos SQL Server existente para deshabilitar la publicación de archivos de registro del agente en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `DisableLogTypes` y su valor es una matriz de cadenas que puede incluir `error`, `agent` o ambos.
Para Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["agent"]}'
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration "{\"DisableLogTypes\":[\"agent\"]}"
```
Al utilizar el símbolo del sistema de Windows, debe aplicar escape con comillas dobles (") en código JSON al ponerlas como prefijo con una barra invertida (\$1).
# Archivos de registro de base de datos de MySQL
Puede supervisar los registros de MySQL directamente desde la consola de Amazon RDS, la API de Amazon RDS, AWS CLI o los SDK de AWS. También es posible el acceso a los registros de MySQL dirigiéndolos a una tabla de la base de datos principal y consultando esa tabla. Puede usar la utilidad mysqlbinlog para descargar un registro binario.
Para obtener más información acerca de la visualización, descarga y vigilancia de los registros de bases de datos basados en archivos, consulte [Supervisión de archivos de registro de Amazon RDS](USER_LogAccess.md).
**Topics**
+ [Información general de los registros de bases de datos de RDS para MySQL](USER_LogAccess.MySQL.LogFileSize.md)
+ [Publicación de registros de MySQL en Amazon CloudWatch Logs](USER_LogAccess.MySQLDB.PublishtoCloudWatchLogs.md)
+ [Envío de la salida del registro de MySQL a las tablas](Appendix.MySQL.CommonDBATasks.Logs.md)
+ [Configuración del registro binario de RDS para MySQL para bases de datos Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md)
+ [Configuración del registro binario de MySQL para clústeres de bases de datos multi-AZ](USER_Binlog.MultiAZ.md)
+ [Acceso a los registros binarios de MySQL](USER_LogAccess.MySQL.Binarylog.md)
# Información general de los registros de bases de datos de RDS para MySQL
Puede supervisar los siguientes tipos de archivos de registro de RDS para MySQL:
+ Registro de errores
+ Registro de consultas lentas
+ Registro general
+ Registro de auditoría
+ Registro de instancias
+ Registro de errores de autenticación de base de datos de IAM
El registro de errores de RDS para MySQL se genera de forma predeterminada. Puede generar la consulta lenta y los registros generales estableciendo parámetros en su grupo de parámetros de base de datos.
**Topics**
+ [Registros de errores de RDS para MySQL](#USER_LogAccess.MySQL.Errorlog)
+ [Registros generales y de consultas lentas de RDS para MySQL](#USER_LogAccess.MySQL.Generallog)
+ [Registro de auditoría de MySQL](#USER_LogAccess.MySQL.Auditlog)
+ [Rotación y retención de registros en RDS para MySQL](#USER_LogAccess.MySQL.LogFileSize.retention)
+ [Límites de tamaño en registro REDO](#USER_LogAccess.MySQL.LogFileSize.RedoLogs)
## Registros de errores de RDS para MySQL
RDS para MySQL escribe los errores en el archivo `mysql-error.log`. Cada archivo de registro tiene la hora a la que se generó (en UTC) agregada a su nombre. Los archivos de registro también tienen una marca temporal que ayuda a determinar cuándo se escribieron las entradas del registro.
RDS for MySQL solo escribe en el registro de errores durante el inicio, el cierre y cuando encuentra errores. Una instancia de base de datos puede pasar horas o días sin que se escriban nuevas entradas en el registro de errores. Si no hay entradas recientes, se debe a que el servidor no ha encontrado ningún error que genere una entrada en el registro.
Por diseño, los registros de errores se filtran para que solo se muestren los eventos inesperados, por ejemplo, los errores. No obstante, los registros de errores también contienen información adicional sobre la base de datos, por ejemplo, el progreso de la consulta, que no se muestra. Por lo tanto, incluso sin ningún error real, el tamaño de los registros de errores podría aumentar debido a las actividades continuas de la base de datos. Y, aunque puede que vea un tamaño determinado en bytes o kilobytes en los registros de error de la Consola de administración de AWS, es posible que tengan 0 bytes al descargarlos.
RDS para MySQL escribe `mysql-error.log` en disco cada 5 minutos. Adjunta el contenido del registro a `mysql-error-running.log`.
RDS para MySQL rota el archivo `mysql-error-running.log` cada hora. Retiene los registros generados durante las dos últimas semanas.
**nota**
Tenga en cuenta que el periodo de retención es diferente entre Amazon RDS y Aurora.
## Registros generales y de consultas lentas de RDS para MySQL
Puede escribir el registro de consultas lentas de RDS para MySQL y el registro general en un archivo o en una tabla de la base de datos. Para hacerlo, establezca los parámetros en el grupo de parámetros de la base de datos. Para obtener información acerca de cómo crear y modificar un grupo de parámetros de base de datos, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md). Debe definir estos parámetros para poder ver el registro de consultas lentas o el registro general en la consola de Amazon RDS o a través de la API de Amazon RDS, la CLI de Amazon RDS o los SDK de AWS.
Puede controlar lo que registra RDS para MySQL con los parámetros de esta lista:
+ `slow_query_log`: para crear el registro de consultas lentas, use el valor 1. El valor predeterminado es 0.
+ `general_log`: para crear el registro general, use el valor 1. El valor predeterminado es 0.
+ `long_query_time`: para evitar que se registren consultas rápidas en el registro de consultas lentas, especifique el valor del tiempo de ejecución mínimo de una consulta, en segundos, para que se registre. El valor predeterminado es 10 segundos y el mínimo es 0. Si log\$1output = FILE, puede especificar un valor de punto flotante que llega a una resolución de microsegundos. Si log\$1output = TABLE, debe especificar un valor entero con resolución de segundos. Solo se registran las consultas cuyo tiempo de ejecución exceda el valor de `long_query_time`. Por ejemplo, si configura `long_query_time` como 0,1, evitará que se registren las consultas que tarden menos de 100 milisegundos en ejecutarse.
+ `log_queries_not_using_indexes`: para incluir en el registro de consultas lentas todas las consultas que no usen un índice, use el valor 1. Las consultas que no usen un índice se registran incluso si su tiempo de ejecución es inferior al valor del parámetro `long_query_time`. El valor predeterminado es 0.
+ `log_output option`: puede especificar una de las opciones siguientes para el parámetro `log_output`.
+ **TABLE** (predeterminada): las consultas generales se escriben en la tabla `mysql.general_log` y las consultas lentas en la tabla `mysql.slow_log`.
+ **FILE**: tanto los registros de las consultas generales como los de las consultas lentas se escriben en el sistema de archivos.
+ **NONE**: deshabilitar registro.
Para que los datos de consultas lentas aparezcan en Registros de Amazon CloudWatch, se deben cumplir las siguientes condiciones:
+ Registros de CloudWatch debe configurarse para incluir registros de consultas lentas.
+ `slow_query_log` debe estar habilitado.
+ `log_output` debe establecerse en `FILE`.
+ La consulta debe tardar más tiempo que el tiempo configurado para `long_query_time`.
Para obtener más información sobre la el registro de consultas lentas y el registro general, consulte los siguientes temas de la documentación de MySQL:
+ [El registro de consultas lentas](https://dev.mysql.com/doc/refman/8.0/en/slow-query-log.html)
+ [El registro de consultas generales](https://dev.mysql.com/doc/refman/8.0/en/query-log.html)
## Registro de auditoría de MySQL
Para acceder al registro de auditoría, la instancia de base de datos debe usar un grupo de opciones personalizado con la opción `MARIADB_AUDIT_PLUGIN`. Para obtener más información, consulte [Compatibilidad con el complemento de auditoría de MariaDB para MySQL](Appendix.MySQL.Options.AuditPlugin.md).
## Rotación y retención de registros en RDS para MySQL
Cuando el registro está habilitado, Amazon RDS rota los registros de las tablas o elimina los archivos de registro a intervalos regulares. Esta medida es una precaución para reducir el riesgo de que un archivo de registro grande bloquee el uso de la base de datos o afecte al desempeño. RDS para MySQL gestiona la rotación y la eliminación de la siguiente manera:
+ El tamaño de los archivos de registro de consultas lentas, registro de errores y registro general de MySQL está limitado al 2 por ciento del espacio de almacenamiento asignado a una instancia de base de datos. Para mantener este umbral, los registros se rotan automáticamente cada hora. MySQL elimina los archivos de registro de más de dos semanas de antigüedad. Si el tamaño combinado de los archivos de registro sobrepasa el umbral después de eliminar los archivos de registro antiguos, los archivos de registro más grandes se eliminan hasta que el tamaño del archivo de registro deje de sobrepasar el umbral.
+ Cuando se habilita el registro `FILE`, los archivos de registro se examinan cada hora y se eliminan los archivos de registro de más de dos semanas de antigüedad. En algunos casos, el tamaño restante del archivo de registro combinado después de la eliminación puede superar el umbral del 2 por ciento del espacio asignado a una instancia de base de datos. En estos casos, los archivos de registro más antiguos se eliminan hasta que el tamaño del archivo de registro no sobrepase el umbral.
+ Cuando el registro de tipo `TABLE` está habilitado, en algunos casos, las tablas de registro se rotan cada 24 horas. Esta rotación de produce cuando el espacio ocupado por los registros de tabla es superior al 20% del espacio de almacenamiento asignado. También ocurre si el tamaño de todos los registros combinados es superior a 10 GB. Si la cantidad de espacio utilizada para una instancia de base de datos es superior al 90 % del espacio de almacenamiento asignado a la instancia de base de datos, se reducen los umbrales de la rotación de registros. Las tablas de registro se rotan si el espacio ocupado por los registros de tabla es superior al 10 % del espacio de almacenamiento asignado. También rotan si el tamaño de todos los registros combinados es superior a 5 GB. Puede suscribirse a la categoría de evento `low storage` para recibir una notificación cuando roten las tablas de registro para liberar espacio. Para obtener más información, consulte [Uso de notificaciones de eventos de Amazon RDS](USER_Events.md).
Cuando se rotan las tablas de registro, la tabla de registro actual se copia primero en una tabla de registro de copia de seguridad. A continuación, se eliminan las entradas de la tabla de registro actual. Si la tabla de registro de copia de seguridad ya existe, se elimina antes de copiar la tabla del registro actual en la copia de seguridad. Puede consultar la tabla de registro de copia de seguridad si es necesaria. La tabla de registro de copia de seguridad para la tabla `mysql.general_log` se llama `mysql.general_log_backup`. La tabla de registro de copia de seguridad para la tabla `mysql.slow_log` se llama `mysql.slow_log_backup`.
Para rotar la tabla `mysql.general_log` puede ejecutar el procedimiento `mysql.rds_rotate_general_log`. Para rotar la tabla `mysql.slow_log` puede ejecutar el procedimiento `mysql.rds_rotate_slow_log`.
Los registros de tabla se rotan durante una actualización de la versión de la base de datos.
Para trabajar con los registros desde la consola de Amazon RDS, la API de Amazon RDS, la CLI de Amazon RDS o los SDK de AWS, configure el parámetro `log_output` en FILE. Al igual que el registro de errores de MySQL, estos archivos de registro rotan cada hora. Se retienen los archivos de registro que se generaron durante las dos semanas anteriores. Tenga en cuenta que el período de retención es diferente entre Amazon RDS y Aurora.
## Límites de tamaño en registro REDO
Para la versión 8.0.32 y anteriores de RDS para MySQL, el valor predeterminado de este parámetro es 256 MB. Esta cantidad se obtiene multiplicando el valor predeterminado del parámetro `innodb_log_file_size` (128 MB) por el valor predeterminado del parámetro `innodb_log_files_in_group` (2). Para obtener más información, consulte [Best practices for configuring parameters for Amazon RDS for MySQL, part 1: Parameters related to performance](https://aws.amazon.com/blogs/database/best-practices-for-configuring-parameters-for-amazon-rds-for-mysql-part-1-parameters-related-to-performance/).
Para la versión 8.0.33 de RDS para MySQL y versiones menores posteriores, Amazon RDS utiliza el parámetro `innodb_redo_log_capacity` en lugar del parámetro `innodb_log_file_size`. El valor predeterminado en Amazon RDS del parámetro `innodb_redo_log_capacity` es 2 GB. Para obtener más información, consulte [Cambios en MySQL 8.0.30](https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-30.html), en la documentación de MySQL.
A partir de MySQL 8.4, Amazon RDS habilita el parámetro `innodb_dedicated_server` de forma predeterminada. Con el parámetro `innodb_dedicated_server`, el motor de base de datos calcula los parámetros `innodb_buffer_pool_size` y `innodb_redo_log_capacity`. Para obtener más información, consulte [Configuración del tamaño del grupo de búferes y la capacidad de registros redo en MySQL 8.4](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md).
# Publicación de registros de MySQL en Amazon CloudWatch Logs
Se puede configurar una instancia de base de datos MySQL para publicar datos de registro en un grupo de registros en Amazon CloudWatch Logs. Con CloudWatch Logs, puede realizar análisis en tiempo real de los datos de registro y utilizar CloudWatch para crear alarmas y ver métricas. Puede utilizar CloudWatch Logs para almacenar los registros de registros en almacenamiento de larga duración.
Amazon RDS publica cada registro de base de datos de MySQL como un flujo de base de datos independiente en el grupo de registros. Por ejemplo, si configura la función de exportación para que incluya el registro de consultas lentas, los datos de consultas lentas se almacenan en un flujo de registros de consultas lentas en el grupo de registros `/aws/rds/instance/my_instance/slowquery`.
El registro de errores están habilitados de forma predeterminada. La tabla siguiente resume los requisitos para los otros registros de MySQL.
| Registro | Requisito |
| --- | --- |
| Registro de auditoría | La instancia de base de datos debe usar un grupo de opciones personalizado con la opción `MARIADB_AUDIT_PLUGIN`. |
| Registro general | La instancia de base de datos debe usar un grupo de parámetros personalizado con la configuración del parámetro `general_log = 1` para habilitar el registro general. |
| Registro de consultas lentas | La instancia de base de datos debe usar un grupo de parámetros personalizado con la configuración del parámetro `slow_query_log = 1` para habilitar el registro de consultas lentas. |
| Registro de errores de autenticación de base de datos de IAM | Debe habilitar el tipo de registro `iam-db-auth-error` para una instancia de base de datos mediante la creación o modificación de una instancia de base de datos. |
| Resultado de registro | La instancia de base de datos debe usar un grupo de parámetros personalizado con la configuración del parámetro `log_output = FILE` para escribir registros en el sistema de archivos y publicarlos en CloudWatch Logs. |
## Consola
**Para publicar registros de base de datos MySQL en CloudWatch Logs con la consola**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Databases (Bases de datos)** y, a continuación, seleccione la instancia de base de datos que desee modificar.
1. Elija **Modify**.
1. En la sección **Logs exports (Exportaciones de registros)**, elija los registros que desea comenzar a publicar en CloudWatch Logs.
1. Elija **Continue**, seguido de **Modify DB Instance** en la página de resumen.
## AWS CLI
Puede publicar registros de MySQL con la AWS CLI. Puede llamar al comando [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) con los parámetros siguientes:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**nota**
Los cambios en la opción `--cloudwatch-logs-export-configuration` siempre se aplican a la instancia de base de datos inmediatamente. Por lo tanto, las opciones `--apply-immediately` y `--no-apply-immediately` no tienen ningún efecto.
También puede publicar registros de MySQL llamando a los siguientes comandos de 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)
Ejecute uno de estos comandos de la AWS CLI con las siguientes opciones:
+ `--db-instance-identifier`
+ `--enable-cloudwatch-logs-exports`
+ `--db-instance-class`
+ `--engine`
Podrían ser necesarias otras opciones en función del comando de la AWS CLI que ejecute.
**Example**
En el siguiente ejemplo se modifica una instancia de base de datos MySQL DB para publicar archivos de registro en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `EnableLogTypes` y su valor es una matriz de cadenas con cualquier combinación de `audit`, `error`, `general` y `slowquery`.
Para Linux, macOS o Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
Para Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
**Example**
En el siguiente ejemplo se crea una instancia de base de datos MySQL y se publican archivos de registro en CloudWatch Logs. El valor `--enable-cloudwatch-logs-exports` es una matriz de cadenas JSON. Las cadenas pueden ser cualquier combinación de `audit`, `error`, `general` y `slowquery`.
Para Linux, macOS o 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
```
Para 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 de RDS
Puede publicar registros de MySQL con la API de RDS. Puede llamar a la acción [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) con los parámetros siguientes:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**nota**
Los cambios en el parámetro `CloudwatchLogsExportConfiguration` siempre se aplican a la instancia de base de datos inmediatamente. Por tanto, el parámetro `ApplyImmediately` no tiene efecto.
También puede publicar registros de MySQL llamando a las siguientes operaciones de la API de RDS:
+ [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)
Ejecute una de estas operaciones de la API de RDS con los siguientes parámetros:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Podrían ser necesarios otros parámetros en función del comando de la AWS CLI que ejecute.
# Envío de la salida del registro de MySQL a las tablas
Para dirigir los registros general y de consultas lentas a tablas de la instancia de base de datos, cree un grupo de parámetros de base de datos y asigne al parámetro `log_output` del servidor el valor `TABLE`. Las consultas generales se registrarán entonces en la tabla `mysql.general_log` y las consultas lentas en la tabla `mysql.slow_log`. Puede consultar las tablas para obtener acceso a la información del registro. Al habilitar este registro, se incrementa la cantidad de datos que se escribe en la base de datos, lo que puede degradar el desempeño.
Tanto el registro general como los registros de consultas lentas están deshabilitados de manera predeterminada. Para habilitar el registro en tablas, también debe asignar a los parámetros `general_log` y `slow_query_log` del servidor el valor `1`.
Las tablas de registro seguirán creciendo hasta que las actividades de registro respectivas se desactiven cambiando el valor del parámetro a `0`. A menudo, se acumula una gran cantidad de datos, lo que puede consumir un porcentaje elevado del espacio de almacenamiento asignado. Amazon RDS no permite truncar las tablas de registro, pero sí mover su contenido. Al rotar una tabla, su contenido se guarda en una tabla de copia de seguridad y se crea una nueva tabla de registro vacía. Puede aplicar manualmente la rotación de las tablas de registro con los procedimientos de línea de comandos siguientes, en los que el símbolo del sistema se representa por:`PROMPT>`
```
PROMPT> CALL mysql.rds_rotate_slow_log;
PROMPT> CALL mysql.rds_rotate_general_log;
```
Para eliminar por completo los datos antiguos y recuperar el espacio del disco, llame al procedimiento correspondiente dos veces consecutivas.
# Configuración del registro binario de RDS para MySQL para bases de datos Single-AZ
El *registro binario* es un conjunto de archivos de registro que contienen información acerca de las modificaciones de datos hechas en una instancia de servidor de MySQL. El registro binario contiene información como la siguiente:
+ Eventos que describen cambios en la base de datos, como la creación de tablas o las modificaciones de filas.
+ Información sobre la duración de cada instrucción que actualizó los datos.
+ Eventos para instrucciones que podrían haber actualizado datos, pero que no lo hicieron.
El registro binario registra las instrucciones que se envían durante la replicación. También es necesario para algunas operaciones de recuperación. Para obtener más información, consulte [The Binary Log](https://dev.mysql.com/doc/refman/8.0/en/binary-log.html) en la documentación de MySQL.
La característica de copias de seguridad automatizadas determina si el registro binario se activa o desactiva para MySQL. Dispone de las opciones siguientes:
Activar el registro binario.
Establecer el periodo de retención de copia de seguridad en un valor positivo distinto de cero.
Desactivar el registro binario.
Establecer el periodo de retención de copia de seguridad en cero.
Para obtener más información, consulte [Habilitar las copias de seguridad automatizadas](USER_WorkingWithAutomatedBackups.Enabling.md).
MySQL en Amazon RDS admite los formatos de registro binario *basado en filas*, *basado en instrucciones* y *mixto*. Recomendamos mezclarlos, a menos que necesite un formato binlog concreto. Para obtener información detallada acerca de los formatos de registro binarios de MySQL, consulte [Binary logging formats](https://dev.mysql.com/doc/refman/8.0/en/binary-log-formats.html) en la documentación de MySQL.
Si tiene pensado utilizar la replicación, el formato de registro binario es importante porque determina el registro de los cambios de datos que se registra en la fuente y se envía a los objetivos de replicación. Para obtener más información acerca de las ventajas y desventajas de distintos tipos de formatos de registro binarios para la replicación, consulte [Advantages and Disadvantages of Statement-Based and Row-Based Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) en la documentación de MySQL.
**importante**
Con MySQL 8.0.34, MySQL ha dejado de utilizar el parámetro `binlog_format`. En versiones posteriores de MySQL, MySQL planea eliminar el parámetro y admitir únicamente la replicación basada en filas. Por ello, recomendamos utilizar el registro basado en filas para las nuevas configuraciones de replicación de MySQL. Para obtener más información, consulte [binlog\$1format](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_format) en la documentación de MySQL.
Las versiones 8.0 y 8.4 de MySQL aceptan el parámetro `binlog_format`. Al usar este parámetro, MySQL emite una advertencia de obsolescencia. En una futura versión principal, MySQL eliminará el parámetro `binlog_format`.
La replicación basada en instrucciones puede causar incoherencias entre el de la instancia de base de datos de origen y la réplica de lectura. Para obtener más información, consulte [Determination of Safe and Unsafe Statements in Binary Logging](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html) en la documentación de MySQL.
Habilitar el registro binario aumenta el número de operaciones de E/S de escritura en el disco en la instancia de base de datos. Puede supervisar el uso de IOPS con la métrica de CloudWatch `WriteIOPS```.
**Para configurar el formato de registro binario de MySQL**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, seleccione **Grupos de parámetros**.
1. Seleccione el grupo de parámetros del de base de datos asociado con la instancia de base de datos que quiera modificar.
No puede modificar un grupo de parámetros predeterminado. Si el de la instancia de base de datos emplea un grupo de parámetros predeterminado, cree un nuevo grupo de parámetros y asócielo con el de la instancia de base de datos.
Para obtener más información acerca de los grupos de parámetros, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. En **Acciones**, elija **Editar**.
1. Establezca el parámetro `binlog_format` en el formato de registro binario de su elección (`ROW`, `STATEMENT` o `MIXED`).
Para desactivar el registro binario establezca el período de retención de copias de seguridad de una instancia de base de datos en cero. Tenga en cuenta que esto deshabilita las copias de seguridad automatizadas diarias. Al deshabilitar las copias de seguridad automatizadas, se desactiva o deshabilita la variable de sesión `log_bin`. Esto deshabilita el registro binario en la instancia de base de datos de RDS para MySQL, lo que a su vez restablece la variable de sesión `binlog_format` al valor predeterminado de `ROW` en la base de datos. Se recomienda no deshabilitar las copias de seguridad. Para obtener más información acerca de la configuración del **Período de retención de copia de seguridad**, consulte [Configuración de instancias de base de datos](USER_ModifyInstance.Settings.md).
1. Elija **Guardar cambios** para guardar los cambios realizados en el grupo de parámetros del de la base de datos.
Dado que el parámetro `binlog_format` es dinámico en RDS para MySQL, no es necesario reiniciar la instancia de base de datos para que se apliquen los cambios. (Tenga en cuenta que en Aurora MySQL, este parámetro es estático. Para obtener más información, consulte [Configuración del registro binario de Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.MySQL.BinaryFormat.html).)
**importante**
El cambio de un grupo de parámetros de base de datos afecta a todas las instancias de base de datos que utilizan ese grupo de parámetros. Si desea especificar diferentes formatos de registro binario para diferentes instancias de base de datos MySQL en una región AWS, las instancias de base de datos deben utilizar diferentes grupos de parámetros de base de datos. Estos grupos de parámetros identifican diferentes formatos de registro. Asigne el grupo de parámetros de base de datos apropiado a cada instancia de base de datos.
# Configuración del registro binario de MySQL para clústeres de bases de datos multi-AZ
El registro binario en los clústeres de bases de datos multi-AZ de Amazon RDS para MySQL registra todos los cambios en la base de datos para facilitar la replicación, la recuperación en un momento dado y la auditoría. En los clústeres de bases de datos multi-AZ, los registros binarios sincronizan los nodos secundarios con el nodo principal, lo que garantiza la coherencia de datos en todas las zonas de disponibilidad y permite realizar conmutaciones por error perfectas.
Para optimizar el registro binario, Amazon RDS admite la compresión de transacciones de registros binarios, lo que reduce los requisitos de almacenamiento de los registros binarios y mejora la eficacia de la replicación.
**Topics**
+ [Compresión de transacciones de registros binarios para clústeres de bases de datos multi-AZ](#USER_Binlog.MultiAZ.compression)
+ [Configuración de la compresión de transacciones de registros binarios para clústeres de bases de datos multi-AZ](#USER_Binlog.MultiAZ.configuring)
## Compresión de transacciones de registros binarios para clústeres de bases de datos multi-AZ
La compresión de transacciones de registros binarios utiliza el algoritmo zstd para reducir el tamaño de los datos de transacciones almacenados en los registros binarios. Cuando está habilitado, el motor de base de datos MySQL comprime las cargas útiles de las transacciones en un solo evento, lo que minimiza la sobrecarga de E/S y almacenamiento. Esta característica mejora el rendimiento de la base de datos, reduce el tamaño de los registros binarios y optimiza el uso de recursos para administrar y replicar los registros en clústeres de bases de datos multi-AZ.
Amazon RDS proporciona compresión de transacciones de registros binarios para clústeres de base de datos multi-AZ de RDS para MySQL mediante los parámetros siguientes:
+ `binlog_transaction_compression`: cuando está activado (`1`), el motor de base de datos comprime las cargas útiles de las transacciones y las graba en el registro binario como un evento único. Esto reduce el uso de almacenamiento y la sobrecarga de E/S. Este parámetro está deshabilitado de forma predeterminada.
+ `binlog_transaction_compression_level_zstd`: configura el nivel de compresión estándar para las transacciones de registros binarios. Los valores más altos aumentan la relación de compresión, lo que reduce aún más los requisitos de almacenamiento, pero incrementan el uso de CPU y memoria para la compresión. El valor predeterminado es 3, con un rango de 1 a 22.
Estos parámetros le permiten afinar la compresión de registros binarios en función de las características de la carga de trabajo y la disponibilidad de los recursos. Para obtener más información, consulte [Binary Log Transaction Compression](https://dev.mysql.com/doc/refman/8.4/en/binary-log-transaction-compression.html) en la documentación de MySQL.
La compresión de transacciones de registros binarios tiene las siguientes ventajas principales:
+ La compresión reduce el tamaño de los registros binarios, especialmente en el caso de cargas de trabajo con transacciones grandes o volúmenes de escritura elevados.
+ Los registros binarios más pequeños reducen la sobrecarga de red y de E/S, lo que mejora el rendimiento de la replicación.
+ El parámetro `binlog_transaction_compression_level_zstd` permite controlar el equilibrio entre la relación de compresión y el consumo de recursos.
## Configuración de la compresión de transacciones de registros binarios para clústeres de bases de datos multi-AZ
Para configurar la compresión de transacciones de registros binarios para un clúster de base de datos multi-AZ de RDS para MySQL, modifique la configuración de los parámetros del clúster correspondiente para adaptarla a sus requisitos de carga de trabajo.
### Consola
**Habilitación de la compresión de transacciones de registros binarios**
1. Modifique el grupo de parámetros del clúster de bases de datos para establecer el parámetro `binlog_transaction_compression` en `1`.
1. (Opcional) Ajuste el valor del parámetro `binlog_transaction_compression_level_zstd` en función de los requisitos de carga de trabajo y la disponibilidad de los recursos.
Para obtener más información, consulte [Modificación de los parámetros en un grupo de parámetros de clúster de base de datos ](USER_WorkingWithParamGroups.ModifyingCluster.md).
### AWS CLI
Para configurar la compresión de transacciones de registros binarios mediante la AWS CLI, utilice el comando [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html).
**Example**
Para Linux, macOS o 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"
```
Para 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 de RDS
Para configurar la compresión de transacciones de registros binarios mediante la API de Amazon RDS, utilice la operación [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html).
# Acceso a los registros binarios de MySQL
Puede usar la herramienta mysqlbinlog para descargar o transmitir los registros binarios desde las instancias de Amazon RDS para MySQL. El registro binario se descarga en el equipo local, donde puede ejecutar acciones tales como reproducirlo con la utilidad mysql. Para obtener más información acerca del uso de la herramienta mysqlbinlog, consulte [Using mysqlbinlog to Back Up Binary Log Files](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-backup.html) (Uso de mysqlbinlog para realizar copias de seguridad de archivos de registro binarios) en la documentación de MySQL.
Para ejecutar la utilidad mysqlbinlog en una instancia de Amazon RDS, use las siguientes opciones:
+ `--read-from-remote-server`: obligatorio.
+ `--host`: el nombre de DNS del punto de conexión de la instancia.
+ `--port`: el puerto que utiliza la instancia.
+ `--user`: un usuario de MySQL al que se le concede el permiso `REPLICATION SLAVE`.
+ `--password`: la contraseña del usuario de MySQL, o bien no indique ninguna para que la herramienta le pida una.
+ `--raw`: descargue el archivo en formato binario.
+ `--result-file`: el archivo local en que se guardará la salida sin procesar.
+ `--stop-never`: transmita los archivos de registro binarios.
+ `--verbose`: cuando utilice el formato binlog de `ROW`, incluya esta opción para ver los eventos de fila como instrucciones pseudo-SQL. Para obtener más información acerca de la opción `--verbose`, consulte [mysqlbinlog row event display](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-row-events.html) (Visualización de eventos de fila mysqlbinlog) en la documentación de MySQL.
+ Especifique los nombres de uno o varios de los archivos de registro binarios. Para obtener una lista de los registros disponibles, use el comando de SQL `SHOW BINARY LOGS`.
Para obtener más información acerca de las opciones de mysqlbinlog, consulte [mysqlbinlog - Utility for Processing Binary Log Files](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog.html) (mysqlbinlog - Utilidad para procesar archivos de registro binarios) en la documentación de MySQL.
En los siguientes ejemplos, se muestra cómo utilizar la herramienta mysqlbinlog.
Para Linux, macOS o 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
```
Para 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
```
Los registros binarios deben permanecer disponibles en la instancia de base de datos para que la utilidad mysqlbinlog pueda acceder a ellos. Para garantizar su disponibilidad, utilice el procedimiento [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) almacenado y especifique un periodo con tiempo suficiente para descargar los registros. Si esta configuración no está establecida, Amazon RDS purga los registros binarios lo antes posible, lo que genera huecos en los registros binarios que recupera la utilidad mysqlbinlog.
En el siguiente ejemplo se define el periodo de retención en 1 día.
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
Para mostrar el valor actual, utilice el procedimiento almacenado [mysql.rds\$1show\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_show_configuration).
```
call mysql.rds_show_configuration;
```
# Archivos de registro de base de datos de Amazon RDS para Oracle
Puede obtener acceso a los registros de alertas, archivos de auditoría y archivos de seguimiento de Oracle mediante la API o la consola de Amazon RDS. Para obtener más información acerca de la visualización, descarga y vigilancia de los registros de bases de datos basados en archivos, consulte [Supervisión de archivos de registro de Amazon RDS](USER_LogAccess.md).
Los archivos de auditoría de Oracle proporcionados son los de auditoría estándar de Oracle. Amazon RDS admite la característica fine-grained auditing (FGA) de Oracle. Sin embargo, el acceso al registro no proporciona acceso a los eventos de FGA que se almacenan en la tabla `SYS.FGA_LOG$`, disponibles en la vista `DBA_FGA_AUDIT_TRAIL`.
La operación de la API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html), que muestra una lista de los archivos de registro de Oracle que están disponibles para una instancia de base de datos, no tiene en cuenta el parámetro `MaxRecords` y devuelve hasta 1000 registros. La llamada devuelve `LastWritten` como una fecha POSIX en milisegundos.
**Topics**
+ [Calendario de retención](#USER_LogAccess.Concepts.Oracle.Retention)
+ [Uso de los archivos de seguimiento de Oracle](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles)
+ [Publicación de registros de Oracle en Amazon CloudWatch Logs](#USER_LogAccess.Oracle.PublishtoCloudWatchLogs)
+ [Acceso a los registros de alertas y de oyentes](#USER_LogAccess.Concepts.Oracle.AlertLogAndListenerLog)
## Calendario de retención
El motor de base de datos de Oracle podría rotar los archivos de registros si alcanzan un tamaño muy grande. Para conservar los archivos de auditoría o de seguimiento, descárguelos. Si almacena los archivos localmente, reducirá los costos de almacenamiento de Amazon RDS y hará que haya más espacio disponible para los datos.
La tabla siguiente muestra el calendario de retención para los registros de alertas, los archivos de auditoría y los archivos de seguimiento de Oracle en Amazon RDS.
****
| Log type (Tipo de registro) | Calendario de retención |
| --- | --- |
| Registros de alertas | El registro de alertas de texto se rota diariamente con una retención de 30 días administrada por Amazon RDS. El registro de alertas XML se conserva durante al menos siete días. Puede acceder a este registro con la vista `ALERTLOG`. |
| Archivos de auditoría | El periodo de retención predeterminado para los archivos de auditoría es de siete días. Amazon RDS podría eliminar los archivos de auditoría que tienen más de siete días. |
| Archivos de seguimiento | El periodo de retención predeterminado para los archivos de seguimiento es de siete días. Amazon RDS podría eliminar los archivos de seguimiento que tienen más de siete días. |
| Registros de escuchas | El periodo de retención predeterminado para los registros de agente de escucha es de siete días. Amazon RDS podría eliminar los registros de agente de escucha que tienen más de siete días. |
**nota**
Los archivos de auditoría y archivos de seguimiento comparten la misma configuración de retención.
## Uso de los archivos de seguimiento de Oracle
Puede encontrar, a continuación, descripciones de procedimientos de Amazon RDS para crear, actualizar, obtener acceso y eliminar archivos de seguimiento.
**Topics**
+ [Descripción de archivos](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest)
+ [Generación de archivos de seguimiento y seguimiento de una sesión](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Generating)
+ [Recuperación de archivos de seguimiento](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Retrieving)
+ [Depuración de archivos de seguimiento](#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.Purging)
### Descripción de archivos
Puede usar cualquiera de estos dos procedimientos para permitir el acceso a cualquier archivo en la ruta `background_dump_dest`. El primer procedimiento actualiza una vista que contiene una lista de todos los archivos existentes en `background_dump_dest`.
```
1. EXEC rdsadmin.manage_tracefiles.refresh_tracefile_listing;
```
Una vez actualizada la vista, consulte la siguiente vista para acceder a los resultados.
```
1. SELECT * FROM rdsadmin.tracefile_listing;
```
Una alternativa al proceso anterior consiste en utilizar `FROM table` para transmitir datos no relacionales con un formato similar al de una tabla con el fin de mostrar el contenido del directorio de bases de datos.
```
1. SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('BDUMP'));
```
La consulta siguiente muestra el texto de un archivo de registro.
```
1. SELECT text FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP','alert_dbname.log.date'));
```
En una réplica de lectura, obtenga el nombre del directorio BDUMP consultando `V$DATABASE.DB_UNIQUE_NAME`. Si el nombre único es `DATABASE_B`, entonces el directorio BDUMP es `BDUMP_B`. En el ejemplo siguiente se consulta el nombre de BDUMP en una réplica y, a continuación, se utiliza este nombre para consultar el contenido de `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'));
```
### Generación de archivos de seguimiento y seguimiento de una sesión
Dado que no existen restricciones sobre `ALTER SESSION`, muchos métodos estándar para generar archivos de seguimiento en Oracle permanecen disponibles para una instancia de base de datos de Amazon RDS. Los siguientes procedimientos están disponibles para los archivos de seguimiento que necesitan un acceso mayor.
****
| Método de Oracle | Método de Amazon RDS |
| --- | --- |
| `oradebug hanganalyze 3 ` | `EXEC rdsadmin.manage_tracefiles.hanganalyze; ` |
| `oradebug dump systemstate 266 ` | `EXEC rdsadmin.manage_tracefiles.dump_systemstate;` |
Puede utilizar varios métodos estándar para realizar el seguimiento de sesiones individuales conectadas a una instancia de base de datos de Oracle en Amazon RDS. Para habilitar el seguimiento de una sesión, puede ejecutar subprogramas en paquetes PL/SQL suministrados por Oracle, como `DBMS_SESSION` y `DBMS_MONITOR`. Para obtener más información, consulte [Enabling Tracing for a Session](https://docs.oracle.com/database/121/TGSQL/tgsql_trace.htm#GUID-F872D6F9-E015-481F-80F6-8A7036A6AD29) en la documentación de Oracle.
### Recuperación de archivos de seguimiento
Puede recuperar cualquier archivo de seguimiento de `background_dump_dest` utilizando una consulta SQL estándar de una tabla externa administrada por Amazon RDS. Para utilizar este método, debe ejecutar un procedimiento para establecer la ubicación de esta tabla en el archivo de seguimiento específico.
Por ejemplo, puede utilizar la vista `rdsadmin.tracefile_listing` mencionada anteriormente para obtener la lista de los archivos de seguimiento del sistema. A continuación, puede utilizar el siguiente procedimiento para configurar la vista `tracefile_table` para que haga referencia al archivo de seguimiento que desee.
```
1. EXEC rdsadmin.manage_tracefiles.set_tracefile_table_location('CUST01_ora_3260_SYSTEMSTATE.trc');
```
En el siguiente ejemplo se crea una tabla externa en el esquema actual con la ubicación establecida en el archivo indicado. Puede recuperar el contenido en un archivo local utilizando una consulta SQL.
```
1. SPOOL /tmp/tracefile.txt
2. SELECT * FROM tracefile_table;
3. SPOOL OFF;
```
### Depuración de archivos de seguimiento
Los archivos de seguimiento pueden acumular y consumir espacio en el disco. De forma predeterminada, Amazon RDS limpia los archivos de seguimiento y registro que tienen más de siete días. Puede ver y establecer el periodo de retención de los archivos de seguimiento mediante el procedimiento `show_configuration`. Debe ejecutar el comando `SET SERVEROUTPUT ON` para ver los resultados de la configuración.
En el siguiente ejemplo se muestra el período actual de retención de archivos de seguimiento y, a continuación, se establece un período nuevo de retención para dichos archivos.
```
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.
```
Además del proceso de purga periódica, puede eliminar manualmente los archivos de `background_dump_dest`. En el siguiente ejemplo se muestra cómo purgar todos los archivos que tienen más de cinco minutos.
```
EXEC rdsadmin.manage_tracefiles.purge_tracefiles(5);
```
También puede purgar todos los archivos que coincidan con un patrón específico (si lo hace, no incluya la extensión de archivo, como .trc). En el siguiente ejemplo se muestra cómo purgar todos los archivos que comienzan por `SCHPOC1_ora_5935`.
```
1. EXEC rdsadmin.manage_tracefiles.purge_tracefiles('SCHPOC1_ora_5935');
```
## Publicación de registros de Oracle en Amazon CloudWatch Logs
Se puede configurar una instancia de base de datos de RDS para Oracle para publicar datos de registro en un grupo de registro en Registros de Amazon CloudWatch. Con CloudWatch Logs, puede analizar los datos de registro y utilizar CloudWatch para crear alarmas y ver métricas. Puede utilizar CloudWatch Logs para almacenar los registros de registros en almacenamiento de larga duración.
Amazon RDS publica cada registro de base de datos de Oracle como un flujo de base de datos independiente en el grupo de registros. Por ejemplo, si configura la función de exportación para que incluya el registro de auditoría, los datos de auditoría se almacenan en un flujo de registros de auditorías en el grupo de registros `/aws/rds/instance/my_instance/audit`. En la tabla siguiente, se resumen los requisitos para que RDS para Oracle publique registros en Registros de Amazon CloudWatch.
| Nombre de registro | Requisito | Predeterminado |
| --- | --- | --- |
| Registro de alerta | Ninguna. No puede deshabilitar este registro. | Habilitado |
| Registro de seguimiento | Defina el parámetro `trace_enabled` en `TRUE` o déjelo establecido en el valor predeterminado. | `TRUE` |
| Registro de auditoría | Establezca el parámetro `audit_trail` en uno de los siguientes valores permitidos: { none | os | db [, extended] | xml [, extended] } | `none` |
| Registro de escucha | Ninguna. No puede deshabilitar este registro. | Habilitado |
| Registro de Oracle Management Agent | Ninguna. No puede deshabilitar este registro. | Habilitado |
Este registro de Oracle Management Agent consta de los grupos de registro que se muestran en la siguiente tabla.
****
| Nombre de registro | Grupo de registro de CloudWatch |
| --- | --- |
| 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 |
Para obtener más información, consulte [Localización de archivos de seguimiento y registros de agentes de administración](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) en la documentación de Oracle.
### Consola
**Para publicar registros de base de datos de Oracle en CloudWatch Logs desde Consola de administración de AWS**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Databases (Bases de datos)** y, a continuación, seleccione la instancia de base de datos que desee modificar.
1. Elija **Modify**.
1. En la sección **Logs exports (Exportaciones de registros)**, elija los registros que desea comenzar a publicar en CloudWatch Logs.
1. Elija **Continue**, seguido de **Modify DB Instance** en la página de resumen.
### AWS CLI
Para publicar registros de Oracle, puede utilizar el comando [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) con los siguientes parámetros:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**nota**
Los cambios en la opción `--cloudwatch-logs-export-configuration` siempre se aplican a la instancia de base de datos inmediatamente. Por lo tanto, las opciones `--apply-immediately` y `--no-apply-immediately` no tienen ningún efecto.
También puede publicar registros de Oracle utilizando los siguientes comandos:
+ [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**
En el siguiente ejemplo se crea una instancia de base de datos con la publicación de registros de CloudWatch Logs habilitada. El valor `--cloudwatch-logs-export-configuration` es una matriz de cadenas JSON. Las cadenas pueden ser cualquier combinación de `alert`, `audit`, `listener` y `trace`.
Para Linux, macOS o 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
```
Para 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**
En el siguiente ejemplo se modifica una instancia de base de datos de Oracle existente para publicar archivos de registro en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `EnableLogTypes` y su valor es una matriz de cadenas con cualquier combinación de `alert`, `audit`, `listener` y `trace`.
Para Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["trace","alert","audit","listener","oemagent"]}'
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration EnableLogTypes=\"trace\",\"alert\",\"audit\",\"listener\",\"oemagent\"
```
**Example**
En el siguiente ejemplo se modifica una instancia de base de datos de Oracle existente para deshabilitar la publicación de archivos de registro en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `DisableLogTypes` y su valor es una matriz de cadenas con cualquier combinación de `alert`, `audit`, `listener` y `trace`.
Para Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--cloudwatch-logs-export-configuration '{"DisableLogTypes":["audit","listener"]}'
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--cloudwatch-logs-export-configuration DisableLogTypes=\"audit\",\"listener\"
```
### API de RDS
Puede publicar registros de base de datos Oracle con la API de RDS. Puede llamar a la acción [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) con los parámetros siguientes:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**nota**
Los cambios en el parámetro `CloudwatchLogsExportConfiguration` siempre se aplican a la instancia de base de datos inmediatamente. Por tanto, el parámetro `ApplyImmediately` no tiene efecto.
También puede publicar registros de Oracle llamando a las siguientes operaciones de la API de RDS:
+ [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)
Ejecute una de estas operaciones de la API de RDS con los siguientes parámetros:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Podrían ser necesarios otros parámetros en función de la operación de la RDS que ejecute.
## Acceso a los registros de alertas y de oyentes
Puede ver el archivo de alertas mediante la consola de Amazon RDS. También puede utilizar la siguiente instrucción SQL.
```
1. SELECT message_text FROM alertlog;
```
Acceda al registro de oyentes mediante Amazon CloudWatch Logs.
**nota**
Oracle rota los registros de alertas y de escuchas cuando superan los 10 MB, momento en el que dejan de estar disponibles en las vistas de Amazon RDS.
# Archivos de registro de base de datos de RDS para PostgreSQL
Puede supervisar los siguientes tipos de archivos de registro de :
+ Registro de PostgreSQL
+ Registro de actualización
+ Registro de errores de autenticación de base de datos de IAM
**nota**
Para habilitar los registros de errores de autenticación de base de datos de IAM, primero debe habilitar la autenticación de base de datos de IAM para la instancia de base de datos de RDS para PostgreSQL. Para obtener más información sobre la habilitación de la autenticación de bases de datos de IAM, consulte [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md).
RDS para PostgreSQL registra las actividades de la base de datos en el archivo de registro de PostgreSQL predeterminado. En el caso de una instancia de base de datos de PostgreSQL en las instalaciones, estos mensajes se almacenan localmente en `log/postgresql.log`. Para una instancia de base de datos de RDS para PostgreSQL, el archivo de registro está disponible en , la instancia de Amazon RDS. También puede acceder a estos registros a través de la Consola de administración de AWS, donde podrá verlos o descargarlos. El nivel de registro predeterminado captura los errores de inicio de sesión, los errores graves del servidor, los bloqueos y los errores de consulta.
Para obtener más información sobre cómo puede ver, descargar y observar los registros de la base de datos basados en archivos, consulte [Supervisión de archivos de registro de Amazon RDS](USER_LogAccess.md). Para saber más sobre los registros de PostgreSQL, consulte [Trabajo con registros de Amazon RDS y Aurora PostgreSQL: parte 1](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/) y [ Trabajo con registros de Amazon RDS y Aurora PostgreSQL: parte 2](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-2/).
Además de los registros estándar de PostgreSQL que se describen en este tema, RDS para PostgreSQL también admite la extensión de auditoría de PostgreSQL (`pgAudit`). La mayoría de los sectores regulados y las agencias gubernamentales necesitan mantener un registro de auditoría o registro de auditoría de los cambios realizados en los datos para cumplir con los requisitos legales. Para obtener información acerca del modo de instalar y usar pgAudit, consulte [Uso de pgAudit para registrar la actividad de la base de datos](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md).
**Topics**
+ [Parámetros de registro en RDS para PostgreSQL](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md)
+ [Activación de registro de consultas para su instancia de base de datos de RDS para PostgreSQL](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md)
+ [Publicación de registros de PostgreSQL en Amazon CloudWatch Logs](#USER_LogAccess.Concepts.PostgreSQL.PublishtoCloudWatchLogs)
# Parámetros de registro en RDS para PostgreSQL
Puede personalizar el comportamiento de registro de su instancia de base de datos de RDS para PostgreSQL modificando varios parámetros. En la siguiente tabla, puede encontrar los parámetros que afectan al tiempo que se almacenan los registros, cuándo se debe rotar el registro y si se debe generar el registro en formato CSV (valor separado por comas). También puede encontrar la salida de texto enviada a STDERR, entre otras configuraciones. Para cambiar la configuración de los parámetros que se pueden modificar, use un grupo de parámetros de base de datos personalizado para su Instancia de base de datos RDS para PostgreSQL. Para obtener más información, consulte [Grupos de parámetros de base de datos para instancias de Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md).
| Parámetro | Predeterminado | Descripción |
| --- | --- | --- |
| log\$1destination | stderr | Establece el formato de salida para el registro. El valor predeterminado es `stderr`, pero también puede especificar un valor separado por comas (CSV) agregándolo `csvlog` al ajuste. Para obtener más información, consulte [Configuración del destino del registro (`stderr`, `csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format). |
| log\$1filename | postgresql.log.%Y-%m-%d-%H | Especifica el patrón del nombre del archivo de registro. Además del valor predeterminado, este parámetro admite `postgresql.log.%Y-%m-%d` y `postgresql.log.%Y-%m-%d-%H%M` para el patrón del nombre de archivo. |
| log\$1line\$1prefix | %t:%r:%u@%d:[%p]: | Define el prefijo de cada línea de registro que se escribe en `stderr`, para anotar la hora (%t), el host remoto (%r), el usuario (%u), la base de datos (%d) y el ID del proceso (%p). |
| log\$1rotation\$1age | 60 | Minutos después de los cuales el archivo de registro rota automáticamente. Puede cambiar este valor dentro del intervalo de 1 a 1440 minutos. Para obtener más información, consulte [Configuración de la rotación del archivo de registro](#USER_LogAccess.Concepts.PostgreSQL.log_rotation). |
| log\$1rotation\$1size | – | El tamaño (kB) con el que se rota automáticamente el registro. De forma predeterminada, este parámetro no se usa porque los registros rotan en función del parámetro `log_rotation_age`. Para obtener más información, consulte [Configuración de la rotación del archivo de registro](#USER_LogAccess.Concepts.PostgreSQL.log_rotation). |
| rds.log\$1retention\$1period | 4320 | Los registros de PostgreSQL que superan el número de minutos especificado se eliminarán. El valor predeterminado de 4320 minutos elimina los archivos de registro transcurridos 3 días. Para obtener más información, consulte [Configuración de periodo de retención de registros](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period). |
Para identificar problemas de aplicaciones, puede buscar errores de consulta, errores de inicio de sesión, interbloqueos y errores de servidor graves en el registro. Por ejemplo, suponga que ha convertido una aplicación heredada de Oracle a Amazon RDS PostgreSQL, pero no todas las consultas se han convertido correctamente. Estas consultas con formato incorrecto generan mensajes de error que se pueden encontrar en los registros para ayudar a identificar los problemas. Para más información sobre el registro de consultas, consulte [Activación de registro de consultas para su instancia de base de datos de RDS para PostgreSQL](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md).
En los temas siguientes, encontrará información sobre cómo configurar varios parámetros que controlan los detalles básicos de sus registros de PostgreSQL.
**Topics**
+ [Configuración de periodo de retención de registros](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period)
+ [Configuración de la rotación del archivo de registro](#USER_LogAccess.Concepts.PostgreSQL.log_rotation)
+ [Configuración del destino del registro (`stderr`, `csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format)
+ [Descripción del parámetro log\$1line\$1prefix](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix)
## Configuración de periodo de retención de registros
El parámetro `rds.log_retention_period` especifica cuánto tiempo su instancia de base de datos de RDS para PostgreSQL mantiene sus archivos de registro. La configuración predeterminada es de 3 días (4320 minutos), pero puede configurarla entre 1 día (1440 minutos) y 7 días (10 080 minutos). Asegúrese de que su instancia de base de datos de RDS para PostgreSQL tenga suficiente almacenamiento para almacenar los archivos de registro durante ese período de tiempo.
Le recomendamos que publique sus registros de forma rutinaria en Registros de Amazon CloudWatch, de modo que pueda ver y analizar los datos del sistema mucho tiempo después de que los registros se hayan eliminado de su . Instancia de base de datos RDS para PostgreSQL. Para obtener más información, consulte [Publicación de registros de PostgreSQL en Amazon CloudWatch Logs](USER_LogAccess.Concepts.PostgreSQL.md#USER_LogAccess.Concepts.PostgreSQL.PublishtoCloudWatchLogs).
## Configuración de la rotación del archivo de registro
Amazon RDS crea los nuevos archivos de registro cada hora de forma predeterminada. El tiempo lo controla el parámetro `log_rotation_age`. Este parámetro tiene un valor predeterminado de 60 (minutos), pero puede configurarlo entre 1 minuto y 24 horas (1440 minutos). Cuando llega el momento de la rotación, se crea un nuevo archivo de registro distinto. Al archivo se le asigna un nombre de conformidad con el patrón especificado por el parámetro `log_filename`.
Los archivos de registro también se pueden rotar según su tamaño, tal y como se especifica en el parámetro `log_rotation_size`. Este parámetro especifica que el registro debe rotarse cuando alcance el tamaño especificado (en kilobytes). Para una instancia de base de datos de RDS para PostgreSQL, `log_rotation_size` no está establecido, es decir, no se ha especificado ningún valor. Sin embargo, puede establecer el parámetro entre 0 y 2 097 151 kB (kilobytes).
Los nombres de archivo de registro se basan en el patrón de nombre de archivo especificado en el parámetro `log_filename`. La configuración disponible para este parámetro es la siguiente:
+ `postgresql.log.%Y-%m-%d`: formato predeterminado para el nombre del archivo de registro. Incluye el año, el mes y la fecha en el nombre del archivo de registro.
+ `postgresql.log.%Y-%m-%d-%H`: incluye la hora en el formato del nombre del archivo de registro.
Para obtener más información, consulte [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) y [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) en la documentación de PostgreSQL.
## Configuración del destino del registro (`stderr`, `csvlog`)
De forma predeterminada, Amazon RDS PostgreSQL genera registros en formato de error estándar (stderr). Esta es la configuración predeterminada del parámetro `log_destination`. Cada mensaje lleva el prefijo según el patrón especificado en el parámetro `log_line_prefix`. Para obtener más información, consulte [Descripción del parámetro log\$1line\$1prefix](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix).
RDS para PostgreSQL también puede generar los registros con el formato `csvlog`. `csvlog` resulta útil para analizar los datos de registro como valores separados con coma (CSV). Por ejemplo, supongamos que utiliza la extensión `log_fdw` para trabajar con los registros como tablas extranjeras. La tabla extranjera creada en los archivos de registro `stderr` contienen una sola columna con datos de eventos de registro. Al añadir `csvlog` al parámetro `log_destination`, se obtiene el archivo de registro en formato CSV con demarcaciones para las múltiples columnas de la tabla externa. Esto le permite ordenar y analizar los registros con mayor facilidad. Para obtener información sobre cómo usar `log_fdw` con `csvlog`, consulte [Uso de la extensión log\$1fdw para acceder al registro de base de datos mediante SQL](CHAP_PostgreSQL.Extensions.log_fdw.md).
Si especifica `csvlog` para este parámetro, tenga en cuenta que se generan los archivos `stderr` y `csvlog`. Asegúrese de supervisar el almacenamiento consumido por los registros, teniendo en cuenta `rds.log_retention_period` y otras configuraciones que afectan al almacenamiento de registros y a los análisis. Usar `stderr` y `csvlog` duplica de sobra el almacenamiento consumido por los registros.
Si añade `csvlog` a `log_destination` y quiere volver solo a `stderr` solo, debe restablecer el parámetro. Para ello, utilice la consola de Amazon RDS y abra el grupo de parámetros de la base de datos personalizado para su instancia. Elija el parámetro `log_destination`, elija **Edit parameter** (Editar parámetro) y, a continuación, seleccione **Reset** (Restablecer).
Para obtener más información acerca de la configuración de los registros, consulte la entrada del blog sobre [trabajar con registros de Amazon RDS y Aurora PostgreSQL: parte 1](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/).
## Descripción del parámetro log\$1line\$1prefix
El formato de registro de `stderr` prefija cada mensaje de registro con los detalles especificados por el parámetro `log_line_prefix`. El valor predeterminado es:
```
%t:%r:%u@%d:[%p]:t
```
A partir de la versión 16 de Aurora PostgreSQL, también puede elegir:
```
%m:%r:%u@%d:[%p]:%l:%e:%s:%v:%x:%c:%q%a
```
Cada entrada de registro enviada a stderr incluye la siguiente información en función del valor seleccionado:
+ `%t`: hora de entrada del registro sin milisegundos
+ `%m`: hora de entrada del registro con milisegundos
+ `%r`: dirección del host remoto.
+ `%u@%d`: nombre de usuario @ nombre de base de datos.
+ `[%p]`: ID del proceso si está disponible.
+ `%l`: Número de línea de registro por sesión
+ `%e`: Código de error SQL
+ `%s`: Marca temporal de inicio de proceso
+ `%v`: ID de transacción virtual
+ `%x`: ID de transacción
+ `%c`: ID de sesión
+ `%q`: Terminador que no sea de sesión
+ `%a`: Nombre de la aplicación
# Activación de registro de consultas para su instancia de base de datos de RDS para PostgreSQL
Puede recopilar información más detallada sobre las actividades de la base de datos, incluidas las consultas, las consultas en espera de bloqueos, los puntos de control y muchos otros detalles configurando algunos de los parámetros que se enumeran en la tabla siguiente. Este tema se centra en el registro de consultas.
| Parámetro | Predeterminado | Descripción |
| --- | --- | --- |
| log\$1connections | – | Registra cada conexión realizada correctamente. |
| log\$1disconnections | – | Registra el final de cada sesión y su duración. |
| log\$1checkpoints | 1 | Registra cada punto de comprobación. |
| log\$1lock\$1waits | – | Registra las esperas de bloqueo largas. Por defecto, este parámetro no está configurado. |
| log\$1min\$1duration\$1sample | – | (ms) Establece el tiempo mínimo de ejecución a partir del cual se registra una muestra de instrucciones. El tamaño de la muestra se establece mediante el parámetro log\$1statement\$1sample\$1rate. |
| log\$1min\$1duration\$1statement | – | Se registra cualquier instrucción SQL que se ejecute al menos durante el período de tiempo especificado o durante más tiempo. Por defecto, este parámetro no está configurado. Si se activa este parámetro, puede resultar más sencillo encontrar consultas no optimizadas. |
| log\$1statement | – | Define el tipo de declaraciones que se deben registrar. De forma predeterminada, este parámetro no está configurado, pero puede cambiarlo a `all`, `ddl` o `mod` para especificar los tipos de instrucciones SQL que desea que se registren. Si especifica algo que no sea `none` para este parámetro, también debe adoptar medidas adicionales para evitar que las contraseñas aparezcan en los archivos de registro. Para obtener más información, consulte [Mitigar el riesgo de exposición de contraseñas al utilizar el registro de consultasMitigar el riesgo de exposición de contraseñas](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk). |
| log\$1statement\$1sample\$1rate | – | El porcentaje de sentencias que superan el tiempo especificado en `log_min_duration_sample` se registrarán, expresado como un valor de coma flotante entre 0.0 y 1.0. |
| log\$1statement\$1stats | – | Escribe las estadísticas de rendimiento acumulativas en el registro del servidor. |
## Uso del registro para encontrar consultas con un rendimiento lento
Puede registrar instrucciones y consultas SQL para ayudar a encontrar consultas que se den con resultados lentos. Para activar esta función, modifique la configuración de los parámetros `log_statement` y `log_min_duration`, tal como se describe en esta sección. Antes de activar el registro de consultas para su instancia de base de datos de RDS para PostgreSQL, debe conocer la posible exposición de contraseñas en los registros y cómo mitigar los riesgos. Para obtener más información, consulte [Mitigar el riesgo de exposición de contraseñas al utilizar el registro de consultasMitigar el riesgo de exposición de contraseñas](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk).
A continuación, encontrará información de referencia sobre los parámetros `log_statement` y `log_min_duration`.log\$1statement
Este parámetro especifica el tipo de instrucciones SQL que deben enviarse al registro. El valor predeterminado es `none`. Si cambia este parámetro a `all`, `ddl` o `mod`, asegúrese de aplicar algunas de las medidas recomendadas para reducir el riesgo de exponer las contraseñas en los registros. Para obtener más información, consulte [Mitigar el riesgo de exposición de contraseñas al utilizar el registro de consultasMitigar el riesgo de exposición de contraseñas](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk).
**all**
Registra todas las instrucciones. Para depuración, se recomienda esta configuración.
**ddl**
Registra todas las instrucciones del lenguaje de definición de datos (DDL), como CREATE, ALTER, DROP, etc.
**MOD**
Registra todas las instrucciones DDL y las instrucciones de lenguaje de manipulación de datos (DML), como INSERT, UPDATE y DELETE, que modifican los datos.
**none**
No se registra ninguna instrucción SQL. Recomendamos esta configuración para evitar el riesgo de exponer las contraseñas en los registros.log\$1min\$1duration\$1statement
Se registra cualquier instrucción SQL que se ejecute al menos durante el período de tiempo especificado o durante más tiempo. Por defecto, este parámetro no está configurado. Si se activa este parámetro, puede resultar más sencillo encontrar consultas no optimizadas.
**–1–2147483647**
El número de milisegundos (ms) de tiempo de ejecución durante los cuales se registra una instrucción.
**Para configurar el registro de consultas**
Estos pasos suponen que su instancia de base de datos de RDS para PostgreSQL utiliza un grupo personalizado de parámetros de base de datos.
1. Establezca el parámetro `log_statement` como `all`. En el siguiente ejemplo se muestra la información que se escribe en el archivo con esta configuración de parámetros.
```
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. Establezca el parámetro `log_min_duration_statement`. En el siguiente ejemplo se muestra la información que se escribe en el archivo `postgresql.log`cuando se establece el parámetro en:`1`
Se registran las consultas que superan la duración especificada en el parámetro `log_min_duration_statement`. A continuación se muestra un ejemplo. Puede ver el archivo de registro de su instancia de base de datos de RDS para PostgreSQL en la consola de 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 ----------------------
```
### Mitigar el riesgo de exposición de contraseñas al utilizar el registro de consultas
Le recomendamos que mantenga `log_statement` establecido en `none` para evitar exponer las contraseñas. Si establece `log_statement` en `all`, `ddl` o `mod`, le recomendamos que siga uno o más de los siguientes pasos.
+ Para el cliente, cifre la información confidencial. Para obtener más información, consulte [Encryption Options](https://www.postgresql.org/docs/current/encryption-options.html) en la documentación de PostgreSQL. Utilice las opciones `ENCRYPTED` (y `UNENCRYPTED`) de las instrucciones `CREATE` y `ALTER`. Para obtener más información, consulte [CREATE USER](https://www.postgresql.org/docs/current/sql-createuser.html) en la documentación de PostgreSQL.
+ Para su instancia de base de datos de RDS para PostgreSQL, configure y utilice la extensión de auditoría de PostgreSQL (pgAudit). Esta extensión redacta la información confidencial de las instrucciones CREATE y ALTER enviadas al registro. Para obtener más información, consulte [Uso de pgAudit para registrar la actividad de la base de datos](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md).
+ Restrinja el acceso a los Registros de CloudWatch.
+ Utilice mecanismos de autenticación más sólidos como IAM.
## Publicación de registros de PostgreSQL en Amazon CloudWatch Logs
Para almacenar los registros de PostgreSQL en un almacenamiento de larga duración, se puede usar Amazon CloudWatch Logs. Con CloudWatch Logs, también puede realizar análisis en tiempo real de los datos de registro y utilizar CloudWatch para ver métricas y crear alarmas. Por ejemplo, si establece `log_statement` en `ddl`, puede configurar una alarma para que avise siempre que se ejecute una instrucción DDL. Puede elegir cargar los registros de PostgreSQL en CloudWatch Logs durante el proceso de creación de su instancia de base de datos de RDS para PostgreSQL. Si optó por no subir registros en ese momento, puedes modificar tu instancia más adelante para empezar a subir los registros a partir de ese momento. En otras palabras, los registros existentes no se cargan. Solo los registros nuevos se cargan a medida que se crean en la instancia de base de datos de RDS para PostgreSQL modificada.
Todas las versiones de RDS para PostgreSQL disponibles actualmente permiten publicar archivos de registro en CloudWatch Logs. Para obtener información detallada sobre la versión, consulte las [actualizaciones de Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-versions.html) en las *notas de la versión de Amazon RDS para PostgreSQL*.
Para trabajar con CloudWatch Logs, configure la instancia de base de datos de RDS para PostgreSQL para que publique datos de registro en un grupo de registros.
Puede publicar los siguientes tipos de registro en CloudWatch Logs para RDS para PostgreSQL:
+ Registro de PostgreSQL
+ Registro de actualización
+ Registro de errores de autenticación de base de datos de IAM
Tras completar la configuración, Amazon RDS publica los eventos de registro en los flujos de registro con un grupo de registros de CloudWatch. Por ejemplo, los datos de registro de PostgreSQL se almacenan en el grupo de registro `/aws/rds/instance/my_instance/postgresql`. Para ver los registros, abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
### Consola
**Para publicar registros de base de datos PostgreSQL en CloudWatch Logs con la consola**
1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, seleccione **Databases (Bases de datos)**.
1. Seleccione la instancia de base de datos que quiera modificar y seleccione **Modify (Modificar)**.
1. En la sección **Logs exports (Exportaciones de registros)**, elija los registros que desea comenzar a publicar en CloudWatch Logs.
La sección **Log exports (Exportaciones de registros)** está disponible para versiones de PostgreSQL que admiten la publicación en CloudWatch Logs.
1. Elija **Continue**, seguido de **Modify DB Instance** en la página de resumen.
### AWS CLI
Puede publicar registros de PostgreSQL con la AWS CLI. Puede llamar al comando [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) con los parámetros siguientes:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**nota**
Los cambios en la opción `--cloudwatch-logs-export-configuration` siempre se aplican a la instancia de base de datos inmediatamente. Por lo tanto, las opciones `--apply-immediately` y `--no-apply-immediately` no tienen ningún efecto.
También puede publicar registros de PostgreSQL llamando a los siguientes comandos de la 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-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
Ejecute uno de estos comandos de la CLI con las siguientes opciones:
+ `--db-instance-identifier`
+ `--enable-cloudwatch-logs-exports`
+ `--db-instance-class`
+ `--engine`
Podrían ser necesarias otras opciones en función del comando de la CLI que ejecute.
**Example Modificar una instancia para publicar registros en CloudWatch Logs**
En el siguiente ejemplo se modifica una instancia de base de datos de PostgreSQL existente para publicar archivos de registro en CloudWatch Logs. El valor `--cloudwatch-logs-export-configuration` es un objeto JSON. La clave de este objeto es `EnableLogTypes` y su valor es una matriz de cadenas con cualquier combinación de `postgresql` y `upgrade`.
Para Linux, macOS o Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql", "upgrade"]}'
```
Para Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["postgresql","upgrade"]}'
```
**Example Crear una instancia para publicar registros en CloudWatch Logs**
En el siguiente ejemplo se crea una instancia de base de datos PostgreSQL y se publican archivos de registro en CloudWatch Logs. El valor `--enable-cloudwatch-logs-exports` es una matriz de cadenas JSON. Las cadenas pueden ser cualquier combinación de `postgresql` y `upgrade`.
Para Linux, macOS o 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
```
Para 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
```
### API de RDS
Puede publicar registros de PostgreSQL con la API de RDS. Puede llamar a la acción [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) con los parámetros siguientes:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**nota**
Los cambios en el parámetro `CloudwatchLogsExportConfiguration` siempre se aplican a la instancia de base de datos inmediatamente. Por tanto, el parámetro `ApplyImmediately` no tiene efecto.
También puede publicar registros de PostgreSQL llamando a las siguientes operaciones de la API de RDS:
+ [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)
Ejecute una de estas operaciones de la API de RDS con los siguientes parámetros:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Podrían ser necesarios otros parámetros en función de la operación que ejecute.