Facebook EmaiInACirclel
Développement front-end, back-end

Comment combattre le « shell hell » des microservices Node.js avec Fuge.io

PentaGuy

Blogger

Si vous développez des microservices Node.js ou avec un autre langage, vous devez isoler de nombreux processus, ce qui se traduit généralement par plusieurs terminaux de console. Or, il existe un outil utile permettant de résoudre ce problème : fuge.

Dans ce tutoriel, nous étudions un simple système de microservices, puis présentons les fonctionnalités efficaces du service fuge.io.

microservices node.js

Fuge fournit un environnement d’exécution permettant de développer des systèmes de microservices, éliminant le « shell hell » et réduisant considérablement la friction pour les développeurs.

Synthèse

Fuge est un outil très pratique de développement orienté microservices. Son objectif principal consiste à résoudre les problèmes occasionnés par la maintenance d’un grand nombre de terminaux (ou shells), phénomène également appelé « shell hell ».

Vivacious Ants

Le système que nous allons développer s’appelle Vivacious-Ants. Il est basé sur un problème très intéressant que j’ai beaucoup aimé résoudre, appelé Dead Ants.

Ce problème repose que la chaîne de caractères suivante :

..ant..ant.ant...ant.ant..ant.ant....ant..ant.ant.ant...ant..

// the answer to this one is zero dead ants
ant ant .... a nt

// 1 dead ant

Ici, notre tâche est de compter combien de fourmis sont mortes (dead ants).

Notre système de microservices aura la structure suivante :

vivacious-ants/
  antscounter/
  analytics/
  app/
  fuge.yml

Nous avons 2 microservices et une application express générée avec express-generator en front-end.

(Le code complet de la solution peut être consulté sur github, le présent article étant davantage axé sur la configuration et les fonctionnalités de fuge.io.)

Configuration de fuge

Analysons le fichier fuge.yml du répertoire vivacious-ants :

# fuge.yml

fuge_global:
  tail: true
  run_containers: false
  monitor: true
  monitor_excludes:
    - '**/node_modules/**'
    - '**/.git/**'
    - '**/*.log/'
antscounter:
  type: node
  path: ./antscounter
  run: 'node index.js'
  ports:
    - main=8080
analytics:
  type: node
  path: ./analytics
  run: 'node index.js'
  ports:
    - main=8081
webbapp:
  type: node
  path: ./webapp
  run: 'node ./bin/www'
  ports:
    - main=3000
mongo:
  image: mongo
  type: container
  ports:
    - main=27017:27017

Fuge est configuré par la fourniture d’un fichier config.yml, la configuration semble très intuitive, et j’ai été agréablement surpris par la simplicité et la robustesse du système.

La configuration de fuge commence par fuge_global::

  • tail: true rejoindra tous les logs des microservices dans votre terminal principal. Cette fonctionnalité est très pratique lorsque vous connectez différents microservices et que vous devez les débuguer.
  • monitor: true permet de redémarrer les microservices à chaque fois que vous modifiez le code. Fuge utilise (chokidar), une alternative ultra-rapide au module fs.watch Node.js comprenant bien plus de fonctionnalités.
  • run_containers: false permet aux conteneurs Docker comme mongodb ou mysql d’être gérés par l’utilisateur. Ce point sera utile si vous réutilisez les services Docker sur différents projets.

Ensuite, nous définissons tous nos microservices Docker en donnant un nom comme antscounter, analytics. Le nom du microservice est très important, car fuge va générer des variables d’environnement sous la forme suivante :

antscounter:
  type: node
  path: ./antscounter
  run: 'node index.js'
  ports:
    - main=8080

Ceci permettra de générer deux variables d’environnement (ou envars) :

 const {
   ANTSCOUNTER_SERVICE_HOST, // 127.0.0.1
   ANTSCOUNTER_SERVICE_PORT, // 8080
 } = process.env;

Vous pouvez vérifier les envars créées en exécutant cette commande :

fuge> info webapp full

Et le résultat sera le suivant :

ANTSCOUNTER_SERVICE_HOST=127.0.0.1
  ANTSCOUNTER_SERVICE_PORT=8080
  ANTSCOUNTER_PORT=tcp://127.0.0.1:8080
  ANTSCOUNTER_PORT_8080_TCP=tcp://127.0.0.1:8080
  ANTSCOUNTER_PORT_8080_TCP_PROTO=tcp
  ANTSCOUNTER_PORT_8080_TCP_PORT=8080
  ANTSCOUNTER_PORT_8080_TCP_ADDR=127.0.0.1
  ANALYTICS_SERVICE_HOST=127.0.0.1
  ANALYTICS_SERVICE_PORT=8081
  ANALYTICS_PORT=tcp://127.0.0.1:8081
  ANALYTICS_PORT_8081_TCP=tcp://127.0.0.1:8081
  ANALYTICS_PORT_8081_TCP_PROTO=tcp
  ANALYTICS_PORT_8081_TCP_PORT=8081
  ANALYTICS_PORT_8081_TCP_ADDR=127.0.0.1
  WEBBAPP_SERVICE_HOST=127.0.0.1
  WEBBAPP_SERVICE_PORT=3000
  WEBBAPP_PORT=tcp://127.0.0.1:3000
  WEBBAPP_PORT_3000_TCP=tcp://127.0.0.1:3000
  WEBBAPP_PORT_3000_TCP_PROTO=tcp
  WEBBAPP_PORT_3000_TCP_PORT=3000
  WEBBAPP_PORT_3000_TCP_ADDR=127.0.0.1
  MONGO_SERVICE_HOST=127.0.0.1
  MONGO_SERVICE_PORT=27017
  MONGO_PORT=tcp://127.0.0.1:27017
  MONGO_PORT_27017_TCP=tcp://127.0.0.1:27017
  MONGO_PORT_27017_TCP_PROTO=tcp
  MONGO_PORT_27017_TCP_PORT=27017
  MONGO_PORT_27017_TCP_ADDR=127.0.0.1
  SERVICE_HOST=127.0.0.1
  SERVICE_PORT=8080

La structure {MICROSERVICENAME}_SERVICE_HOST, {MICROSERVICENAME}_SERVICE_PORT
est également utilisée par kubernetes et docker-swarm. Ainsi, l’interface sera pratiquement la même lorsque nous déploierons nos microservices.

Initialisation du système

  • git cloneVivacious-Ants
  • Allez dans le répertoire vivacious-ants et démarrez le fuge shell.
bash> fuge shell fuge.yml # will start the shell for all the microservices

fuge> apply npm install # will run npm install for every microservice

fuge> start all
  • Après l’exécution :
 fuge> ps

Vous devez obtenir quelque chose comme :

name                          type           status         watch          tail
antscounter                   node           running        yes            yes
analytics                     node           running        yes            yes
webapp                        node           running        yes            yes
mongo                         container      not managed

Utilisation

  • Page d’accueil Ants http://localhost:3000/
  • Analyse Ants http://localhost:3000/analytics

Conclusions

Nous avons découvert les fonctionnalités principales de fuge.io, très utile durant le processus de développement des microservices en node.js.

Conseil ! N’utilisez pas fuge en production. Il n’est pas conçu pour cela, et est exclusivement un outil de développement.

Une fois que vous êtes familiarisé avec son utilisation, votre vie de développeur Node.js sera grandement facilitée.

 

Pour en savoir plus sur Node.js et d’autres sujets tech & digitaux, rejoignez-nous lors des événements dédiés Pentalog & SkillValue.

Si vous souhaitez tester vos connaissances ou l’expertise de vos équipes en développement Node.js, essayez ce quiz NodeJS. Pour une évaluation plus complexe de vos équipes, découvrez la plateforme de tests techniques mise à disposition par SkillValue.

 

Consultez aussi :

Frontend, je ne boirai pas de ton Node

Node.js : la manière la plus intelligente pour programmer des objets intelligents


Laisser un commentaire

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

This site uses Akismet to reduce spam. Learn how your comment data is processed.

En poursuivant votre navigation sur ce site, vous acceptez l’utilisation de cookies. En savoir plus

The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.

Close