2. 程式人生 > 程式設計 >[譯][Part1]使用Go gRPC微服務構建HTTP/REST服務，中介軟體，Kubernetes部署等等

[譯][Part1]使用Go gRPC微服務構建HTTP/REST服務，中介軟體，Kubernetes部署等等

阿新 • • 發佈：2019-12-31

原文：medium.com/@amsokol.co…

關於如何使用一些優秀的框架或者路由來編寫Go REST微服務了已經有很多文章了，當我為我司尋找合適的服務構建方法時，我大量地閱讀了它們。突然間我發現一個非常有趣的方法去構建HTTP/REST微服務，就是用Google開源的protobuf/gRPC框架。我確信已經有很多人聽說過它，甚至有一部分人已經正在使用。但是我相信實際很少人有使用protobuf/gRPC框架來開發HTTP/REST微服務的經驗。我只找到一篇文章(需要翻)在Medium上。

在此我並不打算重複它的內容。我希望通過一步步的引導讓大家學會如何去開發一個簡單的CRUD “To Do List”的微服務通過使用gPRC以及HTTP/REST的後端介面。我會演示如何編寫測試用例以及加入中介軟體（請求ID以及日誌記錄與追蹤）在服務當中。最後甚至還會提供一些例子講述如何構建以及釋出我們的微服務到Kubernetes上。


文章的劃分

整個教程會分為4個部分：

  • Part1 是關於如何構建gRPC CRUD服務端以及客戶端
  • Part2 是關於如何加入HTTP/REST介面到gRPC服務中
  • Part3 是關於如何加入一些中介軟體（例如日誌記錄以及跟蹤）到HTTP/REST介面以及gRPC服務當中
  • Part4 是關於如何編寫Kubernetes deployment的配置檔案，加入health check以及如何構建與釋出專案到Google Cloud的kubernetes叢集上

前期準備

  • 本文並不是一個Go語言的基礎教程，所以需要你已經擁有一定golang的編寫經驗
  • 你需要安裝Go v1.11以上版本，我們將會使用到Go的第三方模組功能
  • 你需要有安裝，配置以及使用SQL資料庫的經驗

API先行

這句話有什麼意義？

  • API定義一定是與程式語言/通訊協議/網路傳輸無關的
  • API定義與API的邏輯實現一定是鬆耦合的
  • API版本化
  • 應該避免手動去同步API定義，API邏輯實現以及API檔案三者的內容，我需要API邏輯實現的腳手架以及API的檔案是根據API定義檔案自動生成的

“To Do List”微服務

“To Do List”微服務允許去管理“To Do”列表，ToDo項包括以下欄位/屬性：

  • ID（unique integer identifier）
  • Title（text）
  • Description（text）
  • Reminder（timestamp）

ToDo服務包含典型的增刪改查以及獲取全部項方法。


建立gRPC CRUD服務

Step1: 建立API定義

Part1完整程式碼戳這裡


開始之前我們先構建一個專案的骨架，這裡又一個非常優秀的Go專案的腳手架模板

我是用的是Windows 10 x64執行環境，但是我想你將我接下來的cmd指令轉換成MacOs/Linux BASH應該不是什麼大問題


首先建立資料夾並初始化專案

mkdir go-grpc-http-rest-microservice-tutorial
cd go-grpc-http-rest-microservice-tutorial
go mod init github.com/<you>/go-grpc-http-rest-microservice-tutorial
複製程式碼

在你的專案裡面建立檔案目錄如下

mkdir -p api\proto\v1
複製程式碼

這裡的v1就是我們API的版本號

API版本化：通過將不同版本的API程式碼放到不同資料夾裡面並以此命名是我的最佳實踐


下一步就是在剛建立的v1資料夾裡面建立todo-service.proto檔案並加入ToDo服務的定義，我們先從Create方法寫起：

syntax = "proto3";
package v1;

import "google/protobuf/timestamp.proto";

// Taks we have to do
message ToDo {
    // Unique integer identifier of the todo task
    int64 id = 1;
    // Title of the task
    string title = 2;
    // Detail description of the todo task
    string description = 3;
    // Date and time to remind the todo task
    google.protobuf.Timestamp reminder = 4;
}

// Request data to create new todo task
message CreateRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Task entity to add
    ToDo toDo = 2;
}

// Response that contains data for created todo task
message CreateResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // ID of created task
    int64 id = 2;
}

// Service to manage list of todo tasks
service ToDoService {
    // Create new todo task
    rpc Create(CreateRequest) returns (CreateResponse);
}
複製程式碼

戳我檢視Proto的編寫語法

如你所見，API定義是跟程式語言，通訊協議以及網路傳輸無關的，這也是protobuf的一個重要標誌

為了能編譯proto檔案我們需要安裝一些工具和依賴

  • 下載proto編譯器的二進位制檔案，戳這裡
  • 解壓安裝包到任何目錄，並在bin目錄下加入環境環境變數
  • 建立third_party資料夾在go-grpc-http-rest-microservice-tutorial裡面
  • 複製所有Proto編譯器裡面include資料夾裡面的內容到third_party中
  • 為Proto編譯器安裝Go語言程式碼生成器外掛
go get -u github.com/golang/protobuf/protoc-gen-go
複製程式碼
  • 確保我們在go-grpc-http-rest-microservice-tutorial目錄下執行
# Windows:
.\third_party\protoc-gen.cmd

# MasOS/Linux:
./third_party/protoc-gen.sh
複製程式碼

執行以後會建立一個名為todo-service.pb.go的檔案在pkg/model/v1下


接下來讓我們將剩下的方法駕到ToDo服務當中並編譯

syntax = "proto3";
package v1;

import "google/protobuf/timestamp.proto";

// Taks we have to do
message ToDo {
    // Unique integer identifier of the todo task
    int64 id = 1;

    // Title of the task
    string title = 2;

    // Detail description of the todo task
    string description = 3;

    // Date and time to remind the todo task
    google.protobuf.Timestamp reminder = 4;
}

// Request data to create new todo task
message CreateRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Task entity to add
    ToDo toDo = 2;
}

// Contains data of created todo task
message CreateResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // ID of created task
    int64 id = 2;
}

// Request data to read todo task
message ReadRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Unique integer identifier of the todo task
    int64 id = 2;
}

// Contains todo task data specified in by ID request
message ReadResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Task entity read by ID
    ToDo toDo = 2;
}

// Request data to update todo task
message UpdateRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Task entity to update
    ToDo toDo = 2;
}

// Contains status of update operation
message UpdateResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Contains number of entities have beed updated
    // Equals 1 in case of succesfull update
    int64 updated = 2;
}

// Request data to delete todo task
message DeleteRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Unique integer identifier of the todo task to delete
    int64 id = 2;
}

// Contains status of delete operation
message DeleteResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // Contains number of entities have beed deleted
    // Equals 1 in case of succesfull delete
    int64 deleted = 2;
}

// Request data to read all todo task
message ReadAllRequest{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;
}

// Contains list of all todo tasks
message ReadAllResponse{
    // API versioning: it is my best practice to specify version explicitly
    string api = 1;

    // List of all todo tasks
    repeated ToDo toDos = 2;
}

// Service to manage list of todo tasks
service ToDoService {
    // Create new todo task
    rpc Create(CreateRequest) returns (CreateResponse);

    // Read todo task
    rpc Read(ReadRequest) returns (ReadResponse);

    // Update todo task
    rpc Update(UpdateRequest) returns (UpdateResponse);

    // Delete todo task
    rpc Delete(DeleteRequest) returns (DeleteResponse);

    // Read all todo tasks
    rpc ReadAll(ReadAllRequest) returns (ReadAllResponse);
}
複製程式碼

再一次執行以下命令來更新Go的程式碼

# Windows:
.\third_party\protoc-gen.cmd

# MasOS/Linux:
./third_party/protoc-gen.sh
複製程式碼

到此為止，API的定義就完成了


Step2: Go實現API邏輯

我是使用Google Cloud上的MySQL作為資料庫來持久化做儲存的。你可以使用其他你喜歡的SQL資料庫。

建立ToDo table的MySQL指令碼

CREATE TABLE `ToDo` (
  `ID` bigint(20) NOT NULL AUTO_INCREMENT,`Title` varchar(200) DEFAULT NULL,`Description` varchar(1024) DEFAULT NULL,`Reminder` timestamp NULL DEFAULT NULL,PRIMARY KEY (`ID`),UNIQUE KEY `ID_UNIQUE` (`ID`)
);
複製程式碼

我會跳過如何安裝配置SQL資料庫以及建立資料表的步驟

建立檔案pkg/service/v1/todo-service.go以及下面的內容

package v1

import (
	"context"
	"database/sql"
	"fmt"
	"time"

	"github.com/golang/protobuf/ptypes"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/api/v1"
)

const (
	// apiVersion is version of API is provided by server
	apiVersion = "v1"
)

// toDoServiceServer is implementation of v1.ToDoServiceServer proto interface
type toDoServiceServer struct {
	db *sql.DB
}

// NewToDoServiceServer creates ToDo service
func NewToDoServiceServer(db *sql.DB) v1.ToDoServiceServer {
	return &toDoServiceServer{db: db}
}

// checkAPI checks if the API version requested by client is supported by server
func (s *toDoServiceServer) checkAPI(api string) error {
	// API version is "" means use current version of the service
	if len(api) > 0 {
		if apiVersion != api {
			return status.Errorf(codes.Unimplemented,"unsupported API version: service implements API version '%s',but asked for '%s'",apiVersion,api)
		}
	}
	return nil
}

// connect returns SQL database connection from the pool
func (s *toDoServiceServer) connect(ctx context.Context) (*sql.Conn,error) {
	c,err := s.db.Conn(ctx)
	if err != nil {
		return nil,status.Error(codes.Unknown,"failed to connect to database-> "+err.Error())
	}
	return c,nil
}

// Create new todo task
func (s *toDoServiceServer) Create(ctx context.Context,req *v1.CreateRequest) (*v1.CreateResponse,error) {
	// check if the API version requested by client is supported by server
	if err := s.checkAPI(req.Api); err != nil {
		return nil,err
	}

	// get SQL connection from pool
	c,err := s.connect(ctx)
	if err != nil {
		return nil,err
	}
	defer c.Close()

	reminder,err := ptypes.Timestamp(req.ToDo.Reminder)
	if err != nil {
		return nil,status.Error(codes.InvalidArgument,"reminder field has invalid format-> "+err.Error())
	}

	// insert ToDo entity data
	res,err := c.ExecContext(ctx,"INSERT INTO ToDo(`Title`,`Description`,`Reminder`) VALUES(?,?,?)",req.ToDo.Title,req.ToDo.Description,reminder)
	if err != nil {
		return nil,"failed to insert into ToDo-> "+err.Error())
	}

	// get ID of creates ToDo
	id,err := res.LastInsertId()
	if err != nil {
		return nil,"failed to retrieve id for created ToDo-> "+err.Error())
	}

	return &v1.CreateResponse{
		Api: apiVersion,Id:  id,},nil
}

// Read todo task
func (s *toDoServiceServer) Read(ctx context.Context,req *v1.ReadRequest) (*v1.ReadResponse,err
	}
	defer c.Close()

	// query ToDo by ID
	rows,err := c.QueryContext(ctx,"SELECT `ID`,`Title`,`Reminder` FROM ToDo WHERE `ID`=?",req.Id)
	if err != nil {
		return nil,"failed to select from ToDo-> "+err.Error())
	}
	defer rows.Close()

	if !rows.Next() {
		if err := rows.Err(); err != nil {
			return nil,"failed to retrieve data from ToDo-> "+err.Error())
		}
		return nil,status.Error(codes.NotFound,fmt.Sprintf("ToDo with ID='%d' is not found",req.Id))
	}

	// get ToDo data
	var td v1.ToDo
	var reminder time.Time
	if err := rows.Scan(&td.Id,&td.Title,&td.Description,&reminder); err != nil {
		return nil,"failed to retrieve field values from ToDo row-> "+err.Error())
	}
	td.Reminder,err = ptypes.TimestampProto(reminder)
	if err != nil {
		return nil,"reminder field has invalid format-> "+err.Error())
	}

	if rows.Next() {
		return nil,fmt.Sprintf("found multiple ToDo rows with ID='%d'",req.Id))
	}

	return &v1.ReadResponse{
		Api:  apiVersion,ToDo: &td,nil

}

// Update todo task
func (s *toDoServiceServer) Update(ctx context.Context,req *v1.UpdateRequest) (*v1.UpdateResponse,"reminder field has invalid format-> "+err.Error())
	}

	// update ToDo
	res,"UPDATE ToDo SET `Title`=?,`Description`=?,`Reminder`=? WHERE `ID`=?",reminder,req.ToDo.Id)
	if err != nil {
		return nil,"failed to update ToDo-> "+err.Error())
	}

	rows,err := res.RowsAffected()
	if err != nil {
		return nil,"failed to retrieve rows affected value-> "+err.Error())
	}

	if rows == 0 {
		return nil,req.ToDo.Id))
	}

	return &v1.UpdateResponse{
		Api:     apiVersion,Updated: rows,nil
}

// Delete todo task
func (s *toDoServiceServer) Delete(ctx context.Context,req *v1.DeleteRequest) (*v1.DeleteResponse,err
	}
	defer c.Close()

	// delete ToDo
	res,"DELETE FROM ToDo WHERE `ID`=?","failed to delete ToDo-> "+err.Error())
	}

	rows,req.Id))
	}

	return &v1.DeleteResponse{
		Api:     apiVersion,Deleted: rows,nil
}

// Read all todo tasks
func (s *toDoServiceServer) ReadAll(ctx context.Context,req *v1.ReadAllRequest) (*v1.ReadAllResponse,err
	}
	defer c.Close()

	// get ToDo list
	rows,`Reminder` FROM ToDo")
	if err != nil {
		return nil,"failed to select from ToDo-> "+err.Error())
	}
	defer rows.Close()

	var reminder time.Time
	list := []*v1.ToDo{}
	for rows.Next() {
		td := new(v1.ToDo)
		if err := rows.Scan(&td.Id,&reminder); err != nil {
			return nil,"failed to retrieve field values from ToDo row-> "+err.Error())
		}
		td.Reminder,err = ptypes.TimestampProto(reminder)
		if err != nil {
			return nil,"reminder field has invalid format-> "+err.Error())
		}
		list = append(list,td)
	}

	if err := rows.Err(); err != nil {
		return nil,"failed to retrieve data from ToDo-> "+err.Error())
	}

	return &v1.ReadAllResponse{
		Api:   apiVersion,ToDos: list,nil
}
複製程式碼

為API邏輯實現建立檔案pkg/service/v1/todo-service.go 最後檔案目錄如下


Step3:為API邏輯實現編寫測試用例

不管我們開發什麼都應該編寫測試用例。這是強制遵守的規定。

這裡有一個很棒的模擬庫，用於測試SQL資料庫的互動go-sqlmock.我將會使用它為我們的ToDo服務編寫測試用例。

將這個檔案放到pkg/service/v1目錄下，當前專案檔案結構如下


Step4:編寫gRPC服務端

建立檔案pkg/protocol/grpc/server.go並寫入

package grpc

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

	"google.golang.org/grpc"

	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/api/v1"
)

// RunServer runs gRPC service to publish ToDo service
func RunServer(ctx context.Context,v1API v1.ToDoServiceServer,port string) error {
	listen,err := net.Listen("tcp",":"+port)
	if err != nil {
		return err
	}

	// register service
	server := grpc.NewServer()
	v1.RegisterToDoServiceServer(server,v1API)

	// graceful shutdown
	c := make(chan os.Signal,1)
	signal.Notify(c,os.Interrupt)
	go func() {
		for range c {
			// sig is a ^C,handle it
			log.Println("shutting down gRPC server...")

			server.GracefulStop()

			<-ctx.Done()
		}
	}()

	// start gRPC server
	log.Println("starting gRPC server...")
	return server.Serve(listen)
}
複製程式碼

RunServer函式負責註冊ToDo服務以及啟動gRPC服務

你需要給gPRC服務配置TLS，檢視示例學習如何配置



接下來建立pkg/cmd/server/server.go以及對應內容

package cmd

import (
	"context"
	"database/sql"
	"flag"
	"fmt"

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

	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/protocol/grpc"
	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/service/v1"
)

// Config is configuration for Server
type Config struct {
	// gRPC server start parameters section
	// gRPC is TCP port to listen by gRPC server
	GRPCPort string

	// DB Datastore parameters section
	// DatastoreDBHost is host of database
	DatastoreDBHost string
	// DatastoreDBUser is username to connect to database
	DatastoreDBUser string
	// DatastoreDBPassword password to connect to database
	DatastoreDBPassword string
	// DatastoreDBSchema is schema of database
	DatastoreDBSchema string
}

// RunServer runs gRPC server and HTTP gateway
func RunServer() error {
	ctx := context.Background()

	// get configuration
	var cfg Config
	flag.StringVar(&cfg.GRPCPort,"grpc-port","","gRPC port to bind")
	flag.StringVar(&cfg.DatastoreDBHost,"db-host","Database host")
	flag.StringVar(&cfg.DatastoreDBUser,"db-user","Database user")
	flag.StringVar(&cfg.DatastoreDBPassword,"db-password","Database password")
	flag.StringVar(&cfg.DatastoreDBSchema,"db-schema","Database schema")
	flag.Parse()

	if len(cfg.GRPCPort) == 0 {
		return fmt.Errorf("invalid TCP port for gRPC server: '%s'",cfg.GRPCPort)
	}

	// add MySQL driver specific parameter to parse date/time
	// Drop it for another database
	param := "parseTime=true"

	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s",cfg.DatastoreDBUser,cfg.DatastoreDBPassword,cfg.DatastoreDBHost,cfg.DatastoreDBSchema,param)
	db,err := sql.Open("mysql",dsn)
	if err != nil {
		return fmt.Errorf("failed to open database: %v",err)
	}
	defer db.Close()

	v1API := v1.NewToDoServiceServer(db)

	return grpc.RunServer(ctx,v1API,cfg.GRPCPort)
}
複製程式碼

RunServer函式負責讀取命令列輸入的引數，建立資料庫連線，建立ToDo服務例項以及呼叫之前gPRC服務中的RunServer函式


最後建立以下檔案cmd/server/main.go以及內容

package main

import (
	"fmt"
	"os"

	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/cmd"
)

func main() {
	if err := cmd.RunServer(); err != nil {
		fmt.Fprintf(os.Stderr,"%v\n",err)
		os.Exit(1)
	}
}
複製程式碼

以上就是服務端所有的程式碼了，當前專案目錄如下


Step5: 建立gRPC客戶端

建立檔案cmd/client-grpc/main.go以及以下內容

package main

import (
	"context"
	"flag"
	"log"
	"time"

	"github.com/golang/protobuf/ptypes"
	"google.golang.org/grpc"

	"github.com/amsokol/go-grpc-http-rest-microservice-tutorial/pkg/api/v1"
)

const (
	// apiVersion is version of API is provided by server
	apiVersion = "v1"
)

func main() {
	// get configuration
	address := flag.String("server","gRPC server in format host:port")
	flag.Parse()

	// Set up a connection to the server.
	conn,err := grpc.Dial(*address,grpc.WithInsecure())
	if err != nil {
		log.Fatalf("did not connect: %v",err)
	}
	defer conn.Close()

	c := v1.NewToDoServiceClient(conn)

	ctx,cancel := context.WithTimeout(context.Background(),5*time.Second)
	defer cancel()

	t := time.Now().In(time.UTC)
	reminder,_ := ptypes.TimestampProto(t)
	pfx := t.Format(time.RFC3339Nano)

	// Call Create
	req1 := v1.CreateRequest{
		Api: apiVersion,ToDo: &v1.ToDo{
			Title:       "title (" + pfx + ")",Description: "description (" + pfx + ")",Reminder:    reminder,}
	res1,err := c.Create(ctx,&req1)
	if err != nil {
		log.Fatalf("Create failed: %v",err)
	}
	log.Printf("Create result: <%+v>\n\n",res1)

	id := res1.Id

	// Read
	req2 := v1.ReadRequest{
		Api: apiVersion,}
	res2,err := c.Read(ctx,&req2)
	if err != nil {
		log.Fatalf("Read failed: %v",err)
	}
	log.Printf("Read result: <%+v>\n\n",res2)

	// Update
	req3 := v1.UpdateRequest{
		Api: apiVersion,ToDo: &v1.ToDo{
			Id:          res2.ToDo.Id,Title:       res2.ToDo.Title,Description: res2.ToDo.Description + " + updated",Reminder:    res2.ToDo.Reminder,}
	res3,err := c.Update(ctx,&req3)
	if err != nil {
		log.Fatalf("Update failed: %v",err)
	}
	log.Printf("Update result: <%+v>\n\n",res3)

	// Call ReadAll
	req4 := v1.ReadAllRequest{
		Api: apiVersion,}
	res4,err := c.ReadAll(ctx,&req4)
	if err != nil {
		log.Fatalf("ReadAll failed: %v",err)
	}
	log.Printf("ReadAll result: <%+v>\n\n",res4)

	// Delete
	req5 := v1.DeleteRequest{
		Api: apiVersion,}
	res5,err := c.Delete(ctx,&req5)
	if err != nil {
		log.Fatalf("Delete failed: %v",err)
	}
	log.Printf("Delete result: <%+v>\n\n",res5)
}
複製程式碼

以上就是客戶端所有程式碼，當前專案目錄如下


Step6: 啟動gRPC的客戶端和服務端

最後一步驟是確保gPRC服務能跑起來

開啟一個終端build以及run gRPC服務（將下面資料庫連線的引數替代成你自己的資料庫配置）

cd cmd/server
go build .
server.exe -grpc-port=9090 -db-host=<HOST>:3306 -db-user=<USER> -db-password=<PASSWORD> -db-schema=<SCHEMA>
複製程式碼

如果能看到

2018/09/09 08:02:16 starting gRPC server...
複製程式碼

證明我們的服務已經被啟動起來了

開啟另一個終端build和run gRPC客戶端

cd cmd/client-grpc
go build .
client-grpc.exe -server=localhost:9090
複製程式碼

如果能看到以下資訊：

2018/09/09 09:16:01 Create result: <api:"v1" id:13 >
2018/09/09 09:16:01 Read result: <api:"v1" toDo:<id:13 title:"title (2018-09-09T06:16:01.5755011Z)" description:"description (2018-09-09T06:16:01.5755011Z)" reminder:<seconds:1536473762 > > >
2018/09/09 09:16:01 Update result: <api:"v1" updated:1 >
2018/09/09 09:16:01 ReadAll result: <api:"v1" toDos:<id:9 title:"title (2018-09-09T04:45:16.3693282Z)" description:"description (2018-09-09T04:45:16.3693282Z)" reminder:<seconds:1536468316 > > toDos:<id:10 title:"title (2018-09-09T04:46:00.7490565Z)" description:"description (2018-09-09T04:46:00.7490565Z)" reminder:<seconds:1536468362 > > toDos:<id:13 title:"title (2018-09-09T06:16:01.5755011Z)" description:"description (2018-09-09T06:16:01.5755011Z) + updated" reminder:<seconds:1536473762 > > >
2018/09/09 09:16:01 Delete result: <api:"v1" deleted:1 >
複製程式碼

所有東西都正常運作了！



以上就是Part1的全部內容了，我們成功構建了gRPC的客戶端以及服務端

Part1的原始碼在此處

接下來 Part2是講述如何在我們本章建立的gRPC服務上增加HTTP/REST介面，敬請期待。

感謝收看！????

相關推薦

[譯][Part1]使用Go gRPC微服務構建HTTP/REST服務，中介軟體，Kubernetes部署等等

原文：medium.com/@amsokol.co… 關於如何使用一些優秀的框架或者路由來編寫Go REST微服務了已經有很多文章了，當我為我司尋找合適的服務構建方法時，我大量地閱讀了它們。突然間我發現一個非常有趣的方法去構建

使用SpringBoot構建REST服務-什麼是REST服務

前言： 本文按照Spring官網構建REST服務的步驟測試，可以得到結論： 到底什麼樣的風格才是RESTful風格呢？

記錄go-python微服務實踐，希望能幫助需要的人

介紹 本文講述如何使用 grpc，由 go 作為客戶端，python 作為服務端進行通訊。 （題外：一直迷惑於怎樣讓他們兩個連起來，後來才發現只要對同一個proto檔案進行編譯就好了。。。?）

【譯】遷移至微服務——比你想象的更加簡單

原文連結 遷移到微服務的路線圖 遷移到微服務聽起來似乎是一項巨大而複雜的任務。雖然過程可能稍顯複雜，但實際上比你想象的更為簡單。這篇部落格以一個標準的J2EE應用程式為例建立了一個基礎遷移路線圖，從一體化架

Golang gRPC筆記04 同時提供 gRPC 服務和 HTTP 介面

一、 gRPC 和 HTTP 我們通常把 RPC 用作內部通訊，而使用 Restful Api 進行外部通訊。在某些時候，我們需要同時提供 RPC 服務和 HTTP 介面，

Go Micro 微服務搭建

最近因為要用到 go-micro，所以在學習微服務相關的內容，這一篇是記錄 micro 的搭建過程。

微服務構建專案(二) Ribbon+restTemplate和openfeign實現遠端呼叫的區別

一、Ribbon實現遠端呼叫 服務消費者訂單模組OrderService.java，用於遠端呼叫服務提供者會員模組。

微服務構建專案(四)使用nacos作為配置中心

nacos不僅能作為服務註冊中心，還可以作為配置中心，實現動態配置的功能。以下介紹nacos作為服務註冊中心的步驟：

微服務構建專案(四) nacos叢集構建

nacos支援三種部署方式：單節點、叢集、多叢集。一般在聯絡的時候單節點就可以了，但是在生產環境中，為提高專案的穩定性，需要部署nacos叢集。

GO-GRPC實踐(一) 完成第一個GRPC介面並使用etcd作為服務註冊和發現

https://me1onrind.github.io/2021/06/06/grpc_one/ demo程式碼地址 https://github.com/Me1onRind/go-demo

近期業務大量突增微服務效能優化總結-4.增加對於同步微服務的 HTTP 請求等待佇列的監控

最近，業務增長的很迅猛，對於我們後臺這塊也是一個不小的挑戰，這次遇到的核心業務介面的效能瓶頸，並不是單獨的一個問題導致的，而是幾個問題揉在一起：我們解決一個之後，發上線，之後發現還有另一個的效能瓶頸問

Go 框架學習之旅 ① 深入解析 net/http 啟動服務的層級邏輯

選擇框架 有的同學喜歡追求最全的框架，覺得功能越多越好，但是往往並不是每一個功能都能在實際工作中用到；有的同學喜歡追求效能最高的框架，但是總覺得用起來非常彆扭；也常有同學會認為框架無好壞，每個框架基本都

Golang構建HTTP服務（一）--- net/http庫原始碼筆記

實現一個最簡單HTTP server需要多少程式碼？只需要一行，Python2的python -m SimpleHTTPServer，ruby的ruby -run -e httpd . -p 8888。對於Golang，實現一個最簡單的http server也用不著幾行，卻能帶來更具殺傷力的效

Golang構建HTTP服務（二）--- Handler，ServeMux與中介軟體

Golang標準庫http包提供了基礎的http服務，這個服務又基於Handler介面和ServeMux結構的做Mutilpexer。實際上，go的作者設計Handler這樣的介面，不僅提供了預設的ServeMux物件，開發者也可以自定義ServeMux物件。

Spring Cloud構建微服務架構：分散式服務跟蹤（抽樣收集）【Dalston版】

通過 TraceID和 SpanID已經實現了對分散式系統中的請求跟蹤，而這些記錄的跟蹤資訊最終會被分析系統收集起來，並用來實現對分散式系統的監控和分析功能，比如：預警延遲過長的請求鏈路、查詢請求鏈路的呼叫明細等。此

Spring Cloud構建微服務架構：分散式服務跟蹤（收集原理）【Dalston版】

在本節內容之前，我們已經對如何引入Sleuth跟蹤資訊和搭建Zipkin服務端分析跟蹤延遲的過程做了詳細的介紹，相信大家對於Sleuth和Zipkin已經有了一定的感性認識。接下來，我們介紹一下關於Zipkin收集跟蹤資訊的過程細

Spring Cloud構建微服務架構：分散式服務跟蹤（整合logstash）【Dalston版】

通過之前的《入門示例》，我們已經為兩個由SpringCloud構建的微服務專案 trace-1和 trace-2引入了Spring Cloud Sleuth的基礎模組 spring-cloud-starter-sleuth，實現了為各微服務的日誌資訊中新增跟蹤資訊的功能。但

Spring Cloud構建微服務架構：分散式服務跟蹤（整合zipkin）【Dalston版】

通過上一篇《分散式服務跟蹤（整合logstash）》，我們雖然已經能夠利用ELK平臺提供的收集、儲存、搜尋等強大功能，對跟蹤資訊的管理和使用已經變得非常便利。但是，在ELK平臺中的資料分析維度缺少對請求鏈路中各階段

Spring Cloud構建微服務架構：分散式服務跟蹤（入門）

通過之前的N篇博文介紹，實際上我們已經能夠通過使用它們搭建起一個基礎的微服務架構系統來實現我們的業務需求了。但是，隨著業務的發展，我們的系統規模也會變得越來越大，各微服務間的呼叫關係也變得越來越錯綜複雜

Spring Cloud構建微服務架構：分散式服務跟蹤（跟蹤原理）

通過上一篇《分散式服務跟蹤（入門）》的例子，我們已經通過Spring Cloud Sleuth往微服務應用中添加了實現分散式跟蹤具備的基本要素。下面通過本文來詳細說說實現分散式服務跟蹤的一些要點。