Rust分布式系统开发库kurtosis-sdk的使用，kurtosis-sdk助力构建可扩展的微服务与云原生应用

Kurtosis Rust SDK

这是一个基于Kurtosis的SDK，基于可用的protobufs构建。

示例

确保引擎正在运行：

kurtosis engine start

然后你可以使用Kurtosis+Rust运行一个Starlark脚本：

use kurtosis_sdk::{engine_api::{engine_service_client::{EngineServiceClient}, CreateEnclaveArgs}, enclave_api::{api_container_service_client::ApiContainerServiceClient, RunStarlarkScriptArgs}};
use kurtosis_sdk::enclave_api::starlark_run_response_line::RunResponseLine::InstructionResult;

const STARLARK_SCRIPT : &str = "
def main(plan):
    plan.print('Hello World!')
";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建enclave
    let mut engine = EngineServiceClient::connect("https://[::1]:9710").await?;
    let create_enclave_response = engine.create_enclave(CreateEnclaveArgs{
        enclave_name: "my-rust-test".to_string(),
        api_container_log_level: "info".to_string(),
        // 默认值
        api_container_version_tag: "".to_string(),
        is_partitioning_enabled: false,
    }).await?.into_inner();
    
    // 连接到enclave
    let enclave_port = create_enclave_response.enclave_info.expect("Enclave info必须存在").api_container_host_machine_info.expect("Enclave主机信息必须存在").grpc_port_on_host_machine;
    let mut enclave = ApiContainerServiceClient::connect(format!("https://[::1]:{}", enclave_port)).await?;
    
    // 运行Starlark脚本
    let mut run_result = enclave.run_starlark_script(RunStarlarkScriptArgs{
        serialized_script: STARLARK_SCRIPT.to_string(),
        serialized_params: "{}".to_string(),
        dry_run: Option::Some(false),
        parallelism: Option::None,
        main_function_name: "main".to_string(),
    }).await?.into_inner();
    
    // 获取输出行
    while let Some(next_message) = run_result.message().await? {
        next_message.run_response_line.map(|line| match line {
            InstructionResult(result) => {
                println!("{}", result.serialized_instruction_result)
            }
            _ => (),
        });
    }
    Ok(())
}

完整示例

以下是一个更完整的示例，展示了如何使用kurtosis-sdk构建微服务：

use kurtosis_sdk::{
    engine_api::{
        engine_service_client::EngineServiceClient, 
        CreateEnclaveArgs,
        GetEnclavesArgs
    },
    enclave_api::{
        api_container_service_client::ApiContainerServiceClient,
        RunStarlarkScriptArgs,
        StartServicesArgs,
        ServiceInfo
    }
};
use tokio::time::{sleep, Duration};

const MICROSERVICE_SCRIPT: &str = r#"
def main(plan):
    # 添加Postgres服务
    postgres = plan.add_service(
        name="postgres",
        config=ServiceConfig(
            image="postgres:latest",
            env_vars={
                "POSTGRES_PASSWORD": "password
            },
            ports={
                "postgres": PortSpec(number=5432)
            }
        )
    )
    
    # 添加Redis服务
    redis = plan.add_service(
        name="redis",
        config=ServiceConfig(
            image="redis:latest",
            ports={
                "redis": PortSpec(number=6379)
            }
        )
    )
    
    # 添加应用服务
    app = plan.add_service(
        name="app",
        config=ServiceConfig(
            image="my-app:latest",
            env_vars={
                "DB_HOST": postgres.hostname,
                "DB_PORT": postgres.ports["postgres"].number,
                "REDIS_HOST": redis.hostname,
                "REDIS_PORT": redis.ports["redis"].number
            },
            ports={
                "http": PortSpec(number=8080)
            }
        )
    )
    
    plan.print("所有服务已启动!")
"#;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接到Kurtosis引擎
    let mut engine = EngineServiceClient::connect("http://localhost:9710").await?;
    
    // 创建新的enclave
    let create_response = engine.create_enclave(CreateEnclaveArgs {
        enclave_name: "microservices-demo".to_string(),
        api_container_log_level: "info".to_string(),
        api_container_version_tag: "".to_string(),
        is_partitioning_enabled: false,
    }).await?;
    
    let enclave_info = create_response.into_inner().enclave_info.unwrap();
    let port = enclave_info.api_container_host_machine_info.unwrap().grpc_port_on_host_machine;
    
    // 连接到enclave
    let mut enclave = ApiContainerServiceClient::connect(format!("http://localhost:{}", port)).await?;
    
    // 运行Starlark脚本部署微服务
    let mut run_result = enclave.run_starlark_script(RunStarlarkScriptArgs {
        serialized_script: MICROSERVICE_SCRIPT.to_string(),
        serialized_params: "{}".to_string(),
        dry_run: Some(false),
        parallelism: None,
        main_function_name: "main".to_string(),
    }).await?;
    
    // 检查服务状态
    sleep(Duration::from_secs(5)).await;
    
    let services = enclave.start_services(StartServicesArgs {
        service_identifiers: vec!["postgres".to_string(), "redis".to_string(), "app".to_string()],
    }).await?.into_inner().services;
    
    for (name, service) in services {
        println!("服务 {} 运行在 {}", name, service.private_ip);
        for (port_name, port_spec) in service.ports {
            println!("  - {}: {}", port_name, port_spec.number);
        }
    }
    
    Ok(())
}

安装

在项目目录中运行以下Cargo命令：

cargo add kurtosis-sdk

或者在你的Cargo.toml中添加以下行：

kurtosis-sdk = "1.10.3"

许可证

BUSL-1.1