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 la prise en charge de la délégation des extensions Amazon Aurora pour PostgreSQL
Grâce à la prise en charge de la délégation des extensions d’Amazon Aurora pour PostgreSQL, vous pouvez déléguer la gestion des extensions à un utilisateur qui n’a pas besoin d’être un `rds_superuser`. Avec cette prise en charge de la délégation des extensions, un rôle appelé `rds_extension` est créé. Vous devrez l’attribuer à un utilisateur pour qu’il puisse gérer les autres extensions. Ce rôle peut créer, mettre à jour et supprimer des extensions.
Vous pouvez spécifier les extensions qui peuvent être installées sur votre instance de base de données Aurora PostgreSQL, en les répertoriant dans le paramètre `rds.allowed_extensions`. Pour en savoir plus, consultez [Utilisation des extensions PostgreSQL avec Amazon RDS pour PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.Extensions.html).
Vous pouvez restreindre la liste des extensions disponibles qui peuvent être gérées par l’utilisateur ayant le rôle `rds_extension` à l’aide du paramètre `rds.allowed_delegated_extensions`.
La prise en charge de la délégation des extensions est disponible dans les versions suivantes :
+ Toutes les versions supérieures
+ 15.5 et versions 15 ultérieures
+ 14.10 et versions 14 ultérieures
+ 13.13 et versions 13 ultérieures
+ 12.17 et versions 12 ultérieures
**Topics**
+ [Activation de la prise en charge de la délégation des extensions pour un utilisateur](#AuroraPostgreSQL.delegated_ext_mgmt)
+ [Configuration utilisée dans la prise en charge de la délégation des extensions Aurora pour PostgreSQL](#AuroraPostgreSQL.delegated_ext_config)
+ [Désactiver la prise en charge de la délégation des extensions](#AuroraPostgreSQL.delegated_ext_disable)
+ [Avantages liés à l’utilisation de la prise en charge de la délégation des extensions Amazon Aurora](#AuroraPostgreSQL.delegated_ext_benefits)
+ [Limitation de la prise en charge de la délégation des extensions Aurora pour PostgreSQL](#AuroraPostgreSQL.delegated_ext_limit)
+ [Autorisations requises pour certaines extensions](#AuroraPostgreSQL.delegated_ext_perm)
+ [Considérations de sécurité](#AuroraPostgreSQL.delegated_ext_sec)
+ [Désactivation de la suppression d’extension en cascade](#AuroraPostgreSQL.delegated_ext_drop)
+ [Exemples d’extensions pouvant être ajoutées à l’aide de la prise en charge de la délégation des extensions](#AuroraPostgreSQL.delegated_ext_support)
## Activation de la prise en charge de la délégation des extensions pour un utilisateur
Vous devez effectuer les opérations suivantes pour activer la prise en charge de la délégation des extensions pour un utilisateur :
1. **Accorder un rôle `rds_extension` à un utilisateur** : connectez-vous à la base de données en tant que `rds_superuser` et exécutez la commande suivante.
```
Postgres => grant rds_extension to user_name;
```
1. **Définir la liste des extensions que les utilisateurs délégués pourront gérer** : `rds.allowed_delegated_extensions` permet de spécifier un sous-ensemble des extensions disponibles à l’aide de `rds.allowed_extensions` dans le paramètre de cluster de bases de données. Vous pouvez effectuer cette opération à l’un des niveaux suivants :
+ Dans le cluster ou le groupe de paramètres d'instance, via l'API AWS Management Console or. Pour de plus amples informations, veuillez consulter [Groupes de paramètres pour Amazon Aurora](USER_WorkingWithParamGroups.md).
+ Utilisez la commande suivante au niveau de la base de données :
```
alter database database_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
+ Utilisez la commande suivante au niveau de l’utilisateur :
```
alter user user_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
**Note**
Il n’est pas nécessaire de redémarrer la base de données après avoir modifié le paramètre dynamique `rds.allowed_delegated_extensions`.
1. **Autoriser l’utilisateur délégué à accéder aux objets créés lors du processus de création des extensions** : certaines extensions créent des objets qui nécessitent l’octroi d’autorisations supplémentaires avant que l’utilisateur ayant le rôle `rds_extension` puisse y accéder. `rds_superuser` doit accorder à l’utilisateur délégué l’accès à ces objets. L’une des options consiste à utiliser un déclencheur d’événement pour accorder automatiquement l’autorisation à l’utilisateur délégué.
**Exemple de déclencheur d'événement**
Si vous souhaitez autoriser un utilisateur délégué ayant le rôle `rds_extension` à utiliser des extensions qui nécessitent de définir des autorisations sur ses objets créés lors de la création des extensions, vous pouvez personnaliser l’exemple de déclencheur d’événement ci-dessous et ajouter uniquement les extensions pour lesquelles vous souhaitez que les utilisateurs délégués aient accès à toutes les fonctionnalités. Ce déclencheur d’événement peut être créé sur template1 (modèle par défaut). Par conséquent, toutes les bases de données créées à partir de template1 auront ce déclencheur d’événement. Lorsqu’un utilisateur délégué installe l’extension, ce déclencheur octroie automatiquement la propriété des objets créés par l’extension.
```
CREATE OR REPLACE FUNCTION create_ext()
RETURNS event_trigger AS $$
DECLARE
schemaname TEXT;
databaseowner TEXT;
r RECORD;
BEGIN
IF tg_tag = 'CREATE EXTENSION' and current_user != 'rds_superuser' THEN
RAISE NOTICE 'SECURITY INVOKER';
RAISE NOTICE 'user: %', current_user;
FOR r IN SELECT * FROM pg_catalog.pg_event_trigger_ddl_commands()
LOOP
CONTINUE WHEN r.command_tag != 'CREATE EXTENSION' OR r.object_type != 'extension';
schemaname = (
SELECT n.nspname
FROM pg_catalog.pg_extension AS e
INNER JOIN pg_catalog.pg_namespace AS n
ON e.extnamespace = n.oid
WHERE e.oid = r.objid
);
databaseowner = (
SELECT pg_catalog.pg_get_userbyid(d.datdba)
FROM pg_catalog.pg_database d
WHERE d.datname = current_database()
);
RAISE NOTICE 'Record for event trigger %, objid: %,tag: %, current_user: %, schema: %, database_owenr: %', r.object_identity, r.objid, tg_tag, current_user, schemaname, databaseowner;
IF r.object_identity = 'address_standardizer_data_us' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_gaz TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_lex TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_rules TO %I WITH GRANT OPTION;', schemaname, databaseowner);
ELSIF r.object_identity = 'dict_int' THEN
EXECUTE pg_catalog.format('ALTER TEXT SEARCH DICTIONARY %I.intdict OWNER TO %I;', schemaname, databaseowner);
ELSIF r.object_identity = 'pg_partman' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.part_config TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.part_config_sub TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.custom_time_partitions TO %I WITH GRANT OPTION;', schemaname, databaseowner);
ELSIF r.object_identity = 'postgis_topology' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON ALL TABLES IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT USAGE ON SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
END IF;
END LOOP;
END IF;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;
CREATE EVENT TRIGGER log_create_ext ON ddl_command_end EXECUTE PROCEDURE create_ext();
```
## Configuration utilisée dans la prise en charge de la délégation des extensions Aurora pour PostgreSQL
| Nom de la configuration | Description | Valeur par défaut | Remarques | Qui peut modifier ou accorder l’autorisation |
| --- | --- | --- | --- | --- |
| `rds.allowed_delegated_extensions` | Ce paramètre limite les extensions qu’un rôle rds\$1extension peut gérer dans une base de données. Il doit s’agir d’un sous-ensemble de rds.allowed\$1extensions. | chaîne vide | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonRDS/latest/AuroraUserGuide/Aurora_delegated_ext.html) Pour en savoir plus sur la configuration de ce paramètre, consultez [Activation de la prise en charge de la délégation des extensions pour un utilisateur](#AuroraPostgreSQL.delegated_ext_mgmt). | rds\$1superuser |
| `rds.allowed_extensions` | Ce paramètre permet au client de limiter les extensions qui peuvent être installées dans l’instance de base de données RDS pour PostgreSQL. Pour plus d’informations, consultez [Restriction de l’installation des extensions PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). | "\$1" | Par défaut, ce paramètre est défini sur \$1, ce qui signifie que toutes les extensions prises en charge par RDS pour PostgreSQL et Aurora PostgreSQL peuvent être créées par les utilisateurs disposant des privilèges nécessaires. Une chaîne vide signifie qu’aucune extension ne peut être installée dans l’instance de base de données Aurora PostgreSQL. | administrateur |
| `rds-delegated_extension_allow_drop_cascade` | Ce paramètre contrôle la capacité de l’utilisateur ayant le rôle `rds_extension` à supprimer l’extension à l’aide de l’option en cascade. | off | Par défaut, la propriété `rds-delegated_extension_allow_drop_cascade` a la valeur `off`. Cela signifie que les utilisateurs ayant le rôle `rds_extension` ne sont pas autorisés à supprimer une extension à l’aide de l’option en cascade. Pour qu’ils puissent effectuer cette action, le paramètre `rds.delegated_extension_allow_drop_cascade` doit être défini sur `on`. | rds\$1superuser |
## Désactiver la prise en charge de la délégation des extensions
**Désactivation partielle**
Les utilisateurs délégués ne peuvent pas créer d’extensions, mais peuvent toujours mettre à jour les extensions existantes.
+ Réinitialisez `rds.allowed_delegated_extensions` dans le groupe de paramètres de cluster de bases de données.
+ Utilisez la commande suivante au niveau de la base de données :
```
alter database database_name reset rds.allowed_delegated_extensions;
```
+ Utilisez la commande suivante au niveau de l’utilisateur :
```
alter user user_name reset rds.allowed_delegated_extensions;
```
**Désactivation complète**
La révocation du rôle `rds_extension` d’un utilisateur rétablit ses autorisations standard. L’utilisateur ne pourra plus créer, mettre à jour ni supprimer des extensions.
```
postgres => revoke rds_extension from user_name;
```
## Avantages liés à l’utilisation de la prise en charge de la délégation des extensions Amazon Aurora
Grâce à la prise en charge de la délégation des extensions d’Amazon Aurora pour PostgreSQL, vous déléguez en toute sécurité la gestion des extensions aux utilisateurs qui n’ont pas le rôle `rds_superuser`. Cette fonctionnalité présente les avantages suivants :
+ Vous pouvez facilement déléguer la gestion des extensions aux utilisateurs de votre choix.
+ Cela ne nécessite pas le rôle `rds_superuser`.
+ Permet de prendre en charge différents ensembles d’extensions pour différentes bases de données dans le même cluster de bases de données.
## Limitation de la prise en charge de la délégation des extensions Aurora pour PostgreSQL
+ Les objets créés pendant le processus de création d’une extension peuvent nécessiter des privilèges supplémentaires pour que l’extension fonctionne correctement.
## Autorisations requises pour certaines extensions
Pour créer, utiliser ou mettre à jour les extensions suivantes, l’utilisateur délégué doit disposer des privilèges nécessaires sur les fonctions, tables et schémas suivants.
| Extensions nécessitant des droits de propriété ou des autorisations | Fonction | Tables | Schema | Dictionnaire de recherche de texte | Comment |
| --- | --- | --- | --- | --- | --- |
| address\$1standardizer\$1data\$1us | | us\$1gaz, us\$1lex, us\$1lex, I.us\$1rules | | | |
| amcheck | bt\$1index\$1check, bt\$1index\$1parent\$1check | | | | |
| dict\$1int | | | | intdict | |
| pg\$1partman | | custom\$1time\$1partitions, part\$1config, part\$1config\$1sub | | | |
| pg\$1stat\$1statements | | | | | |
| PostGIS | st\$1tileenvelope | spatial\$1ref\$1sys | | | |
| postgis\$1raster | | | | | |
| postgis\$1topology | | topologie, couche | topologie | | l’utilisateur délégué doit être le propriétaire de la base de données |
| log\$1fdw | create\$1foreign\$1table\$1for\$1log\$1file | | | | |
| rds\$1tools | role\$1password\$1encryption\$1type | | | | |
| postgis\$1tiger\$1geocoder | | geocode\$1settings\$1default, geocode\$1settings | tiger | | |
| pg\$1freespacemap | pg\$1freespace | | | | |
| pg\$1visibility | pg\$1visibility | | | | |
## Considérations de sécurité
N’oubliez pas qu’un utilisateur doté d’un rôle `rds_extension` peut gérer les extensions sur toutes les bases de données sur lesquelles il dispose du privilège de connexion. Si l’intention est de permettre à l’utilisateur délégué de ne gérer une extension que sur une seule base de données, il est recommandé de révoquer tous les privilèges publics sur chaque base de données, puis d’accorder explicitement le privilège de connexion pour cette base de données spécifique à l’utilisateur délégué.
Plusieurs extensions peuvent permettre à un utilisateur d’accéder aux informations de plusieurs bases de données. Assurez-vous que les utilisateurs auxquels vous accordez `rds_extension` disposent de fonctionnalités entre les bases de données avant d’ajouter ces extensions à `rds.allowed_delegated_extensions`. Par exemple, `postgres_fdw` et `dblink` fournissent des fonctionnalités permettant d’interroger les bases de données sur la même instance ou sur des instances distantes. `log_fdw` lit les fichiers journaux du moteur Postgres, qui concernent toutes les bases de données de l’instance et peuvent contenir des requêtes lentes ou des messages d’erreur provenant de plusieurs bases de données. `pg_cron` permet d’exécuter des tâches d’arrière-plan planifiées sur l’instance de base de données et peut configurer des tâches pour qu’elles s’exécutent dans une autre base de données.
## Désactivation de la suppression d’extension en cascade
La possibilité de supprimer l’extension avec l’option en cascade par un utilisateur ayant le rôle `rds_extension` est contrôlée par le paramètre `rds.delegated_extension_allow_drop_cascade`. Par défaut, la propriété `rds-delegated_extension_allow_drop_cascade` a la valeur `off`. Cela signifie que les utilisateurs dotés du rôle `rds_extension` ne sont pas autorisés à supprimer une extension à l’aide de l’option en cascade, comme indiqué dans la requête ci-dessous.
```
DROP EXTENSION CASCADE;
```
Car cela supprime automatiquement les objets qui dépendent de l’extension, puis tous les objets qui dépendent de ces objets. Toute tentative d’utilisation de l’option en cascade entraînera une erreur.
Pour qu’ils puissent effectuer cette action, le paramètre `rds.delegated_extension_allow_drop_cascade` doit être défini sur `on`.
La modification du paramètre dynamique `rds.delegated_extension_allow_drop_cascade` ne nécessite pas de redémarrage de la base de données. Vous pouvez procéder à l’un des niveaux suivants :
+ Dans le cluster ou le groupe de paramètres d'instance, via l'API AWS Management Console or.
+ À l’aide de la commande suivante au niveau de la base de données :
```
alter database database_name set rds.delegated_extension_allow_drop_cascade = 'on';
```
+ À l’aide de la commande suivante au niveau de l’utilisateur :
```
alter role tenant_user set rds.delegated_extension_allow_drop_cascade = 'on';
```
## Exemples d’extensions pouvant être ajoutées à l’aide de la prise en charge de la délégation des extensions
+ `rds_tools`
```
extension_test_db=> create extension rds_tools;
CREATE EXTENSION
extension_test_db=> SELECT * from rds_tools.role_password_encryption_type() where rolname = 'pg_read_server_files';
ERROR: permission denied for function role_password_encryption_type
```
+ `amcheck`
```
extension_test_db=> CREATE TABLE amcheck_test (id int);
CREATE TABLE
extension_test_db=> INSERT INTO amcheck_test VALUES (generate_series(1,100000));
INSERT 0 100000
extension_test_db=> CREATE INDEX amcheck_test_btree_idx ON amcheck_test USING btree (id);
CREATE INDEX
extension_test_db=> create extension amcheck;
CREATE EXTENSION
extension_test_db=> SELECT bt_index_check('amcheck_test_btree_idx'::regclass);
ERROR: permission denied for function bt_index_check
extension_test_db=> SELECT bt_index_parent_check('amcheck_test_btree_idx'::regclass);
ERROR: permission denied for function bt_index_parent_check
```
+ `pg_freespacemap`
```
extension_test_db=> create extension pg_freespacemap;
CREATE EXTENSION
extension_test_db=> SELECT * FROM pg_freespace('pg_authid');
ERROR: permission denied for function pg_freespace
extension_test_db=> SELECT * FROM pg_freespace('pg_authid',0);
ERROR: permission denied for function pg_freespace
```
+ `pg_visibility`
```
extension_test_db=> create extension pg_visibility;
CREATE EXTENSION
extension_test_db=> select * from pg_visibility('pg_database'::regclass);
ERROR: permission denied for function pg_visibility
```
+ `postgres_fdw`
```
extension_test_db=> create extension postgres_fdw;
CREATE EXTENSION
extension_test_db=> create server myserver foreign data wrapper postgres_fdw options (host 'foo', dbname 'foodb', port '5432');
ERROR: permission denied for foreign-data wrapper postgres_fdw
```