实战：基于 GitOps 实现 AI 应用的自动化部署与发布

核心提要

AI 应用（如模型推理服务、智能分析平台）的部署与发布面临「环境一致性难保障、版本回滚复杂、部署流程繁琐、与模型迭代链路脱节」四大痛点，而 GitOps 以「Git 作为单一事实来源、声明式配置、自动化同步、可审计可追溯」为核心特性，完美适配 AI 应用的部署发布需求。

本实战以MNIST 手写数字识别 AI 推理服务为示例，基于「Git + Argo CD + Kubernetes + Docker + GitHub Actions」技术栈，完整覆盖「GitOps 环境搭建→AI 应用容器化→声明式配置编写→CI/CD 流水线构建→自动化部署与同步→版本回滚与审计」全流程，最终实现「提交代码/模型变更→自动构建镜像→自动同步部署→全程可追溯」的 AI 应用自动化发布闭环，达成部署效率提升 80%、环境一致性 100%、回滚时间缩短至 1 分钟内的目标。

一、前置准备：场景与工具选型

1. 业务场景与目标

AI 应用：MNIST 推理服务（Python + ONNX Runtime），对外提供 HTTP 推理 API；
部署环境：Kubernetes 集群（单节点/集群均可，推荐 minikube 用于测试，生产环境推荐 EKS/ACK）；
核心目标：
- 以 Git 为唯一入口，管理 AI 应用的容器镜像、K8s 部署配置、模型版本；
- 实现代码/模型变更后，自动化构建、推送镜像、部署至 K8s 集群；
- 保障开发/测试/生产环境配置一致，支持一键版本回滚；
- 所有部署变更全程可审计、可追溯。

2. 核心工具选型与作用

|-------------|--------------------------|-------|---------------------------------------------------|
| 工具类别 | 选型 | 版本 | 核心作用 |
| 代码/配置仓库 | GitHub/GitLab | - | 存储 AI 应用代码、Dockerfile、K8s 声明式配置、GitOps 配置（单一事实来源） |
| 容器化工具 | Docker | 24.0+ | AI 应用容器化打包，保障环境一致性 |
| Kubernetes | Minikube（测试）/ ACK（生产） | 1.26+ | AI 应用的运行与编排环境 |
| GitOps 同步引擎 | Argo CD | 2.8+ | 监控 Git 仓库配置变更，自动同步至 K8s 集群，保障实际状态与声明式配置一致 |
| CI 流水线 | GitHub Actions/GitLab CI | - | 自动化构建 AI 应用镜像、推送至镜像仓库、更新 Git 仓库中的镜像版本 |
| 镜像仓库 | Docker Hub/Harbor | - | 存储构建完成的 AI 应用容器镜像 |
| 模型存储 | Git LFS/OSS | - | 存储 MNIST ONNX 模型（解决 Git 无法高效存储大文件问题） |

3. 环境搭建步骤

（1）基础环境准备

安装 Minikube（搭建本地 K8s 测试环境）

复制代码

# Linux 环境安装 Minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# 启动 Minikube（分配 2C 4G 资源，满足 AI 推理服务需求）
minikube start --cpus=2 --memory=4096 --driver=docker

安装 Kubectl（K8s 命令行工具）

复制代码

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

安装 Docker（容器化构建工具）

复制代码

sudo apt-get update && sudo apt-get install docker-ce docker-ce-cli containerd.io -y
sudo usermod -aG docker $USER && newgrp docker

配置 Git 与镜像仓库（以 GitHub + Docker Hub 为例）
1. 注册 GitHub 账号，创建两个仓库：① mnist-infer-service（存储 AI 应用代码）；② mnist-gitops-config（存储 GitOps 声明式配置，作为 GitOps 单一事实来源）；
2. 注册 Docker Hub 账号，创建仓库 mnist-infer-service（用于存储构建后的镜像）；
3. 本地配置 Git 与 Docker 登录：
Git 配置

git config --global user.name "Your Name"
git config --global user.email "your-email@xxx.com"

Docker Hub 登录

docker login

（2）部署 Argo CD（GitOps 核心同步引擎）

在 K8s 集群中创建 Argo CD 命名空间
复制代码
```
kubectl create namespace argocd
```

安装 Argo CD

复制代码

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/v2.8.0/manifests/install.yaml

等待 Argo CD 所有 Pod 处于 Running 状态
复制代码
```
kubectl get pods -n argocd -w
```

暴露 Argo CD 控制台（测试环境使用端口转发，生产环境推荐 Ingress）

复制代码

# 端口转发，访问 http://localhost:8080 即可进入 Argo CD 控制台
kubectl port-forward svc/argocd-server -n argocd 8080:443

获取 Argo CD 初始管理员密码

复制代码

# 初始密码存储在 argocd-initial-admin-secret 密钥中
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d && echo

二、操作步骤

步骤 1：AI 应用容器化（保障环境一致性）

容器化是 GitOps 部署的基础，通过 Docker 打包 AI 应用与依赖，确保开发、测试、生产环境完全一致，避免「在我这能跑，到你那就报错」的问题。

1. 准备 AI 应用核心文件

在 mnist-infer-service GitHub 仓库中，整理以下核心文件（本地先编写，后续推送到 GitHub）：

（1）AI 推理服务代码（`app.py`）

复制代码

from flask import Flask, request, jsonify
import onnxruntime as ort
import numpy as np
from PIL import Image
from io import BytesIO
import base64
import os

app = Flask(__name__)

# 加载 ONNX 模型（模型文件从容器内 /app/model 目录读取）
MODEL_PATH = "/app/model/advanced_mnist_model.onnx"
ort_session = ort.InferenceSession(
    MODEL_PATH,
    providers=["CPUExecutionProvider"]
)

def preprocess_image(image_data):
    """图像预处理：转为 28x28 灰度图，归一化"""
    try:
        img = Image.open(BytesIO(base64.b64decode(image_data))).convert('L')
        img = img.resize((28, 28))
        img_np = np.array(img, dtype=np.float32) / 255.0
        return np.expand_dims(np.expand_dims(img_np, axis=0), axis=0)
    except Exception as e:
        raise Exception(f"图像预处理失败：{str(e)}")

@app.route("/api/v1/infer", methods=["POST"])
def infer():
    """推理接口：接收 base64 图像，返回预测结果"""
    try:
        data = request.get_json()
        if "image_base64" not in data:
            return jsonify({"code": 400, "message": "缺少参数 image_base64", "result": None})
        
        img_np = preprocess_image(data["image_base64"])
        outputs = ort_session.run(None, {"input": img_np})
        pred_digit = int(np.argmax(outputs[0], axis=1)[0])
        
        return jsonify({
            "code": 200,
            "message": "success",
            "result": {"predict_digit": pred_digit}
        })
    except Exception as e:
        return jsonify({"code": 500, "message": f"推理失败：{str(e)}", "result": None})

if __name__ == "__main__":
    # 监听所有地址，端口 5000（容器内暴露端口）
    app.run(host="0.0.0.0", port=5000, debug=False)

（2）依赖清单（`requirements.txt`）

复制代码

flask==2.3.3
onnxruntime==1.15.1
Pillow==10.0.1
numpy==1.24.3

（3）Dockerfile（容器化构建配置）

采用多阶段构建，减小镜像体积，适配 AI 应用部署场景：

复制代码

# 阶段 1：构建依赖环境
FROM python:3.9-slim as builder
WORKDIR /app
COPY requirements.txt .
# 安装依赖，生成依赖包缓存
RUN pip3 install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

# 阶段 2：生产镜像（轻量化，仅包含必要文件）
FROM python:3.9-slim
WORKDIR /app
# 从构建阶段复制依赖
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin
# 复制应用代码
COPY app.py .
# 复制 ONNX 模型（模型文件需提前放入 ./model 目录）
COPY model/advanced_mnist_model.onnx /app/model/
# 暴露应用端口
EXPOSE 5000
# 启动命令（避免使用 shell 形式，提升容器稳定性）
CMD ["python3", "app.py"]

（4）ONNX 模型文件

将提前准备好的 advanced_mnist_model.onnx 放入 ./model 目录（使用 Git LFS 管理，避免 Git 仓库过大）：

复制代码

# 安装 Git LFS
git lfs install
# 跟踪模型文件
git lfs track "*.onnx"
# 提交 .gitattributes 文件
git add .gitattributes

2. 本地测试容器化构建

复制代码

# 构建 Docker 镜像
docker build -t mnist-infer-service:v1.0.0 .

# 运行容器，测试应用可用性
docker run -d -p 5000:5000 --name mnist-infer-container mnist-infer-service:v1.0.0

# 验证接口（可使用 curl 或 Postman 测试）
curl -X POST http://localhost:5000/api/v1/infer \
  -H "Content-Type: application/json" \
  -d '{"image_base64": "你的测试图像 base64 编码"}'

3. 推送代码至 GitHub 仓库

复制代码

# 初始化本地仓库
git init
git add .
git commit -m "init: MNIST 推理服务初始版本，包含容器化配置"
# 关联远程 GitHub 仓库
git remote add origin https://github.com/your-username/mnist-infer-service.git
# 推送代码
git push -u origin main

步骤 2：编写 GitOps 声明式配置（单一事实来源）

GitOps 的核心是「声明式配置」，即在 Git 仓库中明确描述 AI 应用在 K8s 集群中的期望状态（如部署多少副本、暴露什么端口、使用什么镜像），由 Argo CD 负责将实际状态同步至期望状态。

所有声明式配置存储在 mnist-gitops-config GitHub 仓库中（作为 GitOps 单一事实来源），采用 Kustomize 管理（简化配置复用，避免冗余）。

1. 准备 GitOps 配置目录结构

复制代码

mnist-gitops-config/
├── base/                # 基础配置（通用配置，跨环境复用）
│   ├── deployment.yaml  # K8s 部署配置
│   ├── service.yaml     # K8s 服务配置（暴露应用）
│   └── kustomization.yaml  # Kustomize 基础配置
└── overlays/            # 环境覆盖配置（不同环境的差异化配置）
    ├── dev/             # 开发环境配置
    │   └── kustomization.yaml
    ├── test/            # 测试环境配置
    │   └── kustomization.yaml
    └── prod/            # 生产环境配置
        └── kustomization.yaml

2. 编写基础声明式配置

（1）base/deployment.yaml（K8s 部署配置，核心）

复制代码

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mnist-infer-service
  labels:
    app: mnist-infer-service
spec:
  replicas: 2  # 默认副本数（可在各环境中覆盖）
  selector:
    matchLabels:
      app: mnist-infer-service
  template:
    metadata:
      labels:
        app: mnist-infer-service
    spec:
      containers:
      - name: mnist-infer-service
        image: your-dockerhub-username/mnist-infer-service:v1.0.0  # 镜像地址（后续由 CI 流水线自动更新）
        ports:
        - containerPort: 5000  # 容器内端口，与应用一致
        resources:
          requests:
            cpu: 500m
            memory: 1Gi
          limits:
            cpu: 1000m
            memory: 2Gi
        livenessProbe:  # 存活探针，检测应用是否正常运行
          httpGet:
            path: /api/v1/infer
            port: 5000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:  # 就绪探针，检测应用是否可接收请求
          httpGet:
            path: /api/v1/infer
            port: 5000
          initialDelaySeconds: 10
          periodSeconds: 5

（2）base/service.yaml（K8s 服务配置，暴露应用）

复制代码

apiVersion: v1
kind: Service
metadata:
  name: mnist-infer-service
spec:
  type: ClusterIP  # 开发/测试环境使用 ClusterIP，生产环境可改为 LoadBalancer
  selector:
    app: mnist-infer-service
  ports:
  - port: 80
    targetPort: 5000  # 映射到容器内端口

（3）base/kustomization.yaml（Kustomize 基础配置）

复制代码

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
# 引用基础资源配置
resources:
  - deployment.yaml
  - service.yaml

3. 编写环境差异化配置（以 dev 环境为例）

overlays/dev/kustomization.yaml（开发环境覆盖配置）

复制代码

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
# 引用基础配置
bases:
  - ../../base
# 差异化配置：覆盖副本数（开发环境副本数 1，减少资源占用）
patches:
- patch: |-
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: mnist-infer-service
    spec:
      replicas: 1
# 为开发环境资源添加标签，便于区分
commonLabels:
  environment: dev

4. 推送 GitOps 配置至 GitHub 仓库

复制代码

# 初始化本地仓库
git init
git add .
git commit -m "init: GitOps 声明式配置，包含 base 与 dev 环境"
# 关联远程 GitHub 仓库
git remote add origin https://github.com/your-username/mnist-gitops-config.git
# 推送代码
git push -u origin main

步骤 3：搭建 CI 流水线（自动化构建与配置更新）

采用 GitHub Actions 搭建 CI 流水线，实现「当 AI 应用代码/模型变更时，自动构建 Docker 镜像、推送至 Docker Hub、更新 GitOps 仓库中的镜像版本」，为 GitOps 同步提供动力。

1. 在 `mnist-infer-service` 仓库中创建 CI 流水线配置

创建 .github/workflows/ci-build-push.yaml 文件，内容如下：

复制代码

name: MNIST Infer Service CI Build & Push
on:
  # 触发条件：main 分支有代码提交（包括代码、模型、Dockerfile 变更）
  push:
    branches: [ main ]
    paths:
      - "**.py"
      - "requirements.txt"
      - "Dockerfile"
      - "model/**"
jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      # 步骤 1：拉取 GitHub 仓库代码
      - name: Checkout Code
        uses: actions/checkout@v4
        with:
          lfs: true  # 拉取 Git LFS 管理的模型文件

      # 步骤 2：设置 Docker 镜像标签（使用提交哈希作为标签，确保唯一性）
      - name: Set Image Tag
        id: set-tag
        run: |
          TAG=$(git rev-parse --short HEAD)
          echo "IMAGE_TAG=v1.0.${TAG}" >> $GITHUB_ENV
          echo "DOCKER_IMAGE=your-dockerhub-username/mnist-infer-service:${IMAGE_TAG}" >> $GITHUB_ENV

      # 步骤 3：登录 Docker Hub（使用 GitHub Secrets 存储敏感信息）
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_HUB_USERNAME }}
          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}

      # 步骤 4：构建并推送 Docker 镜像
      - name: Build and Push Docker Image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ env.DOCKER_IMAGE }}

      # 步骤 5：拉取 GitOps 配置仓库，更新镜像版本
      - name: Update GitOps Config
        run: |
          # 克隆 GitOps 配置仓库
          git clone https://github.com/your-username/mnist-gitops-config.git
          cd mnist-gitops-config
          
          # 使用 kustomize 更新镜像版本（替换 base/deployment.yaml 中的镜像地址）
          kustomize edit set image mnist-infer-service=${{ env.DOCKER_IMAGE }} -f base/
          
          # 提交变更并推送至 GitOps 仓库（使用 GitHub Personal Access Token）
          git config --global user.name "GitHub Actions"
          git config --global user.email "actions@github.com"
          git add .
          git commit -m "chore: update mnist-infer-service image to ${{ env.IMAGE_TAG }}"
          git push https://${{ secrets.GITHUB_PERSONAL_ACCESS_TOKEN }}@github.com/your-username/mnist-gitops-config.git main

2. 配置 GitHub Secrets（存储敏感信息）

在 mnist-infer-service 仓库的「Settings → Secrets and variables → Actions → New repository secret」中，添加以下 3 个密钥：

DOCKER_HUB_USERNAME：Docker Hub 用户名；
DOCKER_HUB_ACCESS_TOKEN：Docker Hub 访问令牌（在 Docker Hub 个人设置中生成）；
GITHUB_PERSONAL_ACCESS_TOKEN：GitHub 个人访问令牌（拥有仓库推送权限，在 GitHub 个人设置中生成）。

3. 触发 CI 流水线测试

修改 mnist-infer-service 仓库中的 app.py（如添加一行日志），提交并推送代码，触发 GitHub Actions 流水线：

复制代码

git add app.py
git commit -m "test: 添加日志输出，触发 CI 流水线"
git push origin main

可在 GitHub 仓库的「Actions」面板中查看流水线运行状态，运行成功后：

Docker Hub 中会出现新构建的镜像（标签为 v1.0.xxx，xxx 为提交哈希）；
mnist-gitops-config 仓库的 base/deployment.yaml 中的镜像版本会被自动更新。

步骤 4：Argo CD 同步部署（GitOps 核心自动化）

Argo CD 作为 GitOps 同步引擎，会持续监控 GitOps 配置仓库（mnist-gitops-config）的变更，自动将 K8s 集群的实际状态同步至 Git 中声明的期望状态，实现 AI 应用的自动化部署。

1. 在 Argo CD 中创建应用（关联 GitOps 仓库与 K8s 集群）

登录 Argo CD 控制台（http://localhost:8080）；
点击「New App」，填写应用配置信息：

|------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------|
| 配置项 | 取值 | 说明 |
| Application Name | mnist-infer-service-dev | 应用名称（区分环境） |
| Project | default | 项目名称（使用默认即可） |
| Sync Policy | Automatic | 同步策略（自动同步，Git 配置变更后自动部署） |
| Prune Resources | Enabled | 启用资源清理（删除 Git 中不存在的资源） |
| Self Heal | Enabled | 启用自我修复（实际状态与期望状态不一致时自动修复） |
| Repository URL | https://github.com/your-username/mnist-gitops-config.git | GitOps 配置仓库地址 |
| Revision | main | 仓库分支 |
| Path | overlays/dev | 环境配置路径（开发环境） |
| Cluster URL | https://kubernetes.default.svc | K8s 集群地址（本地集群使用默认即可） |
| Namespace | default | 部署命名空间（可自定义，需提前创建） |
点击「Create」，创建 Argo CD 应用。

2. 观察 Argo CD 自动同步过程

应用创建后，Argo CD 会自动拉取 GitOps 配置仓库的配置，开始同步部署；
同步状态从「OutOfSync」变为「Synced」，表示实际状态与期望状态一致；
点击应用名称，可查看部署的 K8s 资源（Deployment、Service）的详细状态，以及同步日志；

本地使用 Kubectl 验证部署结果：

复制代码

# 查看 Deployment 状态
kubectl get deployments mnist-infer-service

# 查看 Pod 状态
kubectl get pods -l app=mnist-infer-service

# 端口转发，验证应用可用性
kubectl port-forward svc/mnist-infer-service 8081:80

访问 http://localhost:8081/api/v1/infer，测试推理接口，确认应用部署成功且可用。

3. 验证 GitOps 自动同步能力

修改 mnist-infer-service 仓库中的模型文件（替换为新版本 ONNX 模型），提交并推送代码：

GitHub Actions 流水线自动触发，构建新镜像、推送至 Docker Hub、更新 GitOps 配置仓库的镜像版本；
Argo CD 监控到 GitOps 配置仓库变更，自动开始同步，更新 K8s 中的 Deployment 镜像；
K8s 自动滚动更新 Pod，实现 AI 应用的无感知升级；
整个过程无需人工干预，全程自动化，且所有变更均可在 Git 中追溯。

步骤 5：版本回滚与审计（GitOps 核心优势）

GitOps 以 Git 作为单一事实来源，版本回滚变得极其简单------只需将 GitOps 配置仓库回滚至历史版本，Argo CD 会自动同步，实现一键回滚，且所有操作均可审计。

1. 版本回滚操作（两种方式）

方式 1：Git 仓库回滚（推荐，可追溯）

进入 mnist-gitops-config 仓库，查看历史提交记录，找到需要回滚的版本（如之前的稳定版本）；

执行 Git 回滚命令，推送至远程仓库：

复制代码

# 克隆 GitOps 配置仓库（本地操作）
git clone https://github.com/your-username/mnist-gitops-config.git
cd mnist-gitops-config

# 查看历史提交记录
git log --oneline

# 回滚至指定版本（替换为实际的提交哈希）
git revert <commit-hash> --no-edit

# 推送回滚变更
git push origin main

Argo CD 监控到 Git 仓库变更，自动同步，将 K8s 中的应用回滚至稳定版本；
回滚完成后，验证应用状态，确认恢复正常。

方式 2：Argo CD 控制台手动回滚（快速应急）

登录 Argo CD 控制台，进入 mnist-infer-service-dev 应用；
点击「History and Rollback」，查看应用的部署历史；
选择需要回滚的历史版本，点击「Rollback」，确认回滚；
Argo CD 自动将应用回滚至选定版本，无需修改 Git 仓库（后续建议同步更新 Git 仓库，保持单一事实来源一致）。

2. 审计与追溯

Git 仓库审计 ：所有部署、更新、回滚操作均在 Git 仓库中有提交记录，可通过 git log 查看变更人、变更时间、变更内容；
Argo CD 审计：Argo CD 控制台的「History and Rollback」记录了所有同步操作，可查看同步时间、同步状态、变更资源；
K8s 审计 ：通过 kubectl describe 命令，可查看 Deployment、Pod 的变更历史，了解应用的部署与升级过程。

三、长效优化与生产环境落地建议

1. 配置优化

环境隔离：开发/测试/生产环境使用独立的 K8s 集群或命名空间，GitOps 配置仓库中使用独立的 overlays 目录，避免环境污染；
镜像版本管控：采用语义化版本（如 v1.0.0、v1.1.0），避免使用 latest 标签，确保部署版本可追溯；
资源配额：为每个命名空间配置 K8s 资源配额（ResourceQuota），避免 AI 应用过度占用集群资源。

2. 安全优化

镜像安全扫描：在 CI 流水线中添加镜像安全扫描步骤（如使用 Trivy），检测镜像中的漏洞，避免部署不安全镜像；
Git 仓库权限管控：为 GitOps 配置仓库设置精细的权限，仅允许指定人员修改配置，避免恶意变更；
K8s 资源安全：使用 ServiceAccount 限制 Pod 权限，启用 PodSecurityPolicy，避免容器提权。

3. 可观测性优化

监控告警：为 AI 应用配置 Prometheus + Grafana 监控，监控 Pod 状态、接口响应延迟、推理成功率；为 Argo CD 配置告警，同步失败时触发通知；
日志收集：使用 ELK 栈或 Loki 收集 AI 应用容器日志，便于故障排查；
链路追踪：集成 SkyWalking 或 Jaeger，实现 AI 应用部署与推理链路的全链路追踪。

4. 模型迭代与 GitOps 融合

模型版本与应用版本绑定：将模型版本作为应用版本的一部分，确保应用与模型的版本一致性；
模型自动化更新：搭建模型训练流水线，训练完成后自动转换为 ONNX 格式，推送至 Git LFS 或 OSS，触发 CI/CD 流水线，实现模型与应用的协同更新。

四、核心经验总结

Git 是 GitOps 的核心：将所有配置、版本信息存储在 Git 中，实现单一事实来源，是自动化部署、版本回滚、审计追溯的基础；
声明式配置是关键：声明式配置描述「期望状态」，而非「部署步骤」，简化了部署流程，提升了环境一致性，是 Argo CD 自动化同步的前提；
CI 与 GitOps 协同：CI 负责「构建与配置更新」，GitOps 负责「同步与部署」，两者协同实现完整的自动化闭环，缺一不可；
AI 应用适配性：AI 应用的模型文件需使用 Git LFS 或专用存储管理，容器化时需优化镜像体积与推理性能，确保适配 GitOps 部署流程；
可追溯与可回滚是核心优势：GitOps 让所有部署变更可审计、可追溯，版本回滚变得简单高效，极大降低了 AI 应用发布的风险。

附：常见问题排查

Argo CD 同步失败（OutOfSync 无法转为 Synced）：排查 GitOps 配置是否符合 K8s 语法、镜像地址是否正确、K8s 集群资源是否充足、Argo CD 权限是否足够；
CI 流水线推送 GitOps 配置失败：排查 GitHub Personal Access Token 权限是否足够、GitOps 仓库地址是否正确、kustomize 命令是否正确；
模型文件拉取失败 ：确保 Git LFS 已启用，CI 流水线中配置 lfs: true，本地克隆时使用 git lfs pull；
应用部署后无法访问 ：排查 K8s Service 与 Deployment 的标签是否匹配、容器端口是否正确暴露、Pod 是否正常运行（查看 Pod 日志 kubectl logs <pod-name>）。

实战：基于 GitOps 实现 AI 应用的自动化部署与发布

核心提要

一、前置准备：场景与工具选型

1. 业务场景与目标

2. 核心工具选型与作用

3. 环境搭建步骤

（1）基础环境准备

Git 配置

Docker Hub 登录

（2）部署 Argo CD（GitOps 核心同步引擎）

二、操作步骤

步骤 1：AI 应用容器化（保障环境一致性）

1. 准备 AI 应用核心文件

（1）AI 推理服务代码（app.py）

（2）依赖清单（requirements.txt）

（3）Dockerfile（容器化构建配置）

（4）ONNX 模型文件

2. 本地测试容器化构建

3. 推送代码至 GitHub 仓库

步骤 2：编写 GitOps 声明式配置（单一事实来源）

1. 准备 GitOps 配置目录结构

2. 编写基础声明式配置

（1）base/deployment.yaml（K8s 部署配置，核心）

（2）base/service.yaml（K8s 服务配置，暴露应用）

（3）base/kustomization.yaml（Kustomize 基础配置）

3. 编写环境差异化配置（以 dev 环境为例）

overlays/dev/kustomization.yaml（开发环境覆盖配置）

4. 推送 GitOps 配置至 GitHub 仓库

步骤 3：搭建 CI 流水线（自动化构建与配置更新）

1. 在 mnist-infer-service 仓库中创建 CI 流水线配置

2. 配置 GitHub Secrets（存储敏感信息）

3. 触发 CI 流水线测试

步骤 4：Argo CD 同步部署（GitOps 核心自动化）

1. 在 Argo CD 中创建应用（关联 GitOps 仓库与 K8s 集群）

2. 观察 Argo CD 自动同步过程

3. 验证 GitOps 自动同步能力

步骤 5：版本回滚与审计（GitOps 核心优势）

1. 版本回滚操作（两种方式）

方式 1：Git 仓库回滚（推荐，可追溯）

方式 2：Argo CD 控制台手动回滚（快速应急）

2. 审计与追溯

三、长效优化与生产环境落地建议

1. 配置优化

2. 安全优化

3. 可观测性优化

4. 模型迭代与 GitOps 融合

四、核心经验总结

附：常见问题排查

（1）AI 推理服务代码（`app.py`）

（2）依赖清单（`requirements.txt`）

1. 在 `mnist-infer-service` 仓库中创建 CI 流水线配置