Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwendung `DescribeOrderableDBInstanceOptions` mit einem AWS SDK oder CLI
Die folgenden Code-Beispiele zeigen, wie `DescribeOrderableDBInstanceOptions` verwendet wird.
Beispiele für Aktionen sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Im folgenden Codebeispiel können Sie diese Aktion im Kontext sehen:
+ [Kennenlernen der Grundlagen](example_aurora_Scenario_GetStartedClusters_section.md)
------
#### [ .NET ]
**SDK für .NET (v4)**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Aurora#code-examples) einrichten und ausführen.
```
///
/// 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> DescribeOrderableDBInstanceOptionsPagedAsync(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;
}
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/goto/DotNetSDKV4/rds-2014-10-31/DescribeOrderableDBInstanceOptions) in der *AWS SDK für .NET API-Referenz*.
------
#### [ C\$1\$1 ]
**SDK für C\$1\$1**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/aurora#code-examples) einrichten und ausführen.
```
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 DB instance classes, displays the list
//! to the user, and returns the user selection.
/*!
\sa chooseDBInstanceClass()
\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::Aurora::chooseDBInstanceClass(const Aws::String &engine,
const Aws::String &engineVersion,
Aws::String &dbInstanceClass,
const Aws::RDS::RDSClient &client) {
std::vector instanceClasses;
Aws::String marker; // The marker is used for pagination.
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 (std::find(instanceClasses.begin(), instanceClasses.end(),
instanceClass) == instanceClasses.end()) {
instanceClasses.push_back(instanceClass);
}
}
marker = outcome.GetResult().GetMarker();
}
else {
std::cerr << "Error with Aurora::DescribeOrderableDBInstanceOptions. "
<< outcome.GetError().GetMessage()
<< std::endl;
return false;
}
} while (!marker.empty());
std::cout << "The available 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 DB instance class do you want to use? ",
1, static_cast(instanceClasses.size()));
dbInstanceClass = instanceClasses[choice - 1];
return true;
}
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/goto/SdkForCpp/rds-2014-10-31/DescribeOrderableDBInstanceOptions) in der *AWS SDK für C\$1\$1 API-Referenz*.
------
#### [ Go ]
**SDK für Go V2**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/aurora#code-examples) einrichten und ausführen.
```
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 DbClusters struct {
AuroraClient *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 (clusters *DbClusters) GetOrderableInstances(ctx context.Context, engine string, engineVersion string) (
[]types.OrderableDBInstanceOption, error) {
var output *rds.DescribeOrderableDBInstanceOptionsOutput
var instances []types.OrderableDBInstanceOption
var err error
orderablePaginator := rds.NewDescribeOrderableDBInstanceOptionsPaginator(clusters.AuroraClient,
&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 instances: %v\n", err)
break
} else {
instances = append(instances, output.OrderableDBInstanceOptions...)
}
}
return instances, err
}
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/rds#Client.DescribeOrderableDBInstanceOptions) in der *AWS SDK für Go API-Referenz*.
------
#### [ Java ]
**SDK für Java 2.x**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/rds#code-examples) einrichten und ausführen.
```
public static void describeDBEngines(RdsClient rdsClient) {
try {
DescribeDbEngineVersionsRequest engineVersionsRequest = DescribeDbEngineVersionsRequest.builder()
.engine("aurora-mysql")
.defaultOnly(true)
.maxRecords(20)
.build();
DescribeDbEngineVersionsResponse response = rdsClient.describeDBEngineVersions(engineVersionsRequest);
List engines = response.dbEngineVersions();
// Get all DBEngineVersion objects.
for (DBEngineVersion engineOb : engines) {
System.out.println("The name of the DB parameter group family for the database engine is "
+ engineOb.dbParameterGroupFamily());
System.out.println("The name of the database engine " + engineOb.engine());
System.out.println("The version number of the database engine " + engineOb.engineVersion());
}
} catch (RdsException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/goto/SdkForJavaV2/rds-2014-10-31/DescribeOrderableDBInstanceOptions) in der *AWS SDK for Java 2.x API-Referenz*.
------
#### [ PowerShell ]
**Tools für PowerShell V4**
**Beispiel 1: Dieses Beispiel listet die DB-Engine-Versionen auf, die eine bestimmte DB-Instance-Klasse in einer AWS-Region unterstützen.**
```
$params = @{
Engine = 'aurora-postgresql'
DBInstanceClass = 'db.r5.large'
Region = 'us-east-1'
}
Get-RDSOrderableDBInstanceOption @params
```
**Beispiel 2: Dieses Beispiel listet die DB-Instance-Klassen auf, die von einer bestimmten DB-Engine-Version in einer AWS-Region unterstützt werden.**
```
$params = @{
Engine = 'aurora-postgresql'
EngineVersion = '13.6'
Region = 'us-east-1'
}
Get-RDSOrderableDBInstanceOption @params
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/powershell/v4/reference) in der *AWS -Tools für PowerShell Cmdlet-Referenz (V4).*
**Tools für V5 PowerShell **
**Beispiel 1: Dieses Beispiel listet die DB-Engine-Versionen auf, die eine bestimmte DB-Instance-Klasse in einer AWS-Region unterstützen.**
```
$params = @{
Engine = 'aurora-postgresql'
DBInstanceClass = 'db.r5.large'
Region = 'us-east-1'
}
Get-RDSOrderableDBInstanceOption @params
```
**Beispiel 2: Dieses Beispiel listet die DB-Instance-Klassen auf, die von einer bestimmten DB-Engine-Version in einer AWS-Region unterstützt werden.**
```
$params = @{
Engine = 'aurora-postgresql'
EngineVersion = '13.6'
Region = 'us-east-1'
}
Get-RDSOrderableDBInstanceOption @params
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/powershell/v5/reference) in der *AWS -Tools für PowerShell Cmdlet-Referenz (*V5).
------
#### [ Python ]
**SDK für Python (Boto3)**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/aurora#code-examples) einrichten und ausführen.
```
class AuroraWrapper:
"""Encapsulates Aurora DB cluster actions."""
def __init__(self, rds_client):
"""
:param rds_client: A Boto3 Amazon Relational Database Service (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
```
+ Einzelheiten zur API finden Sie unter [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/goto/boto3/rds-2014-10-31/DescribeOrderableDBInstanceOptions) in der *AWS API-Referenz zum SDK for Python (Boto3)*.
------
#### [ Rust ]
**SDK für Rust**
Es gibt noch mehr dazu GitHub. Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples) einrichten und ausführen.
```
pub async fn get_instance_classes(&self) -> Result, ScenarioError> {
let describe_orderable_db_instance_options_items = self
.rds
.describe_orderable_db_instance_options(
DB_ENGINE,
self.engine_version
.as_ref()
.expect("engine version for db instance options")
.as_str(),
)
.await;
describe_orderable_db_instance_options_items
.map(|options| {
options
.iter()
.filter(|o| o.storage_type() == Some("aurora"))
.map(|o| o.db_instance_class().unwrap_or_default().to_string())
.collect::>()
})
.map_err(|err| ScenarioError::new("Could not get available instance classes", &err))
}
pub async fn describe_orderable_db_instance_options(
&self,
engine: &str,
engine_version: &str,
) -> Result, SdkError>
{
self.inner
.describe_orderable_db_instance_options()
.engine(engine)
.engine_version(engine_version)
.into_paginator()
.items()
.send()
.try_collect()
.await
}
#[tokio::test]
async fn test_scenario_get_instance_classes() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.return_once(|_, _, _| {
Ok(CreateDbClusterParameterGroupOutput::builder()
.db_cluster_parameter_group(DbClusterParameterGroup::builder().build())
.build())
});
mock_rds
.expect_describe_orderable_db_instance_options()
.with(eq("aurora-mysql"), eq("aurora-mysql8.0"))
.return_once(|_, _| {
Ok(vec![
OrderableDbInstanceOption::builder()
.db_instance_class("t1")
.storage_type("aurora")
.build(),
OrderableDbInstanceOption::builder()
.db_instance_class("t1")
.storage_type("aurora-iopt1")
.build(),
OrderableDbInstanceOption::builder()
.db_instance_class("t2")
.storage_type("aurora")
.build(),
OrderableDbInstanceOption::builder()
.db_instance_class("t3")
.storage_type("aurora")
.build(),
])
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario
.set_engine("aurora-mysql", "aurora-mysql8.0")
.await
.expect("set engine");
let instance_classes = scenario.get_instance_classes().await;
assert_eq!(
instance_classes,
Ok(vec!["t1".into(), "t2".into(), "t3".into()])
);
}
#[tokio::test]
async fn test_scenario_get_instance_classes_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_orderable_db_instance_options()
.with(eq("aurora-mysql"), eq("aurora-mysql8.0"))
.return_once(|_, _| {
Err(SdkError::service_error(
DescribeOrderableDBInstanceOptionsError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_orderable_db_instance_options_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_family = Some("aurora-mysql".into());
scenario.engine_version = Some("aurora-mysql8.0".into());
let instance_classes = scenario.get_instance_classes().await;
assert_matches!(
instance_classes,
Err(ScenarioError {message, context: _}) if message == "Could not get available instance classes"
);
}
```
+ Einzelheiten zur API finden Sie in der *Referenz zu den [DescribeOrderableDBInstanceOptionen](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_orderable_db_instance_options) im AWS SDK für die Rust-API*.
------
#### [ SAP ABAP ]
**SDK für SAP ABAP**
Es gibt noch mehr dazu. GitHub Hier finden Sie das vollständige Beispiel und erfahren, wie Sie das [AWS -Code-Beispiel-](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rds#code-examples) einrichten und ausführen.
```
" 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.
```
+ Einzelheiten zur API finden Sie in der *Referenz zu den [DescribeOrderableDBInstanceOptionen](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) im AWS SDK für SAP ABAP API.*
------
Eine vollständige Liste der AWS SDK-Entwicklerhandbücher und Codebeispiele finden Sie unter[Verwenden Sie diesen Dienst mit einem AWS SDK](CHAP_Tutorials.md#sdk-general-information-section). Dieses Thema enthält auch Informationen zu den ersten Schritten und Details zu früheren SDK-Versionen.