Impostazione delle variabili d'ambiente per il nodo da recuperare

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.

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.

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.

Basta fornire i valori env sulla riga di comando

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

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

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

Funziona su tutte le piattaforme.

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

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

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

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.

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

Per gli utenti di Windows questa domanda Stack Overflow e la risposta migliore sono molto utili su come impostare le variabili di ambiente tramite la riga di comando

Come posso impostare NODE_ENV = produzione in Windows?

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=

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 .

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.

4. puoi averne di più

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

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

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.

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

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