Uso de funciones de orafce Uso de pgactive para crear la replicación activa-activa Reducción de la sobrecarga con la extensión pg_repack Actualización y uso de PLV8 Uso de PL/Rust para escribir funciones en lenguaje Rust

Uso de extensiones PostgreSQL con Amazon RDS para PostgreSQL

Puede ampliar la funcionalidad de PostgreSQL instalando una variedad de extensiones y módulos. Por ejemplo, para trabajar con datos espaciales, puede instalar y utilizar la extensión de PostGIS. Para obtener más información, consulte Administración de datos espaciales con la extensión PostGIS. Otro ejemplo, si desea mejorar la entrada de datos para tablas muy grandes, puede considerar la posibilidad de particionar los datos con la extensión pg_partman. Para obtener más información, consulte Administración de las particiones de PostgreSQL con la extensión pg_partman.

nota

A partir de la versión 14.5 de RDS para PostgreSQL, RDS para PostgreSQL admite Extensiones de lenguaje de confianza para PostgreSQL. Esta función se implementa como la extensión pg_tle, que puede añadir a su instancia de base de datos de RDS para PostgreSQL. Con esta extensión, los desarrolladores pueden crear sus propias extensiones de PostgreSQL en un entorno seguro que simplifica los requisitos de instalación y configuración. Para obtener más información, consulte Uso de Extensiones de lenguaje de confianza para PostgreSQL.

En algunos casos, en lugar de instalar una extensión, puede agregar un módulo específico a la lista de shared_preload_libraries en el grupo de parámetros de la base de datos personalizado de la instancia de base de datos de RDS para PostgreSQL. Por lo general, el grupo de parámetros del clúster de base de datos predeterminado solo carga las pg_stat_statements, pero hay varios otros módulos disponibles para agregarlos a la lista. Por ejemplo, puede añadir la capacidad de programación añadiendo el módulopg_cron, tal como se detalla en Programación de mantenimiento con la extensión pg_cron de PostgreSQL. Como otro ejemplo, puede registrar los planes de ejecución de consultas cargando el módulo auto_explain. Para obtener más información, consulte Logging execution plans of queries (Registro de los planes de ejecución de las consultas) en el centro de conocimiento de AWS.

Según la versión de RDS para PostgreSQL, la instalación de una extensión podría requerir permisos rds_superuser, de la siguiente forma:

Para versiones 12 y anteriores de RDS para PostgreSQL, la instalación de extensiones requiere privilegios de rds_superuser.
Para la versión 13 y superiores de RDS para PostgreSQL , los usuarios (roles) con permisos de creación en una instancia de base de datos determinada pueden instalar y utilizar cualquier extensión de confianza. Para obtener una lista de las extensiones de confianza, consulte Extensiones de confianza de PostgreSQL.

También puede especificar con precisión qué extensiones se pueden instalar en la instancia de base de datos de RDS para PostgreSQL, enumerándolas en el parámetro rds.allowed_extensions. Para obtener más información, consulte Restringir la instalación de extensiones de PostgreSQL.

Para obtener más información acerca del rol rds_superuser, consulte Descripción de los roles y permisos de PostgreSQL.

Temas

Uso de las funciones de la extensión orafce

La extensión orafce brinda funciones y operadores que emulan un subconjunto de funciones y paquetes de una base de datos de Oracle. La extensión orafce facilita la realización de la portabilidad de una aplicación Oracle a PostgreSQL. Esta extensión es compatible con la versión 9.6.6 y posteriores de RDS for PostgreSQL. Para obtener más información sobre orafce, consulte orafce en GitHub.

nota

RDS for PostgreSQL no admite el paquete utl_file que forma parte de la extensión orafce. Esto se debe a que las funciones del esquema utl_file proporcionan operaciones de lectura y escritura con archivos de texto del sistema operativo, lo que requiere el acceso de los superusuarios al host subyacente. Como servicio administrado, RDS for PostgreSQL no brinda acceso al host.

Para usar la extensión orafce

Conéctese a la instancia de base de datos con el nombre de usuario principal que utilizó para crear la instancia de base de datos.

Si desea activar orafce para una base de datos diferente en la misma instancia de base de datos, utilice el comando psql /c dbname. Con este comando, cambia de la base de datos principal después de iniciar la conexión.
Active la extensión orafce con la instrucción CREATE EXTENSION.
```
CREATE EXTENSION orafce;
```
Transfiera la propiedad del esquema de Oracle al rol rds_superuser con la instrucción ALTER SCHEMA.
```
ALTER SCHEMA oracle OWNER TO rds_superuser;
```
Si desea ver la lista de propietarios del esquema de Oracle, utilice el comando \dn de psql.

Uso de pgactive para admitir la replicación activa-activa

La extensión pgactive utiliza la replicación activa-activa para admitir y coordinar las operaciones de escritura en varias bases de datos de RDS para PostgreSQL. Amazon RDS para PostgreSQL admite la extensión pgactive en las siguientes versiones:

RDS para PostgreSQL 16.1 y versiones 16 posteriores
RDS para PostgreSQL 15.2-R2 y versiones 15 posteriores
RDS para PostgreSQL 14.10 y versiones 14 posteriores
RDS para PostgreSQL 13.13 y versiones 13 posteriores
RDS para PostgreSQL 12.17 y versiones 12 posteriores
RDS para PostgreSQL 11.22

nota

Cuando hay operaciones de escritura en más de una base de datos en una configuración de replicación, es posible que surjan conflictos. Para obtener más información, consulte Gestión de conflictos en la replicación activa-activa

Temas

Inicialización de la capacidad de la extensión pgactive
Configuración de la replicación activa-activa para las instancias de base de datos de RDS para PostgreSQL
Gestión de conflictos en la replicación activa-activa
Gestión de secuencias en la replicación activa-activa
Referencia de parámetros para la extensión pgactive
Medición del retraso de réplica entre miembros de pgactive
Limitaciones de la extensión pgactive

Inicialización de la capacidad de la extensión pgactive

Para inicializar la capacidad de la extensión pgactive en la instancia de base de datos de RDS para PostgreSQL, defina el valor del parámetro rds.enable_pgactive en 1 y, a continuación, cree la extensión en la base de datos. Al hacerlo, se activan automáticamente los parámetros rds.logical_replication track_commit_timestamp y se establece el valor de wal_level en logical.

Debe tener permisos como el rol rds_superuser para realizar estas tareas.

Puede usar la AWS Management Console o la AWS CLI para crear las instancias de base de datos de RDS para PostgreSQL necesarias. En los pasos siguientes, se supone que la instancia de base de datos de RDS para PostgreSQL está asociada a un grupo de parámetros de base de datos personalizado. Para obtener información sobre la creación de un grupo de parámetros de base de datos personalizado, consulte Working with parameter groups (Trabajar con grupos de parámetros).

Para inicializar la capacidad de la extensión pgactive

Inicie sesión en la AWS Management Console y abra la consola de Amazon RDS en https://console.aws.amazon.com/rds/.
En el panel de navegación, elija su instancia de base de datos de RDS para PostgreSQL.
Abra la pestaña Configuración para su instancia de base de datos de RDS para PostgreSQL. En los detalles de la instancia, busque el enlace Grupo de parámetros de instancia de base de datos.
Elija el enlace para abrir los parámetros personalizados asociados a la instancia de base de datos de RDS para PostgreSQL.
Busque el parámetro rds.enable_pgactive y configúrelo en 1 para inicializar la capacidad pgactive.
Elija Guardar cambios.
En el panel de navegación de la consola de Amazon RDS, elija Bases de datos.
Seleccione su instancia de base de datos de RDS para PostgreSQL y, a continuación, seleccione Reinicio en el menú Acciones.
Confirme el reinicio de la instancia de base de datos para que sus cambios se apliquen.
Cuando la instancia de base de datos esté disponible, podrá utilizar psql o cualquier otro cliente de PostgreSQL para conectarse a la instancia de base de datos de RDS para PostgreSQL.

En el siguiente ejemplo, se asume que su instancia de base de datos de RDS para PostgreSQL tiene una base de datos predeterminada llamada postgres.
```
psql --host=mydb.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=master username --password --dbname=postgres
```
Para comprobar que pgactive esté inicializado, ejecute el siguiente comando.
```
postgres=>SELECT setting ~ 'pgactive' 
FROM pg_catalog.pg_settings
WHERE name = 'shared_preload_libraries';
```
Si pgactive está en shared_preload_libraries, el comando anterior devolverá lo siguiente:
```
?column? 
----------
 t
```
Cree la extensión de la siguiente manera.
```
postgres=> CREATE EXTENSION pgactive;
```

Para inicializar la capacidad de la extensión pgactive

Para inicializar pgactive utilizando la AWS CLI, llame a la operación modify-db-parameter-group para modificar determinados parámetros de su grupo de parámetros personalizado, tal como se muestra en el siguiente procedimiento.

Utilice el siguiente comando de la AWS CLI para configurar rds.enable_pgactive en 1 para inicializar la capacidad pgactive de la instancia de base de datos de RDS para PostgreSQL.


postgres=>aws rds modify-db-parameter-group \
   --db-parameter-group-name custom-param-group-name \
   --parameters "ParameterName=rds.enable_pgactive,ParameterValue=1,ApplyMethod=pending-reboot" \
   --region aws-region

Utilice el siguiente comando de la AWS CLI para reiniciar la instancia de base de datos de RDS para PostgreSQL para que se inicialice la biblioteca de pgactive.
```
aws rds reboot-db-instance \
    --db-instance-identifier your-instance \
    --region aws-region
```

Cuando la instancia esté disponible, use psql para conectarse a la instancia de base de datos de RDS para PostgreSQL.


psql --host=mydb.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=master user --password --dbname=postgres

Cree la extensión de la siguiente manera.
```
postgres=> CREATE EXTENSION pgactive;
```

Configuración de la replicación activa-activa para las instancias de base de datos de RDS para PostgreSQL

En el siguiente procedimiento, se muestra cómo iniciar la replicación activa-activa entre dos instancias de base de datos de RDS para PostgreSQL que ejecutan PostgreSQL 15.4 o posterior en la misma región. Para ejecutar el ejemplo de alta disponibilidad multirregión, debe implementar instancias de Amazon RDS para PostgreSQL en dos regiones diferentes y configurar la interconexión de VPC. Para obtener más información, consulte Interconexión de VPC.

nota

El envío de tráfico entre varias regiones puede conllevar costes adicionales.

En estos pasos, se asume que la instancia de base de datos de RDS para PostgreSQL se ha configurado con la extensión pgactive. Para obtener más información, consulte Inicialización de la capacidad de la extensión pgactive.

Para configurar la primera instancia de base de datos de RDS para PostgreSQL con la extensión `pgactive`

En el siguiente ejemplo, se ilustra cómo se crea el grupo pgactive, junto con otros pasos necesarios para crear la extensión pgactive en la instancia de base de datos de RDS para PostgreSQL.

Utilice psql u otra herramienta de cliente para conectarse a su primera instancia de base de datos de RDS para PostgreSQL.


psql --host=firstinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=master username --password --dbname=postgres

Cree una base de datos en la instancia de RDS para PostgreSQL mediante el siguiente comando:
```
postgres=> CREATE DATABASE app;
```
Cambie la conexión a la nueva base de datos mediante el siguiente comando:
```
\c app
```

Para comprobar si el parámetro shared_preload_libraries contiene pgactive, ejecute el siguiente comando:


app=>SELECT setting ~ 'pgactive' FROM pg_catalog.pg_settings WHERE name = 'shared_preload_libraries';



 ?column? 
----------
 t

Cree y rellene una tabla de ejemplo utilizando las siguientes instrucciones SQL:

Cree una tabla de ejemplo con la siguiente instrucción SQL.


app=> CREATE SCHEMA inventory;
CREATE TABLE inventory.products (
id int PRIMARY KEY, product_name text NOT NULL,
created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP);

Rellene la tabla con algunos datos de ejemplo mediante la siguiente instrucción SQL.


app=> INSERT INTO inventory.products (id, product_name)
VALUES (1, 'soap'), (2, 'shampoo'), (3, 'conditioner');

Compruebe que los datos existen en la tabla mediante la siguiente instrucción SQL.
```
 app=>SELECT count(*) FROM inventory.products;

 count
-------
 3
```

Cree la extensión pgactive en la base de datos existente.
```
app=> CREATE EXTENSION pgactive;
```
Cree e inicialice el grupo pgactive mediante los siguientes comandos:
```
app=> SELECT pgactive.pgactive_create_group(
    node_name := 'node1-app',
    node_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=master username password=PASSWORD');
```
node1-app es el nombre que se asigna para identificar de forma exclusiva un nodo del grupo pgactive.

nota
Para realizar este paso correctamente en una instancia de base de datos de acceso público, debe activar el parámetro rds.custom_dns_resolution configurándolo en 1.
Para comprobar si la instancia de base de datos está lista, utilice el siguiente comando:
```
app=> SELECT pgactive.pgactive_wait_for_node_ready();
```
Si el comando se ejecuta correctamente, verá el siguiente resultado:
```
pgactive_wait_for_node_ready 
------------------------------ 
(1 row)
```

Para configurar la segunda instancia de RDS para PostgreSQL y unirla al grupo `pgactive`

En el siguiente ejemplo, se ilustra cómo puede unir una instancia de base de datos de RDS para PostgreSQL al grupo pgactive, junto con otros pasos necesarios para crear la extensión pgactive en la instancia de base de datos.

En estos pasos se asume que otras instancias de base de datos de RDS para PostgreSQL se han configurado con la extensión pgactive. Para obtener más información, consulte Inicialización de la capacidad de la extensión pgactive.

Utilice psql para conectarse a la instancia en la que desea recibir actualizaciones del publicador.


psql --host=secondinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=master username --password --dbname=postgres

Cree una base de datos en la segunda instancia de base de datos de RDS para PostgreSQL mediante el siguiente comando:
```
postgres=> CREATE DATABASE app;
```
Cambie la conexión a la nueva base de datos mediante el siguiente comando:
```
\c app
```
Cree la extensión pgactive en la base de datos existente.
```
app=> CREATE EXTENSION pgactive;
```

Una la segunda instancia de base de datos de RDS para PostgreSQL al grupo pgactive de la siguiente manera.


app=> SELECT pgactive.pgactive_join_group(
node_name := 'node2-app',
node_dsn := 'dbname=app host=secondinstance.111122223333.aws-region.rds.amazonaws.com user=master username password=PASSWORD',
join_using_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD');

node2-app es el nombre que se asigna para identificar de forma exclusiva un nodo del grupo pgactive.

Para comprobar si la instancia de base de datos está lista, utilice el siguiente comando:


app=> SELECT pgactive.pgactive_wait_for_node_ready();

Si el comando se ejecuta correctamente, verá el siguiente resultado:



pgactive_wait_for_node_ready 
------------------------------ 
(1 row)

Si la primera base de datos de RDS para PostgreSQL es relativamente grande, puede ver que pgactive.pgactive_wait_for_node_ready()emite el informe de progreso de la operación de restauración. El resultado tiene un aspecto similar al siguiente:


NOTICE:  restoring database 'app', 6% of 7483 MB complete
NOTICE:  restoring database 'app', 42% of 7483 MB complete
NOTICE:  restoring database 'app', 77% of 7483 MB complete
NOTICE:  restoring database 'app', 98% of 7483 MB complete
NOTICE:  successfully restored database 'app' from node node1-app in 00:04:12.274956
 pgactive_wait_for_node_ready 
------------------------------ 
(1 row)

A partir de este momento, pgactive sincroniza los datos entre las dos instancias de base de datos.

Puede utilizar el siguiente comando para comprobar si la base de datos de la segunda instancia de base de datos contiene los datos:
```
app=> SELECT count(*) FROM inventory.products;
```
Si los datos se sincronizan correctamente, verá el siguiente resultado:
```
 count
-------
 3
```

Ejecute el siguiente comando para insertar nuevos valores:


app=> INSERT INTO inventory.products (id, product_name) VALUES ('lotion');

Conéctese a la base de datos de la primera instancia de base de datos y ejecute la siguiente consulta:
```
app=> SELECT count(*) FROM inventory.products;
```
Si se inicializa la replicación activa-activa, el resultado es similar al siguiente:
```
count
-------
 4
```

Para separar y eliminar una instancia de base de datos del grupo `pgactive`

Para separar y eliminar una instancia de base de datos del grupo pgactive, siga estos pasos:

Puede separar la segunda instancia de base de datos de la primera instancia de base de datos mediante el siguiente comando:
```
app=> SELECT * FROM pgactive.pgactive_detach_nodes(ARRAY[‘node2-app']);
```
Elimine la extensión pgactive de la segunda instancia de base de datos mediante el siguiente comando:
```
app=> SELECT * FROM pgactive.pgactive_remove();
```
Para eliminar la extensión a la fuerza:
```
app=> SELECT * FROM pgactive.pgactive_remove(true);
```
Suelte la extensión con el siguiente comando:
```
app=> DROP EXTENSION pgactive;
```

Gestión de conflictos en la replicación activa-activa

La extensión pgactive funciona por base de datos y no por clúster. Cada instancia de base de datos que utiliza pgactive es una instancia independiente y puede aceptar cambios de datos de cualquier fuente. Cuando se envía un cambio a una instancia de base de datos, PostgreSQL lo confirma localmente y, a continuación, utiliza pgactive para replicar el cambio de forma asíncrona en otras instancias de base de datos. Cuando dos instancias de base de datos de PostgreSQL actualizan el mismo registro prácticamente al mismo tiempo, puede producirse un conflicto.

La extensión pgactive proporciona mecanismos para la detección y la resolución automática de conflictos. Realiza un seguimiento de la marca de tiempo en que se confirmó la transacción en ambas instancias de base de datos y aplica automáticamente el cambio con la última marca de tiempo. La extensión pgactive también registra cuando se produce un conflicto en la tabla pgactive.pgactive_conflict_history.

El pgactive.pgactive_conflict_history seguirá creciendo. Puede definir una política de depuración. Esto se puede hacer borrando algunos registros de forma regular o definiendo un esquema de partición para esta relación (y, luego, separando, descartando o truncando las particiones de interés). Para implementar la política de depuración de forma regular, una opción es usar la extensión pg_cron Consulte la siguiente información con un ejemplo para la tabla de historial de pg_cron Programación de mantenimiento con la extensión pg_cron de PostgreSQL.

Gestión de secuencias en la replicación activa-activa

Una instancia de base de datos de RDS para PostgreSQL con la extensión pgactive utiliza dos mecanismos de secuencia diferentes para generar valores únicos.

Secuencias globales

Para usar una secuencia global, cree una secuencia local con la instrucción CREATE SEQUENCE. Utilice pgactive.pgactive_snowflake_id_nextval(seqname) en lugar de usingnextval(seqname) para obtener el siguiente valor único de la secuencia.

En el siguiente ejemplo se crea una secuencia global.


postgres=> CREATE TABLE gstest (
      id bigint primary key,
      parrot text
    );


postgres=>CREATE SEQUENCE gstest_id_seq OWNED BY gstest.id;


postgres=> ALTER TABLE gstest \
      ALTER COLUMN id SET DEFAULT \
      pgactive.pgactive_snowflake_id_nextval('gstest_id_seq');

Secuencias particionadas

En las secuencias divididas o particionadas, se utiliza una secuencia PostgreSQL normal en cada nodo. Cada secuencia se incrementa en la misma cantidad y comienza con diferentes desplazamientos. Por ejemplo, con el paso 100, el nodo 1 genera una secuencia como 101, 201, 301, etc., y el nodo 2 genera una secuencia como 102, 202, 302, etc. Este esquema funciona bien incluso si los nodos no pueden comunicarse durante períodos prolongados, pero requiere que el diseñador especifique un número máximo de nodos al establecer el esquema y requiere una configuración por nodo. Los errores pueden provocar fácilmente la superposición de secuencias.

Es relativamente sencillo configurar este enfoque con pgactive creando la secuencia deseada en un nodo de la siguiente manera:



CREATE TABLE some_table (generated_value bigint primary key);


postgres=> CREATE SEQUENCE some_seq INCREMENT 100 OWNED BY some_table.generated_value;


postgres=> ALTER TABLE some_table ALTER COLUMN generated_value SET DEFAULT nextval('some_seq');

A continuación, llame a setval en cada nodo para dar un valor inicial de desplazamiento diferente, de la siguiente manera.


postgres=>
-- On node 1
SELECT setval('some_seq', 1);

-- On node 2
SELECT setval('some_seq', 2);

Referencia de parámetros para la extensión pgactive

Puede utilizar la siguiente consulta para ver todos los parámetros asociados a la extensión pgactive.


postgres=> SELECT * FROM pg_settings WHERE name LIKE 'pgactive.%';

Medición del retraso de réplica entre miembros de pgactive

Puede utilizar la siguiente consulta para ver el retraso de réplica entre los miembros de pgactive. Ejecute esta consulta en todos los nodos de pgactive para obtener una idea completa.



      postgres=# SELECT *, (last_applied_xact_at - last_applied_xact_committs) AS lag FROM pgactive.pgactive_node_slots;
-{ RECORD 1 ]----------------+----------------------------------------------------------------- 
node_name                    | node2-app
slot_name                    | pgactive_5_7332551165694385385_0_5__
slot_restart_lsn             | 0/1A898A8
slot_confirmed_lsn           | 0/1A898E0
walsender_active             | t
walsender_pid                | 69022
sent_lsn                     | 0/1A898E0 
write_lsn                    | 0/1A898E0
flush_lsn                    | 0/1A898E0  
replay_lsn                   | 0/1A898E0
last_sent_xact_id            | 746
last_sent_xact_committs      | 2024-02-06 18:04:22.430376+00
last_sent_xact_at            | 2024-02-06 18:04:22.431359+00
last_applied_xact_id         | 746
last_applied_xact_committs   | 2024-02-06 18:04:22.430376+00
last_applied_xact_at         | 2024-02-06 18:04:52.452465+00
lag                          | 00:00:30.022089

Limitaciones de la extensión pgactive

Todas las tablas requieren una clave principal; de lo contrario, no se permiten operaciones para actualizar ni eliminar. Los valores de la columna de clave principal no deberían actualizarse.
Las secuencias pueden tener huecos y, a veces, es posible que no sigan un orden. Las secuencias no se replican. Para obtener más información, consulte Gestión de secuencias en la replicación activa-activa.
Los DDL y los objetos grandes no se replican.
Los índices únicos secundarios pueden provocar divergencias en los datos.
La intercalación debe ser idéntica en todos los nodos del grupo.
El equilibrador de carga entre los nodos es un antipatrón.
Las transacciones grandes pueden provocar retardos en la replicación.

Reducción de la sobrecarga en tablas e índices con la extensión pg_repack

Puede usar la extensión pg_repack para eliminar el sobredimensionamiento de las tablas y los índices como alternativa a VACUUM FULL. Esta extensión es compatible con RDS para las versiones 9.6.3 y superiores de PostgreSQL. Para obtener más información acerca de la extensión pg_repack y el reempaquetado de tablas completo, consulte la documentación del proyecto de GitHub.

A diferencia de lo que ocurre con VACUUM FULL, la extensión pg_repack requiere un bloqueo exclusivo (AccessExclusiveLock) por un breve período de tiempo durante la operación de reconstrucción de la tabla en los siguientes casos:

Creación inicial de la tabla de registro: se crea una tabla de registro para registrar los cambios que se producen durante la copia inicial de los datos, como se muestra en el siguiente ejemplo:


postgres=>\dt+ repack.log_*
List of relations
-[ RECORD 1 ]-+----------
Schema        | repack
Name          | log_16490
Type          | table
Owner         | postgres
Persistence   | permanent
Access method | heap
Size          | 65 MB
Description   |

Fase final de intercambio y eliminación.

Para el resto de la operación de reconstrucción, solo se necesita un bloqueo ACCESS SHARE en la tabla original para copiar sus filas a la nueva tabla. Esto ayuda a que las operaciones INSERT, UPDATE y DELETE continúen como de costumbre.

Recomendaciones

Las siguientes recomendaciones se aplican al eliminar el sobredimensionamiento de las tablas e índices mediante la extensión pg_repack:

Realice el reempaquetado fuera del horario laboral o durante un período de mantenimiento para minimizar su impacto en el rendimiento de otras actividades de la base de datos.
Monitorice de cerca las sesiones de bloqueo durante la actividad de reconstrucción y asegúrese de que no haya ninguna actividad en la tabla original que pueda bloquear pg_repack, especialmente durante la fase final de intercambio y eliminación, cuando es necesario bloquear exclusivamente la tabla original. Para obtener más información, consulte Identificar qué bloquea una consulta.

Si ve una sesión que bloquee, puede finalizarla mediante el siguiente comando tras estudiarla detenidamente. Esto ayuda a continuar con pg_repack para terminar la reconstrucción:
```
SELECT pg_terminate_backend(pid);
```
Al aplicar los cambios acumulados de la tabla de registro pg_repack's en sistemas con una tasa de transacciones muy alta, es posible que el proceso de solicitud no pueda mantener la tasa de cambios. En esos casos, pg_repack no podría completar el proceso de aplicación. Para obtener más información, consulte Monitorización de la nueva tabla durante el reempaquetado. Si los índices están muy sobredimensionados, una solución alternativa es volver a empaquetar únicamente los índices. Esto también ayuda a que los ciclos de limpieza de índices de VACUUM finalicen más rápido.

Puede omitir la fase de limpieza de índices mediante el VACUUM manual de la versión 12 de PostgreSQL, y se omite automáticamente durante el autovacuum de emergencia de la versión 14 de PostgreSQL. Esto ayuda a que VACUUM se complete más rápido sin eliminar el sobredimensionamiento del índice y solo está diseñado para situaciones de emergencia, como evitar que el VACUUM se acumule. Para obtener más información, consulte Evitar la sobrecarga en los índices en la Guía del usuario de Amazon Aurora.

Requisitos previos

La tabla debe tener una restricción de PRIMARY KEY o una UNIQUE que no sea null.
La versión de la extensión debe ser la misma tanto para el cliente como para el servidor.
Asegúrese de que la instancia de RDS tenga más FreeStorageSpace que el tamaño total de la tabla sin la sobrecarga. Como ejemplo, considere el tamaño total de la tabla, incluidos el TOAST y los índices, como de 2 TB, y el tamaño total de la tabla como 1 TB. El FreeStorageSpace requerido debe ser superior al valor devuelto por el siguiente cálculo:

2TB (Table size) - 1TB (Table bloat) = 1TB

Puede utilizar la siguiente consulta para comprobar el tamaño total de la tabla y utilizar pgstattuple para derivar la sobrecarga. Para obtener más información, consulte Diagnóstico de sobrecarga de tablas e índices en la Guía del usuario de Amazon Aurora.
```
SELECT pg_size_pretty(pg_total_relation_size('table_name')) AS total_table_size;
```
Este espacio se recupera una vez finalizada la actividad.
Asegúrese de que la instancia de RDS tenga suficiente capacidad de procesamiento y E/S para gestionar la operación de reempaquetado. Podría considerar la posibilidad de escalar verticalmente la clase de instancia para lograr un equilibrio óptimo del rendimiento.

Para usar la extensión `pg_repack`

Instale la extensión pg_repack en la instancia de base de datos de RDS for PostgreSQL con el siguiente comando.
```
CREATE EXTENSION pg_repack;
```

Ejecute los siguientes comandos para conceder acceso de escritura a las tablas de registro temporales creadas por pg_repack.


ALTER DEFAULT PRIVILEGES IN SCHEMA repack GRANT INSERT ON TABLES TO PUBLIC;
ALTER DEFAULT PRIVILEGES IN SCHEMA repack GRANT USAGE, SELECT ON SEQUENCES TO PUBLIC;

Conéctese a la base de datos mediante la utilidad de cliente pg_repack. Utilice una cuenta que tenga privilegios rds_superuser. Por ejemplo, suponga que ese rol rds_test tiene privilegios rds_superuser. La siguiente sintaxis realiza pg_repack para tablas completas, incluidos todos los índices de tablas de la base de datos postgres.
```
pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test -k postgres
```
nota
Debe conectarse usando la opción -k. La opción -a no se admite.

La respuesta del cliente pg_repack proporciona información relativa a las tablas de la instancia de base de datos que se han vuelto a empaquetar.
```
INFO: repacking table "pgbench_tellers"
INFO: repacking table "pgbench_accounts"
INFO: repacking table "pgbench_branches"
```

La siguiente sintaxis vuelve a empaquetar una sola tabla orders, incluidos los índices de la base de datos postgres.


pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test --table orders -k postgres

La siguiente sintaxis reempaqueta solo los índices de la tabla orders de la base de datos postgres.


pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test --table orders --only-indexes -k postgres

Monitorización de la nueva tabla durante el reempaquetado

El tamaño de la base de datos se incrementa en función del tamaño total de la tabla, menos la sobrecarga, hasta la fase de intercambio y eliminación del reempaquetado. Puede monitorizar la tasa de crecimiento del tamaño de la base de datos, calcular la velocidad de reempaquetado y estimar aproximadamente el tiempo que se tarda en completar la transferencia inicial de datos.

Como ejemplo, considere que el tamaño total de la tabla es de 2 TB, el tamaño de la base de datos es de 4 TB y la sobrecarga total de la tabla es de 1 TB. El valor del tamaño total de la base de datos devuelto por el cálculo al final de la operación de reempaquetado es el siguiente:

2TB (Table size) + 4 TB (Database size) - 1TB (Table bloat) = 5TB

Puede estimar aproximadamente la velocidad de la operación de reempaquetado muestreando la tasa de crecimiento en bytes entre dos puntos en el tiempo. Si la tasa de crecimiento es de 1 GB por minuto, la operación inicial de creación de la tabla puede tardar 1000 minutos o 16,6 horas aproximadamente en completarse. Además de la construcción inicial de la tabla, pg_repack también necesita aplicar los cambios acumulados. El tiempo que tarda depende del ritmo de aplicación de los cambios continuos más los acumulados.

nota
Puede usar la extensión pgstattuple para calcular la sobrecarga en la tabla. Para obtener más información, consulte pgstattuple.
El número de filas de la tabla de registro pg_repack's, según el esquema de reempaquetado, representa el volumen de cambios pendientes de aplicarse a la nueva tabla tras la carga inicial.

Puede consultar la tabla de registro pg_repack's en pg_stat_all_tables para supervisar los cambios aplicados a la nueva tabla. pg_stat_all_tables.n_live_tup indica el número de registros pendientes de ser aplicados a la nueva tabla. Para obtener más información, consulte pg_stat_all_tables.
```
postgres=>SELECT relname,n_live_tup FROM pg_stat_all_tables WHERE schemaname = 'repack' AND relname ILIKE '%log%';
        
-[ RECORD 1 ]---------
relname    | log_16490
n_live_tup | 2000000
        
```

Puede utilizar la extensión pg_stat_statements para determinar el tiempo que tarda cada paso de la operación de reempaquetado. Esto es útil para prepararse para aplicar la misma operación de reempaque en un entorno de producción. Puede ajustar la cláusula LIMIT para ampliar aún más la salida.


postgres=>SELECT
     SUBSTR(query, 1, 100) query,
     round((round(total_exec_time::numeric, 6) / 1000 / 60),4) total_exec_time_in_minutes
 FROM
     pg_stat_statements
 WHERE
     query ILIKE '%repack%'
 ORDER BY
     total_exec_time DESC LIMIT 5;
        
 query                                                                 | total_exec_time_in_minutes
-----------------------------------------------------------------------+----------------------------
 CREATE UNIQUE INDEX index_16493 ON repack.table_16490 USING btree (a) |                     6.8627
 INSERT INTO repack.table_16490 SELECT a FROM ONLY public.t1           |                     6.4150
 SELECT repack.repack_apply($1, $2, $3, $4, $5, $6)                    |                     0.5395
 SELECT repack.repack_drop($1, $2)                                     |                     0.0004
 SELECT repack.repack_swap($1)                                         |                     0.0004
(5 rows)

El reempaquetado es una operación completamente fuera de lugar, por lo que la tabla original no se ve afectada y no prevemos ningún problema inesperado que requiera la recuperación de la tabla original. Si el reempaquetado falla inesperadamente, debe inspeccionar la causa del error y resolverlo.

Una vez resuelto el problema, coloque y vuelva a crear la extensión pg_repack en la base de datos en la que se encuentre la tabla y vuelva a intentar el paso pg_repack. Además, la disponibilidad de los recursos de computación y la accesibilidad simultánea de la tabla desempeñan un papel crucial a la hora de completar a tiempo la operación de reempaquetado.

Actualización y uso de la extensión PLV8

PLV8 es una extensión de lenguaje Javascript de confianza para PostgreSQL Puede usarlo para procedimientos almacenados, desencadenadores y otro código de procedimiento que se puede llamar desde SQL. Esta extensión de lenguaje es compatible con todas las versiones actuales de PostgreSQL.

Si utiliza PLV8 y actualiza PostgreSQL a una nueva versión de PLV8, inmediatamente aprovecha la nueva extensión. Lleve a cabo los siguientes pasos para sincronizar los metadatos del catálogo con la nueva versión de PLV8. Estos pasos son opcionales, pero recomendamos que los complete para evitar advertencias de discrepancia de metadatos.

El proceso de actualización elimina todas las funciones PLV8 existentes. Por lo tanto, le recomendamos que cree una instantánea de su instancia de base de datos de RDS for PostgreSQL antes de la actualización. Para obtener más información, consulte Creación de una instantánea de base de datos para una instancia de base de datos single-AZ.

Para sincronizar los metadatos del catálogo con una nueva versión de PLV8

Verifique que necesita realizar la actualización. Para ello, ejecute el siguiente comando mientras está conectado a la instancia.


SELECT * FROM pg_available_extensions WHERE name IN ('plv8','plls','plcoffee');

Si los resultados contienen valores de una versión instalada con un número inferior a la versión predeterminada, continúe con este procedimiento para actualizar las extensiones. Por ejemplo, el siguiente conjunto de resultados indica que debería actualizar.


name    | default_version | installed_version |                     comment
--------+-----------------+-------------------+--------------------------------------------------
plls    | 2.1.0           | 1.5.3             | PL/LiveScript (v8) trusted procedural language
plcoffee| 2.1.0           | 1.5.3             | PL/CoffeeScript (v8) trusted procedural language
plv8    | 2.1.0           | 1.5.3             | PL/JavaScript (v8) trusted procedural language
(3 rows)

Cree una instantánea de la instancia de base de datos de RDS for PostgreSQL si aún no lo ha hecho. Puede continuar con los pasos siguientes mientras se crea la instantánea.
Obtenga un recuento del número de funciones de PLV8 de su instancia de base de datos para que pueda validar que se aplican todas después de la actualización. Por ejemplo, la siguiente consulta SQL devuelve el número de funciones escritas en plv8, plcoffee y plls.
```
SELECT proname, nspname, lanname 
FROM pg_proc p, pg_language l, pg_namespace n
WHERE p.prolang = l.oid
AND n.oid = p.pronamespace
AND lanname IN ('plv8','plcoffee','plls');
```
Use pg_dump para crear un archivo de volcado solo de esquema. Por ejemplo, cree un archivo en el equipo cliente en el directorio /tmp.
```
./pg_dump -Fc --schema-only -U master postgres >/tmp/test.dmp
```
En este ejemplo se utilizan las siguientes opciones:
- -Fc: formato personalizado
- --schema-only: vuelca solo los comandos necesarios para crear el esquema (funciones en este caso)
- -U: el nombre de usuario maestro de RDS
- database: el nombre de la base de datos para nuestra instancia de base de datos
Para obtener más información sobre pg_dump, consulte pg_dump en la documentación de PostgreSQL.
Extraiga la instrucción DDL "CREATE FUNCTION" que se encuentra en el archivo de volcado. El siguiente ejemplo utiliza el comando grep para extraer la instrucción DDL que crea las funciones y guardarlas en un archivo. Se utiliza en los pasos posteriores para volver a crear las funciones.
```
./pg_restore -l /tmp/test.dmp | grep FUNCTION > /tmp/function_list/
```
Para obtener más información sobre pg_restore, consulte pg_restore en la documentación de PostgreSQL.
Borre las funciones y las extensiones. El siguiente ejemplo elimina cualquier objeto basado en PLV8. La opción cascade garantiza que se borren los dependientes.
```
DROP EXTENSION plv8 CASCADE;
```
Si su instancia de PostgreSQL contiene objetos basados en plcoffee o plls, repita este paso para dichas extensiones.
Cree las extensiones. El siguiente ejemplo crea las extensiones plv8, plcoffee y plls.
```
CREATE EXTENSION plv8;
CREATE EXTENSION plcoffee;
CREATE EXTENSION plls;
```
Cree las funciones con el archivo de volcado y el archivo "driver".

El siguiente ejemplo recrea las funciones que extrajo anteriormente.
```
./pg_restore -U master -d postgres -Fc -L /tmp/function_list /tmp/test.dmp
```

Verifique que todas las funciones se recrean con la siguiente consulta.


SELECT * FROM pg_available_extensions WHERE name IN ('plv8','plls','plcoffee');

La versión 2 de PLV8 agrega la siguiente fila adicional a su conjunto de resultados:


    proname    |  nspname   | lanname
---------------+------------+----------
 plv8_version  | pg_catalog | plv8

Uso de PL/Rust para escribir funciones de PostgreSQL en lenguaje Rust

PL/Rust es una extensión del lenguaje Rust de confianza para PostgreSQL. Puede usarlo para procedimientos almacenados, funciones y otro código de procedimiento que se pueda llamar desde SQL. La extensión de lenguaje PL/Rust está disponible en las siguientes versiones:

RDS para PostgreSQL 16.1 y versiones 16 posteriores
RDS para PostgreSQL, 15.2-R2 y versiones 15 posteriores
RDS para PostgreSQL, 14.9 y versiones 14 posteriores
RDS para PostgreSQL, 13.12 y versiones 13 posteriores

Para obtener más información, consulte PL/Rust en GitHub.

Configuración de PL/Rust

Para instalar la extensión plrust en la instancia de base de datos, agregue plrust al parámetro shared_preload_libraries en el grupo de parámetros de base de datos asociado con la instancia de base de datos. Con la extensión plrust instalada, puede crear funciones.

Para modificar el parámetro shared_preload_libraries, la instancia de base de datos debe asociarse al grupo de parámetros personalizado. Para obtener información sobre la creación de un grupo de parámetros de base de datos personalizado, consulte Working with parameter groups (Trabajar con grupos de parámetros).

Puede instalar la extensión plrust mediante la AWS Management Console o la AWS CLI.

En los pasos siguientes se supone que la instancia de base de datos está asociada a un grupo de parámetros de base de datos personalizado.

Instalar la extensión plrust en el parámetro `shared_preload_libraries`

Realice los siguientes pasos con una cuenta que sea miembro del grupo rds_superuser (rol).

Inicie sesión en la AWS Management Console y abra la consola de Amazon RDS en https://console.aws.amazon.com/rds/.
En el panel de navegación, seleccione Databases (Bases de datos).
Elija el nombre de la instancia de base de datos para ver los detalles.
Abra la pestaña Configuración de la instancia de base de datos y busque el enlace del grupo de parámetros de instancias de base de datos.
Elija el enlace para abrir los parámetros personalizados asociados a la instancia de base de datos.
En el campo de búsqueda Parametes (Parámetros), escriba shared_pre para buscar el parámetro shared_preload_libraries.
Seleccione Edit parameters (Editar parámetros) para acceder a los valores de las propiedades.
Añada plrust a la lista en el campo Valores. Utilice una coma para separar los elementos de la lista de valores.
Reinicie la instancia de base de datos para que los cambios en el parámetro shared_preload_libraries surtan efecto. El reinicio inicial puede requerir tiempo adicional para completarse.
Cuando la instancia esté disponible, compruebe si se ha inicializado plrust. Use psql para conectarse a la instancia de base de datos y ejecute el siguiente comando.
```
SHOW shared_preload_libraries;
```
El resultado debería tener un aspecto similar al siguiente:
```
shared_preload_libraries 
--------------------------
rdsutils,plrust
(1 row) 
```

Instale la extensión plrust en el parámetro shared_preload_libraries.

Realice los siguientes pasos con una cuenta que sea miembro del grupo rds_superuser (rol).

Use el comando modify-db-parameter-group de AWS CLI para añadir plrust al parámetro shared_preload_libraries.


aws rds modify-db-parameter-group \
   --db-parameter-group-name custom-param-group-name \
   --parameters "ParameterName=shared_preload_libraries,ParameterValue=plrust,ApplyMethod=pending-reboot" \
   --region aws-region

Use el comando reboot-db-instance de AWS CLI para reiniciar la instancia de base de datos e inicializar la biblioteca plrust. El reinicio inicial puede requerir tiempo adicional para completarse.
```
aws rds reboot-db-instance \
    --db-instance-identifier your-instance \
    --region aws-region
```
Cuando la instancia esté disponible, compruebe si se ha inicializado plrust. Use psql para conectarse a la instancia de base de datos y ejecute el siguiente comando.
```
SHOW shared_preload_libraries;
```
El resultado debería tener un aspecto similar al siguiente:
```
shared_preload_libraries
--------------------------
rdsutils,plrust
(1 row) 
```

Creación de funciones con PL/Rust

PL/Rust compilará la función como biblioteca dinámica, la cargará y la ejecutará.

La siguiente función de Rust filtra los múltiplos de una matriz.


postgres=> CREATE LANGUAGE plrust;
CREATE EXTENSION


CREATE OR REPLACE FUNCTION filter_multiples(a BIGINT[], multiple BIGINT) RETURNS BIGINT[]
    IMMUTABLE STRICT
    LANGUAGE PLRUST AS
$$
    Ok(Some(a.into_iter().filter(|x| x.unwrap() % multiple != 0).collect()))
$$;
        
WITH gen_values AS (
SELECT ARRAY(SELECT * FROM generate_series(1,100)) as arr)
SELECT filter_multiples(arr, 3)
from gen_values;

Uso de cajas con PL/Rust

A partir de las versiones 15.4, 14.9 y 13.12 de Amazon RDS para PostgreSQL, PL/Rust admite las siguientes cajas:

aes
ctr
rand

A partir de las versiones 15.5-R2, 14.10-R2 y 13.13-R2 de RDS para PostgreSQL, PL/Rust admite dos cajas adicionales:

croaring-rs
num-bigint

Estas cajas solo admiten las funciones predeterminadas. Es posible que las nuevas versiones de RDS para PostgreSQL contengan versiones actualizadas de las cajas y que las versiones anteriores de las cajas ya no sean compatibles.

Siga las prácticas recomendadas para realizar una actualización de una versión principal y comprobar si las funciones de PL/Rust son compatibles con la nueva versión principal. Para obtener más información, consulte el blog Best practices for upgrading Amazon RDS to major and minor versions of PostgreSQL y Actualización del motor de base de datos de PostgreSQL para Amazon RDS en la Guía del usuario de Amazon RDS.

Encontrará ejemplos del uso de dependencias al crear una función de PL/Rust en Use dependencies.

Limitaciones de PL/Rust

De forma predeterminada, los usuarios de bases de datos no pueden usar PL/Rust. Para proporcionar acceso a PL/Rust, conéctese como usuario con el privilegio rds_superuser y ejecute el siguiente comando:


postgres=> GRANT USAGE ON LANGUAGE PLRUST TO user;

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

La base de datos lleva mucho tiempo inactiva en la conexión de la transacción

Administración de las particiones con la extensión pg_partman

Uso de extensiones PostgreSQL con Amazon RDS para PostgreSQL

nota

Temas

Uso de las funciones de la extensión orafce

nota

Para usar la extensión orafce

Uso de pgactive para admitir la replicación activa-activa

nota

Temas

Inicialización de la capacidad de la extensión pgactive

Para inicializar la capacidad de la extensión pgactive

Para inicializar la capacidad de la extensión pgactive

Configuración de la replicación activa-activa para las instancias de base de datos de RDS para PostgreSQL

nota

Para configurar la primera instancia de base de datos de RDS para PostgreSQL con la extensión pgactive

nota

Para configurar la segunda instancia de RDS para PostgreSQL y unirla al grupo pgactive

Para separar y eliminar una instancia de base de datos del grupo pgactive

Gestión de conflictos en la replicación activa-activa

Gestión de secuencias en la replicación activa-activa

Secuencias globales

Secuencias particionadas

Referencia de parámetros para la extensión pgactive

Medición del retraso de réplica entre miembros de pgactive

Limitaciones de la extensión pgactive

Reducción de la sobrecarga en tablas e índices con la extensión pg_repack

Recomendaciones

Requisitos previos

Para usar la extensión pg_repack

nota

Monitorización de la nueva tabla durante el reempaquetado

nota

Actualización y uso de la extensión PLV8

Para sincronizar los metadatos del catálogo con una nueva versión de PLV8

Uso de PL/Rust para escribir funciones de PostgreSQL en lenguaje Rust

Temas

Configuración de PL/Rust

Instalar la extensión plrust en el parámetro shared_preload_libraries

Instale la extensión plrust en el parámetro shared_preload_libraries.

Creación de funciones con PL/Rust

Uso de cajas con PL/Rust

Limitaciones de PL/Rust

Para configurar la primera instancia de base de datos de RDS para PostgreSQL con la extensión `pgactive`

Para configurar la segunda instancia de RDS para PostgreSQL y unirla al grupo `pgactive`

Para separar y eliminar una instancia de base de datos del grupo `pgactive`

Para usar la extensión `pg_repack`

Instalar la extensión plrust en el parámetro `shared_preload_libraries`