测试想转后端？说几句不太好听但真实的话

use axum::{routing::{get, post}, Json, Router};
use serde::{Deserialize, Serialize};
 
// 一个最简单的 API handler
#[derive(Serialize, Deserialize)]
struct Todo {
    id: u64,
    title: String,
    done: bool,
}
 
async fn list_todos() -> Json<Vec<Todo>> {
    // 先返回假数据，后面再接数据库
    Json(vec![
        Todo { id: 1, title: "学 Rust".into(), done: false },
        Todo { id: 2, title: "写后端".into(), done: false },
    ])
}
 
#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/todos", get(list_todos));
 
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await
        .unwrap();
    axum::serve(listener, app).await.unwrap();
}

// 定义统一的错误类型，这是后端开发的基本功
#[derive(Debug)]
enum AppError {
    NotFound,
    Database(sqlx::Error),
    Validation(String),
}
 
// 实现 IntoResponse，让 Axum 知道怎么把错误变成 HTTP 响应
impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, message) = match self {
            AppError::NotFound => (axum::http::StatusCode::NOT_FOUND, "资源不存在"),
            AppError::Database(_) => (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "数据库错误"),
            AppError::Validation(msg) => (axum::http::StatusCode::BAD_REQUEST, "参数错误"),
        };
        (status, message).into_response()
    }
}

# 多阶段构建——最终镜像只有二进制文件，体积小
FROM rust:1.78 as builder
WORKDIR /app
COPY . .
RUN cargo build --release
 
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/target/release/my-backend /usr/local/bin/
EXPOSE 3000
CMD ["my-backend"]

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://postgres:password@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
 
  db:
    image: postgres:16
    environment:
      - POSTGRES_PASSWORD=password
    volumes:
      - pgdata:/var/lib/postgresql/data
 
  redis:
    image: redis:7-alpine
 
volumes:
  pgdata:

use std::env;
 
struct Config {
    database_url: String,
    redis_url: String,
    jwt_secret: String,
    port: u16,
}
 
impl Config {
    fn from_env() -> Self {
        Self {
            database_url: env::var("DATABASE_URL")
                .expect("DATABASE_URL must be set"),
            redis_url: env::var("REDIS_URL")
                .unwrap_or_else(|_| "redis://localhost:6379".into()),
            jwt_secret: env::var("JWT_SECRET")
                .expect("JWT_SECRET must be set"),
            port: env::var("PORT")
                .unwrap_or_else(|_| "3000".into())
                .parse()
                .expect("PORT must be a number"),
        }
    }
}

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-backend
spec:
  replicas: 3  # 跑 3 个实例
  selector:
    matchLabels:
      app: my-backend
  template:
    metadata:
      labels:
        app: my-backend
    spec:
      containers:
        - name: my-backend
          image: my-backend:latest
          ports:
            - containerPort: 3000
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: my-backend-secrets
                  key: database-url
          resources:
            requests:
              memory: "64Mi"
              cpu: "250m"
            limits:
              memory: "128Mi"
              cpu: "500m"
          livenessProbe:   # 存活检查——容器挂了自动重启
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10
          readinessProbe:  # 就绪检查——没准备好不接流量
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 3
            periodSeconds: 5
---
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-backend
spec:
  selector:
    app: my-backend
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

async fn health() -> &'static str {
    "ok"
}
 
let app = Router::new()
    .route("/todos", get(list_todos).post(create_todo))
    .route("/health", get(health));

# 用 Helm 安装一个 Redis
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install my-redis bitnami/redis
 
# 用 Helm 部署你自己的服务
helm install my-backend ./charts/my-backend

# 用 kind 搭建本地 K8s 环境
kind create cluster --name my-cluster
 
# 把你的镜像加载到 kind 里
kind load docker-image my-backend:latest --name my-cluster
 
# 部署
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
 
# 查看状态
kubectl get pods
kubectl logs -f my-backend-xxx

use tracing::{info, warn, error, instrument};
 
#[instrument(skip(db))]  // 自动记录函数调用和参数
async fn create_todo(
    State(db): State<PgPool>,
    Json(input): Json<CreateTodo>,
) -> Result<Json<Todo>, AppError> {
    info!(title = %input.title, "创建新的待办事项");
 
    let todo = sqlx::query_as!(Todo,
        "INSERT INTO todos (title) VALUES ($1) RETURNING *",
        input.title
    )
    .fetch_one(&db)
    .await
    .map_err(|e| {
        error!(error = %e, "数据库写入失败");
        AppError::Database(e)
    })?;
 
    info!(id = todo.id, "待办事项创建成功");
    Ok(Json(todo))
}

# .github/workflows/deploy.yml
name: Build and Deploy
 
on:
  push:
    branches: [main]
 
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo test --all
 
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Docker image
        run: docker build -t my-backend:${{ github.sha }} .
      - name: Push to registry
        run: |
          echo ${{ secrets.REGISTRY_PASSWORD }} | docker login -u ${{ secrets.REGISTRY_USERNAME }} --password-stdin
          docker push my-backend:${{ github.sha }}
 
  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to K8s
        run: |
          kubectl set image deployment/my-backend \
            my-backend=my-backend:${{ github.sha }}

use tokio::signal;
 
async fn shutdown_signal() {
    let ctrl_c = async {
        signal::ctrl_c().await.expect("failed to install Ctrl+C handler");
    };
 
    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };
 
    tokio::select! {
        _ = ctrl_c => {},
        _ = terminate => {},
    }
 
    tracing::info!("收到关闭信号，开始优雅关闭...");
}
 
#[tokio::main]
async fn main() {
    // ... 初始化 app ...
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
 
    // 优雅关闭：收到信号后停止接收新请求，等待现有请求处理完
    axum::serve(listener, app)
        .with_graceful_shutdown(shutdown_signal())
        .await
        .unwrap();
}

pub fn calculate_discount(price: f64, quantity: u32) -> f64 {
    if quantity >= 10 {
        price * 0.9 // 九折
    } else {
        price
    }
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_no_discount() {
        assert_eq!(calculate_discount(100.0, 5), 100.0);
    }
 
    #[test]
    fn test_bulk_discount() {
        assert_eq!(calculate_discount(100.0, 10), 90.0);
    }
 
    #[test]
    fn test_boundary() {
        // 边界：9件不打折，10件打折
        assert_eq!(calculate_discount(100.0, 9), 100.0);
        assert_eq!(calculate_discount(100.0, 10), 90.0);
    }
}