Gestern fragte ein Freund, wie das Express-Projekt bereitgestellt werden könne. Deshalb habe ich diesen Artikel zusammengestellt, in dem es hauptsächlich darum geht, wie man ein auf NodeJS entwickeltes Serverprogramm als Referenz für Freunde in Not bereitstellt.
Der Artikel enthält mehrere Teile:
Prozess (Prozess) ist der Computer Die Betriebssystemzuteilung und die Grundeinheit der Planungsaufgabe . Öffnen Sie den Task-Manager und Sie können sehen, dass tatsächlich viele Programme im Hintergrund des Computers ausgeführt werden und jedes Programm ein Prozess ist.
Moderne Browser verfügen grundsätzlich über eine Multiprozessarchitektur. Öffnen Sie zum Beispiel „Weitere Tools“ – „Task-Manager“ und Sie können die Prozessinformationen des aktuellen Browsers sehen Darüber hinaus gibt es Netzwerkprozesse, GPU-Prozesse usw.
Die Multiprozessarchitektur sorgt für einen stabileren Betrieb der Anwendung. Nehmen wir als Beispiel den Browser: Wenn alle Programme in einem Prozess ausgeführt werden, ein Netzwerkfehler oder ein Fehler beim Rendern der Seite auftritt, stürzt der gesamte Browser ab. Durch die Multiprozessarchitektur hat selbst ein Absturz des Netzwerkprozesses keinen Einfluss auf die Anzeige vorhandener Seiten und kann im schlimmsten Fall vorübergehend nicht auf das Netzwerk zugreifen.
Ein Thread ist die kleinste Einheit, die das Betriebssystem zur Rechenplanung ausführen kann . Es wird in den Prozess eingebunden und ist die eigentliche Bedieneinheit im Prozess. Ein Programm ist beispielsweise wie ein Unternehmen mit mehreren Abteilungen, bei denen es sich um Prozesse handelt. Durch die Zusammenarbeit jeder Abteilung kann das Unternehmen normal ablaufen.
Wir alle wissen, dass JavaScript eine Single-Threaded-Sprache ist. Dieses Design ist darauf zurückzuführen, dass JS in der Anfangszeit hauptsächlich zum Schreiben von Skripten verwendet wurde und für die Realisierung der interaktiven Effekte der Seite verantwortlich war. Wenn es als Multithread-Sprache konzipiert ist, ist dies erstens nicht erforderlich und zweitens betreiben mehrere Threads gemeinsam einen DOM-Knoten. Auf wessen Rat sollte der Browser dann hören? Natürlich unterstützt JS mit der Entwicklung der Technologie jetzt auch Multithreading, wird jedoch nur zur Verarbeitung einiger Logik verwendet, die nichts mit DOM-Operationen zu tun hat.
Einzelne Threads und einzelne Prozesse stellen ein ernstes Problem dar. Sobald der Hauptthread eines laufenden node.js-Programms aufhängt, hängt sich auch der Prozess auf und die gesamte Anwendung hängt ebenfalls auf. Darüber hinaus verfügen die meisten modernen Computer über Mehrkern-CPUs mit vier Kernen und acht Threads bzw. acht Kernen und sechzehn Threads, was sehr verbreitete Geräte sind. Als Einzelprozessprogramm verschwendet node.js die Leistung von Multi-Core-CPUs.
Als Reaktion auf diese Situation benötigen wir ein geeignetes Multiprozessmodell, um ein Node.js-Einzelprozessprogramm in eine Multiprozessarchitektur umzuwandeln.
Es gibt zwei gängige Lösungen für die Implementierung einer Multiprozess-Architektur in Node.js, die beide native Module verwenden, nämlich das child_process Modul und das cluster -Modul.
child_process ist ein integriertes Modul von node.js. Der Name lässt vermuten, dass es für Dinge im Zusammenhang mit untergeordneten Prozessen verantwortlich ist.
Wir werden nicht näher auf die spezifische Verwendung dieses Moduls eingehen. Tatsächlich verfügt es nur über sechs oder sieben Methoden, die dennoch sehr leicht zu verstehen sind. Wir verwenden eine der fork -Methoden, um zu demonstrieren, wie mehrere Prozesse und die Kommunikation zwischen mehreren Prozessen implementiert werden.
Schauen wir uns zunächst die Verzeichnisstruktur des vorbereiteten Demonstrationsfalls an:
Wir verwenden das http Modul, um einen http-Server zu erstellen. Wenn eine /sum -Anfrage eingeht, wird über das child_process -Modul ein untergeordneter Prozess erstellt und der übergeordnete Prozess wird benachrichtigt, um die Berechnungslogik auszuführen muss auch die vom untergeordneten Prozess gesendeten Nachrichten abhören:
/ /child_process.js
const http = require('http')
const { fork } = require('child_process')
const server = http.createServer((req, res) => {
if (req.url == '/sum') {
// Die fork-Methode empfängt einen Modulpfad, startet dann einen untergeordneten Prozess und führt das Modul im untergeordneten Prozess aus // childProcess stellt den erstellten untergeordneten Prozess dar let childProcess = fork('./sum.js')
//Eine Nachricht an den untergeordneten Prozess senden childProcess.send('Der untergeordnete Prozess beginnt mit der Berechnung')
// Überwachen Sie die Nachrichten des untergeordneten Prozesses im übergeordneten Prozess childProcess.on('message', (data) => {
res.end(Daten + '')
})
//Abhören des Abschlussereignisses des untergeordneten Prozesses childProcess.on('close', () => {
// Wenn der untergeordnete Prozess normal beendet wird oder einen Fehler meldet und auflegt, wird er hier angezeigt console.log('untergeordneter Prozess wird geschlossen')
childProcess.kill()
})
//Das Fehlerereignis des untergeordneten Prozesses abhören childProcess.on('error', () => {
console.log('Unterprozessfehler')
childProcess.kill()
})
}
if (req.url == '/hello') {
res.end('Hallo')
}
// Simulieren Sie den übergeordneten Prozess, um einen Fehler zu melden, wenn (req.url == '/error') {
throw new Error('Übergeordneter Prozessfehler')
res.end('Hallo')
}
})
server.listen(3000, () => {
console.log('Server läuft auf 3000')
}) sum.js wird verwendet, um die vom untergeordneten Prozess auszuführenden Aufgaben zu simulieren. Der untergeordnete Prozess hört die vom übergeordneten Prozess gesendeten Nachrichten ab, verarbeitet die Berechnungsaufgaben und sendet die Ergebnisse dann an den übergeordneten Prozess:
// sum.js
Funktion getSum() {
Sei Summe = 0
for (sei i = 0; i < 10000 * 1000 * 100; i++) {
Summe += 1
}
Rückgabesumme
}
// Prozess ist ein globales Objekt in node.js, das den aktuellen Prozess darstellt. Hier ist es der untergeordnete Prozess.
// Auf vom Hauptprozess gesendete Nachrichten warten Process.on('message', (data) => {
console.log('Nachricht vom Hauptprozess:', Daten)
const result = getSum()
//Senden Sie die Berechnungsergebnisse an den übergeordneten Prozess Process.send(result)
}) Öffnen Sie das Terminal und führen Sie den Befehl node 1.child_process aus:
Besuchen Sie den Browser:
Simulieren Sie als Nächstes die Situation, in der der untergeordnete Prozess einen Fehler meldet:
// sum.js
Funktion getSum() {
// ....
}
// Nachdem der untergeordnete Prozess 5 Sekunden lang ausgeführt wurde, hängt der Simulationsprozess auf setTimeout(() => {
throw new Error('error report')
}, 1000 * 5)
process.on('message', (data) => {
// ...
}) Besuchen Sie den Browser erneut und beobachten Sie die Konsole nach 5 Sekunden:
Der untergeordnete Prozess ist abgebrochen und greift dann auf eine andere URL zu: /hello ,
Es ist ersichtlich, dass der übergeordnete Prozess die Anforderung weiterhin korrekt verarbeiten kann, was darauf hinweist, dass der vom untergeordneten Prozess gemeldete Fehler keinen Einfluss auf den Betrieb des übergeordneten Prozesses hat .
Als Nächstes simulieren wir das Szenario, in dem der übergeordnete Prozess einen Fehler meldet, kommentieren den simulierten Fehlerbericht des sum.js -Moduls aus, starten dann den Dienst neu und greifen mit dem Browser auf /error zu:
Nachdem festgestellt wurde, dass der übergeordnete Prozess hängen geblieben war, wurde das gesamte Programm node.js automatisch beendet und der Dienst brach vollständig zusammen, so dass kein Raum für eine Wiederherstellung blieb.
Es ist ersichtlich, dass es nicht kompliziert ist, die Multiprozessarchitektur von node.js über fork -Methode von child_process zu implementieren. Die Kommunikation zwischen Prozessen erfolgt hauptsächlich über send und on . Aus dieser Benennung können wir auch erkennen, dass die unterste Ebene ein Publish-Subscribe-Modell sein sollte.
Es gibt jedoch ein ernstes Problem. Obwohl der untergeordnete Prozess keinen Einfluss auf den übergeordneten Prozess hat, werden alle untergeordneten Prozesse „in einem Topf getötet“, sobald der übergeordnete Prozess einen Fehler macht. Daher eignet sich diese Lösung zum Aufspalten einiger komplexer und zeitaufwändiger Vorgänge in einen separaten Unterprozess . Genauer gesagt wird diese Verwendung verwendet, um die Implementierung von Multi-Threading und nicht von Multi-Processing zu ersetzen.
verwendet das Modul child_process , um mehrere Prozesse zu implementieren, was nutzlos zu sein scheint. Daher wird allgemein empfohlen, das cluster zur Implementierung des Multiprozessmodells von node.js zu verwenden.
cluster bedeutet Cluster. Ich glaube, jeder kennt diesen Begriff. Beispielsweise verfügte das Unternehmen in der Vergangenheit nur über eine Rezeption, und manchmal war es zu voll, um Besucher rechtzeitig zu empfangen. Jetzt hat das Unternehmen vier Rezeptionen zugewiesen. Auch wenn drei besetzt sind, gibt es immer noch eine, die neue Besucher empfangen kann. Clustering bedeutet im Großen und Ganzen, dass die Aufgabe sinnvollerweise verschiedenen Personen zugewiesen wird, um sicherzustellen, dass die Aufgabe am besten erledigt werden kann.
Auch die Nutzung des cluster ist relativ einfach. Wenn der aktuelle Prozess der Hauptprozess ist, erstellen Sie eine entsprechende Anzahl von Unterprozessen basierend auf der Anzahl der CPU-Kerne und überwachen Sie das exit -Ereignis des Unterprozesses. Wenn ein Unterprozess beendet wird, forken Sie den neuen Unterprozess erneut -Verfahren. Handelt es sich nicht um einen Kindprozess, wird das eigentliche Geschäft abgewickelt.
const http = require('http')
const Cluster = require('Cluster')
const cpus = require('os').cpus()
if (cluster.isMaster) {
// Wenn das Programm startet, geht es zuerst hierher und erstellt mehrere Unterprozesse entsprechend der Anzahl der CPU-Kerne für (let i = 0; i < cpus.length; i++) {
//Erstelle einen untergeordneten Prozesscluster.fork()
}
// Wenn ein untergeordneter Prozess aufhängt, gibt das Clustermodul das Ereignis „exit“ aus. An diesem Punkt wird der Prozess durch einen erneuten Aufruf von fork neu gestartet.
Cluster.on('exit', () => {
Cluster.fork()
})
} anders {
// Die Fork-Methode wird ausgeführt, um einen untergeordneten Prozess zu erstellen, und das Modul wird erneut ausgeführt. Zu diesem Zeitpunkt kommt die Logik hierher const server = http.createServer((req, res) => {
console.log(process.pid)
res.end('ok')
})
server.listen(3000, () => {
console.log('Server läuft auf 3000', 'pid: ' +process.pid)
})
} Starten Sie den Dienst:
Wie Sie sehen, hat das cluster viele untergeordnete Prozesse erstellt, und es scheint, dass jeder untergeordnete Prozess denselben Webdienst ausführt.
Es ist zu beachten, dass diese untergeordneten Prozesse zu diesem Zeitpunkt nicht denselben Port überwachen . Der von der Methode createServer erstellte Server ist weiterhin für die Portüberwachung verantwortlich und leitet Anforderungen an jeden untergeordneten Prozess weiter.
Schreiben wir ein Anforderungsskript, um den oben genannten Dienst anzufordern und die Auswirkung zu sehen.
// request.js
const http = require('http')
for (sei i = 0; i < 1000; i++) {
http.get('http://localhost:3000')
} Das http-Modul kann nicht nur einen http-Server erstellen, sondern auch zum Senden von http-Anfragen verwendet werden. Axios unterstützt Browser- und Serverumgebungen. Auf der Serverseite wird das http-Modul zum Senden von http-Anfragen verwendet.
Verwenden Sie node , um die Datei auszuführen und sehen Sie sich die Originalkonsole an:
Die Prozess-IDs verschiedener Unterprozesse, die die Anfrage konkret bearbeiten, werden gedruckt.
Dies ist die Multiprozessarchitektur von nodd.js, die über das cluster implementiert wird.
Wenn wir node.js-Projekte bereitstellen, werden wir das cluster -Modul natürlich nicht so trocken schreiben und verwenden. Es gibt ein sehr nützliches Tool namens PM2 , ein Prozessmanagement-Tool, das auf dem Cluster-Modul basiert. Seine grundlegende Verwendung wird in den folgenden Kapiteln vorgestellt.
Bisher haben wir einen Teil des Artikels damit verbracht, das Wissen über Multiprozesse in node.js vorzustellen. Tatsächlich möchten wir nur erklären, warum wir pm2 verwenden müssen, um node.js-Anwendungen zu verwalten . Aufgrund des begrenzten Platzes dieses Artikels und des Mangels an genauer/detaillierter Beschreibung gibt dieser Artikel nur eine kurze Einführung. Wenn Sie zum ersten Mal mit diesem Inhalt in Kontakt kommen, verstehen Sie ihn möglicherweise nicht sehr gut. Machen Sie sich also keine Sorgen, es wird später einen ausführlicheren Artikel geben.
In diesem Artikel wurde ein mit Express entwickeltes Beispielprogramm vorbereitet. Klicken Sie hier, um darauf zuzugreifen.
Es implementiert hauptsächlich einen Schnittstellendienst. Beim Zugriff auf /api/users wird mockjs verwendet, um 10 Benutzerdaten zu simulieren und eine Benutzerliste zurückzugeben. Gleichzeitig wird ein Timer gestartet, um eine Fehlersituation zu simulieren:
const express = require('express')
const Mock = require('mockjs')
const app = express()
app.get("/api/users", (req, res) => {
const userList = Mock.mock({
'userList|10': [{
'id|+1': 1,
'name': '@cname',
'email': '@email'
}]
})
setTimeout(()=> {
wirf einen neuen Fehler ('Serverfehler')
}, 5000)
res.status(200)
res.json(userList)
})
app.listen(3000, () => {
console.log("Dienst gestartet: 3000")
}) Testen Sie es lokal und führen Sie den Befehl im Terminal aus:
node server.js
Öffnen Sie den Browser und greifen Sie auf die Benutzerlistenoberfläche zu:
Nach fünf Sekunden hängt der Server:
Wir können dieses Problem später lösen, wenn wir pm2 zum Verwalten von Anwendungen verwenden.
Normalerweise packen wir es nach Abschluss eines Vue/React-Projekts zuerst und veröffentlichen es dann. Tatsächlich müssen Front-End-Projekte hauptsächlich gepackt werden, da die endgültige Ausführungsumgebung des Programms der Browser ist und der Browser verschiedene Kompatibilitäts- und Leistungsprobleme aufweist, z. B.:
.vue , .jsx und .ts Dateien kompiliert werden,Projekte, die mit express.js oder koa.js entwickelt wurden, müssen nicht kompiliert werden diese Probleme. Darüber hinaus übernimmt Node.js die modulare Spezifikation CommonJS und verfügt über einen Caching-Mechanismus. Gleichzeitig wird das Modul nur importiert, wenn es verwendet wird . Wenn Sie es in eine Datei packen, wird dieser Vorteil tatsächlich verschwendet. Für node.js-Projekte ist daher kein Paket erforderlich.
In diesem Artikel wird am Beispiel des CentOS-Systems gezeigt,
Um den Wechsel der Knotenversionen zu erleichtern, verwenden wir NVM zur Knotenverwaltung.
Nvm (Node Version Manager) ist das Versionsverwaltungstool von Node.js. Dadurch kann der Knoten beliebig zwischen mehreren Versionen gewechselt werden, wodurch wiederholte Download- und Installationsvorgänge vermieden werden, wenn ein Versionswechsel erforderlich ist.
Das offizielle Repository von Nvm ist github.com/nvm-sh/nvm. Da das Installationsskript auf der githubusercontent -Site gespeichert ist, ist es häufig nicht zugänglich. Deshalb habe ich auf Gitee ein neues Spiegel-Repository dafür erstellt, damit ich von Gitee aus auf das Installationsskript zugreifen kann.
Laden Sie das Installationsskript über den Befehl curl herunter und verwenden Sie bash , um das Skript auszuführen, wodurch die Installation von nvm automatisch abgeschlossen wird:
# curl -o- https://gitee.com/hsyq/nvm/raw/master/install.sh | bash
Wenn die Installation abgeschlossen ist, öffnen wir ein neues Fenster, um nvm zu verwenden:
[root@ecs-221238 ~]# nvm -v0.39.1
kann die Versionsnummer normal drucken, was darauf hinweist, dass NVM erfolgreich installiert wurde.
Jetzt können Sie nvm zum Installieren und Verwalten von Node verwenden.
Verfügbare Knotenversionen anzeigen:
# nvm ls-remote
Installationsknoten:
# nvm install 18.0.0
Installierte Knotenversionen anzeigen:
[root@ecs-221238 ~]# nvm-Liste -> v18.0.0 Standard -> 18.0.0 (-> v18.0.0) iojs -> N/A (Standard) instabil -> N/A (Standard) Knoten -> stabil (-> v18.0.0) (Standard) stabil -> 18.0 (-> v18.0.0) (Standard)
Wählen Sie eine zu verwendende Version aus:
# nvm use 18.0.0
Beachten Sie, dass Sie bei der Verwendung von nvm unter Windows Administratorrechte verwenden müssen, um den nvm-Befehl auszuführen. Unter CentOS melde ich mich standardmäßig als Root-Benutzer an, daher gibt es kein Problem. Wenn bei der Verwendung unbekannte Fehler auftreten, können Sie nach Lösungen suchen oder versuchen herauszufinden, ob das Problem durch Berechtigungen verursacht wird.
Bei der Installation des Knotens wird npm automatisch installiert. Überprüfen Sie die Versionsnummern von Knoten und NPM:
[root@ecs-221238 ~]# Knoten -v v18.0.0 [root@ecs-221238 ~]# npm -v
Die Standard-NPM-Image-Quelle
in 8.6.0ist die offizielle Adresse:
[root@ecs-221238 ~]# npm config get Registry https://registry.npmjs.org/
Wechseln Sie zur inländischen Taobao-Spiegelquelle:
[root@ecs-221238 ~]# npm config set Registry https://registry.npmmirror.com
Zu diesem Zeitpunkt hat der Server den Knoten The installiert Umgebung und NPM sind konfiguriert.
Es gibt viele Möglichkeiten, entweder durch Herunterladen auf den Server aus dem Github/GitLab/Gitee-Repository oder durch lokales Hochladen über das FTP-Tool. Die Schritte sind sehr einfach und werden nicht noch einmal demonstriert.
Das Demoprojekt wird im Verzeichnis /www abgelegt:
Im Allgemeinen öffnen Cloud-Server nur Port 22 für die Remote-Anmeldung. Häufig verwendete Ports wie 80 und 443 sind nicht geöffnet. Darüber hinaus läuft das von uns vorbereitete Express-Projekt auf Port 3000. Sie müssen also zunächst zur Konsole des Cloud-Servers gehen, die Sicherheitsgruppe finden, ein paar Regeln hinzufügen und die Ports 80 und 3000 öffnen.
können wir nodemon zur Echtzeitüberwachung und zum automatischen Neustart verwenden, um die Entwicklungseffizienz zu verbessern. In einer Produktionsumgebung müssen Sie den großen Killer verwenden – PM2.
installieren Sie pm2 zunächst global:
# npm i -g pm2
Führen Sie den Befehl pm2 -v aus, um zu überprüfen, ob die Installation erfolgreich ist:
[root@ecs-221238 ~]# pm2 -v5.2.0
Wechseln Sie in das Projektverzeichnis und installieren Sie zuerst die Abhängigkeiten:
cd /www/express-demo npm install
und verwenden Sie dann den Befehl pm2 um die Anwendung zu starten.
pm2 start app.js -i max // Oder pm2 start server.js -i 2
Die PM2-Verwaltungsanwendung verfügt über zwei Modi: Fork und Cluster. Wenn Sie die Anwendung starten und den Parameter -i verwenden, um die Anzahl der Instanzen anzugeben, wird der Clustermodus automatisch aktiviert. Zu diesem Zeitpunkt sind Lastausgleichsfunktionen verfügbar.
-i: Instanz, die Anzahl der Instanzen. Sie können eine bestimmte Anzahl eingeben oder auf max. konfigurieren.
PM2prüft automatisch die Anzahl der verfügbaren CPUs und startet dann so viele Prozesse wie möglich.
Die Anwendung wird nun gestartet. PM2 verwaltet die Anwendung in Form eines Daemon-Prozesses. Diese Tabelle zeigt einige Informationen über die laufende Anwendung, wie z. B. den Ausführungsstatus, die CPU-Auslastung, die Speichernutzung usw.
Greifen Sie in einem lokalen Browser auf die Benutzeroberfläche zu:
Der Clustermodus ist ein Multiprozess- und Multiinstanzmodell . Wenn eine Anfrage eingeht, wird sie einem der Prozesse zur Verarbeitung zugewiesen. Genau wie bei der Verwendung cluster -Moduls, die wir zuvor gesehen haben, wird der Prozess aufgrund der Vormundschaft von pm2 auch dann sofort neu gestartet, wenn ein Prozess stirbt.
Kehren Sie zum Serverterminal zurück und führen Sie den Befehl pm2 logs aus, um die pm2-Protokolle anzuzeigen:
Es ist ersichtlich, dass die Anwendungsinstanz mit der ID 1 aufhängt und pm2 die Instanz sofort neu startet. Beachten Sie, dass es sich bei der ID hier um die ID der Anwendungsinstanz und nicht um die Prozess-ID handelt.
An diesem Punkt ist die einfache Bereitstellung eines Expressprojekts abgeschlossen. Durch den Einsatz des Tools pm2 können wir grundsätzlich sicherstellen, dass unser Projekt stabil und zuverlässig laufen kann.
Hier finden Sie eine Zusammenfassung einiger häufig verwendeter Befehle des PM2-Tools als Referenz.
# Fork-Modus pm2 start app.js --name app # Setzen Sie den Namen der Anwendung auf app #Cluster-Modus# Verwenden Sie den Lastausgleich, um 4 Prozesse zu starten pm2 start app.js -i 4 # Startet 4 Prozesse mit Lastausgleich, abhängig von der verfügbaren CPU pm2 starte app.js -i 0 # Entspricht der Wirkung des obigen Befehls pm2 start app.js -i max # Erweitern Sie die App um 3 zusätzliche Prozesse pm2 Scale App +3 # Erweitern oder verkleinern Sie die App auf 2 Prozesse. PM2 Scale App 2 # Anwendungsstatus anzeigen # Den Status aller Prozesse in der PM2-Liste anzeigen # Drucken Sie die Liste aller Prozesse im JSON-Rohformat pm2 jlist aus # Verwenden Sie verschönertes JSON, um die Liste aller Prozesse auszudrucken. pm2 Prettylist # Alle Informationen zu einem bestimmten Prozess anzeigen. PM2 Beschreibung 0 # Verwenden Sie das Dashboard, um alle Prozesse zu überwachen. pm2 monit #Protokollverwaltung# Alle Anwendungsprotokolle PM2-Protokolle in Echtzeit anzeigen # App-Anwendungsprotokolle in Echtzeit anzeigen. PM2-Protokoll-App # Verwenden Sie das JSON-Format, um Protokolle in Echtzeit anzuzeigen. Geben Sie keine alten Protokolle aus, sondern nur neu generierte Protokolle. PM2-Protokolle --json #Anwendungsverwaltung# Stoppen Sie alle Prozesse. PM2 Stoppen Sie alle # Alle Prozesse neu starten. pm2 Alle neu starten # Stoppen Sie den Prozess mit der angegebenen ID pm2 stop 0 # Starten Sie den Prozess mit der angegebenen ID pm2 restart 0 neu # Prozess pm2 mit ID 0 löschen, 0 löschen # Alle Prozesse löschen pm2 alle löschen
Sie können jeden Befehl selbst ausprobieren, um die Wirkung zu sehen.
Hier ist eine spezielle Demonstration des Befehls monit , mit dem ein Panel im Terminal gestartet werden kann, um den Ausführungsstatus der Anwendung in Echtzeit anzuzeigen. Alle von pm2 verwalteten Anwendungen können über die Aufwärts- und Abwärtspfeile umgeschaltet werden:
PM2 verfügt über sehr leistungsstarke Funktionen, die weit über die oben genannten Befehle hinausgehen. Bei der tatsächlichen Projektbereitstellung müssen Sie möglicherweise auch Protokolldateien, den Überwachungsmodus, Umgebungsvariablen usw. konfigurieren. Es wäre sehr mühsam, Befehle jedes Mal manuell einzugeben. Daher stellt pm2 Konfigurationsdateien zum Verwalten und Bereitstellen von Anwendungen bereit.
Sie können eine Konfigurationsdatei mit dem folgenden Befehl generieren:
[root@ecs-221238 express-demo]# pm2 init simple Die generierte Datei /www/express-demo/ecosystem.config.js
generiert eine Datei ecosystem.config.js :
module.exports = {
Apps: [{
Name: „app1“,
Skript: „./app.js“
}]
} Sie können auch selbst eine Konfigurationsdatei erstellen, z. B. app.config.js :
const path = require('path')
module.exports = {
// Eine Konfigurationsdatei kann mehrere node.js-Anwendungen gleichzeitig verwalten // apps ist ein Array, jedes Element ist die Konfiguration einer Anwendung apps: [{
//Anwendungsname: „express-demo“,
// Skript für die Anwendungseintragsdatei: „./server.js“,
// Es gibt zwei Modi zum Starten der Anwendung: Cluster und Fork. Der Standardwert ist Fork.
exec_mode: 'cluster',
// Anzahl der Anwendungsinstanzen zum Erstellen von Instanzen: 'max',
// Überwachung einschalten und Anwendung automatisch neu starten, wenn sich die Datei ändert watch: true,
//Änderungen an einigen Verzeichnisdateien ignorieren.
// Da das Protokollverzeichnis im Projektpfad abgelegt wird, muss es ignoriert werden, da die Anwendung sonst beim Starten Protokolle generiert. Wenn PM2 neu startet und Protokolle generiert, wird ein Unendliches eingegeben Schleifeignore_watch: [
„node_modules“,
„Protokolle“
],
// Fehlerprotokoll-Speicherpfad err_file: path.resolve(__dirname, 'logs/error.log'),
//Protokollspeicherpfad drucken out_file: path.resolve(__dirname, 'logs/out.log'),
//Datumsformat vor jedem Protokoll in der Protokolldatei festlegen log_date_format: „JJJJ-MM-TT HH:mm:ss“,
}]
} Lassen Sie pm2 Konfigurationsdateien verwenden, um Knotenanwendungen zu verwalten:
pm2 startet app.config.js
Jetzt legen die von pm2 verwalteten Anwendungen die Protokolle im Projektverzeichnis ab (standardmäßig im Installationsverzeichnis von pm2) und können Dateiänderungen überwachen. , starten Sie den Dienst automatisch neu.
