How to Use the AWS SDK for Rust

Use the aws-config crate to handle credential loading and region configuration, then instantiate specific service clients like S3 or DynamoDb via the SdkConfig object. You typically define your dependencies in Cargo.toml, initialize the config asynchronously, and call service methods that return Result types to handle errors.

Add the necessary crates to your Cargo.toml. The aws-config crate is essential for bootstrapping, while service-specific crates (like aws-sdk-s3) provide the client APIs.

[dependencies]
aws-config = "1.5"
aws-sdk-s3 = "1.5"
tokio = { version = "1", features = ["full"] }

In your Rust code, initialize the configuration using load_default which automatically checks environment variables, shared credentials files, and IAM roles. Then, create the client and execute an asynchronous operation, handling the result explicitly.

use aws_config::load_defaults;
use aws_sdk_s3::Client;
use aws_sdk_s3::types::BucketName;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load configuration from environment, shared config, or IAM role
    let config = load_defaults(aws_config::BehaviorVersion::latest()).await;
    
    // Create the S3 client
    let client = Client::from_conf(config);

    // Example: List buckets
    let result = client.list_buckets().send().await?;

    if let Some(buckets) = result.buckets() {
        for bucket in buckets {
            if let Some(name) = bucket.name() {
                println!("Found bucket: {}", name);
            }
        }
    }

    Ok(())
}

Authentication is handled automatically by aws-config if you have standard AWS credentials configured (e.g., ~/.aws/credentials or environment variables AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY). For local development, you can also use aws_localstack or mock the client, but for production, rely on the default loading chain.

Note that the AWS SDK for Rust is asynchronous by design. All client methods return futures, so you must run your code inside an async runtime like tokio. The SDK uses the Result<T, E> pattern for error handling, where E is usually an aws_sdk_s3::error::SdkError. You can inspect these errors to distinguish between service errors (like NoSuchBucket) and client-side issues (like network timeouts).

If you need to customize the region or endpoint, you can chain .region() or .endpoint_url() onto the ConfigBuilder before calling .build(). For example, aws_config::Region::new("us-west-2") allows you to override the default region detection. Keep your dependencies updated, as the AWS SDK for Rust evolves rapidly to support new services and features.

The provided text is a reference manual for the Rust programming language itself, not a guide for external tools like AWS. It explains how to write basic Rust code, handle files, and understand compiler behavior. To use AWS, you need to install separate libraries that are not covered in this specific documentation.