Fermer

décembre 29, 2018

Comment utiliser CI pour automatiser les services Kinvey Flex


Le déploiement répété de nouvelles versions d’un service Flex Kinvey que vous développez peut être une corvée. Apprenez à automatiser le processus avec l'intégration continue.

Progress Kinvey est une plate-forme de développement à haute productivité permettant de créer rapidement des applications mobiles modernes et des expériences grand public. La productivité des développeurs est considérablement accélérée 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 des systèmes d'entreprise et hérités.

Kinvey FlexServices sont des microservices NodeJS légers à code faible utilisés pour les intégrations de données et la logique métier fonctionnelle. Les services Flex utilisent le SDK Flex et peuvent comprendre FlexData pour les intégrations de données, FlexFunctions pour les crochets de pré / post sur des données basées sur des déclencheurs ou les points de terminaison personnalisés et FlexAuth pour l’authentification personnalisée via MIC (Mobile Identity Connect).

Si vous n’êtes pas encore Client Kinvey, rendez-vous sur notre page produit Kinvey pour en savoir plus sur la plate-forme et pour vous inscrire pour un compte gratuit. En outre, ce didacticiel suppose des connaissances en matière d’architecture SOA (Service Oriented Architecture) et d’automatisation (intégration / déploiement continu).

Lorsqu'un FlexService est en cours de développement, le déploiement permanent de nouvelles versions à des fins de test ou de production peut devenir une tâche ardue . Heureusement, vous pouvez utiliser un outil d'intégration continue (CI) tel que Travis CI pour automatiser complètement le processus, depuis le déclenchement d'une construction sur chaque validation de référentiel jusqu'au déploiement de FlexService sur FSR (FlexService Runtime – infrastructure cloud gérée par Kinvey).

Ce document contient toutes les étapes, y compris la configuration d'un référentiel, la configuration de Travis CI et un service Flex local, ainsi que la vérification de la configuration du service nécessaire dans la console Kinvey.

Travis CI est un service de CI hébergé et distribué utilisé pour construire et tester des projets logiciels hébergés sur GitHub. Il est totalement gratuit pour les référentiels publics, mais son utilisation avec des référentiels privés entraîne des frais.

Vous devez disposer des éléments suivants pour exécuter les instructions de cet article:

  • Compte GitHub

  • Compte Travis CI (vous pouvez vous connecter avec votre Compte GitHub)

  • Compte Kinvey avec authentification à deux facteurs (2FA) – Les comptes d'authentification à plusieurs facteurs peuvent toujours bénéficier de ce didacticiel, bien que certaines étapes nécessitent des modifications.

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

Console Kinvey

Commencez par créer une application Kinvey et un service Flex à l'aide de la console Kinvey. Commencez par vous connecter à la console Kinvey à l'aide de votre compte Kinvey et créez une nouvelle application. Nous appellerons notre application flex-automation-article . Accédez ensuite au catalogue de services en haut à gauche et ajoutez un nouveau service. Il doit s'agir d'un service flexible avec service d'exécution Flex . Vous devez lui donner un nom tel que flex-automation-article-service et choisir l'application que vous venez de créer pour lui permettre d'accéder au service.

Référentiel GitHub

Vous aurez besoin d'un public. Dépôt GitHub où Travis CI aura accès à votre projet. Pour les besoins de ce didacticiel, nous appellerons le référentiel et le projet NodeJS flex-automation-article . Après avoir cloné le référentiel sur votre ordinateur de développement, créez un sous-dossier portant le même nom, qui sera le dossier du projet actuel. Cette convention permet de garder la structure de vos dossiers claire et de séparer vos fichiers. Créez ensuite un fichier .gitignore dans le dossier repo (et non dans le répertoire du projet) et ajoutez-y les entrées suivantes. Les fichiers qu’ils représentent resteront à l’écart du contrôle de source. N'oubliez pas de remplacer "article-flex-automation-article" par le nom de dossier que vous avez choisi.

article-module-automation / node_modules

article-package / package-automation-flex lock.json

article / .kinvey

article / output.log

Le fichier .kinvey qui stocke des informations sur les services Flex configurés. , est exclu du contrôle de version car le processus d’automatisation lit ces informations à partir de variables d’environnement de la plate-forme Travis CI que nous allons définir plus loin dans le didacticiel.

Il est important de créer également un fichier README.md au même niveau de dossier que .gitignore. Nous en aurons besoin plus tard lorsque nous afficherons le statut de la compilation.

Projet NodeJS

À ce stade, nous disposons de la structure de base nécessaire pour notre service Flex et il est temps de l’initialiser. Naviguez jusqu'au répertoire du projet et initialisez un projet NodeJS simple à l'aide de NPM . Lorsque le système vous demande le point d’entrée, spécifiez src / index.js . Pour la commande de test, spécifiez ./ node_modules / mocha / bin / mocha . Cela fait, c'est probablement une bonne idée de valider l'état actuel dans GitHub.

Les prochaines dépendances. Ajoutez les entrées suivantes dans package.json puis exécutez npm install pour les installer.

Le but de chaque dépendance sera expliqué plus tard. Les versions des packages sont à jour au moment de la rédaction de cet article.

"dépendances" : {

"kinvey-flex-sdk" : "^ 3.1.2"

"mocha" : "^ 5.2.0"

"otp.js" : "^ 1.1.0 "

" demande ": " ^ 2.88.0 "

" demande-promesse ": [19659038] "^ 4.2.2"

}

Code de service Flex

Créez quelques répertoires dans le répertoire du projet (pas le répertoire parent!) Et appelez-les src . et test . Dans ces fichiers, créez les fichiers index.js et index.test.js respectivement. Ces fichiers serviront de point d’entrée pour le code des services Flex.

Ajoutez ce qui suit à votre fichier source index.js :

"use-strict"

const kinveyFlexSDK = require ( "kinvey-flex-sdk" );

kinveyFlexSDK.service ((err, flex) => {

si (err) {

console.log ( "Erreur lors de l'initialisation de Flex!" );

return ;

}

flex.functions.register ( "testFunction" (contexte, complet, modules) => {

flex.logger.info ( "Je suis un test simple function. ");

flex.logger.warn (" Je ne ferai rien de spécial. ");

retour complet (). setBody ({succès: "vrai" [19659034]serviceVersion: "1.0.0" }) .ok (). Next ();

};

})

] L’extrait de code a essentiellement deux fonctions:

Ensuite, ajoutez le code suivant à votre fichier test index.test.js :

const assert = require ( "assert" [19659034

décrivent ( "Array" function () {

décrivent ( "# indexOf ()" . ] function () {

il ( "doit retourner -1 lorsque la valeur n’est pas présente" function () {[19659040] assert.equal ([1,2,3] .indexOf (4), -1);

};

}.

} );

Le test n'a rien à voir avec le code de votre fonction. Nous l’ajoutons simplement pour avoir quelques tests lors du processus d’automatisation. Une fois que vous avez commencé à utiliser Kinvey Flex Services, vous devez créer les tests appropriés pour votre code source.

N'oubliez pas que c’est toujours une bonne idée d’inclure des tests dans votre projet.

Exécutez la commande suivante pour vous assurer que le test est réussi:

Ensuite, vous voudrez vérifier si le microservice fonctionne correctement localement.

Ceci démarrera un service local qui écoutera le port 10001 (qui vous pouvez voir dans la sortie de la console). Ensuite, à l'aide d'un client REST (tel que Postman), vous pouvez envoyer une simple demande POST à ​​ http: // localhost: 10001 / _flexFunctions / testFunction et voir si vous obtenez la réponse attendue. Vous devriez voir une sortie semblable à celle-ci:

{

"demande" : {

"méthode" : "POST" ,

"en-têtes" : {},

"nom d'utilisateur" : ""

"userId" [19659034]: ""

"nomObjet" : ""

"tempObjectStore" : {}, [}, [19659040] "corps" : {}

},

"réponse" : {

"statut" : 0 ,

"en-têtes" : {},

"corps" : {

"succès" : "true"

"serviceVersion" : "1.0.0"

},

"statusCode" : 200,

"continue" : true

}

}

Pour arrêter le service local, appuyez sur CTRL + C.

C'est un bon point à faire valoir. votre prochain commit.

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 d’associer le projet NodeJS et le service Flex que nous avons créés à l’aide de 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 (pas le répertoire parent!), Puis exécutez ce qui suit:

Utilisez 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 créera pour vous une fois l’opération terminée. Nous appellerons notre profil development car il se trouve sur notre machine locale. Si vous êtes un client Kinvey, vous pouvez avoir une instance Kinvey dédiée. Si tel est le cas, veuillez saisir le bon identifiant d'instance. Si vous n'avez pas d'instance Kinvey dédiée, vous pouvez laisser cette option vide.

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

Développement de l'utilisation du profil kinvey

Nous souhaitons ensuite connecter le projet NodeJS au service de la console Kinvey. Pour ce faire, exécutez ce qui suit dans le dossier du projet:

La commande vous invite à choisir l'application avec laquelle utiliser le service, ainsi que le service que vous avez créé. Il a utilisé les informations fournies pour créer un profil Flex qu'il a stocké dans un fichier .kinvey dans le dossier du projet.

Si vous avez atteint ce point et que tout va bien, vous pouvez continuer et déployer le service. Là encore, il est important d’exécuter la commande à partir du dossier de projet.

La sortie devrait contenir un message indiquant qu'un travail de déploiement a été lancé. 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 les progrès avant de poursuivre. Vous pouvez suivre l'avancement du travail en exécutant les opérations suivantes:

Le statut commence à NEW, puis passe à UPDATING et se termine à ONLINE. . Il n'y aura pas de notifications automatiques lorsque le déploiement est terminé. Vous devrez donc vérifier manuellement l'état du déploiement du service en exécutant la commande ci-dessus (remarque: vous devrez peut-être l'exécuter plusieurs fois jusqu'à ce que l'état EN LIGNE apparaisse).

Test du service Flex [19659017] Une fois le travail de déploiement terminé, accédez à la console Kinvey, accédez au Service Catalog choisissez le service approprié et cliquez sur l’onglet FlexFunction Handlers . vérifiez que vous voyez le gestionnaire testFunction défini dans notre code. Cela signifie que notre service est en ligne.

Pour tester rapidement le service, nous allons configurer un point de terminaison personnalisé. Pour ce faire, accédez à la section Apps de la console Kinvey (coin supérieur gauche), en sélectionnant la bonne application (cliquez sur le nom de l'environnement que vous utilisez pour ce didacticiel), puis sur puis passez à Points de terminaison personnalisés dans le volet de navigation de gauche. Ensuite, nous créons un point de terminaison de type MicroService de préférence avec le même nom que la fonction – testFunction . Dans la fenêtre suivante, nous sélectionnons le service Flex créé, suivi du gestionnaire que nous avons enregistré.

Kinvey1 "title =" Kinvey1 "/></p data-recalc-dims=

Pour appeler notre point de terminaison personnalisé, accédez à API Console dans le volet de navigation de gauche.Sélectionnez le type de demande POST, puis sélectionnez un noeud final dans le menu déroulant (les noeuds finaux apparaissent en bas du menu déroulant). vous donne la réponse attendue.

HTTP / 1.1 200 OK

Type de contenu: application / json; charset = utf-8

X-Kinvey-API-Version: 3

X-Kinvey-Request -Id: ***

X-Powered-By: Express

{

"succès" : "vrai"

[1965] 19659036] "serviceVersion" : "1.0.0"

}

Travis CI Transcript

Nous sommes prêts à commencer à jouer. avec l'automatisation réelle. ajoutez un fichier de transcription pour Travis CI. Ce fichier de transcription indique au moteur d’automatisation les étapes à suivre pour déployer le service Flex. Nous le faisons en créant un fichier .travis.yml dans le dossier parent (pas le répertoire du projet!). Dans le fichier, mettez le contenu suivant:

langue: node_js

node_js:

- 8

script:

- cd ./flex -automation-article /

- npm install

- npm install -g kinvey-cli

- test npm

- node ./buildProcessAuth.js

- Le profil kinvey crée $ KINVEY_SERVICE_PROFILE --email $ KINVEY_USER_EMAIL --password $ KINVEY_USER_PASSWORD

- kinvey flex deploy --service $ KINVEY_USER_PASSWORD

- kinvey flex deploy --service $ KINVEY_USER_PASSWORD ] uniquement:

- master

N'oubliez pas de changer le nom du dossier à la ligne cinq si vous avez utilisé un nom différent.

La transcription reprend dans une large mesure les étapes que vous avez suivies pour initialiser et déployer manuellement le service Flex. En bref, il installe les packages nécessaires, exécute les tests et, s’ils réussissent, exécutent les commandes spécifiques à Kinvey qui donnent lieu à un travail de déploiement de service.

Notez que sur la ligne 9, nous exécutons un script JS. Il est là pour gérer l’authentification en cas d’expiration du jeton d’authentification Kinvey 2FA.

Collez le code de script dans un fichier appelé buildProcessAuth.js et placez-le dans le répertoire du projet (pas le parent). dossier de référentiel).

"use strict"

const otp = require ( "otp.js" );

const rp = require ( "application-promesse ");

const options = {

méthode: " POST "

corps: {

email : process.env.KINVEY_USER_EMAIL,

mot de passe: process.env.KINVEY_USER_PASSWORD,

19659040] json: true

};

rp (optio ns)

.then ( function (data) {

console.log ( "authentifié avec succès auprès de Kinvey!" );

})

. capture ( fonction (err) {

si (err && err.message) {[19659040] console.error (err.message);

}

process.exit (1);

})

La Le code de script crée une session avec Kinvey en utilisant les variables d’environnement pour le courrier électronique, le mot de passe et le secret de l’utilisateur (nous y reviendrons dans un instant). La création d'une session avec Kinvey nécessite un jeton d'authentification à deux facteurs, ce qui explique l'utilisation de One-Time Password manager (otp.js) .

Cette opération met fin à toutes les éditions locales. que nous devons faire, allons-y et engageons le git final pour le projet.

Travis CI UI

Après avoir créé et validé un fichier de transcription, nous pouvons continuer à configurer Travis CI. Accédez à https://travis-ci.org/ et connectez-vous (de préférence avec votre compte GitHub car cela connectera automatiquement les deux comptes). Sur la page Settings vous verrez vos référentiels publics (vous aurez besoin de la version payante de Travis CI pour pouvoir l'utiliser avec des pensions privées). Vous devez activer Travis CI pour votre référentiel. Ensuite, ouvrez la page des paramètres du référentiel. Au moins à des fins de test, je recommande de laisser uniquement le paramètre construction branches poussées activé. Dans le menu annulation automatique laissez tout inchangé.

Ensuite, nous commençons à ajouter les variables d'environnement. Ils sont les suivants:

Le meilleur outil 2023 pour ta croissance Instagram !



Source link