[microservicios golang] 7. Introducción al marco go-micro, andamiaje go-micro, go-micro combinado con consul para crear casos de microservicio

Mobile 2023-07-16 02:27:33 views: null

1. marco go-micro

  1. prefacio

La sección anterior explicó los casos relacionados con el clúster de microservicios GRPC + el clúster Cónsul + grpc-cónsul-resolver , conociendo el protocolo de comunicación utilizado para la comunicación entre microservicios , cómo realizar el registro y descubrimiento de servicios , construyendo clústeres de gestión de servicios y servicios y la comunicación RPC. método entre servicios , el contenido específico incluye: protocolo protobuf , implementación de consul y docker de consul cluster , el uso del marco GRPC y otras soluciones de implementación específicas. Todas las soluciones específicas anteriores son para resolver: problemas específicos en el proceso de práctica de microservicios Una pregunta se planteó para realizar el desarrollo del proyecto de la arquitectura de microservicio.Sin embargo, en el proceso de desarrollo del proyecto específico, los desarrolladores se centran en el desarrollo de la lógica empresarial y la realización de funciones , una gran cantidad de configuraciones de entorno , depuración y construcción y otro trabajo básico . consumen una cantidad considerable de energía, por lo que es necesario administrar y mantener de forma centralizada las soluciones relacionadas involucradas en la arquitectura de microservicios , que requiere el uso de Micro para el procesamiento

  1. introducción go-micro

Go Micro es un ecosistema de microservicios que simplifica el desarrollo distribuido . Este sistema proporciona una construcción de módulos eficiente y conveniente para desarrollar aplicaciones distribuidas . El objetivo principal es simplificar el desarrollo de sistemas distribuidos . Implementa consul como descubrimiento de servicios de forma predeterminada (en 2019, el el código fuente se modificó para usar mdns de forma predeterminada ), comunicarse a través de http , y codificar y decodificar a través de protobuf y json , lo que puede facilitar a los desarrolladores desarrollar proyectos con arquitectura de microservicios de manera muy simple, y con el aumento de módulos y funciones comerciales, Go Micro puede también proporciona herramientas y funciones para gestionar entornos de microservicios
dirección de github: https://github.com/asim/go-micro

  1. Funciones principales de go-micro

  • Autenticación

La autenticación está integrada como un ciudadano de primera clase, la autenticación y la autorización permiten una red segura de confianza cero al proporcionar identidades y certificados para cada servicio, esto también incluye control de acceso basado en reglas

  • configuración dinámica

Cargue y recargue en caliente la configuración dinámica desde cualquier lugar , la interfaz de configuración proporciona una forma de cargar la configuración a nivel de aplicación desde cualquier fuente (como variables de entorno, archivos, etc.), las fuentes se pueden fusionar e incluso se pueden definir respaldos

  • almacenamiento de datos

Una interfaz de almacenamiento de datos simple para leer, escribir y eliminar registros. Incluye soporte para memoria , archivos y CockroachDB de forma predeterminada. El estado y la persistencia se convierten en requisitos básicos fuera de la creación de prototipos. Micro espera integrarlo en el marco. medio

  • descubrimiento de servicios

Registro automático de servicios y resolución de nombres . El descubrimiento de servicios es el núcleo del desarrollo de microservicios . Cuando el servicio A necesita comunicarse con el servicio B, necesita la ubicación del servicio. El mecanismo de descubrimiento predeterminado es DNS de multidifusión (mdns ), un sistema zeroconf

  • balanceo de carga

Equilibrio de carga del lado del cliente basado en el descubrimiento de servicios , una vez que tenga la dirección de cualquier cantidad de instancias de servicio , ahora necesita una forma de decidir a qué nodo enrutar, utilizando el equilibrio de carga de hash aleatorio para proporcionar una distribución uniforme entre los servicios , y en caso de que de problemas vuelva a intentar diferentes nodos

  • codificación de mensajes

La codificación de mensajes dinámicos basada en el tipo de contenido , el cliente y el servidor usarán el códec y el tipo de contenido para codificar y decodificar sin problemas los tipos de Go, cualquier tipo de mensaje puede codificarse y enviarse desde diferentes clientes, de forma predeterminada, el cliente y el servidor manejarán esto, esto incluye protobuf y json por defecto

  • cliente/servidor RPC

Solicitud/respuesta basada en RPC , admite flujos bidireccionales , proporciona una abstracción para la comunicación síncrona, las solicitudes a los servicios se analizarán automáticamente, se equilibrarán las cargas, se marcarán y se transmitirán

  • Mensajería asíncrona

PubSub está integrado como un ciudadano de primera clase de comunicación asíncrona y arquitectura basada en eventos La notificación de eventos es el modo central del desarrollo de microservicios El sistema de mensajes predeterminado es el agente de mensajes de eventos HTTP

  • flujo de eventos

PubSub es ideal para notificaciones asincrónicas , pero para casos de uso más avanzados, se prefieren los flujos de eventos , proporciona almacenamiento persistente , consume compensaciones y reconocimientos, Go Micro incluye soporte para flujos NATS Jetstream y Redis

  • Sincronizar

Los sistemas distribuidos generalmente se construyen de una manera eventualmente consistente . El soporte para bloqueo distribuido y liderazgo (Líder) está integrado como una interfaz de sincronización. Cuando use una base de datos o programación eventualmente consistente , use la interfaz de sincronización

  • Interfaces enchufables

Go Micro utiliza interfaces de Go para cada abstracción del sistema distribuido. Por lo tanto, estas interfaces son conectables y permiten que Go Micro sea independiente del tiempo de ejecución y se conecte a cualquier tecnología subyacente.

  1. ir-micro instalar

dirección de github: https://github.com/asim/go-micro, de la siguiente manera, después de hacer clic en CLI , puede ver los comandos relacionados con la instalación :
A través de la instalación go install github.com/go-micro/cli/cmd/go-micro@latest, después del éxito, el servidor y el cliente del microservicio se pueden construir a través del comando go-micro new service helloworld . el sistema generará automáticamente archivos y métodos para llamadas remotas como .proto y .pb.go
La instalación es la siguiente: ejecuta el comando go install github.com/go-micro/cli/cmd/go-micro@latest

Una vez que se completa el comando, puede ver el archivo de ejecución go-micro.exe correspondiente en el directorio bin de GOPATH

Luego verifique si la instalación fue exitosa, ingrese el comando : go-micro
Instalación exitosa

2. Uso de go-micro

(1) Explicación de caso simple de helloworld

  1. crear servidor

Ejecutar en el directorio de servidores : go-micro new service helloworld

  1. Descargar dependencias del proyecto

Cuando lo use por primera vez, debe ejecutar los comandos en el Makefile

Makefile内容如下: 
GOPATH:=$(shell go env GOPATH)

.PHONY: init
init:
    @go get -u google.golang.org/protobuf/proto
    @go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
    @go install github.com/go-micro/generator/cmd/protoc-gen-micro@latest

.PHONY: proto
proto:
    @protoc --proto_path=. --micro_out=. --go_out=:. proto/helloworld.proto

.PHONY: update
update:
    @go get -u

.PHONY: tidy
tidy:
    @go mod tidy

.PHONY: build
build:
    @go build -o helloworld *.go

.PHONY: test
test:
    @go test -v ./... -cover

.PHONY: docker
docker:
    @docker build -t helloworld:latest .

windows下依次执行Markfile init里面的命令:

#init里面的命令：引入需要的包
go get -u google.golang.org/protobuf/proto
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install github.com/go-micro/generator/cmd/protoc-gen-micro@latest
#proto：执行生成对应的protobuf相关文件
protoc --proto_path=. --micro_out=. --go_out=:. proto/helloworld.proto

linux下通过make命令下载对应依赖或者编译项目

make proto update tidy

完成上面命令后的目录如下:

  1. 初始化服务端项目

go mod init helloworld
go mod tidy

如果出现:

F:\www\go-data\src\go_code\micro\grpc_demo\server\helloworld>go mod tidy
go: finding module for package google.golang.org/protobuf/runtime/protoimpl
go: finding module for package go-micro.dev/v4/logger
go: finding module for package go-micro.dev/v4
go: finding module for package go-micro.dev/v4/server
go: finding module for package go-micro.dev/v4/api
go: finding module for package google.golang.org/protobuf/proto
go: finding module for package google.golang.org/protobuf/reflect/protoreflect
go: finding module for package go-micro.dev/v4/client
go: found go-micro.dev/v4 in go-micro.dev/v4 v4.10.2
go: found go-micro.dev/v4/logger in go-micro.dev/v4/logger v1.18.0
go: found go-micro.dev/v4/api in go-micro.dev/v4/api v1.18.0
go: found go-micro.dev/v4/client in go-micro.dev/v4/client v1.18.0
go: found go-micro.dev/v4/server in go-micro.dev/v4/server v1.18.0
go: found google.golang.org/protobuf/proto in google.golang.org/protobuf v1.30.0
go: found google.golang.org/protobuf/reflect/protoreflect in google.golang.org/protobuf v1.30.0
go: found google.golang.org/protobuf/runtime/protoimpl in google.golang.org/protobuf v1.30.0
go: helloworld/proto imports
        go-micro.dev/v4/api: go-micro.dev/v4/[email protected]: parsing go.mod:
        module declares its path as: github.com/micro/go-micro
                but was required as: go-micro.dev/v4/api

说明下载"go-micro.dev/v4"这个包失败了,这时则需运行命令 go get go-micro.dev/v4,如图:

然后再次执行步骤3中的命令即可

  1. 配置服务端consul

(1).启动consul

在配置consul之前,需要启动consul,命令行执行命令 :consul agent -dev,启动consul服务, 也可以使用 consul集群相关操作进行处理

(2).引入consul包

然后在servers/helloworld/main.go下引入consul包:
可以在import引入包后,执行 go mod tidy ,也可以执行 go get github.com/go-micro/plugins/v4/registry/consul 命令引入 
 github.com/go-micro/plugins/v4/registry/consul

(3).实例化consul: 

consulReg := consul.NewRegistry()

(4).注册consul

srv := micro.NewService(
    micro.Address("192.168.1.132:8080"),  // 选择注册服务器地址,默认为本机,也可以选择consul集群中的client
    micro.Name(service),
    micro.Version(version),
    micro.Registry(consulReg),
)

(5).详细代码

package main

import (
    "helloworld/handler"
    pb "helloworld/proto"
    "go-micro.dev/v4"
    "go-micro.dev/v4/logger"
    "github.com/go-micro/plugins/v4/registry/consul"
)

var (
    service = "helloworld"
    version = "latest"
)

func main() {
    //集成consul
    consulReg := consul.NewRegistry()
    // Create service
    srv := micro.NewService(
        micro.Address("127.0.0.1:8080"),  //指定微服务的ip:  选择注册服务器地址,也可以不配置,默认为本机,也可以选择consul集群中的client
        micro.Name(service),
        micro.Version(version),
        //注册consul
        micro.Registry(consulReg),
    )
    srv.Init(
        micro.Name(service),
        micro.Version(version),
    )

    // Register handler
    if err := pb.RegisterHelloworldHandler(srv.Server(), new(handler.Helloworld)); err != nil {
        logger.Fatal(err)
    }
    // Run service
    if err := srv.Run(); err != nil {
        logger.Fatal(err)
    }
}

(6).结果显示

微服务服务端就配置并启动了

  1. 生成客户端

(1).生成客户端目录

在client目录下运行 :go-micro new client helloworld
目录如下: 结构和服务端结构一致,参考服务端结构
注意：在这里生成的客户端文件夹名字是helloworld-client
里面也存在 Makefile文件,操作和上面服务端一致, 下面就要让 客户端连接上微服务服务端

(2).创建客户端proto文件相关

这里可以直接把服务端中的proto文件夹复制到helloworld-client文件夹下,然后可以初始化项目,删除go.mod, 执行初始化命令 :go mod init helloworld-client, go mod tidy
重新初始化helloworld-client： 删除go.mod文件，然后执行： go mod init helloworld-client, go mod tidy

(3).完善helloworld-client/main.go文件

1).修改helloworld/proto包名字
需要把helloworld/proto修改为helloworld-client/proto

然后也要引入consul包

2).引入consul包
然后在client/helloworld-client/main.go下引入consul包:
可以在import引入包后,执行 go mod tidy ,也可以执行 go get github.com/go-micro/plugins/v4/registry/consul 命令引入 
 github.com/go-micro/plugins/v4/registry/consul
3).实例化consul: 
consulReg := consul.NewRegistry()
4).注册consul
//集成consul
consulReg := consul.NewRegistry(
    //指定微服务的ip:  选择注册服务器地址,默认为本机,也可以选择consul集群中的client
    registry.Addrs("127.0.0.1:8500"),
)
// Create service
srv := micro.NewService(
    //注册consul
    micro.Registry(consulReg),
)
5).详细代码
package main

import (
    "context"
    "time"
    pb "helloworld-client/proto"
    "go-micro.dev/v4"
    "go-micro.dev/v4/logger"   
    "go-micro.dev/v4/registry"
    "github.com/go-micro/plugins/v4/registry/consul"
)

var (
    service = "helloworld" //需要和微服务服务端对应的service名统一,这样才能调用该微服务
    version = "latest"
)

func main() {
    //集成consul
    consulReg := consul.NewRegistry(
        //指定微服务的ip:  选择注册服务器地址,默认为本机,也可以选择consul集群中的client
        registry.Addrs("127.0.0.1:8500"),
    )
    // Create service
    srv := micro.NewService(
        //注册consul
        micro.Registry(consulReg),
    )
    srv.Init()

    // 创建客户端实例
    c := pb.NewHelloworldService(service, srv.Client())
    for {
        // Call service: CallRequest就是.proto中的
        rsp, err := c.Call(context.Background(), &pb.CallRequest{Name: "张三"})
        if err != nil {
            logger.Fatal(err)
        }

        logger.Info(rsp)
        //每隔一段时间请求
        time.Sleep(2 * time.Second)  // 每隔2秒请求
    }
}
6).结果显示
客户端配置操作完成

(二).goodsinfo微服务案例讲解

  1. 创建服务端

在servers目录下运行 :go-micro new service goodsinfo

目录和上面helloworld案例类似,只不过是名字变成了goodsinfo而已

然后修改goodsinfo.proto,增加需要的服务方法:这里的写法和[golang 微服务] 4. gRPC介绍,Protobuf结合gRPC 创建微服务 里面的类似：

syntax = "proto3";

package goodsinfo;

option go_package = "./proto;goodsinfo";

//商品相关方法
service Goodsinfo {
    //AddGoods: 定义增加商品的微服务, 这里的写法和gRPC中的写法一致
    rpc AddGoods(AddRequest) returns (AddResponse) {}
}

//和gRPC中的写法一致
message AddRequest {
    string title = 1;
    string price = 2;
    string content = 3;
}

//和gRPC中的写法一致
message AddResponse {
    string message = 1;
    bool success = 2;
}

  1. 下载项目所需依赖

初次使用时,需执行Makefile里面的命令

Makefile内容如下: 
GOPATH:=$(shell go env GOPATH)

.PHONY: init
init:
    @go get -u google.golang.org/protobuf/proto
    @go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
    @go install github.com/go-micro/generator/cmd/protoc-gen-micro@latest

.PHONY: proto
proto:
    @protoc --proto_path=. --micro_out=. --go_out=:. proto/helloworld.proto

.PHONY: update
update:
    @go get -u

.PHONY: tidy
tidy:
    @go mod tidy

.PHONY: build
build:
    @go build -o helloworld *.go

.PHONY: test
test:
    @go test -v ./... -cover

.PHONY: docker
docker:
    @docker build -t helloworld:latest .

windows下依次执行init里面的命令:

#init：引入相关包
go get -u google.golang.org/protobuf/proto
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install github.com/go-micro/generator/cmd/protoc-gen-micro@latest
#proto： 生成protobuf相关文件
protoc --proto_path=. --micro_out=. --go_out=:. proto/helloworld.proto

linux下通过make命令下载对应依赖或者编译项目

make proto update tidy

完成上面命令后的目录如下:

生成了goodsinfo相关handler,以及.pb.go文件

  1. 初始化服务端项目

go mod init goodsinfo
go mod tidy

如果出现:

F:\www\go-data\src\go_code\micro\grpc_demo\server\helloworld>go mod tidy
go: finding module for package google.golang.org/protobuf/runtime/protoimpl
go: finding module for package go-micro.dev/v4/logger
go: finding module for package go-micro.dev/v4
go: finding module for package go-micro.dev/v4/server
go: finding module for package go-micro.dev/v4/api
go: finding module for package google.golang.org/protobuf/proto
go: finding module for package google.golang.org/protobuf/reflect/protoreflect
go: finding module for package go-micro.dev/v4/client
go: found go-micro.dev/v4 in go-micro.dev/v4 v4.10.2
go: found go-micro.dev/v4/logger in go-micro.dev/v4/logger v1.18.0
go: found go-micro.dev/v4/api in go-micro.dev/v4/api v1.18.0
go: found go-micro.dev/v4/client in go-micro.dev/v4/client v1.18.0
go: found go-micro.dev/v4/server in go-micro.dev/v4/server v1.18.0
go: found google.golang.org/protobuf/proto in google.golang.org/protobuf v1.30.0
go: found google.golang.org/protobuf/reflect/protoreflect in google.golang.org/protobuf v1.30.0
go: found google.golang.org/protobuf/runtime/protoimpl in google.golang.org/protobuf v1.30.0
go: helloworld/proto imports
        go-micro.dev/v4/api: go-micro.dev/v4/[email protected]: parsing go.mod:
        module declares its path as: github.com/micro/go-micro
                but was required as: go-micro.dev/v4/api

说明下载"go-micro.dev/v4"这个包失败了,这时则需运行命令 go get go-micro.dev/v4,如图:

然后再次执行步骤3中的命令即可

修改远程调用的方法handler/goodsinfo.go

原始的代码: 
package handler

import (
    "context"
    "io"
    "time"
    "go-micro.dev/v4/logger"
    pb "goodsinfo/proto"
)

type Goodsinfo struct{}

func (e *Goodsinfo) Call(ctx context.Context, req *pb.CallRequest, rsp *pb.CallResponse) error {
    logger.Infof("Received Goodsinfo.Call request: %v", req)
    rsp.Msg = "Hello " + req.Name
    return nil
}

func (e *Goodsinfo) ClientStream(ctx context.Context, stream pb.Goodsinfo_ClientStreamStream) error {
    var count int64
    for {
        req, err := stream.Recv()
        if err == io.EOF {
            logger.Infof("Got %v pings total", count)
            return stream.SendMsg(&pb.ClientStreamResponse{Count: count})
        }
        if err != nil {
            return err
        }
        logger.Infof("Got ping %v", req.Stroke)
        count++
    }
}

func (e *Goodsinfo) ServerStream(ctx context.Context, req *pb.ServerStreamRequest, stream pb.Goodsinfo_ServerStreamStream) error {
    logger.Infof("Received Goodsinfo.ServerStream request: %v", req)
    for i := 0; i < int(req.Count); i++ {
        logger.Infof("Sending %d", i)
        if err := stream.Send(&pb.ServerStreamResponse{
            Count: int64(i),
        }); err != nil {
            return err
        }
        time.Sleep(time.Millisecond * 250)
    }
    return nil
}

func (e *Goodsinfo) BidiStream(ctx context.Context, stream pb.Goodsinfo_BidiStreamStream) error {
    for {
        req, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        logger.Infof("Got ping %v", req.Stroke)
        if err := stream.Send(&pb.BidiStreamResponse{Stroke: req.Stroke}); err != nil {
            return err
        }
    }
}
修改成我们想要的代码: 
package handler

import (
    "context"
    "go-micro.dev/v4/logger"
    pb "goodsinfo/proto"
)

type Goodsinfo struct{}

func (e *Goodsinfo) AddGoods(ctx context.Context, req *pb.AddRequest, rsp *pb.AddResponse) error {
    logger.Infof("request: %v", req)
    //书写返回的逻辑结果
    rsp.Message = "增加成功"
    rsp.Success = true
    return nil
}

  1. 配置服务端consul

(1).启动consul

在配置consul之前,需要启动consul,命令行执行命令 :consul agent -dev,启动consul服务, 也可以使用 consul集群相关操作进行处理

(2).引入consul包

然后在servers/goodsinfo/main.go下引入consul包:
可以在import引入包后,执行 go mod tidy ,也可以执行 go get github.com/go-micro/plugins/v4/registry/consul 命令引入 
 github.com/go-micro/plugins/v4/registry/consul

(3).实例化consul: 

consulReg := consul.NewRegistry()

(4).注册consul

srv := micro.NewService(
    micro.Address("192.168.1.132:8080"),  // 选择注册服务器地址,默认为本机,也可以选择consul集群中的client
    micro.Name(service),
    micro.Version(version),
    micro.Registry(consulReg),
)

(5).详细代码

package main

import (

    "goodsinfo/handler"
    pb "goodsinfo/proto"
    "go-micro.dev/v4"
    "go-micro.dev/v4/logger"
    "github.com/go-micro/plugins/v4/registry/consul"
)

var (
    service = "goodsinfo"
    version = "latest"
)

func main() {
    //集成consul
    consulReg := consul.NewRegistry()
    // Create service
    srv := micro.NewService(
        micro.Address("127.0.0.1:8080"),  //指定微服务的ip:  选择注册服务器地址,也可以不配置,默认为本机,也可以选择consul集群中的client
        micro.Name(service),
        micro.Version(version),
        //注册consul
        micro.Registry(consulReg),
    )
    srv.Init(
        micro.Name(service),
        micro.Version(version),
    )

    // Register handler
    if err := pb.RegisterGoodsinfoHandler(srv.Server(), new(handler.Goodsinfo)); err != nil {
        logger.Fatal(err)
    }
    // Run service
    if err := srv.Run(); err != nil {
        logger.Fatal(err)
    }
}

(6).结果显示

展示和上面helloworld类似,微服务服务端就配置并启动了

  1. 生成客户端

(1).生成客户端目录

在client目录下运行 :go-micro new client goodsinfo
目录如下: 结构和服务端结构一致,参考服务端结构
里面也存在 Makefile文件,操作和上面服务端一致, 下面就要让 客户端连接上微服务服务端

(2).创建客户端proto文件相关

这里可以直接把服务端中的proto文件夹复制到goodsinfo-client文件夹下,然后可以初始化项目,删除go.mod, 执行初始化命令 :go mod init goodsinfo-client, go mod tidy

如果出现:

go: goodsinfo-client/proto imports
        go-micro.dev/v4/api: go-micro.dev/v4/[email protected]: parsing go.mod:
        module declares its path as: github.com/micro/go-micro
                but was required as: go-micro.dev/v4/api

则go get go-micro.dev/v4,和上面服务器解决方案一致

当然,也可以再次执行Makefile中的命令,和上面服务器一致

(3).完善goodsinfo-client/main.go文件

1).修改goodsinfo/proto包名字
需要把goodsinfo/proto修改为goodsinfo-client/proto

然后也要引入consul包

2).引入consul包
然后在client/goodsinfo-client/main.go下引入consul包:
可以在import引入包后,执行 go mod tidy ,也可以执行 go get github.com/go-micro/plugins/v4/registry/consul 命令引入 
 github.com/go-micro/plugins/v4/registry/consul
3).实例化consul: 
consulReg := consul.NewRegistry()
4).注册consul
//集成consul
consulReg := consul.NewRegistry(
    //指定微服务的ip:  选择注册服务器地址,默认为本机,也可以选择consul集群中的client
    registry.Addrs("127.0.0.1:8500"),
    )
// Create service
srv := micro.NewService(
    //注册consul
    micro.Registry(consulReg),
)
5).详细代码
package main

import (
    "context"
    "go-micro.dev/v4/registry"
    "time"
    pb "goodsinfo-client/proto"
    "go-micro.dev/v4"
    "go-micro.dev/v4/logger"
    "github.com/go-micro/plugins/v4/registry/consul"
)

var (
    service = "goodsinfo"
    version = "latest"
)

func main() {
    //集成consul
    consulReg := consul.NewRegistry(
        //指定微服务的ip:  选择注册服务器地址,默认为本机,也可以选择consul集群中的client
        registry.Addrs("127.0.0.1:8500"),
        )
    // Create service
    srv := micro.NewService(
        //注册consul
        micro.Registry(consulReg),
    )

    srv.Init()

    // 创建客户端服务
    c := pb.NewGoodsinfoService(service, srv.Client())

    // Call service
    rsp, err := c.AddGoods(context.Background(), &pb.AddRequest{
        Title: "我是一个商品",
        Price: "20.22",
        Content: "内容展示",
    })
    if err != nil {
        logger.Fatal(err)
    }

    logger.Info(rsp)
}
6).结果显示
客户端配置操作完成

[上一节][golang 微服务] 6. GRPC微服务集群+Consul集群+grpc-consul-resolver案例演示

[下一节][golang 微服务] 8.go-micro的负载均衡操作，go Web框(Gin,Beego)调用go-micro微服务

Supongo que te gusta

Origin blog.csdn.net/zhoupenghui168/article/details/131252892
Recomendado
Clasificación
Diario
Más
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)
2024-05-05(0)
2024-05-04(17)
2024-05-03(8)
2024-05-02(0)
2024-05-01(4)
2024-04-30(33)
2024-04-29(5)

Code World

© 2018 codetd.com