> 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-5-speicher/01-vsan-architecture.md).

# vSAN-Architektur & VergeFS

Tiefgehender Einblick in die blockbasierte vSAN-Architektur von VergeOS, hashbasierte Datenverteilung, Inline-Deduplizierung, Verschlüsselung, selbstheilende Redundanz und speichereffiziente Snapshots.

## VergeFS: Integrierter Speicherdienst

Modul 1 hat die vSAN-Konzepte auf hoher Ebene vorgestellt. Auf dieser Seite gehen wir näher auf die interne Architektur ein: Wie Blöcke gehasht und verteilt werden, wie Lese- und Schreibvorgänge durch das System laufen und wie Funktionen wie Deduplizierung, Verschlüsselung und Snapshots auf Blockebene implementiert sind.

## Architektur auf Blockebene

Das Herzstück von VergeFS ist eine **Speicher-Engine auf Blockebene**. Jede Dateneinheit, die auf den vSAN geschrieben wird – ob VM-Festplatte, Snapshot, ISO-Abbild oder Systemmetadaten –, wird in **Datenblöcke**aufgeteilt. Jedem Block wird ein **SHA-1-Content-Hash** zugewiesen, der im gesamten System als eindeutige Kennung dient. SHA-1 wird hier für die inhaltsbasierte Adressierung und Verteilung verwendet, nicht für kryptografische Sicherheit.

Dieser Hash bildet die Grundlage für fast alle vSAN-Funktionen:

* **Verteilung** – Der Hash bestimmt, auf welchen Knoten die primäre und die redundanten Kopien des Blocks gespeichert werden
* **Deduplizierung** – Identische Blöcke erzeugen identische Hashes, sodass nur eine Kopie gespeichert wird
* **Integrität** – Der Hash überprüft den Blockinhalt und ermöglicht so die kontinuierliche Erkennung von Bit-Rot
* **Ermittlung des Speicherorts** – Aus dem Hash und den gerätespezifischen Zuordnungstabellen pro Tier auf Tier 0 wird der physische Speicherort jedes Blocks deterministisch abgeleitet

### Die Hash-Map und Tier 0

Die Blockplatzierung in vSAN wird **aus dem SHA-1-Content-Hash** in Kombination mit den gerätespezifischen Zuordnungstabellen pro Tier abgeleitet, die auf **Tier 0** -Laufwerken (NVMe-SSDs mit hoher Lebensdauer) gespeichert sind:

* Jedes Tier verwaltet eine `0.map` (Zuordnungstabelle für primäre Kopien) und eine `1.map` (Zuordnungstabelle für sekundäre Kopien)
* Der SHA-1-Hash dient als Eingabe für eine deterministische Platzierungsberechnung anhand dieser Tabellen – es gibt keine zentrale Tabelle, in der festgehalten wird: „Block X liegt auf Knoten Y, Laufwerk Z“
* Referenzzähler werden **nicht** dauerhaft in einer Hash-Map gespeichert – sie werden durch den differenziellen **vSAN Walk** beim Durchlaufen der aktiven Hashes neu erstellt
* Der Dateisystemindex von Tier 0 und die gerätespezifischen Zuordnungstabellen pro Tier bilden zusammen mit den vSAN-Metadaten den tatsächlichen Inhalt von Tier 0

**Tier 0 ist ausschließlich eine Metadatenebene.** Dort werden der vSAN-Dateisystemindex und die gerätespezifischen Zuordnungstabellen pro Tier gespeichert. Tier 0 ist **kein** Performance-Cache und speichert auch keine **kein** Nutzdaten. Da vSAN-Metadatenoperationen von Tier 0 abhängen, wirkt sich die Leistung Ihrer Tier-0-Laufwerke direkt auf die Reaktionsfähigkeit des Gesamtsystems aus.

{% hint style="warning" %}
**Tier 0 enthält ausschließlich Metadaten**

Tier 0 **dient nicht** als Performance-Cache oder Tier für häufig genutzte Daten. Es speichert ausschließlich den vSAN-Dateisystemindex und die gerätespezifischen Zuordnungstabellen pro Tier. Nutzdaten befinden sich auf den Tiers 1–5. Verwenden Sie für Tier 0 stets Enterprise-SSDs (NVMe oder SAS) mit einer Mindestlebensdauer von 1 DWPD und halten Sie mindestens 30 % freien Speicherplatz vor.
{% endhint %}

### Funktionsweise der Hash-Map

Das folgende Diagramm veranschaulicht, wie VM-Daten durch die vSAN-Architektur auf Blockebene fließen:

![vSAN-Hash-Map-Architektur](https://3404212562-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FqLUTTK5fxfW4S9FoS9GE%2Fuploads%2Fgit-blob-9bcd002448914d8cf6d30ee53033586dc8966617%2Fvsan-hash-map.png?alt=media)

Der Ablauf ist wie folgt:

1. Eine VM schreibt Daten auf ihre virtuelle Festplatte
2. VergeFS teilt den Schreibvorgang in Datenblöcke auf
3. Jedem Block wird ein SHA-1-Inhaltshash zugewiesen
4. Die Platzierungsberechnung anhand der gerätespezifischen Zuordnungen pro Tier (gespeichert auf Tier 0) wählt einen primären und einen redundanten Speicherort aus
5. Der Block wird sowohl auf einen primären als auch auf einen redundanten Knoten geschrieben
6. Metadatenaktualisierungen auf Tier 0 werden gebündelt und asynchron angewendet

## Hashbasierte Datenverteilung

vSAN verteilt Datenblöcke mithilfe eines **hashbasierten Verteilungsalgorithmus**. Dadurch werden eine ausgeglichene E/A-Last, Fehlertoleranz und effiziente Skalierung gewährleistet.

### Schreibpfad

Wenn eine VM Daten schreibt:

1. VergeFS teilt die Daten in Blöcke auf und berechnet für jeden einen SHA-1-Inhaltshash
2. Die Platzierungsberechnung anhand der gerätespezifischen Zuordnungen pro Tier bestimmt einen **primären Knoten** und einen **redundanten Knoten** – der Controller ist **nicht** am Datenschreibpfad beteiligt
3. Wenn ein identischer Hash bereits vorhanden ist, wird der Schreibvorgang **dedupliziert** (es wird kein neuer Datenblock geschrieben; die Deduplizierung ergibt sich natürlich aus der inhaltsadressierten Speicherung)
4. Bei neuen Blöcken werden beide Kopien **gleichzeitig** über das Core-Fabric-Netzwerk direkt auf die Zielknoten geschrieben
5. Der Schreibvorgang wird **erst bestätigt, wenn beide Kopien bestätigt wurden** – so wird die Datenbeständigkeit sichergestellt, bevor die VM eine Meldung über den abgeschlossenen Schreibvorgang erhält
6. Metadatenaktualisierungen auf Tier 0 werden **gebündelt** und asynchron angewendet, anstatt den Datenpfad über einen zentralen Index zu serialisieren

### Lesevorgang

Wenn eine VM Daten liest:

1. Der Speicherort des Blocks wird anhand seines Inhaltshashs und der gerätespezifischen Zuordnungen pro Tier ermittelt
2. Das System **bevorzugt das Lesen der primären Kopie**
3. Wenn sich eine redundante Kopie auf demselben **Knoten wie die anfragende VM befindet**, liest VergeFS die **lokale Kopie** , um den Netzwerkverkehr zu minimieren (lokales Lesen wird bevorzugt)
4. Wenn die primäre Kopie langsam reagiert oder nicht erreichbar ist, **wechselt VergeFS automatisch zur redundanten Kopie** – transparent und ohne Beeinträchtigung der VM

```mermaid
flowchart TB
    VM["VM-Leseanforderung"] --> LOOKUP["Speicherort anhand des<br/>Inhaltshashs ermitteln"]
    LOOKUP --> LOCAL{"Lokale Kopie<br/>verfügbar?"}
    LOCAL -->|Ja| READLOCAL["Lokale redundante<br/>Kopie lesen"]
    LOCAL -->|Nein| PRIMARY["Vom primären<br/>Knoten lesen"]
    PRIMARY --> HEALTHY{"Primär<br/>reaktionsfähig?"}
    HEALTHY -->|Ja| RETURN["Daten<br/>an VM zurückgeben"]
    HEALTHY -->|Nein| FAILOVER["Failover auf<br/>redundante Kopie"]
    READLOCAL --> RETURN
    FAILOVER --> RETURN

    style VM fill:#e3f2fd,stroke:#1565c0
    style LOOKUP fill:#fff3e0,stroke:#e65100
    style RETURN fill:#e8f5e9,stroke:#2e7d32
```

### Verteilung über mehrere Knoten

Datenblöcke werden verteilt auf **alle Knoten, die Speicher bereitstellen,** innerhalb jeder Ebene. Dieses Design bietet:

* **Ausgewogene Leistung** — Die I/O-Last wird auf alle Knoten verteilt und verhindert so Engpässe
* **Fehlertoleranz** — Kein einzelner Knoten enthält alle Kopien eines Datensatzes
* **Effiziente Skalierung** — Das Hinzufügen eines Knotens erweitert den Speicherpool automatisch und löst einen Neuausgleich aus
* **Parallele I/O** — Mehrere Knoten stellen gleichzeitig Daten bereit und erhöhen so den Gesamtdurchsatz

## Globale Inline-Deduplizierung

VergeOS vSAN führt **eine globale Inline-Deduplizierung** durch, die immer aktiviert ist und keinerlei Konfiguration erfordert. Da jeder Datenblock anhand seines Inhalts-Hashs identifiziert wird, ergibt sich die Deduplizierung ganz natürlich aus der Architektur:

1. Beim Schreiben eines neuen Blocks wird dessen Hash berechnet
2. Existiert bereits ein identischer Hash, ist der Block ein Duplikat – die Deduplizierung ergibt sich ganz natürlich aus der inhaltsbasierten Adressierung
3. Bei doppelten Blöcken wird kein zusätzlicher Speicherplatz belegt – stattdessen wird einfach erneut auf den vorhandenen Block verwiesen
4. Dies geschieht **inline** (während des Schreibvorgangs) und nicht als Hintergrundaufgabe

Die Deduplizierung funktioniert **über alle VMs, Ebenen und Datentypen hinweg** im System. Häufige Szenarien, in denen die Deduplizierung erheblich Speicherplatz spart, sind:

* Mehrere VMs mit demselben Betriebssystem (gemeinsam genutzte Betriebssystemblöcke)
* Vorlagenbasierte VM-Bereitstellungen (geklonte Basis-Images)
* Entwicklungsumgebungen mit ähnlichen Konfigurationen
* Backup-Snapshots mit nur geringfügigen Datenänderungen zwischen den Iterationen

Die Deduplizierungsraten sind im VergeOS-Speicher-Dashboard sichtbar. Dort werden üblicherweise die effektiven Kapazitätseinsparungen für jede Ebene angezeigt.

{% hint style="info" %}
**VMware-Brücke**

Sie kommen von VMware vSAN? Die Deduplizierung in VergeOS ist immer aktiviert, erfolgt inline und global über alle Ebenentypen hinweg (NVMe, SSD, HDD) – es gibt weder einen Schalter noch einen separaten Aktivierungsschritt.
{% endhint %}

## Komprimierung

VergeOS vSAN **komprimiert** Daten im Ruhezustand nicht. Anders als Plattformen, die gespeicherte Blöcke inline komprimieren, speichert VergeFS Daten in ihrer ursprünglichen Form auf dem Datenträger.

**Komprimierung wird nur bei der Site-Sync-Replikation angewendet** – wenn Daten über das Netzwerk zwischen VergeOS-Standorten übertragen werden. In diesem Zusammenhang verringert die Komprimierung den Bandbreitenverbrauch bei WAN-Übertragungen, ohne die lokale Speicherleistung zu beeinträchtigen.

Durch diese Designentscheidung bleibt der lokale I/O-Pfad einfach und schnell. Die oben beschriebene Deduplizierung bietet den wichtigsten Vorteil für die Speichereffizienz gespeicherter Daten.

## AES-256-Verschlüsselung im Ruhezustand

vSAN unterstützt **AES-256-Verschlüsselung im Ruhezustand**, das bei der Ersteinrichtung von VergeOS konfiguriert wird. Wichtige Details:

| Aspekt                        | Details                                                                      |
| ----------------------------- | ---------------------------------------------------------------------------- |
| **Algorithmus**               | AES-256                                                                      |
| **Konfigurationszeitpunkt**   | Nur während der Ersteinrichtung                                              |
| **Umkehrbarkeit**             | Nach der Installation nicht umkehrbar                                        |
| **Geltungsbereich**           | Alle Daten auf allen Ebenen werden transparent verschlüsselt                 |
| **Schlüsselspeicheroption 1** | USB-Laufwerke, die an die ersten beiden Controller-Knoten angeschlossen sind |
| **Schlüsselspeicheroption 2** | Manuelle Passworteingabe bei jedem Systemstart                               |

Die Verschlüsselung ist für VMs und Anwendungen transparent: Sie lesen und schreiben Daten wie gewohnt, während VergeFS die Ver- und Entschlüsselung auf Blockebene übernimmt. Die Verschlüsselungskonfiguration gilt systemweit. Sie können nicht einige Ebenen verschlüsseln und andere unverschlüsselt lassen.

So überprüfen Sie den Verschlüsselungsstatus: Navigieren Sie zu **Nodes > Node 1 > Drives**, doppelklicken Sie auf das erste Laufwerk und überprüfen Sie das Kontrollkästchen **Verschlüsselt** .

## Redundanzmodelle

vSAN verwaltet mehrere Kopien jedes Datenblocks, um vor Hardwareausfällen zu schützen. Die Redundanz wird auf **Systemebene** konfiguriert und gilt **pro Ebene** — nicht pro VM oder Speichercontainer.

| Funktion                                       | N+1 (RF2) – Standard | N+2 (RF3) |
| ---------------------------------------------- | -------------------- | --------- |
| **Datenkopien**                                | 2                    | 3         |
| **Verkraftbare gleichzeitige Ausfälle**        | 1 Knoten             | 2 Knoten  |
| **Mindestanzahl an Controller-Knoten**         | 2                    | 3         |
| **Empfohlene Anzahl an Knoten**                | 3                    | 5         |
| **Speicher-Overhead** (vor der Deduplizierung) | \~2x                 | \~3x      |

**N+1 (RF2)** ist die Standardeinstellung und eignet sich für die meisten Produktionsumgebungen. Dabei werden zwei Kopien jedes Blocks auf verschiedenen Knoten vorgehalten, sodass ein gleichzeitiger Ausfall eines Knotens verkraftet wird.

**N+2 (RF3)** hält drei Kopien auf drei oder mehr Knoten vor und verkraftet zwei gleichzeitige Ausfälle. Dieses Modell ist für besonders kritische Workloads oder Remote-/Edge-Standorte gedacht, an denen Ersatzhardware nicht schnell verfügbar ist.

Ein Ausfall betrifft nur die **Ebene, auf der sich die ausgefallenen Laufwerke befinden** — andere Ebenen bleiben voll betriebsfähig. Wenn beispielsweise in einem N+2-System Laufwerke der Ebene 1 auf zwei Knoten und ein Laufwerk der Ebene 4 auf einem dritten Knoten ausfallen, bleibt der Cluster ohne Datenverlust betriebsfähig.

{% hint style="success" %}
**Reparaturserver**

Für zusätzlichen Schutz über die konfigurierte Redundanzstufe hinaus bietet ein **Reparaturserver** kann so konfiguriert werden, dass fehlende Datenblöcke automatisch von einem Synchronisierungsziel abgerufen werden, wenn die Ausfälle das konfigurierte Redundanzniveau überschreiten – wodurch sich ein vollständiges Zurücksetzen auf einen Snapshot möglicherweise vermeiden lässt.
{% endhint %}

## Selbstheilung

Wenn ein Knoten oder Laufwerk ausfällt, erkennt vSAN den Ausfall automatisch und beginnt ohne manuelles Eingreifen mit der Wiederherstellung:

```mermaid
flowchart LR
    A["Laufwerks- oder Knotenausfall<br/>erkannt"] --> B["Lese-/Schreibvorgänge werden auf<br/>redundante Kopien umgeleitet"]
    B --> C["VMs laufen weiter<br/>– keine Ausfallzeit"]
    B --> D["Automatische Neuerstellung<br/>beginnt sofort"]
    D --> E["Fehlende Blöcke werden<br/>auf fehlerfreie Knoten<br/>erneut repliziert"]
    E --> F["Vollständige Redundanz<br/>wiederhergestellt"]

    style A fill:#fce4ec,stroke:#c62828
    style C fill:#e8f5e9,stroke:#2e7d32
    style F fill:#e8f5e9,stroke:#2e7d32
```

Der Selbstheilungsprozess:

1. **Erkennung** – vSAN überwacht kontinuierlich den Zustand von Laufwerken und Knoten. Ausfälle werden automatisch erkannt.
2. **Failover** – Lese- und Schreibvorgänge werden sofort auf redundante Kopien umgeleitet. Bei den VMs kommt es zu keiner Ausfallzeit.
3. **Neuerstellung** – Fehlende Datenblöcke werden aus erhalten gebliebenen Kopien erneut auf die übrigen fehlerfreien Knoten repliziert. Dies geschieht im Hintergrund, während die Workloads weiter ausgeführt werden.
4. **Wiederherstellung** – Sobald alle Blöcke erneut repliziert wurden, erreicht die Speicherebene wieder das konfigurierte Redundanzniveau.

### Datenintegrität

Über die Wiederherstellung nach Ausfällen hinaus führt vSAN eine **kontinuierliche Erkennung von Bitfäule** mithilfe einer Hash-Validierung durch. Der gespeicherte Hash jedes Blocks wird regelmäßig mit dessen Inhalt abgeglichen. Wird eine Beschädigung erkannt, wird der Block automatisch anhand einer gültigen redundanten Kopie repariert.

## Speichereffiziente Snapshots und Klone

Die blockbasierte Architektur von vSAN ermöglicht **speichereffiziente Snapshots** mit minimalem zusätzlichem Speicherbedarf:

* Ein Snapshot erfasst den **Zustand des Dateisystemindex zu einem bestimmten Zeitpunkt** – Datenblöcke werden dabei nicht kopiert
* Von einem Snapshot referenzierte Blöcke bleiben erhalten, auch wenn die ursprüngliche VM sie löscht (Referenzzählung).
* Klone funktionieren ähnlich: Sie verweisen auf dieselben zugrunde liegenden Blöcke und belegen nur dann zusätzlichen Speicherplatz, wenn Daten voneinander abweichen (Copy-on-Write).
* Snapshots können **über ein optionales Flag unveränderlich gemacht werden** Dabei gibt es die Zustände Unlocked/Locked/Unlocking und nach dem Sperren eine siebentägige Entsperrverzögerung. Snapshots sind standardmäßig löschbar. Sperren Sie Snapshots, wenn Schutz vor Ransomware oder Aufbewahrungsgarantien erforderlich sind.

### Löschung und Garbage Collection

Wenn eine VM, ein Laufwerk oder ein Snapshot gelöscht wird:

1. Die Hashes der Datei werden aus dem vSAN-Verzeichnisbaum entfernt.
2. Der **vSAN Walk** ermittelt bei einem differentiellen Durchlauf die Referenzzähler anhand der verbleibenden gültigen Hashes neu – die Zähler werden nicht gespeichert, sondern beim Durchlaufen neu aufgebaut.
3. Blöcke, auf die nicht mehr verwiesen wird, warten etwa **10 Durchläufe (ca. 70 Sekunden),** bevor sie zurückgewonnen werden können. So entsteht ein Sicherheitszeitraum, der vor schnellen Änderungen schützt.
4. Der physische Speicherplatz wird asynchron freigegeben, während der Durchlauf diese Blöcke zurückgewinnt.

Deshalb nimmt der Speicherplatz nach einer Löschung möglicherweise nicht sofort ab – die Speicherfreigabe erfolgt asynchron im Rahmen der vSAN-Walk-Vorgänge im Hintergrund.

## Wichtigste Erkenntnisse

| Konzept              | Zusammenfassung                                                                                                                                      |
| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **VergeFS**          | Integrierter verteilter Speicher – kein externes SAN/NAS, kein CVM-Overhead                                                                          |
| **Blockarchitektur** | Alle Daten werden in Blöcke aufgeteilt, die jeweils durch einen SHA-1-Inhaltshash identifiziert werden                                               |
| **Tier 0**           | Nur Metadaten (Dateisystemindex und Gerätezuordnungen pro Tier). Kein Cache. Auf Controller-Knoten erforderlich (Knoten 1–2 für N+1, 1–3 für N+2).   |
| **Verteilung**       | Hashbasiert, verteilt auf alle speicherteilnehmenden Knoten pro Tier                                                                                 |
| **Deduplizierung**   | Inline, immer aktiv, global über alle Tiers hinweg – keine Konfiguration erforderlich                                                                |
| **Komprimierung**    | Nicht im Ruhezustand – nur während der Site-Sync-Replikation                                                                                         |
| **Verschlüsselung**  | AES-256 im Ruhezustand, bei der Installation konfiguriert, nicht umkehrbar                                                                           |
| **Redundanz**        | N+1 (2 Kopien, Standard) oder N+2 (3 Kopien) – systemweit pro Tier                                                                                   |
| **Selbstheilung**    | Automatisches Failover und Wiederaufbau bei Ausfällen, kontinuierliche Erkennung von Bitrot                                                          |
| **Snapshots**        | Zeitpunktbezogene Hash-Referenzen, platzsparend; Unveränderlichkeit ist optional (Unlocked/Locked/Unlocking, 7 Tage Verzögerung bis zur Entsperrung) |

## Nächste Schritte

Nachdem Sie nun die interne Architektur von vSAN verstanden haben, geht es im nächsten Thema darum, wie das Tier-System in der Praxis funktioniert – Tiers konfigurieren, Laufwerke zuweisen, Kapazität planen und den Speicher skalieren: [**Speicher-Tiers**](https://docs.verge.io/learn-the-platform/de/modul-5-speicher/02-storage-tiers.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-5-speicher/01-vsan-architecture.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.
