构建一个由 Actix-web 驱动、集成微前端与 Jetpack Compose 的多平台基础设施即代码编排系统

摆在平台工程团队面前的挑战通常不是技术本身，而是技术组合带来的组织摩擦与效率损耗。开发团队需要快速、可靠地创建测试环境，而SRE团队则需要在移动状态下对关键基础设施变更进行监控与干预。任何一个环节的阻塞，都会直接转化为研发效能的下降。问题的核心是：如何构建一个统一的平台，既能为开发者提供自助式的Web操作界面，又能为SRE提供即时的移动端原生体验，同时保证后端服务的绝对高性能与安全。

定义问题与方案权衡

一个常见的技术方案是采用单一技术栈，例如一个大型的React单页应用前端，配合Node.js或Go的后端。这种方案的优势在于技术收敛，团队构建快。但其弊端在生产环境中会逐渐显现：

1. 前端单体困境：随着平台功能增多（例如，数据库管理、K8s资源视图、CI/CD流水线监控），前端应用会变得异常臃肿，不同业务域的团队在同一个代码库中频繁冲突，发布周期被拉长。
2. 后端性能与安全：后端作为基础设施的直接操作者，其稳定性和性能至关重要。对于需要处理大量并发请求、执行长时间CPU密集型任务（如解析IaC计划）的场景，基于解释性语言的后端可能面临性能瓶颈和内存安全风险。
3. 用户体验割裂：SRE在处理线上告警时，往往依赖手机。让他们打开一个复杂的、为桌面端设计的Web界面进行紧急操作，体验极差且效率低下。

基于此，我们决定评估一个更为激进的、跨技术栈的异构方案。该方案旨在通过技术选型，精准匹配不同场景下的特定需求。

• **后端核心 - Actix-web (Rust)**：选择Rust是为了获得极致的性能、内存安全和并发能力。作为编排IaC任务的核心，它必须稳定可靠。Actix-web框架以其卓越的性能和Actor模型，非常适合构建高并发、事件驱动的后台服务。
• **Web门户 - 微前端 (Module Federation)**：我们将Web门户拆分为多个独立的微前端应用。每个微前端由一个特定的领域团队负责（例如，计算资源团队、数据库团队）。这使得团队可以独立开发、测试和部署其负责的功能模块，极大地提升了组织的可扩展性。
• **移动端SRE工具 - Jetpack Compose (Kotlin)**：为SRE团队提供一个原生Android应用。利用Jetpack Compose，我们可以快速构建一个现代化、响应式的UI，专注于展示关键监控数据、审批高危操作、追踪基础设施变更状态等移动优先的核心功能。
• **基础设施定义 - 基础设施即代码 (Terraform)**：所有基础设施的变更都必须通过代码来管理。后端服务的核心职责之一就是安全、可靠地执行Terraform代码，并将过程与结果透明化地展示给用户。

此方案的复杂性显而易见，它要求团队具备多种技术栈的驾驭能力。但我们认为，为了实现长期的架构可扩展性、极致的系统性能和针对不同用户角色的最优体验，这种前期的投入是必要的。

以下是该架构的顶层设计：

graph TD
    subgraph User Interfaces
        A[Web Portal - Micro-frontends]
        B[SRE Mobile App - Jetpack Compose]
    end

    subgraph Backend Core
        C(API Gateway)
        D[Actix-web Service]
        E(WebSocket/SSE Streamer)
    end

    subgraph Execution Engine
        F{Job Queue - Redis/Kafka}
        G[IaC Worker Pool]
    end

    subgraph Infrastructure
        H(Terraform State - S3)
        I[Cloud Provider - AWS/GCP/Azure]
    end

    A -- HTTP/REST --> C
    B -- HTTP/REST & WebSocket --> C
    C -- gRPC/HTTP --> D
    A -- WebSocket --> E
    B -- WebSocket --> E
    D -- Publishes Job --> F
    D -- Writes to --> J[PostgreSQL - Job Metadata]
    G -- Subscribes to --> F
    G -- Executes --> T[Terraform CLI]
    T -- Manages --> I
    T -- Reads/Writes State --> H
    D -- Streams logs via --> E

接下来，我们将通过一个具体的垂直实现——“创建一个新的S3存储桶作为临时环境”——来展示这个架构中各个组件是如何协同工作的。

核心实现：IaC编排引擎 (Actix-web)

后端服务是整个系统的心脏。它需要接收来自前端的请求，将其转化为一个安全的、可追踪的IaC执行任务，并实时反馈执行状态。

1. 项目结构与依赖

首先，初始化一个Rust项目，并在 Cargo.toml 中添加必要的依赖。

# Cargo.toml

[package]
name = "iac-orchestrator"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1", features = ["full"] }
uuid = { version = "1", features = ["v4", "serde"] }
anyhow = "1.0"
log = "0.4"
env_logger = "0.9"
# 用于执行子进程
async-process = "1.7" 
futures-lite = "1.13"

2. API定义与任务模型

我们定义用于创建环境的API请求体和表示任务状态的数据模型。

// src/models.rs

use serde::{Deserialize, Serialize};
use uuid::Uuid;
use std::time::SystemTime;

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub enum JobStatus {
    Pending,
    Running,
    Succeeded,
    Failed,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ProvisioningJob {
    pub id: Uuid,
    pub created_at: SystemTime,
    pub status: JobStatus,
    pub resource_type: String,
    pub parameters: serde_json::Value,
    // 我们将日志存储在这里，实际生产中应使用外部存储
    pub logs: Vec<String>, 
}

impl ProvisioningJob {
    pub fn new(resource_type: String, parameters: serde_json::Value) -> Self {
        Self {
            id: Uuid::new_v4(),
            created_at: SystemTime::now(),
            status: JobStatus::Pending,
            resource_type,
            parameters,
            logs: Vec::new(),
        }
    }
}

#[derive(Deserialize, Debug)]
pub struct CreateJobRequest {
    pub resource_type: String,
    pub parameters: serde_json::Value,
}

3. 核心编排逻辑

API端点接收请求后，不会直接阻塞执行Terraform。在真实项目中，这是一个致命错误。正确的做法是创建一个任务记录，放入持久化的任务队列（此处为简化，我们使用内存中的dashmap模拟数据库），然后由一个独立的Worker来执行。

// src/main.rs

use actix_web::{web, App, HttpResponse, HttpServer, Responder, Error};
use std::sync::{Arc};
use dashmap::DashMap;
use uuid::Uuid;
use tokio::sync::Mutex;

mod models;
mod terraform_runner;

use models::{CreateJobRequest, ProvisioningJob, JobStatus};

// 使用DashMap模拟一个线程安全的内存数据库来存储任务
type JobStore = Arc<DashMap<Uuid, Arc<Mutex<ProvisioningJob>>>>;

// API端点：创建新的基础设施置备任务
async fn create_provisioning_job(
    job_store: web::Data<JobStore>,
    req: web::Json<CreateJobRequest>,
) -> impl Responder {
    // 生产环境中，参数需要经过严格的校验
    log::info!("Received job request: {:?}", req);
    
    let mut job = ProvisioningJob::new(req.resource_type.clone(), req.parameters.clone());
    
    let job_id = job.id;
    let job_arc = Arc::new(Mutex::new(job));
    job_store.insert(job_id, job_arc.clone());

    // 关键：异步执行Terraform任务，不阻塞HTTP请求线程
    // 生产环境中，这里应该是向Redis或Kafka发送一条消息
    tokio::spawn(async move {
        // 在后台执行terraform
        let result = terraform_runner::run_terraform_apply(job_arc.clone()).await;
        
        let mut job_guard = job_arc.lock().await;
        if let Err(e) = result {
            log::error!("Job {} failed: {}", job_guard.id, e);
            job_guard.status = JobStatus::Failed;
            job_guard.logs.push(format!("ERROR: {}", e));
        } else {
            log::info!("Job {} succeeded", job_guard.id);
            job_guard.status = JobStatus::Succeeded;
        }
    });

    HttpResponse::Accepted().json(job_id)
}

// API端点：获取任务状态和日志
async fn get_job_status(
    job_store: web::Data<JobStore>,
    path: web::Path<Uuid>,
) -> Result<HttpResponse, Error> {
    let job_id = path.into_inner();
    match job_store.get(&job_id) {
        Some(job_arc) => {
            let job = job_arc.lock().await;
            Ok(HttpResponse::Ok().json(&*job))
        }
        None => Ok(HttpResponse::NotFound().body("Job not found")),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));

    // 初始化共享的任务存储
    let job_store: JobStore = Arc::new(DashMap::new());

    log::info!("Starting server at http://127.0.0.1:8080");

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(job_store.clone()))
            .route("/jobs", web::post().to(create_provisioning_job))
            .route("/jobs/{id}", web::get().to(get_job_status))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

4. 安全地执行子进程 (Terraform Runner)

这是最危险也最核心的部分。直接在服务中执行外部命令需要极度小心。

// src/terraform_runner.rs

use crate::models::{JobStatus, ProvisioningJob};
use std::sync::Arc;
use tokio::sync::Mutex;
use anyhow::{Context, Result};
use std::process::Stdio;
use async_process::{Command, Stdio as AsyncStdio};
use futures_lite::{io::BufReader, prelude::*};
use std::path::Path;

// 核心执行函数
pub async fn run_terraform_apply(job_arc: Arc<Mutex<ProvisioningJob>>) -> Result<()> {
    // 1. 更新任务状态为Running
    {
        let mut job = job_arc.lock().await;
        job.status = JobStatus::Running;
        job.logs.push("Status changed to Running.".to_string());
    }

    // 2. 准备Terraform工作目录和变量
    // 在真实世界中，每个任务都应该在一个隔离的、临时的目录中执行
    let job_id_str = { job_arc.lock().await.id.to_string() };
    let work_dir = format!("/tmp/tf_workspaces/{}", job_id_str);
    std::fs::create_dir_all(&work_dir).context("Failed to create workspace")?;

    // 假设我们有一个标准的S3模块
    let tf_module_path = Path::new("./terraform/s3_bucket");
    
    // 将请求参数转换为Terraform需要的 .tfvars.json 文件
    let parameters = { job_arc.lock().await.parameters.clone() };
    let tfvars_path = Path::new(&work_dir).join("terraform.tfvars.json");
    std::fs::write(&tfvars_path, serde_json::to_string_pretty(&parameters)?)
        .context("Failed to write .tfvars.json")?;

    // 3. 执行 terraform init
    run_command("terraform", &["init"], tf_module_path, job_arc.clone()).await?;

    // 4. 执行 terraform apply
    run_command("terraform", &["apply", "-auto-approve"], tf_module_path, job_arc.clone()).await?;
    
    // 5. 清理工作目录（可选）
    // std::fs::remove_dir_all(&work_dir).context("Failed to clean up workspace")?;

    Ok(())
}

// 一个通用的、可以流式捕获输出的命令执行器
async fn run_command(cmd: &str, args: &[&str], work_dir: &Path, job_arc: Arc<Mutex<ProvisioningJob>>) -> Result<()> {
    let full_command = format!("{} {}", cmd, args.join(" "));
    log::info!("Executing command: `{}` in {:?}", full_command, work_dir);
    {
        job_arc.lock().await.logs.push(format!("Executing: {}", full_command));
    }

    let mut command = Command::new(cmd);
    command.args(args)
           .current_dir(work_dir)
           .stdout(AsyncStdio::piped())
           .stderr(AsyncStdio::piped());

    let mut child = command.spawn().context(format!("Failed to spawn command: {}", cmd))?;

    let stdout_reader = BufReader::new(child.stdout.take().unwrap());
    let stderr_reader = BufReader::new(child.stderr.take().unwrap());

    let mut stdout_lines = stdout_reader.lines();
    let mut stderr_lines = stderr_reader.lines();

    loop {
        tokio::select! {
            // 从stdout读取一行
            line = stdout_lines.next() => {
                if let Some(Ok(line)) = line {
                    log::info!("[stdout] {}", line);
                    job_arc.lock().await.logs.push(line);
                } else {
                    // 流结束
                }
            },
            // 从stderr读取一行
            line = stderr_lines.next() => {
                if let Some(Ok(line)) = line {
                    log::error!("[stderr] {}", line);
                    job_arc.lock().await.logs.push(format!("[stderr] {}", line));
                } else {
                    // 流结束
                }
            },
            // 等待子进程退出
            status = child.status() => {
                let status = status.context("Command exited with unknown status")?;
                if status.success() {
                    job_arc.lock().await.logs.push(format!("Command `{}` completed successfully.", full_command));
                    return Ok(());
                } else {
                    let err_msg = format!("Command `{}` failed with exit code: {}", full_command, status);
                    job_arc.lock().await.logs.push(err_msg.clone());
                    return Err(anyhow::anyhow!(err_msg));
                }
            }
        }
    }
}

基础设施定义 (Terraform)

这是由平台团队维护的标准化的Terraform模块。业务开发者通过API传入参数来使用它，而无需关心其内部实现。

# terraform/s3_bucket/main.tf

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

variable "bucket_name" {
  type        = string
  description = "The name of the S3 bucket."
}

variable "tags" {
  type        = map(string)
  description = "A map of tags to assign to the bucket."
  default     = {}
}

variable "aws_region" {
  type        = string
  description = "AWS region for the bucket."
  default     = "us-east-1"
}

resource "aws_s3_bucket" "this" {
  bucket = var.bucket_name
  
  tags = merge(
    var.tags,
    {
      "ManagedBy" = "IAC-Orchestrator"
    }
  )
}

resource "aws_s3_bucket_public_access_block" "this" {
  bucket = aws_s3_bucket.this.id

  block_public_acls       = true
  block_public_policy     = true
  ignore_public_acls      = true
  restrict_public_buckets = true
}

output "bucket_id" {
  value = aws_s3_bucket.this.id
}

output "bucket_arn" {
  value = aws_s3_bucket.this.arn
}

Web UI 微前端 (React Component)

这个React组件模拟了一个微前端模块，负责提供创建S3 Bucket的表单，并实时显示创建日志。

// components/S3Provisioner.jsx
import React, { useState, useEffect, useRef } from 'react';

const API_BASE_URL = 'http://127.0.0.1:8080';

export default function S3Provisioner() {
    const [bucketName, setBucketName] = useState(`my-unique-test-bucket-${Date.now()}`);
    const [region, setRegion] = useState('us-east-1');
    const [jobId, setJobId] = useState(null);
    const [logs, setLogs] = useState([]);
    const [jobStatus, setJobStatus] = useState(null);
    const logContainerRef = useRef(null);

    const handleSubmit = async (e) => {
        e.preventDefault();
        setLogs(['Requesting new job...']);
        setJobId(null);
        setJobStatus('Pending');

        try {
            const response = await fetch(`${API_BASE_URL}/jobs`, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    resource_type: 's3_bucket',
                    parameters: {
                        bucket_name: bucketName,
                        aws_region: region,
                        tags: {
                            Owner: 'dev-team-alpha'
                        }
                    }
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
            const createdJobId = await response.json();
            setJobId(createdJobId);
            setLogs(prev => [...prev, `Job created with ID: ${createdJobId}`]);
        } catch (error) {
            setLogs(prev => [...prev, `Error creating job: ${error.message}`]);
            setJobStatus('Failed');
        }
    };

    // 使用轮询来获取任务状态和日志，生产环境中应使用WebSocket或SSE
    useEffect(() => {
        if (!jobId || jobStatus === 'Succeeded' || jobStatus === 'Failed') {
            return;
        }

        const intervalId = setInterval(async () => {
            try {
                const response = await fetch(`${API_BASE_URL}/jobs/${jobId}`);
                if (!response.ok) return;

                const data = await response.json();
                setLogs(data.logs);
                setJobStatus(data.status);
            } catch (error) {
                console.error("Failed to fetch job status:", error);
            }
        }, 2000);

        return () => clearInterval(intervalId);
    }, [jobId, jobStatus]);

    useEffect(() => {
        if (logContainerRef.current) {
            logContainerRef.current.scrollTop = logContainerRef.current.scrollHeight;
        }
    }, [logs]);

    return (
        <div style={{ fontFamily: 'sans-serif', maxWidth: '800px', margin: 'auto' }}>
            <h2>S3 Bucket Provisioner MFE</h2>
            <form onSubmit={handleSubmit}>
                <div>
                    <label>Bucket Name: </label>
                    <input type="text" value={bucketName} onChange={e => setBucketName(e.target.value)} required />
                </div>
                <div>
                    <label>Region: </label>
                    <input type="text" value={region} onChange={e => setRegion(e.target.value)} required />
                </div>
                <button type="submit" disabled={jobStatus === 'Running' || jobStatus === 'Pending'}>
                    Provision Bucket
                </button>
            </form>

            {jobId && (
                <div>
                    <h3>Job Status: {jobStatus || '...'}</h3>
                    <h4>Logs (Job ID: {jobId})</h4>
                    <pre ref={logContainerRef} style={{ background: '#222', color: '#eee', padding: '10px', height: '400px', overflowY: 'scroll', whiteSpace: 'pre-wrap' }}>
                        {logs.join('\n')}
                    </pre>
                </div>
            )}
        </div>
    );
}

SRE 移动端 (Jetpack Compose)

SRE不需要创建资源，但他们需要随时随地监控正在进行的关键变更。这个Compose UI将展示任务列表及其状态。

// JobMonitorScreen.kt

import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import java.time.Instant
import java.time.ZoneId
import java.time.format.DateTimeFormatter

// 模拟的数据模型，与后端对应
data class ProvisioningJob(
    val id: String,
    val status: String,
    val resource_type: String,
    val created_at: String // 使用String简化
)

// 模拟的ViewModel
class JobViewModel {
    var jobs by mutableStateOf<List<ProvisioningJob>>(emptyList())
        private set
    var error by mutableStateOf<String?>(null)
        private set

    // 在实际应用中，这将是一个真正的网络请求
    suspend fun fetchJobs() {
        try {
            // 此处应为 val response = apiClient.getJobs()
            // 为演示，我们模拟一个轮询的更新
            val jobFromApi = getJobStatusFromBackend("your-job-id-from-web-ui") // 手动填入一个正在运行的job id
            if(jobFromApi != null) {
                jobs = listOf(jobFromApi)
            }
            error = null
        } catch (e: Exception) {
            error = "Failed to fetch jobs: ${e.message}"
        }
    }
    
    // 模拟从后端获取单个任务状态
    private fun getJobStatusFromBackend(jobId: String): ProvisioningJob? {
        // ... 此处应为ktor或retrofit的网络调用
        // val job = client.get("/jobs/$jobId").body<ProvisioningJob>()
        // 这里返回硬编码数据
        return ProvisioningJob(
            id = jobId,
            status = "Running", // 状态会变化
            resource_type = "s3_bucket",
            created_at = "2023-10-27T12:00:00Z"
        )
    }
}


@Composable
fun JobMonitorScreen(viewModel: JobViewModel = JobViewModel()) {
    // 使用LaunchedEffect实现简单的轮询
    LaunchedEffect(Unit) {
        while (true) {
            viewModel.fetchJobs()
            delay(5000) // 每5秒刷新一次
        }
    }

    Scaffold(
        topBar = {
            TopAppBar(title = { Text("Infrastructure Job Monitor") })
        }
    ) { paddingValues ->
        Column(modifier = Modifier.padding(paddingValues).fillMaxSize()) {
            if (viewModel.error != null) {
                Text("Error: ${viewModel.error}", color = MaterialTheme.colorScheme.error)
            } else if (viewModel.jobs.isEmpty()) {
                Text("No active jobs found.")
            } else {
                LazyColumn(
                    modifier = Modifier.fillMaxSize(),
                    contentPadding = PaddingValues(16.dp),
                    verticalArrangement = Arrangement.spacedBy(8.dp)
                ) {
                    items(viewModel.jobs) { job ->
                        JobCard(job)
                    }
                }
            }
        }
    }
}

@Composable
fun JobCard(job: ProvisioningJob) {
    Card(
        modifier = Modifier.fillMaxWidth(),
        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
    ) {
        Column(Modifier.padding(16.dp)) {
            Text(
                text = "Job: ${job.id.substring(0, 8)}...",
                style = MaterialTheme.typography.titleMedium
            )
            Spacer(Modifier.height(4.dp))
            Text(
                "Resource: ${job.resource_type}",
                style = MaterialTheme.typography.bodyMedium
            )
            Spacer(Modifier.height(8.dp))
            JobStatusChip(status = job.status)
        }
    }
}

@Composable
fun JobStatusChip(status: String) {
    val backgroundColor = when (status) {
        "Running", "Pending" -> Color(0xFFFFA500) // Orange
        "Succeeded" -> Color(0xFF4CAF50) // Green
        "Failed" -> Color(0xFFF44336) // Red
        else -> Color.Gray
    }
    
    Surface(
        color = backgroundColor,
        shape = MaterialTheme.shapes.small,
        contentColor = Color.White
    ) {
        Text(
            text = status,
            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
            style = MaterialTheme.typography.labelSmall
        )
    }
}

架构的扩展性与局限性

这个架构虽然初步可行，但在走向生产环境的路上，仍有诸多挑战。

扩展性方面：

1. 服务扩展：通过微前端架构，可以平滑地引入新的管理模块，如数据库即服务（DBaaS）、K8s命名空间管理等，而无需触碰现有功能。每个模块都可以由独立的团队以自己的节奏进行迭代。
2. IaC工具扩展：后端的terraform_runner可以被抽象成一个Runner trait，从而实现对Pulumi、Ansible或自定义脚本的支持。通过API请求中的engine字段，可以动态选择不同的执行引擎。
3. 移动端功能扩展：Jetpack Compose应用可以轻松地加入更多SRE功能，例如通过生物识别进行高危操作的审批、一键触发回滚操作、集成On-Call排班表等。

局限性与潜在风险：

1. 状态管理：当前内存中的任务存储是脆弱的。一个生产级的系统必须使用外部数据库（如PostgreSQL）来记录任务元数据，并使用可靠的消息队列（如Kafka或Redis Streams）来解耦API服务和执行Worker。这能保证即使在服务重启后，任务也不会丢失。
2. 安全性：这是最大的挑战。在后端服务器上直接执行terraform命令意味着服务本身需要拥有相当高的云资源操作权限。必须通过严格的IAM角色、运行时沙箱（如gVisor或Firecracker）以及对用户输入参数的强制策略检查（使用OPA - Open Policy Agent）来限制其操作半径，防止恶意用户通过构造参数来执行越权操作。
3. 技术栈复杂度：维护一个横跨Rust、Kotlin、TypeScript和HCL的系统，对团队的技术广度和深度提出了极高要求。统一的日志、监控和追踪标准（如OpenTelemetry）变得至关重要，否则系统一旦出现问题，跨语言的调试将是一场噩梦。
4. 实时通信：当前的Web UI使用了轮询，这会带来延迟并增加服务器负载。一个更优的方案是使用WebSocket或Server-Sent Events (SSE)，让后端在Terraform产生新日志时，主动将日志行推送给所有订阅该任务的客户端（包括Web和Mobile）。