Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden der Unterstützung für delegierte Erweiterungen von Amazon Aurora für PostgreSQL
Mithilfe der Unterstützung für delegierte Erweiterungen von Amazon Aurora für PostgreSQL können Sie die Erweiterungsverwaltung an einen Benutzer delegieren, der kein `rds_superuser` sein muss. Mit dieser Unterstützung für delegierte Erweiterungen wird eine neue Rolle namens `rds_extension` erstellt und Sie müssen diese einem Benutzer zuweisen, um andere Erweiterungen zu verwalten. Mit dieser Rolle können Erweiterungen erstellt, aktualisiert und gelöscht werden.
Sie können die Erweiterungen angeben, die auf Ihrer DB-Instance von Aurora PostgreSQL installiert werden können, indem Sie sie im Parameter `rds.allowed_extensions` aufführen. Weitere Informationen finden Sie unter [Verwenden von PostgreSQL-Erweiterungen mit Amazon RDS für PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.Extensions.html).
Mit dem Parameter `rds.allowed_delegated_extensions` können Sie die Liste der Erweiterungen einschränken, die vom Benutzer mit der `rds_extension`-Rolle verwaltet werden kann.
Die Unterstützung für delegierte Erweiterungen ist in den folgenden Versionen verfügbar:
+ Alle höheren Versionen
+ 15.5 und höhere 15-Versionen
+ 14.10 und höhere 14 Versionen
+ 13.13 und höhere 13 Versionen
+ 12.17 und höhere 12 Versionen
**Topics**
+ [Aktivieren der Unterstützung für delegierte Erweiterungen für einen Benutzer](#AuroraPostgreSQL.delegated_ext_mgmt)
+ [Konfiguration, die in der Unterstützung für delegierte Erweiterungen von Aurora für PostgreSQL verwendet wird](#AuroraPostgreSQL.delegated_ext_config)
+ [Deaktivieren der Unterstützung für die delegierte Erweiterung](#AuroraPostgreSQL.delegated_ext_disable)
+ [Vorteile der Verwendung der Unterstützung für delegierte Erweiterungen von Amazon Aurora](#AuroraPostgreSQL.delegated_ext_benefits)
+ [Einschränkung der Unterstützung für delegierte Erweiterungen von Amazon Aurora für PostgreSQL](#AuroraPostgreSQL.delegated_ext_limit)
+ [Für bestimmte Erweiterungen erforderliche Berechtigungen](#AuroraPostgreSQL.delegated_ext_perm)
+ [Sicherheitsüberlegungen](#AuroraPostgreSQL.delegated_ext_sec)
+ [Drop extension cascade ist deaktiviert](#AuroraPostgreSQL.delegated_ext_drop)
+ [Beispielerweiterungen, die mithilfe der Unterstützung für delegierte Erweiterungen hinzugefügt werden können](#AuroraPostgreSQL.delegated_ext_support)
## Aktivieren der Unterstützung für delegierte Erweiterungen für einen Benutzer
Sie müssen die folgenden Schritte ausführen, um die Unterstützung für delegierte Erweiterungen für einen Benutzer zu aktivieren:
1. **Einem Benutzer die `rds_extension`-Rolle erteilen** – Stellen Sie als `rds_superuser` eine Verbindung zur Datenbank her und führen Sie den folgenden Befehl aus:
```
Postgres => grant rds_extension to user_name;
```
1. **Die Liste der Erweiterungen festlegen, die von delegierten Benutzern verwaltet werden können** – Mit `rds.allowed_delegated_extensions` können Sie unter Verwendung von `rds.allowed_extensions` im DB-Cluster-Parameter eine Teilmenge der verfügbaren Erweiterungen angeben. Sie können dies auf einer der folgenden Ebenen durchführen:
+ Im Cluster oder in der Instanzparametergruppe, über die API AWS-Managementkonsole oder. Weitere Informationen finden Sie unter [Parametergruppen für Amazon Aurora](USER_WorkingWithParamGroups.md).
+ Verwenden Sie den folgenden Befehl auf Datenbankebene:
```
alter database database_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
+ Verwenden Sie den folgenden Befehl auf Benutzerebene:
```
alter user user_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
**Anmerkung**
Sie müssen die Datenbank nicht neu starten, nachdem Sie den dynamischen Parameter `rds.allowed_delegated_extensions` geändert haben.
1. **Dem delegierten Benutzer Zugriff auf Objekte gewähren, die während dem Prozess der Erweiterungserstellung erstellt wurden** – Bestimmte Erweiterungen erstellen Objekte, für die zusätzliche Berechtigungen erteilt werden müssen, bevor der Benutzer mit der `rds_extension`-Rolle auf sie zugreifen kann. Der `rds_superuser` muss dem delegierten Benutzer Zugriff auf diese Objekte gewähren. Eine der Optionen besteht darin, einen Ereignisauslöser zu verwenden, um dem delegierten Benutzer automatisch die Berechtigung zu erteilen.
**Beispiel für einen Event-Trigger**
Wenn Sie einem delegierten Benutzer mit `rds_extension` die Verwendung von Erweiterungen ermöglichen möchten, für die Berechtigungen für seine bei der Erstellung der Erweiterung erstellten Objekte erforderlich sind, können Sie das folgende Beispiel für einen Ereignisauslöser anpassen und nur die Erweiterungen hinzufügen, für die die delegierten Benutzer Zugriff auf die gesamte Funktionalität haben sollen. Dieser Ereignisauslöser kann auf template1 (der Standardvorlage) erstellt werden, sodass alle mit template1 erstellten Datenbanken über diesen Ereignisauslöser verfügen. Wenn ein delegierter Benutzer die Erweiterung installiert, gewährt dieser Trigger automatisch die Eigentümerschaft an den von der Erweiterung erstellten Objekten.
```
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();
```
## Konfiguration, die in der Unterstützung für delegierte Erweiterungen von Aurora für PostgreSQL verwendet wird
| Konfigurationsname | Description | Standardwert | Hinweise | Wer Berechtigungen ändern oder erteilen kann |
| --- | --- | --- | --- | --- |
| `rds.allowed_delegated_extensions` | Dieser Parameter schränkt die Erweiterungen ein, die eine rds\$1extension-Rolle in einer Datenbank verwalten kann. Es muss sich um eine Teilmenge von rds.allowed\$1extensions handeln. | leere Zeichenfolge | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/Aurora_delegated_ext.html) Weitere Informationen zum Einrichten dieses Parameters finden Sie unter [Aktivieren der Unterstützung für delegierte Erweiterungen für einen Benutzer](#AuroraPostgreSQL.delegated_ext_mgmt). | rds\$1superuser |
| `rds.allowed_extensions` | Mit diesem Parameter kann der Kunde die Erweiterungen einschränken, die in der DB-Instance von Aurora PostgreSQL installiert werden können. Weitere Informationen finden Sie unter [Einschränken der Installation von PostgreSQL-Erweiterungen](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction). | "\$1" | Standardmäßig ist dieser Parameter auf „\$1“ gesetzt, was bedeutet, dass alle von RDS für PostgreSQL und Aurora PostgreSQL unterstützten Erweiterungen von Benutzern mit den erforderlichen Berechtigungen erstellt werden dürfen. Leer bedeutet, dass keine Erweiterungen in der DB-Instance von Aurora PostgreSQL installiert werden können. | Administrator |
| `rds-delegated_extension_allow_drop_cascade` | Dieser Parameter steuert, ob Benutzer mit `rds_extension` die Erweiterung mithilfe der Option cascade löschen können. | aus | `rds-delegated_extension_allow_drop_cascade` ist standardmäßig auf `off` festgelegt. Dies bedeutet, dass Benutzer mit `rds_extension` eine Erweiterung mithilfe der Option cascade nicht löschen dürfen. Zur Erteilung dieser Fähigkeit sollte der Parameter `rds.delegated_extension_allow_drop_cascade` auf `on` gesetzt werden. | rds\$1superuser |
## Deaktivieren der Unterstützung für die delegierte Erweiterung
**Teilweises Deaktivieren**
Die delegierten Benutzer können keine neuen Erweiterungen erstellen, aber trotzdem bestehende Erweiterungen aktualisieren.
+ Setzen Sie `rds.allowed_delegated_extensions` in der DB-Cluster-Parametergruppe auf den Standardwert zurück.
+ Verwenden Sie den folgenden Befehl auf Datenbankebene:
```
alter database database_name reset rds.allowed_delegated_extensions;
```
+ Verwenden Sie den folgenden Befehl auf Benutzerebene:
```
alter user user_name reset rds.allowed_delegated_extensions;
```
**Vollständiges Deaktivieren**
Wenn Sie einem Benutzer die `rds_extension`-Rolle entziehen, erhält der Benutzer wieder die Standardberechtigungen. Der Benutzer kann keine Erweiterungen mehr erstellen, aktualisieren oder löschen.
```
postgres => revoke rds_extension from user_name;
```
## Vorteile der Verwendung der Unterstützung für delegierte Erweiterungen von Amazon Aurora
Durch die Verwendung der Unterstützung für delegierte Erweiterungen von Amazon Aurora für PostgreSQL delegieren Sie die Erweiterungsverwaltung sicher an Benutzer, die nicht über die `rds_superuser`-Rolle verfügen. Diese Funktion bietet die folgenden Vorteile:
+ Sie können die Erweiterungsverwaltung ganz einfach an Benutzer Ihrer Wahl delegieren.
+ Dafür ist keine `rds_superuser`-Rolle erforderlich.
+ Bietet die Möglichkeit, verschiedene Gruppen von Erweiterungen für unterschiedliche Datenbanken im selben DB-Cluster zu unterstützen
## Einschränkung der Unterstützung für delegierte Erweiterungen von Amazon Aurora für PostgreSQL
+ Objekte, die während der Erweiterungserstellung erstellt wurden, benötigen möglicherweise zusätzliche Berechtigungen, damit die Erweiterung ordnungsgemäß funktioniert.
## Für bestimmte Erweiterungen erforderliche Berechtigungen
Um die folgenden Erweiterungen zu erstellen, zu verwenden oder zu aktualisieren, sollte der delegierte Benutzer über die erforderlichen Berechtigungen für die folgenden Funktionen, Tabellen und Schemas verfügen.
| Erweiterungen, für die eine Eigentümerschaft oder Berechtigungen erforderlich sind | Funktion | Tabellen | Schema | Wörterbuch für die Textsuche | 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 | | Der delegierte Benutzer muss der Datenbankbesitzer sein. |
| 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 | | | | |
## Sicherheitsüberlegungen
Denken Sie daran, dass ein Benutzer mit der `rds_extension`-Rolle Erweiterungen für alle Datenbanken verwalten kann, für die er die Connect-Berechtigung hat. Wenn beabsichtigt ist, dass ein delegierter Benutzer die Erweiterung für eine einzelne Datenbank verwaltet, empfiehlt es sich, alle öffentlichen Berechtigungen für jede Datenbank zu entziehen und dann dem delegierten Benutzer explizit die Connect-Berechtigung für diese spezifische Datenbank zu gewähren.
Es gibt mehrere Erweiterungen, mit denen ein Benutzer auf Informationen aus mehreren Datenbanken zugreifen kann. Stellen Sie sicher, dass die Benutzer, denen Sie `rds_extension` gewähren, über datenbankübergreifende Funktionen verfügen, bevor Sie diese Erweiterungen zu `rds.allowed_delegated_extensions` hinzufügen. `postgres_fdw` und `dblink` stellen beispielsweise Funktionen für datenbankübergreifende Abfragen auf derselben Instance oder auf Remote-Instances bereit. `log_fdw` liest die Protokolldateien der Postgres-Engine, die für alle Datenbanken in der Instance gelten und möglicherweise langsame Abfragen oder Fehlermeldungen von mehreren Datenbanken enthalten. `pg_cron` ermöglicht die Ausführung von geplanten Hintergrundaufträgen auf der DB-Instance und kann Aufträge so konfigurieren, dass sie in einer anderen Datenbank ausgeführt werden.
## Drop extension cascade ist deaktiviert
Die Möglichkeit, die Erweiterung mit der Option cascade durch einen Benutzer mit der `rds_extension`-Rolle zu löschen, wird durch den Parameter `rds.delegated_extension_allow_drop_cascade` gesteuert. `rds-delegated_extension_allow_drop_cascade` ist standardmäßig auf `off` festgelegt. Das bedeutet, dass Benutzer mit der Rolle `rds_extension` keine Erweiterung mithilfe der Option cascade löschen dürfen, wie in der untenstehenden Abfrage gezeigt.
```
DROP EXTENSION CASCADE;
```
Da dadurch automatisch Objekte gelöscht werden, die von der Erweiterung abhängen – und in der Folge auch alle Objekte, die wiederum von diesen Objekten abhängig sind. Der Versuch, die Option cascade zu verwenden, führt zu einem Fehler.
Zur Erteilung dieser Fähigkeit sollte der Parameter `rds.delegated_extension_allow_drop_cascade` auf `on` gesetzt werden.
Das Ändern des dynamischen Parameters `rds.delegated_extension_allow_drop_cascade` erfordert keinen Neustart der Datenbank. Sie können dies auf einer der folgenden Ebenen tun:
+ Im Cluster oder in der Instanzparametergruppe, über die API AWS-Managementkonsole oder.
+ Verwenden Sie den folgenden Befehl auf Datenbankebene:
```
alter database database_name set rds.delegated_extension_allow_drop_cascade = 'on';
```
+ Verwenden Sie den folgenden Befehl auf Benutzerebene:
```
alter role tenant_user set rds.delegated_extension_allow_drop_cascade = 'on';
```
## Beispielerweiterungen, die mithilfe der Unterstützung für delegierte Erweiterungen hinzugefügt werden können
+ `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
```