> For the complete documentation index, see [llms.txt](https://docs.verge.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.verge.io/learn-the-platform/de/modul-10-szenario-labs/lab-hci-compute.md).

# Labor: HCI- und Compute-Bereitstellung

## Zielsetzung

Bereitstellen Sie VergeOS in einer HCI- + Dediziert-Compute-Konfiguration mit dem Terraform-Playground. Sie werden eine Topologie mit zwei Clustern bereitstellen — einen HCI-Grundlagencluster (Controller + Storage) und einen dedizierten Nur-Compute-Cluster — und dann die Workload-Platzierung über die Cluster hinweg konfigurieren, unabhängige Compute-Skalierung validieren und das Betriebsmodell mit reinen HCI-Bereitstellungen vergleichen.

## Voraussetzungen

* Alle vorherigen Module (1–9) abgeschlossen
* Den HCI-Bereitstellungs-Lab und den UCI-Bereitstellungs-Lab abgeschlossen
* Zugriff auf das Repository vergeos-terraform-playground (lokal geklont)
* Terraform-CLI installiert und konfiguriert
* Eine VergeOS-Umgebung oder ein Labor, das verschachtelte Bereitstellungen unterstützt
* Vertrautheit mit den Terraform-Grundlagen (init, plan, apply)

## Schwierigkeitsgrad

**Mittelstufe** — Erfordert Verständnis der VergeOS-Clusterarchitektur, des Multi-Cluster-Netzwerks und grundlegender Terraform-Nutzung

## Geschätzte Zeit

**1,5 Stunden**

***

## Hintergrund: HCI- + Dediziert-Compute-Architektur

Bevor Sie mit dem Lab beginnen, sehen Sie sich das Zwei-Cluster-Modell an, das HCI + Dedicated Compute definiert:

```mermaid
graph TB
    subgraph "Cluster 1: HCI (Controller + Storage ± Compute)"
        N1["Knoten 1<br/>Controller + Storage<br/>Tier 0 + Tier 1"]
        N2["Knoten 2<br/>Controller + Storage<br/>Tier 0 + Tier 1"]
        N3["Knoten 3 (optional)<br/>HCI-Knoten<br/>Storage + Compute*"]
        N4["Knoten 4 (optional)<br/>HCI-Knoten<br/>Storage + Compute*"]
    end
    subgraph "Cluster 2: Nur Compute"
        N5["Knoten 5<br/>Nur Compute"]
        N6["Knoten 6<br/>Nur Compute"]
        N7["Knoten 7<br/>Nur Compute"]
        N8["Knoten 8+<br/>Nur Compute (Skalierung)"]
    end
    Kernnetzwerk["Kernnetzwerk<br/>25–100 GbE"]
    N1 --- CoreNet
    N2 --- CoreNet
    N3 --- CoreNet
    N4 --- CoreNet
    N5 --- CoreNet
    N6 --- CoreNet
    N7 --- CoreNet
    N8 --- CoreNet
```

**Grundprinzipien:**

* **Cluster 1 (HCI)** umfasst immer die Knoten 1 und 2 mit Controllern und Tier-0-Storage. Optionale Knoten 3–4 fügen Storage- und (optional) Compute-Kapazität hinzu.
* **Cluster 2 (Nur Compute)** enthält Knoten, die vollständig für die Ausführung von Workloads vorgesehen sind — kein Storage-Overhead, maximale Ressourcen für VMs.
* Das **Compute-Schalter** im HCI-Cluster steuert, ob HCI-Knoten neben ihren Storage-/Steuerungsfunktionen auch Workloads ausführen dürfen.
* Alle Storage-E/A der Compute-Knoten läuft über das Kernnetzwerk zum HCI-Cluster, weshalb die Bandbreite zwischen den Clustern kritisch ist.

***

## Schritte

### Teil 1: Prüfen der HCI- + Compute-Topologie

Verstehen Sie die Konfiguration vor der Bereitstellung.

1. Navigieren Sie im Repository des Terraform-Playgrounds zum `examples/` Verzeichnis und identifizieren Sie das HCI- + Compute- `.tfvars` Datei (suchen Sie nach Dateien, die sich auf "hci-compute"- oder "hybrid"-Topologien beziehen)
2. Untersuchen Sie die Variablen und identifizieren Sie:
   * Wie viele Cluster definiert sind und welche Rollen sie haben (HCI vs. nur Compute)
   * Knotenanzahl und Zuordnung pro Cluster
   * Das **Compute-Schalter** Einstellung auf dem HCI-Cluster — ist sie aktiviert oder deaktiviert?
   * Konfiguration der Storage-Tiers (Tier 0 für Metadaten auf Controller-Knoten, Tier 1 für Workload-Daten)
   * Netzwerkkonfiguration für die Kommunikation zwischen den Clustern
3. Vergleichen Sie diese `.tfvars` Datei mit den reinen HCI-Konfigurationen aus dem vorherigen Lab. Beachten Sie die strukturellen Unterschiede:
   * Zusätzliche Clusterdefinition für Nur-Compute-Knoten
   * Zuweisung der Storage-Tiers — Nur-Compute-Knoten haben keine Storage-Tiers
   * Anforderungen an die Netzwerkbandbreite zwischen den Clustern
4. Sehen Sie sich die Dokumentation zum Bereitstellungsszenario (`docs/deployment-scenarios.md`) für den Abschnitt HCI + Compute an

### Teil 2: Bereitstellen der HCI- + Compute-Topologie

Stellen Sie die Umgebung mit zwei Clustern bereit.

1. Ausführen `terraform init` um den Provider zu initialisieren (falls noch nicht geschehen)
2. Ausführen `terraform plan -var-file=<hci-compute>.tfvars` und prüfen Sie die geplanten Ressourcen sorgfältig:
   * Überprüfen, dass zwei separate Cluster erstellt werden
   * Bestätigen, dass die Knoten-Zuordnungen der erwarteten Topologie entsprechen
   * Prüfen, dass Storage-Tiers nur HCI-Cluster-Knoten zugewiesen werden
   * Validieren, dass die Netzwerkschnittstellen für die Kommunikation zwischen den Clustern konfiguriert sind
3. Ausführen `terraform apply -var-file=<hci-compute>.tfvars` um bereitzustellen
4. Melden Sie sich in der VergeOS-UI an und überprüfen Sie die Bereitstellung:
   * **Cluster:** Beide Cluster erscheinen — einer mit der Bezeichnung HCI, einer mit der Bezeichnung Compute
   * **Knoten:** Jeder Knoten ist seinem richtigen Cluster zugewiesen
   * **Storage:** vSAN-Storage-Pools existieren nur im HCI-Cluster; bei Nur-Compute-Knoten wird kein Storage angezeigt
   * **Netzwerk:** Das Kernnetzwerk verbindet beide Cluster; die Konnektivität zwischen den Clustern ist hergestellt
   * **Controller:** Controller-VMs laufen auf den Knoten 1 und 2 im HCI-Cluster

### Teil 3: Workload-Platzierung konfigurieren

Üben Sie die Platzierung von Workloads über die Topologie mit zwei Clustern hinweg.

1. **Erstellen Sie eine VM auf dem Nur-Compute-Cluster:**
   * Erstellen Sie in der VergeOS-UI eine neue VM und wählen Sie für die Platzierung den Nur-Compute-Cluster aus
   * Weisen Sie CPU- und Arbeitsspeicherressourcen zu
   * Hängen Sie eine virtuelle Festplatte an — beachten Sie, dass der Storage aus dem vSAN des HCI-Clusters bereitgestellt wird, obwohl die VM auf einem Nur-Compute-Knoten ausgeführt wird
   * Starten Sie die VM und überprüfen Sie, ob sie erfolgreich startet
2. **Erstellen Sie eine VM im HCI-Cluster** (falls Compute aktiviert ist):
   * Erstellen Sie eine zweite VM und platzieren Sie sie diesmal im HCI-Cluster
   * Vergleichen Sie die Ressourcenverfügbarkeit zwischen den beiden Clustern
   * Beachten Sie den Unterschied: HCI-Knoten teilen sich Ressourcen zwischen Storage/Steuerung und Compute, während Nur-Compute-Knoten alle Ressourcen Workloads widmen
3. **Verschieben Sie eine VM in einen anderen Cluster:**
   * Wählen Sie eine VM, die auf dem Nur-Compute-Cluster läuft, und fahren Sie sie herunter (die Cluster-Zuordnung kann während des Betriebs der VM nicht geändert werden)
   * Bearbeiten Sie die VM und ändern Sie das **Cluster** Feld in den HCI-Cluster und schalten Sie die VM dann wieder ein
   * Wiederholen Sie dies bei Bedarf in die andere Richtung (HCI → Nur Compute)
   * Dokumentieren Sie die Einschränkungen: Eine clusterübergreifende Verschiebung erfordert, dass die VM gestoppt ist, und ist **nicht** zustandserhaltend — die VM wird heruntergefahren und im Zielcluster neu gestartet
   * Vergleichen Sie dies mit der in der UI verfügbaren **Migrieren** Aktion, die nur innerhalb eines Clusters möglich ist (sie wählt ein Ziel **Knoten** innerhalb des aktuellen Clusters der VM) und live ohne Herunterfahren der VM ausgeführt werden kann
4. **Überwachen Sie die I/O zwischen den Clustern:**
   * Öffnen Sie das VergeOS-Dashboard und navigieren Sie zur Netzwerküberwachung
   * Beobachten Sie den Storage-I/O-Verkehr, der von den Nur-Compute-Knoten zum HCI-Cluster fließt
   * Beachten Sie die Bandbreitennutzung im Kernnetzwerk — deshalb ist die Planung der Bandbreite zwischen den Clustern so wichtig

### Teil 4: Unabhängige Compute-Skalierung validieren

Demonstrieren Sie den Skalierungsvorteil des HCI- + Compute-Modells.

1. **Kapazität des Nur-Compute-Clusters prüfen:**
   * Prüfen Sie in der VergeOS-UI die gesamte auf dem Nur-Compute-Cluster verfügbare CPU- und Arbeitsspeicherkapazität
   * Vergleichen Sie dies mit den verfügbaren Compute-Ressourcen des HCI-Clusters (nach Storage-/Steuerungs-Overhead)
   * Dokumentieren Sie den Unterschied in der effektiven Compute-Kapazität
2. **Simulieren Sie ein Scale-out-Szenario:**
   * Überprüfen Sie das `.tfvars` Datei und identifizieren Sie, wie zusätzliche Nur-Compute-Knoten hinzugefügt werden
   * Ändern Sie die Knotenzahl für den Nur-Compute-Cluster (z. B. 1–2 weitere Knoten hinzufügen)
   * Ausführen `terraform plan` um die Änderung vorzuschauen — beachten Sie, dass nur Compute-Knoten hinzugefügt werden; Storage bleibt unverändert
   * Wenden Sie die Änderung an und überprüfen Sie, dass die neuen Knoten dem Nur-Compute-Cluster beitreten
   * Bestätigen Sie, dass der HCI-Cluster vollständig unverändert bleibt — kein Rebalancing, keine Storage-Unterbrechung
3. **Skalierungsmodelle vergleichen:**

   | Skalierungsaktion            | Reines HCI                                                  | HCI + Compute                                                 |
   | ---------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------- |
   | Compute-Kapazität hinzufügen | Vollständigen HCI-Knoten hinzufügen (mit Storage)           | Leichten Nur-Compute-Knoten hinzufügen                        |
   | Storage-Kapazität hinzufügen | HCI-Knoten hinzufügen oder vorhandene Festplatten erweitern | Knoten nur zum HCI-Cluster hinzufügen                         |
   | Unabhängig skalieren         | ❌ Compute und Storage gekoppelt                             | ✅ Compute skaliert unabhängig                                 |
   | Hardwareflexibilität         | Alle Knoten benötigen Hardware der Storage-Klasse           | Compute-Knoten für Workloads optimiert                        |
   | Betriebliche Komplexität     | Einfach — ein einzelner Cluster                             | Mäßig — zwei Cluster, Netzwerkanbindung zwischen den Clustern |

### Teil 5: Den Compute-Schalter erkunden

Verstehen Sie die Auswirkungen der Compute-Einstellung des HCI-Clusters.

1. **Den aktuellen Zustand des Compute-Schalters prüfen:**
   * Navigieren Sie in der VergeOS-UI zu den Einstellungen des HCI-Clusters
   * Ermitteln Sie, ob der Compute-Schalter derzeit aktiviert oder deaktiviert ist
   * Falls aktiviert, notieren Sie, welche Workloads (falls vorhanden) auf HCI-Knoten ausgeführt werden
2. **Verstehen Sie die beiden Modi:**

   | Einstellung             | Verhalten                                               | Am besten geeignet für                                                                      |
   | ----------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
   | **Compute aktiviert**   | HCI-Knoten führen Workloads neben Storage/Steuerung aus | Kleinere Bereitstellungen, bei denen die Maximierung der Auslastung bevorzugt wird          |
   | **Compute deaktiviert** | HCI-Cluster nur für Storage und Steuerung reserviert    | Leistungssensitive Umgebungen, in denen die Trennung von Storage und Compute bevorzugt wird |
3. **Dokumentieren Sie Ihre Empfehlung:**
   * Welche Einstellung des Compute-Schalters würden Sie auf Grundlage der aktuellen Bereitstellungsgröße empfehlen?
   * Welche Faktoren würden dazu führen, dass Sie die Einstellung ändern?
   * Hinweis: Das Ändern des Compute-Schalters kann einen Rolling Restart der Knoten im HCI-Cluster erfordern — prüfen Sie die Auswirkungen mit dem VergeOS-Support, bevor Sie diese Änderung in der Produktion vornehmen

### Teil 6: Übung zur Designentscheidung

Wenden Sie an, was Sie gelernt haben, auf ein reales Szenario.

1. **Szenario:** Ein Kunde betreibt derzeit einen VergeOS-HCI-Cluster mit 4 Knoten. Er muss 50 neue VMs für eine Entwicklungsumgebung hinzufügen, benötigt aber keinen zusätzlichen Storage. Die aktuelle Storage-Auslastung beträgt nur 40 %, die CPU-Auslastung liegt jedoch bei 75 %.
2. **Bewerten Sie die Optionen:**
   * **Option A:** 2 weitere HCI-Knoten hinzufügen (HCI-Cluster mit 6 Knoten)
   * **Option B:** Einen Nur-Compute-Cluster mit 2 Knoten hinzufügen (4-Knoten-HCI + 2-Knoten-Compute)
   * **Option C:** Auf vollständige UCI-Architektur migrieren
3. **Dokumentieren Sie für jede Option:**
   * Auswirkungen auf die Hardwarekosten
   * Änderung der betrieblichen Komplexität
   * Netzwerkanforderungen
   * Pfad für zukünftige Skalierbarkeit
   * Ihre Empfehlung mit Begründung
4. **Bonus:** Identifizieren Sie, welches Terraform-Playground-Beispiel Option B am ehesten entspricht, und nennen Sie die `.tfvars` Änderungen, die erforderlich sind, um die Anforderungen des Kunden zu erfüllen

***

## Bereinigung

Wenn Sie mit dem Lab fertig sind:

1. Entfernen Sie alle im Lab erstellten Test-VMs
2. Ausführen `terraform destroy` um die gesamte HCI- + Compute-Bereitstellung abzubauen
3. Überprüfen Sie in der VergeOS-UI, dass alle Ressourcen bereinigt wurden

***

## Verifizierung

Ihr HCI- + Compute-Bereitstellungs-Lab ist abgeschlossen, wenn Sie beantworten können **ja** allen folgenden Punkten antworten kannst:

* [ ] Erfolgreich eine Topologie mit zwei Clustern für HCI + Compute über Terraform bereitgestellt
* [ ] Clusterrollen (HCI vs. nur Compute), Storage-Zuordnung und Netzwerkkonfiguration in der VergeOS-UI verifiziert
* [ ] VMs auf dem Nur-Compute-Cluster erstellt und bestätigt, dass der Storage vom HCI-Cluster bereitgestellt wurde
* [ ] Storage-I/O-Verkehr zwischen den Clustern im Kernnetzwerk überwacht
* [ ] Den Nur-Compute-Cluster erfolgreich unabhängig skaliert (Knoten hinzugefügt, ohne den Storage zu beeinflussen)
* [ ] Das Verhalten des Compute-Schalters und Ihre Empfehlung für die Bereitstellung dokumentiert
* [ ] Die Übung zur Designentscheidung abgeschlossen, in der HCI, HCI+Compute und UCI verglichen werden
* [ ] Alle Laborressourcen bereinigt mit `terraform destroy`


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.verge.io/learn-the-platform/de/modul-10-szenario-labs/lab-hci-compute.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
