# Conexión a al clúster de bases de datos con la autenticación de IAM
Con la autenticación de bases de datos de IAM, puede usar un token de autenticación al conectarse a su clúster de bases de datos. Un *token de autenticación* es una cadena de caracteres que usa en lugar de una contraseña. Después de generar un token de autenticación, será válido durante 15 minutos antes de caducar. Si intenta conectarse mediante un token caducado, la solicitud de conexión se deniega.
Todos los tokens de autenticación deben ir acompañados de una firma válida, mediante AWS Signature versión 4. (Para obtener más información, consulte [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en la* Referencia general de AWS.*). AWS CLI y un SDK de AWS, como AWS SDK para Java o AWS SDK para Python (Boto3), pueden firmar automáticamente cada token que cree.
Puede utilizar un token de autenticación cuando se conecte a Amazon Aurora desde otro servicio de AWS, como AWS Lambda. Al utilizar un token, puede evitar introducir una contraseña en el código. De forma opcional, puede usar un SDK de AWS para crear y firmar mediante programación un token de autenticación.
Una vez que tenga un token de autenticación de IAM firmado, podrá conectarse a un clúster de bases de datos de Aurora. A continuación, puede aprender cómo hacer esto mediante una herramienta de línea de comandos o un SDK de AWS, como AWS SDK para Java o AWS SDK para Python (Boto3).
Para obtener más información, consulte las siguientes entradas del blog:
+ [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/)
+ [Using IAM authentication to connect with pgAdmin Amazon Aurora PostgreSQL or Amazon RDS para PostgreSQL (Usar la autenticación de IAM para conectar pgAdmin con Amazon Aurora PostgreSQL o Amazon RDS para PostgreSQL)](https://aws.amazon.com/blogs/database/using-iam-authentication-to-connect-with-pgadmin-amazon-aurora-postgresql-or-amazon-rds-for-postgresql/)
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Topics**
+ [Conexión a su clúster de de base de datos mediante la autenticación IAM con los controladores de AWS](IAMDBAuth.Connecting.Drivers.md)
+ [Conexión a su clúster de bases de datos con autenticación de IAM desde la línea de comandos: AWS CLI y cliente de MySQL](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.md)
+ [Conexión a su clúster de bases de datos desde la línea de comandos: AWS CLI y psql Client](UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.PostgreSQL.md)
+ [Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para .NET](UsingWithRDS.IAMDBAuth.Connecting.NET.md)
+ [Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Go](UsingWithRDS.IAMDBAuth.Connecting.Go.md)
+ [Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Java](UsingWithRDS.IAMDBAuth.Connecting.Java.md)
+ [Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Python (Boto3)](UsingWithRDS.IAMDBAuth.Connecting.Python.md)
# Conexión a su clúster de de base de datos mediante la autenticación IAM con los controladores de AWS
El conjunto de controladores de AWS se ha diseñado para permitir tiempos de transición y conmutación por error más rápidos y autenticarse con AWS Secrets Manager, AWS Identity and Access Management (IAM) e identidad federada. Los controladores de AWS se basan en la supervisión del estado del clúster de base de datos y en el conocimiento de la topología del clúster para determinar quién es el nuevo escritor. Este enfoque reduce los tiempos de transición y conmutación por error a segundos de un solo dígito, en comparación con las decenas de segundos de los controladores de código abierto.
Para obtener más información sobre los controladores de AWS, consulte el controlador de idioma correspondiente a su clúster de base de datos de [Aurora MySQL](Aurora.Connecting.md#Aurora.Connecting.JDBCDriverMySQL) o [Aurora PostgreSQL](Aurora.Connecting.md#Aurora.Connecting.AuroraPostgreSQL.Utilities).
# Conexión a su clúster de bases de datos con autenticación de IAM desde la línea de comandos: AWS CLI y cliente de MySQL
Puede conectarse desde la línea de comando a un clúster de bases de datos de Auroracon AWS CLI y la herramienta de línea de comandos de `mysql` como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obtener información sobre cómo conectarse a la base de datos mediante SQL Workbench/J con la autenticación IAM, consulte la publicación de blog [Use IAM authentication to connect with SQL Workbench/J to Aurora MySQL or Amazon RDS for MySQL](https://aws.amazon.com/blogs/database/use-iam-authentication-to-connect-with-sql-workbenchj-to-amazon-aurora-mysql-or-amazon-rds-for-mysql/).
**Topics**
+ [Generación de un token de autenticación de IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken)
+ [Conexión a su clúster de bases de datos](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect)
## Generación de un token de autenticación de IAM
En el siguiente ejemplo se muestra cómo obtener un token de autenticación firmado mediante la 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
```
En el ejemplo, los parámetros son los siguientes:
+ `--hostname`: el nombre de host del clúster de bases de datos a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `--region`: la región de AWS en la que se ejecuta el clúster de bases de datos
+ `--username`: la cuenta de base de datos a la que desea acceder.
Los primeros caracteres del token tienen un aspecto similar al siguiente.
```
rdsmysql.123456789012.us-west-2.rds.amazonaws.com:3306/?Action=connect&DBUser=jane_doe&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Expires=900...
```
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
## Conexión a su clúster de bases de datos
El formato general para conectarse se muestra a continuación.
```
mysql --host=hostName --port=portNumber --ssl-ca=full_path_to_ssl_certificate --enable-cleartext-plugin --user=userName --password=authToken
```
Los parámetros son los siguientes:
+ `--host`: el nombre de host del clúster de bases de datos a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `--ssl-ca`: la ruta completa al archivo de certificado SSL que contiene la clave pública
Para obtener más información, consulte [Conexiones TLS a clústeres de base de datos de Aurora MySQL](AuroraMySQL.Security.md#AuroraMySQL.Security.SSL).
Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).
+ `--enable-cleartext-plugin`: un valor que especifica que `AWSAuthenticationPlugin` debe usarse para esta conexión.
Si está utilizando un cliente MariaDB, la opción `--enable-cleartext-plugin` no es necesaria.
+ `--user`: la cuenta de base de datos a la que desea acceder.
+ `--password`: un token de autenticación de IAM firmado.
El token de autenticación consta de varios cientos de caracteres. Puede ser difícil de tratar en la línea de comando. Una forma de solucionar esto es guardar el token en una variable de entorno y, a continuación, usar esa variable al conectarse. En el siguiente ejemplo se muestra una forma de realizar esta alternativa. En el ejemplo, */sample\$1dir/* es la ruta completa al archivo de certificado SSL que contiene la clave pública.
```
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
```
Al conectarse mediante `AWSAuthenticationPlugin`, la conexión está protegida mediante SSL. Para verificar esto, escriba lo siguiente en el símbolo del sistema `mysql>`.
```
show status like 'Ssl%';
```
En las siguientes líneas de la salida aparecen más detalles.
```
+---------------+-------------+
| Variable_name | Value |
+---------------+-------------+
| ... | ...
| Ssl_cipher | AES256-SHA |
| ... | ...
| Ssl_version | TLSv1.1 |
| ... | ...
+-----------------------------+
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión a su clúster de bases de datos desde la línea de comandos: AWS CLI y psql Client
Puede conectarse desde la línea de comando a un clúster de bases de datos de Aurora PostgreSQL con AWS CLI y la herramienta de línea de comandos psql como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**nota**
Para obtener información acerca de cómo conectarse a la base de datos mediante pgAdmin con la autenticación IAM, consulte la entrada de blog [Use IAM authentication to connect with pgAdmin to Amazon Aurora PostgreSQL or Amazon RDS for PostgreSQL (Usar la autenticación de IAM para conectarse con pgAdmin a Amazon Aurora PostgreSQL o 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**
+ [Generación de un token de autenticación de IAM](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.AuthToken.PostgreSQL)
+ [Conexión a un clúster de Aurora PostgreSQL](#UsingWithRDS.IAMDBAuth.Connecting.AWSCLI.Connect.PostgreSQL)
## Generación de un token de autenticación de IAM
El token de autenticación consta de varios cientos de caracteres por que puede ser difícil de tratar en la línea de comando. Una forma de solucionar esto es guardar el token en una variable de entorno y, a continuación, usar esa variable al conectarse. En el siguiente ejemplo se muestra cómo usar la AWS CLI para obtener un token de autenticación firmado mediante el comando `generate-db-auth-token` y almacenarlo en una variable de entorno `PGPASSWORD`.
```
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 )"
```
En el ejemplo, los parámetros para el comando `generate-db-auth-token` son los siguientes:
+ `--hostname`: el nombre de host del clúster (punto de enlace del clúster) de base de datos a los que desea obtener acceso.
+ `--port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `--region`: la región de AWS en la que se ejecuta el clúster de bases de datos
+ `--username`: la cuenta de base de datos a la que desea acceder.
Los primeros caracteres del token generado tienen un aspecto similar al siguiente.
```
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...
```
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
## Conexión a un clúster de Aurora PostgreSQL
El formato general para usar psql para conectarse se muestra a continuación.
```
psql "host=hostName port=portNumber sslmode=verify-full sslrootcert=full_path_to_ssl_certificate dbname=DBName user=userName password=authToken"
```
Los parámetros son los siguientes:
+ `host`: el nombre de host del clúster (punto de enlace del clúster) de base de datos a los que desea obtener acceso.
+ `port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `sslmode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `sslmode=verify-full`, la conexión SSL verifica el punto de conexión del clúster de bases de datos con respecto al punto de enlace del certificado SSL.
+ `sslrootcert`: la ruta completa al archivo de certificado SSL que contiene la clave pública
Para obtener más información, consulte [Protección de los datos de Aurora PostgreSQL con SSL/TLS](AuroraPostgreSQL.Security.md#AuroraPostgreSQL.Security.SSL).
Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).
+ `dbname`: la base de datos a la que desea obtener acceso.
+ `user`: la cuenta de base de datos a la que desea acceder.
+ `password`: un token de autenticación de IAM firmado.
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
El siguiente ejemplo muestra el uso de psql para conectarse. En el ejemplo, psql utiliza la variable de entorno `RDSHOST` para el host y la variable de entorno `PGPASSWORD` para el token generado. Además, */sample\$1dir/* es la ruta completa al archivo de certificado SSL que contiene la clave pública.
```
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"
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para .NET
Puede conectarse a un clúster de bases de datos de Aurora MySQL o Aurora PostgreSQL con el AWS SDK para .NET como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Ejemplos**
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a un clúster de bases de datos.
Para ejecutar este ejemplo de código, necesita [AWS SDK para .NET](https://aws.amazon.com/sdk-for-net/), que se encuentra en el sitio de AWS. Los paquetes `AWSSDK.CORE` y `AWSSDK.RDS` son necesarios. Para conectarse a un clúster de base de datos, use el conector de base de datos .NET para el motor de base de datos, como MySqlConnector para MariaDB o MySQL, o Npgsql para PostgreSQL.
Este código se conecta a un clúster de bases de datos de Aurora MySQL. Modifique los valores de las siguientes variables según sea necesario:
+ `server`: el punto de enlace del clúster de bases de datos que desea acceder
+ `user`: la cuenta de base de datos a la que desea acceder.
+ `database`: la base de datos a la que desea obtener acceso.
+ `port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `SslMode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `SslMode=Required`, la conexión SSL verifica el punto de conexión del clúster de bases de datos con respecto al punto de enlace del certificado SSL.
+ `SslCa`: la ruta completa al certificado SSL de Amazon Aurora
Para descargar un certificado, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
```
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();
}
}
}
```
Este código se conecta a un clúster de bases de datos de Aurora PostgreSQL.
Modifique los valores de las siguientes variables según sea necesario:
+ `Server`: el punto de enlace del clúster de bases de datos que desea acceder
+ `User ID`: la cuenta de base de datos a la que desea acceder.
+ `Database`: la base de datos a la que desea obtener acceso.
+ `Port`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `SSL Mode`: el modo de SSL que se debe utilizar.
Cuando se utiliza `SSL Mode=Required`, la conexión SSL verifica el punto de conexión del clúster de bases de datos con respecto al punto de enlace del certificado SSL.
+ `Root Certificate`: la ruta completa al certificado SSL de Amazon Aurora
Para descargar un certificado, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
```
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();
}
}
}
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Go
Puede conectarse a un clúster de bases de datos de Aurora MySQL o Aurora PostgreSQL con el AWS SDK para Go como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
**Ejemplos**
Para ejecutar estos ejemplos de código, necesita [AWS SDK para Go](https://aws.amazon.com/sdk-for-go/), que se encuentra en el sitio de AWS.
Modifique los valores de las siguientes variables según sea necesario:
+ `dbName`: la base de datos a la que desea obtener acceso.
+ `dbUser`: la cuenta de base de datos a la que desea acceder.
+ `dbHost`: el punto de enlace del clúster de bases de datos que desea acceder
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
+ `dbPort`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `region`: la región de AWS en la que se ejecuta el clúster de bases de datos
Además, debe asegurarse de que las bibliotecas importadas en el código de muestra existen en el sistema.
**importante**
En los ejemplos de esta sección se utiliza el código siguiente para proporcionar credenciales que tienen acceso a una base de datos desde un entorno local:
`creds := credentials.NewEnvCredentials()`
Si accede a una base de datos desde un servicio de AWS, como Amazon EC2 o Amazon ECS, puede reemplazar el código por el siguiente código:
`sess := session.Must(session.NewSession())`
`creds := sess.Config.Credentials`
Si realiza este cambio, asegúrese de agregar la siguiente importación:
`"github.com/aws/aws-sdk-go/aws/session"`
**Topics**
+ [Conexión mediante la autenticación de IAM y el V2 AWS SDK para Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV2)
+ [Conexión mediante la autenticación de IAM y el V1 AWS SDK para Go](#UsingWithRDS.IAMDBAuth.Connecting.GoV1)
## Conexión mediante la autenticación de IAM y el V2 AWS SDK para Go
Se puede conectar a un de instancia de base de datos mediante la autenticación de IAM y el V2AWS SDK para Go.
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a un clúster de bases de datos.
Este código se conecta a un clúster de bases de datos de Aurora MySQL.
```
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)
}
}
```
Este código se conecta a un clúster de bases de datos de Aurora PostgreSQL.
```
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)
}
}
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
## Conexión mediante la autenticación de IAM y el V1 AWS SDK para Go
Conexión a un clúster de bases de datos mediante la autenticación de IAM y el V1 AWS SDK para Go
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a un clúster de bases de datos.
Este código se conecta a un clúster de bases de datos de Aurora MySQL.
```
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)
}
}
```
Este código se conecta a un clúster de bases de datos de Aurora PostgreSQL.
```
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)
}
}
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Java
Puede conectarse a un clúster de bases de datos de Aurora MySQL o Aurora PostgreSQL con el AWS SDK para Java como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
+ [Configurar el SDK de AWS para Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html)
Para ver ejemplos de cómo usar el SDK para Java 2.x, consulte [Ejemplos de Amazon RDS que utilizan SDK para Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/java_rds_code_examples.html). También puede utilizar el contenedor JDBC avanzado de AWS; consulte la [documentación del contenedor JDBC avanzado de AWS](https://github.com/aws/aws-advanced-jdbc-wrapper/blob/main/docs/Documentation.md).
**Topics**
+ [Generación de un token de autenticación de IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken)
+ [Creación manual de un token de autenticación de IAM](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken2)
+ [Conexión a su clúster de bases de datos](#UsingWithRDS.IAMDBAuth.Connecting.Java.AuthToken.Connect)
## Generación de un token de autenticación de IAM
Si escribe programas mediante AWS SDK para Java, puede obtener un token de autenticación firmado mediante la clase `RdsIamAuthTokenGenerator`. El uso de esta clase requiere que proporcione las credenciales de AWS. Para hacer esto, puede crear una instancia de la clase `DefaultAWSCredentialsProviderChain`. `DefaultAWSCredentialsProviderChain` usa la primera clave de acceso y clave secreta de AWS que encuentra en la [cadena predeterminada de proveedores de credenciales](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default). A fin de obtener más información acerca de las claves de acceso de AWS, consulte [Administración de claves de acceso para usuarios](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
Tras crear una instancia de `RdsIamAuthTokenGenerator`, puede llamar al método `getAuthToken` para obtener un token firmado. Proporcione la región de AWS el nombre de host, el número de puerto y el nombre de usuario. En el siguiente ejemplo de código se ilustra cómo hacerlo.
```
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;
}
}
```
## Creación manual de un token de autenticación de IAM
En Java, la forma más sencilla de generar un token de autenticación es usar `RdsIamAuthTokenGenerator`. Esta clase crea automáticamente un token de autenticación y, a continuación, lo firma mediante AWS Signature versión 4. Para obtener más información, consulte [Proceso de firma Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) en la *Referencia general de AWS*.
Sin embargo, también puede crear y firmar un token de autenticación manualmente, como se muestra en el siguiente ejemplo de código.
```
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);
}
}
}
```
## Conexión a su clúster de bases de datos
El siguiente ejemplo de código, muestra cómo generar un token de autenticación y, a continuación, usarlo para conectarse a un clúster que ejecuta Aurora MySQL.
Para ejecutar este ejemplo de código, necesita [AWS SDK para Java](https://aws.amazon.com/sdk-for-java/), que se encuentra en el sitio de AWS. Además, necesitará lo siguiente:
+ MySQL Connector/J. Este ejemplo de código se ha probado con `mysql-connector-java-5.1.33-bin.jar`.
+ Un certificado intermedio para Amazon Aurora que es específico de una región de AWS. (Para obtener más información, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).) En tiempo de ejecución, el cargador de clases busca el certificado en el mismo directorio que este ejemplo de código Java, de modo que el cargador de clases pueda encontrarlo.
+ Modifique los valores de las siguientes variables según sea necesario:
+ `RDS_INSTANCE_HOSTNAME`: el nombre de anfitrión del clúster de bases de datos que desea acceder.
+ `RDS_INSTANCE_PORT`: el número de puerto usado para conectarse al clúster de bases de datos de PostgreSQL.
+ `REGION_NAME`: la región de AWS en la que se ejecuta el clúster de bases de datos.
+ `DB_USER`: la cuenta de base de datos a la que desea acceder.
+ `SSL_CERTIFICATE`: un certificado de SSL para Amazon Aurora que es específico de una región de AWS.
Para descargar un certificado para su región de AWS, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md). Coloque el certificado SSL en el mismo directorio que este archivo de programa Java, de modo que el cargador de clases pueda encontrar el certificado en tiempo de ejecución.
En este ejemplo de código, se obtienen las credenciales de AWS de la [cadena predeterminada de proveedores de credenciales](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/credentials.html#credentials-default).
**nota**
Especifique una contraseña para `DEFAULT_KEY_STORE_PASSWORD` que no sea la que se muestra aquí como práctica recomendada de seguridad.
```
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");
}
}
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).
# Conexión al clúster de base de datos mediante la autenticación de IAM y el AWS SDK para Python (Boto3)
Puede conectarse a un clúster de bases de datos de Aurora MySQL o Aurora PostgreSQL con el AWS SDK para Python (Boto3) como se describe a continuación.
**Requisitos previos**
A continuación, se muestran requisitos previos para conectarse al clúster de de base de datos mediante la autenticación de IAM:
+ [Activación y desactivación de la autenticación de bases de datos de IAM](UsingWithRDS.IAMDBAuth.Enabling.md)
+ [Creación y uso de una política de IAM para el acceso a bases de datos de IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md)
+ [Creación de cuentas de base de datos utilizando autenticación de IAM](UsingWithRDS.IAMDBAuth.DBAccounts.md)
Además, debe asegurarse de que las bibliotecas importadas en el código de muestra existen en el sistema.
**Ejemplos**
Los ejemplos de código utilizan perfiles para credenciales compartidas. Para obtener información acerca de la especificación de credenciales, consulte [Credenciales](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) en la documentación de AWS SDK para Python (Boto3).
En los siguientes ejemplos de código, se muestra cómo se genera un token de autenticación y cómo se utiliza para conectarse a un clúster de bases de datos.
Para ejecutar este ejemplo de código, necesita [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/), que se encuentra en el sitio de AWS.
Modifique los valores de las siguientes variables según sea necesario:
+ `ENDPOINT`: el punto de enlace del clúster de bases de datos que desea acceder
+ `PORT`: el número de puerto que se utiliza para conectarse al clúster de bases de datos.
+ `USER`: la cuenta de base de datos a la que desea acceder.
+ `REGION`: la región de AWS en la que se ejecuta el clúster de bases de datos
+ `DBNAME`: la base de datos a la que desea obtener acceso.
+ `SSLCERTIFICATE`: la ruta completa al certificado SSL de Amazon Aurora
Para `ssl_ca`, especifique un certificado SSL. Para descargar un certificado SSL, consulte [Uso de SSL/TLS para cifrar una conexión a un clúster de base de datos](UsingWithRDS.SSL.md).
**nota**
No puede utilizar un registro DNS personalizado de Route 53 en lugar del punto de conexión del clúster de base de datos para generar el token de autenticación.
Este código se conecta a un clúster de bases de datos de Aurora MySQL.
Antes de ejecutar este código, siga las instrucciones del [índice del paquete de Python](https://pypi.org/project/PyMySQL/) para instalar el controlador PyMySQL.
```
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))
```
Este código se conecta a un clúster de bases de datos de Aurora PostgreSQL.
Antes de ejecutar este código, instale `psycopg2` y siga las instrucciones en [Psycopg documentation](https://pypi.org/project/psycopg2/) (Documentación de Psycopg).
```
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))
```
Si desea conectarse a un clúster de base de datos a través de un proxy, consulte [Conexión a una base de datos mediante autenticación de IAM](rds-proxy-connecting.md#rds-proxy-connecting-iam).