Uso de Extensiones de lenguaje de confianza para PostgreSQL
Extensiones de lenguaje de confianza para PostgreSQL es un kit de desarrollo de código abierto para crear extensiones de PostgreSQL. Le permite crear extensiones de PostgreSQL de alto rendimiento y ejecutarlas de forma segura en su instancia de base de datos de RDS para PostgreSQL. Al utilizar Extensiones de lenguaje de confianza (TLE) para PostgreSQL, puede crear extensiones de PostgreSQL que sigan el enfoque documentado para ampliar la funcionalidad de PostgreSQL. Para obtener más información, consulte el punto Packaging Related Objects into an Extension
Una ventaja clave de TLE es que se puede utilizar en entornos que no proporcionan acceso al sistema de archivos subyacente a la instancia de PostgreSQL. Anteriormente, la instalación de una nueva extensión requería acceso al sistema de archivos. TLE elimina esta restricción. Pues proporciona un entorno de desarrollo para crear nuevas extensiones para cualquier base de datos de PostgreSQL, incluidas las que se ejecutan en los instancias de base de datos de RDS para PostgreSQL.
TLE está diseñado para evitar el acceso a recursos no seguros para las extensiones que se crean con TLE. Su entorno de ejecución limita el impacto de cualquier defecto de extensión a una única conexión de base de datos. TLE también proporciona a los administradores de bases de datos un control preciso sobre quién puede instalar las extensiones y proporciona un modelo de permisos para ejecutarlas.
TLE es compatible con las siguientes versiones de RDS para PostgreSQL:
-
Versión 16.1 y versiones posteriores a 16
-
Versión 15.2 y versiones posteriores a 15
-
Versión 14.5 y versiones posteriores a 14
-
Versión 13.12 y versiones posteriores a 13
El entorno de desarrollo y el entorno de ejecución de Extensiones de lenguaje de confianza se empaquetan como la extensión pg_tle
de PostgreSQL, versión 1.0.1. Admite la creación de extensiones en JavaScript, Perl, Tcl, PL/pgSQL y SQL. La extensión pg_tle
se instala en la instancia de base de datos de RDS para PostgreSQL del mismo modo que se instalan otras extensiones de PostgreSQL. Una vez configurada pg_tle
, los desarrolladores pueden usarla para crear nuevas extensiones de PostgreSQL, conocidas como extensiones TLE.
En los temas siguientes, encontrará información sobre cómo configurar Extensiones de lenguaje de confianza y cómo comenzar a crear sus propias extensiones TLE.
Temas
- Terminología
- Requisitos para usar Extensiones de lenguaje de confianza para PostgreSQL
- Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL
- Información general de Extensiones de lenguaje de confianza para PostgreSQL
- Creación de extensiones TLE para RDS para PostgreSQL
- Eliminar las extensiones TLE de una base de datos
- Desinstalación de Extensiones de lenguaje de confianza para PostgreSQL
- Uso de enlaces de PostgreSQL con sus extensiones TLE
- Uso de tipos de datos personalizados en TLE
- Referencia de funciones para Extensiones de lenguaje de confianza para PostgreSQL
- Referencia de enlaces para Extensiones de lenguaje de confianza para PostgreSQL
Terminología
Para entender mejor Extensiones de lenguaje de confianza, consulta el siguiente glosario para ver los términos utilizados en este tema.
- Extensiones de lenguaje de confianza para PostgreSQL
-
Extensiones de lenguaje de confianza para PostgreSQL es el nombre oficial del kit de desarrollo de código abierto que se incluye como extensión
pg_tle
. Está disponible para su uso en cualquier sistema PostgreSQL. Para obtener más información, consulte aws/pg_tleen GitHub. - Extensiones de lenguaje de confianza
-
Extensiones de lenguaje de confianza es la versión abreviada de Extensiones de lenguaje de confianza para PostgreSQL. En esta documentación se utilizan el nombre abreviado y sus siglas (TLE).
- lenguaje de confianza
-
Un lenguaje de confianza es un lenguaje de programación o de scripting que tiene atributos de seguridad específicos. Por ejemplo, los lenguajes de confianza suelen restringir el acceso al sistema de archivos y limitan el uso de las propiedades de red especificadas. El kit de desarrollo TLE está diseñado para ser compatible con lenguajes de confianza. PostgreSQL admite varios lenguajes diferentes que se utilizan para crear extensiones fiables o no fiables. Para ver un ejemplo, consulte el punto Trusted and Untrusted PL/Perl
(PL/Perl fiable y no fiable) en la documentación de PostgreSQL. Al crear una extensión con Extensiones de lenguaje de confianza, la extensión utiliza mecanismos de lenguaje de confianza de forma inherente. - Extensión TLE
-
Una extensión TLE es una extensión de PostgreSQL que se ha creado mediante el kit de desarrollo de Extensiones de lenguaje de confianza (TLE).
Requisitos para usar Extensiones de lenguaje de confianza para PostgreSQL
Estos son los requisitos para configurar y usar el kit de desarrollo TLE.
Versiones de RDS para PostgreSQL: las extensiones de lenguaje de confianza se admiten en RDS para PostgreSQL versiones 13.12 y versiones 13 posteriores, 14.5 y versiones 14 posteriores, y 15.2 y versiones posteriores únicamente.
Si necesita actualizar su instancia de RDS para PostgreSQL, consulte Actualización del motor de base de datos de PostgreSQL para Amazon RDS.
Si aún no tiene un clúster de base de datos de Aurora que ejecute PostgreSQL, puede crear una. Para obtener más información, consulte Instancia de base de datos de RDS para PostgreSQL, consulte Creación de una instancia de base de datos de PostgreSQL y conexión a ella.
Requiere privilegios de
rds_superuser
: para instalar y configurar la extensiónpg_tle
, el rol de usuario de la base de datos debe tener permisos del rolrds_superuser
. De forma predeterminada, este rol se otorga al usuariopostgres
que crea el Instancia de base de datos RDS para PostgreSQL.Requiere un grupo de parámetros de base de datos personalizado: su instancia de base de datos de RDS para PostgreSQL debe configurarse con un grupo de parámetros de base de datos personalizado.
Si su instancia de base de datos de RDS para PostgreSQL no está configurado con un grupo de parámetros de base de datos personalizado, debe crear uno y asociarlo su instancia de base de datos de RDS para PostgreSQL. Para obtener un breve resumen de los pasos, consulte Creación y aplicación de un grupo de parámetros de base de datos personalizado.
Si su instancia de base de datos de RDS para PostgreSQL ya se ha configurado con un grupo de parámetros de base de datos personalizado, puede configurar Extensiones de lenguaje de confianza. Para obtener más información, consulte Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
Creación y aplicación de un grupo de parámetros de base de datos personalizado
Siga los siguientes pasos para crear un grupo de parámetros de base de datos personalizado y configure su instancia de base de datos de RDS para PostgreSQL para utilizarlo.
Para crear un grupo de parámetros de base de datos personalizado y utilizarlo con su instancia de base de datos de RDS para PostgreSQL
Inicie sesión en la AWS Management Console y abra la consola de Amazon RDS en https://console.aws.amazon.com/rds/
. Elija Parameter groups (Grupos de parámetros) en el menú de Amazon RDS.
Elija Create parameter group.
En la página Parameter group details (Detalles del grupo de parámetros), escriba la siguiente información.
En Parameter group family (Familia de grupo de parámetros), elija postgres14.
En Type (Tipo), elija DB Parameter Group (Grupo de parámetros de bases de datos).
En Group name (Nombre de grupo), asigne al grupo de parámetros un nombre significativo en el contexto de sus operaciones.
En Description (Descripción), introduzca una descripción útil para que los demás miembros de su equipo puedan encontrarla fácilmente.
Seleccione Crear. El grupo de parámetros de base de datos personalizado se crea en su Región de AWS. Ahora puede modificar su instancia de base de datos de RDS para PostgreSQL para usarlo. Para ello, siga los siguientes pasos.
Seleccione Databases (Bases de datos) en el menú de Amazon RDS.
Elija la instancia de base de datos de RDS para PostgreSQL que desea usar con TLE de entre las enumeradas y, a continuación, elija Modify (Modificar).
En la En la página Modify DB cluster settings (Modificar la configuración del clúster de base de datos), busque Database options (Opciones de la base de datos) y elija su grupo de parámetros de base de datos personalizado en el selector.
Elija Continue (Continuar) para guardar el cambio.
Elija Apply immediately (Aplicar inmediatamente) para poder seguir configurando la instancia de base de datos de RDS para PostgreSQL para utilizar TLE.
Para continuar con la configuración del sistema para Extensiones de lenguaje de confianza, consulte Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
Para obtener más información sobre cómo trabajar con Grupos de parámetros de base de datos, consulte Trabajo con los grupos de parámetros en una instancia de base de datos.
Puede evitar especificar el argumento --region
al utilizar los comandos de la CLI al configurar su AWS CLI con su Región de AWS predeterminada. Para obtener más información, consulte Fundamentos de configuración en la Guía del usuario de AWS Command Line Interface.
Para crear un grupo de parámetros de base de datos personalizado y utilizarlo con su instancia de base de datos de RDS para PostgreSQL
Utilice el comando create-db-parameter-group de la AWS CLI para crear un grupo de parámetros de base de datos personalizado basado en postgres14 para su Región de AWS.
Para Linux, macOS o Unix:
aws rds create-db-parameter-group \ --region
aws-region
\ --db-parameter-group-namecustom-params-for-pg-tle
\ --db-parameter-group-family postgres14 \ --description "My custom DB parameter group for Trusted Language Extensions"En Windows:
aws rds create-db-parameter-group ^ --region
aws-region
^ --db-parameter-group-namecustom-params-for-pg-tle
^ --db-parameter-group-family postgres14 ^ --description "My custom DB parameter group for Trusted Language Extensions"Su grupo de parámetros de base de datos personalizado está disponible en su Región de AWS, por lo que puede modificar instancia de base de datos de RDS para PostgreSQL para utilizarla.
Utilice el comando modify-db-instance de la AWS CLI para aplicar su grupo de parámetros de base de datos personalizado a su instancia de base de datos de RDS para PostgreSQL. Este comando reinicia inmediatamente la instancia activa.
Para Linux, macOS o Unix:
aws rds modify-db-instance \ --region
aws-region
\ --db-instance-identifieryour-instance-name
\ --db-parameter-group-namecustom-params-for-pg-tle
\ --apply-immediatelyEn Windows:
aws rds modify-db-instance ^ --region
aws-region
^ --db-instance-identifieryour-instance-name
^ --db-parameter-group-namecustom-params-for-pg-tle
^ --apply-immediately
Para continuar con la configuración del sistema para Extensiones de lenguaje de confianza, consulte Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
Para obtener más información, consulte Working with parameter groups (Trabajar con grupos de parámetros).
Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL
En los pasos siguientes se supone que su instancia de base de datos de RDS para PostgreSQL está asociada a un grupo de parámetros de base de datos personalizado. Puede utilizar la AWS Management Console o la AWS CLI para estos pasos.
Al configurar Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL, las instala en una base de datos específica para que las usen los usuarios de la base de datos que tienen permisos en esa base de datos.
Para configurar Extensiones de lenguaje de confianza
Realice los siguientes pasos con una cuenta que sea miembro del grupo (rol) rds_superuser
.
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 la instancia de base de datos de RDS for PostgreSQL.
-
Abra la pestaña Configuration (Configuración) para su Instancia de base de datos RDS para PostgreSQL. Entre los detalles de la instancia, busque el enlace del grupo de parámetros.
-
Elija el enlace para abrir los parámetros personalizados asociados al Instancia de base de datos RDS para PostgreSQL.
-
En el campo de búsqueda Parametes (Parámetros), escriba
shared_pre
para buscar el parámetroshared_preload_libraries
. -
Seleccione Edit parameters (Editar parámetros) para acceder a los valores de las propiedades.
-
Añada
pg_tle
a la lista en el campo Values (Valores). Utilice una coma para separar los elementos de la lista de valores. Reinicie la instancia de base de datos de RDS for PostgreSQL para que surta efecto el cambio en el parámetro
shared_preload_libraries
.Cuando la instancia esté disponible, verifique si se ha inicializado
pg_tle
. Usepsql
para conectarse a la instancia de base de datos de RDS for PostgreSQL y, a continuación, ejecute el siguiente comando.SHOW shared_preload_libraries;
shared_preload_libraries -------------------------- rdsutils,pg_tle (1 row)
Con la extensión
pg_tle
inicializada, ahora ya puede crear la extensión.CREATE EXTENSION pg_tle;
Para comprobar que la extensión esté instalada, use el metacomando
psql
.labdb=>
\dx
List of installed extensions Name | Version | Schema | Description ---------+---------+------------+-------------------------------------------- pg_tle | 1.0.1 | pgtle | Trusted-Language Extensions for PostgreSQL plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
Asigne el rol
pgtle_admin
al nombre de usuario principal que creó para la instancia de base de datos de RDS para PostgreSQL al configurarla. Si ha aceptado el valor predeterminado, espostgres
.labdb=>
GRANT pgtle_admin TO postgres;GRANT ROLE
Puede comprobar si se ha realizado la concesión con el metacomando
psql
, tal como se muestra en el siguiente ejemplo. Solo los rolespgtle_admin
ypostgres
se muestran en el resultado. Para obtener más información, consulte Descripción del rol rds_superuser.labdb=>
\du
List of roles Role name | Attributes | Member of -----------------+---------------------------------+----------------------------------- pgtle_admin | Cannot login | {} postgres | Create role, Create DB +| {rds_superuser,pgtle_admin} | Password valid until infinity |...
Cierre la sesión de
psql
con el metacomando\q
.\q
Para empezar a crear extensiones TLE, consulte Ejemplo: creación de una extensión de lenguaje de confianza mediante SQL.
Puede evitar especificar el argumento --region
al utilizar los comandos de la CLI al configurar su AWS CLI con su Región de AWS predeterminada. Para obtener más información, consulte Fundamentos de configuración en la Guía del usuario de AWS Command Line Interface.
Para configurar Extensiones de lenguaje de confianza
Use el comando modify-db-cluster-parameter-group de AWS CLI para añadir
pg_tle
al parámetroshared_preload_libraries
.aws rds modify-db-parameter-group \ --db-parameter-group-name
custom-param-group-name
\ --parameters "ParameterName=shared_preload_libraries,ParameterValue=pg_tle,ApplyMethod=pending-reboot" \ --regionaws-region
-
Use el comando reboot-db-instance de AWS CLI para reiniciar la instancia de base de datos de RDS para PostgreSQL e inicialice la biblioteca de
pg_tle
.aws rds reboot-db-instance \ --db-instance-identifier
your-instance
\ --regionaws-region
Cuando la instancia esté disponible, puede verificar si
pg_tle
se ha inicializado. Usepsql
para conectarse a la instancia de base de datos de RDS for PostgreSQL y, a continuación, ejecute el siguiente comando.SHOW shared_preload_libraries;
shared_preload_libraries -------------------------- rdsutils,pg_tle (1 row)
Con
pg_tle
inicializado, ahora ya puede crear la extensión.CREATE EXTENSION pg_tle;
Asigne el rol
pgtle_admin
al nombre de usuario principal que creó para la instancia de base de datos de RDS para PostgreSQL al configurarla. Si ha aceptado el valor predeterminado, espostgres
.GRANT pgtle_admin TO postgres;
GRANT ROLE
Cierre la sesión de
psql
de la siguiente manera.labdb=>
\q
Para empezar a crear extensiones TLE, consulte Ejemplo: creación de una extensión de lenguaje de confianza mediante SQL.
Información general de Extensiones de lenguaje de confianza para PostgreSQL
Extensiones de lenguaje de confianza para PostgreSQL es una extensión de PostgreSQL que se instala en la instancia de base de datos de RDS para PostgreSQL de la misma manera que se configuran otras extensiones de PostgreSQL. En la siguiente imagen de un ejemplo de base de datos de la herramienta de cliente pgAdmin, puede ver algunos de los componentes que componen la extensión pg_tle
.
![Imagen que muestra algunos de los componentes que conforman el kit de desarrollo TLE.](images/apg-pg_tle-installed-view-in-pgAdmin.png)
Puede ver los siguientes detalles.
-
El kit de desarrollo de Extensiones de lenguaje de confianza (TLE) está empaquetado como la extensión
pg_tle
. De este modo,pg_tle
se añade a las extensiones disponibles para la base de datos en la que se instala. TLE tiene su propio esquema:
pgtle
. Este esquema contiene funciones auxiliares (3) para instalar y administrar las extensiones que cree.TLE proporciona más de una docena de funciones auxiliares para instalar, registrar y administrar las extensiones. Para obtener más información sobre estas funciones, consulte Referencia de funciones para Extensiones de lenguaje de confianza para PostgreSQL.
Otros componentes de la extensión pg_tle
incluyen lo siguiente:
El rol
pgtle_admin
: el rolpgtle_admin
se crea al instalar la extensiónpg_tle
. Este rol es privilegiado y debe tratarse como tal. Le recomendamos encarecidamente que siga el principio de privilegio mínimo al conceder el rolpgtle_admin
a los usuarios de la base de datos. En otras palabras, conceda el rolpgtle_admin
solo a los usuarios de bases de datos que estén autorizados a crear, instalar y administrar nuevas extensiones TLE, comopostgres
.La tabla
pgtle.feature_info
: la tablapgtle.feature_info
es una tabla protegida que contiene información sobre los TLE, los enlaces, los procedimientos y las funciones personalizados almacenados que utilizan. Si tiene privilegiospgtle_admin
, utilice las siguientes funciones de Extensiones de lenguaje de confianza para añadir y actualizar la información de la tabla.
Creación de extensiones TLE para RDS para PostgreSQL
Puede instalar cualquier extensión que cree con TLE en cualquier instancia de base de datos de RDS para PostgreSQL que tenga la extensión pg_tle
instalada. La extensión pg_tle
se limita a la base de datos PostgreSQL en la que está instalada. Las extensiones que cree con TLE están incluidas en la misma base de datos.
Utilice las distintas funciones de pgtle
para instalar el código que conforma la extensión TLE. Todas las siguientes funciones de Extensiones de lenguaje de confianza requieren el rol pgtle_admin
.
Ejemplo: creación de una extensión de lenguaje de confianza mediante SQL
El siguiente ejemplo muestra cómo crear una extensión TLE denominada pg_distance
que contenga algunas funciones SQL para calcular distancias mediante diferentes fórmulas. En la lista, puede encontrar la función para calcular la distancia Manhattan y la función para calcular la distancia euclidiana. Para obtener más información sobre la diferencia entre estas fórmulas, consulte Geometría del taxista
Puede utilizar este ejemplo en su instancia de base de datos de RDS para PostgreSQL si tiene la extensión pg_tle
configurada como se detalla en Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
nota
Debe tener los privilegios del rol pgtle_admin
para seguir este procedimiento.
Para crear la extensión TLE de ejemplo
En los pasos siguientes se utiliza un ejemplo de base de datos denominado labdb
. Esta base de datos es propiedad del usuario postgres
principal. El rol postgres
también tiene los permisos del rol pgtle_admin
.
Use
psql
para conectarse a la Instancia de base de datos RDS para PostgreSQL.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdbCree una extensión TLE denominada
pg_distance
copiando el siguiente código y pegándolo en la consola de sesión depsql
.SELECT pgtle.install_extension ( 'pg_distance', '0.1', 'Distance functions for two points', $_pg_tle_$ CREATE FUNCTION dist(x1 float8, y1 float8, x2 float8, y2 float8, norm int) RETURNS float8 AS $$ SELECT (abs(x2 - x1) ^ norm + abs(y2 - y1) ^ norm) ^ (1::float8 / norm); $$ LANGUAGE SQL; CREATE FUNCTION manhattan_dist(x1 float8, y1 float8, x2 float8, y2 float8) RETURNS float8 AS $$ SELECT dist(x1, y1, x2, y2, 1); $$ LANGUAGE SQL; CREATE FUNCTION euclidean_dist(x1 float8, y1 float8, x2 float8, y2 float8) RETURNS float8 AS $$ SELECT dist(x1, y1, x2, y2, 2); $$ LANGUAGE SQL; $_pg_tle_$ );
Debería ver un resultado como el siguiente.
install_extension --------------- t (1 row)
Los artefactos que componen la extensión
pg_distance
ahora ya están instalados en su base de datos. Estos artefactos incluyen el archivo de control y el código de la extensión, que son elementos que deben estar presentes para poder crear la extensión mediante el comandoCREATE EXTENSION
. En otras palabras, aún debe crear la extensión para que sus funciones estén disponibles para los usuarios de la base de datos.Para crear la extensión, utilice el comando
CREATE EXTENSION
como lo haría con cualquier otra extensión. Al igual que con otras extensiones, el usuario de la base de datos debe tener los permisosCREATE
en la base de datos.CREATE EXTENSION pg_distance;
Para probar la extensión TLE
pg_distance
, puede utilizarla para calcular la distancia Manhattanentre cuatro puntos. labdb=>
SELECT manhattan_dist(1, 1, 5, 5);
8
Para calcular la distancia euclidiana
entre el mismo conjunto de puntos, puede utilizar lo siguiente. labdb=>
SELECT euclidean_dist(1, 1, 5, 5);
5.656854249492381
La extensión pg_distance
carga las funciones de la base de datos y las pone a disposición de cualquier usuario con permisos en la base de datos.
Modificación de su extensión TLE
Para mejorar el rendimiento de las consultas para las funciones incluidas en esta extensión TLE, añada los dos atributos de PostgreSQL siguientes a sus especificaciones.
IMMUTABLE
: el atributoIMMUTABLE
garantiza que el optimizador de consultas pueda utilizar optimizaciones para mejorar los tiempos de respuesta de las consultas. Para obtener más información, consulte Function Volatility Categories(Categorías de volatilidad de función) en la documentación de PostgreSQL. PARALLEL SAFE
: el atributoPARALLEL SAFE
es otro atributo que permite a PostgreSQL ejecutar la función en modo paralelo. Para obtener más información, consulte CREATE FUNCTIONen la documentación de PostgreSQL.
En el siguiente ejemplo, puede ver cómo se usa la función pgtle.install_update_path
para agregar estos atributos a cada función a fin de crear una versión 0.2
de la extensión TLE pg_distance
. Para obtener más información acerca de esta función, consulte pgtle.install_update_path. Debe tener el rol pgtle_admin
para realizar esta tarea.
Para actualizar una extensión TLE existente y especificar la versión predeterminada
Conecte con la instancia de base de datos de RDS para PostgreSQL con
psql
u otra herramienta de cliente como pgAdmin.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdbModifique una extensión TLE existente copiando el siguiente código y pegándolo en la consola de sesión de
psql
.SELECT pgtle.install_update_path ( 'pg_distance', '0.1', '0.2', $_pg_tle_$ CREATE OR REPLACE FUNCTION dist(x1 float8, y1 float8, x2 float8, y2 float8, norm int) RETURNS float8 AS $$ SELECT (abs(x2 - x1) ^ norm + abs(y2 - y1) ^ norm) ^ (1::float8 / norm); $$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION manhattan_dist(x1 float8, y1 float8, x2 float8, y2 float8) RETURNS float8 AS $$ SELECT dist(x1, y1, x2, y2, 1); $$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE; CREATE OR REPLACE FUNCTION euclidean_dist(x1 float8, y1 float8, x2 float8, y2 float8) RETURNS float8 AS $$ SELECT dist(x1, y1, x2, y2, 2); $$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE; $_pg_tle_$ );
Verá una respuesta similar a la siguiente.
install_update_path --------------------- t (1 row)
Puede hacer que esta versión de la extensión sea la versión predeterminada para que los usuarios de la base de datos no tengan que especificar una versión al crear o actualizar la extensión en su base de datos.
Para especificar que la versión modificada (versión 0.2) de la extensión TLE es la versión predeterminada, utilice la función
pgtle.set_default_version
tal como se muestra en el siguiente ejemplo.SELECT pgtle.set_default_version('pg_distance', '0.2');
Para obtener más información acerca de esta función, consulte pgtle.set_default_version.
Con el código en su lugar, puede actualizar la extensión TLE instalada de la forma habitual, mediante el comando
ALTER EXTENSION ... UPDATE
, tal como se muestra aquí:ALTER EXTENSION pg_distance UPDATE;
Eliminar las extensiones TLE de una base de datos
Puede eliminar sus extensiones TLE mediante el comando DROP EXTENSION
de la misma manera que lo hace con otras extensiones de PostgreSQL. Al eliminar la extensión, no se eliminan los archivos de instalación que la componen, lo que permite a los usuarios volver a crearla. Para eliminar la extensión y sus archivos de instalación, realice el siguiente proceso de dos pasos.
Para eliminar la extensión TLE y eliminar sus archivos de instalación
Use
psql
u otra herramienta de cliente para conectarse a la instancia de base de datos de RDS para PostgreSQL.psql --host=
.111122223333
.aws-region
.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
Elimine la extensión tal como haría con cualquier extensión de PostgreSQL.
DROP EXTENSION
your-TLE-extension
Por ejemplo, si crea la extensión
pg_distance
tal como se indica en Ejemplo: creación de una extensión de lenguaje de confianza mediante SQL, puede eliminarla de la siguiente manera.DROP EXTENSION pg_distance;
Verá un resultado que confirma que se ha eliminado la extensión, de la siguiente manera.
DROP EXTENSION
En este punto, la extensión ya no está activa en la base de datos. Sin embargo, sus archivos de instalación y su archivo de control siguen disponibles en la base de datos, por lo que los usuarios de la base de datos pueden volver a crear la extensión si lo desean.
Si desea dejar los archivos de extensión intactos para que los usuarios de la base de datos puedan crear su extensión TLE, puede detenerse aquí.
Si desea eliminar todos los archivos que conforman la extensión, proceda con el siguiente paso.
Para eliminar todos los archivos de instalación de la extensión, utilice la función
pgtle.uninstall_extension
. Esta función elimina todos los archivos de código y control de la extensión.SELECT pgtle.uninstall_extension('
your-tle-extension-name
');Por ejemplo, para eliminar todos los archivos de instalación
pg_distance
, utilice el siguiente comando.SELECT pgtle.uninstall_extension('pg_distance');
uninstall_extension --------------------- t (1 row)
Desinstalación de Extensiones de lenguaje de confianza para PostgreSQL
Si ya no quiere crear sus propias extensiones TLE con TLE, puede eliminar la extensión pg_tle
y eliminar todos los artefactos. Esta acción incluye eliminar cualquier extensión TLE de la base de datos y el esquema pgtle
.
Para eliminar la extensión pg_tle
y su esquema de una base de datos
Use
psql
u otra herramienta de cliente para conectarse a la instancia de base de datos de RDS para PostgreSQL.psql --host=
.111122223333
.aws-region
.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
Elimine la extensión
pg_tle
de la base de datos. Si la base de datos está ejecutando sus propias extensiones TLE, también debe eliminar esas extensiones. Para ello, puede utilizar la palabra claveCASCADE
, tal como se muestra a continuación.DROP EXTENSION pg_tle CASCADE;
Si la extensión
pg_tle
no sigue activa en la base de datos, no es necesario que utilice la palabra claveCASCADE
.Elimine el esquema
pgtle
. Esta acción elimina todas las funciones de administración de la base de datos.DROP SCHEMA pgtle CASCADE;
El comando devuelve lo siguiente cuando se completa el proceso.
DROP SCHEMA
Se eliminan la extensión
pg_tle
, su esquema y sus funciones, así como todos los artefactos. Para crear nuevas extensiones con TLE, vuelva a realizar el proceso de configuración. Para obtener más información, consulte Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
Uso de enlaces de PostgreSQL con sus extensiones TLE
Un enlace es un mecanismo de devolución de llamada disponible en PostgreSQL que permite a los desarrolladores llamar a funciones personalizadas u otras rutinas durante las operaciones normales de la base de datos. El kit de desarrollo de TLE admite enlaces de PostgreSQL para que pueda integrar funciones personalizadas con el comportamiento de PostgreSQL en el tiempo de ejecución. Por ejemplo, puede utilizar un enlace para asociar el proceso de autenticación a su propio código personalizado o para modificar el proceso de planificación y ejecución de consultas según sus necesidades específicas.
Sus extensiones TLE pueden utilizar enlaces. Si un enlace tiene un alcance global, se aplica a todas las bases de datos. Por lo tanto, si su extensión TLE usa un enlace global, debe crear su extensión TLE en todas las bases de datos a las que puedan acceder sus usuarios.
Cuando usa la extensión pg_tle
para crear sus propias Extensiones de lenguaje de confianza, puede usar los enlaces disponibles de una API de SQL para crear las funciones de su extensión. Debe registrar cualquier enlace con pg_tle
. Para algunos enlaces, es posible que también tenga que establecer varios parámetros de configuración. Por ejemplo, el enlace de retención passcode
se puede configurar como activado, desactivado u obligatorio. Para obtener más información sobre los requisitos específicos de los enlaces pg_tle
disponibles, consulte Referencia de enlaces para Extensiones de lenguaje de confianza para PostgreSQL.
Ejemplo: Crear una extensión que utilice un enlace de PostgreSQL
El ejemplo descrito en esta sección utiliza un enlace de PostgreSQL para comprobar la contraseña proporcionada durante operaciones SQL específicas e impide que los usuarios de la base de datos establezcan sus contraseñas iguales a las que figuran en la tabla password_check.bad_passwords
. La tabla contiene las diez opciones de contraseñas más utilizadas, pero fáciles de descifrar.
Para configurar este ejemplo en su instancia de base de datos de RDS para PostgreSQL, ya tiene que tener Extensiones de lenguaje de confianza instalado. Para obtener más información, consulte Configuración de Extensiones de lenguaje de confianza en su instancia de base de datos de RDS para PostgreSQL.
Para configurar el ejemplo del enlace de verificación de contraseñas
Use
psql
para conectarse a la Instancia de base de datos RDS para PostgreSQL.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdb
Copie el código de la Lista de códigos del enlace password_check y péguelo en su base de datos.
SELECT pgtle.install_extension ( 'my_password_check_rules', '1.0', 'Do not let users use the 10 most commonly used passwords', $_pgtle_$ CREATE SCHEMA password_check; REVOKE ALL ON SCHEMA password_check FROM PUBLIC; GRANT USAGE ON SCHEMA password_check TO PUBLIC; CREATE TABLE password_check.bad_passwords (plaintext) AS VALUES ('123456'), ('password'), ('12345678'), ('qwerty'), ('123456789'), ('12345'), ('1234'), ('111111'), ('1234567'), ('dragon'); CREATE UNIQUE INDEX ON password_check.bad_passwords (plaintext); CREATE FUNCTION password_check.passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean) RETURNS void AS $$ DECLARE invalid bool := false; BEGIN IF password_type = 'PASSWORD_TYPE_MD5' THEN SELECT EXISTS( SELECT 1 FROM password_check.bad_passwords bp WHERE ('md5' || md5(bp.plaintext || username)) = password ) INTO invalid; IF invalid THEN RAISE EXCEPTION 'Cannot use passwords from the common password dictionary'; END IF; ELSIF password_type = 'PASSWORD_TYPE_PLAINTEXT' THEN SELECT EXISTS( SELECT 1 FROM password_check.bad_passwords bp WHERE bp.plaintext = password ) INTO invalid; IF invalid THEN RAISE EXCEPTION 'Cannot use passwords from the common common password dictionary'; END IF; END IF; END $$ LANGUAGE plpgsql SECURITY DEFINER; GRANT EXECUTE ON FUNCTION password_check.passcheck_hook TO PUBLIC; SELECT pgtle.register_feature('password_check.passcheck_hook', 'passcheck'); $_pgtle_$ );
Cuando la extensión se haya cargado en la base de datos, verá un resultado como el siguiente.
install_extension ------------------- t (1 row)
Mientras siga conectado a la base de datos, ya podrá crear la extensión.
CREATE EXTENSION my_password_check_rules;
Puede confirmar que la extensión se ha creado en la base de datos mediante el siguiente metacomando
psql
.\dx
List of installed extensions Name | Version | Schema | Description -------------------------+---------+------------+------------------------------------------------------------- my_password_check_rules | 1.0 | public | Prevent use of any of the top-ten most common bad passwords pg_tle | 1.0.1 | pgtle | Trusted-Language Extensions for PostgreSQL plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language (3 rows)
Abra otra sesión de terminal para trabajar con la AWS CLI. Debe modificar su grupo de parámetros de base de datos personalizado para activar el enlace de verificación de contraseñas. Para ello, utilice el comando modify-db-parameter-group de la CLI tal como se muestra en el siguiente ejemplo.
aws rds modify-db-parameter-group \ --region
aws-region
\ --db-parameter-group-nameyour-custom-parameter-group
\ --parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"Cuando el parámetro se haya activado correctamente, verá un resultado como el siguiente.
( "DBParameterGroupName": "docs-lab-parameters-for-tle" }
Puede que el cambio en la configuración del grupo de parámetros tarde unos minutos en aplicarse. Sin embargo, este parámetro es dinámico, por lo que no es necesario reiniciar la instancia de base de datos de RDS para PostgreSQL para que la configuración surta efecto.
Abra la sesión
psql
y consulte la base de datos para comprobar que el enlace password_check esté activado.labdb=>
SHOW pgtle.enable_password_check;pgtle.enable_password_check ----------------------------- on (1 row)
El enlace password-check ahora está activo. Puede probarlo creando un rol nuevo y utilizando una de las contraseñas incorrectas, tal como se muestra en el siguiente ejemplo.
CREATE ROLE test_role PASSWORD 'password';
ERROR: Cannot use passwords from the common password dictionary
CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamp with time zone,boolean) line 21 at RAISE
SQL statement "SELECT password_check.passcheck_hook(
$1::pg_catalog.text,
$2::pg_catalog.text,
$3::pgtle.password_types,
$4::pg_catalog.timestamptz,
$5::pg_catalog.bool)"
El resultado se ha modificado para que se pueda leer.
El siguiente ejemplo muestra que el comportamiento \password
del metacomando interactivo pgsql
también se ve afectado por el enlace password_check.
postgres=>
SET password_encryption TO 'md5';SET
postgres=>
\passwordEnter new password for user "postgres":
*****
Enter it again:
*****
ERROR: Cannot use passwords from the common password dictionary CONTEXT: PL/pgSQL function password_check.passcheck_hook(text,text,pgtle.password_types,timestamp with time zone,boolean) line 12 at RAISE SQL statement "SELECT password_check.passcheck_hook($1::pg_catalog.text, $2::pg_catalog.text, $3::pgtle.password_types, $4::pg_catalog.timestamptz, $5::pg_catalog.bool)"
Puede eliminar esta extensión TLE y desinstalar sus archivos de código fuente si lo desea. Para obtener más información, consulte Eliminar las extensiones TLE de una base de datos.
Lista de códigos del enlace password_check
El código de ejemplo que se muestra aquí define la especificación de la extensión TLE my_password_check_rules
. Al copiar este código y pegarlo en la base de datos, el código de la extensión my_password_check_rules
se carga en la base de datos y el enlace password_check
queda registrado para que lo utilice la extensión.
SELECT pgtle.install_extension ( 'my_password_check_rules', '1.0', 'Do not let users use the 10 most commonly used passwords', $_pgtle_$ CREATE SCHEMA password_check; REVOKE ALL ON SCHEMA password_check FROM PUBLIC; GRANT USAGE ON SCHEMA password_check TO PUBLIC; CREATE TABLE password_check.bad_passwords (plaintext) AS VALUES ('123456'), ('password'), ('12345678'), ('qwerty'), ('123456789'), ('12345'), ('1234'), ('111111'), ('1234567'), ('dragon'); CREATE UNIQUE INDEX ON password_check.bad_passwords (plaintext); CREATE FUNCTION password_check.passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean) RETURNS void AS $$ DECLARE invalid bool := false; BEGIN IF password_type = 'PASSWORD_TYPE_MD5' THEN SELECT EXISTS( SELECT 1 FROM password_check.bad_passwords bp WHERE ('md5' || md5(bp.plaintext || username)) = password ) INTO invalid; IF invalid THEN RAISE EXCEPTION 'Cannot use passwords from the common password dictionary'; END IF; ELSIF password_type = 'PASSWORD_TYPE_PLAINTEXT' THEN SELECT EXISTS( SELECT 1 FROM password_check.bad_passwords bp WHERE bp.plaintext = password ) INTO invalid; IF invalid THEN RAISE EXCEPTION 'Cannot use passwords from the common common password dictionary'; END IF; END IF; END $$ LANGUAGE plpgsql SECURITY DEFINER; GRANT EXECUTE ON FUNCTION password_check.passcheck_hook TO PUBLIC; SELECT pgtle.register_feature('password_check.passcheck_hook', 'passcheck'); $_pgtle_$ );
Uso de tipos de datos personalizados en TLE
PostgreSQL admite comandos para registrar nuevos tipos base (también conocidos como tipos escalares) para gestionar con eficiencia estructuras de datos complejas en su base de datos. Un tipo base le permite personalizar la forma en que se almacenan los datos internamente y cómo convertirlos a una representación textual externa y desde ella. Estos tipos de datos personalizados son útiles a la hora de ampliar PostgreSQL para que admita dominios funcionales en los que un tipo integrado, como un número o un texto, no puede proporcionar una semántica de búsqueda suficiente.
RDS para PostgreSQL le permite crear tipos de datos personalizados en su extensión de lenguaje de confianza y definir funciones que admitan operaciones de SQL e indexación para estos nuevos tipos de datos. Los tipos de datos personalizados están disponibles para las siguientes versiones:
-
RDS para PostgreSQL, versión 15.4 y versiones 15 posteriores
-
RDS para PostgreSQL, versión 14.9 y versiones 14 posteriores
-
RDS para PostgreSQL, versión 13.12 y versiones 13 posteriores
Para obtener más información, consulte Trusted Language Base types