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

415

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.

user1107173
la source

Réponses:

397

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.

SamT
la source
26
Si vous utilisez au fishlieu de bash, vous devez utiliser: env USER_ID=239482 my_command. Par exemple, pour définir des variables d'environnement pour la debugbibliothèque de node.js : env DEBUG='*' node some_file.js fishshell.com/docs/current/faq.html#faq-single-env
SilentSteel
1
J'ai trouvé que je devais supprimer les guillemets autour de "*" pour que cela fonctionne:env DEBUG=* node some_file.js
divillysausages
@SamT comment définir ces variables dans Ubuntu linux?
Mohammed Zameer
1
est-il possible d'ajouter un fichier plutôt que d'ajouter un grand nombre de scripts env ou un utilisateur unix doit-il créer un script bash?
mibbit
@mibbit oui, c'est de cela qu'il dotenvs'agit, car il lira votre .envfichier et l'appliquera.
balexandre
201

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.

ctrlplusb
la source
1
Bien que si vous fournissez les détails de configuration pertinents dont votre application a besoin (comme cette question pose des questions), elle tomberait probablement en son absence .. mais cela semble toujours être une bonne option.
John
6
Si vous recherchez une sécurité supplémentaire, github.com/rolodato/dotenv-safe et quelques tests devraient le faire.
ctrlplusb
1
Si vous cherchez à ne pas en avoir besoin dans votre candidature: github.com/direnv/direnv
AlecRust
100

Fournissez simplement les valeurs env sur la ligne de commande

USER_ID='abc' USER_KEY='def' node app.js
palanik
la source
2
J'ajoute simplement que cela a fonctionné pour moi sur Windows avec le shell bash (cygwin; installé avec les outils git je pense).
markau
@TiborSzasz: Cygwin ou Powershell devrait résoudre ce problème. Cela est mentionné deux ans plus tard, bien sûr.
orlando marinella
9
Pour Windows, utilisez: SET USER_ID = 'abc'
Mike
@Mike, vous devriez en faire une bonne réponse :)
rocketspacer
6
Nous pouvons utiliser le package cross-env ( npmjs.com/package/cross-env ) pour le faire fonctionner sur unix ou windwos
Brij
79

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.

jsbisht
la source
22
... les variables d'environnement sont destinées à être définies de l'extérieur du code, pas à l'intérieur - donc cela va à l'encontre de l'objectif et d'un mauvais exemple
Soren
44
@Soren notre programme de noeud qui lance le processus enfant a bénéficié de cette réponse, donc il y a des cas d'utilisation pour cela même si c'est un peu peu orthodoxe
pspi
2
@pspi - Je suis sûr à 99% que vous vous trompez et à moins que vous ne soyez l'auteur d'un package de configuration comme celui-ci, vous devriez plutôt utiliser ce package de configuration.
Soren
17
Ceci est utile si vous écrivez des scripts de construction dans js et les exécutez à partir de npm
Stephen Drew
28
Ceci est également utile, par exemple, pour définir et remplacer l'environnement lors de l'exécution de tests.
mtkopone
54

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));
Benxamin
la source
1
Hmm, j'ai essayé d'utiliser ce paquet mais il semble ne suivre que l'utilisation des variables d'environnement. Il ne lit pas le fichier .env ( npmjs.com/package/envs ). Est-ce un package correct?
wawka
1
Tu as raison! Il ne lit pas le fichier .env. C'est embarrassant. J'ai oublié que je chargeais le .env avec un script bash comme @SamT l'a mentionné, donc ça a quand même fonctionné.
Benxamin
1
"besoin ('envs')"? Qu'est-ce que "envs"?
CodyBugstein
1
'envs' est le nom d'un module de noeud: npmjs.com/package/envs
Benxamin
4
Je recommande également d'utiliser le module "dotenv", il a mis toutes les variables ENV dans l'objet proccess, plutôt sympa d'ailleurs.
Bruno de Oliveira
37

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

leszek.hanusz
la source
1
Ensuite, voyez cette réponse: stackoverflow.com/questions/135688/…
leszek.hanusz
2
Et qu'en est-il de Windows? Pourriez-vous s'il vous plaît ajouter ici?
YakovL
Ah, peu importe, on dirait qu'on y répond ici: stackoverflow.com/questions/9249830/…
YakovL
sous Linux bash, ces valeurs sont-elles persistantes? que se passe-t-il si je veux simplement l'exécuter uniquement lorsque le terminal est ouvert afin de ne pas causer de problèmes avec d'autres applications plus tard?
JesseBoyd
13

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
dpolicastro
la source
9

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.
Drkawashima
la source
8

É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

Blairg23
la source
2
@JohnXiao comment ça?
Blairg23
4

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=
Sean McClory
la source
2

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 .

simonepri
la source
2

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.

  1. vous pouvez en avoir plus

  2. 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

  3. 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.

Manohar Reddy Poreddy
la source
1

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.

Daniel Danielecki
la source
0

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

omencat
la source
-1

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 );
TacoEater
la source