So stellen Sie Golang Grpc bereit

In den letzten Jahren wurde die Golang-Sprache von immer mehr Entwicklern bevorzugt, und ihre leichten und hochparallelen Funktionen werden häufig in den Backend-Diensten einiger großer Unternehmen verwendet. Mit der Popularität von Microservices und Cloud-Native-Technologie wird Golang zunehmend im Serverbereich eingesetzt, und auch das RPC-Framework grpc von Golang ist weit verbreitet.

In diesem Artikel wird hauptsächlich die Bereitstellung von grpc vorgestellt. Vor der Bereitstellung müssen Sie die Grundkonzepte von Golang und grpc verstehen.

1. Grundkonzepte von Golang

Golang ist eine statisch typisierte, kompilierte und gleichzeitige Programmiersprache, die von Google geboren wurde. Es gibt einige spezielle Konzepte in der Golang-Sprache, die verstanden werden müssen.

1. goroutine: Leichter Thread in Golang und das wichtigste Mittel zum Erreichen einer hohen Parallelität.
2. channel: ein spezieller Datentyp in Golang, der für die Kommunikation zwischen Goroutinen verwendet wird.
3. Auswählen: Schlüsselwort zum Multiplexen von Kanälen in Golang.
4. defer: Schlüsselwort, das verwendet wird, um die Ausführung von Funktionen in Golang zu verzögern.
5. Schnittstelle: eine Möglichkeit, Verhalten in Golang zu definieren.

2. Grundkonzepte von grpc

grpc ist ein leistungsstarkes, offenes und allgemeines RPC-Framework, das von Google entwickelt und als Open Source bereitgestellt wird. grpc unterstützt mehrere Sprachen, einschließlich Golang, C++, Java usw. Die Merkmale von grpc sind:

1. Unterstützt mehrere Serialisierungsprotokolle, einschließlich Protobuf und JSON usw.
2. Basierend auf dem http2-Protokoll unterstützt es erweiterte Funktionen wie bidirektionales Streaming, Flusskontrolle und Header-Komprimierung.
3. Unterstützt benutzerdefinierte Authentifizierung, Lastausgleich und andere Erweiterungen.

3. grpc-Bereitstellung

Nachdem wir die Grundkonzepte kennengelernt haben, stellen wir die Bereitstellung von grpc vor.

1. Grpc-Servercode schreiben

Angenommen, wir möchten ein einfaches grpc-Serverprogramm schreiben. Der Code lautet wie folgt:

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/your/proto"
)

const (
    port = ":50051"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.Name)
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

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

2. Grpc-Clientcode schreiben

Angenommen, wir möchten ein einfaches grpc-Clientprogramm schreiben Der Code lautet wie folgt:

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "path/to/your/proto"
)

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

func main() {
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

3. Kompilieren und generieren Sie Binärdateien

Der Kompilierungsbefehl lautet wie folgt:

$ go build -o greeter_server ./server/main.go
$ go build -o greeter_client ./client/main.go

4. Führen Sie das GRPC-Serverprogramm aus

$ ./greeter_server

Nach dem Ausführen sehen Sie die folgende Ausgabe:

2021/05/07 10:37:30 Listening on :50051

5. Führen Sie das GRPC-Client-Programm aus. Sie werden die folgende Ausgabe sehen:

$ ./greeter_client

IV. In diesem Artikel wird hauptsächlich die Bereitstellung von grpc vorgestellt, einschließlich des Schreibens eines grpc-Serverprogramms, des Schreibens eines grpc-Clientprogramms, des Kompilierens und Generierens von Binärdateien sowie des Ausführens von grpc-Server- und Clientprogrammen. Wenn Sie mehr über Golang und Grpc erfahren möchten, können Sie auf offizielle Dokumente und andere verwandte Materialien verweisen.

Das obige ist der detaillierte Inhalt vonSo stellen Sie Golang Grpc bereit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!