绝了！k3s (k8s) 安装 ollama 运行 deepseek 全流程揭秘，yaml全公开

# https://cloud.tencent.com/developer/article/2495842 环境变量

apiVersion:apps/v1
kind:Deployment
metadata:
labels:
    app:ollama
name:ollama
namespace:moonfdd
spec:
strategy:
    type:Recreate
replicas:1
selector:
    matchLabels:
      app:ollama
template:
    metadata:
      labels:
        app:ollama
    spec:
      containers:
        -env:
            -name:OLLAMA_HOST
              value:"0.0.0.0"
            -name:OLLAMA_PORT
              value:"11434"
            -name:OLLAMA_NUM_PARALLEL
              value:"20"#默认是1
            -name:OLLAMA_ORIGINS
              value:"*"
            -name:OLLAMA_MODELS
              value:"/root/.ollama/models"
          image:'ollama/ollama:0.5.12'
          command: ["ollama", "serve"]
          imagePullPolicy:IfNotPresent
          name:ollama
          volumeMounts:
            -mountPath:/root/.ollama/models/
              name:data
          resources:
            # nvidia.com/gpu: 1
            # memory: "24Gi"
            # limits:
            #   cpu: 200m
            #   memory: 200Mi
            # requests:
            #   cpu: 100m
            #   memory: 100Mi
        -image:'ollama/ollama:0.5.12'
          command: ["sh", "-c", "while true; do ollama run deepseek-r1:1.5b; sleep 5; done"]
          imagePullPolicy:IfNotPresent
          name:ollamacmd
      volumes:
        -name:data
          hostPath:
            path:/root/k8s/moonfdd/ollama/root/.ollama/models/
            type:DirectoryOrCreate
---
apiVersion:v1
kind:Service
metadata:
labels:
    app:ollama
name:ollama
namespace:moonfdd
spec:
ports:
    -name:11434-11434
      port:11434
      protocol:TCP
      targetPort:11434
      nodePort:11434
selector:
    app:ollama
type: NodePort

kubectl apply -f ollama.yaml

package main

import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type Message struct {
    Role    string`json:"role"`
    Content string`json:"content"`
}

// 修改请求结构体，添加 Stream 字段
type DeepSeekRequest struct {
    Model       string    `json:"model"`
    Messages    []Message `json:"messages"`
    MaxTokens   int       `json:"max_tokens,omitempty"`
    Temperature float64   `json:"temperature,omitempty"`
    Stream      bool      `json:"stream"`// 新增流式控制字段
}

// 保持其他结构体不变...

const (
    localAPIURL = "http://172.16.11.111:11434/v1/chat/completions"
)

func main() {
    fmt.Println("开始")
    requestData := DeepSeekRequest{
        Model: "deepseek-r1:1.5b",
        Messages: []Message{
            {
                Role:    "user",
                Content: "微信公众号 福大大架构师每日一题 是谁",
            },
        },
        MaxTokens:   512000,
        Temperature: 1,
        Stream:      true, // 启用流式模式
    }

    requestBody, err := json.Marshal(requestData)
    if err != nil {
        panic("JSON编码失败: " + err.Error())
    }

    // 配置更合理的超时时间
    client := &http.Client{
        Transport: &http.Transport{
            DisableKeepAlives: true, // 🔴 关键设置：禁用连接复用
            MaxIdleConns:      1,
            IdleConnTimeout:   30 * time.Second,
        },
        Timeout: 10 * time.Minute, // 大模型响应时间较长
    }

    req, err := http.NewRequest("POST", localAPIURL, bytes.NewBuffer(requestBody))
    if err != nil {
        panic("创建请求失败: " + err.Error())
    }
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Connection", "close") // 显式关闭连接
    req.Close = true
    resp, err := client.Do(req)
    if err != nil {
        panic("请求发送失败: " + err.Error())
    }
    defer resp.Body.Close()

    // 流式响应处理
    if resp.StatusCode != http.StatusOK {
        fmt.Printf("请求失败，状态码：%d\n", resp.StatusCode)
        return
    }

    // 使用 Scanner 逐行读取流式响应
    scanner := bufio.NewScanner(resp.Body)
    scanner.Buffer(make([]byte, 1024), 10*1024*1024) // 扩大缓冲区

    for scanner.Scan() {
        rawData := scanner.Bytes()
        iflen(rawData) == 0 {
            continue
        }

        var chunk DeepSeekChunk
        err := json.Unmarshal(rawData[6:], &chunk)
        if err == nil {
            for i := 0; i < len(chunk.Choices); i++ {
                fmt.Print(chunk.Choices[i].Delta.Content)
            }
        } else {
            ifstring(rawData) == string("data: [DONE]") {

            } else {
                fmt.Println("\r\n接收失败：", err, string(rawData))
            }
            return
        }

    }

    // if err := scanner.Err(); err != nil {
    //     fmt.Printf("\n流读取错误: %v\n", err)
    // }
}

// DeepSeekChunk 定义与提供的JSON结构相对应的结构体
type DeepSeekChunk struct {
    ID                string   `json:"id"`
    Object            string   `json:"object"`
    Created           int64    `json:"created"`
    Model             string   `json:"model"`
    SystemFingerprint string   `json:"system_fingerprint"`
    Choices           []Choice `json:"choices"`
}

type Choice struct {
    Index        int     `json:"index"`
    Delta        Delta   `json:"delta"`
    FinishReason *string`json:"finish_reason,omitempty"`// 使用指针以处理可能为null的情况 //null "stop"
}

type Delta struct {
    Role    string`json:"role"`
    Content string`json:"content"`
}