Discord ist aus der Online-Kommunikation nicht mehr wegzudenken. Millionen von Nutzern versammeln sich auf unzähligen Servern, um zu spielen, zu lernen, sich auszutauschen oder einfach nur abzuhängen. Für Server-Administratoren ist die Verwaltung und Moderation eine große Aufgabe. Hier kommen Discord Bots ins Spiel: Automatisierte Helfer, die eine Vielzahl von Aufgaben übernehmen können – von der Begrüßung neuer Mitglieder über das Abspielen von Musik bis hin zur umfassenden Moderation. Doch was, wenn du einen Benutzer nicht nur von einem, sondern von allen Servern, auf denen dein Bot aktiv ist, fernhalten möchtest? Genau hierfür benötigst du eine Global-Ban Funktion, gekoppelt mit einer eigenen Datenbank.
In diesem umfassenden Leitfaden lernst du, wie du deinen eigenen Discord Bot von Grund auf programmierst, ihn mit einer Datenbank verbindest und eine leistungsstarke Global-Ban Funktion implementierst. Wir werden uns auf Node.js als Laufzeitumgebung und die populäre Bibliothek discord.js konzentrieren. Für die Datenbank verwenden wir MongoDB in Kombination mit Mongoose, was dir eine flexible und skalierbare Lösung bietet.
1. Voraussetzungen schaffen
Bevor wir in die Tiefen der Bot-Programmierung eintauchen, stellen wir sicher, dass du alles Notwendige zur Hand hast:
- Grundlegende Programmierkenntnisse: Verständnis für JavaScript (Variablen, Funktionen, Schleifen, Objekte).
- Node.js & npm (Node Package Manager): Downloade und installiere die neueste LTS-Version von Node.js von der offiziellen Webseite (nodejs.org). npm wird dabei automatisch mitinstalliert.
- Ein Discord-Konto: Selbstverständlich benötigst du ein Konto, um deinen Bot zu erstellen und zu testen.
- Ein Texteditor oder IDE: Visual Studio Code, Sublime Text oder Atom sind hervorragende Optionen.
2. Deinen Discord Bot einrichten
Der erste Schritt findet nicht im Code, sondern direkt auf der Discord-Entwicklerseite statt. Hier registrieren wir unseren Bot:
- Navigiere zu Discord Developer Portal und logge dich mit deinem Discord-Konto ein.
- Klicke auf „New Application”. Gib deiner Anwendung einen Namen, z.B., „GlobalBanBot” und klicke auf „Create”.
- Auf der linken Seite wähle „Bot”. Klicke dann auf „Add Bot” und bestätige mit „Yes, do it!”.
- Unter dem Abschnitt „BUILD-A-BOT” findest du den Token deines Bots. Klicke auf „Copy” und speichere diesen Token an einem sicheren Ort (aber NIEMALS direkt im Code oder öffentlich teilen!). Dieser Token ist der „Schlüssel” deines Bots.
- Wähle unter „Privileged Gateway Intents” die Optionen „PRESENCE INTENT” und „SERVER MEMBERS INTENT” aus und speichere die Änderungen. Diese sind für die Global-Ban-Funktion entscheidend.
- Um den Bot auf deinen Server einzuladen, gehe zurück zu „General Information”. Kopiere die „Application ID”.
- Ersetze im folgenden URL
YOUR_CLIENT_IDdurch deine kopierte Application ID:https://discord.com/oauth2/authorize?client_id=YOUR_CLIENT_ID&scope=bot&permissions=8
Diepermissions=8gewährt deinem Bot Administrator-Rechte, was für die Global-Ban-Funktion erforderlich ist (insbesondere die Berechtigung zum Bann von Mitgliedern). Achte darauf, dass dein Bot auf jedem Server, auf dem er Mitglieder bannen soll, diese Berechtigung hat. - Füge den generierten URL in deinen Browser ein, wähle den Server aus, auf den du den Bot einladen möchtest, und klicke auf „Autorisieren”.
3. Die Entwicklungsumgebung einrichten
Jetzt ist es Zeit, deinen lokalen Projektordner vorzubereiten:
- Erstelle einen neuen Ordner für dein Projekt, z.B.
discord-global-ban-bot. - Öffne ein Terminal oder die Kommandozeile und navigiere in diesen Ordner.
- Initialisiere ein neues Node.js-Projekt:
npm init -y. Dies erstellt einepackage.json-Datei. - Installieren die notwendigen Pakete:
- discord.js: Die Hauptbibliothek für die Interaktion mit der Discord-API.
npm install [email protected](Achte auf die Version, da sich APIs ändern können.) - Mongoose: Ein Object Data Modeling (ODM) Tool für MongoDB, das die Interaktion mit der Datenbank vereinfacht.
npm install mongoose - dotenv: Um sensible Daten wie deinen Bot-Token sicher zu verwalten.
npm install dotenv
- discord.js: Die Hauptbibliothek für die Interaktion mit der Discord-API.
- Erstelle eine neue Datei namens
.envim Hauptverzeichnis deines Projekts. Trage dort deinen Bot-Token ein:TOKEN=DEIN_BOT_TOKEN_HIER - Erstelle eine weitere Datei namens
index.js(odermain.js) im selben Verzeichnis. Dies wird die Hauptdatei deines Bots.
4. Das Grundgerüst des Bots
Lass uns den grundlegenden Code für deinen Bot schreiben:
require('dotenv').config(); // Lädt Umgebungsvariablen aus .env
const { Client, GatewayIntentBits, Partials, Collection } = require('discord.js');
const mongoose = require('mongoose');
// Erstelle eine neue Discord-Client-Instanz
const client = new Client({
intents: [
GatewayIntentBits.Guilds,
GatewayIntentBits.GuildMembers, // Wichtig für Global-Ban
GatewayIntentBits.GuildMessages,
GatewayIntentBits.MessageContent, // Für Nachrichteninhalte
GatewayIntentBits.DirectMessages,
GatewayIntentBits.GuildPresences // Wichtig für Global-Ban (falls du Präsenzen überprüfen willst)
],
partials: [Partials.Channel, Partials.Message, Partials.GuildMember, Partials.User]
});
// Befehlssammlung initialisieren
client.commands = new Collection();
// Bot ist bereit
client.once('ready', () => {
console.log(`Bot ist online als ${client.user.tag}!`);
client.user.setActivity('nach gebannten Nutzern', { type: 'WATCHING' });
});
// Datenbankverbindung wird später hier eingerichtet
// Login des Bots
client.login(process.env.TOKEN);
Dieses Grundgerüst importiert die notwendigen Module, erstellt eine Client-Instanz mit den benötigten Intents (welche Events der Bot empfangen soll) und loggt sich ein. Die GatewayIntentBits.GuildMembers und GatewayIntentBits.GuildPresences sind entscheidend für die spätere Global-Ban-Funktion.
5. Datenbank-Integration: MongoDB mit Mongoose
Für unsere Global-Ban-Funktion benötigen wir eine persistente Speicherung der gebannten Benutzer. MongoDB ist eine NoSQL-Datenbank, die sich hervorragend für solche Zwecke eignet. Mongoose erleichtert die Interaktion mit MongoDB erheblich.
5.1 MongoDB einrichten
Du hast zwei Hauptoptionen für MongoDB:
- Lokal installieren: Lade MongoDB Community Server von der offiziellen Webseite herunter und installiere es auf deinem Computer.
- MongoDB Atlas (Cloud): Dies ist die empfohlene Methode für die Bereitstellung, da sie einfach einzurichten ist und Skalierbarkeit bietet. Erstelle einen kostenlosen „M0 Shared Cluster” auf MongoDB Atlas. Folge den Anweisungen, um eine Datenbankbenutzerin und eine IP-Whitelist zu erstellen (für Entwicklung kannst du
0.0.0.0/0für alle IPs zulassen, für Produktion aber nur spezifische IPs). Du erhältst dann einen Verbindungs-URI.
Deinen MongoDB-Verbindungs-URI fügst du ebenfalls in die .env-Datei ein:
TOKEN=DEIN_BOT_TOKEN_HIER
MONGO_URI=mongodb+srv://<username>:<password>@<cluster-url>/<dbname>?retryWrites=true&w=majority
5.2 Verbindung mit Mongoose herstellen
Füge diesen Code zu deiner index.js-Datei hinzu, am besten direkt nach der Bot-Initialisierung:
// ... (bestehender Code) ...
// Verbindung zur MongoDB-Datenbank herstellen
mongoose.connect(process.env.MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true
}).then(() => {
console.log('Erfolgreich mit der Datenbank verbunden!');
}).catch(err => {
console.error('Datenbankverbindungsfehler:', err);
});
// ... (bestehender Code) ...
5.3 Schema und Modell für Global Bans definieren
Wir benötigen ein Schema, um die Struktur unserer Global-Ban-Dokumente festzulegen. Erstelle einen neuen Ordner models und darin eine Datei GlobalBan.js:
// models/GlobalBan.js
const mongoose = require('mongoose');
const globalBanSchema = new mongoose.Schema({
userId: { type: String, required: true, unique: true }, // Die ID des gebannten Benutzers
moderatorId: { type: String, required: true }, // Die ID des Moderators, der den Ban verhängt hat
reason: { type: String, required: true }, // Der Grund für den Ban
timestamp: { type: Date, default: Date.now } // Wann der Ban verhängt wurde
});
module.exports = mongoose.model('GlobalBan', globalBanSchema);
Importiere dieses Modell nun in deine index.js:
// ...
const GlobalBan = require('./models/GlobalBan');
// ...
6. Die Global-Ban-Funktion implementieren
Das Herzstück unseres Bots ist die Logik, die Benutzer global bannt und prüft. Es ist wichtig zu verstehen: Ein „globaler Ban” bedeutet hier, dass der Bot einen Benutzer von allen Servern, auf denen der Bot Mitglied ist, ausschließt oder entfernt. Discord selbst bietet keine systemweite Global-Ban-API.
6.1 Der `!globalban` Befehl
Dieser Befehl wird verwendet, um einen Benutzer in unsere Global-Ban-Datenbank einzutragen und ihn von allen zugänglichen Servern zu bannen. Füge diesen Code zu deiner index.js hinzu, z.B. unterhalb des client.once('ready', ...) Blocks:
client.on('messageCreate', async message => {
// Ignoriere Nachrichten von Bots und Direktnachrichten (optional, für Commands in Guilds)
if (message.author.bot || !message.guild) return;
const prefix = '!'; // Dein gewünschtes Präfix
if (!message.content.startsWith(prefix)) return;
const args = message.content.slice(prefix.length).trim().split(/ +/);
const command = args.shift().toLowerCase();
// Berechtigungsprüfung für den Global-Ban Befehl
// Nur Benutzer mit der Berechtigung zum Bann von Mitgliedern dürfen diesen Befehl nutzen.
if (!message.member.permissions.has('BAN_MEMBERS')) {
return message.reply('Du hast nicht die notwendigen Berechtigungen, um diesen Befehl auszuführen.');
}
if (command === 'globalban') {
if (args.length < 2) {
return message.reply('Bitte verwende: `!globalban `');
}
const targetUserId = args[0];
const reason = args.slice(1).join(' ');
// Validiere die User ID (optional, aber empfohlen)
if (isNaN(targetUserId) || targetUserId.length !== 18) { // Discord User IDs sind 18-stellig
return message.reply('Ungültige Benutzer-ID. Eine Discord User ID ist eine 18-stellige Zahl.');
}
try {
// Prüfen, ob der Benutzer bereits global gebannt ist
const existingBan = await GlobalBan.findOne({ userId: targetUserId });
if (existingBan) {
return message.reply(`Benutzer ${targetUserId} ist bereits global gebannt. Grund: "${existingBan.reason}"`);
}
// Neuen Global Ban in der Datenbank speichern
const newGlobalBan = new GlobalBan({
userId: targetUserId,
moderatorId: message.author.id,
reason: reason
});
await newGlobalBan.save();
console.log(`Benutzer ${targetUserId} global gebannt (DB Eintrag).`);
let bannedGuilds = 0;
// Versuche, den Benutzer von allen Gilden zu bannen, in denen der Bot ist
for (const guild of client.guilds.cache.values()) {
try {
const memberToBan = await guild.members.fetch(targetUserId).catch(() => null);
if (memberToBan) { // Wenn der Benutzer auf diesem Server ist
// Überprüfe, ob der Bot die Berechtigung hat, diesen Benutzer zu bannen
// und ob der zu bannende Benutzer nicht den Bot selbst oder einen Administrator ist.
if (guild.members.me.permissions.has('BAN_MEMBERS') &&
memberToBan.id !== client.user.id && // Nicht den Bot bannen
!memberToBan.permissions.has('ADMINISTRATOR')) // Keine Administratoren bannen (optional)
{
await guild.members.ban(targetUserId, { reason: `Globaler Ban: ${reason}` });
bannedGuilds++;
console.log(`Gebannt von ${guild.name}`);
} else {
console.log(`Kann ${targetUserId} nicht von ${guild.name} bannen: Fehlende Berechtigungen oder Admin/Bot.`);
}
}
} catch (banError) {
console.error(`Fehler beim Bannen von ${targetUserId} in Gilde ${guild.name}:`, banError.message);
}
}
message.reply(`Benutzer ${targetUserId} wurde global gebannt und von ${bannedGuilds} Servern entfernt. Grund: "${reason}"`);
} catch (error) {
console.error('Fehler beim Global-Ban:', error);
message.reply('Es ist ein Fehler beim Versuch des Global-Bans aufgetreten.');
}
}
});
6.2 Automatische Prüfung bei Beitritt (`guildMemberAdd`)
Diese Funktion ist entscheidend für einen effektiven Global-Ban. Jedes Mal, wenn ein neuer Benutzer einem Server beitritt, auf dem dein Bot ist, prüft der Bot, ob dieser Benutzer in der Global-Ban-Datenbank steht. Wenn ja, wird er automatisch gekickt oder gebannt. Füge diesen Listener zu deiner index.js hinzu:
client.on('guildMemberAdd', async member => {
try {
const bannedUser = await GlobalBan.findOne({ userId: member.id });
if (bannedUser) {
// Optional: Sende eine private Nachricht an den gebannten Benutzer
try {
await member.send(`Du wurdest von "${member.guild.name}" entfernt, da du global gebannt bist. Grund: "${bannedUser.reason}"`);
} catch (dmError) {
console.warn(`Konnte keine DM an gebannten Benutzer ${member.id} senden:`, dmError.message);
}
// Prüfe, ob der Bot die Berechtigung zum Bannen hat
if (member.guild.members.me.permissions.has('BAN_MEMBERS')) {
await member.ban({ reason: `Globaler Ban: ${bannedUser.reason}` });
console.log(`Benutzer ${member.id} (global gebannt) von ${member.guild.name} gebannt.`);
// Optional: Sende eine Nachricht in einen Moderations-Channel
// const modChannel = member.guild.channels.cache.find(ch => ch.name === 'moderation-logs');
// if (modChannel) {
// modChannel.send(`:hammer: Global gebannter Benutzer **${member.user.tag}** (${member.id}) wurde automatisch von diesem Server gebannt. Grund: `${bannedUser.reason}``);
// }
} else {
console.log(`Bot hat keine BAN_MEMBERS Berechtigung in ${member.guild.name}, konnte ${member.id} nicht bannen.`);
}
}
} catch (error) {
console.error('Fehler bei guildMemberAdd Prüfung:', error);
}
});
7. Die Global-Unban-Funktion
Ein Global-Ban sollte auch rückgängig gemacht werden können. Der !globalunban Befehl entfernt den Eintrag aus der Datenbank.
// ... (innerhalb des messageCreate Listeners) ...
if (command === 'globalunban') {
if (args.length < 1) {
return message.reply('Bitte verwende: `!globalunban `');
}
const targetUserId = args[0];
if (isNaN(targetUserId) || targetUserId.length !== 18) {
return message.reply('Ungültige Benutzer-ID. Eine Discord User ID ist eine 18-stellige Zahl.');
}
try {
const result = await GlobalBan.deleteOne({ userId: targetUserId });
if (result.deletedCount > 0) {
message.reply(`Benutzer ${targetUserId} wurde erfolgreich aus der Global-Ban-Datenbank entfernt.`);
console.log(`Benutzer ${targetUserId} global unbanned.`);
} else {
message.reply(`Benutzer ${targetUserId} ist nicht in der Global-Ban-Datenbank.`);
}
} catch (error) {
console.error('Fehler beim Global-Unban:', error);
message.reply('Es ist ein Fehler beim Versuch des Global-Unbans aufgetreten.');
}
}
});
8. Sicherheit und Best Practices
Die Entwicklung eines Bots erfordert auch ein Bewusstsein für Sicherheit und gute Praktiken:
- Bot-Token sicher halten: Dein Bot-Token ist der Schlüssel zu deinem Bot. Teile ihn niemals und verwende immer Umgebungsvariablen (wie mit
dotenvgezeigt). - Berechtigungen: Erteile deinem Bot nur die absolut notwendigen Berechtigungen. Für einen Global-Ban-Bot sind
BAN_MEMBERSund die oben genannten Intents unerlässlich. - Fehlerbehandlung: Verwende
try-catch-Blöcke, um potenzielle Fehler abzufangen und deinen Bot stabil zu halten. - Rate Limits: Discord hat API-Rate-Limits. discord.js handhabt dies größtenteils automatisch, aber bei sehr schnellen, massiven Operationen (wie dem Bann vieler Benutzer auf einmal) kann es zu Problemen kommen. Sei dir dessen bewusst.
- Datenschutz (DSGVO): Wenn du Benutzerdaten speicherst, informiere dich über die Datenschutzbestimmungen und stelle sicher, dass du diese einhältst.
9. Bot starten und testen
Um deinen Bot zu starten, öffne dein Terminal im Projektordner und führe aus:
node index.js
Dein Bot sollte sich nun in Discord anmelden und in der Konsole eine Bestätigung ausgeben. Teste die Befehle !globalban und !globalunban auf deinem Testserver mit einem zweiten Account.
10. Bereitstellung (Deployment)
Dein Bot läuft derzeit nur, solange dein Computer an ist und das Skript läuft. Für einen 24/7-Betrieb musst du ihn auf einem Server hosten. Beliebte Optionen sind:
- VPS (Virtual Private Server): Wie Vultr, DigitalOcean oder AWS EC2. Du hast volle Kontrolle über die Umgebung.
- PaaS (Platform as a Service): Wie Heroku oder Render. Einfacher einzurichten, aber möglicherweise mit Einschränkungen bei kostenlosen Plänen.
- Glitch: Eine schnelle und einfache Möglichkeit, kleine Bots zu hosten, ideal für Prototypen.
Unabhängig von der Plattform musst du deine .env-Variablen dort als Umgebungsvariablen konfigurieren.
Fazit und Ausblick
Herzlichen Glückwunsch! Du hast erfolgreich einen leistungsstarken Discord Bot mit einer Global-Ban-Funktion und einer eigenen Datenbank programmiert. Du hast gelernt, wie man mit der Discord API über discord.js interagiert, wie man eine NoSQL-Datenbank (MongoDB) mit Mongoose einbindet und wie man persistente Moderationswerkzeuge erstellt.
Diese Global-Ban-Funktion ist ein mächtiges Werkzeug für Server-Admins, um unerwünschte Nutzer über mehrere Server hinweg effektiv zu verwalten. Denke jedoch immer an die Verantwortung, die mit solchen Tools einhergeht.
Von hier aus kannst du deinen Bot erweitern: Füge weitere Moderationsbefehle hinzu (Warnsystem, Mute), implementiere ein Log-System für alle Aktionen, erstelle ein Web-Dashboard für die Verwaltung deiner Bans oder integriere weitere APIs, um deinen Bot noch vielseitiger zu machen. Die Möglichkeiten sind endlos!