E-Mails selbst zu hosten bedeutet:

• volle Kontrolle
• keine Cloud-Abhängigkeit
• maximale Privatsphäre

Aber: Es erfordert saubere Konfiguration.

Voraussetzungen

• Root-Server oder VPS
• Eigene Domain
• Port 25, 587, 993 offen
• Reverse DNS korrekt gesetzt

Schritt 1 – Postfix installieren

sudo apt update

sudo apt install postfix -y

Wähle:

• Internet Site
• System Mail Name = deine-domain.de

Schritt 2 – Dovecot installieren

sudo apt install dovecot-imapd dovecot-pop3d -y

Schritt 3 – Mailbox-Format konfigurieren

sudo nano /etc/dovecot/conf.d/10-mail.conf

Setze:

mail_location = maildir:~/Maildir

Schritt 4 – SSL aktivieren

sudo nano /etc/dovecot/conf.d/10-ssl.conf

ssl = required

Schritt 5 – Benutzer anlegen

adduser mailuser

Mailbox wird automatisch erstellt.

Jetzt wird getestet

telnet localhost 25

Oder Mailclient (Thunderbird):

• IMAP: 993
• SMTP: 587
• SSL/TLS aktiv

Wichtige Zusatzpunkte

• SPF, DKIM, DMARC setzen
• Fail2Ban aktivieren
• Regelmäßige Log-Kontrolle

Fazit

Ein eigener Mailserver ist kein Klickprojekt –
aber mit Postfix & Dovecot bekommst du eine stabile, professionelle Lösung.

Der Beitrag Mailserver selber hosten (Postfix + Dovecot) erschien zuerst auf Root Level.

SSH (Secure Shell) ist das Herzstück jedes Servers.
Über diesen Zugang steuerst du dein System, installierst Pakete, verwaltest Dateien und führst Updates aus.
Doch genau dieser Zugang ist auch eines der beliebtesten Ziele für Angreifer.

Sobald ein Server öffentlich im Internet steht, scannen Bots ununterbrochen IP-Adressen auf offene Ports – besonders auf Port 22, dem Standardport für SSH.
Mit den richtigen Einstellungen machst du ihnen das Leben extrem schwer – und schützt deinen Server dauerhaft.

Schritt 1: Den Standardport ändern

Öffne die SSH-Konfigurationsdatei:

sudo nano /etc/ssh/sshd_config

Suche die Zeile:

#Port 22

Entferne das # und ändere den Wert, z. B. auf:

Port 2222

Warum?
Angreifer scannen meist nur Port 22. Wenn du SSH auf einen anderen Port legst, „verschwindest“ du für viele automatisierte Attacken.

Starte den SSH-Dienst neu:

sudo systemctl restart ssh

Schritt 2: Root-Login deaktivieren

In derselben Datei:

PermitRootLogin no

Dadurch kann sich niemand mehr direkt als Root anmelden.
Erstelle stattdessen einen Benutzer mit Sudo-Rechten:

adduser admin
usermod -aG sudo admin

Anmelden kannst du dich dann mit:

ssh admin@deine-ip -p 2222

Schritt 3: SSH-Keys statt Passwort

Erstelle auf deinem lokalen Rechner ein Schlüsselpaar:

ssh-keygen -t ed25519

Der Public Key wird in ~/.ssh/id_ed25519.pub gespeichert.
Kopiere ihn auf den Server:

ssh-copy-id -p 2222 admin@deine-ip

Dann in der Konfiguration:

PasswordAuthentication no

Jetzt funktioniert nur noch der private Schlüssel – kein Passwort.

Schritt 4: Firewall anpassen

Falls du UFW nutzt:

sudo ufw allow 2222/tcp
sudo ufw enable

So stellst du sicher, dass dein neuer SSH-Port nicht blockiert wird.

Bonus: Extra-Sicherheit mit Fail2Ban

Schaue dir hier für gerne unser anderes Tutorial an! Dieses findest du hier.

Fazit

Mit diesen vier Schritten ist dein SSH-Zugang sicher, schnell und stabil.
Kein Port 22 mehr, kein Root-Login, kein Passwort – nur du mit deinem Schlüssel.
Damit eliminierst du 95 % aller Standardangriffe.

Der Beitrag SSH-Sicherheit richtig konfigurieren – So schützt du dein Tor zum Server erschien zuerst auf Root Level.

Sobald ein Server online ist, tauchen Bots auf, die zufällig Benutzernamen und Passwörter ausprobieren.
Fail2Ban sperrt diese automatisch, bevor Schaden entsteht.

Schritt 1 – Installation

sudo apt update
sudo apt install fail2ban -y

Schritt 2 – Konfiguration anlegen

Als erstes kopieren wir die Standarddatei:

sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

Schritt 3 – SSH-Schutz aktivieren

[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 5
bantime = 600

Nach 5 falschen Versuchen wird die IP 10 Minuten gesperrt.

Schritt 4 – Dienst starten und testen

sudo systemctl enable --now fail2ban
sudo fail2ban-client status sshd

Tipps

• Werte anpassen (maxretry, bantime)
• Log-Pfad prüfen, wenn du andere Dienste schützen willst (z. B. nginx, postfix)

Fazit

Fail2Ban ist leicht zu installieren, arbeitet still im Hintergrund und blockiert automatisch böse Bots.
Ein kleines Tool mit großer Wirkung.

Der Beitrag Fail2Ban konfigurieren – Schutz vor Brute-Force-Angriffen erschien zuerst auf Root Level.

Eine Firewall ist deine erste Verteidigungslinie.
Mit UFW (Uncomplicated Firewall) hast du unter Linux ein einfaches, aber mächtiges Tool.

Schritt 1: Installation

sudo apt update
sudo apt install ufw -y

Schritt 2: Standardregeln setzen

Nur gewünschte Verbindungen erlauben:

sudo ufw default deny incoming
sudo ufw default allow outgoing

Damit blockierst du alles Eingehende, lässt aber alle ausgehenden Verbindungen zu.

Schritt 3: SSH und Web freigeben

sudo ufw allow 22/tcp
sudo ufw allow 80,443/tcp

Tipp: Wenn du SSH-Port geändert hast, gib den neuen Port frei (z. B. 2222/tcp).

Schritt 4: Aktivieren & Status prüfen

sudo ufw enable
sudo ufw status verbose

UFW listet alle aktiven Regeln auf.

Typische Fehler

• Nicht aktiviert: Firewall gesetzt, aber nicht gestartet
• SSH ausgesperrt: Aktiviere UFW erst nach Freigabe deines Ports!

Fazit

UFW ist simpel, übersichtlich und ideal für den Einstieg in Server-Security.
Ein paar Regeln – und dein System ist sofort geschützt.

Der Beitrag UFW Firewall richtig einrichten – Schutz mit einfachen Befehlen erschien zuerst auf Root Level.

Jedes Mal, wenn du eine Website aufrufst, passiert im Hintergrund etwas Entscheidendes:
Dein Rechner muss wissen, welcher Server sich hinter dem Domainnamen verbirgt.

Genau hier kommt DNS (Domain Name System) ins Spiel – es übersetzt Domainnamen wie
root-level.de in die passende IP-Adresse, z. B. 192.168.1.1.

In diesem Tutorial lernst du,

• wie DNS funktioniert,
• was A-, MX- oder CNAME-Einträge sind
• und wie du deine eigene DNS-Zone hosten kannst.

Was ist DNS eigentlich?

DNS ist so etwas wie das Telefonbuch des Internets.
Statt dir komplizierte IP-Adressen zu merken, tippst du einfach root-level.de ein.

Ein DNS-Server sucht dann in seiner Zone nach dem passenden Eintrag und gibt die IP zurück.

Beispiel:

root-level.de → 203.0.113.45

Die wichtigsten DNS-Einträge

Eigene DNS-Zone hosten (unter Linux mit BIND9)

Schritt 1: Installation

Installiere den DNS-Server BIND9 (auf Debian/Ubuntu):

sudo apt update

sudo apt install bind9 bind9utils bind9-doc -y

Schritt 2: Konfiguration vorbereiten

Erstelle eine Zonen-Datei für deine Domain:

sudo nano /etc/bind/db.root-level.de

Beispielinhalt:

$TTL 604800
@ IN SOA ns1.root-level.de. admin.root-level.de. (
3 ; Serial
604800 ; Refresh
86400 ; Retry
2419200 ; Expire
604800 ) ; Negative Cache TTL
;
@ IN NS ns1.root-level.de.
@ IN A 203.0.113.45
www IN A 203.0.113.45
mail IN A 203.0.113.46
@ IN MX 10 mail.root-level.de.

Schritt 3: Zone in BIND eintragen

Öffne die Hauptkonfiguration:

sudo nano /etc/bind/named.conf.local

Trage deine Zone ein:

zone "root-level.de" {
type master;
file "/etc/bind/db.root-level.de";
};

Schritt 4: DNS-Server starten und testen

sudo systemctl restart bind9
sudo systemctl enable bind9

Teste, ob dein DNS funktioniert:

dig @localhost root-level.de

Wenn alles korrekt läuft, sollte im Output deine IP erscheinen.

Sicherheit & Tipps

• DNSSEC aktivieren: Schützt deine Zone vor Manipulation
• Zweite Nameserver verwenden: Fallback, falls der erste ausfällt
• Backups: Zonen-Dateien regelmäßig sichern
• Firewall: UDP-Port 53 offen halten

Fazit

Mit einem eigenen DNS-Server hast du volle Kontrolle über deine Domains und Einträge.
Das ist ideal, wenn du mehrere Projekte betreibst, eigene Mailserver nutzt oder lernen willst, wie das Internet wirklich „unter der Haube“ funktioniert.

Der Beitrag DNS & Domains verstehen – und eigene Zone hosten erschien zuerst auf Root Level.

Wenn du einen Server betreibst, willst du wissen, was im Hintergrund passiert: Wie ist die CPU-Auslastung? Wie viel RAM wird genutzt? Läuft der Server stabil?
Mit Grafana und Prometheus kannst du all das übersichtlich darstellen – in Echtzeit.

Was du brauchst

• Einen Linux-Server (Debian oder Ubuntu)
• SSH-Zugang
• Grundkenntnisse im Terminal

Schritt 1: Prometheus installieren

Prometheus ist das Tool, das deine Serverdaten sammelt.

sudo apt update
sudo apt install prometheus -y

Nach der Installation läuft Prometheus automatisch unter Port 9090.
Du erreichst die Weboberfläche über:

http://deine-server-ip:9090

Schritt 2: Node Exporter installieren

Damit Prometheus Metriken vom System erhält, brauchst du den Node Exporter.

sudo apt install prometheus-node-exporter -y

Jetzt kannst du bereits CPU-, RAM- und Netzwerklast abrufen.

Schritt 3: Grafana installieren

Grafana sorgt für die grafische Darstellung der Daten.

sudo apt install grafana -y
sudo systemctl enable --now grafana-server

Grafana erreichst du über:

http://deine-server-ip:3000

Standard-Login: admin / admin

Schritt 4: Datenquelle verbinden

In Grafana:

1. „Data Sources“ → „Add data source“
2. „Prometheus“ auswählen
3. URL: http://localhost:9090
4. „Save & Test“

Schritt 5: Dashboard erstellen

• Neues Dashboard → „Add Panel“
• Wähle Metriken wie node_cpu_seconds_total oder node_memory_MemAvailable_bytes
• Diagramm speichern

Tipp: Im Grafana-Dashboard-Portal findest du viele fertige Templates!

Fazit

Mit Prometheus & Grafana hast du ein mächtiges Monitoring-Tool, das dir jederzeit Einblick in deinen Serverzustand gibt – kostenlos, flexibel und erweiterbar.

Der Beitrag Monitoring mit Grafana & Prometheus – Dein eigener Systemüberblick erschien zuerst auf Root Level.

Viele hören den Begriff Root-Server, wissen aber nicht genau, was dahintersteckt. In diesem Tutorial erkläre ich dir, was ein Root-Server ist, wie er funktioniert, und wann es sinnvoll ist, einen zu nutzen.

Was ist ein Root-Server?

Ein Root-Server ist ein vollwertiger Server, auf den du uneingeschränkten Zugriff hast – also die sogenannten „Root-Rechte“.
Das bedeutet: Du kannst alles installieren, konfigurieren oder auch löschen – ganz nach deinen Bedürfnissen.

Im Gegensatz dazu steht ein Shared Hosting, bei dem du dir den Server mit anderen teilst und kaum Systemzugriff hast.

VPS, Dedicated oder Cloud?

• VPS (Virtual Private Server): Virtuelle Maschine auf einem geteilten Host – günstig und flexibel.
• Dedicated Server: Physischer Server, den nur du nutzt – maximale Leistung, aber teurer.
• Cloud-Server: Dynamisch skalierbar, oft minutengenau abgerechnet – perfekt für wachsende Projekte.

Wann lohnt sich ein Root-Server?

Ein Root-Server ist sinnvoll, wenn du:

• volle Kontrolle über dein System willst,
• eigene Software oder Gameserver betreiben möchtest,
• oder dich in Linux- und Serveradministration einarbeiten willst.

Risiken & Verantwortung

Mit der Freiheit kommt auch Verantwortung.
Ein Root-Server muss gepflegt werden – regelmäßige Updates, Sicherheitskonfiguration (Firewall, SSH) und Backups sind Pflicht.

Fazit

Ein Root-Server ist perfekt für alle, die mehr wollen als „nur Webhosting“.
Er bietet maximale Kontrolle, erfordert aber technisches Verständnis und regelmäßige Wartung.

Der Beitrag Was ist ein Root-Server? – Einfach erklärt für Einsteiger erschien zuerst auf Root Level.

Rust ist eines der beliebtesten Survival-Spiele, das von Facepunch Studios entwickelt wurde. Es fordert dich heraus, in einer offenen Welt zu überleben, Ressourcen zu sammeln und gegen andere Spieler zu kämpfen. Wenn du deinen eigenen Rust-Server erstellen möchtest, um mit Freunden zu spielen oder eine eigene Community zu starten, bist du hier genau richtig! In diesem Tutorial zeigen wir dir, wie du einen Rust-Server aufsetzt, damit du direkt ins Spiel starten kannst.

Warum einen eigenen Rust-Server erstellen?

Ein eigener Rust-Server bietet viele Vorteile:

• Volle Kontrolle: Du entscheidest, wie der Server läuft – von den Regeln über Mods bis hin zu den Einstellungen.
• Anpassbarkeit: Du kannst die Welt, die Spieleranzahl und viele andere Parameter nach deinen Wünschen anpassen.
• Private Atmosphäre: Spiele nur mit Freunden oder baue eine Community auf, ohne dass Fremde auf deinem Server sind.

Vorbereitungen: Was du brauchst

Bevor du mit dem Serveraufbau beginnst, solltest du sicherstellen, dass du alle benötigten Ressourcen zur Hand hast:

• Ein Computer oder VPS (Virtual Private Server): Du kannst entweder einen eigenen Computer verwenden, aber ein VPS hat den Vorteil einer besseren Leistung und einer stabileren Verbindung.
• Rust auf Steam: Du musst die Steam-Version von Rust besitzen, da du die Serverdateien von Steam herunterladen wirst.
• Mindestsystemanforderungen: Stelle sicher, dass dein Computer oder VPS die Anforderungen erfüllt. Hier sind die empfohlenen Spezifikationen für einen Rust-Server:
  • Betriebssystem: Windows
  • Prozessor: Quad-Core CPU
  • Arbeitsspeicher: Mindestens 8 GB RAM
  • Festplattenspeicher: Mindestens 20 GB freien Speicherplatz
  • Internetverbindung: Eine stabile Verbindung mit ausreichend Bandbreite (mindestens 10 Mbps)

Rust Dedicated Server herunterladen

• Rust Server über SteamCMD herunterladen:
  • Gehe zu SteamCMD und lade die neueste Version herunter.
  • Entpacke SteamCMD in einen Ordner deiner Wahl.
  • Öffne die Eingabeaufforderung (CMD) und navigiere zum SteamCMD-Ordner.
  • Starte SteamCMD und gib die folgenden Befehle ein: login anonymous force_install_dir C:\RustServer app_update 258550 validate quit Dieser Befehl lädt die Rust-Serverdateien in den angegebenen Ordner „C:\RustServer“.
• Firewall und Portweiterleitung:
  • Stelle sicher, dass die Ports 28015 (UDP) für den Rust-Server und 28016 (UDP) für das RCON (Remote Console) in deiner Firewall freigegeben sind. Diese Ports musst du in deinem Router weiterleiten, um sicherzustellen, dass andere Spieler auf den Server zugreifen können.

Rust-Server konfigurieren

Nun, da du die Rust-Serverdateien heruntergeladen hast, geht es darum, den Server zu konfigurieren, sodass er nach deinen Wünschen läuft.

Serverkonfigurationsdateien:

• server.cfg erstellen:
  • Im Ordner deines Servers findest du die Konfigurationsdateien. Die wichtigste Datei ist „server.cfg“, in der du grundlegende Servereinstellungen wie den Namen, die Weltgröße und die Maximalzahl der Spieler festlegst.
  • Öffne den Ordner „server\cfg“ und erstelle oder bearbeite die „server.cfg“-Datei.
  • Füge die folgenden Grundkonfigurationen hinzu: hostname "Mein Rust-Server" server.description "Willkommen auf meinem Rust-Server!" server.url "http://meine-server-webseite.com" server.headerimage "http://meine-server-webseite.com/banner.png" server.seed 1234567 server.worldsize 4000 server.maxplayers 100 server.saveinterval 300
  • Du kannst „server.seed“ auf eine beliebige Zahl setzen, um eine zufällige Welt zu erstellen. „server.worldsize“ definiert die Größe der Welt, und „server.maxplayers“ gibt die maximale Anzahl von Spielern an.
• Serverstartdatei erstellen:
  • Erstelle eine Batch-Datei (z. B. „start.bat“).
  • Beispiel für die „start.bat“-Datei unter Windows: RustDedicated.exe -batchmode +server.hostname "Mein Rust-Server" +server.seed 1234567 +server.worldsize 4000 +server.maxplayers 100 +server.port 28015 +rcon.port 28016 +rcon.password "meinrconpasswort" +server.identity "meinserver"

Server starten und testen

• Server starten:
  • Doppelklicke auf die „start.bat“-Datei.
  • Dein Server sollte nun starten, und du solltest in der Konsole die Ladeinformationen sehen. Wenn alles funktioniert, wird der Server nach wenigen Minuten bereit sein.
• Mit dem Server verbinden:
  • Starte Rust auf deinem Computer und öffne das Spiel.
  • Klicke auf „Spiel beitreten“ und gib in der IP-Adresse deines Servers ein. Du kannst auch „localhost“ verwenden, wenn du den Server auf deinem eigenen Computer betreibst.
  • Wenn du alles richtig gemacht hast, solltest du nun auf deinem eigenen Server spielen können.

Server verwalten: Admin-Rechte und RCON

• Admin-Rechte vergeben:
  • Um dich selbst als Administrator auf deinem Server zu setzen, öffne die Konsole und gebe folgenden Befehl ein: ownerid <deineSteamID> "DeinName"
  • Deine SteamID findest du, indem du „status“ in der Server-Konsole eingibst.
• RCON (Remote Console):
  • Wenn du deinen Server aus der Ferne verwalten möchtest, kannst du RCON verwenden. Stelle sicher, dass du das RCON-Passwort in der Startdatei festgelegt hast.
  • Verwende dann ein Tool wie RustAdmin oder RCONApp, um deinen Server zu steuern.

Mods hinzufügen und anpassen

Mit Oxide oder uMod kannst du Mods und Plugins installieren, um deinen Server weiter anzupassen.

Mods hinzufügen:

• Lade Oxide von der offiziellen uMod-Website herunter.
• Entpacke die Oxide-Dateien in den Serverordner.
• Starte den Server erneut, und Oxide sollte aktiv sein.

Mit Mods kannst du zahlreiche Anpassungen vornehmen, z. B. das Hinzufügen von Wirtschaftssystemen, Mini-Games oder neuen Gameplay-Elementen.

Fazit

Ein Rust-Server eröffnet viele Möglichkeiten für dich und deine Community. Mit den richtigen Tools und Konfigurationen kannst du deinen eigenen Server ganz nach deinen Wünschen gestalten. Folge diesen Schritten, um sicherzustellen, dass dein Server reibungslos läuft, und nutze die vielen Anpassungsoptionen, die Rust bietet.

Jetzt liegt es an dir – viel Spaß beim Überleben, Bauen und Kämpfen auf deinem eigenen Rust-Server!

Der Beitrag Rust Server erstellen auf Windows erschien zuerst auf Root Level.

Rust ist eines der beliebtesten Survival-Spiele, das von Facepunch Studios entwickelt wurde. Es fordert dich heraus, in einer offenen Welt zu überleben, Ressourcen zu sammeln und gegen andere Spieler zu kämpfen. Wenn du deinen eigenen Rust-Server erstellen möchtest, um mit Freunden zu spielen oder eine eigene Community zu starten, bist du hier genau richtig! In diesem Tutorial zeigen wir dir, wie du einen Rust-Server aufsetzt, damit du direkt ins Spiel starten kannst.

Warum einen eigenen Rust-Server erstellen?

Ein eigener Rust-Server bietet viele Vorteile:

• Volle Kontrolle: Du entscheidest, wie der Server läuft – von den Regeln über Mods bis hin zu den Einstellungen.
• Anpassbarkeit: Du kannst die Welt, die Spieleranzahl und viele andere Parameter nach deinen Wünschen anpassen.
• Private Atmosphäre: Spiele nur mit Freunden oder baue eine Community auf, ohne dass Fremde auf deinem Server sind.

Vorbereitungen: Was du brauchst

Bevor du mit dem Serveraufbau beginnst, solltest du sicherstellen, dass du alle benötigten Ressourcen zur Hand hast:

• Ein Computer oder VPS (Virtual Private Server): Du kannst entweder einen eigenen Computer verwenden, aber ein VPS hat den Vorteil einer besseren Leistung und einer stabileren Verbindung.
• Rust auf Steam: Du musst die Steam-Version von Rust besitzen, da du die Serverdateien von Steam herunterladen wirst.
• Mindestsystemanforderungen: Stelle sicher, dass dein Computer oder VPS die Anforderungen erfüllt. Hier sind die empfohlenen Spezifikationen für einen Rust-Server:
  • Betriebssystem: Linux
  • Prozessor: Quad-Core CPU
  • Arbeitsspeicher: Mindestens 8 GB RAM
  • Festplattenspeicher: Mindestens 20 GB freien Speicherplatz
  • Internetverbindung: Eine stabile Verbindung mit ausreichend Bandbreite (mindestens 10 Mbps)

Rust Dedicated Server herunterladen

• Rust Server über SteamCMD installieren:
  • Installiere zunächst SteamCMD auf deinem Server: sudo apt update sudo apt install steamcmd
  • Erstelle einen Ordner für deinen Server: mkdir ~/rustserver cd ~/rustserver
  • Lade den Server herunter: steamcmd +login anonymous +force_install_dir ./ +app_update 258550 validate +quit

Rust-Server konfigurieren

Nun, da du die Rust-Serverdateien heruntergeladen hast, geht es darum, den Server zu konfigurieren, sodass er nach deinen Wünschen läuft.

Serverkonfigurationsdateien:

• server.cfg erstellen:
  • Im Ordner deines Servers findest du die Konfigurationsdateien. Die wichtigste Datei ist „server.cfg“, in der du grundlegende Servereinstellungen wie den Namen, die Weltgröße und die Maximalzahl der Spieler festlegst.
  • Öffne den Ordner „server\cfg“ und erstelle oder bearbeite die „server.cfg“-Datei.
  • Füge die folgenden Grundkonfigurationen hinzu: hostname "Mein Rust-Server" server.description "Willkommen auf meinem Rust-Server!" server.url "http://meine-server-webseite.com" server.headerimage "http://meine-server-webseite.com/banner.png" server.seed 1234567 server.worldsize 4000 server.maxplayers 100 server.saveinterval 300
  • Du kannst „server.seed“ auf eine beliebige Zahl setzen, um eine zufällige Welt zu erstellen. „server.worldsize“ definiert die Größe der Welt, und „server.maxplayers“ gibt die maximale Anzahl von Spielern an.
• Serverstartdatei erstellen:
  • Erstelle eine Shell-Datei (z. B. „start.sh“).
  • Beispiel für die „start.sh“-Datei: ./RustDedicated -batchmode +server.hostname "Mein Rust-Server" +server.seed 1234567 +server.worldsize 4000 +server.maxplayers 100 +server.port 28015 +rcon.port 28016 +rcon.password "meinrconpasswort" +server.identity "meinserver"

Server starten und testen

• Server starten:
  • Führe die „start.sh“-Datei auf deinem Linux-Server aus.
  • Dein Server sollte nun starten, und du solltest in der Konsole die Ladeinformationen sehen. Wenn alles funktioniert, wird der Server nach wenigen Minuten bereit sein.
• Mit dem Server verbinden:
  • Starte Rust auf deinem Computer und öffne das Spiel.
  • Klicke auf „Spiel beitreten“ und gib in der IP-Adresse deines Servers ein. Du kannst auch „localhost“ verwenden, wenn du den Server auf deinem eigenen Computer betreibst.
  • Wenn du alles richtig gemacht hast, solltest du nun auf deinem eigenen Server spielen können.

Server verwalten: Admin-Rechte und RCON

• Admin-Rechte vergeben:
  • Um dich selbst als Administrator auf deinem Server zu setzen, öffne die Konsole und gebe folgenden Befehl ein: ownerid <deineSteamID> "DeinName"
  • Deine SteamID findest du, indem du „status“ in der Server-Konsole eingibst.
• RCON (Remote Console):
  • Wenn du deinen Server aus der Ferne verwalten möchtest, kannst du RCON verwenden. Stelle sicher, dass du das RCON-Passwort in der Startdatei festgelegt hast.
  • Verwende dann ein Tool wie RustAdmin oder RCONApp, um deinen Server zu steuern.

Mods hinzufügen und anpassen

Mit Oxide oder uMod kannst du Mods und Plugins installieren, um deinen Server weiter anzupassen.

Mods hinzufügen:

• Lade Oxide von der offiziellen uMod-Website herunter.
• Entpacke die Oxide-Dateien in den Serverordner.
• Starte den Server erneut, und Oxide sollte aktiv sein.

Mit Mods kannst du zahlreiche Anpassungen vornehmen, z. B. das Hinzufügen von Wirtschaftssystemen, Mini-Games oder neuen Gameplay-Elementen.

Fazit

Ein Rust-Server eröffnet viele Möglichkeiten für dich und deine Community. Mit den richtigen Tools und Konfigurationen kannst du deinen eigenen Server ganz nach deinen Wünschen gestalten. Folge diesen Schritten, um sicherzustellen, dass dein Server reibungslos läuft, und nutze die vielen Anpassungsoptionen, die Rust bietet.

Jetzt liegt es an dir – viel Spaß beim Überleben, Bauen und Kämpfen auf deinem eigenen Rust-Server!

Der Beitrag Rust Server Erstellen auf Linux erschien zuerst auf Root Level.

Voraussetzungen

• Ein Raspberry Pi (z. B. mit Raspbian OS oder Raspberry Pi OS installiert).
• Zugang zu einem Terminal (lokal oder via SSH).
• Ein Benutzer mit sudo-Rechten.
• Internetverbindung.

System aktualisieren und vorbereiten

Bevor du mit der Installation von Webmin beginnst, stelle sicher, dass dein System auf dem neuesten Stand ist. Öffne ein Terminal oder verbinde dich per SSH mit deinem Raspberry Pi und führe folgenden Befehl aus:

sudo apt update
sudo apt upgrade -y

Webmin benötigt einige grundlegende Pakete. Installiere sie mit:

sudo apt install -y wget apt-transport-https software-properties-common

Webmin-Repository hinzufügen

Lade den GPG-Schlüssel für das Webmin-Repository herunter und füge ihn hinzu:

wget -qO- http://www.webmin.com/jcameron-key.asc | sudo tee /etc/apt/trusted.gpg.d/webmin.asc

Füge das Webmin-Repository zur Paketquelle hinzu:

echo "deb http://download.webmin.com/download/repository sarge contrib" | sudo tee /etc/apt/sources.list.d/webmin.list

Aktualisiere die Paketliste:

sudo apt update

Webmin installieren

Installiere Webmin mit dem folgenden Befehl:

sudo apt install -y webmin

Webmin-Dienst überprüfen

Überprüfe, ob der Webmin-Dienst läuft:

sudo systemctl status webmin

Wenn der Dienst läuft, sollte eine Ausgabe wie diese erscheinen:

● webmin.service - Webmin server daemon
   Active: active (running) ...

Falls der Dienst nicht läuft, kannst du ihn mit folgendem Befehl starten:

sudo systemctl start webmin

Zugriff auf Webmin

• Webmin ist standardmäßig auf Port 10000 erreichbar.
• Öffne deinen Webbrowser und navigiere zu:
• https://IP-Adresse-deines-Raspberry-Pi:10000
  • Ersetze <IP-Adresse-deines-Raspberry-Pi> mit der tatsächlichen IP deines Raspberry Pi.
  • Du kannst die IP-Adresse mit dem folgenden Befehl herausfinden:
    • hostname -I
• Du erhältst möglicherweise eine Sicherheitswarnung, weil Webmin ein selbstsigniertes SSL-Zertifikat verwendet. Das ist normal. Klicke auf „Erweitert„ und dann auf „Trotzdem fortfahren„ (je nach Browser).

Anmeldung bei Webmin

Melde dich mit den Zugangsdaten eines Benutzers mit sudo-Rechten an (z. B. pi).Nach der Anmeldung erhältst du Zugriff auf die Webmin-Oberfläche.

Abschluss

Du hast Webmin erfolgreich auf deinem Raspberry Pi installiert. Du kannst jetzt dein System bequem über den Browser verwalten, Benutzerkonten anlegen, den Speicher überwachen, Cronjobs konfigurieren und vieles mehr.

Ich hoffe dir hat das Tutorial gefallen und viel Erfolg!

Der Beitrag Webmin auf dem Raspberry Pi installieren erschien zuerst auf Root Level.