> 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-1-architekturgrundlagen/05-clusters-nodes.md).

# Cluster & Knotentypen

Erfahren Sie, wie VergeOS physische Server in Cluster organisiert, verstehen Sie die verschiedenen Knotentypen (Controller, Scale-out, nur Speicher, nur Compute) und wie Systeme skalieren.

## Was ist ein Cluster?

Ein **Cluster** In VergeOS ist ein Cluster eine logische Gruppierung von Knoten mit denselben Hardwareeigenschaften, die einen Ressourcenpool bildet, der in der VergeOS-Benutzeroberfläche als nutzbare Ressourcen dargestellt wird. Cluster ermöglichen effiziente Verwaltung, Skalierung und hohe Verfügbarkeit für virtualisierte Workloads.

Jedes VergeOS-System beginnt mit mindestens einem Cluster — die ersten beiden Controller-Knoten bilden während der Installation den ersten Cluster. Von dort aus können Sie Knoten zum bestehenden Cluster hinzufügen oder zusätzliche Cluster mit unterschiedlichen Rollen und Hardwareprofilen erstellen.

### Warum Cluster wichtig sind

Cluster dienen mehreren Zwecken:

* **Compute-Isolierung** — CPU, Speicher und VM-Workloads sind an einen bestimmten Cluster gebunden. VMs laufen nur auf Knoten innerhalb ihres zugewiesenen Clusters (mit optionalem Failover zu einem anderen Cluster).
* **Gemeinsamer Speicherpool** — vSAN-Tiers erstrecken sich über Cluster hinweg zu einem einzigen logischen Speicherpool. Ein Speicherlaufwerk auf Cluster 1 und ein Speicherlaufwerk auf Cluster 2 können beide zum selben Tier beitragen. Compute-only-Knoten greifen über das Core Fabric auf diesen gemeinsam genutzten Speicher zu.
* **Hardwareoptimierung** — Verschiedene Cluster können unterschiedliche Hardwareprofile haben: Knoten mit viel Arbeitsspeicher für Datenbanken, mit GPUs ausgestattete Knoten für Rendering, NVMe-dichte Knoten für speicherintensive Workloads
* **Unabhängige Skalierung** — Fügen Sie einem Cluster Compute-Kapazität hinzu, ohne andere zu beeinflussen; der Speicher skaliert über das gesamte System

## Cluster-Typen

VergeOS unterstützt drei verschiedene Cluster-Typen, die innerhalb eines einzigen Systems kombiniert werden können:

| Clustertyp           | Bietet             | vSAN-Beteiligung                                       | Typischer Anwendungsfall                                     |
| -------------------- | ------------------ | ------------------------------------------------------ | ------------------------------------------------------------ |
| **Kombiniert (HCI)** | Compute + Speicher | Ja — Knoten tragen Speicherlaufwerke zu vSAN-Tiers bei | Allgemeine Workloads, kleine bis mittlere Bereitstellungen   |
| **Nur Speicher**     | Nur Speicher       | Ja — Knoten tragen nur Speicher bei                    | Dedizierte Speichererweiterung in UCI-Architekturen          |
| **Nur Compute**      | Nur Compute        | Nein — nur Boot oder PXE-Boot                          | Workloads mit hoher Rechenlast (ML, Rendering, Datenanalyse) |

**Häufige Bereitstellungsbeispiele:**

```mermaid
graph TB
    subgraph hci["HCI (Einzelcluster)"]
        N1["Controller 1<br/>Compute + Speicher"]
        N2["Controller 2<br/>Compute + Speicher"]
        N3["Scale-out<br/>Compute + Speicher"]
    end

    subgraph hybrid["Hybrid (2 Cluster)"]
        H1["Controller 1<br/>Speicher + Verwaltung"]
        H2["Controller 2<br/>Speicher + Verwaltung"]
        HC1["Compute-Knoten 1"]
        HC2["Compute-Knoten 2"]
    end

    subgraph uci["UCI (3 Cluster)"]
        U1["Controller 1<br/>Verwaltung"]
        U2["Controller 2<br/>Verwaltung"]
        US1["Speicherknoten 1"]
        US2["Speicherknoten 2"]
        UC1["Compute-Knoten 1"]
        UC2["Compute-Knoten 2"]
    end

    style N1 fill:#e3f2fd,stroke:#1565c0
    style N2 fill:#e3f2fd,stroke:#1565c0
    style N3 fill:#e3f2fd,stroke:#1565c0
    style H1 fill:#e3f2fd,stroke:#1565c0
    style H2 fill:#e3f2fd,stroke:#1565c0
    style HC1 fill:#fff3e0,stroke:#e65100
    style HC2 fill:#fff3e0,stroke:#e65100
    style U1 fill:#e3f2fd,stroke:#1565c0
    style U2 fill:#e3f2fd,stroke:#1565c0
    style US1 fill:#e8f5e9,stroke:#2e7d32
    style US2 fill:#e8f5e9,stroke:#2e7d32
    style UC1 fill:#fff3e0,stroke:#e65100
    style UC2 fill:#fff3e0,stroke:#e65100
```

## Knotentypen

Jeder physische Server in einem VergeOS-System ist ein **Knoten**. Knoten unterscheiden sich darin, wie sie dem System beitreten, welche Rolle sie spielen und zu welchem Cluster sie gehören. VergeOS definiert vier Knotentypen:

### Controller-Knoten

Jedes VergeOS-System beginnt mit mindestens zwei **Controller-Knoten**. Ein dritter Controller-Knoten ist für N+2-Redundanz erforderlich. Sie sind besonders, weil:

* **Knoten 1** erstellt ein brandneues VergeOS-System. Er initialisiert vSAN, erstellt den ersten Cluster und führt die Konfiguration nach der Installation aus (Netzwerkeinrichtung, Clustererstellung für zusätzliche Knotentypen usw.)
* **Knoten 2** tritt dem von Knoten 1 erstellten System als zweiter Controller bei und sorgt für Redundanz aller Systemverwaltungsfunktionen (N+1)
* **Knoten 3 (optional)** — ein dritter Controller-Knoten kann für N+2-Redundanz hinzugefügt werden, sodass das System zwei gleichzeitige Knotenausfälle verkraften kann

Controller-Knoten gehören immer zu **Cluster 1**. In einer HCI-Topologie stellen sie sowohl Compute als auch Speicher bereit. In einer Hybrid-Topologie stellen sie häufig **nur Speicher und Verwaltung** bereit — keine Produktions-VMs — während ein separater Compute-Cluster alle Workloads übernimmt. In einer vollständigen UCI-Topologie verwalten sie das System, delegieren Speicher und Compute jedoch an dedizierte Cluster.

Der erste Cluster muss mindestens zwei Knoten mit **Tier-0-Speicher** (Metadatenlaufwerke) umfassen — das ist eine harte Anforderung, da Tier 0 den vSAN-Dateisystemindex enthält und redundant sein muss.

### Scale-out-Knoten

Scale-out-Knoten erweitern einen bestehenden HCI-Cluster, indem sie zusätzliche Compute- und Speicherkapazität hinzufügen. Wichtige Merkmale:

* **Identische Hardware** zu den Controller-Knoten in dem Cluster, dem sie beitreten (gleiche CPU-Generation, ähnliches Speicherlayout, passende NIC-Konfiguration)
* Per USB installieren und den Knotentyp Scale-out auswählen. Das Installationsprogramm erkennt das Core Fabric automatisch, dann authentifiziert sich der Operator mit Admin-Anmeldedaten. Wenn mehrere Cluster vorhanden sind, wählt der Operator außerdem den Zielcluster und einen Referenzknoten aus, mit dem die Hardware verglichen wird
* Datenträger werden automatisch den vorhandenen vSAN-Tiers hinzugefügt
* Tragen sowohl Compute (führen VMs aus) als auch Speicher (vSAN-Beteiligung) bei

Scale-out-Knoten sind der einfachste Weg, eine HCI-Bereitstellung zu vergrößern — fügen Sie einen Knoten hinzu, und die Compute- und Speicherkapazität des Clusters steigt proportional.

### Nur-Speicher-Knoten

Nur-Speicher-Knoten sind ausschließlich der Erweiterung der vSAN-Kapazität gewidmet. Sie:

* Tragen Datenträger zu vSAN-Tiers bei, führen aber **nicht** VM-Workloads aus
* Gehören zu einem **Nur-Speicher-Cluster** (z. B. Cluster 2)
* Erfordern das Erstellen des Speicherclusters in der VergeOS-Benutzeroberfläche, bevor der erste Speicherknoten hinzugefügt wird
* Werden in UCI-Architekturen verwendet, in denen Speicher und Compute unabhängig skalieren

### Nur-Compute-Knoten

Nur-Compute-Knoten stellen Rechenleistung bereit, ohne an der vSAN-Speicherung teilzunehmen. Sie:

* Führen VM-Workloads aus, haben aber **keinen lokalen vSAN-Speicher** (nur Boot-Datenträger oder PXE-Boot)
* Gehören zu einem **Nur-Compute-Cluster** (z. B. Cluster 3)
* Erfordern das Erstellen des Compute-Clusters in der VergeOS-Benutzeroberfläche, bevor der erste Compute-Knoten hinzugefügt wird
* Greifen über das Core Fabric auf Speicher von Knoten in HCI- oder Nur-Speicher-Clustern zu

Nur-Compute-Knoten sind ideal für Workloads, die eine hohe CPU-/RAM-/GPU-Dichte ohne proportionalen Speicherzuwachs benötigen — Machine Learning, Rendering, Datenanalyse oder VDI.

### Zusammenfassung der Knotentypen

| Knotentyp                 | Rolle                                | Cluster    | vSAN                         | Führt VMs aus            | Beitrittsmethode                           |
| ------------------------- | ------------------------------------ | ---------- | ---------------------------- | ------------------------ | ------------------------------------------ |
| **Controller (Knoten 1)** | Erstellt neues System                | Cluster 1  | Ja (Tier 0 + Workload-Tiers) | Ja (HCI) oder Nein (UCI) | Erstellung eines neuen Systems             |
| **Controller (Knoten 2)** | Tritt als redundanter Controller bei | Cluster 1  | Ja (Tier 0 + Workload-Tiers) | Ja (HCI) oder Nein (UCI) | Tritt Cluster 1 bei                        |
| **Scale-out**             | Fügt HCI-Kapazität hinzu             | Cluster 1  | Ja (Workload-Tiers)          | Ja                       | Automatische Erkennung im Core Fabric      |
| **Nur-Speicher**          | Dedizierte Speichererweiterung       | Cluster 2+ | Ja (Workload-Tiers)          | Nein                     | Tritt dem vorgesehenen Speichercluster bei |
| **Nur-Compute**           | Dedizierte Compute-Erweiterung       | Cluster 2+ | Nein (nur Boot / PXE)        | Ja                       | Tritt dem vorgesehenen Compute-Cluster bei |

{% hint style="info" %}
**Von VMware oder Nutanix kommend?**

Keine der beiden Plattformen hat innerhalb eines einzelnen Clusters ein natives Konzept für Nur-Speicher- oder Nur-Compute-Mitglieder. VergeOS schon, und es ermöglicht Ihnen, Cluster für eine unabhängige Skalierung zu typisieren.

| VergeOS-Knotenrolle | Nächstes Gegenstück in VMware vSphere                                                          | Nächstes Gegenstück in Nutanix                                                               |
| ------------------- | ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Controller          | ESXi-Host + vCenter-Dienste (keine separate Appliance)                                         | Erster Knoten in einem Cluster; VergeOS-Controller laufen auf Bare Metal, nicht in einer CVM |
| Scale-out           | Zusätzlicher ESXi-Host, der einem vSAN-Cluster beitritt                                        | Zusätzlicher Knoten, der einem Nutanix-Cluster beitritt                                      |
| Nur-Speicher        | Kein natives Äquivalent (vSAN Witness ist am ehesten vergleichbar)                             | Kein Äquivalent — jeder Nutanix-Knoten führt eine CVM aus und beteiligt sich am Compute      |
| Nur-Compute         | ESXi-Host ohne lokales vSAN, der externen Speicher einbindet (hier: vSAN über das Core Fabric) | Kein direktes Äquivalent                                                                     |

VMware- und Nutanix-Cluster sind homogen; VergeOS-Cluster können HCI, Nur-Speicher oder Nur-Compute sein, und ein System kann mehrere unterschiedlich typisierte Cluster kombinieren.
{% endhint %}

## Wie Knoten einem System beitreten

Der Knotenbeitrittsprozess folgt einer strikten Reihenfolge, um Race Conditions zu vermeiden:

```mermaid
flowchart TD
    A["Knoten 1 (Controller)<br/>Erstellt neues VergeOS-System<br/>Initialisiert vSAN, erstellt Cluster 1"] --> B["Knoten 2 (Controller)<br/>Tritt Cluster 1 bei<br/>Stellt ein HA-Paar her"]
    B --> C{"Weitere Knoten?"}
    C -->|"Scale-out"| D["Scale-out-Knoten<br/>Erkennt das System automatisch im Core Fabric<br/>Tritt Cluster 1 nacheinander bei"]
    C -->|"Storage-only"| E["Speichercluster erstellen<br/>(Cluster 2 in der UI)"]
    C -->|"Compute-only"| F["Compute-Cluster erstellen<br/>(Cluster 2 oder 3 in der UI)"]
    E --> G["Speicherknoten<br/>Treten nacheinander dem Speichercluster bei"]
    F --> H["Compute-Knoten<br/>Treten nacheinander dem Compute-Cluster bei"]
    G --> F

    style A fill:#e3f2fd,stroke:#1565c0
    style B fill:#e3f2fd,stroke:#1565c0
    style D fill:#e3f2fd,stroke:#1565c0
    style G fill:#e8f5e9,stroke:#2e7d32
    style H fill:#fff3e0,stroke:#e65100
```

Wichtige Regeln für den Knotenbeitritt:

1. **Knoten 1 muss die Installation abschließen** bevor Knoten 2 beitreten kann — Knoten 2 benötigt ein vorhandenes System, mit dem er sich verbinden kann
2. **Knoten treten nacheinander bei** innerhalb eines Clusters — Knoten 3 nach Knoten 2, Knoten 4 nach Knoten 3 usw. — um Race Conditions bei Änderungen der Clusterzugehörigkeit zu vermeiden
3. **Speichercluster müssen vorhanden sein** bevor Speicherknoten beitreten können — erstellen Sie den Cluster zuerst in der VergeOS-Benutzeroberfläche
4. **Compute-Cluster müssen vorhanden sein** bevor Compute-Knoten beitreten können — dieselbe Voraussetzung
5. **Wenn sowohl Speicher- als auch Compute-Cluster bereitgestellt werden**, sollten Speicherknoten zuerst hinzugefügt werden, damit Compute-Knoten sofort auf vSAN-Speicher zugreifen können

## Cluster-Nummerierung und -Benennung

Cluster werden ab 1 nummeriert, aber der **Name ist frei wählbar** — Sie können einem Cluster beliebig einen Namen geben und ihn jederzeit in der VergeOS-Benutzeroberfläche umbenennen. Die folgenden Namen sind nur gängige Konventionen, keine erforderlichen Werte:

| Cluster-Nummer | Standardrolle                                        | Typischer Name                      |
| -------------- | ---------------------------------------------------- | ----------------------------------- |
| Cluster 1      | HCI (Controller + optional Scale-out)                | „HCI“, „Standard“ oder „Controller“ |
| Cluster 2      | Nur-Speicher (bei UCI) oder Nur-Compute (bei Hybrid) | „Speicher“ oder „Compute“           |
| Cluster 3      | Nur-Compute (in vollständigem UCI mit 3 Clustern)    | „Compute“                           |

In einer vollständigen UCI-Bereitstellung mit 3 Clustern:

* **Cluster 1**: Controller (Systemverwaltung, Tier-0-Metadaten)
* **Cluster 2**: Speicherknoten (gesamter vSAN-Workload-Speicher)
* **Cluster 3**: Compute-Knoten (gesamte VM-Ausführung)

## Mindestanforderungen und hohe Verfügbarkeit

| Anforderung                          | Details                                                                                                                                |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- |
| **Mindestanzahl Knoten pro System**  | 2 (ein Controller-Paar)                                                                                                                |
| **Mindestanzahl Knoten pro Cluster** | 2 (für Redundanz bei Wartung oder Ausfall)                                                                                             |
| **Controller-Knoten**                | Mindestens 2 pro System (N+1 standardmäßig); 3 für N+2-Redundanz erforderlich — muss Tier-0-Speicher für vSAN-Metadaten haben          |
| **HA-Verhalten**                     | Fällt ein Knoten aus, werden seine Workloads auf die verbleibenden Knoten im selben Cluster migriert                                   |
| **Wartungsmodus**                    | Knoten können in den Wartungsmodus versetzt werden; Workloads werden vor Beginn der Wartung live auf andere Knoten im Cluster migriert |

## Skalierung

VergeOS-Systeme skalieren von einem minimalen 2-Knoten-HCI-Cluster bis hin zu Multi-Cluster-Bereitstellungen. Alle Knoten müssen denselben **Switching-Fabric** mit **null Switch-Hops** zwischen ihnen teilen (unter dem Latenzziel von 0,05 ms). Ein einzelnes Rack ist der einfachste Weg, diese Anforderung zu erfüllen. Bereitstellungen mit mehreren Racks sind möglich, aber jedes Core Fabric muss weiterhin an einem einzigen Switch enden — führen Sie längere Kabel zurück zum selben Paar von Fabric-Switches, anstatt das Fabric über mehrere Switches zu spannen (MLAG/Stacking ist für das externe Netzwerk, nicht für das Core Fabric). Die Skalierungsstrategie hängt von Ihrer Architektur ab:

### HCI-Skalierung (einfach)

Fügen Sie Cluster 1 Scale-out-Knoten hinzu. Jeder Knoten fügt sowohl Compute als auch Speicher proportional hinzu.

```mermaid
graph LR
    subgraph "Start: 2-Knoten-HCI"
        A1["Knoten 1"] --- A2["Knoten 2"]
    end

    subgraph "Wachstum: 4-Knoten-HCI"
        B1["Knoten 1"] --- B2["Knoten 2"]
        B3["Knoten 3"] --- B4["Knoten 4"]
        B1 --- B3
        B2 --- B4
    end

    subgraph "Skalierung: 8+ Knoten-HCI"
        C1["Knoten 1-2<br/>(Controller)"]
        C2["Knoten 3-8<br/>(Scale-out)"]
    end
```

**Am besten für**: Ausgewogenes Wachstum, bei dem Compute- und Speicherbedarf gemeinsam steigen.

### UCI-Skalierung (unabhängig)

Fügen Sie Knoten zu bestimmten Clustern hinzu, je nachdem, welche Ressource der Engpass ist:

* **Mehr Speicher benötigt?** Knoten zum Speichercluster hinzufügen
* **Mehr Compute benötigt?** Knoten zum Compute-Cluster hinzufügen
* **Mehr von beidem benötigt?** Unabhängig zu beiden Clustern hinzufügen

**Am besten für**: Workloads mit unausgeglichenem Ressourcenbedarf (z. B. viel Speicher bei wenig Compute oder GPU-dichter Compute bei moderatem Speicher).

### Best Practices für die Skalierung

{% hint style="info" %}
**System vs. Cluster**

In VergeOS ist ein Cluster eine Gruppe von Knoten mit denselben Hardwareeigenschaften. Ein einzelnes VergeOS-System kann mehrere Cluster enthalten, die jeweils für unterschiedliche Workload- oder Hardwareprofile optimiert sind. Das unterscheidet sich von einigen HCI-Plattformen, bei denen sich „Cluster“ auf die gesamte Umgebung bezieht. Weitere Details finden Sie unter [Cluster-Übersicht](https://docs.verge.io/run-the-platform/de/systemadministration/clusters-overview.md).
{% endhint %}

* **Hardware-Konsistenz innerhalb von Clustern** — Verwenden Sie für alle Knoten in einem Cluster dieselben Hardwarespezifikationen. Unterschiedliche Hardware innerhalb eines Clusters kann zu Leistungs- und Zuverlässigkeitsproblemen führen. Um unterschiedliche Hardware, etwa eine neuere Servergeneration, hinzuzufügen, erstellen Sie einen neuen Cluster im selben System.
* **N+1-Redundanz einplanen** — Dimensionieren Sie jeden Cluster so, dass beim Ausfall eines Knotens noch genügend Kapazität für alle Workloads vorhanden ist
* **Vor der Skalierung überwachen** — Verwenden Sie die Metriken des VergeOS-Dashboards (CPU-Auslastung, RAM-Nutzung, vSAN-Kapazität), um zu erkennen, welche Ressource erweitert werden muss
* **Ohne Ausfallzeit skalieren** — Neue Knoten können zu einem laufenden System hinzugefügt werden, ohne bestehende Workloads zu unterbrechen

## Beispiele für Bereitstellungs-Topologien

Gängige Topologien, die realen Bereitstellungsmustern entsprechen:

| Topologie                 | Knoten                                        | Cluster                                   | Wann verwenden                                                            |
| ------------------------- | --------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------- |
| **2-Knoten-HCI**          | 2 Controller                                  | 1 (HCI)                                   | Kleine Standorte, Edge, PoC, grundlegende Evaluierung                     |
| **HCI + Scale-out**       | 2 Controller + N Scale-out                    | 1 (HCI)                                   | Wachsende HCI-Bereitstellungen, die eine ausgewogene Skalierung benötigen |
| **Hybrid (2 Cluster)**    | 2 Controller + N Compute                      | 2 (Speicher + Compute)                    | Compute-lastige Workloads mit moderatem Speicher                          |
| **UCI (3 Cluster)**       | 2 Controller + N Speicher + M Compute         | 3 (Controller + Speicher + Compute)       | Unabhängige Compute-/Speicher-Skalierung                                  |
| **UCI + GPU (4 Cluster)** | 2 Controller + N Speicher + M Compute + G GPU | 4 (Controller + Speicher + Compute + GPU) | KI/ML, Rendering oder VDI mit dedizierten GPU-Knoten                      |

```mermaid
graph TB
    subgraph "2-Knoten-HCI"
        direction LR
        H1["Controller 1<br/>HCI"] --- H2["Controller 2<br/>HCI"]
    end

    subgraph "HCI + Scale-out"
        direction LR
        S1["Controller 1"] --- S2["Controller 2"]
        S3["Scale-out 1"] --- S4["Scale-out 2"]
    end

    subgraph "Hybrid (2 Cluster)"
        direction LR
        subgraph "Cluster 1 (Speicher)"
            Y1["Controller 1"]
            Y2["Controller 2"]
        end
        subgraph "Cluster 2 (Compute)"
            Y3["Compute 1"]
            Y4["Compute 2"]
        end
    end

    subgraph "UCI + GPU (4 Cluster)"
        direction LR
        subgraph "Cluster 1 (Ctrl)"
            U1["Controller 1"]
            U2["Controller 2"]
        end
        Untergraph "Cluster 2 (Speicher)"
            U3["Speicher 1"]
            U4["Speicher 2"]
        end
        Untergraph "Cluster 3 (Rechenleistung)"
            U5["Rechenknoten 1"]
            U6["Rechenknoten 2"]
        end
        Untergraph "Cluster 4 (GPU)"
            G1["GPU-Knoten 1"]
            G2["GPU-Knoten 2"]
        end
    end
```

## Wichtige Erkenntnisse

| Konzept                    | Zusammenfassung                                                                                                   |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| **Cluster**                | Logische Gruppierung von Knoten mit derselben Hardware, die einen Ressourcenpool bilden                           |
| **Drei Clustertypen**      | HCI (Rechenleistung + Speicher), nur Speicher, nur Rechenleistung — innerhalb eines Systems kombinierbar          |
| **Vier Knotentypen**       | Controller, Scale-out, nur Speicher, nur Rechenleistung — jeweils mit einer bestimmten Rolle und Beitrittsmethode |
| **Mindestens 2 Knoten**    | Pro Cluster für Redundanz; Controller benötigen Tier-0-Speicher                                                   |
| **Sequenzieller Beitritt** | Knoten treten nacheinander bei, um Wettlaufsituationen zu vermeiden                                               |
| **Hardware-Konsistenz**    | Alle Knoten in einem Cluster sollten übereinstimmende Hardwarespezifikationen haben                               |
| **Unabhängige Skalierung** | Die UCI-Architektur ermöglicht es, Rechen- oder Speicherkapazität unabhängig voneinander hinzuzufügen             |
| **Skalierung**             | Systeme skalieren von 2-Knoten-HCI zu Multi-Cluster-Bereitstellungen innerhalb einer einzigen Switching-Ebene     |

## Nächste Schritte

Sie verstehen jetzt, wie VergeOS Knoten in Cluster organisiert und wie verschiedene Knotentypen unterschiedliche Rollen übernehmen. Im Praxislabor werden Sie diese Konzepte mit dem Terraform-Playground erkunden: [**Labor: Architektur-Erkundung →**](https://docs.verge.io/learn-the-platform/de/modul-1-architekturgrundlagen/lab.md)


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.verge.io/learn-the-platform/de/modul-1-architekturgrundlagen/05-clusters-nodes.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
