Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilizzo del supporto delle estensioni delegate di Amazon Aurora per PostgreSQL Utilizzo del supporto delle estensioni delegate di Amazon Aurora per PostgreSQL Utilizzando il supporto delle estensioni delegate di Amazon Aurora per PostgreSQL, è possibile delegare la gestione delle estensioni a un utente che non deve essere un `rds_superuser`. Con questo supporto delle estensioni delegate, viene creato un nuovo ruolo denominato `rds_extension` che è necessario assegnare a un utente per gestire altre estensioni. Questo ruolo può creare, aggiornare ed eliminare estensioni. È possibile specificare le estensioni che possono essere installate sull’istanza database Aurora PostgreSQL, elencandole nel parametro `rds.allowed_extensions`. Per ulteriori informazioni, consulta [Utilizzo delle estensioni PostgreSQL con Amazon RDS per PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.Extensions.html). È possibile limitare l’elenco delle estensioni disponibili che possono essere gestite dall’utente con il ruolo `rds_extension` utilizzando il parametro `rds.allowed_delegated_extensions`. Il supporto delle estensioni delegate è disponibile nelle seguenti versioni: + Tutte le versioni successive + 15.5 e versioni successive alla 15 + 14.10 e versioni successive alla 14 + 13.13 e versioni successive alla 13 + 12.17 e versioni successive 12 **Topics** + [ ## Attivazione del supporto delle estensioni delegate per un utente ](#AuroraPostgreSQL.delegated_ext_mgmt) + [ ## Configurazione utilizzata nel supporto delle estensioni delegate Aurora per PostgreSQL ](#AuroraPostgreSQL.delegated_ext_config) + [ ## Disattivazione del supporto per l’estensione delegata ](#AuroraPostgreSQL.delegated_ext_disable) + [ ## Vantaggi dell’utilizzo del supporto delle estensioni delegate di Amazon Aurora ](#AuroraPostgreSQL.delegated_ext_benefits) + [ ## Limitazione del supporto delle estensioni delegate di Aurora per PostgreSQL ](#AuroraPostgreSQL.delegated_ext_limit) + [ ## Autorizzazioni necessarie per determinate estensioni ](#AuroraPostgreSQL.delegated_ext_perm) + [ ## Considerazioni sulla sicurezza ](#AuroraPostgreSQL.delegated_ext_sec) + [ ## Disabilitazione dell’eliminazione delle estensioni con l’opzione cascade ](#AuroraPostgreSQL.delegated_ext_drop) + [ ## Estensioni di esempio che possono essere aggiunte utilizzando il supporto delle estensioni delegate ](#AuroraPostgreSQL.delegated_ext_support) ## Attivazione del supporto delle estensioni delegate per un utente Supporto delle estensioni delegate per un utente È necessario eseguire le seguenti operazioni per abilitare il supporto delle estensioni delegate per un utente: 1. **Concedere il ruolo `rds_extension` a un utente**: connettersi al database come `rds_superuser` ed esegui il seguente comando: ``` Postgres => grant rds_extension to user_name; ``` 1. **Impostare l’elenco delle estensioni disponibili per la gestione degli utenti delegati**: `rds.allowed_delegated_extensions` consente di specificare un sottoinsieme delle estensioni disponibili utilizzando `rds.allowed_extensions` nel parametro del cluster di database. È possibile eseguire questa operazione a uno dei seguenti livelli: + Nel cluster o nel gruppo di parametri dell'istanza, tramite l'API Console di gestione AWS o. Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md). + Utilizzare il seguente comando a livello di database: ``` alter database database_name set rds.allowed_delegated_extensions = 'extension_name_1, extension_name_2,...extension_name_n'; ``` + Utilizzare il seguente comando a livello di utente: ``` alter user user_name set rds.allowed_delegated_extensions = 'extension_name_1, extension_name_2,...extension_name_n'; ``` **Nota** Non è necessario riavviare il database dopo aver modificato il parametro dinamico `rds.allowed_delegated_extensions`. 1. **Consentire l’accesso all’utente delegato agli oggetti creati durante il processo di creazione dell’estensione**: alcune estensioni creano oggetti che richiedono la concessione di autorizzazioni aggiuntive prima che l’utente con il ruolo `rds_extension` possa accedervi. `rds_superuser` deve concedere all’utente delegato l’accesso a tali oggetti. Una delle opzioni consiste nell’utilizzare un trigger di evento per concedere automaticamente l’autorizzazione all’utente delegato. **Esempio di attivazione di un evento** Se si desidera consentire a un utente delegato con `rds_extension` di utilizzare estensioni che richiedono l’impostazione delle autorizzazioni sugli oggetti creati durante la creazione dell’estensione, è possibile personalizzare l’esempio seguente di trigger di evento e aggiungere solo le estensioni per le quali si desidera che gli utenti delegati abbiano accesso alla funzionalità completa. Questo trigger di evento può essere creato su template1 (il modello predefinito), pertanto tutti i database creati da template1 avranno tale trigger di evento. Quando un utente delegato installa l’estensione, questo trigger garantirà automaticamente la proprietà degli oggetti creati dall’estensione. ``` 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(); ``` ## Configurazione utilizzata nel supporto delle estensioni delegate Aurora per PostgreSQL Configurazione utilizzata nel supporto delle estensioni delegate Aurora per PostgreSQL | Nome configurazione | Description | Valore predefinito | Note | Chi può modificare o concedere l’autorizzazione | | --- | --- | --- | --- | --- | | `rds.allowed_delegated_extensions` | Questo parametro limita le estensioni che un ruolo rds\$1extension può gestire in un database. Deve essere un sottoinsieme di rds.allowed\$1extensions. | Stringa vuota | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/Aurora_delegated_ext.html) Per ulteriori informazioni sulla configurazione di questo parametro, consulta [Attivazione del supporto delle estensioni delegate per un utente](#AuroraPostgreSQL.delegated_ext_mgmt). | rds\$1superuser | | `rds.allowed_extensions` | Questo parametro consente all’utente di limitare le estensioni che possono essere installate nell’istanza database Aurora PostgreSQL. Per ulteriori informazioni, consulta [Limitazione dell’installazione delle estensioni PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). | "\$1" | Per impostazione predefinita, questo parametro è impostato su “\$1”, il che significa che tutte le estensioni supportate su RDS per PostgreSQL e Aurora PostgreSQL possono essere create da utenti con i privilegi necessari. Vuoto significa che non è possibile installare estensioni nell’istanza database Aurora PostgreSQL. | administrator | | `rds-delegated_extension_allow_drop_cascade` | Questo parametro controlla la possibilità per l’utente con `rds_extension` di eliminare l’estensione utilizzando un’opzione cascade. | off | Per impostazione predefinita, `rds-delegated_extension_allow_drop_cascade` è impostato su `off`. Ciò significa che gli utenti con `rds_extension` non sono autorizzati a eliminare un’estensione utilizzando l’opzione cascade. Per consentire tale funzionalità, il parametro `rds.delegated_extension_allow_drop_cascade` deve essere impostato su `on`. | rds\$1superuser | ## Disattivazione del supporto per l’estensione delegata Disattivazione di questa funzionalità **Disattivazione parziale** Gli utenti delegati non possono creare nuove estensioni ma possono comunque aggiornare le estensioni esistenti. + Ripristinare `rds.allowed_delegated_extensions` sul valore predefinito nel gruppo di parametri del cluster di database. + Utilizzare il seguente comando a livello di database: ``` alter database database_name reset rds.allowed_delegated_extensions; ``` + Utilizzare il seguente comando a livello di utente: ``` alter user user_name reset rds.allowed_delegated_extensions; ``` **Disattivazione completa** La revoca del ruolo `rds_extension` a un utente ripristinerà le autorizzazioni standard per l’utente. L’utente non può più creare, aggiornare o eliminare le estensioni. ``` postgres => revoke rds_extension from user_name; ``` ## Vantaggi dell’utilizzo del supporto delle estensioni delegate di Amazon Aurora Vantaggi dell’utilizzo del supporto delle estensioni delegate di Amazon Aurora Utilizzando il supporto delle estensioni delegate di Amazon Aurora per PostgreSQL, è possibile delegare in modo sicuro la gestione delle estensioni agli utenti che non dispongono del ruolo `rds_superuser`. Questa funzionalità fornisce i seguenti vantaggi: + È possibile delegare facilmente la gestione delle estensioni agli utenti desiderati. + Non è richiesto il ruolo `rds_superuser`. + Offre la possibilità di supportare diversi set di estensioni per diversi database nello stesso cluster di database. ## Limitazione del supporto delle estensioni delegate di Aurora per PostgreSQL Limitazione del supporto delle estensioni delegate di Aurora per PostgreSQL + Gli oggetti creati durante il processo di creazione dell’estensione possono richiedere privilegi aggiuntivi per il corretto funzionamento dell’estensione. ## Autorizzazioni necessarie per determinate estensioni Autorizzazioni necessarie per determinate estensioni Per creare, utilizzare o aggiornare le seguenti estensioni, l’utente delegato deve disporre dei privilegi necessari sulle seguenti funzioni, tabelle e schemi. | Estensioni che richiedono proprietà o autorizzazioni | Funzione | Tabelle | Schema | Dizionario di ricerca testuale | 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 | | topology, layer | topology | | L’utente delegato deve essere il proprietario del database | | 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 | | | | | ## Considerazioni sulla sicurezza Considerazioni sulla sicurezza Tenere presente che un utente con il ruolo `rds_extension` sarà in grado di gestire le estensioni su tutti i database su cui ha il privilegio di connessione. Se l’intenzione è fare in modo che un utente delegato gestisca l’estensione su un singolo database, è buona norma revocare tutti i privilegi al pubblico su ciascun database, quindi concedere esplicitamente il privilegio di connessione per tale database specifico all’utente delegato. Esistono diverse estensioni che possono consentire a un utente di accedere alle informazioni da più database. Prima di aggiungere queste estensioni a `rds.allowed_delegated_extensions`, assicurarsi che gli utenti a cui si concede `rds_extension` dispongano di funzionalità su più database. Ad esempio, `postgres_fdw` e `dblink` forniscono funzionalità per eseguire query su più database sulla stessa istanza o su istanze remote. `log_fdw` legge i file di log del motore postgres, che riguardano tutti i database dell’istanza, potenzialmente contenenti query lente o messaggi di errore provenienti da più database. `pg_cron` consente l’esecuzione di processi pianificati in background sull’istanza database e può configurare i processi per l’esecuzione in un database diverso. ## Disabilitazione dell’eliminazione delle estensioni con l’opzione cascade Disabilitazione dell’eliminazione delle estensioni con l’opzione cascade La possibilità di eliminare l’estensione con l’opzione cascade da parte di un utente con il ruolo `rds_extension` è controllata dal parametro `rds.delegated_extension_allow_drop_cascade`. Per impostazione predefinita, `rds-delegated_extension_allow_drop_cascade` è impostato su `off`. Ciò significa che agli utenti con il ruolo `rds_extension` non è consentito eliminare un’estensione utilizzando l’opzione cascade, come mostrato nella query seguente. ``` DROP EXTENSION CASCADE; ``` In questo modo verranno eliminati automaticamente gli oggetti che dipendono dall’estensione e, di conseguenza, tutti gli oggetti che dipendono da tali oggetti. Il tentativo di utilizzare l’opzione cascade genererà un errore. Per consentire tale funzionalità, il parametro `rds.delegated_extension_allow_drop_cascade` deve essere impostato su `on`. La modifica del parametro dinamico `rds.delegated_extension_allow_drop_cascade` non richiede il riavvio del database. È possibile eseguire questa operazione a uno dei seguenti livelli: + Nel cluster o nel gruppo di parametri dell'istanza, tramite l'API Console di gestione AWS o. + Utilizzando il seguente comando a livello di database: ``` alter database database_name set rds.delegated_extension_allow_drop_cascade = 'on'; ``` + Utilizzando il seguente comando a livello di utente: ``` alter role tenant_user set rds.delegated_extension_allow_drop_cascade = 'on'; ``` ## Estensioni di esempio che possono essere aggiunte utilizzando il supporto delle estensioni delegate Estensioni di esempio con il supporto delle estensioni delegate + `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 ```