Homelab--Bratonein-Kontrollzentrum--Tutorial/Kapitel 9/Free Rohtext.md

# Kapitel 9 – Webspace

In diesem Kapitel baust du dir einen eigenen Webspace-Container im UCC auf.  
Das ist der Platz für alles, was später öffentlich erreichbar sein soll – zum Beispiel deine eigene Website, ein Blog für deine Projekte, ein Online-Shop für Merch oder ein CMS wie WordPress oder Joomla.  

Unser Ziel ist, dir eine solide Grundlage zu geben, auf der du all diese Anwendungen frei installieren kannst, ohne dich von Anfang an auf eine bestimmte Software festlegen zu müssen.

Wir verwenden dafür einen **LXC-Container mit Debian 12** und installieren darin den sogenannten **LAMP-Stack**:  
- **Linux** als Betriebssystem,  
- **Apache** als Webserver,  
- **MariaDB-Client** für Datenbank-Anbindungen (z. B. wenn du später ein CMS installierst),  
- **PHP** für dynamische Inhalte wie Formulare, Login-Seiten oder Shops.  

Diese Kombination ist seit vielen Jahren die Standard-Basis für Webhosting. Sie ist weit verbreitet, gut dokumentiert und wird von fast allen gängigen Webanwendungen unterstützt.

Dein Webspace ist nach diesem Kapitel sofort einsatzbereit:  
Du kannst eine einfache HTML- oder PHP-Seite hochladen und direkt im Browser aufrufen.  
Darauf aufbauend entscheidest du selbst, ob du später ein CMS, einen Shop oder etwas Eigenes installieren möchtest.

Damit der Webspace nicht nur lokal funktioniert, sondern auch aus dem Internet erreichbar ist, binden wir ihn am Ende an den **Nginx Proxy Manager** an.  
Außerdem zeigen wir dir, wie du deine eigene Domain mithilfe des bereits eingerichteten **DynDNS-Dienstes** auf diesen Container leitest.  
So ist deine Seite wahlweise über eine Subdomain im Heimnetz oder über deine echte Internet-Adresse erreichbar – natürlich mit einem gültigen HTTPS-Zertifikat.

--- 

## Voraussetzungen & Ressourcen

Bevor wir mit der eigentlichen Einrichtung des Webspace beginnen, sorgen wir dafür, dass die technische Grundlage stimmt.  
Wir legen hier verbindlich fest, wie der Container ausgestattet sein muss und welche Dienste im UCC bereits vorhanden sein müssen.  
Die Angaben sind absichtlich großzügig gewählt, damit du später auch ein CMS, einen Shop oder andere komplexere Anwendungen betreiben kannst, ohne noch einmal am Container selbst etwas ändern zu müssen.

### Container-Ressourcen

Für den Webspace-Container legen wir folgende Ausstattung fest:

- **CPU:** 4 vCPUs  
  Vier virtuelle Prozessoren stellen sicher, dass der Webserver auch unter Last stabil und schnell bleibt.  
  Das ist wichtig, sobald mehrere Besucher gleichzeitig auf deine Seite zugreifen oder ein CMS viele Datenbankanfragen stellt.

- **RAM:** 4 GB  
  Mit 4 GB Arbeitsspeicher läuft der Apache-Webserver zusammen mit PHP und typischen Erweiterungen flüssig.  
  Einfache statische Webseiten brauchen weniger, aber dynamische Anwendungen wie Shops oder Blogs benötigen zusätzliche Ressourcen, insbesondere bei Updates oder Bildverarbeitung.

- **Speicherplatz:** 20 GB  
  Dieser Platz reicht für die Grundinstallation des Systems, den Webserver und genügend Dateien für erste Projekte.  
  Wenn du später größere Mediendateien wie Fotos, Videos oder Backups auf dem Webspace speichern willst, solltest du beim Anlegen des Containers gleich mehr Speicher zuweisen, um späteren Umbau zu vermeiden.

- **Betriebssystem:** Debian 12 LTS (64-Bit)  
  Debian ist die Basis des gesamten UCC und wird hier ebenfalls für den Webspace verwendet.  
  So bleiben die Schritte einheitlich und wir profitieren von den stabilen Sicherheits- und Support-Updates der LTS-Version.

- **Netzwerk:** Feste IP-Adresse per DHCP-Reservierung  
  Der Container erhält im Router eine feste Adresse innerhalb des DHCP-Bereichs.  
  Das garantiert, dass er immer unter derselben IP erreichbar ist und vermeidet Konflikte, falls der Router Adressen neu vergibt.  
  Wie du die DHCP-Reservierung einrichtest, hast du bereits in Kapitel 1 gelernt.

[!TIP]
Wenn du schon weißt, dass du sehr große Projekte umsetzen wirst (z. B. hochauflösende Bildgalerien oder umfangreiche Shops), plane den Speicherplatz beim Erstellen des Containers gleich noch größer ein.  
Eine spätere Erweiterung ist zwar möglich, aber deutlich aufwendiger.

### Voraussetzungen im UCC

Neben der Ausstattung des Containers müssen folgende Komponenten aus den vorherigen Kapiteln bereits eingerichtet sein:

- **Proxmox-Host** – läuft betriebsbereit und ist über die Weboberfläche erreichbar (Kapitel 1).  
  Hier legst du den neuen Container an und kannst ihn jederzeit verwalten.

- **Nginx Proxy Manager (NPM)** – wurde in Kapitel 3 eingerichtet und ist weiterhin aktiv.  
  Wir brauchen ihn, um den Webspace später unter einer Subdomain oder deiner eigenen Domain bereitzustellen und automatisch ein HTTPS-Zertifikat zu vergeben.

- **DynDNS-Dienst und Domain** – wie in Kapitel 4 konfiguriert.  
  Damit kannst du den Webspace aus dem Internet unter deiner eigenen Domain erreichen.  
  Auch wenn du den Webspace zunächst nur im Heimnetz nutzt, ist es sinnvoll, die DynDNS-Funktion bereitzuhalten, um später ohne Mehraufwand nach außen zu veröffentlichen.

- **Zugriff auf die Proxmox-Shell oder SSH-Verbindung** – du benötigst einen funktionierenden Zugang, um den Container nach der Erstellung einzurichten.  
  Die meisten Befehle in diesem Kapitel führst du direkt in der Shell des Containers aus.

[!IMPORTANT]
Der Webspace ist nach der Grundinstallation zunächst nur im internen Netzwerk erreichbar.  
Die Anbindung an den Proxy Manager und die öffentliche Domain erfolgt erst am Ende des Kapitels, wenn der Webserver vollständig installiert und getestet ist.

---

### Schritt für Schritt

In den folgenden Schritten bereiten wir den Webspace-Container so vor, dass wir darauf den Webserver und alle benötigten Komponenten installieren können.  
Wir beginnen mit einem sauberen und aktualisierten Grundsystem.  
Dieser Schritt ist wichtig, um spätere Fehler bei der Installation und beim Betrieb zu vermeiden.

### Schritt 1 – Grundsystem aktualisieren

Öffne die Konsole des Webspace-Containers.  
Das geht in Proxmox über den Button **Shell**, wenn du den Container in der linken Seitenleiste ausgewählt hast.  
Alternativ kannst du dich auch per SSH mit dem Container verbinden, falls du den Zugang bereits eingerichtet hast.

Sobald die Konsole geöffnet ist, aktualisieren wir das komplette System auf den neuesten Stand.  
Gib dazu folgenden Befehl ein und bestätige mit der Eingabetaste:

```bash
apt update && apt upgrade -y
```

Der Befehl `apt update` lädt die aktuellen Paketlisten von den Debian-Servern.  
Anschließend installiert `apt upgrade -y` alle verfügbaren Updates.  
Je nachdem, wie viele Pakete aktualisiert werden müssen, kann dieser Schritt einige Minuten dauern.

Sobald die Aktualisierung abgeschlossen ist, muss der Container neu gestartet werden, damit alle neuen Versionen korrekt geladen werden.  
Führe dazu folgenden Befehl aus:

```bash
reboot
```

[!NOTE]
Auch wenn bei der Aktualisierung nur wenige Pakete geändert wurden, ist der Neustart Pflicht.  
Er stellt sicher, dass alle aktualisierten Bibliotheken und Dienste aktiv sind, bevor wir mit der Installation des Webservers beginnen.

### Schritt 2 – Apache Webserver und PHP installieren

Nachdem das Grundsystem auf den neuesten Stand gebracht wurde, installieren wir jetzt den eigentlichen Webserver und die PHP-Unterstützung.  
Diese beiden Komponenten bilden die Grundlage für alle Webseiten, egal ob du später nur statische HTML-Seiten oder ein komplettes CMS wie WordPress betreibst.

Öffne dafür erneut die Konsole des Webspace-Containers in Proxmox über den Button **Shell**.

👉 Screenshot geeignet: Proxmox – Container ausgewählt und Konsole geöffnet

Gib anschließend folgenden Befehl ein und bestätige mit der Eingabetaste:

```bash
apt install -y apache2 php libapache2-mod-php php-mysql php-gd php-curl php-xml php-mbstring mariadb-client unzip curl
```

Dieser Befehl installiert den Apache-Webserver sowie PHP mitsamt den wichtigsten Erweiterungen und einigen Hilfsprogrammen:

- **apache2** liefert die Webseiten aus.  
- **php** und **libapache2-mod-php** ermöglichen das Ausführen von dynamischen PHP-Anwendungen.  
- **php-mysql**, **php-gd**, **php-curl**, **php-xml**, **php-mbstring** sind die Standardmodule, die fast alle gängigen CMS und Shops benötigen.  
- **mariadb-client** erlaubt den Zugriff auf Datenbanken, falls du später z. B. WordPress oder Shop-Systeme installierst.  
- **unzip** und **curl** werden zum Herunterladen und Entpacken von Dateien gebraucht.

👉 Screenshot geeignet: Konsole nach erfolgreichem Abschluss der Paketinstallation

[!NOTE]
Die Installation kann – abhängig von Internetgeschwindigkeit und Container-Leistung – einige Minuten dauern.  
Warte, bis die Installation komplett beendet ist, bevor du weitermachst.

Damit der Webserver bei jedem Start des Containers automatisch aktiv ist und sofort einsatzbereit bleibt, schalten wir ihn nun dauerhaft ein und starten ihn gleich:

```bash
systemctl enable --now apache2
```

[!TIP]
Um sicherzugehen, dass der Dienst läuft, kannst du den Status prüfen:

```bash
systemctl status apache2
```

👉 Screenshot geeignet: Konsole mit Statusanzeige von Apache „active (running)“

Damit ist der Webserver erfolgreich installiert und einsatzbereit.  
Im nächsten Schritt richten wir eine einfache Testseite ein, um die Funktion zu überprüfen.

### Schritt 3 – Testseite für Apache und PHP anlegen

Bevor wir den Webserver mit echten Projekten nutzen, prüfen wir, ob Apache und die PHP-Unterstützung korrekt arbeiten.  
Dafür legen wir im Standard-Webverzeichnis eine kleine Testseite an.

Das Hauptverzeichnis für Webseiten des Apache-Webservers liegt standardmäßig unter:

```bash
cd /var/www/html
```

Erstelle dort eine neue Datei mit dem Namen `info.php`:

```bash
nano info.php
```

👉 Screenshot geeignet: Konsole mit geöffneter Datei `info.php` im Nano-Editor

Füge in die leere Datei die folgende Zeile ein und speichere anschließend mit **STRG+O**, **Enter**, und beende den Editor mit **STRG+X**:

```php
<?php phpinfo(); ?>
```

👉 Screenshot geeignet: Inhalt der Datei `info.php` im Editor vor dem Speichern

Diese Seite zeigt später alle aktiven PHP-Module und dient als Funktionstest.

Öffne jetzt auf einem beliebigen Rechner im Heimnetz einen Webbrowser und rufe die IP-Adresse des Webspace-Containers auf.  
Füge hinten an die Adresse `/info.php` an, zum Beispiel:

```
http://192.168.1.109/info.php
```

👉 Screenshot geeignet: Browser mit geöffneter PHP-Info-Seite

Wenn alles richtig installiert ist, erscheint die PHP-Info-Seite mit einer Übersicht der aktiven Module.  
Damit ist bestätigt, dass Apache und PHP funktionieren und bereit für deine Webseiten sind.

[!TIP]
Lösche die Testdatei wieder, sobald du den Test erfolgreich durchgeführt hast.  
Solche Informationsseiten sollten aus Sicherheitsgründen nicht dauerhaft öffentlich zugänglich bleiben:

```bash
rm /var/www/html/info.php
```

### Schritt 4 – Webspace im Nginx Proxy Manager einbinden

Öffne den **Nginx Proxy Manager** und lege einen neuen Proxy-Host für den Webspace an.

1) **Anmelden** im NPM-Dashboard  
👉 Screenshot geeignet: NPM – Dashboard nach Login

2) Klicke auf **Add Proxy Host**

3) Trage im Reiter **Details** folgende Werte ein:

| Feld                          | Wert / Auswahl                          |
|--------------------------------|-----------------------------------------|
| **Domain Names**              | `webspace.deinedomain.tld`              |
| **Scheme**                    | `http`                                  |
| **Forward Hostname / IP**     | IP-Adresse des Webspace-Containers      |
| **Forward Port**              | `80`                                    |
| **Block Common Exploits**     | aktivieren                              |
| **Websockets Support**        | aktivieren                              |

👉 Screenshot geeignet: Formular „Add Proxy Host“ mit eingetragener IP und Port 80

4) Wechsle zu **SSL** und setze:

| Feld                              | Einstellung               |
|-----------------------------------|---------------------------|
| **Request a new SSL Certificate** | aktivieren                |
| **Force SSL**                     | aktivieren                |
| **HTTP/2 Support**                | aktivieren                |

👉 Screenshot geeignet: SSL-Tab mit aktivierter Option „Force SSL“

5) Klicke **Save**, um den Proxy-Host anzulegen.

Nach wenigen Sekunden ist der Webspace über die Subdomain erreichbar, z. B.:  
`https://webspace.deinedomain.tld`

👉 Screenshot geeignet: Browser – Apache-Standardseite über die Subdomain aufgerufen

[!TIP]  
Falls der Zugriff auch von außen möglich sein soll, muss im Router Port 443 auf den NPM-Host weitergeleitet werden.

### Schritt 5 – Eigene Domain (TLD) mit DynDNS verbinden

Wenn der Webspace nicht nur über eine Subdomain erreichbar sein soll, sondern direkt unter deiner Haupt-Domain, kannst du die TLD beim Domain-Anbieter als DynDNS-Ziel eintragen.  
Fast alle gängigen Hoster unterstützen dies direkt im Kundenportal.

Öffne dazu die DNS-Verwaltung deines Domain-Anbieters und setze den **A-Record (für IPv4)** und – falls du IPv6 nutzt – den **AAAA-Record** auf die DynDNS-Adresse, die du in Kapitel 4 eingerichtet hast.

[!TIP]  
Sobald die DNS-Änderung aktiv ist, zeigt deine Domain automatisch auf den Webspace.  
Im Nginx Proxy Manager sind keine weiteren Schritte erforderlich.

[!NOTE]  
Falls dein Domain-Anbieter die IP-Adresse nicht automatisch aktualisiert, siehe **Kapitel 3 Premium**.  
Dort ist beschrieben, wie du die automatische Aktualisierung des DynDNS-Eintrags sicherstellst.

---

## Nächste Schritte – Erste Nutzung des Webspace

Der Webspace ist jetzt betriebsbereit und über die eingerichtete Subdomain mit aktivem HTTPS erreichbar.  
Damit hast du eine stabile Grundlage für alles, was du online präsentieren möchtest.  
Hier erfährst du, wie du sofort loslegen kannst.

### Dateien und Webseiten hochladen
Die Standard-Webseite von Apache liegt im Verzeichnis:

```bash
/var/www/html
```

Alles, was du in dieses Verzeichnis kopierst oder dort anlegst, wird beim Aufruf deiner Domain angezeigt.  
Du kannst also direkt deine eigene `index.html` oder `index.php` hochladen, um die Standardseite zu ersetzen.

[!TIP]
Wenn du per **SFTP** auf den Container zugreifen möchtest, kannst du dich mit denselben Zugangsdaten einloggen, die du für den Container verwendest.  
Viele FTP-Programme wie **FileZilla** oder **WinSCP** unterstützen SFTP und erleichtern den Upload von Dateien.

👉 Screenshot geeignet: SFTP-Client mit Verbindung zum Container und geöffnetem Verzeichnis `/var/www/html`

### Ein erstes Beispiel
Lege zum Testen eine neue HTML-Datei an:

```bash
nano /var/www/html/index.html
```

Füge folgenden Inhalt ein:

```html
<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <title>Willkommen im Webspace</title>
</head>
<body>
  <h1>Dein Webspace ist bereit!</h1>
  <p>Diese Seite wird aus dem neuen LAMP-Stack geladen.</p>
</body>
</html>
```

Speichere die Datei und rufe im Browser deine Domain auf.  
Die Standardseite wurde durch deine eigene ersetzt.

👉 Screenshot geeignet: Browser mit der selbst erstellten Willkommensseite

### Erste CMS-Installation (optional)
Falls du gleich ein Content-Management-System installieren möchtest (z. B. WordPress oder Joomla), lade die Installationsdateien in dasselbe Verzeichnis hoch und folge dem jeweiligen Einrichtungsassistenten im Browser.  
Die in Schritt 2 installierten PHP-Module decken die gängigen Anforderungen bereits ab.

[!TIP]
Lege für komplexere Anwendungen wie CMS oder Shops ein separates Verzeichnis unterhalb von `/var/www/` an, z. B. `/var/www/wordpress`, um deine Projekte sauber voneinander zu trennen.

### Pflege und Updates
Führe regelmäßig folgende Befehle im Container aus, um das System aktuell zu halten:

```bash
apt update && apt upgrade -y
```

[!IMPORTANT]
Aktualisiere auch deine CMS-Software und Plugins, sobald neue Versionen verfügbar sind.  
So bleibt dein Webspace sicher und stabil.

Mit diesen Schritten kannst du sofort beginnen, eigene Inhalte zu veröffentlichen.  
Der Webspace ist so vorbereitet, dass du weder für statische Seiten noch für gängige CMS zusätzliche Module installieren musst.  
Im Premium-Kapitel erfährst du später, wie du den Webspace für professionelle Workflows optimierst – zum Beispiel mit Git-basiertem Deployment und Staging-Umgebungen.

---

## Troubleshooting & Tipps

Auch wenn die Einrichtung des Webspace in der Regel problemlos verläuft, können im Betrieb typische Fehler auftreten.  
Die folgenden Hinweise helfen dir, die häufigsten Probleme in dieser frühen Phase zu erkennen und zu beheben, ohne dass du tief in die Technik einsteigen musst.

### Webspace ist nicht erreichbar
Wenn beim Aufruf der Subdomain im Browser nichts geladen wird oder eine Fehlermeldung erscheint, prüfe zuerst, ob der Webspace-Container in Proxmox gestartet ist.  
Öffne dazu das Proxmox-Dashboard und starte den Container gegebenenfalls neu.  
Lade danach im Browser die interne IP-Adresse, zum Beispiel:

```
http://192.168.x.x
```

Erscheint die Apache-Standardseite, läuft der Container.  
Lädt die Seite trotzdem nicht über die Subdomain, liegt das Problem meistens am Proxy-Eintrag im Nginx Proxy Manager.  
Öffne den Eintrag und prüfe, ob die korrekte IP-Adresse des Containers und Port 80 eingetragen sind und ob das SSL-Zertifikat aktiv ist.  
Wenn du den Webspace von außerhalb des Heimnetzes erreichen möchtest, kontrolliere außerdem, ob im Router die Ports 80 und 443 auf den NPM-Host weitergeleitet werden.

👉 Screenshot geeignet: NPM – Proxy-Host-Eintrag mit IP und Port

### Browser meldet „Verbindung nicht sicher“
Zeigt der Browser trotz Proxy-Eintrag ein Warnsymbol oder die Meldung über eine unsichere Verbindung, liegt das meist am SSL-Zertifikat.  
Öffne den NPM, wechsle in den Eintrag für den Webspace und dort in den Reiter **SSL**.  
Prüfe, ob die Option **„Request a new SSL Certificate“** aktiviert ist und fordere das Zertifikat bei Bedarf erneut an.  
Achte darauf, dass die Ports 80 und 443 im Router freigegeben sind, damit Let’s Encrypt die Zertifikate ausstellen und verlängern kann.

👉 Screenshot geeignet: NPM – Reiter SSL mit aktiver Zertifikatserneuerung

### Testseite oder PHP-Info wird nicht angezeigt
Wenn die PHP-Info-Seite oder deine erste HTML-Seite nicht geladen wird, kontrolliere zunächst, ob die Datei im Verzeichnis

```
/var/www/html
```

liegt und korrekt benannt ist – die Startseite muss entweder `index.html` oder `index.php` heißen.  
Prüfe außerdem, ob der Apache-Webserver läuft:

```bash
systemctl status apache2
```

Falls der Dienst gestoppt ist, starte ihn mit:

```bash
systemctl start apache2
```

Leere anschließend den Browser-Cache oder lade die Seite mit **Strg + F5** neu.

### Neue Dateien erscheinen nicht im Browser
Wenn du neue Inhalte hochlädst, aber weiterhin die alte Seite angezeigt wird, liegt das fast immer am Cache.  
Leere den Browser-Cache oder lade die Seite mit **Strg + F5** neu.  
Kontrolliere zusätzlich, ob die hochgeladene Startdatei `index.html` oder `index.php` heißt, da Apache diese als Standardseite erwartet.  
Wenn du per SFTP hochlädst, prüfe auch die Dateirechte im Zielverzeichnis `/var/www/html`.

### Probleme mit DynDNS oder Subdomain
Wenn der Webspace unter der Haupt-Domain nicht erreichbar ist, prüfe beim Domain-Anbieter, ob der A-Record (IPv4) und gegebenenfalls der AAAA-Record (IPv6) korrekt auf den DynDNS-Namen aus Kapitel 4 zeigen.  
Es kann bis zu 24 Stunden dauern, bis DNS-Änderungen weltweit aktiv sind.  
Wenn du eine automatische Aktualisierung benötigst, findest du die Anleitung dazu in **Kapitel 3 Premium**.

### Updates schlagen fehl
Bei der Aktualisierung des Containers mit

```bash
apt update && apt upgrade
```

können manchmal Fehlermeldungen zu defekten Paketen erscheinen.  
Diese lassen sich in den meisten Fällen mit folgendem Befehl beheben:

```bash
apt --fix-broken install
```

Wiederhole anschließend das Upgrade:

```bash
apt upgrade -y
```

Falls ein einzelnes Modul Probleme verursacht, prüfe die Meldung und entferne das betroffene Paket vorübergehend.

[!TIP]  
Führe mindestens einmal im Monat ein Update des Containers durch, damit Apache, PHP und alle installierten Module aktuell und sicher bleiben.

---

## Abschluss

Mit diesem Kapitel hast du einen vollwertigen Webspace in dein UCC integriert – inklusive Webserver, PHP-Unterstützung, sicherem Zugriff über den Nginx Proxy Manager und optionaler Verbindung mit deiner eigenen Domain.  
Damit steht dir nun eine stabile und vielseitige Plattform zur Verfügung, die für nahezu jedes Webprojekt genutzt werden kann.

Du hast gelernt, wie du das Grundsystem des Containers vorbereitest, den LAMP-Stack installierst und mit einer Testseite überprüfst, dass der Webserver korrekt arbeitet.  
Durch die Einbindung in den Nginx Proxy Manager ist der Webspace nicht nur über eine Subdomain, sondern auch mit einem gültigen SSL-Zertifikat erreichbar.  
Falls du deine Haupt-Domain (TLD) nutzen möchtest, kannst du diese per DynDNS auf den Webspace leiten und bei Bedarf mit Hilfe von **Kapitel 3 Premium** die automatische Aktualisierung der DNS-Einträge einrichten.

Der Webspace ist nun so vorbereitet, dass du sofort eigene statische Inhalte veröffentlichen kannst – zum Beispiel eine einfache Startseite oder eine Informationsseite für dein Projekt.  
Für dynamische Anwendungen wie Blogs, Online-Shops oder komplexe CMS-Lösungen findest du im **Premium-Kapitel** die passenden Anleitungen zur Installation, Konfiguration und Absicherung.

[!TIP]  
Lösche die PHP-Info-Testseite, sobald du den Funktionstest abgeschlossen hast, um keine internen Serverinformationen nach außen preiszugeben.

[!IMPORTANT]  
Führe regelmäßig Updates aus, um den Webserver und alle installierten Pakete auf dem aktuellen Stand zu halten:

```bash
apt update && apt upgrade -y
```

Auch alle später von dir installierten Anwendungen und deren Erweiterungen benötigen regelmäßige Aktualisierungen, um sicher und stabil zu bleiben.

Mit dieser Basis ist dein UCC bereit für eigene Webauftritte – von der einfachen statischen Webseite bis hin zu professionellen Projekten, die du im Premium-Kapitel einrichtest.  
Dort zeigen wir dir auch, wie du den Webspace um **Git-basiertes Deployment**, **Staging-Umgebungen**, **optimierte Sicherheitskonzepte** und **Backup-Strategien** erweiterst.  
So kannst du den Webspace schrittweise zu einer leistungsfähigen Plattform für professionelle Projekte ausbauen.