Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
Utilisation de Trusted Language Extensions pour PostgreSQL
Trusted Language Extensions pour PostgreSQL est un kit de développement open source permettant de créer des extensions PostgreSQL. Il vous permet de créer des extensions PostgreSQL à hautes performances et de les exécuter en toute sécurité sur votre instance de base de données RDS for PostgreSQL. En utilisant Trusted Language Extensions (TLE) pour PostgreSQL, vous pouvez créer des extensions PostgreSQL qui suivent l'approche documentée pour étendre les fonctionnalités de PostgreSQL. Pour plus d'informations, consultez Packaging Related Objects into an Extension
L'un des principaux avantages de TLE est que vous pouvez l'utiliser dans des environnements qui ne donnent pas accès au système de fichiers sous-jacent à l'instance PostgreSQL. Auparavant, l'installation d'une nouvelle extension nécessitait l'accès au système de fichiers. TLE supprime cette contrainte. Il fournit un environnement de développement permettant de créer de nouvelles extensions pour n'importe quelle base de données PostgreSQL, y compris celles qui s'exécutent sur vos instances de base de données RDS for PostgreSQL.
TLE est conçu pour empêcher l'accès à des ressources dangereuses pour les extensions que vous créez à l'aide de TLE. Son environnement d'exécution limite l'impact de tout défaut d'extension à une seule connexion de base de données. TLE permet également aux administrateurs de base de données de contrôler précisément qui peut installer les extensions et fournit un modèle d'autorisations pour les exécuter.
TLE est pris en charge sur les versions suivantes de RDS for PostgreSQL :
-
Version 16.1 et versions supérieures 16 versions
-
Version 15.2 et supérieure 15 versions
-
Version 14.5 et supérieure 14 versions
-
Version 13.12 et versions supérieures 13 versions
Le runtime et l'environnement de développement Trusted Language Extensions sont fournis sous la forme de l'extension PostgreSQL pg_tle
, version 1.0.1. Il prend en charge la création d'extensions en JavaScript Perl, Tcl, PL/pgSQL et SQL. Vous installez l'extension pg_tle
dans votre instance de base de données RDS for PostgreSQL de la même manière que vous installez les autres extensions PostgreSQL. Une fois le kit pg_tle
configuré, les développeurs peuvent l'utiliser pour créer de nouvelles extensions PostgreSQL, appelées extensions TLE.
Dans les rubriques suivantes, vous apprendrez comment configurer le kit Trusted Language Extensions et comment commencer à créer vos propres extensions TLE.
Rubriques
- Terminologie
- Exigences relatives à l'utilisation de Trusted Language Extensions pour PostgreSQL
- Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL
- Présentation de Trusted Language Extensions pour PostgreSQL
- Création d'extensions TLE pour RDS for PostgreSQL
- Suppression de vos extensions TLE d'une base de données
- Désinstallation de Trusted Language Extensions pour PostgreSQL
- Utilisation des hooks PostgreSQL avec vos extensions TLE
- Utilisation de types de données personnalisés dans TLE
- Référence des fonctions pour Trusted Language Extensions pour PostgreSQL
- Référence des hooks pour Trusted Language Extensions pour PostgreSQL
Terminologie
Pour vous aider à mieux comprendre Trusted Language Extensions, consultez le glossaire suivant des termes utilisés dans cette rubrique.
- Trusted Language Extensions pour PostgreSQL
-
Trusted Language Extensions pour PostgreSQL est le nom officiel du kit de développement open source fourni en tant qu'extension
pg_tle
. Il peut être utilisé sur n'importe quel système PostgreSQL. Pour plus d'informations, consultez aws/pg_tleon. GitHub - Trusted Language Extensions
-
Trusted Language Extensions est le nom court de Trusted Language Extensions pour PostgreSQL. Ce nom court et son abréviation (TLE) sont également utilisés dans cette documentation.
- langage approuvé
-
Un langage approuvé est un langage de programmation ou de script doté d'attributs de sécurité spécifiques. Par exemple, les langages approuvés limitent généralement l'accès au système de fichiers et limitent l'utilisation de propriétés réseau spécifiées. Le kit de développement TLE est conçu pour prendre en charge les langages approuvés. PostgreSQL prend en charge plusieurs langages utilisés pour créer des extensions approuvées ou non approuvées. Pour voir un exemple, consultez Trusted and Untrusted PL/Perl
(Langage PL/Perl approuvé et non approuvé) dans la documentation PostgreSQL. Lorsque vous créez une extension à l'aide du kit Trusted Language Extensions, l'extension utilise intrinsèquement des mécanismes linguistiques approuvés. - extension TLE
-
Une extension TLE est une extension PostgreSQL créée à l'aide du kit de développement Trusted Language Extensions (TLE).
Exigences relatives à l'utilisation de Trusted Language Extensions pour PostgreSQL
Vous trouverez ci-dessous les exigences relatives à la configuration et à l'utilisation du kit de développement TLE.
Versions de RDS for PostgreSQL – Trusted Language Extensions est pris en charge sur RDS for PostgreSQL version 13.12 et versions 13 supérieures, version 14.5 et versions 14 supérieures et version 15.2 et versions supérieures uniquement.
Si vous devez mettre à niveau votre instance RDS for PostgreSQL, consultez Mise à niveau du moteur de base de SQL données Postgre pour Amazon RDS.
Si vous ne possédez pas encore d'instance de base de données Amazon RDS exécutant PostgreSQL, vous pouvez en créer un(e). Pour plus d’informations, consultez instance de base de données RDS for PostgreSQL, consultez Création et connexion à une instance de base de données PostgreSQL.
Nécessite les privilèges
rds_superuser
– Pour installer et configurer l'extensionpg_tle
, votre rôle d'utilisateur de base de données doit disposer des autorisations du rôlerds_superuser
. Par défaut, ce rôle est accordé à l'utilisateurpostgres
qui crée le Instance de base de données RDS for PostgreSQL.Nécessite un groupe de paramètres de base de données personnalisé : votre instance de base de données RDS for PostgreSQL doit être configurée avec un groupe de paramètres de base de données personnalisé.
Si votre instance de base de données RDS for PostgreSQL n'est pas configurée avec un groupe de paramètres de base de données personnalisé, vous devez en créer un(e) et l'associer à votre instance de base de données RDS for PostgreSQL. Pour un bref résumé des étapes, consultez Création et application d'un groupe de paramètres de base de données personnalisé.
Si votre instance de base de données RDS for PostgreSQL est déjà configurée à l'aide d'un groupe de paramètres de base de données personnalisé, vous pouvez configurer Trusted Language Extensions. Pour plus de détails, consultez Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Création et application d'un groupe de paramètres de base de données personnalisé
Utilisez les étapes suivantes pour créer un groupe de paramètres de base de données personnalisé et configurer votre instance de base de données RDS for PostgreSQL afin de l'utiliser.
Pour créer un groupe de paramètres de base de données personnalisé et l'utiliser avec votre instance de base de données RDS for PostgreSQL
Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/rds/
. Choisissez Parameter groups (Groupes de paramètres) dans le menu Amazon RDS.
Choisissez Créer un groupe de paramètres.
Dans la page Parameter group details (Détails des groupes de paramètres), entrez les informations suivantes.
Pour Parameter group family (Famille de groupes de paramètres), choisissez postgres14.
Pour Type, choisissez DB Parameter Group (Groupe de paramètres de base de données).
Pour Group name (Nom du groupe), attribuez un nom significatif à votre groupe de paramètres dans le contexte de vos opérations.
Pour Description, entrez une description utile afin que les autres membres de votre équipe puissent la trouver facilement.
Choisissez Créer. Votre groupe de paramètres de base de données personnalisé est créé dans votre Région AWS. Vous pouvez désormais modifier votre instance de base de données RDS for PostgreSQL afin de l'utiliser dans les étapes suivantes.
Choisissez Databases (Bases de données) dans le menu Amazon RDS.
Choisissez l'instance de base de données RDS for PostgreSQL que vous souhaitez utiliser avec TLE parmi les éléments répertoriés, puis choisissez Modify (Modifier).
Dans la page Modify DB instance settings (Modifier les paramètres d'instance de base de données), recherchez Database options (Options de base de données) dans la section Additional configuration (Configuration supplémentaire) et choisissez votre groupe de paramètres de base de données personnalisé dans le sélecteur.
Choisissez Continue (Continuer) pour enregistrer la modification.
Choisissez Apply immediately (Appliquer immédiatement) afin de continuer à configurer l'instance de base de données RDS for PostgreSQL pour utiliser TLE.
Pour continuer à configurer votre système pour Trusted Language Extensions, consultez Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Pour plus d'informations sur l'utilisation de groupes de paramètres de base de données, consultez Groupes de paramètres de base de données pour les instances de base de données RDSAmazon.
Vous pouvez éviter de spécifier l'argument --region
lorsque vous utilisez des commandes CLI en configurant votre AWS CLI
avec votre Région AWS par défaut. Pour plus d'informations, consultez Configuration basics (Principes de base de la configuration) dans le guide de l'utilisateur AWS Command Line Interface .
Pour créer un groupe de paramètres de base de données personnalisé et l'utiliser avec votre instance de base de données RDS for PostgreSQL
Utilisez la create-db-parameter-group AWS CLI commande pour créer un groupe de paramètres de base de données personnalisé basé sur pour votre. Région AWS
Pour LinuxmacOS, ou 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"Dans 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"Votre groupe de paramètres de base de données personnalisé est disponible dans votre Région AWS. Vous pouvez donc modifier l'instance de base de données RDS for PostgreSQL afin de l'utiliser.
Utilisez la modify-db-instance AWS CLI commande pour appliquer votre groupe de paramètres de base de données personnalisé à . votre instance de base de données RDS pour PostgreSQL. Cette commande redémarre immédiatement l'instance active.
Pour LinuxmacOS, ou Unix :
aws rds modify-db-instance \ --region
aws-region
\ --db-instance-identifieryour-instance-name
\ --db-parameter-group-namecustom-params-for-pg-tle
\ --apply-immediatelyDans Windows :
aws rds modify-db-instance ^ --region
aws-region
^ --db-instance-identifieryour-instance-name
^ --db-parameter-group-namecustom-params-for-pg-tle
^ --apply-immediately
Pour continuer à configurer votre système pour Trusted Language Extensions, consultez Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Pour plus d’informations, consultez Groupes de paramètres pour Amazon RDS.
Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL
Les étapes suivantes supposent que votre instance de base de données RDS for PostgreSQL est associée à un groupe de paramètres de base de données personnalisé. Vous pouvez utiliser le AWS Management Console ou AWS CLI pour effectuer ces étapes.
Lorsque vous configurez Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL, vous l'installez dans une base de données spécifique à l'usage des utilisateurs de base de données autorisés sur cette base de données.
Pour configurer Trusted Language Extensions
Effectuez les étapes suivantes à l'aide d'un compte membre du groupe (rôle) rds_superuser
.
Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/rds/
. -
Dans le volet de navigation, choisissez votre instance de base de données RDS for PostgreSQL.
-
Ouvrez l'onglet Configuration pour votre Instance de base de données RDS for PostgreSQL. Parmi les détails de l'instance, trouvez le lien Groupe de paramètres.
-
Cliquez sur le lien pour ouvrir les paramètres personnalisés associés à votre Instance de base de données RDS for PostgreSQL.
-
Dans le champ de recherche Parameters (Paramètres), tapez
shared_pre
pour trouver le paramètreshared_preload_libraries
. -
Choisissez Edit parameters (Modifier les paramètres) pour accéder aux valeurs des propriétés.
-
Ajoutez
pg_tle
à la liste dans le champ Values (Valeurs). Utilisez une virgule pour séparer les éléments de la liste de valeurs. Redémarrez l'instance de base de données RDS for PostgreSQL afin que vos modifications du paramètre
shared_preload_libraries
prennent effet.Lorsque l'instance est disponible, vérifiez que
pg_tle
a été initialisé. Utilisezpsql
pour vous connecter à l'instance de base de données RDS for PostgreSQL, puis exécutez la commande suivante.SHOW shared_preload_libraries;
shared_preload_libraries -------------------------- rdsutils,pg_tle (1 row)
Une fois l'extension
pg_tle
initialisée, vous pouvez maintenant créer l'extension.CREATE EXTENSION pg_tle;
Vous pouvez vérifier que l'extension est installée en utilisant la métacommande
psql
suivante.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
Accordez le rôle
pgtle_admin
au nom d'utilisateur principal que vous avez créé pour votre instance de base de données RDS for PostgreSQL lors de sa configuration. Si vous avez accepté la valeur par défaut, il s'agit depostgres
.labdb=>
GRANT pgtle_admin TO postgres;GRANT ROLE
Vous pouvez vérifier que l'octroi a eu lieu à l'aide de la métacommande
psql
, comme illustré dans l'exemple suivant. Seuls les rôlespgtle_admin
etpostgres
sont affichés dans la sortie. Pour plus d'informations, consultez Comprendre le rôle 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 |...
Fermez la session
psql
à l'aide de la métacommande\q
.\q
Pour commencer à créer des extensions TLE, consultez Exemple : création d'une extension de langage approuvé utilisant SQL.
Vous pouvez éviter de spécifier l'argument --region
lorsque vous utilisez des commandes CLI en configurant votre AWS CLI
avec votre Région AWS par défaut. Pour plus d'informations, consultez Configuration basics (Principes de base de la configuration) dans le guide de l'utilisateur AWS Command Line Interface .
Pour configurer Trusted Language Extensions
Utilisez la modify-db-parameter-group AWS CLI commande pour
pg_tle
ajouter aushared_preload_libraries
paramètre.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
-
Utilisez la reboot-db-instance AWS CLI commande pour redémarrer l'instance d' RDS pour PostgreSQL et initialiser la bibliothèque.
pg_tle
aws rds reboot-db-instance \ --db-instance-identifier
your-instance
\ --regionaws-region
Lorsque l'instance est disponible, vous pouvez vérifier que
pg_tle
a été initialisé. Utilisezpsql
pour vous connecter à l'instance de base de données RDS for PostgreSQL, puis exécutez la commande suivante.SHOW shared_preload_libraries;
shared_preload_libraries -------------------------- rdsutils,pg_tle (1 row)
Une fois
pg_tle
initialisé, vous pouvez maintenant créer l'extension.CREATE EXTENSION pg_tle;
Accordez le rôle
pgtle_admin
au nom d'utilisateur principal que vous avez créé pour votre instance de base de données RDS for PostgreSQL lors de sa configuration. Si vous avez accepté la valeur par défaut, il s'agit depostgres
.GRANT pgtle_admin TO postgres;
GRANT ROLE
Fermez la session
psql
comme suit.labdb=>
\q
Pour commencer à créer des extensions TLE, consultez Exemple : création d'une extension de langage approuvé utilisant SQL.
Présentation de Trusted Language Extensions pour PostgreSQL
Trusted Language Extensions pour PostgreSQL est une extension PostgreSQL que vous installez dans votre instance de base de données RDS for PostgreSQL de la même manière que vous configurez les autres extensions PostgreSQL. Dans l'image suivante d'un exemple de base de données dans l'outil client pgAdmin, vous pouvez voir certains des composants incluant l'extension pg_tle
.
![Image montrant certains composants du kit de développement TLE.](images/apg-pg_tle-installed-view-in-pgAdmin.png)
Vous pouvez voir les détails suivants.
-
Le kit de développement Trusted Language Extensions (TLE) pour PostgreSQL est fourni en tant qu'extension
pg_tle
. En tant que tel,pg_tle
est ajouté aux extensions disponibles pour la base de données dans laquelle il est installé. TLE a son propre schéma,
pgtle
. Ce schéma contient des fonctions d'assistance (3) pour installer et gérer les extensions que vous créez.TLE fournit plus d'une douzaine de fonctions d'assistance pour installer, enregistrer et gérer vos extensions. Pour en savoir plus sur ces fonctions, consultez Référence des fonctions pour Trusted Language Extensions pour PostgreSQL.
L'extension pg_tle
comprend les autres composants suivants :
Le rôle
pgtle_admin
: le rôlepgtle_admin
est créé lors de l'installation de l'extensionpg_tle
. Ce rôle est privilégié et doit être traité comme tel. Nous vous recommandons vivement de respecter le principe du moindre privilège lorsque vous accordez le rôlepgtle_admin
aux utilisateurs de base de données. En d'autres termes, accordez le rôlepgtle_admin
uniquement aux utilisateurs de base de données autorisés à créer, installer et gérer de nouvelles extensions TLE, telles quepostgres
.La table
pgtle.feature_info
: la tablepgtle.feature_info
est une table protégée qui contient des informations sur vos extensions TLE, vos hooks, ainsi que les procédures et fonctions stockées personnalisées qu'ils utilisent. Si vous disposez de privilègespgtle_admin
, vous pouvez utiliser les fonctions Trusted Language Extensions suivantes pour ajouter et mettre à jour ces informations dans la table.
Création d'extensions TLE pour RDS for PostgreSQL
Vous pouvez installer toutes les extensions que vous créez avec TLE dans n'importe quelle instance de base de données RDS for PostgreSQL disposant de l'extension pg_tle
. L'extension pg_tle
s'applique à la base de données PostgreSQL dans laquelle elle est installée. Les extensions que vous créez à l'aide de TLE sont appliquées à la même base de données.
Utilisez les différentes fonctions pgtle
pour installer le code qui constitue votre extension TLE. Les fonctions Trusted Language Extensions suivantes nécessitent toutes le rôle pgtle_admin
.
Exemple : création d'une extension de langage approuvé utilisant SQL
L'exemple suivant montre comment créer une extension TLE nommée pg_distance
et contenant quelques fonctions SQL permettant de calculer des distances à l'aide de différentes formules. Dans la liste, vous trouverez la fonction de calcul de la distance de Manhattan et la fonction de calcul de la distance euclidienne. Pour plus d'informations sur la différence entre ces formules, consultez Taxicab geometry
Vous pouvez utiliser cet exemple dans votre propre instance de base de données RDS for PostgreSQL si vous disposez de l'extension pg_tle
configurée comme indiqué dans Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Note
Vous devez disposer des privilèges du rôle pgtle_admin
pour suivre cette procédure.
Pour créer l'exemple d'extension TLE
Les étapes suivantes utilisent un exemple de base de données nommé labdb
. Cette base de données appartient à l'utilisateur principal postgres
. Le rôle postgres
possède également les autorisations du rôle pgtle_admin
.
Utilisez
psql
pour vous connecter à Instance de base de données RDS for PostgreSQL.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdbCréez une extension TLE nommée
pg_distance
en copiant le code suivant et en le collant dans votre console de sessionpsql
.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_$ );
Vous devez voir la sortie suivante.
install_extension --------------- t (1 row)
Les artefacts qui constituent l'extension
pg_distance
sont désormais installés dans votre base de données. Ces artefacts incluent le fichier de contrôle et le code de l'extension, qui sont des éléments qui doivent être présents pour que l'extension puisse être créée à l'aide de la commandeCREATE EXTENSION
. En d'autres termes, il vous reste à créer l'extension pour mettre ses fonctions à la disposition des utilisateurs de la base de données.Pour créer cette extension, utilisez la commande
CREATE EXTENSION
comme vous le feriez pour toute autre extension. Comme pour les autres extensions, l'utilisateur de la base de données doit disposer des autorisationsCREATE
dans la base de données.CREATE EXTENSION pg_distance;
Pour tester l'extension TLE
pg_distance
, vous pouvez l'utiliser pour calculer la distance de Manhattanentre quatre points. labdb=>
SELECT manhattan_dist(1, 1, 5, 5);
8
Pour calculer la distance euclidienne
entre le même ensemble de points, vous pouvez utiliser ce qui suit. labdb=>
SELECT euclidean_dist(1, 1, 5, 5);
5.656854249492381
L'extension pg_distance
charge les fonctions dans la base de données et les met à la disposition de tous les utilisateurs dotés d'autorisations sur la base de données.
Modification de votre extension TLE
Pour améliorer les performances des requêtes pour les fonctions incluses dans cette extension TLE, ajoutez les deux attributs PostgreSQL suivants à leurs spécifications.
IMMUTABLE
: l'attributIMMUTABLE
garantit que l'optimiseur de requêtes peut utiliser des optimisations pour améliorer les temps de réponse aux requêtes. Pour plus d'informations, consultez Function Volatility Categories(Catégories de volatilité des fonctions) dans la documentation PostgreSQL. PARALLEL SAFE
: l'attributPARALLEL SAFE
est un autre attribut qui permet à PostgreSQL d'exécuter la fonction en mode parallèle. Pour plus d'informations, consultez CREATE FUNCTIONdans la documentation PostgreSQL.
Dans l'exemple suivant, vous pouvez voir comment la fonction pgtle.install_update_path
est utilisée pour ajouter ces attributs à chaque fonction afin de créer une version 0.2
de l'extension TLE pg_distance
. Pour de plus amples informations sur cette fonction, veuillez consulter pgtle.install_update_path. Vous devez avoir le rôle pgtle_admin
pour effectuer cette tâche.
Pour mettre à jour une extension TLE existante et spécifier la version par défaut
Connectez-vous à l'instance de base de données RDS for PostgreSQL à l'aide de
psql
ou d'un autre outil client, tel que pgAdmin.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdbModifiez l'extension TLE existante en copiant le code suivant et en le collant dans votre console de session
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_$ );
Vous voyez une réponse similaire à la suivante.
install_update_path --------------------- t (1 row)
Vous pouvez faire de cette version de l'extension la version par défaut, afin que les utilisateurs de base de données n'aient pas à spécifier de version lorsqu'ils créent ou mettent à jour l'extension dans leur base de données.
Pour spécifier que la version modifiée (version 0.2) de votre extension TLE est la version par défaut, utilisez la fonction
pgtle.set_default_version
comme indiqué dans l'exemple suivant.SELECT pgtle.set_default_version('pg_distance', '0.2');
Pour de plus amples informations sur cette fonction, veuillez consulter pgtle.set_default_version.
Une fois le code en place, vous pouvez mettre à jour l'extension TLE installée de la manière habituelle, en utilisant la commande
ALTER EXTENSION ... UPDATE
, comme indiqué ici :ALTER EXTENSION pg_distance UPDATE;
Suppression de vos extensions TLE d'une base de données
Vous pouvez supprimer vos extensions TLE en utilisant la commande DROP EXTENSION
de la même manière que vous le feriez pour les autres extensions PostgreSQL. La suppression de l'extension ne supprime pas les fichiers d'installation qui composent l'extension et qui permettent aux utilisateurs de la recréer. Pour supprimer l'extension et ses fichiers d'installation, effectuez la procédure en deux étapes suivante.
Pour supprimer l'extension TLE et supprimer ses fichiers d'installation
Utilisez
psql
ou un autre outil client pour vous connecter à l'instance de base de données RDS for PostgreSQL..psql --host=
.111122223333
.aws-region
.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
Supprimez l'extension comme vous le feriez pour n'importe quelle extension PostgreSQL.
DROP EXTENSION
your-TLE-extension
Par exemple, si vous créez l'extension
pg_distance
comme détaillé dans Exemple : création d'une extension de langage approuvé utilisant SQL, vous pouvez la supprimer comme suit.DROP EXTENSION pg_distance;
Vous voyez une sortie confirmant que l'extension a été supprimée, comme suit.
DROP EXTENSION
À ce stade, l'extension n'est plus active dans la base de données. Cependant, ses fichiers d'installation et son fichier de contrôle sont toujours disponibles dans la base de données, ce qui permet aux utilisateurs de la base de données de recréer l'extension s'ils le souhaitent.
Si vous souhaitez garder intacts les fichiers d'extension afin que les utilisateurs de la base de données puissent créer votre extension TLE, vous pouvez vous arrêter ici.
Pour supprimer tous les fichiers qui composent l'extension, passez à l'étape suivante.
Pour supprimer tous les fichiers d'installation de votre extension, utilisez la fonction
pgtle.uninstall_extension
. Cette fonction supprime tous les fichiers de code et de contrôle relatifs à votre extension.SELECT pgtle.uninstall_extension('
your-tle-extension-name
');Par exemple, pour supprimer tous les fichiers d'installation
pg_distance
, utilisez la commande suivante.SELECT pgtle.uninstall_extension('pg_distance');
uninstall_extension --------------------- t (1 row)
Désinstallation de Trusted Language Extensions pour PostgreSQL
Si vous ne souhaitez plus créer vos propres extensions TLE à l'aide de TLE, vous pouvez supprimer l'extension pg_tle
et supprimer tous les artefacts. Cette action inclut la suppression de toutes les extensions TLE de la base de données et la suppression du schéma pgtle
.
Pour supprimer l'extension pg_tle
et son schéma d'une base de données
Utilisez
psql
ou un autre outil client pour vous connecter à l'instance de base de données RDS for PostgreSQL..psql --host=
.111122223333
.aws-region
.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=dbname
Supprimez l'extension
pg_tle
de la base de données. Si vos propres extensions TLE s'exécutent encore dans la base de données, vous devez les supprimer également. Pour ce faire, vous pouvez utiliser le mot cléCASCADE
, comme illustré ci-dessous.DROP EXTENSION pg_tle CASCADE;
Si l'extension
pg_tle
n'est toujours pas active dans la base de données, vous n'avez pas besoin d'utiliser le mot cléCASCADE
.Supprimez le schéma
pgtle
. Cette action supprime toutes les fonctions de gestion de la base de données.DROP SCHEMA pgtle CASCADE;
La commande renvoie ce qui suit une fois le processus terminé.
DROP SCHEMA
L'extension
pg_tle
, son schéma et ses fonctions, ainsi que tous les artefacts sont supprimés. Pour créer de nouvelles extensions à l'aide de TLE, répétez la procédure de configuration. Pour plus d’informations, consultez Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Utilisation des hooks PostgreSQL avec vos extensions TLE
Un hook est un mécanisme de rappel disponible dans PostgreSQL qui permet aux développeurs d'appeler des fonctions personnalisées ou d'autres routines lors d'opérations de base de données normales. Le kit de développement TLE prend en charge les hooks PostgreSQL afin que vous puissiez intégrer des fonctions personnalisées au comportement PostgreSQL au moment de l'exécution. Par exemple, vous pouvez utiliser un hook pour associer le processus d'authentification à votre propre code personnalisé, ou pour modifier le processus de planification et d'exécution des requêtes en fonction de vos besoins spécifiques.
Vos extensions TLE peuvent utiliser des hooks. Si un hook a une portée globale, il s'applique à toutes les bases de données. Par conséquent, si votre extension TLE utilise un hook global, vous devez créer votre extension TLE dans toutes les bases de données auxquelles vos utilisateurs peuvent accéder.
Lorsque vous utilisez l'extension pg_tle
pour créer votre propre kit Trusted Language Extensions, vous pouvez utiliser les hooks disponibles à partir d'une API SQL pour développer les fonctions de votre extension. Vous devez enregistrer tous les hooks avec pg_tle
. Pour certains hooks, vous devrez peut-être également définir différents paramètres de configuration. Par exemple, le hook de vérification passcode
peut être activé, désactivé ou requis. Pour plus d'informations sur les exigences spécifiques relatives aux hooks pg_tle
disponibles, consultez Référence des hooks pour Trusted Language Extensions pour PostgreSQL.
Exemple : création d'une extension utilisant un hook PostgreSQL
L'exemple présenté dans cette section utilise un hook PostgreSQL pour vérifier le mot de passe fourni lors d'opérations SQL spécifiques et empêche les utilisateurs de base de données de définir leurs mots de passe sur l'un de ceux contenus dans la table password_check.bad_passwords
. La table contient les dix choix de mots de passe les plus couramment utilisés, mais les plus faciles à déchiffrer.
Pour configurer cet exemple dans votre instance de base de données RDS for PostgreSQL, vous devez avoir déjà installé Trusted Language Extensions. Pour plus de détails, consultez Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL.
Pour configurer l'exemple de hook de vérification de mot de passe
Utilisez
psql
pour vous connecter à Instance de base de données RDS for PostgreSQL.psql --host=
db-instance-123456789012
.aws-region
.rds.amazonaws.com --port=5432
--username=postgres
--password --dbname=labdb
Copiez le code à partir de Listing du code du hook de vérification de mot de passe et collez-le dans votre base de données.
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_$ );
Lorsque l'extension a été chargée dans votre base de données, le résultat suivant s'affiche.
install_extension ------------------- t (1 row)
Toujours connecté à la base de données, vous pouvez maintenant créer l'extension.
CREATE EXTENSION my_password_check_rules;
Vous pouvez confirmer que l'extension a été créée dans la base de données à l'aide de la métacommande
psql
suivante.\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)
Ouvrez une autre session de terminal pour travailler avec le AWS CLI. Vous devez modifier votre groupe de paramètres de base de données personnalisé pour activer le hook de vérification de mot de passe. Pour ce faire, utilisez la commande modify-db-parameter-groupCLI comme indiqué dans l'exemple suivant.
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"Lorsque le paramètre est activé avec succès, le résultat suivant s'affiche.
( "DBParameterGroupName": "docs-lab-parameters-for-tle" }
L'application de la modification du groupe de paramètres peut prendre quelques minutes. Toutefois, ce paramètre étant dynamique, vous n'avez pas besoin de redémarrer l'instance de base de données RDS for PostgreSQL pour que le paramètre prenne effet.
Ouvrez la session
psql
et interrogez la base de données pour vérifier que le hook password_check a été activé.labdb=>
SHOW pgtle.enable_password_check;pgtle.enable_password_check ----------------------------- on (1 row)
Le hook de vérification de mot de passe est désormais actif. Vous pouvez le tester en créant un nouveau rôle et en utilisant l'un des mauvais mots de passe, comme illustré dans l'exemple suivant.
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)"
La sortie a été formatée pour être lisible.
L'exemple suivant montre que le comportement pgsql
de la métacomcommande interactive \password
est également affecté par le hook 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)"
Vous pouvez supprimer cette extension TLE et désinstaller ses fichiers sources si vous le souhaitez. Pour plus d’informations, consultez Suppression de vos extensions TLE d'une base de données.
Listing du code du hook de vérification de mot de passe
L'exemple de code affiché ici définit la spécification de l'extension TLE my_password_check_rules
. Lorsque vous copiez ce code et que vous le collez dans votre base de données, le code de l'extension my_password_check_rules
est chargé dans la base de données et le hook password_check
est enregistré pour être utilisé par l'extension.
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_$ );
Utilisation de types de données personnalisés dans TLE
PostgreSQL prend en charge les commandes permettant d'enregistrer de nouveaux types de base (également appelés types scalaires) pour un traitement efficace des structures de données complexes dans votre base de données. Un type de base vous permet de personnaliser la façon dont les données sont stockées en interne et la façon de les convertir vers et depuis une représentation textuelle externe. Ces types de données personnalisés sont utiles lors de l'extension de PostgreSQL pour prendre en charge des domaines fonctionnels dans lesquels un type intégré tel qu'un nombre ou un texte ne peut pas fournir une sémantique de recherche suffisante.
RDS for PostgreSQL vous permet de créer des types de données personnalisés dans votre extension de langage approuvé et de définir des fonctions qui prennent en charge les opérations SQL et d'index pour ces nouveaux types de données. Les types de données personnalisés sont disponibles pour les versions suivantes :
-
RDS for PostgreSQL 15.4 et versions 15 ultérieures
-
RDS for PostgreSQL 14.9 et versions 14 ultérieures
-
RDS for PostgreSQL 13.12 et versions 13 ultérieures
Pour plus d'informations, consultez Types de base de langage approuvé