Comment déployer Golang Grpc

Ces dernières années, le langage golang a été favorisé par de plus en plus de développeurs, et ses fonctionnalités légères et à haute concurrence sont largement utilisées dans les services backend de certaines grandes entreprises. Avec la popularité des microservices et de la technologie cloud native, golang est de plus en plus utilisé dans le domaine des serveurs, et le framework rpc grpc de golang a également été largement utilisé.

Cet article présente principalement le déploiement de grpc. Avant le déploiement, vous devez comprendre les concepts de base de golang et grpc.

1. Concepts de base de golang

golang est un langage de programmation typé statiquement, compilé et concurrent, né de Google. Il existe certains concepts particuliers du langage golang qui doivent être compris.

1. goroutine : thread léger en golang et principal moyen pour atteindre une concurrence élevée.
2. channel : un type de données spécial en golang, utilisé pour la communication entre les goroutines.
3. select : mot-clé pour le multiplexage des canaux en golang.
4. defer : mot-clé utilisé pour retarder l'exécution des fonctions dans golang.
5. interface : une façon de définir le comportement en golang.

2. Concepts de base de grpc

grpc est un framework RPC général et open source hautes performances, développé et open source par Google. grpc prend en charge plusieurs langages, notamment Golang, C++, Java, etc. Les caractéristiques de grpc sont :

1. Prend en charge plusieurs protocoles de sérialisation, notamment protobuf et json, etc.
2. Basé sur le protocole http2, il prend en charge des fonctionnalités avancées telles que le streaming bidirectionnel, le contrôle de flux et la compression d'en-tête.
3. Prend en charge l'authentification personnalisée, l'équilibrage de charge et d'autres extensions.

3. Déploiement grpc

Après avoir les concepts de base, introduisons le déploiement de grpc.

1. Écrire le code du serveur grpc

Supposons que nous voulions écrire un simple programme serveur grpc, le code est le suivant :

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. Écrire le code client grpc

Supposons que nous voulions écrire un simple programme client grpc, Le le code est le suivant :

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. Compilez et générez des fichiers binaires

La commande de compilation est la suivante :

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

4. Exécutez le programme du serveur grpc

$ ./greeter_server

Après l'exécution, vous verrez le résultat suivant :

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

5. Exécutez le programme client grpc

$ ./greeter_client

Après l'exécution, vous verrez le résultat suivant :

2021/05/07 10:38:28 Greeting: Hello world

Parmi eux, world est le paramètre par défaut, et d'autres paramètres peuvent également être transmis, tels que :

$ ./greeter_client Tim

Après l'exécution, vous verrez le résultat suivant :

2021/05/07 10:39:22 Greeting: Hello Tim

IV. Résumé

Cet article présente principalement le déploiement de grpc, y compris l'écriture du programme serveur grpc, l'écriture du programme client grpc, la compilation et la génération de fichiers binaires et l'exécution des programmes serveur et client grpc. Si vous souhaitez en savoir plus sur Golang et Grpc, vous pouvez vous référer aux documents officiels et autres documents connexes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!