Go 使用nacos以及GRPC实现微服务

确保你已经安装了相应的Go库：

go get -u google.golang.org/grpc
go get -u github.com/nacos-group/nacos-sdk-go/clients/config_client
go get -u github.com/nacos-group/nacos-sdk-go/clients/naming_client

编写gRPC服务： 编写你的gRPC服务和proto定义

// your_service.proto

syntax = "proto3";

package yourpackage;

service YourService {
    rpc YourMethod (YourRequest) returns (YourResponse);
}

message YourRequest {
    // Your request message fields
}

message YourResponse {
    // Your response message fields
}

生成gRPC代码：

protoc -I=. --go_out=. --go-grpc_out=. your_service.proto

创建gRPC服务并注册到Nacos：

// your_service.go

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "os"
    "os/signal"
    "syscall"
    "time"

    "google.golang.org/grpc"
    pb "yourpackage" // 根据实际项目路径调整
    "github.com/nacos-group/nacos-sdk-go/clients/naming_client"
    "github.com/nacos-group/nacos-sdk-go/common/constant"
)

type server struct {
    pb.UnimplementedYourServiceServer
}

func (s *server) YourMethod(ctx context.Context, req *pb.YourRequest) (*pb.YourResponse, error) {
    // Implement your service logic here
    return &pb.YourResponse{}, nil
}

func main() {
    // gRPC server setup
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterYourServiceServer(s, &server{})

    // Nacos registration setup
    sc := []constant.ServerConfig{
        {
            IpAddr: "your-nacos-ip", // Nacos服务器IP
            Port:   8848,             // Nacos服务器端口
        },
    }
    cc := constant.ClientConfig{
        NamespaceId:         "your-namespace-id", // 命名空间ID
        TimeoutMs:           5000,
        NotLoadCacheAtStart: true,
        LogDir:              "log",
        RotateTime:          "1h",
        MaxAge:              3,
        LogLevel:            "debug",
    }

    namingClient, err := naming_client.CreateNamingClient(map[string]interface{}{
        "serverConfigs": sc,
        "clientConfig":  cc,
    })
    if err != nil {
        log.Fatalf("Error creating Nacos client: %v", err)
    }

    serviceName := "your-service-name" // Nacos服务名
    groupName := "your-group-name"     // Nacos服务组名

    instance := &naming_client.Instance{
        Ip:          "127.0.0.1", // gRPC服务IP
        Port:        50051,       // gRPC服务端口
        ServiceName: serviceName,
        Weight:      10,
        Enable:      true,
        Healthy:     true,
        Ephemeral:   true,
        GroupName:   groupName,
    }

    _, err = namingClient.RegisterInstance(serviceName, groupName, instance)
    if err != nil {
        log.Fatalf("Error registering service: %v", err)
    }

    // Graceful shutdown
    go func() {
        if err := s.Serve(lis); err != nil {
            log.Fatalf("failed to serve: %v", err)
        }
    }()

    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

    <-sigCh

    fmt.Println("Shutting down...")

    _, err = namingClient.DeregisterInstance(serviceName, groupName, instance)
    if err != nil {
        log.Printf("Error deregistering service: %v", err)
    }

    s.GracefulStop()
    fmt.Println("gRPC server stopped")
}

创建gRPC客户端并从Nacos获取服务地址：

// your_client.go

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/grpc"
    "github.com/nacos-group/nacos-sdk-go/clients/naming_client"
    "github.com/nacos-group/nacos-sdk-go/common/constant"
    pb "yourpackage" // 根据实际项目路径调整
)

func main() {
    // Nacos configuration
    sc := []constant.ServerConfig{
        {
            IpAddr: "your-nacos-ip", // Nacos服务器IP
            Port:   8848,             // Nacos服务器端口
        },
    }
    cc := constant.ClientConfig{
        NamespaceId:         "your-namespace-id", // 命名空间ID
        TimeoutMs:           5000,
        NotLoadCacheAtStart: true,
        LogDir:              "log",
        RotateTime:          "1h",
        MaxAge:              3,
        LogLevel:            "debug",
    }

    // Create Nacos naming client
    namingClient, err := naming_client.CreateNamingClient(map[string]interface{}{
        "serverConfigs": sc,
        "clientConfig":  cc,
    })
    if err != nil {
        log.Fatalf("Error creating Nacos client: %v", err)
    }

    // Get gRPC service instance from Nacos
    serviceName := "your-service-name" // Nacos服务名
    groupName := "your-group-name"     // Nacos服务组名

    instances, err := namingClient.SelectInstances(context.Background(), serviceName, groupName, true)
    if err != nil {
        log.Fatalf("Error selecting instances: %v", err)
    }

    if len(instances) == 0 {
        log.Fatalf("No available instances for service: %s", serviceName)
    }

    // Select a random instance
    selectedInstance := instances[0]
    serverAddr := fmt.Sprintf("%s:%d", selectedInstance.Ip, selectedInstance.Port)

    // Set up a connection to the server
    conn, err := grpc.Dial(serverAddr, grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
        log.Fatalf("Error connecting to gRPC server: %v", err)
    }
    defer conn.Close