[譯] 使用 Go 編寫微服務及其 GraphQL 閘道器

歐長坤發表於2019-03-03

原文地址：Using GraphQL with Microservices in Go

原文作者：Tin Rabzelj

譯文出自：掘金翻譯計劃

本文永久連結：github.com/xitu/gold-m…

譯者：Changkun Ou

校對者：razertory

幾個月前，一個優秀的 GraphQL Go 包 vektah/gqlgen 開始流行。本文描述了在 Spidey 專案（一個線上商店的基本微服務）中如何實現 GraphQL。

下面列出的一些程式碼可能存在一些缺失，完整的程式碼請訪問 GitHub。

架構

Spidey 包含了三個不同的服務並暴露給了 GraphQL 閘道器。叢集內部的通訊則通過 gRPC 來完成。

賬戶服務管理了所有的賬號；目錄服務管理了所有的產品；訂單服務則處理了所有的訂單建立行為。它會與其他兩個服務進行通訊來告知訂單是否正常完成。

獨立的服務包含三層：Server 層、Service 層以及Repository 層。服務端作負責通訊，也就是 Spidey 中使用 gRPC。服務則包含了業務邏輯。倉庫則負責對資料庫進行讀寫操作。

起步

執行 Spidey 需要 Docker、 Docker Compose、 Go、 Protocol Buffers 編譯器及其 Go 外掛以及非常有用的 vektah/gqlgen 包。

你還需要安裝 vgo（一個處於早期開發階段的包管理工具）。工具 dep 也是一種選擇，但是包含的 go.mod 檔案會被忽略。

譯註：在 Go 1.11 中 vgo 作為官方整合的 Go Modules 釋出，已整合在 go 命令中，使用 go mod 進行使用，指令與 vgo 基本一致。

Docker 設定

每個服務在其自身的子資料夾中實現，並至少包含一個 app.dockerfile 檔案。app.dockerfile 檔案使用者構建資料庫映象。

account
├── account.proto
├── app.dockerfile
├── cmd
│   └── account
│       └── main.go
├── db.dockerfile
└── up.sql
複製程式碼

所有服務通過外部的 docker-compose.yaml 定義。

下面是擷取的一部分關於 Account 服務的內容：

version: "3.6"

services:
  account:
    build:
      context: "."
      dockerfile: "./account/app.dockerfile"
    depends_on:
      - "account_db"
    environment:
      DATABASE_URL: "postgres://spidey:123456@account_db/spidey?sslmode=disable"
  account_db:
    build:
      context: "./account"
      dockerfile: "./db.dockerfile"
    environment:
      POSTGRES_DB: "spidey"
      POSTGRES_USER: "spidey"
      POSTGRES_PASSWORD: "123456"
    restart: "unless-stopped"
複製程式碼

設定 context 的目的是保證 vendor 目錄能夠被複制到 Docker 容器中。所有服務共享相同的依賴、某些服務還依賴其他服務的定義。

賬戶服務

賬戶服務暴露了建立以及索引賬戶的方法。

服務

賬戶服務的 API 定義的介面如下：

account/service.go

type Service interface {
  PostAccount(ctx context.Context, name string) (*Account, error)
  GetAccount(ctx context.Context, id string) (*Account, error)
  GetAccounts(ctx context.Context, skip uint64, take uint64) ([]Account, error)
}

type Account struct {
  ID   string `json:"id"`
  Name string `json:"name"`
}
複製程式碼

實現需要用到 Repository：

type accountService struct {
  repository Repository
}

func NewService(r Repository) Service {
  return &accountService{r}
}
複製程式碼

這個服務負責了所有的業務邏輯。PostAccount 函式的實現如下：

func (s *accountService) PostAccount(ctx context.Context, name string) (*Account, error) {
  a := &Account{
    Name: name,
    ID:   ksuid.New().String(),
  }
  if err := s.repository.PutAccount(ctx, *a); err != nil {
    return nil, err
  }
  return a, nil
}
複製程式碼

它將線路協議解析處理為服務端，並將資料庫處理為 Repository。

資料庫

一個賬戶的資料模型非常簡單：

CREATE TABLE IF NOT EXISTS accounts (
  id CHAR(27) PRIMARY KEY,
  name VARCHAR(24) NOT NULL
);
複製程式碼

上面定義資料的 SQL 檔案會複製到 Docker 容器中執行。

account/db.dockerfile

FROM postgres:10.3

COPY up.sql /docker-entrypoint-initdb.d/1.sql

CMD ["postgres"]
複製程式碼

PostgreSQL 資料庫通過下面的 Repository 介面進行訪問：

account/repository.go

type Repository interface {
  Close()
  PutAccount(ctx context.Context, a Account) error
  GetAccountByID(ctx context.Context, id string) (*Account, error)
  ListAccounts(ctx context.Context, skip uint64, take uint64) ([]Account, error)
}
複製程式碼

Repository 基於 Go 標準庫 SQL 包進行封裝：

type postgresRepository struct {
  db *sql.DB
}

func NewPostgresRepository(url string) (Repository, error) {
  db, err := sql.Open("postgres", url)
  if err != nil {
    return nil, err
  }
  err = db.Ping()
  if err != nil {
    return nil, err
  }
  return &postgresRepository{db}, nil
}
複製程式碼

gRPC

賬戶服務的 gRPC 服務定義了下面的 Protocol Buffer：

account/account.proto

syntax = "proto3";
package pb;

message Account {
  string id = 1;
  string name = 2;
}

message PostAccountRequest {
  string name = 1;
}

message PostAccountResponse {
  Account account = 1;
}

message GetAccountRequest {
  string id = 1;
}

message GetAccountResponse {
  Account account = 1;
}

message GetAccountsRequest {
  uint64 skip = 1;
  uint64 take = 2;
}

message GetAccountsResponse {
  repeated Account accounts = 1;
}

service AccountService {
  rpc PostAccount (PostAccountRequest) returns (PostAccountResponse) {}
  rpc GetAccount (GetAccountRequest) returns (GetAccountResponse) {}
  rpc GetAccounts (GetAccountsRequest) returns (GetAccountsResponse) {}
}
複製程式碼

由於這個包被設定為了 pb，於是生成的程式碼可以從 pb 子包匯入使用。

gRPC 的程式碼可以使用 Go 的 generate 指令配合 account/server.go 檔案最上方的註釋進行編譯生成：

account/server.go

//go:generate protoc ./account.proto --go_out=plugins=grpc:./pb
package account
複製程式碼

執行下面的命令就可以將程式碼生成到 pb 子目錄：

$ go generate account/server.go
複製程式碼

服務端作為 Service 服務介面的介面卡，對應轉換了請求和返回的型別。

type grpcServer struct {
  service Service
}

func ListenGRPC(s Service, port int) error {
  lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
  if err != nil {
    return err
  }
  serv := grpc.NewServer()
  pb.RegisterAccountServiceServer(serv, &grpcServer{s})
  reflection.Register(serv)
  return serv.Serve(lis)
}
複製程式碼

下面是 PostAccount 函式的實現：

func (s *grpcServer) PostAccount(ctx context.Context, r *pb.PostAccountRequest) (*pb.PostAccountResponse, error) {
  a, err := s.service.PostAccount(ctx, r.Name)
  if err != nil {
    return nil, err
  }
  return &pb.PostAccountResponse{Account: &pb.Account{
    Id:   a.ID,
    Name: a.Name,
  }}, nil
}
複製程式碼

用法

gRPC 服務端在 account/cmd/account/main.go 檔案中進行初始化：

type Config struct {
  DatabaseURL string `envconfig:"DATABASE_URL"`
}

func main() {
  var cfg Config
  err := envconfig.Process("", &cfg)
  if err != nil {
    log.Fatal(err)
  }

  var r account.Repository
  retry.ForeverSleep(2*time.Second, func(_ int) (err error) {
    r, err = account.NewPostgresRepository(cfg.DatabaseURL)
    if err != nil {
      log.Println(err)
    }
    return
  })
  defer r.Close()

  log.Println("Listening on port 8080...")
  s := account.NewService(r)
  log.Fatal(account.ListenGRPC(s, 8080))
}
複製程式碼

客戶端結構體的實現位於 account/client.go 檔案中。這樣賬戶服務就可以在無需瞭解 RPC 內部實現的情況下進行實現，我們之後再來詳細討論。

account, err := accountClient.GetAccount(ctx, accountId)
if err != nil {
  log.Fatal(err)
}
複製程式碼

目錄服務

目錄服務負責處理 Spidey 商店的商品。它實現了類似於賬戶服務的功能，但是使用了 Elasticsearch 對商品進行持久化。

服務

目錄服務遵循下面的介面：

catalog/service.go

type Service interface {
  PostProduct(ctx context.Context, name, description string, price float64) (*Product, error)
  GetProduct(ctx context.Context, id string) (*Product, error)
  GetProducts(ctx context.Context, skip uint64, take uint64) ([]Product, error)
  GetProductsByIDs(ctx context.Context, ids []string) ([]Product, error)
  SearchProducts(ctx context.Context, query string, skip uint64, take uint64) ([]Product, error)
}

type Product struct {
  ID          string  `json:"id"`
  Name        string  `json:"name"`
  Description string  `json:"description"`
  Price       float64 `json:"price"`
}
複製程式碼

資料庫

Repository 基於 Elasticsearch olivere/elastic 包進行實現。

catalog/repository.go

type Repository interface {
  Close()
  PutProduct(ctx context.Context, p Product) error
  GetProductByID(ctx context.Context, id string) (*Product, error)
  ListProducts(ctx context.Context, skip uint64, take uint64) ([]Product, error)
  ListProductsWithIDs(ctx context.Context, ids []string) ([]Product, error)
  SearchProducts(ctx context.Context, query string, skip uint64, take uint64) ([]Product, error)
}
複製程式碼

由於 Elasticsearch 將文件和 ID 分開儲存，因此實現的一個商品的輔助結構沒有包含 ID：

type productDocument struct {
  Name        string  `json:"name"`
  Description string  `json:"description"`
  Price       float64 `json:"price"`
}
複製程式碼

將商品插入到資料庫中：

func (r *elasticRepository) PutProduct(ctx context.Context, p Product) error {
  _, err := r.client.Index().
    Index("catalog").
    Type("product").
    Id(p.ID).
    BodyJson(productDocument{
      Name:        p.Name,
      Description: p.Description,
      Price:       p.Price,
    }).
    Do(ctx)
  return err
}
複製程式碼

gRPC

目錄服務的 gRPC 服務定義在 catalog/catalog.proto 檔案中，並在 catalog/server.go 中進行實現。與賬戶服務不同的是，它沒有在服務介面中定義所有的 endpoint。

catalog/catalog.proto

syntax = "proto3";
package pb;

message Product {
  string id = 1;
  string name = 2;
  string description = 3;
  double price = 4;
}

message PostProductRequest {
  string name = 1;
  string description = 2;
  double price = 3;
}

message PostProductResponse {
  Product product = 1;
}

message GetProductRequest {
  string id = 1;
}

message GetProductResponse {
  Product product = 1;
}

message GetProductsRequest {
  uint64 skip = 1;
  uint64 take = 2;
  repeated string ids = 3;
  string query = 4;
}

message GetProductsResponse {
  repeated Product products = 1;
}

service CatalogService {
  rpc PostProduct (PostProductRequest) returns (PostProductResponse) {}
  rpc GetProduct (GetProductRequest) returns (GetProductResponse) {}
  rpc GetProducts (GetProductsRequest) returns (GetProductsResponse) {}
}
複製程式碼

儘管 GetProductRequest 訊息包含了額外的欄位，但通過 ID 的搜尋與索引實現。

下面的程式碼展示了 GetProducts 函式的實現：

catalog/server.go

func (s *grpcServer) GetProducts(ctx context.Context, r *pb.GetProductsRequest) (*pb.GetProductsResponse, error) {
  var res []Product
  var err error
  if r.Query != "" {
    res, err = s.service.SearchProducts(ctx, r.Query, r.Skip, r.Take)
  } else if len(r.Ids) != 0 {
    res, err = s.service.GetProductsByIDs(ctx, r.Ids)
  } else {
    res, err = s.service.GetProducts(ctx, r.Skip, r.Take)
  }
  if err != nil {
    log.Println(err)
    return nil, err
  }

  products := []*pb.Product{}
  for _, p := range res {
    products = append(
      products,
      &pb.Product{
        Id:          p.ID,
        Name:        p.Name,
        Description: p.Description,
        Price:       p.Price,
      },
    )
  }
  return &pb.GetProductsResponse{Products: products}, nil
}
複製程式碼

它決定了當給定何種引數來呼叫何種服務函式。其目標是模擬 REST HTTP 的 endpoint。

對於 /products?[ids=...]&[query=...]&skip=0&take=100 形式的請求，只有設計一個 endpoint 來完成 API 呼叫會相對容易一些。

Order 服務

Order 訂單服務就比較棘手了。他需要呼叫賬戶和目錄服務來驗證請求，因為一個訂單隻能給一個特定的賬號和一個存在的商品進行建立。

Service

Service 介面定義了通過賬戶建立和索引全部訂單的介面。

order/service.go

type Service interface {
  PostOrder(ctx context.Context, accountID string, products []OrderedProduct) (*Order, error)
  GetOrdersForAccount(ctx context.Context, accountID string) ([]Order, error)
}

type Order struct {
  ID         string
  CreatedAt  time.Time
  TotalPrice float64
  AccountID  string
  Products   []OrderedProduct
}

type OrderedProduct struct {
  ID          string
  Name        string
  Description string
  Price       float64
  Quantity    uint32
}
複製程式碼

資料庫

一個訂單可以包含多個商品，因此資料模型必須支援這種形式。下面的 order_products 表描述了 ID 為 product_id 的訂購產品以及此類產品的數量。而 product_id 欄位必須可以從目錄服務進行檢索。

order/up.sql

CREATE TABLE IF NOT EXISTS orders (
  id CHAR(27) PRIMARY KEY,
  created_at TIMESTAMP WITH TIME ZONE NOT NULL,
  account_id CHAR(27) NOT NULL,
  total_price MONEY NOT NULL
);

CREATE TABLE IF NOT EXISTS order_products (
  order_id CHAR(27) REFERENCES orders (id) ON DELETE CASCADE,
  product_id CHAR(27),
  quantity INT NOT NULL,
  PRIMARY KEY (product_id, order_id)
);
複製程式碼

Repository 介面很簡單：

order/repository.go

type Repository interface {
  Close()
  PutOrder(ctx context.Context, o Order) error
  GetOrdersForAccount(ctx context.Context, accountID string) ([]Order, error)
}
複製程式碼

但實現它卻並不簡單。

一個訂單必須使用事務機制分兩步插入，然後通過 join 語句進行查詢。

從資料庫中讀取訂單需要解析一個表狀結構資料讀取到物件結構中。下面的程式碼基於訂單 ID 將商品讀取到訂單中：

orders := []Order{}
order := &Order{}
lastOrder := &Order{}
orderedProduct := &OrderedProduct{}
products := []OrderedProduct{}

// 將每行讀取到 Order 結構體
for rows.Next() {
  if err = rows.Scan(
    &order.ID,
    &order.CreatedAt,
    &order.AccountID,
    &order.TotalPrice,
    &orderedProduct.ID,
    &orderedProduct.Quantity,
  ); err != nil {
    return nil, err
  }
  // 讀取訂單
  if lastOrder.ID != "" && lastOrder.ID != order.ID {
    newOrder := Order{
      ID:         lastOrder.ID,
      AccountID:  lastOrder.AccountID,
      CreatedAt:  lastOrder.CreatedAt,
      TotalPrice: lastOrder.TotalPrice,
      Products:   products,
    }
    orders = append(orders, newOrder)
    products = []OrderedProduct{}
  }
  // 讀取商品
  products = append(products, OrderedProduct{
    ID:       orderedProduct.ID,
    Quantity: orderedProduct.Quantity,
  })

  *lastOrder = *order
}

// 新增最後一個訂單 (或者第一個 :D)
if lastOrder != nil {
  newOrder := Order{
    ID:         lastOrder.ID,
    AccountID:  lastOrder.AccountID,
    CreatedAt:  lastOrder.CreatedAt,
    TotalPrice: lastOrder.TotalPrice,
    Products:   products,
  }
  orders = append(orders, newOrder)
}
複製程式碼

gRPC

Order 服務的 gRPC 服務端需要在實現時與賬戶和目錄服務建立聯絡。

Protocol Buffers 定義如下：

order/order.proto

syntax = "proto3";
package pb;

message Order {
  message OrderProduct {
    string id = 1;
    string name = 2;
    string description = 3;
    double price = 4;
    uint32 quantity = 5;
  }

  string id = 1;
  bytes createdAt = 2;
  string accountId = 3;
  double totalPrice = 4;
  repeated OrderProduct products = 5;
}

message PostOrderRequest {
  message OrderProduct {
    string productId = 2;
    uint32 quantity = 3;
  }

  string accountId = 2;
  repeated OrderProduct products = 4;
}

message PostOrderResponse {
  Order order = 1;
}

message GetOrderRequest {
  string id = 1;
}

message GetOrderResponse {
  Order order = 1;
}

message GetOrdersForAccountRequest {
  string accountId = 1;
}

message GetOrdersForAccountResponse {
  repeated Order orders = 1;
}

service OrderService {
  rpc PostOrder (PostOrderRequest) returns (PostOrderResponse) {}
  rpc GetOrdersForAccount (GetOrdersForAccountRequest) returns (GetOrdersForAccountResponse) {}
}
複製程式碼

執行訂單服務需要傳遞其他服務的 URL：

order/server.go

type grpcServer struct {
  service       Service
  accountClient *account.Client
  catalogClient *catalog.Client
}

func ListenGRPC(s Service, accountURL, catalogURL string, port int) error {
  accountClient, err := account.NewClient(accountURL)
  if err != nil {
    return err
  }

  catalogClient, err := catalog.NewClient(catalogURL)
  if err != nil {
    accountClient.Close()
    return err
  }

  lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
  if err != nil {
    accountClient.Close()
    catalogClient.Close()
    return err
  }

  serv := grpc.NewServer()
  pb.RegisterOrderServiceServer(serv, &grpcServer{
    s,
    accountClient,
    catalogClient,
  })
  reflection.Register(serv)

  return serv.Serve(lis)
}
複製程式碼

建立訂單涉及呼叫帳戶服務、檢查帳戶是否存在、然後對產品執行相同操作。計算總價時還需要讀取產品價格。你不會希望使用者能傳入自己的商品的總價。

func (s *grpcServer) PostOrder(
  ctx context.Context,
  r *pb.PostOrderRequest,
) (*pb.PostOrderResponse, error) {
  // 檢查賬戶是否存在
  _, err := s.accountClient.GetAccount(ctx, r.AccountId)
  if err != nil {
    log.Println(err)
    return nil, err
  }

  // 獲取訂單商品
  productIDs := []string{}
  for _, p := range r.Products {
    productIDs = append(productIDs, p.ProductId)
  }
  orderedProducts, err := s.catalogClient.GetProducts(ctx, 0, 0, productIDs, "")
  if err != nil {
    log.Println(err)
    return nil, err
  }

  // 構造商品
  products := []OrderedProduct{}
  for _, p := range orderedProducts {
    product := OrderedProduct{
      ID:          p.ID,
      Quantity:    0,
      Price:       p.Price,
      Name:        p.Name,
      Description: p.Description,
    }
    for _, rp := range r.Products {
      if rp.ProductId == p.ID {
        product.Quantity = rp.Quantity
        break
      }
    }

    if product.Quantity != 0 {
      products = append(products, product)
    }
  }

  // 呼叫服務實現
  order, err := s.service.PostOrder(ctx, r.AccountId, products)
  if err != nil {
    log.Println(err)
    return nil, err
  }

  // 建立訂單響應
  orderProto := &pb.Order{
    Id:         order.ID,
    AccountId:  order.AccountID,
    TotalPrice: order.TotalPrice,
    Products:   []*pb.Order_OrderProduct{},
  }
  orderProto.CreatedAt, _ = order.CreatedAt.MarshalBinary()
  for _, p := range order.Products {
    orderProto.Products = append(orderProto.Products, &pb.Order_OrderProduct{
      Id:          p.ID,
      Name:        p.Name,
      Description: p.Description,
      Price:       p.Price,
      Quantity:    p.Quantity,
    })
  }
  return &pb.PostOrderResponse{
    Order: orderProto,
  }, nil
}
複製程式碼

當請求特定賬戶的訂單時，由於需要產品的詳情，因此呼叫目錄服務是有必要的。

GraphQL 服務

GraphQL schema 的定義在 graphql/schema.graphql 檔案中：

scalar Time

type Account {
  id: String!
  name: String!
  orders: [Order!]!
}

type Product {
  id: String!
  name: String!
  description: String!
  price: Float!
}

type Order {
  id: String!
  createdAt: Time!
  totalPrice: Float!
  products: [OrderedProduct!]!
}

type OrderedProduct {
  id: String!
  name: String!
  description: String!
  price: Float!
  quantity: Int!
}

input PaginationInput {
  skip: Int
  take: Int
}

input AccountInput {
  name: String!
}

input ProductInput {
  name: String!
  description: String!
  price: Float!
}

input OrderProductInput {
  id: String!
  quantity: Int!
}

input OrderInput {
  accountId: String!
  products: [OrderProductInput!]!
}

type Mutation {
  createAccount(account: AccountInput!): Account
  createProduct(product: ProductInput!): Product
  createOrder(order: OrderInput!): Order
}

type Query {
  accounts(pagination: PaginationInput, id: String): [Account!]!
  products(pagination: PaginationInput, query: String, id: String): [Product!]!
}
複製程式碼

gqlgen 工具會生成一堆型別，但是還需要對 Order 模型進行一些控制，在 graphql/types.json 檔案中進行制定，從而不會自動生成模型：

{
  "Order": "github.com/tinrab/spidey/graphql/graph.Order"
}
複製程式碼

現在可以手動實現 Order 結構了：

graphql/graph/models.go

package graph

import time "time"

type Order struct {
  ID         string           `json:"id"`
  CreatedAt  time.Time        `json:"createdAt"`
  TotalPrice float64          `json:"totalPrice"`
  Products   []OrderedProduct `json:"products"`
}
複製程式碼

生成型別的指令在 graphql/graph/graph.go 頂部：

//go:generate gqlgen -schema ../schema.graphql -typemap ../types.json
package graph
複製程式碼

通過下面的命令執行：

$ go generate ./graphql/graph/graph.go
複製程式碼

GraphQL 服務端引用了所有其他服務。

graphql/graph/graph.go

type GraphQLServer struct {
  accountClient *account.Client
  catalogClient *catalog.Client
  orderClient   *order.Client
}

func NewGraphQLServer(accountUrl, catalogURL, orderURL string) (*GraphQLServer, error) {
  // 連線賬戶服務
  accountClient, err := account.NewClient(accountUrl)
  if err != nil {
    return nil, err
  }

  // 連線目錄服務
  catalogClient, err := catalog.NewClient(catalogURL)
  if err != nil {
    accountClient.Close()
    return nil, err
  }

  // 連線訂單服務
  orderClient, err := order.NewClient(orderURL)
  if err != nil {
    accountClient.Close()
    catalogClient.Close()
    return nil, err
  }

  return &GraphQLServer{
    accountClient,
    catalogClient,
    orderClient,
  }, nil
}
複製程式碼

GraphQLServer 結構體需要實現所有生成的 resolver。修改（Mutation）可以在 graphql/graph/mutations.go 中找到，查詢（Query）則可以在 graphql/graph/queries.go 中找到。

修改操作通過呼叫相關服務客戶端傳入引數進行實現：

func (s *GraphQLServer) Mutation_createAccount(ctx context.Context, in AccountInput) (*Account, error) {
  ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
  defer cancel()

  a, err := s.accountClient.PostAccount(ctx, in.Name)
  if err != nil {
    log.Println(err)
    return nil, err
  }

  return &Account{
    ID:   a.ID,
    Name: a.Name,
  }, nil
}
複製程式碼

查詢能夠互相巢狀。在 Spidey 中，查詢賬戶還可以查詢其訂單，見 Account_orders 函式。

func (s *GraphQLServer) Query_accounts(ctx context.Context, pagination *PaginationInput, id *string) ([]Account, error) {
  // 會被首先呼叫
  // ...
}

func (s *GraphQLServer) Account_orders(ctx context.Context, obj *Account) ([]Order, error) {
  // 然後執行這個函式，返回 "obj" 賬戶的訂單
  // ...
}
複製程式碼

總結

執行下面的命令就可以執行 Spidey：

$ vgo vendor
$ docker-compose up -d --build
複製程式碼

然後你就可以在瀏覽器中訪問 http://localhost:8000/playground 來使用 GraphQL 工具建立一個賬戶了：

mutation {
  createAccount(account: {name: "John"}) {
    id
    name
  }
}
複製程式碼

返回結果為：

{
  "data": {
    "createAccount": {
      "id": "15t4u0du7t6vm9SRa4m3PrtREHb",
      "name": "John"
    }
  }
}
複製程式碼

然後可以建立一些產品：

mutation {
  a: createProduct(product: {name: "Kindle Oasis", description: "Kindle Oasis is the first waterproof Kindle with our largest 7-inch 300 ppi display, now with Audible when paired with Bluetooth.", price: 300}) { id },
  b: createProduct(product: {name: "Samsung Galaxy S9", description: "Discover Galaxy S9 and S9+ and the revolutionary camera that adapts like the human eye.", price: 720}) { id },
  c: createProduct(product: {name: "Sony PlayStation 4", description: "The PlayStation 4 is an eighth-generation home video game console developed by Sony Interactive Entertainment", price: 300}) { id },
  d: createProduct(product: {name: "ASUS ZenBook Pro UX550VE", description: "Designed to entice. Crafted to perform.", price: 300}) { id },
  e: createProduct(product: {name: "Mpow PC Headset 3.5mm", description: "Computer Headset with Microphone Noise Cancelling, Lightweight PC Headset Wired Headphones, Business Headset for Skype, Webinar, Phone, Call Center", price: 43}) { id }
}
複製程式碼

注意返回的 ID 值：

{
  "data": {
    "a": {
      "id": "15t7jjANR47uODEPUIy1od5APnC"
    },
    "b": {
      "id": "15t7jsTyrvs1m4EYu7TCes1EN5z"
    },
    "c": {
      "id": "15t7jrfDhZKgxOdIcEtTUsriAsY"
    },
    "d": {
      "id": "15t7jpKt4VkJ5iHbwt4rB5xR77w"
    },
    "e": {
      "id": "15t7jsYs0YzK3B7drQuf1mX5Dyg"
    }
  }
}
複製程式碼

然後發起一些訂單：

mutation {
  createOrder(order: { accountId: "15t4u0du7t6vm9SRa4m3PrtREHb", products: [
    { id: "15t7jjANR47uODEPUIy1od5APnC", quantity: 2 },
    { id: "15t7jpKt4VkJ5iHbwt4rB5xR77w", quantity: 1 },
    { id: "15t7jrfDhZKgxOdIcEtTUsriAsY", quantity: 5 }
  ]}) {
    id
    createdAt
    totalPrice
  }
}
複製程式碼

根據返回結果檢查返回的費用：

{
  "data": {
    "createOrder": {
      "id": "15t8B6lkg80ZINTASts92nBzyE8",
      "createdAt": "2018-06-11T21:18:18Z",
      "totalPrice": 2400
    }
  }
}
複製程式碼

完整程式碼請檢視 GitHub。

如果發現譯文存在錯誤或其他需要改進的地方，歡迎到掘金翻譯計劃對譯文進行修改並 PR，也可獲得相應獎勵積分。文章開頭的 本文永久連結 即為本文在 GitHub 上的 MarkDown 連結。

掘金翻譯計劃是一個翻譯優質網際網路技術文章的社群，文章來源為掘金上的英文分享文章。內容覆蓋 Android、iOS、前端、後端、區塊鏈、產品、設計、人工智慧等領域，想要檢視更多優質譯文請持續關注掘金翻譯計劃、官方微博、知乎專欄。

微服務閘道器
2021-01-26
微服務
微服務閘道器- Nginx
2021-07-19
微服務Nginx
微服務中的閘道器
2020-06-10
微服務
微服務（七）Gateway服務閘道器
2021-11-02
微服務Gateway
微服務閘道器SIA-GateWay使用指南
2019-08-14
微服務Gateway
《springcloud 二》微服務動態閘道器，閘道器叢集
2019-04-09
SpringGCCloud微服務
go-kit微服務：一個簡單的API閘道器
2019-02-26
Go微服務API
微服務閘道器 Spring Cloud Gateway
2019-07-05
微服務SpringCloudGateway
SpringCloud 微服務閘道器 Gateway 元件
2022-08-15
SpringGCCloud微服務Gateway元件
微服務6：通訊之閘道器
2022-02-18
微服務
微服務基礎——厲害了！API閘道器
2019-11-28
微服務API
SpringCloud微服務治理三（Zuul閘道器）
2019-05-15
SpringGCCloud微服務Zuul
微服務下的閘道器如何選擇
2020-11-20
微服務
微服務閘道器Gateway實踐總結
2022-09-01
微服務Gateway
為什麼微服務需要API閘道器？
2016-11-22
微服務API
微服務實踐分享(2)api閘道器
2018-07-01
微服務API
微服務架構閘道器介面設計
2018-01-01
微服務架構
高效能API閘道器（1）、微服務API閘道器架構設計
2024-04-21
API微服務架構
微服務使用者為什麼要用雲原生閘道器
2022-02-25
微服務
.NET Core 微服務—API閘道器(Ocelot) 教程 [四]
2020-08-09
微服務API
.NETCore微服務探尋(一) - 閘道器
2020-06-15
NetCore微服務
.NET Core微服務開發閘道器篇-ocelot
2020-07-15
微服務
.NET Core 微服務—API閘道器(Ocelot) 教程 [一]
2020-07-11
微服務API
個推微服務閘道器架構實踐
2019-03-05
微服務架構
微服務閘道器實戰——Spring Cloud Gateway
2019-05-24
微服務SpringCloudGateway
微服務與閘道器技術（SIA-GateWay）
2019-08-12
微服務Gateway
微服務架構基礎之API閘道器
2018-09-04
微服務架構API
5 種微服務閘道器，該選哪個？
2023-04-04
微服務
微服務設計中的API閘道器模式
2020-10-10
微服務API模式
go-micro講解--Go Micro編寫微服務
2018-07-07
Go微服務
暢購商城(八)：微服務閘道器和JWT令牌
2020-08-05
微服務JWT
Bumblebee微服務閘道器的部署和擴充套件
2019-02-22
微服務套件
微服務閘道器Zuul遷移到Spring Cloud Gateway
2018-09-24
微服務ZuulSpringCloudGateway
微服務閘道器 gateway 跨域問題解決
2021-12-08
微服務Gateway跨域
.Net Core微服務——閘道器（2）：ocelot整合consul
2021-11-08
微服務
為什麼微服務一定要有閘道器？
2018-06-10
微服務
第一章微服務閘道器 - 入門
2017-05-02
微服務
Spring Cloud構建微服務架構-服務閘道器
2019-02-14
SpringCloud微服務架構

[譯] 使用 Go 編寫微服務及其 GraphQL 閘道器

架構

起步

Docker 設定

賬戶服務

服務

資料庫

gRPC

用法

目錄服務

服務

資料庫

gRPC

Order 服務

Service

資料庫

gRPC

GraphQL 服務

總結

相關文章