Catégories
Start-up et applications

Comment générer automatiquement du code gRPC à l'aide de protoc

Créer du code gRPC à partir de zéro est une entreprise laborieuse qui, pour de nombreuses entreprises, fait en sorte que le coût de mise en œuvre du gRPC l'emporte sur les avantages. À tout le moins, partir de zéro signifie convertir des structures de données gRPC (a.k.a messages) exprimées en texte et en nombres vers et depuis le format binaire Protocol Buffers qui est intrinsèque à la facilitation de la communication entre les clients gRPC et un serveur. (Voir la figure 1 ci-dessous)

Figure 1: gRPC utilise le format binaire Protocol Buffers comme lingua franca de l'échange de données

Figure 1: gRPC utilise le format binaire Protocol Buffers comme lingua franca de l'échange de données

De plus, créer votre propre code API gRPC à partir de zéro signifie écrire la logique métier pour les services définis dans l'API. .proto fichier. Et, si cela ne suffit pas, vous devrez écrire le code qui achemine, appelle et depuis des services spécifiques définis pour l'API gRPC. Comme vous pouvez le voir, c'est beaucoup de travail.

Heureusement, la communauté gRPC a créé un outil qui effectue une grande partie du travail banal qui accompagne la création de code pour une API gRPC. L'outil s'appelle protocole. protocole est un exécutable binaire qui permet aux programmeurs de générer automatiquement du code de support pour une API telle que définie dans l'API .proto fichier.

L'objectif de cet article est d'expliquer comment obtenir protocole opérationnel pour générer automatiquement du code gRPC dans une variété de langages de programmation. Nous aborderons le code de génération automatique en JavaScript, C # et GoLang. Ce code sera généré à l'aide du .proto fichier qui fait partie d'un exemple de projet de démonstration nommé SimpleService. De plus, nous partagerons des liens vers un certain nombre de leçons dans l'environnement d'apprentissage interactif Katacoda que nous ProgrammableWeb ont créé pour votre bénéfice.

Comprendre la portée de .proto Plugins

Comme mentionné ci-dessus, protocole est l'exécutable binaire utilisé pour générer automatiquement du code standard. protocole utilise le modèle de conception du plugin. Ainsi, un développeur de plugin écrit un complément pour protocole qui générera automatiquement du code pour la langue donnée d'une manière particulière. Par exemple, il existe un plugin JavaScript qui génère du code JavaScript qui représente des objets qui correspondent aux messages dans un .proto fichier. Ces objets auto-générés contiendront les champs de données qui correspondent à un message particulier. En outre, le code généré automatiquement attache une logique à chaque objet qui sérialisera et désérialisera les données du message vers et depuis le format binaire Protocol Buffers.

D'un autre côté, le plugin GoLang, par exemple, générera également automatiquement du code qui décrit les données du message avec sa logique de sérialisation et de désérialisation ainsi que la logique métier pour les services définis dans l'API. .proto fichier.

Chaque plugin fonctionne un peu différemment. Ainsi, il faut un peu de temps pour maîtriser les détails de chacun. Cependant, en termes d'adoption dans le monde réel, les développeurs ont tendance à se concentrer sur les plugins qui sont pertinents pour les langages de programmation préférés de leur entreprise.

Obtenir protocole

le protocole L'outil est spécifique au système d'exploitation. Il y a protocole versions pour OS X, Windows et Linux. Vous pouvez également créer un protocole exécutable directement à partir du code source à l'aide d'un compilateur C ++. Mais le moyen le plus simple d'utiliser l'outil est de télécharger directement l'exécutable spécifique au système d'exploitation.

Vous pouvez obtenir une liste complète des protocole libère ici. Vous accéderez à une version particulière en cliquant sur l'en-tête de lien hypertexte pour une version de version particulière. (Voir la figure 2 ci-dessous)

Figure 2: L'exécutable du protocole est disponible pour chaque version de Protocol Buffers

Figure 2: le protocole l'exécutable est disponible pour chaque version de Protocol Buffers

Ensuite, vous serez redirigé vers une liste de fichiers zip. Certains de ces fichiers zip sont pertinents pour travailler avec protocole dans une langue particulière. Mais, soyez avisé, le pré-construit protocole compilateur n'est dans aucun de ces fichiers zip. Au contraire, la version prédéfinie de protocole se trouve dans le fichier zip spécifique au système d'exploitation. (Voir la figure 3 ci-dessous)

Figure 3: l'exécutable du protocole est disponible dans un fichier zip spécifique au système d'exploitation

Figure 3: le protocole l'exécutable est disponible dans un fichier zip spécifique au système d'exploitation

Si vous souhaitez en savoir plus sur l'utilisation du code passe-partout généré automatiquement dans la langue de votre choix, jetez un œil aux tests et exemples dans le fichier zip spécifique à la langue, comme illustré ci-dessous dans la figure 4.

Figure 4: Les fichiers zip spécifiques au langage contiennent des exemples fonctionnant avec le compilateur de protocoles

Figure 4: Les fichiers zip spécifiques à la langue contiennent des exemples fonctionnant avec le protocole compilateur

En utilisant protocole pour générer automatiquement du code

Après avoir téléchargé le fichier zip spécifique au système d'exploitation, vous allez le décompresser et copier le fichier, protocole dans un dossier qui se trouve dans le chemin de votre système. Par exemple, si vous utilisez un système Linux, vous accédez au dossier que vous avez décompressé à partir du fichier zip téléchargé, puis exécutez la commande de copie suivante:

cp bin/protoc /bin/protoc

Bien sûr, cela suppose que le dossier /poubelle est défini dans la variable d'environnement PATH de votre système. Une fois que protocole est ajouté à votre chemin, vous pourrez l'utiliser pour générer automatiquement du code à partir de n'importe où sur votre ordinateur.

Une fois que tu as protocole installé sur votre ordinateur, vous l'utiliserez pour générer automatiquement du code gRPC en fonction de la portée d'un plugin particulier. La commande présentée ci-dessous dans le listing 1 est un exemple d'utilisation protocole pour générer automatiquement du code gRPC pour JavaScript. Les détails sur la commande suivent.

protoc --proto_path=proto --js_out=library=simpleservice,binary:js_autogen 
  proto/simple.proto

  • protocole est la commande qui appelle la génération automatique de code
  • –proto_path est l'option qui déclare l'emplacement relatif du dossier contenant les fichiers .proto pertinents
  • -js_out = bibliothèque = simpleservice est le nom du fichier Javascript qui sera créé. Ce fichier contiendra des objets JavaScript qui correspondent aux messages définis dans le fichier .proto. Ces objets auront des fonctions de sérialisation et de désérialisation des données de l'objet vers et depuis le format binaire Protocol Buffers.
  • binaire: js_autogen est le paramètre d'option qui définit l'emplacement du dossier cible pour les fichiers générés automatiquement. Ce dossier doit exister avant que la génération automatique ne soit appelée.
  • proto / simple.proto est l'emplacement du .proto fichier qui sert de base à la génération automatique

Liste 1: En utilisant protocole pour générer automatiquement le passe-partout gRPC en Javascript

La figure 5 ci-dessous montre le code JavaScript résultant de l'exécution du protocole commande décrite ci-dessus dans la liste 1. Le code affiché dans l'IDE de Visual Studio Code.

Figure 5: protoc pour JavaScript générera automatiquement des objets qui sont décrits comme des messages dans le fichier .proto approprié

Figure 5: protocole pour JavaScript générera automatiquement des objets décrits comme des messages dans les .proto fichier.

Comme mentionné ci-dessus, protocole prend en charge une variété de langues pour la génération automatique. Le listing 2 ci-dessous montre le protocole commande pour la génération automatique de code dans .NET / C #.

protoc --proto_path=proto --csharp_out=cs_autogen --csharp_opt=file_extension=.cs 
  proto/simple.proto

  • protocole est la commande qui appelle la génération automatique de code
  • –proto_path est l'option qui déclare l'emplacement du dossier contenant les .proto des dossiers
  • –csharp_out = cs_autogen est le nom du dossier où protocole stockera le code généré automatiquement. Dans ce cas, le dossier de sortie est cs_gen
  • –csharp_opt = extension_fichier = .cs définit l'extension de fichier qui sera appliquée au fichier de sortie. Dans ce cas, l'extension de fichier est définie comme étant .cs, ce qui entraînera un fichier de sortie nommé Simples.cs. Par défaut protocole nomme les fichiers de sortie en fonction du nom du .proto fichier, qui est simple.proto. Aussi, le plugin pascal cas le nom du fichier de sortie. (Le pascal la convention de dénomination de casse est celle dans laquelle le premier caractère d'un mot est en majuscule.) Si la valeur de extension de fichier était réglé sur –csharp_opt = extension_fichier = .cs, le fichier de sortie sera Simple.pb.cs
  • proto / simple.proto est l'emplacement du .proto fichier qui sert de base à la génération automatique

Liste 2: En utilisant protocole pour générer automatiquement le passe-partout gRPC dans .NET / C #

La figure 6 ci-dessous affiche les résultats de l'utilisation protocole pour générer automatiquement du code C #.

Figure 6: les résultats de l'utilisation de protoc pour générer automatiquement du code C #

Figure 6: Les résultats de l'utilisation protocole pour générer automatiquement du code C #

Une fois que vous avez généré les objets pour les messages définis dans l'API gRPC .proto fichier, vous pouvez les utiliser dans vos efforts de développement.

Sachez que dans le cas du code JavaScript et C # démontré dans les exemples ci-dessus, le code standard de génération automatique ne fournit pas toute la logique dont vous avez besoin pour créer une API gRPC entièrement fonctionnelle. Le code standard crée des objets qui représentent les messages gRPC définis dans le .proto fichier. Chaque objet contiendra la logique de sérialisation et de désérialisation nécessaire pour coder et décoder les données de l'objet vers et depuis un binaire Protocol Buffers. Cependant, vous devrez toujours créer un serveur, puis programmer les procédures ainsi que la logique d'accès aux données dont votre API a besoin pour faire son travail. Comme mentionné ci-dessus, cela peut être une entreprise intimidante.

Heureusement, il existe des projets qui fournissent un tel cadre. gRPC Elixir pour Python est l'un de ces projets.

De plus, comme nous l'avons décrit ci-dessus, certains plugins génèrent automatiquement le code standard pour les services gRPC ainsi que les messages. Par exemple, le plugin GoLang pour protocole génère à la fois des messages et des services. Vous pouvez apprendre les détails en prenant ProgrammableWebla leçon interactive de Katacoda qui montre du code auto-générateur sous GoLang. La leçon est basée sur le tutoriel GoLang publié sur grpc.io. Vous pouvez trouver la leçon interactive ici. Une capture d'écran de la leçon est illustrée ci-dessous dans la figure 7.

Figure 7: La leçon interactive Katacoda qui montre comment utiliser protoc pour générer automatiquement un message et un code de service sous GoLang

Figure 7: La leçon interactive Katacoda qui montre comment utiliser protocole pour générer automatiquement un message et un code de service sous GoLang

Un autre projet qui génère à la fois des messages et des procédures est les outils grpc qui peuvent être trouvés sur le site Web de npm. grpc tools, qui est publié par Google, apporte une amélioration à protocole sous la forme d'un binaire nommé grpc_tools_node_protoc. grpc_tools_node_protoc générera automatiquement du code standard en JavaScript pour les messages et procédures gRPC définis dans le .proto fichier. Pour avoir une compréhension plus détaillée de outils grpc, prenez la leçon interactive sur Katacoda que nous ProgrammableWeb créé. Vous pouvez trouver la leçon ici. La figure 8 ci-dessous montre une capture d'écran de la leçon interactive

Figure 8: La leçon interactive Katacoda pour la génération automatique de Node.js crée du code pour les procédures et les messages définis dans le fichier .proto gRPC

Figure 8: La leçon interactive Katacoda pour la génération automatique de Node.js crée du code pour les procédures et les messages définis dans le gRPC .proto fichier

Les exemples ci-dessus ne sont que quelques-uns des nombreux disponibles sur grpc.io. Il existe des exemples en C ++, Dart, Objective C et PHP, pour n'en nommer que quelques-uns. Cela vaut la peine de prendre le temps de passer en revue les didacticiels gRPC pour le langage de programmation choisi. Mais, quel que soit le langage que vous utilisez, rappelez-vous que l'obtention d'un code généré automatiquement et utile ne consiste pas à exécuter une seule commande en ligne de commande. Vous devrez également créer un serveur gRPC qui sait comment parler au code généré automatiquement. La création d'un serveur qui utilise du code gRPC généré automatiquement est un sujet que nous abordons dans l'article Écriture d'un serveur d'API gRPC, que vous pouvez trouver ici.

Mettre tous ensemble

Le code standard de génération automatique offre de nombreux avantages pour le développement de logiciels gRPC. Demander aux développeurs de créer du code banal est une perte de temps et d'argent. Il est plus facile de générer automatiquement le code standard pour le message et les services tels que définis dans un proto puis demandez aux développeurs d'appliquer leur expertise à des tâches de programmation critiques telles que la mise en œuvre de règles de validation contre les données entrantes, l'application de la logique métier dans les procédures et le stockage des données.

Cependant, aussi puissant que le code de génération automatique protocole est, ce n'est pas une fin-tout ou être tout. L'étendue de l'activité d'auto-génération varie en fonction des protocole plugin utilisé. En conséquence, un programmeur devra ajouter du code qui consomme le code généré automatiquement. L'avantage est que le programmeur effectuera des tâches à fort impact plutôt qu'un travail banal. Les gains d'efficacité sont évidents.

protocole et son dérivé, grpc_tools_node_protoc, apportent beaucoup de puissance à la programmation gRPC. L'astuce est de connaître les limites d'un particulier protocole plugin en termes de génération automatique et être en mesure de fournir l'expertise de programmation nécessaire après la génération automatique de code.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *