如何在Go客户端获取gRPC服务端IP？含部署与负载均衡验证场景

好问题！刚好我之前在验证L7负载均衡路由的场景里折腾过类似需求，来给你梳理一下可行的方案：

一、gRPC Go库原生支持的方法：获取直接连接的远端地址 #

gRPC Go客户端确实提供了获取连接远端地址的能力，核心是用peer.Peer结构体来获取TCP连接的对端信息。

1. 单次RPC调用中获取 #

在每次调用RPC方法时，你可以通过上下文传递peer.Peer实例，调用完成后就能拿到远端地址：

import (
    "context"
    "strings"
    "fmt"
    "google.golang.org/grpc/peer"
)

func callHelloService(ctx context.Context, client HelloServiceClient) {
    var p peer.Peer
    // 将Peer实例绑定到上下文
    ctx = peer.NewContext(ctx, &p)
    
    _, err := client.SayHello(ctx, &HelloRequest{Name: "test"})
    if err != nil {
        fmt.Printf("调用失败: %v\n", err)
        return
    }
    
    // p.Addr就是对端的网络地址（格式如"192.168.1.100:50051"）
    serverAddr := p.Addr.String()
    // 提取IP部分
    serverIP := strings.Split(serverAddr, ":")[0]
    fmt.Printf("当前连接的远端地址IP: %s\n", serverIP)
}

⚠️ 注意：如果中间有Nginx/Envoy这类L7负载均衡器，这里拿到的是负载均衡器的IP，而不是后端gRPC服务的真实IP。如果要验证LB的路由决策，你需要拿到后端服务的真实IP，这就需要额外处理了。

2. 通过客户端拦截器全局记录 #

如果想在所有RPC调用中自动记录远端地址，可以用客户端拦截器实现全局处理：

import (
    "fmt"
    "google.golang.org/grpc"
    "google.golang.org/grpc/peer"
)

func serverIPLoggingInterceptor() grpc.UnaryClientInterceptor {
    return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
        var p peer.Peer
        ctx = peer.NewContext(ctx, &p)
        
        // 执行原RPC调用
        err := invoker(ctx, method, req, reply, cc, opts...)
        
        if err == nil && p.Addr != nil {
            fmt.Printf("RPC方法[%s] 连接的远端地址: %s\n", method, p.Addr.String())
            // 这里可以把IP写入日志、监控系统，或者做其他校验
        }
        return err
    }
}

// 创建客户端时注入拦截器
func NewHelloClient(target string) (HelloServiceClient, error) {
    conn, err := grpc.Dial(
        target,
        grpc.WithInsecure(), // 生产环境请用TLS相关配置
        grpc.WithUnaryInterceptor(serverIPLoggingInterceptor()),
    )
    if err != nil {
        return nil, err
    }
    return NewHelloServiceClient(conn), nil
}

二、验证L7负载均衡路由：获取后端服务真实IP #

上面的方法只能拿到LB的IP，如果你需要确认LB是否路由到了正确的后端服务，需要让后端服务主动把自己的IP传递给客户端，有两种常用方式：

1. 在gRPC响应中添加服务端IP字段 #

最简单直接的方式是修改你的Proto定义，在响应结构体中新增一个server_ip字段，服务端处理请求时填充自己的IP：

Proto示例：

syntax = "proto3";

package hello;

service HelloService {
    rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string message = 1;
    string server_ip = 2; // 新增：返回服务端IP
}

服务端代码（Go）：

import (
    "context"
    "net"
)

func (s *helloServer) SayHello(ctx context.Context, req *HelloRequest) (*HelloResponse, error) {
    // 获取服务端本地IP（这里实现一个简单的获取逻辑，可根据部署环境调整）
    serverIP := getLocalIP()
    return &HelloResponse{
        Message:  fmt.Sprintf("Hello %s!", req.Name),
        ServerIp: serverIP,
    }, nil
}

// 简单获取本地非回环IP的函数
func getLocalIP() string {
    addrs, err := net.InterfaceAddrs()
    if err != nil {
        return "unknown"
    }
    for _, addr := range addrs {
        if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
            if ipnet.IP.To4() != nil {
                return ipnet.IP.String()
            }
        }
    }
    return "unknown"
}

客户端调用后，直接读取HelloResponse.ServerIp就能拿到后端服务的真实IP，用来验证LB的路由是否符合预期。

2. 通过gRPC元数据（Metadata）传递 #

如果不想修改Proto定义，可以用gRPC的元数据机制，服务端将IP放到响应头中，客户端读取：

服务端代码：

import (
    "context"
    "google.golang.org/grpc/metadata"
)

func (s *helloServer) SayHello(ctx context.Context, req *HelloRequest) (*HelloResponse, error) {
    serverIP := getLocalIP()
    // 构造响应元数据
    md := metadata.Pairs("server-ip", serverIP)
    // 发送元数据到客户端
    grpc.SendHeader(ctx, md)
    
    return &HelloResponse{Message: fmt.Sprintf("Hello %s!", req.Name)}, nil
}

客户端代码：

import (
    "context"
    "fmt"
    "google.golang.org/grpc/metadata"
)

func callHelloService(ctx context.Context, client HelloServiceClient) {
    var header metadata.MD
    // 通过grpc.Header选项获取响应元数据
    _, err := client.SayHello(ctx, &HelloRequest{Name: "test"}, grpc.Header(&header))
    if err != nil {
        fmt.Printf("调用失败: %v\n", err)
        return
    }
    
    // 读取元数据中的服务端IP
    if serverIPs := header.Get("server-ip"); len(serverIPs) > 0 {
        fmt.Printf("后端服务真实IP: %s\n", serverIPs[0])
    }
}

三、部署场景的小技巧 #

• Kubernetes环境：Pod的IP可以通过环境变量POD_IP（部分集群会自动注入），或者调用K8s向下API获取；也可以用上面的getLocalIP()函数直接读取网卡IP。
• Docker Compose环境：容器的IP可以通过hostname -i命令获取，或者在启动容器时通过环境变量传递（比如在docker-compose.yml中设置environment: - SERVER_IP={{.Service.Name}}）。

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