> 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-3-installation/03-adding-nodes.md).

# Knoten hinzufügen

Erfahren Sie, wie Sie ein VergeOS-System erweitern, indem Sie Scale-out-, Nur-Speicher- und Nur-Compute-Knoten mit dem USB-Installer zu Ihrem Cluster hinzufügen.

## Übersicht

Sobald Ihr Zweiknoten-Controller-Cluster betriebsbereit ist, unterstützt VergeOS drei Methoden zur Kapazitätserweiterung: **Scale-out-Knoten** (fügt einem vorhandenen HCI-Cluster sowohl Rechenleistung als auch Speicher hinzu), **Nur-Speicher-Knoten** (dedizierte Speichererweiterung) und **Nur-Compute-Knoten** (dedizierte Compute-Erweiterung). Jeder Knotentyp folgt einem optimierten USB-Installer-Workflow, der das vorhandene System auf dem Core Fabric automatisch erkennt.

Diese Seite behandelt die Voraussetzungen, Installationsschritte und Verifizierungsverfahren für alle drei Knotentypen.

## Voraussetzungen

Bevor Sie irgendeinen Knoten zu Ihrem VergeOS-System hinzufügen, stellen Sie sicher, dass die folgenden Bedingungen erfüllt sind:

| Anforderung                           | Detail                                                                                                                                                                                                                                                                                  |
| ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Betriebsbereiter 2-Knoten-Cluster** | Der primäre und sekundäre Controller-Knoten aus dem [Installationshandbuch](https://docs.verge.io/learn-the-platform/de/modul-3-installation/02-controller-installation.md) müssen vollständig installiert und funktionsfähig sein                                                      |
| **Netzwerkbereitschaft**              | VLANs, physische NIC-Zuweisungen und die Verkabelung des Core Fabric müssen der bei der Ersteinrichtung dokumentierten Konfiguration entsprechen                                                                                                                                        |
| **Passende Hardware**                 | Scale-out- und Nur-Speicher-Knoten sollten identische Hardwarespezifikationen (CPU, Speicher, NICs, RAM) wie die vorhandenen Knoten im Zielcluster haben. Um abweichende Hardware hinzuzufügen, z. B. eine neuere Servergeneration, erstellen Sie einen neuen Cluster im selben System. |
| **USB-Installer**                     | VergeOS-Installationsmedium, das der Version auf Ihrem vorhandenen Cluster entspricht                                                                                                                                                                                                   |
| **Cluster in der UI erstellt**        | Wenn Sie zum ersten Mal einen **neuen Clustertyp** (nur Speicher oder nur Compute) hinzufügen, erstellen Sie den Cluster in der VergeOS-UI **bevor** Sie den Installer booten                                                                                                           |

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

In VergeOS ist ein Cluster eine Gruppe von Knoten mit denselben Hardwareeigenschaften. Ein einziges VergeOS-System kann mehrere Cluster enthalten, die jeweils für unterschiedliche Workloads oder Hardwareprofile optimiert sind. Dies 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 %}

{% hint style="warning" %}
**Cluster vor der Installation von Knoten erstellen**

Wenn dies der erste Nur-Speicher- oder Nur-Compute-Knoten ist, den Sie hinzufügen, **müssen** Sie zuerst den entsprechenden Cluster in der VergeOS-UI erstellen:

1. Navigieren Sie zu **System → Cluster**
2. Klicken Sie auf **Neuer Cluster**
3. Legen Sie die Rolle des Clusters mit den unabhängigen **Compute** und **Speicher** Umschaltern fest — dies ist keine einzige Entweder-oder-Auswahl. Aktivieren Sie **Speicher** nur (Compute aus) für einen Nur-Speicher-Cluster oder **Compute** nur (Speicher aus) für einen Nur-Compute-Cluster. (Ein HCI-Cluster hat *beide* aktiviert.)
4. Speichern Sie die Clusterkonfiguration

Der Installer kann keinen Knoten zu einem Cluster hinzufügen, der noch nicht existiert.
{% endhint %}

## Vergleich der Knotentypen

Das Verständnis der Unterschiede zwischen den Knotentypen hilft Ihnen, die richtige Erweiterungsstrategie zu wählen:

```mermaid
flowchart TD
    A["Kapazität erweitern?"] --> B{"Welcher Ressource\nist der Engpass?"}
    B -->|"Sowohl Compute\nals auch Speicher"| C["Scale-Out-Knoten\n(HCI-Erweiterung)"]
    B -->|"Nur Speicher"| D["Nur-Speicher-Knoten\n(dedizierter Speicher)"]
    B -->|"Nur Compute"| E["Nur-Compute-Knoten\n(dedizierter Compute)"]
    C --> F["Installer-Typ: Scale-Out\nvSAN: Ja\nVMs ausführen: Ja"]
    D --> G["Installer-Typ: Scale-Out\nvSAN: Ja\nVMs ausführen: Nein"]
    E --> H["Installer-Typ: Nur Compute\nvSAN: Nein\nVMs ausführen: Ja"]

    style C fill:#e3f2fd,stroke:#1565c0
    style D fill:#e8f5e9,stroke:#2e7d32
    style E fill:#fff3e0,stroke:#e65100
```

| Merkmal                                          | Scale-Out                                                          | Nur-Speicher                                                       | Nur-Compute                                                                                                                          |
| ------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ |
| **Installer-Auswahl**                            | "Scale-Out"                                                        | "Scale-Out"                                                        | "Compute Only"                                                                                                                       |
| **vSAN-Beteiligung**                             | Ja — hinzugefügte Datenträger werden bestehenden Tiers hinzugefügt | Ja — hinzugefügte Datenträger werden bestehenden Tiers hinzugefügt | Nein — Installation ohne Konfiguration des lokalen Speichers (PXE-gebootete Nur-Compute-Knoten benötigen kein lokales Boot-Laufwerk) |
| **Führt VM-Workloads aus**                       | Ja                                                                 | Nein                                                               | Ja                                                                                                                                   |
| **Erfordert das Vorab-Erstellen eines Clusters** | Nein (tritt dem vorhandenen HCI-Cluster bei)                       | Ja (wenn erster Speicherknoten)                                    | Ja (wenn erster Compute-Knoten)                                                                                                      |
| **Typischer Anwendungsfall**                     | Ausgewogenes HCI-Wachstum                                          | Speichererweiterung für UCI                                        | Compute-Erweiterung für GPU/ML/VDI                                                                                                   |

## Installation von Scale-Out-Knoten

Scale-out-Knoten sind der einfachste Weg, einen HCI-Cluster zu erweitern. Sie fügen sowohl Compute- als auch Speicherkapazität proportional hinzu und verwenden Hardware, die mit den vorhandenen Controller-Knoten identisch ist.

### Installationsschritte

1. **Vom VergeOS-USB-Installer booten**
   * Stecken Sie den USB-Installer in den als Scale-out-Knoten vorgesehenen Server
   * Starten Sie neu und wählen Sie das USB-Laufwerk im BIOS/UEFI-Bootmenü als Startgerät
2. **Knotentyp auswählen → "Scale-Out"**
   * Wenn der Installer das Knotentyp-Menü anzeigt, wählen Sie **Scale-Out**
   * Dies weist den Installer an, einem vorhandenen Cluster mit sowohl Compute- als auch Speicherrolle beizutreten
3. **Admin-Zugangsdaten eingeben**
   * Geben Sie den während der Installation des primären Controllers erstellten Admin-Benutzernamen und das Passwort an
   * Diese Zugangsdaten authentifizieren den neuen Knoten gegenüber dem vorhandenen System
4. **Netzwerk-Autoerkennung**

   * Der Installer erkennt die Core-Fabric-Konfiguration automatisch, indem er auf UDP-Pakete von vorhandenen Knoten lauscht

   * Überprüfen Sie, ob die erkannten NICs Ihrer dokumentierten Kabelzuordnung entsprechen

   > **Tipp:** Der Installer fordert Sie möglicherweise auf, zu identifizieren, welche NIC für das **Externe** Netzwerk verwendet wird, wenn er es nicht automatisch erkennen kann. Halten Sie Ihre Dokumentation zur NIC-zu-Port-Zuordnung bereit.
5. **Clusterauswahl** (falls mehrere Cluster vorhanden)
   * Wenn Ihr System mehr als einen Cluster hat, fordert der Installer Sie auf auszuwählen, welchem Cluster dieser Knoten beitreten soll
   * Wählen Sie den Knoten im Zielcluster aus, dem dieser neue Knoten in der Hardware am ehesten entspricht
6. **vSAN-Diskkonfiguration**
   * Der Installer zeigt die erkannten Datenträger und ihre vorgeschlagenen Tier-Zuweisungen an
   * Bestätigen Sie, dass die Speichertiers mit der vorhandenen Clusterkonfiguration übereinstimmen — **Einheitlichkeit ist entscheidend**
   * Überprüfen und finalisieren Sie die Festplattenauswahl
7. **Installation abschließen**
   * Der Installer formatiert die Laufwerke, installiert VergeOS und integriert den Knoten in den Cluster
   * Der Knoten startet automatisch neu, wenn die Installation abgeschlossen ist
   * Entfernen Sie das USB-Installationsmedium, wenn Sie dazu aufgefordert werden
8. **In der UI überprüfen**
   * Melden Sie sich in der VergeOS-Web-UI an
   * Navigieren Sie zu **Infrastruktur → Knoten** und bestätigen Sie, dass der neue Knoten mit einem betriebsbereiten Status angezeigt wird
   * Prüfen Sie **System → vSAN** um zu verifizieren, dass die neuen Datenträger integriert sind und die Tiers funktionsfähig sind

{% hint style="info" %}
Nachdem der Knoten beigetreten ist, verteilt vSAN die Daten neu, um die neuen Datenträger einzubeziehen. Der Tier-Status kann während der Wiederherstellungsphase **gelb** anzeigen — das ist normal. Warten Sie, bis alle Tiers wieder **grün** sind, bevor Sie einen weiteren Knoten hinzufügen oder Wartungsarbeiten durchführen.
{% endhint %}

## Installation von Nur-Speicher-Knoten

Nur-Speicher-Knoten erweitern die vSAN-Kapazität, ohne Compute-Ressourcen hinzuzufügen. Sie werden in UCI-Architekturen (Unified Compute Infrastructure) verwendet, bei denen Speicher und Compute unabhängig voneinander skalieren.

### Vor der Installation: Speicher-Cluster erstellen

Wenn dies Ihr **erster** Nur-Speicher-Knoten ist, erstellen Sie den Speicher-Cluster in der UI:

1. Navigieren Sie zu **System → Cluster**
2. Klicken Sie auf **Neuer Cluster**
3. Aktivieren Sie den **Speicher** Umschalter und lassen Sie **Compute** aus
4. Speichern Sie die Konfiguration

### Installationsschritte

Bei der Installation von Nur-Speicher-Knoten wird dieselbe **Option des „Scale-Out“-Installers** wie bei einem regulären Scale-out-Knoten verwendet. Der entscheidende Unterschied besteht darin, dass der Knoten einem Nur-Speicher-Cluster statt einem HCI-Cluster beitritt.

1. **Vom USB-Installer booten** — wie bei Scale-out
2. **Knotentyp auswählen → "Scale-Out"** — der Installer verwendet „Scale-Out“ sowohl für HCI- als auch für Nur-Speicher-Knoten
3. **Admin-Zugangsdaten eingeben** — gegenüber dem vorhandenen System authentifizieren
4. **Netzwerk-Autoerkennung** — NIC-Zuweisungen überprüfen
5. **Clusterauswahl** — wählen Sie den **Speicher-Cluster** den Sie in der UI erstellt haben; wählen Sie den Knoten aus, dem dieser neue Knoten am ehesten entspricht
6. **vSAN-Diskkonfiguration** — bestätigen, dass die Tier-Zuweisungen mit der vorgesehenen Konfiguration des Speicher-Clusters übereinstimmen
7. **Installation abschließen** — Laufwerke werden formatiert, VergeOS wird installiert und der Knoten startet neu
8. **In der UI überprüfen** — bestätigen, dass der Knoten auf der Knoten-Seite unter dem richtigen Speicher-Cluster angezeigt wird

{% hint style="success" %}
Da Nur-Speicher-Knoten die Installer-Option „Scale-Out“ verwenden, ist der unterscheidende Faktor der **Cluster, den Sie auswählen** während Schritt 5. Der Clustertyp (nur Speicher) bestimmt die Rolle des Knotens im System.
{% endhint %}

## Installation von Nur-Compute-Knoten

Nur-Compute-Knoten stellen zusätzliche CPU-, RAM- und optional GPU-Ressourcen bereit, ohne sich an vSAN-Speicher zu beteiligen. Sie sind ideal für Workloads, die hohe Rechenleistung benötigen — Machine Learning, Rendering, VDI oder Datenanalyse.

### Vor der Installation: Compute-Cluster erstellen

Wenn dies Ihr **erster** Nur-Compute-Knoten, erstellen Sie den Compute-Cluster in der UI:

1. Navigieren Sie zu **System → Cluster**
2. Klicken Sie auf **Neuer Cluster**
3. Aktivieren Sie den **Compute** Umschalter und lassen Sie **Speicher** aus
4. Speichern Sie die Konfiguration

### Installationsschritte

1. **Vom USB-Installer booten** — wie bei anderen Knotentypen
2. **Knotentyp auswählen → "Compute Only"** — dies ist eine separate Installer-Option, anders als „Scale-Out“
3. **Admin-Zugangsdaten eingeben** — gegenüber dem vorhandenen System authentifizieren
4. **Netzwerk-Autoerkennung** — NIC-Zuweisungen überprüfen
5. **Clusterauswahl** (optional) — falls aufgefordert, wählen Sie den **Compute-Cluster** und den Knoten aus, dem dieser neue Knoten am ehesten entspricht
6. **Installation abschließen** — der Installer konfiguriert die Netzwerkeinstellungen und **installiert ohne Konfiguration des lokalen Speichers**. Nur-Compute-Knoten können auch per PXE gebootet werden; in diesem Fall ist kein lokales Boot-Laufwerk erforderlich. Der Knoten startet automatisch neu.
7. **In der UI überprüfen** — bestätigen, dass der Knoten auf der Knoten-Seite unter dem richtigen Compute-Cluster angezeigt wird

{% hint style="info" %}
Nur-Compute-Knoten haben **keinen Schritt zur vSAN-Diskkonfiguration**. Sie greifen über das Core Fabric auf Speicher von Knoten in HCI- oder Nur-Speicher-Clusters zu. Das ist der entscheidende Unterschied zu Scale-out- und Nur-Speicher-Installationen.
{% endhint %}

## Best Practices für die Installationsreihenfolge

Bei der Bereitstellung eines Multicluster-Systems (UCI-Architektur) befolgen Sie diese empfohlene Reihenfolge:

```mermaid
flowchart LR
    A["1. Controller-Knoten\n(Cluster 1)"] --> B["2. Speicher-Knoten\n(Cluster 2)"]
    B --> C["3. Compute-Knoten\n(Cluster 3)"]

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

1. **Installieren Sie zuerst die Controller-Knoten** — sie bilden den Basis-Cluster mit Tier-0-Metadatenspeicher
2. **Fügen Sie die Speicher-Knoten als Zweites hinzu** — stellt sicher, dass vSAN-Speicherkapazität verfügbar ist, bevor Compute-Knoten sie benötigen
3. **Fügen Sie die Compute-Knoten zuletzt hinzu** — sie können sofort über das Core Fabric auf den Speicher zugreifen

Innerhalb jedes Clusters, **fügen Sie Knoten nacheinander hinzu** — warten Sie, bis jeder Knoten die Installation abgeschlossen hat und in der UI als funktionsfähig angezeigt wird, bevor Sie mit dem nächsten beginnen. So vermeiden Sie überlappende vSAN-Verteilungs-/Wiederherstellungsoperationen, wenn jeder neue Knoten beitritt.

## Fehlerbehebung

Wenn bei einer Knoteninstallation Probleme auftreten:

| Aktion                      | Befehl                 | Beschreibung                                                       |
| --------------------------- | ---------------------- | ------------------------------------------------------------------ |
| **Installer abbrechen**     | Drücken Sie `Esc`      | Wechselt zu einer Eingabeaufforderung                              |
| **Installation fortsetzen** | `yb-install`           | Setzt dort fort, wo der Installer aufgehört hat                    |
| **Von vorne neu starten**   | `yb-install --restart` | Setzt den gesamten Installationsprozess zurück und startet ihn neu |

### Häufige Probleme

**Knoten erscheint nach dem Neustart nicht in der UI:**

* Überprüfen Sie die Netzwerkverbindung — stellen Sie sicher, dass die Core-Fabric-NICs ordnungsgemäß verkabelt sind
* Prüfen Sie, ob die USB-Installer-Version mit der auf den Controllern laufenden VergeOS-Version übereinstimmt
* Überprüfen Sie die Installationsprotokolle des Knotens über die Konsole

**vSAN-Tier bleibt über längere Zeit gelb:**

* Dies ist während der Datenumverteilung normal — überwachen Sie den Fortschritt in **System → vSAN**
* Stellen Sie sicher, dass zwischen den Knoten im Core Fabric ausreichende Bandbreite vorhanden ist
* Wenden Sie sich an den VergeOS-Support, wenn die Wiederherstellung über die erwarteten Zeiträume hinaus stockt

**Installer kann Netzwerk nicht automatisch erkennen:**

* Überprüfen Sie, ob die Switch-Ports des Core Fabric korrekt konfiguriert sind (Jumbo Frames, STP deaktiviert)
* Prüfen Sie, ob die physische Verkabelung der dokumentierten NIC-zu-Port-Zuordnung entspricht
* Versuchen Sie eine manuelle Netzwerkkonfiguration, wenn die Autoerkennung wiederholt fehlschlägt

**„Keine Cluster verfügbar“ während der Clusterauswahl:**

* Stellen Sie sicher, dass Sie den Zielcluster (Speicher oder Compute) in der UI erstellt haben, bevor Sie den Installer booten
* Vergewissern Sie sich, dass der Clustertyp mit dem Knotentyp des Installers übereinstimmt

## Verifizierungsliste

Nachdem Sie einen Knoten hinzugefügt haben, bestätigen Sie Folgendes:

* [ ] Knoten erscheint auf der **Infrastruktur → Knoten** Seite mit einem betriebsbereiten Status
* [ ] Knoten zeigt die richtige Clusterzuweisung
* [ ] Für Scale-out-/Speicherknoten: **System → vSAN** zeigt alle neuen Datenträger mit korrekten Tier-Zuweisungen
* [ ] Für Scale-out-/Speicherknoten: vSAN-Tiers kehren nach Abschluss der Wiederherstellung zu **grün** (funktionsfähig)-Status zurück
* [ ] Core-Fabric-Konnektivität bestätigt: **Knoten-Diagnose → Fabric-Konfiguration** meldet `bestätigt: wahr` für alle Pfade
* [ ] Keine Fehlerevents im Systemprotokoll im Zusammenhang mit dem neuen Knoten

{% hint style="info" %}
**VMware Bridge**

Kommen Sie von VMware? VergeOS verwendet einen USB-Installer, der das Core Fabric automatisch erkennt und sich mit Admin-Zugangsdaten authentifiziert — Controller-, Scale-out-, Nur-Speicher- und Nur-Compute-Rollen sind allesamt Menüauswahlen, ohne dass auf der VergeOS-Seite ein Schritt zur Vorabkonfiguration pro Host erforderlich ist.
{% endhint %}

{% hint style="info" %}
**Nutanix Bridge**

Kommen Sie von Nutanix? VergeOS hat keine CVM — der Speicherdienst ist ein integrierter OS-Daemon — und Scale-out, Nur-Speicher und Nur-Compute sind erstklassige Knotenrollen, ausgewählt über die Installer-Option und den Zielcluster; ein USB-Installer deckt alle drei ab.
{% endhint %}

## Wichtige Erkenntnisse

| Konzept                           | Zusammenfassung                                                                                                                     |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Drei Knotentypen**              | Scale-out (HCI), Nur-Speicher und Nur-Compute — jeder mit einer spezifischen Rolle                                                  |
| **Einzelner Installer**           | Ein USB-Installationsmedium deckt alle Knotentypen per Menüauswahl ab                                                               |
| **Autoerkennung**                 | Knoten erkennen das System auf dem Core Fabric automatisch                                                                          |
| **Vorab-Erstellung des Clusters** | Speicher- und Compute-Cluster müssen in der UI erstellt werden, bevor der erste Knoten dieses Typs hinzugefügt wird                 |
| **Sequentielle Installation**     | Fügen Sie Knoten innerhalb eines Clusters nacheinander hinzu, um überlappende vSAN-Verteilung/Wiederherstellung zu vermeiden        |
| **Speicher vor Compute**          | In UCI-Bereitstellungen fügen Sie Speicher-Knoten vor Compute-Knoten hinzu                                                          |
| **vSAN-Wiederherstellung**        | Nachdem Sie speicherbereitstellende Knoten hinzugefügt haben, warten Sie, bis die vSAN-Tiers wieder grün sind, bevor Sie fortfahren |

## Nächste Schritte

Nachdem Ihre Knoten hinzugefügt und überprüft wurden, fahren Sie mit der Überprüfung nach der Installation fort, um die allgemeine Systemgesundheit zu bestätigen: [**Überprüfung nach der Installation →**](https://docs.verge.io/learn-the-platform/de/modul-3-installation/04-post-install-verification.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-3-installation/03-adding-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.
