Que faire lorsqu'une erreur "service inconnu" est renvoyée par le serveur gRPC

GRPC récemment populaire. Les données peuvent être sérialisées par Protocol Buffers, qui est un langage de schéma. En supposant que la communication peut être effectuée plus rapidement que la communication json, qui était courante jusqu'à présent Le nombre de cas adoptés dans le développement de micro-services est en augmentation.

Pendant ce temps, un bogue comme le titre s'est produit lors de la tentative de communication entre le client et le serveur construit avec gRPC. J'ai eu beaucoup de problèmes, alors je vais laisser la cause et la solution dans un mémorandum.

Code source

Cliquez ici pour la source. https://github.com/yzmw1213/PostService

Ce que j'ai essayé de faire

Implémentez les deux services suivants sur le serveur gRPC écrits en go. --Service d'affichage

• Service de gestion des balises pour les postes (traités comme données de base)

Ensuite, le code côté client implémenté par dactylographié envoie une requête au service ci-dessus et la traite.

client.ts

import { Tag, CreateTagRequest } from "~/grpc/tag_pb"
import { TagServiceClient } from "~/grpc/TagServiceClientPb"

post() {
  const client = new TagServiceClient(
    "http://localhost:8080", {}, {}
  )
  
  const request = new CreateTagRequest()
  var tag = new Tag()
  tag.setTagId(postTag.tagID)
  tag.setTagName(postTag.tagName)
  tag.setStatus(postTag.status)
  request.setTag(tag)
  //Envoyer une requête à la méthode createTag de TagService
  client.createTag(request, {}, (err, res) => {
    if (err != null) {
      console.log(err)
    }
    console.log(res)
  })
}

Lorsque le client a demandé au service de balises de créer une balise comme décrit ci-dessus, l'erreur suivante s'est produite.

{ code: 12, message: "unknown service post_grpc.TagService" }

Solution

Regardez le [git] officiel (https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto "git") en vous demandant ce qu'est le code: 12 ... vu.

ensuite

// HTTP Mapping: 501 Not Implemented UNIMPLEMENTED = 12;

en bref, Le contenu signifiait «le service n'a pas été mis en œuvre».

Par conséquent, vérifiez si le service appelant est enregistré sur le serveur gRPC.

Utilisez grpcurl pour vérifier le fonctionnement du serveur grpc.

Il y avait de nombreux détails dans cet article. https://qiita.com/yukina-ge/items/a84693f01f3f0edba482

Par exemple, si vous créez un serveur gRPC sur le port 50051, vous pouvez le frapper comme suit.

#Liste des services enregistrés dans le port
$ grpcurl -plaintext localhost:50051 list
grpc.reflection.v1alpha.ServerReflection
post_grpc.PostService

Server Reflection et Post Service semblent être enregistrés. Eh bien, je pensais que TagService l'était ... et quand j'ai lu le code côté serveur, j'ai remarqué une erreur évidente.

server.go

package grpc

import (
	"fmt"
	"log"
	"net"
	"os"
	"os/signal"

	"github.com/yzmw1213/PostService/grpc/post_grpc"
	"github.com/yzmw1213/PostService/usecase/interactor"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
)

type server struct {
	PostUsecase interactor.PostInteractor
	TagUsecase  interactor.TagInteractor
}

//Démarrage du serveur gRPC NewPostGrpcServer
func NewPostGrpcServer() {
	lis, err := net.Listen("tcp", "0.0.0.0:50051")
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	server := &server{}

	s := makeServer()
     //Enregistrer PostService auprès du serveur
	post_grpc.RegisterPostServiceServer(s, server)

     //TagService est manquant!!!


	// Register reflection service on gRPC server.
	reflection.Register(s)
	log.Println("main grpc server has started")

	go func() {
		if err := s.Serve(lis); err != nil {
			log.Fatalf("failed to serve: %v", err)
		}
	}()

	ch := make(chan os.Signal, 1)
	signal.Notify(ch, os.Interrupt)

	// Block until a sgnal is received
	<-ch
	fmt.Println("Stopping the server")
	s.Stop()
	fmt.Println("Closing the client")
	lis.Close()
	fmt.Println("End of Program")
}

func makeServer() *grpc.Server {
	s := grpc.NewServer(
		grpc.UnaryInterceptor(grpc.UnaryServerInterceptor(transmitStatusInterceptor)),
	)

	return s
}

Bien que PostService soit enregistré dans post_grpc.RegisterPostServiceServer TagService doit également être enregistré auprès du serveur gRPC.

J'ai ajouté le code suivant et l'ai résolu.

server.go

     //Enregistrer PostService auprès du serveur
	post_grpc.RegisterPostServiceServer(s, server)
	//Ajoutez ce qui suit
	//Enregistrement du service d'étiquette
	post_grpc.RegisterTagServiceServer(s, server)

Regarder en arrière

Cette fois, j'ai passé beaucoup de temps à identifier la cause. J'ai mis un proxy d'envoi entre le client et le serveur, et j'ai été distrait par le proxy. .. C'était une erreur assez rudimentaire pour moi, même si cela m'inquiétait. grpcurl, utilisons-le depuis le début.

Supplément

Lors de la création d'un serveur gRPC qui suppose un fonctionnement de microservice, J'ai l'impression qu'il existe de nombreux articles écrits sur le principe 1 service / 1 serveur, mais ce n'est pas toujours Il n'est pas nécessaire de diviser le serveur en petites parties pour tous les services, comme implémenté ci-dessus Je pense qu'il n'y aura aucun problème de fonctionnement si chaque service de registre est utilisé.

Services pertinents (tels que l'enregistrement des utilisateurs et les services d'authentification) Je pense qu'il est possible d'opérer sur le même serveur de cette manière.

Je prévois d'écrire un service d'authentification à l'avenir, je vais donc l'essayer.

Article de référence

J'ai essayé de vérifier le fonctionnement du serveur gRPC avec grpcurl