Impostazione delle variabili d'ambiente per il nodo da recuperare


415

Sto cercando di seguire un tutorial e dice:

Esistono alcuni modi per caricare le credenziali.

  1. Caricato da variabili d'ambiente,
  2. Caricato da un file JSON su disco,

Le chiavi devono essere le seguenti:

USER_ID, USER_KEY

... Ciò significa che se si impostano correttamente le variabili di ambiente, non è necessario gestire le credenziali nell'applicazione.

Basato su alcuni googling, sembra che devo impostare le variabili process.env? Come e dove impostare queste credenziali? Esempio per favore.

Risposte:


397

Le variabili di ambiente (in questo caso) vengono utilizzate per trasferire le credenziali all'applicazione. USER_IDe USER_KEYsono entrambi accessibili da process.env.USER_IDe process.env.USER_KEYrispettivamente. Non è necessario modificarli, basta accedere ai loro contenuti.

Sembra che ti stiano semplicemente dando la scelta tra caricare il tuo USER_IDe USER_KEYda uno process.envo alcuni file specifici sul disco.

Ora, la magia si verifica quando si esegue l'applicazione.

USER_ID=239482 USER_KEY=foobar node app.js

Questo passerà l'id utente 239482e la chiave utente come foobar. Questo è adatto per i test, tuttavia per la produzione, probabilmente configurerai alcuni script bash per esportare le variabili.


26
Se si utilizza fishinvece bash, è necessario utilizzare: env USER_ID=239482 my_command. Ad esempio, per impostare le variabili di ambiente per node.js' debugbiblioteca: env DEBUG='*' node some_file.js fishshell.com/docs/current/faq.html#faq-single-env
SilentSteel

1
Ho scoperto che dovevo rimuovere le virgolette intorno a "*" perché funzionasse:env DEBUG=* node some_file.js
divillysausages

@SamT come impostare queste variabili in Ubuntu Linux?
Mohammed Zameer,

1
è possibile aggiungere un file anziché aggiungere un gran numero di script env o un utente unix deve creare uno script bash?
mibbit l'

@mibbit sì, questo dotenvè tutto, poiché leggerà il tuo .envfile e lo applicherà.
Balexandre,

201

Consiglio vivamente di esaminare il pacchetto dotenv.

https://github.com/motdotla/dotenv

È un po 'simile alla libreria suggerita nella risposta di @Benxamin, ma è molto più pulita e non richiede script bash. Vale anche la pena notare che la base di codice è popolare e ben mantenuta.

Fondamentalmente hai bisogno di un file .env (che consiglio vivamente di essere ignorato dal tuo git / mercurial / etc):

FOO=bar
BAZ=bob

Quindi nel file di immissione dell'applicazione inserire la seguente riga il prima possibile:

require('dotenv').config();

Boom. Fatto. 'process.env' ora conterrà le variabili sopra:

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

Il file ".env" non è necessario, quindi non devi preoccuparti che l'app cada in sua assenza.


1
Tuttavia, se inserisci dettagli di configurazione pertinenti richiesti dalla tua app (come ad esempio questa domanda si sta informando), probabilmente cadrà in sua assenza ... ma sembra comunque una buona opzione.
John,

6
Se stai cercando una sicurezza in più, allora github.com/rolodato/dotenv-safe e alcuni test dovrebbero farlo.
ctrlplusb,

1
Se stai cercando di non
doverlo

100

Basta fornire i valori env sulla riga di comando

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

2
Aggiungo solo che ha funzionato per me su Windows con bash shell (cygwin; penso sia stato installato con strumenti git).
Markau

@TiborSzasz: Cygwin o Powershell dovrebbero risolverlo. Questo è menzionato due anni dopo, ovviamente.
Orlando Marinella,

9
Per Windows: SET USER_ID = 'abc'
Mike

@ Mike, dovresti dare una risposta adeguata :)
rocketspacer,

6
Possiamo usare il pacchetto cross-env ( npmjs.com/package/cross-env ) per farlo funzionare su unix o windwos
Brij

79

È possibile impostare la variabile di ambiente tramite la variabile globale di processo come segue:

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

Funziona su tutte le piattaforme.


22
... le variabili d'ambiente devono essere impostate dall'esterno del codice, non dall'indside - quindi questo sta vanificando lo scopo e un cattivo esempio
Soren,

44
@Soren il nostro programma nodo che avvia il processo figlio ha beneficiato di questa risposta, quindi ci sono casi d'uso per questo anche se è un po 'poco ortodosso
pspi

2
@pspi - Sono sicuro al 99% che lo stai facendo in modo sbagliato e, a meno che tu non sia l'autore di un pacchetto di configurazione come questo , dovresti invece utilizzare tale pacchetto di configurazione.
Soren,

17
Questo è utile se stai scrivendo script di build in js e li esegui da npm
Stephen Drew,

28
Ciò è utile anche per l'impostazione e la sostituzione dell'ambiente durante l'esecuzione dei test.
mtkopone,

54

Se si desidera un'opzione di gestione, provare il pacchetto envs npm. Restituisce i valori di ambiente se impostati. Altrimenti, è possibile specificare un valore predefinito archiviato in una variabile oggetto predefinita globale se non si trova nel proprio ambiente.

L'uso di .env ("dot ee-en-vee") o dei file di ambiente è buono per molte ragioni. Gli individui possono gestire le proprie configurazioni. È possibile distribuire diversi ambienti (sviluppo, fase, prod) ai servizi cloud con le proprie impostazioni di ambiente. E puoi impostare impostazioni predefinite sensibili.

All'interno del tuo .envfile ogni riga è una voce, come questo esempio:

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

Si dovrebbe non includere il .envnel controllo versione del repository (aggiungerlo al .gitignorefile).

Per ottenere variabili dal .envfile nel proprio ambiente, è possibile utilizzare uno script bash per fare l'equivalente di export NODE_ENV=developmentprima di avviare l'applicazione.

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

Quindi questo va nel tuo javascript dell'applicazione:

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));

1
Hmm, ho provato ad usare questo pacchetto ma sembra tracciare solo l'utilizzo delle variabili d'ambiente. Non legge il file .env ( npmjs.com/package/envs ). È un pacchetto corretto?
wawka,

1
Hai ragione! Non legge il file .env. Questo è imbarazzante. Ho dimenticato che stavo caricando il .env con uno script bash come menzionato da @SamT, quindi ha funzionato comunque.
Benxamin,

1
"require ( 'ENV')"? Che cos'è "envs"?
CodyBugstein,

1
'envs' è il nome di un modulo nodo: npmjs.com/package/envs
Benxamin,

4
Inoltre consiglio di usare il modulo "dotenv", che mette tutte le variabili ENV nell'oggetto proccess, abbastanza pulito tra l'altro.
Bruno de Oliveira,

37

Dipende dal tuo sistema operativo e dalla tua shell

Su Linux con Shell Bash , si creano variabili d'ambiente come questa (nella console):

export FOO=bar

Per ulteriori informazioni sulle variabili di ambiente su Ubuntu (ad esempio):

Variabili d'ambiente su Ubuntu



2
E che dire di Windows? Potresti aggiungere qui?
YakovL,

Ah, non importa, sembra che sia risposto qui: stackoverflow.com/questions/9249830/...
YakovL

in Linux bash questi valori persistono? cosa succede se voglio solo eseguirlo solo quando il terminale è aperto in modo da non causare problemi con altre applicazioni in un secondo momento?
JesseBoyd,

13

Come ha detto ctrlplusb, ti consiglio di usare il pacchetto dotenv, ma un altro modo per farlo è creare un file js e richiederlo sulla prima riga del tuo server di app.

env.js:

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

app.js:

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

9

Utenti Windows: attenzione! Questi comandi sono consigliati per Unix ma su Windows sono solo temporanei. Impostano una variabile solo per la shell corrente, non appena si riavvia il computer o si avvia una nuova shell di terminali, spariranno.

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

Per impostare una variabile d'ambiente persistente su Windows devi invece utilizzare uno dei seguenti approcci:

A) File .env nel tuo progetto - questo è il metodo migliore perché significherà che puoi spostare il tuo progetto su altri sistemi senza dover impostare il tuo ambiente su quel sistema prima di poter eseguire il tuo codice.

  1. Crea un .envfile nella cartella principale del tuo progetto con il contenuto:TEST="hello world"

  2. Scrivi del codice nodo che leggerà quel file. Suggerisco di installare dotenv ( npm install dotenv --save) e quindi aggiungerlo require('dotenv').config();durante il codice di configurazione del nodo.

  3. Ora il tuo codice nodo sarà in grado di accedereprocess.env.TEST

I file ENV sono utili per mantenere le chiavi API e altri segreti che non si desidera avere nella propria base di codice. Assicurati di aggiungerlo al tuo .gitignore.

B) Usa Powershell : questo creerà una variabile che sarà accessibile in altri terminali. Ma attenzione, la variabile andrà persa dopo aver riavviato il computer.

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

Questo metodo è ampiamente raccomandato nei forum di Windows, ma non credo che le persone siano consapevoli che la variabile non persiste dopo il riavvio del sistema ....

C) Utilizzare la GUI di Windows

  1. Cerca "Variabili d'ambiente" nel menu di ricerca o nel pannello di controllo
  2. Seleziona "Modifica le variabili di ambiente di sistema"
  3. Si aprirà un dialogo. Fai clic sul pulsante "Variabili d'ambiente" nella parte inferiore della finestra di dialogo.
  4. Ora hai una piccola finestra per la modifica delle variabili. Basta fare clic sul pulsante "Nuovo" per aggiungere una nuova variabile d'ambiente. Facile.

8

Passaggio 1: aggiungere le variabili di ambiente al file appropriato. Ad esempio, è possibile chiamare .env.stagingl'ambiente di gestione temporanea, che contiene le variabili di ambiente USER_IDe USER_KEY, specifico per l'ambiente di gestione temporanea.

Passaggio 2: nel package.jsonfile, aggiungere quanto segue:

"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",
  ...
}

quindi chiamalo nel tuo script deploy in questo modo:

npm run build:staging

Installazione super semplice e funziona come un fascino!

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


2
@JohnXiao come va?
Blairg23,


4

Mi sono imbattuto in un simpatico strumento per farlo.

node-ENV-lima

Analizza e carica i file di ambiente (contenenti esportazioni di variabili ENV) nell'ambiente Node.js, ovvero process.env: utilizza questo stile:

.env

# some env variables

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

2

Come espansione della risposta di @ctrlplusb,
ti suggerirei di dare un'occhiata anche al env-dot-proppacchetto.

Ti permette di impostare / ottenere proprietà process.envdall'uso di a dot-path.

Supponiamo che il tuo process.envcontenga quanto segue:

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

Quindi è possibile manipolare le variabili di ambiente in questo modo:

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'}

Questo ti aiuta ad analizzare le variabili di ambiente e ad usarle come oggetto di configurazione nella tua app.
Ti aiuta anche a implementare una configurazione a 12 fattori .


2

Di seguito è riportato un ottimo modo per fare variabili d'ambiente che ho usato con successo:

A. Avere diversi file di configurazione :

  1. dev.js // contiene tutte le variabili di ambiente solo per lo sviluppo
    Il file contiene:

    module.exports = {
     ENV: 'dev',
     someEnvKey1 : 'some DEV Value1',
     someEnvKey2 : 'some DEV Value2'
    };
  2. stage.js // questo ha tutte le variabili d'ambiente solo per lo sviluppo

    ..
  3. qa.js // contiene tutte le variabili di ambiente solo per i test di qa
    Il file contiene:

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

NOTA : i valori stanno cambiando con l'ambiente, principalmente, ma le chiavi rimangono uguali.

  1. puoi averne di più

  2. z__prod.js // contiene tutte le variabili di ambiente solo per produzione / live
    NOTA: questo file non viene mai raggruppato per la distribuzione

  3. Metti tutti questi file di configurazione nella cartella / config /

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

NOTA : il nome di prod è diverso da altri, in quanto non sarebbe usato da tutti.

B. Impostare le variabili di ambiente OS / Lambda / AzureFunction / GoogleCloudFunction dal file di configurazione

Ora idealmente, queste variabili di configurazione nel file, dovrebbero andare come variabili di ambiente del sistema operativo (o, variabili di funzione LAMBDA o variabili di funzione di Azure, Google Cloud Functions, ecc.)

quindi, scriviamo automazione nel sistema operativo Windows (o altro)

  1. Supponiamo di scrivere il file bat ' setenv ', che accetta un argomento che è l'ambiente che vogliamo impostare

  2. Ora esegui " setenv dev "

a) Questo prende l'input dalla variabile dell'argomento passato ('dev' per ora)
b) leggi il file corrispondente ('config \ dev.js')
c) imposta le variabili d'ambiente nel sistema operativo Windows (o altro)

Per esempio,

I contenuti di setenv.bat potrebbero essere:

    node setenv.js

I contenuti di setenv.js potrebbero essere:

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

Questo è tutto , il tuo ambiente è pronto per l'uso.

Quando fai ' setenv qa ', tutte le variabili d'ambiente qa saranno pronte per l'uso da qa.js e pronte per l'uso dallo stesso programma (che richiede sempre process.env.someEnvKey1, ma il valore che ottiene è qa uno).

Spero che aiuti.


1

Semplifica la vita con dotenv-webpack . Basta installarlo npm install dotenv-webpack --save-dev, quindi creare un .envfile nella radice dell'applicazione (ricordarsi di aggiungerlo .gitignoreprima di te git push). Apri questo file e imposta lì alcune variabili ambientali, come ad esempio:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Ora, nella configurazione del tuo webpack aggiungi:

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.

Solo const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()]e ovviamente module.exports = webpackConfig; // Export all custom Webpack configs.sono richiesti. Tuttavia, in alcuni scenari potresti ricevere degli errori. Per questi hai anche la soluzione che implica come puoi correggere alcuni errori.

Ora, dove si vuole si può semplicemente utilizzare process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3nell'applicazione.


0

Stavo diventando indefinito dopo aver impostato un sistema env var. Quando inserisco APP_VERSION in User var var, quindi posso visualizzare il valore dal nodo tramite process.env.APP_VERSION


-1

Se stai usando un mac / linux e vuoi recuperare i parametri locali sulla macchina che stai usando, ecco cosa farai:

  1. Nel terminale eseguire nano ~ / .bash_profile
  2. aggiungi una riga come: export MY_VAR = var
  3. salva ed esegui source ~ / .bash_profile
  4. nel nodo usare come: console.log ( process.env.MY_VAR );
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.