Microservice

In the previous article, we have demonstrated how to quickly create a monolithic service. Next, let’s demonstrate how to quickly create a microservice. In this section, the api part is actually the same as the creation logic of the monolithic service, except that there is no communication between services in the monolithic service. And the api service in the microservice will have more rpc call configuration.

This section will briefly demonstrate with an calling user service. The demo code only conveys ideas, and some links will not be listed one by one.

Scenario summary

Suppose we are developing a mall project, and the developer Xiao Ming is responsible for the development of the user module (user) and the order module (order). Let’s split these two modules into two microservices.①

  • Order service (order) provides a query interface
  • User service (user) provides a method for order service to obtain user information

Service design analysis

According to the scenario summary, we can know that the order is directly facing the user, and the data is accessed through the http protocol, and some basic data of the user needs to be obtained inside the order. Since our service adopts the microservice architecture design, Then two services (user, order) must exchange data. The data exchange between services is the communication between services. At this point, it is also a developer’s need to adopt a reasonable communication protocol. For consideration, communication can be carried out through http, rpc and other methods. Here we choose rpc to implement communication between services. I believe that I have already made a better scenario description of “What is the role of rpc service?”. Of course, there is much more than this design analysis before a service is developed, and we will not describe it in detail here. From the above, we need:

  • user rpc
  • order api

two services to initially implement this small demo.

Create user rpc service

    1.   $ cd ~/go-zero-demo/mall
    2.   $ mkdir -p user/rpc&&cd user/rpc

  • Add user.proto file, add getUser method

    1.   $ vim ~/go-zero-demo/mall/user/user.proto
    1.   syntax = "proto3";
    3.   package user;
    5.   message IdRequest {
    6.       string id = 1;
    7.   }
    9.   message UserResponse {
    10.       string id = 1;
    11.       string name = 2;
    12.       string gender = 3;
    13.   }
    15.   service User {
    16.       rpc getUser(IdRequest) returns(UserResponse);
    17.   }

  • Generate code

    1.   $ cd ~/go-zero-demo/mall/user/rpc
    2.   $ goctl rpc proto -src user.proto -dir .
    3.   protoc  -I=/Users/xx/mall/user user.proto --go_out=plugins=grpc:/Users/xx/mall/user/user
    4.   Done.

  • Fill in business logic

    1.   $ vim internal/logic/getuserlogic.go
    1.   package logic
    3.   import (
    4.       "context"
    6.       "go-zero-demo/mall/user/internal/svc"
    7.       "go-zero-demo/mall/user/user"
    9.       "github.com/tal-tech/go-zero/core/logx"
    11.   type GetUserLogic struct {
    12.       ctx    context.Context
    14.       logx.Logger
    15.   }
    17.   func NewGetUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserLogic {
    18.       return &GetUserLogic{
    19.           ctx:    ctx,
    20.           svcCtx: svcCtx,
    21.           Logger: logx.WithContext(ctx),
    22.       }
    23.   }
    25.   func (l *GetUserLogic) GetUser(in *user.IdRequest) (*user.UserResponse, error) {
    26.       return &user.UserResponse{
    27.           Id:   "1",
    28.           Name: "test",
    29.       }, nil
    30.   }

  • Create an order api service

    1.   $ cd ~/go-zero-demo/mall
    2.   $ mkdir -p order/api&&cd order/api

  • Add api file

    1.   type(
    2.       OrderReq {
    3.           Id string `path:"id"`
    4.       }
    6.       OrderReply {
    7.           Id string `json:"id"`
    8.           Name string `json:"name"`
    9.       }
    10.   )
    11.   service order {
    12.       @handler getOrder
    13.       get /api/order/get/:id (OrderReq) returns (OrderReply)
    14.   }
  • Generate order service
    1.   $ goctl api go -api order.api -dir .
    2.   Done.

  • Add user rpc configuration

    1.   $ vim internal/config/config.go
    1.   package config
    3.   import "github.com/tal-tech/go-zero/rest"
    6.   type Config struct {
    7.       rest.RestConf
    8.       UserRpc zrpc.RpcClientConf
    1.   $ vim etc/order.yaml
    1.   Name: order
    2.   Host: 0.0.0.0
    3.   Port: 8888
    4.   UserRpc:
    5.     Etcd:
    6.       Hosts:
    7.       - 127.0.0.1:2379
    8.       Key: user.rpc

  • Improve service dependence

    1.   $ vim internal/svc/servicecontext.go

  • Add order demo logic

    Add business logic to getorderlogic

    1. $ vim ~/go-zero-demo/mall/order/api/internal/logic/getorderlogic.go
    1. user, err := l.svcCtx.UserRpc.GetUser(l.ctx, &userclient.IdRequest{
    2.     Id: "1",
    3. })
    4. if err != nil {
    5.     return nil, err
    6. }
    8. if user.Name != "test" {
    9.     return nil, errors.New("User does not exist")
    10. }
    12. return &types.OrderReply{
    13.     Id:   req.Id,
    14.     Name: "test order",
    15. }, nil

Start the service and verify

  • Start etcd
    1. $ etcd

  • Start user rpc

    1. $ go run user.go -f etc/user.yaml
    1. Starting rpc server at 127.0.0.1:8080...

  • Start order api

    1. $ go run order.go -f etc/order.yaml
    1. Starting server at 0.0.0.0:8888...

  • Access order api

    1. HTTP/1.1 200 OK
    2. Content-Type: application/json
    3. Date: Sun, 07 Feb 2021 03:45:05 GMT
    4. Content-Length: 30
    6. {"id":"1","name":"test order"}

Source code

Guess you wants