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);
}
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBInstances)。
------
#### [ Kotlin ]
**SDK for Kotlin**
查看 GitHub，了解更多信息。在 [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}")
}
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Kotlin API Reference》**中的 [DescribeDBInstances](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
#### [ PHP ]
**适用于 PHP 的 SDK**
查看 GitHub，了解更多信息。在 [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";
}
```
+ 有关 API 详细信息，请参阅《适用于 PHP 的 AWS SDK API Reference》**中的 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [DescribeDBInstances](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBInstances)。
------
#### [ Ruby ]
**适用于 Ruby 的 SDK**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBInstances)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [DescribeDBInstances](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbinstances(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `DescribeDBParameterGroups` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `DescribeDBParameterGroups`。
操作示例是大型程序的代码摘录，必须在上下文中运行。在以下代码示例中，您可以查看此操作的上下文：
+ [了解基本功能](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 .NET 的 AWS SDK API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameterGroups)。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 C\$1\$1 的 AWS SDK API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameterGroups)。
------
#### [ CLI ]
**AWS CLI**
**描述数据库参数组**
以下 `describe-db-parameter-groups` 示例将检索有关数据库参数组的详细信息。
```
aws rds describe-db-parameter-groups
```
输出：
```
{
"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...
]
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[使用数据库参数组](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [DescribeDBParameterGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameter-groups.html)。
------
#### [ Go ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的 [DescribeDBParameterGroups](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups)。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [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);
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameterGroups)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameterGroups)。
------
#### [ Ruby ]
**适用于 Ruby 的 SDK**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameterGroups)。
------
#### [ SAP ABAP ]
**适用于 SAP ABAP 的 SDK**
查看 GitHub，了解更多信息。在 [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.
```
+ 有关 API 详细信息，请参阅《AWS SDK for SAP ABAP API Reference》**中的 [DescribeDBParameterGroups](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [DescribeDBParameterGroups](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparametergroups(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `DescribeDBParameters` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `DescribeDBParameters`。
操作示例是大型程序的代码摘录，必须在上下文中运行。在以下代码示例中，您可以查看此操作的上下文：
+ [了解基本功能](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 .NET 的 AWS SDK API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameters)。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 C\$1\$1 的 AWS SDK API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameters)。
------
#### [ CLI ]
**AWS CLI**
**描述数据库参数组中的参数**
以下 `describe-db-parameters` 示例将检索有关指定数据库参数组的详细信息。
```
aws rds describe-db-parameters \
--db-parameter-group-name mydbpg
```
输出：
```
{
"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...
]
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[使用数据库参数组](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [DescribeDBParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameters.html)。
------
#### [ Go ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在 [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
}
```
+ 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的 [DescribeDBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters)。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [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);
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameters)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameters)。
------
#### [ Ruby ]
**适用于 Ruby 的 SDK**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameters)。
------
#### [ SAP ABAP ]
**适用于 SAP ABAP 的 SDK**
查看 GitHub，了解更多信息。在 [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.
```
+ 有关 API 详细信息，请参阅《AWS SDK for SAP ABAP API Reference》**中的 [DescribeDBParameters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [DescribeDBParameters](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparameters(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `DescribeDBSnapshots` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `DescribeDBSnapshots`。
操作示例是大型程序的代码摘录，必须在上下文中运行。在以下代码示例中，您可以查看此操作的上下文：
+ [了解基本功能](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 .NET 的 AWS SDK API Reference》**中的 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBSnapshots)。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 C\$1\$1 的 AWS SDK API Reference》**中的 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBSnapshots)。
------
#### [ CLI ]
**AWS CLI**
**示例 1：描述数据库实例的数据库快照**
以下 `describe-db-snapshots` 示例将检索有关数据库实例的数据库快照的详细信息。
```
aws rds describe-db-snapshots \
--db-snapshot-identifier mydbsnapshot
```
输出：
```
{
"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"
}
]
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[创建数据库快照](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html)。
**示例 2：查找手动拍摄的快照数量**
以下 `describe-db-snapshots` 示例使用 `--query` 选项中的 `length` 运算符来返回在特定 AWS 区域拍摄的手动快照的数量。
```
aws rds describe-db-snapshots \
--snapshot-type manual \
--query "length(*[].{DBSnapshots:SnapshotType})" \
--region eu-central-1
```
输出：
```
35
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[创建数据库快照](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [DescribeDBSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshots.html)。
------
#### [ Go ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的 [DescribeDBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBSnapshots)。
------
#### [ Ruby ]
**适用于 Ruby 的 SDK**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《适用于 Ruby 的 AWS SDK API Reference》**中的 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBSnapshots)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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)")
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [DescribeDBSnapshots](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbsnapshots(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `DescribeOrderableDBInstanceOptions` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `DescribeOrderableDBInstanceOptions`。
操作示例是大型程序的代码摘录，必须在上下文中运行。在以下代码示例中，您可以查看此操作的上下文：
+ [了解基本功能](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 .NET 的 AWS SDK API Reference》**中的 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeOrderableDBInstanceOptions)。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 C\$1\$1 的 AWS SDK API Reference》**中的 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeOrderableDBInstanceOptions)。
------
#### [ CLI ]
**AWS CLI**
**描述可订购的数据库实例选项**
以下 `describe-orderable-db-instance-options` 示例将检索有关运行 MySQL 数据库引擎的数据库实例的可订购选项的详细信息。
```
aws rds describe-orderable-db-instance-options \
--engine mysql
```
输出：
```
{
"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...
}
```
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [DescribeOrderableDBInstanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html)。
------
#### [ Go ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在 [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
}
```
+ 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的 [DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeOrderableDBInstanceOptions)。
------
#### [ SAP ABAP ]
**适用于 SAP ABAP 的 SDK**
查看 GitHub，了解更多信息。在 [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.
```
+ 有关 API 详细信息，请参阅《AWS SDK for SAP ABAP API Reference》**中的 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [DescribeOrderableDBInstanceOptions](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describeorderabledbinstanceoptions(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `GenerateRDSAuthToken` 和 AWS SDK 搭配使用
以下代码示例演示了如何使用 `GenerateRDSAuthToken`。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [AWS 代码示例存储库](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)中查找完整示例，了解如何进行设置和运行。
使用 [RdsUtilities](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rds/RdsUtilities.html) 类生成身份验证令牌。
```
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 "";
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API 参考》**中的 [GenerateRDSAuthToken](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/GenerateRDSAuthToken)。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `ModifyDBInstance` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `ModifyDBInstance`。
------
#### [ CLI ]
**AWS CLI**
**示例 1：修改数据库实例**
以下 `modify-db-instance` 示例将选项组和参数组与兼容的 Microsoft SQL Server 数据库实例相关联。`--apply-immediately` 参数使选项和参数组立即关联，而不是等到下一个维护时段。
```
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
```
输出：
```
{
"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
}
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[修改 Amazon RDS 数据库实例](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html)。
**示例 2：将 VPC 安全组与数据库实例关联**
以下 `modify-db-instance` 示例关联特定 VPC 安全组并从数据库实例中移除数据库安全组：
```
aws rds modify-db-instance \
--db-instance-identifier dbName \
--vpc-security-group-ids sg-ID
```
输出：
```
{
"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 ...
}
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[使用安全组控制访问权限](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [ModifyDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-instance.html)。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [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);
}
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的 [ModifyDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBInstance)。
------
#### [ Kotlin ]
**SDK for Kotlin**
查看 GitHub，了解更多信息。在 [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}")
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Kotlin API 参考》**中的 [ModifyDBInstance](https://sdk.amazonaws.com/kotlin/api/latest/index.html)。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `ModifyDBParameterGroup` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `ModifyDBParameterGroup`。
操作示例是大型程序的代码摘录，必须在上下文中运行。在以下代码示例中，您可以查看此操作的上下文：
+ [了解基本功能](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 .NET 的 AWS SDK API Reference》**中的 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/ModifyDBParameterGroup)。
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
查看 GitHub，了解更多信息。在 [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;
}
```
+ 有关 API 详细信息，请参阅《适用于 C\$1\$1 的 AWS SDK API Reference》**中的 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/ModifyDBParameterGroup)。
------
#### [ CLI ]
**AWS CLI**
**修改数据库参数组**
以下 `modify-db-parameter-group` 示例将更改数据库参数组中 `clr enabled` 参数的值。`--apply-immediately` 参数使数据库参数组得到立即修改，而不是等到下一个维护时段。
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-se-2017 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
输出：
```
{
"DBParameterGroupName": "test-sqlserver-se-2017"
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[修改数据库参数组中的参数](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Modifying)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [ModifyDBParameterGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-parameter-group.html)。
------
#### [ Go ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在 [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
}
}
```
+ 有关 API 详细信息，请参阅《适用于 Go 的 AWS SDK API Reference》**中的 [ModifyDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup)。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [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);
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API Reference》**中的 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBParameterGroup)。
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在 [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
```
+ 有关 API 详细信息，请参阅《AWS SDK for Python (Boto3) API Reference》**中的 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/ModifyDBParameterGroup)。
------
#### [ SAP ABAP ]
**适用于 SAP ABAP 的 SDK**
查看 GitHub，了解更多信息。在 [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.
```
+ 有关 API 详细信息，请参阅《AWS SDK for SAP ABAP API Reference》**中的 [ModifyDBParameterGroup](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)。
------
#### [ Swift ]
**适用于 Swift 的 SDK**
查看 GitHub，了解更多信息。在 [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)")
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Swift API reference》**中的 [ModifyDBParameterGroup](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/modifydbparametergroup(input:))。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 将 `RebootDBInstance` 与 AWS SDK 或 CLI 配合使用
以下代码示例演示如何使用 `RebootDBInstance`。
------
#### [ CLI ]
**AWS CLI**
**重启数据库实例**
以下 `reboot-db-instance` 示例开始重启指定的数据库实例。
```
aws rds reboot-db-instance \
--db-instance-identifier test-mysql-instance
```
输出：
```
{
"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...
}
}
```
有关更多信息，请参阅《Amazon RDS 用户指南》**中的[重启数据库实例](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html)。
+ 有关 API 详细信息，请参阅《AWS CLI 命令参考》**中的 [RebootDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-instance.html)。
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在 [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);
}
}
}
```
+ 有关 API 详细信息，请参阅《AWS SDK for Java 2.x API 参考》**中的 [RebootDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/RebootDBInstance)。
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# 适用于使用 AWS SDK 的 Amazon RDS 的场景
以下代码示例向您展示如何通过 AWS SDK 实施 Amazon RDS 中的常见场景。这些场景向您展示了如何通过调用 Amazon RDS 中的多个函数或与其他 AWS 服务结合来完成特定任务。每个场景都包含完整源代码的链接，您可以在其中找到有关如何设置和运行代码的说明。
场景以中等水平的经验为目标，可帮助您结合具体环境了解服务操作。
**Topics**
+ [创建 Aurora Serverless 工作项跟踪器](example_cross_RDSDataTracker_section.md)
# 创建 Aurora Serverless 工作项跟踪器
以下代码示例演示了如何创建用于跟踪 Amazon Aurora Serverless 数据库中的工作项，以及使用 Amazon Simple Email Service（Amazon SES）发送报告的 Web 应用程序。
------
#### [ .NET ]
**适用于 .NET 的 SDK**
展示如何使用 适用于 .NET 的 AWS SDK 通过 Amazon Simple Email Service (Amazon SES) 创建 Web 应用程序来跟踪 Amazon Aurora 数据库中的工作项和电子邮件报告。此示例使用由 React.js 构建的前端与 RESTful .NET 后端进行交互。
+ 将 React Web 应用程序与 AWS 服务集成。
+ 列出、添加、更新和删除 Aurora 表中的项目。
+ 使用 Amazon SES 以电子邮件形式发送已筛选工作项的报告。
+ 使用随附的 AWS CloudFormation 脚本部署与管理示例资源。
有关完整的源代码以及如何设置和运行的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
演示了如何创建用于跟踪和报告存储在 Amazon Aurora Serverless 数据库中的工作项的 Web 应用程序。
有关完整源代码以及如何设置可查询 Amazon Aurora Serverless 数据以及供 React 应用程序使用的 C\$1\$1 REST API 的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ Java ]
**适用于 Java 的 SDK 2.x**
展示如何创建 Web 应用程序来跟踪与报告存储与 Amazon RDS 数据库的工作项。
有关完整源代码以及如何设置查询 Amazon Aurora 无服务器数据以及供 React 应用程序使用的 Spring REST API 的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest) 上的完整示例。
有关完整的源代码以及如何设置和运行使用 JDBC API 的示例的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
展示了如何使用 适用于 JavaScript 的 AWS SDK (v3) 创建可跟踪 Amazon Aurora 数据库中的工作项，以及使用 Amazon Simple Email Service (Amazon SES) 通过电子邮件发送报告的 Web 应用程序。此示例使用由 React.js 构建的前端与 Express Node.js 后端进行交互。
+ 将 React.js Web 应用程序与 AWS 服务 集成。
+ 列出、添加以及更新 Aurora 表中的项目。
+ 使用 Amazon SES 以电子邮件形式发送已筛选工作项的报告。
+ 使用随附的 AWS CloudFormation 脚本部署与管理示例资源。
有关完整的源代码以及如何设置和运行的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
展示如何创建 Web 应用程序来跟踪与报告存储与 Amazon RDS 数据库的工作项。
有关完整源代码以及如何设置查询 Amazon Aurora 无服务器数据以及供 React 应用程序使用的 Spring REST API 的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ PHP ]
**适用于 PHP 的 SDK**
展示了如何使用 适用于 PHP 的 AWS SDK 来创建用于跟踪 Amazon RDS 数据库中的工作项，并通过 Amazon Simple Email Service (Amazon SES) 以电子邮件发送报告的 Web 应用程序。此示例使用由 React.js 构建的前端与 RESTful PHP 后端进行交互。
+ 将 React.js Web 应用程序与 AWS 服务集成。
+ 列出、添加、更新和删除 Amazon RDS 表中的项目。
+ 使用 Amazon SES 以电子邮件发送已筛选工作项的报告。
+ 使用随附的 AWS CloudFormation 脚本部署与管理示例资源。
有关完整的源代码以及如何设置和运行的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
#### [ Python ]
**适用于 Python 的 SDK（Boto3）**
演示了如何使用 适用于 Python (Boto3) 的 AWS SDK 创建可跟踪 Amazon Aurora Serverless 数据库中的工作项，以及使用 Amazon Simple Email Service (Amazon SES) 通过电子邮件发送报告的 REST 服务。此示例使用 Flask Web 框架处理 HTTP 路由，并与 React 网页集成以呈现功能齐全的 Web 应用程序。
+ 构建与 AWS 服务 集成的 Flask REST 服务。
+ 读取、写入和更新存储在 Aurora Serverless 数据库中的工作项。
+ 创建包含数据库凭证的 AWS Secrets Manager 密钥，并使用它来验证对数据库的调用。
+ 使用 Amazon SES 发送工作项的电子邮件报告。
有关完整的源代码以及如何设置和运行的说明，请参阅 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker) 上的完整示例。
**本示例中使用的服务**
+ Aurora
+ Amazon RDS
+ Amazon RDS 数据服务
+ Amazon SES
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。
# Amazon RDS 的无服务器示例
以下代码示例显示了如何将 Amazon RDS 与 AWS SDK 一起使用。
**Topics**
+ [使用 Lambda 函数连接到 Amazon RDS 数据库](example_serverless_connect_RDS_Lambda_section.md)
# 使用 Lambda 函数连接到 Amazon RDS 数据库
以下代码示例显示如何实现连接到 RDS 数据库的 Lambda 函数。该函数发出一个简单的数据库请求并返回结果。
------
#### [ .NET ]
**适用于 .NET 的 SDK**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 .NET 连接到 Amazon RDS 数据库。
```
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 ]
**适用于 Go 的 SDK V2**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Go 连接到 Amazon RDS 数据库。
```
/*
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 ]
**适用于 Java 的 SDK 2.x**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Java 连接到 Amazon RDS 数据库。
```
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 for JavaScript（v3）**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 JavaScript 连接到 Amazon RDS 数据库。
```
// 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)
}
};
```
在 Lambda 函数中使用 TypeScript 连接到 Amazon RDS 数据库。
```
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 ]
**适用于 PHP 的 SDK**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 PHP 连接到 Amazon RDS 数据库。
```
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 ]
**适用于 Python 的 SDK（Boto3）**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Python 连接到 Amazon RDS 数据库。
```
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 ]
**适用于 Ruby 的 SDK**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Ruby 连接到 Amazon RDS 数据库。
```
# 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 ]
**适用于 Rust 的 SDK**
查看 GitHub，了解更多信息。在[无服务器示例](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam)存储库中查找完整示例，并了解如何进行设置和运行。
在 Lambda 函数中使用 Rust 连接到 Amazon RDS 数据库。
```
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}")
}))
}
```
------
有关 AWS SDK 开发人员指南和代码示例的完整列表，请参阅 [将此服务与 AWS 开发工具包结合使用](CHAP_Tutorials.md#sdk-general-information-section) 本主题还包括有关入门的信息以及有关先前的 SDK 版本的详细信息。