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


414

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

Odpowiedzi:


397

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.


26
Jeśli używasz fishzamiast bash, trzeba użyć: env USER_ID=239482 my_command. Na przykład, do ustawiania zmiennych środowiskowych dla node.js' debugbiblioteki: env DEBUG='*' node some_file.js fishshell.com/docs/current/faq.html#faq-single-env
SilentSteel

1
Stwierdziłem, że muszę usunąć cudzysłowy wokół „*”, aby zadziałało:env DEBUG=* node some_file.js
divillysausages

@SamT jak ustawić te zmienne w systemie Ubuntu Linux?
Mohammed Zameer,

1
czy możliwe jest dodanie pliku zamiast dodawania dużej liczby skryptów env, czy też użytkownik unix musi utworzyć skrypt bash?
mibbit

@mibbit tak, właśnie o to dotenvchodzi, ponieważ przeczyta .envplik i zastosuje go.
balexandre

200

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ść.


1
Chociaż jeśli podasz odpowiednie szczegóły konfiguracji wymagane przez twoją aplikację (takie jak pytanie, o które pytasz), prawdopodobnie przewróci się pod nieobecność ... ale nadal wydaje się dobrą opcją.
John

6
Jeśli szukasz dodatkowego bezpieczeństwa, github.com/rolodato/dotenv-safe i kilka testów powinno to zrobić.
ctrlplusb

1
Jeśli nie chcesz tego wymagać w swojej aplikacji: github.com/direnv/direnv
AlecRust

100

Wystarczy podać wartości env w wierszu polecenia

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

2
Dodam tylko, że działało dla mnie w systemie Windows z powłoką bash (cygwin; myślę, że zainstalowałem z narzędziami git).
markau 17.03.16

@TiborSzasz: Cygwin lub Powershell powinny to naprawić. Jest to oczywiście wspomniane dwa lata później.
Orlando Marinella

9
W systemie Windows: SET USER_ID = 'abc'
Mike

@Mike, powinieneś zrobić właściwą odpowiedź :)
rocketspacer

6
Możemy użyć pakietu cross-env ( npmjs.com/package/cross-env ), aby działał na systemach uniksowych lub windwos
Brij

78

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.


22
... zmienne środowiskowe mają być ustawiane z zewnątrz kodu, a nie od strony wewnętrznej - więc to pokonuje cel i zły przykład
Soren

44
@ Soren, nasz program węzłowy, który uruchamia proces potomny, skorzystał z tej odpowiedzi, więc istnieją przypadki użycia tego, mimo że jest to trochę niekonwencjonalne
pspi

2
@pspi - Jestem 99% pewien, że robisz to źle , a jeśli nie jesteś autorem pakietu config jak to należy używać takiego pakietu konfiguracyjnego zamiast.
Soren

17
Jest to przydatne, jeśli piszesz skrypty budowania w js i uruchamiasz je z npm
Stephen Drew,

28
Jest to również przydatne np. Do ustawiania i zastępowania środowiska podczas uruchamiania testów.
mtkopone

54

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

1
Hmm, próbowałem użyć tego pakietu, ale wydaje się, że śledzi tylko użycie zmiennych środowiskowych. Nie odczytuje pliku .env ( npmjs.com/package/envs ). Czy to jest poprawny pakiet?
wawka

1
Masz rację! Nie odczytuje pliku .env. To jest żenujące. Zapomniałem, że ładowałem .env za pomocą skryptu bash, jak wspomniałem @SamT, więc i tak działało.
Benxamin

1
„wymagają („ środowiska ”)? Co to są „envs”?
CodyBugstein,

1
„envs” to nazwa modułu węzła: npmjs.com/package/envs
Benxamin

4
Polecam również użycie modułu „dotenv”, który umieścił wszystkie zmienne ENV w obiekcie proccess, przy okazji całkiem fajnie.
Bruno de Oliveira,

37

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



2
A co z Windows? Czy mógłbyś dodać tutaj?
JakowL,

Ach, nieważne, wygląda na to, że odpowiedź tutaj: stackoverflow.com/questions/9249830/...
YakovL

czy w Linux Bash te wartości są utrwalane? co jeśli chcę go uruchomić tylko wtedy, gdy terminal jest otwarty, aby później nie powodować problemów z innymi aplikacjami?
JesseBoyd,

13

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

9

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.

8

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


2
@JohnXiao jak to jest?
Blairg23


4

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=

2

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


2

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.

  1. możesz mieć więcej

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

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


1

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.


0

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


-1

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 );
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.