Golang读取运行中Docker容器日志失败问题排查与修复

你代码里的types.ContainerLogsOptions设置了Follow: true，这个参数的作用是让Docker API持续保持连接，等待容器的新日志输出。

对于已退出的容器，没有新日志产生，API会在返回所有历史日志后主动断开连接，触发io.EOF，函数正常返回。但运行中的容器会一直维持连接，reader.Read(hdr)会持续阻塞等待新日志，导致程序卡住。

根据你的业务需求选择对应修复方式：

方式一：仅获取指定时间范围的历史日志（直接解决卡住问题） #

把Follow设为false，Docker API会一次性返回Since到Until区间内的所有日志，随后关闭连接，不会产生阻塞：

options := types.ContainerLogsOptions{
    ShowStdout: true,
    ShowStderr: true,
    Since:      since,
    Until:      until,
    Timestamps: true,
    Follow:     false, // 修改为false
    Tail:       "",
    Details:    false,
}

方式二：支持可选的实时日志跟踪（如果需要监控实时日志） #

如果需要同时支持获取历史日志和实时跟踪，可以给函数增加follow参数让调用方控制模式，同时添加上下文超时或读取超时避免永久阻塞：

import (
    "context"
    "errors"
    "io"
    "os"
    "strings"
    "time"

    "github.com/docker/docker/api/types"
)

func ReadContainerLogs(containerID string, since string, until string, follow bool) (ContainerLog, error) {
    dockerLogs := ContainerLog{ContainerID: containerID}

    options := types.ContainerLogsOptions{
        ShowStdout: true,
        ShowStderr: true,
        Since:      since,
        Until:      until,
        Timestamps: true,
        Follow:     follow, // 由外部参数控制跟踪模式
        Tail:       "",
        Details:    false,
    }

    ctx := context.Background()
    // 跟踪模式下添加上下文超时，避免无限阻塞
    if follow {
        var cancel context.CancelFunc
        ctx, cancel = context.WithTimeout(ctx, 5*time.Minute)
        defer cancel()
    }

    reader, err := dockerClient.ContainerLogs(ctx, containerID, options)
    if err != nil {
        return dockerLogs, err
    }
    defer reader.Close()

    hdr := make([]byte, 8)
    for {
        select {
        case <-ctx.Done():
            // 超时或上下文取消时，返回已收集的日志
            return dockerLogs, ctx.Err()
        default:
            // 设置读取超时，避免在无新日志时一直阻塞
            if follow {
                _ = reader.SetReadDeadline(time.Now().Add(1 * time.Second))
            }

            _, err := reader.Read(hdr)
            if err != nil {
                if err == io.EOF {
                    return dockerLogs, nil
                }
                // 跟踪模式下的读取超时不算错误，继续等待新日志
                if errors.Is(err, os.ErrDeadlineExceeded) && follow {
                    continue
                }
                return dockerLogs, err
            }

            count := binary.BigEndian.Uint32(hdr[4:])
            dat := make([]byte, count)
            _, err = reader.Read(dat)
            if err != nil && err != io.EOF {
                return dockerLogs, err
            }

            timeStr, log, found := strings.Cut(string(dat), " ")
            if found {
                docLog := DockerLog{
                    Time:   timeStr,
                    Log:    log,
                    Stream: func() string {
                        if hdr[0] == 1 {
                            return "Stdout"
                        }
                        return "Stderr"
                    }(),
                }
                dockerLogs.DockerLogs = append(dockerLogs.DockerLogs, docLog)
            }
        }
    }
}

• Docker日志流是分帧格式，每帧开头8字节为头部（1字节流类型+3字节保留位+4字节数据长度），你代码里的头部处理逻辑是正确的。
• 开启Follow模式时，必须明确连接的生命周期，要么通过上下文控制超时/取消，要么由调用方传入可取消的上下文。

内容的提问来源于stack exchange，提问作者Shri