Wenn du hier bist, willst du vermutlich zur zweiten Gruppe gehören.

Die Kommandozeile ist kein Relikt aus der Vergangenheit. Sie ist das präziseste Werkzeug, das du auf einem Linux-System hast. Kein Overhead, keine Ablenkung – nur du, das System und klare Befehle.

Und ja: Es gibt hunderte, eher tausende Befehle.
Aber die Wahrheit ist einfacher: Ein relativ kleiner Kern reicht für fast alles.

Navigation: Verstehen, wo du bist

Das Dateisystem ist dein Spielfeld. Wenn du dich hier nicht sicher bewegst, wird alles andere unnötig kompliziert.

Du wirst ständig:

• Verzeichnisse wechseln
• Inhalte prüfen
• Dateien verschieben

Und genau dafür sind diese Basics da.

cd, ls, pwd – klingt banal, ist aber dein tägliches Brot.

Ein sauberer Workflow beginnt immer damit, dass du weißt, wo du bist und was um dich herum passiert.

Dateien: Lesen vor Schreiben

Ein häufiger Anfängerfehler: Direkt editieren, ohne zu verstehen, was in einer Datei steht.

Besser:

• Erst anschauen (less, cat)
• Dann gezielt bearbeiten (nano, vim)

Gerade less ist unterschätzt. Große Logfiles? Kein Problem. Scrollen, suchen, analysieren – ohne Chaos.

Und wenn du Logs debuggen musst:

tail -f /var/log/syslog

Das ist kein Trick. Das ist Alltag.

Filtern & Suchen: Hier beginnt Linux Spaß zu machen

Jetzt kommt der Punkt, an dem sich Linux von anderen Systemen absetzt.

Du arbeitest nicht mehr mit einzelnen Befehlen – sondern kombinierst sie.

Beispiel:

ps aux | grep apache

Boom. Pipeline.

Du nimmst Output, leitest ihn weiter, filterst ihn.
Das ist der Moment, wo aus “Befehle kennen” → “System verstehen” wird.

Tools wie grep, awk, sed sind keine Spielerei.
Sie sind der Grund, warum Admins Dinge in Sekunden lösen, für die andere Minuten brauchen.

Prozesse: Kontrolle behalten

Wenn etwas läuft, musst du es sehen.
Wenn etwas hängt, musst du es stoppen.

• top zeigt dir live, was abgeht
• ps gibt dir Details
• kill beendet Dinge, die nicht kooperieren

Und ja, irgendwann nutzt jeder:

kill -9 PID

Nicht schön. Aber effektiv.

Netzwerk: Realität schlägt Theorie

Netzwerkprobleme sind nie da, wenn man sie braucht – aber immer dann, wenn man sie nicht gebrauchen kann.

Mit ein paar Befehlen kannst du aber ziemlich schnell herausfinden, was los ist:

• ping → lebt die Verbindung?
• ip → wie ist dein Interface konfiguriert?
• curl → was sagt der Server wirklich?

Gerade curl ist so ein Werkzeug, das mit dir wächst.
Am Anfang simple Requests, später Debugging-Tool für APIs.

Rechte: Der Unterschied zwischen “geht” und “warum geht das nicht?”

Linux ist streng. Und das ist gut so.

Rechte sind kein Detail – sie sind zentral.

Wenn etwas nicht funktioniert, ist es oft genau das:

• falscher Besitzer
• falsche Berechtigung

chmod, chown, sudo – das sind keine optionalen Befehle.
Die brauchst du ständig.

Pakete: Software wie sie sein sollte

Keine Installer, keine Downloads von dubiosen Seiten.

Ein Befehl:

apt install nginx

Fertig.

Das ist einer der Punkte, wo Linux einfach überlegen ist.

Realität: Du wirst nicht alle brauchen – aber du solltest sie kennen

Die meisten User nutzen immer wieder dieselben 20–30 Befehle.

Aber die anderen sind wichtig, weil:

• du sie irgendwann brauchst
• du sie verstehst, wenn du sie siehst
• du schneller Lösungen findest

Linux ist kein System, das du “auswendig lernst”.
Es ist eines, das du benutzt – und dabei wächst.

Die Top 50 Linux Befehle (komplette Tabelle)

Fazit

Wenn du diese Liste nicht nur liest, sondern benutzt, passiert Folgendes:

• du wirst schneller
• du wirst sicherer
• du wirst unabhängiger von GUIs

Und irgendwann merkst du:
Du denkst nicht mehr in Klicks – sondern in Befehlen.

Genau da beginnt echtes Linux-Verständnis.

Der Beitrag Linux Kommandozeile: Die 50 Befehle, die du wirklich brauchst erschien zuerst auf Root Level.

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.

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.

Voraussetzung

• Ein Debian-basiertes Linux-System (z. B. Debian, Ubuntu).
• Zugriff auf ein Terminal.
• Entsprechende Berechtigungen (Root oder Benutzer mit Zugriff auf crontab).

Überprüfen, ob cron installiert ist

dpkg -l | grep cron

Wenn nichts angezeigt wird, installiere cron:

sudo apt update
sudo apt install cron

Dann stellen wir sicher, dass der Dienst läuft

sudo systemctl enable cron
sudo systemctl start cron
sudo systemctl status cron

Öffne die Crontab des Benutzers

crontab -e

Wenn du zum ersten Mal eine Crontab öffnest, wirst du möglicherweise gefragt, welchen Editor du verwenden möchtest (z. B. nano, vim oder vi).

Einen bestehenden Cronjob kannst du so aufrufen

crontab -l

Syntax eines Cronjobs

Die Syntax eines Cronjobs besteht aus 5 Zeitfeldern gefolgt von dem auszuführenden Befehl:

* * * * * /pfad/skript.sh
- - - - -
| | | | |
| | | | +----- Tag der Woche (0 - 7, wobei 0 und 7 für Sonntag stehen)
| | | +------- Monat (1 - 12)
| | +--------- Tag im Monat (1 - 31)
| +----------- Stunde (0 - 23)
+------------- Minute (0 - 59)

Hier ein paar Beispiele:

• Jede Minute:

* * * * * /pfad/skript.sh

• Täglich um 3:30 Uhr:

30 3 * * * /pfad/skript.sh

• Montags um 12:00 Uhr:

0 12 * * 1 /pfad/skript.sh

• Jeden 1. und 15. eines Monats um 5:00 Uhr:

0 5 1,15 * * /pfad/skript.sh

Erstelle ein Beispiel-Skript

• Erstelle ein Shell-Skript:

nano /home/benutzer/mein_skript.sh

• Füge einen Beispielinhalt hinzu:

#!/bin/bash
echo "Cronjob läuft: $(date)" >> /home/benutzer/cronjob.log

• Mach das Skript ausführbar:

chmod +x /home/benutzer/mein_skript.sh

Cronjob eintragen

• Öffne die Crontab:

crontab -e

• Füge den Cronjob hinzu:

* * * * * /home/benutzer/mein_skript.sh

Speichere die Datei (z. B. in nano mit Ctrl + O, dann Enter, und schließe mit Ctrl + X).

Logs überprüfen

Um zu sehen, ob dein Cronjob ausgeführt wurde, überprüfe das System-Log:

grep CRON /var/log/syslog

Prüfe die Log-Datei deines Skripts (falls verwendet):

cat /home/benutzer/cronjob.log

Abschluss

Du hast erfolgreich einen Cronjob in deinem System hinterlegt!

Ich hoffe dir hat das Tutorial gefallen und viel Erfolg!

Der Beitrag Cronjob auf Linux Debian einrichten erschien zuerst auf Root Level.

Voraussetzungen

• Ein Server mit Debian 10/11 installiert.
• Root-Zugriff oder ein Benutzer mit sudo-Rechten
• Eine funktionierende Internetverbindung
• Basiskenntnisse im Umgang mit der Kommandozeile.

System vorbereiten

sudo apt update && sudo apt upgrade -y

Dadurch werden alle Pakete auf den neuesten Stand gebracht. Als nächstes installieren wir die benötigten Pakete. (Apache2, MariaDB, PHP)

sudo apt install apache2 mariadb-server libapache2-mod-php \
php php-mysql php-zip php-intl php-curl php-mbstring php-gd php-xml php-bz2 php-imagick unzip wget -y

Datenbank einrichten

Nachdem unser System nun aktualisiert und die Pakete installiert sind, können wir nun anfangen unsere Datenbank einzurichten.
Als erstes sichern wir unsere MariaDB und initialisieren.

sudo mysql_secure_installation

Bei „Set root password?“ wählt ihr -> Ja und bei Alle anderen Sicherheitsoptionen ebenfalls -> Ja

Jetzt können wir unsere Nextcloud-Datenbank und Benutzer anlegen.

sudo mysql -u root -p

CREATE DATABASE nextcloud;
CREATE USER 'nextclouduser'@'localhost' IDENTIFIED BY 'euerpasswort';
GRANT ALL PRIVILEGES ON nextcloud.* TO 'nextclouduser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

„euerpasswort“ ersetzt ihr natürlich durch euer Passwort.

Nextcloud herunterladen und konfigurieren

Jetzt gehen wir ins Verzeichnis /var/www/ wir uns die Nextcloud über wget herunter.

cd /var/www/
wget https://download.nextcloud.com/server/releases/latest.zip

Die .zip-Datei müssen wir jetzt entpacken.

unzip latest.zip

Als nächstes vergeben wir die Berechtigungen für den Ordern.

sudo chown -R www-data:www-data /var/www/nextcloud
sudo chmod -R 755 /var/www/nextcloud

Apache konfigurieren

Wir erstellen nun eine Virtuelle-Host Datei.

sudo nano /etc/apache2/sites-available/nextcloud.conf

und tragen folgendes ein:

<VirtualHost *:80>
    ServerName deinedomain.de
    DocumentRoot /var/www/nextcloud/
    ErrorLog /var/log/apache2/files.deinedomain.de-error.log
    CustomLog /var/log/apache2/files.deinedomain.de-access.log combined
    <Directory /var/www/nextcloud/>
        Options +FollowSymlinks
        AllowOverride All
        <IfModule mod_dav.c>
            Dav off
        </IfModule>
        SetEnv HOME /var/www/nextcloud
        SetEnv HTTP_HOME /var/www/nextcloud
    </Directory>
</VirtualHost>

Falls du eine Subdomain verwenden möchtest, trage bei ServerName „subdomain.deinedomain.de“ ein!

Jetzt aktivieren wir den Virtuellen Host.

sudo a2ensite nextcloud.conf
sudo systemctl reload apache2

SSL-Zertifikat (Optional)

Falls ihr für euren Heimserver ein SSL Zertifikat erstellen möchtet geht das auf folgende weiße.
Wir installieren als erstes Certbot.

sudo apt install certbot python3-certbot-apache -y

Danach lassen wir uns ein Zertifikat austellen mit.

sudo certbot --apache

Nextcloud einrichten

Rufe in deinem Browser http://deinedomain.de (oder https://deinedomain.de, wenn SSL eingerichtet wurde) auf.

• Erstelle einen Admin-Benutzer
• Gib die Datenbankinformationen ein:
  • Datenbankbenutzer: nextclouduser
  • Datenbankpasswort: Das in von dir festgelegte Passwort.
  • Datenbankname: nextcloud
  • Host: localhost

Klicke jetzt auf Installation abschließen.

Abschluss

Du hast Nextcloud erfolgreich auf deinem Debian-System installiert! Du kannst nun Dateien hochladen, Benutzer hinzufügen und weitere Funktionen aktivieren.

Ich hoffe dir hat das Tutorial gefallen und viel Erfolg!

Der Beitrag Installation von Nextcloud auf Linux Debian erschien zuerst auf Root Level.