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.
# Herstellen einer Verbindung zu Ihrem DB-Instance- mithilfe der IAM-Authentifizierung
Bei einer IAM-Datenbankauthentifizierung verwenden Sie ein Authentifizierungstoken, wenn Sie sich mit Ihrer DB-Instance 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 RDS 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 einer Amazon RDS-DB-Instance 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-Instance- 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 Ihrer DB-Instance 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 Ihrer DB-Instance 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 der DB-Instance überwachen und die Instance-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 im Treiber der entsprechenden Sprache für Ihre DB-Instance von [RDS für MariaDB](MariaDB.Connecting.Drivers.md#MariaDB.Connecting.JDBCDriver), [RDS für MySQL](MySQL.Connecting.Drivers.md#MySQL.Connecting.JDBCDriver) oder [RDS für PostgreSQL](PostgreSQL.Connecting.JDBCDriver.md).
**Anmerkung**
Die einzigen Features, die für RDS für MariaDB unterstützt werden, sind Authentifizierung mit AWS Secrets Manager, AWS Identity and Access Management (IAM) und Federated Identity.
# 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 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-Instance- 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-Instance-](#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-Instance-, auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- 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 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-Instance-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
## Herstellen der Verbindung zu einem DB-Instance-
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-Instance-, auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- verwendet wird.
+ `--ssl-ca` – Die SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält
Weitere Informationen zur SSL/TLS Unterstützung von MariaDB finden Sie unter. [SSL/TLS-Unterstützung für MariaDB-DB-Instances in Amazon RDS](MariaDB.Concepts.SSLSupport.md)
Weitere Hinweise zur SSL/TLS Unterstützung von MySQL finden Sie unter[SSL/TLS-Unterstützung für MySQL-DB-Instances in Amazon RDS](MySQL.Concepts.SSLSupport.md).
Zum Download eines SSL-Zertifikats siehe [](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="mysqldb.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 einer DB-Instance 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 einer Amazon-RDS-for-PostgreSQL-DB-Instance einem 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-Instance- 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 Amazon RDS-PostgreSQL-Instance und](#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="rdspostgres.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-Instance-, auf den Sie zugreifen möchten.
+ `--port` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- 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.
```
rdspostgres.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-Instance-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
## Verbinden mit einem Amazon RDS-PostgreSQL-Instance und
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-Instance-, auf den Sie zugreifen möchten.
+ `port` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- verwendet wird.
+ `sslmode` – Der zu verwendende SSL-Modus.
Wenn Sie `sslmode=verify-full` verwenden, prüft die SSL-Verbindung den Endpunkt der DB-Instance gegen den Endpunkt des SSL-Zertifikats.
+ `sslrootcert` – Die SSL-Zertifikatsdatei, die den öffentlichen Schlüssel enthält
Weitere Informationen finden Sie unter [Verwenden von SSL mit einer PostgreSQL-DB-Instance](PostgreSQL.Concepts.General.SSL.md).
Zum Download eines SSL-Zertifikats siehe [](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-Instance-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="rdspostgres.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 einer DB-Instance 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 RDS for MariaDB-, MySQL- oder PostgreSQL-DB-Instance mit herstellen. AWS SDK für .NET
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB-Instance- 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 einer DB-Instance 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 einer MariaDB- oder MySQL-DB-Instance her. Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `server` – Der Endpunkt des DB-Instance-, 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-Instance- verwendet wird.
+ `SslMode` – Der zu verwendende SSL-Modus.
Wenn Sie `SslMode=Required` verwenden, prüft die SSL-Verbindung den Endpunkt der DB-Instance gegen den Endpunkt des SSL-Zertifikats.
+ `SslCa` – Der vollständige Pfad zum SSL-Zertifikat für Amazon RDS
Informationen zum Download eines Zertifikats finden Sie unter [](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Instance-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, "mysqldb.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=mysqldb.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 zu einer PostgreSQL-DB-Instance her.
Ändern Sie die Werte der folgenden Parameter nach Bedarf.
+ `Server` – Der Endpunkt des DB-Instance-, 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-Instance- verwendet wird.
+ `SSL Mode` – Der zu verwendende SSL-Modus.
Wenn Sie `SSL Mode=Required` verwenden, prüft die SSL-Verbindung den Endpunkt der DB-Instance gegen den Endpunkt des SSL-Zertifikats.
+ `Root Certificate` – Der vollständige Pfad zum SSL-Zertifikat für Amazon RDS
Informationen zum Download eines Zertifikats finden Sie unter [](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Instance-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("postgresmydb.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=postgresmydb.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 einer DB-Instance 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 RDS for MariaDB-, MySQL- oder PostgreSQL-DB-Instance mit herstellen. AWS SDK für Go
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB-Instance- 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-Instance-, auf den Sie zugreifen möchten.
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Instance-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
+ `dbPort` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- 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 einer DB-Instance verwenden.
Dieser Code stellt eine Verbindung mit einer MariaDB- oder MySQL-DB-Instance 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 = "mysqldb.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 zu einer PostgreSQL-DB-Instance 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 = "postgresmydb.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 einer DB-Instance 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 einer DB-Instance verwenden.
Dieser Code stellt eine Verbindung mit einer MariaDB- oder MySQL-DB-Instance 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 := "mysqldb.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 zu einer PostgreSQL-DB-Instance 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 := "postgresmydb.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 einer DB-Instance 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 RDS for MariaDB-, MySQL- oder PostgreSQL-DB-Instance mit herstellen. AWS SDK für Java
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB-Instance- 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-Instance-](#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-Instance-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-Instance-
Im folgenden Codebeispiel wird gezeigt, wie Sie ein Authentifizierungstoken erzeugen und anschließend zum Verbinden mit einer Instance für die Ausführung mit MariaDB oder 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 RDS , das für eine AWS Region spezifisch ist. (Weitere Informationen finden Sie unter [](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-Instance-, auf den Sie zugreifen möchten.
+ `RDS_INSTANCE_PORT` – Die Nummer des Ports, der für die Verbindung zur PostgreSQL-DB-Instance 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 RDS , das für eine AWS Region spezifisch ist.
Informationen zum Herunterladen eines Zertifikats für Ihre AWS -Region finden Sie unter [](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 einer DB-Instance 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 RDS for MariaDB-, MySQL- oder PostgreSQL-DB-Instance mit herstellen. AWS SDK für Python (Boto3)
**Voraussetzungen**
Die folgenden Voraussetzungen gelten für die Verbindung mit Ihrem DB-Instance- 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 einer DB-Instance 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-Instance-, auf den Sie zugreifen möchten.
+ `PORT` – Die Nummer des Ports, der für die Verbindung mit dem DB-Instance- 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 RDS
Geben Sie für `ssl_ca` ein SSL-Zertifikat an. Zum Download eines SSL-Zertifikats siehe [](UsingWithRDS.SSL.md).
**Anmerkung**
Sie können keinen benutzerdefinierten Route-53-DNS-Datensatz anstelle des DB-Instance-Endpunkts verwenden, um das Authentifizierungstoken zu generieren.
Dieser Code stellt eine Verbindung mit einer MariaDB- oder MySQL-DB-Instance 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="mysqldb.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 zu einer PostgreSQL-DB-Instance 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="postgresmydb.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 einer DB-Instance herstellen, finden Sie unter [Mithilfe der IAM-Authentifizierung eine Verbindung zu einer Datenbank herstellen](rds-proxy-connecting.md#rds-proxy-connecting-iam).