NodeJS: Datenbank mit MongoDB erstellen – Anleitung & Beispiele

In diesem Tutorial lernst du, wie du schnell und einfach eine Datenbank in NodeJS mit MongoDB und Mongoose erstellst. Außerdem erfährst du, wie du eine Datenbank mit Hilfe von Mongoose lokal einrichtest und eine Datenbankstruktur aufbaust, mit welcher du Daten in deine Datenbank speichern und wieder auslesen kannst.

Voraussetzungen 🤓

Bevor du loslegst, prüfe zunächst ob du die nachfolgenden Voraussetzungen erfüllst:

• Du hast schon mal einen NodeJS Webserver aufgesetzt und kannst mit dem Terminal umgehen ✔️
• Du hast ein Verständnis für REST APIs und Routing ️️️✔️

Ja? Dann kannst du hier gerne weitermachen. Nein? Kein Problem, folge einfach den verlinkten Beiträgen, arbeite sie durch und komme später wieder hier her zurück.

MongoDB einrichten 🚧

Lade dir zunächst MongoDB herunter. Achte dabei, dass du die kostenlose Community-Version verwendest. Entpacke nach dem Download den komprimierten Ordner.

Wichtig zu wissen: Der MongoDB Server hat keinen selbstausführender Klick-Installer. Das bedeutet, dass du später mit einem Terminal-Befehl den Server startest. Hierfür brauchst du die Dateien aus dem entpackten Ordner.

Erstelle nun zwei Ordner in deinem Root-Verzeichnis (Ausgangsverzeichnis). In meinem Fall ist das 'kermin'.

1. mongodb
2. mongodb-data

Ok, jetzt musst du nur noch die Dateien aus dem entpackten Ordner in deinen neu-erstellten 'mongodb'-Ordner kopieren oder "rüberziehen".

Das wars schon! 🎉

Zur Erklärung: Die Dateien im 'mongodb'-Ordner sind notwendig um den Datenbank-Server zu starten, während der 'mongodb-data'-Ordner als Speicherort für die eigentlichen Datenbank-Daten dient.

Ok, lass uns jetzt den MongoDB Server starten! 🚀

Dafür öffnest du im Hintergrund ein Terminal-Fenster und gibst folgenden Befehl ein:

 /Users/kermin/mongodb/bin/mongod --dbpath=/Users/kermin/mongodb-data

👉 Achte dabei, dass du 'kermin' im Pfad jeweils durch dein eigenen Usernamen austauschst.

Falls du diesen Matrix-Code siehst, herzlichen Glückwunsch! Du hast erfolgreich deinen MongoDB Server eingerichtet. 🥳

Wichtig: Der Server läuft nun im Hintergrund und ist bereit. Du solltest darauf achten, dass er immer aktiv ist wenn du mit der Datenbank arbeiten möchtest. Speichere dir am beten den Befehl irgendwo ab – du wirst ihn ganz sicher wieder brauchen. 🙂

Verbindung zum MongoDB Server aufbauen

Wie eingangs bereits erwähnt, solltest du unbedingt verstehen wie du einen Webserver mit NodeJS aufbaust, bevor du hier weitermachst. In den nächsten Schritten gehe ich deshalb nicht tiefer auf die Besonderheiten von Express und NodeJS ein.

Du bist ready? 💪 Dann lass' uns starten!

Erstelle zunächst einen 'db' Ordner in deinem 'src' Verzeichnis. Dort erstellst und legst du die 'connect.js' Datei ab.

Der einfachste Weg um einen Verbindung mit dem Datenbank-Server aufzubauen ist mit mongoose. 👇

npm install mongoose

Jetzt kannst du den Code in deine 'connect.js' 1:1 übernehmen:

const mongoose = require('mongoose');

mongoose.connect("mongodb://127.0.0.1:27017/tutorialdb", {
    useNewUrlParser: true,
    useUnifiedTopology: true
})
    .then(() => console.log('MongoDB Connected'))
    .catch((err) => console.log(err))

Damit die Verbindung aufgebaut werden kann, musst du jetzt nur noch in deiner 'index.js' auf die 'connect.js' verweisen, damit der Code ausgeführt werden kann. Achte darauf, dass du in der 'index.js' den Import ausführst, bevor du auf die Datenbank zugreifst.

require('./src/db/connect.js')

Wenn du jetzt deinen Webserver neu startest (CTRL + C = Server stoppen, mit node index.js wieder starten), sollte er sich mit deiner Datenbank verbinden.

Cool! 😎 Du bist nun mit deiner Datenbank über deinen Webserver verbunden. Im nächsten Schritt schauen wir uns an, wie du ein simples Datenbankmodell mit Hilfe von Mongoose erstellst.

Datenbankmodell mit Mongoose erstellen

Bevor du Daten in die Datenbank speichern kannst, musst du zunächst ein Schema definieren, welches beschreibt in welcher Form deine Daten gespeichert werden sollen. Du baust also für deine Daten eine Struktur – sogenannte Models.

Für das Beispiel-Model dass du erstellen wirst, wählen wir folgendes Szenario: Angenommen du möchtest spezifische Nutzer-Daten für eine fiktive App speichern:

1. User-Name
2. User-Email
3. User-Passwort
4. User-Alter

Alle vier Informationen sind inhaltlich dem Nutzer zuzuweisen, und werden deshalb in ein User-Model zusammengefasst. Schauen wir uns das in der Praxis an. 👇

Erstelle zunächst einen neuen Ordner 'models' in 'src'. In den 'models' Ordner erstellst du wiederum eine neue Datei, die 'user.js'. Die Ordnerstruktur sollte bei dir in dieser Form aufgebaut sein:

src > models > user.js

Der einfachste und schnellste Weg ein in MongoDB zu Modellieren ist Mongoose. Alles beginnt mit einem Schema. Füge folgenden Code in deine 'user.js' ein:

const mongoose = require('mongoose')

const userSchema = mongoose.Schema({
    name: {
        type: String,
        required: true
    },
    email: {
        type: String,
        required: true,
        lowsercase: true,
        unique: true
    },
    password: {
        type: String,
        required: true,
        trim: true,
        minlength: 8
    },
    age: {
        type: String
    }
})

const User = mongoose.model('User', userSchema)

module.exports = User

Richte deinen Fokus zunächst auf das userSchema. Du wirst feststellen, dass du mit einfacher JSON-Schreibweise dein Model sehr schnell und einfach erweitern kannst. Sicher ist dir auch nicht entgangen, dass jedes Attribut weitere Attribute und Werte enthält, wie z.B. den type. Der Type ist wichtig und notwendig, damit MongoDB weiß welcher Datentyp genutzt werden soll um deine Informationen zu speichern. In unserem Beispiel sind es ausschließlich Strings.

Es gibt noch viele weitere Schema-Types (Attribute) die jedoch optional sind. Mit 'required' kannst du z.B. festlegen, dass Password oder die E-Mail Pflichtfelder sind – ohne sie wird somit kein Datenbankeintrag erzeugt. An dieser Stelle gehe ich nicht auf alle Types tiefer ein, aber empfehle dir dich mit ihnen zu beschäftigen. Erklärungen zu den im Beispiel verwendeten Types und darüber hinaus findest du in dieser Dokumentation.

API Endpunkt erstellen

Nachdem du dein Datenbankmodell erstellt hast, geht es nun darum, eine Schnittstelle zu der eigentlichen Datenbank bzw. deinem Datenbank-Server zu bauen. Diese Schnittstelle soll die User-Daten (Name, E-Mail, Passwort, Alter) empfangen und in der Datenbank speichern.

Hierfür startest du mit einer Route. Falls du nachschlagen möchtest wie eine Route aufgebaut ist und wie du sie am besten im Projekt strukturierst, dann empfehle ich dir diesen Beitrag. Lese oder arbeite ihn durch und komme gerne wieder hier her zurück um weiterzumachen. 🙂

Route anlegen & Model importieren

Erstelle einen neuen Ordner mit dem Namen 'routers' in deinem 'src' Verzeichnis. Darin erstellst eine neue Datei 'user.js'. Die Ordnerstruktur sieht dann so aus:

src > routers > user.js

Dir ist vielleicht aufgefallen, dass die Dateinamen für Model und Route die Gleichen sind. Das ist Absicht und soll dir bei der Übersicht und Zuordnung von Model und Route später helfen.

Wir legen fest, dass die Route später via '/user' erreichbar sein soll. Außerdem musst du noch das User-Model importieren. In der 'user.js' deiner Route sieht das dann so in etwa aus:

const express = require('express')
const router = new express.Router()
const User = require('../models/user')

router.post('/user', async function (req, res) {
    // tbd
})

module.exports = router

Wichtig: bevor du weitermachst, vergesse auf keinen Fall deine Route in die 'index.js' zu importieren, sonst weiß deine App bzw. dein Backend nicht, dass es sie gibt. 😉

Falls du nicht mehr ganz sicher bist wie das genau ging – kein Problem. Schaue dir in Ruhe die finale index.js in meiner Github Repo an.

Route Controller erstellen

Nachdem die Vorarbeit getan ist, geht es jetzt ans Eingemachte! Im Route Controller sorgst du dafür, dass die Daten von einem Client kommend, an deine MongoDB Datenbank weitergeleitet und gespeichert werden.

Dazu erzeugst du zunächst eine neue Instanz deines Models mit den Daten aus der Client-Anfrage (Request):

router.post('/user', async function (req, res) {
    const user = new User(req.body)
.
.
.

Über die Variable user hast du nun Zugriff auf die save()-Funktion und kannst damit die Daten in die Datenbank speichern. Bevor du das machst, solltest du allerdings noch zwei Dinge beachten.

1. Der Speichervorgang wird asynchron durchgeführt und du sollest await für einen reibungslosen Ablauf nutzen
2. Es besteht die Gefahr, dass es beim Speichervorgang zu JS-Fehlern kommt. Hierfür empfiehlt es sich einen try-catch-Block zu verwenden um einen möglichen Server-Absturz zu verhindern

router.post('/user', async function (req, res) {
    const user = new User(req.body)
    try {
        await user.save()
        res.send('Eintrag erfolgreich gespeichert!')
    } catch(e) {
        res.status(500).send(e)
    }
})

Das ist alles! Dein Endpunkt ist jetzt bereit für einen Testlauf!

Endpunkt testen 🧪🤓

Der einfachste Weg deinen Endpunkt ohne zusätzlichen Coding-Aufwand zu testen ist Postman. In Postman gibst du das Protokoll, die URL sowie die Route ein:

http://localhost:3001/user

Über den Body-Reiter kannst du in Postman deinen Daten-Request einfügen. Achte darauf, dass du die Daten im "raw"-Format sowie als JSON übermittelst. Vergesse nicht die POST-Method in Postman auszuwählen, da deine Route eine Post-Method erwartet.

Webserver neu zu starten und auf "Send" klicken.

{
    "name": "Kermin",
    "email": "me@kermin.de",
    "password": "pass123456789",
    "age": "28"
}

Wenn alles geklappt hat, solltest du in Postman (weiter unten unter 'Body') folgende Server-Antwort bekommen:

Herzlichen Glückwunsch! Dein Eintrag wurde (hoffentlich) in der Datenbank gespeichert! 🎉

MongoDB GUI für lokale Datenbanken

Du willst dich vermutlich nicht blind drauf verlassen müssen, dass deine Einträge in der Datenbank gespeichert wurden. Sicherlich bist du auch nicht der Operator 😎 und kannst den Matrix-Code der Datenbank entschlüsseln 👇

Auch wenn sich Hinweise in dem Code finden, dass der Speichervorgang erfolgreich war, gibt es einen viel besseren Weg die in die Datenbank einzusehen: Ein Tool mit grafischer Benutzeroberfläche: Robo3T. Lade dir die "Hobby"-Version von Robo3T herunter und installiere sie auf deinem Rechner.

Nach dem Start erstellst du eine neue Verbindung über folgenden Button:

Das darauf folgende Fenster kannst du einfach mit "save" bestätigen und dabei alle vorkonfigurierten Einstellungen unverändert lassen:

Nachdem du eine neue Verbindung erstellt hast, kannst du sie nun direkt testen.

Klicke auf "connect". Du baust eine Verbindung zu deiner lokalen Datenbank auf. Navigiere dich nun links zu deiner Datenbank "tutorialdb" und öffne die Unterverzeichnisse.

Links siehst du die Collections mit dem Eintrag 'users'. Wenn du einen Doppelklick auf users ausführst, öffnen sich rechts alle enthalten Documents (Einträge). In deinem Fall solltest du einen Eintrag sehen mit einer ObjectID. MongoDB generiert nämlich automatisch für jedes Objekt eine eigene einzigartige ID. Wenn alles geklappt hat, solltest du deine Daten einsehen können, die du eben via Postman und Route (API Endpunkt) an deine Datenbank übermittelt hast.

Datenbank auslesen 💾

Nachdem du nun in der Lage bist Daten in deine lokale Datenbank zu speichern, möchtest du sie sicher auch wieder auslesen können.

In diesem Beispiel wollen wir einen User über seine E-Mail-Adresse in der Datenbank finden und an den Client zurückgeben lassen.

Dazu gehst du in deine 'user.js'-Routes-Datei und erweiterst sie um folgenden Code:

router.post('/user/me', async function (req, res) {
    const user = await User.findOne({ email: req.body.email })
    if (user) {
        res.send(user)
    } else {
        res.status(404).send('Nutzer nicht gefunden')
    }
})

Über das User-Model kannst du mit der Funktion findOne() nach einem Eintrag suchen lassen. Als Parameter übergibst du ein JSON-Objekt mit der E-Mail-Adresse als Key-Value Paar. Sofern ein User bzw. ein Eintrag gefunden wurde, wird das ganze User-Objekt an den Client zurückgeschickt, andernfalls wird eine entsprechende Meldung mit dem Fehler-Code 404 zurückgegeben.

Datenbankabruf testen

Es wird wieder Zeit für einen Testlauf. Passe deine Client-Anfrage in Postman an und achte darauf, dass du eine E-Mail-Adresse verwendest die auch in der Datenbank enthalten ist:

Wenn du alles richtig gemacht hast, solltest du den entsprechenden User-Eintrag aus der Datenbank in Postman sehen.

Herzlichen Glückwunsch! Du hast erfolgreich Daten in deine Datenbank gespeichert und wieder abgerufen. 🎉🥳

Übrigens, den vollständigen Code zu diesem Tutorial findest du in diesem Github-Repo.

Fazit & Ausblick

Mit MongoDB, Mongoose und einem NodeJS-Express-Webserver, kannst du super schnell und einfach eine Datenbank aufsetzen. Mit Models legst du die Struktur deiner Datenbank fest, speicherst und rufst Daten über die Routes deines API-Endpunktes ab.

Wie geht es weiter?

Um deine MongoDB-Skills zu erweitern, bietet es sich an z.B. das bestehende Model zu erweitern und damit zu experimentieren. Außerdem könntest du deine Client-Anfragen in ein Frontend integrieren und von dort aus z.B. einen User-Eintrag erzeugen und die Daten auslesen.

Hat dir dieser Beitrag gefallen? Dann teile ihn, damit hilfst du mir diesen Blog bekannter zu machen. Falls du Fragen hast schreibe mir auf Twitter @kermsch. 🙂