Travailler avec des variables d'environnement en Node.js

Temps de lecture: 7 minutes

February 10, 2022

Rédigé par

Dominik Kundel

Twilion

Darragh O'Connor

Twilion

Révisé par

Ayanna Julien

Twilion

Avec seulement quelques lignes de code, vous pouvez exécuter une application Node.js directement depuis le terminal et utiliser Twilio pour envoyer et recevoir des messages texte avec Twilio Programmable SMS.

Les bases des variables d'environnement dans Node.js

Node.js est l'un des frameworks les plus évoqués dans la communauté de développement Web depuis Rails. Bien que très récent, Node.js est à la fois rapide, hautement évolutif et efficace. La raison en est sa structure d'entrée/sortie événementielle et non bloquante.

En le combinant à Twilio, vous pouvez créer des applications de téléphonie en quelques étapes seulement. Toutefois, si vous souhaitez envoyer un SMS, par exemple, vous devrez installer Node.js et le module Twilio Node.js.

Une autre caractéristique importante du langage Node.js (et de ses modules) est sa capacité à utiliser des variables d'environnement utilisées par de nombreux hôtes Cloud (tels que Heroku, Azure, AWS, Now.sh, etc.). Cela vous ouvre un large éventail de possibilités pour configurer différents aspects de votre application Node.js. Ainsi, alors que les hôtes définissent une variable PORT spécifiant sur quel port le serveur doit écouter, les modules peuvent avoir des comportements différents (comme la journalisation) en fonction de la valeur de la variable NODE_ENV.

Dans ce blog, nous allons passer en revue quelques astuces et outils pour utiliser les variables d'environnement dans Node.js.

Tout d'abord, nous devons nous assurer que nous disposons d'un environnement Node.js. Nous vous présenterons ensuite les bases de la configuration de Node.js en vue d'une utilisation avec Twilio sur un Mac. Il sera question notamment d'installer npm sur un Mac et de préparer l'environnement pour un projet Twilio.

Comment vérifier si Node.js est installé

Vous pouvez vérifier si Node.js est déjà installé sur votre ordinateur en ouvrant un terminal et en exécutant la commande suivante :

node -v

Si Node.js n'est pas installé, les étapes suivantes vous montreront comment l'installer :

Accédez à la page de téléchargements Node.js.
Téléchargez Node.js pour MacOS en cliquant sur l'option « Macintosh Installer ».
Exécutez le programme d'installation Node.js .pkg téléchargé.
Exécutez le programme d'installation en acceptant la licence, en sélectionnant la destination et en authentifiant l'installation.

Une fois l'installation terminée, assurez-vous que Node.js exécute « node -v » sur votre terminal. Vous devez obtenir le numéro de version actuel comme indiqué ci-dessus.

Si vous ne voyez pas la version de Node.js installée, vous devrez peut-être relancer votre terminal.

Pour vous assurer que l'installation est correcte et qu'elle exécute « npm -v », essayez de confirmer l'installation via sa version.

Votre environnement Mac est maintenant prêt à installer le module Twilio afin que les scripts Node.js du répertoire actuel puissent l'utiliser.

Chargement explicite de variables à partir de fichiers .env

Vous pouvez accéder directement aux variables d'environnement dans Node.js. Lorsque votre processus Node.js démarre, il fournit automatiquement un accès à toutes les variables d'environnement existantes en créant un objet env dans l'objet global process.

Si vous voulez jeter un coup d'œil à l'objet, exécutez l'environnement Node.js REPL avec « node » dans votre ligne de commande, puis tapez :

console.log(process.env);

Ce code devrait produire l'ensemble des variables d'environnement que ce processus Node.js peut récupérer. Pour accéder à une variable spécifique, faites comme pour n'importe quelle propriété d'un objet :

console.log('The value of PORT is:', process.env.PORT);

Vous remarquerez ici que la valeur de PORT n'est pas définie sur votre ordinateur. Cependant, les hôtes Cloud comme Heroku ou Azure utilisent la variable PORT pour vous indiquer sur quel port votre serveur devrait écouter pour que le routage fonctionne correctement. Ainsi, la prochaine fois que vous configurerez un serveur Web, vous pourrez déterminer le port à écouter en vérifiant d'abord le PORT et en lui donnant ensuite une valeur par défaut :

const app = require('http').createServer((req, res) => res.send('Ahoy!'));
const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is listening on port ${PORT}`);
});

La ligne en surbrillance prendra la valeur du PORT si elle est disponible ou écoutera par défaut 3000 comme port de repli. Essayez d'exécuter le code en l'enregistrant dans un fichier tel que server.js puis exécutez :

node server.js

Le résultat devrait être un message indiquant « Server is listening on port 3000 ». Arrêtez le serveur à l'aide des touches Ctrl+C et redémarrez-le à l'aide de la commande suivante :

PORT=9999 node server.js

Le message indique désormais « Server is listening on port 9999 ». Cela signifie que la variable PORT a été temporairement placée devant le nœud pour cette exécution par PORT=9999.

Puisque process.env est un objet normal, nous pouvons définir/remplacer les valeurs :

process.env.MY_VARIABLE = 'ahoy';

Le code ci-dessus définira ou remplacera la valeur MY_VARIABLE. Cependant, gardez à l'esprit que cette valeur n'est définie que pendant l'exécution de ce processus Node.js, et n'est disponible que dans les processus enfants générés par ce processus. En règle générale, évitez autant que possible de remplacer les variables d'environnement, et initialisez simplement une variable de configuration comme indiqué dans l'exemple PORT.

Si vous développez sur plusieurs projets Node.js depuis un même ordinateur, il se peut que les noms de variables d'environnement se chevauchent. Par exemple, différentes applications de messagerie pourront avoir besoin de différents SID de service de messagerie Twilio, mais les deux s'appelleront TWILIO_MESSAGE_SERVICE_SID. Un excellent moyen d'obtenir une configuration spécifique au projet est d'utiliser des fichiers .env. Ceux-ci permettent de spécifier différentes variables d'environnement et les valeurs associées.

En règle générale, vous ne voudrez pas enregistrer ces fichiers dans le contrôle de source. Lorsque vous en créez un, ajoutez simplement .env à votre fichier .gitignore. Avec les nombreux fichiers env.example des applications de démonstration Twilio, vous pouvez les copier dans des fichiers .env et définir les valeurs vous-même. Une pratique courante consiste à avoir un fichier .env.example ou similaire si vous voulez partager un fichier modèle avec d'autres personnes du projet.

Comment charger les valeurs à partir de ce fichier ? Le moyen le plus rapide consiste à utiliser un module npm appelé dotenv. Installez le module via npm :

npm install dotenv --save

Ajoutez ensuite la ligne suivante en haut de votre fichier d'entrée :

require('dotenv').config();

Ce code chargera automatiquement le fichier .env à la racine de votre projet et initialisera les valeurs, en ignorant les variables déjà prédéfinies. Attention toutefois à ne pas utiliser les fichiers .env dans votre environnement de production. Définissez plutôt les valeurs directement sur l'hôte concerné. Il pourrait être alors judicieux d'encapsuler votre instruction « load » dans une instruction « if » :

if (process.env.NODE_ENV !== 'production') {
  require('dotenv').config();
}

Avec ce code, nous ne chargerons le fichier .env que si le serveur n'est pas déjà en mode production.

Voyons cela en action. Installez dotenv dans un répertoire comme indiqué ci-dessus. Créez ensuite un fichier dotenv-example.js dans le même répertoire et insérez-y les lignes suivantes :

console.log('No value for FOO yet:', process.env.FOO);

if (process.env.NODE_ENV !== 'production') {
  require('dotenv').config();
}

console.log('Now the value for FOO is:', process.env.FOO);

Ensuite, créez un fichier nommé .env dans le même répertoire, avec le contenu suivant :

FOO=bar

Exécutez le script :

node dotenv-example.js

La sortie devrait ressembler à :

No value for FOO yet: undefined
Now the value for FOO is: bar

Comme vous pouvez le voir, la valeur a été chargée et définie à l'aide de dotenv. Si vous réexécutez la même commande avec NODE_ENV définie sur production, vous verrez qu'elle restera undefined.

NODE_ENV=production node dotenv-example.js

La sortie devrait maintenant être :

No value for FOO yet: undefined
Now the value for FOO is: undefined

Si vous ne voulez pas modifier votre code en lui-même, vous pouvez également utiliser l'argument -r de Node pour charger dotenv lors de l'exécution du script. Pour ce faire, remplacez votre fichier dotenv-example.js par :

console.log('The value for FOO is:', process.env.FOO);

Ensuite, exécutez le fichier comme vous le feriez normalement :

node dotenv-example.js

Le script doit indiquer que la valeur actuelle de FOO est undefined. Exécutez-le maintenant avec l'indicateur approprié pour appeler dotenv :

node -r dotenv/config dotenv-example.js

Le résultat est que FOO est maintenant définie sur bar depuis que le fichier .env a été chargé. Si vous souhaitez en savoir plus sur dotenv, consultez sa documentation.

Charger autrement des fichiers .env

Il existe également un autre module basé sur dotenv pour faciliter le chargement des variables d'environnement. Le résultat est node-env-run ou nodenv. Cet outil de ligne de commande chargera un fichier .env, initialisera les valeurs à l'aide de dotenv, puis exécutera votre script.

Vous pouvez l'installer globalement, mais cela n'est recommandé qu'à des fins de développement et au niveau local du projet. Installez-le en exécutant :

npm install node-env-run --save-dev

Ensuite, créez un fichier nodenv-example.js et insérez-y ce code :

console.log('The value for FOO is:', process.env.FOO);

Comme vous pouvez le voir, il n'est pas nécessaire ici de demander quoi que ce soit, car il s'agit simplement de la logique d'application. Essayez de l'exécuter à l'aide de node :

node nodenv-example.js

Ce code exécuté devrait générer « The value for FOO is: undefined. » Essayez maintenant d'utiliser node-env-run en exécutant :

node_modules/.bin/nodenv nodenv-example.js

Le résultat devrait être « The value for FOO is: bar » dans la mesure où il a chargé le fichier .env.

L'utilisation de Node-env-run peut remplacer les valeurs existantes. Pour le voir en action, exécutez d'abord la commande suivante :

FOO=foo node_modules/.bin/nodenv nodenv-example.js

La sortie de ligne de commande devrait indiquer « The value for Foo is: foo ». Si nous activons maintenant le mode force, nous pouvons remplacer les valeurs existantes :

FOO=foo node_modules/.bin/nodenv --force nodenv.js

Par conséquent, nous devrions revenir au « The value for FOO is: bar » initial.

Si vous souhaitez utiliser cet outil régulièrement, je vous recommande de l'encapsuler dans un script npm en l'ajoutant dans le package.json comme suit :

{
  "name": "twilio-blog",
  "version": "1.0.0",
  "description": "",
  "main": "nodenv-example.js",
  "scripts": {
    "start": "node .",
    "start:dev": "nodenv -f ."
  },
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "node-env-run": "^2.0.1"
  }
}

Vous pouvez ainsi exécuter :

npm run start:dev

Si vous souhaitez en savoir plus sur node-env-run, consultez sa documentation.

Variables d'environnement et scripts npm

Dans certains scénarios, il est utile de vérifier la valeur d'une variable d'environnement avant d'entrer dans l'application Node.js en scripts npm. Par exemple, si vous souhaitez utiliser node-env-run lorsque vous êtes dans un environnement de développement, mais node lorsque vous êtes en mode production. Pour ce faire, utilisez l'outil if-env . Installez-le en exécutant :

npm install if-env --save

Toutefois, assurez-vous de ne pas l'installer en tant que « dépendance de développement » car nous en aurons aussi besoin en production.

Maintenant, modifiez vos scripts npm dans votre package.json :

 "scripts": {
    "start": "if-env NODE_ENV=production ?? npm run start:prod || npm run start:dev",
    "start:dev": "nodenv -f .",
    "start:prod": "node ."
  }

Ce script va dès lors exécuter npm run start:prod, puis node. Si NODE_ENV a la valeur production, il pourra exécuter npm run start:dev, puis nodenv -f. Vous pouvez faire de même avec n'importe quelle autre variable d'environnement.

Essayez par exemple en exécutant :

# should output "The value of FOO is: bar"
npm start
# should output "The value of FOO is: undefined"
NODE_ENV=production npm start

Si vous souhaitez en savoir plus sur if-env, consultez sa documentation.

Comment installer npm sur un Mac

Généralement, cette installation s'effectue automatiquement dans le cadre de l'installation ci-dessus. Vous pouvez vous en assurer en exécutant la commande npm dans le terminal. Si l'installation a réussi, une liste d'utilisation s'affichera. Si ce n'est pas le cas, pour installer npm, exécutez la commande suivante :

sudo apt install npm

Débogage dans Node.js

L'étape suivante est celle du débogage. Une stratégie qui m'a beaucoup aidé a été d'utiliser la variable d'environnement DEBUG afin de recevoir des journaux plus détaillés pour de nombreux modules. Prenez, par exemple, un serveur express de base comme celui-ci :

const app = require('express')();
const bodyParser = require('body-parser');
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

app.post('/', (req, res, next) => {
console.log(req);
});

app.listen(3000);

Lancez-le avec la variable DEBUG définie sur * :

DEBUG=* node server.js

Vous recevrez des journaux détaillés qui ressemblent à ceci :

La magie qui se cache derrière est un module léger appelé debug. Lorsque vous voulez l'utiliser, il vous suffit de l'initialiser avec un « espace de nom ». Vous pouvez ensuite vous connecter à cet espace de nom. Si quelqu'un veut voir la sortie, il lui suffit d'activer l'espace de nom dans la variable DEBUG. Dans ce cas, express utilise un groupe de sous-espaces de noms. Si vous voulez tout ce qui provient du routeur express, il vous suffit de paramétrer DEBUG sur le caractère générique approprié :

DEBUG=express:router* node server.js

Si vous souhaitez utiliser debug dans votre module, vous devez d'abord l'installer :

npm install debug --save

Appliquez-le ensuite de la manière suivante :

const debug = require('debug')('myApp:someComponent');

debug('Here is a pretty object %o', { someObject: true });

Si vous souhaitez en savoir plus sur debug, consultez sa documentation.

Utilisez toutes les variables d'environnement de Node.js dans Node.js avec Twilio

Ce ne sont là que quelques exemples de ce que vous pouvez faire avec les variables d'environnement et tous les outils qui existent. Maintenant que vous en savez un peu plus sur les variables d'environnement dans Node.js, essayez les guides de démarrage rapide Node.js , y compris notre guide de démarrage rapide SMS. Commencez gratuitement !