Définition des variables d'environnement pour que Node puisse être récupéré
J'essaie de suivre un tutoriel et il dit:
"Il existe plusieurs façons de charger les informations d'identification.
- Chargé à partir de variables d'environnement,
- 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 Google, il apparaît que je dois 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_ID et USER_KEY sont tous deux accessibles à partir de process.env.USER_ID et process.env.USER_KEY. Vous n'avez pas besoin de les éditer, il vous suffit d'accéder à leur contenu.
On dirait qu'ils vous donnent simplement le choix entre charger votre USER_ID et USER_KEY à partir de process.env ou d'un fichier spécifique sur le disque.
Maintenant, la magie se produit lorsque vous exécutez l'application.
USER_ID=239482 USER_KEY=foobar node app.js
Cela passera l'ID utilisateur 239482 et la clé utilisateur en tant que foobar. Cela convient aux tests, cependant, pour la production, vous allez probablement configurer des scripts bash pour exporter les variables.
Je recommande fortement de regarder dans le paquet de 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.
En gros, vous avez besoin d’un fichier .env (que je vous recommande vivement d’ignorer de votre compte git/Mercurial/etc):
FOO=bar
BAZ=bob
Ensuite, dans votre fichier de candidature, insérez la ligne suivante le plus tôt possible:
require('dotenv').config();
Boom. Terminé. 'process.env' contiendra maintenant 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.
Il suffit de fournir 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 souhaitez une option de gestion, essayez le package envs npm. Il renvoie les valeurs d'environnement si elles sont définies. Sinon, vous pouvez spécifier une valeur par défaut stockée dans une variable d'objet globale par défaut si elle ne se trouve pas dans votre environnement.
L'utilisation de . Env ("dot ee-en-vee") ou de fichiers d'environnement convient à 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 fichier .env, chaque ligne est une entrée, comme dans l'exemple suivant:
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 devez non inclure le .env dans votre référentiel de contrôle de version (ajoutez-le à votre fichier .gitignore).
Pour obtenir des variables du fichier .env dans votre environnement, vous pouvez utiliser un script bash pour effectuer l'équivalent de export NODE_ENV=development juste 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 Shell bash , vous créez des variables d’environnement comme celles-ci (dans la console):
export FOO=bar
Pour plus d'informations sur les variables d'environnement sur Ubuntu (par exemple):
Comme ctrlplusb l'a dit, je vous recommande d'utiliser le package dotenv, mais vous pouvez également créer un fichier js et 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
Étape 1: Ajoutez vos variables d'environnement dans le fichier approprié. Par exemple, votre environnement de transfert peut s'appeler .env.staging, qui contient les variables d'environnement USER_ID et USER_KEY, spécifiques à votre environnement de transfert.
Étape 2: Dans votre fichier package.json, ajoutez les éléments suivants:
"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
Super simple à installer et fonctionne comme un charme!
Source: https://medium.com/@tacomanator/environments-with-create-react-app-7b645312c09d
Pour les utilisateurs de Windows, cette question et la réponse principale relative au dépassement de capacité sont très utiles pour définir des variables d'environnement via la ligne de commande.
Utilisateurs 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 ordinateur ou démarrez un nouveau terminal Shell, ils disparaîtront.
SET TEST="hello world"$env:TEST = "hello world"
Pour définir une variable d'environnement persistant sous Windows, vous devez utiliser 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 sur d’autres systèmes sans avoir à configurer vos vars d’environnement sur ce système avant de pouvoir exécuter votre code. .
Créez un fichier
.envdans la racine du dossier de votre projet avec le contenu suivant:TEST="hello world"Ecrivez un code de noeud qui lira ce fichier. Je suggère d'installer dotenv (
npm install dotenv --save), puis d'ajouterrequire('dotenv').config();lors de la configuration de votre nœud.- Maintenant, votre code de noeud pourra accéder
process.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) Use Powershell - Ceci 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 sachent que la variable ne persiste pas après un redémarrage du système ....
C) Utilisez l'interface graphique de Windows - ce n'est pas aussi cool qu'une commande, mais au moins cela fonctionne et crée une variable persistante.
- Recherchez "Variables d'environnement" dans le menu Démarrer. Recherchez ou dans le Panneau de configuration.
- Sélectionnez "Editer les variables d'environnement du système".
- Un dialogue va s'ouvrir. Cliquez sur le bouton "Variables d'environnement" au bas de la boîte de dialogue.
- Vous avez maintenant une petite fenêtre pour éditer les variables. Cliquez simplement sur le bouton "Nouveau" pour ajouter une nouvelle variable d'environnement. Facile.
Je suis tombé sur un outil de Nice pour le faire.
Analyse et charge les fichiers d’environnement (contenant les exportations de variables ENV) dans l’environnement Node.js, c.-à-d. process.env - Utilise ce style:
.env
# some env variables
FOO=foo1
BAR=bar1
BAZ=1
QUX=
# QUUX=
Comme extension de la réponse @ctrlplusb,
Je vous conseillerais également de regarder le paquet env-dot-prop .
Il vous permet de définir/d’obtenir les propriétés de _process.env_ en utilisant un dot-path .
Supposons que votre _process.env_ contienne 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 à mettre en œuvre une configuration à 12 facteurs .
Voici un très bon moyen d’utiliser les variables d’environnement que j’ai utilisées avec succès:
A. Avoir différents fichiers de configuration:
dev.js // contient toutes les variables d'environnement réservées au développement
Le fichier contient:module.exports = { ENV: 'dev', someEnvKey1 : 'some DEV Value1', someEnvKey2 : 'some DEV Value2' };stage.js // contient toutes les variables d'environnement réservées au développement
..qa.js // contient toutes les variables d'environnement pour le test de qualité uniquement
Le fichier contient:module.exports = { ENV: 'dev', someEnvKey1 : 'some QA Value1', someEnvKey2 : 'some QA Value2' };
NOTE: les valeurs changent en fonction de l'environnement, mais les clés restent les mêmes.
tu peux avoir plus
z__prod.js // contient toutes les variables d'environnement pour production/live uniquement
REMARQUE: ce fichier n'est jamais groupé pour le déploiement.Placez tous ces fichiers de configuration dans/config/folder
<projectRoot>/config/dev.js <projectRoot>/config/qa.js <projectRoot>/config/z__prod.js <projectRoot>/setenv.js <projectRoot>/setenv.bat <projectRoot>/setenv.sh
NOTE: Le nom de prod est différent des autres, car il ne serait pas utilisé par tous.
B. Définir les variables d'environnement OS/Lambda/AzureFunction/GoogleCloudFunction à partir du fichier de configuration
Maintenant, idéalement, ces variables de configuration dans le fichier doivent être utilisées comme variables d’environnement de système d’exploitation (ou, variables de fonction LAMBDA, ou, variables de fonction Azure, Google Cloud Functions, etc.).
alors, nous écrivons automatisation sous Windows (ou autre)
Supposons que nous écrivions 'setenv' fichier bat, qui prend un argument qui est l'environnement que nous voulons définir
Maintenant, lancez "setenv dev"
a) Ceci 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 sous Windows (ou autre)
Par exemple,
Le contenu de 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 à être utilisé.
Quand vous faites 'setenv qa', toutes les variables d'environnement qa seront prêtes à être utilisées à partir de qa.js et par le même programme (qui demande toujours process.env.someEnvKey1, mais la valeur ça devient qa un).
J'espère que ça t'as aidé.
Facilitez-vous la vie avec dotenv-webpack . Installez-le simplement _npm install dotenv-webpack --save-dev_, puis créez un fichier _.env_ à la racine de votre application (pensez à l'ajouter à _.gitignore_ avant _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.
_Seuls 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, ce qui implique comment vous pouvez corriger certaines erreurs.
Maintenant, où que vous soyez, vous pouvez simplement utiliser _process.env.ENV_VAR_1_, _process.env.ENV_VAR_2_, _process.env.ENV_VAR_3_ dans votre application.
Je devenais indéfini après la définition d'une variable système env. Lorsque je mets APP_VERSION dans la variable env. Utilisateur, je peux alors afficher la valeur du noeud via process.env.APP_VERSION.