Node.js
Wdrażanie aplikacji Node.js w środowisku produkcyjnym

Ustawienie NODE_ENV = „produkcja”

Wdrożenia produkcyjne będą się różnić na wiele sposobów, ale standardową konwencją podczas wdrażania w produkcji jest zdefiniowanie zmiennej środowiskowej o nazwie NODE_ENV i ustawienie jej wartości na „produkcja” .

Flagi środowiska wykonawczego

Każdy kod działający w Twojej aplikacji (w tym moduły zewnętrzne) może sprawdzić wartość NODE_ENV :

if(process.env.NODE_ENV === 'production') {
    // We are running in production mode
} else {
   // We are running in development mode
}

Zależności

Gdy NODE_ENV środowiskowa NODE_ENV jest ustawiona na „produkcja”, wszystkie devDependencies w pliku package.json zostaną całkowicie zignorowane podczas uruchamiania npm install . Możesz to również wymusić za pomocą flagi --production :

npm install --production

Aby ustawić NODE_ENV , możesz użyć dowolnej z tych metod

metoda 1: ustaw NODE_ENV dla wszystkich aplikacji węzłów

Windows:

set NODE_ENV=production

Linux lub inny system uniksowy:

export NODE_ENV=production

Ustawia to NODE_ENV dla bieżącej sesji bash, więc wszelkie aplikacje uruchomione po tej instrukcji będą miały NODE_ENV ustawione na production .

metoda 2: ustaw NODE_ENV dla bieżącej aplikacji

NODE_ENV=production node app.js

Spowoduje to ustawienie NODE_ENV dla bieżącej aplikacji. Pomaga to w testowaniu naszych aplikacji w różnych środowiskach.

metoda 3: utwórz plik .env i użyj go

Wykorzystuje to wyjaśniony tutaj pomysł. Zobacz ten post, aby uzyskać bardziej szczegółowe wyjaśnienia.

Zasadniczo tworzysz plik .env i uruchamiasz skrypt bash, aby ustawić je w środowisku.

Aby uniknąć pisania skryptu bash, pakiet env-cmd można wykorzystać do załadowania zmiennych środowiskowych zdefiniowanych w pliku .env .

env-cmd .env node app.js

Metoda 4: Użyj pakietu cross-env

Ten pakiet umożliwia ustawienie zmiennych środowiskowych w jeden sposób dla każdej platformy.

Po zainstalowaniu go za pomocą npm, możesz po prostu dodać go do skryptu wdrażania w package.json w następujący sposób:

"build:deploy": "cross-env NODE_ENV=production webpack"

Zarządzaj aplikacją za pomocą menedżera procesów

Dobrą praktyką jest uruchamianie aplikacji NodeJS kontrolowanych przez menedżerów procesów. Menedżer procesów pomaga utrzymać aplikację przy życiu na zawsze, uruchamia się ponownie w przypadku awarii, ładuje się ponownie bez przestojów i upraszcza administrowanie. Najpotężniejsze z nich (jak PM2 ) mają wbudowany moduł równoważenia obciążenia. PM2 umożliwia także zarządzanie rejestrowaniem, monitorowaniem i klastrowaniem aplikacji.

Kierownik procesu PM2

Instalowanie PM2:

npm install pm2 -g

Proces można uruchomić w trybie klastra z udziałem zintegrowanego modułu równoważenia obciążenia w celu rozłożenia obciążenia między procesami:

pm2 start app.js -i 0 --name "api" ( -i określa liczbę procesów do odrodzenia. Jeśli jest to 0, to numer procesu będzie pm2 start app.js -i 0 --name "api" od liczby rdzeni procesora)

Podczas gdy wielu użytkowników jest w produkcji, musi mieć jeden punkt dla PM2. Dlatego komenda pm2 musi być poprzedzona lokalizacją (dla konfiguracji PM2), w przeciwnym razie pojawi się nowy proces pm2 dla każdego użytkownika z konfiguracją w odpowiednim katalogu domowym. I to będzie niespójne.

Zastosowanie: PM2_HOME=/etc/.pm2 pm2 start app.js

Wdrożenie za pomocą PM2

PM2 to menedżer procesów produkcyjnych dla aplikacji Node.js , który pozwala utrzymać aplikacje przy życiu na zawsze i ponownie je ładować bez przestojów. PM2 umożliwia także zarządzanie rejestrowaniem, monitorowaniem i klastrowaniem aplikacji.

Zainstaluj pm2 globalnie.

npm install -g pm2

Następnie uruchom aplikację node.js przy użyciu PM2.

pm2 start server.js --name "my-app"

Poniższe polecenia są przydatne podczas pracy z PM2 .

Wyświetl wszystkie uruchomione procesy:

pm2 list

Zatrzymaj aplikację:

pm2 stop my-app

Uruchom ponownie aplikację:

pm2 restart my-app

Aby wyświetlić szczegółowe informacje o aplikacji:

pm2 show my-app

Aby usunąć aplikację z rejestru PM2:

pm2 delete my-app

Wdrożenie przy użyciu menedżera procesów

Menedżer procesów jest zwykle używany w produkcji do wdrażania aplikacji nodejs. Główne funkcje menedżera procesów to restartowanie serwera w przypadku awarii, sprawdzanie zużycia zasobów, poprawianie wydajności środowiska wykonawczego, monitorowanie itp.

Niektóre z popularnych menedżerów procesów stworzonych przez społeczność węzłów to wieczność, pm2 itd.

Forvever

forever to narzędzie interfejsu wiersza poleceń zapewniające ciągłość działania danego skryptu. Prosty interfejs forever idealnie nadaje się do uruchamiania mniejszych wdrożeń aplikacji i skryptów Node.js

forever monitoruje proces i uruchamia go ponownie, jeśli ulegnie awarii.

Instaluj na forever całym świecie.

$ npm install -g forever

Uruchom aplikację:

$ forever start server.js

To uruchamia serwer i podaje identyfikator procesu (zaczyna się od 0).

Uruchom ponownie aplikację:

$ forever restart 0

Tutaj 0 jest identyfikatorem serwera.

Zatrzymaj aplikację:

$ forever stop 0

Podobnie do restartu, 0 to identyfikator serwera. Możesz również podać identyfikator procesu lub nazwę skryptu zamiast identyfikatora podanego przez na zawsze.

Więcej poleceń: https://www.npmjs.com/package/forever

Używanie różnych właściwości / konfiguracji dla różnych środowisk, takich jak dev, qa, inscenizacja itp.

Aplikacje na dużą skalę często wymagają różnych właściwości podczas pracy w różnych środowiskach. możemy to osiągnąć, przekazując argumenty do aplikacji NodeJs i używając tego samego argumentu w procesie węzła, aby załadować określony plik właściwości środowiska.

Załóżmy, że mamy dwa pliki właściwości dla różnych środowisk.

• dev.json

    {
        "PORT": 3000,
        "DB": {
            "host": "localhost",
            "user": "bob",
            "password": "12345"
        }
    }
  

• qa.json

    {
        "PORT": 3001,
        "DB": {
            "host": "where_db_is_hosted",
            "user": "bob",
            "password": "54321"
        }
    }
  

Poniższy kod w aplikacji wyeksportuje odpowiedni plik właściwości, którego chcemy użyć.

process.argv.forEach(function (val) {
    var arg = val.split("=");
    if (arg.length > 0) {
        if (arg[0] === 'env') {
            var env = require('./' + arg[1] + '.json');
            exports.prop = env;
        }
    }
});

Podajemy argumenty aplikacji, takie jak następujące

node app.js env=dev

jeśli używamy menedżera procesów tak jak zawsze, to tak proste jak

forever start app.js env=dev

Korzystając z klastrów

Pojedyncze wystąpienie Node.js działa w jednym wątku. Aby skorzystać z systemów wielordzeniowych, użytkownik czasami chce uruchomić klaster procesów Node.js w celu obsługi obciążenia.

 var cluster = require('cluster');
    
    var numCPUs = require('os').cpus().length;
    
        if (cluster.isMaster) {
          // In real life, you'd probably use more than just 2 workers,
          // and perhaps not put the master and worker in the same file.
          //
          // You can also of course get a bit fancier about logging, and
          // implement whatever custom logic you need to prevent DoS
          // attacks and other bad behavior.
          //
          // See the options in the cluster documentation.
          //
          // The important thing is that the master does very little,
          // increasing our resilience to unexpected errors.
            console.log('your server is working on ' + numCPUs + ' cores');
            
             for (var i = 0; i < numCPUs; i++) {
                    cluster.fork();
                  }
             
          cluster.on('disconnect', function(worker) {
            console.error('disconnect!');
            //clearTimeout(timeout);
            cluster.fork();
          });
    
          
        } else {
            require('./app.js');
        
        }