Integrating PolarisMesh with gRPC-Go for Full-Service Governance

Overview

PolarisMesh is an open‑source service discovery and governance platform that provides service addressing, traffic scheduling, fault tolerance, and access control. It can be used unchanged in both Kubernetes and virtual‑machine environments.

Why gRPC‑Go needs additional governance

gRPC‑Go offers high‑performance binary RPC but does not include built‑in locality routing, circuit breaking, graceful shutdown, or global rate limiting, which are required for robust microservice architectures.

Integration Architecture

PolarisMesh extends gRPC‑Go through three plugin types:

Resolver plugin for service discovery via PolarisMesh.

Balancer plugin for dynamic routing and circuit breaking.

ServerInterceptor plugin for service registration, health checking, and graceful shutdown.

Architecture diagram:

Client‑side usage

Import the PolarisMesh plugin and dial using the polaris:// scheme.

import (
    "context"
    "log"

    "google.golang.org/grpc"
    polaris "github.com/polarismesh/grpc-go-polaris"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

conn, err := grpc.DialContext(
    ctx,
    "polaris://EchoServerGRPC/",
    grpc.WithInsecure(),
    grpc.WithDefaultServiceConfig(polaris.LoadBalanceConfig),
)
if err != nil {
    log.Fatal(err)
}
defer conn.Close()

// Normal client call
echoClient := pb.NewEchoServerClient(conn)
echoClient.Echo(ctx, &pb.EchoRequest{Value: value})

Server‑side usage

Register the gRPC server with PolarisMesh so that the service becomes discoverable and participates in governance features.

import (
    "fmt"
    "log"
    "net"
    "os"
    "os/signal"

    "google.golang.org/grpc"
    polaris "github.com/polarismesh/grpc-go-polaris"
)

srv := grpc.NewServer()
pb.RegisterEchoServerServer(srv, &EchoService{})
address := fmt.Sprintf("0.0.0.0:%d", listenPort)
listen, err := net.Listen("tcp", address)
if err != nil {
    log.Fatalf("Failed to listen %s: %v", address, err)
}

// Register with PolarisMesh
pSrv, err := polaris.Register(srv, listen, polaris.WithServerApplication("EchoServerGRPC"))
if err != nil {
    log.Fatal(err)
}

// Graceful shutdown handling
go func() {
    c := make(chan os.Signal, 1)
    signal.Notify(c)
    s := <-c
    log.Printf("receive quit signal: %v", s)
    pSrv.Deregister()
    srv.GracefulStop()
}()

if err = srv.Serve(listen); err != nil {
    log.Printf("serve error: %v", err)
}

Quick‑start example

Source code: https://github.com/polarismesh/grpc-go-polaris/tree/main/examples/quickstart

Other framework integrations

grpc-go: https://github.com/polarismesh/grpc-go-polaris

dubbo-go: https://github.com/apache/dubbo-go/tree/master/registry/polaris

go-zero: https://github.com/zeromicro/zero-contrib/tree/main/zrpc/registry/polaris

GoFrame: https://github.com/gogf/polaris

grpc-java-polaris: https://github.com/polarismesh/grpc-java-polaris

spring-cloud-tencent: https://github.com/Tencent/spring-cloud-tencent