AI基础设施实战：从概念到部署，构建企业级AI能力栈

最近在技术圈里，甲骨文（Oracle）的一则新闻引发了广泛讨论：这家老牌数据库巨头正“举债重金押注 AI 基建”，同时被曝出正在制定新一轮裁员计划。这看似矛盾的操作背后，其实揭示了当前企业级技术市场一个深刻的转型趋势。对于开发者而言，这不仅仅是财经新闻，更是一个强烈的信号——AI基础设施（AI Infra）正在成为企业技术栈的核心，而掌握相关技能，将直接影响我们未来的职业发展路径。

本文将从一个技术实践者的角度，深入探讨“AI基建”究竟包含哪些具体的技术栈、工具和实践。我们会从概念入手，逐步拆解一个现代AI基础设施的构成，并通过一个完整的实战案例，演示如何从零开始搭建一个支持大模型应用开发与部署的简易AI基础设施环境。无论你是后端开发、运维工程师还是对AI应用感兴趣的全栈开发者，都能从中获得可以直接复用的知识和代码。

1. AI 基建：概念、范畴与技术栈

在讨论甲骨文的战略之前，我们首先要明确“AI基建”到底是什么。它不是一个单一的产品，而是一个庞大的技术生态体系，旨在为人工智能（尤其是大语言模型）的研发、训练、部署、管理和应用提供稳定、高效、可扩展的底层支撑。

1.1 核心定义与解决的问题

AI基础设施（AI Infrastructure）指的是支撑人工智能模型全生命周期（数据准备、模型训练、微调、评估、部署、推理、监控）所需的硬件、软件、平台和工具集合。它主要解决以下几个核心问题：

1. 算力瓶颈：大模型训练和推理需要巨大的计算资源（GPU/TPU集群）。AI基建提供弹性的、可管理的算力池。
2. 数据管理与处理：海量、多模态数据的存储、清洗、标注和版本管理。
3. 开发与实验效率：为算法工程师和研究人员提供快速实验、模型版本控制、超参数调优的环境。
4. 模型部署与运维（MLOps）：将训练好的模型高效、稳定、安全地部署到生产环境，并持续监控其性能、准确性和成本。
5. 工具链与平台化：提供统一的平台，降低AI应用开发门槛，让应用开发者能更专注于业务逻辑。

甲骨文作为传统的企业软件和云服务提供商，其“重金押注AI基建”，意味着它正在将其庞大的云数据中心、数据库技术、企业级服务能力，与新的AI算力、AI开发平台进行深度融合，以对抗AWS、Azure、Google Cloud在AI云市场的领先地位。

1.2 现代AI基建的技术栈构成

一个完整的AI基础设施通常包含以下层次，我们可以将其类比为传统的Web开发架构：

对于大多数企业和开发团队，并非需要自建所有层次。云服务商（如AWS SageMaker, GCP Vertex AI, Azure Machine Learning）提供了全托管的平台，而像 Hugging Face、Replicate 等则提供了更聚焦于模型部署与推理的服务。甲骨文的策略，正是希望提供一套从底层IaaS到顶层AI PaaS的完整企业级解决方案。

2. 环境准备：搭建本地AI开发与实验环境

在深入云原生AI基建之前，我们先在本地搭建一个最小化的AI开发环境。这个环境可以用于学习、实验和小型模型的微调，是理解整个AI基建流程的基础。

2.1 基础软件与版本说明

我们将使用以下技术栈，它们都是当前AI开发领域的事实标准：

• 操作系统：Ubuntu 22.04 LTS 或 Windows WSL2 (Ubuntu)。本文以 Ubuntu 22.04 为例。
• 编程语言：Python 3.10 或 3.11。这是PyTorch/TensorFlow主要支持的版本。
• 容器运行时：Docker 24.0+ 与 Docker Compose v2。用于环境隔离和依赖管理。
• Python 环境管理：Miniconda 或 venv。强烈推荐使用Conda管理包含CUDA等系统依赖的复杂环境。
• 深度学习框架：PyTorch 2.0+。我们将以其为例。
• 模型与数据集仓库：Hugging Facetransformers和datasets库。

重要提示：以下版本为示例，请根据你的硬件（特别是GPU型号）和PyTorch官网的安装命令生成器进行调整。

2.2 逐步安装与配置

2.2.1 安装 Miniconda 和创建环境

首先，安装Miniconda来管理独立的Python环境。

# 下载最新的Miniconda安装脚本（Linux x86_64） wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh # 运行安装脚本，按照提示操作（通常一路回车和yes） bash Miniconda3-latest-Linux-x86_64.sh # 安装完成后，关闭并重新打开终端，或运行以下命令激活conda source ~/.bashrc # 创建一个名为`ai-infra-demo`的Python 3.10环境 conda create -n ai-infra-demo python=3.10 -y # 激活该环境 conda activate ai-infra-demo

2.2.2 安装 PyTorch 与 CUDA

访问 PyTorch 官网 ，选择你的CUDA版本。假设你有一张支持CUDA 11.8的NVIDIA GPU。

# 在激活的 conda 环境中，安装 PyTorch、TorchVision、TorchAudio 和 CUDA 11.8 支持 conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia # 验证安装和GPU是否可用 python -c "import torch; print(f'PyTorch version: {torch.__version__}'); print(f'CUDA available: {torch.cuda.is_available()}'); print(f'GPU name: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"No GPU\"}')"

预期输出类似：

PyTorch version: 2.1.0 CUDA available: True GPU name: NVIDIA GeForce RTX 4090

2.2.3 安装 Hugging Face 生态系统及其他工具库

pip install transformers datasets accelerate evaluate peft trl pip install jupyterlab ipywidgets pip install mlflow pip install scikit-learn pandas numpy matplotlib seaborn

2.2.4 安装 Docker 和 Docker Compose

# 卸载旧版本（如有） sudo apt-get remove docker docker-engine docker.io containerd runc # 设置仓库 sudo apt-get update sudo apt-get install ca-certificates curl gnupg sudo install -m 0755 -d /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg sudo chmod a+r /etc/apt/keyrings/docker.gpg echo \ "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \ sudo tee /etc/apt/sources.list.d/docker.list > /dev/null # 安装 Docker Engine sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin # 将当前用户添加到docker组，避免每次使用sudo sudo usermod -aG docker $USER # **重要：需要重新登录或重启终端使组更改生效** # 验证安装 docker --version docker compose version

至此，一个支持GPU加速的本地AI开发环境就准备好了。这个环境已经具备了模型实验、微调和简单服务化的能力。

3. 核心组件实战：构建一个简易的模型服务化管道

理解了技术栈后，我们通过一个实战项目来串联AI基建中的几个关键环节：模型开发 -> 模型管理 -> 服务化部署 -> 监控。我们将使用一个开源的文本生成模型，并利用 MLflow 和 TorchServe 来构建管道。

3.1 项目结构与目标

项目目标：将facebook/opt-125m模型进行本地部署，提供一个HTTP API接口用于文本生成，并使用MLflow跟踪实验和注册模型。

项目结构：

ai_infra_project/ ├── train.py # 模型微调/训练脚本（本例简化，仅做加载和记录） ├── serve_model.py # 使用 TorchServe 部署模型的配置生成脚本 ├── model_handler.py # TorchServe 自定义处理器 ├── docker-compose.yml # 编排 MLflow 和 监控服务 ├── requirements.txt └── README.md

3.2 步骤一：使用 MLflow 跟踪实验并注册模型

MLflow 是一个管理机器学习生命周期的开源平台，我们首先用它来记录我们的模型。

1. 创建项目目录和依赖文件

mkdir ai_infra_project && cd ai_infra_project

创建requirements.txt：

mlflow>=2.0 torch>=2.0 transformers>=4.30 accelerate

2. 编写训练与模型记录脚本 (train.py)

这个脚本模拟一个“训练”过程：加载预训练模型，记录一些参数和评估指标，最后将模型日志和模型本身保存到MLflow。

# train.py import mlflow import mlflow.pytorch from transformers import AutoModelForCausalLM, AutoTokenizer import torch def main(): # 设置 MLflow 跟踪的URI（本地文件系统） mlflow.set_tracking_uri("file:./mlruns") # 设置实验名称 mlflow.set_experiment("OPT-125m-Demo") model_name = "facebook/opt-125m" print(f"Loading model and tokenizer: {model_name}") # 加载模型和分词器 tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name) # 开始一个 MLflow Run with mlflow.start_run() as run: # 记录超参数（示例） mlflow.log_param("model_name", model_name) mlflow.log_param("learning_rate", 2e-5) mlflow.log_param("batch_size", 4) # 模拟训练并记录指标（示例） for epoch in range(3): # 模拟3个epoch mock_loss = 0.5 * (0.9 ** epoch) # 模拟损失下降 mlflow.log_metric("train_loss", mock_loss, step=epoch) print(f"Epoch {epoch}: loss = {mock_loss:.4f}") # 记录一个评估指标 mlflow.log_metric("final_perplexity", 15.3) # **核心：将 PyTorch 模型记录到 MLflow** # 这里我们记录整个 transformers pipeline，便于后续部署 from transformers import pipeline text_generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device=0 if torch.cuda.is_available() else -1) # 使用 mlflow.transformers 记录（需要 mlflow 2.0+） # 先保存模型到本地临时目录，再用 mlflow 记录 import tempfile import os with tempfile.TemporaryDirectory() as tmpdir: model_save_path = os.path.join(tmpdir, "opt-125m-mlflow") text_generator.save_pretrained(model_save_path) # 记录整个模型目录 mlflow.log_artifacts(model_save_path, artifact_path="model") print(f"Model and metrics logged to MLflow run: {run.info.run_id}") # 可选：将当前运行的模型注册到 MLflow Model Registry # mlflow.register_model(f"runs:/{run.info.run_id}/model", "opt-125m-text-gen") if __name__ == "__main__": main()

运行此脚本：

conda activate ai-infra-demo pip install -r requirements.txt python train.py

运行后，会在当前目录下生成一个mlruns文件夹，里面存储了所有实验数据、参数、指标和模型文件。你可以通过mlflow ui命令启动Web界面查看。

3.3 步骤二：使用 TorchServe 部署模型为 HTTP API

TorchServe 是 PyTorch 官方提供的模型服务化工具。我们需要将模型打包成.mar文件并启动服务。

1. 安装 TorchServe 和依赖

pip install torchserve torch-model-archiver

2. 创建自定义处理器 (model_handler.py)

TorchServe 需要知道如何预处理请求和后处理响应。

# model_handler.py import torch import logging import json import transformers from ts.torch_handler.base_handler import BaseHandler logger = logging.getLogger(__name__) class TransformersTextGenerationHandler(BaseHandler): def __init__(self): super().__init__() self.initialized = False self.model = None self.tokenizer = None self.device = None def initialize(self, context): """加载模型和分词器""" self.manifest = context.manifest properties = context.system_properties model_dir = properties.get("model_dir") # 确定设备 self.device = torch.device( "cuda:" + str(properties.get("gpu_id")) if torch.cuda.is_available() and properties.get("gpu_id") is not None else "cpu" ) logger.info(f"Using device: {self.device}") # 从 MLflow 记录的路径加载模型和分词器 # 在实际部署中，model_dir 指向的是我们打包的 .mar 文件解压后的路径 # 这里假设模型文件在 `model` 子目录下 from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline model_path = model_dir # TorchServe 会自动处理 self.tokenizer = AutoTokenizer.from_pretrained(model_path) self.model = AutoModelForCausalLM.from_pretrained(model_path).to(self.device) self.generator = pipeline("text-generation", model=self.model, tokenizer=self.tokenizer, device=self.device) self.initialized = True logger.info("Model and tokenizer initialized successfully") def preprocess(self, data): """预处理请求数据""" # 假设请求格式为 JSON: {"text": "The future of AI is", "max_length": 50} input_text = data[0].get("body").decode('utf-8') input_data = json.loads(input_text) prompt = input_data.get("text", "") self.max_length = input_data.get("max_length", 50) return prompt def inference(self, prompt): """执行推理""" with torch.no_grad(): result = self.generator(prompt, max_length=self.max_length, do_sample=True, temperature=0.9) generated_text = result[0]['generated_text'] return [generated_text] def postprocess(self, inference_output): """后处理推理结果，返回响应""" # 将结果包装成 JSON 格式 return [json.dumps({"generated_text": inference_output[0]})] def handle(self, data, context): """主处理流程""" if not self.initialized: self.initialize(context) prompt = self.preprocess(data) output = self.inference(prompt) return self.postprocess(output)

3. 打包模型为.mar文件

首先，我们需要将 MLflow 保存的模型文件复制到一个固定目录。假设我们使用最后一次运行的模型。

# 找到最新的模型目录（这里简化处理，手动指定） # 假设 mlruns/0/<run_id>/artifacts/model 是模型路径 # 将其复制到 model_store 目录 mkdir -p model_store cp -r mlruns/0/<你的run_id>/artifacts/model/* ./model_store/ # 生成 .mar 文件 torch-model-archiver --model-name opt125m \ --version 1.0 \ --serialized-file ./model_store/pytorch_model.bin \ --handler ./model_handler.py \ --extra-files "./model_store/config.json,./model_store/tokenizer.json,./model_store/tokenizer_config.json" \ --export-path ./model_store \ --force

运行后，会在./model_store目录下生成opt125m.mar文件。

4. 启动 TorchServe

# 启动服务，指定模型存储路径和推理端口 torchserve --start --model-store ./model_store --models opt125m=opt125m.mar --ncs --ts-config ./config.properties

你需要创建一个config.properties文件来配置工作线程数等参数：

inference_address=http://0.0.0.0:8080 management_address=http://0.0.0.0:8081 number_of_gpu=1 worker_threads_per_model=4

5. 测试推理 API

服务启动后，可以使用curl进行测试：

curl -X POST http://localhost:8080/predictions/opt125m \ -H "Content-Type: application/json" \ -d '{"text": "The future of AI infrastructure is", "max_length": 30}'

预期会返回一个包含生成文本的 JSON 响应。

3.4 步骤三：使用 Docker Compose 编排 MLflow UI 和监控

为了更接近生产环境，我们使用 Docker Compose 来一键启动 MLflow 的跟踪服务器和前端UI。

创建docker-compose.yml文件：

# docker-compose.yml version: '3.8' services: mlflow-tracking: image: ghcr.io/mlflow/mlflow:latest container_name: mlflow-tracking-server ports: - "5000:5000" volumes: - ./mlruns:/mlflow/mlruns # 挂载本地实验数据目录 command: mlflow server --backend-store-uri file:/mlflow/mlruns --default-artifact-root file:/mlflow/mlruns --host 0.0.0.0 --port 5000 networks: - ai-infra-net # 可以添加一个简单的监控看板，如 Grafana，来可视化系统资源（可选） prometheus: image: prom/prometheus:latest container_name: prometheus ports: - "9090:9090" volumes: - ./prometheus.yml:/etc/prometheus/prometheus.yml networks: - ai-infra-net grafana: image: grafana/grafana:latest container_name: grafana ports: - "3000:3000" environment: - GF_SECURITY_ADMIN_PASSWORD=admin volumes: - grafana-storage:/var/lib/grafana networks: - ai-infra-net depends_on: - prometheus networks: ai-infra-net: driver: bridge volumes: grafana-storage:

创建 Prometheus 配置文件prometheus.yml：

# prometheus.yml global: scrape_interval: 15s scrape_configs: - job_name: 'torchserve' static_configs: - targets: ['host.docker.internal:8082'] # TorchServe 管理端口，需要暴露metrics

注意：需要配置 TorchServe 暴露 metrics 端口（8082），并在config.properties中启用metrics_mode=prometheus。这属于更进阶的监控配置。

启动服务：

docker compose up -d

现在，你可以通过http://localhost:5000访问 MLflow UI，查看之前记录的所有实验和模型。

4. 常见问题与排查思路（FAQ）

在搭建和运行上述AI基础设施组件时，你可能会遇到以下常见问题：

5. 企业级AI基建最佳实践与工程建议

从我们的简易管道扩展到企业级生产环境，需要考虑更多的工程化因素。结合甲骨文等云厂商的动向，以下是构建稳健AI基础设施的关键实践：

5.1 计算资源管理与成本优化

• 混合云与多云策略：不要绑定单一云厂商。利用像Kubernetes这样的抽象层，实现工作负载在本地数据中心和多个公有云（如OCI, AWS, Azure）间的可移植性。
• 弹性伸缩与Spot实例：对于训练任务，使用可抢占实例（Spot/Preemptible VMs）大幅降低成本。对于推理服务，根据流量指标（QPS， GPU利用率）自动伸缩实例数量。
• GPU资源共享与隔离：使用K8s设备插件（如NVIDIA GPU Operator）和资源配额（ResourceQuota）实现多团队、多项目间的GPU资源共享与公平调度。

5.2 模型生命周期管理（MLOps）

• 版本控制一切：不仅代码用Git，模型、数据、配置文件、甚至环境（Docker镜像）都需要严格的版本控制。MLflow、DVC（Data Version Control）是常用工具。
• 自动化流水线：使用KubeFlow Pipelines、Airflow或GitLab CI/CD将数据预处理、训练、评估、部署串联成自动化流水线。确保每次代码提交都能触发完整的测试和验证流程。
• 模型注册与治理：建立中心化的模型注册中心（如MLflow Model Registry）。定义清晰的模型晋升流程（Staging -> Production -> Archived），并记录每次部署的模型版本、性能指标和责任人。

5.3 推理服务的高可用与性能

• 服务网格与流量管理：在K8s上，使用Istio或Knative进行灰度发布、A/B测试、金丝雀发布和流量切分。这对于模型迭代和回滚至关重要。
• 模型优化与加速：在生产部署前，务必对模型进行优化。技术包括：量化（Quantization）、剪枝（Pruning）、知识蒸馏（Knowledge Distillation）以及使用专用推理引擎（如TensorRT, ONNX Runtime）。
• 批量推理与异步处理：对于非实时性任务，设计批量推理接口，将请求队列化（使用Redis或Kafka），由Worker异步处理，提高GPU利用率和系统吞吐量。

5.4 监控、可观测性与安全

• 多维监控：
  • 系统层面：GPU/CPU/内存使用率，节点健康状态。
  • 服务层面：请求延迟（P50, P99）、吞吐量（QPS）、错误率（4xx, 5xx）。
  • 模型层面：输入数据分布漂移（Data Drift）、预测结果置信度、业务指标（如点击率）下降。
• 安全与合规：
  • 模型安全：防止对抗性攻击、提示注入攻击（针对LLM）。
  • 数据安全：训练和推理数据加密传输与存储，满足GDPR等数据隐私法规。
  • 访问控制：对模型仓库、训练集群、推理API实施严格的RBAC（基于角色的访问控制）。

甲骨文等传统企业软件巨头进军AI基建，其优势正在于将上述安全、合规、高可用、企业集成的能力，与新的AI算力和平台结合，提供给对稳定性要求极高的金融、电信、政府等行业客户。

6. 总结：从“使用AI”到“构建AI能力”

通过本文的探讨和实战，我们可以看到，“AI基建”远不止是购买几块GPU服务器。它是一个涵盖硬件、软件、流程、人才的系统工程。甲骨文的战略调整，反映了市场从“试用AI模型”向“构建企业级AI能力”的深刻转变。

对于开发者和技术团队来说，这意味着我们的技能树需要更新：

1. 掌握核心工具链：熟练使用PyTorch/TensorFlow、Hugging Face、MLflow、Docker、Kubernetes。
2. 理解MLOps理念：将软件工程的最佳实践（版本控制、CI/CD、监控）应用到机器学习项目中。
3. 关注云原生AI服务：了解各大云平台（包括甲骨文云OCI）的AI服务优劣，能在自建和托管之间做出合理选择。
4. 深耕垂直领域：AI基建最终要为业务服务。在金融、医疗、制造等特定领域，数据格式、合规要求、性能指标都有特殊性，需要定制化的基建方案。

未来的AI应用开发，将是“大模型能力”与“稳健基础设施”的结合。搭建好属于自己或团队的AI基建“底座”，才能让创新的AI想法快速、稳定、可控地转化为实际生产力。