> 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/automate-protect-and-extend/de/integrationen-und-apis/kubernetes-integration.md).

# Kubernetes-Integration

## Übersicht

VergeOS bietet native Kubernetes-Integration über einen CSI-Speichertreiber und einen Cloud Controller Manager (CCM). Diese Komponenten verbinden jeden Kubernetes-Cluster, der auf VergeOS-VMs läuft — unabhängig davon, ob er bereitgestellt wurde über [Rancher](/automate-protect-and-extend/de/integrationen-und-apis/rancher-integration.md), kubeadm oder eine andere Methode — mit der zugrunde liegenden VergeOS-Plattform.

| Komponente                                            | Zweck                                                       |
| ----------------------------------------------------- | ----------------------------------------------------------- |
| [CSI-Treiber](#csi-driver)                            | Persistenter Speicher für Kubernetes-Pods über VergeOS vSAN |
| [Cloud Controller Manager](#cloud-controller-manager) | Node-Lebenszyklus und Load-Balancer-Integration             |

### Voraussetzungen

* Ein Kubernetes-Cluster, der auf VergeOS-VMs läuft (RKE2, K3s, kubeadm usw.)
* Ein VergeOS-API-Schlüssel (in den Benutzereinstellungen generiert)
* `kubectl` und `helm` CLI-Tools
* Zugriff auf die kubeconfig des Clusters

{% hint style="info" %}
**Selbstsignierte Zertifikate**

Wenn die VergeOS-Umgebung ein selbstsigniertes Zertifikat verwendet, setzen Sie `vergeos.verifySSL=false` beim Installieren des CSI-Treibers und der CCM-Helm-Charts. Dies ist der Standardwert, aber erwähnenswert, falls wir ihn später ändern.
{% endhint %}

***

## CSI-Treiber

Der Container Storage Interface (CSI)-Treiber ermöglicht Kubernetes-Pods, VergeOS-Speicher als persistente Volumes anzufordern und einzubinden. Er delegiert Speicheroperationen direkt an die VergeOS-API und nutzt das vSAN für das, wofür es gebaut wurde — Deduplizierung, mehrstufige Platzierung und verteilte Redundanz.

### Speicher-Backends

Der CSI-Treiber unterstützt zwei Backends, die beide von einer einzigen Go-Binärdatei bereitgestellt werden:

| Backend   | Zugriffsmodus | Beschreibung                                                                    |
| --------- | ------------- | ------------------------------------------------------------------------------- |
| **NAS**   | ReadWriteMany | EXT4-Volumes auf VergeOS-NAS-Diensten, über NFS bereitgestellt                  |
| **Block** | ReadWriteOnce | VM-Laufwerke, die per Hotplug über das vSAN an VergeOS-VMs angeschlossen werden |

{% hint style="info" %}
**Warum nicht Longhorn?**

Longhorn betreibt seine eigene replizierte Speicher-Engine *innerhalb* Kubernetes und legt Replikation, Snapshots und Scheduling auf den Hypervisor auf. Auf VergeOS ist der native CSI-Treiber die bessere Wahl:

* **Keine doppelte Replikation** — die verteilte Mirror-Architektur des vSAN bietet bereits Datenredundanz
* **Inline-Deduplizierung** — die vSAN-Deduplizierung ist clusterweit global; Longhorn-Volumes sind undurchsichtige Blobs, die daran nicht teilnehmen können
* **Mehrstufige Platzierung** — Volumes landen basierend auf der StorageClass auf der richtigen vSAN-Ebene (NVMe, SSD, HDD)
* **Einheitliche Verwaltung** — Volumes erscheinen in der VergeOS-Benutzeroberfläche neben VMs, Snapshots und NAS-Freigaben
  {% endhint %}

### VM des Blockspeicher-Pools

Erstellen Sie für Blockspeicher eine leere VM in VergeOS mit dem Namen `k8spool`. Sie muss niemals booten — sie hält nur ungenutzte Blocklaufwerke. Die ID der VM wird bei der Installation an das Helm-Chart übergeben.

### Installation

Der CSI-Treiber wird als Helm-Chart aus dem `verge-io` Helm-Repository verteilt und kann über die Helm-CLI oder über die **Rancher Apps UI** auf Downstream-Clustern installiert werden. Siehe [Dokumentation und Ressourcen](#documentation-and-resources) unten für Chart-Details, Helm-Werte und Konfigurationsoptionen.

{% hint style="warning" %}
**Downstream-Cluster**

Bei der Installation über die Rancher Apps UI muss das Helm-Repository auf dem **Downstream-Cluster**und nicht auf dem Rancher-Management-Cluster hinzugefügt werden. ClusterRepos werden nicht vom Management-Cluster übernommen.
{% endhint %}

***

## Cloud Controller Manager

Der Cloud Controller Manager (CCM) ist die standardmäßige Kubernetes-Cloud-Provider-Schnittstelle für VergeOS. Er übernimmt das Node-Lebenszyklusmanagement und die Bereitstellung von Load Balancern.

### Funktionen

* **Node-Verwaltung** — Befüllt die Metadaten von Kubernetes-Nodes (Provider-ID, Instanztyp, interne IPs) aus VergeOS-VMs. Erkennt VM-Existenz und den Power-Status für das Node-Lebenszyklusmanagement.
* **Lastverteilung** — Richtet VergeOS-VNet-NAT-/Übersetzungsregeln ein für `Typ: LoadBalancer` Services. Weist IPs aus einem konfigurierbaren Pool zu und ordnet Service-Ports automatisch Node-Ports zu.

### Wie der Node-Lebenszyklus funktioniert

Der CCM implementiert die Kubernetes- `InstancesV2` Schnittstelle:

1. **InstanceMetadata** — Ordnet einen Kubernetes-Node einer VergeOS-VM zu (nach Provider-ID oder Namen) und gibt dann die Provider-ID zurück (`vergeos://<vm-id>`), den Instanztyp (`<cpu>cpu-<ram>mb`), und die internen IP-Adressen aus den VM-NICs
2. **InstanceExists** — Prüft, ob die zugrunde liegende VM in VergeOS noch existiert
3. **InstanceShutdown** — Meldet, ob die VM ausgeschaltet ist

### Wie Lastverteilung funktioniert

Der CCM implementiert die Kubernetes- `LoadBalancer` Schnittstelle mithilfe von VergeOS-VNet-Regeln:

1. **EnsureLoadBalancer** — Weist eine IP aus dem Pool zu und erstellt dann pro Service-Port eine VNet-NAT-Regel. Die Regeln übersetzen `<allocated-ip>:<port>` auf `<node-ips>:<nodePort>`. Ruft `ApplyRules` auf, um sie zu aktivieren.
2. **UpdateLoadBalancer** — Aktualisiert die Ziel-IPs bestehender Regeln, wenn sich Nodes ändern
3. **EnsureLoadBalancerDeleted** — Löscht alle VNet-Regeln für den Service und wendet die Änderung an

### Installation

Der CCM wird zusammen mit dem CSI-Treiber als Helm-Chart verteilt. Installieren Sie ihn über die Helm-CLI oder über die Rancher Apps UI auf dem Downstream-Cluster. Siehe [Dokumentation und Ressourcen](#documentation-and-resources) unten für Chart-Details und Konfigurationsoptionen.

***

## Cluster-Autoscaler

Der Kubernetes Cluster Autoscaler funktioniert mit über VergeOS bereitgestellten Clustern, die durch [Rancher](/automate-protect-and-extend/de/integrationen-und-apis/rancher-integration.md)bereitzustellen sind. Er passt die Anzahl der Nodes in einem Pool automatisch anhand ausstehender Ressourcenanforderungen von Pods an — skaliert hoch, wenn Pods nicht geplant werden können, und skaliert herunter, wenn Nodes unterausgelastet sind. Siehe [Dokumentation und Ressourcen](#documentation-and-resources) unten für den Link zum Upstream-Projekt.

### So funktioniert es

Der Autoscaler nutzt die API von Rancher, um Node-Pools zu verwalten:

1. **Hochskalieren** — Wenn Pods aufgrund unzureichender Ressourcen ausstehen, vergrößert der Autoscaler den Node-Pool. Rancher verwendet dann den Docker-Machine-Driver, um neue VergeOS-VMs bereitzustellen.
2. **Herunterskalieren** — Wenn Nodes über einen konfigurierbaren Zeitraum unterausgelastet sind, markiert der Autoscaler sie als unschedulable, leert sie und entfernt sie. Der Driver löscht die zugrunde liegenden VergeOS-VMs.

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

Der Autoscaler trifft Skalierungsentscheidungen auf Basis der Ressourcenanforderungen von Pods, nicht der tatsächlichen Nutzung. Stellen Sie sicher, dass Workloads `requests` in ihren Pod-Spezifikationen definieren, damit das Skalierungsverhalten korrekt ist.
{% endhint %}

***

## Zusammenfassung

VergeOS bietet drei Kubernetes-Komponenten, die mit jedem Cluster zusammenarbeiten, der auf VergeOS-VMs läuft:

* **CSI-Treiber** — persistente Volumes über VergeOS NAS (ReadWriteMany) und vSAN-Blockspeicher (ReadWriteOnce)
* **Cloud Controller Manager** — Node-Lebenszyklusmanagement und `LoadBalancer` von VergeOS-VNet-Regeln unterstützte Services
* **Cluster-Autoscaler** — automatische Skalierung von Node-Pools für von Rancher bereitgestellte Cluster

Alle Komponenten werden als Helm-Charts aus dem `verge-io` Repository verteilt und können über die Helm-CLI oder die Rancher Apps UI installiert werden.

## Nächste Schritte

* Neu bei Rancher auf VergeOS? Siehe den [Rancher-Integration](/automate-protect-and-extend/de/integrationen-und-apis/rancher-integration.md) Leitfaden für Cluster-Bereitstellung, die Vorbereitung von Template-VMs und das Einrichten des Node-Drivers.
* Haben Sie bereits einen laufenden Cluster? Fügen Sie das Helm-Repository hinzu und erkunden Sie die verfügbaren Charts:

  ```bash
  helm repo add verge-io https://verge-io.github.io/helm-charts
  helm repo update
  helm search repo verge-io
  ```
* Besuchen Sie die unten aufgeführten Projekt-Repositories für Chart-Werte, Konfigurationsreferenzen und Release Notes.

## Dokumentation und Ressourcen

| Repository                                                                                               | Beschreibung                        |
| -------------------------------------------------------------------------------------------------------- | ----------------------------------- |
| [csi-vergeos](https://github.com/verge-io/csi-vergeos)                                                   | Container Storage Interface-Treiber |
| [vergeos-cloud-controller-manager](https://github.com/verge-io/vergeos-cloud-controller-manager)         | Cloud Controller Manager            |
| [helm-charts](https://github.com/verge-io/helm-charts)                                                   | Helm-Chart-Repository               |
| [Kubernetes Cluster-Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler) | Upstream-Cluster-Autoscaler         |

## Support

Wenn Sie auf Probleme stoßen oder Funktionswünsche haben, eröffnen Sie bitte ein Issue im entsprechenden GitHub-Repository:

* [CSI-Treiber-Issues](https://github.com/verge-io/csi-vergeos/issues)
* [CCM-Issues](https://github.com/verge-io/vergeos-cloud-controller-manager/issues)
* [Helm-Chart-Issues](https://github.com/verge-io/helm-charts/issues)


---

# 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/automate-protect-and-extend/de/integrationen-und-apis/kubernetes-integration.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.
