Ollama 生产环境高并发调用实战:API 网关化改造与并发调优落地指南

很多站长在本地跑通 Ollama 之后,第一反应就是把它塞进业务系统里对外提供服务。但真到生产环境,问题立刻暴露:单机 Ollama 默认只监听 127.0.0.1,并发一上来请求排队、显存打满、超时率飙升,甚至整个推理进程被拖死。站长的经验是,Ollama 本身并不是为高并发设计的,它更像一个单机推理引擎,要把它改造成能扛住线上流量的服务,必须在架构层做网关化、在调用层做连接池与超时控制、在模型层做并发参数调优。这篇文章就从站长实际踩过的坑出发,把 Ollama 生产环境高并发调用实战拆成可落地的三个部分:架构流转、完整 API 调用代码、以及高并发调优建议。

一、架构流转:从单机 Ollama 到生产级推理网关

⚡ 【免费资源】DeepSeek/Ollama 部署排错手册 + 全套 AI 提示词资料包

站长已将大模型部署排错指南、常用环境配置文件及 AI 提效指令库整合分享至夸克网盘,可极速免费转存:

👉 点击前往夸克网盘一键免费转存全套资料包

站长先把最核心的认知说清楚:Ollama 默认的 HTTP 服务是单进程、单模型加载、请求串行或有限并行的。直接让业务代码去调 11434 端口,等于把并发压力全部压在推理进程上。生产环境必须做一层网关,把“调用方”和“推理引擎”解耦。

推荐的流转链路是这样的:业务服务 → API 网关(Nginx 或 OpenResty)→ Ollama 推理节点池 → GPU 资源。网关层负责限流、鉴权、请求排队、超时熔断和负载均衡;Ollama 侧则通过多实例部署来提升并发吞吐。站长通常会在同一台 GPU 机器上启动多个 Ollama 实例,每个实例绑定不同端口,并配合 CUDA_VISIBLE_DEVICES 做显存隔离,或者直接用多台推理节点组成集群。

请求进入网关后,网关根据模型名称和当前各节点的队列深度做加权轮询。如果某个节点返回 503 或响应时间超过阈值,网关自动将其摘除,等健康检查恢复后再重新加入。这样即使单个 Ollama 实例被大请求打满,也不会拖垮整个服务。对于流式输出场景,网关需要开启 proxy_buffering off,否则 SSE 数据会被缓冲,前端迟迟收不到 token。

另外,站长强烈建议在网关层做请求体大小限制和 prompt 长度校验。生产环境里经常有业务方传入超长上下文,直接把显存撑爆。网关提前拦截,比让 Ollama 崩溃后再恢复要划算得多。

二、完整 API 调用代码:带连接池、超时与重试的 Python 实战

🔥 【开发者算力福利】高并发 AI 部署 GPU / 独享云服务器限时特惠

本地算力不足或遇到 CUDA OOM 显存溢出?推荐搭配高性价比独享 GPU 云服务器:

👉 点击前往领取开发者限时优惠券

下面这段代码是站长在生产环境验证过的 Ollama API 调用封装。它使用 httpx 的异步客户端,配合连接池限制、超时控制和指数退避重试,适合在高并发场景下作为业务侧的统一调用入口。注意,这里调用的是网关地址,而不是直接调 Ollama 的 11434 端口。

import asyncio
import httpx
import json
from typing import AsyncGenerator, Optional

class OllamaGatewayClient:
    """
    Ollama 生产环境高并发调用封装
    - 连接池复用,避免频繁建连
    - 分阶段超时:连接超时、读超时、写超时、池等待超时
    - 指数退避重试,仅对可重试状态码生效
    - 支持流式与非流式两种调用模式
    """

    def __init__(
        self,
        base_url: str = "http://gateway.internal/ollama",
        max_connections: int = 200,
        max_keepalive: int = 50,
        connect_timeout: float = 3.0,
        read_timeout: float = 120.0,
        write_timeout: float = 10.0,
        pool_timeout: float = 5.0,
        max_retries: int = 2,
    ):
        self.base_url = base_url.rstrip("/")
        self.max_retries = max_retries
        timeout = httpx.Timeout(
            connect=connect_timeout,
            read=read_timeout,
            write=write_timeout,
            pool=pool_timeout,
        )
        limits = httpx.Limits(
            max_connections=max_connections,
            max_keepalive_connections=max_keepalive,
            keepalive_expiry=30.0,
        )
        self.client = httpx.AsyncClient(
            timeout=timeout,
            limits=limits,
            headers={"Content-Type": "application/json"},
        )

    async def close(self):
        await self.client.aclose()

    async def _post_with_retry(self, path: str, payload: dict) -> httpx.Response:
        last_exc: Optional[Exception] = None
        for attempt in range(self.max_retries + 1):
            try:
                resp = await self.client.post(
                    f"{self.base_url}{path}",
                    content=json.dumps(payload),
                )
                if resp.status_code in (429, 502, 503, 504):
                    if attempt < self.max_retries:
                        await asyncio.sleep(0.5 * (2 ** attempt))
                        continue
                resp.raise_for_status()
                return resp
            except (httpx.ConnectError, httpx.ReadTimeout, httpx.PoolTimeout) as e:
                last_exc = e
                if attempt < self.max_retries:
                    await asyncio.sleep(0.5 * (2 ** attempt))
                    continue
                raise
        raise last_exc  # type: ignore

    async def generate(
        self,
        model: str,
        prompt: str,
        system: str = "",
        temperature: float = 0.7,
        max_tokens: int = 2048,
        stream: bool = False,
    ) -> dict:
        """非流式调用,适合短文本、结构化输出场景"""
        payload = {
            "model": model,
            "prompt": prompt,
            "system": system,
            "stream": False,
            "options": {
                "temperature": temperature,
                "num_predict": max_tokens,
            },
        }
        resp = await self._post_with_retry("/api/generate", payload)
        return resp.json()

    async def generate_stream(
        self,
        model: str,
        prompt: str,
        system: str = "",
        temperature: float = 0.7,
        max_tokens: int = 2048,
    ) -> AsyncGenerator[str, None]:
        """流式调用,适合对话、长文本生成场景"""
        payload = {
            "model": model,
            "prompt": prompt,
            "system": system,
            "stream": True,
            "options": {
                "temperature": temperature,
                "num_predict": max_tokens,
            },
        }
        async with self.client.stream(
            "POST",
            f"{self.base_url}/api/generate",
            content=json.dumps(payload),
        ) as resp:
            resp.raise_for_status()
            async for line in resp.aiter_lines():
                if not line.strip():
                    continue
                try:
                    chunk = json.loads(line)
                except json.JSONDecodeError:
                    continue
                if "response" in chunk:
                    yield chunk["response"]
                if chunk.get("done"):
                    break


async def main():
    client = OllamaGatewayClient(
        base_url="http://gateway.internal/ollama",
        max_connections=200,
        max_keepalive=50,
        read_timeout=120.0,
        max_retries=2,
    )
    try:
        # 非流式示例
        result = await client.generate(
            model="qwen2.5:7b",
            prompt="用一句话说明生产环境高并发调用的核心原则。",
            temperature=0.3,
            max_tokens=128,
        )
        print("非流式结果:", result.get("response", "")[:200])

        # 流式示例
        print("流式结果:", end=" ")
        async for token in client.generate_stream(
            model="qwen2.5:7b",
            prompt="列出三条 Ollama 并发调优建议。",
            max_tokens=256,
        ):
            print(token, end="", flush=True)
        print()
    finally:
        await client.close()


if __name__ == "__main__":
    asyncio.run(main())

这段代码的关键点在于:连接池大小要和网关的 worker 数量匹配,不能无限放大;读超时要根据模型最大生成长度设置,太短会误杀长请求,太长会占满连接;重试只针对 429、502、503、504 这类可恢复错误,业务逻辑错误不重试。站长在实际压测中发现,把连接池控制在 200 以内、keepalive 控制在 50 左右,配合网关的排队机制,整体吞吐比无限制建连高出三到四成。

三、高并发调优建议:从 Ollama 参数到系统层

💡 关联延伸阅读:如果你在配置过程中遇到相关报错,请参阅站长之前的解决教程:Ollama CUDA OOM 显存溢出参数调优配置实战避坑指南:手把手步骤拆解

第一,调整 Ollama 的并发参数。Ollama 支持通过环境变量 OLLAMA_NUM_PARALLEL 控制单个模型同时处理的请求数,默认值通常偏低。站长建议根据显存大小逐步上调,比如 24G 显存跑 7B 模型,可以尝试设为 4 到 8。同时设置 OLLAMA_MAX_LOADED_MODELS,避免多个模型同时加载导致显存碎片化。注意,这两个参数不是越大越好,超过显存承载能力会触发频繁换页,反而降低吞吐。

第二,控制上下文长度和生成长度。生产环境最怕无限制的 num_ctx 和 num_predict。站长通常会在网关层强制限制 prompt 字符数,并在调用参数里显式设置 num_ctx 和 num_predict 上限。对于摘要、分类这类任务,把 num_predict 压到 256 以内,单请求耗时能下降一半以上。

第三,使用多实例加负载均衡。单机单实例的 Ollama 并发能力有限,站长推荐在同一台机器上按 GPU 拆分多个实例,每个实例绑定不同端口和不同 GPU。网关层用 upstream 配置多个后端,并开启健康检查。如果有多台推理机器,直接做集群,网关按权重分发。

第四,开启 keep-alive 并复用连接。Ollama 的 HTTP 服务支持长连接,业务侧必须用连接池,否则每次请求都经历 TCP 握手和 TLS 握手,高并发下光建连就消耗大量 CPU。网关到 Ollama 这一段也要开启 upstream keepalive,减少端口耗尽风险。

第五,做好超时分级和熔断。连接超时设短,读超时设长,池等待超时设中等。网关层配置熔断阈值,比如某个节点连续 10 次 503 就摘除 30 秒。业务侧捕获超时后走降级逻辑,比如返回缓存结果或切换小模型。

第六,监控显存、队列深度和 P99 延迟。站长会重点看三个指标:GPU 显存利用率、Ollama 请求队列长度、以及网关侧 P99 响应时间。显存持续高于 90% 说明并发参数过大;队列长度持续增长说明推理节点不够;P99 突然飙升往往是长 prompt 或大 max_tokens 请求混入。把这些指标接入告警,比事后排查有效得多。

最后,站长提醒一句:Ollama 生产环境高并发调用实战的核心不是把参数调到极限,而是让系统在可控范围内稳定运行。网关化、连接池、超时重试、多实例负载均衡,这四件事做到位,Ollama 完全可以在生产环境扛住可观的并发量。剩下的就是根据业务流量持续压测和微调,找到属于自己场景的最佳平衡点。

站长推荐
⚡ 开发者实操必备资源与算力限时特惠通道

阅读完本教程准备实操?站长已将 AI 部署排错手册、提示词全集与服务器限时优惠整理如下,即拿即用:

滚动至顶部