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 pour 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](https://www.postgresql.org/docs/current/extend-extensions.html) (Empaquetage d’objets associés dans une extension) dans la documentation PostgreSQL.
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 pour 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 pour PostgreSQL :
+ Version 18.1 et versions supérieures 18 versions
+ Version 17.1 et versions 17 ultérieures
+ Version 16.1 et versions 16 ultérieures
+ Version 15.2 et versions 15 ultérieures
+ Version 14.5 et versions 14 ultérieures
+ Version 13.12 et versions 13 ultérieures
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 pour 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.
**Topics**
+ [Terminologie](PostgreSQL_trusted_language_extension-terminology.md)
+ [Exigences relatives à l’utilisation de Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension-requirements.md)
+ [Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md)
+ [Présentation de Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension.overview.md)
+ [Création d'extensions TLE pour RDS for PostgreSQL](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md)
+ [Suppression de vos extensions TLE d'une base de données](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md)
+ [Désinstallation de Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension-uninstalling-pg_tle-devkit.md)
+ [Utilisation des hooks PostgreSQL avec vos extensions TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md)
+ [Utilisation de types de données personnalisés dans TLE](PostgreSQL_trusted_language_extension-custom-data-type.md)
+ [Référence de fonction pour Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension-functions-reference.md)
+ [Référence des hooks pour Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension-hooks-reference.md)
# 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\$1tle](https://github.com/aws/pg_tle) sur 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](https://www.postgresql.org/docs/current/plperl-trusted.html) (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 pour PostgreSQL** : Trusted Language Extensions est pris en charge sur RDS pour PostgreSQL version 13.12 et versions 13 ultérieures, version 14.5 et versions 14 ultérieures et version 15.2 et versions ultérieures uniquement.
+ Si vous devez mettre à niveau votre instance RDS pour PostgreSQL, consultez [Mises à niveau du moteur de base de données RDS pour PostgreSQL](USER_UpgradeDBInstance.PostgreSQL.md).
+ 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 pour PostgreSQL, consultez [Création et connexion à une instance de base de données PostgreSQL](CHAP_GettingStarted.CreatingConnecting.PostgreSQL.md).
+ **Nécessite les privilèges `rds_superuser`** : pour installer et configurer l’extension `pg_tle`, votre rôle d’utilisateur de base de données doit disposer des autorisations du rôle `rds_superuser`. Par défaut, ce rôle est accordé à l’utilisateur `postgres` qui crée le Instance de base de données RDS pour PostgreSQL.
+ **Nécessite un groupe de paramètres de base de données personnalisé** : votre instance de base de données RDS pour 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 pour 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 pour 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é](#PostgreSQL_trusted_language_extension-requirements-create-custom-params).
+ Si votre instance de base de données RDS pour 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 en savoir plus, consultez [Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
## 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 pour PostgreSQL afin de l’utiliser.
### Console
**Pour créer un groupe de paramètres de base de données personnalisé et l'utiliser avec votre instance de RDS pour PostgreSQL**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Choisissez Parameter groups (Groupes de paramètres) dans le menu Amazon RDS.
1. Choisissez **Créer un groupe de paramètres**.
1. 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.
1. 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 pour PostgreSQL afin de l’utiliser dans les étapes suivantes.
1. Choisissez **Databases** (Bases de données) dans le menu Amazon RDS.
1. Choisissez l’instance de base de données RDS pour PostgreSQL que vous souhaitez utiliser avec TLE parmi les éléments répertoriés, puis choisissez **Modify** (Modifier).
1. 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.
1. Choisissez **Continue** (Continuer) pour enregistrer la modification.
1. Choisissez **Apply immediately** (Appliquer immédiatement) afin de continuer à configurer l’instance de base de données RDS pour 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](PostgreSQL_trusted_language_extension-setting-up.md).
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 Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md).
### AWS CLI
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 [Principes de base de la configuration](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) 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 RDS pour PostgreSQL**
1. Utilisez la [create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) 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 Linux, macOS ou Unix :
```
aws rds create-db-parameter-group \
--region aws-region \
--db-parameter-group-name custom-params-for-pg-tle \
--db-parameter-group-family postgres14 \
--description "My custom DB parameter group for Trusted Language Extensions"
```
Pour Windows :
```
aws rds create-db-parameter-group ^
--region aws-region ^
--db-parameter-group-name custom-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 pour PostgreSQL afin de l’utiliser.
1. Utilisez la [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 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 Linux, macOS ou Unix :
```
aws rds modify-db-instance \
--region aws-region \
--db-instance-identifier your-instance-name \
--db-parameter-group-name custom-params-for-pg-tle \
--apply-immediately
```
Pour Windows :
```
aws rds modify-db-instance ^
--region aws-region ^
--db-instance-identifier your-instance-name ^
--db-parameter-group-name custom-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](PostgreSQL_trusted_language_extension-setting-up.md).
Pour plus d'informations, consultez [Groupes de paramètres pour Amazon RDS](USER_WorkingWithParamGroups.md).
# 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 la 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.
## console
**Pour configurer Trusted Language Extensions**
Effectuez les étapes suivantes à l'aide d'un compte membre du groupe (rôle) `rds_superuser`.
1. Connectez-vous à la AWS Management Console et ouvrez la console Amazon RDS à l'adresse [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Dans le volet de navigation, choisissez votre instance de base de données RDS for PostgreSQL.
1. 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**.
1. Cliquez sur le lien pour ouvrir les paramètres personnalisés associés à votre Instance de base de données RDS for PostgreSQL.
1. Dans le champ de recherche **Parameters** (Paramètres), tapez `shared_pre` pour trouver le paramètre `shared_preload_libraries`.
1. Choisissez **Edit parameters** (Modifier les paramètres) pour accéder aux valeurs des propriétés.
1. Ajoutez `pg_tle` à la liste dans le champ **Values** (Valeurs). Utilisez une virgule pour séparer les éléments de la liste de valeurs.
![\[Image du paramètre shared_preload_libraries avec pg_tle ajouté.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pg_tle.png)
1. Redémarrez l'instance de base de données RDS for PostgreSQL afin que vos modifications du paramètre `shared_preload_libraries` prennent effet.
1. Lorsque l'instance est disponible, vérifiez que `pg_tle` a été initialisé. Utilisez `psql` 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)
```
1. 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
```
1. 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 de `postgres`.
```
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ôles `pgtle_admin` et `postgres` sont affichés dans la sortie. Pour plus d'informations, consultez [Comprendre le rôle rds\$1superuser](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md).
```
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 |...
```
1. 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](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
## AWS CLI
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) (Principes de base de la configuration) dans le *guide de l'utilisateur AWS Command Line Interface*.
**Pour configurer Trusted Language Extensions**
1. Utilisez la commande AWS CLI [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) pour ajouter `pg_tle` au paramètre `shared_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" \
--region aws-region
```
1. Utilisez la commande AWS CLI [reboot-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/reboot-db-instance) pour redémarrer l'instance de base de données RDS for PostgreSQL et initialiser la bibliothèque `pg_tle`.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Lorsque l'instance est disponible, vous pouvez vérifier que `pg_tle` a été initialisé. Utilisez `psql` 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;
```
1. 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 de `postgres`.
```
GRANT pgtle_admin TO postgres;
GRANT ROLE
```
1. 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](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example).
# 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.\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/UserGuide/images/apg-pg_tle-installed-view-in-pgAdmin.png)
Vous pouvez voir les détails suivants.
1. 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é.
1. 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.
1. 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 de fonction pour Trusted Language Extensions pour PostgreSQL](PostgreSQL_trusted_language_extension-functions-reference.md).
L'extension `pg_tle` comprend les autres composants suivants :
+ **Le rôle `pgtle_admin`** : le rôle `pgtle_admin` est créé lors de l'installation de l'extension `pg_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ôle `pgtle_admin` aux utilisateurs de base de données. En d'autres termes, accordez le rôle `pgtle_admin` uniquement aux utilisateurs de base de données autorisés à créer, installer et gérer de nouvelles extensions TLE, telles que `postgres`.
+ **La table `pgtle.feature_info`** : la table `pgtle.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èges `pgtle_admin`, vous pouvez utiliser les fonctions Trusted Language Extensions suivantes pour ajouter et mettre à jour ces informations dans la table.
+ [pgtle.register\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature_if_not_exists)
+ [pgtle.unregister\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature_if_exists)
# 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`.
+ [pgtle.install\$1extension](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_extension)
+ [pgtle.install\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.install_update_path)
+ [pgtle.register\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.register_feature_if_not_exists)
+ [pgtle.set\$1default\$1version](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.set_default_version)
+ [pgtle.uninstall\$1extension(name)](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension-name)
+ [pgtle.uninstall\$1extension(name, version)](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension-name-version)
+ [pgtle.uninstall\$1extension\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_extension_if_exists)
+ [pgtle.uninstall\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_update_path)
+ [pgtle.uninstall\$1update\$1path\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.uninstall_update_path_if_exists)
+ [pgtle.unregister\$1feature](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.unregister_feature_if_exists)
## 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](https://en.wikipedia.org/wiki/Taxicab_geometry) (Géométrie de Manhattan) et [Euclidean geometry](https://en.wikipedia.org/wiki/Euclidean_geometry) (Géométrie euclidienne) sur Wikipedia.
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](PostgreSQL_trusted_language_extension-setting-up.md).
**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`.
1. Utilisez `psql` pour vous connecter à Instance de base de données RDS pour PostgreSQL.
```
psql --host=db-instance-123456789012.aws-region.rds.amazonaws.com
--port=5432 --username=postgres --password --dbname=labdb
```
1. Créez une extension TLE nommée `pg_distance` en copiant le code suivant et en le collant dans votre console de session `psql`.
```
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 commande `CREATE 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.
1. 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 autorisations `CREATE` dans la base de données.
```
CREATE EXTENSION pg_distance;
```
1. Pour tester l'extension TLE `pg_distance`, vous pouvez l'utiliser pour calculer la [distance de Manhattan](https://en.wikipedia.org/wiki/Taxicab_geometry) entre quatre points.
```
labdb=> SELECT manhattan_dist(1, 1, 5, 5);
8
```
Pour calculer la [distance euclidienne](https://en.wikipedia.org/wiki/Euclidean_geometry) 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'attribut `IMMUTABLE` 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](https://www.postgresql.org/docs/current/xfunc-volatility.html) (Catégories de volatilité des fonctions) dans la documentation PostgreSQL.
+ `PARALLEL SAFE` : l'attribut `PARALLEL SAFE` est un autre attribut qui permet à PostgreSQL d'exécuter la fonction en mode parallèle. Pour plus d’informations, consultez [CREATE FUNCTION](https://www.postgresql.org/docs/current/sql-createfunction.html) dans 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 plus d’informations sur cette fonction, consultez [pgtle.install\$1update\$1path](PostgreSQL_trusted_language_extension-functions-reference.md#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**
1. 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=labdb
```
1. Modifiez 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.
1. 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 plus d’informations sur cette fonction, consultez [pgtle.set\$1default\$1version](PostgreSQL_trusted_language_extension-functions-reference.md#pgtle.set_default_version).
1. 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**
1. 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
```
1. 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](PostgreSQL_trusted_language_extension-creating-TLE-extensions.md#PostgreSQL_trusted_language_extension-simple-example), 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.
1. 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**
1. 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
```
1. 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`.
1. 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 de plus amples informations, consultez [Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
# 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](PostgreSQL_trusted_language_extension-hooks-reference.md).
## 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 en savoir plus, consultez [Configuration de Trusted Language Extensions dans votre instance de base de données RDS for PostgreSQL](PostgreSQL_trusted_language_extension-setting-up.md).
**Pour configurer l'exemple de hook de vérification de mot de passe**
1. 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
```
1. Copiez le code à partir de [Listing du code du hook de vérification de mot de passe](#PostgreSQL_trusted_language_extension-example-hook_code_listing) 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 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)
```
1. Toujours connecté à la base de données, vous pouvez maintenant créer l'extension.
```
CREATE EXTENSION my_password_check_rules;
```
1. 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)
```
1. Ouvrez une autre session de terminal pour travailler avec 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 CLI [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html), comme illustré dans l'exemple suivant.
```
aws rds modify-db-parameter-group \
--region aws-region \
--db-parameter-group-name your-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.
1. Ouvrez la session `psql` et interrogez la base de données pour vérifier que le hook password\$1check 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\$1check.
```
postgres=> SET password_encryption TO 'md5';
SET
postgres=> \password
Enter 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 de plus amples informations, consultez [Suppression de vos extensions TLE d'une base de donnéesSuppression de vos extensions TLE d'une base de données](PostgreSQL_trusted_language_extension-creating-TLE-extensions.dropping-TLEs.md).
### 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 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é](https://github.com/aws/pg_tle/blob/main/docs/09_datatypes.md) (langue française non garantie).
# Référence de fonction pour Trusted Language Extensions pour PostgreSQL
Consultez la documentation de référence suivante sur les fonctions disponibles dans Trusted Language Extensions pour PostgreSQL. Utilisez ces fonctions pour installer, enregistrer, mettre à jour et gérer vos *extensions TLE*, c'est-à-dire les extensions PostgreSQL que vous développez à l'aide du kit de développement Trusted Language Extensions.
**Topics**
+ [pgtle.available\$1extensions](#pgtle.available_extensions)
+ [pgtle.available\$1extension\$1versions](#pgtle.available_extension_versions)
+ [pgtle.extension\$1update\$1paths](#pgtle.extension_update_paths)
+ [pgtle.install\$1extension](#pgtle.install_extension)
+ [pgtle.install\$1update\$1path](#pgtle.install_update_path)
+ [pgtle.register\$1feature](#pgtle.register_feature)
+ [pgtle.register\$1feature\$1if\$1not\$1exists](#pgtle.register_feature_if_not_exists)
+ [pgtle.set\$1default\$1version](#pgtle.set_default_version)
+ [pgtle.uninstall\$1extension(name)](#pgtle.uninstall_extension-name)
+ [pgtle.uninstall\$1extension(name, version)](#pgtle.uninstall_extension-name-version)
+ [pgtle.uninstall\$1extension\$1if\$1exists](#pgtle.uninstall_extension_if_exists)
+ [pgtle.uninstall\$1update\$1path](#pgtle.uninstall_update_path)
+ [pgtle.uninstall\$1update\$1path\$1if\$1exists](#pgtle.uninstall_update_path_if_exists)
+ [pgtle.unregister\$1feature](#pgtle.unregister_feature)
+ [pgtle.unregister\$1feature\$1if\$1exists](#pgtle.unregister_feature_if_exists)
## pgtle.available\$1extensions
La fonction `pgtle.available_extensions` est une fonction à renvoi d'ensemble. Elle renvoie toutes les extensions TLE disponibles dans la base de données. Chaque ligne renvoyée contient des informations sur une seule extension TLE.
### Prototype de fonction
```
pgtle.available_extensions()
```
### Rôle
Aucune.
### Arguments
Aucune.
### Sortie
+ `name` : nom de l'extension TLE.
+ `default_version` : la version de l'extension TLE à utiliser lorsque la commande `CREATE EXTENSION` est appelée sans version spécifiée.
+ `description` : une description plus détaillée de l'extension TLE.
### Exemple d'utilisation
```
SELECT * FROM pgtle.available_extensions();
```
## pgtle.available\$1extension\$1versions
La fonction `available_extension_versions` est une fonction à renvoi d'ensemble. Elle renvoie une liste de toutes les extensions TLE disponibles et de leurs versions. Chaque ligne contient des informations sur une version spécifique de l'extension TLE donnée, y compris si elle nécessite un rôle spécifique.
### Prototype de fonction
```
pgtle.available_extension_versions()
```
### Rôle
Aucune.
### Arguments
Aucune.
### Sortie
+ `name` : nom de l'extension TLE.
+ `version` : version de l'extension TLE.
+ `superuser` : cette valeur est toujours `false` pour vos extensions TLE. Les autorisations nécessaires pour créer l'extension TLE ou la mettre à jour sont les mêmes que pour la création d'autres objets dans la base de données donnée.
+ `trusted` : cette valeur est toujours `false` pour une extension TLE.
+ `relocatable` : cette valeur est toujours `false` pour une extension TLE.
+ `schema` : spécifie le nom du schéma dans lequel l'extension TLE est installée.
+ `requires` : tableau contenant les noms des autres extensions requises par cette extension TLE.
+ `description` : description détaillée de l'extension TLE.
Pour obtenir plus d'informations sur les valeurs de sortie, consultez la section [Packaging Related Objects into an Extension > Extension Files](https://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) (Packaging des objets connexes dans une extension > Fichiers d'extension) dans la documentation de PostgreSQL.
### Exemple d'utilisation
```
SELECT * FROM pgtle.available_extension_versions();
```
## pgtle.extension\$1update\$1paths
La fonction `extension_update_paths` est une fonction à renvoi d'ensemble. Elle renvoie une liste de tous les chemins de mise à jour possibles pour une extension TLE. Chaque ligne comprend les mises à niveau ou les rétrogradations disponibles pour cette extension TLE.
### Prototype de fonction
```
pgtle.extension_update_paths(name)
```
### Rôle
Aucune.
### Arguments
`name` : nom de l'extension TLE à partir de laquelle obtenir les chemins de mise à niveau.
### Sortie
+ `source` : version source d'une mise à jour.
+ `target` : version cible d'une mise à jour.
+ `path` : chemin de mise à niveau utilisé pour mettre à jour une extension TLE d'une version `source` à une version `target`, par exemple, `0.1--0.2`.
### Exemple d'utilisation
```
SELECT * FROM pgtle.extension_update_paths('your-TLE');
```
## pgtle.install\$1extension
La fonction `install_extension` vous permet d'installer les artefacts qui composent votre extension TLE dans la base de données, après quoi elle peut être créée à l'aide de la commande `CREATE EXTENSION`.
### Prototype de fonction
```
pgtle.install_extension(name text, version text, description text, ext text, requires text[] DEFAULT NULL::text[])
```
### Rôle
Aucune.
### Arguments
+ `name` : nom de l'extension TLE. Cette valeur est utilisée lors d’un appel de `CREATE EXTENSION`.
+ `version` : version de l'extension TLE.
+ `description` : description détaillée de l'extension TLE. Cette description est affichée dans le champ `comment` de `pgtle.available_extensions()`.
+ `ext` : contenu de l'extension TLE. Cette valeur contient des objets tels que des fonctions.
+ `requires` : paramètre facultatif qui spécifie les dépendances pour cette extension TLE. L'extension `pg_tle` est automatiquement ajoutée en tant que dépendance.
Plusieurs de ces arguments sont les mêmes que ceux qui sont inclus dans un fichier de contrôle d'extension pour installer une extension PostgreSQL sur le système de fichiers d'une instance PostgreSQL. Pour plus d'informations, consultez [Extension Files](http://www.postgresql.org/docs/current/extend-extensions.html#id-1.8.3.20.11) (Fichiers d'extension) dans [Packaging Related Objects into an Extension](https://www.postgresql.org/docs/current/extend-extensions.html) (Packaging des objets connexes dans une extension) de la documentation PostgreSQL.
### Sortie
Cette fonction renvoie `OK` en cas de réussite ou `NULL` en cas d'erreur.
+ `OK` : l'extension TLE a été installée avec succès dans la base de données.
+ `NULL` : l'extension TLE n'a pas été installée dans la base de données.
### Exemple d'utilisation
```
SELECT pgtle.install_extension(
'pg_tle_test',
'0.1',
'My first pg_tle extension',
$_pgtle_$
CREATE FUNCTION my_test()
RETURNS INT
AS $$
SELECT 42;
$$ LANGUAGE SQL IMMUTABLE;
$_pgtle_$
);
```
## pgtle.install\$1update\$1path
La fonction `install_update_path` fournit un chemin de mise à jour entre deux versions différentes d'une extension TLE. Cette fonction permet aux utilisateurs de votre extension TLE de mettre à jour sa version en utilisant la syntaxe `ALTER EXTENSION ... UPDATE`.
### Prototype de fonction
```
pgtle.install_update_path(name text, fromvers text, tovers text, ext text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `name` : nom de l'extension TLE. Cette valeur est utilisée lors d’un appel de `CREATE EXTENSION`.
+ `fromvers` : version source de l'extension TLE pour la mise à niveau.
+ `tovers` : version de destination de l'extension TLE pour la mise à niveau.
+ `ext` : contenu de la mise à jour. Cette valeur contient des objets tels que des fonctions.
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT pgtle.install_update_path('pg_tle_test', '0.1', '0.2',
$_pgtle_$
CREATE OR REPLACE FUNCTION my_test()
RETURNS INT
AS $$
SELECT 21;
$$ LANGUAGE SQL IMMUTABLE;
$_pgtle_$
);
```
## pgtle.register\$1feature
La fonction `register_feature` ajoute la fonctionnalité interne PostgreSQL spécifiée à la table `pgtle.feature_info`. Les hooks PostgreSQL sont un exemple de fonctionnalité interne de PostgreSQL. Le kit de développement Trusted Language Extensions prend en charge l'utilisation des hooks PostgreSQL. Actuellement, cette fonction prend en charge la fonctionnalité suivante.
+ `passcheck` : enregistre le hook de vérification de mot de passe avec votre procédure ou fonction qui personnalise le comportement de vérification de mot de passe de PostgreSQL.
### Prototype de fonction
```
pgtle.register_feature(proc regproc, feature pg_tle_feature)
```
### Rôle
`pgtle_admin`
### Arguments
+ `proc` : nom d'une procédure ou d'une fonction stockée à utiliser pour la fonctionnalité.
+ `feature` : nom de la fonctionnalité `pg_tle` (tel que `passcheck`) à enregistrer avec la fonction.
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT pgtle.register_feature('pw_hook', 'passcheck');
```
## pgtle.register\$1feature\$1if\$1not\$1exists
La fonction `pgtle.register_feature_if_not_exists` ajoute la fonctionnalité PostgreSQL spécifiée à la table `pgtle.feature_info` et identifie l'extension TLE ou toute autre procédure ou fonction qui utilise la fonctionnalité. Pour plus d'informations sur les hooks et le kit Trusted Language Extensions, consultez [Utilisation des hooks PostgreSQL avec vos extensions TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md).
### Prototype de fonction
```
pgtle.register_feature_if_not_exists(proc regproc, feature pg_tle_feature)
```
### Rôle
`pgtle_admin`
### Arguments
+ `proc` : nom d'une procédure ou d'une fonction stockée qui contient la logique (code) à utiliser comme fonctionnalité pour votre extension TLE. Par exemple, le code `pw_hook`.
+ `feature` : nom de la fonctionnalité PostgreSQL à enregistrer pour la fonction TLE. Actuellement, la seule fonctionnalité disponible est le hook `passcheck`. Pour plus d’informations, consultez [Crochet de vérification du mot de passe (passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Sortie
Renvoie `true` après l'enregistrement de la fonction pour l'extension spécifiée. Renvoie `false` si la fonctionnalité est déjà enregistrée.
### Exemple d'utilisation
```
SELECT pgtle.register_feature_if_not_exists('pw_hook', 'passcheck');
```
## pgtle.set\$1default\$1version
La fonction `set_default_version` vous permet de spécifier une valeur `default_version` pour votre extension TLE. Vous pouvez utiliser cette fonction pour définir un chemin de mise à niveau et désigner la version comme étant la version par défaut pour votre extension TLE. Lorsque les utilisateurs de la base de données spécifient votre extension TLE dans les commandes `CREATE EXTENSION` et `ALTER EXTENSION ... UPDATE`, cette version de votre extension TLE est créée dans la base de données pour cet utilisateur.
Cette fonction renvoie `true` en cas de réussite. Si l'extension TLE spécifiée dans l'argument `name` n'existe pas, la fonction renvoie une erreur. De même, si la `version` de l'extension TLE n'existe pas, elle renvoie une erreur.
### Prototype de fonction
```
pgtle.set_default_version(name text, version text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `name` : nom de l'extension TLE. Cette valeur est utilisée lors d’un appel de `CREATE EXTENSION`.
+ `version` : version de l'extension TLE à définir par défaut.
### Sortie
+ `true` : lorsque la définition de la version par défaut réussit, la fonction renvoie `true`.
+ `ERROR` : renvoie un message d'erreur si une extension TLE avec le nom ou la version spécifiés n'existe pas.
### Exemple d'utilisation
```
SELECT * FROM pgtle.set_default_version('my-extension', '1.1');
```
## pgtle.uninstall\$1extension(name)
La fonction `uninstall_extension` supprime toutes les versions d'une extension TLE d'une base de données. Cette fonction empêche les appels futurs de `CREATE EXTENSION` d'installer l'extension TLE. Si l'extension TLE n'existe pas dans la base de données, une erreur est signalée.
La fonction `uninstall_extension` n'abandonne pas une extension TLE qui est actuellement active dans la base de données. Pour supprimer une extension TLE actuellement active, vous devez appeler explicitement `DROP EXTENSION`.
### Prototype de fonction
```
pgtle.uninstall_extension(extname text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `extname` : nom de l'extension TLE à désinstaller. Ce nom est le même que celui utilisé avec `CREATE EXTENSION` pour charger l'extension TLE à utiliser dans une base de données spécifiée.
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test');
```
## pgtle.uninstall\$1extension(name, version)
La fonction `uninstall_extension(name, version)` supprime la version spécifiée de l'extension TLE de la base de données. Cette fonction empêche `CREATE EXTENSION` et `ALTER EXTENSION` d'installer ou de mettre à jour une extension TLE à la version spécifiée. Cette fonction supprime également tous les chemins de mise à jour pour la version spécifiée de l'extension TLE. Cette fonction ne désinstallera pas l'extension TLE si elle est actuellement active dans la base de données. Vous devez appeler explicitement `DROP EXTENSION` pour retirer l'extension TLE. Pour désinstaller toutes les versions d'une extension TLE, consultez [pgtle.uninstall\$1extension(name)](#pgtle.uninstall_extension-name).
### Prototype de fonction
```
pgtle.uninstall_extension(extname text, version text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `extname` : nom de l'extension TLE. Cette valeur est utilisée lors d'un appel de `CREATE EXTENSION`.
+ `version` : la version de l'extension TLE à désinstaller de la base de données.
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT * FROM pgtle.uninstall_extension('pg_tle_test', '0.2');
```
## pgtle.uninstall\$1extension\$1if\$1exists
La fonction `uninstall_extension_if_exists` supprime toutes les versions d'une extension TLE d'une base de données spécifiée. Si l'extension TLE n'existe pas, la fonction ne renvoie rien (aucun message d'erreur n'est affiché). Si l'extension spécifiée est actuellement active dans une base de données, cette fonction ne la supprime pas. Vous devez explicitement appeler `DROP EXTENSION` pour supprimer l'extension TLE avant d'utiliser cette fonction pour désinstaller ses artefacts.
### Prototype de fonction
```
pgtle.uninstall_extension_if_exists(extname text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `extname` : nom de l'extension TLE. Cette valeur est utilisée lors d’un appel de `CREATE EXTENSION`.
### Sortie
La fonction `uninstall_extension_if_exists` renvoie `true` après avoir désinstallé l'extension spécifiée. Si l'extension spécifiée n'existe pas, la fonction renvoie `false`.
+ `true` : renvoie `true` après la désinstallation de l'extension TLE.
+ `false` : renvoie `false` lorsque l'extension TLE n'existe pas dans la base de données.
### Exemple d'utilisation
```
SELECT * FROM pgtle.uninstall_extension_if_exists('pg_tle_test');
```
## pgtle.uninstall\$1update\$1path
La fonction `uninstall_update_path` supprime le chemin de mise à jour spécifique pour l'extension TLE. Cela empêche `ALTER EXTENSION ... UPDATE TO` de l'utiliser comme chemin de mise à jour.
Si l'extension TLE est actuellement utilisée par l'une des versions de ce chemin de mise à jour, elle reste dans la base de données.
Si le chemin de mise à jour spécifié n'existe pas, cette fonction génère une erreur.
### Prototype de fonction
```
pgtle.uninstall_update_path(extname text, fromvers text, tovers text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `extname` : nom de l'extension TLE. Cette valeur est utilisée lors de l'appel de `CREATE EXTENSION`.
+ `fromvers` : la version source de l'extension TLE utilisée sur le chemin de mise à jour.
+ `tovers` : la version destination de l'extension TLE utilisée sur le chemin de mise à jour.
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT * FROM pgtle.uninstall_update_path('pg_tle_test', '0.1', '0.2');
```
## pgtle.uninstall\$1update\$1path\$1if\$1exists
La fonction `uninstall_update_path_if_exists` est similaire à `uninstall_update_path`, car elle supprime le chemin de mise à jour spécifié d'une extension TLE. Toutefois, si le chemin de mise à jour n'existe pas, cette fonction ne renvoie pas de message d'erreur. Au lieu de cela, la fonction renvoie `false`.
### Prototype de fonction
```
pgtle.uninstall_update_path_if_exists(extname text, fromvers text, tovers text)
```
### Rôle
`pgtle_admin`
### Arguments
+ `extname` : nom de l'extension TLE. Cette valeur est utilisée lors de l'appel de `CREATE EXTENSION`.
+ `fromvers` : la version source de l'extension TLE utilisée sur le chemin de mise à jour.
+ `tovers` : la version destination de l'extension TLE utilisée sur le chemin de mise à jour.
### Sortie
+ `true` : la fonction a mis à jour avec succès le chemin pour l'extension TLE.
+ `false` : la fonction n'a pas pu mettre à jour le chemin pour l'extension TLE.
### Exemple d'utilisation
```
SELECT * FROM pgtle.uninstall_update_path_if_exists('pg_tle_test', '0.1', '0.2');
```
## pgtle.unregister\$1feature
La fonction `unregister_feature` permet de supprimer les fonctions qui ont été enregistrées pour utiliser des fonctionnalités `pg_tle`, telles que les hooks. Pour obtenir des informations sur l'enregistrement d'une fonctionnalité, consultez [pgtle.register\$1feature](#pgtle.register_feature).
### Prototype de fonction
```
pgtle.unregister_feature(proc regproc, feature pg_tle_features)
```
### Rôle
`pgtle_admin`
### Arguments
+ `proc` : nom d'une fonction stockée à enregistrer avec une fonctionnalité `pg_tle`.
+ `feature` : nom de la fonctionnalité `pg_tle` à enregistrer avec la fonction. Par exemple, `passcheck` est une fonctionnalité qui peut être enregistrée pour être utilisée par les extensions Trusted Language Extensions (TLE) que vous développez. Pour plus d’informations, consultez [Crochet de vérification du mot de passe (passcheck)](PostgreSQL_trusted_language_extension-hooks-reference.md#passcheck_hook).
### Sortie
Aucune.
### Exemple d'utilisation
```
SELECT * FROM pgtle.unregister_feature('pw_hook', 'passcheck');
```
## pgtle.unregister\$1feature\$1if\$1exists
La fonction `unregister_feature` permet de supprimer les fonctions qui ont été enregistrées pour utiliser des fonctionnalités `pg_tle`, telles que les hooks. Pour plus d’informations, consultez [Utilisation des hooks PostgreSQL avec vos extensions TLE](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md). Renvoie `true` après avoir réussi à annuler l'enregistrement de la fonctionnalité. Renvoie `false` si la fonctionnalité n'a pas été enregistrée.
Pour obtenir des informations sur l'enregistrement de fonctionnalités `pg_tle` pour vos extensions TLE, consultez [pgtle.register\$1feature](#pgtle.register_feature).
### Prototype de fonction
```
pgtle.unregister_feature_if_exists('proc regproc', 'feature pg_tle_features')
```
### Rôle
`pgtle_admin`
### Arguments
+ `proc` : nom de la fonction stockée qui a été enregistrée pour inclure une fonctionnalité `pg_tle`.
+ `feature` : nom de la fonctionnalité `pg_tle` qui a été enregistrée avec l'extension de langage approuvé.
### Sortie
Renvoie `true` ou `false`, comme suit.
+ `true` : la fonction a annulé l'enregistrement de la fonctionnalité à l'extension.
+ `false` : la fonction n'a pas pu annuler l'enregistrement de la fonctionnalité à l'extension TLE.
### Exemple d'utilisation
```
SELECT * FROM pgtle.unregister_feature_if_exists('pw_hook', 'passcheck');
```
# Référence des hooks pour Trusted Language Extensions pour PostgreSQL
Le kit Trusted Language Extensions pour PostgreSQL prend en charge les hooks PostgreSQL. Un *hook* est un mécanisme de rappel interne mis à la disposition des développeurs pour étendre les fonctionnalités de base de PostgreSQL. En utilisant des hooks, les développeurs peuvent implémenter leurs propres fonctions ou procédures à utiliser lors de diverses opérations de base de données, modifiant ainsi le comportement de PostgreSQL. Par exemple, vous pouvez utiliser un hook `passcheck` pour personnaliser la façon dont PostgreSQL gère les mots de passe fournis lors de la création ou de la modification de mots de passe pour les utilisateurs (rôles).
Consultez la documentation suivante pour en savoir plus sur le hook passcheck disponible pour vos extensions TLE. Pour en savoir plus sur les hooks disponibles, y compris le hook d’authentification client, consultez [Hooks Trusted Language Extensions](https://github.com/aws/pg_tle/blob/main/docs/04_hooks.md).
## Crochet de vérification du mot de passe (passcheck)
Le crochet `passcheck` permet de personnaliser le comportement de PostgreSQL pendant le processus de vérification du mot de passe pour les commandes SQL et la métacommande `psql`suivantes.
+ `CREATE ROLE username ...PASSWORD` : pour plus d’informations, consultez [CREATE USER](https://www.postgresql.org/docs/current/sql-createrole.html) (CRÉER UN RÔLE) dans la documentation PostgreSQL.
+ `ALTER ROLE username...PASSWORD` : pour plus d’informations, consultez [ALTER ROLE](https://www.postgresql.org/docs/current/sql-alterrole.html) (ALTÉRER UN RÔLE) dans la documentation PostgreSQL.
+ `\password username` : cette métacommande `psql` interactive modifie de manière sécurisée le mot de passe de l’utilisateur spécifié en hachant le mot de passe avant d’utiliser la syntaxe `ALTER ROLE ... PASSWORD` de manière transparente. La métacommande est un encapsuleur sécurisé pour la commande `ALTER ROLE ... PASSWORD`, et le crochet s’applique donc au comportement de la métacommande `psql`.
Pour obtenir un exemple, consultez [Listing du code du hook de vérification de mot de passe](PostgreSQL_trusted_language_extension.overview.tles-and-hooks.md#PostgreSQL_trusted_language_extension-example-hook_code_listing).
**Contents**
+ [Prototype de fonction](#passcheck_hook-prototype)
+ [Arguments](#passcheck_hook-arguments)
+ [Configuration](#passcheck_hook-configuration)
+ [Notes d’utilisation](#passcheck_hook-usage)
### Prototype de fonction
```
passcheck_hook(username text, password text, password_type pgtle.password_types, valid_until timestamptz, valid_null boolean)
```
### Arguments
Une fonction de crochet `passcheck` accepte les arguments suivants.
+ `username` : nom (sous forme de texte) du rôle (nom d’utilisateur) qui définit un mot de passe.
+ `password` : texte brut ou mot de passe haché. Le mot de passe saisi doit correspondre au type spécifié dans `password_type`.
+ `password_type` : spécifiez le format `pgtle.password_type` du mot de passe. Ce format peut être l’une des options suivantes.
+ `PASSWORD_TYPE_PLAINTEXT` : un mot de passe en texte brut.
+ `PASSWORD_TYPE_MD5`— Un mot de passe haché à l'aide de l'algorithme MD5 (message digest 5).
+ `PASSWORD_TYPE_SCRAM_SHA_256` : un mot de passe qui a été haché en utilisant l’algorithme SCRAM-SHA-256.
+ `valid_until` : spécifiez l’heure à laquelle le mot de passe devient invalide. Cet argument est facultatif. Si vous utilisez cet argument, spécifiez l’heure comme une valeur `timestamptz`.
+ `valid_null` : si cette valeur booléenne est définie sur `true`, l’option `valid_until` est définie sur `NULL`.
### Configuration
La fonction `pgtle.enable_password_check` contrôle si le crochet passcheck est actif. Le crochet passcheck a trois paramètres possibles.
+ `off` : désactive le crochet de vérification du mot de passe `passcheck`. C’est la valeur par défaut.
+ `on` : active le crochet de vérification du mot de passe `passcode` afin que les mots de passe soient vérifiés dans la table.
+ `require` : nécessite la définition d’un crochet de vérification du mot de passe.
### Notes d’utilisation
Pour activer ou désactiver le crochet `passcheck`, vous devez modifier le groupe de paramètres de base de données personnalisé pour votre instance de base de données RDS pour PostgreSQL.
Pour Linux, macOS ou Unix :
```
aws rds modify-db-parameter-group \
--region aws-region \
--db-parameter-group-name your-custom-parameter-group \
--parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"
```
Pour Windows :
```
aws rds modify-db-parameter-group ^
--region aws-region ^
--db-parameter-group-name your-custom-parameter-group ^
--parameters "ParameterName=pgtle.enable_password_check,ParameterValue=on,ApplyMethod=immediate"
```