go-zero微服务实战——基本环境搭建

最新推荐文章于 2024-05-11 05:54:53 发布
最新推荐文章于 2024-05-11 05:54:53 发布
阅读量1.8k 收藏 6
点赞数 2
分类专栏： 微服务 文章标签： golang 微服务 开发语言 go-zero
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwh3165037789/article/details/131577365
版权

简介

项目架构来源于go-zero实战：让微服务Go起来。此对该项目有所删减，相对简单适合初学者。

省去了项目中每个服务占用独立docker的过程，省略了docker-compose的构建过程。每个服务是一个独立的程序不依赖与容器。

环境搭建

  1. 安装goctl
go install github.com/zeromicro/go-zero/tools/goctl@latest
  1. 安装protoc
goctl env check --install --verbose --force
  1. 安装go-zero
go get -u github.com/zeromicro/go-zero@latest
  1. 生成api标准api服务
goctl api new apiservice
  1. 生成rpc服务
goctl rpc new rpcservice

生成代码后go mod tidy下载所需依赖。

在apiservice目录下的apiservicelogic.go的27行后修改为如下图所示代码：

在这里插入图片描述

删除apiservice目录下etc下的配置文件，在主程序中做如何修改如下修改，直接配置方便一些：

func main() {

	var c config.Config
	c.Host = "0.0.0.0"
	c.Port = 8000

	server := rest.MustNewServer(c.RestConf)
	defer server.Stop()

	ctx := svc.NewServiceContext(c)
	handler.RegisterHandlers(server, ctx)

	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
	server.Start()
}

api服务统一为8000系列的端口。

在rpcservice目录下的yaml配置文件端口修改为9000系。主函数做如下修改：

func main() {
	var c config.Config
	c.ListenOn = "0.0.0.0:9000"
	c.Mode = "dev"
	ctx := svc.NewServiceContext(c)

	s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
		rpcservice.RegisterRpcserviceServer(grpcServer, server.NewRpcserviceServer(ctx))

		if c.Mode == service.DevMode || c.Mode == service.TestMode {
			reflection.Register(grpcServer)
		}
	})
	defer s.Stop()

	fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
	s.Start()
}

启动程序

在这里插入图片描述

在这里插入图片描述

浏览器访问

在这里插入图片描述

rpc客户端访问

新项目复制两个pb文件，编写客户端主程序。

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"rpcclient/rpcservice"
)

func main() {
	//配置连连接参数(无加密)
	dial, _ := grpc.Dial("localhost:9000", grpc.WithTransportCredentials(insecure.NewCredentials()))
	defer dial.Close()
	//创建客户端连接
	client := rpcservice.NewRpcserviceClient(dial)
	//通过客户端调用方法
	res, _ := client.Ping(context.Background(), &rpcservice.Request{Ping: "xiaoxu"})
	fmt.Println(res.Pong)

}

在这里插入图片描述

go-zero api服务构建

整合mysql数据库

构建如项目上的4个服务。4个服务都是上一节构建基本项目为基础的gitee地址

整合数据库就不再过多赘述了，整合xorm框架，返回数据库引擎即可，如下：

xorm实战——结构体映射到实现数据库操作

import (
	"fmt"

	_ "github.com/go-sql-driver/mysql"
	"github.com/go-xorm/xorm"
)

var Engine *xorm.Engine

func init() {
	var err error
	e, err := xorm.NewEngine("mysql", "root:root@/zerotest?charset=utf8")
	if err != nil {
		fmt.Println("数据库连接失败!")
	}
	// err的错误处理
	Engine = e
}

构建mysql数据库后在其他包下通过库名.Engine即可使用数据库引擎。

创建数据库

CREATE TABLE `order` (
  `id` int NOT NULL AUTO_INCREMENT COMMENT '主键',
  `order_id` varchar(100) NOT NULL COMMENT '订单编号',
  `type` tinyint DEFAULT NULL COMMENT '订单类型',
  `customer_id` int DEFAULT NULL COMMENT '用户编号',
  `amount` int DEFAULT NULL COMMENT '数量',
  `payment` tinyint DEFAULT NULL COMMENT '支付方式',
  `status` tinyint DEFAULT NULL COMMENT '状态',
  `create_time` varchar(100) DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='订单表';

控制器逻辑实现

新建logic目录

在这里插入图片描述

创建订单逻辑类

type orderLogic struct{}

var OrderLogic orderLogic

// 创建订单
func (this orderLogic) Create(param models.Order) error {
	param.Id = 0
	_, err := db.Engine.Insert(param)
	if err != nil {
		fmt.Printf("logic module create err:%v", err)
		return err
	}
	return nil
}

//db是构建服务器引擎的包

控制器调用逻辑代码

// create
func OrderCreateController() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		//获取请求参数
		var req models.Order
		err := httpx.ParseJsonBody(r, &req)
		if err != nil {
			//fmt.Printf("ordercontoller err:%v", err)
			httpx.WriteJson(w, 500, fmt.Sprintf("ordercontoller err:%v", err))
			return
		}
		//******************//
		err = orderlogic.OrderLogic.Create(req)
		//******************//
		if err != nil {
			//fmt.Printf("order create err:%v", err)
			httpx.WriteJson(w, 500, fmt.Sprintf("order create err:%v", err))
			return
		}
		httpx.OkJson(w, map[string]string{"code": "200", "message": "插入成功!"})

	}
}

Create方法不使用结构体模拟类，直接是一个函数也是可以的，但是函数就不能重名了，在微服务中可以为单个函数，在单纯的web服务中还是用类实现比较好。

部分代码：

// create
func OrderCreateController() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		//获取请求参数
		var req models.Order
		err := httpx.ParseJsonBody(r, &req)
		if err != nil {
			//fmt.Printf("ordercontoller err:%v", err)
			httpx.WriteJson(w, 500, fmt.Sprintf("ordercontoller err:%v", err))
			return
		}
		err = orderlogic.OrderLogic.Create(req)
		if err != nil {
			//fmt.Printf("order create err:%v", err)
			httpx.WriteJson(w, 500, fmt.Sprintf("order create err:%v", err))
			return
		}
		httpx.OkJson(w, map[string]string{"code": "200", "message": "插入成功!"})

	}
}

// update
func OrderUpdateController() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req models.Order
		err := httpx.ParseJsonBody(r, &req)
		if err != nil {
			httpx.WriteJson(w, 500, fmt.Sprintf("update err:%v", err))
			return
		}
		err = orderlogic.OrderLogic.Update(req)
		if err != nil {
			//...
			return
		}
		httpx.OkJson(w, map[string]string{"code": "200", "message": "更新成功!"})

	}
}

//Remove

func OrderRemove() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req models.Order
		err := httpx.ParseJsonBody(r, &req)
		if err != nil {
			httpx.WriteJson(w, 500, fmt.Sprintf("remove err%v", err))
			return
		}
		err = orderlogic.OrderLogic.Remove(req)
		if err != nil {
			//...
			return
		}
		httpx.OkJson(w, map[string]string{"code": "200", "message": "删除成功!"})
	}
}

//List

func OrderList() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		res, err := orderlogic.OrderLogic.List()
		if err != nil {
			//...
			return
		}
		httpx.OkJson(w, res)
	}
}

逻辑层直接省略了，就是xorm对mysql的CURD操作。

注册路由

func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
	server.AddRoutes(
		[]rest.Route{
			{
				Method:  http.MethodGet,
				Path:    "/from/:name",
				Handler: ApiserviceHandler(serverCtx),
			},
			//自定义路由
			{
				Method: http.MethodPost,
				Path: "/create",
				Handler: OrderCreateController(),
			},
			{
				Method: http.MethodPost,
				Path: "/update",
				Handler: OrderUpdateController(),
			},
			{
				Method: http.MethodPost,
				Path: "/remove",
				Handler: OrderRemove(),
			},
			{
				Method: http.MethodPost,
				Path: "/list",
				Handler: OrderList(),
			},
		},
	)
}

在这里插入图片描述
综上所属，已经成功的构建了一个web服务，包括对订单order的基本操作。

如果不想手写这莫多代码，可以看看zero的api语法，直接使用api文件一键生成更加方便。

go-zero rpc服务构建

在rpc远程调用中主要用于rpc服务器注册本地的方法，实现服务器之间的内部调用。在上述服务中，都是沿用了插件生成的目录，仅修改了部分配置文件。可以参考如下连接的目录结构层次清晰。

go-zero实战

删除旧的rpc服务的所有目录，保留proto文件，添加如下内容：

syntax = "proto3";

package rpcservice;
option go_package="./rpcservice";

message Request {
  string ping = 1;
}

message Response {
  string pong = 1;
}

service Rpcservice {
  rpc Ping(Request) returns(Response);
  // 自定义方法区
  rpc Create (Request) returns (Response);
  rpc Update (Request) returns (Response);
  rpc Remove (Request) returns (Response);
  rpc Detail (Request) returns (Response);
  rpc List (Request) returns (Response);
}

注意这里不再是goctl rpc new [name]了，该命令是一键生成rpc标准服务命令，而需要自定义rpc服务即根据编写的.proto文件生成服务需要使用protobuf插件命令。

protoc-gen-go，protoc-gen-go-grpc

这两个插件在grpc服务中一般是需要独立安装的，但是在go-zero中goctl集成了这两个插件。

protoc --go_out=. *.proto
protoc --go-grpc_out=. *.proto

以下是自定义rpc服务部分，goctl生成直接跳过

运行完指令后在proto文件指定的目录生成了grpc服务源码，如下

在这里插入图片描述

在这里插入图片描述

注意如果之前已经使用了goctl rpc命令，那么目录下不止有这两个文件，建议删除goctl生成的文件自定义构建，因为许多用不着到。goctl生成的代码主要是结合了zrpc.RpcServerConf的配置，即config目录下的对象，如下：

在这里插入图片描述
在goctl生成的代码中也是支持flag库的，如下，这里后续将会改成静态的省去配置文件。
在这里插入图片描述

goctl生成部分

通过两个命令生成rpc服务文件，如下：

在这里插入图片描述

在生成的代码中已经具备了逻辑层的方法，如下：

在这里插入图片描述

修改主程序注释调用flag参数获取功能，原因是api服务和rpc服务中都有独立的yaml文件这是不合理的，两个flag参数获取存在冲突，所以将两个都注册掉改为静态配置，后续可以改为一个配置文件。

//注释掉flag获取参数的部分
func main() {
	flag.Parse()

	var c config.Config
	// conf.MustLoad(*configFile, &c)
	c.ListenOn = "0.0.0.0:9000"
	c.Name = "order.rpc"
	ctx := svc.NewServiceContext(c)
	s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
		rpcservice.RegisterRpcserviceServer(grpcServer, server.NewRpcserviceServer(ctx))

		if c.Mode == service.DevMode || c.Mode == service.TestMode {
			reflection.Register(grpcServer)
		}
	})
	defer s.Stop()

	fmt.Printf("Starting rpc server at %s...\n", c.ListenOn)
	s.Start()
}

修改rpc服务的逻辑如下所示：

在这里插入图片描述
编写客户端访问rpc服务

import (
	"context"
	"fmt"
	"rpcclient/rpcservice"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	//配置连连接参数(无加密)
	dial, _ := grpc.Dial("localhost:9000", grpc.WithTransportCredentials(insecure.NewCredentials()))
	defer dial.Close()
	//创建客户端连接
	client := rpcservice.NewRpcserviceClient(dial)
	//通过客户端调用方法
	res, err := client.Ping(context.Background(), &rpcservice.Request{ReqJson: "xiaoxu"})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)

}

在这里插入图片描述
成功访问，ping的案例是goctl已经实现了的，虽然早proto中编写了自定义的方法，如下

在这里插入图片描述
但是却仍然无法调用，回报未继承的错误，在客户端加入如下代码：

//order list
r, err := client.List(context.Background(), &rpcservice.Request{})
if err != nil {
	fmt.Println(err)
	return
}
fmt.Println(r.ResJson)

在这里插入图片描述

List not implemented该错误的原因时虽然存在该方法名，但方法没有方法体，也就说函数没有将处理逻。

在这里插入图片描述
在服务端通过反射获取到Rpcservice_Ping_FullMethodName的Ping方法，也就是/rpcservice.Rpcservice/Ping的Ping方法。如下图

在这里插入图片描述

该方法就是生成文件的server目录下包的方法，如下：

在这里插入图片描述
在这里插入图片描述

官方提供的方法ping调用了生成的logic的ping方法，其实就是实现了逻辑的解耦，将逻辑功能分隔开来。如下所示，logic层部分只写逻辑处理，在serve下调用逻辑处理部分函数。

在这里插入图片描述
在这里插入图片描述

当然不论如何解耦，核心还是server目录的文件，必须在此处注册逻辑函数，才可以在rpc武器生成函数实例，客户端才可以成功调用。

该方法实际上也是proto中定义的方法的一个重写过程，是接口的是实现。

注册自定义函数

//list 继承
func (s *RpcserviceServer) List(ctx context.Context,in *rpcservice.Request) (*rpcservice.Response, error) {
	//r, err := logic.List(in)
	o, err := orderlogic.OrderLogic.List()
	if err != nil {
		fmt.Printf("rpc err:%v", err)
		return &rpcservice.Response{}, err
	}
	//o 赚json字符串
	josnstr, _ := json.Marshal(o)
	return &rpcservice.Response{ResJson: string(josnstr)}, nil
}

上面代码逻辑部分一起写在rpc方法注册的函数中，当逻辑代码多是就会十分冗余，最好将逻辑部分提取出来封装在新函数中，在注册是调用新方法即可，想官方提供的模板一样。

服务端注册成功后，服务端调用，代码如下：

package main

import (
	"context"
	"fmt"
	"rpcclient/rpcservice"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func main() {
	//配置连连接参数(无加密)
	dial, _ := grpc.Dial("localhost:9000", grpc.WithTransportCredentials(insecure.NewCredentials()))
	defer dial.Close()
	//创建客户端连接
	client := rpcservice.NewRpcserviceClient(dial)
	//通过客户端调用方法
	res, err := client.Ping(context.Background(), &rpcservice.Request{ReqJson: "xiaoxu"})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(res)

	//order list
	r, err := client.List(context.Background(), &rpcservice.Request{})
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(r.ResJson)

}

在这里插入图片描述

别忘了克隆_grpc.pb和pb文件。

到此服务order已经可以同时提供api服务和rpc服务了。

gitee地址：https://gitee.com/fireapproval/xiaoxu/tree/xiaoxu/go/go-zero-test

xvwen
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
微服务框架 go-zero 快速实战
m0_37322399的博客
08-25 917
go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。go-zero 中的 api，rpc，数据库等涉及的代码，都可以给我们一键生成，无需耗费我们什么精力只需要在生成的代码中填入自己的配置以及逻辑即可，轻松获得支撑千万日活服务的稳定性内建级联超时控制、限流、自适应熔断、自适应降载等微服务治理能力，无需配置和额外代码微服务治理中间件可无缝集成到其它现有框架使用极简的 API 描述，一键生成各端代码。
go-zero 微服务实战系列（一、开篇）
xuhss_com的博客
06-06 1674
在社区中经常看到有人问有没有基于 go-zero 的比较完整的项目参考，该类问题本质上是想知道基于 go-zero 的项目的最佳实践。完整的项目应该是一个完整的产品功能，包含产品需求、架构设计、关键流程的编码、表设计以及各种性能优化和数据一致性等，是一个真正贴近生产级的项目，是可以直接拿来在自己的生产项目中进行参考的，而目前社区并没有类似的比较完整的开源项目参考，因此决定和大家一起从零开始基于 go-zero 构建一个完整的贴近生产的项目。该系列的主题是基于 go-zero 构建一个高并发的系统，为神马要选
go-zero微服务框架
weixin_42094245的博客
06-14 4032
Go-Zero 是一个基于 Golang 的微服务框架，可以帮助开发者快速、高效地构建高性能、高可用的分布式应用系统。RPC 框架和 API 网关，支持多种协议和格式，如 gRPC、HTTP、JSON、Thrift 等；支持微服务通讯和服务治理，包括服务发现、负载均衡、链路追踪、熔断和限流等；支持数据存储和访问，包括 MySQL、Redis、MongoDB 等；支持日志和监控，包括 Prometheus、Grafana 和 Graphite 等；
2024年最全如何安全快速的搭建一个微服务架构(1)，深入剖析
最新发布
2401_84544780的博客
05-11 604
目前存在着某种类型的虚拟机（VM），对我来说，就是通常的Java。在虚拟机中应用的功能组件以对象的形式存在，这些对象是在内存中相互通讯的，它们将来来回回处理并进行方法调用。偶尔，你会采用诸如通知等机制来接触到其他系统以便获取数据或传递信息。有了微服务之后，应用程序如何构建的范式是完全不同的了。你的功能组件会从在同一个主机的内存中通过虚拟机相互通讯转变到部署在容器中，并且使用Restful API调用通过HTTP来相互连接。这是非常强大的，因为它赋予了你功能隔离。
go-zero学习 — 基础
Mr_XiMu的博客
03-20 2471
go-zero学习 — 基础
go-zero微服务实战系列（十、分布式事务如何实现）
hjxisking的专栏
11-08 303
在分布式应用场景中，分布式事务问题是不可回避的，在目前流行的微服务场景下更是如此。比如在我们的商城系统中，下单操作涉及创建订单和库存扣减操作两个操作，而订单服务和商品服务是两个独立的微服务，因为每个微服务独占一个数据库实例，所以下单操作就涉及到分布式事务问题，即要把整个下单操作看成一个整体，要么都成功要么都不成功。本篇文章我们就一起来学习下分布式事务的相关知识。
Go framework-go-zero
杀神lwz的博客
09-02 738
go-zero 是一个集成了各种工程实践的 web 和 rpc 框架。通过弹性设计保障了大并发服务端的稳定性，经受了充分的实战检验。go-zero源码地址go-zero官网地址。
Go微服务精讲：Go-Zero全流程实战即时通讯（13章）
03-21
本文将结合经典 IM 项目，带你深入微服务架构精髓，探究主流微服务框架Go-Zero框架底层运作机制和框架自研之道，让你从分布式系统架构设计、容器化部署管理、高并发性能提升、系统监控等，多维度掌握Go开发高薪技能...
13章Go微服务精讲：Go-Zero全流程实战即时通讯
03-29
视频课程下载——【13章】Go微服务精讲：Go-Zero全流程实战即时通讯
2.2.2 云原生go-zero微服务框架设计思考@万俊峰.pdf
09-13
云原生go-zero微服务框架设计思考 云原生go-zero微服务框架设计思考是由万俊峰Kevin分享的关于go-zero微服务框架的设计原则和实现细节的报告。本报告涵盖了go-zero的设计原则、架构选型、微服务代码生成工具goctl、...
[完结13章+电子书]Go微服务精讲：Go-Zero全流程实战即时通讯
04-29
go-zero是一个基于Go语言的Web和微服务开发框架，它提供了一系列的工具和库，帮助开发者构建高性能、可扩展的应用程序。go-zero采用了领域驱动设计（DDD）和依赖注入（DI）等先进的设计理念，使得开发者可以更加轻松...
基于Go-Zero + Ant Design Pro的前后端分离微服务管理系统的前端模
07-03
Go-Zero是用Go语言编写的开源微服务框架，它提供了完整的中间件支持，包括但不限于路由管理、服务注册与发现、熔断器、负载均衡、日志处理和监控等。Go语言以其高性能、并发能力以及简洁的语法，成为构建高并发、低...
Go微服务精讲：Go-Zero全流程实战即时通讯教程
03-21
Go微服务系统精讲 Go-Zero全流程实战即时通讯 ( IM )——随着微服务技术的快速发展，其在各个领域都形成了一系列事实标准，在 Kubernetes 和容器技术加持下，云原生微服务已经成为了主流解决方案。而 Go 语言作为云...
Go微服务精讲：Go-Zero全流程实战即时通讯（完结13章+电子书）
04-29
在go-zero中默认使用的是P2C的负载均衡算法。 算法的原理：即随机从所有可用节点中选择两个节点，然后计算这两个节点的负载情况，选择负载较低的一个节点来服务本次请求。 为了避免某些节点一直得不到选择导致不平衡...
go-zero-master
06-16
"Go-Zero-Master" 是一个基于 Go 语言的微服务框架，专为构建稳定、高性能的分布式系统设计。这个框架的名字来源于“Go Zero”，它强调了在微服务架构中的核心理念：提供稳定的、无错误的服务。下面我们将深入探讨这...
Go微服务精讲：Go-Zero全流程实战即时通讯（13章全+电子书）
04-29
Go语言作为一个轻量级的，高并发的静态编译型语言，其天然的优势使其成为微服务开发的首选语言之一，内置的goroutine和channel机制保证了Go语言在高并发场景下极高的性能和稳定性。如何使用Go语言开发微服务呢？下面...
go-zero docker-compose 搭建课件服务（七）：prometheus+grafana服务监控
liuyuede123的博客
08-28 566
1、什么是prometheusPrometheus是一个开源的系统监控和警报工具包。自2012年启动以来，许多公司和组织都采用了Prometheus，该项目拥有非常活跃的开发人员和用户社区。它现在是一
go 进阶 go-zero相关: 三. go-zero 微服务基础示例
qq_29799655的博客
05-10 1490
编译命令执行完毕后,会生成一下代码:其中 types/XXX/xxx.pb.go文件与types/XXX/xxx_grpc.pb.go是通过proto生成的,参考grpc“xxx.pb.go”: 内部是编写这个rpc服务时自定义的结构体相关处理“xxx_grpc.pb.go”: 内部是启动这个rpc服务端,启动访问这个rpc客户端的相关代码通过go-zero生成的其中user.proto是用来生成rpc服务的IDL文件。
使用go-zero微服务框架实现云监控后台（一.后台微服务搭建）
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
08-08 2280
接上一篇文章，按照”终端出厂实现自动化运维方案"思路,https://blog.csdn.net/yyz_1987/article/details/118358038 以上送终端状态为例，记录下go-zero微服务的简单使用，实现一个简易的后台监控云服务。 新建一个Golang服务后台项目代码的目录，取名monitor。 网关层实现 按照goctl这一代码生成神器的使用方式，首先定义一下终端需要上送的接口字段信息： statusUpload.api type ( //终端状态上报内容 St
go-zero微服务实战系列
04-04
go-zero微服务实战系列是一系列关于如何使用go-zero框架搭建微服务的实践教程。该系列教程包括以下内容： 1. go-zero微服务框架介绍：介绍go-zero框架的基本概念、特点和使用场景，让读者了解框架的优势和适用性。 2. go-zero微服务开发环境搭建：详细介绍如何在本地搭建go-zero开发环境，包括安装go、安装go-zero、安装MySQL等。 3. go-zero微服务入门教程：通过一个简单的示例，讲解如何使用go-zero框架搭建一个简单的微服务，包括定义接口、编写业务逻辑代码、启动服务等。 4. go-zero微服务架构设计：介绍如何设计一个高可用、高性能的微服务架构，包括服务拆分、负载均衡、服务发现等。 5. go-zero微服务部署实践：介绍如何将go-zero微服务部署到云服务器上，并进行监控和部署优化。 通过学习该系列教程，读者可以了解go-zero框架的基本概念和使用方法，掌握微服务架构设计和部署实践的技能，从而在实际开发中使用go-zero框架搭建高质量的微服务应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xvwen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值