Festlegen von Umgebungsvariablen für den abzurufenden Knoten

Ich versuche einem Tutorial zu folgen und es heißt:

Es gibt verschiedene Möglichkeiten, Anmeldeinformationen zu laden.

1. Aus Umgebungsvariablen geladen,
2. Aus einer JSON-Datei auf der Festplatte geladen,

Die Schlüssel müssen wie folgt sein:

USER_ID, USER_KEY

... Dies bedeutet, dass Sie, wenn Sie Ihre Umgebungsvariablen richtig festlegen, die Anmeldeinformationen in Ihrer Anwendung überhaupt nicht verwalten müssen.

Basierend auf etwas Googeln scheint es, dass ich die Variablen in setzen muss process.env? Wie und wo setze ich diese Anmeldeinformationen? Beispiel Bitte.

Umgebungsvariablen (in diesem Fall) werden verwendet, um Anmeldeinformationen an Ihre Anwendung zu übergeben. USER_IDund USER_KEYkann sowohl aus zugegriffen werden process.env.USER_IDund process.env.USER_KEYjeweils. Sie müssen sie nicht bearbeiten, sondern müssen nur auf ihre Inhalte zugreifen.

Es sieht so aus, als ob sie Ihnen einfach die Wahl zwischen dem Laden Ihrer USER_IDund USER_KEYeiner process.envoder einer bestimmten Datei auf der Festplatte geben.

Jetzt passiert die Magie, wenn Sie die Anwendung ausführen.

USER_ID=239482 USER_KEY=foobar node app.js

Dadurch werden die Benutzer-ID 239482und der Benutzerschlüssel als übergeben foobar. Dies ist zum Testen geeignet. Für die Produktion konfigurieren Sie jedoch wahrscheinlich einige Bash-Skripte zum Exportieren von Variablen.

Ich empfehle dringend, in das dotenv-Paket zu schauen.

https://github.com/motdotla/dotenv

Es ähnelt der Bibliothek, die in der Antwort von @Benxamin vorgeschlagen wurde, ist jedoch viel sauberer und erfordert keine Bash-Skripte. Erwähnenswert ist auch, dass die Codebasis beliebt und gut gepflegt ist.

Grundsätzlich benötigen Sie eine .env-Datei (die ich dringend empfehlen kann, von Ihrem Git / Mercurial / etc ignoriert zu werden):

FOO=bar
BAZ=bob

Fügen Sie dann in Ihrer Bewerbungsdatei so früh wie möglich die folgende Zeile ein:

require('dotenv').config();

Boom. Erledigt. 'process.env' enthält jetzt die obigen Variablen:

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

Die '.env'-Datei ist nicht erforderlich, sodass Sie sich keine Sorgen machen müssen, dass Ihre App in Abwesenheit umkippt.

Geben Sie einfach die env-Werte in der Befehlszeile ein

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

Sie können die Umgebungsvariable über die globale Prozessvariable wie folgt festlegen:

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

Funktioniert auf allen Plattformen.

Wenn Sie eine Verwaltungsoption wünschen, probieren Sie das Paket envs npm aus. Es gibt Umgebungswerte zurück, wenn sie festgelegt sind. Andernfalls können Sie einen Standardwert angeben , die in einer globalen gespeichert defaults Objektvariable , wenn es nicht in Ihrer Umgebung ist.

Die Verwendung von .env- ("dot ee-en-vee") oder Umgebungsdateien ist aus vielen Gründen sinnvoll . Einzelpersonen können ihre eigenen Konfigurationen verwalten. Sie können verschiedene Umgebungen (Entwickler, Bühne, Produkt) für Cloud-Dienste mit eigenen Umgebungseinstellungen bereitstellen. Und Sie können sinnvolle Standardeinstellungen festlegen.

In Ihrer .envDatei ist jede Zeile ein Eintrag, wie in diesem Beispiel:

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

Sie sollten nicht enthalten die .envin Ihrer Version Control Repository (fügen Sie Ihre .gitignoreDatei).

Um Variablen aus der .envDatei in Ihre Umgebung zu übertragen, können Sie ein Bash-Skript verwenden, um das Äquivalent von export NODE_ENV=developmentdirekt vor dem Start Ihrer Anwendung auszuführen.

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

Dann geht das in Ihrer Anwendung 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));

Dies hängt von Ihrem Betriebssystem und Ihrer Shell ab

Unter Linux mit der Shell-Bash erstellen Sie Umgebungsvariablen wie diese (in der Konsole):

export FOO=bar

Weitere Informationen zu Umgebungsvariablen in Ubuntu (zum Beispiel):

Umgebungsvariablen auf Ubuntu

Wie ctrlplusb sagte, empfehle ich Ihnen, das Paket zu verwenden. Eine dotenvandere Möglichkeit, dies zu tun, besteht darin, eine js-Datei zu erstellen und diese in der ersten Zeile Ihres App-Servers zu benötigen.

env.js:

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

app.js:

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

Windows-Benutzer: Achtung! Diese Befehle werden für Unix empfohlen, sind jedoch unter Windows nur vorübergehend. Sie legen eine Variable nur für die aktuelle Shell fest. Sobald Sie Ihren Computer neu starten oder eine neue Terminal-Shell starten, sind sie verschwunden.

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

Um unter Windows eine persistente Umgebungsvariable festzulegen, müssen Sie stattdessen einen der folgenden Ansätze verwenden:

A) .env-Datei in Ihrem Projekt - Dies ist die beste Methode, da Sie Ihr Projekt auf andere Systeme verschieben können, ohne Ihre Umgebungsvariablen auf diesem System einrichten zu müssen, bevor Sie Ihren Code ausführen können.

1. Erstellen Sie eine .envDatei in Ihrem Projektordner root mit dem Inhalt:TEST="hello world"

2. Schreiben Sie einen Knotencode, der diese Datei liest. Ich schlage vor, dotenv zu installieren (npm install dotenv --save ) zu und dann require('dotenv').config();während des Knoten-Setup-Codes hinzuzufügen .

3. Jetzt kann Ihr Knotencode darauf zugreifenprocess.env.TEST

Env-Dateien sind eine gute Möglichkeit, API-Schlüssel und andere Geheimnisse zu bewahren, die Sie nicht in Ihrer Codebasis haben möchten. Stellen Sie einfach sicher, dass Sie es zu Ihrem hinzufügen.gitignore .

B) Powershell verwenden - Dadurch wird eine Variable erstellt, auf die in anderen Terminals zugegriffen werden kann. Beachten Sie jedoch, dass die Variable nach dem Neustart des Computers verloren geht.

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

Diese Methode wird in Windows-Foren allgemein empfohlen, aber ich glaube nicht, dass die Leute wissen, dass die Variable nach einem Systemneustart nicht bestehen bleibt.

C) Verwenden Sie die Windows-GUI

1. Suchen Sie in der Startmenüsuche oder in der Systemsteuerung nach "Umgebungsvariablen"
2. Wählen Sie "Systemumgebungsvariablen bearbeiten".
3. Ein Dialog wird eröffnet. Klicken Sie unten im Dialogfeld auf die Schaltfläche "Umgebungsvariablen".
4. Jetzt haben Sie ein kleines Fenster zum Bearbeiten von Variablen. Klicken Sie einfach auf die Schaltfläche "Neu", um eine neue Umgebungsvariable hinzuzufügen. Einfach.

Schritt 1: Fügen Sie Ihre Umgebungsvariablen zu der entsprechenden Datei hinzu. Beispielsweise könnte Ihre Staging-Umgebung aufgerufen werden .env.staging, die die Umgebungsvariablen USER_IDund enthältUSER_KEY spezifisch für Ihre Staging-Umgebung ist.

Schritt 2: Fügen Sie in Ihrer package.jsonDatei Folgendes hinzu:

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

Rufen Sie es dann in Ihrem Bereitstellungsskript folgendermaßen auf:

npm run build:staging

Super einfach einzurichten und funktioniert wie ein Zauber!

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

Für Windows-Benutzer ist diese Frage zum Stapelüberlauf und die beste Antwort sehr nützlich, um Umgebungsvariablen über die Befehlszeile festzulegen

Wie kann ich NODE_ENV = Produktion in Windows setzen?

Kam auf ein nettes Werkzeug dafür.

Node-Env-Datei

Analysiert und lädt Umgebungsdateien (die ENV-Variablenexporte enthalten) in die Node.js-Umgebung, dh process.env- Verwendet diesen Stil:

.env

# some env variables

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

Als Erweiterung der Antwort von @ctrlplusb
würde ich Ihnen empfehlen, sich auch das env-dot-propPaket anzusehen .

Sie können Eigenschaften festlegen / abrufen, process.envindem Sie a verwenden dot-path.

Nehmen wir an, dass Ihr process.envFolgendes enthält:

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

Dann können Sie die Umgebungsvariablen folgendermaßen bearbeiten:

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

Auf diese Weise können Sie die Umgebungsvariablen analysieren und als Konfigurationsobjekt in Ihrer App verwenden.
Es hilft Ihnen auch bei der Implementierung einer 12-Faktor-Konfiguration .

Eine sehr gute Möglichkeit, Umgebungsvariablen zu verwenden, die ich erfolgreich verwendet habe, ist unten aufgeführt:

A. Haben Sie verschiedene Konfigurationsdateien :

1. dev.js // dies enthält alle Umgebungsvariablen nur für die Entwicklung.
   Die Datei enthält:

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

2. stage.js // Dies enthält alle Umgebungsvariablen nur für die Entwicklung

   ..

3. qa.js // dies enthält alle Umgebungsvariablen nur zum Testen von qa
   Die Datei enthält:

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

HINWEIS : Die Werte ändern sich meistens mit der Umgebung, aber die Schlüssel bleiben gleich.

4. du kannst mehr haben

5. z__prod.js // Dies enthält alle Umgebungsvariablen nur für die Produktion / Live.
   HINWEIS: Diese Datei wird niemals für die Bereitstellung gebündelt

6. Legen Sie alle diese Konfigurationsdateien im Ordner / config / ab

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

HINWEIS : Der Name von prod unterscheidet sich von anderen, da er nicht von allen verwendet wird.

B. Legen Sie die Umgebungsvariablen OS / Lambda / AzureFunction / GoogleCloudFunction aus der Konfigurationsdatei fest

Im Idealfall sollten diese Konfigurationsvariablen in der Datei als Umgebungsvariablen des Betriebssystems (oder als LAMBDA-Funktionsvariablen oder Azure-Funktionsvariablen, Google Cloud-Funktionen usw.) verwendet werden.

Also schreiben wir Automatisierung in Windows OS (oder einem anderen)

1. Angenommen, wir schreiben eine ' setenv' -Fledermausdatei, die ein Argument verwendet, nämlich die Umgebung, die wir festlegen möchten

2. Führen Sie nun " setenv dev " aus

a) Dies übernimmt die Eingabe von der übergebenen Argumentvariablen ('dev' für jetzt).
b) Lesen Sie die entsprechende Datei ('config \ dev.js').
c) die Umgebungsvariablen unter Windows (oder einem anderen).

Zum Beispiel,

Der Inhalt von setenv.bat könnte sein:

    node setenv.js

Der Inhalt von setenv.js könnte sein:

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

Das ist alles , Ihre Umgebung ist einsatzbereit.

Wenn Sie ' setenv qa ' ausführen , sind alle qa-Umgebungsvariablen für die Verwendung in qa.js bereit und können von demselben Programm verwendet werden (das immer nach process.env.someEnvKey1 fragt, aber der Wert, den es erhält, ist qa eins).

Ich hoffe, das hilft.

Erleichtern Sie sich das Leben mit dotenv-webpack . Installieren Sie es einfach npm install dotenv-webpack --save-devund erstellen Sie eine .envDatei im Stammverzeichnis Ihrer Anwendung (denken Sie daran, diese .gitignorevor Ihnen hinzuzufügen git push). Öffnen Sie diese Datei und legen Sie dort einige Umgebungsvariablen fest, z. B.:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Fügen Sie nun in Ihrer Webpack-Konfiguration Folgendes hinzu:

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.

Nur const Dotenv = require('dotenv-webpack');,, plugins: [new Dotenv()]und natürlich module.exports = webpackConfig; // Export all custom Webpack configs.erforderlich. In einigen Szenarien können jedoch Fehler auftreten. Für diese haben Sie auch die Lösung, die impliziert, wie Sie bestimmte Fehler beheben können.

Jetzt, wo immer Sie möchten , können Sie einfach verwenden process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3in Ihrer Anwendung.

Ich wurde undefiniert, nachdem ich eine Systemumgebung festgelegt hatte. Wenn ich APP_VERSION in die Benutzerumgebung einfüge, kann ich den Wert vom Knoten über process.env.APP_VERSION anzeigen

Wenn Sie einen Mac / Linux verwenden und lokale Parameter auf dem von Ihnen verwendeten Computer abrufen möchten, gehen Sie wie folgt vor:

1. Im Terminallauf nano ~ / .bash_profile aus
2. Fügen Sie eine Zeile hinzu wie: Fügen folgt export MY_VAR = var
3. speichern & ausführen Quelle ~ / .bash_profile
4. im Knoten verwenden Sie wie: console.log ( process.env.MY_VAR );