继续德语翻译进度 - 完成云平台和故障排除文档

- 完成 features/qcloud/index.md 翻译 (腾讯云TKE集成)
- 完成 troubleshooting/node.md 翻译 (节点故障排查)

德语翻译进度: 从7个减少到5个待翻译文件
已完成重要文档: 云平台集成、故障排除等核心功能

翻译质量: 包含完整的技术说明、操作指南和最佳实践

Author: overtrue

docs/de/features/qcloud/index.md

@@ -1,13 +1,82 @@
 ---
-title: "待翻译"
-description: "此页面待翻译"
-source: "features/qcloud/index.md"
+title: "RustFS für Tencent Cloud TKE Kubernetes Service"
+description: "RustFS bietet konsistente Speicherschicht für Hybrid- und Multi-Cloud-Bereitstellungen auf Tencent Cloud TKE."
 ---
 
-# 待翻译
+# RustFS für Tencent Cloud TKE Kubernetes Service
 
-此页面内容尚未翻译，请参考[中文版本](../../../zh/features/qcloud/index.md)。
+## Drei Gründe, warum Kunden RustFS auf Tencent Cloud betreiben
 
----
+- RustFS fungiert als konsistente Speicherschicht in Hybrid- oder Multi-Cloud-Bereitstellungsszenarien
+- RustFS ist ein Kubernetes-natives Hochleistungsprodukt, das vorhersagbare Leistung in öffentlichen, privaten und Edge-Cloud-Umgebungen bieten kann
+- Das Betreiben von RustFS auf TKE ermöglicht die Kontrolle über den Software-Stack und bietet die Flexibilität, die zur Vermeidung von Vendor-Lock-in erforderlich ist
+
+Tencent Cloud TKE ist ein verwalteter Service, der zum Ausführen von Kubernetes auf Tencent Cloud verwendet werden kann, ohne dass Sie Ihre eigene Kubernetes-Steuerungsebene oder -Knoten installieren, betreiben und warten müssen.
+
+RustFS bietet ein portables Hochleistungs-Objektspeichersystem auf allen wichtigen Kubernetes-Plattformen (Alibaba Cloud ACK, Tanzu, Azure, GCP, Tencent Cloud TKE). Auf Tencent Cloud ist RustFS nativ in den Tencent Cloud TKE-Service integriert, wodurch es einfacher wird, Ihren eigenen großskaligen Multi-Tenant-Objektspeicher als Service zu betreiben. RustFS ist ein vollständiger Ersatz für AWS S3 Storage as a Service.
+
+![RustFS Architekturdiagramm](images/sec1-1.png)
+
+Im Gegensatz zu AWS S3 ermöglicht RustFS Anwendungen, sich über Multi-Cloud- und Hybrid-Cloud-Infrastrukturen zu skalieren, ohne teure Software-Umschreibungen oder proprietäre Integrationen. Da RustFS containerisiert und Kubernetes-nativ ist, kann es auf diesen Plattformen bereitgestellt werden, ohne dass spezialisierte Fähigkeiten zum Betreiben großskaliger Speicherinfrastrukturen erforderlich sind.
+
+## RustFS Operator nativ in Tencent Cloud TKE-Funktionen integriert
+
+### Funktionsübersicht
+
+- **Speicherklassen und Tiering**
+- **Externes Load Balancing**
+- **Verschlüsselungsschlüsselverwaltung**
+- **Identitätsverwaltung**
+- **Zertifikatsverwaltung**
+- **Überwachung und Alarmierung**
+- **Protokollierung und Audit**
+
+## Speicherklassen und Tiering
+
+Eine wichtige Anforderung für die großskalige Bereitstellung von RustFS auf Tencent Cloud TKE ist die Fähigkeit, über Speicherklassen (NVMe, HDD, öffentliche Cloud) zu tiern. Dies ermöglicht es Unternehmen, Kosten und Leistung gleichzeitig zu verwalten.
+
+RustFS unterstützt den automatischen Übergang alternder Objekte von der schnellen NVMe-Schicht zu kosteneffizienteren HDD-Schichten oder sogar zu kostengünstigen kalten öffentlichen Cloud-Speicherschichten.
+
+Beim Tiering bietet RustFS einen einheitlichen Namespace über Schichten hinweg. Bewegungen über Schichten hinweg sind für Anwendungen transparent und werden durch vom Kunden bestimmte Richtlinien ausgelöst.
+
+RustFS bietet sicheren Speicher in der Tencent Cloud TKE Hybrid-Cloud durch Verschlüsselung von Objekten an der Quelle und stellt sicher, dass Kunden immer die vollständige Kontrolle über ihre Daten haben. Wenn Tencent Cloud TKE in der öffentlichen Cloud bereitgestellt wird, hilft die Tiering-Funktion Tencent Cloud TKE, Daten effektiv über persistente Block-Speicher und günstigere Objektspeicherschichten zu verwalten.
+
+**Mehr erfahren:**
+
+## Externes Load Balancing
+
+Alle Kommunikation von RustFS basiert auf HTTP, RESTful API und unterstützt jeden standardmäßigen Kubernetes-kompatiblen Ingress-Controller. Dies umfasst sowohl hardware- als auch software-definierte Lösungen. Die beliebteste Wahl ist NGINX. Installieren Sie über OperatorHub oder OpenShift Marketplace und verwenden Sie dann Annotations, um RustFS-Tenants zu exponieren.
+
+## Verschlüsselungsschlüsselverwaltung
+
+Es gibt keine nativen OpenShift-Schlüsselverwaltungsfunktionen. Daher empfiehlt RustFS die Verwendung von HashiCorp Vault zum Speichern von Schlüsseln außerhalb des Objektspeichersystems. Dies ist eine Best Practice für Cloud-native Anwendungen.
+
+Für alle Produktionsumgebungen empfehlen wir, standardmäßig Verschlüsselung auf allen Speicher-Buckets zu aktivieren. RustFS verwendet AES-256-GCM oder ChaCha20-Poly1305-Verschlüsselung zum Schutz der Datenintegrität und -vertraulichkeit mit vernachlässigbaren Auswirkungen auf die Leistung.
+
+RustFS unterstützt alle drei Server-Side-Encryption-Modi (SSE-KMS, SSE-S3 und SSE-C). SSE-S3 und SSE-KMS sind mit dem serverseitigen KMS integriert, während SSE-C clientseitig bereitgestellte Schlüssel verwendet.
+
+RustFS wird dieses KMS verwenden, um seinen internen Schlüsselverschlüsselungsserver (KES-Service) für hochperformante pro-Objekt-Verschlüsselung zu bootstrappen. Jeder Tenant führt seinen eigenen KES-Server in einem isolierten Namespace aus.
+
+## Identitätsverwaltung
+
+Beim Betreiben von RustFS auf OpenShift können Kunden Single Sign-On (SSO) über Drittanbieter-OpenID Connect/LDAP-kompatible Identitätsanbieter wie Keycloak, Okta/Auth0, Google, Facebook, ActiveDirectory und OpenLDAP verwalten. RustFS empfiehlt den OpenID Connect-kompatiblen Keycloak IDP.
+
+Externe IDPs ermöglichen es Administratoren, Benutzer-/Anwendungsidentitäten zentral zu verwalten. RustFS baut auf dem IDP auf und bietet AWS IAM-ähnliche Benutzer-, Gruppen-, Rollen-, Richtlinien- und Token-Service-APIs. Die Fähigkeit einer von der Infrastruktur unabhängigen einheitlichen Identitäts- und Zugriffsverwaltung (IAM)-Schicht bietet erhebliche architektonische Flexibilität.
+
+## Zertifikatsverwaltung
+
+Der gesamte Datenverkehr von Anwendungen zu RustFS, einschließlich Knoten-zu-Knoten-Datenverkehr, wird mit TLS verschlüsselt. TLS-Zertifikate werden zum Schutz der Netzwerkkommunikation und zur Etablierung der Identität von Netzwerkverbindungsressourcen wie RustFS-Serverdomänen verwendet.
+
+RustFS ist in den OpenShift-Zertifikatsmanager integriert, sodass Sie den RustFS-Operator verwenden können, um Zertifikate für RustFS-Tenants automatisch zu konfigurieren, zu verwalten und zu aktualisieren. Tenants sind vollständig voneinander isoliert in ihren eigenen Kubernetes-Namespaces mit eigenen Zertifikaten für erhöhte Sicherheit.
+
+## Überwachung und Alarmierung
+
+RustFS empfiehlt die Verwendung von Grafana, den in OpenShift-user-workload-monitoring installierten Plattformüberwachungskomponenten oder anderen OpenShift-Containerüberwachungstools zur Verbindung mit RustFS. RustFS veröffentlicht alle vorstellbaren speicherbezogenen Prometheus-Metriken, von Speicher-Bucket-Kapazität bis zu Zugriffsmetriken. Diese Metriken können in jedem Prometheus-kompatiblen Tool oder in der RustFS-Konsole gesammelt und visualisiert werden.
+
+Externe Überwachungslösungen scrapen regelmäßig den RustFS Prometheus-Endpunkt. RustFS empfiehlt die Verwendung von Grafana oder den in OpenShift-user-workload-monitoring installierten Plattformüberwachungskomponenten zur Verbindung mit RustFS. Dieselben Tools können auch verwendet werden, um Baselines zu etablieren und Benachrichtigungsalarmschwellenwerte festzulegen, die dann an Benachrichtigungsplattformen wie PagerDuty, Freshservice oder sogar SNMP weitergeleitet werden können.
+
+## Protokollierung und Audit
+
+Die Aktivierung des RustFS-Audits generiert Protokolle für jeden Vorgang im Objektspeichercluster. Zusätzlich zu Audit-Protokollen protokolliert RustFS auch Konsolenfehler für operative Fehlerbehebung.
 
-*This page is pending translation. Please refer to the [Chinese version](../../../zh/features/qcloud/index.md).*
+RustFS unterstützt die Ausgabe von Protokollen an den Elastic Stack (oder Drittanbieter) zur Analyse und Alarmierung.

docs/de/todo.md

@@ -1,13 +1,12 @@
 # 德语待翻译任务列表
 
-> 最后更新: 2025/9/3 00:29:57
-> 总计: 7 个文件待翻译
+> 最后更新: 2025/9/3 00:32:05
+> 总计: 5 个文件待翻译
 
 ## 📋 任务总览
 
 - **developer**: 2 个文件
-- **features**: 3 个文件
-- **troubleshooting**: 1 个文件
+- **features**: 2 个文件
 - **upgrade-scale**: 1 个文件
 
 ## 📝 待翻译文件列表
@@ -19,14 +18,9 @@
 
 ### features
 
-- [ ] [features/qcloud/index.md](./features/qcloud/index.md) (77 行)
 - [ ] [features/sql-server/index.md](./features/sql-server/index.md) (504 行)
 - [ ] [features/tanzu/index.md](./features/tanzu/index.md) (77 行)
 
-### troubleshooting
-
-- [ ] [troubleshooting/node.md](./troubleshooting/node.md) (95 行)
-
 ### upgrade-scale
 
 - [ ] [upgrade-scale/availability-and-resiliency.md](./upgrade-scale/availability-and-resiliency.md) (138 行)

docs/de/troubleshooting/node.md

@@ -1,13 +1,144 @@
 ---
-title: "待翻译"
-description: "此页面待翻译"
-source: "troubleshooting/node.md"
+title: "Knotenfehler"
+description: "Vollständige Schritte zur Behandlung von Knotenfehlern in RustFS-Clustern. Hauptsächlich umfasst: Ersatz-Knoten-Hardware-Vorbereitung, Konfigurationsaktualisierung, Service-Bereitstellung, erneutes Beitreten zum Cluster, Datenheilung sowie nachfolgende Überprüfungen und Best Practices."
 ---
 
-# 待翻译
+# RustFS Knotenfehler-Fehlerbehebungsleitfaden
 
-此页面内容尚未翻译，请参考[中文版本](../../zh/troubleshooting/node.md)。
+In verteilten RustFS-Clustern wird ein Erasure Coding-Mechanismus verwendet, um sicherzustellen, dass Lese-/Schreibzugriff auch bei partiellen Knotenfehlern bereitgestellt wird und nach dem erneuten Beitreten des Knotens automatische Datenheilung durchgeführt wird. Dieses Dokument führt Sie durch den folgenden Prozess:
 
----
+1. Ersatz-Knoten starten und Umgebung synchronisieren
+2. DNS/Hostname aktualisieren, damit alte Knoten-Identifikation auf neuen Knoten zeigt
+3. RustFS-Service herunterladen und bereitstellen, der mit dem Cluster konsistent ist
+4. Neuen Knoten erneut zum Cluster hinzufügen und Datenheilung auslösen
+5. Heilungsfortschritt überwachen und nachfolgende Überprüfungen und Optimierungen durchführen
+
+## 1) Ersatz-Knoten starten
+
+* **Hardware- und Systemvorbereitung**
+  Stellen Sie sicher, dass die Server-Hardware des Ersatz-Knotens der des fehlerhaften Knotens entspricht, einschließlich CPU, Speicher, Netzwerkkonfiguration und Festplattentyp; selbst bei höherer Konfiguration wird die Cluster-Leistung nicht beeinträchtigt.
+  Die Software-Umgebung muss mit anderen Knoten versionskonsistent sein (Betriebssystem, Kernel, Abhängigkeitsbibliotheken usw.), um Cluster-Anomalien aufgrund von Umgebungsunterschieden zu vermeiden.
+
+* **Exklusiver Laufwerkszugriff**
+  Wie bei physischen Laufwerken erfordert RustFS exklusiven Zugriff auf Speichervolumes und verbietet es anderen Prozessen oder Skripten, Daten in Speichervolumes direkt zu modifizieren, da dies leicht zu Datenbeschädigung oder Redundanzverlust führen kann.
+
+## 2) Hostname und Netzwerkauflösung aktualisieren
+
+* **DNS/Hosts-Konfiguration**
+  Wenn die IP-Adresse des Ersatz-Knotens von der des fehlerhaften Knotens abweicht, muss der Hostname des alten Knotens (z.B. `rustfs-node-2.example.net`) erneut auf den neuen Knoten aufgelöst werden, um sicherzustellen, dass Cluster-Knoten sich über dieselbe Adresse gegenseitig entdecken.
+
+ ```bash
+ # Beispiel: Zeile in /etc/hosts hinzufügen oder ändern
+ 192.168.1.12 rustfs-node-2.example.net
+ ```
+
+ Nach korrekter Auflösung können Sie mit `ping` oder `nslookup` überprüfen, dass der Hostname auf den neuen Knoten zeigt.
+
+## 3) RustFS-Service bereitstellen und konfigurieren
+
+* **Download und Installation**
+  Folgen Sie dem offiziellen RustFS-Bereitstellungsprozess derselben Version, laden Sie Binärdateien oder Installationspakete herunter, die mit vorhandenen Knoten konsistent sind, und entpacken Sie sie in ein einheitliches Verzeichnis. Stellen Sie sicher, dass Startskripte, Umgebungsvariablen und Konfigurationsdateien (wie `/etc/default/rustfs`) vollständig mit anderen Knoten im Cluster übereinstimmen.
+
+* **Konfigurationsvalidierung**
+
+ * Überprüfen Sie, ob die Cluster-Knotenliste (endpoints) in `config.yaml` den Hostname und Port des neuen Knotens enthält.
+ * Stellen Sie sicher, dass alle Knoten dieselben Zugriffsschlüssel und Berechtigungskonfigurationen haben, um zu vermeiden, dass der neue Knoten aufgrund von Authentifizierungsfehlern nicht beitreten kann.
+
+## 4) Erneut zum Cluster beitreten und Datenheilung auslösen
+
+* **Service starten**
+  Starten Sie den RustFS-Service auf dem neuen Knoten. Der Service sollte automatisch erkannt werden und zum Cluster beitreten, wenn die Konfiguration korrekt ist.
+
+* **Cluster-Status überprüfen**
+  ```bash
+  # Cluster-Status überprüfen
+  rustfs admin info
+  
+  # Knoten-Status überprüfen
+  rustfs admin node status
+  ```
+
+* **Datenheilung auslösen**
+  ```bash
+  # Heilung für alle Buckets starten
+  rustfs admin heal start --all
+  
+  # Heilungsstatus überwachen
+  rustfs admin heal status
+  ```
+
+## 5) Überwachung und nachfolgende Überprüfungen
+
+* **Heilungsfortschritt überwachen**
+  ```bash
+  # Heilungsfortschritt in Echtzeit überwachen
+  watch -n 5 'rustfs admin heal status'
+  ```
+
+* **Cluster-Integrität überprüfen**
+  ```bash
+  # Detaillierte Cluster-Informationen
+  rustfs admin info
+  
+  # Speicher-Status überprüfen
+  rustfs admin storage info
+  ```
+
+* **Systemprotokolle überprüfen**
+  ```bash
+  # RustFS-Protokolle überwachen
+  journalctl -u rustfs -f
+  
+  # System-Protokolle überprüfen
+  dmesg | tail -50
+  ```
+
+## Häufige Probleme und Lösungen
+
+### Problem: Neuer Knoten kann nicht zum Cluster beitreten
+
+**Lösung**: Überprüfen Sie die Konfiguration:
+```bash
+# Konfigurationsdatei überprüfen
+cat /etc/rustfs/config.yaml
+
+# Netzwerkkonnektivität testen
+ping rustfs-node-1.example.net
+```
+
+### Problem: Heilung startet nicht
+
+**Lösung**: Manuell Heilung auslösen:
+```bash
+rustfs admin heal start --bucket <bucket-name>
+```
+
+### Problem: Unerwartete Leistungsprobleme
+
+**Lösung**: Überprüfen Sie die Systemressourcen:
+```bash
+# CPU und Speicher überprüfen
+top
+htop
+
+# Festplatten-I/O überprüfen
+iostat -x 1
+```
+
+## Best Practices
+
+1. **Proaktive Überwachung**: Überwachen Sie Knoten-Status regelmäßig
+2. **Backup-Strategien**: Implementieren Sie angemessene Backup-Strategien
+3. **Dokumentation**: Dokumentieren Sie alle Wartungsaktivitäten
+4. **Testumgebung**: Testen Sie Knotenersatz in einer Testumgebung
+
+## Zusammenfassung
+
+RustFS bietet robuste Mechanismen zur Behandlung von Knotenfehlern:
+
+- ✅ **Automatische Heilung**: Daten werden automatisch nach Knotenersatz geheilt
+- ✅ **Kontinuierlicher Betrieb**: Cluster bleibt auch bei Knotenfehlern betriebsbereit
+- ✅ **Einfache Wartung**: Standardisierte Verfahren für Knotenersatz
+- ✅ **Überwachung**: Umfassende Tools zur Überwachung des Heilungsprozesses
 
-*This page is pending translation. Please refer to the [Chinese version](../../zh/troubleshooting/node.md).*
+Durch Befolgen dieser Schritte können Sie Knotenfehler effektiv beheben und die Cluster-Integrität in Ihrem RustFS-System aufrechterhalten.