API sans serveur GraphQL utilisant Kinvey Microservices

Voyons comment nous pouvons facilement utiliser Kinvey pour créer rapidement un microservice nous permettant de stocker, d’interroger et de mettre à jour le nom et l’âge de nos amis.

Progress Kinvey est une plate-forme d’application Haute productivité offrant un serveur sans serveur . Cloud backend pour la création rapide d'applications et d'expériences d'entreprise à l'échelle du consommateur. La productivité des développeurs est considérablement accrue grâce à des infrastructures frontales open source intégrées à un système à code réduit permettant des intégrations prêtes à l'emploi avec les systèmes d'entreprise et les systèmes existants.

Les services Kinvey Flex Services sont des noeuds légers et à code réduit. js microservices, utilisés pour les intégrations de données et la logique métier fonctionnelle. Les services Flex utilisent le SDK Flex et peuvent être constitués de FlexData pour les intégrations de données, de FlexFunctions pour les données basées sur des déclencheurs avant / après raccrochés ou personnalisés, et FlexAuth pour l'authentification personnalisée via Mobile Identity Connect (MIC) .

Les données sont un composant essentiel de nombreuses applications. En apparence, l'accès aux données semble simple: vous disposez d'un magasin pour vos données, qu'il s'agisse d'un SGBDR traditionnel d'un magasin NoSQL moderne ou d'un stockage local . . La réalité est cependant beaucoup plus complexe. L'abstraction de données fournie par la plate-forme Kinvey sert de cadre pour faire face à ces complexités en fournissant aux développeurs des outils qui simplifient le développement d'applications riches et orientées données. L'abstraction de données de base de Kinvey est la collection . Une collection est simplement un groupe d'entités de données liées. Kinvey ne fait aucune hypothèse sur la composition ou le schéma d'une collection (à l'exception de quelques propriétés système prédéfinies).

Si vous n'êtes toujours pas un client Kinvey, allez sur Kinvey Serverless Cloud Platform pour apprendre. à propos de toutes les possibilités. En outre, ce didacticiel suppose des connaissances relatives à SOA (architecture orientée service) et à l'interrogation / manipulation des données GraphQL .

Ce document décrit toutes les étapes, y compris la configuration d'un service Flex. localement, tout en veillant à ce que le service nécessaire soit configuré dans la console Kinvey – interface utilisateur de gestion d’arrière-plan de Kinvey. Vous devez avoir un compte Kinvey pour pouvoir suivre ces étapes. Si vous n'avez pas encore de compte, utilisez le lien suivant pour vous inscrire: https://console.kinvey.com/sign-up .

Le référentiel GitHub utilisé dans ce didacticiel est disponible à l'adresse suivante: https://github.com/bilger-progress/flex-graphql-article

Au cours des prochaines minutes, nous allons créer un microservice . ] qui nous aide à stocker les noms et les âges de nos amis. Il exposera une requête unique, qui peut nous révéler quel est l'âge de quelqu'un. Si aucun âge n'est défini pour cette personne, nous recevrons le message approprié à cet effet. Il y aura également une seule mutation que nous utiliserons pour définir (ou modifier) ​​l'âge d'une personne.

Console Kinvey

Commencez par créer une application Kinvey et un Flex. Service à l'aide de la console Kinvey .

Commencez par vous connecter à https://console.kinvey.com/ à l'aide de votre compte Kinvey et créez une nouvelle application. Nous appellerons la nôtre flex-graphql-article .

Une fois l'application créée, accédez à Services à partir de la barre de navigation supérieure et ajoutez un nouveau service de type Flex. avec le sous-type Exécution des services Flex . Donnez-lui un nom approprié tel que flex-graphql-article-service puis choisissez l'application que vous venez de créer pour lui donner accès au service. Étant donné que Kinvey Flex Services utilise les environnements dès que vous initialisez le service, vous devez enregistrer l'environnement (initial) généré automatiquement pour votre service . Utilisez l'image ci-dessous comme référence.

En raison du fait que nous allons traiter des données, il est temps Pour créer une Collection dans notre application Kinvey, accédez à la section Collections de la navigation de gauche de notre application: appelons la collection FriendsAges . ].

Configuration locale du service Flex (projet NodeJS)

À ce stade, nous sommes prêts à initialiser notre Flex Service qui est essentiellement un projet Node.js situé sur notre machine de développement. Pour démarrer avec le service, créez un nouveau dossier et initialisez un nouveau projet Node.js à l'intérieur ( à l'aide de NPM ). Vous devrez installer deux dépendances à ce projet Node.js. Ce sont les suivants:

Le module graphql facilite la création rapide d'un service GraphQL validant les requêtes et les mutations. Le module kinvey-flex-sdk sera nécessaire pour initialiser et développer notre service flexible Kinvey . Vérifiez le référentiel pour connaître les versions requises de ces paquets.

Après avoir ajouté ces deux dépendances (paquets), créons un nouveau fichier JavaScript et appelez-le index.js. . Dans ce fichier, nous ajouterons le code de notre service Flex. Pour obtenir la version la plus récente du code, consultez l'adresse suivante: https://github.com/bilger-progress/flex-graphql-article/blob/master/flex-graphql-article/ index.js

Parlons du fonctionnement de ce code

Initialement, parce que le SDK Kinvey Flex utilise un modèle de rappel nous nous assurerons de promisify . ces exécutions de rappel. La fonction, que nous appellerons promisify () englobe les exécutions de rappel dans promesses .

 function promisify (func) {
 return (... args) => {
 renvoie une nouvelle promesse ((résoudre, rejeter) => {
 func (... arguments, (error, data) => {
 si (erreur) {
 renvoyer rejet (erreur) ; 
} 
 retour résoudre (données); 
}; 
}; 
}; 
} 

Après avoir compris cela, il est temps de poursuivre la mise en œuvre de deux fonctions qui serviront à gérer l’âge de nos amis. La première fonction, getAge () récupère tous les données utilisateur de la collection Kinvey et prépare le message correct en fonction de ces informations. La deuxième fonction, setAge () extrait également toutes les données utilisateur de la collection Kinvey, puis met à jour les champs nécessaires.

 function getAge (nom, contexte) {
 ] return fetchFriendData (nom, contexte) 
 .then ((data) => {
 if (! data ||! data.age) {
 return `Désolé. Vous n'avez pas encore défini l'âge de votre ami - $ {nom}. Vous pouvez le faire maintenant. » 
 .catch (erreur => logPromiseError (erreur, contexte)); 
}; 

 fonction setAge (nom, âge, contexte) {
 renvoie fetchFriendData (nom, contexte) 
 .then ( (data) => {
 const savePromisified = promisify (context.modules.dataStore (). collection (COLLECTION_NAME) .save); 
 if (! data) {
 renvoie savePromisified ({nom, age} ); 
} 
 data.age = age; 
 return savePromisified (data); 
}) 
 .then (data => data.age) 
 .catch (error => logPromiseError (error, context)); 
}; 

Afin de garder notre code propre, la récupération des données à partir du backend est effectuée sur une fonction distincte.

 function fetchFriendData (nom, contexte) {
 const findPromisified = promisify (context.modules.dataStore (). collection (COLLECTION_NAME) .find); 
 retourne findPromisified (new context.modules.Query (). equalTo (". nom ", nom)) 
 .then (data => data [0]); 
} 

Si vous regardez plus bas, vous verrez les schémas de la GraphQL interrogation et mutations . La requête sera connectée à la fonction getAge () tandis que la mutation utilisera la fonction setAge () .

 const schema = new GraphQLSchema ({[19459030)] requête: new GraphQLObjectType ({
 name: "RootQueryType", 
 champs: {
 getAge: {
 args: {name: {name: "name", tapez: new GraphQLNonNull (GraphQLString) }}, 
 type: GraphQLString, 
 resolvez (parent, arguments, contexte) {
 return getAge (nom_argument, contexte); 
} 
} 
} 
 }), 
 mutation: new GraphQLObjectType ({
 nom: "RootMutationType", 
 champs: {
 setAge: {
 arguments: {
 nom: {nom: "nom" , tapez: new GraphQLNonNull (GraphQLString)}, 
 age: {nom: "age", tapez: new GraphQLNonNull (GraphQLInt)} 
}, 
 type: GraphQLString, 
 resolvez (parent, arguments) , contexte) {
 renvoie setAge (args.name, args.age, contexte); 
} 
} 
} 
}) 
}); 

Enfin, nous effectuons l'initialisation du service flexible Kinvey. Il existe une seule fonction enregistrée appelée graphql () . Lors de l'exécution de cette fonction, un appel à la méthode exposée par le package graphql est déclenché en passant le schéma déjà déclaré et les paramètres de corps accompagnant la demande.

 flex. functions.register ("graphql", (contexte, complet, modules) => {
 / ** 
 * Les fonctions Flex étant exécutées dans différents contextes (environnements d'application), 
 * les informations contenues dans le "contexte" et "modules" peuvent 
 * différer. Ainsi, pour chaque demande GraphQL, le contexte de l'appel de fonction correspondant doit être préparé 
 *. 
 * / 
 const graphqlArguments = {
 schéma , 
 source: context.body.query, 
 contextValue: {flex, contexte, modules} 
; 
 // FIRE! 
 graphql (graphqlArguments) 
 .then (données => complete (). setBody (data) .ok (). next ()) 
 .catch (error => complete (). setBody (erreur) .runtimeError (). done ()) 
} ]; 

Kinvey CLI

Cool ! À ce stade, nous avons tout ce dont nous avons besoin pour exécuter un service Flex. Tout ce que nous avons à faire est de lier le projet Node.js au service Flex que nous avons créé avec Kinvey Console. Cette opération est effectuée à l'aide de l'utilitaire de ligne de commande Kinvey CLI que nous installerons ensuite. Ouvrez une fenêtre de terminal et tapez ce qui suit:

 npm install -g kinvey-cli 

Une fois l'installation terminée, ouvrez une fenêtre de terminal à l'intérieur du répertoire du projet et exécutez ce qui suit:

Utilisation les mêmes informations d'identification que celles que vous utilisez pour vous connecter à la console Kinvey lorsque vous y êtes invité. Vous devez également nommer le profil que Kinvey CLI va créer pour vous. Nous appellerons notre profil development car il se trouve sur notre ordinateur local. Si vous êtes un client Kinvey, vous avez peut-être une instance dédiée de Kinvey . Si tel est le cas, entrez le bon numéro d'instance . Si vous n'avez pas d'instance Kinvey dédiée, vous pouvez laisser cette option vide. On pourrait également vous poser des questions sur le jeton 2FA si l'authentification à deux facteurs a été activée pour votre compte.

Ceci fait, disons maintenant à Kinvey CLI que nous aimerions bien utiliser ce profil de développement spécifique que nous venons de créer. Pour cela, exécutez ce qui suit:

 développement de l’utilisation du profil kinvey 

Nous souhaitons ensuite connecter le projet Node.js au Pour ce faire, exécutez ce qui suit dans le dossier du projet:

 kinvey flex init 

La commande vous invite à choisir l’application avec laquelle utiliser le service, ainsi que le service que vous avez créé. vous aurez également la possibilité de choisir dans quel environnement de service il sera déployé. Il utilise les informations fournies pour créer un profil Flex qu’il stocke dans un .kinvey ] fichier dans le répertoire du projet.

Si vous avez atteint ce point et que tout est Très bien, vous pouvez aller de l'avant et déployer le service. De nouveau, il est important d’exécuter la commande à partir du dossier de projet.

 Kinvey flex deploy 

La ​​sortie doit contenir un message indiquant qu'un travail de déploiement a Le téléchargement du code et des ressources du serveur de provisionnement sur votre service peut prendre une minute ou deux, c'est pourquoi vous devez surveiller l'avancement des travaux avant de poursuivre. Vous pouvez surveiller l'avancement du travail en exécutant ce qui suit:

le statut commencera à NEW puis passera à UPDATING pour se terminer à ONLINE . Il n'y aura pas de notification automatique à la fin du déploiement. Vous devrez vérifier manuellement l'état de déploiement du service via la commande indiquée ci-dessus, même si cela signifie que vous devez l'exécuter plusieurs fois jusqu'à ce que vous voyiez l'état En ligne .

Sur l'image ci-dessus, vous pouvez voir que le service a été initialement déployé avec la version 8.0.0. Le numéro de version est assez élevé, car j'ai effectué quelques déploiements jusqu'à ce que je sois arrivé à l'état final. Une fois que nous avons demandé un nouveau déploiement, la nouvelle version était déjà visible sur l'attribut deploymentVersion du message de journal. Vous pouvez voir que j'ai appelé deux fois la commande de statut (avec un délai d'environ 4 minutes), jusqu'à ce que je voie la nouvelle version déployée et en ligne.

Une fois le travail de déploiement terminé, vous pouvez accéder à Kinvey Console, accéder à Services choisir le service que vous avez déployé à l'aide de Kinvey CLI et cliquer sur les FlexFunction Handlers . onglet, vous pouvez vérifier que vous voyez le gestionnaire "graphql" défini dans notre code. Cela signifie que notre service est en ligne.

Configuration du point final

La prochaine étape consiste à configurer un point final personnalisé . Nous le faisons en naviguant dans la section Applications de la console Kinvey en sélectionnant la bonne application (cliquez sur le nom de l'environnement que vous utilisez pour ce didacticiel), puis sur . Points de terminaison personnalisés dans la navigation de gauche.

Ensuite, nous créons un point final, qui devrait être appuyé par un microservice. , de préférence avec le même nom que la fonction – "graphql."

Dans la fenêtre suivante, nous sélectionnons le service Flex que nous avons créé, suivi du gestionnaire que nous avons ' Je suis enregistré.

Test du service

À ce stade, nous sommes prêts Pour tester notre API GraphQL ! Passons maintenant à la API Console que vous trouverez également dans le volet de navigation de gauche de votre application . choisissez le point final "graphql" et une demande de type POST . Nous pouvons maintenant procéder et procéder aux actions suivantes:

Nous pouvons commencer par demander l'âge d'un ami. Formons le corps de la requête comme suit:

 {
 "query": "query {getAge (nom: " Nick  ")}" 
} 

Cela devrait donner lieu à un message nous indiquant que nous ne leur avons pas fixé l'âge.

Nous pouvons maintenant définir l’âge de Nick. Formons le corps de la requête comme suit:

 {
 "query": "mutation {setAge (nom: " Nick  ", age: 30)}" 
} 

Voyons comment qui réagit …

OK, vérifions maintenant que cela a fonctionné! Nous allons exécuter le même requête comme nous l'avons fait auparavant.

Woooow! À ce stade, nous avons vu comment l’API se comporte. Nous pouvons lire et mettre à jour avec succès les données de la collection Kinvey à l'aide de GraphQL.

J'espère que vous avez apprécié l'article et créé votre première incroyable API GraphQL à l'aide de la plate-forme Kinvey !

J'apprécierais vos commentaires et questions! Merci!