instanceList = response.dbInstances();
for (DBInstance instance : instanceList) {
System.out.println("Instance ARN is: " + instance.dbInstanceArn());
System.out.println("The Engine is " + instance.engine());
System.out.println("Connection endpoint is" + instance.endpoint().address());
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBInstances) dans le manuel de *référence des AWS SDK for Java 2.x API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/rds#code-examples).
```
suspend fun describeInstances() {
RdsClient.fromEnvironment { region = "us-west-2" }.use { rdsClient ->
val response = rdsClient.describeDbInstances(DescribeDbInstancesRequest {})
response.dbInstances?.forEach { instance ->
println("Instance Identifier is ${instance.dbInstanceIdentifier}")
println("The Engine is ${instance.engine}")
println("Connection endpoint is ${instance.endpoint?.address}")
}
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://sdk.amazonaws.com/kotlin/api/latest/index.html) dans le *AWS SDK pour la référence de l'API Kotlin*.
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/rds#code-examples).
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
//Create an RDSClient
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-2'
]);
try {
$result = $rdsClient->describeDBInstances();
foreach ($result['DBInstances'] as $instance) {
print('DB Identifier: ' . $instance['DBInstanceIdentifier']);
print('
Endpoint: ' . $instance['Endpoint']["Address"]
. ':' . $instance['Endpoint']["Port"]);
print('
Current Status: ' . $instance["DBInstanceStatus"]);
print('
');
}
print(" Raw Result ");
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances) dans le manuel de *référence des AWS SDK pour PHP API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_db_instance(self, instance_id):
"""
Gets data about a DB instance.
:param instance_id: The ID of the DB instance to retrieve.
:return: The retrieved DB instance.
"""
try:
response = self.rds_client.describe_db_instances(
DBInstanceIdentifier=instance_id
)
db_inst = response["DBInstances"][0]
except ClientError as err:
if err.response["Error"]["Code"] == "DBInstanceNotFound":
logger.info("Instance %s does not exist.", instance_id)
else:
logger.error(
"Couldn't get DB instance %s. Here's why: %s: %s",
instance_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return db_inst
```
+ Pour plus de détails sur l'API, voir [AWS Describe DBInstances](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBInstances) *in SDK for Python (Boto3) API Reference*.
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples).
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) DB instances.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all DB instances, or nil if error.
def list_instances(rds_resource)
db_instances = []
rds_resource.db_instances.each do |i|
db_instances.append({
"name": i.id,
"status": i.db_instance_status
})
end
db_instances
rescue Aws::Errors::ServiceError => e
puts "Couldn't list instances:\n#{e.message}"
end
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBInstances) dans le manuel de *référence des AWS SDK pour Ruby API*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Wait until the specified database is available to use.
///
/// - Parameter instanceIdentifier: The database instance identifier of the
/// database to wait for.
func waitUntilDBInstanceReady(instanceIdentifier: String) async -> RDSClientTypes.Endpoint? {
do {
putString("Waiting for the database instance to be ready to use. This may take 10 minutes or more...")
while true {
let output = try await rdsClient.describeDBInstances(
input: DescribeDBInstancesInput(
dbInstanceIdentifier: instanceIdentifier
)
)
guard let instanceList = output.dbInstances else {
continue
}
for instance in instanceList {
let status = instance.dbInstanceStatus
guard let status else {
print("\nUnable to determine the status.")
continue
}
if status.contains("available") {
return instance.endpoint
} else {
putString(".")
do {
try await Task.sleep(for: .seconds(15))
} catch {
print("*** Error pausing the task!")
}
}
}
}
} catch {
print("*** Unable to wait until the database is ready: \(error.localizedDescription)")
return nil
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBInstances](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbinstances(input:)) dans le *AWS SDK pour la référence de l'API Swift*.
------
# Utilisation `DescribeDBParameterGroups` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeDBParameterGroups`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](rds_example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples).
```
///
/// Get descriptions of DB parameter groups.
///
/// Optional name of the DB parameter group to describe.
/// The list of DB parameter group descriptions.
public async Task> DescribeDBParameterGroups(string name = null)
{
var response = await _amazonRDS.DescribeDBParameterGroupsAsync(
new DescribeDBParameterGroupsRequest()
{
DBParameterGroupName = name
});
return response.DBParameterGroups;
}
```
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameterGroups) dans le *AWS SDK pour .NET manuel de référence des API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::DescribeDBParameterGroupsRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
Aws::RDS::Model::DescribeDBParameterGroupsOutcome outcome =
client.DescribeDBParameterGroups(request);
if (outcome.IsSuccess()) {
std::cout << "DB parameter group named '" <<
PARAMETER_GROUP_NAME << "' already exists." << std::endl;
dbParameterGroupFamily = outcome.GetResult().GetDBParameterGroups()[0].GetDBParameterGroupFamily();
}
else {
std::cerr << "Error with RDS::DescribeDBParameterGroups. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
```
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameterGroups) dans le *AWS SDK pour C\$1\$1 manuel de référence des API*.
------
#### [ CLI ]
**AWS CLI**
**Pour décrire votre groupe de paramètres de bases de données**
L’exemple `describe-db-parameter-groups` suivant extrait des détails sur vos groupes de paramètres de base de données.
```
aws rds describe-db-parameter-groups
```
Sortie :
```
{
"DBParameterGroups": [
{
"DBParameterGroupName": "default.aurora-mysql5.7",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Default parameter group for aurora-mysql5.7",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-mysql5.7"
},
{
"DBParameterGroupName": "default.aurora-postgresql9.6",
"DBParameterGroupFamily": "aurora-postgresql9.6",
"Description": "Default parameter group for aurora-postgresql9.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-postgresql9.6"
},
{
"DBParameterGroupName": "default.aurora5.6",
"DBParameterGroupFamily": "aurora5.6",
"Description": "Default parameter group for aurora5.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora5.6"
},
{
"DBParameterGroupName": "default.mariadb10.1",
"DBParameterGroupFamily": "mariadb10.1",
"Description": "Default parameter group for mariadb10.1",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.mariadb10.1"
},
...some output truncated...
]
}
```
Pour de plus amples informations, veuillez consulter [ Utilisation des groupes de paramètres de base de données](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameter-groups.html) dans *AWS CLI la référence des commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples).
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameterGroup gets a DB parameter group by name.
func (instances *DbInstances) GetParameterGroup(ctx context.Context, parameterGroupName string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.DescribeDBParameterGroups(
ctx, &rds.DescribeDBParameterGroupsInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
var notFoundError *types.DBParameterGroupNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("Parameter group %v does not exist.\n", parameterGroupName)
err = nil
} else {
log.Printf("Error getting parameter group %v: %v\n", parameterGroupName, err)
}
return nil, err
} else {
return &output.DBParameterGroups[0], err
}
}
```
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups) dans le *AWS SDK pour Go manuel de référence des API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
```
public static void describeDbParameterGroups(RdsClient rdsClient, String dbGroupName) {
try {
DescribeDbParameterGroupsRequest groupsRequest = DescribeDbParameterGroupsRequest.builder()
.dbParameterGroupName(dbGroupName)
.maxRecords(20)
.build();
DescribeDbParameterGroupsResponse response = rdsClient.describeDBParameterGroups(groupsRequest);
List groups = response.dbParameterGroups();
for (DBParameterGroup group : groups) {
System.out.println("The group name is " + group.dbParameterGroupName());
System.out.println("The group description is " + group.description());
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameterGroups) dans le *AWS SDK for Java 2.x manuel de référence des API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_parameter_group(self, parameter_group_name):
"""
Gets a DB parameter group.
:param parameter_group_name: The name of the parameter group to retrieve.
:return: The parameter group.
"""
try:
response = self.rds_client.describe_db_parameter_groups(
DBParameterGroupName=parameter_group_name
)
parameter_group = response["DBParameterGroups"][0]
except ClientError as err:
if err.response["Error"]["Code"] == "DBParameterGroupNotFound":
logger.info("Parameter group %s does not exist.", parameter_group_name)
else:
logger.error(
"Couldn't get parameter group %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return parameter_group
```
+ Pour plus de détails sur l'API, consultez le [manuel de référence de l'API Describe DBParameter Groups](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameterGroups) in *AWS SDK for Python (Boto3*).
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples).
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) parameter groups.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all parameter groups, or nil if error.
def list_parameter_groups(rds_resource)
parameter_groups = []
rds_resource.db_parameter_groups.each do |p|
parameter_groups.append({
"name": p.db_parameter_group_name,
"description": p.description
})
end
parameter_groups
rescue Aws::Errors::ServiceError => e
puts "Couldn't list parameter groups:\n #{e.message}"
end
```
+ Pour plus de détails sur l'API, consultez la section [Décrire DBParameter les groupes](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameterGroups) dans le *AWS SDK pour Ruby manuel de référence des API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples).
```
" iv_dbparametergroupname = 'mydbparametergroup'
TRY.
oo_result = lo_rds->describedbparametergroups(
iv_dbparametergroupname = iv_dbparametergroupname ).
MESSAGE 'DB parameter group retrieved.' TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez la section [Description DBParameter des groupes](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) dans le *AWS SDK pour la référence de l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Get descriptions of the database parameter groups matching the given
/// name.
///
/// - Parameter groupName: The name of the parameter group to describe.
///
/// - Returns: An array of [RDSClientTypes.DBParameterGroup] objects
/// describing the parameter group.
func describeDBParameterGroups(groupName: String) async -> [RDSClientTypes.DBParameterGroup]? {
do {
let output = try await rdsClient.describeDBParameterGroups(
input: DescribeDBParameterGroupsInput(
dbParameterGroupName: groupName
)
)
return output.dbParameterGroups
} catch {
print("*** Error getting the database parameter group's details: \(error.localizedDescription)")
return nil
}
}
```
+ Pour plus de détails sur l'API, consultez la section [Description DBParameter des groupes](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparametergroups(input:)) dans le *AWS SDK pour une référence sur l'API Swift*.
------
# Utilisation `DescribeDBParameters` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeDBParameters`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](rds_example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples).
```
///
/// Get a list of DB parameters from a specific parameter group.
///
/// Name of a specific DB parameter group.
/// Optional source for selecting parameters.
/// List of parameter values.
public async Task> DescribeDBParameters(string dbParameterGroupName, string source = null)
{
var results = new List();
var paginateParameters = _amazonRDS.Paginators.DescribeDBParameters(
new DescribeDBParametersRequest()
{
DBParameterGroupName = dbParameterGroupName,
Source = source
});
// Get the entire list using the paginator.
await foreach (var parameters in paginateParameters.Parameters)
{
results.Add(parameters);
}
return results;
}
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameters) dans le manuel de *référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
//! Routine which gets DB parameters using the 'DescribeDBParameters' api.
/*!
\sa getDBParameters()
\param parameterGroupName: The name of the parameter group.
\param namePrefix: Prefix string to filter results by parameter name.
\param source: A source such as 'user', ignored if empty.
\param parametersResult: Vector of 'Parameter' objects returned by the routine.
\param client: 'RDSClient' instance.
\return bool: Successful completion.
*/
bool AwsDoc::RDS::getDBParameters(const Aws::String ¶meterGroupName,
const Aws::String &namePrefix,
const Aws::String &source,
Aws::Vector ¶metersResult,
const Aws::RDS::RDSClient &client) {
Aws::String marker;
do {
Aws::RDS::Model::DescribeDBParametersRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
if (!marker.empty()) {
request.SetMarker(marker);
}
if (!source.empty()) {
request.SetSource(source);
}
Aws::RDS::Model::DescribeDBParametersOutcome outcome =
client.DescribeDBParameters(request);
if (outcome.IsSuccess()) {
const Aws::Vector ¶meters =
outcome.GetResult().GetParameters();
for (const Aws::RDS::Model::Parameter ¶meter: parameters) {
if (!namePrefix.empty()) {
if (parameter.GetParameterName().find(namePrefix) == 0) {
parametersResult.push_back(parameter);
}
}
else {
parametersResult.push_back(parameter);
}
}
marker = outcome.GetResult().GetMarker();
}
else {
std::cerr << "Error with RDS::DescribeDBParameters. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
} while (!marker.empty());
return true;
}
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameters) dans le manuel de *référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour décrire les paramètres dans un groupe de paramètres de bases de données**
L’exemple `describe-db-parameters` suivant extrait des détails sur le groupe de paramètres de base de données spécifié.
```
aws rds describe-db-parameters \
--db-parameter-group-name mydbpg
```
Sortie :
```
{
"Parameters": [
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
{
"ParameterName": "auto_generate_certs",
"Description": "Controls whether the server autogenerates SSL key and certificate files in the data directory, if they do not already exist.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
...some output truncated...
]
}
```
Pour de plus amples informations, veuillez consulter [ Utilisation des groupes de paramètres de base de données](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameters.html) dans *AWS CLI la référence des commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples).
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameters gets the parameters that are contained in a DB parameter group.
func (instances *DbInstances) GetParameters(ctx context.Context, parameterGroupName string, source string) (
[]types.Parameter, error) {
var output *rds.DescribeDBParametersOutput
var params []types.Parameter
var err error
parameterPaginator := rds.NewDescribeDBParametersPaginator(instances.RdsClient,
&rds.DescribeDBParametersInput{
DBParameterGroupName: aws.String(parameterGroupName),
Source: aws.String(source),
})
for parameterPaginator.HasMorePages() {
output, err = parameterPaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get parameters for %v: %v\n", parameterGroupName, err)
break
} else {
params = append(params, output.Parameters...)
}
}
return params, err
}
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters) dans le manuel de *référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
```
// Retrieve parameters in the group.
public static void describeDbParameters(RdsClient rdsClient, String dbGroupName, int flag) {
try {
DescribeDbParametersRequest dbParameterGroupsRequest;
if (flag == 0) {
dbParameterGroupsRequest = DescribeDbParametersRequest.builder()
.dbParameterGroupName(dbGroupName)
.build();
} else {
dbParameterGroupsRequest = DescribeDbParametersRequest.builder()
.dbParameterGroupName(dbGroupName)
.source("user")
.build();
}
DescribeDbParametersResponse response = rdsClient.describeDBParameters(dbParameterGroupsRequest);
List dbParameters = response.parameters();
String paraName;
for (Parameter para : dbParameters) {
// Only print out information about either auto_increment_offset or
// auto_increment_increment.
paraName = para.parameterName();
if ((paraName.compareTo("auto_increment_offset") == 0)
|| (paraName.compareTo("auto_increment_increment ") == 0)) {
System.out.println("*** The parameter name is " + paraName);
System.out.println("*** The parameter value is " + para.parameterValue());
System.out.println("*** The parameter data type is " + para.dataType());
System.out.println("*** The parameter description is " + para.description());
System.out.println("*** The parameter allowed values is " + para.allowedValues());
}
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameters) dans le manuel de *référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_parameters(self, parameter_group_name, name_prefix="", source=None):
"""
Gets the parameters that are contained in a DB parameter group.
:param parameter_group_name: The name of the parameter group to query.
:param name_prefix: When specified, the retrieved list of parameters is filtered
to contain only parameters that start with this prefix.
:param source: When specified, only parameters from this source are retrieved.
For example, a source of 'user' retrieves only parameters that
were set by a user.
:return: The list of requested parameters.
"""
try:
kwargs = {"DBParameterGroupName": parameter_group_name}
if source is not None:
kwargs["Source"] = source
parameters = []
paginator = self.rds_client.get_paginator("describe_db_parameters")
for page in paginator.paginate(**kwargs):
parameters += [
p
for p in page["Parameters"]
if p["ParameterName"].startswith(name_prefix)
]
except ClientError as err:
logger.error(
"Couldn't get parameters for %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return parameters
```
+ Pour plus de détails sur l'API, voir [AWS Describe DBParameters](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameters) *in SDK for Python (Boto3) API Reference*.
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples).
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) parameter groups.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all parameter groups, or nil if error.
def list_parameter_groups(rds_resource)
parameter_groups = []
rds_resource.db_parameter_groups.each do |p|
parameter_groups.append({
"name": p.db_parameter_group_name,
"description": p.description
})
end
parameter_groups
rescue Aws::Errors::ServiceError => e
puts "Couldn't list parameter groups:\n #{e.message}"
end
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameters) dans le manuel de *référence des AWS SDK pour Ruby API*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples).
```
" iv_dbparametergroupname = 'mydbparametergroup'
" iv_source = 'user' (optional - filters by parameter source)
TRY.
oo_result = lo_rds->describedbparameters(
iv_dbparametergroupname = iv_dbparametergroupname
iv_source = iv_source ).
DATA(lv_param_count) = lines( oo_result->get_parameters( ) ).
MESSAGE |Retrieved { lv_param_count } parameters.| TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez la section [Description DBParameters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) dans le *AWS SDK pour la référence de l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Returns the detailed parameter list for the specified database
/// parameter group.
///
/// - Parameters:
/// - groupName: The name of the parameter group to return parameters for.
/// - source: The types of parameters to return (`user`, `system`, or
/// `engine-default`).
///
/// - Returns: An array of `RdSClientTypes.Parameter` objects, each
/// describing one of the group's parameters.
func describeDBParameters(groupName: String, source: String? = nil) async -> [RDSClientTypes.Parameter] {
var parameterList: [RDSClientTypes.Parameter] = []
do {
let pages = rdsClient.describeDBParametersPaginated(
input: DescribeDBParametersInput(
dbParameterGroupName: groupName,
source: source
)
)
for try await page in pages {
guard let parameters = page.parameters else {
return []
}
parameterList += parameters
}
} catch {
print("*** Error getting database parameters: \(error.localizedDescription)")
return []
}
return parameterList
}
```
+ Pour plus de détails sur l'API, voir [Description DBParameters](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparameters(input:)) dans le *AWS SDK pour la référence de l'API Swift*.
------
# Utilisation `DescribeDBSnapshots` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeDBSnapshots`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](rds_example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples).
```
///
/// Return a list of DB snapshots for a particular DB instance.
///
/// DB instance identifier.
/// List of DB snapshots.
public async Task> DescribeDBSnapshots(string dbInstanceIdentifier)
{
var results = new List();
var snapshotsPaginator = _amazonRDS.Paginators.DescribeDBSnapshots(
new DescribeDBSnapshotsRequest()
{
DBInstanceIdentifier = dbInstanceIdentifier
});
// Get the entire list using the paginator.
await foreach (var snapshots in snapshotsPaginator.DBSnapshots)
{
results.Add(snapshots);
}
return results;
}
```
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBSnapshots) dans le manuel de *référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::DescribeDBSnapshotsRequest request;
request.SetDBSnapshotIdentifier(snapshotID);
Aws::RDS::Model::DescribeDBSnapshotsOutcome outcome =
client.DescribeDBSnapshots(request);
if (outcome.IsSuccess()) {
snapshot = outcome.GetResult().GetDBSnapshots()[0];
}
else {
std::cerr << "Error with RDS::DescribeDBSnapshots. "
<< outcome.GetError().GetMessage()
<< std::endl;
cleanUpResources(PARAMETER_GROUP_NAME, DB_INSTANCE_IDENTIFIER, client);
return false;
}
```
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBSnapshots) dans le manuel de *référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour décrire un instantané de base de données pour une instance de base de données**
L’exemple `describe-db-snapshots` suivant récupère les détails sur instantané de base de données pour une instance de base de données.
```
aws rds describe-db-snapshots \
--db-snapshot-identifier mydbsnapshot
```
Sortie :
```
{
"DBSnapshots": [
{
"DBSnapshotIdentifier": "mydbsnapshot",
"DBInstanceIdentifier": "mysqldb",
"SnapshotCreateTime": "2018-02-08T22:28:08.598Z",
"Engine": "mysql",
"AllocatedStorage": 20,
"Status": "available",
"Port": 3306,
"AvailabilityZone": "us-east-1f",
"VpcId": "vpc-6594f31c",
"InstanceCreateTime": "2018-02-08T22:24:55.973Z",
"MasterUsername": "mysqladmin",
"EngineVersion": "5.6.37",
"LicenseModel": "general-public-license",
"SnapshotType": "manual",
"OptionGroupName": "default:mysql-5-6",
"PercentProgress": 100,
"StorageType": "gp2",
"Encrypted": false,
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshot",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-AKIAIOSFODNN7EXAMPLE"
}
]
}
```
Pour plus d’informations, consultez [Création d’un instantané de base de données](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) dans le *Guide de l’utilisateur Amazon RDS*.
**Exemple 2 : pour trouver le nombre d’instantanés manuels pris**
L'`describe-db-snapshots`exemple suivant utilise l'`length`opérateur dans l'`--query`option pour renvoyer le nombre de clichés manuels qui ont été pris dans une AWS région donnée.
```
aws rds describe-db-snapshots \
--snapshot-type manual \
--query "length(*[].{DBSnapshots:SnapshotType})" \
--region eu-central-1
```
Sortie :
```
35
```
Pour plus d’informations, consultez [Création d’un instantané de base de données](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshots.html) dans *AWS CLI la référence des commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples).
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetSnapshot gets a DB instance snapshot.
func (instances *DbInstances) GetSnapshot(ctx context.Context, snapshotName string) (*types.DBSnapshot, error) {
output, err := instances.RdsClient.DescribeDBSnapshots(ctx,
&rds.DescribeDBSnapshotsInput{
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't get snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return &output.DBSnapshots[0], nil
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots) dans le manuel de *référence des AWS SDK pour Go API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_snapshot(self, snapshot_id):
"""
Gets a DB instance snapshot.
:param snapshot_id: The ID of the snapshot to retrieve.
:return: The retrieved snapshot.
"""
try:
response = self.rds_client.describe_db_snapshots(
DBSnapshotIdentifier=snapshot_id
)
snapshot = response["DBSnapshots"][0]
except ClientError as err:
logger.error(
"Couldn't get snapshot %s. Here's why: %s: %s",
snapshot_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return snapshot
```
+ Pour plus de détails sur l'API, voir [AWS Describe DBSnapshots](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBSnapshots) *in SDK for Python (Boto3) API Reference*.
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples).
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) DB instance
# snapshots.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return instance_snapshots [Array, nil] All instance snapshots, or nil if error.
def list_instance_snapshots(rds_resource)
instance_snapshots = []
rds_resource.db_snapshots.each do |s|
instance_snapshots.append({
"id": s.snapshot_id,
"status": s.status
})
end
instance_snapshots
rescue Aws::Errors::ServiceError => e
puts "Couldn't list instance snapshots:\n #{e.message}"
end
```
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBSnapshots) dans le manuel de *référence des AWS SDK pour Ruby API*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Wait until the specified database snapshot is available to use.
///
/// - Parameters:
/// - instanceIdentifier: The identifier of the database for which the
/// snapshot was taken.
/// - snapshotIdentifier: The identifier of the snapshot to wait for.
func waitUntilDBSnapshotReady(instanceIdentifier: String, snapshotIdentifier: String) async {
var snapshotReady = false
putString("Waiting for the snapshot to be ready...")
do {
while !snapshotReady {
let output = try await rdsClient.describeDBSnapshots(
input: DescribeDBSnapshotsInput(
dbInstanceIdentifier: instanceIdentifier,
dbSnapshotIdentifier: snapshotIdentifier
)
)
guard let snapshotList = output.dbSnapshots else {
return
}
for snapshot in snapshotList {
guard let snapshotReadyStr = snapshot.status else {
return
}
if snapshotReadyStr.contains("available") {
snapshotReady = true
print()
} else {
putString(".")
do {
try await Task.sleep(for: .seconds(15))
} catch {
print("\n*** Error pausing the task!")
}
}
}
}
} catch {
print("\n*** Unable to wait for the database snapshot to be ready: \(error.localizedDescription)")
}
}
```
+ Pour plus de détails sur l'API, voir [Description DBSnapshots](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbsnapshots(input:)) dans le *AWS SDK pour la référence de l'API Swift*.
------
# Utilisation `DescribeOrderableDBInstanceOptions` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeOrderableDBInstanceOptions`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](rds_example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples).
```
///
/// Get a list of orderable DB instance options for a specific
/// engine and engine version.
///
/// Name of the engine.
/// Version of the engine.
/// List of OrderableDBInstanceOptions.
public async Task> DescribeOrderableDBInstanceOptions(string engine, string engineVersion)
{
// Use a paginator to get a list of DB instance options.
var results = new List();
var paginateInstanceOptions = _amazonRDS.Paginators.DescribeOrderableDBInstanceOptions(
new DescribeOrderableDBInstanceOptionsRequest()
{
Engine = engine,
EngineVersion = engineVersion,
});
// Get the entire list using the paginator.
await foreach (var instanceOptions in paginateInstanceOptions.OrderableDBInstanceOptions)
{
results.Add(instanceOptions);
}
return results;
}
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeOrderableDBInstanceOptions) du manuel de *référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
//! Routine which gets available 'micro' DB instance classes, displays the list
//! to the user, and returns the user selection.
/*!
\sa chooseMicroDBInstanceClass()
\param engineName: The DB engine name.
\param engineVersion: The DB engine version.
\param dbInstanceClass: String for DB instance class chosen by the user.
\param client: 'RDSClient' instance.
\return bool: Successful completion.
*/
bool AwsDoc::RDS::chooseMicroDBInstanceClass(const Aws::String &engine,
const Aws::String &engineVersion,
Aws::String &dbInstanceClass,
const Aws::RDS::RDSClient &client) {
std::vector instanceClasses;
Aws::String marker;
do {
Aws::RDS::Model::DescribeOrderableDBInstanceOptionsRequest request;
request.SetEngine(engine);
request.SetEngineVersion(engineVersion);
if (!marker.empty()) {
request.SetMarker(marker);
}
Aws::RDS::Model::DescribeOrderableDBInstanceOptionsOutcome outcome =
client.DescribeOrderableDBInstanceOptions(request);
if (outcome.IsSuccess()) {
const Aws::Vector &options =
outcome.GetResult().GetOrderableDBInstanceOptions();
for (const Aws::RDS::Model::OrderableDBInstanceOption &option: options) {
const Aws::String &instanceClass = option.GetDBInstanceClass();
if (instanceClass.find("micro") != std::string::npos) {
if (std::find(instanceClasses.begin(), instanceClasses.end(),
instanceClass) ==
instanceClasses.end()) {
instanceClasses.push_back(instanceClass);
}
}
}
marker = outcome.GetResult().GetMarker();
}
else {
std::cerr << "Error with RDS::DescribeOrderableDBInstanceOptions. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
} while (!marker.empty());
std::cout << "The available micro DB instance classes for your database engine are:"
<< std::endl;
for (int i = 0; i < instanceClasses.size(); ++i) {
std::cout << " " << i + 1 << ": " << instanceClasses[i] << std::endl;
}
int choice = askQuestionForIntRange(
"Which micro DB instance class do you want to use? ",
1, static_cast(instanceClasses.size()));
dbInstanceClass = instanceClasses[choice - 1];
return true;
}
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeOrderableDBInstanceOptions) du manuel de *référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour décrire les options d’instance de base de données pouvant être commandées**
L’exemple `describe-orderable-db-instance-options` suivant extrait des détails sur les options commandables pour une instance de base de données exécutant le moteur de base de données MySQL.
```
aws rds describe-orderable-db-instance-options \
--engine mysql
```
Sortie :
```
{
"OrderableDBInstanceOptions": [
{
"MinStorageSize": 5,
"ReadReplicaCapable": true,
"MaxStorageSize": 6144,
"AvailabilityZones": [
{
"Name": "us-east-1a"
},
{
"Name": "us-east-1b"
},
{
"Name": "us-east-1c"
},
{
"Name": "us-east-1d"
}
],
"SupportsIops": false,
"AvailableProcessorFeatures": [],
"MultiAZCapable": true,
"DBInstanceClass": "db.m1.large",
"Vpc": true,
"StorageType": "gp2",
"LicenseModel": "general-public-license",
"EngineVersion": "5.5.46",
"SupportsStorageEncryption": false,
"SupportsEnhancedMonitoring": true,
"Engine": "mysql",
"SupportsIAMDatabaseAuthentication": false,
"SupportsPerformanceInsights": false
}
]
...some output truncated...
}
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html) du manuel de *référence des AWS CLI commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples).
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetOrderableInstances uses a paginator to get DB instance options that can be used to create DB instances that are
// compatible with a set of specifications.
func (instances *DbInstances) GetOrderableInstances(ctx context.Context, engine string, engineVersion string) (
[]types.OrderableDBInstanceOption, error) {
var output *rds.DescribeOrderableDBInstanceOptionsOutput
var instanceOptions []types.OrderableDBInstanceOption
var err error
orderablePaginator := rds.NewDescribeOrderableDBInstanceOptionsPaginator(instances.RdsClient,
&rds.DescribeOrderableDBInstanceOptionsInput{
Engine: aws.String(engine),
EngineVersion: aws.String(engineVersion),
})
for orderablePaginator.HasMorePages() {
output, err = orderablePaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get orderable DB instance options: %v\n", err)
break
} else {
instanceOptions = append(instanceOptions, output.OrderableDBInstanceOptions...)
}
}
return instanceOptions, err
}
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions) du manuel de *référence des AWS SDK pour Go API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_orderable_instances(self, db_engine, db_engine_version):
"""
Gets DB instance options that can be used to create DB instances that are
compatible with a set of specifications.
:param db_engine: The database engine that must be supported by the DB instance.
:param db_engine_version: The engine version that must be supported by the DB instance.
:return: The list of DB instance options that can be used to create a compatible DB instance.
"""
try:
inst_opts = []
paginator = self.rds_client.get_paginator(
"describe_orderable_db_instance_options"
)
for page in paginator.paginate(
Engine=db_engine, EngineVersion=db_engine_version
):
inst_opts += page["OrderableDBInstanceOptions"]
except ClientError as err:
logger.error(
"Couldn't get orderable DB instances. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return inst_opts
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeOrderableDBInstanceOptions) du *AWS SDK pour Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples).
```
" iv_engine = 'mysql'
" iv_engineversion = '8.0.35'
TRY.
oo_result = lo_rds->descrorderabledbinstoptions(
iv_engine = iv_engine
iv_engineversion = iv_engineversion ).
DATA(lv_option_count) = lines( oo_result->get_orderabledbinstoptions( ) ).
MESSAGE |Retrieved { lv_option_count } orderable DB instance options.| TYPE 'I'.
ENDTRY.
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) du *AWS SDK pour la référence de l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Print a list of available database instances with "micro" in the class
/// name, then return one of them to be used by other code.
///
/// - Parameters:
/// - engine: The database engine for which to list database instance
/// classes.
/// - engineVersion: The database version for which to list instances.
///
/// - Returns: An `RDSClientTypes.OrderableDBInstanceOption` describing
/// the selected instance type.
func chooseMicroInstance(engine: String = "mysql", engineVersion: String? = nil) async -> RDSClientTypes.OrderableDBInstanceOption? {
do {
let pages = rdsClient.describeOrderableDBInstanceOptionsPaginated(
input: DescribeOrderableDBInstanceOptionsInput(
engine: engine,
engineVersion: engineVersion
)
)
var optionsList: [RDSClientTypes.OrderableDBInstanceOption] = []
for try await page in pages {
guard let orderableDBInstanceOptions = page.orderableDBInstanceOptions else {
continue
}
for dbInstanceOption in orderableDBInstanceOptions {
guard let className = dbInstanceOption.dbInstanceClass else {
continue
}
if className.contains("micro") {
optionsList.append(dbInstanceOption)
}
}
}
print("Found \(optionsList.count) database instances of 'micro' class types:")
for dbInstanceOption in optionsList {
print(" \(dbInstanceOption.engine ?? "") \(dbInstanceOption.engineVersion ?? "") (\(dbInstanceOption.dbInstanceClass ?? ""))")
}
return optionsList[0]
} catch {
print("*** Error getting a list of orderable instance options: \(error.localizedDescription)")
return nil
}
}
```
+ Pour plus de détails sur l'API, consultez la section [DescribeOrderableDBInstanceOptions](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describeorderabledbinstanceoptions(input:)) du *AWS SDK pour la référence de l'API Swift*.
------
# Utilisation `GenerateRDSAuthToken` avec un AWS SDK
L'exemple de code suivant montre comment utiliser`GenerateRDSAuthToken`.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
Utilisez la [RdsUtilities](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rds/RdsUtilities.html)classe pour générer un jeton d'authentification.
```
public class GenerateRDSAuthToken {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
dbInstanceIdentifier - The database instance identifier.\s
masterUsername - The master user name.\s
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
String masterUsername = args[1];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
String token = getAuthToken(rdsClient, dbInstanceIdentifier, masterUsername);
System.out.println("The token response is " + token);
}
public static String getAuthToken(RdsClient rdsClient, String dbInstanceIdentifier, String masterUsername) {
RdsUtilities utilities = rdsClient.utilities();
try {
GenerateAuthenticationTokenRequest tokenRequest = GenerateAuthenticationTokenRequest.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.username(masterUsername)
.port(3306)
.hostname(dbInstanceIdentifier)
.build();
return utilities.generateAuthenticationToken(tokenRequest);
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
return "";
}
}
```
+ Pour plus de détails sur l'API, voir [Générer un RDSAuth jeton](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/GenerateRDSAuthToken) dans la *référence des AWS SDK for Java 2.x API*.
------
# Utilisation `ModifyDBInstance` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `ModifyDBInstance`.
------
#### [ CLI ]
**AWS CLI**
**Exemple 1 : pour modifier une instance de base de données**
L’exemple `modify-db-instance` suivant associe un groupe d’options et un groupe de paramètres à une instance de base de données Microsoft SQL Server compatible. Le paramètre `--apply-immediately` entraîne l’association immédiate des groupes d’options et de paramètres au lieu d’attendre la prochaine fenêtre de maintenance.
```
aws rds modify-db-instance \
--db-instance-identifier database-2 \
--option-group-name test-se-2017 \
--db-parameter-group-name test-sqlserver-se-2017 \
--apply-immediately
```
Sortie :
```
{
"DBInstance": {
"DBInstanceIdentifier": "database-2",
"DBInstanceClass": "db.r4.large",
"Engine": "sqlserver-se",
"DBInstanceStatus": "available",
...output omitted...
"DBParameterGroups": [
{
"DBParameterGroupName": "test-sqlserver-se-2017",
"ParameterApplyStatus": "applying"
}
],
"AvailabilityZone": "us-west-2d",
...output omitted...
"MultiAZ": true,
"EngineVersion": "14.00.3281.6.v1",
"AutoMinorVersionUpgrade": false,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "license-included",
"OptionGroupMemberships": [
{
"OptionGroupName": "test-se-2017",
"Status": "pending-apply"
}
],
"CharacterSetName": "SQL_Latin1_General_CP1_CI_AS",
"SecondaryAvailabilityZone": "us-west-2c",
"PubliclyAccessible": true,
"StorageType": "gp2",
...output omitted...
"DeletionProtection": false,
"AssociatedRoles": [],
"MaxAllocatedStorage": 1000
}
}
```
Pour plus d’informations, consultez [Modification d’une instance de base de données Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html) dans le *Guide de l’utilisateur Amazon RDS*.
**Exemple 2 : pour associer un groupe de sécurité VPC à une instance de base de données**
L’exemple `modify-db-instance` suivant associe un groupe de sécurité VPC spécifique et supprime des groupes de sécurité de base de données d’une instance de base de données :
```
aws rds modify-db-instance \
--db-instance-identifier dbName \
--vpc-security-group-ids sg-ID
```
Sortie :
```
{
"DBInstance": {
"DBInstanceIdentifier": "dbName",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "available",
"MasterUsername": "admin",
"Endpoint": {
"Address": "dbName.abcdefghijk.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "ABCDEFGHIJK1234"
},
"AllocatedStorage": 20,
"InstanceCreateTime": "2024-02-15T00:37:58.793000+00:00",
"PreferredBackupWindow": "11:57-12:27",
"BackupRetentionPeriod": 7,
"DBSecurityGroups": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-ID",
"Status": "active"
}
],
... output omitted ...
"MultiAZ": false,
"EngineVersion": "8.0.35",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "general-public-license",
... output omitted ...
}
}
```
Pour plus d’informations, consultez [Contrôle d’accès par groupe de sécurité](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, voir [Modifier DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-instance.html) dans *AWS CLI la référence des commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.ModifyDbInstanceRequest;
import software.amazon.awssdk.services.rds.model.ModifyDbInstanceResponse;
import software.amazon.awssdk.services.rds.model.RdsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ModifyDBInstance {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
dbInstanceIdentifier - The database instance identifier.\s
masterUserPassword - The updated password that corresponds to the master user name.\s
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
String masterUserPassword = args[1];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
updateIntance(rdsClient, dbInstanceIdentifier, masterUserPassword);
rdsClient.close();
}
public static void updateIntance(RdsClient rdsClient, String dbInstanceIdentifier, String masterUserPassword) {
try {
// For a demo - modify the DB instance by modifying the master password.
ModifyDbInstanceRequest modifyDbInstanceRequest = ModifyDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceIdentifier)
.publiclyAccessible(true)
.masterUserPassword(masterUserPassword)
.build();
ModifyDbInstanceResponse instanceResponse = rdsClient.modifyDBInstance(modifyDbInstanceRequest);
System.out.print("The ARN of the modified database is: " + instanceResponse.dbInstance().dbInstanceArn());
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBInstance) dans la *référence des AWS SDK for Java 2.x API*.
------
#### [ Kotlin ]
**SDK pour Kotlin**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/rds#code-examples).
```
suspend fun updateIntance(
dbInstanceIdentifierVal: String?,
masterUserPasswordVal: String?,
) {
val request =
ModifyDbInstanceRequest {
dbInstanceIdentifier = dbInstanceIdentifierVal
publiclyAccessible = true
masterUserPassword = masterUserPasswordVal
}
RdsClient.fromEnvironment { region = "us-west-2" }.use { rdsClient ->
val instanceResponse = rdsClient.modifyDbInstance(request)
println("The ARN of the modified database is ${instanceResponse.dbInstance?.dbInstanceArn}")
}
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBInstance](https://sdk.amazonaws.com/kotlin/api/latest/index.html) dans le *AWS SDK pour la référence de l'API Kotlin*.
------
# Utilisation `ModifyDBParameterGroup` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `ModifyDBParameterGroup`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](rds_example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples).
```
///
/// Update a DB parameter group. Use the action DescribeDBParameterGroupsAsync
/// to determine when the DB parameter group is ready to use.
///
/// Name of the DB parameter group.
/// List of parameters. Maximum of 20 per request.
/// The updated DB parameter group name.
public async Task ModifyDBParameterGroup(
string name, List parameters)
{
var response = await _amazonRDS.ModifyDBParameterGroupAsync(
new ModifyDBParameterGroupRequest()
{
DBParameterGroupName = name,
Parameters = parameters,
});
return response.DBParameterGroupName;
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/ModifyDBParameterGroup) dans la *référence des AWS SDK pour .NET API*.
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::ModifyDBParameterGroupRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
request.SetParameters(updateParameters);
Aws::RDS::Model::ModifyDBParameterGroupOutcome outcome =
client.ModifyDBParameterGroup(request);
if (outcome.IsSuccess()) {
std::cout << "The DB parameter group was successfully modified."
<< std::endl;
}
else {
std::cerr << "Error with RDS::ModifyDBParameterGroup. "
<< outcome.GetError().GetMessage()
<< std::endl;
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/ModifyDBParameterGroup) dans la *référence des AWS SDK pour C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Pour modifier un groupe de paramètres de base de données**
L’exemple `modify-db-parameter-group` suivant modifie la valeur du paramètre `clr enabled` dans un groupe de paramètres de base de données. Le paramètre `--apply-immediately` entraîne la modification immédiate du groupe de paramètres de base de données, au lieu d’attendre la prochaine fenêtre de maintenance.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-se-2017 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
Sortie :
```
{
"DBParameterGroupName": "test-sqlserver-se-2017"
}
```
Pour plus d’informations, consultez [Modification de paramètres dans un groupe de paramètres DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Modifying) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-parameter-group.html) dans *AWS CLI la référence des commandes*.
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples).
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// UpdateParameters updates parameters in a named DB parameter group.
func (instances *DbInstances) UpdateParameters(ctx context.Context, parameterGroupName string, params []types.Parameter) error {
_, err := instances.RdsClient.ModifyDBParameterGroup(ctx,
&rds.ModifyDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
Parameters: params,
})
if err != nil {
log.Printf("Couldn't update parameters in %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup) dans la *référence des AWS SDK pour Go API*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
```
// Modify auto_increment_offset and auto_increment_increment parameters.
public static void modifyDBParas(RdsClient rdsClient, String dbGroupName) {
try {
Parameter parameter1 = Parameter.builder()
.parameterName("auto_increment_offset")
.applyMethod("immediate")
.parameterValue("5")
.build();
List paraList = new ArrayList<>();
paraList.add(parameter1);
ModifyDbParameterGroupRequest groupRequest = ModifyDbParameterGroupRequest.builder()
.dbParameterGroupName(dbGroupName)
.parameters(paraList)
.build();
ModifyDbParameterGroupResponse response = rdsClient.modifyDBParameterGroup(groupRequest);
System.out.println("The parameter group " + response.dbParameterGroupName() + " was successfully modified");
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBParameterGroup) dans la *référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples).
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def update_parameters(self, parameter_group_name, update_parameters):
"""
Updates parameters in a custom DB parameter group.
:param parameter_group_name: The name of the parameter group to update.
:param update_parameters: The parameters to update in the group.
:return: Data about the modified parameter group.
"""
try:
response = self.rds_client.modify_db_parameter_group(
DBParameterGroupName=parameter_group_name, Parameters=update_parameters
)
except ClientError as err:
logger.error(
"Couldn't update parameters in %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response
```
+ Pour plus de détails sur l'API, voir [DBParameterModify Group](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/ModifyDBParameterGroup) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples).
```
" iv_dbparametergroupname = 'mydbparametergroup'
" it_parameters - table containing parameter objects with:
" - parametername = 'max_connections'
" - parametervalue = '100'
" - applymethod = 'immediate' or 'pending-reboot'
TRY.
oo_result = lo_rds->modifydbparametergroup(
iv_dbparametergroupname = iv_dbparametergroupname
it_parameters = it_parameters ).
MESSAGE 'DB parameter group modified.' TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
CATCH /aws1/cx_rdsinvdbprmgrstatef00.
MESSAGE 'DB parameter group is in an invalid state.' TYPE 'I'.
ENDTRY.
```
+ Pour plus de détails sur l'API, voir [Modifier le DBParameter groupe](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) dans le *AWS SDK pour la référence de l'API SAP ABAP*.
------
#### [ Swift ]
**Kit SDK pour Swift**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples).
```
import AWSRDS
/// Demonstrates modifying two of the specified database parameter group's
/// parameters.
///
/// - Parameter groupName: The name of the parameter group to change
/// parameters for.
func modifyDBParameters(groupName: String) async {
let parameter1 = RDSClientTypes.Parameter(
applyMethod: RDSClientTypes.ApplyMethod.immediate,
parameterName: "auto_increment_offset",
parameterValue: "5"
)
let parameter2 = RDSClientTypes.Parameter(
applyMethod: RDSClientTypes.ApplyMethod.immediate,
parameterName: "auto_increment_increment",
parameterValue: "5"
)
let parameterList = [parameter1, parameter2]
do {
_ = try await rdsClient.modifyDBParameterGroup(
input: ModifyDBParameterGroupInput(
dbParameterGroupName: groupName,
parameters: parameterList
)
)
print("Successfully modified the parameter group \(groupName).")
} catch {
print("*** Error modifying the parameter group \(groupName): \(error.localizedDescription)")
}
}
```
+ Pour plus de détails sur l'API, voir [Modifier DBParameter le groupe](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/modifydbparametergroup(input:)) dans le *AWS SDK pour une référence à l'API Swift*.
------
# Utilisation `RebootDBInstance` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `RebootDBInstance`.
------
#### [ CLI ]
**AWS CLI**
**Pour redémarrer une instance de base de données**
L’exemple `reboot-db-instance` suivant lance un redémarrage de l’instance de base de données spécifiée.
```
aws rds reboot-db-instance \
--db-instance-identifier test-mysql-instance
```
Sortie :
```
{
"DBInstance": {
"DBInstanceIdentifier": "test-mysql-instance",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "rebooting",
"MasterUsername": "admin",
"Endpoint": {
"Address": "test-mysql-instance.############.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "Z1PVIF0EXAMPLE"
},
... output omitted...
}
}
```
Pour plus d’informations, consultez [Redémarrage d’une instance de base de données](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html) dans le *Guide de l’utilisateur Amazon RDS*.
+ Pour plus de détails sur l'API, voir [Reboot DBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-instance.html) dans *AWS CLI la référence des commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.RebootDbInstanceRequest;
import software.amazon.awssdk.services.rds.model.RebootDbInstanceResponse;
import software.amazon.awssdk.services.rds.model.RdsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class RebootDBInstance {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
dbInstanceIdentifier - The database instance identifier\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
rebootInstance(rdsClient, dbInstanceIdentifier);
rdsClient.close();
}
public static void rebootInstance(RdsClient rdsClient, String dbInstanceIdentifier) {
try {
RebootDbInstanceRequest rebootDbInstanceRequest = RebootDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceIdentifier)
.build();
RebootDbInstanceResponse instanceResponse = rdsClient.rebootDBInstance(rebootDbInstanceRequest);
System.out.print("The database " + instanceResponse.dbInstance().dbInstanceArn() + " was rebooted");
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ Pour plus de détails sur l'API, voir [Reboot DBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/RebootDBInstance) dans le manuel de *référence des AWS SDK for Java 2.x API*.
------
# Scénarios d'utilisation d'Amazon RDS AWS SDKs
Les exemples de code suivants vous montrent comment implémenter des scénarios courants dans Amazon RDS avec AWS SDKs. Ces scénarios vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions dans Amazon RDS ou en les combinant avec d’autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code.
Les scénarios ciblent un niveau d’expérience intermédiaire pour vous aider à comprendre les actions de service dans leur contexte.
**Topics**
+ [Créer un outil de suivi des éléments de travail sans serveur Aurora](rds_example_cross_RDSDataTracker_section.md)
# Créer un outil de suivi des éléments de travail sans serveur Aurora
Les exemples de code suivants montrent comment créer une application web qui suit des éléments de travail dans une base de données Amazon Aurora sans serveur et envoie des rapports par e-mail à l’aide d’Amazon Simple Email Service (Amazon SES).
------
#### [ .NET ]
**SDK pour .NET**
Montre comment utiliser le AWS SDK pour .NET pour créer une application Web qui suit les éléments de travail dans une base de données Amazon Aurora et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise un front-end créé avec React.js pour interagir avec un backend RESTful .NET.
+ Intégrez une application Web React à AWS des services.
+ Listez, ajoutez et mettez à jour des éléments dans une table Aurora.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon Aurora sans serveur.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API REST C\$1\$1 qui interroge les données Amazon Aurora Serverless et à utiliser par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon RDS.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Aurora Serverless et pour une utilisation par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest).
Pour obtenir le code source complet et les instructions sur la façon de configurer et d'exécuter un exemple utilisant l'API JDBC, consultez l'exemple complet sur. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker)
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment utiliser le AWS SDK pour JavaScript (v3) pour créer une application Web qui suit les éléments de travail dans une base de données Amazon Aurora et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise un front end créé avec React.js pour interagir avec un backend Express Node.js.
+ Intégrez une application Web React.js à Services AWS.
+ Lister, ajouter et mettre à jour des éléments dans une table Aurora.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés en utilisant Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment créer une application web qui suit et génère des rapports sur les éléments de travail stockés dans une base de données Amazon RDS.
Pour obtenir le code source complet et les instructions sur la façon de configurer une API Spring REST qui interroge les données Amazon Aurora Serverless et pour une utilisation par une application React, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ PHP ]
**Kit SDK pour PHP**
Montre comment utiliser le AWS SDK pour PHP pour créer une application Web qui suit les éléments de travail dans une base de données Amazon RDS et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise un front-end créé avec React.js pour interagir avec un backend RESTful PHP.
+ Intégrez une application Web React.js à AWS des services.
+ Répertoriez, ajoutez, mettez à jour et supprimez des éléments dans une table Amazon RDS.
+ Envoyez un rapport par e-mail sur les éléments de travail filtrés à l’aide d’Amazon SES.
+ Déployez et gérez des exemples de ressources à l'aide du AWS CloudFormation script inclus.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
#### [ Python ]
**SDK pour Python (Boto3)**
Montre comment utiliser le AWS SDK pour Python (Boto3) pour créer un service REST qui suit les éléments de travail dans une base de données Amazon Aurora Serverless et envoie des rapports par e-mail à l'aide d'Amazon Simple Email Service (Amazon SES). Cet exemple utilise la structure web Flask pour gérer le routage HTTP et s’intègre à une page web React pour présenter une application web entièrement fonctionnelle.
+ Créez un service Flask REST qui s'intègre à Services AWS.
+ Lisez, écrivez et mettez à jour les éléments de travail stockés dans une base de données Aurora sans serveur.
+ Créez un AWS Secrets Manager secret contenant les informations d'identification de la base de données et utilisez-le pour authentifier les appels à la base de données.
+ Utilisez Amazon SES pour envoyer des rapports par e-mail sur les éléments de travail.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker).
**Les services utilisés dans cet exemple**
+ Aurora
+ Amazon RDS
+ Services de données Amazon RDS
+ Amazon SES
------
# Exemples sans serveur pour Amazon RDS
Les exemples de code suivants montrent comment utiliser Amazon RDS avec AWS SDKs.
**Topics**
+ [Connexion à une base de données Amazon RDS dans une fonction Lambda](rds_example_serverless_connect_RDS_Lambda_section.md)
# Connexion à une base de données Amazon RDS dans une fonction Lambda
Les exemples de code suivants illustrent comment implémenter une fonction Lambda qui se connecte à une base de données RDS. La fonction effectue une simple requête de base de données et renvoie le résultat.
------
#### [ .NET ]
**SDK pour .NET**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de .NET.
```
using System.Data;
using System.Text.Json;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.Lambda.Core;
using MySql.Data.MySqlClient;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace aws_rds;
public class InputModel
{
public string key1 { get; set; }
public string key2 { get; set; }
}
public class Function
{
///
// Handles the Lambda function execution for connecting to RDS using IAM authentication.
///
/// The input event data passed to the Lambda function
/// The Lambda execution context that provides runtime information
/// A response object containing the execution result
public async Task FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
// Sample Input: {"body": "{\"key1\":\"20\", \"key2\":\"25\"}"}
var input = JsonSerializer.Deserialize(request.Body);
/// Obtain authentication token
var authToken = RDSAuthTokenGenerator.GenerateAuthToken(
Environment.GetEnvironmentVariable("RDS_ENDPOINT"),
Convert.ToInt32(Environment.GetEnvironmentVariable("RDS_PORT")),
Environment.GetEnvironmentVariable("RDS_USERNAME")
);
/// Build the Connection String with the Token
string connectionString = $"Server={Environment.GetEnvironmentVariable("RDS_ENDPOINT")};" +
$"Port={Environment.GetEnvironmentVariable("RDS_PORT")};" +
$"Uid={Environment.GetEnvironmentVariable("RDS_USERNAME")};" +
$"Pwd={authToken};";
try
{
await using var connection = new MySqlConnection(connectionString);
await connection.OpenAsync();
const string sql = "SELECT @param1 + @param2 AS Sum";
await using var command = new MySqlCommand(sql, connection);
command.Parameters.AddWithValue("@param1", int.Parse(input.key1 ?? "0"));
command.Parameters.AddWithValue("@param2", int.Parse(input.key2 ?? "0"));
await using var reader = await command.ExecuteReaderAsync();
if (await reader.ReadAsync())
{
int result = reader.GetInt32("Sum");
//Sample Response: {"statusCode":200,"body":"{\"message\":\"The sum is: 45\"}","isBase64Encoded":false}
return new APIGatewayProxyResponse
{
StatusCode = 200,
Body = JsonSerializer.Serialize(new { message = $"The sum is: {result}" })
};
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
return new APIGatewayProxyResponse
{
StatusCode = 500,
Body = JsonSerializer.Serialize(new { error = "Internal server error" })
};
}
}
```
------
#### [ Go ]
**Kit SDK pour Go V2**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de Go.
```
/*
Golang v2 code here.
*/
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
type MyEvent struct {
Name string `json:"name"`
}
func HandleRequest(event *MyEvent) (map[string]interface{}, error) {
var dbName string = os.Getenv("DatabaseName")
var dbUser string = os.Getenv("DatabaseUser")
var dbHost string = os.Getenv("DBHost") // Add hostname without https
var dbPort int = os.Getenv("Port") // Add port number
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = os.Getenv("AWS_REGION")
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)
}
defer db.Close()
var sum int
err = db.QueryRow("SELECT ?+? AS sum", 3, 2).Scan(&sum)
if err != nil {
panic(err)
}
s := fmt.Sprint(sum)
message := fmt.Sprintf("The selected sum is: %s", s)
messageBytes, err := json.Marshal(message)
if err != nil {
return nil, err
}
messageString := string(messageBytes)
return map[string]interface{}{
"statusCode": 200,
"headers": map[string]string{"Content-Type": "application/json"},
"body": messageString,
}, nil
}
func main() {
lambda.Start(HandleRequest)
}
```
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de Java.
```
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rdsdata.RdsDataClient;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementRequest;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementResponse;
import software.amazon.awssdk.services.rdsdata.model.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class RdsLambdaHandler implements RequestHandler {
@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
try {
// Obtain auth token
String token = createAuthToken();
// Define connection configuration
String connectionString = String.format("jdbc:mysql://%s:%s/%s?useSSL=true&requireSSL=true",
System.getenv("ProxyHostName"),
System.getenv("Port"),
System.getenv("DBName"));
// Establish a connection to the database
try (Connection connection = DriverManager.getConnection(connectionString, System.getenv("DBUserName"), token);
PreparedStatement statement = connection.prepareStatement("SELECT ? + ? AS sum")) {
statement.setInt(1, 3);
statement.setInt(2, 2);
try (ResultSet resultSet = statement.executeQuery()) {
if (resultSet.next()) {
int sum = resultSet.getInt("sum");
response.setStatusCode(200);
response.setBody("The selected sum is: " + sum);
}
}
}
} catch (Exception e) {
response.setStatusCode(500);
response.setBody("Error: " + e.getMessage());
}
return response;
}
private String createAuthToken() {
// Create RDS Data Service client
RdsDataClient rdsDataClient = RdsDataClient.builder()
.region(Region.of(System.getenv("AWS_REGION")))
.credentialsProvider(DefaultCredentialsProvider.create())
.build();
// Define authentication request
ExecuteStatementRequest request = ExecuteStatementRequest.builder()
.resourceArn(System.getenv("ProxyHostName"))
.secretArn(System.getenv("DBUserName"))
.database(System.getenv("DBName"))
.sql("SELECT 'RDS IAM Authentication'")
.build();
// Execute request and obtain authentication token
ExecuteStatementResponse response = rdsDataClient.executeStatement(request);
Field tokenField = response.records().get(0).get(0);
return tokenField.stringValue();
}
}
```
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l'aide de. JavaScript
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
/*
Node.js code here.
*/
// ES6+ example
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
async function createAuthToken() {
// Define connection authentication parameters
const dbinfo = {
hostname: process.env.ProxyHostName,
port: process.env.Port,
username: process.env.DBUserName,
region: process.env.AWS_REGION,
}
// Create RDS Signer object
const signer = new Signer(dbinfo);
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps() {
// Obtain auth token
const token = await createAuthToken();
// Define connection configuration
let connectionConfig = {
host: process.env.ProxyHostName,
user: process.env.DBUserName,
password: token,
database: process.env.DBName,
ssl: 'Amazon RDS'
}
// Create the connection to the DB
const conn = await mysql.createConnection(connectionConfig);
// Obtain the result of the query
const [res,] = await conn.execute('select ?+? as sum', [3, 2]);
return res;
}
export const handler = async (event) => {
// Execute database flow
const result = await dbOps();
// Return result
return {
statusCode: 200,
body: JSON.stringify("The selected sum is: " + result[0].sum)
}
};
```
Connexion à une base de données Amazon RDS dans une fonction Lambda à l'aide de. TypeScript
```
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
// RDS settings
// Using '!' (non-null assertion operator) to tell the TypeScript compiler that the DB settings are not null or undefined,
const proxy_host_name = process.env.PROXY_HOST_NAME!
const port = parseInt(process.env.PORT!)
const db_name = process.env.DB_NAME!
const db_user_name = process.env.DB_USER_NAME!
const aws_region = process.env.AWS_REGION!
async function createAuthToken(): Promise {
// Create RDS Signer object
const signer = new Signer({
hostname: proxy_host_name,
port: port,
region: aws_region,
username: db_user_name
});
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps(): Promise {
try {
// Obtain auth token
const token = await createAuthToken();
const conn = await mysql.createConnection({
host: proxy_host_name,
user: db_user_name,
password: token,
database: db_name,
ssl: 'Amazon RDS' // Ensure you have the CA bundle for SSL connection
});
const [rows, fields] = await conn.execute('SELECT ? + ? AS sum', [3, 2]);
console.log('result:', rows);
return rows;
}
catch (err) {
console.log(err);
}
}
export const lambdaHandler = async (event: any): Promise<{ statusCode: number; body: string }> => {
// Execute database flow
const result = await dbOps();
// Return error is result is undefined
if (result == undefined)
return {
statusCode: 500,
body: JSON.stringify(`Error with connection to DB host`)
}
// Return result
return {
statusCode: 200,
body: JSON.stringify(`The selected sum is: ${result[0].sum}`)
};
};
```
------
#### [ PHP ]
**Kit SDK pour PHP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de PHP.
```
logger = $logger;
}
private function getAuthToken(): string {
// Define connection authentication parameters
$dbConnection = [
'hostname' => getenv('DB_HOSTNAME'),
'port' => getenv('DB_PORT'),
'username' => getenv('DB_USERNAME'),
'region' => getenv('AWS_REGION'),
];
// Create RDS AuthTokenGenerator object
$generator = new AuthTokenGenerator(CredentialProvider::defaultProvider());
// Request authorization token from RDS, specifying the username
return $generator->createToken(
$dbConnection['hostname'] . ':' . $dbConnection['port'],
$dbConnection['region'],
$dbConnection['username']
);
}
private function getQueryResults() {
// Obtain auth token
$token = $this->getAuthToken();
// Define connection configuration
$connectionConfig = [
'host' => getenv('DB_HOSTNAME'),
'user' => getenv('DB_USERNAME'),
'password' => $token,
'database' => getenv('DB_NAME'),
];
// Create the connection to the DB
$conn = new PDO(
"mysql:host={$connectionConfig['host']};dbname={$connectionConfig['database']}",
$connectionConfig['user'],
$connectionConfig['password'],
[
PDO::MYSQL_ATTR_SSL_CA => '/path/to/rds-ca-2019-root.pem',
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
]
);
// Obtain the result of the query
$stmt = $conn->prepare('SELECT ?+? AS sum');
$stmt->execute([3, 2]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* @param mixed $event
* @param Context $context
* @return array
*/
public function handle(mixed $event, Context $context): array
{
$this->logger->info("Processing query");
// Execute database flow
$result = $this->getQueryResults();
return [
'sum' => $result['sum']
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de Python.
```
import json
import os
import boto3
import pymysql
# RDS settings
proxy_host_name = os.environ['PROXY_HOST_NAME']
port = int(os.environ['PORT'])
db_name = os.environ['DB_NAME']
db_user_name = os.environ['DB_USER_NAME']
aws_region = os.environ['AWS_REGION']
# Fetch RDS Auth Token
def get_auth_token():
client = boto3.client('rds')
token = client.generate_db_auth_token(
DBHostname=proxy_host_name,
Port=port
DBUsername=db_user_name
Region=aws_region
)
return token
def lambda_handler(event, context):
token = get_auth_token()
try:
connection = pymysql.connect(
host=proxy_host_name,
user=db_user_name,
password=token,
db=db_name,
port=port,
ssl={'ca': 'Amazon RDS'} # Ensure you have the CA bundle for SSL connection
)
with connection.cursor() as cursor:
cursor.execute('SELECT %s + %s AS sum', (3, 2))
result = cursor.fetchone()
return result
except Exception as e:
return (f"Error: {str(e)}") # Return an error message if an exception occurs
```
------
#### [ Ruby ]
**Kit SDK pour Ruby**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de Ruby.
```
# Ruby code here.
require 'aws-sdk-rds'
require 'json'
require 'mysql2'
def lambda_handler(event:, context:)
endpoint = ENV['DBEndpoint'] # Add the endpoint without https"
port = ENV['Port'] # 3306
user = ENV['DBUser']
region = ENV['DBRegion'] # 'us-east-1'
db_name = ENV['DBName']
credentials = Aws::Credentials.new(
ENV['AWS_ACCESS_KEY_ID'],
ENV['AWS_SECRET_ACCESS_KEY'],
ENV['AWS_SESSION_TOKEN']
)
rds_client = Aws::RDS::AuthTokenGenerator.new(
region: region,
credentials: credentials
)
token = rds_client.auth_token(
endpoint: endpoint+ ':' + port,
user_name: user,
region: region
)
begin
conn = Mysql2::Client.new(
host: endpoint,
username: user,
password: token,
port: port,
database: db_name,
sslca: '/var/task/global-bundle.pem',
sslverify: true,
enable_cleartext_plugin: true
)
a = 3
b = 2
result = conn.query("SELECT #{a} + #{b} AS sum").first['sum']
puts result
conn.close
{
statusCode: 200,
body: result.to_json
}
rescue => e
puts "Database connection failed due to #{e}"
end
end
```
------
#### [ Rust ]
**SDK pour Rust**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’[exemples sans serveur](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Connexion à une base de données Amazon RDS dans une fonction Lambda à l’aide de Rust.
```
use aws_config::BehaviorVersion;
use aws_credential_types::provider::ProvideCredentials;
use aws_sigv4::{
http_request::{sign, SignableBody, SignableRequest, SigningSettings},
sign::v4,
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde_json::{json, Value};
use sqlx::postgres::PgConnectOptions;
use std::env;
use std::time::{Duration, SystemTime};
const RDS_CERTS: &[u8] = include_bytes!("global-bundle.pem");
async fn generate_rds_iam_token(
db_hostname: &str,
port: u16,
db_username: &str,
) -> Result {
let config = aws_config::load_defaults(BehaviorVersion::v2024_03_28()).await;
let credentials = config
.credentials_provider()
.expect("no credentials provider found")
.provide_credentials()
.await
.expect("unable to load credentials");
let identity = credentials.into();
let region = config.region().unwrap().to_string();
let mut signing_settings = SigningSettings::default();
signing_settings.expires_in = Some(Duration::from_secs(900));
signing_settings.signature_location = aws_sigv4::http_request::SignatureLocation::QueryParams;
let signing_params = v4::SigningParams::builder()
.identity(&identity)
.region(®ion)
.name("rds-db")
.time(SystemTime::now())
.settings(signing_settings)
.build()?;
let url = format!(
"https://{db_hostname}:{port}/?Action=connect&DBUser={db_user}",
db_hostname = db_hostname,
port = port,
db_user = db_username
);
let signable_request =
SignableRequest::new("GET", &url, std::iter::empty(), SignableBody::Bytes(&[]))
.expect("signable request");
let (signing_instructions, _signature) =
sign(signable_request, &signing_params.into())?.into_parts();
let mut url = url::Url::parse(&url).unwrap();
for (name, value) in signing_instructions.params() {
url.query_pairs_mut().append_pair(name, &value);
}
let response = url.to_string().split_off("https://".len());
Ok(response)
}
#[tokio::main]
async fn main() -> Result<(), Error> {
run(service_fn(handler)).await
}
async fn handler(_event: LambdaEvent) -> Result {
let db_host = env::var("DB_HOSTNAME").expect("DB_HOSTNAME must be set");
let db_port = env::var("DB_PORT")
.expect("DB_PORT must be set")
.parse::()
.expect("PORT must be a valid number");
let db_name = env::var("DB_NAME").expect("DB_NAME must be set");
let db_user_name = env::var("DB_USERNAME").expect("DB_USERNAME must be set");
let token = generate_rds_iam_token(&db_host, db_port, &db_user_name).await?;
let opts = PgConnectOptions::new()
.host(&db_host)
.port(db_port)
.username(&db_user_name)
.password(&token)
.database(&db_name)
.ssl_root_cert_from_pem(RDS_CERTS.to_vec())
.ssl_mode(sqlx::postgres::PgSslMode::Require);
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_with(opts)
.await?;
let result: i32 = sqlx::query_scalar("SELECT $1 + $2")
.bind(3)
.bind(2)
.fetch_one(&pool)
.await?;
println!("Result: {:?}", result);
Ok(json!({
"statusCode": 200,
"content-type": "text/plain",
"body": format!("The selected sum is: {result}")
}))
}
```
------