Planen Sie Cron-Jobs in Node.js mit Node-Cron

Vorbereitung Ihrer Umgebung

Bevor Sie beginnen, stellen Sie sicher, dass Node.js auf Ihrem Computer installiert ist. Sie können es von der offiziellen Website herunterladen. Nach der Installation verwenden Sie npm (Node Package Manager), um Bibliotheken für Cron Jobs zu installieren.

node-cron ist eine beliebte Bibliothek für die Planung von Aufgaben in Node.js-Anwendungen. Um node-cron zu installieren, führen Sie diesen Befehl aus:

npm install node-cron

Dieser Befehl fügt node-cron zu Ihrem Projekt hinzu und ermöglicht Ihnen die Planung von Jobs.

Ausführen eines Skripts als Cron Job

Um node-cron zu verwenden, überprüfen Sie zunächst, ob Ihr Skript korrekt läuft, indem Sie folgendes verwenden:

node /pfad/zu/ihrem/skript.js

Wenn es funktioniert, können Sie es mit node-cron planen. Hier ist ein Beispiel, wie "Hallo Welt" jede Minute ausgegeben wird:

const cron = require('node-cron');

cron.schedule('* * * * *', () => {
  console.log('Hallo Welt');
});

Testen Sie Skripte immer, bevor Sie sie planen, da sie sich möglicherweise anders verhalten, wenn sie vom Scheduler ausgeführt werden.

Verstehen der node-cron Bibliothek

Die node-cron Bibliothek nutzt JavaScript's Event Loop, sodass sie Aufgaben plant, ohne andere Operationen zu unterbrechen. Sie verwendet die Crontab-Syntax, ist aber flexibler und integriert sich besser in Node.js-Anwendungen als herkömmliche Crontab-Dateien.

Mit node-cron definieren und verwalten Sie Aufgaben im Code, was es Ihnen ermöglicht, sie basierend auf den Anforderungen Ihrer Anwendung oder Benutzeraktionen zu ändern.

Planung mit Root-Rechten

Wenn Sie Root-Zugriff auf einem Linux-System haben, können Sie eine anwendungsspezifische Crontab-Datei in /etc/crontab.d/ erstellen. Diese Methode funktioniert für Zeitpläne, die für alle Benutzer gelten, erfordert aber eine sorgfältige Handhabung von Berechtigungen und Pfaden.

So fügen Sie einen Eintrag in /etc/crontab.d/meineapp hinzu:

0 0 * * * root node /pfad/zu/ihrem/skript.js >> /var/log/meineapp.log 2>&1

Dies plant die Ausführung Ihres Skripts als Root täglich um Mitternacht und protokolliert Ausgabe und Fehler in /var/log/meineapp.log.

Planung ohne Root-Rechte

Wenn Sie keinen Root-Zugriff haben oder ihn nicht verwenden möchten, sind Benutzer-Crontabs eine weitere Option:

1. Öffnen Sie die Crontab-Datei Ihres Benutzers:

   crontab -e
   

2. Fügen Sie diese Zeile hinzu:

   0 0 * * * /usr/bin/node /pfad/zu/ihrem/skript.js >> /home/benutzer/meineapp.log 2>&1
   

Auf diese Weise wird die Aufgabe unter Ihrem Benutzerkonto ausgeführt, ohne spezielle Berechtigungen zu benötigen, und die Ausgabe wird korrekt protokolliert.

Umgebung und Konfiguration

Bei der Einrichtung von Cron Jobs in Node.js ist es wichtig, Umgebungsvariablen und Konfigurationen zu verwalten. Diese Einstellungen können beeinflussen, wie Ihre geplanten Aufgaben in verschiedenen Umgebungen wie Entwicklung, Test und Produktion ausgeführt werden.

Zur Verwaltung von Umgebungsvariablen für Cron Jobs verwenden Sie das dotenv-Paket. Damit können Sie Konfigurationen in einer .env-Datei speichern, die Ihre Node.js-Anwendung beim Start liest. So geht's:

1. Installieren Sie dotenv:

   npm install dotenv
   

2. Erstellen Sie eine .env-Datei im Projektroot mit Ihren Einstellungen:

   DB_HOST=localhost
   DB_USER=root
   DB_PASS=s1mpl3
   

3. Laden Sie dotenv am Anfang Ihres Skripts:

    require('dotenv').config();
   
    console.log(process.env.DB_HOST); // Gibt aus: localhost
   

Für die Zeitzonenverwaltung mit node-cron ist dies wichtig für Anwendungen, die über verschiedene Zeitzonen hinweg arbeiten. Die node-cron-Bibliothek ermöglicht es Ihnen, eine Zeitzone für jeden Job mit der Option timezone festzulegen:

const cron = require('node-cron');

cron.schedule('* * * * *', () => {
  console.log('Dies wird jede Minute in der angegebenen Zeitzone ausgeführt.');
}, {
  timezone: "Europe/Berlin"
});

Dies stellt sicher, dass Aufgaben unabhängig davon, wo sich Ihr Server befindet oder wie seine Systemzeit eingestellt ist, basierend auf der angegebenen Zeitzone ausgeführt werden.

Dynamische Planung

Dynamische Planung ermöglicht es Ihnen, Aufgaben hinzuzufügen oder zu entfernen, während Ihre Anwendung läuft, ohne sie neu zu starten oder Crontab-Dateien manuell zu bearbeiten.

So planen Sie Aufgaben dynamisch mit node-cron:

• Dynamisches Planen einer Aufgabe:

Erstellen Sie eine Planungsfunktion, die Parameter wie Zeitplan und Aufgabenfunktion akzeptiert:

const cron = require('node-cron');
let aufgabe;

function planeAufgabe(zeitString, aufgabeFunktion) {
  if(aufgabe) {
    aufgabe.stop();
  }

  aufgabe = cron.schedule(zeitString, aufgabeFunktion);
}

Sie können diese Funktion jederzeit aufrufen, um die geplante Aufgabe dynamisch zu ändern.

• Aufgaben abbrechen/stoppen:

Um eine Aufgabe dynamisch innerhalb Ihrer Anwendung zu stoppen oder abzubrechen:

if (aufgabe) {
  aufgabe.stop();
}

Diese Methode bietet Flexibilität bei der Verwaltung von Zeitplänen basierend auf Ereignissen innerhalb Ihrer Anwendung oder Benutzereingaben, ohne direkten Zugriff auf Server-Crontab-Dateien oder Neustart von Diensten zu benötigen.

Durch die Verwendung dieser erweiterten Einstellungsoptionen - Umgebungs-/Konfigurationsverwaltung und dynamische Planung - machen Sie Cron Jobs in Node.js-Anwendungen funktionaler und flexibler.

Identifizierung möglicher Probleme

Bei der Einrichtung von Cron Jobs in Node.js können Sie auf einige Probleme stoßen, die verhindern, dass Ihre geplanten Aufgaben korrekt ausgeführt werden. Zu diesen Problemen können gehören:

• Falsche Dateiberechtigungen: Wenn das Skript nicht die richtigen Berechtigungen hat, funktioniert der Cron Job nicht. Dies passiert oft, wenn Skripte manuell gut laufen, aber nicht wenn sie geplant sind.

• Pfadprobleme: Cron Jobs laufen in einer einfachen Umgebung, die möglicherweise nicht alle Umgebungsvariablen hat, die Sie erwarten. Dies kann zu Problemen mit Pfaden führen, da Ihr Skript notwendige Dateien oder Programme aufgrund fehlender Umgebungsvariablen oder relativer Pfade nicht finden kann.

• Fehlende Umgebungsvariablen: Wenn Ihr Skript Umgebungsvariablen verwendet, die nur in Ihrer Shell gesetzt sind (wie PATH oder benutzerdefinierte Variablen in .bashrc oder .bash_profile), werden diese für den Cron Job nicht verfügbar sein.

• Falsche Verwendung von Bereichswerten: Wenn Sie nicht verstehen, wie Bereichswerte in der Cron-Syntax korrekt verwendet werden, kann dies dazu führen, dass Jobs zu oft, gar nicht oder zu unerwarteten Zeiten ausgeführt werden.

Lösungen und beste Praktiken

Um diese häufigen Probleme zu beheben und sicherzustellen, dass Ihre Node.js Cron Jobs gut funktionieren:

• Setzen Sie korrekte Berechtigungen: Stellen Sie sicher, dass der Benutzer, der den Cron Job ausführt, Ausführungsberechtigungen für Ihr Skript hat. Sie können Ausführungsberechtigungen mit chmod +x /pfad/zu/ihrem/skript.js hinzufügen.

• Verwenden Sie absolute Pfade: Verwenden Sie immer absolute Pfade in Ihren Skripten und bei der Einrichtung in Crontab-Einträgen. Dies stellt sicher, dass unabhängig davon, welches Verzeichnis für Cron's einfache Umgebung "aktuell" ist, es Ihre Dateien und Befehle korrekt finden kann.

  Beispiel: Verwenden Sie /usr/bin/node /absoluter/pfad/zu/meinskript.js anstelle von node meinskript.js.

• Setzen Sie Umgebungsvariablen explizit: Wenn bestimmte Umgebungsvariablen für Ihr Skript benötigt werden:

  • Definieren Sie sie direkt in crontab vor dem Befehl:

    * * * * * ENV_VAR=wert /usr/bin/node /pfad/zu/skript.js
    

  • Oder laden Sie sie aus einer externenDatei am Anfang Ihres Skripts:

    require('dotenv').config({ path: '/absoluter/pfad/zu/.env' });
    

• Verstehen Sie die Cron-Syntax richtig:

  • Verwenden Sie Tools wie den Cron Expression Generator, um Crontab-Ausdrücke zu erstellen und zu überprüfen.

  • Beachten Sie, dass Bereiche (1-5) beide Endpunkte einschließen; Listen (1,2) genaue Werte angeben; Schritte (*/10) Intervalle definieren; Sternchen (*) "jede" bedeuten.

Durch die Anwendung dieser Lösungen und besten Praktiken beim Einrichten von Node.js Cron Jobs stellen Sie eine zuverlässige Aufgabenautomatisierung innerhalb von Anwendungen sicher.

Verwendung externer APIs

Sie können Aufgaben wie das Senden von E-Mails oder das Abrufen von Daten in einer Node.js-Anwendung automatisieren, indem Sie API-Aufrufe planen. Um dies mit node-cron zu tun, richten Sie die Aufgabe ein und führen dann die API-Anfrage darin aus.

Für sichere API-Aufrufe bewahren Sie sensible Informationen wie API-Schlüssel in Umgebungsvariablen auf. Dies verhindert, dass Ihre Anmeldeinformationen in Ihrem Code sichtbar sind. Hier ist ein Beispiel, wie Sie einen täglichen Aufruf an einen externen Wetterdienst planen können:

const cron = require('node-cron');
const axios = require('axios');
require('dotenv').config();

cron.schedule('0 0 * * *', async () => {
  try {
    const response = await axios.get(`https://api.wetter.com/v1?apikey=${process.env.WETTER_API_KEY}`);
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
});

In diesem Code macht axios HTTP-Anfragen, und der API-Schlüssel des Wetterdienstes wird in einer .env-Datei gespeichert.

Datenbank-Bereinigungsaufgaben

Die regelmäßige Bereinigung von Datenbanken hilft, die Leistung und Datengenauigkeit aufrechtzuerhalten. Cron Jobs können Aufgaben wie das Löschen alter Datensätze automatisieren. Hier ist ein Beispiel, wie Sie eine wöchentliche Bereinigung für MongoDB einrichten:

const cron = require('node-cron');
const mongoose = require('mongoose');

// Verbinden Sie sich vor der Ausführung mit MongoDB

cron.schedule('* * */7 * *', async () => {
  try {
    await mongoose.connection.collection('tempDaten').deleteMany({ "erstelltAm": { $lt: new Date(Date.now() - 7*24*60*60*1000) } });
    console.log("Alte temporäre Daten erfolgreich bereinigt.");
  } catch (error) {
    console.error("Fehler beim Bereinigen alter temporärer Daten:", error);
  }
});

Dieses Skript löscht Datensätze aus der tempDaten-Sammlung, die älter als eine Woche sind.

Dynamische Aufgabenplanung basierend auf Systemlogik

Statische Zeitpläne passen möglicherweise nicht immer zu Ihren Bedürfnissen. Möglicherweise benötigen Sie Zeitpläne, die sich basierend auf Benutzeraktionen oder anderen Bedingungen in Ihrer App ändern. Mit node-cron können Sie Aufgaben dynamisch erstellen oder ändern.

Hier ist ein Beispiel, bei dem wir die Aufgabenhäufigkeit basierend auf der Systemlast ändern:

const cron = require('node-cron');
let aufgabe;

function passeAufgabenzeitplanAn(lastDurchschnitt) {
  if(aufgabe) aufgabe.stop();

  if(lastDurchschnitt > 1) { // Passen Sie den Schwellenwert nach Bedarf an.
    // Planen Sie bei hoher Last weniger häufig.
    aufgabe = cron.schedule('* */5 * * *', aufgabeBeiHoherLast);
    console.log("Weniger häufige Aktualisierungen aufgrund hoher Systemlast geplant.");
  } else {
    // Planen Sie unter normalen Bedingungen häufiger.
    aufgabe = cron.schedule('* */1 * * *', aufgabeBeiNormalerLast);
     console.log("Häufigere Aktualisierungen aufgrund normaler Systemlast geplant.");
   }
}

function aufgabeBeiHoherLast() { /* ... */ }

function aufgabeBeiNormalerLast() { /* ... */ }

// Beispiel:
passeAufgabenzeitplanAn(require('os').loadavg()[0]);

In diesem Fall überprüfen wir die durchschnittliche Systemlast (loadavg) und entscheiden, ob unsere Aufgaben unter normalen Bedingungen häufiger oder bei hoher Last weniger häufig ausgeführt werden sollen. Diese Methode bietet Flexibilität und Reaktionsfähigkeit bei der Planung basierend auf den Echtzeit-Bedingungen der Anwendungsumgebung.

Planung von Cloud-Funktionen

Der Google Cloud Scheduler ist ein Dienst, der es Ihnen ermöglicht, fast jede Aufgabe zu planen. Er kann mit Node.js-Projekten arbeiten und bietet eine Möglichkeit, komplexe Zeitpläne oder Aufgaben über verschiedene Systeme hinweg zu verwalten, ohne dass Sie sich selbst um Cron Jobs kümmern müssen.

Um den Google Cloud Scheduler in Ihrer Node.js-Anwendung zu verwenden, erstellen Sie zunächst eine Cloud-Funktion, die die gewünschte Aufgabe ausführt. Dies könnte die Bereinigung von Datenbanken, das Senden von E-Mails in Batches oder die Verarbeitung von Daten sein. Nachdem Sie Ihre Funktion auf Google Cloud Functions bereitgestellt haben, verwenden Sie dann Google Cloud Scheduler, um Zeiten oder Intervalle für die Auslösung dieser Funktion festzulegen.

Die Schritte umfassen:

1. Schreiben und Bereitstellen Ihrer Cloud-Funktion auf der Google Cloud Platform (GCP).
2. Erstellen eines Scheduler-Jobs in GCP, der die URL Ihrer Cloud-Funktion zu bestimmten Zeiten auslöst.

Diese Methode nimmt Ihrer Anwendung die Aufgabe der Planung und Ausführung von Aufgaben ab, indem sie die Funktionen der GCP für die Handhabung großer Lasten und Zuverlässigkeit nutzt.

Serverlose Optionen

Serverlose Computerplattformen wie Vercel und AWS Lambda bieten Möglichkeiten, geplante Aufgaben auszuführen, ohne direkt Server zu verwalten. Diese Plattformen ermöglichen es Ihnen, Code basierend auf Ereignissen auszuführen, einschließlich zeitbasierter Auslöser ähnlich wie Cron Jobs.

• Vercel: Mit Vercel können Sie serverlose Funktionen in Node.js (und anderen Sprachen) bereitstellen, die auf HTTP-Anfragen reagieren. Um wie Cron Jobs zu fungieren, können Dienste wie EasyCron Ihre Vercel-Funktionen in festgelegten Intervallen aufrufen.

• AWS Lambda: AWS unterstützt die Planung direkt über Amazon CloudWatch Events. Sie können Regeln erstellen, die Ihre Lambda-Funktionen nach einem festgelegten Zeitplan oder einem Cron-Ausdruck innerhalb von AWS ausführen.

Beide Optionen beseitigen die Notwendigkeit, Server und Skalierungsprobleme zu verwalten, und ermöglichen es Entwicklern, sich auf das Schreiben von Code für ihre geplanten Aufgaben zu konzentrieren. Die Wahl zwischen diesen Plattformen hängt oft von Faktoren ab wie der bereits vorhandenen Nutzung von AWS-Diensten, spezifischen benötigten Funktionen und persönlichen Vorlieben basierend auf Benutzerfreundlichkeit oder Vertrautheit.

Durch die Nutzung externer Plattformen wie Google Cloud Scheduler oder serverloser Optionen wie Vercel und AWS Lambda haben Entwickler mehr Möglichkeiten, geplante Aufgaben in ihre Anwendungen zu integrieren - sei es durch verwaltete Planungsdienste oder durch die Nutzung serverloser Architekturen für eine effiziente Ausführung von Hintergrundjobs ohne direkte Serververwaltung.

Tools zur Überwachung

Wenn Sie Aufgaben in Ihrer Node.js-Anwendung planen, ist es wichtig sicherzustellen, dass sie korrekt funktionieren. Probleme mit Cron Jobs könnten ohne Überwachung unbemerkt bleiben, was zu Problemen wie fehlenden Daten oder Benachrichtigungen führen kann. Um Aufgaben pünktlich und reibungslos am Laufen zu halten, sind Überwachungstools sehr hilfreich.

Tools wie Healthchecks.io und Dead Man's Snitch funktionieren, indem sie HTTP-Anfragen am Anfang und Ende jeder Aufgabe senden. Wenn ein Job nicht wie erwartet zurückmeldet, senden sie basierend auf Ihren Einstellungen eine Benachrichtigung.

Beste Praktiken für sichere Aufgabenplanung

Bei der Einrichtung von Cron Jobs in einem Node.js-Projekt ist es wichtig, die Sicherheit im Auge zu behalten. Hier sind einige wichtige Praktiken, um Ihre geplanten Aufgaben sicher zu machen:

1. Verwenden Sie minimale Berechtigungen: Führen Sie Ihre Cron Jobs mit den geringsten Berechtigungen aus, die zur Erledigung der Aufgabe erforderlich sind. Führen Sie Skripte nicht als Root oder Administrator aus, es sei denn, es ist unbedingt notwendig.

2. Sichere Umgebungsvariablen: Bewahren Sie sensible Informationen wie API-Schlüssel und Datenbankanmeldeinformationen in Umgebungsvariablen auf, nicht in Ihren Skripten. Verwenden Sie Tools wie dotenv zur sicheren Verwaltung dieser Daten.

3. Validieren Sie externe Eingaben: Wenn Ihr Cron Job externe Eingaben verarbeitet (wie Dateien von einem FTP-Server oder Daten von einer API), überprüfen Sie diese Eingaben sorgfältig, um Angriffe oder die Verarbeitung schädlicher Daten zu verhindern.

4. Aktualisieren Sie Abhängigkeiten regelmäßig: Stellen Sie sicher, dass alle Abhängigkeiten Ihrer Node.js-Anwendung und ihrer Cron Jobs regelmäßig mit Sicherheitspatches aktualisiert werden.

5. Prüfprotokolle und Überwachung: Protokollieren Sie alle Aktionen geplanter Aufgaben, einschließlich Erfolge und Fehler. Verwenden Sie Überwachungstools, um Sie über ungewöhnliches Verhalten oder Fehler zu benachrichtigen, die auf ein Sicherheitsproblem hinweisen könnten.

6. Sichere Zugangskontrolle: Begrenzen Sie den Zugriff auf Systeme, auf denen Cron Jobs laufen, so weit wie möglich, sowohl physisch als auch über das Netzwerk. Verwenden Sie Firewalls, VPNs und SSH-Schlüssel anstelle von nur Passwörtern für den Fernzugriff.

7. Überprüfen Sie den Code regelmäßig: Überprüfen Sie den Code von Skripten, die von Cron Jobs ausgeführt werden, häufig auf potenzielle Sicherheitsprobleme wie Risiken von Befehlseinschleusungen oder falsche Handhabung von Benutzerdaten.

Umgang mit sensiblen Daten in geplanten Aufgaben

Es ist entscheidend, sensible Daten in geplanten Aufgaben sorgfältig zu verwalten, um unbefugten Zugriff zu verhindern:

1. Verschlüsseln Sie sensible Daten: Verschlüsseln Sie sensible Informationen, die ein Cron Job benötigt (wie Datenbankpasswörter), sowohl bei der Speicherung als auch bei der Übertragung über Netzwerke.

2. Verwenden Sie sichere Verbindungen: Stellen Sie sicher, dass alle externen Verbindungen, die Ihr Cron Job herstellt (zum Beispiel API-Aufrufe), sichere Protokolle wie HTTPS verwenden.

3. Zugriffskontrollen: Legen Sie strenge Zugriffskontrollen für Datenbanken und andere Ressourcen fest, die von geplanten Aufgaben verwendet werden, basierend auf dem Prinzip der geringsten Privilegien.

4. Tools zur Verwaltung von Umgebungsvariablen: Verwenden Sie Tools, die für die Verwaltung von Geheimnissen innerhalb von Anwendungen entwickelt wurden, wie HashiCorp Vault, die komplexe Aufgabenplanung sicher handhaben können.

5. Temporäre Anmeldeinformationen: Für den Zugriff auf Cloud-Dienste oder APIs sollten Sie die Verwendung temporärer Anmeldeinformationen in Betracht ziehen, die ablaufen, anstatt langfristige API-Schlüssel im Anwendungscode zu speichern.

6. Vermeiden Sie die Protokollierung sensibler Informationen: Seien Sie vorsichtig damit, was während der Aufgabenausführung protokolliert wird; protokollieren Sie keine sensiblen Details, es sei denn, es ist notwendig - und dann nur, wenn sie ordnungsgemäß maskiert oder verschlüsselt sind.

7. Regelmäßige Überprüfungen: Überprüfen Sie regelmäßig, wie sensible Daten innerhalb geplanter Aufgaben verwaltet werden, einschließlich wer über Umgebungsvariablen oder direkte Datenbankzugriffe, die von diesen Jobs initiiert werden, Zugang hat.

Die Befolgung dieser Richtlinien bei der Einrichtung von node-cron Jobs in Node.js-Projekten hilft, sowohl eine effiziente als auch sichere automatisierte Aufgabenausführung innerhalb von Anwendungen gegen potenzielle Schwachstellen zu gewährleisten, während kritische Operationen automatisch gehandhabt werden.

E-Mail-Automatisierungsbeispiele

Cron Jobs in Node.js-Anwendungen werden oft zum automatischen Versenden von E-Mails verwendet. Zum Beispiel möchten Sie vielleicht wöchentliche Newsletter automatisch versenden. So geht's:

1. Wöchentlicher Newsletter: Mit node-cron können Sie einen Job planen, der jeden Montag um 9 Uhr läuft. Dieser Job würde neue Inhalte aus Ihrer Datenbank abrufen und in eine E-Mail-Vorlage einfügen.

2. Code-Beispiel:

const cron = require('node-cron');
const nodemailer = require('nodemailer');

cron.schedule('0 9 * * 1', async () => {
  const inhalt = await holeWöchentlichenInhalt();
  const emailKörper = erstelleEmail(inhalt);

  let transporter = nodemailer.createTransport({
    service: 'gmail',
    auth: {
      user: process.env.EMAIL,
      pass: process.env.PASSWORT,
    },
  });

  let mailOptionen = {
    from: process.env.EMAIL,
    to: 'benutzer@beispiel.de',
    subject: 'Ihr wöchentlicher Newsletter',
    html: emailKörper,
  };

transporter.sendMail(mailOptionen, function(fehler, info){
if (fehler) {
console.log(fehler);
} else {
console.log('E-Mail erfolgreich gesendet');
}
});
});

Dieses Skript verwendet nodemailer für E-Mails und geht davon aus, dass Funktionen wie holeWöchentlichenInhalt() und erstelleEmail() in Ihrer Anwendung definiert sind.

Beispiele für die Überwachung von Serverressourcen

Die Überwachung von Serverressourcen hilft, Anwendungen reibungslos am Laufen zu halten. Sie können dies mit geplanten Aufgaben automatisieren, die regelmäßig Metriken wie CPU-Auslastung oder Speicherverbrauch sammeln.

1. Tägliche Erfassung von Leistungsmetriken: Planen Sie eine Aufgabe, die diese Metriken täglich mithilfe von Node.js-Modulen oder anderen Bibliotheken sammelt und speichert oder an einen Überwachungsdienst sendet.

2. Code-Beispiel:

const cron = require('node-cron');
const osUtils = require('os-utils');

cron.schedule('* * */24 * *', () => { // Läuft jeden Tag
osUtils.cpuUsage(function(v){
console.log( 'CPU-Auslastung (%): ' + v );
});

let freierSpeicherProzent = osUtils.freememPercentage() * 100;
console.log( 'Freier Speicher (%): ' + freierSpeicherProzent );

let gesamtSpeicherMb= osUtils.totalmem() /1024;
console.log( 'Gesamtspeicher (MB):' + gesamtSpeicherMb);

// Speichern Sie diese Werte oder senden Sie sie an eine externe API.
});

Dieses Beispiel verwendet die os-utils-Bibliothek für Systemmetriken, protokolliert sie aber nur; für eine langfristige Überwachung wäre eine Speicherintegration erforderlich.

Verwaltung von Protokolldateien

Die Verwaltung von Protokolldateien ist wichtig, um das Anwendungsverhalten zu verfolgen, ohne zu viel Festplattenspeicher zu verbrauchen. Cron Jobs können alte Protokolle automatisch komprimieren und sehr alte löschen.

1. Tägliche Protokollarchivierung: Eine Aufgabe könnte jeden Morgen, wenn der Verkehr gering ist, die Protokolldateien des Vortages komprimieren.

2. Monatliche Protokollbereinigung: Eine andere Aufgabe könnte Protokollarchive löschen, die älter als sechs Monate sind, um Datenwachstum zu verhindern.

3. Code-Beispiel:

const cron = require('node-cron');
const { exec }=require("child_process");

// Tägliche Komprimierung von Protokollen 
cron.schedule('* */24 * *', () => { 
exec("tar -czvf protokolle-$(date +%Y-%m-%d).tar.gz /pfad/zu/protokollen", (fehler) => {
if (fehler) console.error(`Fehler beim Komprimieren der Protokolle: ${fehler}`);
else console.log("Protokolle erfolgreich komprimiert.");
});
});

// Monatliche Bereinigung 
cron.schedule('* */720 *', () => { 
exec("find /pfad/zu/archivierten/protokollen -mtime +180 -type f -delete", (fehler) =>{
if(fehler) console.error(`Fehler beim Löschen alter Protokollarchive:${fehler}`);
else console.log("Alte Protokollarchive erfolgreich gelöscht.");
});
});

Diese Beispiele zeigen, wie Node.js Aufgaben wie das Senden von E-Mails, regelmäßiges Sammeln von Serverleistungsdaten und die Verwaltung von Anwendungsprotokollen durch Kompressions- und Löschzeitpläne automatisieren kann - alles wichtige Teile der Wartung von Webanwendungen mit geplanten Aufgaben.