Jak ustawić zmienne środowiskowe z pakietu package.json

Jak ustawić niektóre zmienne środowiskowe od wewnątrz package.json aby były używane z npm startpodobnymi poleceniami?

Oto, co obecnie mam w moim package.json:

{
  ...
  "scripts": {
    "help": "tagove help",
    "start": "tagove start"
  }
  ...
}

Chcę ustawić zmienne środowiskowe (np NODE_ENV) w skrypcie startowym, a jednocześnie jest w stanie uruchomić aplikację z jednym poleceniu npm start.

Ustaw zmienną środowiskową w poleceniu skryptowym:

...
"scripts": {
  "start": "node app.js",
  "test": "env NODE_ENV=test mocha --reporter spec"
},
...

Następnie użyj process.env.NODE_ENVw swojej aplikacji.

Uwaga: envzapewnia, że ​​działa na różnych platformach. Możesz go pominąć, jeśli dbasz tylko o Mac / Linux.

Wystarczy użyć pakietu NPM cross-env . Super łatwe. Działa w systemach Windows, Linux i wszystkich środowiskach. Zauważ, że nie używasz && do przejścia do następnego zadania. Po prostu ustaw env, a następnie rozpocznij następne zadanie. Kredyt dla @mikekidder za sugestię w jednym z komentarzy tutaj.

Z dokumentacji:

{
  "scripts": {
    "build": "cross-env NODE_ENV=production OTHERFLAG=myValue webpack --config build/webpack.config.js"
  }
}

Zauważ, że jeśli chcesz ustawić wiele globalnych zmiennych, wystarczy podać je kolejno, a następnie polecenie, które ma zostać wykonane.

Ostatecznie polecenie, które jest wykonywane (za pomocą spawn) to:

webpack --config build/webpack.config.js

NODE_ENVZmienna zostanie ustalona przez cross-ENV

Chciałem tylko dodać tutaj dwa centy dla przyszłych eksploratorów węzłów. Na moim Ubuntu 14.04 NODE_ENV=testnie działało, musiałem użyć, export NODE_ENV=testpo czym NODE_ENV=testzacząłem działać, dziwne.

W systemie Windows, jak już powiedziano, musisz używać, set NODE_ENV=testale dla rozwiązania wieloplatformowego biblioteka cross-env nie wydawała się załatwić i czy naprawdę potrzebujesz biblioteki, aby to zrobić:

export NODE_ENV=test || set NODE_ENV=test&& yadda yadda

Pionowe paski są potrzebne, ponieważ w przeciwnym razie system Windows zawiesiłby się na nierozpoznanym export NODE_ENVpoleceniu: D. Nie wiem o końcowej spacji, ale dla pewności też je usunąłem.

Ponieważ często pracuję z wieloma zmiennymi środowiskowymi, uważam, że warto je przechowywać w osobnym .envpliku (pamiętaj, aby zignorować to z poziomu kontroli źródła).

VAR_A=Hello World
VAR_B=format the .env file like this with new vars separated by a line break

Następnie dodaj export $(cat .env | xargs) &&przed poleceniem skryptu.

Przykład:

{
  ...
  "scripts": {
    ...
    "start": "export $(cat .env | xargs) && echo do your thing here",
    "env": "export $(cat .env | xargs) && env",
    "env-windows": "export $(cat .env | xargs) && set"
  }
  ...
}

Do testu można wyświetlić zmienne env, uruchamiając npm run env(Linux) lub npm run env-windows(Windows).

Wypróbuj to w systemie Windows, zastępując YOURENV:

  {
    ...
     "scripts": {
       "help": "set NODE_ENV=YOURENV && tagove help",
       "start": "set NODE_ENV=YOURENV && tagove start"
     }
    ...
  }

nagle odkryłem, że Actionhero używa następującego kodu, który rozwiązał mój problem, przekazując --NODE_ENV=productionopcję polecenia start skryptu.

if(argv['NODE_ENV'] != null){
  api.env = argv['NODE_ENV'];
} else if(process.env.NODE_ENV != null){
  api.env = process.env.NODE_ENV;
}

Byłbym naprawdę wdzięczny za przyjęcie odpowiedzi kogoś, kto wie lepiej, jak ustawić zmienne środowiskowe w pakiecie.json lub skrypcie inicjującym lub coś w tym rodzaju, gdzie aplikacja została uruchomiona przez kogoś innego.

W przypadku większego zestawu zmiennych środowiskowych lub gdy chcesz ich ponownie użyć, możesz użyć env-cmd .

./.env plik:

# This is a comment
ENV1=THANKS
ENV2=FOR ALL
ENV3=THE FISH

./package.json:

{
  "scripts": {
    "test": "env-cmd mocha -R spec"
  }
}

Chociaż nie odpowiadam bezpośrednio na pytanie, chciałbym podzielić się pomysłem z innymi odpowiedziami. Z tego, co otrzymałem, każdy z nich oferowałby pewien poziom złożoności w celu osiągnięcia niezależności między platformami.

W moim scenariuszu pierwotnie chciałem ustawić zmienną, aby kontrolować, czy zabezpieczyć serwer za pomocą uwierzytelniania JWT (do celów programistycznych)

Po przeczytaniu odpowiedzi postanowiłem po prostu utworzyć 2 różne pliki z włączonym i wyłączonym uwierzytelnianiem.

  "scripts": {
    "dev": "nodemon --debug  index_auth.js",
    "devna": "nodemon --debug  index_no_auth.js",
  }

Pliki to po prostu opakowania, które wywołują oryginalny plik index.js (którego nazwę zmieniłem appbootstrapper.js):

//index_no_auth.js authentication turned off
const bootstrapper = require('./appbootstrapper');
bootstrapper(false);

//index_auth.js authentication turned on
const bootstrapper = require('./appbootstrapper');
bootstrapper(true);

class AppBootStrapper {

    init(useauth) {
        //real initialization
    }
}

Być może może to pomóc komuś innemu

{
  ...
  "scripts": {
    "start": "ENV NODE_ENV=production someapp --options"
  }
  ...
}

Będzie to działać w konsoli Windows :

"scripts": {
  "aaa": "set TMP=test && npm run bbb",
  "bbb": "echo %TMP%"
}

npm run aaa

wynik: test

Zobacz tę odpowiedź, aby uzyskać szczegółowe informacje.

Nie należy ustawiać zmiennych ENV w package.json. Actionhero używa, NODE_ENVabyś mógł zmienić opcje konfiguracji, które są ładowane z plików w ./config. Sprawdź plik konfiguracyjny redis i zobacz, jak NODE_ENV używa do zmiany opcji bazy danychNODE_ENV=test

Jeśli chcesz użyć innych zmiennych ENV do ustawienia rzeczy (być może portu HTTP), nadal nie musisz nic zmieniać package.json. Na przykład, jeśli ustawiłeś PORT=1234ENV i chcesz użyć tego jako portu HTTP NODE_ENV=production, po prostu odwołaj się do tego w odpowiednim pliku konfiguracyjnym, IE:

# in config/servers/web.js
exports.production = { 
  servers: {
    web: function(api){
      return {
       port: process.env.PORT
      }
    }
  }
}

npm (i przędza) przekazuje wiele danych z package.json do skryptów jako zmienne środowiskowe. Użyj, npm run envaby zobaczyć je wszystkie. Jest to udokumentowane w https://docs.npmjs.com/misc/scripts#environment i dotyczy nie tylko skryptów „cyklu życia”, prepublishale także każdego skryptu wykonywanego przez npm run.

Możesz uzyskać dostęp do tych wewnętrznych kodów (np. process.env.npm_package_config_portW JS), ale są one już dostępne dla powłoki wykonującej skrypty, więc możesz również uzyskać do nich dostęp jako $npm_...rozszerzenia w „skryptach” (składnia unixowa, może nie działać w systemie Windows?).

Sekcja „config” wydaje się przeznaczona do tego zastosowania:

  "name": "myproject",
  ...
  "config": {
    "port": "8010"
  },
  "scripts": {
    "start": "node server.js $npm_package_config_port",
    "test": "wait-on http://localhost:$npm_package_config_port/ && node test.js http://localhost:$npm_package_config_port/"
  } 

Ważną cechą tych pól „config” jest to, że użytkownicy mogą je zastąpić bez modyfikowania pliku package.json !

$ npm run start

> myproject@0.0.0 start /home/cben/mydir
> node server.js $npm_package_config_port

Serving on localhost:8010

$ npm config set myproject:port 8020
$ git diff package.json  # no change!
$ cat ~/.npmrc
myproject:port=8020

$ npm run start

> myproject@0.0.0 start /home/cben/mydir
> node server.js $npm_package_config_port

Serving on localhost:8020

Zobacz dokumentację konfiguracji npm config i przędzy .
Wygląda na to, że przędza czyta, ~/.npmrcwięc npm config setwpływa na oba, ale yarn config setpisze ~/.yarnrc, więc tylko przędza to zobaczy :-(

Odpowiedź Luke'a była prawie taka, jakiej potrzebowałem! Dzięki.

Ponieważ wybrana odpowiedź jest bardzo prosta (i poprawna), ale stara, chciałbym zaoferować alternatywę dla importowania zmiennych z osobnego pliku .env podczas uruchamiania skryptów i naprawienia pewnych ograniczeń odpowiedzi Luke'a. Spróbuj tego:

::: plik .env :::

# This way, you CAN use comments in your .env files
NODE_PATH="src/"

# You can also have extra/empty lines in it
SASS_PATH="node_modules:src/styles"

Następnie w pakiecie json utworzysz skrypt, który ustawi zmienne i uruchom go przed skryptami, których potrzebujesz:

::: package.json :::

scripts: {
  "set-env": "export $(cat .env | grep \"^[^#;]\" |xargs)",
  "storybook": "npm run set-env && start-storybook -s public"
}

Niektóre spostrzeżenia:

• Wyrażenie regularne w poleceniu grep'ed cat usunie komentarze i puste linie.

• &&Nie muszą być „przyklejony” do npm run set-env, jak to jest wymagane, jeśli zostały ustawienie zmiennych w tej samej komendy.

• Jeśli używasz przędzy, możesz zobaczyć ostrzeżenie, możesz ją zmienić na yarn set-envlub użyć npm run set-env --scripts-prepend-node-path &&zamiast tego.

Różne środowiska

Kolejną zaletą korzystania z niego jest to, że możesz mieć różne zmienne środowiskowe.

scripts: {
  "set-env:production": "export $(cat .production.env | grep \"^[^#;]\" |xargs)",
  "set-env:development": "export $(cat .env | grep \"^[^#;]\" |xargs)",
}

Pamiętaj, aby nie dodawać plików .env do repozytorium git, gdy masz w nich klucze, hasła lub sensowne / osobiste dane!

użyj git bash w Windows. Git Bash przetwarza polecenia inaczej niż cmd.

Większość podpowiedzi poleceń systemu Windows dusi się podczas ustawiania zmiennych środowiskowych za pomocą NODE_ENV = produkcja w ten sposób. (Wyjątkiem jest Bash w Windows, który używa natywnego Bash.) Podobnie, istnieje różnica w sposobie wykorzystania zmiennych środowiskowych przez komendy Windows i POSIX. W systemie POSIX używasz: $ ENV_VAR, a w systemie Windows używasz% ENV_VAR%. - cross-env doc

{
  ...
  "scripts": {
    "help": "tagove help",
    "start": "env NODE_ENV=production tagove start"
  }
  ...
}

użyj pakietu dotenv, aby zadeklarować zmienne env