Newshot

在 Kubernetes 中将开放权重 LLM 部署为 API

Translation(model translation, not the source's own text)

文章标题:在 Kubernetes 中将开放权重 LLM 部署为 API

正文: 开放权重模型的能力越来越强,许多组织都在考虑是否应该自行部署和管理这类模型。

今年早些时候,IBM 的 CEO 表示,开放权重模型已经接近闭源模型的水平,而成本只是后者的一小部分。

如果你希望数据保留在公司内部,运行自己的模型也是合理的选择。

本文的目的是弄清楚将开放权重模型部署在 API 后面需要哪些工作。我将使用 Kubernetes 来管理部署和扩缩容。模型部署完成后,我会用 Pi 编程代理来测试模型的编程能力和速度。

硬件

这个项目运行在我自己的 GPU 家庭实验室上,系统是 Ubuntu Server。机器配备一张 RTX 2060,拥有 6 GB 显存。按今天的标准这卡相当老旧,但足以运行一些较小的模型。其余配置为 Ryzen 5 3600(12 线程)和 15 GB 内存。

供参考,RTX 2060 与 AWS g4dn.xlarge 中的 T4 属于同一代,后者按需价格约为 $0.53/小时,如果一直运行(单实例)大约每月 $380。不过 T4 有 16 GB 显存,因此能容纳比我这张卡更大的模型。

显卡的显存是限制模型大小的因素。而且我只有一块 GPU,这意味着我无法扩展到多个实例。在生产环境中,需要扩缩容时会有多个节点可用。

模型

模型方面,我使用 Qwen3.5,40 亿参数,量化为 4 位(Q4_K_M)。这是一个小型模型,能够编写代码和使用工具,适合内部部署给软件工程师配合 Pi 这类编程代理使用。

选择这个模型的原因是它刚好能塞进我显卡的显存。模型文件约 2.7 GB,会加载到 6 GB 显存中。剩余的显存需要用于 KV cache,它保存上下文,是让响应变快的关键。(我在之前的一篇文章中写过 KV 缓存的工作原理。)

再大一号的是 90 亿参数模型,在未计入 KV cache 所需内存之前就已经占约 5.7 GB。那样就没有空间留给上下文,在我的卡上无法使用。

内存分配
内存分配

我的 6GB 显存 GPU 的内存分配

部署

模型作为集中式 API 服务部署在 Kubernetes 中。用户(我)通过 URL 和 API key 调用它,用该模型完成编程任务。

我在家庭实验室中使用 K3s,这是 Kubernetes 的轻量版本。部署包含一个 Deployment、一个 ConfigMap、一个 Secret、一个 Service 和一个 HPA(Horizontal Pod Autoscaler),外加一个 PersistentVolumeClaim,用于在重启之间保留模型文件。

kubernetes 示意图
kubernetes 示意图

本次部署中的 Kubernetes 资源

Deployment 定义了 Pod 使用的镜像、存储和配置。在容器层面,你定义 Pod 运行哪个镜像,以及加载哪些环境变量和配置。镜像方面我使用 llama.cpp 的 llama-server(ghcr.io/ggml-org/llama.cpp:server-cuda),这是一个可直接使用的开放权重模型 HTTP 服务器。每个 Pod 请求一块 GPU(nvidia.com/gpu: 1),模型在启动时下载到挂载在 /models 的卷中。

在 Kubernetes 中将开放权重 LLM 部署为 API


        apiVersion: apps/v1
kind: Deployment
metadata:
  name: llm
  namespace: llm
  labels:
    app: llm
spec:
  strategy:
    type: Recreate           # one GPU: old pod must release it before the new one starts
  selector:
    matchLabels:
      app: llm
  template:
    metadata:
      labels:
        app: llm
    spec:
      runtimeClassName: nvidia   # k3s-specific: use the NVIDIA container runtime
      nodeSelector:
        homelab/gpu: "true"      # only schedule on GPU nodes
      tolerations:               # allowed onto the GPU node once it's tainted
        - key: homelab/gpu
          operator: Exists
          effect: NoSchedule
      containers:
        - name: llama-server
          image: ghcr.io/ggml-org/llama.cpp:server-cuda
          envFrom:
            - configMapRef:
                name: llm-config
            - secretRef:
                name: llm-secrets
          env:
            - name: LLAMA_CACHE
              value: /models
            - name: LLAMA_ARG_HOST
              value: 0.0.0.0
            - name: LLAMA_ARG_PORT
              value: "8080"
          ports:
            - name: http
              containerPort: 8080
          resources:
            requests:
              cpu: "1"             # HPA % is measured against this
              memory: 2Gi
            limits:
              memory: 4Gi
              nvidia.com/gpu: 1    # schedule only where a GPU is free
          volumeMounts:
            - name: models
              mountPath: /models
          # /health returns 503 while the model loads, 200 when ready.
          startupProbe:            # allow up to 15 min for first download + load
            httpGet: { path: /health, port: http }
            periodSeconds: 10
            failureThreshold: 90
          readinessProbe:          # only receive traffic when ready
            httpGet: { path: /health, port: http }
            periodSeconds: 10
          livenessProbe:           # restart if it hangs
            httpGet: { path: /health, port: http }
            periodSeconds: 30
            timeoutSeconds: 5
            failureThreshold: 3
      volumes:
        - name: models
          persistentVolumeClaim:
            claimName: llm-models
      

首次部署时,节点需要拉取镜像并下载模型。2.6 GB 的镜像下载花了约 10 分钟。随后,容器启动后,llama-server 会下载模型,又花了将近 13 分钟。这就是为什么启动探针第一次需要充裕的时间预算。

Deployment 与一个 Service 配合使用,这个 Service 是我们用来与 Pod 通信的接口。Service 为我们提供单个 IP 和端口,并在运行 LLM 的多个 Pod 之间做基本负载均衡。在 K3s 中,类型为 LoadBalancer 的 Service 会暴露在节点的 IP 上,因此该 API 可通过我的家庭网络在 192.168.1.149:8080 访问。


        apiVersion: v1
kind: Service
metadata:
  name: llm
  namespace: llm
spec:
  type: LoadBalancer
  selector:
    app: llm
  ports:
    - name: http
      port: 8080
      targetPort: http
      

环境变量从 ConfigMap 加载。模型参数就在这里:使用哪个模型、上下文大小、卸载多少 GPU 层等等。llama-server 会把任何 LLAMA_ARG_* 环境变量读取为命令行参数,因此整个模型配置都在一个文件中。这是初始设置,使用 Qwen3.5 4B 模型,上下文大小为 32,768 个 token:


        # apps/llm/config/model.env
LLAMA_ARG_HF_REPO=unsloth/Qwen3.5-4B-GGUF:Q4_K_M
# The model "id" clients (Pi) ask for
LLAMA_ARG_ALIAS=qwen3.5-4b
# Total context, split across slots (32768 / 2 = 16384 per request)
LLAMA_ARG_CTX_SIZE=32768
# Concurrent request slots
LLAMA_ARG_N_PARALLEL=2
# Offload all layers to the GPU
LLAMA_ARG_N_GPU_LAYERS=99
# Use the model's chat template (needed for tool calls)
LLAMA_ARG_JINJA=true
# Expose Prometheus metrics at /metrics
LLAMA_ARG_ENDPOINT_METRICS=true
      

在 Kubernetes 中将开放权重 LLM 部署为 API

另一个有趣的设置是 LLAMA_ARG_N_PARALLEL,它定义模型可以并行处理多少个请求。超过该数量的任何并发请求都要等待较早的请求完成。上下文也会在各个槽位之间划分,因此每个槽位获得总上下文大小的一部分:有 2 个槽位时,每个请求获得 16,384 个 token。根据你的规格,你可以调整这个值来满足需求。由于这也是设置每个 pod 并发用户数的因素,你会通过压力测试来调优,找到实例可承受的最大并发数的最佳值,并基于此设置自动扩缩容。

下一部分是水平自动扩缩容。我已将其设置为:如果 CPU 使用率超过 70%(占 pod 请求的 1 个 CPU 的 70%),就最多扩容到 2 个实例。但这没有意义,原因有两个。


        apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: llm
  namespace: llm
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: llm
  minReplicas: 1
  maxReplicas: 2
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 180   # ignore the CPU spike while the model loads
    scaleDown:
      stabilizationWindowSeconds: 300   # avoid flapping; model loads are slow
      

首先,CPU 使用率不是要跟踪的正确指标。更好的指标会是 GPU 内存使用量或排队请求数。然而,开箱即用时,HPA 只能基于 CPU 和内存(RAM,不是 GPU 内存)进行扩缩容。要跟踪这些更有用的指标,我们可以改用 KEDA,但出于下一个原因,这不在本项目范围内。

其次,我只有一个 GPU。即使自动扩缩容触发(它确实会触发),新 pod 也无法启动,因为没有更多可用的 GPU,所以它会停留在 Pending 状态。在首次部署时,加载模型带来的 CPU 峰值足以触发它:HPA 扩容到 2 个副本,并在六分钟后缩回 1 个。我设置 HPA 是为了演示目的,并检查它在这些设置下确实能工作。

k9s 显示两个 llm pod:一个运行在其 CPU 请求的 100%,另一个副本卡在 Pending
k9s 显示两个 llm pod:一个运行在其 CPU 请求的 100%,另一个副本卡在 Pending

HPA 正在生效:运行中的 pod 达到其 1 个 CPU 请求的 100%,因此创建了第二个副本。由于没有第二个 GPU,它停留在 Pending 状态。

关于自动扩缩容需要注意的一点是,K,V 缓存是在 pod 级别维护的。如果你发起一个请求,它进入一个 pod,但下一个请求进入不同的 pod,你就会丢失 K,V 缓存,下一次响应会非常慢。在编码代理的上下文中,这很重要。你可以为此使用不同的方法,我将在本文中不讨论,例如按 IP 或会话 ID 的粘性会话,或使用共享缓存。

最后是 Secret,它保存调用 API 所需的 API 密钥。正如所有使用 Kubernetes 的人所知,secret 并不是真正的秘密:值只是经过 base64 编码。在生产环境中,最好改为从密钥保险库加载你的 secret。


        apiVersion: v1
kind: Secret
metadata:
  name: llm-secrets
  namespace: llm
type: Opaque
data:
  LLAMA_API_KEY: <base64-encoded API key>
      

模型部署完成后,我们可以使用家庭实验室的 IP 和端口调用 API:


        export LLM=http://192.168.1.149:8080
curl $LLM/health
# {"status":"ok"}
      

测试 API

在设置编码代理之前,我们可以直接调用 API 来测试模型:


        curl -s $LLM/v1/chat/completions \
  -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" \
  -d '{"model":"qwen3.5-4b","messages":[{"role":"user","content":"Write a Python function that reverses a string."}]}' \
  | python3 -m json.tool
      
第一次 chat completion 请求返回的 JSON 响应,包含模型的回答、其推理过程、token 用量和耗时
第一次 chat completion 请求返回的 JSON 响应,包含模型的回答、其推理过程、token 用量和耗时

对模型的第一次请求。它耗时 1 分 10 秒,其中 61 秒花在处理一个 20 token 的 prompt 上。

该 API 返回一个遵循 OpenAI API 标准的 JSON 对象。除了 message.content 中的回答之外,它还会返回:

  • reasoning_content:Qwen3.5 是一个思考模型,这里是它在作答之前的推理内容。
  • usage:prompt 和 completion 的 token 数。这里是输入 20 个 token,输出 708 个 token。
  • timings:llama.cpp 的额外字段,包含每一步的速度。模型生成速度约为 80 token/秒,而且每次请求都稳定保持这个速度。

第一次请求会遇到冷启动,通常光处理 prompt 就要花整整一分钟。之后的每次请求处理 prompt 都远不到一秒,所以这是模型加载之后的一次性开销。

我们还可以通过加上 "stream": true 以流式方式调用该 API。这种方式实用得多,因为我们不必等完整答案就绪。我们可以边生成边读取,就像我们在各类 LLM 应用里早已习惯的那样。


        curl -N $LLM/v1/chat/completions \
  -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" \
  -d '{"model":"qwen3.5-4b","stream":true,"messages":[{"role":"user","content":"Count to 10"}]}'
      

流式输出:响应以 server-sent events 的形式到达,每个 token 一个 chunk。最后一个 chunk 携带 timings,之后是 data: [DONE]。

可以看到,响应被拆成许多小块,每个 token 一块:"6"、","、" "、"7"。最后一块带有 finish_reason: "stop" 和 timings,随后流以 data: [DONE] 结束。

有一点值得了解:该 API 是无状态的。再次调用它不会记得之前的对话,除非我们在下一次调用中把它再次发送过去。这就是为什么对话越长上下文越大:每次请求都携带全部历史。


        {"model": "qwen3.5-4b", "messages": [
  {"role": "user", "content": "Count to 10"},
  {"role": "assistant", "content": "1, 2, 3, 4, 5, 6, 7, 8, 9, 10"},
  {"role": "user", "content": "Now count backwards"}
]}
      

每次都重发全部历史听起来代价很高,但服务器会保留 prompt 缓存。如果 prompt 的开头与它已经处理过的内容匹配,它就只处理新增的 token。

在我们的场景里,不必操心历史记录的管理,因为编码 agent 会替我们处理。

编码 agent 依赖的 API 最后一块是 tool calling。模型本身从不执行任何东西。agent 在每次请求中发送一份它可用的工具列表(名称、描述以及参数的 JSON schema),模型则用一个结构化的请求来回复,要求调用其中某个工具:


        "finish_reason": "tool_calls",
"message": {
    "content": "",
    "tool_calls": [{
        "type": "function",
        "function": {"name": "read_file", "arguments": "{\"path\":\"main.py\"}"}
    }]
}
      

agent 执行该工具,在下一次请求中把结果发回去,如此循环,直到模型用纯文本作答。注意,工具定义也计入 prompt:只挂一个工具问“What is in the file main.py?”,prompt 就已经有 273 个 token 了。

在编码 agent 中使用该模型

为了让这个模型派上用场,我会使用 Pi 编码 agent。Pi 是一个开源编码 agent,类似 Codex 或 Claude Code;由于我们的 API 遵循 OpenAI 标准,它可以连接到该 API 来处理我们的编码任务。

为了让这更接近真实的生产环境,我把 Pi 装在自己的笔记本电脑上,而不是装在运行模型的机器上。这就等同于你把模型部署在 EC2 上、而从本地机器运行 agent。

Pi 安装完成后,把模型添加到 ~/.pi/agent/models.json:

文章标题:在 Kubernetes 中将开放权重 LLM 部署为 API

正文:


        {
  "providers": {
    "homelab": {
      "baseUrl": "http://192.168.1.149:8080/v1",
      "api": "openai-completions",
      "apiKey": "LLM_KEY",
      "models": [
        { "id": "qwen3.5-4b", "contextWindow": 32768, "maxTokens": 8192 }
      ]
    }
  }
}
      

contextWindow 告诉 Pi 何时压缩对话,因此我将其设置为与服务器匹配。apiKey 是保存密钥的环境变量的名称,所以别忘了设置它。为确保环境变量自动加载,请将其添加到你的 ~/.bashrc 或 ~/.zshrc:


        export LLM_KEY=...
      

然后我们就可以运行 Pi,如果一切顺利,我们会看到模型已加载。我们可以开始用它来完成编码任务。在这个示例中,我让它构建一个简单的“hello world”网页。

图表:我笔记本电脑上的 Pi,使用的是家庭实验室提供的模型。

我笔记本电脑上的 Pi,使用的是家庭实验室提供的模型。

当 Pi 工作时,GPU 会满负荷运行。每个智能体轮次都让 GPU 保持在 97% 的利用率和 160 W 中的 158 W,持续约 45 秒。

Pi 工作时的 nvtop:RTX 2060 利用率 97%,功耗 158/160 W
Pi 工作时的 nvtop:RTX 2060 利用率 97%,功耗 158/160 W

nvtop 中一次 Pi 请求:97% 的 GPU 利用率和 158 W,即该卡的功耗上限。

测试性能

当我刚开始使用这个模型时,我的会话在几次提示后就中断了。编码智能体需要足够大的上下文,而如果一个模型只允许少数几次提示就报错,那它就不太有用。

一个 Pi 会话:模型修复了一个 bug,然后因连接错误失败,并反复出现“Response was truncated before completion”消息,状态栏显示已使用 16k 的 72.2%
一个 Pi 会话:模型修复了一个 bug,然后因连接错误失败,并反复出现“Response was truncated before completion”消息,状态栏显示已使用 16k 的 72.2%

几次提示后的 Pi:出现连接错误,随后每个响应都被截断。左下角的状态栏显示已使用 16k 上下文的 72.2%。

这里有两个问题。连接错误来自 Pod 在会话中途重启,很可能是因为内存不足。

响应被截断是上下文问题。上下文还没有满,但没有足够的空间让模型完成回答。

当我检查设置时,我发现了上下文为什么这么小。总上下文大小只有 32,768 个 token,而 LLAMA_ARG_N_PARALLEL 被设置为 2,这将上下文在两个槽之间平分。因此每个请求只得到 16,384 个 token。

16k token 听起来很多:大约 12,000 个单词。但编码智能体会很快耗尽它。系统提示和工具定义会出现在每个请求中,模型读取的每个文件和每条命令输出也是如此。在一次会话中,上下文在几分钟内从约 6,000 个 token 翻倍到 12,000 个 token,而服务器日志显示所有请求都发往槽 0。槽 1 从未被使用。

实际上,在 n 个并行运行之间拆分上下文大小是一种你不想要的权衡。你希望能够以共享的 K,V 缓存运行 n_parallel 个运行,从而充分利用上下文大小。为此,你可以设置并行运行的数量,并使用 LLAMA_ARG_KV_UNIFIED=True 环境变量。

Qwen3.5 支持最多 262K token 的上下文,但由于上下文作为 KV 缓存保存在内存中,我受限于我拥有的 VRAM 容量。llama.cpp 在实例启动时会预留它需要的所有内存,因此我可以使用 nvtop 检查模型需要多少内存。使用的内存是模型大小 + 完整上下文的 KV 缓存 + 一些计算缓冲区。一旦加载完成,它不会增长:更长的对话会变得更慢,而不是更大。

这是我初始设置(2 个槽,32,768 个 token 上下文)下的 nvtop:

模型已加载并空闲时的 nvtop:0% GPU 利用率,10 W,llama-server 占用 4800 MiB GPU 内存
模型已加载并空闲时的 nvtop:0% GPU 利用率,10 W,llama-server 占用 4800 MiB GPU 内存

初始设置,空闲状态:llama-server 即使无人使用也占用 6 GB 中的 4.8 GB,而功耗仅为 10 W。

在 Kubernetes 中将开放权重 LLM 部署为 API

由于我是唯一用户,我把 LLAMA_ARG_N_PARALLEL 设为 1,这会给出一个具有完整上下文大小的槽位,并把 Pi 的上下文窗口匹配到它。Pi 的上下文从 16k 增加到 33k,会话恢复了。我也可以使用 LLAMA_ARG_N_PARALLEL=auto 来自动启用共享的 K,V 缓存。但我更喜欢明确指定。

改动后的同一个 Pi 会话,状态栏显示 33k 的 36.1%,模型正在重写文件
改动后的同一个 Pi 会话,状态栏显示 33k 的 36.1%,模型正在重写文件

设置 LLAMA_ARG_N_PARALLEL=1 后的同一个会话:上下文从 16k 变为 33k,模型重新开始工作。

32k 的上下文对编码代理来说仍然很小,而我的内存使用量已经非常接近上限。我接下来做的是把 KV 缓存存为 8 位(q8_0),而不是默认的 16 位(f16),并开启 flash attention。这大致将每个上下文 token 的内存占用减半,所以我可以把上下文大小翻倍到 65,536,然后再推到 81,920。


        ## Optimising context
LLAMA_ARG_CTX_SIZE=81920
LLAMA_ARG_N_PARALLEL=1
LLAMA_ARG_FLASH_ATTN=on
LLAMA_ARG_CACHE_TYPE_K=q8_0
LLAMA_ARG_CACHE_TYPE_V=q8_0
      

当我重新部署 Pod 时,我的改动没有显示出来。我犯了一个新手错误:在没确认 ConfigMap 已更新的情况下重启了 Pod。结果集群中的 ConfigMap 仍然是旧设置,服务器日志仍然显示 2 个各 16k 的槽位。我已经数不清同样的问题以前在我身上发生过多少次了。

终端显示集群中的 ConfigMap 为 CTX_SIZE 32768 和 N_PARALLEL 2,model.env 文件为 CTX_SIZE 81920 和 N_PARALLEL 1,服务器日志显示 n_slots = 2 且 n_ctx_slot = 16384
终端显示集群中的 ConfigMap 为 CTX_SIZE 32768 和 N_PARALLEL 2,model.env 文件为 CTX_SIZE 81920 和 N_PARALLEL 1,服务器日志显示 n_slots = 2 且 n_ctx_slot = 16384

集群中的 ConfigMap(上)与仓库中的 model.env(中)不匹配,服务器日志(下)确认 Pod 仍在运行 2 个 16,384 token 的槽位。

新配置真正生效后,nvtop 显示它仍然能放进内存,还有约 280 MB 余量:

nvtop 中上下文大小为 81,920 token:llama-server 占用 5454 MiB,显卡使用量为 6 GB 中的 5.726
nvtop 中上下文大小为 81,920 token:llama-server 占用 5454 MiB,显卡使用量为 6 GB 中的 5.726

使用 8 位 KV 缓存的 81,920 token 上下文:6 GB 中使用了 5.7 GB。

配置每次请求的上下文GPU 内存
总计 32,768,2 个槽位,16 位 KV cache16,3845.1 GB
总计 81,920,1 个槽位,8 位 KV cache81,9205.7 GB

多花 0.6 GB 内存,每个请求获得的上下文就是 5 倍。

当我在笔记本电脑上用新配置运行 Pi 时,可以在屏幕左下角看到更大的上下文大小,这让模型有用得多。

![Pi 的状态栏显示已

并发数等于槽位 × 副本数。每个 Pod 一次可以服务 N_PARALLEL 个请求,超过这个数量的请求会排队。但上下文会在槽位之间拆分,所以在同一块 GPU 上,每个 Pod 支持的用户越多,每个用户分到的上下文就越少。对于需要大量上下文的编码智能体来说,在多次运行之间使用共享缓存来最大化可用上下文大小是有益的。

扩缩容依据排队请求,而不是 CPU。llama-server 已经在 /metrics 暴露 Prometheus 指标,包括正在处理的请求数和等待中的请求数。这才是用于自动扩缩容的信号,可以配合 KEDA 之类的工具。CPU 几乎说明不了什么:在我的环境里,它唯一飙升的时候就是加载模型时。

扩容很慢。全新节点上的新 Pod 需要先拉取 2.6 GB 的镜像并下载模型,然后才能处理哪怕一个请求。在我第一次部署时,这花了 20 多分钟。在生产环境中,你会希望镜像已预拉取、模型放在共享存储上,这样新副本只需要把模型加载到内存中。

空闲副本仍然占用一整块 GPU 的成本。内存在启动时就被预留,因此无论有没有人使用,空闲副本都会占着它的 GPU。在 AWS 上,每个在 g4dn.xlarge 上 24/7 运行的副本大约 $380/month。应根据实际使用情况(每秒请求数、并发用户数)来确定副本数量,而不只是根据内存分配。

监控与访问。你会希望跟踪排队请求数、首 token 时间、每秒 token 数和 GPU 内存,并在 API 前面放一个网关,用于按用户提供密钥和限流。

从这个项目中学到的经验

总的来说,我受限于自己的硬件。只有 6 GB 显存,我其实无法部署一个对编码很有用的 LLM。开始这个项目时,我想了解把一个开放权重模型部署到 API 后面需要什么。我发现这其实是容易的部分。

和生产环境中的大多数系统一样,棘手的部分是调好节点规格、模型大小、上下文大小、实例数量和自动扩缩容,让系统为用户平稳高效地运行。这只能通过在实际使用中测试这些模型,并对资源使用情况和 SLA(例如是否有排队请求?)进行良好监控来实现,从而让我们有足够洞察随时间改进部署。

尽管我没能尝试更大、能力更强的模型,但我已经能看到,如果使用得当,开放模型在解决许多编码任务方面有多强。它们不如 OpenAI 或 Anthropic 的前沿模型,但对许多日常任务来说可能并不需要那种水平。

关于作者:我是 Pablo Lopez Santori,一名常驻英国爱丁堡的资深数据平台与 AI 工程师。我在生产环境中构建可扩展的分布式平台和 AI 系统,从数据基础设施到应用 AI。如果你有我能帮忙解决的问题,我可以接合同工作,主要是远程,也愿意接受爱丁堡的混合办公。

联系我:邮箱 · LinkedIn · GitHub

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by HN AI
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗