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.
# Grundlegendes zu PostgreSQL-Rollen und -Berechtigungen
Wenn Sie mit dem eine for PostgreSQL-DB-Instance erstellen AWS-Managementkonsole, wird gleichzeitig ein Administratorkonto erstellt. Der Name lautet standardmäßig `postgres`, wie im folgenden Screenshot gezeigt:
![\[Die Standardanmelde-Identität für Anmeldeinformationen auf der Seite Create database (Datenbank erstellen) lautet postgres.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/default-login-identity-apg-rpg.png)
Sie können einen anderen Namen auswählen, anstatt den Standard (`postgres`) beizubehalten. In diesem Fall muss der von Ihnen gewählte Name mit einem Buchstaben beginnen und zwischen 1 und 16 alphanumerische Zeichen umfassen. Der Einfachheit halber verwenden wir für das Hauptbenutzerkonto den Standardwert (`postgres`) in diesem Handbuch.
Wenn Sie den `create-db-instance` AWS CLI anstelle von verwenden, erstellen Sie den Namen AWS-Managementkonsole, indem Sie ihn zusammen mit dem `master-username` Parameter im Befehl übergeben. Weitere Informationen finden Sie unter [Erstellen einer Amazon-RDS-DB-Instance](USER_CreateDBInstance.md).
Unabhängig davon AWS-Managementkonsole, ob Sie die AWS CLI, oder die Amazon RDS-API verwenden und ob Sie den `postgres` Standardnamen verwenden oder einen anderen Namen wählen, ist dieses erste Datenbankbenutzerkonto Mitglied der `rds_superuser` Gruppe und verfügt über `rds_superuser` Berechtigungen.
**Topics**
+ [
# Die Rolle „rds\$1superuser“ verstehen
](Appendix.PostgreSQL.CommonDBATasks.Roles.rds_superuser.md)
+ [
# Steuern des Benutzerzugriffs auf die PostgreSQL−Datenbank
](Appendix.PostgreSQL.CommonDBATasks.Access.md)
+ [
# Delegieren und Steuern der Benutzerpasswortverwaltung
](Appendix.PostgreSQL.CommonDBATasks.RestrictPasswordMgmt.md)
+ [
# Verwenden von SCRAM für die PostgreSQL-Passwortverschlüsselung
](PostgreSQL_Password_Encryption_configuration.md)
# Die Rolle „rds\$1superuser“ verstehen
In PostgreSQL kann eine *Rolle* einen Benutzer, eine Gruppe oder einen Satz bestimmter Berechtigungen definieren, die einer Gruppe oder einem Benutzer für verschiedene Objekte in der Datenbank gewährt werden. PostgreSQL-Befehle für `CREATE USER` und `CREATE GROUP` wurden durch den allgemeineren Befehl `CREATE ROLE` mit bestimmten Eigenschaften zur Unterscheidung von Datenbankbenutzern ersetzt. Einen Datenbankbenutzer kann man sich als Rolle mit der LOGIN-Berechtigung vorstellen.
**Anmerkung**
Die Befehle `CREATE USER` und `CREATE GROUP` können weiterhin verwendet werden. Weitere Informationen dazu finden Sie im Abschnitt [Datenbankrollen](https://www.postgresql.org/docs/current/user-manag.html) der PostgreSQL-Dokumentation.
Der `postgres`-Benutzer ist der Datenbankbenutzer mit den meisten Berechtigungen auf Ihrer RDS-for-PostgreSQL-DB-Instance. Er verfügt über die Eigenschaften, die durch die folgende `CREATE ROLE`-Anweisung definiert sind.
```
CREATE ROLE postgres WITH LOGIN NOSUPERUSER INHERIT CREATEDB CREATEROLE NOREPLICATION VALID UNTIL 'infinity'
```
Die Eigenschaften `NOSUPERUSER`, `NOREPLICATION`, `INHERIT` und `VALID UNTIL 'infinity'` sind die Standardoptionen für CREATE ROLE, sofern nicht anders angegeben.
Standardmäßig verfügt `postgres` über Berechtigungen, die der `rds_superuser`-Rolle gewährt wurden, und über Berechtigungen zum Erstellen von Rollen und Datenbanken. Die `rds_superuser`-Rolle erlaubt dem `postgres`-Benutzer, folgende Aktionen auszuführen:
+ Erweiterungen für die Verwendung mit Amazon RDS hinzufügen. Weitere Informationen finden Sie unter [Arbeiten mit PostgreSQL-Funktionen, die von Amazon RDS für PostgreSQL unterstützt werden](PostgreSQL.Concepts.General.FeatureSupport.md)
+ Rollen für Benutzer erstellen und Benutzern Berechtigungen gewähren. Weitere Informationen dazu finden Sie im Abschnitt [CREATE ROLE](https://www.postgresql.org/docs/current/sql-createrole.html) und [GRANT](https://www.postgresql.org/docs/14/sql-grant.html) der PostgreSQL-Dokumentation.
+ Datenbanken erstellen. Weitere Informationen finden Sie im Abschnitt [CREATE DATABASE](https://www.postgresql.org/docs/14/sql-createdatabase.html) der PostgreSQL-Dokumentation.
+ Gewähren Sie `rds_superuser`-Berechtigungen anderen Benutzerrollen, die nicht über diese Berechtigungen verfügen, und widerrufen Sie diese Berechtigungen bei Bedarf. Es wird empfohlen, diese Rolle nur denjenigen Benutzern zu gewähren, die Superuser-Aufgaben ausführen. Mit anderen Worten, Sie können diese Rolle Datenbankadministratoren (DBAs) oder Systemadministratoren zuweisen.
+ Die `rds_replication`-Rolle Datenbankbenutzern gewähren (oder entziehen), die nicht über die `rds_superuser`-Rolle verfügen.
+ Die `rds_password`-Rolle Datenbankbenutzern gewähren (oder entziehen), die nicht über die `rds_superuser`-Rolle verfügen.
+ Statusinformationen über alle Datenbankverbindungen über die Ansicht `pg_stat_activity` abrufen. Bei Bedarf kann `rds_superuser` alle Verbindungen mit `pg_terminate_backend` oder `pg_cancel_backend` stoppen.
In der `CREATE ROLE postgres...`-Anweisung können Sie sehen, dass die `postgres`-Benutzerrolle PostgreSQL ausdrücklich `superuser`-Berechtigungen verweigert. RDS für PostgreSQL ist ein verwalteter Service, sodass Sie nicht auf das Host-Betriebssystem zugreifen können und keine Verbindung mit dem `superuser`-PostgreSQL-Konto herstellen können. Viele der Aufgaben, die `superuser`-Zugriff auf einem eigenständigem PostgreSQL erfordern, werden von Amazon RDS automatisch verwaltet.
Weitere Informationen zum Gewähren von Berechtigungen finden Sie unter [GRANT](http://www.postgresql.org/docs/current/sql-grant.html) in der PostgreSQL-Dokumentation.
Die `rds_superuser`-Rolle ist eine von mehreren *vordefinierten* Rollen in einem . DB-Instance von RDS für PostgreSQL
**Anmerkung**
In PostgreSQL 13 und früheren Versionen werden *vordefinierte Rollen* als *Standardrollen* bezeichnet.
In der folgenden Liste finden Sie einige der anderen vordefinierten Rollen, die automatisch für einen neuen erstellt werden. DB-Instance von RDS für PostgreSQL Vordefinierte Rollen und ihre Berechtigungen können nicht geändert werden. Sie können Berechtigungen für diese vordefinierten Rollen nicht löschen, umbenennen oder ändern. Jeder entsprechende Versuch führt zu einem Fehler.
+ **rds\$1passwort** – Eine Rolle, die Passwörter ändern und Passwortbeschränkungen für Datenbankbenutzer einrichten kann. Die `rds_superuser`-Rolle erhält diese Rolle standardmäßig und kann die Rolle Datenbankbenutzern gewähren. Weitere Informationen finden Sie unter [Steuern des Benutzerzugriffs auf die PostgreSQL−DatenbankSteuern des Benutzerzugriffs auf PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Access.md).
+ In Versionen von RDS für PostgreSQL, die höher sind als 14, kann die `rds_password`-Rolle Passwörter ändern und Passwortbeschränkungen für Datenbankbenutzer und Benutzer mit der `rds_superuser`-Rolle einrichten. Ab Version 14 und höher von RDS für PostgreSQL kann die `rds_password`-Rolle Passwörter ändern und Passwortbeschränkungen nur für Datenbankbenutzer einrichten. Nur Benutzer mit der `rds_superuser`-Rolle können diese Aktionen für andere Benutzer mit der `rds_superuser`-Rolle ausführen.
+ **rdsadmin** – Eine Rolle, die erstellt wurde, um viele der Verwaltungsaufgaben zu erledigen, die der Administrator mit `superuser`-Berechtigungen für eine eigenständige PostgreSQL-Datenbank ausführt. Diese Rolle wird intern von RDS für PostgreSQL für viele Verwaltungsaufgaben verwendet.
+ **rdstopmgr** – Eine Rolle, die intern von Amazon RDS zur Unterstützung von Multi-AZ-Bereitstellungen verwendet wird.
+ **rds\$1reserved** – Dies ist eine Rolle, die intern von Amazon RDS verwendet wird, um Datenbankverbindungen zu reservieren.
# Anzeigen von Rollen und deren Berechtigungen
Sie können vordefinierte Rollen und deren Berechtigungen in Ihrer DB-Instance von RDS für PostgreSQL je nach PostgreSQL-Version mit unterschiedlichen Befehlen anzeigen. Wenn Sie alle vordefinierten Rollen anzeigen möchten, können Sie eine Verbindung zu Ihrer DB-Instance von RDS für PostgreSQL herstellen und die folgenden Befehle mit `psql` ausführen.
**Für `psql` 15 und frühere Versionen**
Stellen Sie eine Verbindung zu Ihrer DB-Instance von RDS für PostgreSQL her und verwenden Sie den `\du`-Befehl in psql:
```
postgres=> \du
List of roles
Role name | Attributes | Member of
-----------------+------------------------------------------------------------+------------------------------------------------------
postgres | Create role, Create DB +| {rds_superuser}
| Password valid until infinity |
rds_ad | Cannot login | {}
rds_iam | Cannot login | {}
rds_password | Cannot login | {}
rds_replication | Cannot login | {}
rds_superuser | Cannot login | {pg_monitor,pg_signal_backend,rds_password,rds_replication}
rdsadmin | Superuser, Create role, Create DB, Replication, Bypass RLS+| {}
| Password valid until infinity |
```
**Für `psql` 16 und höhere Versionen**
```
postgres=> \drg+
List of role grants
Role name | Member of | Options | Grantor
---------------+-----------------------------+---------------------+----------
postgres | rds_superuser | INHERIT, SET | rdsadmin
rds_superuser | pg_checkpoint | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_monitor | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_signal_backend | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | pg_use_reserved_connections | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_password | ADMIN, INHERIT, SET | rdsadmin
rds_superuser | rds_replication | ADMIN, INHERIT, SET | rdsadmin
```
Wenn Sie die Rollenmitgliedschaft ohne Versionsabhängigkeit überprüfen möchten, können Sie die folgende SQL-Abfrage verwenden:
```
SELECT m.rolname AS "Role name", r.rolname AS "Member of"
FROM pg_catalog.pg_roles m
JOIN pg_catalog.pg_auth_members pam ON (pam.member = m.oid)
LEFT JOIN pg_catalog.pg_roles r ON (pam.roleid = r.oid)
LEFT JOIN pg_catalog.pg_roles g ON (pam.grantor = g.oid)
WHERE m.rolname !~ '^pg_'
ORDER BY 1, 2;
```
In der Ausgabe sehen Sie, dass `rds_superuser` keine Datenbankbenutzerrolle ist (sie kann sich nicht anmelden), aber über die Berechtigungen vieler anderer Rollen verfügt. Sie können auch sehen, dass dieser Datenbankbenutzer `postgres` Mitglied der `rds_superuser`-Rolle ist. Wie bereits erwähnt, ist `postgres` der Standardwert auf der Seite **Create database** (Datenbank erstellen) der Amazon-RDS-Konsole. Wenn Sie einen anderen Namen gewählt haben, wird dieser Name stattdessen in der Rollenliste angezeigt.
# Steuern des Benutzerzugriffs auf die PostgreSQL−Datenbank
Neue Datenbanken in PostgreSQL werden immer mit Standardberechtigungen im `public`-Schema der Datenbank erstellt, mit dem alle Datenbankbenutzer und -rollen Objekte erstellen können. Diese Berechtigungen ermöglichen es Datenbankbenutzern, eine Verbindung mit der Datenbank herzustellen und während der Verbindung temporäre Tabellen zu erstellen.
Es wird empfohlen, diese `public`-Standardberechtigungen zu widerrufen, um den Benutzerzugriff auf die Datenbank-Instances, die Sie auf Ihrer DB-Instance von RDS for PostgreSQL erstellen, besser kontrollieren können. Danach erteilen Sie Datenbankbenutzern auf einer detaillierteren Basis spezifische Berechtigungen, wie im Folgenden gezeigt.
**So richten Sie Rollen und Berechtigungen für eine neue Datenbank-Instance ein**
Angenommen, Sie richten eine Datenbank für eine neu erstellte DB-Instance von RDS for PostgreSQL ein, die von mehreren Forschenden verwendet wird, die alle Lese-/Schreibzugriff auf die Datenbank benötigen.
1. Verwenden Sie `psql` (oder pgAdmin) zum Herstellen einer Verbindung mit Ihrer DB-Instance von RDS for PostgreSQL:
```
psql --host=your-db-instance.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
Geben Sie bei der Aufforderung Ihr Passwort ein. Der `psql`-Client verbindet und zeigt die standardmäßige administrative Verbindungsdatenbank `postgres=>` als Eingabeaufforderung an.
1. Gehen Sie wie folgt vor, um zu verhindern, dass Datenbankbenutzer Objekte im `public`-Schema erstellen:
```
postgres=> REVOKE CREATE ON SCHEMA public FROM PUBLIC;
REVOKE
```
1. Als Nächstes erstellen Sie eine neue Datenbank-Instance:
```
postgres=> CREATE DATABASE lab_db;
CREATE DATABASE
```
1. Widerrufen Sie alle Berechtigungen aus dem `PUBLIC`-Schema in dieser neuen Datenbank.
```
postgres=> REVOKE ALL ON DATABASE lab_db FROM public;
REVOKE
```
1. Erstellen Sie eine Rolle für Datenbankbenutzer.
```
postgres=> CREATE ROLE lab_tech;
CREATE ROLE
```
1. Geben Sie Datenbankbenutzern mit dieser Rolle die Möglichkeit, eine Verbindung mit der Datenbank herzustellen.
```
postgres=> GRANT CONNECT ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Gewähren Sie allen Benutzern mit der `lab_tech`-Rolle alle Berechtigungen für diese Datenbank.
```
postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_db TO lab_tech;
GRANT
```
1. Erstellen Sie Datenbankbenutzer wie folgt:
```
postgres=> CREATE ROLE lab_user1 LOGIN PASSWORD 'change_me';
CREATE ROLE
postgres=> CREATE ROLE lab_user2 LOGIN PASSWORD 'change_me';
CREATE ROLE
```
1. Gewähren Sie diesen beiden Benutzern die Berechtigungen, die mit der lab\$1tech-Rolle verknüpft sind:
```
postgres=> GRANT lab_tech TO lab_user1;
GRANT ROLE
postgres=> GRANT lab_tech TO lab_user2;
GRANT ROLE
```
An dieser Stelle können `lab_user1` und `lab_user2` eine Verbindung mit der `lab_db`-Datenbank herstellen. Dieses Beispiel folgt nicht den bewährten Methoden für den Unternehmensgebrauch, darunter das Erstellen mehrerer Datenbank-Instances, verschiedener Schemas und das Erteilen eingeschränkter Berechtigungen. Umfassende Informationen und zusätzliche Szenarien finden Sie unter [Verwalten von PostgreSQL-Benutzern und -Rollen](https://aws.amazon.com/blogs//database/managing-postgresql-users-and-roles/).
Weitere Informationen zu Berechtigungen in PostgreSQL-Datenbanken finden Sie unter dem Befehl [GRANT](https://www.postgresql.org/docs/current/static/sql-grant.html) in der PostgreSQL-Dokumentation.
# Delegieren und Steuern der Benutzerpasswortverwaltung
Als DBA sollten Sie ggf. die Verwaltung von Benutzerpasswörtern delegieren. Oder Sie möchten verhindern, dass Datenbankbenutzer ihre Passwörter ändern oder Passwortbeschränkungen wie die Lebensdauer des Passworts neu konfigurieren. Um sicherzustellen, dass nur die von Ihnen ausgewählten Datenbankbenutzer Passworteinstellungen ändern können, können Sie die Funktion zur eingeschränkten Passwortverwaltung aktivieren. Wenn Sie diese Funktion aktivieren, können nur die Datenbankbenutzer, denen die `rds_password`-Rolle gewährt wurde, Passwörter verwalten.
**Anmerkung**
Um die eingeschränkte Passwortverwaltung nutzen zu können, muss Ihre DB-Instance für RDS for PostgreSQL PostgreSQL 10.6 oder höher ausführen.
Standardmäßig lautet diese Funktion `off`, wie im Folgenden gezeigt:
```
postgres=> SHOW rds.restrict_password_commands;
rds.restrict_password_commands
--------------------------------
off
(1 row)
```
Zum Aktivieren dieser Funktion verwenden Sie eine benutzerdefinierte Parametergruppe und ändern die Einstellung für `rds.restrict_password_commands` in 1. Stellen Sie sicher, dass Sie Ihre DB-Instance von RDS for PostgreSQL neu starten, damit die Einstellung wirksam wird.
Wenn diese Funktion aktiv ist, werden für die folgenden SQL-Befehle `rds_password`-Berechtigungen benötigt:
```
CREATE ROLE myrole WITH PASSWORD 'mypassword';
CREATE ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword' VALID UNTIL '2023-01-01';
ALTER ROLE myrole WITH PASSWORD 'mypassword';
ALTER ROLE myrole VALID UNTIL '2023-01-01';
ALTER ROLE myrole RENAME TO myrole2;
```
Das Umbenennen einer Rolle (`ALTER ROLE myrole RENAME TO newname`) ist ebenfalls eingeschränkt, wenn das Passwort den MD5 Hash-Algorithmus verwendet.
Wenn diese Funktion aktiv ist, generiert jeder Versuch, einen dieser SQL-Befehle ohne die `rds_password`-Rollenberechtigungen auszuführen, den folgenden Fehler:
```
ERROR: must be a member of rds_password to alter passwords
```
Wir empfehlen, dass Sie die `rds_password`-Berechtigung nur wenigen Rollen zuweisen, die Sie ausschließlich für die Passwortverwaltung verwenden. Wenn Sie `rds_password`-Berechtigungen für Datenbankbenutzer erteilen, die keine `rds_superuser`-Berechtigungen haben, müssen Sie ihnen auch das `CREATEROLE`-Attribut erteilen.
Stellen Sie sicher, dass Sie die Passwortanforderungen wie Ablaufdatum und erforderliche Komplexität auf Kundenseite überprüfen. Wenn Sie Ihr eigenes clientseitiges Dienstprogramm für passwortbezogene Änderungen verwenden, muss das Dienstprogramm Mitglied von `rds_password` sein und über `CREATE ROLE`-Berechtigungen verfügen.
# Verwenden von SCRAM für die PostgreSQL-Passwortverschlüsselung
Der *Salted Challenge Response Authentication Mechanism (SCRAM)* ist eine Alternative zum standardmäßigen Message Digest (MD5) -Algorithmus von PostgreSQL zur Verschlüsselung von Passwörtern. Der SCRAM-Authentifizierungsmechanismus gilt als sicherer als. MD5 Weitere Informationen zu diesen beiden verschiedenen Ansätzen zur Sicherung von Passwörtern finden Sie unter [Passwortauthentifizierung](https://www.postgresql.org/docs/14/auth-password.html) in der PostgreSQL-Dokumentation.
Wir empfehlen, SCRAM statt MD5 als Kennwortverschlüsselungsschema für Ihren zu verwenden. DB-Instance von RDS für PostgreSQL Es ist ein kryptografischer Challenge-Response-Mechanismus, der den scram–sha-256-Algorithmus zur Passwortauthentifizierung und -verschlüsselung nutzt.
Möglicherweise müssen Sie Bibliotheken aktualisieren, damit Ihre Clientanwendungen SCRAM unterstützen können. JDBC-Versionen vor 42.2.0 unterstützen SCRAM beispielsweise nicht. Weitere Informationen finden Sie unter [PostgreSQL-JDBC-Treiber](https://jdbc.postgresql.org/changelogs/2018-01-17-42.2.0-release/) in der Dokumentation zu PostgreSQL-JDBC-Treibern. Für eine Liste anderer PostgreSQL-Treiber und SCRAM-Unterstützung siehe die [Treiberliste](https://wiki.postgresql.org/wiki/List_of_drivers) in der PostgreSQL-Dokumentation.
RDS für PostgreSQL 13.1 und höhere Versionen unterstützen scram-sha-256. Mit diesen Versionen können Sie Ihre DB-Instance auch so konfigurieren, dass SCRAM erforderlich ist, wie in den folgenden Verfahren beschrieben.
## Einrichtung des RDS für die PostgreSQL-DB-Instance, die SCRAM benötigt
können Sie verlangen, dass der DB-Instance von RDS für PostgreSQL nur Passwörter akzeptiert, die den scram-sha-256-Algorithmus verwenden.
**Wichtig**
Wenn Sie bei vorhandenen RDS-Proxys mit PostgreSQL-Datenbanken die Datenbankauthentifizierung so ändern, dass nur `SCRAM` verwendet wird, ist der Proxy für bis zu 60 Sekunden nicht verfügbar. Um das Problem zu vermeiden, führen Sie einen der folgenden Schritte aus:
Stellen Sie sicher, dass die Datenbank sowohl die `SCRAM`- als auch die `MD5`-Authentifizierung zulässt.
Wenn Sie nur die `SCRAM`-Authentifizierung verwenden möchten, erstellen Sie einen neuen Proxy, migrieren Sie Ihren Anwendungsdatenverkehr auf den neuen Proxy und löschen Sie dann den zuvor mit der Datenbank verknüpften Proxy.
Bevor Sie Änderungen an Ihrem System vornehmen, vergewissern Sie sich, dass Sie den folgenden Prozess komplett verstehen:
+ Sammeln Sie Informationen über alle Rollen und Passwortverschlüsselung für alle Datenbankbenutzer.
+ Überprüfen Sie die Parametereinstellungen für Ihren DB-Instance von RDS für PostgreSQL für die Parameter, die die Passwortverschlüsselung steuern.
+ Wenn Ihr DB-Instance von RDS für PostgreSQL eine Standardparametergruppe verwendet, müssen Sie eine benutzerdefinierte DB-Parametergruppe erstellen und sie auf Ihren DB-Instance von RDS für PostgreSQL anwenden, damit Sie bei Bedarf Parameter ändern können. Wenn Ihr DB-Instance von RDS für PostgreSQL eine benutzerdefinierte Parametergruppe verwendet, können Sie die erforderlichen Parameter bei Bedarf später im Prozess ändern.
+ Ändern Sie den Parameter `password_encryption` in `scram-sha-256`.
+ Informieren Sie alle Datenbankbenutzer, dass sie ihre Passwörter aktualisieren müssen. Wiederholen Sie diesen Schritt für Ihr `postgres`-Konto. Die neuen Passwörter werden mit dem scram-sha-256-Algorithmus verschlüsselt und gespeichert.
+ Stellen Sie sicher, dass alle Passwörter mit diesem Verschlüsselungstyp verschlüsselt sind.
+ Wenn alle Passwörter scram-sha-256 verwenden, können Sie den `rds.accepted_password_auth_method`-Parameter von `md5+scram` in `scram-sha-256` ändern.
**Warnung**
Nachdem Sie `rds.accepted_password_auth_method` nur in scram-sha-256 geändert haben, können Benutzer (Rollen) mit `md5`-verschlüsselten Passwörtern keine Verbindung herstellen.
### Machen Sie sich bereit, SCRAM für Ihren ) zu benötigen
Bevor Sie Änderungen an Ihrem DB-Instance von RDS für PostgreSQL, vornehmen, überprüfen Sie alle vorhandenen Datenbankbenutzerkonten. Überprüfen Sie auch die Art der Verschlüsselung, die für Passwörter verwendet wird. Sie können für diese Aufgaben die `rds_tools`-Erweiterung verwenden. Weitere Informationen darüber, welche PostgreSQL-Versionen `rds_tools` unterstützen, finden Sie unter [Erweiterungsversionen für Amazon RDS für PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html).
**So erhalten Sie eine Liste der Datenbankbenutzer (Rollen) und Passwortverschlüsselungsmethoden**
1. Verwenden Sie `psql` zum Herstellen einer Verbindung mit Ihrer DB-Instance von RDS für PostgreSQL, wie im Folgenden gezeigt.
```
psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Installieren Sie die `rds_tools`-Erweiterung.
```
postgres=> CREATE EXTENSION rds_tools;
CREATE EXTENSION
```
1. Rufen Sie eine Auflistung der Rollen und Verschlüsselungsmethoden ab.
```
postgres=> SELECT * FROM
rds_tools.role_password_encryption_type();
```
Die Ausgabe entspricht weitgehend der folgenden.
```
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | md5
user_465 | md5
postgres | md5
(8 rows)
```
### Erstellen einer benutzerdefinierten DB-Parametergruppe
**Anmerkung**
Wenn Ihre DB-Instance von RDS für PostgreSQL bereits eine benutzerdefinierte Parametergruppe verwendet, müssen Sie keine neue erstellen.
Eine Übersicht über Parametergruppen für Amazon RDS finden Sie unter [Arbeiten mit Parametern auf der DB-Instance von RDS for PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md).
Der für Passwörter verwendete Passwortverschlüsselungstyp wird in einem Parameter, `password_encryption`, festgelegt. Die Verschlüsselung, die der DB-Instance von RDS für PostgreSQL zulässt, wird in einem anderen Parameter, `rds.accepted_password_auth_method`, festgelegt. Wenn Sie den Standardwert eines dieser Parameter ändern, müssen Sie eine benutzerdefinierte DB-Parametergruppe erstellen und auf Ihre Instance anwenden.
Sie können auch die AWS-Managementkonsole oder die RDS-API verwenden, um eine benutzerdefinierte zu erstellen. Weitere Informationen finden Sie unter
Sie können jetzt die benutzerdefinierte Parametergruppe Ihrer DB-Instance zuordnen.
**Um eine benutzerdefinierte zu erstellen, DB-Parametergruppe**
1. Verwenden Sie den CLI-Befehl `[create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) ` zum Erstellen der benutzerdefinierten DB-Parametergruppe. In diesem Beispiel wird `postgres13` als Quelle für diese benutzerdefinierte Parametergruppe verwendet.
Für Linux, macOS oder Unix:
```
aws rds create-db-parameter-group --db-parameter-group-name 'docs-lab-scram-passwords' \
--db-parameter-group-family postgres13 --description 'Custom parameter group for SCRAM'
```
Für Windows:
```
aws rds create-db-parameter-group --db-parameter-group-name "docs-lab-scram-passwords" ^
--db-parameter-group-family postgres13 --description "Custom DB parameter group for SCRAM"
```
1. Verwenden Sie den CLI-Befehl `[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)` zum Anwenden dieser benutzerdefinierten Parametergruppe auf Ihren DB-Cluster von RDS für PostgreSQL.
Für Linux, macOS oder Unix:
```
aws rds modify-db-instance --db-instance-identifier 'your-instance-name' \
--db-parameter-group-name "docs-lab-scram-passwords
```
Für Windows:
```
aws rds modify-db-instance --db-instance-identifier "your-instance-name" ^
--db-parameter-group-name "docs-lab-scram-passwords
```
Zum erneuten Synchronisieren Ihrer DB-Instance von RDS für PostgreSQL mit Ihrer benutzerdefinierten DB-Parametergruppe müssen Sie die primäre und alle anderen Instances des Clusters neu starten. Planen Sie dies während Ihres regulären Wartungsfensters, um die Auswirkungen auf Ihre Benutzer zu minimieren.
### Konfigurieren der Passwortverschlüsselung für die Verwendung von SCRAM
Der Passwortverschlüsselungsmechanismus, der von einer DB-Instance von RDS für PostgreSQL verwendet wird, ist in der DB-Parametergruppe auf den Parameter `password_encryption` festgelegt. Zulässige Werte sind keine Angabe, `md5` oder `scram-sha-256`. Der Standardwert hängt von der Version von RDS für PostgreSQL wie folgt ab:
+ RDS für PostgreSQL 14 und höher – Der Standardwert ist `scram-sha-256`.
+ RDS für PostgreSQL 13 – Der Standardwert ist `md5`.
Mit einer benutzerdefinierten DB-Parametergruppe, die Ihrer DB-Instance von RDS für PostgreSQL angefügt ist, können Sie die Werte für den Passwortverschlüsselungsparameter ändern.
![\[Im Folgenden zeigt die RDS-Konsole die Standardwerte für die password_encryption-Parameter für RDS für PostgreSQL.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/rpg-pwd-encryption-md5-scram-1.png)
**So ändern Sie die Passwortverschlüsselungseinstellung in scram-sha-256**
+ Ändern Sie den Wert der Passwortverschlüsselung in scram-sha-256, wie nachfolgend gezeigt. Die Änderung kann sofort angewendet werden, da der Parameter dynamisch ist. Daher ist kein Neustart erforderlich, damit die Änderung wirksam wird.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group --db-parameter-group-name \
'docs-lab-scram-passwords' --parameters 'ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate'
```
Für Windows:
```
aws rds modify-db-parameter-group --db-parameter-group-name ^
"docs-lab-scram-passwords" --parameters "ParameterName=password_encryption,ParameterValue=scram-sha-256,ApplyMethod=immediate"
```
### Migrieren von Passwörtern für Benutzerrollen zu SCRAM
Sie können Passwörter für Benutzerrollen wie folgt zu SCRAM migrieren.
**Um Datenbankbenutzer- (Rollen-) Passwörter von MD5 zu SCRAM zu migrieren**
1. Melden Sie sich als Administratorbenutzer an (Standardbenutzer `postgres`), wie nachfolgend gezeigt.
```
psql --host=db-name.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Überprüfen Sie die Einstellung des `password_encryption`-Parameters auf der DB-Instance von RDS für PostgreSQL mithilfe des folgenden Befehls.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
md5
(1 row)
```
1. Ändern Sie den Wert dieses Parameters in scram-sha-256. Weitere Informationen finden Sie unter [Konfigurieren der Passwortverschlüsselung für die Verwendung von SCRAM](#PostgreSQL_Password_Encryption_configuration.configure-password-encryption).
1. Überprüfen Sie den Wert erneut, um sicherzustellen, dass er jetzt auf `scram-sha-256` festgelegt ist. Gehen Sie dazu wie folgt vor.
```
postgres=> SHOW password_encryption;
password_encryption
---------------------
scram-sha-256
(1 row)
```
1. Bitten Sie alle Datenbankbenutzer, ihre Passwörter zu ändern. Stellen Sie sicher, dass Sie auch Ihr eigenes Passwort für das `postgres`-Konto ändern (der Datenbankbenutzer mit `rds_superuser`-Berechtigungen).
```
labdb=> ALTER ROLE postgres WITH LOGIN PASSWORD 'change_me';
ALTER ROLE
```
1. Wiederholen Sie den Vorgang für alle Datenbanken auf dem DB-Instance von RDS für PostgreSQL
### Ändern des Parameters, um SCRAM zu erfordern
Dies ist der letzte Schritt in diesem Prozess. Nachdem Sie die Änderung im folgenden Verfahren vorgenommen haben, können sich Benutzerkonten (Rollen), die nach wie vor die `md5`-Verschlüsselung für Passwörter verwenden, nicht beim anmelden. DB-Instance von RDS für PostgreSQL
Die `rds.accepted_password_auth_method` gibt die Verschlüsselungsmethode an, die die DB-Instance von RDS für PostgreSQL als Benutzerpasswort beim Anmeldevorgang akzeptiert. Der Standardwert ist `md5+scram`, was bedeutet, dass eine der beiden Methoden akzeptiert wird. Im folgenden Bild finden Sie die Standardeinstellung für diesen Parameter.
![\[Die RDS-Konsole, die die Standardwerte und die zulässigen Werte für den rds.accepted_password_auth_method-Parameter zeigt.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/pwd-encryption-md5-scram-2.png)
Die zulässigen Werte für diesen Parameter sind `md5+scram` oder nur `scram`. Durch Ändern dieses Parameterwerts in `scram` wird er erforderlich.
**So ändern Sie den Parameterwert, sodass eine SCRAM-Authentifizierung für Passwörter erforderlich ist**
1. Stellen Sie sicher, dass alle Datenbank-Benutzerpasswörter für alle Datenbanken auf Ihrer DB-Instance von RDS für PostgreSQL `scram-sha-256` für die Passwortverschlüsselung verwenden. Fragen Sie hierzu `rds_tools` für die Rolle (Benutzer) und den Verschlüsselungstyp wie folgt ab.
```
postgres=> SELECT * FROM rds_tools.role_password_encryption_type();
rolname | encryption_type
----------------------+-----------------
pg_monitor |
pg_read_all_settings |
pg_read_all_stats |
pg_stat_scan_tables |
pg_signal_backend |
lab_tester | scram-sha-256
user_465 | scram-sha-256
postgres | scram-sha-256
( rows)
```
1. Wiederholen Sie die Abfrage auf allen DB-Instances Ihres DB-Instance von RDS für PostgreSQL
Wenn alle Passwörter scram-sha-256 verwenden, können Sie fortfahren.
1. Ändern Sie den Wert der akzeptierten Passwortauthentifizierung in scram-sha-256 wie folgt.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group --db-parameter-group-name 'docs-lab-scram-passwords' \
--parameters 'ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate'
```
Für Windows:
```
aws rds modify-db-parameter-group --db-parameter-group-name "docs-lab-scram-passwords" ^
--parameters "ParameterName=rds.accepted_password_auth_method,ParameterValue=scram,ApplyMethod=immediate"
```