Rust AWS SDK库aws-sdk-elasticloadbalancingv2使用指南

aws-sdk-elasticloadbalancingv2是AWS官方提供的Rust SDK，用于与Elastic Load Balancing (ELB) V2服务交互，包括Application Load Balancer (ALB)和Network Load Balancer (NLB)。

安装与配置

首先在Cargo.toml中添加依赖：

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

基本使用方法

1. 创建客户端

use aws_sdk_elasticloadbalancingv2 as elbv2;

async fn create_client() -> elbv2::Client {
    let config = aws_config::load_from_env().await;
    elbv2::Client::new(&config)
}

2. 创建负载均衡器

async fn create_load_balancer(
    client: &elbv2::Client,
    name: &str,
    subnets: Vec<String>,
) -> Result<(), elbv2::Error> {
    let response = client
        .create_load_balancer()
        .name(name)
        .set_subnets(Some(subnets))
        .scheme("internet-facing")
        .send
        .await?;

    println!("Created LB: {:?}", response.load_balancers);
    Ok(())
}

3. 创建目标组

async fn create_target_group(
    client: &elbv2::Client,
    name: &str,
    vpc_id: &str,
) -> Result<(), elbv2::Error> {
    let response = client
        .create_target_group()
        .name(name)
        .protocol("HTTP")
        .port(80)
        .vpc_id(vpc_id)
        .health_check_path("/health")
        .health_check_interval_seconds(30)
        .health_check_timeout_seconds(5)
        .healthy_threshold_count(2)
        .unhealthy_threshold_count(2)
        .target_type("instance")
        .send()
        .await?;

    println!("Created Target Group: {:?}", response.target_groups);
    Ok(())
}

4. 创建监听器并关联目标组

async fn create_listener(
    client: &elbv2::Client,
    load_balancer_arn: &str,
    target_group_arn: &str,
) -> Result<(), elbv2::Error> {
    let response = client
        .create_listener()
        .load_balancer_arn(load_balancer_arn)
        .protocol("HTTP")
        .port(80)
        .default_actions(
            elbv2::types::Action::builder()
                .type_("forward")
                .target_group_arn(target_group_arn)
                .build(),
        )
        .send()
        .await?;

    println!("Created Listener: {:?}", response.listeners);
    Ok(())
}

5. 注册目标实例

async fn register_targets(
    client: &elbv2::Client,
    target_group_arn: &str,
    instance_ids: Vec<String>,
) -> Result<(), elbv2::Error> {
    let targets = instance_ids
        .into_iter()
        .map(|id| elbv2::types::TargetDescription::builder().id(id).build())
        .collect();

    let response = client
        .register_targets()
        .target_group_arn(target_group_arn)
        .set_targets(Some(targets))
        .send()
        .await?;

    println!("Registered targets: {:?}", response);
    Ok(())
}

高级用法

查询负载均衡器信息

async fn describe_load_balancers(
    client: &elbv2::Client,
    names: Option<Vec<String>>,
) -> Result<(), elbv2::Error> {
    let response = client
        .describe_load_balancers()
        .set_names(names)
        .send()
        .await?;

    println!("Load Balancers: {:?}", response.load_balancers);
    Ok(())
}

修改负载均衡器属性

async fn modify_load_balancer_attributes(
    client: &elbv2::Client,
    load_balancer_arn: &str,
) -> Result<(), elbv2::Error> {
    let attributes = vec![
        elbv2::types::LoadBalancerAttribute::builder()
            .key("idle_timeout.timeout_seconds")
            .value("60")
            .build(),
    ];

    let response = client
        .modify_load_balancer_attributes()
        .load_balancer_arn(load_balancer_arn)
        .set_attributes(Some(attributes))
        .send()
        .await?;

    println!("Modified attributes: {:?}", response.attributes);
    Ok(())
}

错误处理

AWS SDK操作会返回Result类型，建议使用Rust的错误处理机制：

async fn example_error_handling(client: &elbv2::Client) {
    match describe_load_balancers(client, None).await {
        Ok(_) => println!("Successfully described load balancers"),
        Err(e) => eprintln!("Error describing load balancers: {}", e),
    }
}

完整示例

use aws_sdk_elasticloadbalancingv2 as elbv2;

#[tokio::main]
async fn main() -> Result<(), elbv2::Error> {
    let client = create_client().await;
    
    // 创建负载均衡器
    let lb_name = "my-rust-lb";
    let subnets = vec!["subnet-123456".to_string(), "subnet-789012".to_string()];
    create_load_balancer(&client, lb_name, subnets).await?;
    
    // 创建目标组
    let tg_name = "my-rust-tg";
    let vpc_id = "vpc-123456";
    create_target_group(&client, tg_name, vpc_id).await?;
    
    // 查询负载均衡器ARN
    let lbs = client
        .describe_load_balancers()
        .names(lb_name)
        .send()
        .await?;
    
    let lb_arn = lbs.load_balancers.unwrap()[0].load_balancer_arn.as_ref().unwrap();
    
    // 查询目标组ARN
    let tgs = client
        .describe_target_groups()
        .names(tg_name)
        .send()
        .await?;
    
    let tg_arn = tgs.target_groups.unwrap()[0].target_group_arn.as_ref().unwrap();
    
    // 创建监听器
    create_listener(&client, lb_arn, tg_arn).await?;
    
    // 注册目标实例
    let instances = vec!["i-123456".to_string(), "i-789012".to_string()];
    register_targets(&client, tg_arn, instances).await?;
    
    Ok(())
}

注意事项

1. 确保AWS凭证已正确配置（通过环境变量、配置文件或IAM角色）
2. 操作AWS资源可能会产生费用，测试完成后记得清理资源
3. 所有API调用都是异步的，需要使用await
4. 错误处理很重要，AWS操作可能会因为权限、配额等原因失败