Sono disponibili altri esempi AWS SDK nel repository [AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples) Examples. GitHub
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempi di codice per l’SDK per Rust
I seguenti esempi di codice mostrano come utilizzare l' AWS SDK per Rust con. AWS
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
*Scenari*: esempi di codice che mostrano come eseguire un’attività specifica chiamando più funzioni all’interno dello stesso servizio o combinate con altri Servizi AWS.
Alcuni servizi contengono ulteriori categorie di esempio che mostrano come utilizzare le librerie o le funzioni specifiche del servizio.
**Altre risorse**
+ **[Guida per sviluppatori SDK for Rust](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/welcome.html)**: ulteriori informazioni sull'utilizzo di Rust con. AWS
+ **[Centro per sviluppatori AWS](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-programming-language=programming-language%23rust)**: esempi di codice che è possibile filtrare per categoria o per ricerca di testo completo.
+ **[AWS Esempi SDK](https://github.com/awsdocs/aws-doc-sdk-examples)**: GitHub repository con codice completo nelle lingue preferite. Include le istruzioni su come configurare ed eseguire il codice.
**Topics**
+ [Gateway API](rust_1_api-gateway_code_examples.md)
+ [API di gestione Gateway API](rust_1_apigatewaymanagementapi_code_examples.md)
+ [Application Auto Scaling](rust_1_application-auto-scaling_code_examples.md)
+ [Aurora](rust_1_aurora_code_examples.md)
+ [Auto Scaling](rust_1_auto-scaling_code_examples.md)
+ [API Runtime per Amazon Bedrock](rust_1_bedrock-runtime_code_examples.md)
+ [API Runtime per Agent per Amazon Bedrock](rust_1_bedrock-agent-runtime_code_examples.md)
+ [Gestore dell’identità per Amazon Cognito](rust_1_cognito-identity-provider_code_examples.md)
+ [Amazon Cognito Sync](rust_1_cognito-sync_code_examples.md)
+ [Firehose](rust_1_firehose_code_examples.md)
+ [Amazon DocumentDB](rust_1_docdb_code_examples.md)
+ [DynamoDB](rust_1_dynamodb_code_examples.md)
+ [Amazon EBS](rust_1_ebs_code_examples.md)
+ [Amazon EC2](rust_1_ec2_code_examples.md)
+ [Amazon ECR](rust_1_ecr_code_examples.md)
+ [Amazon ECS](rust_1_ecs_code_examples.md)
+ [Amazon EKS](rust_1_eks_code_examples.md)
+ [AWS Glue](rust_1_glue_code_examples.md)
+ [IAM](rust_1_iam_code_examples.md)
+ [AWS IoT](rust_1_iot_code_examples.md)
+ [Kinesis](rust_1_kinesis_code_examples.md)
+ [AWS KMS](rust_1_kms_code_examples.md)
+ [Lambda](rust_1_lambda_code_examples.md)
+ [MediaLive](rust_1_medialive_code_examples.md)
+ [MediaPackage](rust_1_mediapackage_code_examples.md)
+ [MSK Amazon](rust_1_kafka_code_examples.md)
+ [Amazon Polly](rust_1_polly_code_examples.md)
+ [Amazon RDS](rust_1_rds_code_examples.md)
+ [Servizi di dati di Amazon RDS](rust_1_rds-data_code_examples.md)
+ [Amazon Rekognition](rust_1_rekognition_code_examples.md)
+ [Route 53](rust_1_route-53_code_examples.md)
+ [Simple Storage Service (Amazon S3)](rust_1_s3_code_examples.md)
+ [SageMaker AI](rust_1_sagemaker_code_examples.md)
+ [Secrets Manager](rust_1_secrets-manager_code_examples.md)
+ [API Amazon SES v2](rust_1_sesv2_code_examples.md)
+ [Amazon SNS](rust_1_sns_code_examples.md)
+ [Amazon SQS](rust_1_sqs_code_examples.md)
+ [AWS STS](rust_1_sts_code_examples.md)
+ [Systems Manager](rust_1_ssm_code_examples.md)
+ [Amazon Transcribe](rust_1_transcribe_code_examples.md)
# Esempi per Gateway API con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con API Gateway.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
*Scenari*: esempi di codice che mostrano come eseguire un’attività specifica chiamando più funzioni all’interno dello stesso servizio o combinate con altri Servizi AWS.
*AWS i contributi della community* sono esempi che sono stati creati e gestiti da più team AWS. Per fornire un feedback, utilizza il meccanismo disponibile nei repository collegati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
+ [Scenari](#scenarios)
+ [AWS contributi della comunità](#aws_community_contributions)
## Azioni
### `GetRestApis`
Il seguente esempio di codice mostra come usare`GetRestApis`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/apigateway#code-examples).
Visualizza il REST di Amazon API Gateway APIs nella regione.
```
async fn show_apis(client: &Client) -> Result<(), Error> {
let resp = client.get_rest_apis().send().await?;
for api in resp.items() {
println!("ID: {}", api.id().unwrap_or_default());
println!("Name: {}", api.name().unwrap_or_default());
println!("Description: {}", api.description().unwrap_or_default());
println!("Version: {}", api.version().unwrap_or_default());
println!(
"Created: {}",
api.created_date().unwrap().to_chrono_utc()?
);
println!();
}
Ok(())
}
```
+ Per i dettagli sull'API, consulta il *riferimento [GetRestApis](https://docs.rs/aws-sdk-apigateway/latest/aws_sdk_apigateway/client/struct.Client.html#method.get_rest_apis)all'API AWS SDK for Rust*.
## Scenari
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per Rust**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/cross_service/photo_asset_management).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
## AWS contributi della comunità
### Creare e testare un’applicazione serverless
L’esempio di codice seguente mostra come creare e testare un’applicazione serverless utilizzando Gateway API con Lambda e DynamoDB
**SDK per Rust**
Mostra come creare e testare un’applicazione serverless composta da Gateway API con Lambda e DynamoDB utilizzando l’SDK per Rust.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [GitHub](https://github.com/aws-samples/serverless-rust-demo).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
# Esempi per l’API di gestione Gateway API con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con API Gateway Management API.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `PostToConnection`
Il seguente esempio di codice mostra come utilizzare`PostToConnection`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/apigatewaymanagement#code-examples).
```
async fn send_data(
client: &aws_sdk_apigatewaymanagement::Client,
con_id: &str,
data: &str,
) -> Result<(), aws_sdk_apigatewaymanagement::Error> {
client
.post_to_connection()
.connection_id(con_id)
.data(Blob::new(data))
.send()
.await?;
Ok(())
}
let endpoint_url = format!(
"https://{api_id}.execute-api.{region}.amazonaws.com/{stage}",
api_id = api_id,
region = region,
stage = stage
);
let shared_config = aws_config::from_env().region(region_provider).load().await;
let api_management_config = config::Builder::from(&shared_config)
.endpoint_url(endpoint_url)
.build();
let client = Client::from_conf(api_management_config);
```
+ Per i dettagli sulle API, consulta la [PostToConnection](https://docs.rs/aws-sdk-apigatewaymanagementapi/latest/aws_sdk_apigatewaymanagementapi/client/struct.Client.html#method.post_to_connection)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per il servizio Application Auto Scaling con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Application Auto Scaling.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `DescribeScalingPolicies`
Il seguente esempio di codice mostra come utilizzare. `DescribeScalingPolicies`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/applicationautoscaling#code-examples).
```
async fn show_policies(client: &Client) -> Result<(), Error> {
let response = client
.describe_scaling_policies()
.service_namespace(ServiceNamespace::Ec2)
.send()
.await?;
println!("Auto Scaling Policies:");
for policy in response.scaling_policies() {
println!("{:?}\n", policy);
}
println!("Next token: {:?}", response.next_token());
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeScalingPolicies](https://docs.rs/aws-sdk-applicationautoscaling/latest/aws_sdk_applicationautoscaling/client/struct.Client.html#method.describe_scaling_policies)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Aurora con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Aurora.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello Aurora
L'esempio di codice seguente mostra come iniziare a utilizzare Aurora.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
use aws_sdk_rds::Client;
#[derive(Debug)]
struct Error(String);
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl std::error::Error for Error {}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::from_env().load().await;
let client = Client::new(&sdk_config);
let describe_db_clusters_output = client
.describe_db_clusters()
.send()
.await
.map_err(|e| Error(e.to_string()))?;
println!(
"Found {} clusters:",
describe_db_clusters_output.db_clusters().len()
);
for cluster in describe_db_clusters_output.db_clusters() {
let name = cluster.database_name().unwrap_or("Unknown");
let engine = cluster.engine().unwrap_or("Unknown");
let id = cluster.db_cluster_identifier().unwrap_or("Unknown");
let class = cluster.db_cluster_instance_class().unwrap_or("Unknown");
println!("\tDatabase: {name}",);
println!("\t Engine: {engine}",);
println!("\t ID: {id}",);
println!("\tInstance: {class}",);
}
Ok(())
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBClusters](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_clusters) nella *AWS guida di riferimento all'API SDK for Rust*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un gruppo di parametri del cluster di database Aurora personalizzati e imposta i relativi valori.
+ Crea un cluster di database che utilizza il gruppo di parametri.
+ Crea un’istanza database che contiene un database.
+ Acquisisci uno snapshot del cluster di database, quindi elimina le risorse.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
Una libreria contenente le funzioni specifiche per lo scenario Aurora.
```
use phf::{phf_set, Set};
use secrecy::SecretString;
use std::{collections::HashMap, fmt::Display, time::Duration};
use aws_sdk_rds::{
error::ProvideErrorMetadata,
operation::create_db_cluster_parameter_group::CreateDbClusterParameterGroupOutput,
types::{DbCluster, DbClusterParameterGroup, DbClusterSnapshot, DbInstance, Parameter},
};
use sdk_examples_test_utils::waiter::Waiter;
use tracing::{info, trace, warn};
const DB_ENGINE: &str = "aurora-mysql";
const DB_CLUSTER_PARAMETER_GROUP_NAME: &str = "RustSDKCodeExamplesDBParameterGroup";
const DB_CLUSTER_PARAMETER_GROUP_DESCRIPTION: &str =
"Parameter Group created by Rust SDK Code Example";
const DB_CLUSTER_IDENTIFIER: &str = "RustSDKCodeExamplesDBCluster";
const DB_INSTANCE_IDENTIFIER: &str = "RustSDKCodeExamplesDBInstance";
static FILTER_PARAMETER_NAMES: Set<&'static str> = phf_set! {
"auto_increment_offset",
"auto_increment_increment",
};
#[derive(Debug, PartialEq, Eq)]
struct MetadataError {
message: Option,
code: Option,
}
impl MetadataError {
fn from(err: &dyn ProvideErrorMetadata) -> Self {
MetadataError {
message: err.message().map(String::from),
code: err.code().map(String::from),
}
}
}
impl Display for MetadataError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let display = match (&self.message, &self.code) {
(None, None) => "Unknown".to_string(),
(None, Some(code)) => format!("({code})"),
(Some(message), None) => message.to_string(),
(Some(message), Some(code)) => format!("{message} ({code})"),
};
write!(f, "{display}")
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct ScenarioError {
message: String,
context: Option,
}
impl ScenarioError {
pub fn with(message: impl Into) -> Self {
ScenarioError {
message: message.into(),
context: None,
}
}
pub fn new(message: impl Into, err: &dyn ProvideErrorMetadata) -> Self {
ScenarioError {
message: message.into(),
context: Some(MetadataError::from(err)),
}
}
}
impl std::error::Error for ScenarioError {}
impl Display for ScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.context {
Some(c) => write!(f, "{}: {}", self.message, c),
None => write!(f, "{}", self.message),
}
}
}
// Parse the ParameterName, Description, and AllowedValues values and display them.
#[derive(Debug)]
pub struct AuroraScenarioParameter {
name: String,
allowed_values: String,
current_value: String,
}
impl Display for AuroraScenarioParameter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"{}: {} (allowed: {})",
self.name, self.current_value, self.allowed_values
)
}
}
impl From for AuroraScenarioParameter {
fn from(value: aws_sdk_rds::types::Parameter) -> Self {
AuroraScenarioParameter {
name: value.parameter_name.unwrap_or_default(),
allowed_values: value.allowed_values.unwrap_or_default(),
current_value: value.parameter_value.unwrap_or_default(),
}
}
}
pub struct AuroraScenario {
rds: crate::rds::Rds,
engine_family: Option,
engine_version: Option,
instance_class: Option,
db_cluster_parameter_group: Option,
db_cluster_identifier: Option,
db_instance_identifier: Option,
username: Option,
password: Option,
}
impl AuroraScenario {
pub fn new(client: crate::rds::Rds) -> Self {
AuroraScenario {
rds: client,
engine_family: None,
engine_version: None,
instance_class: None,
db_cluster_parameter_group: None,
db_cluster_identifier: None,
db_instance_identifier: None,
username: None,
password: None,
}
}
// Get available engine families for Aurora MySql. rds.DescribeDbEngineVersions(Engine='aurora-mysql') and build a set of the 'DBParameterGroupFamily' field values. I get {aurora-mysql8.0, aurora-mysql5.7}.
pub async fn get_engines(&self) -> Result>, ScenarioError> {
let describe_db_engine_versions = self.rds.describe_db_engine_versions(DB_ENGINE).await;
trace!(versions=?describe_db_engine_versions, "full list of versions");
if let Err(err) = describe_db_engine_versions {
return Err(ScenarioError::new(
"Failed to retrieve DB Engine Versions",
&err,
));
};
let version_count = describe_db_engine_versions
.as_ref()
.map(|o| o.db_engine_versions().len())
.unwrap_or_default();
info!(version_count, "got list of versions");
// Create a map of engine families to their available versions.
let mut versions = HashMap::>::new();
describe_db_engine_versions
.unwrap()
.db_engine_versions()
.iter()
.filter_map(
|v| match (&v.db_parameter_group_family, &v.engine_version) {
(Some(family), Some(version)) => Some((family.clone(), version.clone())),
_ => None,
},
)
.for_each(|(family, version)| versions.entry(family).or_default().push(version));
Ok(versions)
}
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))
}
// Select an engine family and create a custom DB cluster parameter group. rds.CreateDbClusterParameterGroup(DBParameterGroupFamily='aurora-mysql8.0')
pub async fn set_engine(&mut self, engine: &str, version: &str) -> Result<(), ScenarioError> {
self.engine_family = Some(engine.to_string());
self.engine_version = Some(version.to_string());
let create_db_cluster_parameter_group = self
.rds
.create_db_cluster_parameter_group(
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_CLUSTER_PARAMETER_GROUP_DESCRIPTION,
engine,
)
.await;
match create_db_cluster_parameter_group {
Ok(CreateDbClusterParameterGroupOutput {
db_cluster_parameter_group: None,
..
}) => {
return Err(ScenarioError::with(
"CreateDBClusterParameterGroup had empty response",
));
}
Err(error) => {
if error.code() == Some("DBParameterGroupAlreadyExists") {
info!("Cluster Parameter Group already exists, nothing to do");
} else {
return Err(ScenarioError::new(
"Could not create Cluster Parameter Group",
&error,
));
}
}
_ => {
info!("Created Cluster Parameter Group");
}
}
Ok(())
}
pub fn set_instance_class(&mut self, instance_class: Option) {
self.instance_class = instance_class;
}
pub fn set_login(&mut self, username: Option, password: Option) {
self.username = username;
self.password = password;
}
pub async fn connection_string(&self) -> Result {
let cluster = self.get_cluster().await?;
let endpoint = cluster.endpoint().unwrap_or_default();
let port = cluster.port().unwrap_or_default();
let username = cluster.master_username().unwrap_or_default();
Ok(format!("mysql -h {endpoint} -P {port} -u {username} -p"))
}
pub async fn get_cluster(&self) -> Result {
let describe_db_clusters_output = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_ref()
.expect("cluster identifier")
.as_str(),
)
.await;
if let Err(err) = describe_db_clusters_output {
return Err(ScenarioError::new("Failed to get cluster", &err));
}
let db_cluster = describe_db_clusters_output
.unwrap()
.db_clusters
.and_then(|output| output.first().cloned());
db_cluster.ok_or_else(|| ScenarioError::with("Did not find the cluster"))
}
// Get the parameter group. rds.DescribeDbClusterParameterGroups
// Get parameters in the group. This is a long list so you will have to paginate. Find the auto_increment_offset and auto_increment_increment parameters (by ParameterName). rds.DescribeDbClusterParameters
// Parse the ParameterName, Description, and AllowedValues values and display them.
pub async fn cluster_parameters(&self) -> Result, ScenarioError> {
let parameters_output = self
.rds
.describe_db_cluster_parameters(DB_CLUSTER_PARAMETER_GROUP_NAME)
.await;
if let Err(err) = parameters_output {
return Err(ScenarioError::new(
format!("Failed to retrieve parameters for {DB_CLUSTER_PARAMETER_GROUP_NAME}"),
&err,
));
}
let parameters = parameters_output
.unwrap()
.into_iter()
.flat_map(|p| p.parameters.unwrap_or_default().into_iter())
.filter(|p| FILTER_PARAMETER_NAMES.contains(p.parameter_name().unwrap_or_default()))
.map(AuroraScenarioParameter::from)
.collect::>();
Ok(parameters)
}
// Modify both the auto_increment_offset and auto_increment_increment parameters in one call in the custom parameter group. Set their ParameterValue fields to a new allowable value. rds.ModifyDbClusterParameterGroup.
pub async fn update_auto_increment(
&self,
offset: u8,
increment: u8,
) -> Result<(), ScenarioError> {
let modify_db_cluster_parameter_group = self
.rds
.modify_db_cluster_parameter_group(
DB_CLUSTER_PARAMETER_GROUP_NAME,
vec![
Parameter::builder()
.parameter_name("auto_increment_offset")
.parameter_value(format!("{offset}"))
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
Parameter::builder()
.parameter_name("auto_increment_increment")
.parameter_value(format!("{increment}"))
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
],
)
.await;
if let Err(error) = modify_db_cluster_parameter_group {
return Err(ScenarioError::new(
"Failed to modify cluster parameter group",
&error,
));
}
Ok(())
}
// Get a list of allowed engine versions. rds.DescribeDbEngineVersions(Engine='aurora-mysql', DBParameterGroupFamily=)
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Wait for DB cluster to be ready. Call rds.DescribeDBClusters and check for Status == 'available'.
// Get a list of instance classes available for the selected engine and engine version. rds.DescribeOrderableDbInstanceOptions(Engine='mysql', EngineVersion=).
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
pub async fn start_cluster_and_instance(&mut self) -> Result<(), ScenarioError> {
if self.password.is_none() {
return Err(ScenarioError::with(
"Must set Secret Password before starting a cluster",
));
}
let create_db_cluster = self
.rds
.create_db_cluster(
DB_CLUSTER_IDENTIFIER,
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_ENGINE,
self.engine_version.as_deref().expect("engine version"),
self.username.as_deref().expect("username"),
self.password
.replace(SecretString::new("".to_string()))
.expect("password"),
)
.await;
if let Err(err) = create_db_cluster {
return Err(ScenarioError::new(
"Failed to create DB Cluster with cluster group",
&err,
));
}
self.db_cluster_identifier = create_db_cluster
.unwrap()
.db_cluster
.and_then(|c| c.db_cluster_identifier);
if self.db_cluster_identifier.is_none() {
return Err(ScenarioError::with("Created DB Cluster missing Identifier"));
}
info!(
"Started a db cluster: {}",
self.db_cluster_identifier
.as_deref()
.unwrap_or("Missing ARN")
);
let create_db_instance = self
.rds
.create_db_instance(
self.db_cluster_identifier.as_deref().expect("cluster name"),
DB_INSTANCE_IDENTIFIER,
self.instance_class.as_deref().expect("instance class"),
DB_ENGINE,
)
.await;
if let Err(err) = create_db_instance {
return Err(ScenarioError::new(
"Failed to create Instance in DB Cluster",
&err,
));
}
self.db_instance_identifier = create_db_instance
.unwrap()
.db_instance
.and_then(|i| i.db_instance_identifier);
// Cluster creation can take up to 20 minutes to become available
let cluster_max_wait = Duration::from_secs(20 * 60);
let waiter = Waiter::builder().max(cluster_max_wait).build();
while waiter.sleep().await.is_ok() {
let cluster = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = cluster {
warn!(?err, "Failed to describe cluster while waiting for ready");
continue;
}
let instance = self
.rds
.describe_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = instance {
return Err(ScenarioError::new(
"Failed to find instance for cluster",
&err,
));
}
let instances_available = instance
.unwrap()
.db_instances()
.iter()
.all(|instance| instance.db_instance_status() == Some("Available"));
let endpoints = self
.rds
.describe_db_cluster_endpoints(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = endpoints {
return Err(ScenarioError::new(
"Failed to find endpoint for cluster",
&err,
));
}
let endpoints_available = endpoints
.unwrap()
.db_cluster_endpoints()
.iter()
.all(|endpoint| endpoint.status() == Some("available"));
if instances_available && endpoints_available {
return Ok(());
}
}
Err(ScenarioError::with("timed out waiting for cluster"))
}
// Create a snapshot of the DB cluster. rds.CreateDbClusterSnapshot.
// Wait for the snapshot to create. rds.DescribeDbClusterSnapshots until Status == 'available'.
pub async fn snapshot(&self, name: &str) -> Result {
let id = self.db_cluster_identifier.as_deref().unwrap_or_default();
let snapshot = self
.rds
.snapshot_cluster(id, format!("{id}_{name}").as_str())
.await;
match snapshot {
Ok(output) => match output.db_cluster_snapshot {
Some(snapshot) => Ok(snapshot),
None => Err(ScenarioError::with("Missing Snapshot")),
},
Err(err) => Err(ScenarioError::new("Failed to create snapshot", &err)),
}
}
pub async fn clean_up(self) -> Result<(), Vec> {
let mut clean_up_errors: Vec = vec![];
// Delete the instance. rds.DeleteDbInstance.
let delete_db_instance = self
.rds
.delete_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = delete_db_instance {
let identifier = self
.db_instance_identifier
.as_deref()
.unwrap_or("Missing Instance Identifier");
let message = format!("failed to delete db instance {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance to delete
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_instances = self.rds.describe_db_instances().await;
if let Err(err) = describe_db_instances {
clean_up_errors.push(ScenarioError::new(
"Failed to check instance state during deletion",
&err,
));
break;
}
let db_instances = describe_db_instances
.unwrap()
.db_instances()
.iter()
.filter(|instance| instance.db_cluster_identifier == self.db_cluster_identifier)
.cloned()
.collect::>();
if db_instances.is_empty() {
trace!("Delete Instance waited and no instances were found");
break;
}
match db_instances.first().unwrap().db_instance_status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but instances is in {status}");
continue;
}
None => {
warn!("No status for DB instance");
break;
}
}
}
}
// Delete the DB cluster. rds.DeleteDbCluster.
let delete_db_cluster = self
.rds
.delete_db_cluster(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = delete_db_cluster {
let identifier = self
.db_cluster_identifier
.as_deref()
.unwrap_or("Missing DB Cluster Identifier");
let message = format!("failed to delete db cluster {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance and cluster to fully delete. rds.DescribeDbInstances and rds.DescribeDbClusters until both are not found.
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_clusters = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = describe_db_clusters {
clean_up_errors.push(ScenarioError::new(
"Failed to check cluster state during deletion",
&err,
));
break;
}
let describe_db_clusters = describe_db_clusters.unwrap();
let db_clusters = describe_db_clusters.db_clusters();
if db_clusters.is_empty() {
trace!("Delete cluster waited and no clusters were found");
break;
}
match db_clusters.first().unwrap().status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but clusters is in {status}");
continue;
}
None => {
warn!("No status for DB cluster");
break;
}
}
}
}
// Delete the DB cluster parameter group. rds.DeleteDbClusterParameterGroup.
let delete_db_cluster_parameter_group = self
.rds
.delete_db_cluster_parameter_group(
self.db_cluster_parameter_group
.map(|g| {
g.db_cluster_parameter_group_name
.unwrap_or_else(|| DB_CLUSTER_PARAMETER_GROUP_NAME.to_string())
})
.as_deref()
.expect("cluster parameter group name"),
)
.await;
if let Err(error) = delete_db_cluster_parameter_group {
clean_up_errors.push(ScenarioError::new(
"Failed to delete the db cluster parameter group",
&error,
))
}
if clean_up_errors.is_empty() {
Ok(())
} else {
Err(clean_up_errors)
}
}
}
#[cfg(test)]
pub mod tests;
```
Test per la libreria attraverso automock per il wrapper del client RDS.
```
use crate::rds::MockRdsImpl;
use super::*;
use std::io::{Error, ErrorKind};
use assert_matches::assert_matches;
use aws_sdk_rds::{
error::SdkError,
operation::{
create_db_cluster::{CreateDBClusterError, CreateDbClusterOutput},
create_db_cluster_parameter_group::CreateDBClusterParameterGroupError,
create_db_cluster_snapshot::{CreateDBClusterSnapshotError, CreateDbClusterSnapshotOutput},
create_db_instance::{CreateDBInstanceError, CreateDbInstanceOutput},
delete_db_cluster::DeleteDbClusterOutput,
delete_db_cluster_parameter_group::DeleteDbClusterParameterGroupOutput,
delete_db_instance::DeleteDbInstanceOutput,
describe_db_cluster_endpoints::DescribeDbClusterEndpointsOutput,
describe_db_cluster_parameters::{
DescribeDBClusterParametersError, DescribeDbClusterParametersOutput,
},
describe_db_clusters::{DescribeDBClustersError, DescribeDbClustersOutput},
describe_db_engine_versions::{
DescribeDBEngineVersionsError, DescribeDbEngineVersionsOutput,
},
describe_db_instances::{DescribeDBInstancesError, DescribeDbInstancesOutput},
describe_orderable_db_instance_options::DescribeOrderableDBInstanceOptionsError,
modify_db_cluster_parameter_group::{
ModifyDBClusterParameterGroupError, ModifyDbClusterParameterGroupOutput,
},
},
types::{
error::DbParameterGroupAlreadyExistsFault, DbClusterEndpoint, DbEngineVersion,
OrderableDbInstanceOption,
},
};
use aws_smithy_runtime_api::http::{Response, StatusCode};
use aws_smithy_types::body::SdkBody;
use mockall::predicate::eq;
use secrecy::ExposeSecret;
#[tokio::test]
async fn test_scenario_set_engine() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.with(
eq("RustSDKCodeExamplesDBParameterGroup"),
eq("Parameter Group created by Rust SDK Code Example"),
eq("aurora-mysql"),
)
.return_once(|_, _, _| {
Ok(CreateDbClusterParameterGroupOutput::builder()
.db_cluster_parameter_group(DbClusterParameterGroup::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert_eq!(set_engine, Ok(()));
assert_eq!(Some("aurora-mysql"), scenario.engine_family.as_deref());
assert_eq!(Some("aurora-mysql8.0"), scenario.engine_version.as_deref());
}
#[tokio::test]
async fn test_scenario_set_engine_not_create() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.with(
eq("RustSDKCodeExamplesDBParameterGroup"),
eq("Parameter Group created by Rust SDK Code Example"),
eq("aurora-mysql"),
)
.return_once(|_, _, _| Ok(CreateDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert!(set_engine.is_err());
}
#[tokio::test]
async fn test_scenario_set_engine_param_group_exists() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.withf(|_, _, _| true)
.return_once(|_, _, _| {
Err(SdkError::service_error(
CreateDBClusterParameterGroupError::DbParameterGroupAlreadyExistsFault(
DbParameterGroupAlreadyExistsFault::builder().build(),
),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert!(set_engine.is_err());
}
#[tokio::test]
async fn test_scenario_get_engines() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_engine_versions()
.with(eq("aurora-mysql"))
.return_once(|_| {
Ok(DescribeDbEngineVersionsOutput::builder()
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f1")
.engine_version("f1a")
.build(),
)
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f1")
.engine_version("f1b")
.build(),
)
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f2")
.engine_version("f2a")
.build(),
)
.db_engine_versions(DbEngineVersion::builder().build())
.build())
});
let scenario = AuroraScenario::new(mock_rds);
let versions_map = scenario.get_engines().await;
assert_eq!(
versions_map,
Ok(HashMap::from([
("f1".into(), vec!["f1a".into(), "f1b".into()]),
("f2".into(), vec!["f2a".into()])
]))
);
}
#[tokio::test]
async fn test_scenario_get_engines_failed() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_engine_versions()
.with(eq("aurora-mysql"))
.return_once(|_| {
Err(SdkError::service_error(
DescribeDBEngineVersionsError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_db_engine_versions error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let scenario = AuroraScenario::new(mock_rds);
let versions_map = scenario.get_engines().await;
assert_matches!(
versions_map,
Err(ScenarioError { message, context: _ }) if message == "Failed to retrieve DB Engine Versions"
);
}
#[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"
);
}
#[tokio::test]
async fn test_scenario_get_cluster() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let cluster = scenario.get_cluster().await;
assert!(cluster.is_ok());
}
#[tokio::test]
async fn test_scenario_get_cluster_missing_cluster() {
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_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| Ok(DescribeDbClustersOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let cluster = scenario.get_cluster().await;
assert_matches!(cluster, Err(ScenarioError { message, context: _ }) if message == "Did not find the cluster");
}
#[tokio::test]
async fn test_scenario_get_cluster_error() {
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_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_db_clusters_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let cluster = scenario.get_cluster().await;
assert_matches!(cluster, Err(ScenarioError { message, context: _ }) if message == "Failed to get cluster");
}
#[tokio::test]
async fn test_scenario_connection_string() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.endpoint("test_endpoint")
.port(3306)
.master_username("test_username")
.build(),
)
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let connection_string = scenario.connection_string().await;
assert_eq!(
connection_string,
Ok("mysql -h test_endpoint -P 3306 -u test_username -p".into())
);
}
#[tokio::test]
async fn test_scenario_cluster_parameters() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_cluster_parameters()
.with(eq("RustSDKCodeExamplesDBParameterGroup"))
.return_once(|_| {
Ok(vec![DescribeDbClusterParametersOutput::builder()
.parameters(Parameter::builder().parameter_name("a").build())
.parameters(Parameter::builder().parameter_name("b").build())
.parameters(
Parameter::builder()
.parameter_name("auto_increment_offset")
.build(),
)
.parameters(Parameter::builder().parameter_name("c").build())
.parameters(
Parameter::builder()
.parameter_name("auto_increment_increment")
.build(),
)
.parameters(Parameter::builder().parameter_name("d").build())
.build()])
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let params = scenario.cluster_parameters().await.expect("cluster params");
let names: Vec = params.into_iter().map(|p| p.name).collect();
assert_eq!(
names,
vec!["auto_increment_offset", "auto_increment_increment"]
);
}
#[tokio::test]
async fn test_scenario_cluster_parameters_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_cluster_parameters()
.with(eq("RustSDKCodeExamplesDBParameterGroup"))
.return_once(|_| {
Err(SdkError::service_error(
DescribeDBClusterParametersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_db_cluster_parameters_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let params = scenario.cluster_parameters().await;
assert_matches!(params, Err(ScenarioError { message, context: _ }) if message == "Failed to retrieve parameters for RustSDKCodeExamplesDBParameterGroup");
}
#[tokio::test]
async fn test_scenario_update_auto_increment() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_modify_db_cluster_parameter_group()
.withf(|name, params| {
assert_eq!(name, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(
params,
&vec![
Parameter::builder()
.parameter_name("auto_increment_offset")
.parameter_value("10")
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
Parameter::builder()
.parameter_name("auto_increment_increment")
.parameter_value("20")
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
]
);
true
})
.return_once(|_, _| Ok(ModifyDbClusterParameterGroupOutput::builder().build()));
let scenario = AuroraScenario::new(mock_rds);
scenario
.update_auto_increment(10, 20)
.await
.expect("update auto increment");
}
#[tokio::test]
async fn test_scenario_update_auto_increment_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_modify_db_cluster_parameter_group()
.return_once(|_, _| {
Err(SdkError::service_error(
ModifyDBClusterParameterGroupError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"modify_db_cluster_parameter_group_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let scenario = AuroraScenario::new(mock_rds);
let update = scenario.update_auto_increment(10, 20).await;
assert_matches!(update, Err(ScenarioError { message, context: _}) if message == "Failed to modify cluster parameter group");
}
#[tokio::test]
async fn test_start_cluster_and_instance() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_describe_db_instance()
.with(eq("RustSDKCodeExamplesDBInstance"))
.return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
assert!(scenario
.password
.replace(SecretString::new("BAD SECRET".into()))
.unwrap()
.expose_secret()
.is_empty());
assert_eq!(
scenario.db_cluster_identifier,
Some("RustSDKCodeExamplesDBCluster".into())
);
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Err(SdkError::service_error(
CreateDBClusterError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _}) if message == "Failed to create DB Cluster with cluster group")
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_missing_id() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context:_ }) if message == "Created DB Cluster missing Identifier");
}
#[tokio::test]
async fn test_start_cluster_and_instance_instance_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.return_once(|_, _, _, _| {
Err(SdkError::service_error(
CreateDBInstanceError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db instance error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _ }) if message == "Failed to create Instance in DB Cluster")
}
#[tokio::test]
async fn test_start_cluster_and_instance_wait_hiccup() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
})
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds.expect_describe_db_instance().return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| Ok(DescribeDbInstancesOutput::builder().build()));
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| Ok(DescribeDbClustersOutput::builder().build()));
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up_errors() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| {
Err(SdkError::service_error(
DescribeDBInstancesError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db instances error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db clusters error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_err());
let errs = clean_up.unwrap_err();
assert_eq!(errs.len(), 2);
assert_matches!(errs.first(), Some(ScenarioError {message, context: _}) if message == "Failed to check instance state during deletion");
assert_matches!(errs.get(1), Some(ScenarioError {message, context: _}) if message == "Failed to check cluster state during deletion");
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_snapshot() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_snapshot_cluster()
.with(eq("MockCluster"), eq("MockCluster_MockSnapshot"))
.times(1)
.return_once(|_, _| {
Ok(CreateDbClusterSnapshotOutput::builder()
.db_cluster_snapshot(
DbClusterSnapshot::builder()
.db_cluster_identifier("MockCluster")
.db_cluster_snapshot_identifier("MockCluster_MockSnapshot")
.build(),
)
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("MockCluster".into());
let create_snapshot = scenario.snapshot("MockSnapshot").await;
assert!(create_snapshot.is_ok());
}
#[tokio::test]
async fn test_scenario_snapshot_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_snapshot_cluster()
.with(eq("MockCluster"), eq("MockCluster_MockSnapshot"))
.times(1)
.return_once(|_, _| {
Err(SdkError::service_error(
CreateDBClusterSnapshotError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create snapshot error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("MockCluster".into());
let create_snapshot = scenario.snapshot("MockSnapshot").await;
assert_matches!(create_snapshot, Err(ScenarioError { message, context: _}) if message == "Failed to create snapshot");
}
#[tokio::test]
async fn test_scenario_snapshot_invalid() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_snapshot_cluster()
.with(eq("MockCluster"), eq("MockCluster_MockSnapshot"))
.times(1)
.return_once(|_, _| Ok(CreateDbClusterSnapshotOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("MockCluster".into());
let create_snapshot = scenario.snapshot("MockSnapshot").await;
assert_matches!(create_snapshot, Err(ScenarioError { message, context: _}) if message == "Missing Snapshot");
}
```
Un file binario per eseguire lo scenario dall’inizio alla fine, utilizzando un inquirer per consentire all’utente di prendere decisioni.
```
use std::fmt::Display;
use anyhow::anyhow;
use aurora_code_examples::{
aurora_scenario::{AuroraScenario, ScenarioError},
rds::Rds as RdsClient,
};
use aws_sdk_rds::Client;
use inquire::{validator::StringValidator, CustomUserError};
use secrecy::SecretString;
use tracing::warn;
#[derive(Default, Debug)]
struct Warnings(Vec);
impl Warnings {
fn new() -> Self {
Warnings(Vec::with_capacity(5))
}
fn push(&mut self, warning: &str, error: ScenarioError) {
let formatted = format!("{warning}: {error}");
warn!("{formatted}");
self.0.push(formatted);
}
fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
impl Display for Warnings {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
writeln!(f, "Warnings:")?;
for warning in &self.0 {
writeln!(f, "{: >4}- {warning}", "")?;
}
Ok(())
}
}
fn select(
prompt: &str,
choices: Vec,
error_message: &str,
) -> Result {
inquire::Select::new(prompt, choices)
.prompt()
.map_err(|error| anyhow!("{error_message}: {error}"))
}
// Prepare the Aurora Scenario. Prompt for several settings that are optional to the Scenario, but that the user should choose for the demo.
// This includes the engine, engine version, and instance class.
async fn prepare_scenario(rds: RdsClient) -> Result {
let mut scenario = AuroraScenario::new(rds);
// Get available engine families for Aurora MySql. rds.DescribeDbEngineVersions(Engine='aurora-mysql') and build a set of the 'DBParameterGroupFamily' field values. I get {aurora-mysql8.0, aurora-mysql5.7}.
let available_engines = scenario.get_engines().await;
if let Err(error) = available_engines {
return Err(anyhow!("Failed to get available engines: {}", error));
}
let available_engines = available_engines.unwrap();
// Select an engine family and create a custom DB cluster parameter group. rds.CreateDbClusterParameterGroup(DBParameterGroupFamily='aurora-mysql8.0')
let engine = select(
"Select an Aurora engine family",
available_engines.keys().cloned().collect::>(),
"Invalid engine selection",
)?;
let version = select(
format!("Select an Aurora engine version for {engine}").as_str(),
available_engines.get(&engine).cloned().unwrap_or_default(),
"Invalid engine version selection",
)?;
let set_engine = scenario.set_engine(engine.as_str(), version.as_str()).await;
if let Err(error) = set_engine {
return Err(anyhow!("Could not set engine: {}", error));
}
let instance_classes = scenario.get_instance_classes().await;
match instance_classes {
Ok(classes) => {
let instance_class = select(
format!("Select an Aurora instance class for {engine}").as_str(),
classes,
"Invalid instance class selection",
)?;
scenario.set_instance_class(Some(instance_class))
}
Err(err) => return Err(anyhow!("Failed to get instance classes for engine: {err}")),
}
Ok(scenario)
}
// Prepare the cluster, creating a custom parameter group overriding some group parameters based on user input.
async fn prepare_cluster(scenario: &mut AuroraScenario, warnings: &mut Warnings) -> Result<(), ()> {
show_parameters(scenario, warnings).await;
let offset = prompt_number_or_default(warnings, "auto_increment_offset", 5);
let increment = prompt_number_or_default(warnings, "auto_increment_increment", 3);
// Modify both the auto_increment_offset and auto_increment_increment parameters in one call in the custom parameter group. Set their ParameterValue fields to a new allowable value. rds.ModifyDbClusterParameterGroup.
let update_auto_increment = scenario.update_auto_increment(offset, increment).await;
if let Err(error) = update_auto_increment {
warnings.push("Failed to update auto increment", error);
return Err(());
}
// Get and display the updated parameters. Specify Source of 'user' to get just the modified parameters. rds.DescribeDbClusterParameters(Source='user')
show_parameters(scenario, warnings).await;
let username = inquire::Text::new("Username for the database (default 'testuser')")
.with_default("testuser")
.with_initial_value("testuser")
.prompt();
if let Err(error) = username {
warnings.push(
"Failed to get username, using default",
ScenarioError::with(format!("Error from inquirer: {error}")),
);
return Err(());
}
let username = username.unwrap();
let password = inquire::Text::new("Password for the database (minimum 8 characters)")
.with_validator(|i: &str| {
if i.len() >= 8 {
Ok(inquire::validator::Validation::Valid)
} else {
Ok(inquire::validator::Validation::Invalid(
"Password must be at least 8 characters".into(),
))
}
})
.prompt();
let password: Option = match password {
Ok(password) => Some(SecretString::from(password)),
Err(error) => {
warnings.push(
"Failed to get password, using none (and not starting a DB)",
ScenarioError::with(format!("Error from inquirer: {error}")),
);
return Err(());
}
};
scenario.set_login(Some(username), password);
Ok(())
}
// Start a single instance in the cluster,
async fn run_instance(scenario: &mut AuroraScenario) -> Result<(), ScenarioError> {
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
scenario.start_cluster_and_instance().await?;
let connection_string = scenario.connection_string().await?;
println!("Database ready: {connection_string}",);
let _ = inquire::Text::new("Use the database with the connection string. When you're finished, press enter key to continue.").prompt();
// Create a snapshot of the DB cluster. rds.CreateDbClusterSnapshot.
// Wait for the snapshot to create. rds.DescribeDbClusterSnapshots until Status == 'available'.
let snapshot_name = inquire::Text::new("Provide a name for the snapshot")
.prompt()
.unwrap_or(String::from("ScenarioRun"));
let snapshot = scenario.snapshot(snapshot_name.as_str()).await?;
println!(
"Snapshot is available: {}",
snapshot.db_cluster_snapshot_arn().unwrap_or("Missing ARN")
);
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::from_env().load().await;
let client = Client::new(&sdk_config);
let rds = RdsClient::new(client);
let mut scenario = prepare_scenario(rds).await?;
// At this point, the scenario has things in AWS and needs to get cleaned up.
let mut warnings = Warnings::new();
if prepare_cluster(&mut scenario, &mut warnings).await.is_ok() {
println!("Configured database cluster, starting an instance.");
if let Err(err) = run_instance(&mut scenario).await {
warnings.push("Problem running instance", err);
}
}
// Clean up the instance, cluster, and parameter group, waiting for the instance and cluster to delete before moving on.
let clean_up = scenario.clean_up().await;
if let Err(errors) = clean_up {
for error in errors {
warnings.push("Problem cleaning up scenario", error);
}
}
if warnings.is_empty() {
Ok(())
} else {
println!("There were problems running the scenario:");
println!("{warnings}");
Err(anyhow!("There were problems running the scenario"))
}
}
#[derive(Clone)]
struct U8Validator {}
impl StringValidator for U8Validator {
fn validate(&self, input: &str) -> Result {
if input.parse::().is_err() {
Ok(inquire::validator::Validation::Invalid(
"Can't parse input as number".into(),
))
} else {
Ok(inquire::validator::Validation::Valid)
}
}
}
async fn show_parameters(scenario: &AuroraScenario, warnings: &mut Warnings) {
let parameters = scenario.cluster_parameters().await;
match parameters {
Ok(parameters) => {
println!("Current parameters");
for parameter in parameters {
println!("\t{parameter}");
}
}
Err(error) => warnings.push("Could not find cluster parameters", error),
}
}
fn prompt_number_or_default(warnings: &mut Warnings, name: &str, default: u8) -> u8 {
let input = inquire::Text::new(format!("Updated {name}:").as_str())
.with_validator(U8Validator {})
.prompt();
match input {
Ok(increment) => match increment.parse::() {
Ok(increment) => increment,
Err(error) => {
warnings.push(
format!("Invalid updated {name} (using {default} instead)").as_str(),
ScenarioError::with(format!("{error}")),
);
default
}
},
Err(error) => {
warnings.push(
format!("Invalid updated {name} (using {default} instead)").as_str(),
ScenarioError::with(format!("{error}")),
);
default
}
}
}
```
Un wrapper per il servizio Amazon RDS che consente l’automocking per i test.
```
use aws_sdk_rds::{
error::SdkError,
operation::{
create_db_cluster::{CreateDBClusterError, CreateDbClusterOutput},
create_db_cluster_parameter_group::CreateDBClusterParameterGroupError,
create_db_cluster_parameter_group::CreateDbClusterParameterGroupOutput,
create_db_cluster_snapshot::{CreateDBClusterSnapshotError, CreateDbClusterSnapshotOutput},
create_db_instance::{CreateDBInstanceError, CreateDbInstanceOutput},
delete_db_cluster::{DeleteDBClusterError, DeleteDbClusterOutput},
delete_db_cluster_parameter_group::{
DeleteDBClusterParameterGroupError, DeleteDbClusterParameterGroupOutput,
},
delete_db_instance::{DeleteDBInstanceError, DeleteDbInstanceOutput},
describe_db_cluster_endpoints::{
DescribeDBClusterEndpointsError, DescribeDbClusterEndpointsOutput,
},
describe_db_cluster_parameters::{
DescribeDBClusterParametersError, DescribeDbClusterParametersOutput,
},
describe_db_clusters::{DescribeDBClustersError, DescribeDbClustersOutput},
describe_db_engine_versions::{
DescribeDBEngineVersionsError, DescribeDbEngineVersionsOutput,
},
describe_db_instances::{DescribeDBInstancesError, DescribeDbInstancesOutput},
describe_orderable_db_instance_options::DescribeOrderableDBInstanceOptionsError,
modify_db_cluster_parameter_group::{
ModifyDBClusterParameterGroupError, ModifyDbClusterParameterGroupOutput,
},
},
types::{OrderableDbInstanceOption, Parameter},
Client as RdsClient,
};
use secrecy::{ExposeSecret, SecretString};
#[cfg(test)]
use mockall::automock;
#[cfg(test)]
pub use MockRdsImpl as Rds;
#[cfg(not(test))]
pub use RdsImpl as Rds;
pub struct RdsImpl {
pub inner: RdsClient,
}
#[cfg_attr(test, automock)]
impl RdsImpl {
pub fn new(inner: RdsClient) -> Self {
RdsImpl { inner }
}
pub async fn describe_db_engine_versions(
&self,
engine: &str,
) -> Result> {
self.inner
.describe_db_engine_versions()
.engine(engine)
.send()
.await
}
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
}
pub async fn create_db_cluster_parameter_group(
&self,
name: &str,
description: &str,
family: &str,
) -> Result>
{
self.inner
.create_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.description(description)
.db_parameter_group_family(family)
.send()
.await
}
pub async fn describe_db_clusters(
&self,
id: &str,
) -> Result> {
self.inner
.describe_db_clusters()
.db_cluster_identifier(id)
.send()
.await
}
pub async fn describe_db_cluster_parameters(
&self,
name: &str,
) -> Result, SdkError>
{
self.inner
.describe_db_cluster_parameters()
.db_cluster_parameter_group_name(name)
.into_paginator()
.send()
.try_collect()
.await
}
pub async fn modify_db_cluster_parameter_group(
&self,
name: &str,
parameters: Vec,
) -> Result>
{
self.inner
.modify_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.set_parameters(Some(parameters))
.send()
.await
}
pub async fn create_db_cluster(
&self,
name: &str,
parameter_group: &str,
engine: &str,
version: &str,
username: &str,
password: SecretString,
) -> Result> {
self.inner
.create_db_cluster()
.db_cluster_identifier(name)
.db_cluster_parameter_group_name(parameter_group)
.engine(engine)
.engine_version(version)
.master_username(username)
.master_user_password(password.expose_secret())
.send()
.await
}
pub async fn create_db_instance(
&self,
cluster_name: &str,
instance_name: &str,
instance_class: &str,
engine: &str,
) -> Result> {
self.inner
.create_db_instance()
.db_cluster_identifier(cluster_name)
.db_instance_identifier(instance_name)
.db_instance_class(instance_class)
.engine(engine)
.send()
.await
}
pub async fn describe_db_instance(
&self,
instance_identifier: &str,
) -> Result> {
self.inner
.describe_db_instances()
.db_instance_identifier(instance_identifier)
.send()
.await
}
pub async fn snapshot_cluster(
&self,
db_cluster_identifier: &str,
snapshot_name: &str,
) -> Result> {
self.inner
.create_db_cluster_snapshot()
.db_cluster_identifier(db_cluster_identifier)
.db_cluster_snapshot_identifier(snapshot_name)
.send()
.await
}
pub async fn describe_db_instances(
&self,
) -> Result> {
self.inner.describe_db_instances().send().await
}
pub async fn describe_db_cluster_endpoints(
&self,
cluster_identifier: &str,
) -> Result> {
self.inner
.describe_db_cluster_endpoints()
.db_cluster_identifier(cluster_identifier)
.send()
.await
}
pub async fn delete_db_instance(
&self,
instance_identifier: &str,
) -> Result> {
self.inner
.delete_db_instance()
.db_instance_identifier(instance_identifier)
.skip_final_snapshot(true)
.send()
.await
}
pub async fn delete_db_cluster(
&self,
cluster_identifier: &str,
) -> Result> {
self.inner
.delete_db_cluster()
.db_cluster_identifier(cluster_identifier)
.skip_final_snapshot(true)
.send()
.await
}
pub async fn delete_db_cluster_parameter_group(
&self,
name: &str,
) -> Result>
{
self.inner
.delete_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.send()
.await
}
}
```
Il file Cargo.toml con dipendenze utilizzato in questo scenario.
```
[package]
name = "aurora-code-examples"
authors = [
"David Souther ",
]
edition = "2021"
version = "0.1.0"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
anyhow = "1.0.75"
assert_matches = "1.5.0"
aws-config = { version = "1.0.1", features = ["behavior-version-latest"] }
aws-smithy-types = { version = "1.0.1" }
aws-smithy-runtime-api = { version = "1.0.1" }
aws-sdk-rds = { version = "1.3.0" }
inquire = "0.6.2"
mockall = "0.11.4"
phf = { version = "0.11.2", features = ["std", "macros"] }
sdk-examples-test-utils = { path = "../../test-utils" }
secrecy = "0.8.0"
tokio = { version = "1.20.1", features = ["full", "test-util"] }
tracing = "0.1.37"
tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
+ [CreaDBCluster](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster)
+ [CreaDBClusterParameterGroup](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster_parameter_group)
+ [Crea DBCluster istantanea](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster_snapshot)
+ [CreaDBInstance](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_instance)
+ [EliminaDBCluster](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_cluster)
+ [EliminaDBClusterParameterGroup](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_cluster_parameter_group)
+ [EliminaDBInstance](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_instance)
+ [Descriva DBCluster ParameterGroups](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_cluster_parameter_groups)
+ [DBClusterDescrivi parametri](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_cluster_parameters)
+ [Descrivi le DBCluster istantanee](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_cluster_snapshots)
+ [Descriva DBClusters](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_clusters)
+ [Descrivi DBEngine versioni](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_engine_versions)
+ [Descriva DBInstances](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_instances)
+ [DescribeOrderableDBInstanceOpzioni](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_orderable_db_instance_options)
+ [ModificaDBClusterParameterGroup](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.modify_db_cluster_parameter_group)
## Azioni
### `CreateDBCluster`
Il seguente esempio di codice mostra come usare`CreateDBCluster`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get a list of allowed engine versions. rds.DescribeDbEngineVersions(Engine='aurora-mysql', DBParameterGroupFamily=)
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Wait for DB cluster to be ready. Call rds.DescribeDBClusters and check for Status == 'available'.
// Get a list of instance classes available for the selected engine and engine version. rds.DescribeOrderableDbInstanceOptions(Engine='mysql', EngineVersion=).
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
pub async fn start_cluster_and_instance(&mut self) -> Result<(), ScenarioError> {
if self.password.is_none() {
return Err(ScenarioError::with(
"Must set Secret Password before starting a cluster",
));
}
let create_db_cluster = self
.rds
.create_db_cluster(
DB_CLUSTER_IDENTIFIER,
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_ENGINE,
self.engine_version.as_deref().expect("engine version"),
self.username.as_deref().expect("username"),
self.password
.replace(SecretString::new("".to_string()))
.expect("password"),
)
.await;
if let Err(err) = create_db_cluster {
return Err(ScenarioError::new(
"Failed to create DB Cluster with cluster group",
&err,
));
}
self.db_cluster_identifier = create_db_cluster
.unwrap()
.db_cluster
.and_then(|c| c.db_cluster_identifier);
if self.db_cluster_identifier.is_none() {
return Err(ScenarioError::with("Created DB Cluster missing Identifier"));
}
info!(
"Started a db cluster: {}",
self.db_cluster_identifier
.as_deref()
.unwrap_or("Missing ARN")
);
let create_db_instance = self
.rds
.create_db_instance(
self.db_cluster_identifier.as_deref().expect("cluster name"),
DB_INSTANCE_IDENTIFIER,
self.instance_class.as_deref().expect("instance class"),
DB_ENGINE,
)
.await;
if let Err(err) = create_db_instance {
return Err(ScenarioError::new(
"Failed to create Instance in DB Cluster",
&err,
));
}
self.db_instance_identifier = create_db_instance
.unwrap()
.db_instance
.and_then(|i| i.db_instance_identifier);
// Cluster creation can take up to 20 minutes to become available
let cluster_max_wait = Duration::from_secs(20 * 60);
let waiter = Waiter::builder().max(cluster_max_wait).build();
while waiter.sleep().await.is_ok() {
let cluster = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = cluster {
warn!(?err, "Failed to describe cluster while waiting for ready");
continue;
}
let instance = self
.rds
.describe_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = instance {
return Err(ScenarioError::new(
"Failed to find instance for cluster",
&err,
));
}
let instances_available = instance
.unwrap()
.db_instances()
.iter()
.all(|instance| instance.db_instance_status() == Some("Available"));
let endpoints = self
.rds
.describe_db_cluster_endpoints(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = endpoints {
return Err(ScenarioError::new(
"Failed to find endpoint for cluster",
&err,
));
}
let endpoints_available = endpoints
.unwrap()
.db_cluster_endpoints()
.iter()
.all(|endpoint| endpoint.status() == Some("available"));
if instances_available && endpoints_available {
return Ok(());
}
}
Err(ScenarioError::with("timed out waiting for cluster"))
}
pub async fn create_db_cluster(
&self,
name: &str,
parameter_group: &str,
engine: &str,
version: &str,
username: &str,
password: SecretString,
) -> Result> {
self.inner
.create_db_cluster()
.db_cluster_identifier(name)
.db_cluster_parameter_group_name(parameter_group)
.engine(engine)
.engine_version(version)
.master_username(username)
.master_user_password(password.expose_secret())
.send()
.await
}
#[tokio::test]
async fn test_start_cluster_and_instance() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_describe_db_instance()
.with(eq("RustSDKCodeExamplesDBInstance"))
.return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
assert!(scenario
.password
.replace(SecretString::new("BAD SECRET".into()))
.unwrap()
.expose_secret()
.is_empty());
assert_eq!(
scenario.db_cluster_identifier,
Some("RustSDKCodeExamplesDBCluster".into())
);
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Err(SdkError::service_error(
CreateDBClusterError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _}) if message == "Failed to create DB Cluster with cluster group")
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_missing_id() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context:_ }) if message == "Created DB Cluster missing Identifier");
}
#[tokio::test]
async fn test_start_cluster_and_instance_instance_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.return_once(|_, _, _, _| {
Err(SdkError::service_error(
CreateDBInstanceError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db instance error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _ }) if message == "Failed to create Instance in DB Cluster")
}
#[tokio::test]
async fn test_start_cluster_and_instance_wait_hiccup() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
})
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds.expect_describe_db_instance().return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [DBClusterCreate](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster) in *AWS SDK for Rust API reference.*
### `CreateDBClusterParameterGroup`
Il seguente esempio di codice mostra come utilizzare`CreateDBClusterParameterGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Select an engine family and create a custom DB cluster parameter group. rds.CreateDbClusterParameterGroup(DBParameterGroupFamily='aurora-mysql8.0')
pub async fn set_engine(&mut self, engine: &str, version: &str) -> Result<(), ScenarioError> {
self.engine_family = Some(engine.to_string());
self.engine_version = Some(version.to_string());
let create_db_cluster_parameter_group = self
.rds
.create_db_cluster_parameter_group(
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_CLUSTER_PARAMETER_GROUP_DESCRIPTION,
engine,
)
.await;
match create_db_cluster_parameter_group {
Ok(CreateDbClusterParameterGroupOutput {
db_cluster_parameter_group: None,
..
}) => {
return Err(ScenarioError::with(
"CreateDBClusterParameterGroup had empty response",
));
}
Err(error) => {
if error.code() == Some("DBParameterGroupAlreadyExists") {
info!("Cluster Parameter Group already exists, nothing to do");
} else {
return Err(ScenarioError::new(
"Could not create Cluster Parameter Group",
&error,
));
}
}
_ => {
info!("Created Cluster Parameter Group");
}
}
Ok(())
}
pub async fn create_db_cluster_parameter_group(
&self,
name: &str,
description: &str,
family: &str,
) -> Result>
{
self.inner
.create_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.description(description)
.db_parameter_group_family(family)
.send()
.await
}
#[tokio::test]
async fn test_scenario_set_engine() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.with(
eq("RustSDKCodeExamplesDBParameterGroup"),
eq("Parameter Group created by Rust SDK Code Example"),
eq("aurora-mysql"),
)
.return_once(|_, _, _| {
Ok(CreateDbClusterParameterGroupOutput::builder()
.db_cluster_parameter_group(DbClusterParameterGroup::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert_eq!(set_engine, Ok(()));
assert_eq!(Some("aurora-mysql"), scenario.engine_family.as_deref());
assert_eq!(Some("aurora-mysql8.0"), scenario.engine_version.as_deref());
}
#[tokio::test]
async fn test_scenario_set_engine_not_create() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.with(
eq("RustSDKCodeExamplesDBParameterGroup"),
eq("Parameter Group created by Rust SDK Code Example"),
eq("aurora-mysql"),
)
.return_once(|_, _, _| Ok(CreateDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert!(set_engine.is_err());
}
#[tokio::test]
async fn test_scenario_set_engine_param_group_exists() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster_parameter_group()
.withf(|_, _, _| true)
.return_once(|_, _, _| {
Err(SdkError::service_error(
CreateDBClusterParameterGroupError::DbParameterGroupAlreadyExistsFault(
DbParameterGroupAlreadyExistsFault::builder().build(),
),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
let set_engine = scenario.set_engine("aurora-mysql", "aurora-mysql8.0").await;
assert!(set_engine.is_err());
}
```
+ Per i dettagli sull'API, consulta [DBClusterParameterGroupCreate](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster_parameter_group) in *AWS SDK for Rust API reference.*
### `CreateDBClusterSnapshot`
Il seguente esempio di codice mostra come utilizzare`CreateDBClusterSnapshot`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get a list of allowed engine versions. rds.DescribeDbEngineVersions(Engine='aurora-mysql', DBParameterGroupFamily=)
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Wait for DB cluster to be ready. Call rds.DescribeDBClusters and check for Status == 'available'.
// Get a list of instance classes available for the selected engine and engine version. rds.DescribeOrderableDbInstanceOptions(Engine='mysql', EngineVersion=).
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
pub async fn start_cluster_and_instance(&mut self) -> Result<(), ScenarioError> {
if self.password.is_none() {
return Err(ScenarioError::with(
"Must set Secret Password before starting a cluster",
));
}
let create_db_cluster = self
.rds
.create_db_cluster(
DB_CLUSTER_IDENTIFIER,
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_ENGINE,
self.engine_version.as_deref().expect("engine version"),
self.username.as_deref().expect("username"),
self.password
.replace(SecretString::new("".to_string()))
.expect("password"),
)
.await;
if let Err(err) = create_db_cluster {
return Err(ScenarioError::new(
"Failed to create DB Cluster with cluster group",
&err,
));
}
self.db_cluster_identifier = create_db_cluster
.unwrap()
.db_cluster
.and_then(|c| c.db_cluster_identifier);
if self.db_cluster_identifier.is_none() {
return Err(ScenarioError::with("Created DB Cluster missing Identifier"));
}
info!(
"Started a db cluster: {}",
self.db_cluster_identifier
.as_deref()
.unwrap_or("Missing ARN")
);
let create_db_instance = self
.rds
.create_db_instance(
self.db_cluster_identifier.as_deref().expect("cluster name"),
DB_INSTANCE_IDENTIFIER,
self.instance_class.as_deref().expect("instance class"),
DB_ENGINE,
)
.await;
if let Err(err) = create_db_instance {
return Err(ScenarioError::new(
"Failed to create Instance in DB Cluster",
&err,
));
}
self.db_instance_identifier = create_db_instance
.unwrap()
.db_instance
.and_then(|i| i.db_instance_identifier);
// Cluster creation can take up to 20 minutes to become available
let cluster_max_wait = Duration::from_secs(20 * 60);
let waiter = Waiter::builder().max(cluster_max_wait).build();
while waiter.sleep().await.is_ok() {
let cluster = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = cluster {
warn!(?err, "Failed to describe cluster while waiting for ready");
continue;
}
let instance = self
.rds
.describe_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = instance {
return Err(ScenarioError::new(
"Failed to find instance for cluster",
&err,
));
}
let instances_available = instance
.unwrap()
.db_instances()
.iter()
.all(|instance| instance.db_instance_status() == Some("Available"));
let endpoints = self
.rds
.describe_db_cluster_endpoints(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = endpoints {
return Err(ScenarioError::new(
"Failed to find endpoint for cluster",
&err,
));
}
let endpoints_available = endpoints
.unwrap()
.db_cluster_endpoints()
.iter()
.all(|endpoint| endpoint.status() == Some("available"));
if instances_available && endpoints_available {
return Ok(());
}
}
Err(ScenarioError::with("timed out waiting for cluster"))
}
pub async fn snapshot_cluster(
&self,
db_cluster_identifier: &str,
snapshot_name: &str,
) -> Result> {
self.inner
.create_db_cluster_snapshot()
.db_cluster_identifier(db_cluster_identifier)
.db_cluster_snapshot_identifier(snapshot_name)
.send()
.await
}
#[tokio::test]
async fn test_start_cluster_and_instance() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_describe_db_instance()
.with(eq("RustSDKCodeExamplesDBInstance"))
.return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
assert!(scenario
.password
.replace(SecretString::new("BAD SECRET".into()))
.unwrap()
.expose_secret()
.is_empty());
assert_eq!(
scenario.db_cluster_identifier,
Some("RustSDKCodeExamplesDBCluster".into())
);
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Err(SdkError::service_error(
CreateDBClusterError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _}) if message == "Failed to create DB Cluster with cluster group")
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_missing_id() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context:_ }) if message == "Created DB Cluster missing Identifier");
}
#[tokio::test]
async fn test_start_cluster_and_instance_instance_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.return_once(|_, _, _, _| {
Err(SdkError::service_error(
CreateDBInstanceError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db instance error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _ }) if message == "Failed to create Instance in DB Cluster")
}
#[tokio::test]
async fn test_start_cluster_and_instance_wait_hiccup() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
})
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds.expect_describe_db_instance().return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Create DBCluster Snapshot](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_cluster_snapshot) in *AWS SDK for Rust API reference*.
### `CreateDBInstance`
Il seguente esempio di codice mostra come utilizzare. `CreateDBInstance`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get a list of allowed engine versions. rds.DescribeDbEngineVersions(Engine='aurora-mysql', DBParameterGroupFamily=)
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Wait for DB cluster to be ready. Call rds.DescribeDBClusters and check for Status == 'available'.
// Get a list of instance classes available for the selected engine and engine version. rds.DescribeOrderableDbInstanceOptions(Engine='mysql', EngineVersion=).
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
pub async fn start_cluster_and_instance(&mut self) -> Result<(), ScenarioError> {
if self.password.is_none() {
return Err(ScenarioError::with(
"Must set Secret Password before starting a cluster",
));
}
let create_db_cluster = self
.rds
.create_db_cluster(
DB_CLUSTER_IDENTIFIER,
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_ENGINE,
self.engine_version.as_deref().expect("engine version"),
self.username.as_deref().expect("username"),
self.password
.replace(SecretString::new("".to_string()))
.expect("password"),
)
.await;
if let Err(err) = create_db_cluster {
return Err(ScenarioError::new(
"Failed to create DB Cluster with cluster group",
&err,
));
}
self.db_cluster_identifier = create_db_cluster
.unwrap()
.db_cluster
.and_then(|c| c.db_cluster_identifier);
if self.db_cluster_identifier.is_none() {
return Err(ScenarioError::with("Created DB Cluster missing Identifier"));
}
info!(
"Started a db cluster: {}",
self.db_cluster_identifier
.as_deref()
.unwrap_or("Missing ARN")
);
let create_db_instance = self
.rds
.create_db_instance(
self.db_cluster_identifier.as_deref().expect("cluster name"),
DB_INSTANCE_IDENTIFIER,
self.instance_class.as_deref().expect("instance class"),
DB_ENGINE,
)
.await;
if let Err(err) = create_db_instance {
return Err(ScenarioError::new(
"Failed to create Instance in DB Cluster",
&err,
));
}
self.db_instance_identifier = create_db_instance
.unwrap()
.db_instance
.and_then(|i| i.db_instance_identifier);
// Cluster creation can take up to 20 minutes to become available
let cluster_max_wait = Duration::from_secs(20 * 60);
let waiter = Waiter::builder().max(cluster_max_wait).build();
while waiter.sleep().await.is_ok() {
let cluster = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = cluster {
warn!(?err, "Failed to describe cluster while waiting for ready");
continue;
}
let instance = self
.rds
.describe_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = instance {
return Err(ScenarioError::new(
"Failed to find instance for cluster",
&err,
));
}
let instances_available = instance
.unwrap()
.db_instances()
.iter()
.all(|instance| instance.db_instance_status() == Some("Available"));
let endpoints = self
.rds
.describe_db_cluster_endpoints(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = endpoints {
return Err(ScenarioError::new(
"Failed to find endpoint for cluster",
&err,
));
}
let endpoints_available = endpoints
.unwrap()
.db_cluster_endpoints()
.iter()
.all(|endpoint| endpoint.status() == Some("available"));
if instances_available && endpoints_available {
return Ok(());
}
}
Err(ScenarioError::with("timed out waiting for cluster"))
}
pub async fn create_db_instance(
&self,
cluster_name: &str,
instance_name: &str,
instance_class: &str,
engine: &str,
) -> Result> {
self.inner
.create_db_instance()
.db_cluster_identifier(cluster_name)
.db_instance_identifier(instance_name)
.db_instance_class(instance_class)
.engine(engine)
.send()
.await
}
#[tokio::test]
async fn test_start_cluster_and_instance() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_describe_db_instance()
.with(eq("RustSDKCodeExamplesDBInstance"))
.return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
assert!(scenario
.password
.replace(SecretString::new("BAD SECRET".into()))
.unwrap()
.expose_secret()
.is_empty());
assert_eq!(
scenario.db_cluster_identifier,
Some("RustSDKCodeExamplesDBCluster".into())
);
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Err(SdkError::service_error(
CreateDBClusterError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _}) if message == "Failed to create DB Cluster with cluster group")
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_missing_id() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context:_ }) if message == "Created DB Cluster missing Identifier");
}
#[tokio::test]
async fn test_start_cluster_and_instance_instance_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.return_once(|_, _, _, _| {
Err(SdkError::service_error(
CreateDBInstanceError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db instance error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _ }) if message == "Failed to create Instance in DB Cluster")
}
#[tokio::test]
async fn test_start_cluster_and_instance_wait_hiccup() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
})
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds.expect_describe_db_instance().return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [DBInstanceCreate](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.create_db_instance) in *AWS SDK for Rust API reference.*
### `DeleteDBCluster`
Il seguente esempio di codice mostra come utilizzare`DeleteDBCluster`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
pub async fn clean_up(self) -> Result<(), Vec> {
let mut clean_up_errors: Vec = vec![];
// Delete the instance. rds.DeleteDbInstance.
let delete_db_instance = self
.rds
.delete_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = delete_db_instance {
let identifier = self
.db_instance_identifier
.as_deref()
.unwrap_or("Missing Instance Identifier");
let message = format!("failed to delete db instance {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance to delete
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_instances = self.rds.describe_db_instances().await;
if let Err(err) = describe_db_instances {
clean_up_errors.push(ScenarioError::new(
"Failed to check instance state during deletion",
&err,
));
break;
}
let db_instances = describe_db_instances
.unwrap()
.db_instances()
.iter()
.filter(|instance| instance.db_cluster_identifier == self.db_cluster_identifier)
.cloned()
.collect::>();
if db_instances.is_empty() {
trace!("Delete Instance waited and no instances were found");
break;
}
match db_instances.first().unwrap().db_instance_status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but instances is in {status}");
continue;
}
None => {
warn!("No status for DB instance");
break;
}
}
}
}
// Delete the DB cluster. rds.DeleteDbCluster.
let delete_db_cluster = self
.rds
.delete_db_cluster(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = delete_db_cluster {
let identifier = self
.db_cluster_identifier
.as_deref()
.unwrap_or("Missing DB Cluster Identifier");
let message = format!("failed to delete db cluster {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance and cluster to fully delete. rds.DescribeDbInstances and rds.DescribeDbClusters until both are not found.
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_clusters = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = describe_db_clusters {
clean_up_errors.push(ScenarioError::new(
"Failed to check cluster state during deletion",
&err,
));
break;
}
let describe_db_clusters = describe_db_clusters.unwrap();
let db_clusters = describe_db_clusters.db_clusters();
if db_clusters.is_empty() {
trace!("Delete cluster waited and no clusters were found");
break;
}
match db_clusters.first().unwrap().status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but clusters is in {status}");
continue;
}
None => {
warn!("No status for DB cluster");
break;
}
}
}
}
// Delete the DB cluster parameter group. rds.DeleteDbClusterParameterGroup.
let delete_db_cluster_parameter_group = self
.rds
.delete_db_cluster_parameter_group(
self.db_cluster_parameter_group
.map(|g| {
g.db_cluster_parameter_group_name
.unwrap_or_else(|| DB_CLUSTER_PARAMETER_GROUP_NAME.to_string())
})
.as_deref()
.expect("cluster parameter group name"),
)
.await;
if let Err(error) = delete_db_cluster_parameter_group {
clean_up_errors.push(ScenarioError::new(
"Failed to delete the db cluster parameter group",
&error,
))
}
if clean_up_errors.is_empty() {
Ok(())
} else {
Err(clean_up_errors)
}
}
pub async fn delete_db_cluster(
&self,
cluster_identifier: &str,
) -> Result> {
self.inner
.delete_db_cluster()
.db_cluster_identifier(cluster_identifier)
.skip_final_snapshot(true)
.send()
.await
}
#[tokio::test]
async fn test_scenario_clean_up() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| Ok(DescribeDbInstancesOutput::builder().build()));
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| Ok(DescribeDbClustersOutput::builder().build()));
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up_errors() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| {
Err(SdkError::service_error(
DescribeDBInstancesError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db instances error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db clusters error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_err());
let errs = clean_up.unwrap_err();
assert_eq!(errs.len(), 2);
assert_matches!(errs.first(), Some(ScenarioError {message, context: _}) if message == "Failed to check instance state during deletion");
assert_matches!(errs.get(1), Some(ScenarioError {message, context: _}) if message == "Failed to check cluster state during deletion");
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Delete DBCluster](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_cluster) in *AWS SDK for Rust API reference.*
### `DeleteDBClusterParameterGroup`
Il seguente esempio di codice mostra come utilizzare`DeleteDBClusterParameterGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
pub async fn clean_up(self) -> Result<(), Vec> {
let mut clean_up_errors: Vec = vec![];
// Delete the instance. rds.DeleteDbInstance.
let delete_db_instance = self
.rds
.delete_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = delete_db_instance {
let identifier = self
.db_instance_identifier
.as_deref()
.unwrap_or("Missing Instance Identifier");
let message = format!("failed to delete db instance {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance to delete
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_instances = self.rds.describe_db_instances().await;
if let Err(err) = describe_db_instances {
clean_up_errors.push(ScenarioError::new(
"Failed to check instance state during deletion",
&err,
));
break;
}
let db_instances = describe_db_instances
.unwrap()
.db_instances()
.iter()
.filter(|instance| instance.db_cluster_identifier == self.db_cluster_identifier)
.cloned()
.collect::>();
if db_instances.is_empty() {
trace!("Delete Instance waited and no instances were found");
break;
}
match db_instances.first().unwrap().db_instance_status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but instances is in {status}");
continue;
}
None => {
warn!("No status for DB instance");
break;
}
}
}
}
// Delete the DB cluster. rds.DeleteDbCluster.
let delete_db_cluster = self
.rds
.delete_db_cluster(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = delete_db_cluster {
let identifier = self
.db_cluster_identifier
.as_deref()
.unwrap_or("Missing DB Cluster Identifier");
let message = format!("failed to delete db cluster {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance and cluster to fully delete. rds.DescribeDbInstances and rds.DescribeDbClusters until both are not found.
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_clusters = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = describe_db_clusters {
clean_up_errors.push(ScenarioError::new(
"Failed to check cluster state during deletion",
&err,
));
break;
}
let describe_db_clusters = describe_db_clusters.unwrap();
let db_clusters = describe_db_clusters.db_clusters();
if db_clusters.is_empty() {
trace!("Delete cluster waited and no clusters were found");
break;
}
match db_clusters.first().unwrap().status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but clusters is in {status}");
continue;
}
None => {
warn!("No status for DB cluster");
break;
}
}
}
}
// Delete the DB cluster parameter group. rds.DeleteDbClusterParameterGroup.
let delete_db_cluster_parameter_group = self
.rds
.delete_db_cluster_parameter_group(
self.db_cluster_parameter_group
.map(|g| {
g.db_cluster_parameter_group_name
.unwrap_or_else(|| DB_CLUSTER_PARAMETER_GROUP_NAME.to_string())
})
.as_deref()
.expect("cluster parameter group name"),
)
.await;
if let Err(error) = delete_db_cluster_parameter_group {
clean_up_errors.push(ScenarioError::new(
"Failed to delete the db cluster parameter group",
&error,
))
}
if clean_up_errors.is_empty() {
Ok(())
} else {
Err(clean_up_errors)
}
}
pub async fn delete_db_cluster_parameter_group(
&self,
name: &str,
) -> Result>
{
self.inner
.delete_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.send()
.await
}
#[tokio::test]
async fn test_scenario_clean_up() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| Ok(DescribeDbInstancesOutput::builder().build()));
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| Ok(DescribeDbClustersOutput::builder().build()));
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up_errors() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| {
Err(SdkError::service_error(
DescribeDBInstancesError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db instances error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db clusters error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_err());
let errs = clean_up.unwrap_err();
assert_eq!(errs.len(), 2);
assert_matches!(errs.first(), Some(ScenarioError {message, context: _}) if message == "Failed to check instance state during deletion");
assert_matches!(errs.get(1), Some(ScenarioError {message, context: _}) if message == "Failed to check cluster state during deletion");
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Delete DBCluster ParameterGroup](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_cluster_parameter_group) in *AWS SDK for Rust API reference.*
### `DeleteDBInstance`
Il seguente esempio di codice mostra come utilizzare`DeleteDBInstance`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
pub async fn clean_up(self) -> Result<(), Vec> {
let mut clean_up_errors: Vec = vec![];
// Delete the instance. rds.DeleteDbInstance.
let delete_db_instance = self
.rds
.delete_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = delete_db_instance {
let identifier = self
.db_instance_identifier
.as_deref()
.unwrap_or("Missing Instance Identifier");
let message = format!("failed to delete db instance {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance to delete
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_instances = self.rds.describe_db_instances().await;
if let Err(err) = describe_db_instances {
clean_up_errors.push(ScenarioError::new(
"Failed to check instance state during deletion",
&err,
));
break;
}
let db_instances = describe_db_instances
.unwrap()
.db_instances()
.iter()
.filter(|instance| instance.db_cluster_identifier == self.db_cluster_identifier)
.cloned()
.collect::>();
if db_instances.is_empty() {
trace!("Delete Instance waited and no instances were found");
break;
}
match db_instances.first().unwrap().db_instance_status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but instances is in {status}");
continue;
}
None => {
warn!("No status for DB instance");
break;
}
}
}
}
// Delete the DB cluster. rds.DeleteDbCluster.
let delete_db_cluster = self
.rds
.delete_db_cluster(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = delete_db_cluster {
let identifier = self
.db_cluster_identifier
.as_deref()
.unwrap_or("Missing DB Cluster Identifier");
let message = format!("failed to delete db cluster {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance and cluster to fully delete. rds.DescribeDbInstances and rds.DescribeDbClusters until both are not found.
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_clusters = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = describe_db_clusters {
clean_up_errors.push(ScenarioError::new(
"Failed to check cluster state during deletion",
&err,
));
break;
}
let describe_db_clusters = describe_db_clusters.unwrap();
let db_clusters = describe_db_clusters.db_clusters();
if db_clusters.is_empty() {
trace!("Delete cluster waited and no clusters were found");
break;
}
match db_clusters.first().unwrap().status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but clusters is in {status}");
continue;
}
None => {
warn!("No status for DB cluster");
break;
}
}
}
}
// Delete the DB cluster parameter group. rds.DeleteDbClusterParameterGroup.
let delete_db_cluster_parameter_group = self
.rds
.delete_db_cluster_parameter_group(
self.db_cluster_parameter_group
.map(|g| {
g.db_cluster_parameter_group_name
.unwrap_or_else(|| DB_CLUSTER_PARAMETER_GROUP_NAME.to_string())
})
.as_deref()
.expect("cluster parameter group name"),
)
.await;
if let Err(error) = delete_db_cluster_parameter_group {
clean_up_errors.push(ScenarioError::new(
"Failed to delete the db cluster parameter group",
&error,
))
}
if clean_up_errors.is_empty() {
Ok(())
} else {
Err(clean_up_errors)
}
}
pub async fn delete_db_instance(
&self,
instance_identifier: &str,
) -> Result> {
self.inner
.delete_db_instance()
.db_instance_identifier(instance_identifier)
.skip_final_snapshot(true)
.send()
.await
}
#[tokio::test]
async fn test_scenario_clean_up() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| Ok(DescribeDbInstancesOutput::builder().build()));
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| Ok(DescribeDbClustersOutput::builder().build()));
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up_errors() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| {
Err(SdkError::service_error(
DescribeDBInstancesError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db instances error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db clusters error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_err());
let errs = clean_up.unwrap_err();
assert_eq!(errs.len(), 2);
assert_matches!(errs.first(), Some(ScenarioError {message, context: _}) if message == "Failed to check instance state during deletion");
assert_matches!(errs.get(1), Some(ScenarioError {message, context: _}) if message == "Failed to check cluster state during deletion");
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Delete DBInstance](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.delete_db_instance) in *AWS SDK for Rust API reference.*
### `DescribeDBClusterParameters`
Il seguente esempio di codice mostra come utilizzare`DescribeDBClusterParameters`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get the parameter group. rds.DescribeDbClusterParameterGroups
// Get parameters in the group. This is a long list so you will have to paginate. Find the auto_increment_offset and auto_increment_increment parameters (by ParameterName). rds.DescribeDbClusterParameters
// Parse the ParameterName, Description, and AllowedValues values and display them.
pub async fn cluster_parameters(&self) -> Result, ScenarioError> {
let parameters_output = self
.rds
.describe_db_cluster_parameters(DB_CLUSTER_PARAMETER_GROUP_NAME)
.await;
if let Err(err) = parameters_output {
return Err(ScenarioError::new(
format!("Failed to retrieve parameters for {DB_CLUSTER_PARAMETER_GROUP_NAME}"),
&err,
));
}
let parameters = parameters_output
.unwrap()
.into_iter()
.flat_map(|p| p.parameters.unwrap_or_default().into_iter())
.filter(|p| FILTER_PARAMETER_NAMES.contains(p.parameter_name().unwrap_or_default()))
.map(AuroraScenarioParameter::from)
.collect::>();
Ok(parameters)
}
pub async fn describe_db_cluster_parameters(
&self,
name: &str,
) -> Result, SdkError>
{
self.inner
.describe_db_cluster_parameters()
.db_cluster_parameter_group_name(name)
.into_paginator()
.send()
.try_collect()
.await
}
#[tokio::test]
async fn test_scenario_cluster_parameters() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_cluster_parameters()
.with(eq("RustSDKCodeExamplesDBParameterGroup"))
.return_once(|_| {
Ok(vec![DescribeDbClusterParametersOutput::builder()
.parameters(Parameter::builder().parameter_name("a").build())
.parameters(Parameter::builder().parameter_name("b").build())
.parameters(
Parameter::builder()
.parameter_name("auto_increment_offset")
.build(),
)
.parameters(Parameter::builder().parameter_name("c").build())
.parameters(
Parameter::builder()
.parameter_name("auto_increment_increment")
.build(),
)
.parameters(Parameter::builder().parameter_name("d").build())
.build()])
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let params = scenario.cluster_parameters().await.expect("cluster params");
let names: Vec = params.into_iter().map(|p| p.name).collect();
assert_eq!(
names,
vec!["auto_increment_offset", "auto_increment_increment"]
);
}
#[tokio::test]
async fn test_scenario_cluster_parameters_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_cluster_parameters()
.with(eq("RustSDKCodeExamplesDBParameterGroup"))
.return_once(|_| {
Err(SdkError::service_error(
DescribeDBClusterParametersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_db_cluster_parameters_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some("RustSDKCodeExamplesDBCluster".into());
let params = scenario.cluster_parameters().await;
assert_matches!(params, Err(ScenarioError { message, context: _ }) if message == "Failed to retrieve parameters for RustSDKCodeExamplesDBParameterGroup");
}
```
+ Per i dettagli sull'API, consulta [DBClusterDescrivi i parametri](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_cluster_parameters) nell'*AWS SDK for Rust API reference.*
### `DescribeDBClusters`
Il seguente esempio di codice mostra come utilizzare`DescribeDBClusters`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get a list of allowed engine versions. rds.DescribeDbEngineVersions(Engine='aurora-mysql', DBParameterGroupFamily=)
// Create an Aurora DB cluster database cluster that contains a MySql database and uses the parameter group you created.
// Wait for DB cluster to be ready. Call rds.DescribeDBClusters and check for Status == 'available'.
// Get a list of instance classes available for the selected engine and engine version. rds.DescribeOrderableDbInstanceOptions(Engine='mysql', EngineVersion=).
// Create a database instance in the cluster.
// Wait for DB instance to be ready. Call rds.DescribeDbInstances and check for DBInstanceStatus == 'available'.
pub async fn start_cluster_and_instance(&mut self) -> Result<(), ScenarioError> {
if self.password.is_none() {
return Err(ScenarioError::with(
"Must set Secret Password before starting a cluster",
));
}
let create_db_cluster = self
.rds
.create_db_cluster(
DB_CLUSTER_IDENTIFIER,
DB_CLUSTER_PARAMETER_GROUP_NAME,
DB_ENGINE,
self.engine_version.as_deref().expect("engine version"),
self.username.as_deref().expect("username"),
self.password
.replace(SecretString::new("".to_string()))
.expect("password"),
)
.await;
if let Err(err) = create_db_cluster {
return Err(ScenarioError::new(
"Failed to create DB Cluster with cluster group",
&err,
));
}
self.db_cluster_identifier = create_db_cluster
.unwrap()
.db_cluster
.and_then(|c| c.db_cluster_identifier);
if self.db_cluster_identifier.is_none() {
return Err(ScenarioError::with("Created DB Cluster missing Identifier"));
}
info!(
"Started a db cluster: {}",
self.db_cluster_identifier
.as_deref()
.unwrap_or("Missing ARN")
);
let create_db_instance = self
.rds
.create_db_instance(
self.db_cluster_identifier.as_deref().expect("cluster name"),
DB_INSTANCE_IDENTIFIER,
self.instance_class.as_deref().expect("instance class"),
DB_ENGINE,
)
.await;
if let Err(err) = create_db_instance {
return Err(ScenarioError::new(
"Failed to create Instance in DB Cluster",
&err,
));
}
self.db_instance_identifier = create_db_instance
.unwrap()
.db_instance
.and_then(|i| i.db_instance_identifier);
// Cluster creation can take up to 20 minutes to become available
let cluster_max_wait = Duration::from_secs(20 * 60);
let waiter = Waiter::builder().max(cluster_max_wait).build();
while waiter.sleep().await.is_ok() {
let cluster = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = cluster {
warn!(?err, "Failed to describe cluster while waiting for ready");
continue;
}
let instance = self
.rds
.describe_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = instance {
return Err(ScenarioError::new(
"Failed to find instance for cluster",
&err,
));
}
let instances_available = instance
.unwrap()
.db_instances()
.iter()
.all(|instance| instance.db_instance_status() == Some("Available"));
let endpoints = self
.rds
.describe_db_cluster_endpoints(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = endpoints {
return Err(ScenarioError::new(
"Failed to find endpoint for cluster",
&err,
));
}
let endpoints_available = endpoints
.unwrap()
.db_cluster_endpoints()
.iter()
.all(|endpoint| endpoint.status() == Some("available"));
if instances_available && endpoints_available {
return Ok(());
}
}
Err(ScenarioError::with("timed out waiting for cluster"))
}
pub async fn describe_db_clusters(
&self,
id: &str,
) -> Result> {
self.inner
.describe_db_clusters()
.db_cluster_identifier(id)
.send()
.await
}
#[tokio::test]
async fn test_start_cluster_and_instance() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_describe_db_instance()
.with(eq("RustSDKCodeExamplesDBInstance"))
.return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.with(eq("RustSDKCodeExamplesDBCluster"))
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
assert!(scenario
.password
.replace(SecretString::new("BAD SECRET".into()))
.unwrap()
.expose_secret()
.is_empty());
assert_eq!(
scenario.db_cluster_identifier,
Some("RustSDKCodeExamplesDBCluster".into())
);
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Err(SdkError::service_error(
CreateDBClusterError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _}) if message == "Failed to create DB Cluster with cluster group")
}
#[tokio::test]
async fn test_start_cluster_and_instance_cluster_create_missing_id() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.return_once(|_, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context:_ }) if message == "Created DB Cluster missing Identifier");
}
#[tokio::test]
async fn test_start_cluster_and_instance_instance_create_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.return_once(|_, _, _, _| {
Err(SdkError::service_error(
CreateDBInstanceError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"create db instance error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
let create = scenario.start_cluster_and_instance().await;
assert_matches!(create, Err(ScenarioError { message, context: _ }) if message == "Failed to create Instance in DB Cluster")
}
#[tokio::test]
async fn test_start_cluster_and_instance_wait_hiccup() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_create_db_cluster()
.withf(|id, params, engine, version, username, password| {
assert_eq!(id, "RustSDKCodeExamplesDBCluster");
assert_eq!(params, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(engine, "aurora-mysql");
assert_eq!(version, "aurora-mysql8.0");
assert_eq!(username, "test username");
assert_eq!(password.expose_secret(), "test password");
true
})
.return_once(|id, _, _, _, _, _| {
Ok(CreateDbClusterOutput::builder()
.db_cluster(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds
.expect_create_db_instance()
.withf(|cluster, name, class, engine| {
assert_eq!(cluster, "RustSDKCodeExamplesDBCluster");
assert_eq!(name, "RustSDKCodeExamplesDBInstance");
assert_eq!(class, "m5.large");
assert_eq!(engine, "aurora-mysql");
true
})
.return_once(|cluster, name, class, _| {
Ok(CreateDbInstanceOutput::builder()
.db_instance(
DbInstance::builder()
.db_cluster_identifier(cluster)
.db_instance_identifier(name)
.db_instance_class(class)
.build(),
)
.build())
});
mock_rds
.expect_describe_db_clusters()
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe cluster error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
})
.with(eq("RustSDKCodeExamplesDBCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(DbCluster::builder().db_cluster_identifier(id).build())
.build())
});
mock_rds.expect_describe_db_instance().return_once(|name| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_instance_identifier(name)
.db_instance_status("Available")
.build(),
)
.build())
});
mock_rds
.expect_describe_db_cluster_endpoints()
.return_once(|_| {
Ok(DescribeDbClusterEndpointsOutput::builder()
.db_cluster_endpoints(DbClusterEndpoint::builder().status("available").build())
.build())
});
let mut scenario = AuroraScenario::new(mock_rds);
scenario.engine_version = Some("aurora-mysql8.0".into());
scenario.instance_class = Some("m5.large".into());
scenario.username = Some("test username".into());
scenario.password = Some(SecretString::new("test password".into()));
tokio::time::pause();
let assertions = tokio::spawn(async move {
let create = scenario.start_cluster_and_instance().await;
assert!(create.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBClusters](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_clusters) nella *AWS guida di riferimento all'API SDK for Rust*.
### `DescribeDBEngineVersions`
Il seguente esempio di codice mostra come utilizzare`DescribeDBEngineVersions`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Get available engine families for Aurora MySql. rds.DescribeDbEngineVersions(Engine='aurora-mysql') and build a set of the 'DBParameterGroupFamily' field values. I get {aurora-mysql8.0, aurora-mysql5.7}.
pub async fn get_engines(&self) -> Result>, ScenarioError> {
let describe_db_engine_versions = self.rds.describe_db_engine_versions(DB_ENGINE).await;
trace!(versions=?describe_db_engine_versions, "full list of versions");
if let Err(err) = describe_db_engine_versions {
return Err(ScenarioError::new(
"Failed to retrieve DB Engine Versions",
&err,
));
};
let version_count = describe_db_engine_versions
.as_ref()
.map(|o| o.db_engine_versions().len())
.unwrap_or_default();
info!(version_count, "got list of versions");
// Create a map of engine families to their available versions.
let mut versions = HashMap::>::new();
describe_db_engine_versions
.unwrap()
.db_engine_versions()
.iter()
.filter_map(
|v| match (&v.db_parameter_group_family, &v.engine_version) {
(Some(family), Some(version)) => Some((family.clone(), version.clone())),
_ => None,
},
)
.for_each(|(family, version)| versions.entry(family).or_default().push(version));
Ok(versions)
}
pub async fn describe_db_engine_versions(
&self,
engine: &str,
) -> Result> {
self.inner
.describe_db_engine_versions()
.engine(engine)
.send()
.await
}
#[tokio::test]
async fn test_scenario_get_engines() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_engine_versions()
.with(eq("aurora-mysql"))
.return_once(|_| {
Ok(DescribeDbEngineVersionsOutput::builder()
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f1")
.engine_version("f1a")
.build(),
)
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f1")
.engine_version("f1b")
.build(),
)
.db_engine_versions(
DbEngineVersion::builder()
.db_parameter_group_family("f2")
.engine_version("f2a")
.build(),
)
.db_engine_versions(DbEngineVersion::builder().build())
.build())
});
let scenario = AuroraScenario::new(mock_rds);
let versions_map = scenario.get_engines().await;
assert_eq!(
versions_map,
Ok(HashMap::from([
("f1".into(), vec!["f1a".into(), "f1b".into()]),
("f2".into(), vec!["f2a".into()])
]))
);
}
#[tokio::test]
async fn test_scenario_get_engines_failed() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_describe_db_engine_versions()
.with(eq("aurora-mysql"))
.return_once(|_| {
Err(SdkError::service_error(
DescribeDBEngineVersionsError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe_db_engine_versions error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let scenario = AuroraScenario::new(mock_rds);
let versions_map = scenario.get_engines().await;
assert_matches!(
versions_map,
Err(ScenarioError { message, context: _ }) if message == "Failed to retrieve DB Engine Versions"
);
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBEngine le versioni](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_engine_versions) nell'*AWS SDK per il riferimento all'API Rust*.
### `DescribeDBInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeDBInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
pub async fn clean_up(self) -> Result<(), Vec> {
let mut clean_up_errors: Vec = vec![];
// Delete the instance. rds.DeleteDbInstance.
let delete_db_instance = self
.rds
.delete_db_instance(
self.db_instance_identifier
.as_deref()
.expect("instance identifier"),
)
.await;
if let Err(err) = delete_db_instance {
let identifier = self
.db_instance_identifier
.as_deref()
.unwrap_or("Missing Instance Identifier");
let message = format!("failed to delete db instance {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance to delete
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_instances = self.rds.describe_db_instances().await;
if let Err(err) = describe_db_instances {
clean_up_errors.push(ScenarioError::new(
"Failed to check instance state during deletion",
&err,
));
break;
}
let db_instances = describe_db_instances
.unwrap()
.db_instances()
.iter()
.filter(|instance| instance.db_cluster_identifier == self.db_cluster_identifier)
.cloned()
.collect::>();
if db_instances.is_empty() {
trace!("Delete Instance waited and no instances were found");
break;
}
match db_instances.first().unwrap().db_instance_status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but instances is in {status}");
continue;
}
None => {
warn!("No status for DB instance");
break;
}
}
}
}
// Delete the DB cluster. rds.DeleteDbCluster.
let delete_db_cluster = self
.rds
.delete_db_cluster(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = delete_db_cluster {
let identifier = self
.db_cluster_identifier
.as_deref()
.unwrap_or("Missing DB Cluster Identifier");
let message = format!("failed to delete db cluster {identifier}");
clean_up_errors.push(ScenarioError::new(message, &err));
} else {
// Wait for the instance and cluster to fully delete. rds.DescribeDbInstances and rds.DescribeDbClusters until both are not found.
let waiter = Waiter::default();
while waiter.sleep().await.is_ok() {
let describe_db_clusters = self
.rds
.describe_db_clusters(
self.db_cluster_identifier
.as_deref()
.expect("cluster identifier"),
)
.await;
if let Err(err) = describe_db_clusters {
clean_up_errors.push(ScenarioError::new(
"Failed to check cluster state during deletion",
&err,
));
break;
}
let describe_db_clusters = describe_db_clusters.unwrap();
let db_clusters = describe_db_clusters.db_clusters();
if db_clusters.is_empty() {
trace!("Delete cluster waited and no clusters were found");
break;
}
match db_clusters.first().unwrap().status() {
Some("Deleting") => continue,
Some(status) => {
info!("Attempting to delete but clusters is in {status}");
continue;
}
None => {
warn!("No status for DB cluster");
break;
}
}
}
}
// Delete the DB cluster parameter group. rds.DeleteDbClusterParameterGroup.
let delete_db_cluster_parameter_group = self
.rds
.delete_db_cluster_parameter_group(
self.db_cluster_parameter_group
.map(|g| {
g.db_cluster_parameter_group_name
.unwrap_or_else(|| DB_CLUSTER_PARAMETER_GROUP_NAME.to_string())
})
.as_deref()
.expect("cluster parameter group name"),
)
.await;
if let Err(error) = delete_db_cluster_parameter_group {
clean_up_errors.push(ScenarioError::new(
"Failed to delete the db cluster parameter group",
&error,
))
}
if clean_up_errors.is_empty() {
Ok(())
} else {
Err(clean_up_errors)
}
}
pub async fn describe_db_instances(
&self,
) -> Result> {
self.inner.describe_db_instances().send().await
}
#[tokio::test]
async fn test_scenario_clean_up() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| Ok(DescribeDbInstancesOutput::builder().build()));
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| Ok(DescribeDbClustersOutput::builder().build()));
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_ok());
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
#[tokio::test]
async fn test_scenario_clean_up_errors() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_delete_db_instance()
.with(eq("MockInstance"))
.return_once(|_| Ok(DeleteDbInstanceOutput::builder().build()));
mock_rds
.expect_describe_db_instances()
.with()
.times(1)
.returning(|| {
Ok(DescribeDbInstancesOutput::builder()
.db_instances(
DbInstance::builder()
.db_cluster_identifier("MockCluster")
.db_instance_status("Deleting")
.build(),
)
.build())
})
.with()
.times(1)
.returning(|| {
Err(SdkError::service_error(
DescribeDBInstancesError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db instances error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster()
.with(eq("MockCluster"))
.return_once(|_| Ok(DeleteDbClusterOutput::builder().build()));
mock_rds
.expect_describe_db_clusters()
.with(eq("MockCluster"))
.times(1)
.returning(|id| {
Ok(DescribeDbClustersOutput::builder()
.db_clusters(
DbCluster::builder()
.db_cluster_identifier(id)
.status("Deleting")
.build(),
)
.build())
})
.with(eq("MockCluster"))
.times(1)
.returning(|_| {
Err(SdkError::service_error(
DescribeDBClustersError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"describe db clusters error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
mock_rds
.expect_delete_db_cluster_parameter_group()
.with(eq("MockParamGroup"))
.return_once(|_| Ok(DeleteDbClusterParameterGroupOutput::builder().build()));
let mut scenario = AuroraScenario::new(mock_rds);
scenario.db_cluster_identifier = Some(String::from("MockCluster"));
scenario.db_instance_identifier = Some(String::from("MockInstance"));
scenario.db_cluster_parameter_group = Some(
DbClusterParameterGroup::builder()
.db_cluster_parameter_group_name("MockParamGroup")
.build(),
);
tokio::time::pause();
let assertions = tokio::spawn(async move {
let clean_up = scenario.clean_up().await;
assert!(clean_up.is_err());
let errs = clean_up.unwrap_err();
assert_eq!(errs.len(), 2);
assert_matches!(errs.first(), Some(ScenarioError {message, context: _}) if message == "Failed to check instance state during deletion");
assert_matches!(errs.get(1), Some(ScenarioError {message, context: _}) if message == "Failed to check cluster state during deletion");
});
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Instances
tokio::time::advance(Duration::from_secs(1)).await; // Wait for first Describe Cluster
tokio::time::advance(Duration::from_secs(1)).await; // Wait for second Describe Cluster
tokio::time::resume();
let _ = assertions.await;
}
```
+ Per i dettagli sull'API, consulta [Descrivi DBInstances](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_db_instances) nella *AWS guida di riferimento all'API SDK for Rust*.
### `DescribeOrderableDBInstanceOptions`
Il seguente esempio di codice mostra come utilizzare`DescribeOrderableDBInstanceOptions`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
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"
);
}
```
+ Per i dettagli sull'API, consulta [DescribeOrderableDBInstanceOptions](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.describe_orderable_db_instance_options) in *AWS SDK for Rust API reference.*
### `ModifyDBClusterParameterGroup`
Il seguente esempio di codice mostra come utilizzare`ModifyDBClusterParameterGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/aurora#code-examples).
```
// Modify both the auto_increment_offset and auto_increment_increment parameters in one call in the custom parameter group. Set their ParameterValue fields to a new allowable value. rds.ModifyDbClusterParameterGroup.
pub async fn update_auto_increment(
&self,
offset: u8,
increment: u8,
) -> Result<(), ScenarioError> {
let modify_db_cluster_parameter_group = self
.rds
.modify_db_cluster_parameter_group(
DB_CLUSTER_PARAMETER_GROUP_NAME,
vec![
Parameter::builder()
.parameter_name("auto_increment_offset")
.parameter_value(format!("{offset}"))
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
Parameter::builder()
.parameter_name("auto_increment_increment")
.parameter_value(format!("{increment}"))
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
],
)
.await;
if let Err(error) = modify_db_cluster_parameter_group {
return Err(ScenarioError::new(
"Failed to modify cluster parameter group",
&error,
));
}
Ok(())
}
pub async fn modify_db_cluster_parameter_group(
&self,
name: &str,
parameters: Vec,
) -> Result>
{
self.inner
.modify_db_cluster_parameter_group()
.db_cluster_parameter_group_name(name)
.set_parameters(Some(parameters))
.send()
.await
}
#[tokio::test]
async fn test_scenario_update_auto_increment() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_modify_db_cluster_parameter_group()
.withf(|name, params| {
assert_eq!(name, "RustSDKCodeExamplesDBParameterGroup");
assert_eq!(
params,
&vec![
Parameter::builder()
.parameter_name("auto_increment_offset")
.parameter_value("10")
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
Parameter::builder()
.parameter_name("auto_increment_increment")
.parameter_value("20")
.apply_method(aws_sdk_rds::types::ApplyMethod::Immediate)
.build(),
]
);
true
})
.return_once(|_, _| Ok(ModifyDbClusterParameterGroupOutput::builder().build()));
let scenario = AuroraScenario::new(mock_rds);
scenario
.update_auto_increment(10, 20)
.await
.expect("update auto increment");
}
#[tokio::test]
async fn test_scenario_update_auto_increment_error() {
let mut mock_rds = MockRdsImpl::default();
mock_rds
.expect_modify_db_cluster_parameter_group()
.return_once(|_, _| {
Err(SdkError::service_error(
ModifyDBClusterParameterGroupError::unhandled(Box::new(Error::new(
ErrorKind::Other,
"modify_db_cluster_parameter_group_error",
))),
Response::new(StatusCode::try_from(400).unwrap(), SdkBody::empty()),
))
});
let scenario = AuroraScenario::new(mock_rds);
let update = scenario.update_auto_increment(10, 20).await;
assert_matches!(update, Err(ScenarioError { message, context: _}) if message == "Failed to modify cluster parameter group");
}
```
+ Per i dettagli sull'API, consulta [Modify DBCluster ParameterGroup](https://docs.rs/aws-sdk-rds/latest/aws_sdk_rds/client/struct.Client.html#method.modify_db_cluster_parameter_group) in *AWS SDK for Rust API reference.*
# Esempi per Auto Scaling con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Auto Scaling.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello Auto Scaling
Il seguente esempio di codice mostra come iniziare a usare Auto Scaling.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
async fn list_groups(client: &Client) -> Result<(), Error> {
let resp = client.describe_auto_scaling_groups().send().await?;
println!("Groups:");
let groups = resp.auto_scaling_groups();
for group in groups {
println!(
"Name: {}",
group.auto_scaling_group_name().unwrap_or("Unknown")
);
println!(
"Arn: {}",
group.auto_scaling_group_arn().unwrap_or("unknown"),
);
println!("Zones: {:?}", group.availability_zones(),);
println!();
}
println!("Found {} group(s)", groups.len());
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeAutoScalingGroups](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_auto_scaling_groups)guida di *riferimento all'API AWS SDK for Rust*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Creare un gruppo Amazon EC2 Auto Scaling con un modello di avvio e zone di disponibilità e ottenere informazioni sulle istanze in esecuzione.
+ Abilita la raccolta di CloudWatch metriche Amazon.
+ Aggiornare la capacità desiderata del gruppo e attendere l’avvio di un’istanza.
+ Terminare un’istanza nel gruppo.
+ Elencare le attività di dimensionamento che si verificano in risposta alle richieste degli utenti e alle modifiche della capacità.
+ Ottieni statistiche per le CloudWatch metriche, quindi ripulisci le risorse.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
[package]
name = "autoscaling-code-examples"
version = "0.1.0"
authors = ["Doug Schwartz ", "David Souther "]
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
aws-config = { version = "1.0.1", features = ["behavior-version-latest"] }
aws-sdk-autoscaling = { version = "1.3.0" }
aws-sdk-ec2 = { version = "1.3.0" }
aws-types = { version = "1.0.1" }
tokio = { version = "1.20.1", features = ["full"] }
clap = { version = "4.4", features = ["derive"] }
tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
anyhow = "1.0.75"
tracing = "0.1.37"
tokio-stream = "0.1.14"
use std::{collections::BTreeSet, fmt::Display};
use anyhow::anyhow;
use autoscaling_code_examples::scenario::{AutoScalingScenario, ScenarioError};
use tracing::{info, warn};
async fn show_scenario_description(scenario: &AutoScalingScenario, event: &str) {
let description = scenario.describe_scenario().await;
info!("DescribeAutoScalingInstances: {event}\n{description}");
}
#[derive(Default, Debug)]
struct Warnings(Vec);
impl Warnings {
pub fn push(&mut self, warning: &str, error: ScenarioError) {
let formatted = format!("{warning}: {error}");
warn!("{formatted}");
self.0.push(formatted);
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
impl Display for Warnings {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
writeln!(f, "Warnings:")?;
for warning in &self.0 {
writeln!(f, "{: >4}- {warning}", "")?;
}
Ok(())
}
}
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
tracing_subscriber::fmt::init();
let shared_config = aws_config::from_env().load().await;
let mut warnings = Warnings::default();
// 1. Create an EC2 launch template that you'll use to create an auto scaling group. Bonus: use SDK with EC2.CreateLaunchTemplate to create the launch template.
// 2. CreateAutoScalingGroup: pass it the launch template you created in step 0. Give it min/max of 1 instance.
// 4. EnableMetricsCollection: enable all metrics or a subset.
let scenario = match AutoScalingScenario::prepare_scenario(&shared_config).await {
Ok(scenario) => scenario,
Err(errs) => {
let err_str = errs
.into_iter()
.map(|e| e.to_string())
.collect::>()
.join(", ");
return Err(anyhow!("Failed to initialize scenario: {err_str}"));
}
};
info!("Prepared autoscaling scenario:\n{scenario}");
let stable = scenario.wait_for_stable(1).await;
if let Err(err) = stable {
warnings.push(
"There was a problem while waiting for group to be stable",
err,
);
}
// 3. DescribeAutoScalingInstances: show that one instance has launched.
show_scenario_description(
&scenario,
"show that the group was created and one instance has launched",
)
.await;
// 5. UpdateAutoScalingGroup: update max size to 3.
let scale_max_size = scenario.scale_max_size(3).await;
if let Err(err) = scale_max_size {
warnings.push("There was a problem scaling max size", err);
}
// 6. DescribeAutoScalingGroups: the current state of the group
show_scenario_description(
&scenario,
"show the current state of the group after setting max size",
)
.await;
// 7. SetDesiredCapacity: set desired capacity to 2.
let scale_desired_capacity = scenario.scale_desired_capacity(2).await;
if let Err(err) = scale_desired_capacity {
warnings.push("There was a problem setting desired capacity", err);
}
// Wait for a second instance to launch.
let stable = scenario.wait_for_stable(2).await;
if let Err(err) = stable {
warnings.push(
"There was a problem while waiting for group to be stable",
err,
);
}
// 8. DescribeAutoScalingInstances: show that two instances are launched.
show_scenario_description(
&scenario,
"show that two instances are launched after setting desired capacity",
)
.await;
let ids_before = scenario
.list_instances()
.await
.map(|v| v.into_iter().collect::>())
.unwrap_or_default();
// 9. TerminateInstanceInAutoScalingGroup: terminate one of the instances in the group.
let terminate_some_instance = scenario.terminate_some_instance().await;
if let Err(err) = terminate_some_instance {
warnings.push("There was a problem replacing an instance", err);
}
let wait_after_terminate = scenario.wait_for_stable(1).await;
if let Err(err) = wait_after_terminate {
warnings.push(
"There was a problem waiting after terminating an instance",
err,
);
}
let wait_scale_up_after_terminate = scenario.wait_for_stable(2).await;
if let Err(err) = wait_scale_up_after_terminate {
warnings.push(
"There was a problem waiting for scale up after terminating an instance",
err,
);
}
let ids_after = scenario
.list_instances()
.await
.map(|v| v.into_iter().collect::>())
.unwrap_or_default();
let difference = ids_after.intersection(&ids_before).count();
if !(difference == 1 && ids_before.len() == 2 && ids_after.len() == 2) {
warnings.push(
"Before and after set not different",
ScenarioError::with(format!("{difference}")),
);
}
// 10. DescribeScalingActivities: list the scaling activities that have occurred for the group so far.
show_scenario_description(
&scenario,
"list the scaling activities that have occurred for the group so far",
)
.await;
// 11. DisableMetricsCollection
let scale_group = scenario.scale_group_to_zero().await;
if let Err(err) = scale_group {
warnings.push("There was a problem scaling the group to 0", err);
}
show_scenario_description(&scenario, "Scenario scaled to 0").await;
// 12. DeleteAutoScalingGroup (to delete the group you must stop all instances):
// 13. Delete LaunchTemplate.
let clean_scenario = scenario.clean_scenario().await;
if let Err(errs) = clean_scenario {
for err in errs {
warnings.push("There was a problem cleaning the scenario", err);
}
} else {
info!("The scenario has been cleaned up!");
}
if warnings.is_empty() {
Ok(())
} else {
Err(anyhow!(
"There were warnings during scenario execution:\n{warnings}"
))
}
}
pub mod scenario;
use std::{
error::Error,
fmt::{Debug, Display},
time::{Duration, SystemTime},
};
use anyhow::anyhow;
use aws_config::SdkConfig;
use aws_sdk_autoscaling::{
error::{DisplayErrorContext, ProvideErrorMetadata},
types::{Activity, AutoScalingGroup, LaunchTemplateSpecification},
};
use aws_sdk_ec2::types::RequestLaunchTemplateData;
use tracing::trace;
const LAUNCH_TEMPLATE_NAME: &str = "SDK_Code_Examples_EC2_Autoscaling_template_from_Rust_SDK";
const AUTOSCALING_GROUP_NAME: &str = "SDK_Code_Examples_EC2_Autoscaling_Group_from_Rust_SDK";
const MAX_WAIT: Duration = Duration::from_secs(5 * 60); // Wait at most 25 seconds.
const WAIT_TIME: Duration = Duration::from_millis(500); // Wait half a second at a time.
struct Waiter {
start: SystemTime,
max: Duration,
}
impl Waiter {
fn new() -> Self {
Waiter {
start: SystemTime::now(),
max: MAX_WAIT,
}
}
async fn sleep(&self) -> Result<(), ScenarioError> {
if SystemTime::now()
.duration_since(self.start)
.unwrap_or(Duration::MAX)
> self.max
{
Err(ScenarioError::with(
"Exceeded maximum wait duration for stable group",
))
} else {
tokio::time::sleep(WAIT_TIME).await;
Ok(())
}
}
}
pub struct AutoScalingScenario {
ec2: aws_sdk_ec2::Client,
autoscaling: aws_sdk_autoscaling::Client,
launch_template_arn: String,
auto_scaling_group_name: String,
}
impl Display for AutoScalingScenario {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_fmt(format_args!(
"\tLaunch Template ID: {}\n",
self.launch_template_arn
))?;
f.write_fmt(format_args!(
"\tScaling Group Name: {}\n",
self.auto_scaling_group_name
))?;
Ok(())
}
}
pub struct AutoScalingScenarioDescription {
group: Result, ScenarioError>,
instances: Result, anyhow::Error>,
activities: Result, anyhow::Error>,
}
impl Display for AutoScalingScenarioDescription {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
writeln!(f, "\t Group status:")?;
match &self.group {
Ok(groups) => {
for status in groups {
writeln!(f, "\t\t- {status}")?;
}
}
Err(e) => writeln!(f, "\t\t! - {e}")?,
}
writeln!(f, "\t Instances:")?;
match &self.instances {
Ok(instances) => {
for instance in instances {
writeln!(f, "\t\t- {instance}")?;
}
}
Err(e) => writeln!(f, "\t\t! {e}")?,
}
writeln!(f, "\t Activities:")?;
match &self.activities {
Ok(activities) => {
for activity in activities {
writeln!(
f,
"\t\t- {} Progress: {}% Status: {:?} End: {:?}",
activity.cause().unwrap_or("Unknown"),
activity.progress.unwrap_or(-1),
activity.status_code(),
// activity.status_message().unwrap_or_default()
activity.end_time(),
)?;
}
}
Err(e) => writeln!(f, "\t\t! {e}")?,
}
Ok(())
}
}
#[derive(Debug)]
struct MetadataError {
message: Option,
code: Option,
}
impl MetadataError {
fn from(err: &dyn ProvideErrorMetadata) -> Self {
MetadataError {
message: err.message().map(|s| s.to_string()),
code: err.code().map(|s| s.to_string()),
}
}
}
impl Display for MetadataError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let display = match (&self.message, &self.code) {
(None, None) => "Unknown".to_string(),
(None, Some(code)) => format!("({code})"),
(Some(message), None) => message.to_string(),
(Some(message), Some(code)) => format!("{message} ({code})"),
};
write!(f, "{display}")
}
}
#[derive(Debug)]
pub struct ScenarioError {
message: String,
context: Option,
}
impl ScenarioError {
pub fn with(message: impl Into) -> Self {
ScenarioError {
message: message.into(),
context: None,
}
}
pub fn new(message: impl Into, err: &dyn ProvideErrorMetadata) -> Self {
ScenarioError {
message: message.into(),
context: Some(MetadataError::from(err)),
}
}
}
impl Error for ScenarioError {
// While `Error` can capture `source` information about the underlying error, for this example
// the ScenarioError captures the underlying information in MetadataError and treats it as a
// single Error from this Crate. In other contexts, it may be appropriate to model the error
// as including the SdkError as its source.
}
impl Display for ScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.context {
Some(c) => write!(f, "{}: {}", self.message, c),
None => write!(f, "{}", self.message),
}
}
}
impl AutoScalingScenario {
pub async fn prepare_scenario(sdk_config: &SdkConfig) -> Result> {
let ec2 = aws_sdk_ec2::Client::new(sdk_config);
let autoscaling = aws_sdk_autoscaling::Client::new(sdk_config);
let auto_scaling_group_name = String::from(AUTOSCALING_GROUP_NAME);
// Before creating any resources, prepare the list of AZs
let availablity_zones = ec2.describe_availability_zones().send().await;
if let Err(err) = availablity_zones {
return Err(vec![ScenarioError::new("Failed to find AZs", &err)]);
}
let availability_zones: Vec = availablity_zones
.unwrap()
.availability_zones
.unwrap_or_default()
.iter()
.take(3)
.map(|z| z.zone_name.clone().unwrap())
.collect();
// 1. Create an EC2 launch template that you'll use to create an auto scaling group. Bonus: use SDK with EC2.CreateLaunchTemplate to create the launch template.
// * Recommended: InstanceType='t1.micro', ImageId='ami-0ca285d4c2cda3300'
let create_launch_template = ec2
.create_launch_template()
.launch_template_name(LAUNCH_TEMPLATE_NAME)
.launch_template_data(
RequestLaunchTemplateData::builder()
.instance_type(aws_sdk_ec2::types::InstanceType::T1Micro)
.image_id("ami-0ca285d4c2cda3300")
.build(),
)
.send()
.await
.map_err(|err| vec![ScenarioError::new("Failed to create launch template", &err)])?;
let launch_template_arn = match create_launch_template.launch_template {
Some(launch_template) => launch_template.launch_template_id.unwrap_or_default(),
None => {
// Try to delete the launch template
let _ = ec2
.delete_launch_template()
.launch_template_name(LAUNCH_TEMPLATE_NAME)
.send()
.await;
return Err(vec![ScenarioError::with("Failed to load launch template")]);
}
};
// 2. CreateAutoScalingGroup: pass it the launch template you created in step 0. Give it min/max of 1 instance.
// You can use EC2.describe_availability_zones() to get a list of AZs (you have to specify an AZ when you create the group).
// Wait for instance to launch. Use a waiter if you have one, otherwise DescribeAutoScalingInstances until LifecycleState='InService'
if let Err(err) = autoscaling
.create_auto_scaling_group()
.auto_scaling_group_name(auto_scaling_group_name.as_str())
.launch_template(
LaunchTemplateSpecification::builder()
.launch_template_id(launch_template_arn.clone())
.version("$Latest")
.build(),
)
.max_size(1)
.min_size(1)
.set_availability_zones(Some(availability_zones))
.send()
.await
{
let mut errs = vec![ScenarioError::new(
"Failed to create autoscaling group",
&err,
)];
if let Err(err) = autoscaling
.delete_auto_scaling_group()
.auto_scaling_group_name(auto_scaling_group_name.as_str())
.send()
.await
{
errs.push(ScenarioError::new(
"Failed to clean up autoscaling group",
&err,
));
}
if let Err(err) = ec2
.delete_launch_template()
.launch_template_id(launch_template_arn.clone())
.send()
.await
{
errs.push(ScenarioError::new(
"Failed to clean up launch template",
&err,
));
}
return Err(errs);
}
let scenario = AutoScalingScenario {
ec2,
autoscaling: autoscaling.clone(), // Clients are cheap so cloning here to prevent a move is ok.
auto_scaling_group_name: auto_scaling_group_name.clone(),
launch_template_arn,
};
let enable_metrics_collection = autoscaling
.enable_metrics_collection()
.auto_scaling_group_name(auto_scaling_group_name.as_str())
.granularity("1Minute")
.set_metrics(Some(vec![
String::from("GroupMinSize"),
String::from("GroupMaxSize"),
String::from("GroupDesiredCapacity"),
String::from("GroupInServiceInstances"),
String::from("GroupTotalInstances"),
]))
.send()
.await;
match enable_metrics_collection {
Ok(_) => Ok(scenario),
Err(err) => {
scenario.clean_scenario().await?;
Err(vec![ScenarioError::new(
"Failed to enable metrics collections for group",
&err,
)])
}
}
}
pub async fn clean_scenario(self) -> Result<(), Vec> {
let _ = self.wait_for_no_scaling().await;
let delete_group = self
.autoscaling
.delete_auto_scaling_group()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.send()
.await;
// 14. Delete LaunchTemplate.
let delete_launch_template = self
.ec2
.delete_launch_template()
.launch_template_id(self.launch_template_arn.clone())
.send()
.await;
let early_exit = match (delete_group, delete_launch_template) {
(Ok(_), Ok(_)) => Ok(()),
(Ok(_), Err(e)) => Err(vec![ScenarioError::new(
"There was an error cleaning the launch template",
&e,
)]),
(Err(e), Ok(_)) => Err(vec![ScenarioError::new(
"There was an error cleaning the scale group",
&e,
)]),
(Err(e1), Err(e2)) => Err(vec![
ScenarioError::new("Multiple error cleaning the scenario Scale Group", &e1),
ScenarioError::new("Multiple error cleaning the scenario Launch Template", &e2),
]),
};
if early_exit.is_err() {
early_exit
} else {
// Wait for delete_group to finish
let waiter = Waiter::new();
let mut errors = Vec::::new();
while errors.len() < 3 {
if let Err(e) = waiter.sleep().await {
errors.push(e);
continue;
}
let describe_group = self
.autoscaling
.describe_auto_scaling_groups()
.auto_scaling_group_names(self.auto_scaling_group_name.clone())
.send()
.await;
match describe_group {
Ok(group) => match group.auto_scaling_groups().first() {
Some(group) => {
if group.status() != Some("Delete in progress") {
errors.push(ScenarioError::with(format!(
"Group in an unknown state while deleting: {}",
group.status().unwrap_or("unknown error")
)));
return Err(errors);
}
}
None => return Ok(()),
},
Err(err) => {
errors.push(ScenarioError::new("Failed to describe autoscaling group during cleanup 3 times, last error", &err));
}
}
if errors.len() > 3 {
return Err(errors);
}
}
Err(vec![ScenarioError::with(
"Exited cleanup wait loop without retuning success or failing after three rounds",
)])
}
}
pub async fn describe_scenario(&self) -> AutoScalingScenarioDescription {
let group = self
.autoscaling
.describe_auto_scaling_groups()
.auto_scaling_group_names(self.auto_scaling_group_name.clone())
.send()
.await
.map(|s| {
s.auto_scaling_groups()
.iter()
.map(|s| {
format!(
"{}: {}",
s.auto_scaling_group_name().unwrap_or("Unknown"),
s.status().unwrap_or("Unknown")
)
})
.collect::>()
})
.map_err(|e| {
ScenarioError::new("Failed to describe auto scaling groups for scenario", &e)
});
let instances = self
.list_instances()
.await
.map_err(|e| anyhow!("There was an error listing instances: {e}",));
// 10. DescribeScalingActivities: list the scaling activities that have occurred for the group so far.
// Bonus: use CloudWatch API to get and show some metrics collected for the group.
// CW.ListMetrics with Namespace='AWS/AutoScaling' and Dimensions=[{'Name': 'AutoScalingGroupName', 'Value': }]
// CW.GetMetricStatistics with Statistics='Sum'. Start and End times must be in UTC!
let activities = self
.autoscaling
.describe_scaling_activities()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.into_paginator()
.items()
.send()
.collect::, _>>()
.await
.map_err(|e| {
anyhow!(
"There was an error retrieving scaling activities: {}",
DisplayErrorContext(&e)
)
});
AutoScalingScenarioDescription {
group,
instances,
activities,
}
}
async fn get_group(&self) -> Result {
let describe_auto_scaling_groups = self
.autoscaling
.describe_auto_scaling_groups()
.auto_scaling_group_names(self.auto_scaling_group_name.clone())
.send()
.await;
if let Err(err) = describe_auto_scaling_groups {
return Err(ScenarioError::new(
format!(
"Failed to get status of autoscaling group {}",
self.auto_scaling_group_name.clone()
)
.as_str(),
&err,
));
}
let describe_auto_scaling_groups_output = describe_auto_scaling_groups.unwrap();
let auto_scaling_groups = describe_auto_scaling_groups_output.auto_scaling_groups();
let auto_scaling_group = auto_scaling_groups.first();
if auto_scaling_group.is_none() {
return Err(ScenarioError::with(format!(
"Could not find autoscaling group {}",
self.auto_scaling_group_name.clone()
)));
}
Ok(auto_scaling_group.unwrap().clone())
}
pub async fn wait_for_no_scaling(&self) -> Result<(), ScenarioError> {
let waiter = Waiter::new();
let mut scaling = true;
while scaling {
waiter.sleep().await?;
let describe_activities = self
.autoscaling
.describe_scaling_activities()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.send()
.await
.map_err(|e| {
ScenarioError::new("Failed to get autoscaling activities for group", &e)
})?;
let activities = describe_activities.activities();
trace!(
"Waiting for no scaling found {} activities",
activities.len()
);
scaling = activities.iter().any(|a| a.progress() < Some(100));
}
Ok(())
}
pub async fn wait_for_stable(&self, size: usize) -> Result<(), ScenarioError> {
self.wait_for_no_scaling().await?;
let mut group = self.get_group().await?;
let mut count = count_group_instances(&group);
let waiter = Waiter::new();
while count != size {
trace!("Waiting for stable {size} (current: {count})");
waiter.sleep().await?;
group = self.get_group().await?;
count = count_group_instances(&group);
}
Ok(())
}
pub async fn list_instances(&self) -> Result, ScenarioError> {
// The direct way to list instances is by using DescribeAutoScalingGroup's instances property. However, this returns a Vec, as opposed to a Vec.
// Ok(self.get_group().await?.instances.unwrap_or_default().map(|i| i.instance_id.clone().unwrap_or_default()).filter(|id| !id.is_empty()).collect())
// Alternatively, and for the sake of example, DescribeAutoScalingInstances returns a list that can be filtered by the client.
self.autoscaling
.describe_auto_scaling_instances()
.into_paginator()
.items()
.send()
.try_collect()
.await
.map(|items| {
items
.into_iter()
.filter(|i| {
i.auto_scaling_group_name.as_deref()
== Some(self.auto_scaling_group_name.as_str())
})
.map(|i| i.instance_id.unwrap_or_default())
.filter(|id| !id.is_empty())
.collect::>()
})
.map_err(|err| ScenarioError::new("Failed to get list of auto scaling instances", &err))
}
pub async fn scale_min_size(&self, size: i32) -> Result<(), ScenarioError> {
let update_group = self
.autoscaling
.update_auto_scaling_group()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.min_size(size)
.send()
.await;
if let Err(err) = update_group {
return Err(ScenarioError::new(
format!("Failer to update group to min size ({size}))").as_str(),
&err,
));
}
Ok(())
}
pub async fn scale_max_size(&self, size: i32) -> Result<(), ScenarioError> {
// 5. UpdateAutoScalingGroup: update max size to 3.
let update_group = self
.autoscaling
.update_auto_scaling_group()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.max_size(size)
.send()
.await;
if let Err(err) = update_group {
return Err(ScenarioError::new(
format!("Failed to update group to max size ({size})").as_str(),
&err,
));
}
Ok(())
}
pub async fn scale_desired_capacity(&self, capacity: i32) -> Result<(), ScenarioError> {
// 7. SetDesiredCapacity: set desired capacity to 2.
// Wait for a second instance to launch.
let update_group = self
.autoscaling
.set_desired_capacity()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.desired_capacity(capacity)
.send()
.await;
if let Err(err) = update_group {
return Err(ScenarioError::new(
format!("Failed to update group to desired capacity ({capacity}))").as_str(),
&err,
));
}
Ok(())
}
pub async fn scale_group_to_zero(&self) -> Result<(), ScenarioError> {
// If this fails it's fine, just means there are extra cloudwatch metrics events for the scale-down.
let _ = self
.autoscaling
.disable_metrics_collection()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.send()
.await;
// 12. DeleteAutoScalingGroup (to delete the group you must stop all instances):
// UpdateAutoScalingGroup with MinSize=0
let update_group = self
.autoscaling
.update_auto_scaling_group()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.min_size(0)
.desired_capacity(0)
.send()
.await;
if let Err(err) = update_group {
return Err(ScenarioError::new(
"Failed to update group for scaling down&",
&err,
));
}
let stable = self.wait_for_stable(0).await;
if let Err(err) = stable {
return Err(ScenarioError::with(format!(
"Error while waiting for group to be stable on scale down: {err}"
)));
}
Ok(())
}
pub async fn terminate_some_instance(&self) -> Result<(), ScenarioError> {
// Retrieve a list of instances in the auto scaling group.
let auto_scaling_group = self.get_group().await?;
let instances = auto_scaling_group.instances();
// Or use other logic to find an instance to terminate.
let instance = instances.first();
if let Some(instance) = instance {
let instance_id = if let Some(instance_id) = instance.instance_id() {
instance_id
} else {
return Err(ScenarioError::with("Missing instance id"));
};
let termination = self
.ec2
.terminate_instances()
.instance_ids(instance_id)
.send()
.await;
if let Err(err) = termination {
Err(ScenarioError::new(
"There was a problem terminating an instance",
&err,
))
} else {
Ok(())
}
} else {
Err(ScenarioError::with("There was no instance to terminate"))
}
}
}
fn count_group_instances(group: &AutoScalingGroup) -> usize {
group.instances.as_ref().map(|i| i.len()).unwrap_or(0)
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
+ [CreateAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.create_auto_scaling_group)
+ [DeleteAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.delete_auto_scaling_group)
+ [DescribeAutoScalingGroups](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_auto_scaling_groups)
+ [DescribeAutoScalingInstances](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_auto_scaling_instances)
+ [DescribeScalingActivities](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_scaling_activities)
+ [DisableMetricsCollection](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.disable_metrics_collection)
+ [EnableMetricsCollection](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.enable_metrics_collection)
+ [SetDesiredCapacity](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.set_desired_capacity)
+ [TerminateInstanceInAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.terminate_instance_in_auto_scaling_group)
+ [UpdateAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.update_auto_scaling_group)
## Azioni
### `CreateAutoScalingGroup`
Il seguente esempio di codice mostra come usare`CreateAutoScalingGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
async fn create_group(client: &Client, name: &str, id: &str) -> Result<(), Error> {
client
.create_auto_scaling_group()
.auto_scaling_group_name(name)
.instance_id(id)
.min_size(1)
.max_size(5)
.send()
.await?;
println!("Created AutoScaling group");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [CreateAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.create_auto_scaling_group)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`DeleteAutoScalingGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
async fn delete_group(client: &Client, name: &str, force: bool) -> Result<(), Error> {
client
.delete_auto_scaling_group()
.auto_scaling_group_name(name)
.set_force_delete(if force { Some(true) } else { None })
.send()
.await?;
println!("Deleted Auto Scaling group");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.delete_auto_scaling_group)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeAutoScalingGroups`
Il seguente esempio di codice mostra come utilizzare`DescribeAutoScalingGroups`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
async fn list_groups(client: &Client) -> Result<(), Error> {
let resp = client.describe_auto_scaling_groups().send().await?;
println!("Groups:");
let groups = resp.auto_scaling_groups();
for group in groups {
println!(
"Name: {}",
group.auto_scaling_group_name().unwrap_or("Unknown")
);
println!(
"Arn: {}",
group.auto_scaling_group_arn().unwrap_or("unknown"),
);
println!("Zones: {:?}", group.availability_zones(),);
println!();
}
println!("Found {} group(s)", groups.len());
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeAutoScalingGroups](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_auto_scaling_groups)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeAutoScalingInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeAutoScalingInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
pub async fn list_instances(&self) -> Result, ScenarioError> {
// The direct way to list instances is by using DescribeAutoScalingGroup's instances property. However, this returns a Vec, as opposed to a Vec.
// Ok(self.get_group().await?.instances.unwrap_or_default().map(|i| i.instance_id.clone().unwrap_or_default()).filter(|id| !id.is_empty()).collect())
// Alternatively, and for the sake of example, DescribeAutoScalingInstances returns a list that can be filtered by the client.
self.autoscaling
.describe_auto_scaling_instances()
.into_paginator()
.items()
.send()
.try_collect()
.await
.map(|items| {
items
.into_iter()
.filter(|i| {
i.auto_scaling_group_name.as_deref()
== Some(self.auto_scaling_group_name.as_str())
})
.map(|i| i.instance_id.unwrap_or_default())
.filter(|id| !id.is_empty())
.collect::>()
})
.map_err(|err| ScenarioError::new("Failed to get list of auto scaling instances", &err))
}
```
+ Per i dettagli sulle API, consulta la [DescribeAutoScalingInstances](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_auto_scaling_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeScalingActivities`
Il seguente esempio di codice mostra come utilizzare`DescribeScalingActivities`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
pub async fn describe_scenario(&self) -> AutoScalingScenarioDescription {
let group = self
.autoscaling
.describe_auto_scaling_groups()
.auto_scaling_group_names(self.auto_scaling_group_name.clone())
.send()
.await
.map(|s| {
s.auto_scaling_groups()
.iter()
.map(|s| {
format!(
"{}: {}",
s.auto_scaling_group_name().unwrap_or("Unknown"),
s.status().unwrap_or("Unknown")
)
})
.collect::>()
})
.map_err(|e| {
ScenarioError::new("Failed to describe auto scaling groups for scenario", &e)
});
let instances = self
.list_instances()
.await
.map_err(|e| anyhow!("There was an error listing instances: {e}",));
// 10. DescribeScalingActivities: list the scaling activities that have occurred for the group so far.
// Bonus: use CloudWatch API to get and show some metrics collected for the group.
// CW.ListMetrics with Namespace='AWS/AutoScaling' and Dimensions=[{'Name': 'AutoScalingGroupName', 'Value': }]
// CW.GetMetricStatistics with Statistics='Sum'. Start and End times must be in UTC!
let activities = self
.autoscaling
.describe_scaling_activities()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.into_paginator()
.items()
.send()
.collect::, _>>()
.await
.map_err(|e| {
anyhow!(
"There was an error retrieving scaling activities: {}",
DisplayErrorContext(&e)
)
});
AutoScalingScenarioDescription {
group,
instances,
activities,
}
}
```
+ Per i dettagli sulle API, consulta la [DescribeScalingActivities](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.describe_scaling_activities)guida di *riferimento all'API AWS SDK for Rust*.
### `DisableMetricsCollection`
Il seguente esempio di codice mostra come utilizzare`DisableMetricsCollection`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
// If this fails it's fine, just means there are extra cloudwatch metrics events for the scale-down.
let _ = self
.autoscaling
.disable_metrics_collection()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.send()
.await;
```
+ Per i dettagli sulle API, consulta la [DisableMetricsCollection](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.disable_metrics_collection)guida di *riferimento all'API AWS SDK for Rust*.
### `EnableMetricsCollection`
Il seguente esempio di codice mostra come utilizzare`EnableMetricsCollection`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
let enable_metrics_collection = autoscaling
.enable_metrics_collection()
.auto_scaling_group_name(auto_scaling_group_name.as_str())
.granularity("1Minute")
.set_metrics(Some(vec![
String::from("GroupMinSize"),
String::from("GroupMaxSize"),
String::from("GroupDesiredCapacity"),
String::from("GroupInServiceInstances"),
String::from("GroupTotalInstances"),
]))
.send()
.await;
```
+ Per i dettagli sulle API, consulta la [EnableMetricsCollection](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.enable_metrics_collection)guida di *riferimento all'API AWS SDK for Rust*.
### `SetDesiredCapacity`
Il seguente esempio di codice mostra come utilizzare`SetDesiredCapacity`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
pub async fn scale_desired_capacity(&self, capacity: i32) -> Result<(), ScenarioError> {
// 7. SetDesiredCapacity: set desired capacity to 2.
// Wait for a second instance to launch.
let update_group = self
.autoscaling
.set_desired_capacity()
.auto_scaling_group_name(self.auto_scaling_group_name.clone())
.desired_capacity(capacity)
.send()
.await;
if let Err(err) = update_group {
return Err(ScenarioError::new(
format!("Failed to update group to desired capacity ({capacity}))").as_str(),
&err,
));
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [SetDesiredCapacity](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.set_desired_capacity)guida di *riferimento all'API AWS SDK for Rust*.
### `TerminateInstanceInAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`TerminateInstanceInAutoScalingGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
pub async fn terminate_some_instance(&self) -> Result<(), ScenarioError> {
// Retrieve a list of instances in the auto scaling group.
let auto_scaling_group = self.get_group().await?;
let instances = auto_scaling_group.instances();
// Or use other logic to find an instance to terminate.
let instance = instances.first();
if let Some(instance) = instance {
let instance_id = if let Some(instance_id) = instance.instance_id() {
instance_id
} else {
return Err(ScenarioError::with("Missing instance id"));
};
let termination = self
.ec2
.terminate_instances()
.instance_ids(instance_id)
.send()
.await;
if let Err(err) = termination {
Err(ScenarioError::new(
"There was a problem terminating an instance",
&err,
))
} else {
Ok(())
}
} else {
Err(ScenarioError::with("There was no instance to terminate"))
}
}
async fn get_group(&self) -> Result {
let describe_auto_scaling_groups = self
.autoscaling
.describe_auto_scaling_groups()
.auto_scaling_group_names(self.auto_scaling_group_name.clone())
.send()
.await;
if let Err(err) = describe_auto_scaling_groups {
return Err(ScenarioError::new(
format!(
"Failed to get status of autoscaling group {}",
self.auto_scaling_group_name.clone()
)
.as_str(),
&err,
));
}
let describe_auto_scaling_groups_output = describe_auto_scaling_groups.unwrap();
let auto_scaling_groups = describe_auto_scaling_groups_output.auto_scaling_groups();
let auto_scaling_group = auto_scaling_groups.first();
if auto_scaling_group.is_none() {
return Err(ScenarioError::with(format!(
"Could not find autoscaling group {}",
self.auto_scaling_group_name.clone()
)));
}
Ok(auto_scaling_group.unwrap().clone())
}
```
+ Per i dettagli sulle API, consulta la [TerminateInstanceInAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.terminate_instance_in_auto_scaling_group)guida di *riferimento all'API AWS SDK for Rust*.
### `UpdateAutoScalingGroup`
Il seguente esempio di codice mostra come utilizzare`UpdateAutoScalingGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/auto-scaling#code-examples).
```
async fn update_group(client: &Client, name: &str, size: i32) -> Result<(), Error> {
client
.update_auto_scaling_group()
.auto_scaling_group_name(name)
.max_size(size)
.send()
.await?;
println!("Updated AutoScaling group");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [UpdateAutoScalingGroup](https://docs.rs/aws-sdk-autoscaling/latest/aws_sdk_autoscaling/client/struct.Client.html#method.update_auto_scaling_group)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per l’API Runtime per Amazon Bedrock con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon Bedrock Runtime.
*Scenari*: esempi di codice che mostrano come eseguire un’attività specifica chiamando più funzioni all’interno dello stesso servizio o combinate con altri Servizi AWS.
Ogni esempio include un link al codice sorgente completo, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Scenari](#scenarios)
+ [Anthropic Claude](#anthropic_claude)
## Scenari
### Utilizzo dello strumento con l’API Converse
Il seguente esempio di codice mostra come creare un'interazione tipica tra un'applicazione, un modello di intelligenza artificiale generativo e strumenti connessi o come APIs mediare le interazioni tra l'IA e il mondo esterno. Viene utilizzato l’esempio di collegamento di un’API esterna per il meteo al modello di IA in modo che vengano fornite informazioni meteorologiche in tempo reale in base sull’input dell’utente.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Scenario e logica principali della demo. Viene eseguita l’orchestrazione della conversazione tra l’utente, l’API Converse per Amazon Bedrock e uno strumento meteo.
```
#[derive(Debug)]
#[allow(dead_code)]
struct InvokeToolResult(String, ToolResultBlock);
struct ToolUseScenario {
client: Client,
conversation: Vec,
system_prompt: SystemContentBlock,
tool_config: ToolConfiguration,
}
impl ToolUseScenario {
fn new(client: Client) -> Self {
let system_prompt = SystemContentBlock::Text(SYSTEM_PROMPT.into());
let tool_config = ToolConfiguration::builder()
.tools(Tool::ToolSpec(
ToolSpecification::builder()
.name(TOOL_NAME)
.description(TOOL_DESCRIPTION)
.input_schema(ToolInputSchema::Json(make_tool_schema()))
.build()
.unwrap(),
))
.build()
.unwrap();
ToolUseScenario {
client,
conversation: vec![],
system_prompt,
tool_config,
}
}
async fn run(&mut self) -> Result<(), ToolUseScenarioError> {
loop {
let input = get_input().await?;
if input.is_none() {
break;
}
let message = Message::builder()
.role(User)
.content(ContentBlock::Text(input.unwrap()))
.build()
.map_err(ToolUseScenarioError::from)?;
self.conversation.push(message);
let response = self.send_to_bedrock().await?;
self.process_model_response(response).await?;
}
Ok(())
}
async fn send_to_bedrock(&mut self) -> Result {
debug!("Sending conversation to bedrock");
self.client
.converse()
.model_id(MODEL_ID)
.set_messages(Some(self.conversation.clone()))
.system(self.system_prompt.clone())
.tool_config(self.tool_config.clone())
.send()
.await
.map_err(ToolUseScenarioError::from)
}
async fn process_model_response(
&mut self,
mut response: ConverseOutput,
) -> Result<(), ToolUseScenarioError> {
let mut iteration = 0;
while iteration < MAX_RECURSIONS {
iteration += 1;
let message = if let Some(ref output) = response.output {
if output.is_message() {
Ok(output.as_message().unwrap().clone())
} else {
Err(ToolUseScenarioError(
"Converse Output is not a message".into(),
))
}
} else {
Err(ToolUseScenarioError("Missing Converse Output".into()))
}?;
self.conversation.push(message.clone());
match response.stop_reason {
StopReason::ToolUse => {
response = self.handle_tool_use(&message).await?;
}
StopReason::EndTurn => {
print_model_response(&message.content[0])?;
return Ok(());
}
_ => (),
}
}
Err(ToolUseScenarioError(
"Exceeded MAX_ITERATIONS when calling tools".into(),
))
}
async fn handle_tool_use(
&mut self,
message: &Message,
) -> Result {
let mut tool_results: Vec = vec![];
for block in &message.content {
match block {
ContentBlock::Text(_) => print_model_response(block)?,
ContentBlock::ToolUse(tool) => {
let tool_response = self.invoke_tool(tool).await?;
tool_results.push(ContentBlock::ToolResult(tool_response.1));
}
_ => (),
};
}
let message = Message::builder()
.role(User)
.set_content(Some(tool_results))
.build()?;
self.conversation.push(message);
self.send_to_bedrock().await
}
async fn invoke_tool(
&mut self,
tool: &ToolUseBlock,
) -> Result {
match tool.name() {
TOOL_NAME => {
println!(
"\x1b[0;90mExecuting tool: {TOOL_NAME} with input: {:?}...\x1b[0m",
tool.input()
);
let content = fetch_weather_data(tool).await?;
println!(
"\x1b[0;90mTool responded with {:?}\x1b[0m",
content.content()
);
Ok(InvokeToolResult(tool.tool_use_id.clone(), content))
}
_ => Err(ToolUseScenarioError(format!(
"The requested tool with name {} does not exist",
tool.name()
))),
}
}
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let mut scenario = ToolUseScenario::new(client);
header();
if let Err(err) = scenario.run().await {
println!("There was an error running the scenario! {}", err.0)
}
footer();
}
```
Strumento meteo utilizzato dalla demo. Questo script definisce le specifiche dello strumento e implementa la logica per recuperare i dati meteorologici utilizzando l’API Open-Meteo.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Utilità per stampare i blocchi di contenuto dei messaggi.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Utilizza istruzioni, utilità Error e costanti.
```
use std::{collections::HashMap, io::stdin};
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::{BuildError, SdkError},
operation::converse::{ConverseError, ConverseOutput},
types::{
ContentBlock, ConversationRole::User, Message, StopReason, SystemContentBlock, Tool,
ToolConfiguration, ToolInputSchema, ToolResultBlock, ToolResultContentBlock,
ToolSpecification, ToolUseBlock,
},
Client,
};
use aws_smithy_runtime_api::http::Response;
use aws_smithy_types::Document;
use tracing::debug;
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
const SYSTEM_PROMPT: &str = "You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
";
// The maximum number of recursive calls allowed in the tool_use_demo function.
// This helps prevent infinite loops and potential performance issues.
const MAX_RECURSIONS: i8 = 5;
const TOOL_NAME: &str = "Weather_Tool";
const TOOL_DESCRIPTION: &str =
"Get the current weather for a given location, based on its WGS84 coordinates.";
fn make_tool_schema() -> Document {
Document::Object(HashMap::::from([
("type".into(), Document::String("object".into())),
(
"properties".into(),
Document::Object(HashMap::from([
(
"latitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String("Geographical WGS84 latitude of the location.".into()),
),
])),
),
(
"longitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String(
"Geographical WGS84 longitude of the location.".into(),
),
),
])),
),
])),
),
(
"required".into(),
Document::Array(vec![
Document::String("latitude".into()),
Document::String("longitude".into()),
]),
),
]))
}
#[derive(Debug)]
struct ToolUseScenarioError(String);
impl std::fmt::Display for ToolUseScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Tool use error with '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl From<&str> for ToolUseScenarioError {
fn from(value: &str) -> Self {
ToolUseScenarioError(value.into())
}
}
impl From for ToolUseScenarioError {
fn from(value: BuildError) -> Self {
ToolUseScenarioError(value.to_string().clone())
}
}
impl From> for ToolUseScenarioError {
fn from(value: SdkError) -> Self {
ToolUseScenarioError(match value.as_service_error() {
Some(value) => value.meta().message().unwrap_or("Unknown").into(),
None => "Unknown".into(),
})
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
## Anthropic Claude
### Converse
L’esempio di codice seguente mostra come inviare un messaggio di testo ad Anthropic Claude utilizzando l’API Converse di Bedrock.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Invia un messaggio di testo ad Anthropic Claude utilizzando l’API Converse di Bedrock.
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
match response {
Ok(output) => {
let text = get_converse_output_text(output)?;
println!("{}", text);
Ok(())
}
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseError::from)
.unwrap_or_else(|| BedrockConverseError("Unknown service error".into()))),
}
}
fn get_converse_output_text(output: ConverseOutput) -> Result {
let text = output
.output()
.ok_or("no output")?
.as_message()
.map_err(|_| "output not a message")?
.content()
.first()
.ok_or("no content in message")?
.as_text()
.map_err(|_| "content is not text")?
.to_string();
Ok(text)
}
```
Utilizza istruzioni, utilità Error e costanti.
```
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
operation::converse::{ConverseError, ConverseOutput},
types::{ContentBlock, ConversationRole, Message},
Client,
};
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
// Start a conversation with the user message.
const USER_MESSAGE: &str = "Describe the purpose of a 'hello world' program in one line.";
#[derive(Debug)]
struct BedrockConverseError(String);
impl std::fmt::Display for BedrockConverseError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Can't invoke '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl std::error::Error for BedrockConverseError {}
impl From<&str> for BedrockConverseError {
fn from(value: &str) -> Self {
BedrockConverseError(value.to_string())
}
}
impl From<&ConverseError> for BedrockConverseError {
fn from(value: &ConverseError) -> Self {
BedrockConverseError::from(match value {
ConverseError::ModelTimeoutException(_) => "Model took too long",
ConverseError::ModelNotReadyException(_) => "Model is not ready",
_ => "Unknown",
})
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
### ConverseStream
L’esempio di codice seguente mostra come inviare un messaggio di testo ad Anthropic Claude utilizzando l’API Converse di Bedrock ed elaborare il flusso di risposta in tempo reale.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Invia un messaggio di testo a Anthropic Claude e trasmetti in streaming i token di risposta, utilizzando l'API di Bedrock. ConverseStream
```
#[tokio::main]
async fn main() -> Result<(), BedrockConverseStreamError> {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let response = client
.converse_stream()
.model_id(MODEL_ID)
.messages(
Message::builder()
.role(ConversationRole::User)
.content(ContentBlock::Text(USER_MESSAGE.to_string()))
.build()
.map_err(|_| "failed to build message")?,
)
.send()
.await;
let mut stream = match response {
Ok(output) => Ok(output.stream),
Err(e) => Err(BedrockConverseStreamError::from(
e.as_service_error().unwrap(),
)),
}?;
loop {
let token = stream.recv().await;
match token {
Ok(Some(text)) => {
let next = get_converse_output_text(text)?;
print!("{}", next);
Ok(())
}
Ok(None) => break,
Err(e) => Err(e
.as_service_error()
.map(BedrockConverseStreamError::from)
.unwrap_or(BedrockConverseStreamError(
"Unknown error receiving stream".into(),
))),
}?
}
println!();
Ok(())
}
fn get_converse_output_text(
output: ConverseStreamOutputType,
) -> Result {
Ok(match output {
ConverseStreamOutputType::ContentBlockDelta(event) => match event.delta() {
Some(delta) => delta.as_text().cloned().unwrap_or_else(|_| "".into()),
None => "".into(),
},
_ => "".into(),
})
}
```
Utilizza istruzioni, utilità Error e costanti.
```
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::ProvideErrorMetadata,
operation::converse_stream::ConverseStreamError,
types::{
error::ConverseStreamOutputError, ContentBlock, ConversationRole,
ConverseStreamOutput as ConverseStreamOutputType, Message,
},
Client,
};
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
// Start a conversation with the user message.
const USER_MESSAGE: &str = "Describe the purpose of a 'hello world' program in one line.";
#[derive(Debug)]
struct BedrockConverseStreamError(String);
impl std::fmt::Display for BedrockConverseStreamError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Can't invoke '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl std::error::Error for BedrockConverseStreamError {}
impl From<&str> for BedrockConverseStreamError {
fn from(value: &str) -> Self {
BedrockConverseStreamError(value.into())
}
}
impl From<&ConverseStreamError> for BedrockConverseStreamError {
fn from(value: &ConverseStreamError) -> Self {
BedrockConverseStreamError(
match value {
ConverseStreamError::ModelTimeoutException(_) => "Model took too long",
ConverseStreamError::ModelNotReadyException(_) => "Model is not ready",
_ => "Unknown",
}
.into(),
)
}
}
impl From<&ConverseStreamOutputError> for BedrockConverseStreamError {
fn from(value: &ConverseStreamOutputError) -> Self {
match value {
ConverseStreamOutputError::ValidationException(ve) => BedrockConverseStreamError(
ve.message().unwrap_or("Unknown ValidationException").into(),
),
ConverseStreamOutputError::ThrottlingException(te) => BedrockConverseStreamError(
te.message().unwrap_or("Unknown ThrottlingException").into(),
),
value => BedrockConverseStreamError(
value
.message()
.unwrap_or("Unknown StreamOutput exception")
.into(),
),
}
}
}
```
+ Per i dettagli sulle API, consulta la guida di riferimento [ConverseStream](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse_stream)all'API *AWS SDK* for Rust.
### Scenario: utilizzo dello strumento con l’API Converse
Il seguente esempio di codice mostra come creare un'interazione tipica tra un'applicazione, un modello di intelligenza artificiale generativo e strumenti connessi o come APIs mediare le interazioni tra l'IA e il mondo esterno. Viene utilizzato l’esempio di collegamento di un’API esterna per il meteo al modello di IA in modo che vengano fornite informazioni meteorologiche in tempo reale in base sull’input dell’utente.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-runtime#code-examples).
Scenario e logica principali della demo. Viene eseguita l’orchestrazione della conversazione tra l’utente, l’API Converse per Amazon Bedrock e uno strumento meteo.
```
#[derive(Debug)]
#[allow(dead_code)]
struct InvokeToolResult(String, ToolResultBlock);
struct ToolUseScenario {
client: Client,
conversation: Vec,
system_prompt: SystemContentBlock,
tool_config: ToolConfiguration,
}
impl ToolUseScenario {
fn new(client: Client) -> Self {
let system_prompt = SystemContentBlock::Text(SYSTEM_PROMPT.into());
let tool_config = ToolConfiguration::builder()
.tools(Tool::ToolSpec(
ToolSpecification::builder()
.name(TOOL_NAME)
.description(TOOL_DESCRIPTION)
.input_schema(ToolInputSchema::Json(make_tool_schema()))
.build()
.unwrap(),
))
.build()
.unwrap();
ToolUseScenario {
client,
conversation: vec![],
system_prompt,
tool_config,
}
}
async fn run(&mut self) -> Result<(), ToolUseScenarioError> {
loop {
let input = get_input().await?;
if input.is_none() {
break;
}
let message = Message::builder()
.role(User)
.content(ContentBlock::Text(input.unwrap()))
.build()
.map_err(ToolUseScenarioError::from)?;
self.conversation.push(message);
let response = self.send_to_bedrock().await?;
self.process_model_response(response).await?;
}
Ok(())
}
async fn send_to_bedrock(&mut self) -> Result {
debug!("Sending conversation to bedrock");
self.client
.converse()
.model_id(MODEL_ID)
.set_messages(Some(self.conversation.clone()))
.system(self.system_prompt.clone())
.tool_config(self.tool_config.clone())
.send()
.await
.map_err(ToolUseScenarioError::from)
}
async fn process_model_response(
&mut self,
mut response: ConverseOutput,
) -> Result<(), ToolUseScenarioError> {
let mut iteration = 0;
while iteration < MAX_RECURSIONS {
iteration += 1;
let message = if let Some(ref output) = response.output {
if output.is_message() {
Ok(output.as_message().unwrap().clone())
} else {
Err(ToolUseScenarioError(
"Converse Output is not a message".into(),
))
}
} else {
Err(ToolUseScenarioError("Missing Converse Output".into()))
}?;
self.conversation.push(message.clone());
match response.stop_reason {
StopReason::ToolUse => {
response = self.handle_tool_use(&message).await?;
}
StopReason::EndTurn => {
print_model_response(&message.content[0])?;
return Ok(());
}
_ => (),
}
}
Err(ToolUseScenarioError(
"Exceeded MAX_ITERATIONS when calling tools".into(),
))
}
async fn handle_tool_use(
&mut self,
message: &Message,
) -> Result {
let mut tool_results: Vec = vec![];
for block in &message.content {
match block {
ContentBlock::Text(_) => print_model_response(block)?,
ContentBlock::ToolUse(tool) => {
let tool_response = self.invoke_tool(tool).await?;
tool_results.push(ContentBlock::ToolResult(tool_response.1));
}
_ => (),
};
}
let message = Message::builder()
.role(User)
.set_content(Some(tool_results))
.build()?;
self.conversation.push(message);
self.send_to_bedrock().await
}
async fn invoke_tool(
&mut self,
tool: &ToolUseBlock,
) -> Result {
match tool.name() {
TOOL_NAME => {
println!(
"\x1b[0;90mExecuting tool: {TOOL_NAME} with input: {:?}...\x1b[0m",
tool.input()
);
let content = fetch_weather_data(tool).await?;
println!(
"\x1b[0;90mTool responded with {:?}\x1b[0m",
content.content()
);
Ok(InvokeToolResult(tool.tool_use_id.clone(), content))
}
_ => Err(ToolUseScenarioError(format!(
"The requested tool with name {} does not exist",
tool.name()
))),
}
}
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::defaults(BehaviorVersion::latest())
.region(CLAUDE_REGION)
.load()
.await;
let client = Client::new(&sdk_config);
let mut scenario = ToolUseScenario::new(client);
header();
if let Err(err) = scenario.run().await {
println!("There was an error running the scenario! {}", err.0)
}
footer();
}
```
Strumento meteo utilizzato dalla demo. Questo script definisce le specifiche dello strumento e implementa la logica per recuperare i dati meteorologici utilizzando l’API Open-Meteo.
```
const ENDPOINT: &str = "https://api.open-meteo.com/v1/forecast";
async fn fetch_weather_data(
tool_use: &ToolUseBlock,
) -> Result {
let input = tool_use.input();
let latitude = input
.as_object()
.unwrap()
.get("latitude")
.unwrap()
.as_string()
.unwrap();
let longitude = input
.as_object()
.unwrap()
.get("longitude")
.unwrap()
.as_string()
.unwrap();
let params = [
("latitude", latitude),
("longitude", longitude),
("current_weather", "true"),
];
debug!("Calling {ENDPOINT} with {params:?}");
let response = reqwest::Client::new()
.get(ENDPOINT)
.query(¶ms)
.send()
.await
.map_err(|e| ToolUseScenarioError(format!("Error requesting weather: {e:?}")))?
.error_for_status()
.map_err(|e| ToolUseScenarioError(format!("Failed to request weather: {e:?}")))?;
debug!("Response: {response:?}");
let bytes = response
.bytes()
.await
.map_err(|e| ToolUseScenarioError(format!("Error reading response: {e:?}")))?;
let result = String::from_utf8(bytes.to_vec())
.map_err(|_| ToolUseScenarioError("Response was not utf8".into()))?;
Ok(ToolResultBlock::builder()
.tool_use_id(tool_use.tool_use_id())
.content(ToolResultContentBlock::Text(result))
.build()?)
}
```
Utilità per stampare i blocchi di contenuto dei messaggi.
```
fn print_model_response(block: &ContentBlock) -> Result<(), ToolUseScenarioError> {
if block.is_text() {
let text = block.as_text().unwrap();
println!("\x1b[0;90mThe model's response:\x1b[0m\n{text}");
Ok(())
} else {
Err(ToolUseScenarioError(format!(
"Content block is not text ({block:?})"
)))
}
}
```
Utilizza istruzioni, utilità Error e costanti.
```
use std::{collections::HashMap, io::stdin};
use aws_config::BehaviorVersion;
use aws_sdk_bedrockruntime::{
error::{BuildError, SdkError},
operation::converse::{ConverseError, ConverseOutput},
types::{
ContentBlock, ConversationRole::User, Message, StopReason, SystemContentBlock, Tool,
ToolConfiguration, ToolInputSchema, ToolResultBlock, ToolResultContentBlock,
ToolSpecification, ToolUseBlock,
},
Client,
};
use aws_smithy_runtime_api::http::Response;
use aws_smithy_types::Document;
use tracing::debug;
// Set the model ID, e.g., Claude 3 Haiku.
const MODEL_ID: &str = "anthropic.claude-3-haiku-20240307-v1:0";
const CLAUDE_REGION: &str = "us-east-1";
const SYSTEM_PROMPT: &str = "You are a weather assistant that provides current weather data for user-specified locations using only
the Weather_Tool, which expects latitude and longitude. Infer the coordinates from the location yourself.
If the user provides coordinates, infer the approximate location and refer to it in your response.
To use the tool, you strictly apply the provided tool specification.
- Explain your step-by-step process, and give brief updates before each step.
- Only use the Weather_Tool for data. Never guess or make up information.
- Repeat the tool use for subsequent requests if necessary.
- If the tool errors, apologize, explain weather is unavailable, and suggest other options.
- Report temperatures in °C (°F) and wind in km/h (mph). Keep weather reports concise. Sparingly use
emojis where appropriate.
- Only respond to weather queries. Remind off-topic users of your purpose.
- Never claim to search online, access external data, or use tools besides Weather_Tool.
- Complete the entire process until you have all required data before sending the complete response.
";
// The maximum number of recursive calls allowed in the tool_use_demo function.
// This helps prevent infinite loops and potential performance issues.
const MAX_RECURSIONS: i8 = 5;
const TOOL_NAME: &str = "Weather_Tool";
const TOOL_DESCRIPTION: &str =
"Get the current weather for a given location, based on its WGS84 coordinates.";
fn make_tool_schema() -> Document {
Document::Object(HashMap::::from([
("type".into(), Document::String("object".into())),
(
"properties".into(),
Document::Object(HashMap::from([
(
"latitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String("Geographical WGS84 latitude of the location.".into()),
),
])),
),
(
"longitude".into(),
Document::Object(HashMap::from([
("type".into(), Document::String("string".into())),
(
"description".into(),
Document::String(
"Geographical WGS84 longitude of the location.".into(),
),
),
])),
),
])),
),
(
"required".into(),
Document::Array(vec![
Document::String("latitude".into()),
Document::String("longitude".into()),
]),
),
]))
}
#[derive(Debug)]
struct ToolUseScenarioError(String);
impl std::fmt::Display for ToolUseScenarioError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Tool use error with '{}'. Reason: {}", MODEL_ID, self.0)
}
}
impl From<&str> for ToolUseScenarioError {
fn from(value: &str) -> Self {
ToolUseScenarioError(value.into())
}
}
impl From for ToolUseScenarioError {
fn from(value: BuildError) -> Self {
ToolUseScenarioError(value.to_string().clone())
}
}
impl From> for ToolUseScenarioError {
fn from(value: SdkError) -> Self {
ToolUseScenarioError(match value.as_service_error() {
Some(value) => value.meta().message().unwrap_or("Unknown").into(),
None => "Unknown".into(),
})
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Converse](https://docs.rs/aws-sdk-bedrockruntime/latest/aws_sdk_bedrockruntime/client/struct.Client.html#method.converse) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
# Esempi per l’API Runtime per Agent per Amazon Bedrock con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK for Rust con Amazon Bedrock Agents Runtime.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `InvokeAgent`
Il seguente esempio di codice mostra come usare. `InvokeAgent`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/bedrock-agent-runtime#code-examples).
```
use aws_config::{BehaviorVersion, SdkConfig};
use aws_sdk_bedrockagentruntime::{
self as bedrockagentruntime,
types::{error::ResponseStreamError, ResponseStream},
};
#[allow(unused_imports)]
use mockall::automock;
const BEDROCK_AGENT_ID: &str = "AJBHXXILZN";
const BEDROCK_AGENT_ALIAS_ID: &str = "AVKP1ITZAA";
const BEDROCK_AGENT_REGION: &str = "us-east-1";
#[cfg(not(test))]
pub use EventReceiverImpl as EventReceiver;
#[cfg(test)]
pub use MockEventReceiverImpl as EventReceiver;
pub struct EventReceiverImpl {
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
}
#[cfg_attr(test, automock)]
impl EventReceiverImpl {
#[allow(dead_code)]
pub fn new(
inner: aws_sdk_bedrockagentruntime::primitives::event_stream::EventReceiver<
ResponseStream,
ResponseStreamError,
>,
) -> Self {
Self { inner }
}
pub async fn recv(
&mut self,
) -> Result<
Option,
aws_sdk_bedrockagentruntime::error::SdkError<
ResponseStreamError,
aws_smithy_types::event_stream::RawMessage,
>,
> {
self.inner.recv().await
}
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let result = invoke_bedrock_agent("I need help.".to_string(), "123".to_string()).await?;
println!("{}", result);
Ok(())
}
async fn invoke_bedrock_agent(
prompt: String,
session_id: String,
) -> Result {
let sdk_config: SdkConfig = aws_config::defaults(BehaviorVersion::latest())
.region(BEDROCK_AGENT_REGION)
.load()
.await;
let bedrock_client = bedrockagentruntime::Client::new(&sdk_config);
let command_builder = bedrock_client
.invoke_agent()
.agent_id(BEDROCK_AGENT_ID)
.agent_alias_id(BEDROCK_AGENT_ALIAS_ID)
.session_id(session_id)
.input_text(prompt);
let response = command_builder.send().await?;
let response_stream = response.completion;
let event_receiver = EventReceiver::new(response_stream);
process_agent_response_stream(event_receiver).await
}
async fn process_agent_response_stream(
mut event_receiver: EventReceiver,
) -> Result {
let mut full_agent_text_response = String::new();
while let Some(event_result) = event_receiver.recv().await? {
match event_result {
ResponseStream::Chunk(chunk) => {
if let Some(bytes) = chunk.bytes {
match String::from_utf8(bytes.into_inner()) {
Ok(text_chunk) => {
full_agent_text_response.push_str(&text_chunk);
}
Err(e) => {
eprintln!("UTF-8 decoding error for chunk: {}", e);
}
}
}
}
_ => {
panic!("received an unhandled event type from Bedrock stream",);
}
}
}
Ok(full_agent_text_response)
}
#[cfg(test)]
mod test {
use super::*;
#[tokio::test]
async fn test_process_agent_response_stream() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Chunk(
aws_sdk_bedrockagentruntime::types::PayloadPart::builder()
.set_bytes(Some(aws_smithy_types::Blob::new(vec![
116, 101, 115, 116, 32, 99, 111, 109, 112, 108, 101, 116, 105, 111, 110,
])))
.build(),
),
))
});
// end the stream
mock.expect_recv().times(1).returning(|| Ok(None));
let response = process_agent_response_stream(mock).await.unwrap();
assert_eq!("test completion", response);
}
#[tokio::test]
#[should_panic(expected = "received an unhandled event type from Bedrock stream")]
async fn test_process_agent_response_stream_error() {
let mut mock = MockEventReceiverImpl::default();
mock.expect_recv().times(1).returning(|| {
Ok(Some(
aws_sdk_bedrockagentruntime::types::ResponseStream::Trace(
aws_sdk_bedrockagentruntime::types::TracePart::builder().build(),
),
))
});
let _ = process_agent_response_stream(mock).await.unwrap();
}
}
```
+ Per i dettagli sulle API, consulta la [InvokeAgent](https://docs.rs/aws-sdk-bedrockagentruntime/latest/aws_sdk_bedrockagentruntime/client/struct.Client.html#method.invoke_agent)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per il gestore dell’identità per Amazon Cognito con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon Cognito Identity Provider.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `ListUserPools`
Il seguente esempio di codice mostra come usare. `ListUserPools`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/cognitoidentityprovider#code-examples).
```
async fn show_pools(client: &Client) -> Result<(), Error> {
let response = client.list_user_pools().max_results(10).send().await?;
let pools = response.user_pools();
println!("User pools:");
for pool in pools {
println!(" ID: {}", pool.id().unwrap_or_default());
println!(" Name: {}", pool.name().unwrap_or_default());
println!(" Lambda Config: {:?}", pool.lambda_config().unwrap());
println!(
" Last modified: {}",
pool.last_modified_date().unwrap().to_chrono_utc()?
);
println!(
" Creation date: {:?}",
pool.creation_date().unwrap().to_chrono_utc()
);
println!();
}
println!("Next token: {}", response.next_token().unwrap_or_default());
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [ListUserPools](https://docs.rs/aws-sdk-cognitoidentityprovider/latest/aws_sdk_cognitoidentityprovider/client/struct.Client.html#method.list_user_pools)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon Cognito Sync con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon Cognito Sync.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `ListIdentityPoolUsage`
Il seguente esempio di codice mostra come usare. `ListIdentityPoolUsage`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/cognitosync#code-examples).
```
async fn show_pools(client: &Client) -> Result<(), Error> {
let response = client
.list_identity_pool_usage()
.max_results(10)
.send()
.await?;
let pools = response.identity_pool_usages();
println!("Identity pools:");
for pool in pools {
println!(
" Identity pool ID: {}",
pool.identity_pool_id().unwrap_or_default()
);
println!(
" Data storage: {}",
pool.data_storage().unwrap_or_default()
);
println!(
" Sync sessions count: {}",
pool.sync_sessions_count().unwrap_or_default()
);
println!(
" Last modified: {}",
pool.last_modified_date().unwrap().to_chrono_utc()?
);
println!();
}
println!("Next token: {}", response.next_token().unwrap_or_default());
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [ListIdentityPoolUsage](https://docs.rs/aws-sdk-cognitosync/latest/aws_sdk_cognitosync/client/struct.Client.html#method.list_identity_pool_usage)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Firehose con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Firehose.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `PutRecordBatch`
Il seguente esempio di codice mostra come utilizzare. `PutRecordBatch`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/firehose#code-examples).
```
async fn put_record_batch(
client: &Client,
stream: &str,
data: Vec,
) -> Result> {
client
.put_record_batch()
.delivery_stream_name(stream)
.set_records(Some(data))
.send()
.await
}
```
+ Per i dettagli sulle API, consulta la [PutRecordBatch](https://docs.rs/aws-sdk-firehose/latest/aws_sdk_firehose/client/struct.Client.html#method.put_record_batch)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon DocumentDB con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon DocumentDB.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Esempi serverless](#serverless_examples)
## Esempi serverless
### Invocare una funzione Lambda da un trigger Amazon DocumentDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso di modifiche di DocumentDB. La funzione recupera il payload DocumentDB e registra il contenuto del record.
**SDK per Rust**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-docdb-to-lambda).
Utilizzo di un evento Amazon DocumentDB con Lambda tramite Ruby.
```
use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
use aws_lambda_events::{
event::documentdb::{DocumentDbEvent, DocumentDbInnerEvent},
};
// Built with the following dependencies:
//lambda_runtime = "0.11.1"
//serde_json = "1.0"
//tokio = { version = "1", features = ["macros"] }
//tracing = { version = "0.1", features = ["log"] }
//tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
//aws_lambda_events = "0.15.0"
async fn function_handler(event: LambdaEvent) ->Result<(), Error> {
tracing::info!("Event Source ARN: {:?}", event.payload.event_source_arn);
tracing::info!("Event Source: {:?}", event.payload.event_source);
let records = &event.payload.events;
if records.is_empty() {
tracing::info!("No records found. Exiting.");
return Ok(());
}
for record in records{
log_document_db_event(record);
}
tracing::info!("Document db records processed");
// Prepare the response
Ok(())
}
fn log_document_db_event(record: &DocumentDbInnerEvent)-> Result<(), Error>{
tracing::info!("Change Event: {:?}", record.event);
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
let func = service_fn(function_handler);
lambda_runtime::run(func).await?;
Ok(())
}
```
# Esempi per DynamoDB con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con DynamoDB.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
*Scenari*: esempi di codice che mostrano come eseguire un’attività specifica chiamando più funzioni all’interno dello stesso servizio o combinate con altri Servizi AWS.
*AWS i contributi della community* sono esempi che sono stati creati e gestiti da diversi team. AWS Per fornire un feedback, utilizza il meccanismo disponibile nei repository collegati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
+ [Scenari](#scenarios)
+ [Esempi serverless](#serverless_examples)
+ [AWS contributi della comunità](#aws_community_contributions)
## Azioni
### `CreateTable`
Il seguente esempio di codice mostra come usare`CreateTable`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn create_table(
client: &Client,
table: &str,
key: &str,
) -> Result {
let a_name: String = key.into();
let table_name: String = table.into();
let ad = AttributeDefinition::builder()
.attribute_name(&a_name)
.attribute_type(ScalarAttributeType::S)
.build()
.map_err(Error::BuildError)?;
let ks = KeySchemaElement::builder()
.attribute_name(&a_name)
.key_type(KeyType::Hash)
.build()
.map_err(Error::BuildError)?;
let create_table_response = client
.create_table()
.table_name(table_name)
.key_schema(ks)
.attribute_definitions(ad)
.billing_mode(BillingMode::PayPerRequest)
.send()
.await;
match create_table_response {
Ok(out) => {
println!("Added table {} with key {}", table, key);
Ok(out)
}
Err(e) => {
eprintln!("Got an error creating table:");
eprintln!("{}", e);
Err(Error::unhandled(e))
}
}
}
```
+ Per i dettagli sulle API, consulta la [CreateTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.create_table)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteItem`
Il seguente esempio di codice mostra come utilizzare`DeleteItem`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn delete_item(
client: &Client,
table: &str,
key: &str,
value: &str,
) -> Result {
match client
.delete_item()
.table_name(table)
.key(key, AttributeValue::S(value.into()))
.send()
.await
{
Ok(out) => {
println!("Deleted item from table");
Ok(out)
}
Err(e) => Err(Error::unhandled(e)),
}
}
```
+ Per i dettagli sulle API, consulta la [DeleteItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_item)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteTable`
Il seguente esempio di codice mostra come utilizzare`DeleteTable`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn delete_table(client: &Client, table: &str) -> Result {
let resp = client.delete_table().table_name(table).send().await;
match resp {
Ok(out) => {
println!("Deleted table");
Ok(out)
}
Err(e) => Err(Error::Unhandled(e.into())),
}
}
```
+ Per i dettagli sulle API, consulta la [DeleteTable](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.delete_table)guida di *riferimento all'API AWS SDK for Rust*.
### `ListTables`
Il seguente esempio di codice mostra come utilizzare`ListTables`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn list_tables(client: &Client) -> Result, Error> {
let paginator = client.list_tables().into_paginator().items().send();
let table_names = paginator.collect::, _>>().await?;
println!("Tables:");
for name in &table_names {
println!(" {}", name);
}
println!("Found {} tables", table_names.len());
Ok(table_names)
}
```
Determina se esiste una tabella.
```
pub async fn table_exists(client: &Client, table: &str) -> Result {
debug!("Checking for table: {table}");
let table_list = client.list_tables().send().await;
match table_list {
Ok(list) => Ok(list.table_names().contains(&table.into())),
Err(e) => Err(e.into()),
}
}
```
+ Per i dettagli sulle API, consulta la [ListTables](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.list_tables)guida di *riferimento all'API AWS SDK for Rust*.
### `PutItem`
Il seguente esempio di codice mostra come utilizzare`PutItem`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn add_item(client: &Client, item: Item, table: &String) -> Result {
let user_av = AttributeValue::S(item.username);
let type_av = AttributeValue::S(item.p_type);
let age_av = AttributeValue::S(item.age);
let first_av = AttributeValue::S(item.first);
let last_av = AttributeValue::S(item.last);
let request = client
.put_item()
.table_name(table)
.item("username", user_av)
.item("account_type", type_av)
.item("age", age_av)
.item("first_name", first_av)
.item("last_name", last_av);
println!("Executing request [{request:?}] to add item...");
let resp = request.send().await?;
let attributes = resp.attributes().unwrap();
let username = attributes.get("username").cloned();
let first_name = attributes.get("first_name").cloned();
let last_name = attributes.get("last_name").cloned();
let age = attributes.get("age").cloned();
let p_type = attributes.get("p_type").cloned();
println!(
"Added user {:?}, {:?} {:?}, age {:?} as {:?} user",
username, first_name, last_name, age, p_type
);
Ok(ItemOut {
p_type,
age,
username,
first_name,
last_name,
})
}
```
+ Per i dettagli sulle API, consulta la [PutItem](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.put_item)guida di *riferimento all'API AWS SDK for Rust*.
### `Query`
Il seguente esempio di codice mostra come utilizzare`Query`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
Trova i filmati realizzati nell’anno specificato.
```
pub async fn movies_in_year(
client: &Client,
table_name: &str,
year: u16,
) -> Result, MovieError> {
let results = client
.query()
.table_name(table_name)
.key_condition_expression("#yr = :yyyy")
.expression_attribute_names("#yr", "year")
.expression_attribute_values(":yyyy", AttributeValue::N(year.to_string()))
.send()
.await?;
if let Some(items) = results.items {
let movies = items.iter().map(|v| v.into()).collect();
Ok(movies)
} else {
Ok(vec![])
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Query](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.query) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
### `Scan`
Il seguente esempio di codice mostra come usare`Scan`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
pub async fn list_items(client: &Client, table: &str, page_size: Option) -> Result<(), Error> {
let page_size = page_size.unwrap_or(10);
let items: Result, _> = client
.scan()
.table_name(table)
.limit(page_size)
.into_paginator()
.items()
.send()
.collect()
.await;
println!("Items in table (up to {page_size}):");
for item in items? {
println!(" {:?}", item);
}
Ok(())
}
```
+ Per informazioni dettagliate sull’API, consulta [Scan](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.scan) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
## Scenari
### Connettere un’istanza locale
Il seguente esempio di codice mostra come sovrascrivere l'URL di un endpoint per connettersi a una distribuzione di sviluppo locale di DynamoDB e un SDK. AWS
Per ulteriori informazioni, consulta [DynamoDB locale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html).
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
/// Lists your tables from a local DynamoDB instance by setting the SDK Config's
/// endpoint_url and test_credentials.
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
.test_credentials()
// DynamoDB run locally uses port 8000 by default.
.endpoint_url("http://localhost:8000")
.load()
.await;
let dynamodb_local_config = aws_sdk_dynamodb::config::Builder::from(&config).build();
let client = aws_sdk_dynamodb::Client::from_conf(dynamodb_local_config);
let list_resp = client.list_tables().send().await;
match list_resp {
Ok(resp) => {
println!("Found {} tables", resp.table_names().len());
for name in resp.table_names() {
println!(" {}", name);
}
}
Err(err) => eprintln!("Failed to list local dynamodb tables: {err:?}"),
}
}
```
### Creazione di un’applicazione serverless per gestire foto
L’esempio di codice seguente mostra come creare un’applicazione serverless che consente agli utenti di gestire le foto mediante etichette.
**SDK per Rust**
Mostra come sviluppare un’applicazione per la gestione delle risorse fotografiche che rileva le etichette nelle immagini utilizzando Amazon Rekognition e le archivia per recuperarle in seguito.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/cross_service/photo_asset_management).
Per approfondire l’origine di questo esempio, consulta il post su [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
+ Amazon SNS
### Esecuzione di una query mediante PartiQL
L’esempio di codice seguente mostra come:
+ Ricezione di un articolo eseguendo un’istruzione SELECT.
+ Aggiunta di un elemento eseguendo un’istruzione INSERT.
+ Aggiornamento di un elemento eseguendo un’istruzione UPDATE.
+ Eliminazione di un elemento eseguendo un’istruzione DELETE.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb#code-examples).
```
async fn make_table(
client: &Client,
table: &str,
key: &str,
) -> Result<(), SdkError> {
let ad = AttributeDefinition::builder()
.attribute_name(key)
.attribute_type(ScalarAttributeType::S)
.build()
.expect("creating AttributeDefinition");
let ks = KeySchemaElement::builder()
.attribute_name(key)
.key_type(KeyType::Hash)
.build()
.expect("creating KeySchemaElement");
match client
.create_table()
.table_name(table)
.key_schema(ks)
.attribute_definitions(ad)
.billing_mode(BillingMode::PayPerRequest)
.send()
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
async fn add_item(client: &Client, item: Item) -> Result<(), SdkError> {
match client
.execute_statement()
.statement(format!(
r#"INSERT INTO "{}" VALUE {{
"{}": ?,
"acount_type": ?,
"age": ?,
"first_name": ?,
"last_name": ?
}} "#,
item.table, item.key
))
.set_parameters(Some(vec![
AttributeValue::S(item.utype),
AttributeValue::S(item.age),
AttributeValue::S(item.first_name),
AttributeValue::S(item.last_name),
]))
.send()
.await
{
Ok(_) => Ok(()),
Err(e) => Err(e),
}
}
async fn query_item(client: &Client, item: Item) -> bool {
match client
.execute_statement()
.statement(format!(
r#"SELECT * FROM "{}" WHERE "{}" = ?"#,
item.table, item.key
))
.set_parameters(Some(vec![AttributeValue::S(item.value)]))
.send()
.await
{
Ok(resp) => {
if !resp.items().is_empty() {
println!("Found a matching entry in the table:");
println!("{:?}", resp.items.unwrap_or_default().pop());
true
} else {
println!("Did not find a match.");
false
}
}
Err(e) => {
println!("Got an error querying table:");
println!("{}", e);
process::exit(1);
}
}
}
async fn remove_item(client: &Client, table: &str, key: &str, value: String) -> Result<(), Error> {
client
.execute_statement()
.statement(format!(r#"DELETE FROM "{table}" WHERE "{key}" = ?"#))
.set_parameters(Some(vec![AttributeValue::S(value)]))
.send()
.await?;
println!("Deleted item.");
Ok(())
}
async fn remove_table(client: &Client, table: &str) -> Result<(), Error> {
client.delete_table().table_name(table).send().await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [ExecuteStatement](https://docs.rs/aws-sdk-dynamodb/latest/aws_sdk_dynamodb/client/struct.Client.html#method.execute_statement)guida di *riferimento all'API AWS SDK for Rust*.
### Salvataggio di EXIF e altre informazioni sull’immagine
L’esempio di codice seguente mostra come:
+ Recuperare informazioni EXIF da un file JPG, JPEG o PNG.
+ Carica il file immagine in un bucket Amazon S3.
+ Utilizza Amazon Rekognition per identificare i tre attributi principali (etichette) nel file.
+ Aggiungi le informazioni su EXIF ed etichette a una tabella Amazon DynamoDB nella regione.
**SDK per Rust**
Recupera le informazioni EXIF da un file JPG, JPEG o PNG, carica il file di immagine in un bucket Amazon S3, utilizza Amazon Rekognition per identificare i tre attributi principali (*etichette* in Amazon Rekognition) nel file e aggiungi le informazioni su EXIF ed etichette a una tabella Amazon DynamoDB nella regione.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/rustv1/cross_service/detect_labels/src/main.rs).
**Servizi utilizzati in questo esempio**
+ DynamoDB
+ Amazon Rekognition
+ Simple Storage Service (Amazon S3)
## Esempi serverless
### Invocare una funzione Lambda da un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una funzione Lambda che riceve un evento attivato dalla ricezione di record da un flusso DynamoDB. La funzione recupera il payload DynamoDB e registra il contenuto del record.
**SDK per Rust**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda).
Utilizzo di un evento DynamoDB con Lambda tramite Rust.
```
use lambda_runtime::{service_fn, tracing, Error, LambdaEvent};
use aws_lambda_events::{
event::dynamodb::{Event, EventRecord},
};
// Built with the following dependencies:
//lambda_runtime = "0.11.1"
//serde_json = "1.0"
//tokio = { version = "1", features = ["macros"] }
//tracing = { version = "0.1", features = ["log"] }
//tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
//aws_lambda_events = "0.15.0"
async fn function_handler(event: LambdaEvent) ->Result<(), Error> {
let records = &event.payload.records;
tracing::info!("event payload: {:?}",records);
if records.is_empty() {
tracing::info!("No records found. Exiting.");
return Ok(());
}
for record in records{
log_dynamo_dbrecord(record);
}
tracing::info!("Dynamo db records processed");
// Prepare the response
Ok(())
}
fn log_dynamo_dbrecord(record: &EventRecord)-> Result<(), Error>{
tracing::info!("EventId: {}", record.event_id);
tracing::info!("EventName: {}", record.event_name);
tracing::info!("DynamoDB Record: {:?}", record.change );
Ok(())
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.without_time()
.init();
let func = service_fn(function_handler);
lambda_runtime::run(func).await?;
Ok(())
}
```
### Segnalazione di errori di elementi batch per funzioni Lambda con un trigger DynamoDB
L’esempio di codice seguente mostra come implementare una risposta batch parziale per funzioni Lambda che ricevono eventi da un flusso DynamoDB. La funzione riporta gli errori degli elementi batch nella risposta, segnalando a Lambda di riprovare tali messaggi in un secondo momento.
**SDK per Rust**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel repository di [Esempi serverless](https://github.com/aws-samples/serverless-snippets/tree/main/integration-ddb-to-lambda-with-batch-item-handling).
Segnalazione di errori di elementi batch di DynamoDB con Lambda tramite Rust.
```
use aws_lambda_events::{
event::dynamodb::{Event, EventRecord, StreamRecord},
streams::{DynamoDbBatchItemFailure, DynamoDbEventResponse},
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
/// Process the stream record
fn process_record(record: &EventRecord) -> Result<(), Error> {
let stream_record: &StreamRecord = &record.change;
// process your stream record here...
tracing::info!("Data: {:?}", stream_record);
Ok(())
}
/// Main Lambda handler here...
async fn function_handler(event: LambdaEvent) -> Result {
let mut response = DynamoDbEventResponse {
batch_item_failures: vec![],
};
let records = &event.payload.records;
if records.is_empty() {
tracing::info!("No records found. Exiting.");
return Ok(response);
}
for record in records {
tracing::info!("EventId: {}", record.event_id);
// Couldn't find a sequence number
if record.change.sequence_number.is_none() {
response.batch_item_failures.push(DynamoDbBatchItemFailure {
item_identifier: Some("".to_string()),
});
return Ok(response);
}
// Process your record here...
if process_record(record).is_err() {
response.batch_item_failures.push(DynamoDbBatchItemFailure {
item_identifier: record.change.sequence_number.clone(),
});
/* Since we are working with streams, we can return the failed item immediately.
Lambda will immediately begin to retry processing from this failed item onwards. */
return Ok(response);
}
}
tracing::info!("Successfully processed {} record(s)", records.len());
Ok(response)
}
#[tokio::main]
async fn main() -> Result<(), Error> {
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
// disable printing the name of the module in every log line.
.with_target(false)
// disabling time is handy because CloudWatch will add the ingestion time.
.without_time()
.init();
run(service_fn(function_handler)).await
}
```
## AWS contributi della comunità
### Creare e testare un’applicazione serverless
L’esempio di codice seguente mostra come creare e testare un’applicazione serverless utilizzando Gateway API con Lambda e DynamoDB
**SDK per Rust**
Mostra come creare e testare un’applicazione serverless composta da Gateway API con Lambda e DynamoDB utilizzando l’SDK per Rust.
Per il codice sorgente completo e le istruzioni su come configurarlo ed eseguirlo, guarda l'esempio completo su [GitHub](https://github.com/aws-samples/serverless-rust-demo).
**Servizi utilizzati in questo esempio**
+ Gateway API
+ DynamoDB
+ Lambda
# Esempi per Amazon EBS con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon EBS.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `CompleteSnapshot`
Il seguente esempio di codice mostra come usare. `CompleteSnapshot`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn finish(client: &Client, id: &str) -> Result<(), Error> {
client
.complete_snapshot()
.changed_blocks_count(2)
.snapshot_id(id)
.send()
.await?;
println!("Snapshot ID {}", id);
println!("The state is 'completed' when all of the modified blocks have been transferred to Amazon S3.");
println!("Use the get-snapshot-state code example to get the state of the snapshot.");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [CompleteSnapshot](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.complete_snapshot)guida di *riferimento all'API AWS SDK for Rust*.
### `PutSnapshotBlock`
Il seguente esempio di codice mostra come utilizzare`PutSnapshotBlock`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn add_block(
client: &Client,
id: &str,
idx: usize,
block: Vec,
checksum: &str,
) -> Result<(), Error> {
client
.put_snapshot_block()
.snapshot_id(id)
.block_index(idx as i32)
.block_data(ByteStream::from(block))
.checksum(checksum)
.checksum_algorithm(ChecksumAlgorithm::ChecksumAlgorithmSha256)
.data_length(EBS_BLOCK_SIZE as i32)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [PutSnapshotBlock](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.put_snapshot_block)guida di *riferimento all'API AWS SDK for Rust*.
### `StartSnapshot`
Il seguente esempio di codice mostra come utilizzare`StartSnapshot`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn start(client: &Client, description: &str) -> Result {
let snapshot = client
.start_snapshot()
.description(description)
.encrypted(false)
.volume_size(1)
.send()
.await?;
Ok(snapshot.snapshot_id.unwrap())
}
```
+ Per i dettagli sulle API, consulta la [StartSnapshot](https://docs.rs/aws-sdk-ebs/latest/aws_sdk_ebs/client/struct.Client.html#method.start_snapshot)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon EC2 con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon EC2.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello Amazon EC2
Il seguente esempio di codice mostra come iniziare a usare Amazon EC2.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
async fn show_security_groups(client: &aws_sdk_ec2::Client, group_ids: Vec) {
let response = client
.describe_security_groups()
.set_group_ids(Some(group_ids))
.send()
.await;
match response {
Ok(output) => {
for group in output.security_groups() {
println!(
"Found Security Group {} ({}), vpc id {} and description {}",
group.group_name().unwrap_or("unknown"),
group.group_id().unwrap_or("id-unknown"),
group.vpc_id().unwrap_or("vpcid-unknown"),
group.description().unwrap_or("(none)")
);
}
}
Err(err) => {
let err = err.into_service_error();
let meta = err.meta();
let message = meta.message().unwrap_or("unknown");
let code = meta.code().unwrap_or("unknown");
eprintln!("Error listing EC2 Security Groups: ({code}) {message}");
}
}
}
```
+ Per i dettagli sulle API, consulta la [DescribeSecurityGroups](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_security_groups)guida di *riferimento all'API AWS SDK for Rust*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Creare una coppia di chiavi e un gruppo di sicurezza.
+ Selezionare un’Amazon Machine Image (AMI) e un tipo di istanza compatibile e quindi creare un’istanza.
+ Arrestare e riavviare l’istanza.
+ Associazione di un indirizzo IP elastico all’istanza.
+ Connettiti alla tua istanza con SSH, quindi elimina le risorse.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
L' EC2InstanceScenario implementazione contiene la logica per eseguire l'esempio nel suo insieme.
```
//! Scenario that uses the AWS SDK for Rust (the SDK) with Amazon Elastic Compute Cloud
//! (Amazon EC2) to do the following:
//!
//! * Create a key pair that is used to secure SSH communication between your computer and
//! an EC2 instance.
//! * Create a security group that acts as a virtual firewall for your EC2 instances to
//! control incoming and outgoing traffic.
//! * Find an Amazon Machine Image (AMI) and a compatible instance type.
//! * Create an instance that is created from the instance type and AMI you select, and
//! is configured to use the security group and key pair created in this example.
//! * Stop and restart the instance.
//! * Create an Elastic IP address and associate it as a consistent IP address for your instance.
//! * Connect to your instance with SSH, using both its public IP address and your Elastic IP
//! address.
//! * Clean up all of the resources created by this example.
use std::net::Ipv4Addr;
use crate::{
ec2::{EC2Error, EC2},
getting_started::{key_pair::KeyPairManager, util::Util},
ssm::SSM,
};
use aws_sdk_ssm::types::Parameter;
use super::{
elastic_ip::ElasticIpManager, instance::InstanceManager, security_group::SecurityGroupManager,
util::ScenarioImage,
};
pub struct Ec2InstanceScenario {
ec2: EC2,
ssm: SSM,
util: Util,
key_pair_manager: KeyPairManager,
security_group_manager: SecurityGroupManager,
instance_manager: InstanceManager,
elastic_ip_manager: ElasticIpManager,
}
impl Ec2InstanceScenario {
pub fn new(ec2: EC2, ssm: SSM, util: Util) -> Self {
Ec2InstanceScenario {
ec2,
ssm,
util,
key_pair_manager: Default::default(),
security_group_manager: Default::default(),
instance_manager: Default::default(),
elastic_ip_manager: Default::default(),
}
}
pub async fn run(&mut self) -> Result<(), EC2Error> {
self.create_and_list_key_pairs().await?;
self.create_security_group().await?;
self.create_instance().await?;
self.stop_and_start_instance().await?;
self.associate_elastic_ip().await?;
self.stop_and_start_instance().await?;
Ok(())
}
/// 1. Creates an RSA key pair and saves its private key data as a .pem file in secure
/// temporary storage. The private key data is deleted after the example completes.
/// 2. Optionally, lists the first five key pairs for the current account.
pub async fn create_and_list_key_pairs(&mut self) -> Result<(), EC2Error> {
println!( "Let's create an RSA key pair that you can be use to securely connect to your EC2 instance.");
let key_name = self.util.prompt_key_name()?;
self.key_pair_manager
.create(&self.ec2, &self.util, key_name)
.await?;
println!(
"Created a key pair {} and saved the private key to {:?}.",
self.key_pair_manager
.key_pair()
.key_name()
.ok_or_else(|| EC2Error::new("No key name after creating key"))?,
self.key_pair_manager
.key_file_path()
.ok_or_else(|| EC2Error::new("No key file after creating key"))?
);
if self.util.should_list_key_pairs()? {
for pair in self.key_pair_manager.list(&self.ec2).await? {
println!(
"Found {:?} key {} with fingerprint:\t{:?}",
pair.key_type(),
pair.key_name().unwrap_or("Unknown"),
pair.key_fingerprint()
);
}
}
Ok(())
}
/// 1. Creates a security group for the default VPC.
/// 2. Adds an inbound rule to allow SSH. The SSH rule allows only
/// inbound traffic from the current computer’s public IPv4 address.
/// 3. Displays information about the security group.
///
/// This function uses to get the current public IP
/// address of the computer that is running the example. This method works in most
/// cases. However, depending on how your computer connects to the internet, you
/// might have to manually add your public IP address to the security group by using
/// the AWS Management Console.
pub async fn create_security_group(&mut self) -> Result<(), EC2Error> {
println!("Let's create a security group to manage access to your instance.");
let group_name = self.util.prompt_security_group_name()?;
self.security_group_manager
.create(
&self.ec2,
&group_name,
"Security group for example: get started with instances.",
)
.await?;
println!(
"Created security group {} in your default VPC {}.",
self.security_group_manager.group_name(),
self.security_group_manager
.vpc_id()
.unwrap_or("(unknown vpc)")
);
let check_ip = self.util.do_get("https://checkip.amazonaws.com").await?;
let current_ip_address: Ipv4Addr = check_ip.trim().parse().map_err(|e| {
EC2Error::new(format!(
"Failed to convert response {} to IP Address: {e:?}",
check_ip
))
})?;
println!("Your public IP address seems to be {current_ip_address}");
if self.util.should_add_to_security_group() {
match self
.security_group_manager
.authorize_ingress(&self.ec2, current_ip_address)
.await
{
Ok(_) => println!("Security group rules updated"),
Err(err) => eprintln!("Couldn't update security group rules: {err:?}"),
}
}
println!("{}", self.security_group_manager);
Ok(())
}
/// 1. Gets a list of Amazon Linux 2 AMIs from AWS Systems Manager. Specifying the
/// '/aws/service/ami-amazon-linux-latest' path returns only the latest AMIs.
/// 2. Gets and displays information about the available AMIs and lets you select one.
/// 3. Gets a list of instance types that are compatible with the selected AMI and
/// lets you select one.
/// 4. Creates an instance with the previously created key pair and security group,
/// and the selected AMI and instance type.
/// 5. Waits for the instance to be running and then displays its information.
pub async fn create_instance(&mut self) -> Result<(), EC2Error> {
let ami = self.find_image().await?;
let instance_types = self
.ec2
.list_instance_types(&ami.0)
.await
.map_err(|e| e.add_message("Could not find instance types"))?;
println!(
"There are several instance types that support the {} architecture of the image.",
ami.0
.architecture
.as_ref()
.ok_or_else(|| EC2Error::new(format!("Missing architecture in {:?}", ami.0)))?
);
let instance_type = self.util.select_instance_type(instance_types)?;
println!("Creating your instance and waiting for it to start...");
self.instance_manager
.create(
&self.ec2,
ami.0
.image_id()
.ok_or_else(|| EC2Error::new("Could not find image ID"))?,
instance_type,
self.key_pair_manager.key_pair(),
self.security_group_manager
.security_group()
.map(|sg| vec![sg])
.ok_or_else(|| EC2Error::new("Could not find security group"))?,
)
.await
.map_err(|e| e.add_message("Scenario failed to create instance"))?;
while let Err(err) = self
.ec2
.wait_for_instance_ready(self.instance_manager.instance_id(), None)
.await
{
println!("{err}");
if !self.util.should_continue_waiting() {
return Err(err);
}
}
println!("Your instance is ready:\n{}", self.instance_manager);
self.display_ssh_info();
Ok(())
}
async fn find_image(&mut self) -> Result {
let params: Vec = self
.ssm
.list_path("/aws/service/ami-amazon-linux-latest")
.await
.map_err(|e| e.add_message("Could not find parameters for available images"))?
.into_iter()
.filter(|param| param.name().is_some_and(|name| name.contains("amzn2")))
.collect();
let amzn2_images: Vec = self
.ec2
.list_images(params)
.await
.map_err(|e| e.add_message("Could not find images"))?
.into_iter()
.map(ScenarioImage::from)
.collect();
println!("We will now create an instance from an Amazon Linux 2 AMI");
let ami = self.util.select_scenario_image(amzn2_images)?;
Ok(ami)
}
// 1. Stops the instance and waits for it to stop.
// 2. Starts the instance and waits for it to start.
// 3. Displays information about the instance.
// 4. Displays an SSH connection string. When an Elastic IP address is associated
// with the instance, the IP address stays consistent when the instance stops
// and starts.
pub async fn stop_and_start_instance(&self) -> Result<(), EC2Error> {
println!("Let's stop and start your instance to see what changes.");
println!("Stopping your instance and waiting until it's stopped...");
self.instance_manager.stop(&self.ec2).await?;
println!("Your instance is stopped. Restarting...");
self.instance_manager.start(&self.ec2).await?;
println!("Your instance is running.");
println!("{}", self.instance_manager);
if self.elastic_ip_manager.public_ip() == "0.0.0.0" {
println!("Every time your instance is restarted, its public IP address changes.");
} else {
println!(
"Because you have associated an Elastic IP with your instance, you can connect by using a consistent IP address after the instance restarts."
);
}
self.display_ssh_info();
Ok(())
}
/// 1. Allocates an Elastic IP address and associates it with the instance.
/// 2. Displays an SSH connection string that uses the Elastic IP address.
async fn associate_elastic_ip(&mut self) -> Result<(), EC2Error> {
self.elastic_ip_manager.allocate(&self.ec2).await?;
println!(
"Allocated static Elastic IP address: {}",
self.elastic_ip_manager.public_ip()
);
self.elastic_ip_manager
.associate(&self.ec2, self.instance_manager.instance_id())
.await?;
println!("Associated your Elastic IP with your instance.");
println!("You can now use SSH to connect to your instance by using the Elastic IP.");
self.display_ssh_info();
Ok(())
}
/// Displays an SSH connection string that can be used to connect to a running
/// instance.
fn display_ssh_info(&self) {
let ip_addr = if self.elastic_ip_manager.has_allocation() {
self.elastic_ip_manager.public_ip()
} else {
self.instance_manager.instance_ip()
};
let key_file_path = self.key_pair_manager.key_file_path().unwrap();
println!("To connect, open another command prompt and run the following command:");
println!("\nssh -i {} ec2-user@{ip_addr}\n", key_file_path.display());
let _ = self.util.enter_to_continue();
}
/// 1. Disassociate and delete the previously created Elastic IP.
/// 2. Terminate the previously created instance.
/// 3. Delete the previously created security group.
/// 4. Delete the previously created key pair.
pub async fn clean_up(self) {
println!("Let's clean everything up. This example created these resources:");
println!(
"\tKey pair: {}",
self.key_pair_manager
.key_pair()
.key_name()
.unwrap_or("(unknown key pair)")
);
println!(
"\tSecurity group: {}",
self.security_group_manager.group_name()
);
println!(
"\tInstance: {}",
self.instance_manager.instance_display_name()
);
if self.util.should_clean_resources() {
if let Err(err) = self.elastic_ip_manager.remove(&self.ec2).await {
eprintln!("{err}")
}
if let Err(err) = self.instance_manager.delete(&self.ec2).await {
eprintln!("{err}")
}
if let Err(err) = self.security_group_manager.delete(&self.ec2).await {
eprintln!("{err}");
}
if let Err(err) = self.key_pair_manager.delete(&self.ec2, &self.util).await {
eprintln!("{err}");
}
} else {
println!("Ok, not cleaning up any resources!");
}
}
}
pub async fn run(mut scenario: Ec2InstanceScenario) {
println!("--------------------------------------------------------------------------------");
println!(
"Welcome to the Amazon Elastic Compute Cloud (Amazon EC2) get started with instances demo."
);
println!("--------------------------------------------------------------------------------");
if let Err(err) = scenario.run().await {
eprintln!("There was an error running the scenario: {err}")
}
println!("--------------------------------------------------------------------------------");
scenario.clean_up().await;
println!("Thanks for running!");
println!("--------------------------------------------------------------------------------");
}
```
La struttura di EC2Impl funge da punto di automazione per i test e le relative funzioni per il wrapping delle chiamate SDK EC2.
```
use std::{net::Ipv4Addr, time::Duration};
use aws_sdk_ec2::{
client::Waiters,
error::ProvideErrorMetadata,
operation::{
allocate_address::AllocateAddressOutput, associate_address::AssociateAddressOutput,
},
types::{
DomainType, Filter, Image, Instance, InstanceType, IpPermission, IpRange, KeyPairInfo,
SecurityGroup, Tag,
},
Client as EC2Client,
};
use aws_sdk_ssm::types::Parameter;
use aws_smithy_runtime_api::client::waiters::error::WaiterError;
#[cfg(test)]
use mockall::automock;
#[cfg(not(test))]
pub use EC2Impl as EC2;
#[cfg(test)]
pub use MockEC2Impl as EC2;
#[derive(Clone)]
pub struct EC2Impl {
pub client: EC2Client,
}
#[cfg_attr(test, automock)]
impl EC2Impl {
pub fn new(client: EC2Client) -> Self {
EC2Impl { client }
}
pub async fn create_key_pair(&self, name: String) -> Result<(KeyPairInfo, String), EC2Error> {
tracing::info!("Creating key pair {name}");
let output = self.client.create_key_pair().key_name(name).send().await?;
let info = KeyPairInfo::builder()
.set_key_name(output.key_name)
.set_key_fingerprint(output.key_fingerprint)
.set_key_pair_id(output.key_pair_id)
.build();
let material = output
.key_material
.ok_or_else(|| EC2Error::new("Create Key Pair has no key material"))?;
Ok((info, material))
}
pub async fn list_key_pair(&self) -> Result, EC2Error> {
let output = self.client.describe_key_pairs().send().await?;
Ok(output.key_pairs.unwrap_or_default())
}
pub async fn delete_key_pair(&self, key_name: &str) -> Result<(), EC2Error> {
let key_name: String = key_name.into();
tracing::info!("Deleting key pair {key_name}");
self.client
.delete_key_pair()
.key_name(key_name)
.send()
.await?;
Ok(())
}
pub async fn create_security_group(
&self,
name: &str,
description: &str,
) -> Result {
tracing::info!("Creating security group {name}");
let create_output = self
.client
.create_security_group()
.group_name(name)
.description(description)
.send()
.await
.map_err(EC2Error::from)?;
let group_id = create_output
.group_id
.ok_or_else(|| EC2Error::new("Missing security group id after creation"))?;
let group = self
.describe_security_group(&group_id)
.await?
.ok_or_else(|| {
EC2Error::new(format!("Could not find security group with id {group_id}"))
})?;
tracing::info!("Created security group {name} as {group_id}");
Ok(group)
}
/// Find a single security group, by ID. Returns Err if multiple groups are found.
pub async fn describe_security_group(
&self,
group_id: &str,
) -> Result, EC2Error> {
let group_id: String = group_id.into();
let describe_output = self
.client
.describe_security_groups()
.group_ids(&group_id)
.send()
.await?;
let mut groups = describe_output.security_groups.unwrap_or_default();
match groups.len() {
0 => Ok(None),
1 => Ok(Some(groups.remove(0))),
_ => Err(EC2Error::new(format!(
"Expected single group for {group_id}"
))),
}
}
/// Add an ingress rule to a security group explicitly allowing IPv4 address
/// as {ip}/32 over TCP port 22.
pub async fn authorize_security_group_ssh_ingress(
&self,
group_id: &str,
ingress_ips: Vec,
) -> Result<(), EC2Error> {
tracing::info!("Authorizing ingress for security group {group_id}");
self.client
.authorize_security_group_ingress()
.group_id(group_id)
.set_ip_permissions(Some(
ingress_ips
.into_iter()
.map(|ip| {
IpPermission::builder()
.ip_protocol("tcp")
.from_port(22)
.to_port(22)
.ip_ranges(IpRange::builder().cidr_ip(format!("{ip}/32")).build())
.build()
})
.collect(),
))
.send()
.await?;
Ok(())
}
pub async fn delete_security_group(&self, group_id: &str) -> Result<(), EC2Error> {
tracing::info!("Deleting security group {group_id}");
self.client
.delete_security_group()
.group_id(group_id)
.send()
.await?;
Ok(())
}
pub async fn list_images(&self, ids: Vec) -> Result, EC2Error> {
let image_ids = ids.into_iter().filter_map(|p| p.value).collect();
let output = self
.client
.describe_images()
.set_image_ids(Some(image_ids))
.send()
.await?;
let images = output.images.unwrap_or_default();
if images.is_empty() {
Err(EC2Error::new("No images for selected AMIs"))
} else {
Ok(images)
}
}
/// List instance types that match an image's architecture and are free tier eligible.
pub async fn list_instance_types(&self, image: &Image) -> Result, EC2Error> {
let architecture = format!(
"{}",
image.architecture().ok_or_else(|| EC2Error::new(format!(
"Image {:?} does not have a listed architecture",
image.image_id()
)))?
);
let free_tier_eligible_filter = Filter::builder()
.name("free-tier-eligible")
.values("false")
.build();
let supported_architecture_filter = Filter::builder()
.name("processor-info.supported-architecture")
.values(architecture)
.build();
let response = self
.client
.describe_instance_types()
.filters(free_tier_eligible_filter)
.filters(supported_architecture_filter)
.send()
.await?;
Ok(response
.instance_types
.unwrap_or_default()
.into_iter()
.filter_map(|iti| iti.instance_type)
.collect())
}
pub async fn create_instance<'a>(
&self,
image_id: &'a str,
instance_type: InstanceType,
key_pair: &'a KeyPairInfo,
security_groups: Vec<&'a SecurityGroup>,
) -> Result {
let run_instances = self
.client
.run_instances()
.image_id(image_id)
.instance_type(instance_type)
.key_name(
key_pair
.key_name()
.ok_or_else(|| EC2Error::new("Missing key name when launching instance"))?,
)
.set_security_group_ids(Some(
security_groups
.iter()
.filter_map(|sg| sg.group_id.clone())
.collect(),
))
.min_count(1)
.max_count(1)
.send()
.await?;
if run_instances.instances().is_empty() {
return Err(EC2Error::new("Failed to create instance"));
}
let instance_id = run_instances.instances()[0].instance_id().unwrap();
let response = self
.client
.create_tags()
.resources(instance_id)
.tags(
Tag::builder()
.key("Name")
.value("From SDK Examples")
.build(),
)
.send()
.await;
match response {
Ok(_) => tracing::info!("Created {instance_id} and applied tags."),
Err(err) => {
tracing::info!("Error applying tags to {instance_id}: {err:?}");
return Err(err.into());
}
}
tracing::info!("Instance is created.");
Ok(instance_id.to_string())
}
/// Wait for an instance to be ready and status ok (default wait 60 seconds)
pub async fn wait_for_instance_ready(
&self,
instance_id: &str,
duration: Option,
) -> Result<(), EC2Error> {
self.client
.wait_until_instance_status_ok()
.instance_ids(instance_id)
.wait(duration.unwrap_or(Duration::from_secs(60)))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to start.",
exceeded.max_wait().as_secs()
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
pub async fn describe_instance(&self, instance_id: &str) -> Result {
let response = self
.client
.describe_instances()
.instance_ids(instance_id)
.send()
.await?;
let instance = response
.reservations()
.first()
.ok_or_else(|| EC2Error::new(format!("No instance reservations for {instance_id}")))?
.instances()
.first()
.ok_or_else(|| {
EC2Error::new(format!("No instances in reservation for {instance_id}"))
})?;
Ok(instance.clone())
}
pub async fn start_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Starting instance {instance_id}");
self.client
.start_instances()
.instance_ids(instance_id)
.send()
.await?;
tracing::info!("Started instance.");
Ok(())
}
pub async fn stop_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Stopping instance {instance_id}");
self.client
.stop_instances()
.instance_ids(instance_id)
.send()
.await?;
self.wait_for_instance_stopped(instance_id, None).await?;
tracing::info!("Stopped instance.");
Ok(())
}
pub async fn reboot_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Rebooting instance {instance_id}");
self.client
.reboot_instances()
.instance_ids(instance_id)
.send()
.await?;
Ok(())
}
pub async fn wait_for_instance_stopped(
&self,
instance_id: &str,
duration: Option,
) -> Result<(), EC2Error> {
self.client
.wait_until_instance_stopped()
.instance_ids(instance_id)
.wait(duration.unwrap_or(Duration::from_secs(60)))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to stop.",
exceeded.max_wait().as_secs(),
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
pub async fn delete_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Deleting instance with id {instance_id}");
self.stop_instance(instance_id).await?;
self.client
.terminate_instances()
.instance_ids(instance_id)
.send()
.await?;
self.wait_for_instance_terminated(instance_id).await?;
tracing::info!("Terminated instance with id {instance_id}");
Ok(())
}
async fn wait_for_instance_terminated(&self, instance_id: &str) -> Result<(), EC2Error> {
self.client
.wait_until_instance_terminated()
.instance_ids(instance_id)
.wait(Duration::from_secs(60))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to terminate.",
exceeded.max_wait().as_secs(),
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
pub async fn allocate_ip_address(&self) -> Result {
self.client
.allocate_address()
.domain(DomainType::Vpc)
.send()
.await
.map_err(EC2Error::from)
}
pub async fn deallocate_ip_address(&self, allocation_id: &str) -> Result<(), EC2Error> {
self.client
.release_address()
.allocation_id(allocation_id)
.send()
.await?;
Ok(())
}
pub async fn associate_ip_address(
&self,
allocation_id: &str,
instance_id: &str,
) -> Result {
let response = self
.client
.associate_address()
.allocation_id(allocation_id)
.instance_id(instance_id)
.send()
.await?;
Ok(response)
}
pub async fn disassociate_ip_address(&self, association_id: &str) -> Result<(), EC2Error> {
self.client
.disassociate_address()
.association_id(association_id)
.send()
.await?;
Ok(())
}
}
#[derive(Debug)]
pub struct EC2Error(String);
impl EC2Error {
pub fn new(value: impl Into) -> Self {
EC2Error(value.into())
}
pub fn add_message(self, message: impl Into) -> Self {
EC2Error(format!("{}: {}", message.into(), self.0))
}
}
impl From for EC2Error {
fn from(value: T) -> Self {
EC2Error(format!(
"{}: {}",
value
.code()
.map(String::from)
.unwrap_or("unknown code".into()),
value
.message()
.map(String::from)
.unwrap_or("missing reason".into()),
))
}
}
impl std::error::Error for EC2Error {}
impl std::fmt::Display for EC2Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
```
La struttura di SSM funge da punto di automazione per i test e le relative funzioni per il wrapping delle chiamate SDK SSM.
```
use aws_sdk_ssm::{types::Parameter, Client};
use aws_smithy_async::future::pagination_stream::TryFlatMap;
use crate::ec2::EC2Error;
#[cfg(test)]
use mockall::automock;
#[cfg(not(test))]
pub use SSMImpl as SSM;
#[cfg(test)]
pub use MockSSMImpl as SSM;
pub struct SSMImpl {
inner: Client,
}
#[cfg_attr(test, automock)]
impl SSMImpl {
pub fn new(inner: Client) -> Self {
SSMImpl { inner }
}
pub async fn list_path(&self, path: &str) -> Result, EC2Error> {
let maybe_params: Vec> = TryFlatMap::new(
self.inner
.get_parameters_by_path()
.path(path)
.into_paginator()
.send(),
)
.flat_map(|item| item.parameters.unwrap_or_default())
.collect()
.await;
// Fail on the first error
let params = maybe_params
.into_iter()
.collect::, _>>()?;
Ok(params)
}
}
```
Lo scenario utilizza diverse strutture in stile “Manager” per gestire l’accesso alle risorse create ed eliminate durante l’esecuzione dello scenario.
```
use aws_sdk_ec2::operation::{
allocate_address::AllocateAddressOutput, associate_address::AssociateAddressOutput,
};
use crate::ec2::{EC2Error, EC2};
/// ElasticIpManager tracks the lifecycle of a public IP address, including its
/// allocation from the global pool and association with a specific instance.
#[derive(Debug, Default)]
pub struct ElasticIpManager {
elastic_ip: Option,
association: Option,
}
impl ElasticIpManager {
pub fn has_allocation(&self) -> bool {
self.elastic_ip.is_some()
}
pub fn public_ip(&self) -> &str {
if let Some(allocation) = &self.elastic_ip {
if let Some(addr) = allocation.public_ip() {
return addr;
}
}
"0.0.0.0"
}
pub async fn allocate(&mut self, ec2: &EC2) -> Result<(), EC2Error> {
let allocation = ec2.allocate_ip_address().await?;
self.elastic_ip = Some(allocation);
Ok(())
}
pub async fn associate(&mut self, ec2: &EC2, instance_id: &str) -> Result<(), EC2Error> {
if let Some(allocation) = &self.elastic_ip {
if let Some(allocation_id) = allocation.allocation_id() {
let association = ec2.associate_ip_address(allocation_id, instance_id).await?;
self.association = Some(association);
return Ok(());
}
}
Err(EC2Error::new("No ip address allocation to associate"))
}
pub async fn remove(mut self, ec2: &EC2) -> Result<(), EC2Error> {
if let Some(association) = &self.association {
if let Some(association_id) = association.association_id() {
ec2.disassociate_ip_address(association_id).await?;
}
}
self.association = None;
if let Some(allocation) = &self.elastic_ip {
if let Some(allocation_id) = allocation.allocation_id() {
ec2.deallocate_ip_address(allocation_id).await?;
}
}
self.elastic_ip = None;
Ok(())
}
}
use std::fmt::Display;
use aws_sdk_ec2::types::{Instance, InstanceType, KeyPairInfo, SecurityGroup};
use crate::ec2::{EC2Error, EC2};
/// InstanceManager wraps the lifecycle of an EC2 Instance.
#[derive(Debug, Default)]
pub struct InstanceManager {
instance: Option,
}
impl InstanceManager {
pub fn instance_id(&self) -> &str {
if let Some(instance) = &self.instance {
if let Some(id) = instance.instance_id() {
return id;
}
}
"Unknown"
}
pub fn instance_name(&self) -> &str {
if let Some(instance) = &self.instance {
if let Some(tag) = instance.tags().iter().find(|e| e.key() == Some("Name")) {
if let Some(value) = tag.value() {
return value;
}
}
}
"Unknown"
}
pub fn instance_ip(&self) -> &str {
if let Some(instance) = &self.instance {
if let Some(public_ip_address) = instance.public_ip_address() {
return public_ip_address;
}
}
"0.0.0.0"
}
pub fn instance_display_name(&self) -> String {
format!("{} ({})", self.instance_name(), self.instance_id())
}
/// Create an EC2 instance with the given ID on a given type, using a
/// generated KeyPair and applying a list of security groups.
pub async fn create(
&mut self,
ec2: &EC2,
image_id: &str,
instance_type: InstanceType,
key_pair: &KeyPairInfo,
security_groups: Vec<&SecurityGroup>,
) -> Result<(), EC2Error> {
let instance_id = ec2
.create_instance(image_id, instance_type, key_pair, security_groups)
.await?;
let instance = ec2.describe_instance(&instance_id).await?;
self.instance = Some(instance);
Ok(())
}
/// Start the managed EC2 instance, if present.
pub async fn start(&self, ec2: &EC2) -> Result<(), EC2Error> {
if self.instance.is_some() {
ec2.start_instance(self.instance_id()).await?;
}
Ok(())
}
/// Stop the managed EC2 instance, if present.
pub async fn stop(&self, ec2: &EC2) -> Result<(), EC2Error> {
if self.instance.is_some() {
ec2.stop_instance(self.instance_id()).await?;
}
Ok(())
}
pub async fn reboot(&self, ec2: &EC2) -> Result<(), EC2Error> {
if self.instance.is_some() {
ec2.reboot_instance(self.instance_id()).await?;
ec2.wait_for_instance_stopped(self.instance_id(), None)
.await?;
ec2.wait_for_instance_ready(self.instance_id(), None)
.await?;
}
Ok(())
}
/// Terminate and delete the managed EC2 instance, if present.
pub async fn delete(self, ec2: &EC2) -> Result<(), EC2Error> {
if self.instance.is_some() {
ec2.delete_instance(self.instance_id()).await?;
}
Ok(())
}
}
impl Display for InstanceManager {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(instance) = &self.instance {
writeln!(f, "\tID: {}", instance.instance_id().unwrap_or("(Unknown)"))?;
writeln!(
f,
"\tImage ID: {}",
instance.image_id().unwrap_or("(Unknown)")
)?;
writeln!(
f,
"\tInstance type: {}",
instance
.instance_type()
.map(|it| format!("{it}"))
.unwrap_or("(Unknown)".to_string())
)?;
writeln!(
f,
"\tKey name: {}",
instance.key_name().unwrap_or("(Unknown)")
)?;
writeln!(f, "\tVPC ID: {}", instance.vpc_id().unwrap_or("(Unknown)"))?;
writeln!(
f,
"\tPublic IP: {}",
instance.public_ip_address().unwrap_or("(Unknown)")
)?;
let instance_state = instance
.state
.as_ref()
.map(|is| {
is.name()
.map(|isn| format!("{isn}"))
.unwrap_or("(Unknown)".to_string())
})
.unwrap_or("(Unknown)".to_string());
writeln!(f, "\tState: {instance_state}")?;
} else {
writeln!(f, "\tNo loaded instance")?;
}
Ok(())
}
}
use std::{env, path::PathBuf};
use aws_sdk_ec2::types::KeyPairInfo;
use crate::ec2::{EC2Error, EC2};
use super::util::Util;
/// KeyPairManager tracks a KeyPairInfo and the path the private key has been
/// written to, if it's been created.
#[derive(Debug)]
pub struct KeyPairManager {
key_pair: KeyPairInfo,
key_file_path: Option,
key_file_dir: PathBuf,
}
impl KeyPairManager {
pub fn new() -> Self {
Self::default()
}
pub fn key_pair(&self) -> &KeyPairInfo {
&self.key_pair
}
pub fn key_file_path(&self) -> Option<&PathBuf> {
self.key_file_path.as_ref()
}
pub fn key_file_dir(&self) -> &PathBuf {
&self.key_file_dir
}
/// Creates a key pair that can be used to securely connect to an EC2 instance.
/// The returned key pair contains private key information that cannot be retrieved
/// again. The private key data is stored as a .pem file.
///
/// :param key_name: The name of the key pair to create.
pub async fn create(
&mut self,
ec2: &EC2,
util: &Util,
key_name: String,
) -> Result {
let (key_pair, material) = ec2.create_key_pair(key_name.clone()).await.map_err(|e| {
self.key_pair = KeyPairInfo::builder().key_name(key_name.clone()).build();
e.add_message(format!("Couldn't create key {key_name}"))
})?;
let path = self.key_file_dir.join(format!("{key_name}.pem"));
// Save the key_pair information immediately, so it can get cleaned up if write_secure fails.
self.key_file_path = Some(path.clone());
self.key_pair = key_pair.clone();
util.write_secure(&key_name, &path, material)?;
Ok(key_pair)
}
pub async fn delete(self, ec2: &EC2, util: &Util) -> Result<(), EC2Error> {
if let Some(key_name) = self.key_pair.key_name() {
ec2.delete_key_pair(key_name).await?;
if let Some(key_path) = self.key_file_path() {
if let Err(err) = util.remove(key_path) {
eprintln!("Failed to remove {key_path:?} ({err:?})");
}
}
}
Ok(())
}
pub async fn list(&self, ec2: &EC2) -> Result, EC2Error> {
ec2.list_key_pair().await
}
}
impl Default for KeyPairManager {
fn default() -> Self {
KeyPairManager {
key_pair: KeyPairInfo::builder().build(),
key_file_path: Default::default(),
key_file_dir: env::temp_dir(),
}
}
}
use std::net::Ipv4Addr;
use aws_sdk_ec2::types::SecurityGroup;
use crate::ec2::{EC2Error, EC2};
/// SecurityGroupManager tracks the lifecycle of a SecurityGroup for an instance,
/// including adding a rule to allow SSH from a public IP address.
#[derive(Debug, Default)]
pub struct SecurityGroupManager {
group_name: String,
group_description: String,
security_group: Option,
}
impl SecurityGroupManager {
pub async fn create(
&mut self,
ec2: &EC2,
group_name: &str,
group_description: &str,
) -> Result<(), EC2Error> {
self.group_name = group_name.into();
self.group_description = group_description.into();
self.security_group = Some(
ec2.create_security_group(group_name, group_description)
.await
.map_err(|e| e.add_message("Couldn't create security group"))?,
);
Ok(())
}
pub async fn authorize_ingress(&self, ec2: &EC2, ip_address: Ipv4Addr) -> Result<(), EC2Error> {
if let Some(sg) = &self.security_group {
ec2.authorize_security_group_ssh_ingress(
sg.group_id()
.ok_or_else(|| EC2Error::new("Missing security group ID"))?,
vec![ip_address],
)
.await?;
};
Ok(())
}
pub async fn delete(self, ec2: &EC2) -> Result<(), EC2Error> {
if let Some(sg) = &self.security_group {
ec2.delete_security_group(
sg.group_id()
.ok_or_else(|| EC2Error::new("Missing security group ID"))?,
)
.await?;
};
Ok(())
}
pub fn group_name(&self) -> &str {
&self.group_name
}
pub fn vpc_id(&self) -> Option<&str> {
self.security_group.as_ref().and_then(|sg| sg.vpc_id())
}
pub fn security_group(&self) -> Option<&SecurityGroup> {
self.security_group.as_ref()
}
}
impl std::fmt::Display for SecurityGroupManager {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.security_group {
Some(sg) => {
writeln!(
f,
"Security group: {}",
sg.group_name().unwrap_or("(unknown group)")
)?;
writeln!(f, "\tID: {}", sg.group_id().unwrap_or("(unknown group id)"))?;
writeln!(f, "\tVPC: {}", sg.vpc_id().unwrap_or("(unknown group vpc)"))?;
if !sg.ip_permissions().is_empty() {
writeln!(f, "\tInbound Permissions:")?;
for permission in sg.ip_permissions() {
writeln!(f, "\t\t{permission:?}")?;
}
}
Ok(())
}
None => writeln!(f, "No security group loaded."),
}
}
}
```
Il punto di ingresso principale per lo scenario.
```
use ec2_code_examples::{
ec2::EC2,
getting_started::{
scenario::{run, Ec2InstanceScenario},
util::UtilImpl,
},
ssm::SSM,
};
#[tokio::main]
async fn main() {
tracing_subscriber::fmt::init();
let sdk_config = aws_config::load_from_env().await;
let ec2 = EC2::new(aws_sdk_ec2::Client::new(&sdk_config));
let ssm = SSM::new(aws_sdk_ssm::Client::new(&sdk_config));
let util = UtilImpl {};
let scenario = Ec2InstanceScenario::new(ec2, ssm, util);
run(scenario).await;
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
+ [AllocateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.allocate_address)
+ [AssociateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.associate_address)
+ [AuthorizeSecurityGroupIngress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.authorize_security_group_ingress)
+ [CreateKeyPair](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.create_key_pair)
+ [CreateSecurityGroup](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.create_security_group)
+ [DeleteKeyPair](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.delete_key_pair)
+ [DeleteSecurityGroup](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.delete_security_group)
+ [DescribeImages](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_images)
+ [DescribeInstanceTypes](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_instance_types)
+ [DescribeInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_instances)
+ [DescribeKeyPairs](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_key_pairs)
+ [DescribeSecurityGroups](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_security_groups)
+ [DisassociateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.disassociate_address)
+ [ReleaseAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.release_address)
+ [RunInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.run_instances)
+ [StartInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.start_instances)
+ [StopInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.stop_instances)
+ [TerminateInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.terminate_instances)
+ [UnmonitorInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.unmonitor_instances)
## Azioni
### `AllocateAddress`
Il seguente esempio di codice mostra come utilizzare`AllocateAddress`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn allocate_ip_address(&self) -> Result {
self.client
.allocate_address()
.domain(DomainType::Vpc)
.send()
.await
.map_err(EC2Error::from)
}
```
+ Per i dettagli sulle API, consulta la [AllocateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.allocate_address)guida di *riferimento all'API AWS SDK for Rust*.
### `AssociateAddress`
Il seguente esempio di codice mostra come utilizzare`AssociateAddress`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn associate_ip_address(
&self,
allocation_id: &str,
instance_id: &str,
) -> Result {
let response = self
.client
.associate_address()
.allocation_id(allocation_id)
.instance_id(instance_id)
.send()
.await?;
Ok(response)
}
```
+ Per i dettagli sulle API, consulta la [AssociateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.associate_address)guida di *riferimento all'API AWS SDK for Rust*.
### `AuthorizeSecurityGroupIngress`
Il seguente esempio di codice mostra come utilizzare`AuthorizeSecurityGroupIngress`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
/// Add an ingress rule to a security group explicitly allowing IPv4 address
/// as {ip}/32 over TCP port 22.
pub async fn authorize_security_group_ssh_ingress(
&self,
group_id: &str,
ingress_ips: Vec,
) -> Result<(), EC2Error> {
tracing::info!("Authorizing ingress for security group {group_id}");
self.client
.authorize_security_group_ingress()
.group_id(group_id)
.set_ip_permissions(Some(
ingress_ips
.into_iter()
.map(|ip| {
IpPermission::builder()
.ip_protocol("tcp")
.from_port(22)
.to_port(22)
.ip_ranges(IpRange::builder().cidr_ip(format!("{ip}/32")).build())
.build()
})
.collect(),
))
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [AuthorizeSecurityGroupIngress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.authorize_security_group_ingress)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateKeyPair`
Il seguente esempio di codice mostra come utilizzare`CreateKeyPair`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
Implementazione di Rust che chiama create\$1key\$1pair del client EC2 ed estrae il materiale restituito.
```
pub async fn create_key_pair(&self, name: String) -> Result<(KeyPairInfo, String), EC2Error> {
tracing::info!("Creating key pair {name}");
let output = self.client.create_key_pair().key_name(name).send().await?;
let info = KeyPairInfo::builder()
.set_key_name(output.key_name)
.set_key_fingerprint(output.key_fingerprint)
.set_key_pair_id(output.key_pair_id)
.build();
let material = output
.key_material
.ok_or_else(|| EC2Error::new("Create Key Pair has no key material"))?;
Ok((info, material))
}
```
Una funzione che chiama l’implementazione create\$1key e salva in modo sicuro la chiave privata PEM.
```
/// Creates a key pair that can be used to securely connect to an EC2 instance.
/// The returned key pair contains private key information that cannot be retrieved
/// again. The private key data is stored as a .pem file.
///
/// :param key_name: The name of the key pair to create.
pub async fn create(
&mut self,
ec2: &EC2,
util: &Util,
key_name: String,
) -> Result {
let (key_pair, material) = ec2.create_key_pair(key_name.clone()).await.map_err(|e| {
self.key_pair = KeyPairInfo::builder().key_name(key_name.clone()).build();
e.add_message(format!("Couldn't create key {key_name}"))
})?;
let path = self.key_file_dir.join(format!("{key_name}.pem"));
// Save the key_pair information immediately, so it can get cleaned up if write_secure fails.
self.key_file_path = Some(path.clone());
self.key_pair = key_pair.clone();
util.write_secure(&key_name, &path, material)?;
Ok(key_pair)
}
```
+ Per i dettagli sulle API, consulta la [CreateKeyPair](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.create_key_pair)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateSecurityGroup`
Il seguente esempio di codice mostra come utilizzare`CreateSecurityGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn create_security_group(
&self,
name: &str,
description: &str,
) -> Result {
tracing::info!("Creating security group {name}");
let create_output = self
.client
.create_security_group()
.group_name(name)
.description(description)
.send()
.await
.map_err(EC2Error::from)?;
let group_id = create_output
.group_id
.ok_or_else(|| EC2Error::new("Missing security group id after creation"))?;
let group = self
.describe_security_group(&group_id)
.await?
.ok_or_else(|| {
EC2Error::new(format!("Could not find security group with id {group_id}"))
})?;
tracing::info!("Created security group {name} as {group_id}");
Ok(group)
}
```
+ Per i dettagli sulle API, consulta la [CreateSecurityGroup](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.create_security_group)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateTags`
Il seguente esempio di codice mostra come utilizzare`CreateTags`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
Questo esempio applica il tag Name dopo aver creato un’istanza.
```
pub async fn create_instance<'a>(
&self,
image_id: &'a str,
instance_type: InstanceType,
key_pair: &'a KeyPairInfo,
security_groups: Vec<&'a SecurityGroup>,
) -> Result {
let run_instances = self
.client
.run_instances()
.image_id(image_id)
.instance_type(instance_type)
.key_name(
key_pair
.key_name()
.ok_or_else(|| EC2Error::new("Missing key name when launching instance"))?,
)
.set_security_group_ids(Some(
security_groups
.iter()
.filter_map(|sg| sg.group_id.clone())
.collect(),
))
.min_count(1)
.max_count(1)
.send()
.await?;
if run_instances.instances().is_empty() {
return Err(EC2Error::new("Failed to create instance"));
}
let instance_id = run_instances.instances()[0].instance_id().unwrap();
let response = self
.client
.create_tags()
.resources(instance_id)
.tags(
Tag::builder()
.key("Name")
.value("From SDK Examples")
.build(),
)
.send()
.await;
match response {
Ok(_) => tracing::info!("Created {instance_id} and applied tags."),
Err(err) => {
tracing::info!("Error applying tags to {instance_id}: {err:?}");
return Err(err.into());
}
}
tracing::info!("Instance is created.");
Ok(instance_id.to_string())
}
```
+ Per i dettagli sulle API, consulta la [CreateTags](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.create_tags)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteKeyPair`
Il seguente esempio di codice mostra come utilizzare`DeleteKeyPair`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
Classe wrapper per delete\$1key, che rimuove anche la chiave PEM privata di backup.
```
pub async fn delete(self, ec2: &EC2, util: &Util) -> Result<(), EC2Error> {
if let Some(key_name) = self.key_pair.key_name() {
ec2.delete_key_pair(key_name).await?;
if let Some(key_path) = self.key_file_path() {
if let Err(err) = util.remove(key_path) {
eprintln!("Failed to remove {key_path:?} ({err:?})");
}
}
}
Ok(())
}
```
```
pub async fn delete_key_pair(&self, key_name: &str) -> Result<(), EC2Error> {
let key_name: String = key_name.into();
tracing::info!("Deleting key pair {key_name}");
self.client
.delete_key_pair()
.key_name(key_name)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteKeyPair](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.delete_key_pair)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteSecurityGroup`
Il seguente esempio di codice mostra come utilizzare`DeleteSecurityGroup`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn delete_security_group(&self, group_id: &str) -> Result<(), EC2Error> {
tracing::info!("Deleting security group {group_id}");
self.client
.delete_security_group()
.group_id(group_id)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteSecurityGroup](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.delete_security_group)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteSnapshot`
Il seguente esempio di codice mostra come utilizzare`DeleteSnapshot`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
```
async fn delete_snapshot(client: &Client, id: &str) -> Result<(), Error> {
client.delete_snapshot().snapshot_id(id).send().await?;
println!("Deleted");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteSnapshot](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.delete_snapshot)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeImages`
Il seguente esempio di codice mostra come utilizzare`DescribeImages`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn list_images(&self, ids: Vec) -> Result, EC2Error> {
let image_ids = ids.into_iter().filter_map(|p| p.value).collect();
let output = self
.client
.describe_images()
.set_image_ids(Some(image_ids))
.send()
.await?;
let images = output.images.unwrap_or_default();
if images.is_empty() {
Err(EC2Error::new("No images for selected AMIs"))
} else {
Ok(images)
}
}
```
Utilizzo della funzione list\$1images con SSM per applicare limitazioni in base all’ambiente. Per maggiori dettagli su SSM, vedi https://docs.aws.amazon.com/systems-manager/ latest/userguide/example GetParameters \$1ssm\$1 \$1section.html.
```
async fn find_image(&mut self) -> Result {
let params: Vec = self
.ssm
.list_path("/aws/service/ami-amazon-linux-latest")
.await
.map_err(|e| e.add_message("Could not find parameters for available images"))?
.into_iter()
.filter(|param| param.name().is_some_and(|name| name.contains("amzn2")))
.collect();
let amzn2_images: Vec = self
.ec2
.list_images(params)
.await
.map_err(|e| e.add_message("Could not find images"))?
.into_iter()
.map(ScenarioImage::from)
.collect();
println!("We will now create an instance from an Amazon Linux 2 AMI");
let ami = self.util.select_scenario_image(amzn2_images)?;
Ok(ami)
}
```
+ Per i dettagli sulle API, consulta la guida di riferimento [DescribeImages](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_images)all'API *AWS SDK* for Rust.
### `DescribeInstanceStatus`
Il seguente esempio di codice mostra come utilizzare`DescribeInstanceStatus`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
async fn show_all_events(client: &Client) -> Result<(), Error> {
let resp = client.describe_regions().send().await.unwrap();
for region in resp.regions.unwrap_or_default() {
let reg: &'static str = Box::leak(Box::from(region.region_name().unwrap()));
let region_provider = RegionProviderChain::default_provider().or_else(reg);
let config = aws_config::from_env().region(region_provider).load().await;
let new_client = Client::new(&config);
let resp = new_client.describe_instance_status().send().await;
println!("Instances in region {}:", reg);
println!();
for status in resp.unwrap().instance_statuses() {
println!(
" Events scheduled for instance ID: {}",
status.instance_id().unwrap_or_default()
);
for event in status.events() {
println!(" Event ID: {}", event.instance_event_id().unwrap());
println!(" Description: {}", event.description().unwrap());
println!(" Event code: {}", event.code().unwrap().as_ref());
println!();
}
}
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeInstanceStatus](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_instance_status)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeInstanceTypes`
Il seguente esempio di codice mostra come utilizzare`DescribeInstanceTypes`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
/// List instance types that match an image's architecture and are free tier eligible.
pub async fn list_instance_types(&self, image: &Image) -> Result, EC2Error> {
let architecture = format!(
"{}",
image.architecture().ok_or_else(|| EC2Error::new(format!(
"Image {:?} does not have a listed architecture",
image.image_id()
)))?
);
let free_tier_eligible_filter = Filter::builder()
.name("free-tier-eligible")
.values("false")
.build();
let supported_architecture_filter = Filter::builder()
.name("processor-info.supported-architecture")
.values(architecture)
.build();
let response = self
.client
.describe_instance_types()
.filters(free_tier_eligible_filter)
.filters(supported_architecture_filter)
.send()
.await?;
Ok(response
.instance_types
.unwrap_or_default()
.into_iter()
.filter_map(|iti| iti.instance_type)
.collect())
}
```
+ Per i dettagli sulle API, consulta la [DescribeInstanceTypes](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_instance_types)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeInstances`
Il seguente esempio di codice mostra come utilizzare`DescribeInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
Restituisce i dettagli di un’istanza EC2.
```
pub async fn describe_instance(&self, instance_id: &str) -> Result {
let response = self
.client
.describe_instances()
.instance_ids(instance_id)
.send()
.await?;
let instance = response
.reservations()
.first()
.ok_or_else(|| EC2Error::new(format!("No instance reservations for {instance_id}")))?
.instances()
.first()
.ok_or_else(|| {
EC2Error::new(format!("No instances in reservation for {instance_id}"))
})?;
Ok(instance.clone())
}
```
Dopo aver creato un’istanza EC2, recupera e archivia i relativi dettagli.
```
/// Create an EC2 instance with the given ID on a given type, using a
/// generated KeyPair and applying a list of security groups.
pub async fn create(
&mut self,
ec2: &EC2,
image_id: &str,
instance_type: InstanceType,
key_pair: &KeyPairInfo,
security_groups: Vec<&SecurityGroup>,
) -> Result<(), EC2Error> {
let instance_id = ec2
.create_instance(image_id, instance_type, key_pair, security_groups)
.await?;
let instance = ec2.describe_instance(&instance_id).await?;
self.instance = Some(instance);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeKeyPairs`
Il seguente esempio di codice mostra come utilizzare`DescribeKeyPairs`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn list_key_pair(&self) -> Result, EC2Error> {
let output = self.client.describe_key_pairs().send().await?;
Ok(output.key_pairs.unwrap_or_default())
}
```
+ Per i dettagli sulle API, consulta la [DescribeKeyPairs](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_key_pairs)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeRegions`
Il seguente esempio di codice mostra come utilizzare`DescribeRegions`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
async fn show_regions(client: &Client) -> Result<(), Error> {
let rsp = client.describe_regions().send().await?;
println!("Regions:");
for region in rsp.regions() {
println!(" {}", region.region_name().unwrap());
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeRegions](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_regions)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeSecurityGroups`
Il seguente esempio di codice mostra come utilizzare`DescribeSecurityGroups`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
async fn show_security_groups(client: &aws_sdk_ec2::Client, group_ids: Vec) {
let response = client
.describe_security_groups()
.set_group_ids(Some(group_ids))
.send()
.await;
match response {
Ok(output) => {
for group in output.security_groups() {
println!(
"Found Security Group {} ({}), vpc id {} and description {}",
group.group_name().unwrap_or("unknown"),
group.group_id().unwrap_or("id-unknown"),
group.vpc_id().unwrap_or("vpcid-unknown"),
group.description().unwrap_or("(none)")
);
}
}
Err(err) => {
let err = err.into_service_error();
let meta = err.meta();
let message = meta.message().unwrap_or("unknown");
let code = meta.code().unwrap_or("unknown");
eprintln!("Error listing EC2 Security Groups: ({code}) {message}");
}
}
}
```
+ Per i dettagli sulle API, consulta la [DescribeSecurityGroups](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_security_groups)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeSnapshots`
Il seguente esempio di codice mostra come utilizzare`DescribeSnapshots`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ebs#code-examples).
Mostra lo stato di uno snapshot.
```
async fn show_state(client: &Client, id: &str) -> Result<(), Error> {
let resp = client
.describe_snapshots()
.filters(Filter::builder().name("snapshot-id").values(id).build())
.send()
.await?;
println!(
"State: {}",
resp.snapshots().first().unwrap().state().unwrap().as_ref()
);
Ok(())
}
```
```
async fn show_snapshots(client: &Client) -> Result<(), Error> {
// "self" represents your account ID.
// You can list the snapshots for any account by replacing
// "self" with that account ID.
let resp = client.describe_snapshots().owner_ids("self").send().await?;
let snapshots = resp.snapshots();
let length = snapshots.len();
for snapshot in snapshots {
println!(
"ID: {}",
snapshot.snapshot_id().unwrap_or_default()
);
println!(
"Description: {}",
snapshot.description().unwrap_or_default()
);
println!("State: {}", snapshot.state().unwrap().as_ref());
println!();
}
println!();
println!("Found {} snapshot(s)", length);
println!();
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeSnapshots](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.describe_snapshots)guida di *riferimento all'API AWS SDK for Rust*.
### `DisassociateAddress`
Il seguente esempio di codice mostra come utilizzare`DisassociateAddress`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn disassociate_ip_address(&self, association_id: &str) -> Result<(), EC2Error> {
self.client
.disassociate_address()
.association_id(association_id)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DisassociateAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.disassociate_address)guida di *riferimento all'API AWS SDK for Rust*.
### `RebootInstances`
Il seguente esempio di codice mostra come utilizzare`RebootInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn reboot(&self, ec2: &EC2) -> Result<(), EC2Error> {
if self.instance.is_some() {
ec2.reboot_instance(self.instance_id()).await?;
ec2.wait_for_instance_stopped(self.instance_id(), None)
.await?;
ec2.wait_for_instance_ready(self.instance_id(), None)
.await?;
}
Ok(())
}
```
```
pub async fn reboot_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Rebooting instance {instance_id}");
self.client
.reboot_instances()
.instance_ids(instance_id)
.send()
.await?;
Ok(())
}
```
Utilità waiter dell’istanza con stato Arrestato o Pronto mediante l’API Waiters. L’utilizzo dell’API Waiters richiede “use aws\$1sdk\$1ec2::client::Waiters” nel file rust.
```
/// Wait for an instance to be ready and status ok (default wait 60 seconds)
pub async fn wait_for_instance_ready(
&self,
instance_id: &str,
duration: Option,
) -> Result<(), EC2Error> {
self.client
.wait_until_instance_status_ok()
.instance_ids(instance_id)
.wait(duration.unwrap_or(Duration::from_secs(60)))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to start.",
exceeded.max_wait().as_secs()
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
pub async fn wait_for_instance_stopped(
&self,
instance_id: &str,
duration: Option,
) -> Result<(), EC2Error> {
self.client
.wait_until_instance_stopped()
.instance_ids(instance_id)
.wait(duration.unwrap_or(Duration::from_secs(60)))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to stop.",
exceeded.max_wait().as_secs(),
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [RebootInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.reboot_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `ReleaseAddress`
Il seguente esempio di codice mostra come utilizzare`ReleaseAddress`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn deallocate_ip_address(&self, allocation_id: &str) -> Result<(), EC2Error> {
self.client
.release_address()
.allocation_id(allocation_id)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [ReleaseAddress](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.release_address)guida di *riferimento all'API AWS SDK for Rust*.
### `RunInstances`
Il seguente esempio di codice mostra come utilizzare`RunInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn create_instance<'a>(
&self,
image_id: &'a str,
instance_type: InstanceType,
key_pair: &'a KeyPairInfo,
security_groups: Vec<&'a SecurityGroup>,
) -> Result {
let run_instances = self
.client
.run_instances()
.image_id(image_id)
.instance_type(instance_type)
.key_name(
key_pair
.key_name()
.ok_or_else(|| EC2Error::new("Missing key name when launching instance"))?,
)
.set_security_group_ids(Some(
security_groups
.iter()
.filter_map(|sg| sg.group_id.clone())
.collect(),
))
.min_count(1)
.max_count(1)
.send()
.await?;
if run_instances.instances().is_empty() {
return Err(EC2Error::new("Failed to create instance"));
}
let instance_id = run_instances.instances()[0].instance_id().unwrap();
let response = self
.client
.create_tags()
.resources(instance_id)
.tags(
Tag::builder()
.key("Name")
.value("From SDK Examples")
.build(),
)
.send()
.await;
match response {
Ok(_) => tracing::info!("Created {instance_id} and applied tags."),
Err(err) => {
tracing::info!("Error applying tags to {instance_id}: {err:?}");
return Err(err.into());
}
}
tracing::info!("Instance is created.");
Ok(instance_id.to_string())
}
```
+ Per i dettagli sulle API, consulta la [RunInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.run_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `StartInstances`
Il seguente esempio di codice mostra come utilizzare`StartInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
Avvia un’istanza EC2 per ID istanza.
```
pub async fn start_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Starting instance {instance_id}");
self.client
.start_instances()
.instance_ids(instance_id)
.send()
.await?;
tracing::info!("Started instance.");
Ok(())
}
```
Attende che un’istanza passi allo stato Pronto e OK mediante l’API Waiters. L’utilizzo dell’API Waiters richiede “use aws\$1sdk\$1ec2::client::Waiters” nel file rust.
```
/// Wait for an instance to be ready and status ok (default wait 60 seconds)
pub async fn wait_for_instance_ready(
&self,
instance_id: &str,
duration: Option,
) -> Result<(), EC2Error> {
self.client
.wait_until_instance_status_ok()
.instance_ids(instance_id)
.wait(duration.unwrap_or(Duration::from_secs(60)))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to start.",
exceeded.max_wait().as_secs()
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [StartInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.start_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `StopInstances`
Il seguente esempio di codice mostra come utilizzare`StopInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn stop_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Stopping instance {instance_id}");
self.client
.stop_instances()
.instance_ids(instance_id)
.send()
.await?;
self.wait_for_instance_stopped(instance_id, None).await?;
tracing::info!("Stopped instance.");
Ok(())
}
```
Attende che un’istanza passi allo stato Arrestato mediante l’API Waiters. L’utilizzo dell’API Waiters richiede “use aws\$1sdk\$1ec2::client::Waiters” nel file rust.
```
pub async fn stop_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Stopping instance {instance_id}");
self.client
.stop_instances()
.instance_ids(instance_id)
.send()
.await?;
self.wait_for_instance_stopped(instance_id, None).await?;
tracing::info!("Stopped instance.");
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [StopInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.stop_instances)guida di *riferimento all'API AWS SDK for Rust*.
### `TerminateInstances`
Il seguente esempio di codice mostra come utilizzare`TerminateInstances`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ec2#code-examples).
```
pub async fn delete_instance(&self, instance_id: &str) -> Result<(), EC2Error> {
tracing::info!("Deleting instance with id {instance_id}");
self.stop_instance(instance_id).await?;
self.client
.terminate_instances()
.instance_ids(instance_id)
.send()
.await?;
self.wait_for_instance_terminated(instance_id).await?;
tracing::info!("Terminated instance with id {instance_id}");
Ok(())
}
```
Attende che un’istanza passi allo stato Terminato mediante l’API Waiters. L’utilizzo dell’API Waiters richiede “use aws\$1sdk\$1ec2::client::Waiters” nel file rust.
```
async fn wait_for_instance_terminated(&self, instance_id: &str) -> Result<(), EC2Error> {
self.client
.wait_until_instance_terminated()
.instance_ids(instance_id)
.wait(Duration::from_secs(60))
.await
.map_err(|err| match err {
WaiterError::ExceededMaxWait(exceeded) => EC2Error(format!(
"Exceeded max time ({}s) waiting for instance to terminate.",
exceeded.max_wait().as_secs(),
)),
_ => EC2Error::from(err),
})?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [TerminateInstances](https://docs.rs/aws-sdk-ec2/latest/aws_sdk_ec2/client/struct.Client.html#method.terminate_instances)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon ECR con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon ECR.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `DescribeRepositories`
Il seguente esempio di codice mostra come usare. `DescribeRepositories`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecr#code-examples).
```
async fn show_repos(client: &aws_sdk_ecr::Client) -> Result<(), aws_sdk_ecr::Error> {
let rsp = client.describe_repositories().send().await?;
let repos = rsp.repositories();
println!("Found {} repositories:", repos.len());
for repo in repos {
println!(" ARN: {}", repo.repository_arn().unwrap());
println!(" Name: {}", repo.repository_name().unwrap());
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeRepositories](https://docs.rs/aws-sdk-ecr/latest/aws_sdk_ecr/client/struct.Client.html#method.describe_repositories)guida di *riferimento all'API AWS SDK for Rust*.
### `ListImages`
Il seguente esempio di codice mostra come utilizzare`ListImages`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecr#code-examples).
```
async fn show_images(
client: &aws_sdk_ecr::Client,
repository: &str,
) -> Result<(), aws_sdk_ecr::Error> {
let rsp = client
.list_images()
.repository_name(repository)
.send()
.await?;
let images = rsp.image_ids();
println!("found {} images", images.len());
for image in images {
println!(
"image: {}:{}",
image.image_tag().unwrap(),
image.image_digest().unwrap()
);
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [ListImages](https://docs.rs/aws-sdk-ecr/latest/aws_sdk_ecr/client/struct.Client.html#method.list_images)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon ECS con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon ECS.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `CreateCluster`
Il seguente esempio di codice mostra come usare. `CreateCluster`
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples).
```
async fn make_cluster(client: &aws_sdk_ecs::Client, name: &str) -> Result<(), aws_sdk_ecs::Error> {
let cluster = client.create_cluster().cluster_name(name).send().await?;
println!("cluster created: {:?}", cluster);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [CreateCluster](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.create_cluster)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteCluster`
Il seguente esempio di codice mostra come utilizzare`DeleteCluster`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples).
```
async fn remove_cluster(
client: &aws_sdk_ecs::Client,
name: &str,
) -> Result<(), aws_sdk_ecs::Error> {
let cluster_deleted = client.delete_cluster().cluster(name).send().await?;
println!("cluster deleted: {:?}", cluster_deleted);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteCluster](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.delete_cluster)guida di *riferimento all'API AWS SDK for Rust*.
### `DescribeClusters`
Il seguente esempio di codice mostra come utilizzare`DescribeClusters`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples).
```
async fn show_clusters(client: &aws_sdk_ecs::Client) -> Result<(), aws_sdk_ecs::Error> {
let resp = client.list_clusters().send().await?;
let cluster_arns = resp.cluster_arns();
println!("Found {} clusters:", cluster_arns.len());
let clusters = client
.describe_clusters()
.set_clusters(Some(cluster_arns.into()))
.send()
.await?;
for cluster in clusters.clusters() {
println!(" ARN: {}", cluster.cluster_arn().unwrap());
println!(" Name: {}", cluster.cluster_name().unwrap());
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DescribeClusters](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.describe_clusters)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per Amazon EKS con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con Amazon EKS.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `CreateCluster`
Il seguente esempio di codice mostra come usare`CreateCluster`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/eks#code-examples).
```
async fn make_cluster(
client: &aws_sdk_eks::Client,
name: &str,
arn: &str,
subnet_ids: Vec,
) -> Result<(), aws_sdk_eks::Error> {
let cluster = client
.create_cluster()
.name(name)
.role_arn(arn)
.resources_vpc_config(
VpcConfigRequest::builder()
.set_subnet_ids(Some(subnet_ids))
.build(),
)
.send()
.await?;
println!("cluster created: {:?}", cluster);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [CreateCluster](https://docs.rs/aws-sdk-eks/latest/aws_sdk_eks/client/struct.Client.html#method.create_cluster)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteCluster`
Il seguente esempio di codice mostra come utilizzare`DeleteCluster`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/eks#code-examples).
```
async fn remove_cluster(
client: &aws_sdk_eks::Client,
name: &str,
) -> Result<(), aws_sdk_eks::Error> {
let cluster_deleted = client.delete_cluster().name(name).send().await?;
println!("cluster deleted: {:?}", cluster_deleted);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteCluster](https://docs.rs/aws-sdk-eks/latest/aws_sdk_eks/client/struct.Client.html#method.delete_cluster)guida di *riferimento all'API AWS SDK for Rust*.
# AWS Glue esempi che utilizzano SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con. AWS Glue
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Ciao AWS Glue
L’esempio di codice seguente mostra come iniziare a utilizzare AWS Glue.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let mut list_jobs = glue.list_jobs().into_paginator().send();
while let Some(list_jobs_output) = list_jobs.next().await {
match list_jobs_output {
Ok(list_jobs) => {
let names = list_jobs.job_names();
info!(?names, "Found these jobs")
}
Err(err) => return Err(GlueMvpError::from_glue_sdk(err)),
}
}
```
+ Per i dettagli sulle API, consulta la [ListJobs](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.list_jobs)guida di *riferimento all'API AWS SDK for Rust*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come:
+ Crea un crawler che esegue la scansione di un bucket Amazon S3 pubblico e genera un database di metadati in formato CSV.
+ Elenca le informazioni su database e tabelle in. AWS Glue Data Catalog
+ Crea un processo per estrarre i dati CSV dal bucket S3, trasformare i dati e caricare l’output in formato JSON in un altro bucket S3.
+ Elenca le informazioni sulle esecuzioni dei processi, visualizza i dati trasformati e pulisci le risorse.
Per ulteriori informazioni, consulta [Tutorial: Guida introduttiva a AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/tutorial-create-job.html).
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
Creare e avviare un crawler in grado di eseguire il crawling di un bucket pubblico di Amazon Simple Storage Service (Amazon S3) generando un database di metadati che descrive i dati rilevati in formato CSV.
```
let create_crawler = glue
.create_crawler()
.name(self.crawler())
.database_name(self.database())
.role(self.iam_role.expose_secret())
.targets(
CrawlerTargets::builder()
.s3_targets(S3Target::builder().path(CRAWLER_TARGET).build())
.build(),
)
.send()
.await;
match create_crawler {
Err(err) => {
let glue_err: aws_sdk_glue::Error = err.into();
match glue_err {
aws_sdk_glue::Error::AlreadyExistsException(_) => {
info!("Using existing crawler");
Ok(())
}
_ => Err(GlueMvpError::GlueSdk(glue_err)),
}
}
Ok(_) => Ok(()),
}?;
let start_crawler = glue.start_crawler().name(self.crawler()).send().await;
match start_crawler {
Ok(_) => Ok(()),
Err(err) => {
let glue_err: aws_sdk_glue::Error = err.into();
match glue_err {
aws_sdk_glue::Error::CrawlerRunningException(_) => Ok(()),
_ => Err(GlueMvpError::GlueSdk(glue_err)),
}
}
}?;
```
Elenca le informazioni su database e tabelle nel tuo AWS Glue Data Catalog.
```
let database = glue
.get_database()
.name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?
.to_owned();
let database = database
.database()
.ok_or_else(|| GlueMvpError::Unknown("Could not find database".into()))?;
let tables = glue
.get_tables()
.database_name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let tables = tables.table_list();
```
Creare e avviare un processo che estrae i dati CSV dal bucket Amazon S3 di origine, li trasforma rimuovendo e rinominando i campi e carica l'output in formato JSON in un altro bucket Amazon S3.
```
let create_job = glue
.create_job()
.name(self.job())
.role(self.iam_role.expose_secret())
.command(
JobCommand::builder()
.name("glueetl")
.python_version("3")
.script_location(format!("s3://{}/job.py", self.bucket()))
.build(),
)
.glue_version("3.0")
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let job_name = create_job.name().ok_or_else(|| {
GlueMvpError::Unknown("Did not get job name after creating job".into())
})?;
let job_run_output = glue
.start_job_run()
.job_name(self.job())
.arguments("--input_database", self.database())
.arguments(
"--input_table",
self.tables
.first()
.ok_or_else(|| GlueMvpError::Unknown("Missing crawler table".into()))?
.name(),
)
.arguments("--output_bucket_url", self.bucket())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let job = job_run_output
.job_run_id()
.ok_or_else(|| GlueMvpError::Unknown("Missing run id from just started job".into()))?
.to_string();
```
Eliminare tutte le risorse create dalla demo.
```
glue.delete_job()
.job_name(self.job())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
for t in &self.tables {
glue.delete_table()
.name(t.name())
.database_name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
}
glue.delete_database()
.name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
glue.delete_crawler()
.name(self.crawler())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
+ [CreateCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.create_crawler)
+ [CreateJob](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.create_job)
+ [DeleteCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_crawler)
+ [DeleteDatabase](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_database)
+ [DeleteJob](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_job)
+ [DeleteTable](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_table)
+ [GetCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_crawler)
+ [GetDatabase](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_database)
+ [GetDatabases](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_databases)
+ [GetJob](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_job)
+ [GetJobRun](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_job_run)
+ [GetJobRuns](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_job_runs)
+ [GetTables](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_tables)
+ [ListJobs](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.list_jobs)
+ [StartCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.start_crawler)
+ [StartJobRun](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.start_job_run)
## Azioni
### `CreateCrawler`
Il seguente esempio di codice mostra come utilizzare`CreateCrawler`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let create_crawler = glue
.create_crawler()
.name(self.crawler())
.database_name(self.database())
.role(self.iam_role.expose_secret())
.targets(
CrawlerTargets::builder()
.s3_targets(S3Target::builder().path(CRAWLER_TARGET).build())
.build(),
)
.send()
.await;
match create_crawler {
Err(err) => {
let glue_err: aws_sdk_glue::Error = err.into();
match glue_err {
aws_sdk_glue::Error::AlreadyExistsException(_) => {
info!("Using existing crawler");
Ok(())
}
_ => Err(GlueMvpError::GlueSdk(glue_err)),
}
}
Ok(_) => Ok(()),
}?;
```
+ Per i dettagli sulle API, consulta la [CreateCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.create_crawler)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateJob`
Il seguente esempio di codice mostra come utilizzare`CreateJob`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let create_job = glue
.create_job()
.name(self.job())
.role(self.iam_role.expose_secret())
.command(
JobCommand::builder()
.name("glueetl")
.python_version("3")
.script_location(format!("s3://{}/job.py", self.bucket()))
.build(),
)
.glue_version("3.0")
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let job_name = create_job.name().ok_or_else(|| {
GlueMvpError::Unknown("Did not get job name after creating job".into())
})?;
```
+ Per i dettagli sulle API, consulta la [CreateJob](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.create_job)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteCrawler`
Il seguente esempio di codice mostra come utilizzare`DeleteCrawler`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
glue.delete_crawler()
.name(self.crawler())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
```
+ Per i dettagli sulle API, consulta la [DeleteCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_crawler)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteDatabase`
Il seguente esempio di codice mostra come utilizzare`DeleteDatabase`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
glue.delete_database()
.name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
```
+ Per i dettagli sulle API, consulta la [DeleteDatabase](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_database)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteJob`
Il seguente esempio di codice mostra come utilizzare`DeleteJob`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
glue.delete_job()
.job_name(self.job())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
```
+ Per i dettagli sulle API, consulta la [DeleteJob](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_job)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteTable`
Il seguente esempio di codice mostra come utilizzare`DeleteTable`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
for t in &self.tables {
glue.delete_table()
.name(t.name())
.database_name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
}
```
+ Per i dettagli sulle API, consulta la [DeleteTable](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.delete_table)guida di *riferimento all'API AWS SDK for Rust*.
### `GetCrawler`
Il seguente esempio di codice mostra come utilizzare`GetCrawler`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let tmp_crawler = glue
.get_crawler()
.name(self.crawler())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
```
+ Per i dettagli sulle API, consulta la [GetCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_crawler)guida di *riferimento all'API AWS SDK for Rust*.
### `GetDatabase`
Il seguente esempio di codice mostra come utilizzare`GetDatabase`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let database = glue
.get_database()
.name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?
.to_owned();
let database = database
.database()
.ok_or_else(|| GlueMvpError::Unknown("Could not find database".into()))?;
```
+ Per i dettagli sulle API, consulta la [GetDatabase](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_database)guida di *riferimento all'API AWS SDK for Rust*.
### `GetJobRun`
Il seguente esempio di codice mostra come utilizzare`GetJobRun`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let get_job_run = || async {
Ok::(
glue.get_job_run()
.job_name(self.job())
.run_id(job_run_id.to_string())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?
.job_run()
.ok_or_else(|| GlueMvpError::Unknown("Failed to get job_run".into()))?
.to_owned(),
)
};
let mut job_run = get_job_run().await?;
let mut state = job_run.job_run_state().unwrap_or(&unknown_state).to_owned();
while matches!(
state,
JobRunState::Starting | JobRunState::Stopping | JobRunState::Running
) {
info!(?state, "Waiting for job to finish");
tokio::time::sleep(self.wait_delay).await;
job_run = get_job_run().await?;
state = job_run.job_run_state().unwrap_or(&unknown_state).to_owned();
}
```
+ Per i dettagli sulle API, consulta la [GetJobRun](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_job_run)guida di *riferimento all'API AWS SDK for Rust*.
### `GetTables`
Il seguente esempio di codice mostra come utilizzare`GetTables`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let tables = glue
.get_tables()
.database_name(self.database())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let tables = tables.table_list();
```
+ Per i dettagli sulle API, consulta la [GetTables](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.get_tables)guida di *riferimento all'API AWS SDK for Rust*.
### `ListJobs`
Il seguente esempio di codice mostra come utilizzare`ListJobs`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let mut list_jobs = glue.list_jobs().into_paginator().send();
while let Some(list_jobs_output) = list_jobs.next().await {
match list_jobs_output {
Ok(list_jobs) => {
let names = list_jobs.job_names();
info!(?names, "Found these jobs")
}
Err(err) => return Err(GlueMvpError::from_glue_sdk(err)),
}
}
```
+ Per i dettagli sulle API, consulta la [ListJobs](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.list_jobs)guida di *riferimento all'API AWS SDK for Rust*.
### `StartCrawler`
Il seguente esempio di codice mostra come utilizzare`StartCrawler`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let start_crawler = glue.start_crawler().name(self.crawler()).send().await;
match start_crawler {
Ok(_) => Ok(()),
Err(err) => {
let glue_err: aws_sdk_glue::Error = err.into();
match glue_err {
aws_sdk_glue::Error::CrawlerRunningException(_) => Ok(()),
_ => Err(GlueMvpError::GlueSdk(glue_err)),
}
}
}?;
```
+ Per i dettagli sulle API, consulta la [StartCrawler](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.start_crawler)guida di *riferimento all'API AWS SDK for Rust*.
### `StartJobRun`
Il seguente esempio di codice mostra come utilizzare`StartJobRun`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/glue#code-examples).
```
let job_run_output = glue
.start_job_run()
.job_name(self.job())
.arguments("--input_database", self.database())
.arguments(
"--input_table",
self.tables
.first()
.ok_or_else(|| GlueMvpError::Unknown("Missing crawler table".into()))?
.name(),
)
.arguments("--output_bucket_url", self.bucket())
.send()
.await
.map_err(GlueMvpError::from_glue_sdk)?;
let job = job_run_output
.job_run_id()
.ok_or_else(|| GlueMvpError::Unknown("Missing run id from just started job".into()))?
.to_string();
```
+ Per i dettagli sulle API, consulta la [StartJobRun](https://docs.rs/aws-sdk-glue/latest/aws_sdk_glue/client/struct.Client.html#method.start_job_run)guida di *riferimento all'API AWS SDK for Rust*.
# Esempi per IAM con SDK per Rust
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando l' AWS SDK per Rust con IAM.
*Nozioni di base*: esempi di codice che mostrano come eseguire le operazioni essenziali all’interno di un servizio.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Nozioni di base](#get_started)
+ [Nozioni di base](#basics)
+ [Azioni](#actions)
## Nozioni di base
### Hello IAM
Il seguente esempio di codice mostra come iniziare a usare IAM.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
Da src/bin/hello R.S.
```
use aws_sdk_iam::error::SdkError;
use aws_sdk_iam::operation::list_policies::ListPoliciesError;
use clap::Parser;
const PATH_PREFIX_HELP: &str = "The path prefix for filtering the results.";
#[derive(Debug, clap::Parser)]
#[command(about)]
struct HelloScenarioArgs {
#[arg(long, default_value="/", help=PATH_PREFIX_HELP)]
pub path_prefix: String,
}
#[tokio::main]
async fn main() -> Result<(), SdkError> {
let sdk_config = aws_config::load_from_env().await;
let client = aws_sdk_iam::Client::new(&sdk_config);
let args = HelloScenarioArgs::parse();
iam_service::list_policies(client, args.path_prefix).await?;
Ok(())
}
```
Da src/ .rsiam-service-lib.
```
pub async fn list_policies(
client: iamClient,
path_prefix: String,
) -> Result, SdkError> {
let list_policies = client
.list_policies()
.path_prefix(path_prefix)
.scope(PolicyScopeType::Local)
.into_paginator()
.items()
.send()
.try_collect()
.await?;
let policy_names = list_policies
.into_iter()
.map(|p| {
let name = p
.policy_name
.unwrap_or_else(|| "Missing Policy Name".to_string());
println!("{}", name);
name
})
.collect();
Ok(policy_names)
}
```
+ Per i dettagli sull'API, consulta la guida di riferimento [ListPolicies](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.list_policies)all'API *AWS SDK for Rust*.
## Nozioni di base
### Informazioni di base
L’esempio di codice seguente mostra come creare un utente e assumere un ruolo.
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
+ Crea un utente che non disponga di autorizzazioni.
+ Crea un ruolo che conceda l’autorizzazione per elencare i bucket Amazon S3 per l’account.
+ Aggiungi una policy per consentire all’utente di assumere il ruolo.
+ Assumi il ruolo ed elenca i bucket S3 utilizzando le credenziali temporanee, quindi ripulisci le risorse.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_iam::Error as iamError;
use aws_sdk_iam::{config::Credentials as iamCredentials, config::Region, Client as iamClient};
use aws_sdk_s3::Client as s3Client;
use aws_sdk_sts::Client as stsClient;
use tokio::time::{sleep, Duration};
use uuid::Uuid;
#[tokio::main]
async fn main() -> Result<(), iamError> {
let (client, uuid, list_all_buckets_policy_document, inline_policy_document) =
initialize_variables().await;
if let Err(e) = run_iam_operations(
client,
uuid,
list_all_buckets_policy_document,
inline_policy_document,
)
.await
{
println!("{:?}", e);
};
Ok(())
}
async fn initialize_variables() -> (iamClient, String, String, String) {
let region_provider = RegionProviderChain::first_try(Region::new("us-west-2"));
let shared_config = aws_config::from_env().region(region_provider).load().await;
let client = iamClient::new(&shared_config);
let uuid = Uuid::new_v4().to_string();
let list_all_buckets_policy_document = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"s3:ListAllMyBuckets\",
\"Resource\": \"arn:aws:s3:::*\"}]
}"
.to_string();
let inline_policy_document = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Action\": \"sts:AssumeRole\",
\"Resource\": \"{}\"}]
}"
.to_string();
(
client,
uuid,
list_all_buckets_policy_document,
inline_policy_document,
)
}
async fn run_iam_operations(
client: iamClient,
uuid: String,
list_all_buckets_policy_document: String,
inline_policy_document: String,
) -> Result<(), iamError> {
let user = iam_service::create_user(&client, &format!("{}{}", "iam_demo_user_", uuid)).await?;
println!("Created the user with the name: {}", user.user_name());
let key = iam_service::create_access_key(&client, user.user_name()).await?;
let assume_role_policy_document = "{
\"Version\": \"2012-10-17\",
\"Statement\": [{
\"Effect\": \"Allow\",
\"Principal\": {\"AWS\": \"{}\"},
\"Action\": \"sts:AssumeRole\"
}]
}"
.to_string()
.replace("{}", user.arn());
let assume_role_role = iam_service::create_role(
&client,
&format!("{}{}", "iam_demo_role_", uuid),
&assume_role_policy_document,
)
.await?;
println!("Created the role with the ARN: {}", assume_role_role.arn());
let list_all_buckets_policy = iam_service::create_policy(
&client,
&format!("{}{}", "iam_demo_policy_", uuid),
&list_all_buckets_policy_document,
)
.await?;
println!(
"Created policy: {}",
list_all_buckets_policy.policy_name.as_ref().unwrap()
);
let attach_role_policy_result =
iam_service::attach_role_policy(&client, &assume_role_role, &list_all_buckets_policy)
.await?;
println!(
"Attached the policy to the role: {:?}",
attach_role_policy_result
);
let inline_policy_name = format!("{}{}", "iam_demo_inline_policy_", uuid);
let inline_policy_document = inline_policy_document.replace("{}", assume_role_role.arn());
iam_service::create_user_policy(&client, &user, &inline_policy_name, &inline_policy_document)
.await?;
println!("Created inline policy.");
//First, fail to list the buckets with the user.
let creds = iamCredentials::from_keys(key.access_key_id(), key.secret_access_key(), None);
let fail_config = aws_config::from_env()
.credentials_provider(creds.clone())
.load()
.await;
println!("Fail config: {:?}", fail_config);
let fail_client: s3Client = s3Client::new(&fail_config);
match fail_client.list_buckets().send().await {
Ok(e) => {
println!("This should not run. {:?}", e);
}
Err(e) => {
println!("Successfully failed with error: {:?}", e)
}
}
let sts_config = aws_config::from_env()
.credentials_provider(creds.clone())
.load()
.await;
let sts_client: stsClient = stsClient::new(&sts_config);
sleep(Duration::from_secs(10)).await;
let assumed_role = sts_client
.assume_role()
.role_arn(assume_role_role.arn())
.role_session_name(format!("iam_demo_assumerole_session_{uuid}"))
.send()
.await;
println!("Assumed role: {:?}", assumed_role);
sleep(Duration::from_secs(10)).await;
let assumed_credentials = iamCredentials::from_keys(
assumed_role
.as_ref()
.unwrap()
.credentials
.as_ref()
.unwrap()
.access_key_id(),
assumed_role
.as_ref()
.unwrap()
.credentials
.as_ref()
.unwrap()
.secret_access_key(),
Some(
assumed_role
.as_ref()
.unwrap()
.credentials
.as_ref()
.unwrap()
.session_token
.clone(),
),
);
let succeed_config = aws_config::from_env()
.credentials_provider(assumed_credentials)
.load()
.await;
println!("succeed config: {:?}", succeed_config);
let succeed_client: s3Client = s3Client::new(&succeed_config);
sleep(Duration::from_secs(10)).await;
match succeed_client.list_buckets().send().await {
Ok(_) => {
println!("This should now run successfully.")
}
Err(e) => {
println!("This should not run. {:?}", e);
panic!()
}
}
//Clean up.
iam_service::detach_role_policy(
&client,
assume_role_role.role_name(),
list_all_buckets_policy.arn().unwrap_or_default(),
)
.await?;
iam_service::delete_policy(&client, list_all_buckets_policy).await?;
iam_service::delete_role(&client, &assume_role_role).await?;
println!("Deleted role {}", assume_role_role.role_name());
iam_service::delete_access_key(&client, &user, &key).await?;
println!("Deleted key for {}", key.user_name());
iam_service::delete_user_policy(&client, &user, &inline_policy_name).await?;
println!("Deleted inline user policy: {}", inline_policy_name);
iam_service::delete_user(&client, &user).await?;
println!("Deleted user {}", user.user_name());
Ok(())
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API SDK AWS per Rust*.
+ [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)
+ [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)
+ [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)
+ [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)
+ [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)
+ [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)
+ [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)
+ [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)
+ [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)
+ [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)
+ [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)
+ [PutUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.put_user_policy)
## Azioni
### `AttachRolePolicy`
Il seguente esempio di codice mostra come usare`AttachRolePolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn attach_role_policy(
client: &iamClient,
role: &Role,
policy: &Policy,
) -> Result> {
client
.attach_role_policy()
.role_name(role.role_name())
.policy_arn(policy.arn().unwrap_or_default())
.send()
.await
}
```
+ Per i dettagli sulle API, consulta la [AttachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_role_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `AttachUserPolicy`
Il seguente esempio di codice mostra come utilizzare`AttachUserPolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn attach_user_policy(
client: &iamClient,
user_name: &str,
policy_arn: &str,
) -> Result<(), iamError> {
client
.attach_user_policy()
.user_name(user_name)
.policy_arn(policy_arn)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [AttachUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.attach_user_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateAccessKey`
Il seguente esempio di codice mostra come utilizzare`CreateAccessKey`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn create_access_key(client: &iamClient, user_name: &str) -> Result {
let mut tries: i32 = 0;
let max_tries: i32 = 10;
let response: Result> = loop {
match client.create_access_key().user_name(user_name).send().await {
Ok(inner_response) => {
break Ok(inner_response);
}
Err(e) => {
tries += 1;
if tries > max_tries {
break Err(e);
}
sleep(Duration::from_secs(2)).await;
}
}
};
Ok(response.unwrap().access_key.unwrap())
}
```
+ Per i dettagli sulle API, consulta la [CreateAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_access_key)guida di *riferimento all'API AWS SDK for Rust*.
### `CreatePolicy`
Il seguente esempio di codice mostra come utilizzare`CreatePolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn create_policy(
client: &iamClient,
policy_name: &str,
policy_document: &str,
) -> Result {
let policy = client
.create_policy()
.policy_name(policy_name)
.policy_document(policy_document)
.send()
.await?;
Ok(policy.policy.unwrap())
}
```
+ Per i dettagli sulle API, consulta la [CreatePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateRole`
Il seguente esempio di codice mostra come utilizzare`CreateRole`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn create_role(
client: &iamClient,
role_name: &str,
role_policy_document: &str,
) -> Result {
let response: CreateRoleOutput = loop {
if let Ok(response) = client
.create_role()
.role_name(role_name)
.assume_role_policy_document(role_policy_document)
.send()
.await
{
break response;
}
};
Ok(response.role.unwrap())
}
```
+ Per i dettagli sulle API, consulta la [CreateRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_role)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateServiceLinkedRole`
Il seguente esempio di codice mostra come utilizzare`CreateServiceLinkedRole`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn create_service_linked_role(
client: &iamClient,
aws_service_name: String,
custom_suffix: Option,
description: Option,
) -> Result> {
let response = client
.create_service_linked_role()
.aws_service_name(aws_service_name)
.set_custom_suffix(custom_suffix)
.set_description(description)
.send()
.await?;
Ok(response)
}
```
+ Per i dettagli sulle API, consulta la [CreateServiceLinkedRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_service_linked_role)guida di *riferimento all'API AWS SDK for Rust*.
### `CreateUser`
Il seguente esempio di codice mostra come utilizzare`CreateUser`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn create_user(client: &iamClient, user_name: &str) -> Result {
let response = client.create_user().user_name(user_name).send().await?;
Ok(response.user.unwrap())
}
```
+ Per i dettagli sulle API, consulta la [CreateUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.create_user)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteAccessKey`
Il seguente esempio di codice mostra come utilizzare`DeleteAccessKey`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_access_key(
client: &iamClient,
user: &User,
key: &AccessKey,
) -> Result<(), iamError> {
loop {
match client
.delete_access_key()
.user_name(user.user_name())
.access_key_id(key.access_key_id())
.send()
.await
{
Ok(_) => {
break;
}
Err(e) => {
println!("Can't delete the access key: {:?}", e);
sleep(Duration::from_secs(2)).await;
}
}
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteAccessKey](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_access_key)guida di *riferimento all'API AWS SDK for Rust*.
### `DeletePolicy`
Il seguente esempio di codice mostra come utilizzare`DeletePolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_policy(client: &iamClient, policy: Policy) -> Result<(), iamError> {
client
.delete_policy()
.policy_arn(policy.arn.unwrap())
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeletePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteRole`
Il seguente esempio di codice mostra come utilizzare`DeleteRole`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_role(client: &iamClient, role: &Role) -> Result<(), iamError> {
let role = role.clone();
while client
.delete_role()
.role_name(role.role_name())
.send()
.await
.is_err()
{
sleep(Duration::from_secs(2)).await;
}
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_role)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteServiceLinkedRole`
Il seguente esempio di codice mostra come utilizzare`DeleteServiceLinkedRole`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_service_linked_role(
client: &iamClient,
role_name: &str,
) -> Result<(), iamError> {
client
.delete_service_linked_role()
.role_name(role_name)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteServiceLinkedRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_service_linked_role)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteUser`
Il seguente esempio di codice mostra come utilizzare`DeleteUser`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_user(client: &iamClient, user: &User) -> Result<(), SdkError> {
let user = user.clone();
let mut tries: i32 = 0;
let max_tries: i32 = 10;
let response: Result<(), SdkError> = loop {
match client
.delete_user()
.user_name(user.user_name())
.send()
.await
{
Ok(_) => {
break Ok(());
}
Err(e) => {
tries += 1;
if tries > max_tries {
break Err(e);
}
sleep(Duration::from_secs(2)).await;
}
}
};
response
}
```
+ Per i dettagli sulle API, consulta la [DeleteUser](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user)guida di *riferimento all'API AWS SDK for Rust*.
### `DeleteUserPolicy`
Il seguente esempio di codice mostra come utilizzare`DeleteUserPolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn delete_user_policy(
client: &iamClient,
user: &User,
policy_name: &str,
) -> Result<(), SdkError> {
client
.delete_user_policy()
.user_name(user.user_name())
.policy_name(policy_name)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DeleteUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.delete_user_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `DetachRolePolicy`
Il seguente esempio di codice mostra come utilizzare`DetachRolePolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn detach_role_policy(
client: &iamClient,
role_name: &str,
policy_arn: &str,
) -> Result<(), iamError> {
client
.detach_role_policy()
.role_name(role_name)
.policy_arn(policy_arn)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DetachRolePolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_role_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `DetachUserPolicy`
Il seguente esempio di codice mostra come utilizzare`DetachUserPolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn detach_user_policy(
client: &iamClient,
user_name: &str,
policy_arn: &str,
) -> Result<(), iamError> {
client
.detach_user_policy()
.user_name(user_name)
.policy_arn(policy_arn)
.send()
.await?;
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [DetachUserPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.detach_user_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `GetAccountPasswordPolicy`
Il seguente esempio di codice mostra come utilizzare`GetAccountPasswordPolicy`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn get_account_password_policy(
client: &iamClient,
) -> Result> {
let response = client.get_account_password_policy().send().await?;
Ok(response)
}
```
+ Per i dettagli sulle API, consulta la [GetAccountPasswordPolicy](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.get_account_password_policy)guida di *riferimento all'API AWS SDK for Rust*.
### `GetRole`
Il seguente esempio di codice mostra come utilizzare`GetRole`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn get_role(
client: &iamClient,
role_name: String,
) -> Result> {
let response = client.get_role().role_name(role_name).send().await?;
Ok(response)
}
```
+ Per i dettagli sulle API, consulta la [GetRole](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.get_role)guida di *riferimento all'API AWS SDK for Rust*.
### `ListAttachedRolePolicies`
Il seguente esempio di codice mostra come utilizzare`ListAttachedRolePolicies`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn list_attached_role_policies(
client: &iamClient,
role_name: String,
path_prefix: Option,
marker: Option,
max_items: Option,
) -> Result> {
let response = client
.list_attached_role_policies()
.role_name(role_name)
.set_path_prefix(path_prefix)
.set_marker(marker)
.set_max_items(max_items)
.send()
.await?;
Ok(response)
}
```
+ Per i dettagli sulle API, consulta la [ListAttachedRolePolicies](https://docs.rs/aws-sdk-iam/latest/aws_sdk_iam/client/struct.Client.html#method.list_attached_role_policies)guida di *riferimento all'API AWS SDK for Rust*.
### `ListGroups`
Il seguente esempio di codice mostra come utilizzare`ListGroups`.
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/iam#code-examples).
```
pub async fn list_groups(
client: &iamClient,
path_prefix: Option,
marker: Option,
max_items: Option,
) -> Result