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);
}
}
}
```
+ Para obter detalhes da API, consulte [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBInstances) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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}")
}
}
}
```
+ Consulte detalhes da API em [DescribeDBInstances](https://sdk.amazonaws.com/kotlin/api/latest/index.html) na * Referência da API AWS SDK para Kotlin*.
------
#### [ PHP ]
**SDK para PHP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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";
}
```
+ Consulte detalhes da API em [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances) na *Referência de API do AWS SDK para PHP*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBInstances](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBInstances) na *Referência da API AWS SDK para Python (Boto3)*.
------
#### [ Ruby ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBInstances) na *Referência de API do AWS SDK para Ruby*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Para obter detalhes da API, consulte [DescribeDBInstances](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbinstances(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `DescribeDBParameterGroups` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `DescribeDBParameterGroups`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação no contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameterGroups) na *Referência da API AWS SDK para .NET*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameterGroups) na *Referência da API AWS SDK para C\$1\$1*.
------
#### [ CLI ]
**AWS CLI**
**Como descrever um grupo de parâmetros de banco de dados**
O exemplo de `describe-db-parameter-groups` a seguir recupera detalhes sobre os grupos de parâmetros de banco de dados.
```
aws rds describe-db-parameter-groups
```
Resultado:
```
{
"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...
]
}
```
Para obter mais informações, consulte [ Como trabalhar com grupos de parâmetros de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameter-groups.html) na *Referência de comandos da AWS CLI*.
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups) na *Referência da API AWS SDK para Go*.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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);
}
}
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameterGroups) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameterGroups) na *referência da API do AWS SDK para Python (Boto3)*.
------
#### [ Ruby ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameterGroups) na *Referência da API AWS SDK para Ruby*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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.
```
+ Para ver detalhes da API, consulte [DescribeDBParameterGroups](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) na *Referência de API do SDK da AWS para SAP ABAP*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Para obter detalhes da API, consulte [DescribeDBParameterGroups](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparametergroups(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `DescribeDBParameters` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `DescribeDBParameters`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação no contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBParameters](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameters) na *Referência da API AWS SDK para .NET*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameters) na *Referência da API AWS SDK para C\$1\$1*.
------
#### [ CLI ]
**AWS CLI**
**Como descrever os parâmetros de um grupo de parâmetros de banco de dados**
O exemplo de `describe-db-parameters` a seguir recupera detalhes sobre o grupo de parâmetros de banco de dados especificado.
```
aws rds describe-db-parameters \
--db-parameter-group-name mydbpg
```
Resultado:
```
{
"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...
]
}
```
Para obter mais informações, consulte [ Como trabalhar com grupos de parâmetros de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [DescribeDBParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameters.html) na *Referência de comandos da AWS CLI*.
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
```
+ Consulte detalhes da API em [DescribeDBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters) na *Referência da API AWS SDK para Go*.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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);
}
}
```
+ Consulte detalhes da API em [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameters) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBParameters](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameters) na *Referência da API AWS SDK para Python (Boto3)*.
------
#### [ Ruby ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameters) na *Referência da API AWS SDK para Ruby*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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.
```
+ Para ver detalhes da API, consulte [DescribeDBParameters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) na *Referência de API do SDK da AWS para SAP ABAP*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
```
+ Para obter detalhes da API, consulte [DescribeDBParameter](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparameters(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `DescribeDBSnapshots` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `DescribeDBSnapshots`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação no contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBSnapshots) na *Referência da API AWS SDK para .NET*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBSnapshots) na *Referência da API AWS SDK para C\$1\$1*.
------
#### [ CLI ]
**AWS CLI**
**Exemplo 1: como descrever um snapshot de banco de dados de uma instância de banco de dados**
O exemplo de `describe-db-snapshots` a seguir recupera os detalhes de um snapshot de banco de dados para uma instância de banco de dados.
```
aws rds describe-db-snapshots \
--db-snapshot-identifier mydbsnapshot
```
Resultado:
```
{
"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"
}
]
}
```
Para obter mais informações, consulte [Criar um snapshot de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) no *Guia do usuário do Amazon RDS*.
**Exemplo 2: como encontrar o número de snapshots manuais criados**
O exemplo de `describe-db-snapshots` a seguir usa o operador `length` na opção `--query` para retornar o número de snapshots manuais que foram criados em uma determinada região da AWS.
```
aws rds describe-db-snapshots \
--snapshot-type manual \
--query "length(*[].{DBSnapshots:SnapshotType})" \
--region eu-central-1
```
Resultado:
```
35
```
Para obter mais informações, consulte [Criar um snapshot de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [DescribeDBSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshots.html) na *Referência de comandos da AWS CLI*.
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Consulte detalhes da API em [DescribeDBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots) na *Referência da API AWS SDK para Go*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBSnapshots) na *referência da API do AWS SDK para Python (Boto3)*.
------
#### [ Ruby ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBSnapshots) na *Referência da API AWS SDK para Ruby*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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)")
}
}
```
+ Para obter detalhes da API, consulte [DescribeDBSnapshots](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbsnapshots(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `DescribeOrderableDBInstanceOptions` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `DescribeOrderableDBInstanceOptions`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação no contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeOrderableDBInstanceOptions) na *Referência da API AWS SDK para .NET*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeOrderableDBInstanceOptions) na *Referência da API AWS SDK para C\$1\$1*.
------
#### [ CLI ]
**AWS CLI**
**Como descrever as opções de instância solicitável do banco de dados**
O exemplo de `describe-orderable-db-instance-options` a seguir recupera detalhes sobre as opções que podem ser solicitadas em uma instância de banco de dados que executa o mecanismo de banco de dados do MySQL.
```
aws rds describe-orderable-db-instance-options \
--engine mysql
```
Resultado:
```
{
"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...
}
```
+ Consulte detalhes da API em [DescribeOrderableDBInstanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html) na *Referência de comandos da AWS CLI*.
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
```
+ Consulte detalhes da API em [DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions) na *Referência da API AWS SDK para Go*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeOrderableDBInstanceOptions) na *Referência da API AWS SDK para Python (Boto3)*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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.
```
+ Para ver detalhes da API, consulte [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) na *Referência de API do SDK da AWS para SAP ABAP*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Para obter detalhes da API, consulte [DescribeOrderableDBInstanceOptions](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describeorderabledbinstanceoptions(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `GenerateRDSAuthToken` com um SDK da AWS
O código de exemplo a seguir mostra como usar `GenerateRDSAuthToken`.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples).
Use a classe [RdsUtilities](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rds/RdsUtilities.html) para gerar um token de autenticação.
```
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 "";
}
}
```
+ Para ter detalhes da API, consulte [GenerateRDSAuthToken](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/GenerateRDSAuthToken) na *Referência de API do AWS SDK for Java 2.x*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `ModifyDBInstance` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `ModifyDBInstance`.
------
#### [ CLI ]
**AWS CLI**
**Exemplo 1: Como modificar uma instância de banco de dados**
O exemplo de `modify-db-instance` a seguir associa um grupo de opção e um grupo de parâmetros a uma instância de banco de dados do Microsoft SQL Server compatível. O parâmetro `--apply-immediately` faz com que os grupos de opção e parâmetro sejam associados imediatamente em vez de ter que esperar a próxima janela de manutenção.
```
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
```
Resultado:
```
{
"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
}
}
```
Para obter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html) no *Guia do usuário do Amazon RDS*.
**Exemplo 2: Como associar um grupo de segurança da VPC a uma instância de banco de dados**
O seguinte exemplo de `modify-db-instance` associa um grupo de segurança da VPC específico e remove grupos de segurança de banco de dados da instância de banco de dados:
```
aws rds modify-db-instance \
--db-instance-identifier dbName \
--vpc-security-group-ids sg-ID
```
Resultado:
```
{
"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 ...
}
}
```
Para ter mais informações, consulte [Controlar acesso com grupos de segurança](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [ModifyDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-instance.html) na *Referência de comandos da AWS CLI*.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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);
}
}
}
```
+ Consulte detalhes da API em [ModifyDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBInstance) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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}")
}
}
```
+ Para ter detalhes da API, consulte [ModifyDBInstance](https://sdk.amazonaws.com/kotlin/api/latest/index.html) na *Referência de API do AWS SDK para Kotlin*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `ModifyDBParameterGroup` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `ModifyDBParameterGroup`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação no contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/ModifyDBParameterGroup) na *Referência da API AWS SDK para .NET*.
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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;
}
```
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/ModifyDBParameterGroup) na *Referência da API AWS SDK para C\$1\$1*.
------
#### [ CLI ]
**AWS CLI**
**Como modificar um grupo de parâmetros de banco de dados**
O exemplo de `modify-db-parameter-group` a seguir altera o valor do parâmetro `clr enabled` em um grupo de parâmetros de banco de dados. O parâmetro `--apply-immediately` faz com que o grupo de parâmetros de banco de dados seja modificado imediatamente em vez de ter que esperar a próxima janela de manutenção.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-se-2017 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
Resultado:
```
{
"DBParameterGroupName": "test-sqlserver-se-2017"
}
```
Para obter mais informações, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Modifying) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-parameter-group.html) na *Referência de comandos da AWS CLI*.
------
#### [ Go ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
}
}
```
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup) na *Referência da API AWS SDK para Go*.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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);
}
}
```
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBParameterGroup) na *Referência da API AWS SDK for Java 2.x*.
------
#### [ Python ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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
```
+ Consulte detalhes da API em [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/ModifyDBParameterGroup) na *Referência da API AWS SDK para Python (Boto3)*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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.
```
+ Para ver detalhes da API, consulte [ModifyDBParameterGroup](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) na *Referência de API do SDK da AWS para SAP ABAP*.
------
#### [ Swift ]
**SDK para Swift**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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)")
}
}
```
+ Para obter detalhes da API, consulte [ModifyDBParameterGroup](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/modifydbparametergroup(input:)) na *Referência de API do AWS SDK para Swift*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Usar `RebootDBInstance` com o AWS SDK ou a CLI
Os exemplos de código a seguir mostram como usar o `RebootDBInstance`.
------
#### [ CLI ]
**AWS CLI**
**Como reinicializar uma instância de banco de dados**
O exemplo de `reboot-db-instance` a seguir inicia uma reinicialização da instância de banco de dados especificada.
```
aws rds reboot-db-instance \
--db-instance-identifier test-mysql-instance
```
Resultado:
```
{
"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...
}
}
```
Para obter mais informações, consulte [Reinicializar uma instância de banco de dados](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html) no *Guia do usuário do Amazon RDS*.
+ Consulte detalhes da API em [RebootDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-instance.html) na *Referência de comandos da AWS CLI*.
------
#### [ Java ]
**SDK para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWSCode Examples Repository](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);
}
}
}
```
+ Para ter detalhes da API, consulte [RebootDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/RebootDBInstance) na *Referência de API do AWS SDK for Java 2.x*.
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Cenários do Amazon RDS usando AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns no Amazon RDS com AWS SDKs. Esses casos mostram como realizar tarefas específicas chamando várias funções dentro do Amazon RDS ou combinadas com outros Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Crie um rastreador de itens de trabalho do Aurora Sem Servidor](example_cross_RDSDataTracker_section.md)
# Crie um rastreador de itens de trabalho do Aurora Sem Servidor
Os exemplos de código a seguir mostram como criar uma aplicação Web que rastreia os itens de trabalho em um banco de dados do Amazon Aurora Sem Servidor e usa o Amazon Simple Email Service (Amazon SES) para enviar relatórios.
------
#### [ .NET ]
**SDK para .NET**
Mostra como usar o AWS SDK para .NET para desenvolver uma aplicação Web que monitora itens de trabalho no banco de dados do Amazon Aurora e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end criado com React.js para interagir com um back-end .NET RESTful.
+ Integre uma aplicação Web do React com os serviços da AWS.
+ Liste, adicione, atualize e exclua itens em uma tabela do Aurora.
+ Envie um relatório por e-mail dos itens de trabalho filtrados usando o Amazon SES.
+ Implante e gerencie recursos de exemplo com o script do AWS CloudFormation incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar o exemplo, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker).
**Serviços utilizados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Mostra como criar uma aplicação Web que rastreia e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon Aurora Sem Servidor.
Para obter o código-fonte completo e instruções sobre como configurar a API REST de C\$1\$1 que consulta os dados do Amazon Aurora Sem Servidor e para uso por uma aplicação React, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Java ]
**SDK para Java 2.x**
Mostra como construir uma aplicação Web que monitora e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon RDS.
Para obter o código-fonte completo e instruções sobre como configurar a API Spring REST que consulta os dados do Amazon Aurora Sem Servidor e para uso por uma aplicação React, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest).
Para obter o código-fonte completo e instruções sobre como configurar e executar o exemplo que utiliza a API JDBC, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Mostra como usar o AWS SDK para JavaScript (v3) para criar uma aplicação Web que rastreia itens de trabalho em um banco de dados do Amazon Aurora e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end criado com React.js para interagir com um back-end Node.js Express.
+ Integre uma aplicação Web React.js com Serviços da AWS.
+ Liste, adicione e atualize itens em uma tabela do Aurora.
+ Use o Amazon SES para enviar um relatório por e-mail dos itens de trabalho filtrados.
+ Implante e gerencie recursos de exemplo com o script do AWS CloudFormation incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar o exemplo, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app).
**Serviços utilizados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Kotlin ]
**SDK para Kotlin**
Mostra como construir uma aplicação Web que monitora e gera relatórios sobre itens de trabalho armazenados em um banco de dados do Amazon RDS.
Para obter o código-fonte completo e instruções sobre como configurar a API Spring REST que consulta os dados do Amazon Aurora Sem Servidor e para uso por uma aplicação React, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds).
**Serviços usados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ PHP ]
**SDK para PHP**
Mostra como usar o AWS SDK para PHP para construir uma aplicação Web que monitora itens de trabalho no banco de dados do Amazon RDS e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa um front-end construído com React.js para interagir com um back-end PHP RESTful.
+ Integre uma aplicação Web React.js com os serviços da AWS.
+ Liste, adicione, atualize e exclua itens em uma tabela do Amazon RDS.
+ Envie um relatório por e-mail dos itens de trabalho filtrados usando o Amazon SES.
+ Implante e gerencie recursos de exemplo com o script do AWS CloudFormation incluído.
Para obter o código-fonte completo e instruções sobre como configurar e executar o exemplo, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker).
**Serviços utilizados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
#### [ Python ]
**SDK para Python (Boto3).**
Mostra como usar o AWS SDK para Python (Boto3) para criar um serviço REST que rastreia itens de trabalho no banco de dados do Amazon Aurora Sem Servidor e envia relatórios por e-mail usando o Amazon Simple Email Service (Amazon SES). Este exemplo usa o framework da Web do Flask para lidar com o roteamento HTTP e se integra a uma página da Web do React para apresentar uma aplicação Web totalmente funcional.
+ Crie um serviço REST do Flask que se integre a Serviços da AWS.
+ Leia, grave e atualize itens de trabalho armazenados em um banco de dados do Aurora Sem Servidor.
+ Crie um segredo do AWS Secrets Manager que contenha credenciais do banco de dados e use-o a fim de autenticar chamadas para o banco de dados.
+ Use o Amazon SES para enviar relatórios por e-mail de itens de trabalho.
Para obter o código-fonte completo e instruções sobre como configurar e executar o exemplo, consulte o exemplo completo no [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker).
**Serviços utilizados neste exemplo**
+ Aurora
+ Amazon RDS
+ Serviços de dados do Amazon RDS
+ Amazon SES
------
Para obter uma lista completa dos Guias do desenvolvedor do AWS SDK e exemplos de código, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.
# Exemplos de tecnologia sem servidor para o Amazon RDS
Os exemplos de código a seguir mostram como usar o Amazon RDS com SDKs da AWS.
**Topics**
+ [Como se conectar a um banco de dados do Amazon RDS em uma função do Lambda](example_serverless_connect_RDS_Lambda_section.md)
# Como se conectar a um banco de dados do Amazon RDS em uma função do Lambda
Os exemplos de código a seguir mostram como implementar uma função do Lambda que se conecte a um banco de dados do RDS. A função faz uma solicitação simples ao banco de dados e exibe o resultado.
------
#### [ .NET ]
**SDK para .NET**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando .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 ]
**SDK para Go V2**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 para Java 2.x**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 para JavaScript (v3)**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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)
}
};
```
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 ]
**SDK para PHP**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 ]
**SDK para Python (Boto3).**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 ]
**SDK para Ruby**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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 para Rust**
Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos [Exemplos sem servidor](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam).
Conectar-se a um banco de dados do Amazon RDS em uma função do Lambda usando 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}")
}))
}
```
------
Para ver uma lista completa dos guias de desenvolvedor e exemplos de código do SDK da AWS, consulte [Using this service with an AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Este tópico também inclui informações sobre como começar e detalhes sobre versões anteriores do SDK.