Golang命令行服务编排与Docker wait-for工具使用指南

在微服务架构和容器化部署中，服务之间的依赖关系和启动顺序管理是一个常见挑战。本文将介绍如何使用Golang进行命令行服务编排，并结合Docker生态中的wait-for工具来确保服务依赖关系。

一、Golang命令行服务编排

Golang提供了强大的标准库来构建命令行工具和服务编排逻辑。以下是一个基本的服务编排示例：

package main

import (
	"fmt"
	"log"
	"os/exec"
	"sync"
)

func main() {
	services := []struct {
		name     string
		command  string
		args     []string
		dependsOn []string
	}{
		{"database", "docker", []string{"run", "-d", "--name=db", "postgres"}, nil},
		{"redis", "docker", []string{"run", "-d", "--name=redis", "redis"}, nil},
		{"app", "docker", []string{"run", "--name=app", "--link=db", "--link=redis", "myapp"}, []string{"database", "redis"}},
	}

	var wg sync.WaitGroup
	serviceStatus := make(map[string]bool)

	for _, svc := range services {
		wg.Add(1)
		go func(svc struct {
			name     string
			command  string
			args     []string
			dependsOn []string
		}) {
			defer wg.Done()

			// 检查依赖
			for _, dep := range svc.dependsOn {
				for !serviceStatus[dep] {
					// 等待依赖服务就绪
				}
			}

			cmd := exec.Command(svc.command, svc.args...)
			output, err := cmd.CombinedOutput()
			if err != nil {
				log.Printf("Failed to start %s: %v\nOutput: %s", svc.name, err, output)
				return
			}
			fmt.Printf("Service %s started successfully\n", svc.name)
			serviceStatus[svc.name] = true
		}(svc)
	}

	wg.Wait()
	fmt.Println("All services started")
}

二、Docker wait-for工具的使用

wait-for是一个常用的等待工具，可以检查TCP端口或HTTP端点是否就绪。以下是几种使用方式：

1. 使用官方wait-for脚本

FROM golang:1.21 as builder
WORKDIR /app
COPY . .
RUN go build -o myapp

FROM alpine:3.14
WORKDIR /app
COPY --from=builder /app/myapp .
COPY wait-for.sh .
RUN chmod +x wait-for.sh

CMD ["./wait-for.sh", "db:5432", "--", "./myapp"]

2. Golang实现的wait-for替代方案

如果你不想依赖外部脚本，可以用纯Golang实现：

package main

import (
	"fmt"
	"net"
	"os"
	"time"
)

func waitFor(host string, port string, timeout time.Duration) bool {
	start := time.Now()
	for time.Since(start) < timeout {
		conn, err := net.Dial("tcp", fmt.Sprintf("%s:%s", host, port))
		if err == nil {
			conn.Close()
			return true
		}
		time.Sleep(1 * time.Second)
	}
	return false
}

func main() {
	if len(os.Args) < 3 {
		fmt.Println("Usage: wait-for <host> <port> [timeout] [-- command args...]")
		os.Exit(1)
	}

	host := os.Args[1]
	port := os.Args[2]
	timeout := 30 * time.Second

	// 解析超时参数
	args := os.Args[3:]
	var command []string
	for i, arg := range args {
		if arg == "--" {
			command = args[i+1:]
			args = args[:i]
			break
		}
	}

	// 检查服务是否就绪
	if !waitFor(host, port, timeout) {
		fmt.Printf("Timeout waiting for %s:%s\n", host, port)
		os.Exit(1)
	}

	// 执行后续命令
	if len(command) > 0 {
		cmd := exec.Command(command[0], command[1:]...)
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
		if err := cmd.Run(); err != nil {
			os.Exit(1)
		}
	}
}

3. 在Docker Compose中使用

version: '3.8'

services:
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

  app:
    build: .
    depends_on:
      - db
    command: ["./wait-for", "db:5432", "--", "./myapp"]

三、高级用法：HTTP端点检查

对于HTTP服务，可以扩展wait-for功能：

func waitForHTTP(url string, timeout time.Duration, expectedStatus int) bool {
	client := http.Client{Timeout: 1 * time.Second}
	start := time.Now()
	
	for time.Since(start) < timeout {
		resp, err := client.Get(url)
		if err == nil && resp.StatusCode == expectedStatus {
			resp.Body.Close()
			return true
		}
		if resp != nil {
			resp.Body.Close()
		}
		time.Sleep(1 * time.Second)
	}
	return false
}

四、最佳实践

1. 超时设置：总是设置合理的超时时间，避免无限等待
2. 健康检查：不只是检查端口是否开放，最好实现真正的健康检查端点
3. 日志记录：记录等待过程，便于故障排查
4. 优雅退出：当等待超时时，确保所有资源被正确清理
5. 组合使用：可以将端口检查和HTTP检查组合使用

通过结合Golang的命令行编程能力和wait-for工具，你可以构建出健壮的服务编排系统，确保服务按照正确的依赖顺序启动。