☁️Installation Nextcloud auf Ubuntu 24.04 – Schritt für Schritt

In diesem Beitrag erfährst du, wie du Nextcloud – eine Open-Source-Lösung für private Clouds – zusammen mit einer MySQL-Datenbank unter Einsatz von Docker und Docker Compose auf Ubuntu 24.04 installierst und konfigurierst. Durch die Containerisierung erhältst du eine flexible, skalierbare und isolierte Umgebung, die insbesondere für fortgeschrittene IT-Profis interessant ist.


🚀 Schritt 1: System vorbereiten und Docker sowie Docker Compose installieren

Stelle zunächst sicher, dass dein Ubuntu 24.04 System aktuell ist und alle notwendigen Pakete installiert sind. Öffne ein Terminal und führe folgende Befehle aus:

sudo apt update
sudo apt upgrade -y
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io -y
sudo apt install docker-compose-plugin -y

📦 Schritt 2: Nextcloud mit MySQL als Container bereitstellen

Erstelle eine docker-compose.yml Datei, um sowohl Nextcloud als auch eine MySQL-Datenbank als Container bereitzustellen. Mit Docker Compose startest du beide Container gleichzeitig und verwaltest sie effizient.

version: '3.7'

services:
  db:
    image: mysql:8
    command: --transaction-isolation=READ-COMMITTED --log-bin=binlog --binlog-format=ROW
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: mysecretpassword
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_PASSWORD: nextcloud_password
    volumes:
      - db_data:/var/lib/mysql

  app:
    image: nextcloud
    ports:
      - 8080:80
    restart: always
    depends_on:
      - db
    environment:
      - MYSQL_PASSWORD=nextcloud_password
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_HOST=db
    volumes:
      - nextcloud_data:/var/www/html

volumes:
  db_data:
  nextcloud_data:

🔄 Schritt 3: Container starten und testen

Wechsle in das Verzeichnis, in dem sich deine docker-compose.yml befindet, und starte die Container mit:

docker-compose up -d

Öffne deinen Webbrowser und navigiere zu http://localhost:8080 (oder der entsprechenden IP/Domain deines Servers), um die Nextcloud-Installation abzuschließen. Dort wirst du aufgefordert, die Datenbankdetails einzugeben – verwende die in deiner docker-compose.yml konfigurierten Werte.


📌 Fazit

Mit dieser Anleitung hast du Nextcloud zusammen mit einer MySQL-Datenbank erfolgreich in Docker-Containern auf Ubuntu 24.04 bereitgestellt. Die Containerisierung ermöglicht es dir, die Cloud-Lösung flexibel, isoliert und einfach zu verwalten. Mit Docker Compose startest du beide Container gleichzeitig – und dank der Installation des Docker Compose Plugins ist die Handhabung modern und unkompliziert.

Hast du Fragen oder weitere Tipps zur Containerisierung von Nextcloud? Teile deine Erfahrungen und Anregungen gern in den Kommentaren!

🐳Installation Docker auf Ubuntu 24.04 – Schritt für Schritt

In diesem Beitrag erfährst du, wie du Docker – eine leistungsstarke Containerisierungsplattform – auf deinem Ubuntu 24.04 Server installierst und konfigurierst. Docker ermöglicht es dir, Anwendungen in isolierten Containern auszuführen, was die Bereitstellung, Skalierung und Verwaltung deiner Software wesentlich vereinfacht.


🔍 Schritt u1: System vorbereiten und aktualisieren

Bevor du Docker installierst, solltest du dein System aktualisieren und einige notwendige Pakete installieren. Öffne ein Terminal und führe folgende Befehle aus:

sudo apt update
sudo apt upgrade -y
sudo apt install apt-transport-https ca-certificates curl software-properties-common -y

🔑 Schritt u2: Docker GPG-Schlüssel hinzufügen und Repository einrichten

Füge den offiziellen Docker GPG-Schlüssel hinzu, um die Authentizität der Docker-Pakete sicherzustellen:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Füge nun das offizielle Docker Repository zu deiner APT-Quellenliste hinzu:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere nun die Paketdatenbank erneut:

sudo apt update

🚢 Schritt u3: Docker installieren

Jetzt kannst du Docker Engine, Docker CLI und Containerd installieren. Führe dazu folgenden Befehl aus:

sudo apt install docker-ce docker-ce-cli containerd.io -y

🔄 Schritt u4: Docker konfigurieren und testen

Um Docker als nicht-root Benutzer zu verwenden, füge deinen Benutzer zur Docker-Gruppe hinzu:

sudo usermod -aG docker $USER

Um die Gruppenzuordnung wirksam werden zu lassen, starte deinen Computer neu oder melde dich ab und wieder an:

sudo reboot

Nach dem Neustart kannst du testen, ob Docker korrekt installiert wurde, indem du das „Hello World“-Container-Image ausführst:

docker run hello-world

📌 Fazit

Mit Docker kannst du Anwendungen in isolierten Containern betreiben, was dir eine hohe Flexibilität und Skalierbarkeit bietet. In dieser Anleitung hast du gelernt, wie du Docker auf Ubuntu 24.04 installierst, das offizielle Repository einrichtest, Docker Engine und CLI installierst und schließlich deinen ersten Container testest. Nutze Docker, um deine Entwicklungs- und Produktionsumgebungen effizient zu managen und voneinander zu isolieren.

Hast du Fragen oder weitere Tipps zur Nutzung von Docker? Teile deine Erfahrungen und Anregungen gern in den Kommentaren!

🚀 Installation Apache2 auf Ubuntu 24.04 – Schritt für Schritt

In diesem Artikel zeige ich dir Schritt für Schritt, wie du den Apache2 Webserver auf Ubuntu 24.04 installierst, konfigurierst und testest. Ob du eine neue Website hosten oder deine lokale Entwicklungsumgebung einrichten möchtest – Apache2 ist eine robuste und weit verbreitete Lösung, die sich perfekt für KMU und private Projekte eignet.


🔍 Voraussetzungen

Bevor du startest, solltest du folgende Punkte beachten:

  • Ubuntu 24.04: Stelle sicher, dass dein System aktuell ist.
  • Administratorrechte: Du benötigst Root- oder sudo-Rechte, um Pakete zu installieren und den Server zu konfigurieren.
  • Netzwerkkonfiguration: Dein Server sollte eine feste IP-Adresse besitzen, damit deine Website über das Netzwerk erreichbar ist.

🛠️ Schritt 1️⃣: System aktualisieren

Bevor du neue Software installierst, ist es ratsam, dein System zu aktualisieren. Öffne ein Terminal und führe folgende Befehle aus:

sudo apt update
sudo apt upgrade -y

Dies stellt sicher, dass alle vorhandenen Pakete auf dem neuesten Stand sind.


🛠️ Schritt 2️⃣: Apache2 installieren

Der Apache2 Webserver ist im Ubuntu-Paket-Repository verfügbar. Installiere ihn mit:

sudo apt install apache2 -y

Nach der Installation startet der Dienst automatisch. Du kannst den Status überprüfen mit:

sudo systemctl status apache2

Wenn alles korrekt läuft, sollte „active (running)“ angezeigt werden.


🔒 Schritt 3️⃣: Firewall konfigurieren

Falls du eine Firewall (z. B. UFW) aktiviert hast, musst du Apache2 den Zugriff erlauben:

sudo ufw allow in "Apache Full"

Dies öffnet die Ports 80 (HTTP) und 443 (HTTPS).


🛠️ Schritt 4️⃣: Apache2 konfigurieren

Die Hauptkonfigurationsdateien von Apache2 befinden sich im Verzeichnis /etc/apache2/. Einige wichtige Punkte:

  • Virtual Hosts: Um mehrere Websites zu hosten, erstelle separate Virtual Host-Dateien in /etc/apache2/sites-available/. Ein Beispiel für einen Virtual Host:
<VirtualHost *:80> 
  ServerAdmin [email protected] 
  ServerName deinedomain.de 
  ServerAlias www.deinedomain.de 
  DocumentRoot /var/www/deinedomain 
  ErrorLog ${APACHE_LOG_DIR}/error.log 
  CustomLog ${APACHE_LOG_DIR}/access.log combined 
</VirtualHost>
  • Aktivieren des Virtual Host: Nachdem du die Datei erstellt hast, aktiviere sie mit:
sudo a2ensite deinedomain.conf 
sudo systemctl reload apache2
  • Module aktivieren: Apache2 bietet viele Module (z. B. rewrite, ssl). Um ein Modul zu aktivieren, benutze den Befehl:
sudo a2enmod rewrite sudo systemctl restart apache2

🔍 Schritt 5️⃣: Installation testen

Öffne deinen Browser und gib die IP-Adresse deines Servers ein. Du solltest die standardmäßige Apache2-Willkommensseite sehen. Falls du einen Virtual Host konfiguriert hast, teste die entsprechende Domain.

Du kannst auch die Logdateien unter /var/log/apache2/ überprüfen, um sicherzustellen, dass keine Fehler auftreten.


📌 Fazit

Die Installation und Grundkonfiguration von Apache2 auf Ubuntu 24.04 ist relativ unkompliziert – vorausgesetzt, du hast die notwendigen Rechte und deine Systemvoraussetzungen stimmen. Mit Apache2 erhältst du einen leistungsstarken Webserver, der sich ideal an deine Bedürfnisse anpassen lässt. Ob du nun eine kleine Website betreiben oder eine komplexe Serverlandschaft verwalten möchtest – mit den hier gezeigten Schritten bist du bestens gerüstet.

Hast du Fragen oder Tipps zur Apache2-Installation? Teile sie in den Kommentaren!

🚀 Installation NGINX auf Ubuntu 24.04 – Schritt für Schritt

Als Fachinformatiker arbeite ich tagtäglich mit unterschiedlichen Webservern. In diesem Beitrag erkläre ich dir, wie du NGINX auf Ubuntu 24.04 installierst, einen Server Block einrichtest und das Ganze mit SSL absicherst. NGINX besticht durch seine hohe Performance und Flexibilität – ideal für moderne Webanwendungen und den Einsatz in KMU.


🔍 Voraussetzungen

Bevor du loslegst, stelle sicher, dass:

  • Ubuntu 24.04 auf deinem Server installiert ist.
  • Du Sudo-Rechte besitzt (als Administrator oder mit sudo).
  • Dein System auf dem neuesten Stand ist (siehe Schritt 1).
  • Eine feste IP-Adresse bzw. ein Domainname konfiguriert ist (für den späteren Server Block).

🛠️ Schritt 1️⃣: System aktualisieren

Aktualisiere zunächst die Paketliste und installiere alle Updates, um eine stabile Basis zu haben:

sudo apt update
sudo apt upgrade -y

🛠️ Schritt 2️⃣: NGINX installieren

NGINX ist im offiziellen Ubuntu-Repository enthalten. Installiere NGINX mit:

sudo apt install nginx -y

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

sudo systemctl status nginx

Du solltest dabei „active (running)“ sehen.


🔒 Schritt 3️⃣: Firewall konfigurieren

Falls du UFW (Uncomplicated Firewall) nutzt, erlaube NGINX den Zugriff über HTTP und HTTPS:

sudo ufw allow 'Nginx Full'

Damit werden die Ports 80 und 443 geöffnet. Prüfe den Status mit:

sudo ufw status
sudo ufw status

📌 Schritt 4️⃣: NGINX konfigurieren – Einen Server Block erstellen

Um mehrere Webseiten auf einem Server zu hosten, verwendet man Server Blocks (ähnlich wie Virtual Hosts bei Apache). Im Folgenden zeige ich dir, wie du einen neuen Server Block einrichtest:

1. Web-Verzeichnis anlegen:
Erstelle das Verzeichnis für deine Website, z. B. für die Domain „meinewebsite.local“:

sudo mkdir -p /var/www/meinewebsite.local/html

2. Eigentümer und Rechte setzen:
Übernimm den Besitz (ersetze $USER durch deinen Benutzernamen, falls nötig):

sudo chown -R $USER:$USER /var/www/meinewebsite.local/html sudo chmod -R 755 /var/www/meinewebsite.local

3. Test-HTML erstellen:
Lege eine einfache „index.html“ an. Dies geht einfach mittels eines bevorzugten Texteditor wie vim. Dazu einfach : vi /var/www/meinewebsite.local/html/index.html und dann mit „Esc dann : und danach wq + Enter“.
Füge folgenden Inhalt ein:

<!DOCTYPE html> <html lang="de"> <head> <meta charset="UTF-8"> <title>Willkommen bei MeineWebsite</title> </head> <body> <h1>Hallo Welt!</h1> <p>NGINX läuft auf Ubuntu 24.04 – Installation erfolgreich!</p> </body> </html>

4. Server Block konfigurieren: Erstelle eine neue Konfigurationsdatei in /etc/nginx/sites-available/. Dazu einfach:

 vi /etc/nginx/sites-available/meinewebsite.local

Und folgenden vhost config angepasst abspeichern:

server { 
  listen 80; 
  listen [::]:80; 
  server_name meinewebsite.local www.meinewebsite.local; 
  root /var/www/meinewebsite.local/html; 
  index index.html index.htm; 
  location / { 
    try_files $uri $uri/ =404;
   } 
 }

5. Server Block aktivieren:
Erstelle einen symbolischen Link in das Verzeichnis „sites-enabled“ um die Webseite zu aktivieren:

 ln -s /etc/nginx/sites-available/meinewebsite.local /etc/nginx/sites-enabled/

6. NGINX-Konfiguration testen und neu laden:
Erstelle einen symbolischen Link in das Verzeichnis „sites-enabled“ um die Webseite zu aktivieren:

sudo nginx -t

Falls alles ok ist, lade NGINX neu:

systemctl reload nginx

🔒 Schritt 5️⃣: NGINX mit SSL absichern

Um die Kommunikation zu verschlüsseln, installiere ein SSL-Zertifikat – beispielsweise über Let’s Encrypt.

1. Certbot installieren:
Installiere Certbot und das NGINX-Plugin:

 apt install certbot python3-certbot-nginx -y

2. SSL-Zertifikat anfordern: Fordere ein Zertifikat für deine Domain an (ersetze „meinewebsite.local“ durch deinen tatsächlichen Domainnamen):

 apt install certbot python3-certbot-nginx -y

Folge den interaktiven Anweisungen (E-Mail eingeben, Nutzungsbedingungen akzeptieren usw.). Certbot konfiguriert NGINX automatisch für HTTPS.

3. Automatische Zertifikatserneuerung testen:

sudo certbot renew --dry-run

📌 Fazit

Mit NGINX auf Ubuntu 24.04 hast du einen leistungsstarken Webserver installiert, der sich durch hohe Performance und Flexibilität auszeichnet – ideal für moderne Webanwendungen in KMU.
Als Fachinformatiker weiß ich, wie wichtig Stabilität und Sicherheit sind. Mit den oben beschriebenen Schritten richtest du einen neuen Server Block ein und sicherst den Datenverkehr mit einem kostenlosen SSL-Zertifikat ab.

Hast du Fragen oder eigene Tipps? Teile deine Erfahrungen und Anregungen in den Kommentaren!

🚀 Installation Fail2ban und ssh absichern – Schritt für Schritt

In diesem Beitrag erfährst du, wie du Fail2Ban – ein leistungsstarkes Tool zur Abwehr von Brute-Force-Angriffen – auf deinem Ubuntu-Server installierst und konfigurierst. Fail2Ban überwacht deine Logdateien und blockiert wiederholte, fehlgeschlagene Anmeldeversuche temporär, um unerwünschte Zugriffe effektiv zu verhindern.


🔒 Schritt u1: Fail2Ban installieren

Beginne mit der Installation von Fail2Ban. Öffne dazu ein Terminalfenster auf deinem Ubuntu-Server und führe folgenden Befehl aus:

sudo apt install fail2ban -y

Nach erfolgreicher Installation ist Fail2Ban bereit, konfiguriert zu werden.


🛠️ Schritt u2: Konfiguration anpassen

Um die Standardkonfiguration anzupassen, kopiere zunächst die Originaldatei jail.conf in eine lokale Konfigurationsdatei jail.local. So bleiben Updates unberührt:

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

Öffne nun die Datei /etc/fail2ban/jail.local mit deinem bevorzugten Editor, zum Beispiel mit vi oder nano, um den [sshd]-Abschnitt anzupassen:

sudo vi /etc/fail2ban/jail.local

Stelle sicher, dass der [sshd]-Abschnitt in etwa folgendermaßen konfiguriert ist:

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

Speichere die Datei nach deinen Anpassungen ab.


🔄 Schritt u3: Fail2Ban neu starten und Status prüfen

Nachdem du die Konfiguration angepasst hast, starte Fail2Ban neu, damit die Änderungen wirksam werden:

sudo systemctl restart fail2ban

Überprüfe anschließend den Status des Fail2Ban-Dienstes für den SSH-Dienst:

sudo fail2ban-client status sshd

📌 Fazit

Mit Fail2Ban hast du ein zusätzliches Sicherheitstool eingerichtet, das deinen Server aktiv vor Brute-Force-Angriffen schützt. Durch die Überwachung der Authentifizierungsversuche und das temporäre Sperren verdächtiger IP-Adressen wird die Angriffsfläche erheblich reduziert. So erhöhst du die Sicherheit deines Servers nachhaltig.

Hast du Fragen oder weitere Tipps zur Konfiguration von Fail2Ban? Teile deine Erfahrungen und Anregungen gern in den Kommentaren!

🚀 Installation von Ubuntu 24.04 und Hardening – Schritt für Schritt

In diesem Beitrag zeige ich dir aus der Sicht eines Fachinformatikers, wie du Ubuntu 24.04 installierst und anschließend durch gezielte Maßnahmen härtest. Nach Abschluss bist du durch den Einsatz von UFW, Fail2Ban und der Authentifizierung ausschließlich mittels Zertifikat (SSH Public-Key/Cer‑based Login) bestens gegen unerwünschte Zugriffe geschützt.


🔍 Schritt u1: Ubuntu 24.04 installieren und System aktualisieren

Zunächst solltest du Ubuntu 24.04 auf deinem Server installieren – entweder als physische Maschine oder in einer Virtualisierungsumgebung. Sobald dein System läuft, aktualisiere es, um sicherzustellen, dass alle Sicherheitsupdates eingespielt sind:

sudo apt update
sudo apt upgrade -y

Starte anschließend den Server neu, falls dies empfohlen wird:

sudo reboot

🔒 Schritt u2: UFW – die Firewall konfigurieren

UFW (Uncomplicated Firewall) ist ein einfach zu bedienendes Frontend für iptables. Damit kannst du den Netzwerkzugriff auf deinen Server steuern.

1. Standardregeln setzen:
Zunächst sollten eingehende Verbindungen standardmäßig blockiert werden, während ausgehende Verbindungen erlaubt sind:

sudo ufw default deny incoming sudo ufw default allow outgoing

2. SSH-Zugriff erlauben:
Damit du deinen Server weiterhin über SSH erreichst, öffne den entsprechenden Port (standardmäßig 22):

sudo ufw allow ssh

Man sollte jedoch immer die Netze Einschränken von denen man zugreifen darf, wie z.B. hier auf das „192.168.1.0/24“ Netz:

sudo ufw allow from 192.168.1.0/24 to any port 22 proto tcp

3. Firewall aktivieren:
Jetzt kannst du die Firewall aktivieren:

sudo ufw enable

4. Status überprüfen:

sudo ufw status verbose

🛠️ Schritt u3: Fail2Ban installieren und konfigurieren

Fail2Ban schützt deinen Server vor Brute-Force-Angriffen, indem es wiederholte fehlgeschlagene Anmeldeversuche überwacht und die Angreifer temporär blockiert.

1. Fail2Ban installieren:

sudo apt install fail2ban -y

2. Konfiguration anpassen: Erstelle eine lokale Konfigurationsdatei, um die Standardregeln zu überschreiben:

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

3. SSH-Absicherung aktivieren: Öffne die Datei /etc/fail2ban/jail.local mit deinem Editor (z. B. vim oder nano):

sudo vi /etc/fail2ban/jail.local

Suche nach dem [sshd]-Abschnitt und stelle sicher, dass er wie folgt konfiguriert ist (du kannst auch Anpassungen vornehmen):

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

Speichere die Datei und beende den Editor mit „Esc“ -> “ :“ -> „wq“ oder bei nano (Strg+O, Enter, Strg+X).

4. Fail2Ban neu starten:

sudo systemctl restart fail2ban

5. Status prüfenn:

sudo fail2ban-client status sshd

📌 Schritt u4: Anmeldung ausschließlich mit Zertifikat (SSH Key) einrichten

Die Anmeldung über Zertifikate (Public-Key-Authentifizierung) ist wesentlich sicherer als die Nutzung von Passwörtern.

1. SSH-Schlüssel generieren (auf deinem Client): Auf deinem lokalen Rechner generierst du ein Schlüsselpaar:

ssh-keygen -t ed25519 -C "[email protected]"

Folge den Anweisungen und speichere den Schlüssel (standardmäßig unter ~/.ssh/id_ed25519 und ~/.ssh/id_ed25519.pub). Der Verschlüsselungsalgorithmus hier ist ed25519, man könnte auch ecdsa, rsa etc. verwenden

2. Öffentlichen Schlüssel auf den Server kopieren: Nutze ssh-copy-id, um deinen öffentlichen Schlüssel auf den Server zu übertragen:

ssh-copy-id -i ~/.ssh/id_ed25519.pub dein-benutzername@server-ip

3. SSH-Konfiguration auf dem Server anpassen: Öffne die SSH-Daemon-Konfigurationsdatei:

vi /etc/ssh/sshd_config 

Stelle sicher, dass folgende Einstellungen gesetzt sind (füge sie gegebenenfalls ein oder ändere bestehende Zeilen):

# Nur Schlüsselbasierte Authentifizierung erlauben 
PubkeyAuthentication yes 
PasswordAuthentication no 
ChallengeResponseAuthentication no 
# Root-Login per Passwort deaktivieren (optional, empfohlen) 
PermitRootLogin prohibit-password 

Speichere die Datei und schließe den Editor. Dazu erneut den Editor mit „Esc“ -> “ :“ -> „wq“ oder bei nano (Strg+O, Enter, Strg+X) abspeichern und beenden.

4. SSH-Dienst neu starten:

sudo systemctl restart sshd

Nun kann sich der Server nur noch mit einem gültigen Schlüssel anmelden – Passwörter werden nicht mehr akzeptiert.

Bevor ihr eure SSH-Verbindung beendet, prüft noch einmal mit einem zweiten Fenster die Funktionalität, damit ihr euch nicht ausversehen aussperrt !


🔒 Fazit

Mit diesen Maßnahmen hast du Ubuntu 24.04 nicht nur installiert, sondern auch gründlich gehärtet. Durch den Einsatz von UFW schützt du deinen Server bereits an der Netzwerkschnittstelle, Fail2Ban sichert gegen Brute-Force-Angriffe ab, und die ausschließliche Zertifikat-basierte Anmeldung sorgt für eine sehr sichere Authentifizierung.

Diese Kombination aus Firewall, Intrusion Detection und starker Authentifizierung stellt sicher, dass dein Ubuntu-Server optimal gegen Angriffe geschützt ist. Hast du noch Fragen oder weitere Tipps? Teile deine Erfahrungen und Anregungen gern in den Kommentaren!