Eine Node.js-App mit Zugriff auf STACKIT MongoDB Flex erstellen

In diesem Tutorial implementieren Sie ein praxisnahes Szenario mit STACKIT MongoDB Flex (MongoDB Flex). Nach Abschluss aller Schritte verfügen Sie über eine Node.js-App, die ihre Daten in einer MongoDB Flex-Datenbank speichert. Sie lernen, wie Sie eine Node.js-Anwendung mit MongoDB Flex verbinden und warum MongoDB so gut mit JavaScript-Anwendungen zusammenarbeitet. Mit dem erworbenen Wissen können Sie beispielsweise eine REST- oder GraphQL-API erstellen, die auf einer soliden und flexiblen Datenbank basiert.

Übersicht

Dieses Tutorial ist in die folgenden Abschnitte unterteilt:

1. Erstellen einer MongoDB Flex-Instanz mit einem Benutzer, den entsprechenden Berechtigungen und ACL-Einstellungen.
2. Initialisieren einer Umgebung zur Ausführung von Node.js mit den benötigten npm-Paketen.
3. Schreiben einer kleinen Node.js-Anwendung, die die Verbindung zur Datenbank testet.
4. Erstellen einer Node.js-Anwendung, die MongoDB Flex als Backend nutzt.

Voraussetzungen

• Sie haben ein STACKIT Kundenkonto: Kundenkonto erstellen
• Sie haben ein STACKIT Benutzerkonto: Benutzerkonto erstellen
• Sie haben ein STACKIT Projekt: Projekt erstellen
• Auf dem Entwicklungssystem haben Sie Zugriff auf eine Shell, in der Node.js verfügbar ist.
• Sie können die STACKIT Cloud von Ihrem Entwicklungsrechner aus erreichen.
• Sie kennen die externe IPv4-Adresse Ihres Client-Systems.

Erstellen einer MongoDB Flex-Instanz mit einem Benutzer, den entsprechenden Berechtigungen und ACL-Einstellungen

Initialisieren einer Umgebung zur Ausführung von Node.js mit den benötigten npm-Paketen

Prüfen Sie zunächst, ob Sie eine aktuelle Version von Node.js installiert haben.

node --version

Die Ausgabe sollte etwa so aussehen:

v24.4.1

Die installierte Version sollte mindestens v20.0.0 entsprechen oder höher sein. Wenn Sie eine ältere Version installiert haben, konsultieren Sie bitte das Handbuch Ihres Systems, um eine neuere Version zu installieren.

Nachdem Sie diese Voraussetzung geprüft haben, erstellen Sie einen Ordner für dieses Tutorial:

mkdir nodejs-with-mongodb-flex-tutorial
cd nodejs-with-mongodb-flex-tutorial
npm init -y
npm install mongodb dotenv

Die Ausgabe sollte etwa so aussehen:

added 13 packages, and audited 14 packages in 1s

1 package is looking for funding
  run `npm fund` for details

found 0 vulnerabilities

Bitte beachten Sie, dass Sie Anpassungen an der erstellten package.json vornehmen können, zum Beispiel um die initiale Versionsnummer, die Lizenz oder den Autor anzupassen. Jetzt sind Sie bereit, Ihre kleine Node.js-Testanwendung zu schreiben.

Schreiben einer kleinen Node.js-Anwendung, die die Verbindung zur Datenbank testet

Öffnen Sie einen Code-Editor Ihrer Wahl und erstellen Sie eine Datei namens .env mit folgendem Inhalt (fügen Sie den Verbindungsstring ein, den Sie zuvor gespeichert haben):

MONGODB_URI=mongodb://USERNAME:YOUR-SECRET-PASSWORD@s-f47ac10b-58cc-4372-a567-0e02b2c3d479-0.mongodb.eu01.onstackit.cloud:27017/default?authSource=default&tls=true&authMechanism=SCRAM-SHA-256

Erstellen Sie eine weitere Datei namens test-connection.mjs:

import { MongoClient } from "mongodb";
import dotenv from "dotenv";

dotenv.config();

const uri = process.env.MONGODB_URI;

async function testConnection() {
  if (!uri) {
    console.error("MONGODB_URI nicht gesetzt!");
    return;
  }

  const client = new MongoClient(uri);

  try {
    console.log("Verbindung zu MongoDB Flex wird hergestellt...");

    await client.connect();

    await client.db("admin").command({ ping: 1 });

    console.log("Erfolgreich verbunden!");

    const dbName = client.db().databaseName;
    console.log(`Verbunden mit: ${dbName}`);
  } catch (error) {
    console.error("Fehler beim Verbinden mit MongoDB Flex:", error.message);
  } finally {
    await client.close();
    console.log("Verbindung geschlossen.");
  }
}

testConnection();

Führen Sie nun die Mini-Anwendung mit Ihrem Node.js-Interpreter aus:

node test-connection.mjs

Erstellen einer Node.js-Anwendung, die MongoDB Flex als Backend nutzt

Nachdem Sie alles korrekt eingerichtet haben, können Sie mit der Implementierung der eigentlichen Anwendung beginnen. Zuerst müssen wir weitere Abhängigkeiten installieren:

npm install express

Sie sollten eine Ausgabe ähnlich zu dieser erhalten:

added 67 packages, and audited 81 packages in 2s

15 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

Der Einfachheit halber werden wir in diesem Tutorial nicht die empfohlenen Best Practices für die Node.js-Ordnerstruktur einrichten. Wir empfehlen, diese Best-Practice-Struktur zu befolgen, wenn Sie ein Projekt für den produktiven Einsatz erstellen.

Erstellen Sie eine Datei namens main.mjs:

import express from "express";
import { ObjectId } from "mongodb";

const router = express.Router();

// Helper function for validation
function validateBook(book) {
  const errors = [];
  if (!book.titel || book.titel.trim() === "") {
    errors.push("Titel ist erforderlich");
  }
  if (!book.autor || book.autor.trim() === "") {
    errors.push("Autor ist erforderlich");
  }
  if (book.seiten && (isNaN(book.seiten) || book.seiten <= 0)) {
    errors.push("Seitenzahl muss eine positive Zahl sein");
  }
  return errors;
}

// GET /api/books - get all books
router.get("/", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const books = await db.collection("books").find({}).toArray();

    res.json({
      success: true,
      count: books.length,
      data: books,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler beim Abrufen der Bücher",
      error: error.message,
    });
  }
});

// POST /api/books - Add new book
router.post("/", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const bookData = req.body;

    // Validation
    const errors = validateBook(bookData);
    if (errors.length > 0) {
      return res.status(400).json({
        success: false,
        message: "Validierungsfehler",
        errors: errors,
      });
    }

    // Create book object
    const newBook = {
      titel: bookData.titel.trim(),
      autor: bookData.autor.trim(),
      isbn: bookData.isbn || null,
      seiten: bookData.seiten || null,
      genre: bookData.genre || null,
      erscheinungsjahr: bookData.erscheinungsjahr || null,
      beschreibung: bookData.beschreibung || null,
      erstelltAm: new Date(),
      aktualisiertAm: new Date(),
    };

    const result = await db.collection("books").insertOne(newBook);

    res.status(201).json({
      success: true,
      message: "Buch erfolgreich hinzugefügt",
      data: { _id: result.insertedId, ...newBook },
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler beim Hinzufügen des Buchs",
      error: error.message,
    });
  }
});

export default router;

Erstellen Sie eine Datei namens books.mjs:

import express from "express";

const router = express.Router();

// GET /api/search?q=suchbegriff - search for books
router.get("/", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const { q } = req.query;

    if (!q || q.trim() === "") {
      return res.status(400).json({
        success: false,
        message: "Suchbegriff ist erforderlich",
      });
    }

    const searchRegex = new RegExp(q.trim(), "i"); // case-insensitive search

    const books = await db
      .collection("books")
      .find({
        $or: [
          { titel: searchRegex },
          { autor: searchRegex },
          { genre: searchRegex },
          { beschreibung: searchRegex },
        ],
      })
      .toArray();

    res.json({
      success: true,
      count: books.length,
      searchTerm: q.trim(),
      data: books,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler bei der Suche",
      error: error.message,
    });
  }
});

// GET /api/search/genre/:genre - filter books for genre
router.get("/genre/:genre", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const { genre } = req.params;
    const genreRegex = new RegExp(genre, "i");

    const books = await db.collection("books").find({ genre: genreRegex }).toArray();

    res.json({
      success: true,
      count: books.length,
      genre: genre,
      data: books,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler beim Filtern nach Genre",
      error: error.message,
    });
  }
});

// GET /api/search/autor/:autor - filter books for author
router.get("/autor/:autor", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const { autor } = req.params;
    const autorRegex = new RegExp(autor, "i");

    const books = await db.collection("books").find({ autor: autorRegex }).toArray();

    res.json({
      success: true,
      count: books.length,
      autor: autor,
      data: books,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler beim Filtern nach Autor",
      error: error.message,
    });
  }
});

// GET /api/search/jahr/:jahr - filter books for release date
router.get("/jahr/:jahr", async (req, res) => {
  try {
    const db = req.app.locals.db;
    const { jahr } = req.params;
    const jahrNum = parseInt(jahr);

    if (isNaN(jahrNum)) {
      return res.status(400).json({
        success: false,
        message: "Ungültiges Jahr",
      });
    }

    const books = await db.collection("books").find({ erscheinungsjahr: jahrNum }).toArray();

    res.json({
      success: true,
      count: books.length,
      jahr: jahrNum,
      data: books,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: "Fehler beim Filtern nach Jahr",
      error: error.message,
    });
  }
});

export default router;