使用Golang管理docker-compose的最佳实践

在Go语言中，虽然没有直接等同于Node.js docker-compose包的官方库，但可以通过以下几种方式管理Docker Compose：

1. 使用os/exec调用命令行

最直接的方式是通过Go执行docker-compose命令：

package main

import (
    "bytes"
    "fmt"
    "log"
    "os/exec"
    "path/filepath"
)

type DockerCompose struct {
    ProjectDir string
}

func NewDockerCompose(projectDir string) *DockerCompose {
    return &DockerCompose{
        ProjectDir: projectDir,
    }
}

func (dc *DockerCompose) executeCommand(args ...string) (string, error) {
    cmd := exec.Command("docker-compose", args...)
    cmd.Dir = dc.ProjectDir
    
    var stdout, stderr bytes.Buffer
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    
    err := cmd.Run()
    if err != nil {
        return "", fmt.Errorf("command failed: %v\nstderr: %s", err, stderr.String())
    }
    
    return stdout.String(), nil
}

func (dc *DockerCompose) Up() (string, error) {
    return dc.executeCommand("up", "-d")
}

func (dc *DockerCompose) Down() (string, error) {
    return dc.executeCommand("down")
}

func (dc *DockerCompose) Ps() (string, error) {
    return dc.executeCommand("ps")
}

func (dc *DockerCompose) Logs(service string) (string, error) {
    return dc.executeCommand("logs", service)
}

func main() {
    projectPath, _ := filepath.Abs("./my-docker-project")
    dc := NewDockerCompose(projectPath)
    
    // 启动服务
    output, err := dc.Up()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Services started:", output)
    
    // 查看服务状态
    status, err := dc.Ps()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Services status:", status)
}

2. 使用Docker Go SDK + 解析Compose文件

对于更精细的控制，可以结合Docker Go SDK和解析docker-compose.yml文件：

package main

import (
    "context"
    "fmt"
    "log"
    "gopkg.in/yaml.v3"
    "github.com/docker/docker/api/types"
    "github.com/docker/docker/api/types/container"
    "github.com/docker/docker/client"
    "io/ioutil"
    "os"
)

type ComposeService struct {
    Image       string            `yaml:"image"`
    Ports       []string          `yaml:"ports"`
    Environment map[string]string `yaml:"environment"`
    Volumes     []string          `yaml:"volumes"`
}

type ComposeConfig struct {
    Version  string                    `yaml:"version"`
    Services map[string]ComposeService `yaml:"services"`
}

func parseComposeFile(filePath string) (*ComposeConfig, error) {
    data, err := ioutil.ReadFile(filePath)
    if err != nil {
        return nil, err
    }
    
    var config ComposeConfig
    err = yaml.Unmarshal(data, &config)
    if err != nil {
        return nil, err
    }
    
    return &config, nil
}

func createContainerFromService(cli *client.Client, serviceName string, service ComposeService) error {
    ctx := context.Background()
    
    // 拉取镜像
    reader, err := cli.ImagePull(ctx, service.Image, types.ImagePullOptions{})
    if err != nil {
        return err
    }
    defer reader.Close()
    
    // 创建容器配置
    containerConfig := &container.Config{
        Image: service.Image,
        Env:   convertEnvMapToSlice(service.Environment),
    }
    
    hostConfig := &container.HostConfig{}
    
    // 创建容器
    resp, err := cli.ContainerCreate(ctx, containerConfig, hostConfig, nil, nil, serviceName)
    if err != nil {
        return err
    }
    
    // 启动容器
    err = cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{})
    if err != nil {
        return err
    }
    
    fmt.Printf("Container %s created and started\n", serviceName)
    return nil
}

func convertEnvMapToSlice(envMap map[string]string) []string {
    var envs []string
    for key, value := range envMap {
        envs = append(envs, fmt.Sprintf("%s=%s", key, value))
    }
    return envs
}

func main() {
    // 解析docker-compose.yml
    config, err := parseComposeFile("docker-compose.yml")
    if err != nil {
        log.Fatal(err)
    }
    
    // 创建Docker客户端
    cli, err := client.NewClientWithOpts(client.FromEnv)
    if err != nil {
        log.Fatal(err)
    }
    
    // 为每个服务创建容器
    for serviceName, service := range config.Services {
        err := createContainerFromService(cli, serviceName, service)
        if err != nil {
            log.Printf("Failed to create service %s: %v", serviceName, err)
        }
    }
}

3. 使用第三方库

虽然专门的docker-compose Go库较少，但可以结合以下库：

// 使用 testcontainers-go 进行集成测试
package main

import (
    "context"
    "fmt"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/wait"
    "time"
)

func main() {
    ctx := context.Background()
    
    // 使用Docker Compose模块
    compose := testcontainers.NewLocalDockerCompose(
        []string{"docker-compose.yml"},
        "my-project",
    )
    
    // 启动服务
    err := compose.WithCommand([]string{"up", "-d"}).Invoke()
    if err != nil {
        panic(err)
    }
    
    // 等待服务就绪
    err = compose.WaitForService("database", wait.ForLog("ready for connections").WithStartupTimeout(30*time.Second))
    if err != nil {
        panic(err)
    }
    
    fmt.Println("Docker Compose services are running")
    
    // 清理
    defer compose.Down()
}

4. 完整的封装示例

这里是一个更完整的封装示例：

package dockercompose

import (
    "bytes"
    "fmt"
    "io"
    "os"
    "os/exec"
    "path/filepath"
    "strings"
)

type Manager struct {
    composeFiles []string
    projectName  string
    workDir      string
}

func NewManager(workDir string, composeFiles []string, projectName string) *Manager {
    return &Manager{
        workDir:      workDir,
        composeFiles: composeFiles,
        projectName:  projectName,
    }
}

func (m *Manager) buildArgs(args []string) []string {
    var cmdArgs []string
    
    // 添加项目名称
    if m.projectName != "" {
        cmdArgs = append(cmdArgs, "-p", m.projectName)
    }
    
    // 添加compose文件
    for _, file := range m.composeFiles {
        cmdArgs = append(cmdArgs, "-f", file)
    }
    
    // 添加其他参数
    cmdArgs = append(cmdArgs, args...)
    
    return cmdArgs
}

func (m *Manager) Execute(args []string, stdout, stderr io.Writer) error {
    cmdArgs := m.buildArgs(args)
    
    cmd := exec.Command("docker-compose", cmdArgs...)
    cmd.Dir = m.workDir
    cmd.Stdout = stdout
    cmd.Stderr = stderr
    
    return cmd.Run()
}

func (m *Manager) Up(services ...string) error {
    args := []string{"up", "-d"}
    args = append(args, services...)
    
    var stdout, stderr bytes.Buffer
    err := m.Execute(args, &stdout, &stderr)
    if err != nil {
        return fmt.Errorf("up failed: %v\n%s", err, stderr.String())
    }
    
    return nil
}

func (m *Manager) Down() error {
    args := []string{"down"}
    
    var stdout, stderr bytes.Buffer
    err := m.Execute(args, &stdout, &stderr)
    if err != nil {
        return fmt.Errorf("down failed: %v\n%s", err, stderr.String())
    }
    
    return nil
}

func (m *Manager) Logs(service string, follow bool) error {
    args := []string{"logs"}
    if follow {
        args = append(args, "-f")
    }
    args = append(args, service)
    
    return m.Execute(args, os.Stdout, os.Stderr)
}

func (m *Manager) GetRunningServices() ([]string, error) {
    var stdout bytes.Buffer
    err := m.Execute([]string{"ps", "--services"}, &stdout, io.Discard)
    if err != nil {
        return nil, err
    }
    
    services := strings.Split(strings.TrimSpace(stdout.String()), "\n")
    return services, nil
}

// 使用示例
func main() {
    workDir, _ := filepath.Abs(".")
    composeFiles := []string{"docker-compose.yml", "docker-compose.override.yml"}
    
    manager := NewManager(workDir, composeFiles, "myapp")
    
    // 启动所有服务
    err := manager.Up()
    if err != nil {
        fmt.Printf("Error starting services: %v\n", err)
        return
    }
    
    // 获取运行中的服务
    services, err := manager.GetRunningServices()
    if err != nil {
        fmt.Printf("Error getting services: %v\n", err)
        return
    }
    
    fmt.Printf("Running services: %v\n", services)
    
    // 清理
    defer manager.Down()
}

目前Go生态中没有与Node.js docker-compose包完全对应的库，但通过os/exec调用命令行是最直接的方法。对于需要更精细控制的场景，可以结合Docker Go SDK和YAML解析来实现类似功能。