2. Go 微服务基础：并发模型、HTTP/gRPC 服务搭建与服务注册发现

构建微服务系统，首先需要掌握 Go 语言的核心并发模型、网络服务搭建方式以及服务间通信与治理的基础设施。本章将围绕这四个关键点展开，为后续的日志链路追踪奠定坚实的运行环境基础。

2.1 Go 语言并发模型：Goroutine 与 Channel

Go 语言的并发模型基于 CSP（Communicating Sequential Processes） 理论，核心原语是 Goroutine 和 Channel。Goroutine 是轻量级线程，由 Go 运行时管理，创建成本极低（约 4KB 栈空间）。Channel 用于 Goroutine 之间的通信与同步，遵循“不要通过共享内存来通信，而应通过通信来共享内存”的设计哲学。

关键指标对比：
特性OS 线程Goroutine
创建成本高（MB 级栈）低（KB 级栈，可动态增长）
调度方式内核态抢占式调度用户态协作式调度（M:N 模型）
上下文切换微秒级（涉及内核态切换）纳秒级（用户态切换）
通信方式共享内存 + 锁Channel 优先，也支持共享内存

以下是一个典型的 Goroutine 与 Channel 协作示例：

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        time.Sleep(time.Second) // 模拟耗时任务
        results <- j * 2
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // 启动 3 个 Worker Goroutine
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= numJobs; a++ {
        <-results
    }
}
实践建议：在微服务中，每个 HTTP/gRPC 请求处理通常在一个独立的 Goroutine 中执行。链路追踪的上下文（如 TraceID、SpanID）必须通过 context.Context 显式传递，避免因 Goroutine 切换导致追踪信息丢失。

2.2 HTTP 服务搭建：标准库与 Gin 框架

Go 标准库 net/http 提供了构建 HTTP 服务的基础能力，而 Gin 框架则在此基础上提供了更高效的路由、中间件和参数绑定能力，是微服务开发中的常用选择。

2.2.1 标准库 HTTP 服务

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Microservice!")
}

func main() {
    http.HandleFunc("/hello", helloHandler)
    http.ListenAndServe(":8080", nil)
}

2.2.2 Gin 框架 HTTP 服务

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello, Microservice with Gin!",
        })
    })
    r.Run(":8080")
}
注意：在生产环境中，必须为 HTTP 服务配置优雅关闭（Graceful Shutdown），确保正在处理的请求完成后再退出进程，避免数据丢失或追踪链路断裂。

2.3 gRPC 服务搭建：Protocol Buffers 与双向流

gRPC 是高性能的 RPC 框架，基于 HTTP/2 和 Protocol Buffers（protobuf）序列化协议。它支持四种通信模式：一元 RPC、服务端流、客户端流和双向流。在微服务架构中，gRPC 常用于内部服务间的高效通信。

2.3.1 定义 protobuf 服务

syntax = "proto3";

package user;

service UserService {
    rpc GetUser (GetUserRequest) returns (GetUserResponse);
    rpc ListUsers (ListUsersRequest) returns (stream User);
}

message GetUserRequest {
    string user_id = 1;
}

message GetUserResponse {
    string user_id = 1;
    string name = 2;
    string email = 3;
}

message ListUsersRequest {
    int32 page_size = 1;
}

message User {
    string user_id = 1;
    string name = 2;
    string email = 3;
}

2.3.2 服务端实现

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/your/protobuf/package"
)

type userServer struct {
    pb.UnimplementedUserServiceServer
}

func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
    return &pb.GetUserResponse{
        UserId: req.UserId,
        Name:   "Alice",
        Email:  "alice@example.com",
    }, nil
}

func main() {
    lis, _ := net.Listen("tcp", ":50051")
    s := grpc.NewServer()
    pb.RegisterUserServiceServer(s, &userServer{})
    log.Fatal(s.Serve(lis))
}
链路追踪集成：gRPC 拦截器（Interceptor）是注入链路追踪的天然位置。通过一元拦截器或流拦截器，可以在每个 RPC 调用前后自动提取和注入 TraceID，无需修改业务代码。

2.4 服务注册与发现基础

在微服务架构中，服务实例的 IP 和端口是动态变化的。服务注册与发现（Service Discovery）解决了“如何找到可用服务实例”的问题。常见的实现包括 Consul、etcd、ZooKeeper 以及 Kubernetes 内置的 DNS 服务发现。

2.4.1 核心概念对比

组件一致性协议健康检查适用场景
ConsulRaft支持（HTTP/TCP/gRPC）多数据中心、服务网格
etcdRaft需自行实现Kubernetes 核心存储
ZooKeeperZAB需自行实现大数据生态、传统架构
Kubernetes DNS无（基于 API Server）依赖 Pod 就绪探针云原生、容器化部署

2.4.2 服务注册与发现流程

下图展示了服务启动时注册、客户端调用时发现以及健康检查的完整流程：

服务注册与发现流程 服务提供者 A 注册中心 服务消费者 B ① 注册 ② 发现 ③ 健康检查 ④ 直接调用 说明： 服务启动时向注册中心注册自身地址与健康检查接口。 消费者从注册中心获取可用实例列表，并直接发起调用。

2.4.3 使用 Consul 进行服务注册（Go 示例）

package main

import (
    "fmt"
    "log"
    "net"

    consulapi "github.com/hashicorp/consul/api"
)

func registerService() {
    config := consulapi.DefaultConfig()
    config.Address = "127.0.0.1:8500"
    client, _ := consulapi.NewClient(config)

    ip, _ := net.LookupHost("localhost")
    registration := &consulapi.AgentServiceRegistration{
        ID:      "user-service-1",
        Name:    "user-service",
        Port:    50051,
        Address: ip[0],
        Check: &consulapi.AgentServiceCheck{
            GRPC:     "localhost:50051/grpc.health.v1.Health/Check",
            Interval: "10s",
            Timeout:  "5s",
        },
    }

    err := client.Agent().ServiceRegister(registration)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Service registered successfully")
}
链路追踪与注册发现：在服务发现阶段，消费者获取到的实例信息中应包含该服务实例的元数据（如服务版本、环境标签）。这些元数据可以注入到追踪 Span 的 Tags 中，帮助在分布式追踪系统中快速定位问题服务版本。

2.5 本章小结

本章涵盖了构建 Go 微服务所需的四个基础能力：

  • 并发模型：Goroutine 与 Channel 是处理高并发请求的基石，链路追踪上下文必须通过 Context 显式传递。
  • HTTP 服务：标准库与 Gin 框架均可快速搭建 RESTful 服务，需配置优雅关闭。
  • gRPC 服务：基于 protobuf 定义接口，支持高效的双向流通信，拦截器是注入追踪的绝佳位置。
  • 服务注册与发现：Consul、etcd 等组件解决了动态实例管理问题，是微服务治理的第一步。
← 上一章 📖 返回目录 下一章 →