instanceList = response.dbInstances();
for (DBInstance instance : instanceList) {
System.out.println("Instance ARN is: " + instance.dbInstanceArn());
System.out.println("The Engine is " + instance.engine());
System.out.println("Connection endpoint is" + instance.endpoint().address());
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBInstances)를 참조하십시오.
------
#### [ Kotlin ]
**SDK for Kotlin**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
suspend fun describeInstances() {
RdsClient.fromEnvironment { region = "us-west-2" }.use { rdsClient ->
val response = rdsClient.describeDbInstances(DescribeDbInstancesRequest {})
response.dbInstances?.forEach { instance ->
println("Instance Identifier is ${instance.dbInstanceIdentifier}")
println("The Engine is ${instance.engine}")
println("Connection endpoint is ${instance.endpoint?.address}")
}
}
}
```
+ API 세부 정보는 *AWS SDK for Kotlin API 참조*의 [DescribeDBInstances](https://sdk.amazonaws.com/kotlin/api/latest/index.html)를 참조하세요.
------
#### [ PHP ]
**SDK for PHP**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
require __DIR__ . '/vendor/autoload.php';
use Aws\Exception\AwsException;
//Create an RDSClient
$rdsClient = new Aws\Rds\RdsClient([
'region' => 'us-east-2'
]);
try {
$result = $rdsClient->describeDBInstances();
foreach ($result['DBInstances'] as $instance) {
print('DB Identifier: ' . $instance['DBInstanceIdentifier']);
print('
Endpoint: ' . $instance['Endpoint']["Address"]
. ':' . $instance['Endpoint']["Port"]);
print('
Current Status: ' . $instance["DBInstanceStatus"]);
print('
');
}
print(" Raw Result ");
var_dump($result);
} catch (AwsException $e) {
echo $e->getMessage();
echo "\n";
}
```
+ API 세부 정보는 *AWS SDK for PHP API 참조*의 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForPHPV3/rds-2014-10-31/DescribeDBInstances)를 참조하세요.
------
#### [ Python ]
**SDK for Python(Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_db_instance(self, instance_id):
"""
Gets data about a DB instance.
:param instance_id: The ID of the DB instance to retrieve.
:return: The retrieved DB instance.
"""
try:
response = self.rds_client.describe_db_instances(
DBInstanceIdentifier=instance_id
)
db_inst = response["DBInstances"][0]
except ClientError as err:
if err.response["Error"]["Code"] == "DBInstanceNotFound":
logger.info("Instance %s does not exist.", instance_id)
else:
logger.error(
"Couldn't get DB instance %s. Here's why: %s: %s",
instance_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return db_inst
```
+ API 세부 정보는 *AWSSDK for Python (Boto3) API 참조*의 [DescribeDBInstances](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBInstances)를 참조하십시오.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) DB instances.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all DB instances, or nil if error.
def list_instances(rds_resource)
db_instances = []
rds_resource.db_instances.each do |i|
db_instances.append({
"name": i.id,
"status": i.db_instance_status
})
end
db_instances
rescue Aws::Errors::ServiceError => e
puts "Couldn't list instances:\n#{e.message}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby API 참조*의 [DescribeDBInstances](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBInstances)를 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Wait until the specified database is available to use.
///
/// - Parameter instanceIdentifier: The database instance identifier of the
/// database to wait for.
func waitUntilDBInstanceReady(instanceIdentifier: String) async -> RDSClientTypes.Endpoint? {
do {
putString("Waiting for the database instance to be ready to use. This may take 10 minutes or more...")
while true {
let output = try await rdsClient.describeDBInstances(
input: DescribeDBInstancesInput(
dbInstanceIdentifier: instanceIdentifier
)
)
guard let instanceList = output.dbInstances else {
continue
}
for instance in instanceList {
let status = instance.dbInstanceStatus
guard let status else {
print("\nUnable to determine the status.")
continue
}
if status.contains("available") {
return instance.endpoint
} else {
putString(".")
do {
try await Task.sleep(for: .seconds(15))
} catch {
print("*** Error pausing the task!")
}
}
}
}
} catch {
print("*** Unable to wait until the database is ready: \(error.localizedDescription)")
return nil
}
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [DescribeDBInstances](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbinstances(input:))를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `DescribeDBParameterGroups` 사용
다음 코드 예시는 `DescribeDBParameterGroups`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
///
/// Get descriptions of DB parameter groups.
///
/// Optional name of the DB parameter group to describe.
/// The list of DB parameter group descriptions.
public async Task> DescribeDBParameterGroups(string name = null)
{
var response = await _amazonRDS.DescribeDBParameterGroupsAsync(
new DescribeDBParameterGroupsRequest()
{
DBParameterGroupName = name
});
return response.DBParameterGroups;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameterGroups)를 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::DescribeDBParameterGroupsRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
Aws::RDS::Model::DescribeDBParameterGroupsOutcome outcome =
client.DescribeDBParameterGroups(request);
if (outcome.IsSuccess()) {
std::cout << "DB parameter group named '" <<
PARAMETER_GROUP_NAME << "' already exists." << std::endl;
dbParameterGroupFamily = outcome.GetResult().GetDBParameterGroups()[0].GetDBParameterGroupFamily();
}
else {
std::cerr << "Error with RDS::DescribeDBParameterGroups. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameterGroups)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**DB 파라미터 그룹을 설명하려면**
다음 `describe-db-parameter-groups` 예시에서는 DB 파라미터 그룹의 세부 정보를 가져옵니다.
```
aws rds describe-db-parameter-groups
```
출력:
```
{
"DBParameterGroups": [
{
"DBParameterGroupName": "default.aurora-mysql5.7",
"DBParameterGroupFamily": "aurora-mysql5.7",
"Description": "Default parameter group for aurora-mysql5.7",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-mysql5.7"
},
{
"DBParameterGroupName": "default.aurora-postgresql9.6",
"DBParameterGroupFamily": "aurora-postgresql9.6",
"Description": "Default parameter group for aurora-postgresql9.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora-postgresql9.6"
},
{
"DBParameterGroupName": "default.aurora5.6",
"DBParameterGroupFamily": "aurora5.6",
"Description": "Default parameter group for aurora5.6",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.aurora5.6"
},
{
"DBParameterGroupName": "default.mariadb10.1",
"DBParameterGroupFamily": "mariadb10.1",
"Description": "Default parameter group for mariadb10.1",
"DBParameterGroupArn": "arn:aws:rds:us-east-1:123456789012:pg:default.mariadb10.1"
},
...some output truncated...
]
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 파라미터 그룹 작업](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeDBParameterGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameter-groups.html)를 참조하세요.
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameterGroup gets a DB parameter group by name.
func (instances *DbInstances) GetParameterGroup(ctx context.Context, parameterGroupName string) (
*types.DBParameterGroup, error) {
output, err := instances.RdsClient.DescribeDBParameterGroups(
ctx, &rds.DescribeDBParameterGroupsInput{
DBParameterGroupName: aws.String(parameterGroupName),
})
if err != nil {
var notFoundError *types.DBParameterGroupNotFoundFault
if errors.As(err, ¬FoundError) {
log.Printf("Parameter group %v does not exist.\n", parameterGroupName)
err = nil
} else {
log.Printf("Error getting parameter group %v: %v\n", parameterGroupName, err)
}
return nil, err
} else {
return &output.DBParameterGroups[0], err
}
}
```
+ API 세부 정보는 *AWS SDK for Go API 참조*의 [DescribeDBParameterGroups](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameterGroups)를 참조하십시오.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
public static void describeDbParameterGroups(RdsClient rdsClient, String dbGroupName) {
try {
DescribeDbParameterGroupsRequest groupsRequest = DescribeDbParameterGroupsRequest.builder()
.dbParameterGroupName(dbGroupName)
.maxRecords(20)
.build();
DescribeDbParameterGroupsResponse response = rdsClient.describeDBParameterGroups(groupsRequest);
List groups = response.dbParameterGroups();
for (DBParameterGroup group : groups) {
System.out.println("The group name is " + group.dbParameterGroupName());
System.out.println("The group description is " + group.description());
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameterGroups)를 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_parameter_group(self, parameter_group_name):
"""
Gets a DB parameter group.
:param parameter_group_name: The name of the parameter group to retrieve.
:return: The parameter group.
"""
try:
response = self.rds_client.describe_db_parameter_groups(
DBParameterGroupName=parameter_group_name
)
parameter_group = response["DBParameterGroups"][0]
except ClientError as err:
if err.response["Error"]["Code"] == "DBParameterGroupNotFound":
logger.info("Parameter group %s does not exist.", parameter_group_name)
else:
logger.error(
"Couldn't get parameter group %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return parameter_group
```
+ API 세부 정보는 *AWSSDK for Python (Boto3) API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameterGroups)를 참조하십시오.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) parameter groups.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all parameter groups, or nil if error.
def list_parameter_groups(rds_resource)
parameter_groups = []
rds_resource.db_parameter_groups.each do |p|
parameter_groups.append({
"name": p.db_parameter_group_name,
"description": p.description
})
end
parameter_groups
rescue Aws::Errors::ServiceError => e
puts "Couldn't list parameter groups:\n #{e.message}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameterGroups)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub에 더 많은 내용이 있습니다. [AWS코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
" iv_dbparametergroupname = 'mydbparametergroup'
TRY.
oo_result = lo_rds->describedbparametergroups(
iv_dbparametergroupname = iv_dbparametergroupname ).
MESSAGE 'DB parameter group retrieved.' TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [DescribeDBParameterGroups](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)를 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Get descriptions of the database parameter groups matching the given
/// name.
///
/// - Parameter groupName: The name of the parameter group to describe.
///
/// - Returns: An array of [RDSClientTypes.DBParameterGroup] objects
/// describing the parameter group.
func describeDBParameterGroups(groupName: String) async -> [RDSClientTypes.DBParameterGroup]? {
do {
let output = try await rdsClient.describeDBParameterGroups(
input: DescribeDBParameterGroupsInput(
dbParameterGroupName: groupName
)
)
return output.dbParameterGroups
} catch {
print("*** Error getting the database parameter group's details: \(error.localizedDescription)")
return nil
}
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [DescribeDBParameterGroups](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparametergroups(input:))를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `DescribeDBParameters` 사용
다음 코드 예시는 `DescribeDBParameters`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
///
/// Get a list of DB parameters from a specific parameter group.
///
/// Name of a specific DB parameter group.
/// Optional source for selecting parameters.
/// List of parameter values.
public async Task> DescribeDBParameters(string dbParameterGroupName, string source = null)
{
var results = new List();
var paginateParameters = _amazonRDS.Paginators.DescribeDBParameters(
new DescribeDBParametersRequest()
{
DBParameterGroupName = dbParameterGroupName,
Source = source
});
// Get the entire list using the paginator.
await foreach (var parameters in paginateParameters.Parameters)
{
results.Add(parameters);
}
return results;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBParameters) 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
//! Routine which gets DB parameters using the 'DescribeDBParameters' api.
/*!
\sa getDBParameters()
\param parameterGroupName: The name of the parameter group.
\param namePrefix: Prefix string to filter results by parameter name.
\param source: A source such as 'user', ignored if empty.
\param parametersResult: Vector of 'Parameter' objects returned by the routine.
\param client: 'RDSClient' instance.
\return bool: Successful completion.
*/
bool AwsDoc::RDS::getDBParameters(const Aws::String ¶meterGroupName,
const Aws::String &namePrefix,
const Aws::String &source,
Aws::Vector ¶metersResult,
const Aws::RDS::RDSClient &client) {
Aws::String marker;
do {
Aws::RDS::Model::DescribeDBParametersRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
if (!marker.empty()) {
request.SetMarker(marker);
}
if (!source.empty()) {
request.SetSource(source);
}
Aws::RDS::Model::DescribeDBParametersOutcome outcome =
client.DescribeDBParameters(request);
if (outcome.IsSuccess()) {
const Aws::Vector ¶meters =
outcome.GetResult().GetParameters();
for (const Aws::RDS::Model::Parameter ¶meter: parameters) {
if (!namePrefix.empty()) {
if (parameter.GetParameterName().find(namePrefix) == 0) {
parametersResult.push_back(parameter);
}
}
else {
parametersResult.push_back(parameter);
}
}
marker = outcome.GetResult().GetMarker();
}
else {
std::cerr << "Error with RDS::DescribeDBParameters. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
} while (!marker.empty());
return true;
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBParameters)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**DB 파라미터 그룹의 파라미터를 설명하려면**
다음 `describe-db-parameters` 예시에서는 지정된 DB 파라미터 그룹의 세부 정보를 가져옵니다.
```
aws rds describe-db-parameters \
--db-parameter-group-name mydbpg
```
출력:
```
{
"Parameters": [
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
{
"ParameterName": "auto_generate_certs",
"Description": "Controls whether the server autogenerates SSL key and certificate files in the data directory, if they do not already exist.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false,
"ApplyMethod": "pending-reboot"
},
...some output truncated...
]
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 파라미터 그룹 작업](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeDBParameters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-parameters.html)를 참조하세요.
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetParameters gets the parameters that are contained in a DB parameter group.
func (instances *DbInstances) GetParameters(ctx context.Context, parameterGroupName string, source string) (
[]types.Parameter, error) {
var output *rds.DescribeDBParametersOutput
var params []types.Parameter
var err error
parameterPaginator := rds.NewDescribeDBParametersPaginator(instances.RdsClient,
&rds.DescribeDBParametersInput{
DBParameterGroupName: aws.String(parameterGroupName),
Source: aws.String(source),
})
for parameterPaginator.HasMorePages() {
output, err = parameterPaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get parameters for %v: %v\n", parameterGroupName, err)
break
} else {
params = append(params, output.Parameters...)
}
}
return params, err
}
```
+ API 세부 정보는 *AWS SDK for Go API 참조*의 [DescribeDBParameters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBParameters)를 참조하십시오.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
// Retrieve parameters in the group.
public static void describeDbParameters(RdsClient rdsClient, String dbGroupName, int flag) {
try {
DescribeDbParametersRequest dbParameterGroupsRequest;
if (flag == 0) {
dbParameterGroupsRequest = DescribeDbParametersRequest.builder()
.dbParameterGroupName(dbGroupName)
.build();
} else {
dbParameterGroupsRequest = DescribeDbParametersRequest.builder()
.dbParameterGroupName(dbGroupName)
.source("user")
.build();
}
DescribeDbParametersResponse response = rdsClient.describeDBParameters(dbParameterGroupsRequest);
List dbParameters = response.parameters();
String paraName;
for (Parameter para : dbParameters) {
// Only print out information about either auto_increment_offset or
// auto_increment_increment.
paraName = para.parameterName();
if ((paraName.compareTo("auto_increment_offset") == 0)
|| (paraName.compareTo("auto_increment_increment ") == 0)) {
System.out.println("*** The parameter name is " + paraName);
System.out.println("*** The parameter value is " + para.parameterValue());
System.out.println("*** The parameter data type is " + para.dataType());
System.out.println("*** The parameter description is " + para.description());
System.out.println("*** The parameter allowed values is " + para.allowedValues());
}
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeDBParameters)를 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_parameters(self, parameter_group_name, name_prefix="", source=None):
"""
Gets the parameters that are contained in a DB parameter group.
:param parameter_group_name: The name of the parameter group to query.
:param name_prefix: When specified, the retrieved list of parameters is filtered
to contain only parameters that start with this prefix.
:param source: When specified, only parameters from this source are retrieved.
For example, a source of 'user' retrieves only parameters that
were set by a user.
:return: The list of requested parameters.
"""
try:
kwargs = {"DBParameterGroupName": parameter_group_name}
if source is not None:
kwargs["Source"] = source
parameters = []
paginator = self.rds_client.get_paginator("describe_db_parameters")
for page in paginator.paginate(**kwargs):
parameters += [
p
for p in page["Parameters"]
if p["ParameterName"].startswith(name_prefix)
]
except ClientError as err:
logger.error(
"Couldn't get parameters for %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return parameters
```
+ API 세부 정보는 *AWSSDK for Python (Boto3) API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBParameters)를 참조하십시오.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) parameter groups.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return [Array, nil] List of all parameter groups, or nil if error.
def list_parameter_groups(rds_resource)
parameter_groups = []
rds_resource.db_parameter_groups.each do |p|
parameter_groups.append({
"name": p.db_parameter_group_name,
"description": p.description
})
end
parameter_groups
rescue Aws::Errors::ServiceError => e
puts "Couldn't list parameter groups:\n #{e.message}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBParameters) 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub에 더 많은 내용이 있습니다. [AWS코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
" iv_dbparametergroupname = 'mydbparametergroup'
" iv_source = 'user' (optional - filters by parameter source)
TRY.
oo_result = lo_rds->describedbparameters(
iv_dbparametergroupname = iv_dbparametergroupname
iv_source = iv_source ).
DATA(lv_param_count) = lines( oo_result->get_parameters( ) ).
MESSAGE |Retrieved { lv_param_count } parameters.| TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [DescribeDBParameters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)를 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Returns the detailed parameter list for the specified database
/// parameter group.
///
/// - Parameters:
/// - groupName: The name of the parameter group to return parameters for.
/// - source: The types of parameters to return (`user`, `system`, or
/// `engine-default`).
///
/// - Returns: An array of `RdSClientTypes.Parameter` objects, each
/// describing one of the group's parameters.
func describeDBParameters(groupName: String, source: String? = nil) async -> [RDSClientTypes.Parameter] {
var parameterList: [RDSClientTypes.Parameter] = []
do {
let pages = rdsClient.describeDBParametersPaginated(
input: DescribeDBParametersInput(
dbParameterGroupName: groupName,
source: source
)
)
for try await page in pages {
guard let parameters = page.parameters else {
return []
}
parameterList += parameters
}
} catch {
print("*** Error getting database parameters: \(error.localizedDescription)")
return []
}
return parameterList
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [DescribeDBParameters](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbparameters(input:))를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `DescribeDBSnapshots` 사용
다음 코드 예시는 `DescribeDBSnapshots`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
///
/// Return a list of DB snapshots for a particular DB instance.
///
/// DB instance identifier.
/// List of DB snapshots.
public async Task> DescribeDBSnapshots(string dbInstanceIdentifier)
{
var results = new List();
var snapshotsPaginator = _amazonRDS.Paginators.DescribeDBSnapshots(
new DescribeDBSnapshotsRequest()
{
DBInstanceIdentifier = dbInstanceIdentifier
});
// Get the entire list using the paginator.
await foreach (var snapshots in snapshotsPaginator.DBSnapshots)
{
results.Add(snapshots);
}
return results;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeDBSnapshots)를 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::DescribeDBSnapshotsRequest request;
request.SetDBSnapshotIdentifier(snapshotID);
Aws::RDS::Model::DescribeDBSnapshotsOutcome outcome =
client.DescribeDBSnapshots(request);
if (outcome.IsSuccess()) {
snapshot = outcome.GetResult().GetDBSnapshots()[0];
}
else {
std::cerr << "Error with RDS::DescribeDBSnapshots. "
<< outcome.GetError().GetMessage()
<< std::endl;
cleanUpResources(PARAMETER_GROUP_NAME, DB_INSTANCE_IDENTIFIER, client);
return false;
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeDBSnapshots)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**예 1: DB 인스턴스의 DB 스냅샷을 설명하려면**
다음 `describe-db-snapshots` 예시에서는 DB 인스턴스의 DB 스냅샷에 대한 세부 정보를 가져옵니다.
```
aws rds describe-db-snapshots \
--db-snapshot-identifier mydbsnapshot
```
출력:
```
{
"DBSnapshots": [
{
"DBSnapshotIdentifier": "mydbsnapshot",
"DBInstanceIdentifier": "mysqldb",
"SnapshotCreateTime": "2018-02-08T22:28:08.598Z",
"Engine": "mysql",
"AllocatedStorage": 20,
"Status": "available",
"Port": 3306,
"AvailabilityZone": "us-east-1f",
"VpcId": "vpc-6594f31c",
"InstanceCreateTime": "2018-02-08T22:24:55.973Z",
"MasterUsername": "mysqladmin",
"EngineVersion": "5.6.37",
"LicenseModel": "general-public-license",
"SnapshotType": "manual",
"OptionGroupName": "default:mysql-5-6",
"PercentProgress": 100,
"StorageType": "gp2",
"Encrypted": false,
"DBSnapshotArn": "arn:aws:rds:us-east-1:123456789012:snapshot:mydbsnapshot",
"IAMDatabaseAuthenticationEnabled": false,
"ProcessorFeatures": [],
"DbiResourceId": "db-AKIAIOSFODNN7EXAMPLE"
}
]
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 스냅샷 생성](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html)을 참조하세요.
**예시 2: 생성한 수동 스냅샷의 수 확인**
다음 `describe-db-snapshots` 예시에서는 `--query` 옵션의 `length` 연산자를 사용하여 특정 AWS 리전에서 생성된 수동 스냅샷의 수를 반환합니다.
```
aws rds describe-db-snapshots \
--snapshot-type manual \
--query "length(*[].{DBSnapshots:SnapshotType})" \
--region eu-central-1
```
출력:
```
35
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 스냅샷 생성](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateSnapshot.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeDBSnapshots](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-db-snapshots.html)를 참조하세요.
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetSnapshot gets a DB instance snapshot.
func (instances *DbInstances) GetSnapshot(ctx context.Context, snapshotName string) (*types.DBSnapshot, error) {
output, err := instances.RdsClient.DescribeDBSnapshots(ctx,
&rds.DescribeDBSnapshotsInput{
DBSnapshotIdentifier: aws.String(snapshotName),
})
if err != nil {
log.Printf("Couldn't get snapshot %v: %v\n", snapshotName, err)
return nil, err
} else {
return &output.DBSnapshots[0], nil
}
}
```
+ API 세부 정보는 *AWS SDK for Go API 참조*의 [DescribeDBSnapshots](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeDBSnapshots)를 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_snapshot(self, snapshot_id):
"""
Gets a DB instance snapshot.
:param snapshot_id: The ID of the snapshot to retrieve.
:return: The retrieved snapshot.
"""
try:
response = self.rds_client.describe_db_snapshots(
DBSnapshotIdentifier=snapshot_id
)
snapshot = response["DBSnapshots"][0]
except ClientError as err:
logger.error(
"Couldn't get snapshot %s. Here's why: %s: %s",
snapshot_id,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return snapshot
```
+ API 세부 정보는 *AWSSDK for Python (Boto3) API 참조*의 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeDBSnapshots)를 참조하십시오.
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
require 'aws-sdk-rds' # v2: require 'aws-sdk'
# List all Amazon Relational Database Service (Amazon RDS) DB instance
# snapshots.
#
# @param rds_resource [Aws::RDS::Resource] An SDK for Ruby Amazon RDS resource.
# @return instance_snapshots [Array, nil] All instance snapshots, or nil if error.
def list_instance_snapshots(rds_resource)
instance_snapshots = []
rds_resource.db_snapshots.each do |s|
instance_snapshots.append({
"id": s.snapshot_id,
"status": s.status
})
end
instance_snapshots
rescue Aws::Errors::ServiceError => e
puts "Couldn't list instance snapshots:\n #{e.message}"
end
```
+ API 세부 정보는 *AWS SDK for Ruby API 참조*의 [DescribeDBSnapshots](https://docs.aws.amazon.com/goto/SdkForRubyV3/rds-2014-10-31/DescribeDBSnapshots)를 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Wait until the specified database snapshot is available to use.
///
/// - Parameters:
/// - instanceIdentifier: The identifier of the database for which the
/// snapshot was taken.
/// - snapshotIdentifier: The identifier of the snapshot to wait for.
func waitUntilDBSnapshotReady(instanceIdentifier: String, snapshotIdentifier: String) async {
var snapshotReady = false
putString("Waiting for the snapshot to be ready...")
do {
while !snapshotReady {
let output = try await rdsClient.describeDBSnapshots(
input: DescribeDBSnapshotsInput(
dbInstanceIdentifier: instanceIdentifier,
dbSnapshotIdentifier: snapshotIdentifier
)
)
guard let snapshotList = output.dbSnapshots else {
return
}
for snapshot in snapshotList {
guard let snapshotReadyStr = snapshot.status else {
return
}
if snapshotReadyStr.contains("available") {
snapshotReady = true
print()
} else {
putString(".")
do {
try await Task.sleep(for: .seconds(15))
} catch {
print("\n*** Error pausing the task!")
}
}
}
}
} catch {
print("\n*** Unable to wait for the database snapshot to be ready: \(error.localizedDescription)")
}
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [DescribeDBSnapshots](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describedbsnapshots(input:))를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `DescribeOrderableDBInstanceOptions` 사용
다음 코드 예시는 `DescribeOrderableDBInstanceOptions`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
///
/// Get a list of orderable DB instance options for a specific
/// engine and engine version.
///
/// Name of the engine.
/// Version of the engine.
/// List of OrderableDBInstanceOptions.
public async Task> DescribeOrderableDBInstanceOptions(string engine, string engineVersion)
{
// Use a paginator to get a list of DB instance options.
var results = new List();
var paginateInstanceOptions = _amazonRDS.Paginators.DescribeOrderableDBInstanceOptions(
new DescribeOrderableDBInstanceOptionsRequest()
{
Engine = engine,
EngineVersion = engineVersion,
});
// Get the entire list using the paginator.
await foreach (var instanceOptions in paginateInstanceOptions.OrderableDBInstanceOptions)
{
results.Add(instanceOptions);
}
return results;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/DescribeOrderableDBInstanceOptions)를 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
//! Routine which gets available 'micro' DB instance classes, displays the list
//! to the user, and returns the user selection.
/*!
\sa chooseMicroDBInstanceClass()
\param engineName: The DB engine name.
\param engineVersion: The DB engine version.
\param dbInstanceClass: String for DB instance class chosen by the user.
\param client: 'RDSClient' instance.
\return bool: Successful completion.
*/
bool AwsDoc::RDS::chooseMicroDBInstanceClass(const Aws::String &engine,
const Aws::String &engineVersion,
Aws::String &dbInstanceClass,
const Aws::RDS::RDSClient &client) {
std::vector instanceClasses;
Aws::String marker;
do {
Aws::RDS::Model::DescribeOrderableDBInstanceOptionsRequest request;
request.SetEngine(engine);
request.SetEngineVersion(engineVersion);
if (!marker.empty()) {
request.SetMarker(marker);
}
Aws::RDS::Model::DescribeOrderableDBInstanceOptionsOutcome outcome =
client.DescribeOrderableDBInstanceOptions(request);
if (outcome.IsSuccess()) {
const Aws::Vector &options =
outcome.GetResult().GetOrderableDBInstanceOptions();
for (const Aws::RDS::Model::OrderableDBInstanceOption &option: options) {
const Aws::String &instanceClass = option.GetDBInstanceClass();
if (instanceClass.find("micro") != std::string::npos) {
if (std::find(instanceClasses.begin(), instanceClasses.end(),
instanceClass) ==
instanceClasses.end()) {
instanceClasses.push_back(instanceClass);
}
}
}
marker = outcome.GetResult().GetMarker();
}
else {
std::cerr << "Error with RDS::DescribeOrderableDBInstanceOptions. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
} while (!marker.empty());
std::cout << "The available micro DB instance classes for your database engine are:"
<< std::endl;
for (int i = 0; i < instanceClasses.size(); ++i) {
std::cout << " " << i + 1 << ": " << instanceClasses[i] << std::endl;
}
int choice = askQuestionForIntRange(
"Which micro DB instance class do you want to use? ",
1, static_cast(instanceClasses.size()));
dbInstanceClass = instanceClasses[choice - 1];
return true;
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeOrderableDBInstanceOptions)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**주문 가능한 DB 인스턴스 옵션을 설명하려면**
다음 `describe-orderable-db-instance-options` 예시에서는 MySQL DB 엔진을 실행 중인 DB 인스턴스의 주문 가능한 옵션에 대한 세부 정보를 가져옵니다.
```
aws rds describe-orderable-db-instance-options \
--engine mysql
```
출력:
```
{
"OrderableDBInstanceOptions": [
{
"MinStorageSize": 5,
"ReadReplicaCapable": true,
"MaxStorageSize": 6144,
"AvailabilityZones": [
{
"Name": "us-east-1a"
},
{
"Name": "us-east-1b"
},
{
"Name": "us-east-1c"
},
{
"Name": "us-east-1d"
}
],
"SupportsIops": false,
"AvailableProcessorFeatures": [],
"MultiAZCapable": true,
"DBInstanceClass": "db.m1.large",
"Vpc": true,
"StorageType": "gp2",
"LicenseModel": "general-public-license",
"EngineVersion": "5.5.46",
"SupportsStorageEncryption": false,
"SupportsEnhancedMonitoring": true,
"Engine": "mysql",
"SupportsIAMDatabaseAuthentication": false,
"SupportsPerformanceInsights": false
}
]
...some output truncated...
}
```
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeOrderableDBInstanceOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/describe-orderable-db-instance-options.html)를 참조하세요.
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// GetOrderableInstances uses a paginator to get DB instance options that can be used to create DB instances that are
// compatible with a set of specifications.
func (instances *DbInstances) GetOrderableInstances(ctx context.Context, engine string, engineVersion string) (
[]types.OrderableDBInstanceOption, error) {
var output *rds.DescribeOrderableDBInstanceOptionsOutput
var instanceOptions []types.OrderableDBInstanceOption
var err error
orderablePaginator := rds.NewDescribeOrderableDBInstanceOptionsPaginator(instances.RdsClient,
&rds.DescribeOrderableDBInstanceOptionsInput{
Engine: aws.String(engine),
EngineVersion: aws.String(engineVersion),
})
for orderablePaginator.HasMorePages() {
output, err = orderablePaginator.NextPage(ctx)
if err != nil {
log.Printf("Couldn't get orderable DB instance options: %v\n", err)
break
} else {
instanceOptions = append(instanceOptions, output.OrderableDBInstanceOptions...)
}
}
return instanceOptions, err
}
```
+ API 세부 정보는 *AWS SDK for Go API 참조*의 [DescribeOrderableDBInstanceOptions](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions)를 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def get_orderable_instances(self, db_engine, db_engine_version):
"""
Gets DB instance options that can be used to create DB instances that are
compatible with a set of specifications.
:param db_engine: The database engine that must be supported by the DB instance.
:param db_engine_version: The engine version that must be supported by the DB instance.
:return: The list of DB instance options that can be used to create a compatible DB instance.
"""
try:
inst_opts = []
paginator = self.rds_client.get_paginator(
"describe_orderable_db_instance_options"
)
for page in paginator.paginate(
Engine=db_engine, EngineVersion=db_engine_version
):
inst_opts += page["OrderableDBInstanceOptions"]
except ClientError as err:
logger.error(
"Couldn't get orderable DB instances. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return inst_opts
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeOrderableDBInstanceOptions)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub에 더 많은 내용이 있습니다. [AWS코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
" iv_engine = 'mysql'
" iv_engineversion = '8.0.35'
TRY.
oo_result = lo_rds->descrorderabledbinstoptions(
iv_engine = iv_engine
iv_engineversion = iv_engineversion ).
DATA(lv_option_count) = lines( oo_result->get_orderabledbinstoptions( ) ).
MESSAGE |Retrieved { lv_option_count } orderable DB instance options.| TYPE 'I'.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [DescribeOrderableDBInstanceOptions](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)를 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Print a list of available database instances with "micro" in the class
/// name, then return one of them to be used by other code.
///
/// - Parameters:
/// - engine: The database engine for which to list database instance
/// classes.
/// - engineVersion: The database version for which to list instances.
///
/// - Returns: An `RDSClientTypes.OrderableDBInstanceOption` describing
/// the selected instance type.
func chooseMicroInstance(engine: String = "mysql", engineVersion: String? = nil) async -> RDSClientTypes.OrderableDBInstanceOption? {
do {
let pages = rdsClient.describeOrderableDBInstanceOptionsPaginated(
input: DescribeOrderableDBInstanceOptionsInput(
engine: engine,
engineVersion: engineVersion
)
)
var optionsList: [RDSClientTypes.OrderableDBInstanceOption] = []
for try await page in pages {
guard let orderableDBInstanceOptions = page.orderableDBInstanceOptions else {
continue
}
for dbInstanceOption in orderableDBInstanceOptions {
guard let className = dbInstanceOption.dbInstanceClass else {
continue
}
if className.contains("micro") {
optionsList.append(dbInstanceOption)
}
}
}
print("Found \(optionsList.count) database instances of 'micro' class types:")
for dbInstanceOption in optionsList {
print(" \(dbInstanceOption.engine ?? "") \(dbInstanceOption.engineVersion ?? "") (\(dbInstanceOption.dbInstanceClass ?? ""))")
}
return optionsList[0]
} catch {
print("*** Error getting a list of orderable instance options: \(error.localizedDescription)")
return nil
}
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [DescribeOrderableDBInstanceOptions](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/describeorderabledbinstanceoptions(input:))를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK와 함께 `GenerateRDSAuthToken` 사용
다음 코드 예시는 `GenerateRDSAuthToken`의 사용 방법을 보여 줍니다.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
[RDSUtilities](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/rds/RdsUtilities.html) 클래스를 사용하여 인증 토큰을 생성합니다.
```
public class GenerateRDSAuthToken {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
dbInstanceIdentifier - The database instance identifier.\s
masterUsername - The master user name.\s
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
String masterUsername = args[1];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
String token = getAuthToken(rdsClient, dbInstanceIdentifier, masterUsername);
System.out.println("The token response is " + token);
}
public static String getAuthToken(RdsClient rdsClient, String dbInstanceIdentifier, String masterUsername) {
RdsUtilities utilities = rdsClient.utilities();
try {
GenerateAuthenticationTokenRequest tokenRequest = GenerateAuthenticationTokenRequest.builder()
.credentialsProvider(ProfileCredentialsProvider.create())
.username(masterUsername)
.port(3306)
.hostname(dbInstanceIdentifier)
.build();
return utilities.generateAuthenticationToken(tokenRequest);
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
return "";
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [GenerateRDSAuthToken](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/GenerateRDSAuthToken)을 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `ModifyDBInstance` 사용
다음 코드 예시는 `ModifyDBInstance`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예제 1: DB 인스턴스를 수정하려면 다음과 같이 하세요.**
다음 `modify-db-instance` 예시에서는 옵션 그룹과 파라미터 그룹을 호환되는 Microsoft SQL Server DB 인스턴스에 연결합니다. `--apply-immediately` 파라미터를 사용하면 다음 유지 관리 기간이 될 때까지 기다리는 대신 옵션과 파라미터 그룹이 즉시 연결됩니다.
```
aws rds modify-db-instance \
--db-instance-identifier database-2 \
--option-group-name test-se-2017 \
--db-parameter-group-name test-sqlserver-se-2017 \
--apply-immediately
```
출력:
```
{
"DBInstance": {
"DBInstanceIdentifier": "database-2",
"DBInstanceClass": "db.r4.large",
"Engine": "sqlserver-se",
"DBInstanceStatus": "available",
...output omitted...
"DBParameterGroups": [
{
"DBParameterGroupName": "test-sqlserver-se-2017",
"ParameterApplyStatus": "applying"
}
],
"AvailabilityZone": "us-west-2d",
...output omitted...
"MultiAZ": true,
"EngineVersion": "14.00.3281.6.v1",
"AutoMinorVersionUpgrade": false,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "license-included",
"OptionGroupMemberships": [
{
"OptionGroupName": "test-se-2017",
"Status": "pending-apply"
}
],
"CharacterSetName": "SQL_Latin1_General_CP1_CI_AS",
"SecondaryAvailabilityZone": "us-west-2c",
"PubliclyAccessible": true,
"StorageType": "gp2",
...output omitted...
"DeletionProtection": false,
"AssociatedRoles": [],
"MaxAllocatedStorage": 1000
}
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [Amazon RDS DB 인스턴스 수정](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.DBInstance.Modifying.html)을 참조하세요.
**예시 2: DB 인스턴스에 VPC 보안 그룹을 연결**
다음 `modify-db-instance` 예시에서는 특정 VPC 보안 그룹을 연결하고 DB 인스턴스에서 DB 보안 그룹을 제거합니다.
```
aws rds modify-db-instance \
--db-instance-identifier dbName \
--vpc-security-group-ids sg-ID
```
출력:
```
{
"DBInstance": {
"DBInstanceIdentifier": "dbName",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "available",
"MasterUsername": "admin",
"Endpoint": {
"Address": "dbName.abcdefghijk.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "ABCDEFGHIJK1234"
},
"AllocatedStorage": 20,
"InstanceCreateTime": "2024-02-15T00:37:58.793000+00:00",
"PreferredBackupWindow": "11:57-12:27",
"BackupRetentionPeriod": 7,
"DBSecurityGroups": [],
"VpcSecurityGroups": [
{
"VpcSecurityGroupId": "sg-ID",
"Status": "active"
}
],
... output omitted ...
"MultiAZ": false,
"EngineVersion": "8.0.35",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "general-public-license",
... output omitted ...
}
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [보안 그룹을 통한 액세스 제어](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html)를 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [ModifyDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-instance.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.ModifyDbInstanceRequest;
import software.amazon.awssdk.services.rds.model.ModifyDbInstanceResponse;
import software.amazon.awssdk.services.rds.model.RdsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ModifyDBInstance {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
dbInstanceIdentifier - The database instance identifier.\s
masterUserPassword - The updated password that corresponds to the master user name.\s
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
String masterUserPassword = args[1];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
updateIntance(rdsClient, dbInstanceIdentifier, masterUserPassword);
rdsClient.close();
}
public static void updateIntance(RdsClient rdsClient, String dbInstanceIdentifier, String masterUserPassword) {
try {
// For a demo - modify the DB instance by modifying the master password.
ModifyDbInstanceRequest modifyDbInstanceRequest = ModifyDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceIdentifier)
.publiclyAccessible(true)
.masterUserPassword(masterUserPassword)
.build();
ModifyDbInstanceResponse instanceResponse = rdsClient.modifyDBInstance(modifyDbInstanceRequest);
System.out.print("The ARN of the modified database is: " + instanceResponse.dbInstance().dbInstanceArn());
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [ModifyDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBInstance)를 참조하십시오.
------
#### [ Kotlin ]
**SDK for Kotlin**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
suspend fun updateIntance(
dbInstanceIdentifierVal: String?,
masterUserPasswordVal: String?,
) {
val request =
ModifyDbInstanceRequest {
dbInstanceIdentifier = dbInstanceIdentifierVal
publiclyAccessible = true
masterUserPassword = masterUserPasswordVal
}
RdsClient.fromEnvironment { region = "us-west-2" }.use { rdsClient ->
val instanceResponse = rdsClient.modifyDbInstance(request)
println("The ARN of the modified database is ${instanceResponse.dbInstance?.dbInstanceArn}")
}
}
```
+ API 세부 정보는 *Kotlin용 AWS SDK API 참조*의 [ModifyDBInstance](https://sdk.amazonaws.com/kotlin/api/latest/index.html)를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `ModifyDBParameterGroup` 사용
다음 코드 예시는 `ModifyDBParameterGroup`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](example_rds_Scenario_GetStartedInstances_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/RDS#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
///
/// Update a DB parameter group. Use the action DescribeDBParameterGroupsAsync
/// to determine when the DB parameter group is ready to use.
///
/// Name of the DB parameter group.
/// List of parameters. Maximum of 20 per request.
/// The updated DB parameter group name.
public async Task ModifyDBParameterGroup(
string name, List parameters)
{
var response = await _amazonRDS.ModifyDBParameterGroupAsync(
new ModifyDBParameterGroupRequest()
{
DBParameterGroupName = name,
Parameters = parameters,
});
return response.DBParameterGroupName;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/DotNetSDKV3/rds-2014-10-31/ModifyDBParameterGroup)을 참조하십시오.
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::RDS::RDSClient client(clientConfig);
Aws::RDS::Model::ModifyDBParameterGroupRequest request;
request.SetDBParameterGroupName(PARAMETER_GROUP_NAME);
request.SetParameters(updateParameters);
Aws::RDS::Model::ModifyDBParameterGroupOutcome outcome =
client.ModifyDBParameterGroup(request);
if (outcome.IsSuccess()) {
std::cout << "The DB parameter group was successfully modified."
<< std::endl;
}
else {
std::cerr << "Error with RDS::ModifyDBParameterGroup. "
<< outcome.GetError().GetMessage()
<< std::endl;
}
```
+ API 세부 정보는 *AWS SDK for C\$1\$1 API 참조*의 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/ModifyDBParameterGroup)을 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**DB 파라미터 그룹을 수정하려면**
다음 `modify-db-parameter-group` 예시에서는 DB 파라미터 그룹의 `clr enabled` 파라미터 값을 변경합니다. `--apply-immediately` 파라미터를 사용하면 다음 유지 관리 기간이 될 때까지 기다리는 대신 DB 파라미터 그룹이 즉시 수정됩니다.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name test-sqlserver-se-2017 \
--parameters "ParameterName='clr enabled',ParameterValue=1,ApplyMethod=immediate"
```
출력:
```
{
"DBParameterGroupName": "test-sqlserver-se-2017"
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 파라미터 그룹의 파라미터 수정](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html#USER_WorkingWithParamGroups.Modifying)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [ModifyDBParameterGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-db-parameter-group.html)을 참조하세요.
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import (
"context"
"errors"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/rds"
"github.com/aws/aws-sdk-go-v2/service/rds/types"
)
type DbInstances struct {
RdsClient *rds.Client
}
// UpdateParameters updates parameters in a named DB parameter group.
func (instances *DbInstances) UpdateParameters(ctx context.Context, parameterGroupName string, params []types.Parameter) error {
_, err := instances.RdsClient.ModifyDBParameterGroup(ctx,
&rds.ModifyDBParameterGroupInput{
DBParameterGroupName: aws.String(parameterGroupName),
Parameters: params,
})
if err != nil {
log.Printf("Couldn't update parameters in %v: %v\n", parameterGroupName, err)
return err
} else {
return nil
}
}
```
+ API 세부 정보는 *AWS SDK for Go API 참조*의 [ModifyDBParameterGroup](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.ModifyDBParameterGroup)을 참조하십시오.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
// Modify auto_increment_offset and auto_increment_increment parameters.
public static void modifyDBParas(RdsClient rdsClient, String dbGroupName) {
try {
Parameter parameter1 = Parameter.builder()
.parameterName("auto_increment_offset")
.applyMethod("immediate")
.parameterValue("5")
.build();
List paraList = new ArrayList<>();
paraList.add(parameter1);
ModifyDbParameterGroupRequest groupRequest = ModifyDbParameterGroupRequest.builder()
.dbParameterGroupName(dbGroupName)
.parameters(paraList)
.build();
ModifyDbParameterGroupResponse response = rdsClient.modifyDBParameterGroup(groupRequest);
System.out.println("The parameter group " + response.dbParameterGroupName() + " was successfully modified");
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/ModifyDBParameterGroup)을 참조하십시오.
------
#### [ Python ]
**SDK for Python (Boto3)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
class InstanceWrapper:
"""Encapsulates Amazon RDS DB instance actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon RDS client.
"""
self.rds_client = rds_client
@classmethod
def from_client(cls):
"""
Instantiates this class from a Boto3 client.
"""
rds_client = boto3.client("rds")
return cls(rds_client)
def update_parameters(self, parameter_group_name, update_parameters):
"""
Updates parameters in a custom DB parameter group.
:param parameter_group_name: The name of the parameter group to update.
:param update_parameters: The parameters to update in the group.
:return: Data about the modified parameter group.
"""
try:
response = self.rds_client.modify_db_parameter_group(
DBParameterGroupName=parameter_group_name, Parameters=update_parameters
)
except ClientError as err:
logger.error(
"Couldn't update parameters in %s. Here's why: %s: %s",
parameter_group_name,
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
else:
return response
```
+ API 세부 정보는 *AWS SDK for Python (Boto3) API 참조*의 [ModifyDBParameterGroup](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/ModifyDBParameterGroup)를 참조하세요.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
GitHub에 더 많은 내용이 있습니다. [AWS코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
" iv_dbparametergroupname = 'mydbparametergroup'
" it_parameters - table containing parameter objects with:
" - parametername = 'max_connections'
" - parametervalue = '100'
" - applymethod = 'immediate' or 'pending-reboot'
TRY.
oo_result = lo_rds->modifydbparametergroup(
iv_dbparametergroupname = iv_dbparametergroupname
it_parameters = it_parameters ).
MESSAGE 'DB parameter group modified.' TYPE 'I'.
CATCH /aws1/cx_rdsdbprmgrnotfndfault.
MESSAGE 'DB parameter group not found.' TYPE 'I'.
CATCH /aws1/cx_rdsinvdbprmgrstatef00.
MESSAGE 'DB parameter group is in an invalid state.' TYPE 'I'.
ENDTRY.
```
+ API 세부 정보는 *AWS SDK for SAP ABAP API 참조*의 [ModifyDBParameterGroup](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)을 참조하세요.
------
#### [ Swift ]
**SDK for Swift**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import AWSRDS
/// Demonstrates modifying two of the specified database parameter group's
/// parameters.
///
/// - Parameter groupName: The name of the parameter group to change
/// parameters for.
func modifyDBParameters(groupName: String) async {
let parameter1 = RDSClientTypes.Parameter(
applyMethod: RDSClientTypes.ApplyMethod.immediate,
parameterName: "auto_increment_offset",
parameterValue: "5"
)
let parameter2 = RDSClientTypes.Parameter(
applyMethod: RDSClientTypes.ApplyMethod.immediate,
parameterName: "auto_increment_increment",
parameterValue: "5"
)
let parameterList = [parameter1, parameter2]
do {
_ = try await rdsClient.modifyDBParameterGroup(
input: ModifyDBParameterGroupInput(
dbParameterGroupName: groupName,
parameters: parameterList
)
)
print("Successfully modified the parameter group \(groupName).")
} catch {
print("*** Error modifying the parameter group \(groupName): \(error.localizedDescription)")
}
}
```
+ API 세부 정보는 *AWS SDK for Swift API 참조*의 [ModifyDBParameterGroup](https://sdk.amazonaws.com/swift/api/awsrds/latest/documentation/awsrds/rdsclient/modifydbparametergroup(input:))을 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK 또는 CLI와 함께 `RebootDBInstance` 사용
다음 코드 예시는 `RebootDBInstance`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**DB 인스턴스를 재부팅하려면**
다음 `reboot-db-instance` 예시에서는 지정된 DB 인스턴스의 재부팅을 시작합니다.
```
aws rds reboot-db-instance \
--db-instance-identifier test-mysql-instance
```
출력:
```
{
"DBInstance": {
"DBInstanceIdentifier": "test-mysql-instance",
"DBInstanceClass": "db.t3.micro",
"Engine": "mysql",
"DBInstanceStatus": "rebooting",
"MasterUsername": "admin",
"Endpoint": {
"Address": "test-mysql-instance.############.us-west-2.rds.amazonaws.com",
"Port": 3306,
"HostedZoneId": "Z1PVIF0EXAMPLE"
},
... output omitted...
}
}
```
자세한 내용은 *Amazon RDS 사용자 안내서*의 [DB 인스턴스 재부팅](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_RebootInstance.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [RebootDBInstance](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/reboot-db-instance.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples)에서 전체 예제를 확인하고 설정 및 실행하는 방법을 알아보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.RebootDbInstanceRequest;
import software.amazon.awssdk.services.rds.model.RebootDbInstanceResponse;
import software.amazon.awssdk.services.rds.model.RdsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class RebootDBInstance {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
dbInstanceIdentifier - The database instance identifier\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String dbInstanceIdentifier = args[0];
Region region = Region.US_WEST_2;
RdsClient rdsClient = RdsClient.builder()
.region(region)
.build();
rebootInstance(rdsClient, dbInstanceIdentifier);
rdsClient.close();
}
public static void rebootInstance(RdsClient rdsClient, String dbInstanceIdentifier) {
try {
RebootDbInstanceRequest rebootDbInstanceRequest = RebootDbInstanceRequest.builder()
.dbInstanceIdentifier(dbInstanceIdentifier)
.build();
RebootDbInstanceResponse instanceResponse = rdsClient.rebootDBInstance(rebootDbInstanceRequest);
System.out.print("The database " + instanceResponse.dbInstance().dbInstanceArn() + " was rebooted");
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [RebootDBInstance](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/RebootDBInstance)를 참조하세요.
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# AWS SDK를 사용한 Amazon RDS에 대한 시나리오
다음 코드 예제는 AWS SDK로 Amazon RDS에서 일반적인 시나리오를 구현하는 방법을 보여줍니다. 이러한 시나리오에서는 Amazon RDS 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 태스크를 수행하는 방법을 보여줍니다. 각 시나리오에는 전체 소스 코드에 대한 링크가 포함되어 있습니다. 여기에서 코드를 설정 및 실행하는 방법에 대한 지침을 찾을 수 있습니다.
시나리오는 컨텍스트에 맞는 서비스 작업을 이해하는 데 도움이 되도록 중급 수준의 경험을 대상으로 합니다.
**Topics**
+ [Aurora 서버리스 작업 항목 트래커 만들기](example_cross_RDSDataTracker_section.md)
# Aurora 서버리스 작업 항목 트래커 만들기
다음 코드 예제는 Amazon Aurora Serverless 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 보내는 웹 애플리케이션을 만드는 방법을 보여 줍니다.
------
#### [ .NET ]
**SDK for .NET**
AWS SDK for .NET을 사용하여 Amazon Aurora 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 통해 보고서를 이메일로 보내는 웹 애플리케이션을 만드는 방법을 보여줍니다. 이 예제에서는 RESTful .NET 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React 웹 애플리케이션을 AWS 서비스와 통합합니다.
+ Aurora 테이블의 항목을 나열, 추가, 업데이트 및 삭제합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 통해 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/AuroraItemTracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ C\$1\$1 ]
**SDK for C\$1\$1**
Amazon Aurora Serverless 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 C\$1\$1 REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/serverless-aurora)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Java ]
**SDK for Java 2.x**
Amazon RDS 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_Spring_RDS_Rest)에서 전체 예제를 참조하세요.
JDBC API를 사용한 예제를 설정하고 실행하는 방법에 대한 전체 소스 코드와 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/Creating_rds_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
AWS SDK for JavaScript(v3)을 사용하여 Amazon Aurora 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 통해 보고서를 이메일로 보내는 웹 애플리케이션을 만드는 방법을 보여줍니다. 이 예제에서는 Express Node.js 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React.js 웹 애플리케이션을 AWS 서비스와 통합합니다.
+ Aurora 테이블의 항목을 나열, 추가 및 업데이트합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 통해 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/aurora-serverless-app)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Kotlin ]
**SDK for Kotlin**
Amazon RDS 데이터베이스에 저장된 작업 항목을 추적하고 보고하는 웹 애플리케이션을 만드는 방법을 보여줍니다.
Amazon Aurora Serverless 데이터를 쿼리하고 React 애플리케이션에서 사용하도록 Spring REST API를 설정하는 방법에 대한 지침과 전체 소스 코드는 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/serverless_rds)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ PHP ]
**SDK for PHP**
AWS SDK for PHP을 사용하여 Amazon RDS 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 통해 보고서를 이메일로 보내는 웹 애플리케이션을 만드는 방법을 보여줍니다. 이 예제에서는 RESTful PHP 백엔드와의 상호 작용을 위해 React.js로 빌드된 프런트엔드를 사용합니다.
+ React.js 웹 애플리케이션을 AWS 서비스와 통합합니다.
+ Amazon RDS 테이블의 항목을 나열, 추가, 업데이트 및 삭제합니다.
+ Amazon SES를 사용하여 필터링된 작업 항목에 대한 이메일 보고서를 보냅니다.
+ 포함된 AWS CloudFormation 스크립트를 통해 예제 리소스를 배포하고 관리합니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/cross_service/aurora_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
#### [ Python ]
**SDK for Python (Boto3)**
AWS SDK for Python (Boto3)을 사용하여 Amazon Aurora Serverless 데이터베이스에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 통해 보고서를 이메일로 보내는 REST 서비스를 만드는 방법을 보여 줍니다. 이 예제는 Flask 웹 프레임워크를 사용하여 HTTP 라우팅을 처리하고 React 웹 페이지와 통합하여 완전한 기능을 갖춘 웹 애플리케이션을 제공합니다.
+ AWS 서비스와 통합되는 Flask REST 서비스를 구축합니다.
+ Aurora Serverless 데이터베이스에 저장된 작업 항목을 읽고, 쓰고, 업데이트합니다.
+ 데이터베이스 자격 증명 정보가 포함된 AWS Secrets Manager 암호를 만들고 이를 사용하여 데이터베이스에 대한 호출을 인증합니다.
+ Amazon SES를 사용하여 작업 항목에 대한 이메일 보고서를 보냅니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_item_tracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ Aurora
+ Amazon RDS
+ Amazon RDS 데이터 서비스
+ Amazon SES
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.
# Amazon RDS를 사용하는 서버리스 예제
다음 코드 예제에서는 Amazon RDS를 AWS SDK와 함께 사용하는 방법을 보여줍니다.
**Topics**
+ [Lambda 함수를 사용하여 Amazon RDS 데이터베이스에 연결](example_serverless_connect_RDS_Lambda_section.md)
# Lambda 함수를 사용하여 Amazon RDS 데이터베이스에 연결
다음 코드 예시는 RDS 데이터베이스에 연결하는 Lambda 함수를 구현하는 방법을 보여줍니다. 이 함수는 간단한 데이터베이스 요청을 하고 결과를 반환합니다.
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
.NET을 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
using System.Data;
using System.Text.Json;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.Lambda.Core;
using MySql.Data.MySqlClient;
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace aws_rds;
public class InputModel
{
public string key1 { get; set; }
public string key2 { get; set; }
}
public class Function
{
///
// Handles the Lambda function execution for connecting to RDS using IAM authentication.
///
/// The input event data passed to the Lambda function
/// The Lambda execution context that provides runtime information
/// A response object containing the execution result
public async Task FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
{
// Sample Input: {"body": "{\"key1\":\"20\", \"key2\":\"25\"}"}
var input = JsonSerializer.Deserialize(request.Body);
/// Obtain authentication token
var authToken = RDSAuthTokenGenerator.GenerateAuthToken(
Environment.GetEnvironmentVariable("RDS_ENDPOINT"),
Convert.ToInt32(Environment.GetEnvironmentVariable("RDS_PORT")),
Environment.GetEnvironmentVariable("RDS_USERNAME")
);
/// Build the Connection String with the Token
string connectionString = $"Server={Environment.GetEnvironmentVariable("RDS_ENDPOINT")};" +
$"Port={Environment.GetEnvironmentVariable("RDS_PORT")};" +
$"Uid={Environment.GetEnvironmentVariable("RDS_USERNAME")};" +
$"Pwd={authToken};";
try
{
await using var connection = new MySqlConnection(connectionString);
await connection.OpenAsync();
const string sql = "SELECT @param1 + @param2 AS Sum";
await using var command = new MySqlCommand(sql, connection);
command.Parameters.AddWithValue("@param1", int.Parse(input.key1 ?? "0"));
command.Parameters.AddWithValue("@param2", int.Parse(input.key2 ?? "0"));
await using var reader = await command.ExecuteReaderAsync();
if (await reader.ReadAsync())
{
int result = reader.GetInt32("Sum");
//Sample Response: {"statusCode":200,"body":"{\"message\":\"The sum is: 45\"}","isBase64Encoded":false}
return new APIGatewayProxyResponse
{
StatusCode = 200,
Body = JsonSerializer.Serialize(new { message = $"The sum is: {result}" })
};
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
return new APIGatewayProxyResponse
{
StatusCode = 500,
Body = JsonSerializer.Serialize(new { error = "Internal server error" })
};
}
}
```
------
#### [ Go ]
**SDK for Go V2**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Go를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
/*
Golang v2 code here.
*/
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/feature/rds/auth"
_ "github.com/go-sql-driver/mysql"
)
type MyEvent struct {
Name string `json:"name"`
}
func HandleRequest(event *MyEvent) (map[string]interface{}, error) {
var dbName string = os.Getenv("DatabaseName")
var dbUser string = os.Getenv("DatabaseUser")
var dbHost string = os.Getenv("DBHost") // Add hostname without https
var dbPort int = os.Getenv("Port") // Add port number
var dbEndpoint string = fmt.Sprintf("%s:%d", dbHost, dbPort)
var region string = os.Getenv("AWS_REGION")
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic("configuration error: " + err.Error())
}
authenticationToken, err := auth.BuildAuthToken(
context.TODO(), dbEndpoint, region, dbUser, cfg.Credentials)
if err != nil {
panic("failed to create authentication token: " + err.Error())
}
dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?tls=true&allowCleartextPasswords=true",
dbUser, authenticationToken, dbEndpoint, dbName,
)
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
var sum int
err = db.QueryRow("SELECT ?+? AS sum", 3, 2).Scan(&sum)
if err != nil {
panic(err)
}
s := fmt.Sprint(sum)
message := fmt.Sprintf("The selected sum is: %s", s)
messageBytes, err := json.Marshal(message)
if err != nil {
return nil, err
}
messageString := string(messageBytes)
return map[string]interface{}{
"statusCode": 200,
"headers": map[string]string{"Content-Type": "application/json"},
"body": messageString,
}, nil
}
func main() {
lambda.Start(HandleRequest)
}
```
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Java를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rdsdata.RdsDataClient;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementRequest;
import software.amazon.awssdk.services.rdsdata.model.ExecuteStatementResponse;
import software.amazon.awssdk.services.rdsdata.model.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class RdsLambdaHandler implements RequestHandler {
@Override
public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
try {
// Obtain auth token
String token = createAuthToken();
// Define connection configuration
String connectionString = String.format("jdbc:mysql://%s:%s/%s?useSSL=true&requireSSL=true",
System.getenv("ProxyHostName"),
System.getenv("Port"),
System.getenv("DBName"));
// Establish a connection to the database
try (Connection connection = DriverManager.getConnection(connectionString, System.getenv("DBUserName"), token);
PreparedStatement statement = connection.prepareStatement("SELECT ? + ? AS sum")) {
statement.setInt(1, 3);
statement.setInt(2, 2);
try (ResultSet resultSet = statement.executeQuery()) {
if (resultSet.next()) {
int sum = resultSet.getInt("sum");
response.setStatusCode(200);
response.setBody("The selected sum is: " + sum);
}
}
}
} catch (Exception e) {
response.setStatusCode(500);
response.setBody("Error: " + e.getMessage());
}
return response;
}
private String createAuthToken() {
// Create RDS Data Service client
RdsDataClient rdsDataClient = RdsDataClient.builder()
.region(Region.of(System.getenv("AWS_REGION")))
.credentialsProvider(DefaultCredentialsProvider.create())
.build();
// Define authentication request
ExecuteStatementRequest request = ExecuteStatementRequest.builder()
.resourceArn(System.getenv("ProxyHostName"))
.secretArn(System.getenv("DBUserName"))
.database(System.getenv("DBName"))
.sql("SELECT 'RDS IAM Authentication'")
.build();
// Execute request and obtain authentication token
ExecuteStatementResponse response = rdsDataClient.executeStatement(request);
Field tokenField = response.records().get(0).get(0);
return tokenField.stringValue();
}
}
```
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
JavaScript를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
/*
Node.js code here.
*/
// ES6+ example
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
async function createAuthToken() {
// Define connection authentication parameters
const dbinfo = {
hostname: process.env.ProxyHostName,
port: process.env.Port,
username: process.env.DBUserName,
region: process.env.AWS_REGION,
}
// Create RDS Signer object
const signer = new Signer(dbinfo);
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps() {
// Obtain auth token
const token = await createAuthToken();
// Define connection configuration
let connectionConfig = {
host: process.env.ProxyHostName,
user: process.env.DBUserName,
password: token,
database: process.env.DBName,
ssl: 'Amazon RDS'
}
// Create the connection to the DB
const conn = await mysql.createConnection(connectionConfig);
// Obtain the result of the query
const [res,] = await conn.execute('select ?+? as sum', [3, 2]);
return res;
}
export const handler = async (event) => {
// Execute database flow
const result = await dbOps();
// Return result
return {
statusCode: 200,
body: JSON.stringify("The selected sum is: " + result[0].sum)
}
};
```
TypeScript를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import { Signer } from "@aws-sdk/rds-signer";
import mysql from 'mysql2/promise';
// RDS settings
// Using '!' (non-null assertion operator) to tell the TypeScript compiler that the DB settings are not null or undefined,
const proxy_host_name = process.env.PROXY_HOST_NAME!
const port = parseInt(process.env.PORT!)
const db_name = process.env.DB_NAME!
const db_user_name = process.env.DB_USER_NAME!
const aws_region = process.env.AWS_REGION!
async function createAuthToken(): Promise {
// Create RDS Signer object
const signer = new Signer({
hostname: proxy_host_name,
port: port,
region: aws_region,
username: db_user_name
});
// Request authorization token from RDS, specifying the username
const token = await signer.getAuthToken();
return token;
}
async function dbOps(): Promise {
try {
// Obtain auth token
const token = await createAuthToken();
const conn = await mysql.createConnection({
host: proxy_host_name,
user: db_user_name,
password: token,
database: db_name,
ssl: 'Amazon RDS' // Ensure you have the CA bundle for SSL connection
});
const [rows, fields] = await conn.execute('SELECT ? + ? AS sum', [3, 2]);
console.log('result:', rows);
return rows;
}
catch (err) {
console.log(err);
}
}
export const lambdaHandler = async (event: any): Promise<{ statusCode: number; body: string }> => {
// Execute database flow
const result = await dbOps();
// Return error is result is undefined
if (result == undefined)
return {
statusCode: 500,
body: JSON.stringify(`Error with connection to DB host`)
}
// Return result
return {
statusCode: 200,
body: JSON.stringify(`The selected sum is: ${result[0].sum}`)
};
};
```
------
#### [ PHP ]
**SDK for PHP**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
PHP를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
logger = $logger;
}
private function getAuthToken(): string {
// Define connection authentication parameters
$dbConnection = [
'hostname' => getenv('DB_HOSTNAME'),
'port' => getenv('DB_PORT'),
'username' => getenv('DB_USERNAME'),
'region' => getenv('AWS_REGION'),
];
// Create RDS AuthTokenGenerator object
$generator = new AuthTokenGenerator(CredentialProvider::defaultProvider());
// Request authorization token from RDS, specifying the username
return $generator->createToken(
$dbConnection['hostname'] . ':' . $dbConnection['port'],
$dbConnection['region'],
$dbConnection['username']
);
}
private function getQueryResults() {
// Obtain auth token
$token = $this->getAuthToken();
// Define connection configuration
$connectionConfig = [
'host' => getenv('DB_HOSTNAME'),
'user' => getenv('DB_USERNAME'),
'password' => $token,
'database' => getenv('DB_NAME'),
];
// Create the connection to the DB
$conn = new PDO(
"mysql:host={$connectionConfig['host']};dbname={$connectionConfig['database']}",
$connectionConfig['user'],
$connectionConfig['password'],
[
PDO::MYSQL_ATTR_SSL_CA => '/path/to/rds-ca-2019-root.pem',
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,
]
);
// Obtain the result of the query
$stmt = $conn->prepare('SELECT ?+? AS sum');
$stmt->execute([3, 2]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
/**
* @param mixed $event
* @param Context $context
* @return array
*/
public function handle(mixed $event, Context $context): array
{
$this->logger->info("Processing query");
// Execute database flow
$result = $this->getQueryResults();
return [
'sum' => $result['sum']
];
}
}
$logger = new StderrLogger();
return new Handler($logger);
```
------
#### [ Python ]
**SDK for Python(Boto3)**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Python을 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
import json
import os
import boto3
import pymysql
# RDS settings
proxy_host_name = os.environ['PROXY_HOST_NAME']
port = int(os.environ['PORT'])
db_name = os.environ['DB_NAME']
db_user_name = os.environ['DB_USER_NAME']
aws_region = os.environ['AWS_REGION']
# Fetch RDS Auth Token
def get_auth_token():
client = boto3.client('rds')
token = client.generate_db_auth_token(
DBHostname=proxy_host_name,
Port=port
DBUsername=db_user_name
Region=aws_region
)
return token
def lambda_handler(event, context):
token = get_auth_token()
try:
connection = pymysql.connect(
host=proxy_host_name,
user=db_user_name,
password=token,
db=db_name,
port=port,
ssl={'ca': 'Amazon RDS'} # Ensure you have the CA bundle for SSL connection
)
with connection.cursor() as cursor:
cursor.execute('SELECT %s + %s AS sum', (3, 2))
result = cursor.fetchone()
return result
except Exception as e:
return (f"Error: {str(e)}") # Return an error message if an exception occurs
```
------
#### [ Ruby ]
**SDK for Ruby**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Ruby를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
# Ruby code here.
require 'aws-sdk-rds'
require 'json'
require 'mysql2'
def lambda_handler(event:, context:)
endpoint = ENV['DBEndpoint'] # Add the endpoint without https"
port = ENV['Port'] # 3306
user = ENV['DBUser']
region = ENV['DBRegion'] # 'us-east-1'
db_name = ENV['DBName']
credentials = Aws::Credentials.new(
ENV['AWS_ACCESS_KEY_ID'],
ENV['AWS_SECRET_ACCESS_KEY'],
ENV['AWS_SESSION_TOKEN']
)
rds_client = Aws::RDS::AuthTokenGenerator.new(
region: region,
credentials: credentials
)
token = rds_client.auth_token(
endpoint: endpoint+ ':' + port,
user_name: user,
region: region
)
begin
conn = Mysql2::Client.new(
host: endpoint,
username: user,
password: token,
port: port,
database: db_name,
sslca: '/var/task/global-bundle.pem',
sslverify: true,
enable_cleartext_plugin: true
)
a = 3
b = 2
result = conn.query("SELECT #{a} + #{b} AS sum").first['sum']
puts result
conn.close
{
statusCode: 200,
body: result.to_json
}
rescue => e
puts "Database connection failed due to #{e}"
end
end
```
------
#### [ Rust ]
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [서버리스 예제](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-connect-rds-iam) 리포지토리에서 전체 예제를 찾아보고 설정 및 실행 방법을 알아봅니다.
Rust를 사용하여 Lambda 함수에서 Amazon RDS 데이터베이스에 연결
```
use aws_config::BehaviorVersion;
use aws_credential_types::provider::ProvideCredentials;
use aws_sigv4::{
http_request::{sign, SignableBody, SignableRequest, SigningSettings},
sign::v4,
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde_json::{json, Value};
use sqlx::postgres::PgConnectOptions;
use std::env;
use std::time::{Duration, SystemTime};
const RDS_CERTS: &[u8] = include_bytes!("global-bundle.pem");
async fn generate_rds_iam_token(
db_hostname: &str,
port: u16,
db_username: &str,
) -> Result {
let config = aws_config::load_defaults(BehaviorVersion::v2024_03_28()).await;
let credentials = config
.credentials_provider()
.expect("no credentials provider found")
.provide_credentials()
.await
.expect("unable to load credentials");
let identity = credentials.into();
let region = config.region().unwrap().to_string();
let mut signing_settings = SigningSettings::default();
signing_settings.expires_in = Some(Duration::from_secs(900));
signing_settings.signature_location = aws_sigv4::http_request::SignatureLocation::QueryParams;
let signing_params = v4::SigningParams::builder()
.identity(&identity)
.region(®ion)
.name("rds-db")
.time(SystemTime::now())
.settings(signing_settings)
.build()?;
let url = format!(
"https://{db_hostname}:{port}/?Action=connect&DBUser={db_user}",
db_hostname = db_hostname,
port = port,
db_user = db_username
);
let signable_request =
SignableRequest::new("GET", &url, std::iter::empty(), SignableBody::Bytes(&[]))
.expect("signable request");
let (signing_instructions, _signature) =
sign(signable_request, &signing_params.into())?.into_parts();
let mut url = url::Url::parse(&url).unwrap();
for (name, value) in signing_instructions.params() {
url.query_pairs_mut().append_pair(name, &value);
}
let response = url.to_string().split_off("https://".len());
Ok(response)
}
#[tokio::main]
async fn main() -> Result<(), Error> {
run(service_fn(handler)).await
}
async fn handler(_event: LambdaEvent) -> Result {
let db_host = env::var("DB_HOSTNAME").expect("DB_HOSTNAME must be set");
let db_port = env::var("DB_PORT")
.expect("DB_PORT must be set")
.parse::()
.expect("PORT must be a valid number");
let db_name = env::var("DB_NAME").expect("DB_NAME must be set");
let db_user_name = env::var("DB_USERNAME").expect("DB_USERNAME must be set");
let token = generate_rds_iam_token(&db_host, db_port, &db_user_name).await?;
let opts = PgConnectOptions::new()
.host(&db_host)
.port(db_port)
.username(&db_user_name)
.password(&token)
.database(&db_name)
.ssl_root_cert_from_pem(RDS_CERTS.to_vec())
.ssl_mode(sqlx::postgres::PgSslMode::Require);
let pool = sqlx::postgres::PgPoolOptions::new()
.connect_with(opts)
.await?;
let result: i32 = sqlx::query_scalar("SELECT $1 + $2")
.bind(3)
.bind(2)
.fetch_one(&pool)
.await?;
println!("Result: {:?}", result);
Ok(json!({
"statusCode": 200,
"content-type": "text/plain",
"body": format!("The selected sum is: {result}")
}))
}
```
------
AWS SDK 개발자 가이드 및 코드 예제의 전체 목록은 [AWS SDK와 함께 이 서비스 사용](CHAP_Tutorials.md#sdk-general-information-section)을 참조하세요. 이 주제에는 시작하기에 대한 정보와 이전 SDK 버전에 대한 세부 정보도 포함되어 있습니다.