grpc golang-Installation

gRPC (Google Remote Procedure Call) ist ein leistungsstarkes, sprachübergreifendes Framework für Remote-Prozeduraufrufe, das Dienstschnittstellen über Protokollpuffer (ProtoBuf) definiert und viele Programmiersprachen unterstützt. gRPC wird häufig bei der Entwicklung verteilter Systeme verwendet. Sein effizienter Serialisierungs- und Deserialisierungsmechanismus, die HTTP/2-basierte Flusskontrolle und die Chunked-Übertragung sowie andere Funktionen bieten offensichtliche Vorteile bei der Netzwerkübertragung.

In diesem Artikel wird hauptsächlich die Installation von gRPC in Golang und das Schreiben eines einfachen Client- und Server-Beispielcodes vorgestellt.

1. Installieren Sie gRPC

Bevor Sie gRPC installieren, müssen Sie Protocol Buffers 3 installieren. Protocol Buffers ist ein Tool, das gRPC benötigt, um automatisch Code zu generieren, und es ist auch ein Tool zum Serialisieren von Daten.

Laden Sie zunächst das Installationspaket von Protocol Buffers 3 herunter, am Beispiel von Mac OS:

$ curl -OL https://github.com/google/protobuf/releases/download/v3.9.1/protobuf-all-3.9.1.zip
$ unzip protobuf-all-3.9.1.zip
$ cd protobuf-3.9.1

Führen Sie configure, make, make install aus, um Protocol Buffers zu installieren: #🎜🎜 #

$ ./configure
$ make
$ sudo make install

Nach der Installation von Protocol Buffers verwenden Sie den folgenden Befehl, um Gos gRPC und zugehörige Tools zu installieren:

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

2. Schreiben Sie eine ProtoBuf-Datei

Es wird eine ProtoBuf-Datei verwendet um Dienstschnittstellen und Datenstrukturen zu definieren und über das gRPC-Tool automatisch entsprechenden Code (einschließlich Client- und Servercode) zu generieren.

Wir schreiben hier ein einfaches Beispiel, um eine Rechnerdienstschnittstelle zu definieren, die Additionsoperationen unterstützt:

syntax = "proto3";

package calculator;

service Calculator {
  rpc Add(AddRequest) returns (AddResponse) {}
}

message AddRequest {
  int32 left = 1;
  int32 right = 2;
}

message AddResponse {
  int32 sum = 1;
}

In diesem Beispiel definieren Sie eine Dienstschnittstelle mit dem Namen Calculator , die eine Add-Methode enthält, die empfängt einen AddRequest-Parameter und gibt einen AddResponse-Parameter zurück.

AddRequest und AddResponse sind beide Nachrichtenstrukturen, die jeweils zwei Felder vom Typ int32 enthalten, die die beiden Operanden und das Ergebnis der Addition darstellen.

3. Code generieren

Nachdem Sie die ProtoBuf-Datei geschrieben haben, verwenden Sie den folgenden Befehl, um Client- und Servercode zu generieren:

$ protoc --go_out=plugins=grpc:. calculator.proto

Dieser Befehl generiert einen Eine Go-Datei mit dem Namen Rechner.pb.go, die den Client- und Servercode für den Rechnerdienst definiert.

4. Client- und Servercode schreiben

Nachdem Sie den Client- und Servercode generiert haben, können Sie mit dem Schreiben des eigentlichen Clients und Servers beginnen.

Zuerst erstellen wir eine Datei mit dem Namen server.go, um die Rechnerschnittstelle zu implementieren:

package main

import (
    "context"
    "log"
    "net"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

type server struct{}

func (s *server) Add(ctx context.Context, in *pb.AddRequest) (*pb.AddResponse, error) {
    sum := in.Left + in.Right
    return &pb.AddResponse{Sum: sum}, nil
}

const (
    port = ":50051"
)

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterCalculatorServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

In diesem Beispiel definieren wir eine Datei mit dem Namen server. Die Struktur wird implementiert die Add-Methode in der Calculator-Schnittstelle. Die Add-Methode empfängt einen AddRequest-Parameter, berechnet die Summe der beiden Operanden und gibt einen AddResponse-Parameter zurück.

Registrieren Sie abschließend den Dienst über die vom gRPC-Framework bereitgestellte RegisterCalculatorServer-Methode beim gRPC-Server und starten Sie den gRPC-Server.

Als nächstes schreiben wir den Client-Code und erstellen eine Datei mit dem Namen client.go, um ein einfaches Beispiel für das Hinzufügen von Operationen über den Rechnerdienst zu implementieren:

package main

import (
    "context"
    "log"
    "os"
    "strconv"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // 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 := pb.NewCalculatorClient(conn)

    // Contact the server and print out its response.
    left, err := strconv.Atoi(os.Args[1])
    if err != nil {
        log.Fatalf("could not parse left operand: %v", err)
    }
    right, err := strconv.Atoi(os.Args[2])
    if err != nil {
        log.Fatalf("could not parse right operand: %v", err)
    }
    r, err := c.Add(context.Background(), &pb.AddRequest{Left: int32(left), Right: int32(right)})
    if err != nil {
        log.Fatalf("could not add: %v", err)
    }
    log.Printf("Sum: %d", r.Sum)
}

In In diesem Beispiel Wir erstellen ein Client-Objekt namens client und stellen über die grpc.Dial-Methode eine Verbindung zum Server her. Anschließend analysieren wir die beiden Operanden des Zusatzes aus den Befehlszeilenparametern und rufen die Add-Methode auf, um die Anforderung zu senden, die vom Server zurückgegebenen Ergebnisse abzurufen und sie auszugeben.

5. Führen Sie das Beispiel aus

Nachdem beide Dateien geschrieben wurden, verwenden Sie die folgenden Befehle, um beide Programme zu kompilieren und auszuführen:

$ go build server.go
$ go build client.go
$ ./server

Dann in Führen Sie den folgenden Befehl in einem anderen Terminal aus, um das Client-Programm auszuführen:

$ ./client 1 2

Das Laufergebnis gibt das Berechnungsergebnis 3 aus.

Das Obige ist die Installation und Verwendung von gRPC in Golang. Das Schreiben effizienter verteilter Systeme über gRPC wird sehr einfach.

Das obige ist der detaillierte Inhalt vongrpc golang-Installation. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!