** * Dieser Artikel wurde am 7. November 2019 erstellt Versuchen wir es mit gRPC mit Go and Docker - LiBz Tech Blog Gleicher Inhalt **

Einführung

Hallo! Ich bin Watanabe, ein Ingenieur. Es ist ein ganzes Jahr her, seit ich im November zu LiB gekommen bin. Dies ist mein 4. Beitrag in diesem Blog.

In der vorherigen "Geschichte der Einführung eines sehr Rails-ähnlichen serverlosen Frameworks" Ruby on Jets "in die Produktionsumgebung" , Jets-Entwickler ** tongueroo ** und Ruby-Schöpfer ** Matsumoto Yukihiro Es war sehr ermutigend, dass viele Leute es teilten, einschließlich **! Vielen Dank an alle.

Dieses Mal werde ich über das von Google entwickelte RPC-Framework ** gRPC ** schreiben.

Was ist gRPC?

Es handelt sich um eine Open-Source-Version des RPC-Frameworks (Remote Procedure Call) namens stubby, das in Google verwendet wird.

Eigenschaften von gRPC

** Hochgeschwindigkeits-Kommunikation mit niedriger Dosis und typgarantierter Kommunikation zwischen verschiedenen Sprachen mithilfe von Protokollpuffern ** (Schnittstellenbeschreibungssprachen wie xml, json)
Für Server / Client ** Automatische Quellcodegenerierung **
Mehrsprachige Unterstützung (C ++, Java, Go, Python, Ruby, Node.js, C #, Objective-C, PHP usw.)
Kommunikationsprotokoll ** Kommunikation über HTTP / 2 **
Bidirektionale Kommunikation über Streaming (herkömmliche Kommunikation ist 1Request-1Response)

Aufgrund der oben genannten Funktionen kann ** gRPC die Probleme der Verbindung und Datenübertragung zwischen Systemen mit Mikrodienstleistung lösen und effizient kommunizieren **.

Von gRPC gelöste Microservice-Probleme

Die Schnittstelle muss zwischen mehreren Systemen vereinheitlicht werden
Systeme ändern sich häufig, was es schwierig macht, die Konsistenz über alle Systeme hinweg sicherzustellen

** -> Server / Client-Quellcode kann automatisch aus ProtocolBuffer (.proto-Datei) generiert und mehrere Sprachen ausgewählt werden **

--Dokumente (Spezifikationen, Wiki, Swagger usw.) zum Verständnis der Spezifikationen mehrerer Systeme

** -> Die Kommunikation zwischen Diensten wird aus der Protodatei generiert, sodass die Protodatei die richtigen Spezifikationen aufweist (der Quellcode wird basierend auf der Protodatei generiert, sodass keine Auslassungen oder Fehler auftreten) **

Die Leistung verschlechtert sich aufgrund häufiger API-Anforderungen
Erhöhen Sie einfach die Anforderungszeiten. Es ist erforderlich, mehrere verteilte Ressourcen im System zu erfassen, die jeweils erworben wurden

** -> HTTP / 2 kann mehrere Anforderungen und Antworten mit einer TCP-Verbindung verarbeiten **

In HTTP / 1 kann nur eine Ressource mit einer Verbindung erfasst werden (die Anzahl der Verbindungen ist begrenzt, auch wenn auf der Browserseite mehrere TCPs gleichzeitig eingefügt werden).

** -> Aufgrund der HTTP / 2-Kommunikation kann die Verbindung kontinuierlich verwendet werden, ohne verworfen zu werden **

gRPC-Herausforderungen

Natürlich gibt es nicht nur Vor-, sondern auch Nachteile. Die Tatsache, dass der Kommunikationsstandard HTTP / 2 ist, bedeutet, dass ** Browser und Load Balancer, die ihn nicht unterstützen, keine Anforderungen empfangen können **.

Reverse Proxy für Browser wie grpc-gateway und grpc-web Es ist kein Problem, wenn Sie eine Bibliothek verwenden, die dies tut Die Kommunikation zwischen Diensten erfolgt über das HTTP2-Protokoll, und nur die Kommunikation zwischen Browser und Server erfolgt über das HTTP1-Protokoll. Einige Benutzer fühlen sich daher beim Mischen möglicherweise unwohl.

Das Überprüfen des Betriebs des gRPC-Servers ist ebenfalls etwas mühsam. Sie können den Vorgang wie die herkömmliche API mit curl überprüfen, aber Sie können curl nicht mit gRPC verwenden. (Vor kurzem können Sie die Funktionsweise von gRPC wie curl gRPCurl und gRPC UI überprüfen, bei denen es sich um einen GUI-Client für gRPC handelt. hinastory / items / 131cb603af34e3235ccf) Es scheint ein Werkzeug zu geben)

Let's try gRPC

Ich habe den folgenden Artikel um den Code verwendet!

Einführung in gRPC ab Go Versuchen Sie gRPC mit Golang

1. Vorbereitung

gRPC --protoc (ein Compiler, der Code aus .proto-Dateien generiert) --protoc-gen-go (protoc Go-Plug-In)

Installieren Sie die oben genannten drei.

gRPC

$ go get -u google.golang.org/grpc

protoc

Das hängt vom Betriebssystem ab. Bitte installieren Sie von hier.

protoc-gen-go

$ go get -u github.com/golang/protobuf/protoc-gen-go

Dockerfile

Da wir diesmal Docker verwenden werden, werden wir auch eine Docker-Datei und die Datei docker-compose.yml vorbereiten.

FROM golang:1.13.1  
  
RUN apt-get update && apt-get install -y unzip  
  
# Install protobuf  
# @see https://github.com/yoshi42662/go-grpc/blob/master/server/Dockerfile  
RUN mkdir -p /tmp/protoc && \  
  curl -L https://github.com/protocolbuffers/protobuf/releases/download/v3.10.0/protoc-3.10.0-linux-x86_64.zip > /tmp/protoc/protoc.zip && \  
  cd /tmp/protoc && \  
  unzip protoc.zip && \  
  cp /tmp/protoc/bin/protoc /usr/local/bin && \  
  chmod go+rx /usr/local/bin/protoc && \  
  cd /tmp && \  
  rm -r /tmp/protoc  
  
WORKDIR /study-grpc  
COPY . /study-grpc  
  
RUN go get -u google.golang.org/grpc  
RUN go get -u github.com/golang/protobuf/protoc-gen-go

docker-compose.yml

Zur Zeit ist es gut, wenn der Container läuft, also habe ich ihn auf command: bash gesetzt

`docker-compose.yml`


version: '3.7'  
  
services:  
  study-grpc:  
    build: .  
    container_name: "study-grpc"  
	ports:  
      - 1234:1234  
    volumes:  
      - .:/study-grpc  
	command: bash
	tty: true

2. Erstellen Sie eine Protodatei

Definieren Sie die Schnittstelle in der Protodatei und generieren Sie den Code. Ich habe pb / cat.proto erstellt.

syntax = "proto3";  
  
service Cat {  
    rpc GetMyCat (GetMyCatMessage) returns (MyCatResponse) {}  
}  
  
message GetMyCatMessage {  
    string target_cat = 1;  
}  
  
message MyCatResponse {  
    string name = 1;  
    string kind = 2;  
}

Beachten Sie, dass wenn Sie vergessen, syntax =" proto3 " zu schreiben, dies als proto2 interpretiert wird. gRPC verwendet im Allgemeinen proto3. Der Unterschied zwischen proto2 und proto3 ist hier Der Artikel war leicht zu verstehen.

Der Nummernteil von string name = 1 ist die Tag-Nummer. Die Tag-Nummer wird zur Unterscheidung der Felder verwendet. Es wird gesagt, dass es besser ist, die Nummer nach der Zuweisung nicht zu ändern. Wenn sich also etwas ändert, wird eine neue Nummer zugewiesen.

Gehen Sie dann in den Container und kompilieren Sie die Protodatei, um den Quellcode zu generieren.

#Container-Start
$ docker-compose up

#Geh in den Behälter
$ docker exec -it study-grpc bash

#Ausführung des Protokollbefehls
$ protoc --go_out=plugins=grpc:. ./pb/cat.proto

Es ist in Ordnung, wenn "pb / cat.pb.go" generiert wird.

3. Verarbeitung auf der Serverseite

Erstellen Sie "server.go".

package main  
  
import (  
	"context"  
	"errors"
	"google.golang.org/grpc"
	"log"
	"net"
	cat "study-grpc/pb"  
)  
  
type myCatService struct{}  
  
func (s *myCatService) GetMyCat(ctx context.Context, message *cat.GetMyCatMessage) (*cat.MyCatResponse, error) {  
	switch message.TargetCat {  
	case "tama":  
		return &cat.MyCatResponse{  
			Name: "tama",  
			Kind: "Maine Coon",  
		}, nil  
	case "mike":  
		return &cat.MyCatResponse{  
			Name: "mike",  
			Kind: "Norwegian Forest Cat",  
		}, nil  
	default:  
		return nil, errors.New("Not Found YourCat..")  
	}  
}  
  
func main() {  
	port, err := net.Listen("tcp", ":1234")  
	if err != nil {  
		log.Println(err.Error())  
		return  
	}
	s := grpc.NewServer()  
	cat.RegisterCatServer(s, &myCatService{})  
	s.Serve(port)  
}

4. Client-seitige (Anforderungs-) Verarbeitung

Erstellen Sie "client.go".

package main  
  
import (  
	"context"  
	"fmt"
	"google.golang.org/grpc"
	"log"
	cat "study-grpc/pb"  
)  
  
func main() {  
	conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())  
	if err != nil {  
		log.Fatal("connection error:", err)  
	}  
	defer conn.Close()  
  
	client := cat.NewCatClient(conn)  
	message := &cat.GetMyCatMessage{TargetCat: "mike"}  
	res, err := client.GetMyCat(context.Background(), message)  
	if err != nil {  
		log.Fatal(err)  
	}  
	fmt.Printf("result:%s\n", res)  
}

5. Erstellen und ausführen

Lassen Sie uns die erstellten server.go und client.go erstellen und ausführen.

#Geh in den Behälter
$ docker exec -it study-grpc bash

# server.bauen gehen&Lauf
$ go build server.go
$ ./server

# client.bauen gehen&Lauf
$ go build client.go
$ ./client

#Wenn das Erstellen schwierig ist, ist das Ausführen in Ordnung
$ go run server.go
$ go run client.go

Ausführungsergebnis

result:name:"mike" kind:"Norwegian Forest Cat"

Schließlich

Was haben Sie gedacht?

Wenn ich nur den Namen höre, denke ich "gRPC? ProtocolBuffer? Es scheint schwierig", aber ich denke, es war einfacher, als ich es mir vorgestellt hatte, als ich tatsächlich meine Hände bewegte.

Es wurde nachweislich nicht nur von Google, sondern auch von einer Reihe großer Unternehmen übernommen, und die Zahl der Fälle in japanischen Unternehmen nimmt stetig zu.

Es gibt viele Herausforderungen für Microservices, aber gRPC, das den Kommunikationsteil löst, ist eine der Optionen, und ich möchte mich definitiv daran erinnern.

Der diesmal verwendete Code ist in diesem Repository zusammengefasst.

Versuchen wir es mit gRPC mit Go und Docker