Ustawianie zmiennych środowiskowych dla węzła do pobrania

Próbuję wykonać samouczek, który mówi:

Istnieje kilka sposobów ładowania poświadczeń.

1. Załadowany ze zmiennych środowiskowych,
2. Załadowany z pliku JSON na dysku,

Klucze muszą być następujące:

USER_ID, USER_KEY

... Oznacza to, że jeśli właściwie ustawisz zmienne środowiskowe, nie musisz wcale zarządzać poświadczeniami w swojej aplikacji.

Na podstawie niektórych Google, wydaje się, że muszę ustawić zmienne process.env? Jak i gdzie ustawić te dane uwierzytelniające? Przykład Proszę.

Zmienne środowiskowe (w tym przypadku) są używane do przekazywania poświadczeń do aplikacji. USER_IDi USER_KEYmogą być dostępne zarówno z, jak process.env.USER_IDi process.env.USER_KEYodpowiednio. Nie musisz ich edytować, po prostu uzyskaj dostęp do ich zawartości.

Wygląda na to, że po prostu dają ci wybór pomiędzy załadowaniem twojego USER_IDa USER_KEYjednego process.envlub jednego określonego pliku na dysku.

Teraz magia dzieje się po uruchomieniu aplikacji.

USER_ID=239482 USER_KEY=foobar node app.js

To przekaże identyfikator użytkownika 239482i klucz użytkownika jako foobar. Jest to odpowiednie do testowania, jednak w przypadku produkcji prawdopodobnie będziesz konfigurował niektóre skrypty bash do eksportowania zmiennych.

Bardzo polecam zajrzeć do pakietu dotenv.

https://github.com/motdotla/dotenv

Jest trochę podobny do biblioteki sugerowanej w odpowiedzi z @Benxamin, ale jest o wiele czystszy i nie wymaga żadnych skryptów bash. Warto również zauważyć, że baza kodu jest popularna i dobrze utrzymana.

Zasadniczo potrzebujesz pliku .env (który zdecydowanie polecam zignorować z git / mercurial / etc):

FOO=bar
BAZ=bob

Następnie w pliku wejściowym aplikacji umieść następujący wiersz jak najwcześniej:

require('dotenv').config();

Bum. Gotowy. „process.env” będzie teraz zawierał powyższe zmienne:

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

Plik „.env” nie jest wymagany, więc nie musisz się martwić, że Twoja aplikacja przewróci się pod nieobecność.

Wystarczy podać wartości env w wierszu polecenia

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

Możesz ustawić zmienną środowiskową za pomocą globalnej zmiennej procesowej w następujący sposób:

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

Działa na wszystkich platformach.

Jeśli chcesz mieć opcję zarządzania, wypróbuj pakiet envs npm. Zwraca wartości środowiska, jeśli są ustawione. W przeciwnym razie możesz określić wartość domyślną przechowywaną w globalnej zmiennej obiektu domyślnego, jeśli nie znajduje się ona w twoim środowisku.

Korzystanie z plików .env („dot ee-en-vee”) lub plików środowiska jest dobre z wielu powodów. Osoby fizyczne mogą zarządzać własnymi konfiguracjami. Możesz wdrożyć różne środowiska (deweloper, scena, prod) w usługach chmurowych z własnymi ustawieniami środowiska. I możesz ustawić rozsądne wartości domyślne.

Wewnątrz .envpliku każda linia jest wpisem, podobnie jak w tym przykładzie:

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

Należy nie zawierają .envw swoim repozytorium kontroli wersji (dodać go do .gitignorepliku).

Aby pobrać zmienne z .envpliku do swojego środowiska, możesz użyć skryptu bash, aby zrobić odpowiednik export NODE_ENV=developmenttuż przed uruchomieniem aplikacji.

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

To idzie w javascript aplikacji:

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

To zależy od systemu operacyjnego i powłoki

W systemie Linux z powłoką bashową tworzysz zmienne środowiskowe takie jak to (w konsoli):

export FOO=bar

Aby uzyskać więcej informacji na temat zmiennych środowiskowych w Ubuntu (na przykład):

Zmienne środowiskowe na Ubuntu

Jak powiedział ctrlplusb, polecam użyć pakietu dotenv , ale innym sposobem jest utworzenie pliku js i wymaganie go w pierwszym wierszu serwera aplikacji.

env.js:

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

app.js:

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

Użytkownicy systemu Windows: uważaj! Te polecenia są zalecane w systemie Unix, ale w systemie Windows są one tylko tymczasowe. Ustawiają zmienną tylko dla bieżącej powłoki, gdy tylko zrestartujesz maszynę lub uruchomisz nową powłokę terminala, znikną.

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

Aby ustawić trwałą zmienną środowiskową w systemie Windows, należy zamiast tego zastosować jedną z następujących metod:

A) Plik .env w projekcie - jest to najlepsza metoda, ponieważ będzie oznaczać, że możesz przenieść projekt do innych systemów bez konieczności konfigurowania zmiennych środowiska na tym systemie, na którym możesz uruchomić swój kod.

1. Utwórz .envplik w katalogu głównym folderu projektu z zawartością:TEST="hello world"

2. Napisz kod węzła, który odczyta ten plik. Sugeruję zainstalowanie dotenv ( npm install dotenv --save), a następnie dodanierequire('dotenv').config(); podczas instalacji kodu węzła.

3. Teraz twój kod węzła będzie mógł uzyskać dostępprocess.env.TEST

Pliki env dobrze zachowują klucze API i inne sekrety, których nie chcesz mieć w swojej bazie kodu. Po prostu dodaj go do swojego .gitignore.

B) Użyj PowerShell - utworzy zmienną, która będzie dostępna w innych terminalach. Ale uwaga, zmienna zostanie utracona po ponownym uruchomieniu komputera.

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

Ta metoda jest powszechnie zalecana na forach Windows, ale nie sądzę, aby ludzie wiedzieli, że zmienna nie utrzymuje się po ponownym uruchomieniu systemu ....

C) Użyj interfejsu GUI systemu Windows

1. Wyszukaj „Zmienne środowiskowe” w menu wyszukiwania Start lub w Panelu sterowania
2. Wybierz „Edytuj systemowe zmienne środowiskowe”
3. Dialog się otworzy. Kliknij przycisk „Zmienne środowiskowe” u dołu okna dialogowego.
4. Teraz masz małe okno do edycji zmiennych. Wystarczy kliknąć przycisk „Nowy”, aby dodać nową zmienną środowiskową. Łatwy.

Krok 1: Dodaj zmienne środowiskowe do odpowiedniego pliku. Na przykład można wywołać środowisko pomostowe .env.staging, które zawiera zmienne środowiskowe USER_IDi USER_KEYspecyficzne dla środowiska pomostowego.

Krok 2: W swoim package.jsonpliku dodaj:

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

następnie wywołaj go w skrypcie wdrażania w następujący sposób:

npm run build:staging

Super prosta konfiguracja i działa jak urok!

Źródło: https://medium.com/@tacomanator/environments-with-create-react-app-7b645312c09d

Dla użytkowników systemu Windows to pytanie o przepełnienie stosu i najwyższa odpowiedź są dość przydatne w zakresie ustawiania zmiennych środowiskowych za pomocą wiersza polecenia

Jak ustawić NODE_ENV = produkcja w systemie Windows?

Znalazłem fajne narzędzie do tego.

plik-env węzła

Analizuje i ładuje pliki środowiskowe (zawierające eksport zmiennych ENV) do środowiska Node.js, tj. process.env- Używa tego stylu:

.env

# some env variables

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

W ramach rozszerzenia odpowiedzi @ctrlplusb
sugeruję, abyś również spojrzał na env-dot-proppakiet.

Pozwala ustawić / uzyskać właściwości process.envprzy użyciu dot-path.

Załóżmy, że process.envzawiera następujące elementy:

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

Następnie możesz manipulować zmiennymi środowiskowymi w następujący sposób:

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

Pomaga to analizować zmienne środowiskowe i wykorzystywać je jako obiekt konfiguracji w aplikacji.
Pomaga także wdrożyć konfigurację 12-czynnikową .

Bardzo dobry sposób wykonywania zmiennych środowiskowych, których z powodzeniem używałem, jest poniżej:

A. Mają różne pliki konfiguracyjne :

1. dev.js // to ma wszystkie zmienne środowiskowe tylko do programowania
   Plik zawiera:

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

2. stage.js // ma to wszystkie zmienne środowiskowe tylko do programowania

   ..

3. qa.js // zawiera wszystkie zmienne środowiskowe przeznaczone wyłącznie do testowania qa
   Plik zawiera:

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

UWAGA : wartości zmieniają się głównie w środowisku, ale klucze pozostają takie same.

4. możesz mieć więcej

5. z__prod.js // ma to wszystkie zmienne środowiskowe tylko do produkcji / na żywo
   UWAGA: Ten plik nigdy nie jest dołączany do wdrożenia

6. Umieść wszystkie te pliki konfiguracyjne w folderze / config /

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

UWAGA : Nazwa prod jest inna niż inne, ponieważ nie byłaby używana przez wszystkich.

B. Ustaw zmienne środowiskowe OS / Lambda / AzureFunction / GoogleCloudFunction z pliku konfiguracyjnego

Teraz idealnie te zmienne konfiguracyjne w pliku powinny być zmienne środowiskowe systemu operacyjnego (lub zmienne funkcyjne LAMBDA lub zmienne funkcyjne platformy Azure, funkcje Google Cloud itp.)

więc piszemy automatyzację w systemie operacyjnym Windows (lub innym)

1. Załóżmy, że piszemy plik nietoperza „ setenv ”, który przyjmuje jeden argument, którym jest środowisko, które chcemy ustawić

2. Teraz uruchom „ setenv dev ”

a) Pobiera dane wejściowe z przekazanej zmiennej argumentu (na razie „dev”)
b) odczytuje odpowiedni plik („config \ dev.js”)
c) ustawia zmienne środowiskowe w systemie operacyjnym Windows (lub innym)

Na przykład,

Zawartość setenv.bat może być:

    node setenv.js

Zawartość pliku setenv.js może być:

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

To wszystko , twoje środowisko jest gotowe do użycia.

Kiedy wykonasz ' setenv qa ', wszystkie zmienne środowiskowe qa będą gotowe do użycia z qa.js i gotowe do użycia przez ten sam program (który zawsze prosi o process.env.someEnvKey1, ale otrzymywana wartość to qa one).

Mam nadzieję, że to pomaga.

Ułatw sobie życie z dotenv-webpack . Po prostu zainstaluj go npm install dotenv-webpack --save-dev, a następnie utwórz .envplik w katalogu głównym aplikacji (pamiętaj, aby dodać go .gitignoreprzed sobą git push). Otwórz ten plik i ustaw tam niektóre zmienne środowiskowe, na przykład:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Teraz w konfiguracji pakietu internetowego dodaj:

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.

Tylko const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()]i oczywiście module.exports = webpackConfig; // Export all custom Webpack configs.są wymagane. Jednak w niektórych scenariuszach mogą pojawić się błędy. W przypadku tych masz również rozwiązanie sugerujące, w jaki sposób możesz naprawić określony błąd.

Teraz, gdziekolwiek chcesz, możesz po prostu użyć process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3w aplikacji.

Po ustawieniu env var systemu stałem się niezdefiniowany. Kiedy wstawię APP_VERSION w zmiennej env użytkownika, wtedy mogę wyświetlić wartość z węzła poprzez proces.env.APP_VERSION

Jeśli używasz systemu Mac / Linux i chcesz odzyskać parametry lokalne na używanym komputerze, wykonaj następujące czynności:

1. W terminalu uruchom profil nano ~ / .bash_profile
2. dodaj linię taką jak: eksport MY_VAR = var
3. zapisz i uruchom plik źródłowy ~ / .bash_profile
4. w węźle użyj takich jak: console.log ( process.env.MY_VAR );