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.
# IAM-Datenbankauthentifizierung
Sie können sich bei Ihrem mithilfe der AWS Identity and Access Management (IAM-) Datenbankauthentifizierung authentifizieren. Die IAM-Datenbankauthentifizierung funktioniert mit Aurora MySQL und Aurora PostgreSQL. Mit dieser Authentifizierungsmethode benötigen Sie kein Passwort, um eine Verbindung mit einer DB-Cluster herzustellen. Stattdessen verwenden Sie ein Authentifizierungstoken.
Ein *Authentifizierungstoken* ist eine eindeutige Zeichenfolge, die von Amazon Aurora auf Anforderung erzeugt wird. Authentifizierungstoken werden mit AWS Signature Version 4 generiert. Jedes Token verfällt 15 Minuten nach seiner Erzeugung. Da die Authentifizierung mithilfe von IAM extern verwaltet wird, ist es nicht erforderlich, Benutzeranmeldeinformationen in der Datenbank zu speichern. Sie können weiterhin auch die Standard-Datenbank-Authentifizierung verwenden. Das Token wird nur zur Authentifizierung verwendet und wirkt sich nicht auf die Sitzung aus, nachdem es eingerichtet wurde.
Die IAM-Datenbank-Authentifizierung bietet die folgenden Vorteile:
+ Der Netzwerkverkehr zur und von der Datenbank wird mit Secure Socket Layer (SSL) oder Transport Layer Security (TLS) verschlüsselt. Weitere Informationen zur Verwendung von Amazon Aurora SSL/TLS mit Amazon finden Sie unter[Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
+ Sie können IAM verwenden, um den Zugriff auf Ihre Datenbankressourcen zentral zu verwalten, anstatt den Zugriff individuell auf jedem DB-Cluster zu verwalten.
+ Für Anwendungen, die auf Amazon EC2 laufen, können Sie die der EC2-Instance eigenen Profil-Anmeldeinformationen anstatt eines Passworts verwenden, um auf Ihre Datenbank zuzugreifen. Dies erhöht die Sicherheit.
Erwägen Sie im Allgemeinen, die IAM-Datenbankauthentifizierung zu verwenden, wenn Ihre Anwendungen weniger als 200 Verbindungen pro Sekunde erstellen und Sie Benutzernamen und Passwörter nicht direkt in Ihrem Anwendungscode verwalten möchten.
Der JDBC-Treiber von Amazon Web Services (AWS) unterstützt die IAM-Datenbankauthentifizierung. Weitere Informationen finden Sie unter [AWS IAM-Authentifizierungs-Plug-In](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/using-the-jdbc-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) im [Amazon Web Services (AWS) JDBC-Treiber-Repository](https://github.com/aws/aws-advanced-jdbc-wrapper). GitHub
Der Python-Treiber von Amazon Web Services (AWS) unterstützt die IAM-Datenbankauthentifizierung. Weitere Informationen finden Sie unter [AWS IAM-Authentifizierungs-Plug-In](https://github.com/aws/aws-advanced-python-wrapper/blob/main/docs/using-the-python-driver/using-plugins/UsingTheIamAuthenticationPlugin.md) im [ GitHubPython-Treiber-Repository von Amazon Web Services (AWS)](https://github.com/aws/aws-advanced-python-wrapper).
Navigieren Sie durch die folgenden Themen, um zu erfahren, wie IAM für die DB-Authentifizierung eingerichtet wird:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Herstellen einer Verbindung zu Ihrem DB--Cluster mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.Connecting.md)
## Verfügbarkeit von Regionen und Versionen
Die Verfügbarkeit von Funktionen und der Support variieren zwischen bestimmten Versionen der einzelnen Aurora-Datenbank-Engines und in allen AWS-Regionen. Weitere Informationen zur Verfügbarkeit von Versionen und Regionen mit Aurora- und IAM-Datenbankauthentifizierung finden Sie unter [Unterstützte Regionen und Aurora-DB-Engines für die IAM-Datenbankauthentifizierung](Concepts.Aurora_Fea_Regions_DB-eng.Feature.IAMdbauth.md).
Für Aurora MySQL unterstützen alle unterstützten DB-Instance-Klassen die IAM-Datenbank-Authentifizierung, mit Ausnahme von db.t2.small und db.t3.small. Informationen zu den unterstützten DB-Instance-Klassen finden Sie unter [Unterstützte DB-Engines für DB-Instance-Klassen](Concepts.DBInstanceClass.SupportAurora.md).
## CLI- und SDK-Unterstützung
Die IAM-Datenbankauthentifizierung ist für die [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/generate-db-auth-token.html)und für die folgenden sprachspezifischen Sprachen verfügbar: AWS SDKs
+ [AWS SDK für .NET](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/RDS/TRDSAuthTokenGenerator.html)
+ [AWS SDK für C\$1\$1](https://docs.aws.amazon.com/sdk-for-cpp/latest/api/class_aws_1_1_r_d_s_1_1_r_d_s_client.html#ae134ffffed5d7672f6156d324e7bd392)
+ [AWS SDK für Go](https://docs.aws.amazon.com/sdk-for-go/api/service/rds/#pkg-overview)
+ [AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/latest/reference/software/amazon/awssdk/services/rds/RdsUtilities.html)
+ [AWS SDK für JavaScript](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_rds_signer.html)
+ [AWS SDK für PHP](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.Rds.AuthTokenGenerator.html)
+ [AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.generate_db_auth_token)
+ [AWS SDK für Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/RDS/AuthTokenGenerator.html)
## Einschränkungen der IAM-Datenbank-Authentifizierung
Beachten Sie bei der Verwendung der IAM-Datenbankauthentifizierung die folgenden Einschränkungen:
+ Derzeit unterstützt die IAM-Datenbankauthentifizierung nicht alle globalen Bedingungskontextschlüssel.
Weitere Informationen über globale Bedingungskontextschlüssel finden Sie unter [Globale AWS -Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im *IAM-Benutzerhandbuch*.
+ Wenn die IAM-Rolle (`rds_iam`) einem Benutzer (einschließlich RDS-Hauptbenutzer) hinzugefügt wird, hat bei PostgreSQL die IAM-Authentifizierung Vorrang vor der Passwort-Authentifizierung, so dass sich der Benutzer als IAM-Benutzer anmelden muss.
+ Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
+ CloudWatch und protokollieren Sie die CloudTrail IAM-Authentifizierung nicht. Diese Services verfolgen keine `generate-db-auth-token` API-Aufrufe, die die IAM-Rolle autorisieren, eine Datenbankverbindung zu aktivieren.
+ Die IAM-DB-Authentifizierung erfordert Rechenressourcen auf dem Cluster der Datenbank. Für eine zuverlässige Verbindung benötigen Sie zwischen 300 und 1000 MiB zusätzlichen Speicher in Ihrer Datenbank. Um den für Ihren Workload benötigten Speicher zu ermitteln, vergleichen Sie die RES-Spalte für RDS-Prozesse in der Enhanced-Monitoring-processlist vor und nach der Aktivierung der IAM-DB-Authentifizierung. Siehe [Anzeigen von Betriebssystem-Metriken in der RDS-Konsole](USER_Monitoring.OS.Viewing.md).
Wenn Sie eine Burstable-Klassen-Instance verwenden, vermeiden Sie einen Speichermangel, indem Sie den von anderen Parametern wie Puffern und Cache belegten Speicher um denselben Betrag reduzieren.
+ Für Aurora MySQL können Sie keine passwortbasierte Authentifizierung für einen Datenbankbenutzer verwenden, den Sie mit IAM-Authentifizierung konfigurieren.
+ Die IAM-DB-Authentifizierung wird für RDS auf Outposts für keine Engine unterstützt.
## Empfehlungen für die IAM-Datenbankauthentifizierung
Bei Verwendung der IAM-Datenbankauthentifizierung empfehlen wir Folgendes:
+ Verwenden Sie die IAM-Datenbankauthentifizierung, wenn Ihre Anwendung weniger als 200 neue IAM-Datenbankauthentifizierungsverbindungen pro Sekunde benötigt.
Die Datenbank-Engines, die mit Amazon Aurora kompatibel sind, setzen den Authentifizierungsversuchen pro Sekunde keine Grenzen. Wenn Sie jedoch die IAM-Datenbank-Authentifizierung verwenden, muss Ihre Anwendung ein Authentifizierungstoken erzeugen. Ihre Anwendung verwendet dann dieses Token, um eine Verbindung mit dem DB-Cluster herzustellen. Wenn Sie die Höchstanzahl neuer Verbindungen pro Sekunde überschreiten, kann der zusätzliche Overhead der IAM-Datenbankauthentifizierung zur Verbindungsablehnung führen.
Erwägen Sie die Verwendung von Verbindungspooling in Ihren Anwendungen, um den ständigen Verbindungsaufbau zu begrenzen. Dadurch lässt sich der Aufwand für die IAM-DB-Authentifizierung reduzieren und Ihre Anwendungen können bestehende Verbindungen wiederverwenden. Erwägen Sie alternativ die Verwendung von RDS-Proxy für diese Anwendungsfälle. RDS-Proxy ist mit zusätzlichen Kosten verbunden. Weitere Informationen finden Sie unter [RDS-Proxy – Preise](https://aws.amazon.com/rds/proxy/pricing/).
+ Die Größe eines IAM-Datenbankauthentifizierungstokens hängt von vielen Faktoren ab, einschließlich der Anzahl der IAM-Tags, IAM-Servicerichtlinien, ARN-Längen sowie andere IAM- und Datenbankeigenschaften. Die Mindestgröße dieses Tokens beträgt im Allgemeinen etwa 1 KB, kann aber durchaus größer sein. Da dieses Token als Passwort in der Verbindungszeichenfolge zur Datenbank verwendet wird, die die IAM-Authentifizierung verwendet, sollten Sie sicherstellen, dass Ihr Datenbanktreiber (z. B. ODBC) und and/or alle Tools dieses Token nicht aufgrund seiner Größe einschränken oder anderweitig kürzen. Ein verkürztes Token führt dazu, dass die von der Datenbank und IAM durchgeführte Authentifizierungsüberprüfung fehlschlägt.
+ Wenn Sie beim Erstellen eines IAM-Datenbank-Authentifizierungstokens temporäre Anmeldeinformationen verwenden, müssen die temporären Anmeldeinformationen weiterhin gültig sein, wenn Sie das IAM-Datenbank-Authentifizierungstoken für eine Verbindungsanforderung verwenden.
## Kontextschlüssel für globale Bedingungen werden nicht unterstützt AWS
Die IAM-Datenbankauthentifizierung unterstützt die folgende Teilmenge der AWS globalen Bedingungskontextschlüssel nicht.
+ `aws:Referer`
+ `aws:SourceIp`
+ `aws:SourceVpc`
+ `aws:SourceVpce`
+ `aws:UserAgent`
+ `aws:VpcSourceIp`
Weitere Informationen finden Sie unter [Globale AWS -Bedingungskontextschlüssel](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) im *IAM-Benutzerhandbuch*.
# Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung
Die IAM-Datenbank-Authentifizierung ist für DB-Cluster standardmäßig deaktiviert. Sie können die IAM-Datenbankauthentifizierung mithilfe der AWS-Managementkonsole AWS CLI, oder der API aktivieren oder deaktivieren.
Sie können die IAM-Datenbankauthentifizierung aktivieren, wenn Sie eine der folgenden Aktionen ausführen:
+ Informationen zum Erstellen eines neuen DB-Clusters mit aktivierter IAM-Datenbankauthentifizierung finden Sie unter [Erstellen eines Amazon Aurora-DB Clusters](Aurora.CreateInstance.md).
+ Informationen zum Ändern eines DB-Clusters zur Aktivierung der IAM-Datenbankauthentifizierung finden Sie unter [Ändern eines Amazon Aurora-DB-Clusters](Aurora.Modifying.md).
+ Informationen zum Wiederherstellen eines DB-Clusters aus einem Snapshot mit aktivierter IAM-Datenbankauthentifizierung finden Sie unter [Wiederherstellen aus einem DB-Cluster-Snapshot](aurora-restore-snapshot.md).
+ Informationen zum Wiederherstellen eines DB-Clusters zu einem Zeitpunkt mit aktivierter IAM-Datenbankauthentifizierung finden Sie unter [Wiederherstellen eines DB-Clusters zu einer bestimmten Zeit](aurora-pitr.md).
## Konsole
Jeder Erstellungs- oder Änderungsworkflow verfügt über einen Abschnitt **Database authentification (Datenbankauthentifizierung)**, in dem Sie die IAM-Datenbankauthentifizierung aktivieren oder deaktivieren können. Wählen Sie in diesem Abschnitt **Password and IAM database authentication (Passwort- und IAM-Datenbankauthentifizierung)**, um die IAM-Datenbankauthentifizierung zu aktivieren.
**So aktivieren bzw. deaktivieren die IAM-Datenbankauthentifizierung für eine vorhandene DB-einen vorhandenen DB-Cluster:**
1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Datenbanken** aus.
1. Wählen Sie den DB-Cluster aus, die Sie ändern möchten.
**Anmerkung**
Sie können die IAM-Authentifizierung nur aktivieren, wenn alle DB-Instances im Cluster mit IAM kompatibel sind. Überprüfen Sie die Kompatibilitätsanforderungen in [Verfügbarkeit von Regionen und Versionen](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
1. Wählen Sie **Modify** aus.
1. Wählen Sie im Abschnitt **Datenbankauthentifizierung** die Option aus, um die **IAM-Datenbankauthentifizierung** zu aktivieren. Wählen Sie **Passwort-Authentifizierung** oder **Passwort- und Kerberos-Authentifizierung** aus, um die IAM-Authentifizierung zu deaktivieren.
1. Sie können auch die Veröffentlichung von IAM-DB-Authentifizierungsprotokollen in Logs aktivieren. CloudWatch Wählen **Sie unter Protokollexporte** die Option **iam-db-auth-error Protokoll** aus. Das Veröffentlichen Ihrer CloudWatch Protokolle in Logs verbraucht Speicherplatz, und für diesen Speicherplatz fallen Gebühren an. Achten Sie darauf, alle CloudWatch Logs zu löschen, die Sie nicht mehr benötigen.
1. Klicken Sie auf **Continue**.
1. Um die Änderungen sofort anzuwenden, wählen Sie im Abschnitt **Scheduling of modifications (Planen von Änderungen)** die Option **Immediately (Sofort)**.
1. Wählen Sie **Cluster ändern**.
## AWS CLI
Verwenden Sie den Befehl, um mithilfe von einen neuen DB-Cluster mit IAM-Authentifizierung zu erstellen. AWS CLI[https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html) Legen Sie die Option `--enable-iam-database-authentication` fest.
Um einen bestehenden DB-Cluster mit oder ohne IAM-Authentifizierung zu aktualisieren, verwenden Sie den AWS CLI -Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html). Sie müssen entweder die Option `--enable-iam-database-authentication` oder `--no-enable-iam-database-authentication` angeben.
**Anmerkung**
Sie können die IAM-Authentifizierung nur aktivieren, wenn alle DB-Instances im Cluster mit IAM kompatibel sind. Überprüfen Sie die Kompatibilitätsanforderungen in [Verfügbarkeit von Regionen und Versionen](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Standardmäßig führt Aurora die Änderung während des nächsten Wartungsfensters durch. Wenn Sie diese Einstellung übergehen und die IAM-DB-Authentifizierung schnellstmöglich aktivieren möchten, verwenden Sie den Parameter `--apply-immediately`.
Wenn Sie einen wiederherstellen, verwenden Sie einen der folgenden AWS CLI Befehle:
+ `[restore-db-cluster-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html)`
+ `[restore-db-cluster-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)`
Die Voreinstellung der IAM-Datenbank-Authentifizierung entspricht der Einstellung des Quell-Snapshot. Wählen Sie die entsprechende Option `--enable-iam-database-authentication` oder `--no-enable-iam-database-authentication` aus.
## RDS-API
Verwenden Sie die API-Operation , um mithilfe der API eine neue DB-Instance mit IAM-Authentifizierung zu erstellen [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html). Stellen Sie den Parameter `EnableIAMDatabaseAuthentication` auf `true` ein.
Um einen bestehenden DB-Cluster mit oder ohne IAM-Authentifizierung zu aktualisieren, verwenden Sie die API-Operation [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html). Setzen Sie den Parameter `EnableIAMDatabaseAuthentication` auf `true`, um die IAM-Authentifizierung zu aktivieren, oder auf `false`, um sie zu deaktivieren.
**Anmerkung**
Sie können die IAM-Authentifizierung nur aktivieren, wenn alle DB-Instances im Cluster mit IAM kompatibel sind. Überprüfen Sie die Kompatibilitätsanforderungen in [Verfügbarkeit von Regionen und Versionen](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability).
Verwenden Sie eine der folgenden API-Operationen, wenn Sie einen DB--Cluster wiederherstellen.
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html)
Die Voreinstellung der IAM-Datenbank-Authentifizierung entspricht der Einstellung des Quell-Snapshot. Zum Ändern dieser Einstellung setzen Sie den Parameter `EnableIAMDatabaseAuthentication` auf `true`, um die IAM-Authentifizierung zu aktivieren, oder auf `false`, um sie zu deaktivieren.
# Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff
Sie müssen eine IAM-Richtlinie erstellen, um einem Benutzer oder einer Rolle zu erlauben, eine Verbindung mit Ihrem DB-Cluster herzustellen. Anschließend fügen Sie die Richtlinie an einen Berechtigungssatz oder eine Rolle an.
**Anmerkung**
Weitere Informationen zu IAM-Richtlinien finden Sie unter [Identity and Access Management für Amazon Aurora](UsingWithRDS.IAM.md).
Die folgende Beispielrichtlinie erlaubt einem Benutzer, eine Verbindung mit einem DB-Cluster mithilfe der IAM-Datenbank-Authentifizierung herzustellen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:cluster-ABCDEFGHIJKL01234/db_user"
]
}
]
}
```
------
**Wichtig**
Ein Benutzer mit Administratorberechtigungen kann auf DB-Cluster zugreifen, ohne über eine IAM-Richtlinie explizite Berechtigungen zu erhalten. Wenn Sie den Administratorzugriff auf DB--Cluster einschränken möchten, können Sie eine IAM-Rolle mit geeigneten, weniger privilegierten Berechtigungen erstellen und diese dem Administrator zuweisen.
**Anmerkung**
Verwechseln Sie das Präfix `rds-db:` nicht mit anderen RDS-API-Operationspräfixen, die mit `rds:` beginnen. Das Präfix `rds-db:` und die Aktion `rds-db:connect` werden nur zur IAM-Datenbank-Authentifizierung verwendet. Sie sind in keinem anderen Kontext gültig.
Die Beispielrichtlinie enthält eine einzige Anweisung mit den folgenden Elementen:
+ `Effect` – Geben Sie `Allow` an, um den Zugriff auf den DB-Cluster zu gewähren. Wenn Sie den Zugriff nicht ausdrücklich erlauben, wird er automatisch verweigert.
+ `Action` – Geben Sie `rds-db:connect` an, um Verbindungen mit dem DB-Cluster zu erlauben.
+ `Resource` – Geben Sie einen Amazon-Ressourcennamen (ARN) an, der ein Datenbankkonto auf einem DB-Cluster beschreibt. Das ARN-Format lautet folgendermaßen.
```
arn:aws:rds-db:region:account-id:dbuser:DbClusterResourceId/db-user-name
```
Ersetzen Sie in diesem Format Folgendes:
+ `region`ist die AWS Region für den . In der Beispielrichtlinie ist die AWS Region`us-east-2`.
+ `account-id`ist die AWS Kontonummer für den . In der Beispielrichtlinie lautet die Kontonummer `1234567890`. Der Benutzer muss demselben Konto wie das Konto für den DB--Cluster angehören.
Erstellen Sie für einen kontoübergreifenden Zugriff eine IAM-Rolle mit der oben angegebenen Richtlinie in dem Konto für den DB--Cluster und erlauben Sie Ihrem anderen Konto, die Rolle zu übernehmen.
+ `DbClusterResourceId` ist die Kennung des DB-Clusters. Diese Kennung ist für eine AWS Region eindeutig und ändert sich nie. In dieser Beispielrichtlinie lautet die Kennung `cluster-ABCDEFGHIJKL01234`.
Um eine in Amazon Aurora AWS-Managementkonsole für Amazon zu finden, wählen Sie den aus, um dessen Details zu sehen. Wechseln Sie zur Registerkarte **Konfiguration**. Die **Resource ID (Ressourcen-ID)** wird im Abschnitt **Configuration Details (Konfigurationsdetails)** angezeigt.
Alternativ können Sie den AWS CLI Befehl verwenden, um die Identifikatoren und Ressourcen IDs für Ihren gesamten in der aktuellen AWS Region aufzulisten, wie im Folgenden dargestellt.
```
aws rds describe-db-clusters --query "DBClusters[*].[DBClusterIdentifier,DbClusterResourceId]"
```
**Anmerkung**
Wenn Sie über den RDS-Proxy eine Verbindung zu einer Datenbank herstellen, geben Sie die Proxy-Ressourcen-ID an, z. B. `prx-ABCDEFGHIJKL01234`. Hinweise zur Verwendung der IAM-Datenbankauthentifizierung mit RDS-Proxy finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
+ `db-user-name` ist der Name des mit der IAM-Authentifizierung zu verknüpfenden Datenbankkontos. In der Beispielrichtlinie lautet das Datenbankkonto `db_user`.
Sie können andere erstellen ARNs , um verschiedene Zugriffsmuster zu unterstützen. Die folgende Richtlinie erlaubt den Zugriff auf zwei verschiedene Datenbankkonten auf einem DB-Cluster.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-ABCDEFGHIJKL01234/jane_doe",
"arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-ABCDEFGHIJKL01234/mary_roe"
]
}
]
}
```
------
Die folgende Richtlinie verwendet das Zeichen „\$1“, um allen und Datenbankkonten für ein bestimmtes AWS Konto und eine bestimmte AWS Region zuzuordnen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:111122223333:dbuser:*/*"
]
}
]
}
```
------
Die folgende Richtlinie entspricht allen für ein bestimmtes AWS Konto und eine bestimmte AWS Region. Allerdings gewährt die Richtlinie nur den Zugriff auf DB-Cluster, die über ein `jane_doe`-Datenbankkonto verfügen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"rds-db:connect"
],
"Resource": [
"arn:aws:rds-db:us-east-2:123456789012:dbuser:*/jane_doe"
]
}
]
}
```
------
Der Benutzer oder die Rolle hat nur auf jene Datenbanken Zugriff, auf die der Datenbankbenutzer zugreifen kann. Nehmen wir beispielsweise an, dass Ihr DB-Cluster über eine Datenbank mit dem Namen *dev* und eine weitere Datenbank mit dem Namen *test* verfügt. Wenn der Datenbankbenutzer `jane_doe` nur auf *dev* zugreifen kann, haben auch alle anderen Benutzer oder Rollen, die auf diesen DB-Cluster mit dem Benutzer `jane_doe` zugreifen, lediglich die Berechtigung für den Zugriff auf *dev*. Diese Zugriffsbeschränkung gilt auch für andere Datenbankobjekte, wie z. B. Tabellen, Ansichten usw.
Ein Administrator muss IAM-Richtlinien erstellen, die Entitäten die Berechtigung zum Ausführen bestimmter API-Operationen für die angegebenen Ressourcen gewähren, die diese benötigen. Der Administrator muss diese Richtlinien anschließend den Berechtigungssätzen oder Rollen anfügen, die diese Berechtigungen benötigen. Beispiele für Richtlinien finden Sie unter [Beispiele für identitätsbasierte Amazon-Aurora-Richtlinien](security_iam_id-based-policy-examples.md).
## Anfügen einer IAM-Richtlinie an einen Berechtigungssatz oder eine Rolle
Nachdem Sie eine IAM-Richtlinie erstellt haben, um die Datenbank-Authentifizierung zu erlauben, müssen Sie die Richtlinie an einen Berechtigungssatz oder eine Rolle anfügen. Eine praktische Anleitung zu diesem Thema finden Sie unter [Erstellen und Anfügen Ihrer ersten vom Kunden verwalteten Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) im *IAM-Benutzerhandbuch*.
Wenn Sie die praktischen Anleitung durchgehen, können Sie eine der in diesem Abschnitt aufgeführten Beispielrichtlinien als Ausgangsbasis verwenden und auf Ihre Bedürfnisse anpassen. Am Ende des Tutorials verfügen Sie über einen Berechtigungssatz mit einer angefügten Richtlinie, der zur Durchführung der Aktion `rds-db:connect` berechtigt ist.
**Anmerkung**
Sie können mehrere Berechtigungssätze oder Rollen mit demselben Datenbank-Benutzerkonto verknüpfen. Nehmen wir beispielsweise an, dass Ihre IAM-Richtlinie folgenden Ressourcen-ARN enthält.
```
arn:aws:rds-db:us-east-2:123456789012:dbuser:cluster-12ABC34DEFG5HIJ6KLMNOP78QR/jane_doe
```
Wenn Sie die Richtlinie an *Jane*, *Bob* und *Diego* anfügen, sind diese Benutzer in der Lage, eine Verbindung mit dem angegebenen DB-Cluster mithilfe des Datenbankkontos `jane_doe` herzustellen.
# Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung
Mit der IAM-Datenbank-Authentifizierung müssen Sie den von Ihnen erstellten Benutzerkonten keine Datenbankpasswörter zuweisen. Wenn Sie einen mit dem Datenbankkonto verknüpften Benutzer entfernen, sollten Sie auch das Datenbankkonto mit der Anweisung `DROP USER` entfernen.
**Anmerkung**
Der für die IAM-Authentifizierung verwendete Benutzername muss mit der Schreibweise des Benutzernamens in der Datenbank übereinstimmen.
**Topics**
+ [
## Verwenden der IAM-Authentifizierung mit Aurora MySQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.MySQL)
+ [
## Verwenden der IAM-Authentifizierung mit Aurora PostgreSQL
](#UsingWithRDS.IAMDBAuth.DBAccounts.PostgreSQL)
## Verwenden der IAM-Authentifizierung mit Aurora MySQL
Bei Aurora MySQL erfolgt die Authentifizierung über `AWSAuthenticationPlugin` ein von uns AWS bereitgestelltes Plugin, das nahtlos mit IAM zusammenarbeitet, um Ihre Benutzer zu authentifizieren. Stellen Sie als Hauptbenutzer oder als anderer Benutzer, der Benutzer erstellen und Berechtigungen gewähren kann, eine Verbindung mit dem DB-Cluster her. Geben Sie die `CREATE USER`-Anweisung aus, wie im folgenden Beispiel dargestellt.
```
CREATE USER 'jane_doe' IDENTIFIED WITH AWSAuthenticationPlugin AS 'RDS';
```
Die Klausel `IDENTIFIED WITH` ermöglicht Aurora MySQL die Verwendung von `AWSAuthenticationPlugin`, um das Datenbankkonto (`jane_doe`) zu authentifizieren. Die `AS 'RDS'`-Klausel bezieht sich auf die Authentifizierungsmethode. Stellen Sie sicher, dass der angegebene Datenbankbenutzername mit einer Ressource in der IAM-Richtlinie für den IAM-Datenbankzugriff identisch ist. Weitere Informationen finden Sie unter [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md).
**Anmerkung**
`ERROR 1524 (HY000): Plugin 'AWSAuthenticationPlugin' is not loaded`
Stellen Sie sicher, dass Sie eine unterstützte Konfiguration verwenden und die IAM-Datenbankauthentifizierung auf Ihrem DB-Cluster aktiviert haben, um den Fehler zu beheben. Weitere Informationen erhalten Sie unter [Verfügbarkeit von Regionen und Versionen](UsingWithRDS.IAMDBAuth.md#UsingWithRDS.IAMDBAuth.Availability) und [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md).
Nachdem Sie ein Konto mithilfe von `AWSAuthenticationPlugin` erstellt haben, können Sie es in der gleichen Weise wie sonstige Datenbankkonten verwalten. Sie können beispielsweise Kontoberechtigungen mit den Anweisungen `GRANT` und `REVOKE` oder mehrere Kontoattribute mit der Anweisung `ALTER USER` ändern.
SSL/TLS Bei Verwendung von IAM wird der Datenbank-Netzwerkverkehr verschlüsselt. Ändern Sie mit dem folgenden Befehl das Benutzerkonto, um SSL-Verbindungen zuzulassen.
```
ALTER USER 'jane_doe'@'%' REQUIRE SSL;
```
## Verwenden der IAM-Authentifizierung mit Aurora PostgreSQL
Wenn Sie die IAM-Authentifizierung mit Aurora PostgreSQL verwenden möchten, stellen Sie als Hauptbenutzer oder als anderer Benutzer, der Benutzer erstellen und Berechtigungen gewähren kann, eine Verbindung mit dem DB-Cluster her. Nachdem die Verbindung hergestellt wurde, erstellen Sie Datenbankbenutzer und weisen ihnen die `rds_iam`-Rolle zu, wie im folgenden Beispiel dargestellt.
```
CREATE USER db_userx;
GRANT rds_iam TO db_userx;
```
Stellen Sie sicher, dass der angegebene Datenbankbenutzername mit einer Ressource in der IAM-Richtlinie für den IAM-Datenbankzugriff identisch ist. Weitere Informationen finden Sie unter [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Sie müssen der `rds_iam`-Rolle gestatten, die IAM-Authentifizierung zu verwenden. Sie können auch verschachtelte Mitgliedschaften oder indirekte Zuweisungen der Rolle verwenden.
Beachten Sie, dass ein PostgreSQL-Datenbankbenutzer entweder die IAM- oder Kerberos-Authentifizierung verwenden kann, jedoch nicht beides, so dass dieser Benutzer nicht auch über die `rds_ad`-Rolle verfügen kann. Dies gilt auch für verschachtelte Mitgliedschaften. Weitere Informationen finden Sie unter [Schritt 7: Erstellen von PostgreSQL-Benutzern für Ihre Kerberos-Prinzipale](postgresql-kerberos-setting-up.md#postgresql-kerberos-setting-up.create-logins).
# Herstellen einer Verbindung zu Ihrem DB--Cluster mithilfe der IAM-Authentifizierung
Bei einer IAM-Datenbankauthentifizierung verwenden Sie ein Authentifizierungstoken, wenn Sie sich mit Ihrem DB-Cluster verbinden. Ein *Authentifizierungstoken* ist eine Zeichenfolge, die Sie anstelle eines Passworts verwenden. Nachdem Sie ein Authentifizierungstoken erzeugt haben, ist es 15 Minuten lang gültig. Wenn Sie versuchen, sich mit einem verfallenen Token zu verbinden, wird die Verbindungsabfrage abgelehnt.
Jedes Authentifizierungstoken muss eine gültige Signatur unter Verwendung von AWS Signature Version 4 enthalten. (Weitere Informationen finden Sie unter [Signaturprozess mit Signaturversion 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in der *Allgemeine AWS-Referenz.*) Die AWS CLI und ein AWS-SDK, z. B. AWS SDK für Java oder AWS SDK für Python (Boto3) kann jedes von Ihnen erstellte Token automatisch signieren.
Sie können ein Authentifizierungstoken verwenden, wenn Sie von einem anderen AWS-Service aus eine Verbindung zu Amazon Aurora einrichten, beispielsweise AWS Lambda. Durch Verwendung eines Tokens können Sie vermeiden, ein Passwort in Ihrem Code angeben zu müssen. Alternativ können Sie ein AWS SDK verwenden, um ein Authentifizierungstoken programmgesteuert zu erzeugen und programmgesteuert zu signieren.
Nachdem Sie über ein signiertes IAM-Authentifizierungstoken verfügen, können Sie eine Verbindung mit einem Aurora-DB-Cluster herstellen. Nachfolgend erfahren Sie, wie Sie dies mit einem Befehlszeilen-Tool oder mit einem AWS SDK, wie AWS SDK für Java oder AWS SDK für Python (Boto3), erreichen.
Weitere Informationen finden Sie in den folgenden Blogeinträgen:
+ [IAM-Authentifikation zum Verbinden mit von SQL Workbench/J mit Aurora MySQL oder Amazon RDS for MySQL verwenden](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [Verwenden der IAM-Authentifizierung zum Verbinden mit pgAdmin Amazon Aurora PostgreSQL oder Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [
# Herstellen einer Verbindung zu Ihrem DB-Cluster mithilfe von IAM-Authentifizierung für die AWS-Treiber
](IAMDBAuth.Connecting.Drivers.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung über die Befehlszeile: AWS CLI und MySQL-Client
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung über die Befehlszeile: AWS CLI und psql-Client
](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für .NET
](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Go
](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Java
](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Python (Boto3)
](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Herstellen einer Verbindung zu Ihrem DB-Cluster mithilfe von IAM-Authentifizierung für die AWS-Treiber
Die AWS-Treibersuite wurde so konzipiert, dass sie schnellere Umstellungs- und Failover-Zeiten sowie die Authentifizierung mit AWS Secrets Manager, AWS Identity and Access Management (IAM) und Verbundidentität unterstützt. Die AWS-Treiber müssen den Status des DB-Clusters überwachen und die Cluster-Topologie kennen, um den neuen Writer zu ermitteln. Dieser Ansatz reduziert die Umstellungs- und Failover-Zeiten auf Werte im einstelligen Sekundenbereich, im Vergleich zu Werten im zweistelligen Bereich bei Open-Source-Treibern.
Weitere Informationen zu den AWS-Treibern finden Sie in der Dokumentation zum Treiber der entsprechenden Sprache für Ihren [Aurora-MySQL](Aurora.Connecting.md#Aurora.Connecting.JDBCDriverMySQL)- oder [Aurora-PostgreSQL](Aurora.Connecting.md#Aurora.Connecting.AuroraPostgreSQL.Utilities)-DB-Cluster.
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung über die Befehlszeile: AWS CLI und MySQL-Client
Sie können von der Befehlszeile aus eine Verbindung zu einem Aurora-DB-Cluster der herstellen, indem Sie das `mysql` Befehlszeilentool AWS CLI und verwenden, wie im Folgenden beschrieben.
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Anmerkung**
Informationen zum Herstellen einer Verbindung mit Ihrer Datenbank mithilfe von SQL Workbench/J mit IAM-Authentifizierung finden Sie im Blogbeitrag [Verwenden Sie die IAM-Authentifizierung, um eine Verbindung mit SQL Workbench/J zu Aurora MySQL oder Amazon RDS for](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/) MySQL herzustellen.
**Topics**
+ [
## Generieren eines IAM-Authentifizierungstokens
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [
## Herstellen der Verbindung zu einem DB--Cluster
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Generieren eines IAM-Authentifizierungstokens
Im folgenden Beispiel wird gezeigt, wie Sie ein signiertes Authentifizierungstoken mithilfe der erhalte AWS CLI.
```
aws rds generate-db-auth-token \
--hostname rdsmysql.123456789012.us-west-2.rds.amazonaws.com \
--port 3306 \
--region us-west-2 \
--username jane_doe
```
In diesem Beispiel lauten die Parameter folgendermaßen:
+ `--hostname` – Der Hostname des DB--Clusters, auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `--region`— Die AWS Region, in der der wird
+ `--username` – Das Datenbankkonto, auf das Sie zugreifen möchten.
Die ersten Zeichen des Tokens sehen folgendermaßen aus.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
## Herstellen der Verbindung zu einem DB--Cluster
Das allgemeine Format zur Herstellung einer Verbindung wird nachfolgend dargestellt.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Dabei werden die folgenden Parameter verwendet:
+ `--host` – Der Hostname des DB--Clusters, auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `--ssl-ca` – Die SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält
Weitere Informationen finden Sie unter [TLS-Verbindungen mit DB-Clustern von Aurora MySQL](AuroraMySQL.Security.md#AuroraMySQL.Security.SSL).
Zum Download eines SSL-Zertifikats siehe [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin` – Ein Wert, der angibt, dass `AWSAuthenticationPlugin` für diese Verbindung zu verwenden ist.
Wenn Sie einen MariaDB-Client verwenden, ist die `--enable-cleartext-plugin` Option nicht erforderlich.
+ `--user` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `--password` – Ein signiertes IAM-Authentifizierungstoken.
Das Authentifizierungstoken besteht aus hunderten von Zeichen. Dessen Handhabung in der Befehlszeile kann unhandlich sein. Eine Möglichkeit zur Umgehung dieses Problems besteht darin, das Token in einer Umgebungsvariable zu speichern und dann bei der Verbindungsherstellung diese Variable zu verwenden. Im folgenden Beispiel ist eine Möglichkeit dargestellt, um dieses Problem zu umgehen. Im Beispiel */sample\$1dir/* ist dies der vollständige Pfad zur SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält.
```
RDSHOST="mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
TOKEN="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 3306 --region us-west-2 --username jane_doe )"
mysql --host=$RDSHOST --port=3306 --ssl-ca=/sample_dir/global-bundle.pem --enable-cleartext-plugin --user=jane_doe --password=$TOKEN
```
Wenn Sie die Verbindung mithilfe von `AWSAuthenticationPlugin` herstellen, wird die Verbindung mit SSL geschützt. Geben Sie an der `mysql>`-Eingabeaufforderung Folgendes ein, um dies zu überprüfen.
```
show status like 'Ssl%';
```
In den folgenden Linien in der Ausgabe finden Sie weitere Details.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung über die Befehlszeile: AWS CLI und psql-Client
Sie können über die Befehlszeile eine Verbindung mit einem Aurora-PostgreSQL-DB-Cluster mit der AWS CLI und dem psql-Befehlszeilen-Tool herstellen, wie nachfolgend beschrieben.
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Anmerkung**
Informationen zum Herstellen einer Verbindung mit Ihrer Datenbank mithilfe von pgAdmin mit IAM-Authentifizierung finden Sie im Blogbeitrag [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or Amazon RDS for PostgreSQL](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/).
**Topics**
+ [
## Generieren eines IAM-Authentifizierungstokens
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [
## Verbinden mit einem und einem Aurora PostgreSQL-Cluster
](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Generieren eines IAM-Authentifizierungstokens
Das Authentifizierungstoken besteht aus hunderten von Zeichen, wodurch es in der Befehlszeile unhandlich wird. Eine Möglichkeit zur Umgehung dieses Problems besteht darin, das Token in einer Umgebungsvariable zu speichern und dann bei der Verbindungsherstellung diese Variable zu verwenden. Das folgende Beispiel zeigt, wie Sie mithilfe des AWS CLI `generate-db-auth-token` Befehls ein signiertes Authentifizierungstoken abrufen und in einer `PGPASSWORD` Umgebungsvariablen speichern können.
```
export RDSHOST="mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
```
In diesem Beispiel lauten die Parameter für den `generate-db-auth-token`-Befehl folgendermaßen:
+ `--hostname`– Der Hostname des DB--Clusters (Cluster-Endpunkt), auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `--region`— Die AWS Region, in der der ausgeführt wird
+ `--username` – Das Datenbankkonto, auf das Sie zugreifen möchten.
Die ersten Zeichen des generierten Tokens sehen folgendermaßen aus.
```
mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com:5432/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
## Verbinden mit einem und einem Aurora PostgreSQL-Cluster
Das allgemeine Format zur Herstellung einer Verbindung mithilfe von psql wird nachfolgend dargestellt.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Dabei werden die folgenden Parameter verwendet:
+ `host`– Der Hostname des DB--Clusters (Cluster-Endpunkt), auf den Sie zugreifen möchten.
+ `port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `sslmode` – Der zu verwendende SSL-Modus.
Wenn Sie `sslmode=verify-full` verwenden, prüft die SSL-Verbindung den Endpunkt des DB-Clusters gegen den Endpunkt des SSL-Zertifikats.
+ `sslrootcert` – Die SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält
Weitere Informationen finden Sie unter [Sicherung von Aurora-PostgreSQL-Daten mit SSL/TLS](AuroraPostgreSQL.Security.md#AuroraPostgreSQL.Security.SSL).
Zum Download eines SSL-Zertifikats siehe [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
+ `dbname` – Die Datenbank, auf die Sie zugreifen möchten.
+ `user` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `password` – Ein signiertes IAM-Authentifizierungstoken.
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
Das folgende Beispiel zeigt die Verwendung von psql für die Verbindung. Im Beispiel verwendet psql die Umgebungsvariable `RDSHOST` für den Host und die Umgebungsvariable `PGPASSWORD` für das generierte Token. Außerdem */sample\$1dir/* ist dies der vollständige Pfad zur SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält.
```
export RDSHOST="mypostgres-cluster.cluster-123456789012.us-west-2.rds.amazonaws.com"
export PGPASSWORD="$(aws rds generate-db-auth-token --hostname $RDSHOST --port 5432 --region us-west-2 --username jane_doe )"
psql "host=$RDSHOST port=5432 sslmode=verify-full sslrootcert=/sample_dir/global-bundle.pem dbname=DBName user=jane_doe password=$PGPASSWORD"
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für .NET
Sie können wie im Folgenden beschrieben eine Verbindung zu einer mit Aurora MySQL oder Aurora PostgreSQL DB-Cluster herstellen. AWS SDK für .NET
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Beispiele**
In den folgenden Beispielcodes wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einem DB-Cluster verwenden.
Um dieses Codebeispiel auszuführen, benötigen Sie den, der auf der [AWS SDK für .NET](https://aws.amazon.com/sdk-for-net/)Site zu finden ist. AWS Die `AWSSDK.CORE`- und die `AWSSDK.RDS`-Pakete sind erforderlich. Um eine Verbindung zu einem herzustellen, verwenden Sie den.NET-Datenbankconnector für die DB-Engine, z. B. MySqlConnector für MariaDB oder MySQL, oder Npgsql für PostgreSQL.
Dieser Code stellt eine Verbindung mit einem Aurora MySQL DB-Cluster her. Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `server` – Der Endpunkt des DB--Clusters, auf den Sie zugreifen möchten.
+ `user` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `database` – Die Datenbank, auf die Sie zugreifen möchten.
+ `port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `SslMode` – Der zu verwendende SSL-Modus.
Wenn Sie `SslMode=Required` verwenden, prüft die SSL-Verbindung den Endpunkt des DB-Clusters gegen den Endpunkt des SSL-Zertifikats.
+ `SslCa` – Der vollständige Pfad zum SSL-Zertifikat für Amazon Aurora
Informationen zum Download eines Zertifikats finden Sie unter [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
```
using System;
using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;
using Amazon;
namespace ubuntu
{
class Program
{
static void Main(string[] args)
{
var pwd = Amazon.RDS.Util.RDSAuthTokenGenerator.GenerateAuthToken(RegionEndpoint.USEast1, "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com", 3306, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
MySqlConnection conn = new MySqlConnection($"server=mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com;user=jane_doe;database=mydB;port=3306;password={pwd};SslMode=Required;SslCa=full_path_to_ssl_certificate");
conn.Open();
// Define a query
MySqlCommand sampleCommand = new MySqlCommand("SHOW DATABASES;", conn);
// Execute a query
MySqlDataReader mysqlDataRdr = sampleCommand.ExecuteReader();
// Read all rows and output the first column in each row
while (mysqlDataRdr.Read())
Console.WriteLine(mysqlDataRdr[0]);
mysqlDataRdr.Close();
// Close connection
conn.Close();
}
}
}
```
Dieser Code stellt eine Verbindung mit einem Aurora PostgreSQL DB-Cluster her.
Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `Server` – Der Endpunkt des DB--Clusters, auf den Sie zugreifen möchten.
+ `User ID` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `Database` – Die Datenbank, auf die Sie zugreifen möchten.
+ `Port` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `SSL Mode` – Der zu verwendende SSL-Modus.
Wenn Sie `SSL Mode=Required` verwenden, prüft die SSL-Verbindung den Endpunkt des DB-Clusters gegen den Endpunkt des SSL-Zertifikats.
+ `Root Certificate` – Der vollständige Pfad zum SSL-Zertifikat für Amazon Aurora
Informationen zum Download eines Zertifikats finden Sie unter [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
```
using System;
using Npgsql;
using Amazon.RDS.Util;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
var pwd = RDSAuthTokenGenerator.GenerateAuthToken("postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com", 5432, "jane_doe");
// for debug only Console.Write("{0}\n", pwd); //this verifies the token is generated
NpgsqlConnection conn = new NpgsqlConnection($"Server=postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com;User Id=jane_doe;Password={pwd};Database=mydb;SSL Mode=Require;Root Certificate=full_path_to_ssl_certificate");
conn.Open();
// Define a query
NpgsqlCommand cmd = new NpgsqlCommand("select count(*) FROM pg_user", conn);
// Execute a query
NpgsqlDataReader dr = cmd.ExecuteReader();
// Read all rows and output the first column in each row
while (dr.Read())
Console.Write("{0}\n", dr[0]);
// Close connection
conn.Close();
}
}
}
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Go
Sie können wie im Folgenden beschrieben eine Verbindung zu einer mit Aurora MySQL oder Aurora PostgreSQL DB-Cluster herstellen. AWS SDK für Go
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Beispiele**
Um diese Codebeispiele auszuführen, benötigen Sie den, der auf der [AWS SDK für Go](https://aws.amazon.com/sdk-for-go/)Website zu finden ist. AWS
Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `dbName` – Die Datenbank, auf die Sie zugreifen möchten.
+ `dbUser` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `dbHost` – Der Endpunkt des DB--Clusters, auf den Sie zugreifen möchten.
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
+ `dbPort` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `region`— Die AWS Region, in der der läuft
Stellen Sie außerdem sicher, dass die importierten Bibliotheken im Beispielcode auf Ihrem System vorhanden sind.
**Wichtig**
Die Beispiele in diesem Abschnitt verwenden den folgenden Code, um Anmeldeinformationen bereitzustellen, die von einer lokalen Umgebung aus auf eine Datenbank zugreifen:
`creds := credentials.NewEnvCredentials()`
Wenn Sie über einen AWS Service wie Amazon EC2 oder Amazon ECS auf eine Datenbank zugreifen, können Sie den Code durch den folgenden Code ersetzen:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Wenn Sie diese Änderung vornehmen, stellen Sie sicher, dass Sie den folgenden Import hinzufügen:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [
## Verbindung mithilfe der IAM-Authentifizierung und V2 herstellen AWS SDK für Go
](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [
## Verbindung mithilfe der IAM-Authentifizierung und V1 herstellen. AWS SDK für Go
](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Verbindung mithilfe der IAM-Authentifizierung und V2 herstellen AWS SDK für Go
Sie können mithilfe der IAM-Authentifizierung und V2 eine Verbindung zu einem herstellen. AWS SDK für Go
In den folgenden Beispielcodes wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einem DB-Cluster verwenden.
Dieser Code stellt eine Verbindung mit einem Aurora MySQL DB-Cluster her.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 3306
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Dieser Code stellt eine Verbindung mit einem Aurora PostgreSQL DB-Cluster her.
```
package main
import (
"context"
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/lib/pq"
)
func main() {
var dbName string = "DatabaseName"
var dbUser string = "DatabaseUser"
var dbHost string = "postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
var dbPort int = 5432
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = "us-east-1"
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authenticationToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Verbindung mithilfe der IAM-Authentifizierung und V1 herstellen. AWS SDK für Go
Sie können mithilfe der IAM-Authentifizierung und V1 eine Verbindung zu einem herstellen AWS SDK für Go
In den folgenden Beispielcodes wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einem DB-Cluster verwenden.
Dieser Code stellt eine Verbindung mit einem Aurora MySQL DB-Cluster her.
```
package main
import (
"database/sql"
"fmt"
"log"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/go-sql-driver/mysql"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
dbPort := 3306
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Dieser Code stellt eine Verbindung mit einem Aurora PostgreSQL DB-Cluster her.
```
package main
import (
"database/sql"
"fmt"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/service/rds/rdsutils"
_ "github.com/lib/pq"
)
func main() {
dbName := "app"
dbUser := "jane_doe"
dbHost := "postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
dbPort := 5432
dbEndpoint := fmt.Sprintf("%s:%d", dbHost, dbPort)
region := "us-east-1"
creds := credentials.NewEnvCredentials()
authToken, err := rdsutils.BuildAuthToken(dbEndpoint, region, dbUser, creds)
if err != nil {
panic(err)
}
dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s",
dbHost, dbPort, dbUser, authToken, dbName,
)
db, err := sql.Open("postgres", dsn)
if err != nil {
panic(err)
}
err = db.Ping()
if err != nil {
panic(err)
}
}
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Java
Sie können wie im Folgenden beschrieben eine Verbindung zu einer mit Aurora MySQL oder Aurora PostgreSQL DB-Cluster herstellen. AWS SDK für Java
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Richten Sie das AWS SDK for Java ein](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Beispiele zur Verwendung des SDK für Java 2.x finden Sie unter [Amazon RDS examples using SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). Sie können auch den AWS Advanced JDBC Wrapper verwenden, siehe [AWS Advanced JDBC](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md) Wrapper Dokumentation.
**Topics**
+ [
## Generieren eines IAM-Authentifizierungstokens
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [
## Manuelles Erzeugen eines IAM-Authentifizierungstokens
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [
## Herstellen der Verbindung zu einem DB--Cluster
](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Generieren eines IAM-Authentifizierungstokens
Wenn Sie Programme mit dem schreiben AWS SDK für Java, können Sie mithilfe der Klasse ein signiertes Authentifizierungstoken erhalten. `RdsIamAuthTokenGenerator` Für die Verwendung dieser Klasse müssen Sie AWS Anmeldeinformationen angeben. Dazu erstellen Sie eine Instanz der `DefaultAWSCredentialsProviderChain` Klasse. `DefaultAWSCredentialsProviderChain`verwendet den ersten AWS Zugriffsschlüssel und den ersten geheimen Schlüssel, den es in der [standardmäßigen Anbieterkette für Anmeldeinformationen](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default) findet. Weitere Informationen über AWS -Zugriffsschlüssel finden Sie unter [Verwalten von Zugriffsschlüsseln für Benutzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
Nachdem Sie eine Instance von `RdsIamAuthTokenGenerator` erstellt haben, können Sie das `getAuthToken`-Verfahren aufrufen, um ein signiertes Token zu erhalten. Geben Sie die AWS -Region, den Hostnamen, die Portnummer und den Benutzernamen an. Der folgende Beispielcode veranschaulicht diese Vorgehensweise.
```
package com.amazonaws.codesamples;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
public class GenerateRDSAuthToken {
public static void main(String[] args) {
String region = "us-west-2";
String hostname = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
System.out.println(generateAuthToken(region, hostname, port, username));
}
static String generateAuthToken(String region, String hostName, String port, String username) {
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new DefaultAWSCredentialsProviderChain())
.region(region)
.build();
String authToken = generator.getAuthToken(
GetIamAuthTokenRequest.builder()
.hostname(hostName)
.port(Integer.parseInt(port))
.userName(username)
.build());
return authToken;
}
}
```
## Manuelles Erzeugen eines IAM-Authentifizierungstokens
Der einfachste Weg in Java, um ein Authentifizierungstoken zu erzeugen, ist die Verwendung von `RdsIamAuthTokenGenerator`. Diese Klasse erstellt ein Authentifizierungstoken für Sie und signiert es dann mit der AWS Signaturversion 4. Weitere Informationen finden Sie unter [Signaturprozess mit Signaturversion 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) im *Allgemeine AWS-Referenz.*
Sie können allerdings das Authentifizierungstoken auch manuell erstellen und signieren, wie im folgenden Beispielcode dargestellt.
```
package com.amazonaws.codesamples;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.SigningAlgorithm;
import com.amazonaws.util.BinaryUtils;
import org.apache.commons.lang3.StringUtils;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.SortedMap;
import java.util.TreeMap;
import static com.amazonaws.auth.internal.SignerConstants.AWS4_TERMINATOR;
import static com.amazonaws.util.StringUtils.UTF8;
public class CreateRDSAuthTokenManually {
public static String httpMethod = "GET";
public static String action = "connect";
public static String canonicalURIParameter = "/";
public static SortedMap canonicalQueryParameters = new TreeMap();
public static String payload = StringUtils.EMPTY;
public static String signedHeader = "host";
public static String algorithm = "AWS4-HMAC-SHA256";
public static String serviceName = "rds-db";
public static String requestWithoutSignature;
public static void main(String[] args) throws Exception {
String region = "us-west-2";
String instanceName = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
String port = "3306";
String username = "jane_doe";
Date now = new Date();
String date = new SimpleDateFormat("yyyyMMdd").format(now);
String dateTimeStamp = new SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'").format(now);
DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
String awsAccessKey = creds.getCredentials().getAWSAccessKeyId();
String awsSecretKey = creds.getCredentials().getAWSSecretKey();
String expiryMinutes = "900";
System.out.println("Step 1: Create a canonical request:");
String canonicalString = createCanonicalString(username, awsAccessKey, date, dateTimeStamp, region, expiryMinutes, instanceName, port);
System.out.println(canonicalString);
System.out.println();
System.out.println("Step 2: Create a string to sign:");
String stringToSign = createStringToSign(dateTimeStamp, canonicalString, awsAccessKey, date, region);
System.out.println(stringToSign);
System.out.println();
System.out.println("Step 3: Calculate the signature:");
String signature = BinaryUtils.toHex(calculateSignature(stringToSign, newSigningKey(awsSecretKey, date, region, serviceName)));
System.out.println(signature);
System.out.println();
System.out.println("Step 4: Add the signing info to the request");
System.out.println(appendSignature(signature));
System.out.println();
}
//Step 1: Create a canonical request date should be in format YYYYMMDD and dateTime should be in format YYYYMMDDTHHMMSSZ
public static String createCanonicalString(String user, String accessKey, String date, String dateTime, String region, String expiryPeriod, String hostName, String port) throws Exception {
canonicalQueryParameters.put("Action", action);
canonicalQueryParameters.put("DBUser", user);
canonicalQueryParameters.put("X-Amz-Algorithm", "AWS4-HMAC-SHA256");
canonicalQueryParameters.put("X-Amz-Credential", accessKey + "%2F" + date + "%2F" + region + "%2F" + serviceName + "%2Faws4_request");
canonicalQueryParameters.put("X-Amz-Date", dateTime);
canonicalQueryParameters.put("X-Amz-Expires", expiryPeriod);
canonicalQueryParameters.put("X-Amz-SignedHeaders", signedHeader);
String canonicalQueryString = "";
while(!canonicalQueryParameters.isEmpty()) {
String currentQueryParameter = canonicalQueryParameters.firstKey();
String currentQueryParameterValue = canonicalQueryParameters.remove(currentQueryParameter);
canonicalQueryString = canonicalQueryString + currentQueryParameter + "=" + currentQueryParameterValue;
if (!currentQueryParameter.equals("X-Amz-SignedHeaders")) {
canonicalQueryString += "&";
}
}
String canonicalHeaders = "host:" + hostName + ":" + port + '\n';
requestWithoutSignature = hostName + ":" + port + "/?" + canonicalQueryString;
String hashedPayload = BinaryUtils.toHex(hash(payload));
return httpMethod + '\n' + canonicalURIParameter + '\n' + canonicalQueryString + '\n' + canonicalHeaders + '\n' + signedHeader + '\n' + hashedPayload;
}
//Step 2: Create a string to sign using sig v4
public static String createStringToSign(String dateTime, String canonicalRequest, String accessKey, String date, String region) throws Exception {
String credentialScope = date + "/" + region + "/" + serviceName + "/aws4_request";
return algorithm + '\n' + dateTime + '\n' + credentialScope + '\n' + BinaryUtils.toHex(hash(canonicalRequest));
}
//Step 3: Calculate signature
/**
* Step 3 of the &AWS; Signature version 4 calculation. It involves deriving
* the signing key and computing the signature. Refer to
* http://docs.aws.amazon
* .com/general/latest/gr/sigv4-calculate-signature.html
*/
public static byte[] calculateSignature(String stringToSign,
byte[] signingKey) {
return sign(stringToSign.getBytes(Charset.forName("UTF-8")), signingKey,
SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(byte[] data, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
Mac mac = algorithm.getMac();
mac.init(new SecretKeySpec(key, algorithm.toString()));
return mac.doFinal(data);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
public static byte[] newSigningKey(String secretKey,
String dateStamp, String regionName, String serviceName) {
byte[] kSecret = ("AWS4" + secretKey).getBytes(Charset.forName("UTF-8"));
byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
byte[] kService = sign(serviceName, kRegion,
SigningAlgorithm.HmacSHA256);
return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
}
public static byte[] sign(String stringData, byte[] key,
SigningAlgorithm algorithm) throws SdkClientException {
try {
byte[] data = stringData.getBytes(UTF8);
return sign(data, key, algorithm);
} catch (Exception e) {
throw new SdkClientException(
"Unable to calculate a request signature: "
+ e.getMessage(), e);
}
}
//Step 4: append the signature
public static String appendSignature(String signature) {
return requestWithoutSignature + "&X-Amz-Signature=" + signature;
}
public static byte[] hash(String s) throws Exception {
try {
MessageDigest md = MessageDigest.getInstance("SHA-256");
md.update(s.getBytes(UTF8));
return md.digest();
} catch (Exception e) {
throw new SdkClientException(
"Unable to compute hash while signing request: "
+ e.getMessage(), e);
}
}
}
```
## Herstellen der Verbindung zu einem DB--Cluster
Im folgenden Codebeispiel wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einem Cluster für die Ausführung mit Aurora MySQL verwenden können.
Um dieses Codebeispiel auszuführen, benötigen Sie den [AWS SDK für Java](https://aws.amazon.com/sdk-for-java/), der auf der AWS Site zu finden ist. Außerdem benötigen Sie Folgendes:
+ MySQL Connector/J. Dieses Codebeispiel wurde mit `mysql-connector-java-5.1.33-bin.jar` getestet.
+ Ein Zwischenzertifikat für Amazon Aurora, das für eine AWS Region spezifisch ist. (Weitere Informationen finden Sie unter [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).) Während der Laufzeit sucht der Class Loader das Zertifikat in demselben Verzeichnis, in dem sich dieser Java-Beispielcode befindet, damit er es finden kann.
+ Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `RDS_INSTANCE_HOSTNAME` – Der Hostname des DB--Clusters, auf den Sie zugreifen möchten.
+ `RDS_INSTANCE_PORT` – Die Nummer des Ports, der für die Verbindung zum PostgreSQL-DB-Cluster verwendet wird.
+ `REGION_NAME`— Die AWS Region, in der der ausgeführt wird.
+ `DB_USER` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `SSL_CERTIFICATE`— Ein SSL-Zertifikat für Amazon Aurora, das für eine AWS Region spezifisch ist.
Informationen zum Herunterladen eines Zertifikats für Ihre AWS -Region finden Sie unter [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md). Speichern Sie das SSL-Zertifikat in demselben Verzeichnis wie diese Java-Programmdatei ab, damit der Class Loader das Zertifikat während der Laufzeit finden kann.
In diesem Codebeispiel werden AWS Anmeldeinformationen aus der [standardmäßigen Anbieterkette für Anmeldeinformationen abgerufen](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**Anmerkung**
Geben Sie aus Sicherheitsgründen für `DEFAULT_KEY_STORE_PASSWORD` ein anderes Passwort als hier angegeben an.
```
package com.amazonaws.samples;
import com.amazonaws.services.rds.auth.RdsIamAuthTokenGenerator;
import com.amazonaws.services.rds.auth.GetIamAuthTokenRequest;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;
import java.net.URL;
public class IAMDatabaseAuthenticationTester {
//&AWS; Credentials of the IAM user with policy enabling IAM Database Authenticated access to the db by the db user.
private static final DefaultAWSCredentialsProviderChain creds = new DefaultAWSCredentialsProviderChain();
private static final String AWS_ACCESS_KEY = creds.getCredentials().getAWSAccessKeyId();
private static final String AWS_SECRET_KEY = creds.getCredentials().getAWSSecretKey();
//Configuration parameters for the generation of the IAM Database Authentication token
private static final String RDS_INSTANCE_HOSTNAME = "rdsmysql.123456789012.us-west-2.rds.amazonaws.com";
private static final int RDS_INSTANCE_PORT = 3306;
private static final String REGION_NAME = "us-west-2";
private static final String DB_USER = "jane_doe";
private static final String JDBC_URL = "jdbc:mysql://" + RDS_INSTANCE_HOSTNAME + ":" + RDS_INSTANCE_PORT;
private static final String SSL_CERTIFICATE = "rds-ca-2019-us-west-2.pem";
private static final String KEY_STORE_TYPE = "JKS";
private static final String KEY_STORE_PROVIDER = "SUN";
private static final String KEY_STORE_FILE_PREFIX = "sys-connect-via-ssl-test-cacerts";
private static final String KEY_STORE_FILE_SUFFIX = ".jks";
private static final String DEFAULT_KEY_STORE_PASSWORD = "changeit";
public static void main(String[] args) throws Exception {
//get the connection
Connection connection = getDBConnectionUsingIam();
//verify the connection is successful
Statement stmt= connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 'Success!' FROM DUAL;");
while (rs.next()) {
String id = rs.getString(1);
System.out.println(id); //Should print "Success!"
}
//close the connection
stmt.close();
connection.close();
clearSslProperties();
}
/**
* This method returns a connection to the db instance authenticated using IAM Database Authentication
* @return
* @throws Exception
*/
private static Connection getDBConnectionUsingIam() throws Exception {
setSslProperties();
return DriverManager.getConnection(JDBC_URL, setMySqlConnectionProperties());
}
/**
* This method sets the mysql connection properties which includes the IAM Database Authentication token
* as the password. It also specifies that SSL verification is required.
* @return
*/
private static Properties setMySqlConnectionProperties() {
Properties mysqlConnectionProperties = new Properties();
mysqlConnectionProperties.setProperty("verifyServerCertificate","true");
mysqlConnectionProperties.setProperty("useSSL", "true");
mysqlConnectionProperties.setProperty("user",DB_USER);
mysqlConnectionProperties.setProperty("password",generateAuthToken());
return mysqlConnectionProperties;
}
/**
* This method generates the IAM Auth Token.
* An example IAM Auth Token would look like follows:
* btusi123---cmz7kenwo2ye---rds---cn-north-1.amazonaws.com.rproxy.goskope.com.cn:3306/?Action=connect&DBUser=iamtestuser&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20171003T010726Z&X-Amz-SignedHeaders=host&X-Amz-Expires=899&X-Amz-Credential=AKIAPFXHGVDI5RNFO4AQ%2F20171003%2Fcn-north-1%2Frds-db%2Faws4_request&X-Amz-Signature=f9f45ef96c1f770cdad11a53e33ffa4c3730bc03fdee820cfdf1322eed15483b
* @return
*/
private static String generateAuthToken() {
BasicAWSCredentials awsCredentials = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
RdsIamAuthTokenGenerator generator = RdsIamAuthTokenGenerator.builder()
.credentials(new AWSStaticCredentialsProvider(awsCredentials)).region(REGION_NAME).build();
return generator.getAuthToken(GetIamAuthTokenRequest.builder()
.hostname(RDS_INSTANCE_HOSTNAME).port(RDS_INSTANCE_PORT).userName(DB_USER).build());
}
/**
* This method sets the SSL properties which specify the key store file, its type and password:
* @throws Exception
*/
private static void setSslProperties() throws Exception {
System.setProperty("javax.net.ssl.trustStore", createKeyStoreFile());
System.setProperty("javax.net.ssl.trustStoreType", KEY_STORE_TYPE);
System.setProperty("javax.net.ssl.trustStorePassword", DEFAULT_KEY_STORE_PASSWORD);
}
/**
* This method returns the path of the Key Store File needed for the SSL verification during the IAM Database Authentication to
* the db instance.
* @return
* @throws Exception
*/
private static String createKeyStoreFile() throws Exception {
return createKeyStoreFile(createCertificate()).getPath();
}
/**
* This method generates the SSL certificate
* @return
* @throws Exception
*/
private static X509Certificate createCertificate() throws Exception {
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
URL url = new File(SSL_CERTIFICATE).toURI().toURL();
if (url == null) {
throw new Exception();
}
try (InputStream certInputStream = url.openStream()) {
return (X509Certificate) certFactory.generateCertificate(certInputStream);
}
}
/**
* This method creates the Key Store File
* @param rootX509Certificate - the SSL certificate to be stored in the KeyStore
* @return
* @throws Exception
*/
private static File createKeyStoreFile(X509Certificate rootX509Certificate) throws Exception {
File keyStoreFile = File.createTempFile(KEY_STORE_FILE_PREFIX, KEY_STORE_FILE_SUFFIX);
try (FileOutputStream fos = new FileOutputStream(keyStoreFile.getPath())) {
KeyStore ks = KeyStore.getInstance(KEY_STORE_TYPE, KEY_STORE_PROVIDER);
ks.load(null);
ks.setCertificateEntry("rootCaCertificate", rootX509Certificate);
ks.store(fos, DEFAULT_KEY_STORE_PASSWORD.toCharArray());
}
return keyStoreFile;
}
/**
* This method clears the SSL properties.
* @throws Exception
*/
private static void clearSslProperties() throws Exception {
System.clearProperty("javax.net.ssl.trustStore");
System.clearProperty("javax.net.ssl.trustStoreType");
System.clearProperty("javax.net.ssl.trustStorePassword");
}
}
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Herstellen einer Verbindung zu Ihrem mithilfe der IAM-Authentifizierung und der AWS SDK für Python (Boto3)
Sie können wie im Folgenden beschrieben eine Verbindung zu einer mit Aurora MySQL oder Aurora PostgreSQL DB-Cluster herstellen. AWS SDK für Python (Boto3)
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB--Cluster mithilfe der IAM-Authentifizierung:
+ [Aktivieren und Deaktivieren der IAM-Datenbank-Authentifizierung](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Erstellen und Verwenden einer IAM-Richtlinie für den IAM-Datenbankzugriff](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Erstellen eines Datenbankkontos mithilfe der IAM-Authentifizierung](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Stellen Sie außerdem sicher, dass die importierten Bibliotheken im Beispielcode auf Ihrem System vorhanden sind.
**Beispiele**
Die Codebeispiele verwenden Profile für freigegebene Anmeldeinformationen. [Informationen zur Angabe von Anmeldeinformationen finden Sie in der Dokumentation unter Anmeldeinformationen.](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) AWS SDK für Python (Boto3)
In den folgenden Beispielcodes wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einem DB-Cluster verwenden.
Um dieses Codebeispiel auszuführen, benötigen Sie den [AWS SDK für Python (Boto3)](https://aws.amazon.com/sdk-for-python/), auf der AWS Site zu finden.
Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `ENDPOINT` – Der Endpunkt des DB--Clusters, auf den Sie zugreifen möchten.
+ `PORT` – Die Nummer des Ports, der für die Verbindung mit dem DB--Cluster verwendet wird.
+ `USER` – Das Datenbankkonto, auf das Sie zugreifen möchten.
+ `REGION`— Die AWS Region, in der der ausgeführt wird
+ `DBNAME` – Die Datenbank, auf die Sie zugreifen möchten.
+ `SSLCERTIFICATE` – Der vollständige Pfad zum SSL-Zertifikat für Amazon Aurora
Geben Sie für `ssl_ca` ein SSL-Zertifikat an. Zum Download eines SSL-Zertifikats siehe [Wird verwendet SSL/TLS , um eine Verbindung zu einer zu verschlüsseln](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Cluster-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
Dieser Code stellt eine Verbindung mit einem Aurora MySQL DB-Cluster her.
Bevor Sie diesen Code ausführen, installieren Sie den PyMy SQL-Treiber, indem Sie den Anweisungen im [Python-Paketindex](https://pypi.org/project/PyMySQL/) folgen.
```
import pymysql
import sys
import boto3
import os
ENDPOINT="mysqlcluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
PORT="3306"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
os.environ['LIBMYSQL_ENABLE_CLEARTEXT_PLUGIN'] = '1'
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='default')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = pymysql.connect(auth_plugin_map={'mysql_clear_password':None},host=ENDPOINT, user=USER, password=token, port=PORT, database=DBNAME, ssl_ca='SSLCERTIFICATE', ssl_verify_identity=True, ssl_verify_cert=True)
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Dieser Code stellt eine Verbindung mit einem Aurora PostgreSQL DB-Cluster her.
Bevor Sie diesen Code ausführen, installieren Sie `psycopg2`, indem Sie die Anweisungen in der [Psycopg-Dokumentation](https://pypi.org/project/psycopg2/) befolgen.
```
import psycopg2
import sys
import boto3
import os
ENDPOINT="postgresmycluster.cluster-123456789012.us-east-1.rds.amazonaws.com"
PORT="5432"
USER="jane_doe"
REGION="us-east-1"
DBNAME="mydb"
#gets the credentials from .aws/credentials
session = boto3.Session(profile_name='RDSCreds')
client = session.client('rds')
token = client.generate_db_auth_token(DBHostname=ENDPOINT, Port=PORT, DBUsername=USER, Region=REGION)
try:
conn = psycopg2.connect(host=ENDPOINT, port=PORT, database=DBNAME, user=USER, password=token, sslrootcert="SSLCERTIFICATE")
cur = conn.cursor()
cur.execute("""SELECT now()""")
query_results = cur.fetchall()
print(query_results)
except Exception as e:
print("Database connection failed due to {}".format(e))
```
Informationen dazu, wie Sie über einen Proxy eine Verbindung mit einem DB-Cluster herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Problembehebung bei der IAM-DB-Authentifizierung
Im Folgenden finden Sie Tipps zur Problembehebung für einige häufige IAM-DB-Authentifizierungsprobleme und Informationen zu CloudWatch-Protokollen und Metriken für die IAM-DB-Authentifizierung.
## Exportieren von Fehlerprotokolle zur IAM-DB-Authentifizierung in CloudWatch Logs
Fehlerprotokolle zur IAM-DB-Authentifizierung werden auf dem Datenbank-Host gespeichert und Sie können diese Protokolle in Ihr CloudWatch-Logs-Konto exportieren. Verwenden Sie die Protokolle und Problembehebungsmethoden auf dieser Seite, um Probleme mit der IAM-DB-Authentifizierung zu beheben.
Sie können Protokollexporte nach CloudWatch Logs über die Konsole, die AWS CLI und die RDS-API aktivieren. Anleitungen zur Konsole finden Sie unter [Veröffentlichen von Datenbankprotokollen in Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md).
Verwenden Sie den folgenden Befehl, um Ihre IAM-DB-Authentifizierungsfehlerprotokolle nach CloudWatch Logs zu exportieren, wenn Sie einen DB-Cluster über die AWS CLI erstellen:
```
aws rds create-db-cluster --db-cluster-identifier mydbinstance \
--region us-east-1 \
--engine postgres \
--engine-version 16 \
--master-username master \
--master-user-password password \
--publicly-accessible \
--enable-iam-database-authentication \
--enable-cloudwatch-logs-exports=iam-db-auth-error
```
Verwenden Sie den folgenden Befehl, um Ihre IAM-DB-Authentifizierungsfehlerprotokolle nach CloudWatch Logs zu exportieren, wenn Sie einen DB-Cluster über die AWS CLI ändern:
```
aws rds modify-db-cluster --db-cluster-identifier mydbcluster \
--region us-east-1 \
--cloudwatch-logs-export-configuration '{"EnableLogTypes":["iam-db-auth-error"]}'
```
Um zu bestätigen, ob Ihr DB-Cluster IAM-DB-Authentifizierungsprotokolle nach CloudWatch Logs exportiert, überprüfen Sie, ob der Parameter `EnabledCloudwatchLogsExports` in der Ausgabe für den Befehl `describe-db-instances` auf `iam-db-auth-error` festgelegt ist.
```
aws rds describe-db-cluster --region us-east-1 --db-cluster-identifier mydbcluster
...
"EnabledCloudwatchLogsExports": [
"iam-db-auth-error"
],
...
```
## CloudWatch-Metriken zur IAM-DB-Authentifizierung
Amazon Aurora liefert nahezu in Echtzeit Metriken zur IAM-DB-Authentifizierung für Ihr Amazon-CloudWatch-Konto. Die folgende Tabelle listet die IAM-DB-Authentifizierungsmetriken auf, die in CloudWatch verfügbar sind:
| Metrik | Beschreibung |
| --- | --- |
| `IamDbAuthConnectionRequests` | Gesamtzahl der Verbindungsanfragen, die mit der IAM-DB-Authentifizierung gestellt wurden |
| `IamDbAuthConnectionSuccess` | Gesamtzahl der erfolgreichen IAM-DB-Authentifizierungsanfragen |
| `IamDbAuthConnectionFailure` | Gesamtzahl der fehlgeschlagenen IAM-DB-Authentifizierungsanfragen |
| `IamDbAuthConnectionFailureInvalidToken` | Gesamtzahl der aufgrund ungültiger Token fehlgeschlagenen IAM-DB-Authentifizierungsanfragen |
| `IamDbAuthConnectionFailureInsufficientPermissions` | Gesamtzahl der aufgrund falscher Richtlinien oder Berechtigungen fehlgeschlagenen IAM-DB-Authentifizierungsanfragen |
| `IamDbAuthConnectionFailureThrottling` | Gesamtzahl der aufgrund der Drosselung der IAM-DB-Authentifizierung fehlgeschlagenen IAM-DB-Authentifizierungsanfragen |
| `IamDbAuthConnectionFailureServerError` | Gesamtzahl der aufgrund interner Serverfehler im IAM-DB-Authentifizierungsfeature fehlgeschlagenen IAM-DB-Authentifizierungsanfragen |
## Häufige Probleme und Lösungen
Bei der Verwendung der IAM-DB-Authentifizierung können die folgenden Probleme auftreten. Verwenden Sie die Schritte zur Problembehebung in der Tabelle, um die Probleme zu lösen:
| Fehler | Metrik(en) | Ursache | Lösung |
| --- | --- | --- | --- |
| `[ERROR] Failed to authenticate the connection request for user db_user because the provided token is malformed or otherwise invalid. (Status Code: 400, Error Code: InvalidToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Das IAM-DB-Authentifizierungs-Token in der Verbindungsanfrage ist entweder kein gültiges SigV4A-Token oder es ist nicht richtig formatiert. | Überprüfen Sie Ihre Strategie zur Token-Generierung in Ihrer Anwendung. In einigen Fällen müssen Sie sicherstellen, dass Sie das Token mit einer gültigen Formatierung übergeben. Wenn Sie das Token kürzen (oder eine falsche Zeichenkettenformatierung verwendet wurde), wird das Token ungültig. |
| `[ERROR] Failed to authenticate the connection request for user db_user because the token age is longer than 15 minutes. (Status Code: 400, Error Code:ExpiredToken)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInvalidToken` | Das IAM-DB-Authentifizierungs-Token ist abgelaufen. Tokens sind nur 15 Minuten lang gültig. | Überprüfen Sie Ihre Token-Zwischenspeicherung und/oder Token-Wiederverwendungslogik in Ihrer Anwendung. Sie sollten Tokens, die älter als 15 Minuten sind, nicht wiederverwenden. |
| `[ERROR] Failed to authorize the connection request for user db_user because the IAM policy assumed by the caller 'arn:aws:sts::123456789012:assumed-role/ / ' is not authorized to perform `rds-db:connect` on the DB instance. (Status Code: 403, Error Code:NotAuthorized)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureInsufficientPermissions` | Dies kann folgende Ursachen haben: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/AuroraUserGuide/UsingWithRDS.IAMDBAuth.Troubleshooting.html) | Stellen Sie sicher, dass Sie die IAM-Rolle und/oder -Richtlinie in Ihrer Anwendung übernehmen. Stellen Sie sicher, dass Sie für die Generierung des Tokens dieselbe Richtlinie verwenden wie für die Verbindung mit der DB. |
| `[ERROR] Failed to authorize the connection request for user db_user due to IAM DB authentication throttling. (Status Code: 429, Error Code: ThrottlingException)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Sie stellen in kurzer Zeit zu viele Verbindungsanforderungen an Ihre DB. Das Limit für die Drosselung der IAM-DB-Authentifizierung liegt bei 200 Verbindungen pro Sekunde. | Reduzieren Sie die Geschwindigkeit, mit der neue Verbindungen hergestellt werden, mit der IAM-Authentifizierung. Erwägen Sie die Implementierung von Verbindungspooling mithilfe von RDS-Proxy, um vorhandene Verbindungen in Ihrer Anwendung wiederzuverwenden. |
| `[ERROR] Failed to authorize the connection request for user db_user due to an internal IAM DB authentication error. (Status Code: 500, Error Code: InternalError)` | `IamDbAuthConnectionFailure` `IamDbAuthConnectionFailureThrottling` | Bei der Autorisierung der DB-Verbindung mit der IAM-DB-Authentifizierung ist ein interner Fehler aufgetreten. | Wenden Sie sich an https://aws.amazon.com/premiumsupport/, um das Problem zu untersuchen. |