Rust AWS SDK EFS插件库的使用：aws-sdk-efs实现Amazon Elastic File System管理

完整示例代码

下面是一个完整的示例，展示了如何使用aws-sdk-efs库来创建、管理和删除EFS资源：

use aws_sdk_efs as efs;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // 1. 创建EFS客户端
    let client = create_efs_client().await;
    
    // 2. 创建文件系统
    let file_system_id = match create_file_system(&client).await {
        Ok(id) => id,
        Err(e) => {
            eprintln!("Failed to create file system: {}", e);
            return Err(e.into());
        }
    };
    
    // 3. 等待文件系统变为可用状态
    wait_for_file_system_available(&client, &file_system_id).await?;
    
    // 4. 列出所有文件系统
    list_file_systems(&client).await?;
    
    // 5. 创建挂载目标
    let subnet_id = "subnet-12345678"; // 替换为你的子网ID
    let security_groups = vec!["sg-12345678".to_string()]; // 替换为你的安全组ID
    create_mount_target(&client, &file_system_id, subnet_id, security_groups).await?;
    
    // 6. 创建访问点
    create_access_point(&client, &file_system_id, "my-access-point").await?;
    
    // 7. 使用分页列出所有文件系统
    list_all_file_systems_paginated(&client).await?;
    
    // 8. 清理资源
    delete_file_system(&client, &file_system_id).await?;
    
    Ok(())
}

async fn create_efs_client() -> efs::Client {
    // 从环境加载AWS配置
    let config = aws_config::load_from_env().await;
    efs::Client::new(&config)
}

async fn create_file_system(client: &efs::Client) -> Result<String, efs::Error> {
    let resp = client
        .create_file_system()
        .creation_token("my-unique-token")
        .tags(
            efs::types::Tag::builder()
                .key("Name")
                .value("MyEFS")
                .build()
        )
        .send()
        .await?;

    let file_system_id = resp.file_system_id().unwrap().to_string();
    println!("Created EFS with ID: {}", file_system_id);
    Ok(file_system_id)
}

async fn list_file_systems(client: &efs::Client) -> Result<(), efs::Error> {
    let resp = client.describe_file_systems().send().await?;

    println!("Listing all EFS file systems:");
    for fs in resp.file_systems().unwrap_or_default() {
        println!(
            "ID: {}, Size: {} GB, State: {:?}",
            fs.file_system_id().unwrap_or_default(),
            fs.size_in_bytes().unwrap().value() / (1024 * 1024 * 1024),
            fs.life_cycle_state().unwrap()
        );
    }
    Ok(())
}

async fn wait_for_file_system_available(
    client: &efs::Client,
    file_system_id: &str,
) -> Result<(), efs::Error> {
    use tokio::time::{sleep, Duration};

    println!("Waiting for file system {} to become available...", file_system_id);
    
    loop {
        let resp = client
            .describe_file_systems()
            .file_system_id(file_system_id)
            .send()
            .await?;

        if let Some(fs) = resp.file_systems().and_then(|fs| fs.first()) {
            match fs.life_cycle_state() {
                Some(efs::types::LifeCycleState::Available) => {
                    println!("File system is now available");
                    return Ok(());
                }
                Some(efs::types::LifeCycleState::Creating) => {
                    println!("File system is still creating...");
                }
                _ => {
                    println!("Unexpected state: {:?}", fs.life_cycle_state());
                    return Err(efs::Error::unhandled("Unexpected file system state"));
                }
            }
        }

        sleep(Duration::from_secs(5)).await;
    }
}

async fn create_mount_target(
    client: &efs::Client,
    file_system_id: &str,
    subnet_id: &str,
    security_groups: Vec<String>,
) -> Result<(), efs::Error> {
    println!("Creating mount target for file system {}...", file_system_id);
    
    let resp = client
        .create_mount_target()
        .file_system_id(file_system_id)
        .subnet_id(subnet_id)
        .security_groups(security_groups)
        .send()
        .await?;

    println!(
        "Created mount target with ID: {}",
        resp.mount_target_id().unwrap()
    );
    Ok(())
}

async fn create_access_point(
    client: &efs::Client,
    file_system_id: &str,
    name: &str,
) -> Result<(), efs::Error> {
    println!("Creating access point for file system {}...", file_system_id);
    
    let resp = client
        .create_access_point()
        .file_system_id(file_system_id)
        .posix_user(
            efs::types::PosixUser::builder()
                .uid(1000)
                .gid(1000)
                .build()
        )
        .root_directory(
            efs::types::RootDirectory::builder()
                .path("/data")
                .creation_info(
                    efs::types::CreationInfo::builder()
                        .owner_uid(1000)
                        .owner_gid(1000)
                        .permissions("755")
                        .build()
                )
                .build()
        )
        .tags(
            efs::types::Tag::builder()
                .key("Name")
                .value(name)
                .build()
        )
        .send()
        .await?;

    println!("Created access point with ID: {}", resp.access_point_id().unwrap());
    Ok(())
}

async fn list_all_file_systems_paginated(client: &efs::Client) -> Result<(), efs::Error> {
    println!("Listing all file systems with pagination...");
    
    let mut paginator = client
        .describe_file_systems()
        .into_paginator()
        .send();

    while let Some(page) = paginator.next().await {
        let page = page?;
        for fs in page.file_systems().unwrap_or_default() {
            println!("Found EFS: {:?}", fs.file_system_id());
        }
    }
    Ok(())
}

async fn delete_file_system(client: &efs::Client, file_system_id: &str) -> Result<(), efs::Error> {
    println!("Deleting file system {}...", file_system_id);
    
    // 先删除所有挂载目标
    let mount_targets = client
        .describe_mount_targets()
        .file_system_id(file_system_id)
        .send()
        .await?;

    println!("Found {} mount targets to delete", mount_targets.mount_targets().unwrap_or_default().len());
    
    for target in mount_targets.mount_targets().unwrap_or_default() {
        client
            .delete_mount_target()
            .mount_target_id(target.mount_target_id().unwrap())
            .send()
            .await?;
        println!("Deleted mount target: {}", target.mount_target_id().unwrap());
    }

    // 然后删除文件系统
    client
        .delete_file_system()
        .file_system_id(file_system_id)
        .send()
        .await?;

    println!("Successfully deleted file system {}", file_system_id);
    Ok(())
}

使用说明

1. 在运行此代码前，请确保：

   • 已配置好AWS凭证
   • 替换代码中的子网ID和安全组ID为你自己的值
   • 已安装Rust和Cargo

2. 将上述代码保存为main.rs文件，并在Cargo.toml中添加以下依赖：

[dependencies]
aws-config = "0.55"
aws-sdk-efs = "0.25"
tokio = { version = "1", features = ["full"] }

1. 运行程序：

cargo run

这个完整示例展示了aws-sdk-efs库的主要功能，包括创建文件系统、管理挂载目标和访问点、列出资源以及清理资源等操作。代码中包含了详细的注释和错误处理，可以帮助开发者快速上手使用Rust管理AWS EFS资源。