Définition des variables d'environnement pour le nœud à récupérer

J'essaie de suivre un tutoriel et il dit:

Il existe plusieurs façons de charger les informations d'identification.

1. Chargé des variables d'environnement,
2. Chargé à partir d'un fichier JSON sur le disque,

Les clés doivent être les suivantes:

USER_ID, USER_KEY

... Cela signifie que si vous définissez correctement vos variables d'environnement, vous n'avez pas du tout besoin de gérer les informations d'identification dans votre application.

Sur la base de quelques recherches sur Google, il semble que je doive définir les variables dans process.env? Comment et où dois-je définir ces informations d'identification? Exemple s'il vous plaît.

Les variables d'environnement (dans ce cas) sont utilisées pour transmettre les informations d'identification à votre application. USER_IDet USER_KEYsont accessibles à partir de process.env.USER_IDet process.env.USER_KEYrespectivement. Vous n'avez pas besoin de les modifier, accédez simplement à leur contenu.

Il semble qu'ils vous donnent simplement le choix entre charger votre USER_IDet à USER_KEYpartir de l'un process.envou de certains fichiers spécifiques sur le disque.

Maintenant, la magie se produit lorsque vous exécutez l'application.

USER_ID=239482 USER_KEY=foobar node app.js

Cela transmettra l'ID utilisateur 239482et la clé utilisateur sous la forme foobar. Cela convient pour les tests, mais pour la production, vous configurerez probablement certains scripts bash pour exporter des variables.

Je recommande fortement de regarder dans le paquet dotenv.

https://github.com/motdotla/dotenv

C'est un peu similaire à la bibliothèque suggérée dans la réponse de @Benxamin, mais c'est beaucoup plus propre et ne nécessite aucun script bash. Il convient également de noter que la base de code est populaire et bien entretenue.

Fondamentalement, vous avez besoin d'un fichier .env (que je recommande fortement d'être ignoré de votre git / mercurial / etc):

FOO=bar
BAZ=bob

Ensuite, dans votre fichier d'entrée d'application, insérez la ligne suivante le plus tôt possible:

require('dotenv').config();

Boom. Terminé. 'process.env' contiendra désormais les variables ci-dessus:

console.log(process.env.FOO);
// bar

Le fichier '.env' n'est pas requis, vous n'avez donc pas à vous soucier de la chute de votre application en son absence.

Fournissez simplement les valeurs env sur la ligne de commande

USER_ID='abc' USER_KEY='def' node app.js

Vous pouvez définir la variable d'environnement via la variable globale de processus comme suit:

process.env['NODE_ENV'] = 'production';

Fonctionne sur toutes les plateformes.

Si vous voulez une option de gestion, essayez le package envs npm. Il renvoie des valeurs d'environnement si elles sont définies. Sinon, vous pouvez spécifier une valeur par défaut qui est stockée dans une valeur par défaut globale variable d'objet par si elle ne se trouve pas dans votre environnement.

L'utilisation de fichiers .env ("dot ee-en-vee") ou d'environnement est bonne pour de nombreuses raisons. Les individus peuvent gérer leurs propres configurations. Vous pouvez déployer différents environnements (dev, stage, prod) sur des services cloud avec leurs propres paramètres d'environnement. Et vous pouvez définir des valeurs par défaut raisonnables.

Dans votre .envfichier, chaque ligne est une entrée, comme cet exemple:

NODE_ENV=development
API_URL=http://api.domain.com
TRANSLATION_API_URL=/translations/
GA_UA=987654321-0
NEW_RELIC_KEY=hi-mom
SOME_TOKEN=asdfasdfasdf
SOME_OTHER_TOKEN=zxcvzxcvzxcv

Vous ne devez pas inclure le .envdans votre référentiel de contrôle de version (ajoutez-le à votre .gitignorefichier).

Pour obtenir des variables du .envfichier dans votre environnement, vous pouvez utiliser un script bash pour faire l'équivalent de export NODE_ENV=developmentjuste avant de démarrer votre application.

#!/bin/bash
while read line; do export "$line";
done <source .env

Ensuite, cela va dans votre application javascript:

var envs = require('envs');

// If NODE_ENV is not set, 
// then this application will assume it's prod by default.
app.set('environment', envs('NODE_ENV', 'production')); 

// Usage examples:
app.set('ga_account', envs('GA_UA'));
app.set('nr_browser_key', envs('NEW_RELIC_BROWSER_KEY'));
app.set('other', envs('SOME_OTHER_TOKEN));

Cela dépend de votre système d'exploitation et de votre shell

Sur linux avec le shell bash , vous créez des variables d'environnement comme ceci (dans la console):

export FOO=bar

Pour plus d'informations sur les variables d'environnement sur ubuntu (par exemple):

Variables d'environnement sur Ubuntu

Comme l'a dit ctrlplusb, je vous recommande d'utiliser le package dotenv, mais une autre façon de le faire est de créer un fichier js et de l'exiger sur la première ligne de votre serveur d'applications.

env.js:

process.env.VAR1="Some value"
process.env.VAR2="Another Value"

app.js:

require('env')
console.log(process.env.VAR1) // Some value

Utilisateurs de Windows: faites attention! Ces commandes sont recommandées pour Unix mais sous Windows elles ne sont que temporaires. Ils définissent une variable pour le shell actuel uniquement, dès que vous redémarrez votre machine ou démarrez un nouveau shell de terminal, ils disparaîtront.

• SET TEST="hello world"
• $env:TEST = "hello world"

Pour définir une variable d'environnement persistante sous Windows, vous devez utiliser à la place l'une des approches suivantes:

A) Fichier .env dans votre projet - c'est la meilleure méthode car cela signifie que vous pouvez déplacer votre projet vers d'autres systèmes sans avoir à configurer vos variables d'environnement sur cette beore système, vous pouvez exécuter votre code.

1. Créez un .envfichier dans la racine de votre dossier de projet avec le contenu:TEST="hello world"

2. Écrivez un code de nœud qui lira ce fichier. Je suggère d'installer dotenv ( npm install dotenv --save) puis d'ajouterrequire('dotenv').config(); pendant votre code de configuration de noeud.

3. Maintenant, votre code de nœud pourra accéderprocess.env.TEST

Les fichiers env sont un bon moyen de conserver les clés api et autres secrets que vous ne voulez pas avoir dans votre base de code. Assurez-vous simplement de l'ajouter à votre .gitignore.

B) Utilisez Powershell - cela créera une variable qui sera accessible dans d'autres terminaux. Mais attention, la variable sera perdue après le redémarrage de votre ordinateur.

[Environment]::SetEnvironmentVariable("TEST", "hello world", "User")

Cette méthode est largement recommandée sur les forums Windows, mais je ne pense pas que les gens soient conscients que la variable ne persiste pas après un redémarrage du système ....

C) Utilisez l'interface graphique de Windows

1. Recherchez «Variables d'environnement» dans la recherche du menu Démarrer ou dans le panneau de configuration
2. Sélectionnez "Modifier les variables d'environnement système"
3. Un dialogue s'ouvrira. Cliquez sur le bouton "Variables d'environnement" en bas de la boîte de dialogue.
4. Vous avez maintenant une petite fenêtre pour éditer des variables. Cliquez simplement sur le bouton "Nouveau" pour ajouter une nouvelle variable d'environnement. Facile.

Étape 1: ajoutez vos variables d'environnement à leur fichier approprié. Par exemple, votre environnement de transfert pourrait être appelé .env.staging, qui contient les variables d'environnement USER_IDet USER_KEY, spécifique à votre environnement de transfert.

Étape 2: dans votre package.jsonfichier, ajoutez ce qui suit:

"scripts": {
  "build": "sh -ac '. ./.env.${REACT_APP_ENV}; react-scripts build'",
  "build:staging": "REACT_APP_ENV=staging npm run build",
  "build:production": "REACT_APP_ENV=production npm run build",
  ...
}

puis appelez-le dans votre script de déploiement comme ceci:

npm run build:staging

Configuration super simple et fonctionne comme un charme!

Source: https://medium.com/@tacomanator/environments-with-create-react-app-7b645312c09d

Pour les utilisateurs de Windows, cette question de débordement de pile et la première réponse sont très utiles sur la façon de définir les variables d'environnement via la ligne de commande

Comment puis-je définir NODE_ENV = production dans Windows?

Je suis tombé sur un bel outil pour le faire.

node-env-file

Analyse et charge les fichiers d'environnement (contenant les exportations de variables ENV) dans l'environnement Node.js, c'est process.env-à- dire - Utilise ce style:

.env

# some env variables

FOO=foo1
BAR=bar1
BAZ=1
QUX=
# QUUX=

En tant qu'extension de la réponse @ctrlplusb,
je vous suggère de jeter également un œil au env-dot-proppackage.

Il vous permet de définir / obtenir des propriétés à l' process.envaide d'un dot-path.

Supposons que votre process.envcontient les éléments suivants:

process.env = {
  FOO_BAR: 'baz'
  'FOO_🦄': '42'
}

Ensuite, vous pouvez manipuler les variables d'environnement comme ça:

const envDotProp = require('env-dot-prop');

console.log(process.env);
//=> {FOO_BAR: 'baz', 'FOO_🦄': '42'}

envDotProp.get('foo');
//=> {bar: 'baz', '🦄': '42'}

envDotProp.get('foo.🦄');
//=> '42'

envDotProp.get('foo.🦄', {parse: true});
//=> 42

envDotProp.set('baz.foo', 'bar');
envDotProp.get('', {parse: true});
//=> {foo: {bar: 'baz', '🦄': 42}, baz: {foo: 'bar'}}

console.log(process.env);
//=> {FOO_BAR: 'baz', 'FOO_🦄': '42', BAZ_FOO: 'bar'}

envDotProp.delete('foo');
envDotProp.get('');
//=> {baz: {foo: 'bar'}}

console.log(process.env);
//=> {BAZ_FOO: 'bar'}

Cela vous aide à analyser les variables d'environnement et à les utiliser comme objet de configuration dans votre application.
Il vous aide également à implémenter une configuration à 12 facteurs .

Une très bonne façon de faire les variables d'environnement que j'ai utilisées avec succès est ci-dessous:

A. Avoir différents fichiers de configuration :

1. dev.js // contient toutes les variables d'environnement pour le développement uniquement
   Le fichier contient:

   module.exports = {
    ENV: 'dev',
    someEnvKey1 : 'some DEV Value1',
    someEnvKey2 : 'some DEV Value2'
   };

2. stage.js // ceci a toutes les variables d'environnement pour le développement uniquement

   ..

3. qa.js // contient toutes les variables d'environnement pour le test qa uniquement
   Le fichier contient:

   module.exports = {
    ENV: 'dev',
    someEnvKey1 : 'some QA Value1',
    someEnvKey2 : 'some QA Value2'
   };

REMARQUE : les valeurs changent avec l'environnement, principalement, mais les clés restent les mêmes.

4. vous pouvez en avoir plus

5. z__prod.js // cela a toutes les variables d'environnement pour la production / live uniquement
   REMARQUE: ce fichier n'est jamais fourni pour le déploiement

6. Mettez tous ces fichiers de configuration dans le dossier / config /

   <projectRoot>/config/dev.js
   <projectRoot>/config/qa.js
   <projectRoot>/config/z__prod.js
   <projectRoot>/setenv.js
   <projectRoot>/setenv.bat
   <projectRoot>/setenv.sh

REMARQUE : Le nom de prod est différent des autres, car il ne serait pas utilisé par tous.

B. Définissez les variables d'environnement OS / Lambda / AzureFunction / GoogleCloudFunction à partir du fichier de configuration

Maintenant, idéalement, ces variables de configuration dans un fichier devraient être utilisées comme variables d'environnement du système d'exploitation (ou, variables de fonction LAMBDA, ou, variables de fonction Azure, Google Cloud Functions, etc.)

donc, nous écrivons l'automatisation dans Windows OS (ou autre)

1. Supposons que nous écrivions le fichier de chauve-souris « setenv », qui prend un argument qui est l'environnement que nous voulons définir

2. Exécutez maintenant " setenv dev "

a) Cela prend l'entrée de la variable d'argument passée ('dev' pour l'instant)
b) lire le fichier correspondant ('config \ dev.js')
c) définit les variables d'environnement dans le système d'exploitation Windows (ou autre)

Par exemple,

Le contenu setenv.bat peut être:

    node setenv.js

Le contenu de setenv.js peut être:

    // import "process.env.ENV".js file (dev.js example)
    // loop the imported file contents
    //     set the environment variables in Windows OS (or, Lambda, etc.)

C'est tout , votre environnement est prêt à l'emploi.

Lorsque vous effectuez ' setenv qa ', toutes les variables d'environnement qa seront prêtes à être utilisées à partir de qa.js et prêtes à être utilisées par le même programme (qui demande toujours process.env.someEnvKey1, mais la valeur qu'il obtient est qa one).

J'espère que cela pourra aider.

Simplifiez-vous la vie avec dotenv-webpack . Installez-le simplement npm install dotenv-webpack --save-dev, puis créez un .envfichier à la racine de votre application (n'oubliez pas de l'ajouter .gitignoreavant vous git push). Ouvrez ce fichier et définissez-y quelques variables d'environnement, comme par exemple:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Maintenant, dans votre configuration webpack, ajoutez:

const Dotenv = require('dotenv-webpack');
const webpackConfig = {
  node: { global: true, fs: 'empty' }, // Fix: "Uncaught ReferenceError: global is not defined", and "Can't resolve 'fs'".
  output: {
    libraryTarget: 'umd' // Fix: "Uncaught ReferenceError: exports is not defined".
  },
  plugins: [new Dotenv()]
};
module.exports = webpackConfig; // Export all custom Webpack configs.

Seulement const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()]et bien sûr module.exports = webpackConfig; // Export all custom Webpack configs.sont requis. Cependant, dans certains scénarios, vous pouvez obtenir des erreurs. Pour ceux-ci, vous avez également la solution impliquant comment vous pouvez corriger certaines erreurs.

Maintenant, où que vous voulez , vous pouvez simplement utiliser process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3dans votre application.

Je devenais indéfini après avoir défini un système env var. Lorsque je mets APP_VERSION dans la var User env, je peux afficher la valeur du nœud via process.env.APP_VERSION

Si vous utilisez un mac / linux et que vous souhaitez récupérer des paramètres locaux sur la machine que vous utilisez, voici ce que vous allez faire:

1. Dans le terminal, exécutez nano ~ / .bash_profile
2. ajoutez une ligne comme: export MY_VAR = var
3. enregistrer et exécuter la source ~ / .bash_profile
4. dans le nœud, utilisez comme: console.log ( process.env.MY_VAR );