Weaviate 安装与部署

#向量数据库 #Weaviate #Docker #Kubernetes #部署运维

目录

• 快速开始：5步跑通本地环境
• 三种部署方式概览
• 部署前的关键决策
• 方式一：Weaviate Cloud 托管服务（WCS）
• 方式二：Docker 本地部署（推荐）
• 方式三：Kubernetes 生产集群
• Python 客户端安装与连接
• 模块启用配置
• 配置参数速查
• 版本与升级
• 常见问题排查

快速开始：5步跑通本地环境

• [ ] 第1步：确认 Docker 已安装（docker --version，需要 20.10+）
• [ ] 第2步：创建项目目录，新建 docker-compose.yml（内容见基础版（无外部模块））
• [ ] 第3步：在同目录创建 .env 文件，填入 OPENAI_API_KEY=sk-xxx（如果使用 OpenAI 模块）
• [ ] 第4步：运行 docker compose up -d，等待约30秒
• [ ] 第5步：执行 curl http://localhost:8080/v1/meta 看到 JSON 输出，代表成功

通过后继续往下读完整配置说明，再前往 05-第一个Weaviate应用 动手写代码。

三种部署方式概览

选择部署方式之前，先用这张表对齐预期：

部署前的关键决策

在安装 Weaviate 之前，有一个思维模型值得先建立起来。

想象你在开一家咖啡馆。开业前你不只是"租个铺子"，还要决定：要不要配咖啡机？要不要加奶泡器？要不要装冰淇淋机？这些设备需要提前接好电、备好耗材，开张之后临时加装会很麻烦。

Weaviate 的部署也是这样。 它不只是一个数据库，还是一个模块化的 AI 原生系统。你需要在启动时就决定：

• 要不要内置向量化能力？（用 OpenAI、Cohere 还是本地模型？）
• 要不要内置生成式 AI？（直接在数据库里跑 RAG？）
• 要不要内置重排序？（提升搜索质量？）

这些"外挂技能"都要在 ENABLE_MODULES 里声明，就像装修房子时先想好要装几个插座——事后再改要大动干戈。

方式一：Weaviate Cloud 托管服务（WCS）

什么时候选择 Weaviate Cloud？

如果你不想自己管理服务器、担心运维、或者只是做 PoC 验证，Weaviate Cloud（WCD）是零运维的最佳选择。它就像点外卖——你不需要买菜、洗碗，只管吃就行。

适用场景：

• 快速原型验证
• 小团队 / 个人项目
• 不想在基础设施上花时间
• 需要高可用但团队没有 DevOps 资源

注册与创建免费集群

1. 访问 Weaviate Cloud Console
2. 注册账号（支持 GitHub / Google 登录）
3. 点击 "Create cluster"
4. 选择 "Free sandbox"（免费，14 天有效期，到期前可以重建）
5. 输入集群名称，选择区域（建议选离你最近的节点，国内用新加坡或日本）
6. 等待约 2 分钟，集群状态变为 "Running"

获取连接信息

集群创建后，在 Console 里可以找到：

Python 连接代码（weaviate-client v4）

import weaviate
from weaviate.classes.init import Auth, AdditionalConfig, Timeout
import os

# 基础连接（从环境变量读取）
client = weaviate.connect_to_weaviate_cloud(
    cluster_url=os.environ["WEAVIATE_URL"],          # https://xxx.weaviate.network
    auth_credentials=Auth.api_key(os.environ["WEAVIATE_API_KEY"]),
    # 如果需要调用 OpenAI 等模型，传入对应的 API Key
    headers={
        "X-OpenAI-Api-Key": os.environ["OPENAI_API_KEY"],
    }
)

# 健康检查
assert client.is_ready(), "Weaviate 连接失败，请检查 URL 和 API Key"
print("连接成功，Weaviate 版本:", client.get_meta()["version"])
client.close()

如果在国内连接 WCS 有延迟，调整超时参数：

client = weaviate.connect_to_weaviate_cloud(
    cluster_url=os.environ["WEAVIATE_URL"],
    auth_credentials=Auth.api_key(os.environ["WEAVIATE_API_KEY"]),
    additional_config=AdditionalConfig(
        timeout=Timeout(init=30, query=60, insert=120)
    ),
    headers={
        "X-OpenAI-Api-Key": os.environ["OPENAI_API_KEY"],
    }
)

WCS 方案优缺点：

• 优点：零运维、开箱即用、内置高可用、自动备份
• 缺点：生产环境成本较高（按向量数量和查询次数计费）、数据存储在外部、免费沙箱只有14天

方式二：Docker 本地部署（推荐）

这是日常开发最常用的方式，通过 docker-compose.yml 文件可以清晰管理所有配置，也是本文的重点章节。

前置条件

# 检查 Docker 版本（需要 20.10+）
docker --version

# 检查 Docker Compose（需要 v2，即 docker compose 而非 docker-compose）
docker compose version

最小化启动（无向量化模块）

如果你只是想快速体验 Weaviate，不需要自动向量化（自己传向量进去），可以用最简单的命令：

docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  semitechnologies/weaviate:1.29.0

验证服务是否正常：

curl http://localhost:8080/v1/meta | python3 -m json.tool

看到类似这样的输出就表示 Weaviate 已经在运行了：

{
  "hostname": "http://[::]:8080",
  "modules": {},
  "version": "1.29.0"
}

基础版（无外部模块）

# docker-compose.yml
version: '3.4'

services:
  weaviate:
    image: semitechnologies/weaviate:1.29.0
    container_name: weaviate
    restart: on-failure:0
    ports:
      - "8080:8080"    # HTTP REST API
      - "50051:50051"  # gRPC（v4客户端必须）
    volumes:
      - weaviate_data:/var/lib/weaviate
    environment:
      # 允许匿名访问（开发环境）
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      # 数据持久化路径（容器内部路径）
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
      # 默认查询返回条数
      QUERY_DEFAULTS_LIMIT: 25
      # 集群节点名称
      CLUSTER_HOSTNAME: 'node1'

volumes:
  weaviate_data:

完整版（含 text2vec-openai + generative-openai）

这是日常开发最常用的配置，启用了 OpenAI 的向量化和生成模块：

# docker-compose.yml（OpenAI 全栈方案）
version: '3.4'

services:
  weaviate:
    image: semitechnologies/weaviate:1.29.0
    container_name: weaviate
    restart: on-failure:0
    ports:
      - "8080:8080"
      - "50051:50051"
    volumes:
      - weaviate_data:/var/lib/weaviate
    environment:
      # ===== 访问控制 =====
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'

      # ===== 数据存储 =====
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'

      # ===== 模块配置（核心！） =====
      # 默认向量化模块
      DEFAULT_VECTORIZER_MODULE: 'text2vec-openai'
      # 启用的模块列表（逗号分隔，顺序无关）
      ENABLE_MODULES: 'text2vec-openai,generative-openai'

      # ===== OpenAI API Key =====
      # 从环境变量读取，绝对不要硬编码！
      OPENAI_APIKEY: ${OPENAI_API_KEY}

      # ===== 查询配置 =====
      QUERY_DEFAULTS_LIMIT: 25
      CLUSTER_HOSTNAME: 'node1'

volumes:
  weaviate_data:

创建 .env 文件：

# .env 文件（务必加入 .gitignore！）
OPENAI_API_KEY=sk-your-actual-key-here

完全本地化方案（无外部 API）

不想依赖 OpenAI 等外部 API？可以用 text2vec-transformers 在本地跑开源嵌入模型，用 generative-ollama 在本地跑 LLM。这套组合完全不需要任何外部 API，适合数据合规要求高或网络受限的场景。

# docker-compose.yml（完全本地化方案：text2vec-transformers + Ollama）
version: '3.4'

services:
  weaviate:
    image: semitechnologies/weaviate:1.29.0
    container_name: weaviate
    restart: on-failure:0
    ports:
      - "8080:8080"
      - "50051:50051"
    volumes:
      - weaviate_data:/var/lib/weaviate
    environment:
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'

      # ===== 本地向量化模块 =====
      DEFAULT_VECTORIZER_MODULE: 'text2vec-transformers'
      ENABLE_MODULES: 'text2vec-transformers,generative-ollama'

      # ===== 推理服务地址 =====
      # text2vec-transformers 推理服务
      TRANSFORMERS_INFERENCE_API: 'http://t2v-transformers:8080'
      # Ollama 服务地址
      GENERATIVE_OLLAMA_APIENDPOINT: 'http://ollama:11434'

      QUERY_DEFAULTS_LIMIT: 25
      CLUSTER_HOSTNAME: 'node1'
    # 声明服务启动顺序；此处未配置健康检查，不保证推理服务已经就绪
    depends_on:
      - t2v-transformers
      - ollama

  # 文本向量化推理服务（本地运行 Sentence-Transformers 模型）
  t2v-transformers:
    image: semitechnologies/transformers-inference:sentence-transformers-multi-qa-MiniLM-L6-cos-v1
    container_name: t2v-transformers
    environment:
      # 如果有 GPU，改为 '1'
      ENABLE_CUDA: '0'
    # 推理服务不需要对外暴露，内部通信即可

  # Ollama 本地 LLM 服务
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    # 如果有 GPU，取消注释以下配置
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: 1
    #           capabilities: [gpu]

volumes:
  weaviate_data:
  ollama_models:

启动后，还需要在 Ollama 里拉取要使用的 LLM 模型：

# 启动容器
docker compose up -d

# 等待 Ollama 就绪后拉取模型（约几分钟，取决于网速）
docker exec ollama ollama pull llama3.2

# 验证模型已就绪
docker exec ollama ollama list

Python 代码中使用本地化方案（先执行 import weaviate 和 from weaviate.classes.config import Configure，再执行 client = weaviate.connect_to_local()；默认连接要求前述8080和50051端口映射可用，使用完毕后调用 client.close()）：

client.collections.create(
    "Article",
    vectorizer_config=Configure.Vectorizer.text2vec_transformers(),
    generative_config=Configure.Generative.ollama(
        api_endpoint="http://ollama:11434",
        model="llama3.2",
    )
)

启动与管理命令

# 启动（后台运行）
docker compose up -d

# 查看日志
docker compose logs -f weaviate

# 查看运行状态
docker compose ps

# 停止（保留数据）
docker compose stop

# 停止并删除容器（数据 volume 保留）
docker compose down

# 彻底清除（包括数据！谨慎操作）
docker compose down -v

验证模块是否加载成功

curl http://localhost:8080/v1/meta | python3 -c "
import json, sys
data = json.load(sys.stdin)
print('Weaviate 版本:', data['version'])
print('已加载模块:', list(data.get('modules', {}).keys()))
"

期望输出：

Weaviate 版本: 1.29.0
已加载模块: ['text2vec-openai', 'generative-openai']

常见问题：端口冲突

如果 8080 或 50051 端口被占用：

# 检查端口占用
lsof -i :8080
lsof -i :50051

# 修改 docker-compose.yml 中的端口映射（宿主机端口:容器端口）
ports:
  - "18080:8080"   # 用 18080 替代 8080
  - "50052:50051"  # 用 50052 替代 50051

方式三：Kubernetes 生产集群

适用场景

Kubernetes 部署适合：

• 需要水平扩展（多副本，raft 一致性协议）
• 需要高可用（Pod 故障自动恢复）
• 需要与现有 K8s 集群集成
• 数据量超过单机承载能力（通常 > 50GB 向量数据）

前置条件

# 检查 kubectl
kubectl version --client

# 检查 Helm（需要 v3+）
helm version

# 添加 Weaviate Helm 仓库
helm repo add weaviate https://weaviate.github.io/weaviate-helm
helm repo update

# 查看可用版本
helm search repo weaviate/weaviate --versions | head -10

生产最低配置建议

基础 values.yaml（开发/测试）

# values.yaml - 开发/测试环境

# 副本数
replicas: 1

# Weaviate 镜像版本
image:
  tag: "1.29.0"

# gRPC 服务（v4 客户端必须启用！）
grpc:
  enabled: true
  service:
    type: LoadBalancer

# 存储配置
storage:
  size: 32Gi

# 环境变量
env:
  AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: "true"
  PERSISTENCE_DATA_PATH: "/var/lib/weaviate"
  DEFAULT_VECTORIZER_MODULE: "text2vec-openai"
  ENABLE_MODULES: "text2vec-openai,generative-openai"
  QUERY_DEFAULTS_LIMIT: "25"
  CLUSTER_HOSTNAME: "node1"

# 资源限制（根据实际需求调整）
resources:
  requests:
    cpu: "500m"
    memory: "1Gi"
  limits:
    cpu: "2000m"
    memory: "4Gi"

生产环境 values.yaml（多Pod示例，尚非完整高可用配置）

# values.yaml - 生产环境

# 生产环境建议至少 3 副本
replicas: 3

image:
  tag: "1.29.0"

grpc:
  enabled: true
  service:
    type: LoadBalancer

# 存储配置（生产环境建议 SSD StorageClass）
storage:
  size: 200Gi
  storageClassName: "premium-ssd"  # 根据云服务商调整

# API Key 通过 K8s Secret 引用，不写在 values.yaml 明文里
envSecrets:
  OPENAI_APIKEY: "weaviate-secrets/openai-api-key"

env:
  AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: "false"
  PERSISTENCE_DATA_PATH: "/var/lib/weaviate"
  DEFAULT_VECTORIZER_MODULE: "text2vec-openai"
  ENABLE_MODULES: "text2vec-openai,generative-openai,reranker-cohere"
  QUERY_DEFAULTS_LIMIT: "25"
  # Raft 协议配置（多副本时必须设置，等于副本数）
  RAFT_BOOTSTRAP_EXPECT: "3"

# 资源配置
resources:
  requests:
    cpu: "2000m"
    memory: "8Gi"
  limits:
    cpu: "4000m"
    memory: "16Gi"

# Pod 反亲和性：优先分布到不同的Kubernetes节点；preferred为软约束，不保证节点分散
affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
              - key: app
                operator: In
                values:
                  - weaviate
          topologyKey: kubernetes.io/hostname

使用 Helm 部署

# 创建命名空间
kubectl create namespace weaviate

# 创建存放 API Key 的 Secret（不要用 values.yaml 明文存 Key）
kubectl create secret generic weaviate-secrets \
  --from-literal=openai-api-key=sk-your-key-here \
  --namespace weaviate

# 首次安装
helm install weaviate weaviate/weaviate \
  --namespace weaviate \
  --values values.yaml

# 查看部署状态（-w 持续监视）
kubectl get pods -n weaviate -w

# 等待所有 Pod 就绪
kubectl wait --for=condition=ready pod \
  -l app=weaviate \
  -n weaviate \
  --timeout=300s

# 端口转发到本地测试
kubectl port-forward svc/weaviate 8080:80 -n weaviate &
kubectl port-forward svc/weaviate-grpc 50051:50051 -n weaviate &

# 测试连通性
curl http://localhost:8080/v1/meta

# 后续更新（修改 values.yaml 后执行）
helm upgrade weaviate weaviate/weaviate \
  --namespace weaviate \
  --values values.yaml

# 回滚到上一个版本
helm rollback weaviate -n weaviate

Python 客户端安装与连接

安装

pip install weaviate-client

v3 vs v4 主要变化对照

三种连接方式

1. 连接本地 Docker（最常用）

import weaviate

# 连接本地 Docker（默认 localhost:8080 和 50051）
client = weaviate.connect_to_local()

# 如果本地使用了 OpenAI 模块，需要传入 API Key
client = weaviate.connect_to_local(
    headers={
        "X-OpenAI-Api-Key": "sk-your-key",
    }
)

print(client.is_ready())  # True 表示连接成功

2. 连接 WCS 云服务

import weaviate
from weaviate.classes.init import Auth
import os

client = weaviate.connect_to_weaviate_cloud(
    cluster_url=os.environ["WEAVIATE_URL"],
    auth_credentials=Auth.api_key(os.environ["WEAVIATE_API_KEY"]),
    headers={
        "X-OpenAI-Api-Key": os.environ["OPENAI_API_KEY"],
    }
)

print(client.is_ready())

3. 连接带认证的自托管实例

import weaviate
from weaviate.classes.init import Auth

# 自托管 Weaviate 启用了 API Key 认证
client = weaviate.connect_to_custom(
    http_host="your-weaviate-host.com",
    http_port=80,
    http_secure=True,            # 是否使用 HTTPS
    grpc_host="your-weaviate-host.com",
    grpc_port=50051,
    grpc_secure=True,            # 是否使用 gRPC TLS
    auth_credentials=Auth.api_key("your-api-key"),
    headers={
        "X-OpenAI-Api-Key": "sk-your-key",
    }
)

健康检查

import weaviate

client = weaviate.connect_to_local()

try:
    # 基本就绪检查
    if client.is_ready():
        print("Weaviate 已就绪")
    else:
        print("Weaviate 未就绪，请检查服务状态")

    # 获取版本和模块信息
    meta = client.get_meta()
    print(f"版本: {meta['version']}")
    print(f"已加载模块: {list(meta.get('modules', {}).keys())}")

    # 列出所有 Collections
    collections = client.collections.list_all()
    print(f"现有 Collections: {list(collections.keys())}")

finally:
    # 必须关闭连接，否则可能导致资源泄漏
    client.close()

with weaviate.connect_to_local() as client:
    print(client.is_ready())
    # 退出 with 块时自动调用 client.close()

模块启用配置

ENABLE_MODULES 格式

# 单个模块
ENABLE_MODULES: 'text2vec-openai'

# 多个模块（逗号分隔，注意不要有空格）
ENABLE_MODULES: 'text2vec-openai,generative-openai'

# 多模块单行写法（逗号分隔，不含空格或末尾逗号）
ENABLE_MODULES: 'text2vec-openai,text2vec-cohere,generative-openai,reranker-cohere'

方案一：全 OpenAI 栈（最简单）

适合想快速跑通、不在意 API 费用的场景：

environment:
  DEFAULT_VECTORIZER_MODULE: 'text2vec-openai'
  ENABLE_MODULES: 'text2vec-openai,generative-openai'
  OPENAI_APIKEY: ${OPENAI_API_KEY}

方案二：多模型混合栈

适合需要同时支持多个模型提供商的场景：

environment:
  DEFAULT_VECTORIZER_MODULE: 'text2vec-openai'
  ENABLE_MODULES: 'text2vec-openai,text2vec-cohere,generative-openai,generative-anthropic,reranker-cohere'
  OPENAI_APIKEY: ${OPENAI_API_KEY}
  COHERE_APIKEY: ${COHERE_API_KEY}
  ANTHROPIC_APIKEY: ${ANTHROPIC_API_KEY}

方案三：完全本地化（text2vec-transformers + Ollama）

适合数据不出内网、或无法访问外部 API 的场景（完整 docker-compose 见完全本地化方案（无外部 API））：

environment:
  DEFAULT_VECTORIZER_MODULE: 'text2vec-transformers'
  ENABLE_MODULES: 'text2vec-transformers,generative-ollama'
  TRANSFORMERS_INFERENCE_API: 'http://t2v-transformers:8080'
  GENERATIVE_OLLAMA_APIENDPOINT: 'http://ollama:11434'

常用模块速查表

配置参数速查

核心环境变量

API Key 环境变量

性能调优参数

版本与升级

版本命名规则

Weaviate 采用语义版本（Semantic Versioning）：主版本.次版本.补丁版本，例如 v1.29.0。

当前处于 v1.x 系列，次版本（中间数字）的变更通常引入新特性，补丁版本只修 Bug。

重要版本里程碑

升级前必读

升级步骤（Docker Compose）：

# 1. 备份数据卷
docker compose stop
docker run --rm \
  -v weaviate_data:/data \
  -v $(pwd)/backup:/backup \
  alpine tar czf /backup/weaviate_data_$(date +%Y%m%d).tar.gz /data
echo "备份完成"

# 2. 修改 docker-compose.yml 中的镜像版本
# image: semitechnologies/weaviate:1.28.0  →  semitechnologies/weaviate:1.29.0

# 3. 拉取新镜像并重启
docker compose pull
docker compose up -d

# 4. 验证版本和数据完整性
curl http://localhost:8080/v1/meta | python3 -c "import json,sys; print(json.load(sys.stdin)['version'])"

Kubernetes 滚动升级注意事项：

# 修改 values.yaml 中的 image.tag 后，执行滚动升级
helm upgrade weaviate weaviate/weaviate \
  --namespace weaviate \
  --values values.yaml \
  --wait \
  --timeout 10m

# 监控升级过程（滚动更新，Pod 逐个替换）
kubectl rollout status statefulset/weaviate -n weaviate

# 如果升级失败，立即回滚
helm rollback weaviate -n weaviate

常见问题排查

问题一：Python 客户端连接超时

症状： weaviate.connect_to_local() 抛出超时异常

原因： 通常是 gRPC 端口 50051 没有暴露或被防火墙拦截

排查步骤：

# 1. 检查容器是否正常运行
docker compose ps

# 2. 检查端口是否监听
docker compose port weaviate 50051

# 3. 直接测试 REST API
curl http://localhost:8080/v1/.well-known/ready

# 4. 检查日志是否有错误
docker compose logs weaviate | grep -i error

解决方案： 确保 docker-compose.yml 里同时暴露了 8080 和 50051 两个端口。

问题二：模块加载失败

症状： 创建 Collection 时报 module not found 或 vectorizer not enabled

排查：

# 检查已加载的模块
curl http://localhost:8080/v1/meta | python3 -c "
import json, sys
data = json.load(sys.stdin)
print(json.dumps(data.get('modules', {}), indent=2))
"

解决方案： 检查 ENABLE_MODULES 环境变量是否正确设置，重启容器后重新检查。

问题三：OpenAI 向量化失败

症状： 插入数据时报 could not generate vector 或 401 错误

原因： OpenAI API Key 未正确传入 Weaviate

解决方案：

1. 检查 .env 文件中的 Key 是否正确
2. 确认 docker-compose.yml 里有 OPENAI_APIKEY: ${OPENAI_API_KEY}
3. 重新执行 docker compose up -d
4. 或者在 Python 连接代码中通过 headers 传入：

client = weaviate.connect_to_local(
    headers={"X-OpenAI-Api-Key": "sk-your-key"}
)

问题四：数据重启后消失

症状： 重启容器后，之前写入的数据全都不见了

原因： 没有挂载数据卷（Volume）

解决方案： 在 docker-compose.yml 中添加：

services:
  weaviate:
    volumes:
      - weaviate_data:/var/lib/weaviate

volumes:
  weaviate_data:

问题五：内存不足（OOM）

症状： 容器频繁重启，docker compose logs 显示 OOM Killed

解决方案：

# 检查 Docker 分配给容器的内存上限
docker stats weaviate

# 在 Docker Desktop 设置中增加内存（建议 8GB+）
# 或者给 docker-compose.yml 添加内存限制（防止撑爆宿主机）
services:
  weaviate:
    deploy:
      resources:
        limits:
          memory: 6G
        reservations:
          memory: 4G

问题六：Kubernetes Pod 一直 Pending

症状： kubectl get pods -n weaviate 显示 Pod 处于 Pending 状态

排查：

# 查看 Pod 详细事件（关键！通常错误信息都在 Events 里）
kubectl describe pod -l app=weaviate -n weaviate

# 常见原因：
# 1. 资源不足：requests 超过节点可用资源
# 2. PVC 无法绑定：StorageClass 不存在
# 3. 节点选择器不匹配

小结

安装 Weaviate 的关键不是"安装"本身，而是提前想清楚你要启用哪些模块。

• 本地开发：Docker Compose + 必要的模块，用 .env 文件管理 API Key，两端口（8080/50051）都要暴露
• 完全本地化：text2vec-transformers + generative-ollama，数据不出内网，代价是资源消耗更大
• 云端托管：Weaviate Cloud 免费沙箱，零运维，适合快速验证（14天有效期）
• 生产部署：Kubernetes + Helm，配合 K8s Secret 管理敏感信息；本文以 3 个 Pod 副本为配置示例，高可用还取决于数据复制、节点分布、认证和故障恢复配置，不能仅凭副本数保证
• 升级前必备份，跨次版本升级要逐步进行

下一步，用 Python v4 客户端构建第一个完整的 Weaviate 应用——从连接、建表、插入数据，到向量搜索、混合搜索，再到内置 RAG 问答，一气呵成。

相关文档：

• Weaviate 概述与核心概念
• Weaviate 架构原理
• 第一个 Weaviate 应用
• Modules 模块系统详解
• Weaviate 学习路线图