SiameseUniNLU部署教程：Kubernetes Helm Chart封装与多实例水平扩展实践

1. 引言

如果你正在寻找一个能同时处理命名实体识别、关系抽取、情感分析等多种自然语言理解任务的模型，并且希望它能稳定、高效地运行在云环境中，那么SiameseUniNLU可能就是你要找的答案。

这个基于StructBERT架构的模型，通过一个巧妙的“提示+文本”设计思路，用一个模型就能搞定十几种不同的NLP任务。听起来很酷，对吧？但问题来了：怎么把它从本地的一个Python脚本，变成一个能在生产环境稳定运行、能轻松扩展的服务呢？

这就是我们今天要解决的问题。我将带你一步步把SiameseUniNLU封装成Kubernetes Helm Chart，实现多实例水平扩展，让它从一个“单兵作战”的脚本，变成一个“集团军”级别的服务集群。

2. SiameseUniNLU模型简介

2.1 模型核心设计

SiameseUniNLU的设计思路很聪明——它不像传统模型那样为每个任务单独训练一个模型，而是用一个统一的架构来处理多种任务。

想象一下，你有一个万能工具箱，里面不是装满了各种专用工具，而是只有几个核心部件，通过不同的组合方式就能完成不同的工作。SiameseUniNLU就是这样的“万能工具箱”。

它的核心是提示（Prompt）+文本（Text） 的构建方式：

  • 提示部分：告诉模型要做什么任务，比如“找出文本中的人物和地点”
  • 文本部分：就是你要处理的原始文本

模型通过指针网络（Pointer Network）来识别文本中的关键片段，无论是实体、关系还是其他需要抽取的信息。

2.2 支持的任务类型

这个模型能做的事情比你想象的要多：

任务类型 简单解释 实际例子
命名实体识别 找出文本中特定类型的词语 从“谷爱凌在北京冬奥会获得金牌”中找出“谷爱凌”（人物）和“北京”（地点）
关系抽取 找出实体之间的关系 从“张三在阿里巴巴担任工程师”中找出“张三”和“阿里巴巴”之间的“工作于”关系
情感分类 判断文本的情感倾向 判断“这个产品太好用了”是正向情感
文本分类 把文本分到预定义的类别 把新闻文章分类为“体育”、“科技”、“财经”等
阅读理解 根据文本回答问题 从一段文章中找出“谁获得了冠军”的答案

2.3 为什么需要容器化和扩展？

你可能在想：“我直接在服务器上运行python app.py不就行了吗？”确实可以，但有几个问题：

  1. 环境依赖复杂：每台服务器都要安装Python、PyTorch、Transformers等依赖
  2. 扩展困难：流量大了怎么办？手动启动更多实例？监控和管理都很麻烦
  3. 部署不一致：开发环境、测试环境、生产环境可能不一样
  4. 资源隔离差：一个服务出问题可能影响其他服务

用Kubernetes和Helm来解决这些问题，就像从“手工作坊”升级到“自动化工厂”。

3. 基础部署：从脚本到Docker容器

3.1 创建Docker镜像

首先，我们需要把原来的Python脚本打包成Docker镜像。这样无论在哪里运行，环境都是一致的。

创建一个Dockerfile文件：

# 使用PyTorch官方镜像作为基础
FROM pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

# 复制模型文件和应用代码
COPY nlp_structbert_siamese-uninlu_chinese-base/ /app/model/
COPY requirements.txt /app/

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 创建应用入口脚本
RUN echo '#!/bin/bash\n\
cd /app/model\n\
python app.py --host=0.0.0.0 --port=7860\n' > /app/entrypoint.sh && \
    chmod +x /app/entrypoint.sh

# 暴露端口
EXPOSE 7860

# 设置启动命令
ENTRYPOINT ["/app/entrypoint.sh"]

3.2 准备requirements.txt

确保你的依赖文件包含所有必要的包：

torch>=2.0.0
transformers>=4.30.0
flask>=2.3.0
flask-cors>=4.0.0
sentencepiece>=0.1.99
protobuf>=3.20.0

3.3 构建和测试镜像

现在可以构建镜像并测试了：

# 构建Docker镜像
docker build -t siamese-uninlu:1.0.0 .

# 运行测试
docker run -d -p 7860:7860 --name uninlu-test siamese-uninlu:1.0.0

# 测试API是否正常
curl -X POST http://localhost:7860/api/predict \
  -H "Content-Type: application/json" \
  -d '{
    "text": "谷爱凌在北京冬奥会获得金牌",
    "schema": "{\"人物\": null, \"地理位置\": null}"
  }'

如果看到返回的JSON结果，说明镜像构建成功了。

4. Kubernetes部署：单实例服务

4.1 创建基础Kubernetes配置

在把服务部署到Kubernetes之前，我们需要创建几个配置文件。先从一个简单的Deployment开始。

创建deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: siamese-uninlu
  labels:
    app: siamese-uninlu
spec:
  replicas: 1
  selector:
    matchLabels:
      app: siamese-uninlu
  template:
    metadata:
      labels:
        app: siamese-uninlu
    spec:
      containers:
      - name: uninlu
        image: siamese-uninlu:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 7860
        resources:
          requests:
            memory: "2Gi"
            cpu: "1000m"
          limits:
            memory: "4Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /health
            port: 7860
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 7860
          initialDelaySeconds: 5
          periodSeconds: 5

4.2 添加健康检查端点

为了让Kubernetes能监控服务的健康状态，我们需要在原来的app.py中添加一个健康检查端点：

from flask import Flask, request, jsonify
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import json

app = Flask(__name__)

# 加载模型（这里简化了，实际需要根据SiameseUniNLU的加载方式调整）
model = None
tokenizer = None

def load_model():
    global model, tokenizer
    if model is None:
        model_path = "/app/model"
        tokenizer = AutoTokenizer.from_pretrained(model_path)
        model = AutoModelForSequenceClassification.from_pretrained(model_path)
        model.eval()
    return model, tokenizer

@app.route('/health', methods=['GET'])
def health_check():
    """健康检查端点"""
    try:
        # 检查模型是否加载
        _, _ = load_model()
        return jsonify({"status": "healthy", "model_loaded": True}), 200
    except Exception as e:
        return jsonify({"status": "unhealthy", "error": str(e)}), 500

@app.route('/api/predict', methods=['POST'])
def predict():
    """预测接口"""
    try:
        data = request.json
        text = data.get('text', '')
        schema = data.get('schema', '{}')
        
        # 这里调用实际的预测逻辑
        # 为了示例，我们返回一个模拟结果
        result = {
            "text": text,
            "schema": schema,
            "predictions": [
                {"entity": "谷爱凌", "type": "人物", "start": 0, "end": 3},
                {"entity": "北京", "type": "地理位置", "start": 4, "end": 6}
            ]
        }
        return jsonify(result), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    # 预加载模型
    load_model()
    app.run(host='0.0.0.0', port=7860, debug=False)

4.3 创建Service和Ingress

为了让服务能被外部访问，我们需要创建Service和Ingress：

创建service.yaml：

apiVersion: v1
kind: Service
metadata:
  name: siamese-uninlu-service
spec:
  selector:
    app: siamese-uninlu
  ports:
  - port: 80
    targetPort: 7860
  type: ClusterIP

创建ingress.yaml（如果需要从集群外部访问）：

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: siamese-uninlu-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: uninlu.yourdomain.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: siamese-uninlu-service
            port:
              number: 80

4.4 部署到Kubernetes

现在可以部署到Kubernetes集群了：

# 应用所有配置
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml

# 检查部署状态
kubectl get pods -l app=siamese-uninlu
kubectl get svc siamese-uninlu-service
kubectl get ingress siamese-uninlu-ingress

# 查看日志
kubectl logs -f deployment/siamese-uninlu

5. Helm Chart封装：实现可复用部署

5.1 Helm Chart基础结构

Helm是Kubernetes的包管理器，可以把我们的应用打包成一个Chart，方便分享和部署。创建一个标准的Chart结构：

siamese-uninlu-chart/
├── Chart.yaml          # Chart元数据
├── values.yaml         # 默认配置值
├── templates/          # Kubernetes模板文件
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── ingress.yaml
│   ├── configmap.yaml
│   └── hpa.yaml       # 水平自动扩展
└── charts/             # 子Chart（依赖）

5.2 Chart.yaml配置

apiVersion: v2
name: siamese-uninlu
description: A Helm chart for deploying SiameseUniNLU model on Kubernetes
type: application
version: 1.0.0
appVersion: "1.0.0"
keywords:
  - nlp
  - ai
  - machine-learning
  - kubernetes
home: https://github.com/your-repo/siamese-uninlu
sources:
  - https://github.com/your-repo/siamese-uninlu
maintainers:
  - name: Your Name
    email: your.email@example.com

5.3 values.yaml配置

这是Chart的核心配置文件，用户可以在这里自定义各种参数：

# 镜像配置
image:
  repository: your-registry/siamese-uninlu
  tag: "1.0.0"
  pullPolicy: IfNotPresent

# 副本数配置
replicaCount: 2

# 服务配置
service:
  type: ClusterIP
  port: 80
  targetPort: 7860

# 资源限制
resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

# 自动扩展配置
autoscaling:
  enabled: true
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 70
  targetMemoryUtilizationPercentage: 80

# 健康检查配置
probe:
  liveness:
    initialDelaySeconds: 30
    periodSeconds: 10
    timeoutSeconds: 5
    failureThreshold: 3
  readiness:
    initialDelaySeconds: 5
    periodSeconds: 5
    timeoutSeconds: 3
    failureThreshold: 3

# 模型配置
model:
  cachePath: "/app/model-cache"
  preload: true

# Ingress配置
ingress:
  enabled: true
  className: "nginx"
  hosts:
    - host: uninlu.yourdomain.com
      paths:
        - path: /
          pathType: Prefix
  tls: []

5.4 模板文件示例

这是templates/deployment.yaml的模板化版本：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "siamese-uninlu.fullname" . }}
  labels:
    {{- include "siamese-uninlu.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "siamese-uninlu.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "siamese-uninlu.selectorLabels" . | nindent 8 }}
    spec:
      containers:
      - name: {{ .Chart.Name }}
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        imagePullPolicy: {{ .Values.image.pullPolicy }}
        ports:
        - containerPort: {{ .Values.service.targetPort }}
        env:
        - name: MODEL_CACHE_PATH
          value: {{ .Values.model.cachePath | quote }}
        - name: PRELOAD_MODEL
          value: {{ .Values.model.preload | quote }}
        resources:
          {{- toYaml .Values.resources | nindent 12 }}
        livenessProbe:
          httpGet:
            path: /health
            port: {{ .Values.service.targetPort }}
          initialDelaySeconds: {{ .Values.probe.liveness.initialDelaySeconds }}
          periodSeconds: {{ .Values.probe.liveness.periodSeconds }}
          timeoutSeconds: {{ .Values.probe.liveness.timeoutSeconds }}
          failureThreshold: {{ .Values.probe.liveness.failureThreshold }}
        readinessProbe:
          httpGet:
            path: /health
            port: {{ .Values.service.targetPort }}
          initialDelaySeconds: {{ .Values.probe.readiness.initialDelaySeconds }}
          periodSeconds: {{ .Values.probe.readiness.periodSeconds }}
          timeoutSeconds: {{ .Values.probe.readiness.timeoutSeconds }}
          failureThreshold: {{ .Values.probe.readiness.failureThreshold }}

5.5 辅助模板

创建templates/_helpers.tpl来定义一些可重用的模板片段：

{{/* 生成完整的应用名称 */}}
{{- define "siamese-uninlu.fullname" -}}
{{- if .Values.fullnameOverride }}
{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- $name := default .Chart.Name .Values.nameOverride }}
{{- if contains $name .Release.Name }}
{{- .Release.Name | trunc 63 | trimSuffix "-" }}
{{- else }}
{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" }}
{{- end }}
{{- end }}
{{- end }}

{{/* 定义通用标签 */}}
{{- define "siamese-uninlu.labels" -}}
helm.sh/chart: {{ include "siamese-uninlu.chart" . }}
{{ include "siamese-uninlu.selectorLabels" . }}
{{- if .Chart.AppVersion }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
{{- end }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end }}

{{/* 选择器标签 */}}
{{- define "siamese-uninlu.selectorLabels" -}}
app.kubernetes.io/name: {{ include "siamese-uninlu.name" . }}
app.kubernetes.io/instance: {{ .Release.Name }}
{{- end }}

{{/* Chart名称 */}}
{{- define "siamese-uninlu.chart" -}}
{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" }}
{{- end }}

{{/* 应用名称 */}}
{{- define "siamese-uninlu.name" -}}
{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" }}
{{- end }}

6. 水平扩展与自动伸缩

6.1 水平扩展策略

当流量增加时，我们需要能够自动扩展服务实例。Kubernetes的Horizontal Pod Autoscaler（HPA）可以帮我们做到这一点。

创建templates/hpa.yaml：

{{- if .Values.autoscaling.enabled }}
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: {{ include "siamese-uninlu.fullname" . }}
  labels:
    {{- include "siamese-uninlu.labels" . | nindent 4 }}
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: {{ include "siamese-uninlu.fullname" . }}
  minReplicas: {{ .Values.autoscaling.minReplicas }}
  maxReplicas: {{ .Values.autoscaling.maxReplicas }}
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: {{ .Values.autoscaling.targetCPUUtilizationPercentage }}
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: {{ .Values.autoscaling.targetMemoryUtilizationPercentage }}
{{- end }}

6.2 配置ConfigMap管理模型配置

为了更方便地管理模型配置，我们可以使用ConfigMap：

创建templates/configmap.yaml：

apiVersion: v1
kind: ConfigMap
metadata:
  name: {{ include "siamese-uninlu.fullname" . }}-config
data:
  model-config.json: |
    {
      "model_name": "nlp_structbert_siamese-uninlu_chinese-base",
      "max_length": 512,
      "batch_size": 32,
      "device": "cuda",
      "supported_tasks": [
        "ner",
        "re",
        "sentiment",
        "classification",
        "qa"
      ],
      "default_schemas": {
        "ner": "{\"人物\":null,\"地理位置\":null,\"组织机构\":null}",
        "sentiment": "{\"情感分类\":null}"
      }
    }
  app-config.yaml: |
    server:
      host: "0.0.0.0"
      port: 7860
      workers: 4
      timeout: 300
    logging:
      level: "INFO"
      format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    cache:
      enabled: true
      ttl: 3600
      max_size: 1000

6.3 更新Deployment使用ConfigMap

修改templates/deployment.yaml，添加ConfigMap挂载：

# 在spec.template.spec部分添加
volumes:
- name: config-volume
  configMap:
    name: {{ include "siamese-uninlu.fullname" . }}-config

# 在容器定义中添加
volumeMounts:
- name: config-volume
  mountPath: /app/config

6.4 多实例部署测试

现在我们可以测试多实例部署了：

# 使用Helm安装Chart
helm install siamese-uninlu ./siamese-uninlu-chart \
  --set replicaCount=3 \
  --set autoscaling.enabled=true \
  --set autoscaling.minReplicas=2 \
  --set autoscaling.maxReplicas=5

# 查看部署状态
kubectl get pods -l app.kubernetes.io/name=siamese-uninlu

# 查看HPA状态
kubectl get hpa

# 模拟流量增加，观察自动扩展
# 可以使用压力测试工具，或者手动增加副本数
kubectl scale deployment siamese-uninlu --replicas=5

7. 生产环境优化建议

7.1 性能优化配置

在生产环境中，我们需要对服务进行优化。更新values.yaml中的资源配置：

# 优化后的资源配置
resources:
  requests:
    memory: "4Gi"      # 增加内存请求
    cpu: "2000m"       # 增加CPU请求
    ephemeral-storage: "10Gi"  # 添加存储请求
  limits:
    memory: "8Gi"      # 增加内存限制
    cpu: "4000m"       # 增加CPU限制
    ephemeral-storage: "20Gi"  # 添加存储限制

# GPU支持（如果集群有GPU）
gpu:
  enabled: false
  count: 1
  type: "nvidia.com/gpu"

# 亲和性配置，优化节点调度
affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/arch
          operator: In
          values:
          - amd64
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 100
      podAffinityTerm:
        labelSelector:
          matchExpressions:
          - key: app.kubernetes.io/name
            operator: In
            values:
            - siamese-uninlu
        topologyKey: kubernetes.io/hostname

7.2 监控和日志收集

添加监控和日志配置：

# 在values.yaml中添加
monitoring:
  enabled: true
  prometheus:
    enabled: true
    path: /metrics
    port: 7861
  grafana:
    enabled: true
    dashboard: "siamese-uninlu-dashboard"

logging:
  enabled: true
  level: "INFO"
  format: "json"
  output:
    stdout: true
    file: true
    filePath: "/var/log/siamese-uninlu/app.log"

创建监控ServiceMonitor（如果使用Prometheus Operator）：

{{- if .Values.monitoring.prometheus.enabled }}
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: {{ include "siamese-uninlu.fullname" . }}-monitor
  labels:
    {{- include "siamese-uninlu.labels" . | nindent 4 }}
spec:
  selector:
    matchLabels:
      {{- include "siamese-uninlu.selectorLabels" . | nindent 6 }}
  endpoints:
  - port: metrics
    path: {{ .Values.monitoring.prometheus.path }}
    interval: 30s
{{- end }}

7.3 网络和安全性配置

# 网络策略
networkPolicy:
  enabled: true
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              name: monitoring
        - podSelector:
            matchLabels:
              app: prometheus
      ports:
        - port: 7861
          protocol: TCP

# TLS/SSL配置
tls:
  enabled: true
  secretName: siamese-uninlu-tls
  hosts:
    - uninlu.yourdomain.com

# 安全上下文
securityContext:
  enabled: true
  runAsUser: 1000
  runAsGroup: 1000
  fsGroup: 1000
  readOnlyRootFilesystem: true
  allowPrivilegeEscalation: false

8. 部署和运维实践

8.1 完整的部署流程

这里是一个完整的部署脚本示例：

#!/bin/bash
# deploy-siamese-uninlu.sh

set -e

# 1. 构建Docker镜像
echo "步骤1: 构建Docker镜像..."
docker build -t your-registry/siamese-uninlu:1.0.0 .
docker push your-registry/siamese-uninlu:1.0.0

# 2. 创建命名空间
echo "步骤2: 创建Kubernetes命名空间..."
kubectl create namespace ai-models --dry-run=client -o yaml | kubectl apply -f -

# 3. 使用Helm部署
echo "步骤3: 使用Helm部署Chart..."
helm upgrade --install siamese-uninlu ./siamese-uninlu-chart \
  --namespace ai-models \
  --set image.repository=your-registry/siamese-uninlu \
  --set image.tag=1.0.0 \
  --set replicaCount=3 \
  --set autoscaling.enabled=true \
  --set ingress.enabled=true \
  --set ingress.hosts[0].host=uninlu.yourdomain.com \
  --set resources.requests.memory=4Gi \
  --set resources.requests.cpu=2000m \
  --set resources.limits.memory=8Gi \
  --set resources.limits.cpu=4000m

# 4. 等待部署完成
echo "步骤4: 等待部署完成..."
kubectl wait --namespace ai-models \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/name=siamese-uninlu \
  --timeout=300s

# 5. 测试服务
echo "步骤5: 测试服务..."
SERVICE_IP=$(kubectl get svc -n ai-models siamese-uninlu-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
if [ -z "$SERVICE_IP" ]; then
  SERVICE_IP="localhost"
fi

curl -X POST "http://${SERVICE_IP}/api/predict" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "测试文本",
    "schema": "{\"人物\": null}"
  }'

echo "部署完成！"

8.2 日常运维命令

创建运维脚本ops-commands.sh：

#!/bin/bash
# 运维常用命令

NAMESPACE="ai-models"
RELEASE_NAME="siamese-uninlu"

# 查看所有Pod状态
function check_pods() {
    kubectl get pods -n $NAMESPACE -l app.kubernetes.io/name=siamese-uninlu
}

# 查看服务状态
function check_services() {
    kubectl get svc -n $NAMESPACE
}

# 查看HPA状态
function check_hpa() {
    kubectl get hpa -n $NAMESPACE
}

# 查看日志
function view_logs() {
    POD_NAME=$(kubectl get pods -n $NAMESPACE -l app.kubernetes.io/name=siamese-uninlu -o jsonpath='{.items[0].metadata.name}')
    kubectl logs -f -n $NAMESPACE $POD_NAME
}

# 查看资源使用
function check_resources() {
    kubectl top pods -n $NAMESPACE
}

# 重启部署
function restart_deployment() {
    kubectl rollout restart deployment -n $NAMESPACE $RELEASE_NAME
}

# 扩展副本数
function scale_replicas() {
    if [ -z "$1" ]; then
        echo "请指定副本数，例如: scale_replicas 5"
        return 1
    fi
    kubectl scale deployment -n $NAMESPACE $RELEASE_NAME --replicas=$1
}

# 更新配置
function update_config() {
    helm upgrade $RELEASE_NAME ./siamese-uninlu-chart -n $NAMESPACE \
        --set image.tag=$1 \
        --reuse-values
}

# 回滚到上一个版本
function rollback() {
    helm rollback $RELEASE_NAME -n $NAMESPACE
}

# 显示帮助
function show_help() {
    echo "可用命令:"
    echo "  check_pods       查看Pod状态"
    echo "  check_services   查看服务状态"
    echo "  check_hpa        查看HPA状态"
    echo "  view_logs        查看日志"
    echo "  check_resources  查看资源使用"
    echo "  restart_deployment 重启部署"
    echo "  scale_replicas <数量> 扩展副本数"
    echo "  update_config <版本> 更新配置"
    echo "  rollback         回滚到上一个版本"
}

# 如果没有参数，显示帮助
if [ $# -eq 0 ]; then
    show_help
else
    $@
fi

8.3 监控告警配置

创建Prometheus告警规则alerts.yaml：

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: siamese-uninlu-alerts
  namespace: ai-models
spec:
  groups:
  - name: siamese-uninlu
    rules:
    - alert: HighErrorRate
      expr: rate(http_requests_total{status=~"5..",job="siamese-uninlu"}[5m]) / rate(http_requests_total{job="siamese-uninlu"}[5m]) > 0.05
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "SiameseUniNLU错误率过高"
        description: "错误率超过5%，当前值为 {{ $value }}"
    
    - alert: HighLatency
      expr: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket{job="siamese-uninlu"}[5m])) > 2
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "SiameseUniNLU响应时间过长"
        description: "95%分位响应时间超过2秒，当前值为 {{ $value }}秒"
    
    - alert: PodCrashLooping
      expr: rate(kube_pod_container_status_restarts_total{container="siamese-uninlu"}[15m]) > 0
      for: 5m
      labels:
        severity: critical
      annotations:
        summary: "SiameseUniNLU Pod频繁重启"
        description: "Pod {{ $labels.pod }}在频繁重启"
    
    - alert: HighMemoryUsage
      expr: (container_memory_working_set_bytes{container="siamese-uninlu"} / container_spec_memory_limit_bytes{container="siamese-uninlu"}) > 0.9
      for: 10m
      labels:
        severity: warning
      annotations:
        summary: "SiameseUniNLU内存使用率过高"
        description: "内存使用率超过90%，当前值为 {{ $value }}"

9. 总结

通过这个教程，我们完成了SiameseUniNLU模型从简单的Python脚本到完整的Kubernetes Helm Chart部署的转变。让我们回顾一下关键步骤：

9.1 主要成果

  1. 容器化部署：将模型打包成Docker镜像，解决了环境依赖和一致性问题
  2. Kubernetes编排：使用Deployment、Service、Ingress等资源管理服务生命周期
  3. Helm Chart封装：创建可复用的部署包，支持参数化配置
  4. 水平扩展能力：通过HPA实现自动伸缩，应对流量变化
  5. 生产级优化：添加了健康检查、资源限制、监控告警等生产环境必备功能

9.2 部署架构优势

现在我们的SiameseUniNLU服务具有以下优势：

  • 高可用性：多副本部署，单个实例故障不影响整体服务
  • 弹性伸缩：根据负载自动调整实例数量
  • 易于管理：通过Helm一键部署和升级
  • 监控完备：完整的监控和告警体系
  • 资源隔离：每个实例有独立的资源限制，避免相互影响

9.3 后续优化方向

如果你想让这个部署更加完善，可以考虑：

  1. 模型版本管理：实现A/B测试和灰度发布
  2. 流量治理：集成服务网格（如Istio）进行更精细的流量控制
  3. 模型热更新：支持不重启服务更新模型
  4. 多模型支持：扩展支持其他NLP模型的统一部署框架
  5. 成本优化：根据使用模式自动调整资源分配

9.4 快速开始

如果你想立即尝试，这里是最简化的部署命令：

# 1. 克隆Chart仓库
git clone https://github.com/your-repo/siamese-uninlu-chart.git
cd siamese-uninlu-chart

# 2. 安装Chart
helm install siamese-uninlu . \
  --set image.repository=your-registry/siamese-uninlu \
  --set image.tag=1.0.0 \
  --set replicaCount=2

# 3. 访问服务
kubectl port-forward svc/siamese-uninlu-service 7860:80
# 然后在浏览器中访问 http://localhost:7860

这个部署方案不仅适用于SiameseUniNLU，也可以作为其他AI模型服务的参考架构。希望这个教程能帮助你更好地在生产环境中部署和管理AI模型服务。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。

# 自然语言处理
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

一个 API 入口调用多个大模型：AiiOnly客户端 + CC Switch 打通 Codex AI编程流程

avatar AI编程社区
cover

VSCode Claude Code + MiMo 中转免登录完整配置教程（解决原生登录弹窗 + 模型报错）

avatar AI编程社区
cover

从零开始做一个属于自己的 Skill（保姆级教程）

avatar AI编程社区